it-swarm.com.de

Sind Ansible-Handler in Rollen definiert, die nach dem gesamten Playbook oder der Rolle ausgeführt werden?

Ich verwende Ansible 2.0, und ich könnte dies einfach ausführen, aber ich könnte auch dazu verleitet werden, etwas zu glauben, das durch meine empirischen Tests nicht wahr ist, und ich kann keine Dokumentation finden, die mir sagt, wann Handler ausgeführt werden sollen.

Wenn Handler am Ende ihrer Aufgaben nicht ausgeführt werden, ist dies mein Rätsel. Ich habe ein Spielbuch mit 5 Rollen darin. Ich möchte am Ende eine 6-Rolle hinzufügen, bei der die Handler der 4. Rolle abgeschlossen sein müssen, bevor sie beginnen können.

Gibt es eine Möglichkeit, Ansible auszuführen, um sich darauf zu verlassen, dass ein Handler abgeschlossen ist (d. H. Eine Rolle vollständig abgeschlossen ist), bevor etwas anderes ausgeführt wird, oder verwende ich falsche Handler?

13
Peter Turner

Handler werden ausgeführt:

  • am Ende eines Stücks (kein Spielbuch)
  • beim Ausführen der Aufgabe meta: flush_handlers

Also ", um dem Ende eine 6-Rolle hinzuzufügen, für die die Handler der 4. Rolle benötigt werden", benötigen Sie:

  • entweder um die Rollenzuweisung in separate Spiele aufzuteilen;
  • oder fügen Sie eine Meta-Aufgabe hinzu und fügen Sie die 6. Rolle in das Modul include_role ein:

    roles:
      - role4
    tasks:
      - meta: flush_handlers
      - include_role:
          name: role6
    

Für Ihren Anwendungsfall würde ich die erste Methode vorschlagen, da das include_role - Modul noch sehr frisch ist und es Macken bei der Verwendung gibt (siehe diese Frage zu SO ).


Beachten Sie außerdem, dass die Namen und Abhöraufrufe der Handler global sind, sodass zwei Handler in getrennten Rollen in Konflikt geraten, wenn sie denselben Namen hatten und beide Rollen in einem einzigen Spiel zugewiesen wurden. (Ref. Handler: Ausführen von Operationen bei Änderung )

Handler [] werden mit einem global eindeutigen Namen referenziert und von Benachrichtigern benachrichtigt. [] Ein Handler wird nur einmal ausgeführt, nachdem alle Aufgaben in einem bestimmten Spiel abgeschlossen wurden.

