Tutorial per principianti - Playbook, variabili e inventario di Ansible

Beginner S Tutorial Ansible Playbooks



I playbook di Ansible sono file che contengono attività eseguite per configurare gli host con Ansible. I playbook di Ansible sono scritti in formato YAML. YAML è un formato di file molto semplice, proprio come JSON. Ti mostrerò come appaiono i playbook Ansible YAML in una sezione successiva di questo articolo.

I file di Ansible Inventory mantengono un elenco degli host che desideri configurare o gestire con Ansible. Puoi raggruppare questi host e gestirli anche per gruppi. Puoi anche passare variabili diverse per ogni host o per un gruppo di host.







In questo articolo, ti mostrerò come lavorare con playbook Ansible, variabili, file di inventario e alcuni moduli Ansible comuni con esempi pratici. Quindi, cominciamo!



Prerequisiti

Se desideri provare gli esempi in questo articolo,



1) Devi avere Ansible installato sul tuo computer.
2) Devi avere almeno un host Ubuntu/Debian e un host CentOS/RHEL 8 configurato per l'automazione Ansible.





Ci sono molti articoli su LinuxHint dedicati all'installazione di Ansible e alla configurazione degli host per l'automazione di Ansible. Puoi controllare questi articoli se necessario per ulteriori informazioni.

Creazione di una directory di progetto

Per prima cosa, crea una directory di progetto ~/progetto/ con il seguente comando:

$mkdir -pv~/progetto/playbook

Vai a ~/progetto/ directory come segue:

$cd~/progetto

File di inventario di base:

Crea un file di inventario Ansible padroni di casa nella directory del progetto con il seguente comando:

$nanopadroni di casa

Puoi digitare gli indirizzi IP degli host che desideri configurare/automatizzare utilizzando Ansible nel padroni di casa file di inventario.

192.168.20.167
192.168.20.168
192.168.20.169
192.168.20.170

Una volta terminato questo passaggio, salvare il file premendo + X seguito da E e .

Se desideri utilizzare i nomi DNS invece degli indirizzi IP nel file di inventario, puoi farlo anche tu.

Se non disponi di un server DNS funzionante, puoi utilizzare il /etc/host file sul tuo computer per la risoluzione DNS locale.

Per la risoluzione DNS locale, apri il /etc/host file con un editor di testo ( nano , nel mio caso) come segue:

$sudo nano /eccetera/padroni di casa

Digita gli indirizzi IP e i nomi DNS desiderati come segue:

192.168.20.167 vm1.nodekite.com
192.168.20.168 vm2.nodekite.com
192.168.20.169 vm3.nodekite.com
192.168.20.170 vm4.nodekite.com

Una volta terminato questo passaggio, premere + X seguito da E e .

Apri il file di inventario di Ansible padroni di casa come segue:

$nanopadroni di casa

Ora puoi digitare i nomi DNS degli host che desideri configurare/automatizzare utilizzando Ansible nel padroni di casa file di inventario.

vm1.nodekite.com
vm2.nodekite.com
vm3.nodekite.com
vm4.nodekite.com

Una volta terminato, salva il file di inventario degli host premendo + X seguito da E e .

Test della connettività a tutti gli host

Ora puoi provare a eseguire il ping di tutti gli host nel file di inventario come segue:

$ansible-ioospita tutti-uansible-m ping

Come puoi vedere, tutti gli host nel file di inventario sono raggiungibili. Quindi, siamo pronti per passare alla sezione successiva di questo articolo.

Il tuo primo playbook Ansible

Creiamo un semplice playbook Ansible ping_all_hosts.yaml nel libri di gioco/ directory. Questa azione eseguirà il ping di tutti gli host nel padroni di casa file di inventario, come prima.

$nanoplaybook/ping_all_hosts.yaml

Digita le seguenti righe nel ping_all_hosts.yaml File playbook Ansible:

- host: tutti
utente: ansible
compiti:
- nome: ping tutti gli host
ping:

Qui,

host: tutti – seleziona tutti gli host dal file di inventario padroni di casa .
utente: ansible – dice ad Ansible di SSH negli host nel file di inventario come ansible utente.
compiti – tutte le attività che Ansible eseguirà negli host sono elencate qui. Ciascuno dei compiti di solito ha un nome e una o più opzioni specifiche del modulo.

Il playbook ping_all_hosts.yaml ha una sola attività, eseguire il ping di tutti gli host nel file di inventario padroni di casa . Il nome dell'attività è Ping tutti gli host e usa il ping modulo.

