Condicionales y bucles en Ansible

Introducción

En este laboratorio, explorarás dos características muy potentes de Ansible: los condicionales y los bucles. Estos conceptos te permiten crear playbooks más dinámicos y eficientes al controlar la ejecución de tareas basándote en condiciones específicas y al repetir tareas para múltiples elementos. Al finalizar este laboratorio, comprenderás cómo utilizar condicionales para tomar decisiones en tus playbooks y cómo implementar bucles para realizar tareas repetitivas de manera eficiente. Este conocimiento te ayudará a crear playbooks de Ansible más flexibles y potentes para gestionar tu infraestructura.

Configuración del entorno

En este paso, configurarás el entorno de trabajo para los ejercicios de condicionales y bucles en Ansible. Esta preparación proporciona los archivos y directorios utilizados en todas las tareas posteriores.

Primero, vamos a navegar al directorio del proyecto. En la terminal, escribe:

cd ~/project

Este comando cambia tu directorio actual a ~/project, que es nuestro espacio de trabajo designado para este laboratorio.

Ahora, crearemos un archivo de inventario. En Ansible, un archivo de inventario define los hosts y grupos de hosts sobre los cuales operan los comandos, módulos y tareas de un playbook. Para este laboratorio, utilizaremos un inventario simple que incluye únicamente a localhost.

Crea un nuevo archivo llamado inventory.ini:

nano inventory.ini

Este comando abre el editor de texto nano. Si no estás familiarizado con nano, no te preocupes; es un editor de texto sencillo y fácil de usar. El cursor se colocará en el archivo, listo para que escribas.

Ahora, añade el siguiente contenido al archivo:

[local]
localhost ansible_connection=local

Desglocemos esto:

• [local] define un grupo llamado "local".
• localhost es el nombre del host.
• ansible_connection=local le indica a Ansible que ejecute los comandos localmente en lugar de hacerlo a través de SSH.

Para guardar el archivo y salir de nano, presiona Ctrl+X, luego presiona Y para guardar el búfer modificado y, por último, presiona Enter para confirmar el nombre del archivo.

A continuación, creemos un directorio para nuestros playbooks:

mkdir playbooks
cd playbooks

El comando mkdir crea un nuevo directorio llamado "playbooks", y luego usamos cd para entrar en él.

¿Por qué hacemos esto? Organizar tus archivos de Ansible en directorios es una buena práctica. Mantiene tu proyecto ordenado, especialmente a medida que este crece y se vuelve más complejo.

Siguiendo estos pasos, habrás configurado un entorno básico de Ansible. Tienes un archivo de inventario que le indica a Ansible con qué hosts trabajar y un directorio dedicado para tus playbooks. Esta estructura facilitará la gestión de tus proyectos de Ansible a medida que aprendas y experimentes con características más avanzadas.

Introducción a los condicionales

En este paso, utilizarás los condicionales de Ansible para controlar la ejecución de tareas basándote en condiciones específicas. Esto resulta útil cuando necesitas realizar diferentes acciones dependiendo del estado de tu sistema o del valor de determinadas variables.

Creemos un playbook sencillo que demuestre el uso de condicionales:

nano conditional_example.yml

Este comando abre el editor de texto nano para crear un nuevo archivo llamado conditional_example.yml. Ahora, añade el siguiente contenido:

---
- name: Conditional Example
  hosts: localhost
  gather_facts: yes
  tasks:
    - name: Check OS family
      debug:
        msg: "This is a Debian-based system"
      when: ansible_os_family == "Debian"

    - name: Check OS family (alternative)
      debug:
        msg: "This is not a Debian-based system"
      when: ansible_os_family != "Debian"

Desglocemos esto:

• --- al principio del archivo indica el inicio de un documento YAML.
• name: Conditional Example le da un nombre a nuestro playbook.
• hosts: localhost especifica que este playbook se ejecutará en la máquina local.
• gather_facts: yes le indica a Ansible que recopile información sobre el sistema antes de ejecutar las tareas. Esto es importante porque utilizaremos estos hechos (facts) en nuestras condiciones.
• tasks: da inicio a la lista de tareas que se van a ejecutar.

Cada tarea utiliza el módulo debug para imprimir un mensaje, pero la ejecución está controlada por la cláusula when:

• La primera tarea solo se ejecutará si el sistema está basado en Debian (ansible_os_family == "Debian").
• La segunda tarea solo se ejecutará si el sistema no está basado en Debian (ansible_os_family != "Debian").

ansible_os_family es un hecho recopilado por Ansible sobre el sistema de destino. Se utiliza aquí para demostrar cómo funcionan los condicionales.

Guarda los cambios y sal del editor nano (Ctrl+X, luego Y, y después Enter).

Ahora, ejecuta el playbook:

