Gestionar Múltiples Inventarios de Ansible

Introducción

En este laboratorio, aprenderás cómo trabajar con múltiples inventarios en Ansible. Administrar múltiples inventarios es un escenario común en entornos complejos con diferentes grupos de hosts o entornos separados. Aprenderás cómo definir y organizar múltiples inventarios, acceder a hosts de diferentes inventarios y realizar operaciones en múltiples inventarios.

Skills Graph

Crear Directorio y Archivos de Inventario

Comencemos creando un directorio para almacenar nuestros archivos de inventario y luego creemos dos archivos de inventario separados para los entornos de desarrollo y producción.

Primero, crea un nuevo directorio llamado inventory en la ruta /home/labex/project:

mkdir -p /home/labex/project/inventory

Este comando crea un nuevo directorio llamado inventory. La opción -p asegura que se creen los directorios padre si no existen.

Ahora, crea dos archivos de inventario: dev_inventory.ini y prod_inventory.ini dentro del directorio inventory:

touch /home/labex/project/inventory/dev_inventory.ini
touch /home/labex/project/inventory/prod_inventory.ini

El comando touch crea archivos vacíos si no existen, o actualiza la hora de modificación si ya existen.

A continuación, agregaremos contenido a estos archivos de inventario. Abre dev_inventory.ini en un editor de texto (puedes usar nano o cualquier otro editor de texto con el que te sientas cómodo):

nano /home/labex/project/inventory/dev_inventory.ini

Agrega el siguiente contenido:

[dev]
localhost ansible_connection=local

Guarda el archivo y sale del editor (en nano, puedes hacer esto presionando Ctrl+X, luego Y, luego Enter).

Ahora, abre prod_inventory.ini:

nano /home/labex/project/inventory/prod_inventory.ini

Agrega el siguiente contenido:

[prod]
localhost ansible_connection=local

Guarda y sale del editor.

En estos archivos de inventario:

• [dev] y [prod] son nombres de grupos. Ayudan a organizar los hosts en grupos lógicos.
• localhost es el nombre de host. Estamos usando localhost para simular diferentes entornos en la misma máquina.
• ansible_connection=local le dice a Ansible que ejecute comandos localmente en lugar de intentar conectarse por SSH a la máquina. Esto es útil para ejecutar Ansible en la misma máquina en la que está instalado.

En un escenario del mundo real, normalmente tendrías diferentes direcciones IP o nombres de host para tus servidores de desarrollo y producción en lugar de usar localhost para ambos.

Crear un Playbook para Múltiples Inventarios

En este paso, crearemos un playbook que pueda trabajar con nuestros inventarios de desarrollo y producción. En Ansible, un playbook es un archivo YAML que define un conjunto de tareas a ejecutar en los hosts.

Primero, creemos un nuevo archivo llamado multi_env_playbook.yaml en el directorio /home/labex/project:

touch /home/labex/project/multi_env_playbook.yaml

Ahora, abramos el archivo multi_env_playbook.yaml en un editor de texto. Usaremos nano, que es un editor de texto de línea de comandos sencillo:

nano /home/labex/project/multi_env_playbook.yaml

Copiemos y pegemos el siguiente contenido en el archivo:

---
- name: Demonstrate multi-environment playbook
  hosts: all
  gather_facts: no
  tasks:
    - name: Print environment type
      debug:
        msg: "This host belongs to the {{ 'production' if 'prod' in group_names else 'development' }} environment"

    - name: Show hostname
      command: hostname
      register: hostname_output

    - name: Display hostname
      debug:
        msg: "The hostname is: {{ hostname_output.stdout }}"

Después de pegar, presiona Ctrl + X, luego Y y, finalmente, Enter para guardar y salir de nano.

Desglosemos este playbook para entender cada parte:

1. --- en la parte superior del archivo indica el inicio de un documento YAML.
2. name: Demonstrate multi-environment playbook es un nombre descriptivo para esta ejecución (play).
3. hosts: all significa que este playbook se ejecutará en todos los hosts del inventario.
4. gather_facts: no omite la fase de recopilación de datos (fact gathering) para acelerar la ejecución. La recopilación de datos es cuando Ansible recopila información sobre los hosts de destino.
5. tasks: inicia la lista de tareas a ejecutar.
6. La primera tarea utiliza el módulo debug para imprimir un mensaje. Utiliza una declaración condicional para determinar si el host está en el entorno de producción o desarrollo:
   • group_names es una variable especial que contiene una lista de todos los grupos a los que pertenece el host actual.
   • Si 'prod' está en la lista group_names, imprime "production", de lo contrario, "development".
7. La segunda tarea ejecuta el comando hostname y almacena su salida en una variable llamada hostname_output.
8. La tercera tarea muestra el nombre de host utilizando el módulo debug. Accede a la salida almacenada utilizando hostname_output.stdout.

Ejecutar el Playbook con el Inventario de Desarrollo

Ahora que tenemos nuestro playbook y nuestros inventarios configurados, ejecutemos el playbook utilizando el inventario de desarrollo.

Ejecuta el siguiente comando en tu terminal:

ansible-playbook -i /home/labex/project/inventory/dev_inventory.ini /home/labex/project/multi_env_playbook.yaml

Desglosemos este comando:

• ansible-playbook es el comando para ejecutar un playbook de Ansible.
• -i /home/labex/project/inventory/dev_inventory.ini especifica el archivo de inventario a utilizar. La opción -i significa "inventory" (inventario).
• /home/labex/project/multi_env_playbook.yaml es la ruta a nuestro archivo de playbook.

Este comando le dice a Ansible que utilice el archivo dev_inventory.ini y ejecute el playbook multi_env_playbook.yaml.

Deberías ver una salida similar a la siguiente:

