Share
Questa è la prima parte di un tutorial in due parti su Ansible. In questa parte imparerai cos'è Ansible, come installarlo e configurarlo e come installare un cluster Vagrant locale per testarlo. Quindi, scoprirai l'inventario, i moduli, i comandi ad-hoc, i playbook, le strategie di esecuzione, i blocchi e il vault.
Ansible è uno strumento di gestione e orchestrazione della configurazione. Funziona nello stesso dominio di Puppet, Chef e Saltstack. Ciò significa che con Ansible puoi eseguire il provisioning remoto di un'intera flotta di server remoti, installare e distribuire software su di essi e rintracciarli da remoto.
Ansible è un progetto open source implementato in Python e ha un'architettura collegabile con moduli in grado di gestire praticamente qualsiasi sistema operativo, ambiente cloud e strumento o framework di amministrazione del sistema. Puoi anche estenderlo facilmente con i tuoi plugin se vuoi fare qualcosa di speciale.
Una delle caratteristiche uniche di Ansible è che non installa alcun software su macchine gestite. Gestisce le macchine da remoto tramite SSH. Per gestire una macchina remota, devi solo assicurarti che la tua chiave SSH pubblica sia nel file authorized_keys di quella macchina.
Ansible gira su una macchina di controllo e può gestire server che eseguono qualsiasi sistema operativo, ma la macchina di controllo non può essere una macchina Windows al momento. Userò Mac OS X in questo tutorial come macchina di controllo.
Ansible richiede Python 2.6 o 2.7. Per installarlo, digita:
pip installare ansible
Su Mac OS X, si consiglia di aumentare il numero di handle di file:
sudo launchctl limit maxfiles 1024 illimitato
Se vedi un errore come "Troppi file aperti" probabilmente hai bisogno di farlo.
Per verificare che Ansible sia stato installato correttamente, digitare ansible --version. Tu dovresti vedere:
ansible 2.0.0.2 config file = percorso di ricerca modulo configurato = Predefinito senza sovrascrizioni
Il numero di versione potrebbe essere diverso, ovviamente.
Ansible ha un file di configurazione che ti consente di controllare molte opzioni. L'ordine di ricerca è:
È anche possibile sovrascrivere impostazioni specifiche utilizzando singole variabili di ambiente, che hanno la precedenza sul file di configurazione.
Controlla la documentazione di Ansible per conoscere tutte le opzioni.
Per capire veramente il potere di Ansible, hai bisogno di un gruppo di server da gestire. Ai fini di questo tutorial userò un cluster Vagrant di 3 VM, ma per quanto riguarda Ansible sono solo alcuni degli host che deve gestire. Per ulteriori informazioni su Vagrant, consulta Introduzione a Vagrant.
Innanzitutto, installa VirtualBox e Vagrant. Quindi inserisci quanto segue in un file chiamato "Vagrantfile" in una directory di lavoro
Accentsconagua
# - * - mode: ruby - * - # vi: set ft = ruby: hosts = "larry" => "192.168.88.10", "curly" => "192.168.88.11", "moe" => "192.168 .88.12 " Vagrant.configure (" 2 ") do | config | config.vm.box = "precise64" config.vm.box_url = "http://files.vagrantup.com/precise64.box" hosts.each do | name, ip | nome config.vm.define do | machine | machine.vm.network: private_network, ip: ip machine.vm.provider "virtualbox" do | v | v.name = nome fine fine fine fine Quindi digita vagabondo. Vagrant creerà tre macchine virtuali per te, disponibili come larry, curly e moe. Per verificare, digitare stato vagabondo. Tu dovresti vedere:
Stati della macchina corrente: larry running (virtualbox) riccio in esecuzione (virtualbox) moe in esecuzione (virtualbox) Questo ambiente rappresenta più VM. Le macchine virtuali sono tutte elencate sopra con il loro stato attuale. Per ulteriori informazioni su una VM specifica, esegui "status vagabondo NAME".
Per assicurarsi di poter SSH negli host del cluster, digitare: vagrant ssh-config >> ~ / .ssh / config.
Ora puoi usare SSH in uno qualsiasi dei tuoi server virtuali usando il loro nome host. Per esempio: ssh riccio. Ciò consentirà ad Ansible di connettersi agli host del cluster su SSH senza problemi con nomi utente, password o chiavi.
Ora che abbiamo un cluster, dobbiamo dirlo ad Ansible. Questo viene fatto usando un file di inventario. Il file di inventario è un elenco di nomi host organizzati in gruppi che utilizzano un formato di file INI. Inserisci quanto segue in un file chiamato "hosts" nella directory di lavoro.
[divertente] larry [più divertente] moe ricci
Metto "larry" in un gruppo chiamato "funny" e gli altri host in un gruppo chiamato "funnier". Quella organizzazione ci permetterà di eseguire azioni su questi gruppi. È inoltre possibile eseguire azioni su singoli host e su tutti gli host.
Ansible ha un'architettura molto modulare ed estensibile. Tutte le sue capacità sono organizzate in moduli. Ci sono moduli di base e moduli aggiuntivi. Ogni modulo rappresenta un comando e la maggior parte accetta argomenti. Puoi utilizzare i moduli direttamente nei comandi ad-hoc o nei playbook. Puoi leggere tutti i moduli nella documentazione.
È tempo di prendere le mani. Il modo più semplice per usare Ansible è eseguire comandi ad-hoc. I comandi ad-hoc utilizzano i moduli. Il formato di un comando ad-hoc è:
ansible
Ad esempio, per vedere se tutti gli host nel tuo inventario sono attivi, puoi usare il modulo ping (senza argomenti):
ansible all -i hosts -m ping curly | SUCCESS => "changed": false, "ping": "pong" larry | SUCCESS => "changed": false, "ping": "pong" moe | SUCCESS => "changed": false, "ping": "pong"
Ansible ha molti moduli per tutte le comuni attività di amministrazione del sistema come la gestione dei file, la gestione degli utenti e la gestione dei pacchetti, nonché molte attività non comuni. Ma se non trovi ciò di cui hai bisogno o semplicemente ti senti più a tuo agio con i comandi di shell semplice, puoi usare il modulo shell direttamente includendo le pipe. Il seguente comando estrae gli indirizzi IP interni ed esterni di tutti gli host:
ansible all -i hosts -m shell -a '/ sbin / ifconfig | grep inet. * Bcast '"larry | SUCCESS | rc = 0 >> addr inet: 10.0.2.15 Bcast: 10.0.2.255 Maschera: 255.255.255.0 inet addr: 192.168.88.10 Bcast: 192.168.88.255 Maschera: 255.255.255.0 ricci | SUCCESS | rc = 0 >> addr: 10.0.2.15 Bcast: 10.0.2.255 Maschera: 255.255.255.0 addr inr: 192.168.88.11 Bcast: 192.168.88.255 Maschera: 255.255.255.0 moe | SUCCESS | rc = 0 >> addr : 10.0.2.15 Bcast: 10.0.2.255 Maschera: 255.255.255.0 inet addr: 192.168.88.12 Bcast: 192.168.88.255 Maschera: 255.255.255.0
I comandi ad-hoc sono piacevoli quando vuoi fare rapidamente qualcosa su un gruppo di host, ma il vero potere di Ansible è nei suoi quaderni. I playbook sono file YAML in cui si definiscono raccolte di attività per raggiungere obiettivi come provisioning, configurazione, distribuzione e orchestrazione dell'infrastruttura.
Diamo un'occhiata a come appare un tipico libro di esercizi prima di scendere ai dettagli.
--- - hosts: funnier tasks: - name: Installa Nginx apt: pkg = nginx state = installed update_cache = true notify: Avvia Nginx - name: Installa Python 3 apt: pkg = python3-minimum state = gestori installati: - nome: Avvia il servizio Nginx: nome = stato nginx = iniziato
Il playbook ha una sezione host in cui si specificano gli host dal file di inventario. In questo caso, il nome del gruppo è "più divertente". Poi c'è una sezione tasks con due task che installano Nginx e Python 3. Infine, c'è una sezione handlers dove Nginx viene avviato dopo la sua installazione.
Esegui i quaderni con il ansible-playbook comando. Devi ancora fornire un file di inventario e il playbook che desideri eseguire. Salva il libro di gioco in un file chiamato "playbook.yml" nella tua directory di lavoro. Proviamolo:
ansible-playbook -i ospita playbook.yml PLAY **************************************** *********************************** TASK [setup] *********** ************************************************** ****** ok: [moe] ok: [ricci] TASK [Installa Nginx] ***************************** ****************************** fatale: [moe]: FAILED! => "changed": false, "failed": true, "msg": "Impossibile bloccare apt per l'operazione esclusiva" fatale: [curly]: FAILED! => "changed": false, "failed": true, "msg": "Impossibile bloccare apt per l'operazione esclusiva" PLAY RECAP ******************* ************************************************** ricci: ok = 1 modificato = 0 non raggiungibile = 0 non riuscito = 1 moe: ok = 1 modificato = 0 non raggiungibile = 0 non riuscito = 1
Oh, no. Quello che è successo? Ansible fornisce qui un messaggio di errore decente: "Impossibile bloccare apt per l'operazione esclusiva". Molti libri di gioco richiedono privilegi sudo. Questo libro di esercizi non è un'eccezione. Per eseguire il playbook con privilegi sudo, basta aggiungere il --sudo bandiera:
ansible-playbook -i ospita playbook.yml --sudo PLAY ************************************* ************************************** TASK [setup] ******** ************************************************** ********* ok: [ricci] ok: [moe] TASK [Installa Nginx] ************************** ********************************* modificato: [moe] modificato: [curly] TASK [Installa Python 3] * ************************************************** ***** modificato: [moe] modificato: [curly] RUNNING HANDLER [Inizio Nginx] ***************************** ********************* modificato: [moe] modificato: [curly] PLAY RECAP ***************** ************************************************** ** Ricci: ok = 4 modificato = 3 non raggiungibile = 0 non riuscito = 0 moe: ok = 4 modificato = 3 non raggiungibile = 0 non riuscito = 0
Ansible è idempotente, il che significa che se qualcosa è già nello stato desiderato, allora Ansible lo lascerà in pace. Nell'output di ansible-playbook, puoi vedere quali attività hanno avuto esito positivo o negativo e quali host sono stati modificati.
Eseguiamo di nuovo lo stesso libro di esercizi. Nulla dovrebbe essere cambiato:
ansible-playbook -i ospita playbook.yml --sudo PLAY ************************************* ************************************** TASK [setup] ******** ************************************************** ********* ok: [moe] ok: [ricci] TASK [Installa Nginx] ************************** ********************************* ok: [ricci] ok: [moe] TASK [Installa Python 3] * ************************************************** ***** ok: [ricci] ok: [moe] PLAY RECAP ********************************* ************************************ curly: ok = 3 changed = 0 unreachable = 0 failed = 0 moe: ok = 3 changed = 0 unreachable = 0 failed = 0
Prima di Ansible 2.0, le riproduzioni vengono eseguite in modo lineare, attività per attività. Tutti gli host di destinazione hanno eseguito la prima attività. Solo quando tutti gli host sono stati eseguiti con la prima attività, potrebbero iniziare la seconda attività.
Ansible 2.0 ha aggiunto il concetto di strategie di corsa. Attualmente ci sono due strategie: la strategia "lineare" che ho descritto sopra, che è la strategia di default, e la strategia "libera" in cui gli host sono liberi di eseguire le attività nel playbook in ordine, ma non in lockstep con altri host.
Questo potrebbe essere utile se centinaia di host hanno bisogno di scaricare diversi file da alcuni server FTP. Il primo host può finire di scaricare il primo file e passare a quello successivo, mentre altri host sono ancora occupati a scaricare il primo file. Nel momento in cui gli altri host devono scaricare il file successivo, il primo host è già fatto e c'è meno conflitto.
La strategia gratuita sembra superiore nella maggior parte delle situazioni. Devi solo aggiungere un strategia: gratuita coppia chiave-valore al playbook.
- hosts: all strategy: free tasks: ...
Un'altra nuova funzione di Ansible 2.0 è costituita da blocchi. I blocchi ti consentono di raggruppare le attività. Questo è molto utile se hai compiti che devono essere eseguiti solo in determinate condizioni. In precedenza, dovevi farlo separatamente per ogni compito.
--- - hosts: all tasks: - debug: msg = "Task 1 here" quando: ansible_distribution == 'Ubuntu' - debug: msg = "Task 2 qui" quando: ansible_distribution == 'Ubuntu' - debug: msg = "Attività 3 qui "when: ansible_distribution == 'Ubuntu'
Con i blocchi, è possibile raggruppare tutte queste attività di debug insieme e inserire la condizione "quando" a livello di blocco.
- hosts: tutte le attività: - block: - debug: msg = "Attività 1 qui" - debug: msg = "Attività 2 qui" - debug: msg = "Attività 3 qui" quando: ansible_distribution == 'Ubuntu'
Ansible comunica con macchine remote su SSH, ma le cartelle di gioco possono contenere segreti come nome utente, password e chiavi API. Dato che in genere si memorizzano i playbook nei sistemi di controllo del codice sorgente come git, queste informazioni saranno visibili a chiunque abbia accesso in lettura.
Ansible ti aiuta con il programma ansible-vault che ti consente di creare, modificare e reimpostare i file crittografati. Questi file possono essere decodificati al volo quando si esegue il playbook fornendo una password. Se aggiungi il ---Chiedere-pass volta segnala ad ansible-playbook quindi ti chiederà la password del vault.
In alternativa, puoi aggiungere --Vault-file-password e Ansible leggerà la password dal tuo file. Se si utilizza il file della password, non memorizzarlo nel controllo del codice sorgente!
Ora puoi archiviare in modo sicuro i file crittografati nel controllo del codice sorgente e non preoccuparti di trovare i tuoi segreti. Devi gestire attentamente la password del Vault. Se lo perdi, non sarai in grado di decodificare i file nel Vault.
Ansible è un ottimo strumento. È leggero Può essere utilizzato in modo interattivo con comandi ad-hoc e si adatta molto bene a sistemi di grandi dimensioni. Ha anche un sacco di slancio e una grande comunità. Se gestisci o anche solo lavori con server remoti, vuoi Ansible.
Restate sintonizzati per la seconda parte.