ansible-playbook -i ../inventory.ini conditional_example.yml

Este comando le indica a Ansible que ejecute nuestro playbook. La opción -i ../inventory.ini especifica el archivo de inventario que creamos anteriormente.

Deberías ver una salida que indica si tu sistema está basado en Debian o no. Solo se mostrará uno de los mensajes de depuración, dependiendo de la familia del sistema operativo de tu equipo.

Este ejemplo demuestra cómo se pueden utilizar los condicionales para adaptar tus playbooks a diferentes entornos. En escenarios del mundo real, podrías usar condicionales para instalar paquetes diferentes según el tipo de sistema operativo, o para omitir ciertas tareas si un archivo ya existe.

Recuerda que el poder de los condicionales radica en su capacidad para hacer que tus playbooks sean flexibles y capaces de manejar varios escenarios sin necesidad de crear playbooks separados para cada caso.

Trabajo con múltiples condiciones

En este paso, combinarás múltiples condiciones utilizando operadores lógicos antes de ejecutar una tarea. Este patrón permite implementar comportamientos condicionales más avanzados en playbooks del mundo real.

Crea un nuevo archivo llamado multiple_conditions.yml:

nano multiple_conditions.yml

Ahora, añade el siguiente contenido al archivo:

---
- name: Multiple Conditions Example
  hosts: localhost
  gather_facts: yes
  vars:
    check_memory: true
  tasks:
    - name: Check OS and Memory
      debug:
        msg: "This is a Debian-based system with more than 1GB of memory"
      when:
        - ansible_os_family == "Debian"
        - ansible_memtotal_mb > 1024
        - check_memory | bool

    - name: Print System Information
      debug:
        msg: "OS: {{ ansible_distribution }}, Memory: {{ ansible_memtotal_mb }} MB"
      when: ansible_distribution == "Ubuntu" or ansible_memtotal_mb < 2048

Desglocemos este playbook:

• Definimos una variable check_memory a nivel de playbook. Esta podría establecerse de forma dinámica o pasarse como una variable adicional al ejecutar el playbook.

• La primera tarea utiliza múltiples condiciones:

  • Comprueba si la familia del sistema operativo es Debian.
  • Comprueba si la memoria total es superior a 1024 MB (1 GB).
  • Comprueba si la variable check_memory es verdadera.

  Todas estas condiciones deben cumplirse para que la tarea se ejecute. El símbolo | en check_memory | bool es un filtro que convierte el valor a un booleano.

• La segunda tarea demuestra el uso del operador or. Se ejecutará si la distribución es Ubuntu O la memoria total es inferior a 2048 MB (2 GB).

• Estamos utilizando más hechos de Ansible aquí: ansible_distribution proporciona el nombre específico de la distribución y ansible_memtotal_mb proporciona la memoria total del sistema en megabytes.

Guarda los cambios y sal del editor nano.

Ahora, ejecuta este playbook:

ansible-playbook -i ../inventory.ini multiple_conditions.yml

Observa la salida. Dependiendo de las características de tu sistema, es posible que veas uno o ambos mensajes de depuración.

Este ejemplo muestra cómo puedes crear condiciones complejas para que tus playbooks sean altamente adaptables a diferentes escenarios. Puedes combinar varios hechos del sistema, variables personalizadas y operadores lógicos para afinar el momento en que deben ejecutarse tus tareas.

Introducción a los bucles

En este paso, utilizarás los bucles de Ansible para repetir una tarea con diferentes valores. Esto resulta útil cuando necesitas realizar la misma acción con varios elementos, como crear varios usuarios, instalar múltiples paquetes o crear varios directorios.

Creemos un playbook para demostrar el uso de bucles. Crea un nuevo archivo llamado loop_example.yml:

nano loop_example.yml

Ahora, añade el siguiente contenido:

---
- name: Loop Example
  hosts: localhost
  vars:
    fruits:
      - apple
      - banana
      - cherry
  tasks:
    - name: Print fruit names
      debug:
        msg: "Current fruit: {{ item }}"
      loop: "{{ fruits }}"

    - name: Create directories
      file:
        path: "/tmp/{{ item }}"
        state: directory
      loop:
        - dir1
        - dir2
        - dir3

Desglocemos esto:

• Definimos una variable fruits como una lista de nombres de frutas.

• La primera tarea utiliza un bucle para recorrer la lista fruits. En cada iteración, el valor actual está disponible mediante la variable {{ item }}.

• La segunda tarea demuestra cómo utilizar un bucle con el módulo file para crear múltiples directorios. Estamos creando tres directorios en la carpeta /tmp.

• Observa que podemos utilizar el bucle directamente en la tarea (como en la segunda tarea) o hacer referencia a una variable (como en la primera).

Guarda los cambios y sal del editor nano.

Ahora, ejecuta este playbook:

