Demistificare gli Handler di Ansible: Riavvii di Servizi Idempotenti Garantiti

Gli handler di Ansible risolvono un problema comune di distribuzione: il tuo file di configurazione può essere controllato a ogni esecuzione, ma il servizio dovrebbe riavviarsi solo quando quel file cambia effettivamente. Senza handler, il tuo playbook può riavviare servizi sani senza motivo.

Questa guida spiega come funzionano gli handler, dove definirli e quando eseguirli anticipatamente. Gli esempi utilizzano servizi web, ma lo stesso schema funziona per worker di applicazioni, scheduler e demone di sistema.

Cosa Sono gli Handler di Ansible?

In Ansible, un handler è un'attività che viene eseguita solo dopo che un'altra attività lo notifica. Quando un'attività cambia qualcosa e include notify, Ansible mette in coda l'handler corrispondente.

Caratteristiche principali degli handler:

• Attivati da notifica: Un handler viene eseguito quando un'attività modificata usa notify.
• Eseguiti una volta per play: Se cinque attività notificano lo stesso handler, Ansible lo esegue comunque una volta alla fine del play.
• Ideali per riavvii e ricariche: Gli handler sono perfetti per azioni sui servizi che dovrebbero avvenire solo dopo modifiche alla configurazione.

Perché Usare gli Handler per i Riavvii dei Servizi?

Il caso d'uso principale degli handler di Ansible è la gestione dei servizi. Quando aggiorni un file di configurazione di Apache, Nginx o di un'applicazione, il servizio spesso necessita di un riavvio o di una ricarica. Vuoi quell'azione solo quando il file distribuito differisce dal file corrente.

Considera l'alternativa:

• Senza handler: Un'attività di riavvio diretta viene eseguita ogni volta che il playbook la raggiunge, a meno che non aggiunga condizioni extra.
• Con gli handler: L'attività template o copy notifica un riavvio solo quando riporta changed.

Ad esempio, un playbook di produzione per Nginx potrebbe essere eseguito ogni ora per correggere la deriva della configurazione. Con gli handler, i file di configurazione invariati non causano ricariche orarie.

Come Implementare gli Handler di Ansible

Gli handler risiedono in una sezione handlers in un playbook o in handlers/main.yml all'interno di un ruolo. Il nome dell'handler deve corrispondere al nome usato da notify.

Sintassi Base dell'Handler

Gli handler vengono dichiarati in un blocco handlers a livello di playbook o all'interno di un ruolo.

---
- name: Configura e riavvia il server web
  hosts: webservers
  become: yes
  tasks:
    - name: Assicura che la configurazione di Apache sia presente
      template:
        src: templates/httpd.conf.j2
        dest: /etc/httpd/conf/httpd.conf
      notify:
        - Riavvia Apache

  handlers:
    - name: Riavvia Apache
      service:
        name: httpd
        state: restarted

In questo esempio:

1. Viene utilizzata un'attività template per distribuire un nuovo file di configurazione di Apache (httpd.conf).
2. La parola chiave notify è impostata su Riavvia Apache. Ciò significa che se l'attività template modifica con successo il file httpd.conf, Ansible segnalerà l'handler denominato Riavvia Apache.
3. La sezione handlers definisce l'handler Riavvia Apache, che utilizza il modulo service per riavviare il servizio httpd.

Notifica di Più Handler

Una singola attività può notificare più handler. Questo è utile se la modifica di una configurazione richiede il riavvio di più servizi o l'esecuzione di diverse azioni di pulizia.

---
- name: Distribuisci applicazione con aggiornamenti di database e server web
  hosts: app_servers
  become: yes
  tasks:
    - name: Aggiorna configurazione applicazione
      copy:
        src: files/app.conf
        dest: /etc/app/app.conf
      notify:
        - Riavvia servizio applicazione
        - Ricarica Nginx

  handlers:
    - name: Riavvia servizio applicazione
      service:
        name: myapp
        state: restarted

    - name: Ricarica Nginx
      service:
        name: nginx
        state: reloaded

