Automatización de Infraestructura con Ansible y Terraform

La automatización de infraestructura ha pasado de ser un lujo a una necesidad absoluta en el mundo del hosting moderno. Gestionar servidores, balanceadores, bases de datos y redes de forma manual ya no es viable cuando se busca escalar con rapidez y mantener la consistencia. En este ecosistema, dos herramientas se han consolidado como los pilares fundamentales: Ansible y Terraform. Aunque a menudo se comparan, la realidad es que son complementarios. Mientras uno se especializa en la configuración y el estado del software (Ansible), el otro es el rey del aprovisionamiento y la gestión de recursos cloud (Terraform). Dominar ambos es la clave para una estrategia de infraestructura como código (IaC) impecable.

Este artículo es una guía extensa y práctica para SysAdmins y DevOps que buscan implementar automatización real en sus entornos de hosting. No solo veremos qué hace cada uno, sino cómo combinarlos para orquestar desde un simple VPS hasta un clúster de alta disponibilidad.

¿Por qué automatizar? El problema del hosting manual

Antes de sumergirnos en las herramientas, entendamos el dolor que resuelven. Gestionar un servidor de hosting manualmente implica SSH, ejecutar comandos, recordar configuraciones y rezar para que no haya errores humanos. Con 5 servidores, es molesto. Con 50, es inviable.

La automatización con Ansible y Terraform ofrece:

• Reproducibilidad: Tu infraestructura se define en archivos de texto. Si algo falla, lo destruyes y lo recreas en minutos.
• Control de versiones: Tus playbooks y configuraciones de Terraform viven en Git. Puedes hacer rollbacks, revisar cambios y auditar quién modificó qué.
• Consistencia: No más "en mi máquina funciona". Cada servidor se aprovisiona y configura exactamente igual.
• Velocidad: Desplegar un nuevo servidor web con Nginx, PHP y un certificado SSL puede pasar de 30 minutos a 3 minutos.

[INFO] La infraestructura como código no es solo una herramienta, es una metodología. Tratar tus servidores como ganado (desechable y reemplazable) y no como mascotas (irremplazables y únicas) es el cambio de mentalidad más importante.

Ansible: El configurador sin agente

Ansible es una herramienta de automatización de TI que se centra en la configuración, el despliegue de aplicaciones y la orquestación. Su principal ventaja es que es agentless (sin agente). No necesitas instalar nada en los servidores destino; solo necesitas Python y SSH. Esto lo hace increíblemente fácil de empezar.

¿Qué hace Ansible excepcional?

• Push vs Pull: Ansible "empuja" la configuración desde un nodo de control a los nodos gestionados. Es ideal para entornos donde quieres aplicar cambios inmediatos.
• YAML puro: Sus playbooks son fáciles de leer y escribir. Un desarrollador puede entender un playbook de Ansible casi sin formación previa.
• Idempotencia: Ejecutar un playbook una vez o cien veces produce el mismo resultado final. Si un paquete ya está instalado, no se reinstala. Si un servicio ya está corriendo, no se reinicia a menos que sea necesario.

Ejemplo práctico: Configurar un servidor LEMP con Ansible

Imagina que quieres configurar un servidor web para hosting básico (Nginx, PHP-FPM, MariaDB). Un playbook de Ansible se vería así:

---
- name: Configurar servidor LEMP para hosting
  hosts: webservers
  become: yes
  vars:
    domain: "mipagina.com"
    php_version: "8.1"

  tasks:
    - name: Actualizar cache de apt
      apt:
        update_cache: yes
        cache_valid_time: 3600

    - name: Instalar Nginx, PHP y MariaDB
      apt:
        name:
          - nginx
          - php{{ php_version }}-fpm
          - php{{ php_version }}-mysql
          - mariadb-server
        state: present

    - name: Iniciar y habilitar servicios
      service:
        name: "{{ item }}"
        state: started
        enabled: yes
      loop:
        - nginx
        - php{{ php_version }}-fpm
        - mariadb

    - name: Crear virtual host para el dominio
      template:
        src: vhost.conf.j2
        dest: /etc/nginx/sites-available/{{ domain }}
      notify: recargar nginx

    - name: Habilitar el sitio
      file:
        src: /etc/nginx/sites-available/{{ domain }}
        dest: /etc/nginx/sites-enabled/{{ domain }}
        state: link

  handlers:
    - name: recargar nginx
      service:
        name: nginx
        state: reloaded