Il ping modulo non ha bisogno di altre opzioni. Quindi, l'ho lasciato vuoto (non c'è niente dopo i due punti, : )

Una volta terminato questo passaggio, salvare il file premendo + X seguito da E e .

Puoi eseguire il ping_all_hosts.yaml Ansible playbook come segue:

$ansible-playbook-ioospita playbook/ping_all_hosts.yaml

Come puoi vedere, l'attività di ping ha esito positivo in tutti gli host nel file di inventario.

File di configurazione Ansible semplice

Nell'esempio precedente, dovevi usare il -io opzione per indicare ad Ansible quale file di inventario utilizzare. Nel mio caso, è il padroni di casa file di inventario.

$ansible-playbook-ioospita playbook/ping_all_hosts.yaml

Se non desideri passare un file di inventario con il -io opzione ogni volta che esegui un playbook Ansible, tutto ciò che devi fare è impostare un file di inventario predefinito per il tuo progetto.

Per farlo, crea un nuovo file di configurazione di Ansible ansible.cfg nella radice del tuo progetto come segue:

$nanoansible.cfg

Digita le seguenti righe nel ansible.cfg file:

[default]
inventario = ./padroni di casa

Una volta terminato, salvare il file premendo + X seguito da E e .

Puoi eseguire lo stesso playbook di Ansible come segue:

$playbook ansible-playbook/ping_all_hosts.yaml

Come puoi vedere, il playbook utilizza il padroni di casa file di inventario per impostazione predefinita. Puoi ancora usare il -io opzione per specificare un file di inventario diverso, se lo desideri. Ansible è molto flessibile.

Raggruppamento di host nel file di inventario

Finora, ti ho mostrato come eseguire una serie di attività (playbook) in tutti gli host nel file di inventario. Ma cosa succede se si desidera eseguire una serie di attività in alcuni host e un'altra serie di attività in altri host? Puoi raggruppare gli host nel file di inventario ed eseguire diverse attività sui gruppi di host.

In questa sezione, ti mostrerò come raggruppare gli host nel file di inventario e come lavorare con i gruppi di host.

Per prima cosa, apri il file di inventario padroni di casa come segue:

$nanopadroni di casa

Digita le seguenti righe nel padroni di casa file di inventario:

[debian10]
vm1.nodekite.com
vm2.nodekite.com
[centos8]
vm3.nodekite.com
vm4.nodekite.com

Qui, ho creato due gruppi di host: debian10 e centos8 .

Nel debian10 gruppo, ho due host: vm1.nodekite.com e vm2.nodekite.com

Nel centos8 gruppo, ho due host: vm3.nodekite.com e vm4.nodekite.com

Una volta terminato, salvare il file premendo + X seguito da E e .

Ora creeremo un nuovo playbook ping_debian10_hosts.yaml , che eseguirà il ping degli host come prima, ma solo gli host nel debian10 gruppo ospitante.

Crea un playbook ping_debian10_hosts.yaml nel libri di gioco/ directory come segue:

$nanoplaybook/ping_debian10_hosts.yaml

Digita le seguenti righe nel ping_debian10_hosts.yaml Libro di gioco Ansible:

- host: debian10
utente: ansible
compiti:
- nome: Ping all Debian10padroni di casa
ping:

Invece di host: tutti , Ho aggiunto host: debian10 qui. debian10 è il gruppo ospitante. Questo playbook verrà eseguito solo sugli host in debian10 gruppo ospitante.

Una volta terminato, salvare il file premendo + X seguito da E e .

Esegui il playbook come segue:

$playbook ansible-playbook/ping_debian10_hosts.yaml

Come puoi vedere, solo i padroni di casa nel debian10 gruppo host viene eseguito il ping.

Usando lo stesso metodo, crea un altro playbook ping_centos8_hosts.yaml come segue:

$nanoplaybook/ping_centos8_hosts.yaml

Digita le seguenti righe nel ping_centos8_hosts.yaml Libro di gioco Ansible:

- host: centos8
utente: ansible
compiti:
- nome: Ping tutto CentOS8padroni di casa
ping:

Allo stesso modo, ho aggiunto host: centos8 qui. centos8 è il gruppo ospitante. Questo playbook verrà eseguito solo sugli host in centos8 gruppo ospitante.

Una volta terminato, salvare il file premendo + X seguito da E e .

Esegui il playbook come segue:

$playbook ansible-playbook/ping_centos8_hosts.yaml

Come puoi vedere, solo i padroni di casa nel centos8 gruppo host viene eseguito il ping.

Tipi di variabili Ansible

Ci sono diversi tipi di variabili in Ansible. I principali tipi di variabili sono Variabili Ansible Facts e Variabili definite dall'utente .

Variabili di fatti Ansible: A seconda dell'host su cui sta lavorando Ansible, Ansible genera variabili di fatti Ansible. Le variabili dei fatti di Ansible contengono informazioni sull'host, come indirizzi IP, nome host, nome di dominio, data, ora, variabili di ambiente della shell e altro.

Variabili definite dall'utente: Si tratta di variabili personalizzate definite dall'utente. Puoi passare le variabili definite dall'utente dalla riga di comando o utilizzando il file di inventario.

Principalmente le variabili definite dall'utente sono di due tipi: Variabili di gruppo e Variabili host .

Precedenza variabile ansible

La precedenza variabile di Ansible è : Variabili della riga di comando > Variabili host > Variabili di gruppo

Se si imposta la stessa variabile della variabile host e della variabile di gruppo, verrà applicata la variabile host.

Allo stesso modo, le variabili impostate dalla riga di comando durante l'esecuzione di un playbook sostituiranno sia le variabili host che quelle di gruppo.

Lavorare con le variabili di fatti Ansible

In questa sezione, ti mostrerò come lavorare con le variabili dei fatti di Ansible. Quindi, cominciamo!

Puoi elencare tutte le variabili Ansible Facts degli host nel tuo padroni di casa file di inventario come segue:

$ansible tutto-uansible-mimpostare

Come puoi vedere, tutte le variabili Ansible Facts sono elencate in formato JSON. È una lista molto lunga.

Poiché l'elenco è piuttosto lungo, puoi aprirlo con un programma cercapersone come meno come segue:

$ansible tutto-uansible-mimpostare| meno

Ora puoi scorrere l'output in alto, in basso, a sinistra e a destra come richiesto.

Puoi anche cercare i nomi delle variabili dal cercapersone. Per farlo, premi il tasto / tasto sulla tastiera. Quindi, digita la stringa di ricerca ( Nome host nel mio caso) e premere .

Come puoi vedere, la variabile dei fatti Ansible che corrisponde alla stringa di ricerca è ansible_hostname . puoi premere n per andare alla prossima partita e P per passare alla corrispondenza precedente dal cercapersone. In questo modo trovi la variabile dei fatti Ansible di cui hai bisogno per il tuo progetto Ansible.

Vediamo ora come accedere alle variabili dei fatti di Ansible.

Crea un nuovo playbook print_variable1.yaml come segue:

$nanoplaybook/print_variable1.yaml

Digita le seguenti righe nel print_variable1.yaml file:

- host: tutti
utente: ansible
compiti:
- nome stampatoNome hostdi tutti gli host
eseguire il debug:
messaggio:'{{ ansible_hostname }}'

Qui, ho aggiunto un compito Stampa il nome host di tutti gli host . Questa attività utilizza Ansible eseguire il debug modulo per stampare un messaggio quando viene eseguito il playbook.

msg è l'unico parametro richiesto di eseguire il debug modulo. Il msg Il parametro accetta una stringa tra virgolette, che è il messaggio che verrà stampato sulla console.

Qui, {{ nome_variabile }} format viene utilizzato per accedere a una variabile. In questo caso, {{ ansible_hostname }} è usato per stampare il ansible_hostname variabile di ciascuno degli host nel file di inventario.

Una volta terminato, salvare il file premendo + X seguito da E e .

Puoi anche accedere alla variabile dei fatti di Ansible come fatti_ansibles[nome_variabile] . Così il ansible_hostname variabile diventerà ansible_facts[nome host] .

Possiamo riscrivere il print_variable1.yaml playbook come questo pure. Otterremo lo stesso output.

- host: tutti
utente: ansible
compiti:
- nome stampatoNome hostdi tutti gli host
eseguire il debug:
messaggio:'{{ ansible_facts['variable_name'] }}'

Esegui il playbook print_variable1.yaml come segue:

$playbook ansible-playbook/print_variable1.yaml

Come puoi vedere, il nome host di ciascuno degli host nel file di inventario è stampato sulla console.

Stampiamo ora l'indirizzo IPv4 predefinito di ciascun host insieme al nome host. Come puoi vedere, è possibile accedere all'indirizzo IPv4 predefinito dell'host utilizzando il pulsante indirizzo proprietà del ansible_default_ipv4 oggetto.

