Come lavorare con Ansible When e altre condizioni

Se hai bisogno di eseguire attività Ansible basate su diverse condizioni, allora sei fortunato. Ansible when e altre condizioni ti permettono di valutare condizioni, come ad esempio in base al sistema operativo, o se un’attività dipende dall’attività precedente.

In questo tutorial, imparerai come lavorare con Ansible when e altre condizioni in modo da poter eseguire attività senza creare problemi.

Iniziamo!

Prerequisiti

Questo tutorial comprende esempi pratici. Se desideri seguirlo, assicurati di avere quanto segue a disposizione:

• Un host controller Ansible – Questo tutorial utilizza Ansible v2.9.24 ospitato su una macchina Ubuntu 18.04.5 LTS.

Correlati:Guida: Come configurare Ansible (Ubuntu, RHEL, CentOS, macOS)

• A remote computer to run commands.
• Avrai bisogno di un file di inventario configurato e uno o più host già configurati per eseguire comandi e playbook di Ansible. Il tutorial utilizzerà un gruppo di inventario chiamato web.

Lavorare con Ansible when con più attività in un playbook

Avere più attività in un playbook può essere noioso se vengono tutte eseguite senza condizioni specifiche. Iniziamo questo tutorial definendo le condizioni when nel playbook Ansible con più attività.

1. Apri un terminale sull’host controller di Ansible.

2. Esegui i comandi seguenti per creare una directory e assegnarle un nome a tua scelta nella tua directory home, e naviga in quella directory.

Per questo esempio, la directory si chiama ansible_when_condition_demo. Questa directory conterrà il playbook che utilizzerai per invocare la condizione when all’interno dell’attività Ansible.

# Crea una directory chiamata ~/ansible_when_condition_demo
mkdir ~/ansible_when_condition_demo
# Cambia la directory di lavoro in ~/ansible_when_condition_demo
cd ~/ansible_when_condition_demo

3. Nel tuo editor di codice preferito, crea un file YAML nella directory ~/ansible_when_condition_demo. In questo esempio, il file si chiama my_playbook.yml. Copia e incolla il contenuto del playbook YAML qui sotto nel file my_playbook.yml.

In entrambe le attività seguenti (Task-1 e Task-2), le condizioni when verificano su quale sistema operativo si trova ogni host remoto. Il risultato viene quindi passato alla variabile segnaposto ansible_os_family su ogni attività.

Se il valore del segnaposto ansible_os_family è uguale a RedHat o Debian, allora Ansible esegue una delle attività per installare Apache.

---
- name: Ansible tasks to work on Ansible When
# Definizione del server remoto su cui Ansible verrà eseguito
  hosts: web
  remote_user: ubuntu # Utilizzo di un host remoto come ubuntu
  become: true # Esecuzione delle attività come utente con privilegi elevati (sudo)
  tasks:

# (Attività 1) Verifica se ansible_os_family == "RedHat" e quindi installa Apache sul nodo remoto
    - name: Install Apache on CentOS  Server
      yum: name=httpd  state=present
      become: yes
      when: ansible_os_family == "RedHat"

# (Attività 2) Verifica se ansible_os_family == "Debian" e quindi installa Apache sul nodo remoto
    - name: Install Apache on Ubuntu Server
      apt:name=apache2 state=present
      become: yes
      when: ansible_os_family == "Debian"

4. Ora esegui il comando ansible-playbook di seguito per eseguire le attività definite nel playbook (my_playbook.yml) sull’host remoto, definito nel tuo file di inventario esistente.

ansible-playbook my_playbook.yml 

Nella schermata sottostante, puoi vedere che:

• La prima ATTIVITÀ ha restituito uno stato OK, il che indica che l’attività non richiede alcuna modifica.
• La seconda ATTIVITÀ ha restituito uno stato di skipping. Quando la condizione non viene soddisfatta, l’attività viene saltata.
• La terza ATTIVITÀ ha restituito uno stato di changed, il che indica che l’host remoto non era nello stato corretto (ossia Apache non è presente) ed è stato modificato per installare Apache.

5. Apri una sessione SSH verso l’host remoto, che era l’obiettivo del playbook Ansible, utilizzando il tuo client SSH preferito per verificare che Apache sia installato e in esecuzione.

6. Infine, esegui il comando service di seguito per verificare se Apache è installato (status apache2) sull’host remoto.

service status apache2

Come puoi vedere di seguito, hai installato il servizio Apache sulla macchina remota.

Lavorando con Ansible when e cicli

In precedenza hai eseguito compiti Ansible in base a un parametro di Ansible when per un parametro specifico come ansible_os_family. Ma forse è necessario controllare una condizione con più parametri definiti in una lista. In tal caso, prova ad aggiungere un loop in un compito.

