Tutoriales

Uso de instrucciones condicionales When en Ansible Playbooks

Si tiene experiencia en programación o secuencias de comandos, entonces debe estar familiarizado con el concepto llamado «declaraciones condicionales». Las declaraciones condicionales le permiten ejecutar el código en función del resultado de la condición. Del mismo modo en ansiblepuedes usar el cuando declaraciones condicionales para ejecutar tareas. Si la condición se evalúa como verdadera, la tarea se ejecutará; de lo contrario, se omitirá.

La sintaxis para el when enunciado condicional es el siguiente. Aprenderá cómo aplicar la declaración condicional con tareas en las secciones siguientes.

Play definition

tasks:

    Task 1
    when: condition 

    Task 2
    when: condition 

Cuando declaraciones condicionales con hechos Ansible

Hechos son información relacionada con el sistema recopilada por ansible mediante el módulo de configuración en los nodos administrados. Puede haber casos en los que tenga que tomar decisiones basadas en los hechos recopilados.

Si no tiene idea sobre los hechos, tenemos un breve artículo sobre los hechos y puede acceder a él mediante el siguiente enlace.

En el siguiente libro de jugadas, he escrito una tarea para instalar el epel-liberación repositorio usando el dnf módulo. Usando el hecho (distribución_ansible), he escrito la declaración condicional para instalar el paquete solo en Linux «rocoso». he usado el jinga2 filtro de conversión de mayúsculas y minúsculas para convertir la salida de ansible_distribution a minúsculas.

---
- name: Installing packages
  hosts: all
  become: true
  gather_facts: true    # By default it is set to true

  tasks:

   - name: Install epel-release
     dnf:
       pkg: epel-release
       state: present
     when: ansible_distribution | lower == "rocky"

Cuando ejecuto el libro de jugadas, el cuando la condición evaluará y ejecutará la tarea solo en Rocky Linux. La tarea se omitirá para todas las demás distribuciones.

$ ansible-playbook when_condition_test.yml 

PLAY [Installing packages] ********************************************************

TASK [Gathering Facts] ************************************************************
ok: [rocky.anslab.com]
ok: [ubuntu.anslab.com]

TASK [Install epel-release] ***********************************************************************************
skipping: [ubuntu.anslab.com]
ok: [rocky.anslab.com]

PLAY RECAP ***********************************************************************************
rocky.anslab.com           : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
ubuntu.anslab.com          : ok=1    changed=0    unreachable=0    failed=0    skipped=1    rescued=0    ignored=0   

Declaraciones condicionales When de Ansible con operadores lógicos AND/OR

Puede utilizar el operador lógico AND/OR para evaluar varias condiciones. Estoy usando el mismo libro de jugadas pero agregué una condición más basada en hechos. Esta reproducción se omitirá ya que la versión de distribución con la que estoy corriendo es 8 y estoy verificando la condición contra la versión 9.

   - name: Logical AND Testing
     dnf:
       pkg: htop
       state: present
     when: ansible_distribution | lower == "rocky" and ansible_distribution_major_version == "9"

Salida de muestra:

TASK [Gathering Facts] *********************************************************************************************************************
ok: [rocky.anslab.com]
ok: [ubuntu.anslab.com]

TASK [Logical AND Testing] *****************************************************************************************************************
skipping: [ubuntu.anslab.com]
skipping: [rocky.anslab.com]

También puede escribir AND lógico usando YAML formato de lista.

   - name: Logical AND using List syntax
     dnf:
       pkg: htop
       state: present
     when:
       - ansible_distribution | lower == "rocky"
       - ansible_distribution_major_version == "9"

Cuando ejecuto el mismo libro de jugadas contra el operador lógico OR, la tarea funcionará bien.

TASK [Gathering Facts] *********************************************************************************************************************
ok: [ubuntu.anslab.com]
ok: [rocky.anslab.com]

TASK [Logical OR Testing] ******************************************************************************************************************
skipping: [ubuntu.anslab.com]
ok: [rocky.anslab.com]

Cuando tenga varias expresiones para evaluar, puede ponerlas entre paréntesis. Aquí estoy usando la sintaxis JINJA2 (int >= 8) para evaluar si la versión de distribución es mayor o igual a 8.

   - name: Multiple conditions
     dnf:
       pkg: epel-release
       state: present
     when: (ansible_distribution | lower == "centos" or ansible_distribution | lower == "rocky") and ansible_distribution_major_version | int >= 8

Trabajar con Ansible cuando la declaración condicional con el operador de membresía

Puedes usar el EN operador para evaluar la expresión contra una lista de valores. En el siguiente libro de jugadas, creé una tarea para ejecutar en distribuciones basadas en RHEL.

   - name: Membership Operator
     dnf:
       pkg: epel-release
       state: present
     when: ansible_distribution | lower in ["centos","rocky"]

Salida de muestra:

TASK [Gathering Facts] **********************************************************************************
ok: [ubuntu.anslab.com]
ok: [rocky.anslab.com]

TASK [Membership Operator] ***********************************************************************************
skipping: [ubuntu.anslab.com]
ok: [rocky.anslab.com]