Crea un nuovo playbook print_variable2.yaml come segue:

$nanoplaybook/print_variable2.yaml

Digita le seguenti righe nel print_variable2.yaml file:

- host: tutti
utente: ansible
compiti:
- nome stampatoNome hostdi tutti gli host
eseguire il debug:
messaggio:'{{ ansible_hostname }} - {{ ansible_default_ipv4.address }}'

Questo playbook è lo stesso di prima. L'unica differenza è la nuova variabile {{ ansible_default_ipv4.address }} nel msg opzione del eseguire il debug modulo.

Una volta terminato, salvare il file premendo + X seguito da E e .

Corri il print_variable2.yaml playbook come segue:

$playbook ansible-playbook/print_variable2.yaml

Come puoi vedere, l'indirizzo IPv4 predefinito e il nome host degli host sono stampati sulla console.

Quindi, questo è il modo in cui lavori con le variabili Ansible Facts.

Impostazione delle variabili definite dall'utente dalla riga di comando:

In questa sezione, ti mostrerò come impostare le variabili definite dall'utente dalla riga di comando durante l'esecuzione di playbook Ansible.

Per prima cosa, crea un nuovo playbook print_variable3.yaml come segue:

$nanoplaybook/print_variable3.yaml

Digita le seguenti righe nel print_variable3.yaml file:

- host: tutti
utente: ansible
compiti:
- nome stampatocomandovariabile di linea
eseguire il debug:
messaggio:'Benvenuto {{ nome utente }}'

Ecco, ho usato il eseguire il debug modulo per stampare il messaggio Benvenuto {{ nome utente }} . nome utente è una variabile che verrà sostituita quando eseguiremo il playbook.

Una volta terminato, salvare il file premendo + X seguito da E e .

Esegui il playbook print_variable3.yaml come segue:

$ansible-playbook-e 'nome utente=Bob'playbook/print_variable3.yaml

NOTA: Qui, -e l'opzione è usata per passare a nome utente variabile con il valore Bob al playbook print_variable3.yaml dalla riga di comando.

Come puoi vedere, il messaggio Benvenuto Bob è stampato sulla console.

Scopriamo ora come passare più variabili dalla riga di comando.

Crea un nuovo playbook print_variable4.yaml come segue:

$nanoplaybook/print_variable4.yaml

Digita le seguenti righe nel print_variable4.yaml file:

- host: tutti
utente: ansible
compiti:
- nome: stampa le variabili definite dall'utente
eseguire il debug:
messaggio:'nome utente={{ nome utente }} http_port={{ http_port }}'

Il playbook dovrebbe esserti molto familiare in questo momento. Non fa altro che stampare le 2 variabili nome utente e http_port sulla console.

Una volta terminato, salvare il file premendo + X seguito da E e .

Ora puoi passare il nome utente e http_port variabile al playbook utilizzando due differenti -e opzione come segue:

$ ansible-playbook-e 'nome utente=Bob' -e 'http_port=8080'
playbook/print_variable4.yaml

Oppure, puoi semplicemente separare le variabili con uno spazio bianco, come segue:

$ ansible-playbook-e 'nome utente=Bob http_port=8080'
playbook/print_variable4.yaml

Come puoi vedere, il nome utente e http_port le variabili sono stampate sulla console.

Utilizzo di variabili di gruppo definite dall'utente

Diciamo che vuoi aggiungere alcune variabili a un gruppo di host. Questa azione è molto facile da eseguire in Ansible.

Per prima cosa, apri il tuo padroni di casa file di inventario come segue:

$nanopadroni di casa

Digita le seguenti righe nel tuo padroni di casa file di inventario:

[debian10]
vm1.nodekite.com
vm2.nodekite.com
[debian10:vars]
nome utente = Giglio
http_port =4343
[centos8]
vm3.nodekite.com
vm4.nodekite.com
[centos8: vars]
nome utente = Bob
http_port =7878

Come puoi vedere, ho creato una nuova sezione [debian10:var] per debian10 gruppo host e aggiunto le variabili ( nome utente e http_port ) per debian10 gruppo ospitante lì.

Allo stesso modo, ho creato una nuova sezione [centos8: var] per centos8 gruppo host e aggiunto le variabili ( nome utente e http_port ) per centos8 gruppo ospitante lì.

Una volta terminato, salva il padroni di casa file di inventario premendo + X seguito da E e .

