Introducción a Ansible: Primeros Pasos para la Automatización de Infraestructura

Introducción

Ansible ha revolucionado la automatización de infraestructura al proporcionar un enfoque simple, sin agentes y potente para la gestión de configuración y orquestación. A diferencia de las herramientas tradicionales de gestión de configuración que requieren agentes en los nodos gestionados, Ansible utiliza SSH para sistemas Linux/Unix y WinRM para Windows, lo que hace que sea increíblemente fácil comenzar con prácticas de infraestructura como código.

En el panorama DevOps actual, la configuración manual de servidores no solo consume mucho tiempo, sino que también es propensa a errores. Ansible resuelve este problema permitiéndote definir el estado de tu infraestructura en archivos YAML simples llamados playbooks. Ya sea que estés gestionando 5 servidores o 5,000, Ansible te permite automatizar tareas repetitivas, garantizar la consistencia en tu infraestructura e implementar principios de infraestructura como código.

Esta guía completa te guiará a través de todo lo que necesitas saber para comenzar con Ansible, desde la instalación hasta escribir tus primeras tareas de automatización. Al final de este tutorial, comprenderás los conceptos básicos de Ansible y podrás automatizar tareas comunes de administración de servidores.

¿Por qué Elegir Ansible para la Automatización de Infraestructura?

Ventajas Clave

Arquitectura Sin Agentes: Ansible no requiere agentes ni software adicional en los nodos gestionados. Utiliza SSH estándar para la comunicación, reduciendo la sobrecarga y las preocupaciones de seguridad.

Curva de Aprendizaje Simple: Escrito en YAML, los playbooks de Ansible son legibles para humanos y fáciles de entender, incluso para aquellos nuevos en la automatización.

Operaciones Idempotentes: Ansible garantiza que ejecutar el mismo playbook varias veces produce el mismo resultado sin causar cambios no deseados.

Amplia Biblioteca de Módulos: Con miles de módulos integrados, Ansible puede gestionar prácticamente cualquier sistema, aplicación o plataforma en la nube.

Modelo Basado en Push: A diferencia de las herramientas basadas en pull, Ansible empuja configuraciones desde un nodo de control central, brindándote retroalimentación y control inmediatos.

Requisitos Previos

Antes de sumergirte en Ansible, asegúrate de tener lo siguiente:

  • Nodo de Control: Un sistema Linux/Unix (Ubuntu 20.04+, Debian 10+, CentOS 7+, Rocky Linux 8+ o macOS) donde se instalará Ansible
  • Nodos Gestionados: Uno o más servidores que deseas gestionar con Ansible
  • Acceso SSH: Autenticación basada en claves SSH configurada entre el nodo de control y los nodos gestionados
  • Python: Python 3.6+ en el nodo de control (Python 2.7+ o 3.5+ en los nodos gestionados)
  • Acceso Sudo/Root: Privilegios administrativos en los nodos gestionados
  • Conocimientos Básicos de Linux: Comprensión de línea de comandos, SSH y administración básica de sistemas

Requisitos de Red

  • El nodo de control debe tener conectividad de red con todos los nodos gestionados
  • El puerto SSH (predeterminado 22) debe ser accesible en los nodos gestionados
  • Los nodos gestionados deben permitir que el usuario de Ansible ejecute comandos vía SSH

Instalación y Configuración

Instalación de Ansible en Ubuntu/Debian

La forma recomendada de instalar Ansible en sistemas basados en Debian es a través del PPA oficial:

# Actualizar índice de paquetes
sudo apt update

# Instalar software-properties-common para add-apt-repository
sudo apt install -y software-properties-common

# Agregar repositorio PPA de Ansible
sudo add-apt-repository --yes --update ppa:ansible/ansible

# Instalar Ansible
sudo apt install -y ansible

# Verificar instalación
ansible --version

Salida esperada:

ansible [core 2.15.x]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/user/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/user/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x

Instalación de Ansible en CentOS/Rocky Linux

Para sistemas basados en RHEL, usa el repositorio EPEL:

# Instalar repositorio EPEL
sudo dnf install -y epel-release

# Instalar Ansible
sudo dnf install -y ansible

# Verificar instalación
ansible --version

Instalación de Ansible con pip (Método Alternativo)

Para mayor control sobre la versión o cuando necesites la versión más reciente:

# Instalar pip si no está instalado
sudo apt install -y python3-pip  # Ubuntu/Debian
# O
sudo dnf install -y python3-pip  # CentOS/Rocky