ansible-playbook -i ../inventory.ini loop_example.yml

Cuando ejecutes este playbook, verás que la primera tarea imprime el nombre de cada fruta y la segunda tarea crea tres directorios en /tmp.

Los bucles son una característica muy potente en Ansible que puede reducir significativamente la cantidad de código repetitivo en tus playbooks. Son especialmente útiles cuando se trabaja con listas de elementos como usuarios, paquetes o archivos.

Técnicas avanzadas de bucles

En este paso, utilizarás técnicas avanzadas de bucles en Ansible para trabajar con estructuras de datos complejas y controlar el proceso del bucle.

Crea un nuevo archivo llamado advanced_loops.yml:

nano advanced_loops.yml

Ahora, añade el siguiente contenido:

---
- name: Advanced Loop Techniques
  hosts: localhost
  vars:
    users:
      - name: alice
        groups: ["developers", "testers"]
      - name: bob
        groups: ["managers", "developers"]
  tasks:
    - name: Create users with groups
      debug:
        msg: "Creating user {{ item.name }} with groups: {{ item.groups | join(', ') }}"
      loop: "{{ users }}"

    - name: Demonstrate loop_control
      debug:
        msg: "Processing item {{ index }} - {{ item }}"
      loop: ["a", "b", "c", "d"]
      loop_control:
        index_var: index

    - name: Loop over dictionary
      debug:
        msg: "{{ key }}: {{ value }}"
      loop: "{{ {'x': 1, 'y': 2, 'z': 3} | dict2items }}"
      vars:
        key: "{{ item.key }}"
        value: "{{ item.value }}"

Desglocemos estas técnicas avanzadas:

• Recorrer una lista de diccionarios: La primera tarea recorre la lista users, donde cada elemento es un diccionario que contiene un nombre y una lista de grupos. Podemos acceder a estos elementos anidados utilizando la notación de puntos (item.name, item.groups).

• Uso de loop_control: La segunda tarea demuestra loop_control, lo cual nos permite cambiar el nombre de la variable del bucle (cuyo valor por defecto es item) y acceder al índice actual del bucle. Aquí utilizamos index_var: index para crear una variable llamada index que realiza un seguimiento del número de iteración actual.

• Recorrer un diccionario: La última tarea muestra cómo recorrer un diccionario. Usamos el filtro dict2items para convertir el diccionario en una lista de pares clave-valor sobre la cual se puede iterar. A continuación, utilizamos item.key y item.value para acceder a las claves y valores del diccionario.

Guarda los cambios y sal del editor nano.

Ahora, ejecuta este playbook:

ansible-playbook -i ../inventory.ini advanced_loops.yml

Cuando ejecutes este playbook, verás cómo funcionan estas técnicas avanzadas de bucle. La salida mostrará:

• Mensajes de creación de usuarios con sus respectivos grupos.
• Elementos procesados indicando su índice.
• Pares clave-valor provenientes del diccionario.

Estas técnicas avanzadas te permiten trabajar con estructuras de datos más complejas y te otorgan un control más preciso sobre tus bucles. Son particularmente útiles al tratar con datos anidados, cuando necesitas realizar un seguimiento del índice del bucle o al trabajar con diccionarios.

Resumen

En este laboratorio, has aprendido sobre los condicionales y los bucles en Ansible, dos características potentes que te permiten crear playbooks más dinámicos y eficientes. Aquí tienes los puntos clave:

1. Los condicionales (cláusula when) te permiten controlar la ejecución de tareas basándote en condiciones específicas, como hechos sobre el sistema de destino o variables definidas por el usuario.
2. Puedes combinar múltiples condiciones utilizando operadores lógicos como and y or para crear sentencias condicionales más complejas.
3. Los bucles (palabra clave loop) te permiten repetir tareas con diferentes valores, aumentando la eficiencia y reduciendo la complejidad del playbook.
4. Ansible admite varios tipos de bucles, incluidos los recorridos sobre listas, diccionarios y estructuras de datos más complejas.
5. Las técnicas avanzadas de bucles, como loop_control y el recorrido de diccionarios, proporcionan aún más flexibilidad al manejar tareas repetitivas.

Estas características son esenciales para crear playbooks de Ansible flexibles y potentes que puedan adaptarse a diferentes escenarios y gestionar eficientemente múltiples elementos. A medida que sigas trabajando con Ansible, practica la incorporación de condicionales y bucles en tus playbooks para hacerlos más dinámicos y eficientes.

Recuerda tener siempre en cuenta la legibilidad y la facilidad de mantenimiento de tus playbooks al utilizar estas características. Si bien pueden simplificar enormemente tu código, un uso excesivo o unas condiciones y bucles demasiado complejos pueden hacer que los playbooks sean difíciles de entender y mantener.