Corri il print_variable4.yaml playbook come segue:

$playbook ansible-playbook/print_variable4.yaml

Come puoi vedere, le variabili corrette vengono passate a ciascuno degli host a seconda del loro gruppo di host.

Utilizzo di variabili host definite dall'utente

In questa sezione, ti mostrerò come impostare le variabili per host specifici nel file di inventario.

Per prima cosa, apri il padroni di casa file di inventario come segue:

$nanopadroni di casa

Per aggiungere variabili a un host specifico (ad esempio, vm1.nodekite.com ), basta aggiungere uno spazio/tab dopo il nome IP/DNS dell'host e digitare le variabili, come mostrato nella schermata seguente.

Puoi anche aggiungere più variabili. Separa semplicemente ogni variabile con uno spazio.

Una volta terminato, salva il file di inventario premendo + X seguito da E e .

Corri il print_variable4.yaml playbook come segue:

$playbook ansible-playbook/print_variable4.yaml

Come puoi vedere, le variabili sono impostate solo per il vm1.nodekite.com ospite. Agli altri host sono applicate variabili di gruppo.

Generazione rapida di file di inventario con gli intervalli

Puoi utilizzare gli intervalli per generare rapidamente file di inventario Ansible se gli indirizzi IP dell'host o i nomi DNS sono coerenti (ovvero hanno un formato specifico).

Negli esempi precedenti, ho usato gli host vm1.nodekite.com , vm2.nodekite.com , vm3.nodekite.com e vm4.nodekite.com . Invece di digitare 4 righe, avrei potuto semplicemente digitare vm[1:4].nodekite.com nel file di inventario.

Per sperimentare con gli intervalli, aprire il padroni di casa file di inventario come segue:

$nanopadroni di casa

Rimuovere tutti gli host e le variabili dai file di inventario.

Ora possiamo sostituire vm1.nodekite.com e vm2.nodekite.com insieme a vm[1:2].nodekite.com per debian10 gruppo ospitante come segue.

Allo stesso modo, possiamo sostituire vm3.nodekite.com e vm4.nodekite.com insieme a vm[3:4].nodekite.com per centos8 gruppo ospitante.

Una volta terminato, salvare il file premendo + X seguito da E e .

Corri il ping_all_hosts.yaml come segue:

$playbook ansible-playbook/ping_all_hosts.yaml

Come puoi vedere, gli intervalli di host sono stati espansi quando ho eseguito il playbook.

Memorizzazione di variabili in file diversi

Memorizzare le variabili di gruppo e le variabili host nello stesso file di inventario è molto semplice. Ma potresti cercare una maggiore flessibilità. Soprattutto quando si desidera utilizzare gli intervalli nel file di inventario poiché non è più possibile impostare le variabili host se si utilizzano gli intervalli. Bene, puoi memorizzare variabili di gruppo e variabili host in file diversi. In questa sezione, ti mostrerò come è fatto.

Per impostazione predefinita, Ansible cerca le variabili di gruppo nel group_vars / directory e variabili host nel variabili_host / directory.

Quindi, crea il group_vars / e variabili_host / directory come segue:

$mkdir -pv {ospite,gruppo}_il cui, di chi

Per impostare le variabili di gruppo per il debian10 gruppo host, crea un file debian10 (uguale al nome del gruppo) in group_vars / directory come segue:

$nanogroup_vars/debian10

Digita le tue variabili come segue:

nome utente: Lily
http_port: 4343

Una volta terminato, salvare il file premendo + X seguito da Y e .

Allo stesso modo, per impostare le variabili di gruppo per centos8 gruppo host, crea un file centos8 (uguale al nome del gruppo) in group_vars / directory come segue:

$nanogroup_vars/centos8

Digita le tue variabili come segue:

nome utente: Bob
http_port: 7878

Una volta terminato, salvare il file premendo + X seguito da Y e .

Corri il print_variable4.yaml playbook come segue:

$playbook ansible-playbook/print_variable4.yaml

Come puoi vedere, le variabili di gruppo sono impostate correttamente per ciascun gruppo di host.

Per impostare le variabili host per l'host vm1.nodekite.com , crea un file vm1.nodekite.com (uguale al nome host o all'indirizzo IP) nel variabili_host / directory come segue:

$nanovm1.nodekite.com

Digita le variabili host come segue:

nome utente: Alex
http_port: 7788

Una volta terminato, salvare il file premendo + X seguito da Y e .