Apri il file my_playbook.yml che hai creato in precedenza (passaggio tre sotto “Lavorare con Ansible when con molteplici attività nel playbook”). Sostituisci il contenuto del file my_playbook.yml con il codice seguente.

La attività nel codice seguente (Task-1) esegue un loop in cui la condizione when controlla se il valore dell’elemento è maggiore di cinque e restituisce il risultato.

---
- name: Ansible tasks to work on Ansible When
# Definizione del server remoto su cui verrà eseguito Ansible
  hosts: web
  remote_user: ubuntu   # Utilizzo di un host remoto come ubuntu
  become: true
  tasks:
  # (Task -1) Controllo se il valore dell'elemento è maggiore di 5
    - name: Run with items greater than 5
      ansible.builtin.command: echo {{ item }}
      loop: [ 0, 2, 4, 6, 8, 10 ]
      when: item > 5*

Ora esegui il comando di seguito per eseguire il playbook come hai fatto in precedenza.

 ansible-playbook my_playbook.yml

Di seguito, è possibile vedere lo stato restituito skipping quando la condizione è falsa e lo stato changed quando la condizione è vera.

Lavorando con Ansible when e i facts di Ansible

Forse vuoi aggiungere più condizioni per eseguire un’attività. In tal caso, impara come utilizzare i facts di Ansible all’interno della condizione when. I facts di Ansible ti consentono di aggiungere una dichiarazione condizionale per eseguire attività basate su facts raccolti, come il tuo sistema operativo, gli indirizzi IP, i file system collegati e altro ancora.

Sostituisci il contenuto del file my_playbook.yml con il seguente codice.

Nel codice sottostante, entrambe le attività (Task-1 e Task-2) vengono eseguite (arresto del sistema) solo quando una delle condizioni seguenti è vera:

• Sia il valore distribution che il valore distribtion_major_version restituiscono un valore vero.
• Il valore di os_family è uguale a CentOS.

---
- name: Ansible When Single task example
  hosts: web
  remote_user: ubuntu
  become: true
  tasks:
# (Task-1): Per arrestare il nodo remoto se la distribuzione è CentOS con una versione principale 6 
    - name: Shut down CentOS 6 systems
      ansible.builtin.command: /sbin/shutdown -t now
      when:
        - ansible_facts['distribution'] == "CentOS"
        - ansible_facts['distribution_major_version'] == "6"
# (Task-2): Per arrestare il nodo remoto se os_family è CentOS. 
    - name: Shut down CentOS flavored systems
      ansible.builtin.command: /sbin/shutdown -t now
      when: ansible_facts['os_family'] == "CentOS"

Esegui il playbook come hai fatto in precedenza con il comando seguente.

ansible-playbook my_playbook.yml

Nota che entrambe le attività mostrano lo stato skipping poiché si è in Ubuntu. L’attività viene eseguita solo se si è in CentOS.

Lavorare con Ansible when basato su valori registrati

A volte si desidera eseguire o saltare un’attività in base all’esito di un’attività precedente in un playbook. Ad esempio, si potrebbe voler configurare un servizio dopo un aggiornamento dell’attività precedente. In questo caso, utilizzare una variabile registrata. Una variabile registrata consente di registrare l’esito dell’attività precedente come variabile e utilizzarla per la prossima attività come input.

1. Creare una directory vuota chiamata /home/ubuntu/hello.

2. Sostituire il contenuto del file my_playbook.yml con il codice seguente, che esegue quanto segue:

La prima attività (Task-1) elenca i contenuti (file e sottodirectory) della directory /etc/hosts in memoria e salva quel risultato nella variabile contents1 tramite il comando register.

La seconda attività (Task-2) elenca i contenuti (attualmente vuoti) della directory /home/ubuntu/hello in memoria e salva quel elenco nella variabile contents2.

La terza attività (Task-3) controlla e stampa un messaggio “La directory è vuota” se sia il risultato registrato per la variabile contents1 che contents2 è vuoto.

La proprietà stdout delle variabili contents1 e contents2 è l’output della shell salvato dal risultato dell’esecuzione dei comandi di attività.

---
- name: Ansible When Single task example
  hosts: web
  remote_user: ubuntu
  become: true
  tasks:
# (Task-1): Elencare il contenuto della directory in /etc/hosts
      - name: List contents of directory and Store in content1
        ansible.builtin.command: ls /etc/hosts
        register: contents1
# (Task-2): Elencare il contenuto della directory in /home/ubuntu/hello
      - name: List contents of directory and Store in content2
        ansible.builtin.command: ls /home/ubuntu/hello
        register: contents2