Handlernamen und Abhörthemen werden in einem globalen Namespace gespeichert.


  • Empirischer Beweis (führen Sie dieses Shell-Skript aus, um zu bestätigen, dass die Handler am Ende des Spiels ausgeführt werden - hier gab es widersprüchliche Kommentare und Antworten):

    #!/bin/bash
    
    mkdir -p ./sf831880/roles/role1
    mkdir -p ./sf831880/roles/role1/handlers
    mkdir -p ./sf831880/roles/role1/tasks
    mkdir -p ./sf831880/roles/role2
    mkdir -p ./sf831880/roles/role2/handlers
    mkdir -p ./sf831880/roles/role2/tasks
    
    cat >./sf831880/roles/role1/tasks/main.yml <<TASKS1_END
    ---
    - name: Always true in role1
      command: echo role1
      notify: handler1
    TASKS1_END
    
    cat >./sf831880/roles/role2/tasks/main.yml <<TASKS2_END
    ---
    - name: Always true in role2
      command: echo role2
      notify: handler2
    TASKS2_END
    
    cat >./sf831880/roles/role1/handlers/main.yml <<HANDLERS1_END
    ---
    - name: handler1
      debug:
        msg: "This is a handler in role1"
    HANDLERS1_END
    
    cat >./sf831880/roles/role2/handlers/main.yml <<HANDLERS2_END
    ---
    - name: handler2
      debug:
        msg: "This is a handler in role2"
    HANDLERS2_END
    
    cat >./sf831880/playbook.yml <<PLAYBOOK_END
    ---
    - hosts: localhost
      gather_facts: no
      connection: local
      roles:
        - role1
        - role2
      tasks:
        - debug:
            msg: "This is a task in a play"
    PLAYBOOK_END
    
    ansible-playbook ./sf831880/playbook.yml
    

    Ergebnis:

    PLAY [localhost] ***************************************************************
    
    TASK [role1 : Always true in role1] ********************************************
    changed: [localhost]
    
    TASK [role2 : Always true in role2] ********************************************
    changed: [localhost]
    
    TASK [debug] *******************************************************************
    ok: [localhost] => {
        "msg": "This is a task in a play"
    }
    
    RUNNING HANDLER [role1 : handler1] *********************************************
    ok: [localhost] => {
        "msg": "This is a handler in role1"
    }
    
    RUNNING HANDLER [role2 : handler2] *********************************************
    ok: [localhost] => {
        "msg": "This is a handler in role2"
    
  • Spiel geändert, um meta: flush_handlers Zu enthalten:

    ---
    - hosts: localhost
      gather_facts: no
      connection: local
      roles:
        - role1
        - role2
      tasks:
        - meta: flush_handlers
        - debug:
            msg: "This is a task in a play"
    

    Das Ergebnis:

    PLAY [localhost] ***************************************************************
    
    TASK [role1 : Always true in role1] ********************************************
    changed: [localhost]
    
    TASK [role2 : Always true in role2] ********************************************
    changed: [localhost]
    
    RUNNING HANDLER [role1 : handler1] *********************************************
    ok: [localhost] => {
        "msg": "This is a handler in role1"
    }
    
    RUNNING HANDLER [role2 : handler2] *********************************************
    ok: [localhost] => {
        "msg": "This is a handler in role2"
    }
    
    TASK [debug] *******************************************************************
    ok: [localhost] => {
        "msg": "This is a task in a play"
    
17
techraf

Handler sind Listen von Aufgaben, die sich nicht wirklich von regulären Aufgaben unterscheiden, auf die durch einen global eindeutigen Namen verwiesen wird und die von Benachrichtigern benachrichtigt werden. Wenn ein Handler durch nichts benachrichtigt wird, wird er nicht ausgeführt. Unabhängig davon, wie viele Aufgaben einen Handler benachrichtigen, wird er nur einmal ausgeführt, nachdem alle Aufgaben in einem bestimmten Spiel abgeschlossen wurden. ansible doc

1) Handler, die dasselbe tun, sollten den gleichen Namen haben.
restart nginx Startet Nginx IMMER neu, nicht handler1 und handler2

2) Handler werden am Ende des gesamten "Spiels" ausgeführt, ein Spiel, das sich auf Ihre Abschnitte bezieht.

3) Ich würde die Funktionen register und when für Aufgaben verwenden, die neu gestartet werden sollen. Beachten Sie, dass diese var mit sich führen sollte.

Codequelle

PLAY [localhost] ***************************************************************

TASK [debug] *******************************************************************
ok: [localhost] => {
    "msg": "Play 1"
}

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role2 : Run if change in task c of role 1] *******************************
changed: [localhost]

TASK [role2 : Always true in role2] ********************************************
changed: [localhost]

TASK [debug] *******************************************************************
ok: [localhost] => {
    "msg": "This is a task in a play"
}

RUNNING HANDLER [role1 : handler] **********************************************
ok: [localhost] => {
    "msg": "This is a handler in role1"
}

PLAY [localhost] ***************************************************************

TASK [debug] *******************************************************************
ok: [localhost] => {
    "msg": "Play 2"
}

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role1 : Always true in role1] ********************************************
changed: [localhost]

TASK [role2 : Run if change in task c of role 1] *******************************
changed: [localhost]

TASK [role2 : Always true in role2] ********************************************
changed: [localhost]

TASK [debug] *******************************************************************
ok: [localhost] => {
    "msg": "This is a task in a play"
}

RUNNING HANDLER [role1 : handler] **********************************************
ok: [localhost] => {
    "msg": "This is a handler in role1"
}

PLAY RECAP *********************************************************************
localhost                  : ok=20   changed=14   unreachable=0    failed=0

Viele Möglichkeiten, die gleiche Aufgabe zu erledigen. Handler wurden entwickelt, um zu verhindern, dass derselbe Prozess mehrmals neu gestartet wird, z. B. mehrere Änderungen an einem Nginx-Server mit Websites, SSL-Zertifikaten und anderen Aufgaben, für die ein Neustart des Dienstes erforderlich ist.

2
Jacob Evans