Automatización con Ansible y Terraform para infraestructura híbrida

El dilema de la infraestructura híbrida y la necesidad de dos herramientas

La gestión de infraestructura híbrida —esa mezcla de servidores on-premise, instancias en múltiples nubes públicas y entornos de edge— se ha convertido en el campo de batalla donde los equipos de SysAdmin y DevOps ganan o pierden la partida. Ya no basta con tener scripts aislados o herramientas que solo gestionan un proveedor. La automatización SysAdmin moderna exige un enfoque dual: Terraform para el aprovisionamiento declarativo de la infraestructura base y Ansible para la configuración, el despliegue de software y la gestión del estado post-aprovisionamiento.

En este artículo, exploraremos cómo combinar Terraform y Ansible para construir un pipeline de automatización robusto, escalable y preparado para los retos de DevOps 2026. No se trata de elegir una sobre la otra, sino de entender su sinergia: Terraform crea el escenario, Ansible lo puebla y lo mantiene.

¿Por qué Terraform y Ansible juntos? No es una moda, es una necesidad

Muchos equipos caen en la trampa de usar solo una herramienta. Terraform es excelente para definir recursos (VPC, subredes, instancias, bases de datos), pero su modelo declarativo se vuelve frágil cuando necesitas instalar paquetes, modificar archivos de configuración o reiniciar servicios. Ansible, por otro lado, brilla en la configuración de sistemas, pero carece de la capacidad nativa para gestionar el ciclo de vida de recursos complejos en la nube.

La combinación es la respuesta:

• Terraform gestiona el estado de la infraestructura (infrastructure as code).
• Ansible gestiona el estado del software dentro de esa infraestructura (configuration as code).

[TIP] Piensa en Terraform como el arquitecto que construye el edificio (redes, servidores, balanceadores) y en Ansible como el equipo de mudanzas que instala los muebles, configura los enchufes y deja todo funcionando.

Flujo de trabajo ideal: de Terraform a Ansible sin fricción

El flujo más común y recomendado para infraestructura híbrida es el siguiente:

1. Planificación con Terraform: Defines tus recursos en archivos .tf. Para infraestructura híbrida, esto significa tener múltiples providers (AWS, Azure, vSphere, OpenStack, etc.) en el mismo directorio.
2. Aprovisionamiento: Ejecutas terraform apply. Terraform crea las máquinas virtuales, las redes y los grupos de seguridad.
3. Generación de inventario dinámico: El paso crítico. Terraform debe exportar las IPs o nombres de host de las máquinas recién creadas. Esto se logra mediante outputs y, mejor aún, mediante un provisioner local-exec que genere un archivo de inventario de Ansible o que actualice un inventario dinámico en un servicio externo (como Consul o un CMDB).
4. Configuración con Ansible: Ejecutas tu playbook de Ansible apuntando al inventario generado. Aquí es donde configuras repositorios, instalas agentes de monitoreo, despliegas aplicaciones y ajustas parámetros del kernel.
5. Validación y pruebas: Finalmente, ejecutas tests de integración (por ejemplo, con Testinfra o Serverspec) para asegurar que el estado final es el deseado.

Ejemplo práctico: Aprovisionar y configurar un servidor web híbrido

Imagina que necesitas un servidor web Nginx en tu datacenter on-premise (vSphere) y otro en AWS. Con Terraform, defines ambos en un solo plan:

# providers.tf
provider "aws" {
  region = "us-east-1"
}

provider "vsphere" {
  user           = var.vsphere_user
  password       = var.vsphere_password
  vsphere_server = var.vsphere_server
}

# main.tf
resource "aws_instance" "web_aws" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t3.micro"
  tags = {
    Name = "web-hybrid-aws"
  }
}

resource "vsphere_virtual_machine" "web_onprem" {
  name             = "web-hybrid-onprem"
  resource_pool_id = data.vsphere_resource_pool.pool.id
  datastore_id     = data.vsphere_datastore.datastore.id
  num_cpus         = 2
  memory           = 4096
  guest_id         = "ubuntu64Guest"
  network_interface {
    network_id = data.vsphere_network.network.id
  }
  disk {
    label = "disk0"
    size  = 20
  }
}