Corri il print_variable4.yaml playbook come segue:

$ playbook ansible-playbook/print_variable4.yaml
[

Come puoi vedere, le variabili host sono impostate correttamente per l'host vm1.nodekite.com .

Lavorare con i loop in Ansible

In questa sezione, ti mostrerò come utilizzare i loop in Ansible.

Per prima cosa, crea un nuovo playbook loop1.yaml nel libri di gioco/ directory come segue:

$nanoplaybook/loop1.yaml

Digita le seguenti righe nel loop1.yaml libro di gioco:

- host: tutti
utente: ansible
compiti:
- nome: Stampa elenco utenti
eseguire il debug:
messaggio:'Utente: {{ articolo }}'
with_items:
- Alex
- Bob
- Lily

Qui, ho 1 attività che stampa un elenco di utenti utilizzando loop.

Per impostare i valori di iterazione per l'attività, si usa il with_items modulo. Quindi, aggiungi i valori uno per uno.

with_items:
- Alex
- Bob
- Lily

Accedete al valore dell'iterazione corrente usando il articolo variabile.

eseguire il debug:
messaggio:'Utente: {{ articolo }}'

Una volta terminato, salvare il file premendo + X seguito da E e .

Corri il loop1.yaml playbook come segue:

$playbook ansible-playbook/loop1.yaml

Come puoi vedere, la stessa attività è stata eseguita per ogni elemento su ciascun host. Quindi, il ciclo funziona.

Lavorare con le condizioni in Ansible

Se desideri eseguire attività in base a determinate condizioni, questa sezione fa per te.

Per eseguire attività in base alle condizioni, puoi utilizzare il quando modulo di Ansible. Vediamo un esempio di questo modulo. Per prima cosa, crea un nuovo playbook condition1.yaml come segue:

$nanoplaybook/condition1.yaml

Digita le seguenti righe nel condition1.yaml libro di gioco:

- host: tutti
utente: ansible
compiti:
- nome: esegui questa attività solo su Debian
eseguire il debug:
messaggio:'questo compito è in esecuzione su Debian'
quando: ansible_facts['distribuzione']=='Debian'

Qui,

ansible_facts['distribution'] == 'Debian' viene utilizzato per verificare se il distribuzione è Debian . L'attività verrà eseguita solo se la distribuzione è Debian.

Il ansible_facts['distribuzione'] viene utilizzato per accedere alla variabile Ansible Facts distribuzione_ansible . Puoi anche controllare la versione di distribuzione usando il ansible_distribution_major_version variabile.

Una volta terminato, salvare il file premendo + X seguito da E e .

Corri il condition1.yaml playbook come segue:

$playbook ansible-playbook/condition1.yaml

Come puoi vedere, l'attività è stata eseguita solo sugli host Debian. L'attività non è stata eseguita sugli host CentOS.

Puoi anche controllare più condizioni contemporaneamente ed eseguire l'attività solo se tutte le condizioni sono vere. Vediamo un esempio.

Crea un nuovo playbook condition2.yaml come segue:

$nanoplaybook/condition2.yaml

Digita le seguenti righe nel condition2.yaml file:

- host: tutti
utente: ansible
compiti:
- nome: esegui questa attività solo su Debian10
eseguire il debug:
messaggio:'questa attività è in esecuzione su Debian 10'
quando: ansible_facts['distribuzione']=='Debian'
e fatti_ansible['distribution_major_version']=='10'

Qui, l'attività verrà eseguita solo se la distribuzione è Debian ( ansible_facts['distribution'] == 'Debian' ) e la versione è 10 ( ansible_facts['distribution_major_version'] == '10' ). Se entrambe le condizioni sono vere, l'attività verrà eseguita. In caso contrario, l'attività non verrà eseguita.

ho usato il e parola chiave per verificare se entrambe le condizioni sono vere qui. Se vuoi verificare se una qualsiasi delle condizioni è vera, puoi usare il o parola chiave invece.

Una volta terminato, salvare il file premendo + X seguito da E e .

Esegui il playbook condition2.yaml come segue:

$playbook ansible-playbook/condition2.yaml

Come puoi vedere, l'attività è stata eseguita solo sugli host Debian 10.

Cambiamo il playbook condition2.yaml per eseguire l'attività solo su host Debian 8 come segue.

Come puoi vedere, tutti gli host sono stati ignorati poiché non ho alcun host Debian 8 nel file di inventario.

Lavorare con il modulo Ansible apt

Il adatto modulo di Ansible viene utilizzato per installare un pacchetto software specifico su host Ubuntu/Debian. Vediamo come utilizzare questo modulo.

Per prima cosa, crea un nuovo playbook apt1.yaml nel libri di gioco/ directory come segue:

$nanoplaybook/apt1.yaml

Digita le seguenti righe nel apt1.yaml libro di gioco:

- host: debian10
utente: ansible
diventa vero
compiti:
- nome: Installa apache2
adatto:
nome: apache2
stato: ultimo

Il adatto modulo richiede solo il nome del pacchetto che si desidera installare/aggiornare/rimuovere e il stato del pacchetto.

Ecco, sto cercando di installare il apache2 pacchetto ( nome: apache2 ) sui miei host Debian 10. Poiché sto cercando di installare un pacchetto e anche di aggiornarlo se è disponibile una nuova versione, il stato dovrebbe essere più recente .

stato accetta anche le seguenti opzioni:

- assente – Il pacchetto verrà rimosso se già installato.
- più recente – Il pacchetto verrà aggiornato se è disponibile un aggiornamento. Se il pacchetto non è già installato, verrà installato.
- regalo – Il pacchetto verrà installato se non è già installato. Ma il pacchetto non verrà aggiornato se è disponibile un aggiornamento.

Nota che ho aggiunto diventa vero nel playbook. Questo darà il ansible privilegi utente sudo per modificare la struttura del filesystem (ad esempio installa/aggiorna/rimuovi pacchetti). Privo di diventa vero , il adatto modulo non sarà in grado di installare il apache2 pacchetto.

Una volta terminato, salva il playbook premendo + X seguito da E e .

Corri il apt1.yaml playbook come segue:

$playbook ansible-playbook/apt1.yaml

Come puoi vedere, il playbook è stato eseguito con successo sugli host Debian 10.

Come puoi vedere, il apache2 pacchetto è installato sui miei host Debian 10.

Lavorare con il modulo Ansible dnf/yum

Il dnf e yum modulo di Ansible viene utilizzato per installare un pacchetto software specifico su host CentOS/RHEL. Puoi usare questo modulo nello stesso modo in cui lo hai fatto adatto modulo nella sezione precedente di questo articolo.

entrambi i dnf e yum i moduli accettano gli stessi parametri. Puoi usare il dnf modulo su host CentOS/RHEL 8 e yum su CentOS/RHEL 7 o versioni precedenti.

Vediamo ora un esempio di questo modulo.

Per prima cosa, crea un nuovo playbook dnf1.yaml nel libri di gioco/ directory come segue:

$nanoplaybook/dnf1.yaml

Digita le seguenti righe nel dnf1.yaml libro di gioco:

- host: centos8
utente: ansible
diventa vero
compiti:
- nome: Installa il pacchetto httpd
dnf:
nome: httpd
stato: ultimo

Il dnf e yum modulo richiede solo il nome del pacchetto che si desidera installare/aggiornare/rimuovere e il stato del pacchetto.

Ecco, sto cercando di installare il httpd pacchetto ( nome: httpd ) sui miei host CentOS 8. Poiché sto cercando di installare un pacchetto e vorrei anche aggiornarlo se è disponibile una nuova versione, il stato dovrebbe essere più recente .

stato accetta le seguenti opzioni:

- assente – Il pacchetto verrà rimosso se già installato.
- più recente – Il pacchetto verrà aggiornato se è disponibile un aggiornamento. Se il pacchetto non è già installato, verrà installato.
- regalo – Il pacchetto verrà installato se non è già installato. Ma il pacchetto non verrà aggiornato se è disponibile un aggiornamento.

Nota che ho aggiunto diventa vero nel playbook. Questo dà il ansible privilegi utente sudo per modificare la struttura del filesystem (ad esempio installa/aggiorna/rimuovi pacchetti). Privo di diventa vero , il adatto modulo non sarà in grado di installare il httpd pacchetto.

Una volta terminato, salva il playbook premendo + X seguito da E e .

Corri il dnf1.yaml playbook come segue:

$playbook ansible-playbook/dnf1.yaml

Come puoi vedere, il playbook è stato eseguito correttamente sull'host CentOS 8.

Lavorare con il modulo di servizio Ansible

Il servizio Il modulo di Ansible viene utilizzato per avviare, arrestare, riavviare, abilitare (aggiungere il servizio all'avvio) e disabilitare (rimuovere il servizio dall'avvio) i servizi nei tuoi host.

Nelle sezioni precedenti, ti ho mostrato come installare il pacchetto del server HTTP Apache utilizzando Ansible adatto , dnf e yum moduli. Assicuriamoci ora che il servizio del server Apache HTTP sia in esecuzione e sia stato aggiunto all'avvio del sistema.

Lavorerò con i miei host Debian 10. Ma puoi lavorare con gli host CentOS 8, se lo desideri. Regola semplicemente il playbook di conseguenza.

Innanzitutto, crea un nuovo playbook Ansible apt2.yaml come segue:

$nanoplaybook/apt2.yaml

Digita le seguenti righe nel apt2.yaml libro di gioco:

- host: debian10
utente: ansible
diventa vero
compiti:
- nome: Installa apache2
adatto:
nome: apache2
stato: ultimo
- nome: avvia il servizio apache2
servizio:
nome: apache2
stato: iniziato
abilitato: Vero

Qui, ho aggiunto una nuova attività, Avvia il servizio apache2 .

nome: apache2 – il servizio su cui sto lavorando è apache2 .

stato: iniziato – il servizio deve essere in esecuzione.

abilitato: Vero – il servizio deve essere aggiunto all'avvio del sistema.

Il stato il parametro accetta altri valori.

- ricaricato – Il servizio deve ricaricare i file di configurazione.
- riavviato – Il servizio deve essere riavviato.
- cominciato – Il servizio deve essere in esecuzione. Se il servizio non è in esecuzione, avvia il servizio.
- fermato – Il servizio deve essere interrotto. Se il servizio è in esecuzione, interrompere il servizio.

Esegui il playbook apt2.yaml come segue:

$playbook ansible-playbook/apt2.yaml

Come puoi vedere, il playbook è stato eseguito correttamente.

Come puoi vedere, il apache2 servizio è in esecuzione sui miei host Debian 10.

Lavorare con il modulo di copia Ansible

L'Ansible copia viene utilizzato principalmente per copiare file dal tuo computer a host remoti.

Nella sezione precedente, ho installato il server Web Apache 2 sui miei host Debian 10. Copiamo ora un index.html file nella webroot degli host Debian 10.

Per prima cosa, crea una nuova directory File/ come segue:

$mkdir -vFile

Crea un nuovo file index.html nel File/ directory come segue:

$nanoFile/index.html

Digita le seguenti righe nel index.html file:


< html >
< testa >
< titolo >Server web di Ansible</ titolo >
</ testa >
< corpo >
< h1 >Benvenuto in LinuxHint</ h1 >
< P >Questo server web è stato distribuito con Ansible.</ P >
</ corpo >
</ html >

Una volta terminato, salvare il file premendo + X seguito da E e .

Crea un nuovo playbook Ansible apt3.yaml come segue:

$nanoplaybook/apt3.yaml

Digita le seguenti righe nel apt3.yaml file:

- host: debian10
utente: ansible
diventa vero
compiti:
- nome: Installa apache2
adatto:
nome: apache2
stato: ultimo
- nome: copia index.html sul server
copia:
src: ../File/index.html
destinazione:/dove/www/html/index.html
modalità: 0644
proprietario: www-data
gruppo: www-data
- nome: avvia il servizio apache2
servizio:
nome: apache2
stato: iniziato
abilitato: Vero

Ecco, il compito Copia index.html sul server copia il index.html dal File/ directory per il /var/www/html/ directory degli host Debian 10.

src: ../files/index.html – Il percorso del file di origine.
dest: /var/www/html/index.html – Il percorso del file di destinazione.
modalità: 0644 – Le autorizzazioni per l'utente del file (6 – lettura e scrittura), gruppo (4 – lettura) e altri (4 – lettura).
proprietario: www-data – Imposta il proprietario del file su www-dati .
gruppo: www-data – Impostare il gruppo del file su www-dati .

Una volta terminato, salvare il file premendo + X seguito da E e .

Corri il apt3.yaml playbook come segue:

$playbook ansible-playbook/apt3.yaml

Come puoi vedere, il compito Copia index.html sul server ha successo.

Come puoi vedere, il index.html il file è stato copiato negli host Debian 10.

Come puoi vedere, il server web Debian 10 serve il index.html pagina che ho appena copiato sugli host Debian 10.

Quindi, queste sono le basi di Ansible. Puoi saperne di più su Ansible leggendo la documentazione ufficiale di Ansible. Grazie per aver letto questo articolo.