In questo scenario, se app.conf viene aggiornato, verranno attivati sia l'handler Riavvia servizio applicazione che Ricarica Nginx.

Utilizzo degli Handler nei Ruoli

Gli handler sono comunemente usati all'interno dei ruoli di Ansible. Sono definiti nel file handlers/main.yml di un ruolo. Quando un'attività all'interno del ruolo (o da un playbook che include il ruolo) notifica un handler definito nel ruolo, Ansible lo eseguirà.

Supponiamo che tu abbia un ruolo chiamato apache con la seguente struttura:

apache/
├── handlers/
│   └── main.yml
└── tasks/
    └── main.yml

apache/tasks/main.yml:

---
- name: Distribuisci configurazione Apache
  template:
    src: httpd.conf.j2
    dest: /etc/httpd/conf/httpd.conf
  notify:
    - Riavvia Apache

apache/handlers/main.yml:

---
- name: Riavvia Apache
  service:
    name: httpd
    state: restarted

Quindi, nel tuo playbook, includeresti il ruolo:

---
- name: Configura server web usando il ruolo Apache
  hosts: webservers
  become: yes
  roles:
    - apache

Quando l'attività Distribuisci configurazione Apache nel ruolo apache viene eseguita e modifica la configurazione, l'handler Riavvia Apache definito in apache/handlers/main.yml verrà attivato.

Migliori Pratiche per l'Uso degli Handler

• Mantieni ogni handler concentrato su una singola azione.
• Usa nomi che corrispondono all'azione, come Ricarica Nginx.
• Preferisci state: reloaded quando il servizio supporta le ricariche e non è necessario un riavvio completo.
• Evita attività di riavvio diretto dopo le attività di configurazione.
• Ricorda che gli handler notificati vengono eseguiti alla fine del play a meno che non li esegui anticipatamente.

Concetti Avanzati: Esecuzione Anticipata degli Handler (Flush)

Per impostazione predefinita, gli handler vengono eseguiti una volta alla fine di un play. A volte è necessario un riavvio prima che le attività successive continuino. Ad esempio, potresti dover riavviare un'app dopo aver scritto la sua configurazione principale prima di eseguire un controllo di integrità o una migrazione.

---
- name: Esegui aggiornamenti di configurazione sequenziali che richiedono riavvii immediati del servizio
  hosts: servers
  become: yes
  tasks:
    - name: Aggiorna file di configurazione principale
      copy:
        src: files/primary.conf
        dest: /etc/myapp/primary.conf
      notify:
        - Riavvia Myapp

    - name: Esegui anticipatamente gli handler per applicare il riavvio immediato
      meta: flush_handlers

    - name: Aggiorna file di configurazione secondario
      copy:
        src: files/secondary.conf
        dest: /etc/myapp/secondary.conf
      notify:
        - Riavvia Myapp

  handlers:
    - name: Riavvia Myapp
      service:
        name: myapp
        state: restarted

Qui, la prima modifica alla configurazione attiva Riavvia Myapp, e meta: flush_handlers lo esegue immediatamente. Un'attività successiva può notificare nuovamente lo stesso handler se modifica un altro file.

Quando Consultare un Professionista

Richiedi una revisione quando un handler riavvia database di produzione, bilanciatori di carico o servizi in cluster. Alcuni sistemi necessitano di riavvii progressivi, controlli di quorum o fasi di drenaggio che non dovrebbero essere nascoste dietro un semplice handler.

Conclusione

Usa gli handler di Ansible ogni volta che un'attività modificata dovrebbe attivare un riavvio del servizio, una ricarica o una ricarica del demone. Mantengono i tuoi playbook idempotenti, riducono i riavvii non necessari e rendono più facile ragionare sulle modifiche ai servizi.