El arte de la orquestación: Conoce Ansible

Introducción

En el mundo del desarrollo de software moderno, la capacidad de automatizar tareas repetitivas y gestionar infraestructura de manera eficiente se ha convertido en una habilidad fundamental. Ansible emerge como una de las herramientas más poderosas y accesibles para quienes buscan dar el salto hacia el mundo DevOps.

A diferencia de otras herramientas de gestión de configuración, Ansible destaca por su simplicidad y su arquitectura sin agentes. No necesitas instalar software adicional en los servidores que gestionas; solo requieres SSH y Python. En este artículo, te guiaré desde los conceptos básicos hasta técnicas avanzadas que te permitirán automatizar prácticamente cualquier tarea en tu infraestructura.

¿Qué es Ansible?

Ansible es una plataforma de automatización open-source desarrollada por Red Hat que permite gestionar configuraciones, desplegar aplicaciones y orquestar tareas complejas en múltiples servidores simultáneamente. Su filosofía se basa en la simplicidad y la legibilidad, utilizando archivos YAML para definir las tareas a ejecutar.

Lo que hace especial a Ansible es su enfoque declarativo: describes el estado deseado de tu infraestructura, y Ansible se encarga de llevarlo a ese estado, sin importar el punto de partida.

Si buscan una definición más neandertech, ansible nos permite ejecutar comandos y scripts en múltiples servidores de forma simultánea, facilitando la administración y configuración de infraestructuras complejas. Increíblemente útil para tareas repetitivas y despliegues automatizados. Además, sigue la filosofía de un Scriptscultor donde todo se define en archivos YAML, haciendo que la automatización sea accesible y fácil de entender.

Primeros Pasos: El Archivo de Inventario

Antes de ejecutar cualquier comando, Ansible necesita saber sobre qué máquinas va a trabajar. Esto se define en un archivo de inventario, que puede ser tan simple como una lista de direcciones IP o tan complejo como una estructura jerárquica de grupos.

El formato más común es un archivo INI:

[mint]
maria@192.168.100.11

[mint:vars]
puerto=9090

[desarrollo:children]
mint

[desarrollo:vars]
ansible_user=maria

También puedes usar formato YAML para mayor flexibilidad:

all:
  children:
    desarrollo:
      hosts:
        mint:
          ansible_host: 192.168.100.11
          puerto: 9090
      vars:
        ansible_user: maria

Tu Primer Comando: El Ping

El comando más básico y útil para verificar conectividad es el módulo ping:

ansible -i maquinas all -m ping

Si todo está configurado correctamente, recibirás una respuesta similar a:

maria@192.168.100.11 | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python3.12"
    },
    "changed": false,
    "ping": "pong"
}

Este simple "pong" confirma que Ansible puede conectarse exitosamente a tu servidor remoto.

Comandos Ad-hoc: Poder Inmediato

Los comandos ad-hoc te permiten ejecutar tareas rápidas sin necesidad de escribir un playbook completo. Ansible incluye módulos integrados para las tareas más comunes:

1. Módulo ping: Verifica conectividad
2. Módulo command: Ejecuta comandos simples
3. Módulo shell: Ejecuta comandos de shell con características avanzadas
4. Módulo copy: Copia archivos a servidores remotos
5. Módulo yum/apt: Gestiona paquetes del sistema

Por ejemplo, para obtener información detallada del sistema:

ansible mint -m setup

Configuración: El Archivo ansible.cfg

Para evitar especificar la ruta del inventario en cada comando, puedes crear un archivo ansible.cfg en tu directorio de trabajo:

[defaults]
inventory=./maquinas

Ansible busca este archivo en el siguiente orden de prioridad:

1. El directorio actual
2. La variable de entorno ANSIBLE_CONFIG
3. El directorio home del usuario (~/.ansible.cfg)

Playbooks: Automatización Declarativa

Los playbooks son el corazón de Ansible. Un playbook es un archivo YAML que define una serie de tareas organizadas para ejecutarse en uno o más hosts.

Aquí tienes un ejemplo básico:

---
- name: Primer Playbook
  hosts: all

  tasks:
    - name: Hacer un ping
      ansible.builtin.ping:

Para ejecutarlo:

ansible-playbook ping.yml

El resultado mostrará el progreso de cada tarea:

PLAY [Primer Playbook] *********************************************************

TASK [Gathering Facts] *********************************************************
ok: [maria@192.168.100.11]

TASK [Hacer un ping] ***********************************************************
ok: [maria@192.168.100.11]

PLAY RECAP *********************************************************************
maria@192.168.100.11       : ok=2    changed=0    unreachable=0    failed=0

Variables: Reutilización y Flexibilidad

Las variables son fundamentales para crear playbooks reutilizables. Puedes definirlas en múltiples lugares según tus necesidades:

• En el archivo de inventario
• Directamente en el playbook
• En archivos separados de variables
• Como parámetros de línea de comandos

Las variables definidas en vars tienen mayor prioridad que las definidas en defaults, lo que te permite sobrescribir valores según el contexto.

Condicionales: When

El condicional when permite ejecutar tareas solo cuando se cumplen ciertas condiciones:

---
- name: Trabajando con WHEN
  hosts: all

  tasks:
  - name: Capturar fecha
    shell:
     cmd: date
    register: fecha
    when: ansible_facts["distribution"]=='Linux Mint'

  - name: Visualizar fecha
    ansible.builtin.debug:
      msg: "{{fecha.stdout}}"
    when: ansible_facts["distribution"]=='Linux Mint'

IMPORTANTE