Una vez aplicado, necesitas que Terraform cree un inventario para Ansible. Aquí es donde entra el provisioner local-exec:

# outputs.tf (o dentro de main.tf)
resource "null_resource" "generate_inventory" {
  depends_on = [
    aws_instance.web_aws,
    vsphere_virtual_machine.web_onprem
  ]

  provisioner "local-exec" {
    command = <<-EOT
      cat > inventory.ini <<-EOF
[web_servers]
web-aws ansible_host=${aws_instance.web_aws.public_ip} ansible_user=ubuntu
web-onprem ansible_host=${vsphere_virtual_machine.web_onprem.default_ip_address} ansible_user=ubuntu
EOF
    EOT
  }
}

Ahora, tu playbook de Ansible puede apuntar a inventory.ini y configurar ambos servidores de manera idéntica:

---
- name: Configurar servidores web híbridos
  hosts: web_servers
  become: yes
  tasks:
    - name: Instalar Nginx
      apt:
        name: nginx
        state: present

    - name: Asegurar que Nginx esté corriendo
      service:
        name: nginx
        state: started
        enabled: yes

    - name: Copiar configuración personalizada
      template:
        src: templates/nginx.conf.j2
        dest: /etc/nginx/nginx.conf
      notify: restart nginx

  handlers:
    - name: restart nginx
      service:
        name: nginx
        state: restarted

[INFO] El uso de null_resource con local-exec es un patrón común, pero para entornos productivos se recomienda usar Terraform Cloud, GitLab CI o Jenkins para orquestar este paso de generación de inventario, evitando depender de la máquina local del operador.

Estrategias para infraestructura híbrida compleja

Gestionar múltiples nubes y un datacenter propio introduce desafíos que van más allá del aprovisionamiento. Aquí algunas estrategias clave para DevOps 2026:

1. Inventarios dinámicos con Terraform y Ansible

En lugar de generar un archivo .ini estático, puedes usar el plugin de inventario dinámico de Terraform para Ansible. Aunque no es oficial, existen proyectos como ansible-terraform-inventory que leen el estado de Terraform (terraform.tfstate) directamente. Esto elimina la necesidad de scripts intermedios y mantiene el inventario siempre sincronizado.

# Ejecutar Ansible usando el inventario dinámico
ansible-playbook -i /path/to/terraform-inventory.py site.yml

2. Gestión de secretos en entornos híbridos

Un error común es hardcodear credenciales en los playbooks o en las variables de Terraform. Para infraestructura híbrida, la solución es un vault centralizado (HashiCorp Vault, AWS Secrets Manager, Azure Key Vault). Ansible se integra nativamente con Vault mediante el módulo community.hashi_vault.vault_read, y Terraform puede leer secretos de Vault usando el provider de Vault.

# Ansible task para leer un secreto de Vault
- name: Obtener contraseña de base de datos desde Vault
  community.hashi_vault.vault_read:
    url: https://vault.example.com
    path: secret/data/db
    token: "{{ vault_token }}"
  delegate_to: localhost
  register: db_secret

3. Manejo del estado de Terraform en equipo

Para infraestructura híbrida, el archivo de estado (terraform.tfstate) es crítico y debe estar protegido. Usa Terraform Cloud, S3 con DynamoDB (AWS) o Azure Storage Account para almacenar el estado de forma remota y con bloqueo. Esto evita conflictos cuando múltiples miembros del equipo ejecutan terraform apply.

