Condicionales y bucles de Ansible

Introducción

En este laboratorio, explorarás dos características poderosas de Ansible: las 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 repetir tareas para múltiples elementos. Al final de este laboratorio, entenderás cómo usar las 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 poderosos para administrar tu infraestructura.

Skills Graph

Configuración del entorno

Antes de sumergirnos en las condicionales y los bucles de Ansible, configuremos nuestro entorno de trabajo. Este paso es crucial ya que establece las bases para todas nuestras tareas posteriores.

Primero, naveguemos hasta el 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 en los que operan los comandos, módulos y tareas de un playbook. Para este laboratorio, usaremos un inventario simple que incluye solo el 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 simple y fácil de usar. El cursor se colocará en el archivo, listo para que escribas.

Ahora, agreguemos el siguiente contenido al archivo:

[local]
localhost ansible_connection=local

Desglosemos esto:

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

Para guardar el archivo y salir de nano:

1. Presiona Ctrl + X
2. Se te preguntará si deseas guardar el búfer modificado. Presiona Y para sí.
3. 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 movernos a este nuevo directorio.

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

Siguiendo estos pasos, ahora has configurado un entorno básico de Ansible. Tienes un archivo de inventario que le dice 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 complejas.

Introducción a las condicionales

Las condicionales en Ansible te permiten controlar la ejecución de tareas basadas en ciertas condiciones. Esto es increíblemente útil cuando necesitas realizar diferentes acciones dependiendo del estado de tu sistema o del valor de ciertas variables.

Creemos un playbook simple 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, agreguemos 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"

Desglosemos esto:

1. --- en la parte superior del archivo indica el inicio de un documento YAML.
2. name: Conditional Example le da un nombre a nuestro playbook.
3. hosts: localhost especifica que este playbook se ejecutará en la máquina local.
4. gather_facts: yes le dice a Ansible que recopile información sobre el sistema antes de ejecutar las tareas. Esto es importante porque usaremos estos datos en nuestras condiciones.
5. tasks: inicia la lista de tareas 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 es basado en Debian (ansible_os_family == "Debian").
• La segunda tarea solo se ejecutará si el sistema no es basado en Debian (ansible_os_family!= "Debian").

ansible_os_family es un dato recopilado por Ansible sobre el sistema objetivo. Se utiliza aquí para demostrar cómo funcionan las condicionales.

Guarda y sale del editor nano (Ctrl+X, luego Y, luego Enter).

Ahora, ejecutemos el playbook:

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

Este comando le dice 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 indique si tu sistema es basado en Debian o no. Solo se mostrará uno de los mensajes de depuración, dependiendo de la familia del sistema operativo de tu sistema.

Este ejemplo demuestra cómo se pueden usar las condicionales para hacer que tus playbooks sean adaptables a diferentes entornos. En escenarios del mundo real, podrías usar condicionales para instalar diferentes paquetes en diferentes tipos de sistemas operativos, o para omitir ciertas tareas si un archivo ya existe.

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

Trabajando con múltiples condiciones

En escenarios del mundo real, a menudo es necesario verificar múltiples condiciones antes de ejecutar una tarea. Ansible te permite combinar múltiples condiciones utilizando operadores lógicos. Creemos otro playbook para demostrar este uso más avanzado de las condicionales.

Crea un nuevo archivo llamado multiple_conditions.yml:

nano multiple_conditions.yml

Ahora, agreguemos 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

Desglosemos este playbook:

1. Definimos una variable check_memory a nivel de playbook. Esta variable se podría establecer de forma dinámica o pasar como una variable adicional al ejecutar el playbook.

2. La primera tarea utiliza múltiples condiciones:

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

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

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

4. Aquí estamos utilizando más datos (facts) de Ansible: ansible_distribution proporciona el nombre específico de la distribución, y ansible_memtotal_mb ofrece la memoria total del sistema en megabytes.

Guarda y sale del editor nano.

Ahora, ejecutemos 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 se pueden crear condiciones complejas para hacer que tus playbooks sean altamente adaptables a diferentes escenarios. Puedes combinar diversos datos del sistema, variables personalizadas y operadores lógicos para ajustar con precisión cuándo deben ejecutarse tus tareas.

Introducción a los bucles

Los bucles en Ansible te permiten repetir una tarea múltiples veces con diferentes valores. Esto es extremadamente útil cuando necesitas realizar la misma acción con múltiples 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, agrega 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

Desglosemos esto:

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

2. La primera tarea utiliza un bucle para iterar sobre la lista fruits. En cada iteración, el valor actual está disponible como {{ item }}.

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

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

Guarda y sale del editor nano.

Ahora, ejecutemos 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 poderosa en Ansible que puede reducir significativamente la cantidad de código repetitivo en tus playbooks. Son especialmente útiles cuando trabajas con listas de elementos como usuarios, paquetes o archivos.

Técnicas avanzadas de bucles

Ansible ofrece técnicas de bucles más avanzadas que te permiten trabajar con estructuras de datos complejas y tener más control sobre el proceso de bucle. Exploremos algunas de estas técnicas creando un nuevo playbook.

Crea un nuevo archivo llamado advanced_loops.yml:

nano advanced_loops.yml

Ahora, agrega 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 }}"

Desglosemos estas técnicas avanzadas:

1. Bucle sobre 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).

2. Uso de loop_control:
   La segunda tarea demuestra loop_control, que nos permite cambiar el nombre de la variable de bucle (por defecto es item) y acceder al índice actual del bucle. Aquí, usamos index_var: index para crear una variable index que lleva el seguimiento del número de iteración actual.

3. Bucle sobre 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 que se pueden recorrer. Luego, usamos item.key y item.value para acceder a las claves y valores del diccionario.

Guarda y sale del editor nano.

Ahora, ejecutemos este playbook:

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

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

• Mensajes de creación de usuarios con sus respectivos grupos
• Elementos que se están procesando con su índice
• Pares clave-valor del diccionario

Estas técnicas avanzadas te permiten trabajar con estructuras de datos más complejas y te dan un control más preciso sobre tus bucles. Son especialmente útiles cuando se trata de datos anidados, cuando necesitas llevar el seguimiento del índice del bucle o cuando trabajas con diccionarios.

Resumen

En este laboratorio, has aprendido sobre las condicionales y los bucles de Ansible, dos características poderosas que te permiten crear playbooks más dinámicos y eficientes. Estos son los puntos clave:

1. Las condicionales (cláusula when) te permiten controlar la ejecución de tareas basadas en condiciones específicas, como datos (facts) sobre el sistema objetivo o variables definidas por el usuario.
2. Puedes combinar múltiples condiciones utilizando operadores lógicos como and y or para crear declaraciones 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, incluyendo recorrer listas, diccionarios y estructuras de datos más complejas.
5. Las técnicas avanzadas de bucles, como loop_control y recorrer diccionarios, brindan aún más flexibilidad para manejar tareas repetitivas.

Estas características son esenciales para crear playbooks de Ansible flexibles y poderosos 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 siempre considerar la legibilidad y mantenibilidad de tus playbooks cuando uses estas características. Si bien pueden simplificar mucho tu código, el uso excesivo o condiciones y bucles demasiado complejos pueden hacer que los playbooks sean más difíciles de entender y mantener.