Este playbook es simple, legible y garantiza que cada servidor de la categoría webservers tendrá exactamente la misma configuración.

Terraform: El arquitecto de la nube

Si Ansible configura el interior del servidor, Terraform se encarga de construir el edificio. Es una herramienta de infraestructura como código declarativa que se especializa en aprovisionar recursos en cualquier proveedor cloud (AWS, Google Cloud, Azure, DigitalOcean, etc.) o incluso en tu propio centro de datos con vSphere.

¿Qué hace Terraform excepcional?

• Declarativo vs Imperativo: Tú defines el estado deseado de tu infraestructura (quiero 3 servidores, 1 balanceador, 1 red privada). Terraform calcula el plan para llegar a ese estado y lo ejecuta. No le dices cómo hacerlo, le dices qué quieres.
• Gestión de estado: Terraform guarda un archivo de estado (terraform.tfstate) que mapea los recursos reales en el cloud con tu configuración. Esto le permite saber qué añadir, modificar o destruir.
• Plan de ejecución: Antes de tocar nada, ejecutas terraform plan. Te muestra exactamente qué va a pasar (crear, destruir, modificar). Esto evita sorpresas desagradables.

Ejemplo práctico: Aprovisionar un droplet en DigitalOcean con Terraform

Supón que quieres crear un servidor en DigitalOcean para tu hosting. Con Terraform, tu configuración principal (main.tf) sería:

provider "digitalocean" {
  token = var.do_token
}

resource "digitalocean_droplet" "web" {
  image  = "ubuntu-22-04-x64"
  name   = "web-server-01"
  region = "fra1"
  size   = "s-2vcpu-4gb"
  ssh_keys = [data.digitalocean_ssh_key.terraform.id]

  tags = ["web", "hosting", "production"]
}

data "digitalocean_ssh_key" "terraform" {
  name = "MiClaveSSH"
}

resource "digitalocean_firewall" "web" {
  name = "firewall-web"

  droplet_ids = [digitalocean_droplet.web.id]

  inbound_rule {
    protocol         = "tcp"
    port_range       = "22"
    source_addresses = ["0.0.0.0/0", "::/0"]
  }

  inbound_rule {
    protocol         = "tcp"
    port_range       = "80"
    source_addresses = ["0.0.0.0/0", "::/0"]
  }

  inbound_rule {
    protocol         = "tcp"
    port_range       = "443"
    source_addresses = ["0.0.0.0/0", "::/0"]
  }

  outbound_rule {
    protocol              = "tcp"
    port_range            = "1-65535"
    destination_addresses = ["0.0.0.0/0", "::/0"]
  }
}

Con terraform apply, en segundos tienes un droplet con su firewall configurado. Si necesitas escalar, cambias el count o usas módulos.

La sinergia perfecta: Ansible + Terraform

Aquí está la magia. Usar solo Terraform o solo Ansible es como tener un martillo sin clavos. La verdadera potencia surge al combinarlos.

El flujo de trabajo ideal:

1. Terraform aprovisiona la infraestructura: Crea los servidores, redes, balanceadores, bases de datos gestionadas, etc.
2. Ansible configura el software: Una vez que los servidores existen y tienen IP, Ansible se conecta y configura Nginx, PHP, firewall interno, usuarios, claves SSH, etc.

Cómo conectar ambas herramientas

La clave está en la comunicación de datos. Terraform puede generar un inventario dinámico que Ansible pueda consumir.

Opción 1: Output de Terraform a un archivo de inventario