Trabajar con declaraciones condicionales when con variables de Ansible

Puede evaluar las condiciones contra las variables mágicas, host vars, group vars.

Si no tiene idea acerca de las variables ansibles, puede consultar nuestro artículo usando el enlace a continuación.

En el libro de jugadas a continuación, he creado una variable llamada trigger_pipeline y ponerlo en no. La condición se establece de manera que la tarea solo se ejecutará cuando trigger_pipeline se establece en ejecutar.

---
- name: Pipeline call
 hosts: all
 gather_facts: false

 vars:
   trigger_pipeline: no

 tasks:

   - name: Trigger Pipeline
     debug:
       msg: Running pipeline
     when: trigger_pipeline == "execute"

Cuando ejecute el libro de jugadas, esta tarea se omitirá.

TASK [Trigger Pipeline] *********************************************************
skipping: [rocky.anslab.com]

Puedo anular la variable trigger_pipeline desde la línea de comando ejecutando el siguiente comando.

$ ansible-playbook when_condition_test.yml -e trigger_pipeline=execute

TASK [Trigger Pipeline] **********************************************************************************
ok: [rocky.anslab.com] => {
    "msg": "Running pipeline"
}

Utilizando el operador ISpuede verificar si una variable está declarada en not en las declaraciones condicionales.

when: trigger_pipeline is defined          # TRUE only when var is defined
when: trigger_pipeline is undefined        # TRUE only when var is not defined

Cuando declaraciones condicionales con Ansible Register

Registro La directiva se utiliza para almacenar la salida de una tarea. Es similar a almacenar el resultado en una variable y luego usarlo para su posterior procesamiento. Según los datos almacenados en la variable de registro, puede escribir declaraciones condicionales.

En las tareas a continuación, he creado dos tareas donde la primera tarea usará el caparazón módulo y ejecutar /bin/true. La salida se almacenará en el registro variable que se utiliza en la segunda tarea para imprimir.

 tasks:

   - name: set to true
     shell: /bin/true
     register: result

   - name: print result
     debug:
       var: result

Salida de muestra:

ok: [rocky.anslab.com] => {
    "result": {
        "ansible_facts": {
            "discovered_interpreter_python": "/usr/libexec/platform-python"
        },
        "changed": true,
        "cmd": "/bin/true",
        "delta": "0:00:00.003477",
        "end": "2022-05-23 17:13:15.056197",
        "failed": false,
        "msg": "",
        "rc": 0,
        "start": "2022-05-23 17:13:15.052720",
        "stderr": "",
        "stderr_lines": [],
        "stdout": "",
        "stdout_lines": []
    }
}

Puede utilizar cualquiera de estos valores para crear condiciones. Supongamos que desea ejecutar la tarea solo cuando el rc se establece en ceroentonces puede escribir la condición como se muestra a continuación.

when: result.rc == 0

Del mismo modo, en función de los valores disponibles, puede escribir tantas condiciones de acuerdo con el caso de uso. A continuación se muestran algunas de las condiciones basadas en la salida de la variable de resultado.

when: result.stdout != ""             # Checking if stdout is not empty
when: result.failed == "false"        # checking if failed is set to false
when: changed == "true"               # Checking if the status of changed is true

Cuando declaraciones condicionales con bucles

Puede combinar la declaración condicional con bucles. En este caso, para cada elemento en el bucle, la declaración condicional se evaluará con respecto a la expresión dada.

Echa un vistazo a la obra de teatro a continuación. Estoy creando dos usuarios llamados ubuntu y rocoso utilizando el módulo de usuario. La directiva de bucle se repetirá contra la variable de nombre de usuario. Aquí, la condición está escrita de manera que el usuario de ubuntu debe crearse solo en el host de Linux de ubuntu y el usuario de Rocky debe crearse en el host de Linux de Rocky.

- name: Create Users
  hosts: all
  gather_facts: true
  become: true

 vars:
   username:
     - ubuntu
     - rocky

 tasks:

   - name: Create the user
     user:
       name: "{{ item }}"
       state: present
       password: "{{  item | password_hash('sha512') }}"
     loop: "{{ username }}"
     when: (item == "ubuntu" and ansible_distribution | lower == "ubuntu") or (item == "rocky" and ansible_distribution | lower == "rocky")

Como puede ver en el siguiente resultado, los usuarios se crean en las respectivas distribuciones de acuerdo con la condición.

TASK [Create the user] ********************************************************************************
skipping: [rocky.anslab.com] => (item=ubuntu) 
changed: [ubuntu.anslab.com] => (item=ubuntu)
skipping: [ubuntu.anslab.com] => (item=rocky) 
changed: [rocky.anslab.com] => (item=rocky)

Conclusión

En este artículo, hemos visto qué es una declaración condicional y cómo usar las declaraciones condicionales when en Ansible para evaluar condiciones y ejecutar tareas en función del resultado.

Cuando aprenda conceptos avanzados como roles, importaciones, incluye, llegará a saber más sobre las declaraciones condicionales y cómo usarlas de manera más eficiente.

Recurso:

LEER  ThisIsNotRat: Toma el control de tu sistema con Telegram

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba