Ricerca nel sito web

Come creare riproduzioni e playbook Ansible - Parte 5


In questa Parte 5 della serie Ansible, spiegheremo come creare Ansible Play e Playbook utilizzando i moduli Ansible.

Ansible viene fornito con script autonomi chiamati moduli che vengono utilizzati nei playbook per l'esecuzione di attività specializzate su nodi remoti.

I moduli sono utili per automatizzare attività come la gestione dei pacchetti, l'archiviazione e la copia dei file, per citarne solo alcune. Ti consentono di apportare modifiche ai file di configurazione e gestire dispositivi come router, switch, bilanciatori di carico, firewall e una serie di altri dispositivi.

L'obiettivo di questo argomento secondario è fornire una panoramica delle varie attività che possono essere eseguite dai moduli Ansible:

Gestione dei pacchetti in Linux

La gestione dei pacchetti è una delle attività più essenziali e frequenti svolte dagli amministratori di sistema. Ansible viene fornito con moduli che ti aiutano a eseguire attività di gestione dei pacchetti sia nei sistemi basati su RedHat che Debian.

Sono relativamente facili da indovinare. C'è il modulo apt per la gestione dei pacchetti APT per Debian based, il vecchio modulo yum per la gestione dei pacchetti YUM e il modulo dnf associato alle nuove distribuzioni RHEL .

Di seguito sono riportati alcuni esempi di come è possibile utilizzare i moduli in un playbook:

Esempio 1: installazione del server Web Apache su RHEL 8

---
- name: install Apache webserver
  hosts: webservers

  tasks:
       - name: install httpd
         dnf:  
          name: httpd  
          State: latest

Esempio 2: installazione del server Web Apache su Debian 10

---
- name: install Apache webserver
  hosts: databases

  tasks:
       - name: install Apache webserver
         apt:  
          name: apache2  
          State: latest

Modulo di servizio

Il modulo di servizio consente agli amministratori di sistema di avviare, arrestare, aggiornare, aggiornare e ricaricare i servizi sul sistema.

Esempio 1: avvio del server Web Apache

---
- name: Start service httpd, if not started
  service:
    name: httpd
    state: started

Esempio 2: arresto del server Web Apache

---
- name: Stop service httpd
  service:
    name: httpd
    state: stopped

Esempio 3: riavvio di un'interfaccia di rete enp2s0

---
- name: Restart network service for interface eth0
  service:
    name: network
    state: restarted
    args: enp2s0

Copia modulo

Come suggerisce il nome, il modulo di copia copia i file da una posizione sul computer remoto a una posizione diversa sullo stesso computer.

Esempio 1: copia di file da Linux locale a remoto

---
- name: Copy file with owner and permissions
  copy:
    src: /etc/files/tecmint.conf
    dest: /srv/tecmint.conf
    owner: tecmint
    group: tecmint
    mode: '0644'

Il playbook copia il file di configurazione tecmint.conf dalla directory /etc/files/ alla directory /srv/ come tecmint utente con autorizzazioni 0644.

Le autorizzazioni possono anche essere rappresentate utilizzando la rappresentazione simbolica come mostrato nell'ultima riga.

Esempio 2: copia di file da Linux locale a remoto

---
- name: Copy file with owner and permissions
  copy:
    src: /etc/files/tecmint.conf
    dest: /srv/tecmint.conf
    owner: tecmint
    group: tecmint
    mode: u=rw, g=r, o=r

I permessi nell'esempio precedente possono essere rappresentati come mostrato nell'ultima riga, All'utente vengono assegnati i permessi di lettura e scrittura, al gruppo vengono assegnati i permessi di scrittura e al resto al mondo vengono assegnati i permessi di lettura.

Modulo File

Il modulo file viene utilizzato per eseguire molte operazioni sui file, tra cui la creazione di file e directory, l'assegnazione di permessi sui file e l'impostazione di collegamenti simbolici.

Esempio 1: eseguire le autorizzazioni dei file Linux

---
- name: Change file ownership, group, and permissions
  file:
    path: /etc/tecmint.conf
    owner: tecmint
    group: tecmint
    mode: '0644'