# Actualizar pip
python3 -m pip install --upgrade pip

# Instalar Ansible
python3 -m pip install --user ansible

# Agregar al PATH si es necesario (agregar a ~/.bashrc o ~/.zshrc)
export PATH="$PATH:$HOME/.local/bin"

# Verificar instalación
ansible --version

Configuración de Autenticación con Claves SSH

Antes de usar Ansible, configura la autenticación basada en claves SSH:

# Generar par de claves SSH (si no tienes uno)
ssh-keygen -t ed25519 -C "ansible-automation" -f ~/.ssh/ansible_key

# Copiar clave pública a los nodos gestionados
ssh-copy-id -i ~/.ssh/ansible_key.pub user@managed-node-1
ssh-copy-id -i ~/.ssh/ansible_key.pub user@managed-node-2
ssh-copy-id -i ~/.ssh/ansible_key.pub user@managed-node-3

# Probar conexión SSH
ssh -i ~/.ssh/ansible_key user@managed-node-1

Para distribución automatizada de claves en múltiples servidores:

#!/bin/bash
# distribute-keys.sh

ANSIBLE_KEY="$HOME/.ssh/ansible_key.pub"
MANAGED_NODES="192.168.1.10 192.168.1.11 192.168.1.12"
SSH_USER="admin"

for node in $MANAGED_NODES; do
    echo "Copying key to $node..."
    ssh-copy-id -i $ANSIBLE_KEY ${SSH_USER}@${node}
done

Conceptos Básicos y Arquitectura

Componentes de Ansible

Nodo de Control: La máquina donde Ansible está instalado y desde donde ejecutas comandos y playbooks.

Nodos Gestionados: Los servidores o dispositivos que gestionas con Ansible. También llamados "hosts".

Inventario: Un archivo que define los nodos gestionados, organizados en grupos. Puede ser estático (INI o YAML) o dinámico (scripts que consultan fuentes externas).

Módulos: Unidades reutilizables de código que Ansible ejecuta en nodos gestionados. Ejemplos incluyen apt, yum, copy, service, etc.

Tareas: Acciones individuales que Ansible realiza usando módulos.

Playbooks: Archivos YAML que contienen uno o más plays, que definen tareas a ejecutar en hosts específicos.

Plays: Mapean grupos de nodos gestionados a tareas.

Roles: Forma estructurada de organizar playbooks, variables, archivos y plantillas en componentes reutilizables.

Facts: Información del sistema recopilada automáticamente desde nodos gestionados.

Cómo Funciona Ansible

  1. Defines el estado deseado en playbooks o ejecutas comandos ad-hoc
  2. Ansible se conecta a los nodos gestionados vía SSH
  3. Ansible copia el código del módulo a los nodos gestionados
  4. Los módulos se ejecutan en los nodos gestionados y devuelven resultados
  5. Ansible elimina el código del módulo de los nodos gestionados
  6. Los resultados se muestran en el nodo de control

Configuración de tu Primer Inventario

El archivo de inventario es donde defines tus nodos gestionados. Crea tu primer inventario:

Inventario Estático (Formato INI)

# Crear directorio de inventario
mkdir -p ~/ansible-projects/inventory

# Crear archivo de inventario
cat > ~/ansible-projects/inventory/hosts << 'EOF'
# Web Servers
[webservers]
web1.example.com ansible_host=192.168.1.10
web2.example.com ansible_host=192.168.1.11
web3.example.com ansible_host=192.168.1.12

# Database Servers
[databases]
db1.example.com ansible_host=192.168.1.20
db2.example.com ansible_host=192.168.1.21

# Load Balancers
[loadbalancers]
lb1.example.com ansible_host=192.168.1.30

# Group of groups
[production:children]
webservers
databases
loadbalancers

# Variables for all hosts
[all:vars]
ansible_user=admin
ansible_ssh_private_key_file=~/.ssh/ansible_key
ansible_python_interpreter=/usr/bin/python3
EOF

Inventario Estático (Formato YAML)

# ~/ansible-projects/inventory/hosts.yml
all:
  children:
    webservers:
      hosts:
        web1.example.com:
          ansible_host: 192.168.1.10
        web2.example.com:
          ansible_host: 192.168.1.11
        web3.example.com:
          ansible_host: 192.168.1.12
    databases:
      hosts:
        db1.example.com:
          ansible_host: 192.168.1.20
        db2.example.com:
          ansible_host: 192.168.1.21
    loadbalancers:
      hosts:
        lb1.example.com:
          ansible_host: 192.168.1.30
    production:
      children:
        webservers:
        databases:
        loadbalancers:
  vars:
    ansible_user: admin
    ansible_ssh_private_key_file: ~/.ssh/ansible_key
    ansible_python_interpreter: /usr/bin/python3

