Ricerca nel sito web

Come installare e configurare Ansible su Ubuntu 22.04


Questo tutorial esiste per queste versioni del sistema operativo

  • Ubuntu 22.04 (Jammy Jellyfish)
  • Ubuntu 18.04 (Bionic Beaver)

Su questa pagina

  1. Prerequisiti
  2. Passaggio 1 - Installa Ansible
  3. Passaggio 2 - Configurazione del file di inventario
    1. Organizzazione dei server in gruppi e sottogruppi

    1. Imposta le chiavi SSH sui nodi con la chiave pubblica esistente

    1. Controlla l'utilizzo del disco
    2. Scegli come target singoli host e gruppi
    3. Aggiorna tutti i server

    Ansible è uno strumento di gestione della configurazione molto popolare progettato per semplificare il processo di controllo di un gran numero di server. Può automatizzare il processo di configurazione di nuovi server e installazione di applicazioni con un singolo comando o file. Puoi controllare più server ed eseguire processi su di essi contemporaneamente da un singolo nodo. Ansible non richiede l'installazione di alcun software speciale sui nodi del server e può controllarli tramite SSH.

    In questa guida impareremo come installare e configurare Ansible su un server Ubuntu 22.04.

    Prerequisiti

    • Due o più sistemi server che eseguono Ubuntu 22.04 con server OpenSSH installato.
    • Sia il server che i nodi sono accessibili tramite indirizzi IP pubblici.
    • Un utente non root con privilegi sudo è configurato sul server Ansible e un utente root con una password è configurato sui client Ansible.

    Passaggio 1: installare Ansible

    Useremo il repository ufficiale di Ansibles per installare la sua ultima versione. Aggiungi il repository ufficiale di Ansibles al server.

    $ sudo add-apt-repository ppa:ansible/ansible
    

    Fortunatamente, Ubuntu viene fornito con Ansible 2.9 che è ciò che installeremo. Eseguire il comando seguente per installare Ansible.

    $ sudo apt install ansible -y
    

    Testare l'installazione eseguendo il seguente comando.

    $ ansible --version
    ansible [core 2.13.3rc1]
      config file = /etc/ansible/ansible.cfg
      configured module search path = ['/home/navjot/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
      ansible python module location = /usr/lib/python3/dist-packages/ansible
      ansible collection location = /home/navjot/.ansible/collections:/usr/share/ansible/collections
      executable location = /usr/bin/ansible
      python version = 3.10.4 (main, Jun 29 2022, 12:14:53) [GCC 11.2.0]
      jinja version = 3.0.3
      libyaml = True
    

    Installa e attiva il pacchetto python3-argcomplete per configurare il supporto per il completamento bash di Ansible.

    $ sudo apt install python3-argcomplete
    $ sudo activate-global-python-argcomplete3
    

    Ora puoi premere il tasto Tab per ottenere un elenco di opzioni per la shell bash.

    Passaggio 2: impostazione del file di inventario

    Per potersi connettere a più host, è necessario un file che registrerà i dettagli dei nodi. Questo file è chiamato il file di inventario.

    A seconda del numero di server che desideri controllare, il file Ansibles Inventory ti consente anche di organizzarli in gruppi e sottogruppi. Puoi anche impostare variabili personalizzate applicabili a host o gruppi selezionati che possono essere ulteriormente utilizzati durante la trasmissione delle istruzioni.

    Ansible viene fornito con un file di inventario predefinito disponibile in /etc/ansible/hosts. Aprilo con l'editor Nano.

    $ sudo nano /etc/ansible/hosts
    

    Incolla il seguente codice nella parte inferiore del file.

    [servers]
    server1 ansible_host=203.0.113.111
    server2 ansible_host=203.0.113.112
    server3 ansible_host=203.0.113.113
    
    [all:vars]
    ansible_python_interpreter=/usr/bin/python3
    

    La sezione server definisce l'elenco di nodi a cui vuoi connetterti. È possibile creare tanti gruppi per disporre i server in più gruppi.

    Il gruppo all:vars imposta il parametro ansible_python_interpreter su tutti gli host nell'inventario. Si assicura che Ansible utilizzi l'eseguibile Python 3 invece di Python 2 che è stato rimosso dalle recenti versioni di Ubuntu.

    Quando hai finito, salva il file premendo Ctrl + X e inserendo Y quando ti viene chiesto di confermare le modifiche.

    Nota: puoi anche creare il tuo file di inventario in qualsiasi posizione di tua scelta che puoi poi spacciare utilizzando il parametro -i durante l'esecuzione dei comandi Ansible.

    Puoi controllare la tua lista di inventario con il seguente comando.

    $ ansible-inventory --list -y
    all:
      children:
        servers:
          hosts:
            server1:
              ansible_host: 203.0.113.111
              ansible_python_interpreter: /usr/bin/python3
            server2:
              ansible_host: 203.0.113.112
              ansible_python_interpreter: /usr/bin/python3
            server3:
              ansible_host: 203.0.113.113
              ansible_python_interpreter: /usr/bin/python3
        ungrouped: {}
    

    Organizzazione dei server in gruppi e sottogruppi

    Questo è un consiglio utile se hai molti server con alcuni server che eseguono funzioni specifiche. Ad esempio, è possibile utilizzare questo metodo per raggruppare separatamente server Web e server di database. Puoi persino inserire un host in più gruppi. Per raggiungere questo obiettivo, il tuo file di inventario dovrebbe essere simile al seguente.

    [webservers]
    203.0.113.111
    203.0.113.112
    
    [dbservers]
    203.0.113.113
    server_hostname
    
    [development]
    203.0.113.111
    203.0.113.113
    
    [production]
    203.0.113.112
    server_hostname
    
    

    Passaggio 3: configurare le chiavi SSH

    Affinché Ansible sia in grado di connettersi ai server, è necessario configurare le chiavi SSH tra il server Ansible e gli host specificati nel file di inventario. Funzionerà solo se i client Ansible non hanno una chiave pubblica abilitata e hanno un account root abilitato con una password.

    Utilizza i passaggi seguenti per creare e configurare una chiave SSH per Ansible e i suoi nodi.

    Crea la chiave per Ansible.

    $ ssh-keygen -t rsa -b 4096 -C "Ansible key"
    

    Copia la chiave pubblica sui tuoi account sui server remoti. Per questo, useremo il comando ssh-copy-id.

    $ ssh-copy-id -i $HOME/.ssh/id_rsa.pub 
    $ ssh-copy-id -i $HOME/.ssh/id_rsa.pub 
    $ ssh-copy-id -i $HOME/.ssh/id_rsa.pub 
    

    È tutto. Ora Ansible dovrebbe essere in grado di parlare con i tuoi server.

    Imposta le chiavi SSH sui nodi con la chiave pubblica esistente

    Se i client hanno già le chiavi pubbliche abilitate, dovrai seguire alcuni passaggi aggiuntivi. Per questo, devi creare un nuovo utente accessibile solo da Ansible su ogni server nodo. Quell'utente avrà privilegi sudo accessibili senza password e sarà accessibile solo dal tuo server ansible.

    Per creare un utente ansible, eseguire il seguente comando.

    $ sudo adduser ansible
    

    Scegli una password complessa e lascia vuoti tutti gli altri campi.

    Ora, configura l'accesso sudo senza password a questo utente tramite il seguente comando.

    $ echo "ansible ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/ansible
    

    Ora che hai aggiunto e configurato il nuovo utente, puoi copiare la chiave SSH dal tuo server ansible al server del nodo usando il seguente comando.

    $ ssh-copy-id 
    

    Ti verrà richiesta una password per l'utente ansible. Inseriscilo e la chiave SSH verrà copiata.

    Successivamente, disabilita l'accesso basato su password per l'utente ansible sul server del nodo.

    $ sudo usermod -L ansible
    

    Ora, il tuo server del nodo è accessibile solo dal server Ansible poiché solo quel server ha la chiave pubblica per esso e non puoi usarlo direttamente con i privilegi sudo sul server del nodo poiché l'accesso con password è disabilitato.

    Dovrai ripetere questi passaggi per ogni server nodo. Inoltre, sostituisci l'utente root con l'utente ansible in questo tutorial.

    Passaggio 4: prova la connessione

    Dopo aver impostato il file di inventario e le chiavi SSH, dovremmo verificare se Ansible può connettersi ai server.

    Digitare il seguente comando per verificare la connessione. Questo comando verificherà la connessione a tutti i server dal file di inventario.

    $ ansible all -m ping -u root
    

    Questo comando utilizza il modulo ping di Ansibles per eseguire un test di connettività su tutti i server. Dovresti ottenere un output simile al seguente.

    server1 | SUCCESS => {
        "changed": false,
        "ping": "pong"
    }
    server2 | SUCCESS => {
        "changed": false,
        "ping": "pong"
    }
    server3 | SUCCESS => {
        "changed": false,
        "ping": "pong"
    }
    

    Se è la prima volta che utilizzi Ansible, ti verrà chiesto di confermare l'autenticità di tutti i server. Quando richiesto, digita yes e premi INVIO per confermare.

    Passaggio 5: eseguire alcuni comandi di base

    Eseguiamo alcuni comandi di base sui server utilizzando Ansible. Per eseguire qualsiasi comando sul server, viene utilizzato il seguente formato.

    $ ansible all -a "command" -u <username>
    

    Controlla l'utilizzo del disco

    Innanzitutto, controlliamo l'utilizzo del disco su tutti i nostri server.

    $ ansible all -a "df -h" -u root
    server1 | CHANGED | rc=0 >>
    Filesystem      Size  Used Avail Use% Mounted on
    tmpfs           198M  972K  197M   1% /run
    /dev/sda2        50G  3.9G   44G   9% /
    tmpfs           989M     0  989M   0% /dev/shm
    tmpfs           5.0M     0  5.0M   0% /run/lock
    tmpfs           198M  4.0K  198M   1% /run/user/1000
    
    server2 | CHANGED | rc=0 >>
    Filesystem      Size  Used Avail Use% Mounted on
    tmpfs           198M  922K  197M   1% /run
    /dev/sda2        50G  4.9G   43G  10% /
    tmpfs           989M     0  989M   0% /dev/shm
    tmpfs           5.0M     0  5.0M   0% /run/lock
    tmpfs           198M  4.0K  198M   1% /run/user/1000
    

    Scegli come target singoli host e gruppi

    Fino ad ora, eseguivamo i comandi su tutti i server remoti contemporaneamente. Ma questo non è sempre il caso. Per eseguire un comando su un solo server, è necessario utilizzare il seguente formato.

    $ ansible server1 -a "uptime" -u root
    server1 | CHANGED | rc=0 >>
     21:38:26 up 11 min,  2 users,  load average: 0.00, 0.20, 0.19
    

    Il comando precedente controlla il tempo di attività sul server1 dal gruppo di inventario.

    Puoi anche scegliere come target più server utilizzando il seguente formato.

    $ ansible server1:server2 -m ping -u root
    

    Puoi anche scegliere come target gruppi o sottogruppi direttamente dal file di inventario.

    $ ansible groupname -m ping -u <username>
    

    Aggiorna tutti i server

    Per questo tutorial, supponiamo che tutti i server remoti eseguano il sistema operativo Debian o Ubuntu.

    Esegui il seguente comando per aggiornare il software su tutti i tuoi server.

    $ ansible all -m apt -a "update_cache=yes upgrade=yes" -u root
    

    Il parametro -m definisce il modulo che deve essere eseguito da Ansible. Il parametro -a fa riferimento agli argomenti o comandi per il modulo associato. Qui stiamo usando il modulo apt di Ansible per aggiornare i server proprio come abbiamo usato il modulo ping nel nostro ultimo esempio. update_cache aggiorna la cache APT sul server e upgrade=yes indica ad Ansible di eseguire apt upgrade comando.

    Se stai utilizzando l'utente ansible come documentato sopra, devi modificare il comando ansible in modo che venga eseguito con privilegi sudo elevati.

    $ ansible server2 -m apt -a "update_cache=yes upgrade=yes" -K -b -u ansible
    

    Qui, -K richiede una password per l'escalation dei privilegi. -b esegue l'operazione ansible con diventa che ti permette di essere un altro utente. Entrambe le variabili combinate consentono ad ansible di essere eseguito con privilegi sudo elevati. Dovrai usarlo per tutti i comandi che richiedono privilegi sudo.

    A volte, alcuni di questi comandi di aggiornamento potrebbero richiedere un riavvio, quindi esegui il seguente comando per riavviare tutti i tuoi server.

    $ ansible all -a "reboot" -u root
    

    Questi erano solo alcuni dei comandi di base che puoi eseguire utilizzando Ansible.

    Passaggio 6: introduzione ai playbook

    I comandi precedenti consentono di eseguire attività una tantum, ma se si desidera configurare più server o eseguire la stessa sequenza di comandi su più server, è necessario configurare i playbook. I playbook sono file scritti in YAML e contengono istruzioni per automatizzare una sequenza di attività per la configurazione di applicazioni e servizi.

    Ora creeremo un playbook per installare Nginx e configurare una pagina HTML sul nodo Ansible. Crea una directory per Ansible nella tua home directory.

    $ mkdir ~/ansible
    

    Crea e apri il file del playbook per la modifica.

    $ cd ~/ansible
    $ nano testplaybook.yml
    

    I playbook utilizzano il formato YAML per definire una o più riproduzioni. Un gioco è un insieme di attività ordinate organizzate in modo da automatizzare un processo. Le riproduzioni sono definite come un elenco YAML.

    Il primo passo per definire una riproduzione è determinare quali host sono l'obiettivo usando la direttiva hosts: all. La direttiva become viene utilizzata per indicare che le seguenti attività devono essere eseguite da un super utente.

    Definiremo tre attività: una per aggiungere un utente, una per aggiornare tutti i pacchetti e l'ultima per installare il server Nginx. La sezione vars del playbook viene utilizzata per definire variabili personalizzate. Definiamo due variabili, una per l'utente che dobbiamo aggiungere e la seconda per definire lo stato del pacchetto che dobbiamo installare. Per utilizzare la variabile, dobbiamo racchiudere il nome della variabile tra doppie parentesi graffe.

    Il modulo ansible.builtin.user viene utilizzato per aggiungere un nuovo utente con privilegi sudo. Per aggiungere l'utente, stiamo usando le variabili name, password e group. La variabile group è impostata su sudo per dare i permessi di superutente all'utente. Non puoi inserire la password in testo normale nel file del playbook, quindi aggiungeremo un segreto con hash SHA. Useremo l'utility mkpasswd per questo. Per installarlo, esegui il seguente comando per installare il pacchetto whois.

    $ sudo apt install whois
    

    Genera la password con hash. Ti verrà chiesta la solita password e ti verrà fornita una stringa con hash. Annotare la chiave con hash da utilizzare nel file del playbook.

    $ mkpasswd --method=sha-512
    Password:
    $6$dGbprm2oVqClDDDh$Epk6r5eXYkYBaQpQpP.H7VCdz0g9Aj0aO8hjy/WXq4WmfQ7GvQP2/cl/cNhd7.LRFuCKix9uCF2t8X5/Pv0Lk1
    

    La direttiva update_cache serve ad aggiornare l'elenco dei repository di sistemi proprio come il comando apt update e upgrade: dist indica ad Ansible di eseguire l'aggiornamento del sistema. La terza attività è autoesplicativa che installa l'ultima versione del server Nginx.

    Sulla base delle informazioni discusse, incolla il seguente codice nel file. Incolla la chiave con hash che hai ottenuto come valore per la variabile password.

    ---
    - name: Test playbook
      hosts: all
      become: true
      vars:
          state: latest
          user: navjot
      tasks:
      - name: Add the user {{ user }}
        ansible.builtin.user:
          name: "{{ user }}"
          password: '$6$dGbprm2oVqClDDDh$Epk6r5eXYkYBaQpQpP.H7VCdz0g9Aj0aO8hjy/WXq4WmfQ7GvQP2/cl/cNhd7.LRFuCKix9uCF2t8X5/Pv0Lk1'
          group: sudo
      - name: Upgrade all apt packages
        apt:
          update_cache: yes
          upgrade: dist
      - name: Install the {{ state }} of package "nginx"
        apt:
          name: "nginx"
          state: "{{ state }}"
    

    Salva il file premendo Ctrl + X e immettendo Y quando viene richiesto di confermare le modifiche.

    Per eseguire il playbook, eseguire il comando seguente. Il flag --ask-become-pass richiederà la tua password di root per eseguire un'operazione con privilegi elevati.

    $ ansible-playbook testplaybook.yml --ask-become-pass
    

    Otterrai il seguente output.

    BECOME password:
    
    PLAY [Test playbook] ***************************************************************************************************
    
    TASK [Gathering Facts] *************************************************************************************************
    ok: [server1]
    ok: [server2]
    ok: [server3]
    
    TASK [Add the user casablanca] *****************************************************************************************
    changed: [server3]
    changed: [server2]
    changed: [server1]
    
    TASK [Upgrade all apt packages] ****************************************************************************************
    changed: [server1]
    changed: [server2]
    changed: [server3]
    
    TASK [Install the latest of package "nginx"] ***************************************************************************
    changed: [server3]
    changed: [server2]
    changed: [server1]
    
    PLAY RECAP *************************************************************************************************************
    server1                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
    server2                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
    server3                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
    

    Questo conferma che il tuo playbook è stato eseguito correttamente.

    Se stai utilizzando un file di inventario personalizzato, devi includere la posizione del file nel comando come segue.

    $ ansible-playbook -i /etc/ansible/custominventory testplaybook.yml --ask-become-pass 
    

    Conclusione

    Questo conclude il nostro tutorial sull'installazione e la configurazione di Ansible sul server Ubuntu 22.04. Se hai domande, pubblicale nei commenti qui sotto.