Automatización de Infraestructura Linux con Ansible y Terraform 2025

Introducción

La administración de sistemas Linux ha evolucionado de forma radical en la última década. Ya no se concibe un entorno de servidores gestionados de forma manual, con configuraciones inconsistentes y parches aplicados “a ojo”. La automatización Linux se ha convertido en el pilar fundamental de cualquier infraestructura moderna, y dos herramientas dominan este ecosistema: Ansible y Terraform.

Mientras que Terraform se encarga de aprovisionar la infraestructura (crear máquinas, redes, balanceadores), Ansible se ocupa de la configuración y el despliegue de software sobre esa infraestructura ya creada. Juntos forman un tándem imbatible para implementar infraestructura como código (IaC) de forma eficiente, repetible y segura.

En este artículo exploraremos cómo combinar ambas herramientas en entornos Linux, con ejemplos prácticos, buenas prácticas y una visión orientada al SysAdmin 2025, donde la automatización no es un lujo, sino un requisito.

¿Por qué Ansible y Terraform juntos?

Podríamos pensar que Ansible o Terraform por sí solos bastan, pero la realidad es que resuelven problemas distintos:

Terraform: Declarativo, orientado a la creación y destrucción de recursos cloud (AWS, Azure, GCP, OpenStack, VMware). Mantiene el estado de la infraestructura en un archivo (terraform.tfstate).
Ansible: Imperativo (aunque también soporta declarativo con playbooks), enfocado en la configuración de sistemas ya existentes, instalación de paquetes, ajuste de servicios, gestión de usuarios, etc.

Combinarlos permite un flujo completo: Terraform levanta el entorno, Ansible lo configura y lo mantiene.

[INFO] En entornos on-premise, Terraform también puede aprovisionar máquinas virtuales en Proxmox, vSphere o incluso contenedores LXC. Ansible luego toma el control.

Instalación y primeros pasos en Linux

Instalando Terraform

La forma más limpia en distribuciones basadas en Debian/Ubuntu:

wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install terraform

Para RHEL/CentOS/Fedora:

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo
sudo yum install terraform

Instalando Ansible

Ansible es aún más sencillo, ya que no requiere agente en los nodos gestionados:

sudo apt update && sudo apt install ansible

O mediante pip para tener la versión más reciente:

pip install ansible

[TIP] Si trabajas con múltiples versiones de Ansible, considera usar entornos virtuales de Python (venv).

Flujo de trabajo combinado: ejemplo práctico

Vamos a desplegar un pequeño clúster de servidores web con balanceador de carga usando Terraform (proveedor AWS) y configurarlo con Ansible.

1. Definir infraestructura con Terraform

Creamos un archivo main.tf:

provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "web" {
  count         = 2
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t3.micro"

  tags = {
    Name = "web-server-${count.index}"
  }
}

resource "aws_instance" "lb" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "load-balancer"
  }
}

Luego ejecutamos:

terraform init
terraform plan
terraform apply -auto-approve

Terraform nos devolverá las IPs públicas de las instancias. Guardamos esas IPs en un archivo de inventario dinámico o estático para Ansible.

2. Configurar servidores con Ansible

Creamos un inventario hosts.ini:

[webservers]
web-server-0 ansible_host=54.123.45.1
web-server-1 ansible_host=54.123.45.2

[lb]
load-balancer ansible_host=54.123.45.10

Y un playbook site.yml:

- hosts: webservers
  become: yes
  tasks:
    - name: Instalar nginx
      apt:
        name: nginx
        state: present
    - name: Iniciar servicio
      service:
        name: nginx
        state: started
        enabled: yes

- hosts: lb
  become: yes
  tasks:
    - name: Instalar haproxy
      apt:
        name: haproxy
        state: present
    - name: Configurar balanceo
      template:
        src: haproxy.cfg.j2
        dest: /etc/haproxy/haproxy.cfg
      notify: reiniciar haproxy

  handlers:
    - name: reiniciar haproxy
      service:
        name: haproxy
        state: restarted

Ejecutamos:

ansible-playbook -i hosts.ini site.yml

Buenas prácticas para SysAdmin 2025

Gestión de secretos

Nunca hardcodees contraseñas o claves API en los playbooks o configuraciones de Terraform. Usa:

Ansible Vault para cifrar variables sensibles.
Vault de HashiCorp o AWS Secrets Manager para Terraform.

Ejemplo con Ansible Vault:

ansible-vault create secrets.yml
ansible-playbook site.yml --ask-vault-pass

Uso de roles en Ansible

Estructura tu proyecto con roles para reutilizar código:

roles/
  nginx/
    tasks/main.yml
    templates/
    vars/
  haproxy/
    tasks/main.yml
    templates/

Módulos de Terraform

Crea módulos reutilizables para componentes comunes (VPC, instancias, security groups).

module "vpc" {
  source = "./modules/vpc"
  cidr   = "10.0.0.0/16"
}

Integración continua (CI/CD)

Automatiza el flujo completo con pipelines:

terraform plan en cada PR.
terraform apply al hacer merge a main.
ansible-playbook contra los servidores recién creados.

Herramientas como GitLab CI, GitHub Actions o Jenkins son ideales.

[WARNING] Siempre ejecuta terraform plan antes de apply en producción. Un cambio accidental puede destruir recursos críticos.

Automatización de la automatización: Terraform + Ansible juntos

Una técnica avanzada es llamar a Ansible directamente desde Terraform usando el provisioner local-exec o el provisioner remote-exec. Ejemplo:

resource "aws_instance" "web" {
  # ... configuración ...

  provisioner "local-exec" {
    command = "ansible-playbook -i '${self.public_ip},' playbook.yml"
  }
}

Sin embargo, esto no es recomendable en producción porque Terraform no gestiona bien el estado de las configuraciones. Mejor separa las fases.

Una alternativa más limpia es usar Ansible Dynamic Inventory para AWS, que consulta directamente la API de AWS y obtiene las instancias etiquetadas.

ansible-playbook -i aws_ec2.yml site.yml

El archivo aws_ec2.yml:

plugin: aws_ec2
regions:
  - us-east-1
filters:
  tag:Name: web-*

Monitoreo y mantenimiento continuo

Una vez automatizado el despliegue, hay que mantenerlo. Ansible es ideal para tareas recurrentes:

Actualizaciones de seguridad.
Rotación de logs.
Verificación de servicios.

Crea un playbook de mantenimiento:

- hosts: all
  tasks:
    - name: Actualizar paquetes
      apt:
        upgrade: dist
        update_cache: yes
    - name: Verificar servicios críticos
      service:
        name: "{{ item }}"
        state: started
      loop:
        - nginx
        - haproxy
        - sshd

Programa su ejecución con cron o systemd timers.

Conclusión: El futuro es IaC

La infraestructura como código ya no es una opción, es el estándar. Para cualquier SysAdmin 2025, dominar Ansible y Terraform en entornos Linux es tan básico como saber usar la terminal.

Terraform te da el poder de crear y destruir infraestructura de forma reproducible.
Ansible te permite configurarla, mantenerla y asegurarla sin esfuerzo manual.

Juntos, eliminan errores humanos, aceleran los despliegues y permiten escalar equipos sin aumentar la carga operativa.

[TIP] Empieza pequeño: automatiza un solo servidor web con Terraform y Ansible. Luego escala a clústers, balanceadores y entornos multi-cloud.

La automatización no es un proyecto, es una cultura. Y en Linux, esa cultura tiene nombre: Ansible + Terraform.