Prueba de Conectividad del Inventario

Verifica que Ansible puede conectarse a tus nodos gestionados:

# Ping a todos los hosts
ansible all -i ~/ansible-projects/inventory/hosts -m ping

# Ping a un grupo específico
ansible webservers -i ~/ansible-projects/inventory/hosts -m ping

# Listar todos los hosts en el inventario
ansible all -i ~/ansible-projects/inventory/hosts --list-hosts

# Mostrar estructura del inventario
ansible-inventory -i ~/ansible-projects/inventory/hosts --graph

Salida esperada para ping:

web1.example.com | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
web2.example.com | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Ejecutar Comandos Ad-Hoc

Los comandos ad-hoc son útiles para tareas rápidas y únicas sin escribir un playbook.

Sintaxis Básica

ansible <hosts> -i <inventory> -m <module> -a "<arguments>"

Ejemplos Prácticos

Verificar espacio en disco en todos los servidores:

ansible all -i inventory/hosts -m shell -a "df -h"

Actualizar caché de paquetes en servidores Ubuntu:

ansible webservers -i inventory/hosts -m apt -a "update_cache=yes" --become

Instalar un paquete:

ansible databases -i inventory/hosts -m apt -a "name=postgresql state=present" --become

Reiniciar un servicio:

ansible webservers -i inventory/hosts -m systemd -a "name=nginx state=restarted" --become

Copiar un archivo a todos los servidores:

ansible all -i inventory/hosts -m copy -a "src=/local/file.txt dest=/tmp/file.txt mode=0644"

Crear un usuario:

ansible all -i inventory/hosts -m user -a "name=deploy state=present shell=/bin/bash" --become

Recopilar facts del sistema:

ansible web1.example.com -i inventory/hosts -m setup

Verificar uptime:

ansible all -i inventory/hosts -m command -a "uptime"

Gestión de Configuración

Archivo de Configuración de Ansible

Ansible busca archivos de configuración en este orden:

  1. Variable de entorno ANSIBLE_CONFIG
  2. ansible.cfg en el directorio actual
  3. ~/.ansible.cfg en el directorio home
  4. /etc/ansible/ansible.cfg en todo el sistema

Crear una configuración específica del proyecto:

# ~/ansible-projects/ansible.cfg
[defaults]
# Ubicación del archivo de inventario
inventory = ./inventory/hosts

# No verificar claves de host (solo para pruebas)
host_key_checking = False

# Número de procesos paralelos
forks = 10

# Timeout para conexiones
timeout = 30

# Usuario predeterminado para conexiones SSH
remote_user = admin

# Archivo de clave privada
private_key_file = ~/.ssh/ansible_key

# Deshabilitar cowsay (opcional)
nocows = 1

# Recopilación de facts (implicit, explicit, smart)
gathering = smart

# Caché de facts
fact_caching = jsonfile
fact_caching_connection = /tmp/ansible_facts
fact_caching_timeout = 3600

# Logging
log_path = ./ansible.log

# Ruta de roles
roles_path = ./roles

[privilege_escalation]
# Configuración de become
become = False
become_method = sudo
become_user = root
become_ask_pass = False

[ssh_connection]
# Configuración SSH
pipelining = True
control_path = /tmp/ansible-ssh-%%h-%%p-%%r

Variables de Entorno

Variables de entorno comunes de Ansible:

# Establecer ubicación del inventario
export ANSIBLE_INVENTORY=~/ansible-projects/inventory/hosts

# Establecer archivo de configuración
export ANSIBLE_CONFIG=~/ansible-projects/ansible.cfg

# Aumentar verbosidad
export ANSIBLE_VERBOSITY=2

# Establecer argumentos SSH
export ANSIBLE_SSH_ARGS="-o ControlMaster=auto -o ControlPersist=60s"

# Deshabilitar verificación de claves de host
export ANSIBLE_HOST_KEY_CHECKING=False

Escribir tu Primer Playbook

Los playbooks son el corazón de la automatización con Ansible. Creemos un playbook práctico:

Playbook Básico de Configuración de Servidor Web