# (Task-3): Visualizzare "La directory è vuota" se una delle directory 
# /etc/hosts o /home/ubuntu/hello è vuota
      - name: Check contents for emptiness for content1 or content2
        ansible.builtin.debug:
          msg: "Directory is empty"
        when: contents1.stdout == "" or contents2.stdout == ""

3. Infine, eseguire il playbook con il comando ansible-playbook di seguito.

ansible-playbook my_playbook.yml

Come mostrato di seguito, poiché il risultato registrato per la variabile contents2 è vuoto, il terzo task restituisce il messaggio La directory è vuota.

Lavorare con il when di Ansible nelle Roles di Ansible

In questo ultimo esempio, imparerai come funziona il when di Ansible all’interno delle Roles di Ansible. Le roles di Ansible ti permettono di riutilizzare configurazioni standard e di effettuare un deploy più rapido. Continua a leggere per scoprire come un task invoca le roles di Ansible solo se la condizione when di Ansible è vera.

Correlato:Comprensione e configurazione delle Roles di Ansible [Tutorial]

1. Esegui i comandi seguenti per creare una directory chiamata ~/ansible_role_when_demo nella tua directory home e cambia a quella cartella come directory di lavoro. La directory ~/ansible_role_when_demo conterrà i file di esempio di questo esempio.

# Crea una directory chiamata ~/ansible_role_when_demo nella tua directory home
mkdir ~/ansible_role_when_demo
# Cambia alla directory ~/ansible_role_when_demo
cd ~/ansible_role_when_demo

2. Successivamente, esegui i comandi seguenti per creare una directory ~/ansible_role_when_demo/roles e una directory ~/ansible_role_when_demo/roles/java/tasks.

Di seguito è riportato ciò che conterrà ogni directory:

• La directory ~/ansible_role_when_demo/roles conterrà il ruolo che devi distribuire.

Per impostazione predefinita, Ansible cerca i ruoli in due posizioni: in una directory chiamata roles/ all’interno della directory in cui si trova il playbook o in /etc/ansible/roles. Se desideri archiviare i ruoli in percorsi diversi, dichiara i percorsi usando il parametro - role: nel playbook.

• La cartella ~/ansible_role_when_demo/roles/java/tasks conterrà un file main.yml che sarà necessario per distribuire un ruolo.

# Crea una directory chiamata roles all'interno della directory ~/ansible_role_when_demo
mkdir -p roles
# Cambia la directory di lavoro nella directory ~/ansible_role_when_demo/roles
cd roles 
# Crea la directory padre (-p) chiamata java e una sottodirectory chiamata tasks
mkdir -p java/tasks

Ora, crea un file chiamato main.yml nella directory ~/ansible_role_when_demo/roles/java/tasks, quindi copia e incolla il codice di playbook di seguito nel file main.yml.

Il playbook di seguito installa Java sul nodo remoto in cui viene eseguito con il modulo apt.

Correlato:Come utilizzare il modulo apt di Ansible per gestire i pacchetti Linux

---
# Installazione di Java (Open Jdk)
- name: Install Java 1.8
  apt: name=openjdk-8-jdk

4. Crea un altro file YAML con un nome a tua scelta e copia/incolla il codice di seguito. Per questo esempio, il file è chiamato ~/ansible_role_when_demo/java-setup.yml.

Il codice di seguito distribuisce il ruolo Ansible (java) all’utente remoto (ubuntu) che ha accesso amministrativo solo quando l’utente remoto è su Debian OS.

- name: Java Installation playbook
# Definizione del server remoto su cui verrà distribuito il pacchetto
  hosts: myserver
  remote_user: ubuntu   # Utilizzo dell'utente remoto come ubuntu
  become: true
  tasks:  
  roles:
     - role: java
       # Esegui il task solo se il remote_user è su un sistema operativo Debian.
       when: ansible_facts['os_family'] == 'Debian'

5. Esegui il comando tree per verificare che tutte le cartelle e i file richiesti esistano nella directory ~/ansible_role_when_demo.

6. Infine, esegui il playbook con il comando ansible-playbook di seguito. ansible-playbook java-setup.yml

ansible-playbook java-setup.yml

Di seguito, il compito ha restituito uno stato changed, indicando che Java è stato installato con successo poiché il nodo remoto è un sistema Debian. Esecuzione del playbook Ansible utilizzando Ansible when con i ruoli di Ansible

Conclusione

In questo tutorial, hai imparato diversi modi per utilizzare Ansible when e altre condizioni. Hai anche imparato come applicare le condizioni di Ansible when, dalle attività di base che sfruttano i fatti di Ansible alla distribuzione di ruoli di Ansible.

Ora come potresti ampliare questa nuova conoscenza? Forse risparmiare tempo configurando più server con i modelli di Ansible applicando le condizioni di Ansible when?

Correlato:Come creare modelli di Ansible per risparmiare tempo di configurazione