Debes acceder a los facts del sistema a través del diccionario ansible_facts, no mediante el prefijo directo como en versiones antiguas.

Operadores Disponibles

• Comparación: <, >, <=, >=, ==, !=
• Existencia: is defined, is not defined
• Pertenencia: in (para listas y conjuntos)

Conversión de Tipos con Filtros Jinja2

Ansible utiliza Jinja2 para el templating, lo que incluye poderosos filtros de conversión:

- name: Visualizar version
  ansible.builtin.debug:
    msg: "{{ansible_facts['distribution_version']}}"
  when: ansible_facts['distribution_version'] | float > 22

Filtros comunes:

• int: Convierte a entero
• float: Convierte a flotante
• string: Convierte a cadena
• list: Convierte a lista
• dict: Convierte a diccionario
• bool: Convierte a booleano

Ansible Galaxy: Roles Reutilizables

Ansible Galaxy es una plataforma que permite compartir y descargar roles predefinidos. Un rol es una estructura organizada de tareas, variables, archivos y plantillas.

Para crear un nuevo rol:

ansible-galaxy init desarrollo

Esto genera la siguiente estructura:

desarrollo
├── defaults
│   └── main.yml
├── files
├── handlers
│   └── main.yml
├── meta
│   └── main.yml
├── README.md
├── tasks
│   └── main.yml
├── templates
├── tests
│   ├── inventory
│   └── test.yml
└── vars
    └── main.yml

Cada directorio tiene un propósito específico:

• defaults/main.yml: Variables por defecto (menor prioridad)
• files/: Archivos estáticos para copiar a hosts remotos
• handlers/main.yml: Manejadores que responden a notificaciones
• meta/main.yml: Metadatos y dependencias del rol
• tasks/main.yml: Tareas principales del rol
• templates/: Plantillas Jinja2 para archivos dinámicos
• vars/main.yml: Variables específicas del rol (mayor prioridad)

Tags: Ejecución Selectiva

Los tags permiten ejecutar solo partes específicas de un playbook:

---
- name: Trabajando con Tags
  hosts: mint

  tasks:
    - name: Preparar desarrollo
      ansible.builtin.debug:
        msg: Preparar el entorno de desarrollo
      tags:
        - desarrollo

    - name: Instalar mysql
      ansible.builtin.debug:
        msg: "Instalando Mysql"
      tags:
        - always

    - name: Preparar produccion
      ansible.builtin.debug:
        msg: Prepara el entorno de produccion
      tags:
        - produccion

Para ejecutar solo las tareas de desarrollo:

ansible-playbook playbook.yaml -t desarrollo

El tag especial always asegura que una tarea se ejecute independientemente de los tags especificados.

Plantillas Jinja2

Las plantillas Jinja2 te permiten crear archivos dinámicos basados en variables y facts del sistema:

Hola {{ansible_hostname}}

Hoy es {{ansible_date_time.date}} y la hora actual es {{ansible_date_time.time}}.

No es necesario usar la extensión .j2, aunque es una convención común. Ansible reconoce las plantillas por su uso dentro de los playbooks.

Módulo Copy: Transferencia de Archivos

El módulo copy es fundamental para gestionar archivos en servidores remotos:

---
- name: Copiar ficheros
  hosts:
    - mint

  tasks:
    - name: Copiar fichero
      copy:
        src: ejemploCopiar.txt
        dest: /tmp/

    - name: Crear archivo con contenido
      copy:
        content: "Esto es una prueba\n"
        dest: "/tmp/prueba3.txt"

    - name: Eliminar fichero
      file:
        path: "/tmp/ejemploCopiar.txt"
        state: "absent"

Ventajas de Usar Ansible

1. Sin Agentes: Solo necesitas SSH y Python en los servidores remotos
2. Sintaxis Simple: YAML es fácil de leer y escribir
3. Idempotencia: Puedes ejecutar playbooks múltiples veces sin efectos secundarios
4. Gran Comunidad: Miles de roles disponibles en Galaxy
5. Multiplataforma: Funciona con Linux, Windows, redes y cloud

Desventajas a Considerar

1. Rendimiento: En infraestructuras muy grandes, puede ser más lento que alternativas con agentes
2. Curva de Aprendizaje: Aunque simple, dominar Jinja2 y las mejores prácticas requiere tiempo
3. Windows Support: Aunque existe, no es tan robusto como el soporte para Linux

Conclusión

Ansible es una herramienta fundamental en el arsenal de cualquier profesional DevOps. Su enfoque en la simplicidad y la automatización declarativa lo convierte en una excelente puerta de entrada al mundo de la infraestructura como código.

Desde la gestión básica de configuraciones hasta el despliegue complejo de aplicaciones distribuidas, Ansible proporciona las herramientas necesarias para automatizar prácticamente cualquier aspecto de tu infraestructura.

La mejor manera de aprender Ansible es practicando. Comienza con tareas simples como copiar archivos o instalar paquetes, y gradualmente avanza hacia playbooks más complejos y la creación de tus propios roles.

Desde La Cueva del NeanderTech te animamos a experimentar con Ansible en un entorno de pruebas. Los errores son parte del aprendizaje, y cada playbook que escribas te acercará más a dominar esta poderosa herramienta.

"La automatización aplicada a una operación eficiente magnificará la eficiencia. La automatización aplicada a una operación ineficiente magnificará la ineficiencia."

— Bill Gates

Referencias

Documentación Oficial de Ansible|Ansible Galaxy - Repositorio de Roles|Red Hat Ansible Automation Platform|Ansible Best Practices