# ~/ansible-projects/webserver-setup.yml
---
- name: Configure web servers with Nginx
  hosts: webservers
  become: yes

  tasks:
    - name: Update apt cache
      apt:
        update_cache: yes
        cache_valid_time: 3600
      when: ansible_os_family == "Debian"

    - name: Install Nginx
      apt:
        name: nginx
        state: present
      when: ansible_os_family == "Debian"

    - name: Install Nginx on RHEL
      yum:
        name: nginx
        state: present
      when: ansible_os_family == "RedHat"

    - name: Ensure Nginx is started and enabled
      systemd:
        name: nginx
        state: started
        enabled: yes

    - name: Copy custom index.html
      copy:
        content: |
          <!DOCTYPE html>
          <html>
          <head><title>Welcome to {{ inventory_hostname }}</title></head>
          <body>
            <h1>Server: {{ inventory_hostname }}</h1>
            <p>Configured by Ansible</p>
          </body>
          </html>
        dest: /var/www/html/index.html
        mode: '0644'

    - name: Configure firewall for HTTP
      ufw:
        rule: allow
        port: '80'
        proto: tcp
      when: ansible_os_family == "Debian"

Ejecutar el playbook:

cd ~/ansible-projects
ansible-playbook webserver-setup.yml

Mejores Prácticas

1. Idempotencia

Siempre escribe playbooks que sean idempotentes: deben producir el mismo resultado independientemente de cuántas veces se ejecuten.

2. Usar Módulos en Lugar de Comandos Shell

Prefiere módulos integrados sobre módulos shell/command.

3. Organizar con Roles

Para proyectos complejos, usa roles para una mejor organización.

4. Usar Variables Sabiamente

Mantén datos sensibles en vaults encriptados.

5. Probar Antes de Desplegar

Siempre usa el modo de verificación para probar cambios.

6. Usar Tags

Etiqueta tareas para ejecución selectiva.

7. Control de Versiones

Siempre mantén tu código Ansible en control de versiones.

8. Documentación

Documenta tus playbooks con comentarios.

Solución de Problemas

Problemas Comunes y Soluciones

Problema: Fallo de Conexión SSH

# Depurar conexión SSH
ansible all -m ping -vvv

# Probar SSH manualmente
ssh -i ~/.ssh/ansible_key user@host

# Verificar configuración SSH
ansible all -m setup -a "filter=ansible_ssh*"

Problema: Permiso Denegado

# Usar become para escalada de privilegios
ansible-playbook site.yml --become --ask-become-pass

# Verificar configuración sudo en el nodo gestionado
ansible host -m shell -a "sudo -l" --become

Problema: Módulo No Encontrado

# Listar módulos instalados
ansible-doc -l

# Verificar versión de Python
ansible all -m shell -a "python3 --version"

# Instalar paquetes Python requeridos
ansible all -m pip -a "name=requests state=present"

Conclusión

Ansible es una herramienta poderosa para la automatización de infraestructura que simplifica la gestión de configuración, despliegue de aplicaciones y orquestación. Esta guía ha cubierto los conceptos fundamentales, desde la instalación y configuración hasta escribir tus primeros playbooks e implementar mejores prácticas.

Puntos clave de esta introducción:

  • La arquitectura sin agentes de Ansible facilita el despliegue y la gestión
  • Los playbooks basados en YAML son legibles y versionables
  • La amplia biblioteca de módulos cubre la mayoría de las necesidades de automatización
  • Los comandos ad-hoc son útiles para tareas rápidas
  • Los playbooks permiten flujos de trabajo de automatización complejos y reutilizables
  • Seguir las mejores prácticas garantiza una automatización mantenible y confiable

A medida que continúes tu viaje con Ansible, concéntrate en construir una biblioteca de roles reutilizables, implementar pruebas adecuadas y automatizar gradualmente más de tu infraestructura. La inversión inicial en aprender Ansible dará frutos en trabajo manual reducido, consistencia mejorada y despliegues más rápidos.

Próximos pasos:

  1. Practica escribiendo playbooks para tus casos de uso específicos
  2. Explora Ansible Galaxy para roles de la comunidad
  3. Aprende sobre Ansible Vault para gestión de secretos
  4. Estudia temas avanzados como inventario dinámico y módulos personalizados
  5. Implementa CI/CD para tu código Ansible

Recuerda que la infraestructura como código es un viaje, no un destino. Comienza pequeño, automatiza incrementalmente y refina continuamente tus playbooks basándote en las lecciones aprendidas. Con Ansible en tu caja de herramientas, estás bien equipado para abordar los desafíos de infraestructura moderna de manera eficiente y confiable.