Puedes usar un local_file en Terraform para generar un archivo inventory.ini o inventory.yml.

resource "local_file" "ansible_inventory" {
  content = templatefile("inventory.tpl", {
    web_ips = digitalocean_droplet.web.*.ipv4_address
  })
  filename = "${path.module}/inventory.ini"
}

Luego ejecutas Ansible apuntando a ese inventario.

Opción 2: Plugin de Terraform para Ansible (ansible_host)

Terraform puede ejecutar un playbook de Ansible directamente después de crear un recurso usando el null_resource y un provisioner local-exec.

resource "null_resource" "ansible_provisioner" {
  depends_on = [digitalocean_droplet.web]

  provisioner "local-exec" {
    command = "ansible-playbook -i '${digitalocean_droplet.web.ipv4_address},' playbooks/setup.yml"
  }
}

[WARNING] Usar local-exec puede ser frágil. Si el playbook falla, el recurso de Terraform se marca como creado pero la configuración está corrupta. Es mejor usar un pipeline externo (CI/CD) que ejecute Terraform y luego Ansible de forma secuencial.

Ejemplo completo de flujo CI/CD

1. Un desarrollador hace push a git con cambios en infra/terraform/ y infra/ansible/.
2. El pipeline (GitHub Actions/GitLab CI) ejecuta terraform plan y luego terraform apply.
3. Tras el apply, el pipeline extrae las IPs de los outputs de Terraform.
4. Se ejecuta ansible-playbook -i inventory.yml setup.yml.
5. Si todo va bien, la nueva infraestructura está lista y configurada.

Casos de uso en hosting

Migración de servidores

¿Tienes un servidor de hosting legacy que quieres replicar? Con Terraform creas la nueva máquina en el cloud y con Ansible replicas toda la configuración (virtual hosts, bases de datos, usuarios FTP). La migración se vuelve un proceso controlado y reversible.

Escalado horizontal

Cuando tu sitio recibe un pico de tráfico, puedes disparar un script que ejecute Terraform para crear 5 servidores web nuevos, y luego Ansible los configure automáticamente para unirse al pool del balanceador.

Gestión de múltiples entornos

Con Terraform workspaces o módulos, puedes tener los mismos recursos para dev, staging y production. Ansible se encarga de que cada entorno tenga las configuraciones específicas (diferentes dominios, certificados SSL, etc.).

Buenas prácticas para SysAdmins

1. Mantén el estado de Terraform seguro: Usa un backend remoto (S3, GCS, Terraform Cloud). El archivo .tfstate contiene secretos y es crítico.
2. Usa roles y colecciones en Ansible: No pongas todo en un solo playbook. Crea roles para Nginx, PHP, MySQL, etc. Reutiliza código.
3. Versiona todo: Cada cambio en tu infraestructura debe pasar por un PR (Pull Request). Revisa los planes de Terraform y los diffs de los playbooks.
4. Usa variables y secretos: No hardcodees contraseñas. Usa ansible-vault para encriptar secretos en Ansible y variables de entorno o Vault para Terraform.
5. Prueba en staging: Nunca apliques un terraform destroy en producción sin probarlo antes. Usa entornos aislados.

Conclusión

La automatización de infraestructura con Ansible y Terraform no es una moda, es el estándar de la industria para cualquier profesional del hosting y la administración de sistemas. Terraform te da el poder de esculpir tu infraestructura en la nube con precisión quirúrgica, mientras que Ansible se encarga de que cada servidor cante la misma canción.

Dominar ambos te permite pasar de ser un SysAdmin que apaga incendios a un arquitecto que diseña sistemas autorreparables y escalables. La inversión en aprender estas herramientas se amortiza con la primera vez que despliegas un clúster completo en menos de 10 minutos.

[TIP] Empieza pequeño. Automatiza la creación de un solo VPS con Terraform y luego configúralo con Ansible para servir una página estática. Cuando veas lo fácil que es, ya no querrás volver atrás.