PLAY [Demonstrate multi-environment playbook] *******************************************

TASK [Print environment type] *********************************************************
ok: [localhost] => {
    "msg": "This host belongs to the development environment"
}

TASK [Show hostname] ******************************************************************
changed: [localhost]

TASK [Display hostname] ***************************************************************
ok: [localhost] => {
    "msg": "The hostname is: 66d80191e483433f91fbdca9"
}

PLAY RECAP ****************************************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Esta salida muestra que:

1. El playbook se ejecutó correctamente en el entorno de desarrollo.
2. Identificó correctamente que el host pertenece al entorno de desarrollo.
3. Obtuvo y mostró correctamente el nombre de host.
4. El "PLAY RECAP" muestra un resumen de la ejecución del playbook. Aquí, "ok=3" significa que tres tareas se ejecutaron correctamente, y "changed=1" significa que una tarea hizo un cambio en el sistema (ejecutando el comando hostname).

Ejecutar el Playbook con el Inventario de Producción

Ahora, ejecutemos el mismo playbook utilizando el inventario de producción para ver cómo se comporta de manera diferente.

Ejecuta el siguiente comando en tu terminal:

ansible-playbook -i /home/labex/project/inventory/prod_inventory.ini /home/labex/project/multi_env_playbook.yaml

Este comando es similar al anterior, pero utiliza el archivo prod_inventory.ini en lugar de dev_inventory.ini.

Deberías ver una salida similar a la siguiente:

PLAY [Demonstrate multi-environment playbook] *********************************

TASK [Print environment type] *************************************************
ok: [localhost] => {
    "msg": "This host belongs to the production environment"
}

TASK [Show hostname] **********************************************************
changed: [localhost]

TASK [Display hostname] *******************************************************
ok: [localhost] => {
    "msg": "The hostname is: labex-instance"
}

PLAY RECAP ********************************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Observa que esta vez, el playbook identifica correctamente que se está ejecutando en el entorno de producción. Esto se debe a que estamos utilizando el archivo de inventario de producción, que define el host bajo el grupo [prod].

El resto de la salida es similar a lo que vimos con el inventario de desarrollo, lo cual es esperado ya que todavía estamos ejecutando en la misma máquina local.

Ejecutar el Playbook con Ambos Inventarios

Finalmente, ejecutemos el playbook utilizando ambos inventarios a la vez. Esto demuestra cómo Ansible puede trabajar con múltiples inventarios simultáneamente.

Ejecuta el siguiente comando en tu terminal:

ansible-playbook -i /home/labex/project/inventory/dev_inventory.ini -i /home/labex/project/inventory/prod_inventory.ini /home/labex/project/multi_env_playbook.yaml

Este comando incluye ambos archivos de inventario utilizando múltiples opciones -i. Ansible combinará estos inventarios al ejecutar el playbook.

Deberías ver una salida similar a la siguiente:

PLAY [Demonstrate multi-environment playbook] *******************************************************************************************************************************************************************************************************************************************

TASK [Print environment type] ***********************************************************************************************************************************************************************************************************************************************************
ok: [localhost] => {
    "msg": "This host belongs to the production environment"
}

TASK [Show hostname] ********************************************************************************************************************************************************************************************************************************************************************
changed: [localhost]

TASK [Display hostname] *****************************************************************************************************************************************************************************************************************************************************************
ok: [localhost] => {
    "msg": "The hostname is: 66d80191e483433f91fbdca9"
}

PLAY RECAP ******************************************************************************************************************************************************************************************************************************************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Puedes notar que, aunque incluimos ambos inventarios, el playbook se ejecutó solo una vez. Esto se debe a que ambos inventarios se refieren al mismo localhost, y Ansible elimina los hosts duplicados por defecto. Si hubiera diferentes hosts en cada inventario, Ansible ejecutaría el playbook para cada host único.

El entorno se identifica como "producción" porque el archivo de inventario de producción se especifica al final en el comando. Ansible utiliza la última aparición de un host al determinar la pertenencia a grupos y los valores de variables. Si invertimos el orden de las opciones -i, la salida mostraría "desarrollo".

Este enfoque de utilizar múltiples inventarios puede ser muy útil en escenarios del mundo real donde puedas tener hosts comunes en diferentes entornos, o cuando quieras ejecutar un playbook en una combinación de hosts de diferentes archivos de inventario.

Resumen

En este laboratorio, has aprendido cómo gestionar múltiples inventarios de Ansible. Has creado archivos de inventario separados para los entornos de desarrollo y producción, has escrito un playbook que puede funcionar en ambos entornos y has ejecutado el playbook utilizando diferentes configuraciones de inventario.

Las principales lecciones de este laboratorio son las siguientes:

1. Crear y organizar múltiples archivos de inventario: Has aprendido cómo crear archivos de inventario separados para diferentes entornos, lo que ayuda a organizar y gestionar los hosts.
2. Escribir playbooks que se adapten a diferentes entornos: Has creado un playbook que verifica en qué entorno se está ejecutando y ajusta su comportamiento en consecuencia.
3. Ejecutar playbooks con un solo inventario o múltiples inventarios: Has aprendido cómo especificar uno o más archivos de inventario al ejecutar un playbook, lo que permite un objetivo flexible de los hosts.
4. Comprender cómo Ansible maneja los hosts que aparecen en múltiples inventarios: Has visto que Ansible elimina los hosts duplicados y utiliza la última aparición de un host al determinar la pertenencia a grupos.

Estas habilidades son cruciales cuando se gestionan infraestructuras complejas con entornos distintos. Al aprovechar múltiples inventarios, puedes mantener una mejor organización y control sobre tu automatización de Ansible en diferentes conjuntos de hosts o entornos.