La procedura precedente crea un file chiamato tecmint.conf nella directory /etc impostando i permessi su 0644.

Esempio 2: Elimina file Linux

---
- name: Remove file (delete file)
  file:
    path: /etc/tecmint.conf
    state: absent

Ciò rimuove o elimina il file tecmint.conf.

Esempio 3: creare una directory

---
- name: create a directory if it doesn’t exist
  file:
    path: /etc/mydirectory
    State: directory
    mode: '0777'

Verrà creata una directory nella directory /etc impostando le autorizzazioni su 0777.

Esempio 4: eliminare in modo ricorsivo una directory

---
- name: Recursively deleting a  directory
  file:
    path: /etc/tecmint.conf
    state: absent

La riproduzione precedente elimina ricorsivamente una directory.

Modulo Lineinfile

Il modulo lineinfile è utile quando desideri modificare una singola riga in un file. Può sostituire una linea esistente.

Esempio 1: manipolare file in Linux

---
 - name: Ensure SELinux is set to enforcing mode
  lineinfile:
    path: /etc/selinux/config
    regexp: '^SELINUX='
    line: SELINUX=disabled

La sequenza sopra imposta il valore SELINUX su disabilitato.

SELINUX=disabled

Esempio 2: modifica dei file in Linux

---
- name: Add a line to a file if the file does not exist, without         passing regexp
  lineinfile:
    path: /etc/hosts
    line: 10.200.50.51 linux-console.net
    create: yes

In questo modo viene aggiunta la voce 10.200.50.51 linux-console.net al file /etc/hosts.

Modulo Archivio

Un modulo Archivio viene utilizzato per la creazione di un archivio compresso di uno o più file. Si presuppone che l'origine della compressione esista e sia presente nella destinazione di destinazione. Dopo l'archiviazione, il file sorgente può essere successivamente eliminato o rimosso utilizzando l'istruzione remove=True.

Esempio 1: creare un file di archivio

- name: Compress directory /path/to/tecmint_dir/ into /path/to/tecmint.tgz
  archive:
    path: /path/to/tecmint_dir
    dest: /path/to/tecmint.tgz

This compresses the /path/to/tecmint_dir  directory to /path/to/tecmint.tgz

Esempio 2: creare un file di archivio e rimuoverlo

- name: Compress regular file /path/to/tecmint into /path/to/foo.gz and remove it
  archive:
    path: /path/to/tecmint
    dest: /path/to/tecmint.tgz
    remove: yes

Nella riproduzione precedente, il file sorgente /path/to/tecmint viene eliminato al termine dell'archiviazione.

Esempio 3: creare un file di archivio

- name: Create a bz2 archive of /path/to/tecmint
  archive:
    path: /path/to/tecmint
    format: bz2

Questo crea un file compresso in formato bz2 dal file /path/to/tecmint.

Modulo Git

Il modulo gestisce i checkout git dei repository software.

Esempio 1: controllare i repository Git

- git:
    repo: 'https://foosball.example.org/path/to/repo.git'
    dest: /srv/checkout
    version: release-0.22

Modulo di comando

Uno dei moduli più comunemente usati, il modulo command prende il nome del comando e successivamente seguito da un elenco di argomenti. Il comando viene trasmesso nello stesso modo in cui lo digiteresti in una shell Linux.

Esempio 1: eseguire un comando

- name: Executing a command using the command module
  command: cat helloworld.txt

Esempio 2: verifica del tempo di attività di Linux remoto

---
 - name: Check the remote host uptime
    hosts: servers
    tasks:
      - name: Execute the Uptime command over Command module
        register: uptimeoutput
        command: "uptime"

- debug:
          var: uptimeoutput.stdout_lines

Il modulo di comando recupera il tempo di attività dei server remoti.

Variabili per recuperare i risultati dell'esecuzione dei comandi

Di solito, i playbook Ansible vengono utilizzati per eseguire attività su host gestiti senza visualizzare l'output sulla riga di comando. In alcuni casi, tuttavia, potrebbe essere necessario acquisire l'output o i risultati. In questa sezione ti spiegheremo come acquisire l'output di un playbook in una variabile e visualizzarlo successivamente.