# backend.tf
terraform {
  backend "s3" {
    bucket         = "my-hybrid-tfstate"
    key            = "prod/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

4. Roles de Ansible parametrizados para entornos mixtos

No todas las máquinas en tu infraestructura híbrida son iguales. Un servidor en AWS puede tener un sistema operativo diferente al de tu datacenter (por ejemplo, Amazon Linux vs. Ubuntu). Crea roles de Ansible que sean agnósticos al sistema operativo usando when condicionales y variables de hecho (ansible_os_family, ansible_distribution).

- name: Instalar dependencias según SO
  package:
    name: "{{ item }}"
    state: present
  loop:
    - "{{ 'httpd' if ansible_os_family == 'RedHat' else 'apache2' }}"
    - "{{ 'python3-pip' if ansible_os_family == 'Debian' else 'python3-pip' }}"

Automatización SysAdmin: más allá del aprovisionamiento

La verdadera potencia de esta combinación se ve en el día a día del SysAdmin. No solo se trata de aprovisionar, sino de mantener, actualizar y escalar la infraestructura híbrida de forma consistente.

Actualizaciones de seguridad masivas

Con Ansible, puedes lanzar un playbook que parchee todos los servidores, tanto on-premise como en la nube, desde un solo punto de control. Combinado con Terraform, puedes incluso reemplazar instancias (blue/green deployment) si la actualización requiere un cambio de AMI o de imagen base.

- name: Actualizar todos los servidores híbridos
  hosts: all
  tasks:
    - name: Actualizar paquetes (Debian/Ubuntu)
      apt:
        upgrade: dist
        update_cache: yes
      when: ansible_os_family == "Debian"

    - name: Actualizar paquetes (RedHat/CentOS)
      yum:
        name: '*'
        state: latest
      when: ansible_os_family == "RedHat"

Escalado automático con Terraform y Ansible

Imagina que un pico de tráfico dispara un auto-scaling group en AWS. Terraform puede crear nuevas instancias, y un webhook (usando AWS Lambda o un script en tu datacenter) puede ejecutar Ansible automáticamente para configurar esas nuevas instancias con el último estado deseado. Esto es DevOps 2026 en acción: infraestructura elástica que se configura a sí misma.

[WARNING] No intentes gestionar el escalado automático solo con Terraform. Terraform es declarativo y no está diseñado para reaccionar a eventos en tiempo real. Usa servicios nativos de la nube (Auto Scaling Groups, Instance Groups) y dispara Ansible mediante eventos (SNS, CloudWatch, etc.).

Disaster Recovery (DR) automatizado

Una de las tareas más tediosas del SysAdmin es probar y ejecutar planes de DR. Con Terraform, puedes replicar tu infraestructura en una región secundaria o en un proveedor diferente. Con Ansible, puedes asegurar que la configuración de las aplicaciones es idéntica. Un playbook de DR podría verse así:

1. Terraform apply en la región de respaldo.
2. Ansible configura DNS, bases de datos y aplicaciones.
3. Tests automatizados verifican que el sitio de respaldo responde correctamente.

Herramientas complementarias para el ecosistema 2026

El stack de automatización no termina en Terraform y Ansible. Para una infraestructura híbrida verdaderamente moderna, considera integrar:

• Packer: Para crear imágenes de máquinas (AMIs, templates de vSphere) que ya incluyan el software base, reduciendo el trabajo de Ansible a solo configuración dinámica.
• Consul / etcd: Para descubrimiento de servicios y almacenamiento de configuración clave-valor. Ansible puede leer de Consul para generar inventarios dinámicos.
• Vault: Ya lo mencionamos, pero es crucial para la gestión de secretos en entornos híbridos.
• GitOps con ArgoCD o Flux: Aunque más orientado a Kubernetes, el principio de GitOps (el estado deseado en Git) se puede aplicar a la infraestructura híbrida usando Terraform Cloud y Ansible Tower/AWX.

Conclusión: el futuro es híbrido y automatizado

La combinación de Terraform y Ansible no es una solución temporal; es la base sobre la que se construirá la automatización SysAdmin en los próximos años. Para DevOps 2026, dominar ambas herramientas y entender cómo orquestarlas en entornos híbridos será tan fundamental como saber programar en Python o gestionar contenedores.

La clave está en la separación de responsabilidades: Terraform se encarga del "qué" (recursos, redes, proveedores) y Ansible del "cómo" (configuración, software, estado). Juntos, permiten a los equipos de operaciones moverse con la velocidad del desarrollo, manteniendo la estabilidad y el control que exige la infraestructura crítica.

[TIP] Empieza con un pequeño proyecto híbrido: un servidor web en tu datacenter y otro en una nube pública. Automatiza todo el ciclo de vida con Terraform y Ansible. Una vez que veas la magia de un terraform apply seguido de un ansible-playbook que deja ambos servidores idénticos, entenderás por qué esta combinación es imbatible.

La infraestructura híbrida no va a desaparecer; al contrario, se volverá más compleja. La automatización con Terraform y Ansible es tu mejor aliada para no solo sobrevivir, sino prosperar en este nuevo paradigma.