Un registro ansible viene utilizzato per acquisire l'output di un'attività e salvarlo come variabile. La variabile conterrà successivamente lo stdout dell'attività.

Ad esempio, supponiamo che tu voglia controllare l'utilizzo del disco dei nodi gestiti nelle rispettive directory root utilizzando il comando df -Th /. Utilizzerai il modulo 'command' per definire il comando e 'register' per salvare l'output std in una variabile.

Per visualizzare il comando, utilizzerai il modulo 'debug' insieme al valore restituito stdout.

---

 - hosts: all
   become: yes

   tasks:
     - name: Execute /boot usage on Hosts
       command: 'df -Th /'
       register: df

     - debug: var=df.stdout

Ora eseguiamo il playbook. In questo caso, abbiamo chiamato il nostro playbook check_disk_space.yml.

ansible-playbook check_disk_space.yml

Come hai visto, l'output è tutto confuso e rende difficile seguirlo.

Per allineare l'output e renderlo più facile da leggere, sostituisci il valore restituito stdout con stdout_lines.

---

 - hosts: all
   become: yes

   tasks:
     - name: Execute /boot usage on Hosts
       command: 'df -Th /'
       register: df

     - debug: var=df.stdout_lines

Usa i condizionali per controllare l'esecuzione della riproduzione

Proprio come nei linguaggi di programmazione, le dichiarazioni condizionali vengono utilizzate quando è possibile più di un risultato. Diamo un'occhiata ad alcune delle istruzioni condizionali comunemente utilizzate nei playbook Ansible.

Quando dichiarazione

A volte, potresti voler eseguire attività su nodi specifici e non su altri. L'istruzione condizionale 'when' è abbastanza facile da usare e implementare in un playbook. Quando si utilizza la clausola 'when' dichiara semplicemente la condizione adiacente alla clausola come mostrato:

when: condition

Quando la condizione è soddisfatta, l'attività viene eseguita sul sistema remoto.

Diamo un’occhiata ad alcuni esempi:

Esempio 1: utilizzo dell'operatore Quando

---
- hosts: all

  tasks:
  - name: Install Nginx on Debian
     apt: name=nginx state=present
     when: ansible_os_family == “Debian”

L'immagine sopra installa il server web Nginx su host che eseguono la famiglia di distribuzioni Debian.

Puoi anche utilizzare gli operatori OR e AND insieme all'istruzione condizionale quando.

Esempio 2: utilizzo dell'operatore AND con When

---
- hosts: all

  tasks:
  - name: Install Nginx on Debian
     apt: name=nginx state=present
     when: ansible_os_family == “Debian” and
           ansible_distribution_version == “18.04”

Quando si utilizza l'operatore AND, entrambe le istruzioni devono essere soddisfatte affinché l'attività venga eseguita.

L'immagine sopra installa Nginx su nodi che eseguono una famiglia di sistemi operativi Debian che è la versione 18.04. Ovviamente, questo sarà Ubuntu 18.04.

Esempio 3: utilizzo dell'operatore OR con When

Con l'operatore OR, l'attività viene eseguita se una delle condizioni è soddisfatta.

---
- hosts: all

  tasks:
  - name: Install Nginx on Debian
     apt: name=nginx state=present
     when: ansible_os_family == “Debian” or
	      Ansible_os_family == “SUSE”

Il gioco sopra installa i server web Nginx sulla famiglia di sistemi operativi Debian o SUSE o su entrambi.

NOTA: assicurati sempre di utilizzare il doppio segno di uguaglianza == quando testi una condizione.

Condizionali in loop

I condizionali possono essere utilizzati anche in un ciclo. Supponiamo ad esempio di avere un elenco di più pacchetti che devono essere installati su nodi remoti.

Nel playbook seguente abbiamo un array chiamato packages contenente un elenco di pacchetti che devono essere installati. Queste attività verranno eseguite una dopo l'altra se la clausola obbligatoria è impostata su Vero.

---
 - name: Install Software packages
    hosts: all
    vars:
	packages:
    • name: nginx
required: True
    • name: mysql
required: True
    • name: apache
required: False



   tasks:
    • name: Install “{{ item.name }}”on Debian
apt: 
 name: “{{ item.name }}”
 state: present 
When: item.required == True
loop: “{{ packages }}”  

Configurare la gestione degli errori

A volte, le attività falliscono durante l'esecuzione dei playbook. Supponiamo che tu stia eseguendo 5 attività su 3 server come mostrato nel playbook di seguito. Se si verifica un errore nell'attività 3 (Avvio di MySQL) sul server 2, Ansible interromperà l'esecuzione delle attività rimanenti sul server 2 e tenterà di completare le attività rimanenti sul resto dei server.

---
 - name: Install Software packages
   hosts: server1, server2, server3
   tasks:
- name: Install dependencies
<< some code >>

- name: Install MySQL database
<< some code >>

- name: Start MySQL
<< some code >>

- name: Install Nginx
<< some code >>

- name: Start Nginx
<< some code >>

Se desideri coerenza nell'esecuzione del playbook, ad esempio, interrompi l'esecuzione di un playbook, se uno dei server fallisce, aggiungi l'opzione.

---
 - name: Install Software packages
   hosts: server1, server2, server3
   any_errors_fatal:  true
   tasks:

In questo modo, se un'attività fallisce su un server, Ansible interromperà l'esecuzione dell'intero playbook su tutti i server e uscirà.

Se desideri che il playbook ignori gli errori e proceda con l'esecuzione della serie rimanente di attività, utilizza l'opzione ignore_errors: True.

---
 - name: Install Software packages
   hosts: server1, server2, server3
   tasks:
- name: Install dependencies
<< some code >>
     ignore_errors: True

Crea playbook per configurare i sistemi su uno stato specifico

In questa sezione esaminiamo alcune opzioni aggiuntive disponibili durante l'esecuzione di un playbook.

Iniziamo con la modalità Verifica o l'opzione Esecuzione di prova. L'opzione di prova o modalità di controllo viene utilizzata durante l'esecuzione di un playbook per verificare se verranno rilevati errori e se verranno apportate modifiche agli host gestiti. Tuttavia, non apporta alcuna modifica ai nodi remoti.

Ad esempio, per eseguire a secco un playbook chiamato httpd.yml che installa e avvia il server web Apache, esegui:

ansible-playbook httpd.yml --check

L'altra opzione che dobbiamo considerare è l'opzione --start-at-task. Viene utilizzato quando si specifica il nome dell'attività da cui deve iniziare il playbook.

Facciamo un esempio: il playbook seguente descrive 2 attività: la prima installa il server Web Apache e la seconda installa l'utilità htop.

---
 - name: Install httpd

   hosts: all
   tasks:
    yum:	 
name: httpd
     state: Installed

- name: Install htop

      yum:  
      name: htop
      state: started

Se vuoi saltare l'installazione del server web Apache e installare invece l'utilità htop, esegui:

ansible-playbook playbook.yml --start-at-task “Install htop”

Infine, puoi taggare le tue attività o riproduzioni aggiungendo l'opzione tag al tuo playbook come mostrato. Ciò è utile quando si dispone di un playbook piuttosto grande e si desidera eseguire attività specifiche dall'intero playbook.

---
 - name: Install httpd
   tags: Install and start
   hosts: all
   tasks:
    yum:	 
name: httpd
     state: Installed

   tags: Install

    • service: 
name: httpd
state: started
ansible-playbook playbook.yml -tags "Install"

Per omettere i tag utilizza le opzioni --skip-tags come mostrato.

ansible-playbook playbook.yml --skip-tags "Install"
Conclusione

In questo argomento, ti abbiamo illustrato i moduli comunemente utilizzati in Ansible, come recuperare stdout dall'esecuzione di un playbook per l'analisi, utilizzando i condizionali nel playbook e come gestire gli errori che potrebbero verificarsi durante l'esecuzione compiti. Infine, abbiamo ricapitolato la configurazione dei playbook e come utilizzare opzioni aggiuntive per decidere quali attività eseguire se non intendi eseguire l'intero playbook.