🎨 Sysprovider Code
Sysprovider LogoWiki
🇪🇸Hosting español para ecommerce

Automatización de infraestructura con Terraform y Ansible 2025

Actualizado el 8 de marzo de 2026

La automatización de infraestructura ha pasado de ser una ventaja competitiva a un requisito indispensable para cualquier organización que gestione servidores en la nube o entornos on-premise. En 2025, la combinación de Terraform y Ansible sigue siendo el estándar de facto para implementar una estrategia robusta de infraestructura como código (IaC). Este artículo explora en profundidad cómo estas dos herramientas se complementan para lograr despliegues repetibles, escalables y seguros, cubriendo desde los fundamentos hasta casos de uso avanzados.

El ecosistema de automatización en 2025

El panorama actual de la administración de sistemas exige velocidad y consistencia. La automatización ya no es un lujo, sino una necesidad para evitar el desvío de configuración (configuration drift) y reducir el tiempo de inactividad. Terraform y Ansible abordan este problema desde dos ángulos distintos pero complementarios.

Terraform: El arquitecto de la infraestructura

Terraform se centra en el aprovisionamiento y la gestión del ciclo de vida de los recursos. Es una herramienta declarativa que define el estado deseado de la infraestructura: redes, máquinas virtuales, balanceadores de carga, bases de datos, etc. Su lenguaje, HCL (HashiCorp Configuration Language), permite describir la infraestructura de manera legible y versionable.

Características clave en 2025:

  • Módulos reutilizables: Los módulos de Terraform permiten empaquetar configuraciones complejas (por ejemplo, un clúster de Kubernetes completo) y compartirlas entre equipos.
  • Gestión de estado remoto: Con backends como S3, Azure Storage o Terraform Cloud, el estado se almacena de forma segura y permite la colaboración en equipo.
  • Provider ecosystem: Más de 2000 proveedores (AWS, Azure, GCP, VMware, OpenStack, etc.) que cubren prácticamente cualquier recurso cloud o local.

Ansible: El configurador y orquestador

Mientras Terraform construye el "esqueleto" de la infraestructura, Ansible se encarga de la configuración del software, la instalación de paquetes, el despliegue de aplicaciones y la gestión de la configuración del sistema operativo. Es una herramienta imperativa (aunque también soporta declarativo) basada en YAML y sin necesidad de agente en los nodos gestionados.

Características clave en 2025:

  • Playbooks y roles: Los playbooks definen tareas de forma ordenada, mientras que los roles permiten organizar tareas, variables, templates y archivos de forma modular.
  • Idempotencia: Ansible garantiza que ejecutar un playbook múltiples veces produce el mismo resultado, evitando cambios no deseados.
  • Colecciones (Collections): En 2025, las colecciones de Ansible (ansible.builtin, community.general, etc.) han madurado enormemente, ofreciendo módulos para casi cualquier tarea de administración.

La sinergia: Terraform + Ansible como un flujo de trabajo completo

La verdadera potencia surge al combinar ambas herramientas. Terraform se encarga de la capa de infraestructura (crear VMs, redes, almacenamiento) y Ansible se encarga de la capa de configuración (instalar software, configurar servicios, desplegar aplicaciones). Este flujo de trabajo se conoce como "provision and configure" y es la base de los despliegues repetibles.

Ejemplo práctico: Despliegue de un servidor web LAMP

Supongamos que queremos desplegar una aplicación LAMP (Linux, Apache, MySQL, PHP) en AWS. El flujo sería:

  1. Terraform crea:

    • Una VPC con subred pública y privada.
    • Una instancia EC2 (t3.medium) en la subred pública.
    • Un grupo de seguridad que permite tráfico HTTP/HTTPS.
    • Una dirección IP elástica asociada a la instancia.

  2. Ansible se conecta a la instancia EC2 (usando el inventario dinámico generado por Terraform) y ejecuta un playbook que:

    • Actualiza el sistema operativo.
    • Instala Apache, MySQL y PHP.
    • Configura los virtual hosts y la base de datos.
    • Despliega la aplicación desde un repositorio Git.

Código de ejemplo: Paso 1 - Terraform

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

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0" # Amazon Linux 2
  instance_type = "t3.medium"
  subnet_id     = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web_sg.id]

  tags = {
    Name = "web-server-lamp"
  }
}

resource "aws_eip" "web_ip" {
  instance = aws_instance.web.id
}

output "instance_ip" {
  value = aws_eip.web_ip.public_ip
}

Código de ejemplo: Paso 2 - Ansible

# playbook-lamp.yml
---
- name: Configurar servidor LAMP
  hosts: web_servers
  become: yes
  vars:
    db_name: "mydb"
    db_user: "admin"
    db_password: "{{ vault_db_password }}"

  tasks:
    - name: Instalar paquetes necesarios
      yum:
        name:
          - httpd
          - mariadb-server
          - php
          - php-mysqlnd
        state: present

    - name: Iniciar y habilitar servicios
      systemd:
        name: "{{ item }}"
        state: started
        enabled: yes
      loop:
        - httpd
        - mariadb

    - name: Crear base de datos
      mysql_db:
        name: "{{ db_name }}"
        state: present
        login_unix_socket: /var/lib/mysql/mysql.sock

    - name: Crear usuario de base de datos
      mysql_user:
        name: "{{ db_user }}"
        password: "{{ db_password }}"
        priv: "{{ db_name }}.*:ALL"
        state: present
        login_unix_socket: /var/lib/mysql/mysql.sock

[TIP] Para integrar Terraform con Ansible de manera fluida, utiliza el provisioner remote-exec de Terraform o, mejor aún, genera un inventario dinámico con el output de Terraform. Herramientas como terraform-inventory o scripts personalizados facilitan esta tarea.

Automatización avanzada: Pipelines CI/CD y GitOps

En 2025, la automatización no se detiene en el aprovisionamiento inicial. La integración con pipelines de CI/CD es crucial para mantener la infraestructura actualizada y los despliegues repetibles a lo largo del ciclo de vida del software.

Flujo GitOps con Terraform y Ansible

  1. Repositorio de infraestructura: Un repositorio Git contiene los archivos de Terraform (.tf) y los playbooks de Ansible (.yml).
  2. Pipeline CI/CD: Cuando se hace un push a la rama main, un pipeline (Jenkins, GitLab CI, GitHub Actions) ejecuta:
    • terraform plan para mostrar los cambios.
    • terraform apply para aplicar los cambios (previa aprobación manual o automática).
    • Un script que extrae las IPs de las nuevas instancias y las pasa a Ansible.
    • ansible-playbook para configurar el software.
  3. Monitorización y corrección: Herramientas como Terraform Cloud o Atlantis permiten detectar desvíos de configuración y proponer correcciones automáticas.

Ejemplo de pipeline con GitHub Actions

# .github/workflows/deploy-infra.yml
name: Deploy Infraestructura LAMP

on:
  push:
    branches:
      - main

jobs:
  terraform:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: 1.7.0
      - name: Terraform Init
        run: terraform init
      - name: Terraform Apply
        run: terraform apply -auto-approve
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

  ansible:
    needs: terraform
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Ansible Playbook
        run: |
          ansible-playbook -i inventory/aws_ec2.yml playbook-lamp.yml
        env:
          ANSIBLE_HOST_KEY_CHECKING: "False"

[WARNING] Nunca incluyas contraseñas o claves privadas en el código. Utiliza vault de Ansible (ansible-vault encrypt) o secretos del pipeline (GitHub Secrets, GitLab CI Variables) para gestionar credenciales.

Estrategias de organización y módulos para equipos

Para equipos grandes, la organización del código es fundamental. En 2025, las mejores prácticas incluyen:

Estructura de repositorio recomendada

infraestructura/
├── terraform/
│   ├── modules/
│   │   ├── vpc/
│   │   ├── ec2/
│   │   └── rds/
│   └── environments/
│       ├── dev/
│       ├── staging/
│       └── prod/
├── ansible/
│   ├── roles/
│   │   ├── common/
│   │   ├── apache/
│   │   └── mysql/
│   ├── playbooks/
│   │   └── site.yml
│   └── inventory/
│       ├── aws_ec2.yml
│       └── group_vars/
└── pipelines/
    └── .gitlab-ci.yml

Uso de módulos para reutilización

Los módulos de Terraform permiten encapsular configuraciones complejas. Por ejemplo, un módulo vpc puede ser reutilizado en todos los entornos:

# modules/vpc/main.tf
resource "aws_vpc" "main" {
  cidr_block = var.cidr_block
  enable_dns_support = true
  enable_dns_hostnames = true
  tags = {
    Name = var.name
  }
}

resource "aws_subnet" "public" {
  count = length(var.public_subnets)
  vpc_id = aws_vpc.main.id
  cidr_block = var.public_subnets[count.index]
  map_public_ip_on_launch = true
  availability_zone = var.azs[count.index]
}

Y luego se invoca desde el entorno dev:

# environments/dev/main.tf
module "vpc" {
  source = "../../modules/vpc"
  name = "dev-vpc"
  cidr_block = "10.0.0.0/16"
  public_subnets = ["10.0.1.0/24", "10.0.2.0/24"]
  azs = ["us-east-1a", "us-east-1b"]
}

[INFO] La reutilización de módulos reduce drásticamente el tiempo de desarrollo y minimiza errores humanos. Asegúrate de versionar los módulos (por ejemplo, usando source = "git::https://...//modules/vpc?ref=v1.2.0").

Seguridad y cumplimiento en automatización

La automatización también debe ser segura. En 2025, las políticas de seguridad se integran directamente en el flujo de IaC.

Políticas con Sentinel (Terraform Cloud)

Terraform Cloud ofrece políticas basadas en Sentinel para evitar configuraciones inseguras. Por ejemplo, una política que impide que los buckets S3 sean públicos:

# policy.sentinel
import "tfplan/v2" as tfplan

# Regla: No permitir buckets públicos
main = rule {
  all tfplan.resource_changes as _, rc {
    rc.type is "aws_s3_bucket" and
    not rc.change.after.acl contains "public-read" and
    not rc.change.after.acl contains "public-read-write"
  }
}

Ansible y la gestión de secretos

Ansible Vault permite cifrar variables sensibles. Para integrarlo con pipelines, se puede pasar la contraseña del vault mediante una variable de entorno:

ansible-playbook playbook.yml --vault-password-file vault_pass.txt

[WARNING] Nunca subas el archivo vault_pass.txt al repositorio. Utiliza un gestor de secretos (AWS Secrets Manager, HashiCorp Vault, etc.) para almacenar la contraseña.

Tendencias futuras: ¿Qué esperar en 2026?

La evolución de Terraform y Ansible no se detiene. Algunas tendencias que veremos en los próximos años:

  1. Mayor integración con Kubernetes: Tanto Terraform (con el provider helm) como Ansible (con módulos k8s) están profundizando su soporte para clústeres de contenedores.
  2. Inteligencia Artificial en IaC: Herramientas como Terraform Cloud ya ofrecen sugerencias basadas en IA para optimizar recursos y detectar anomalías en los planes.
  3. Despliegues multi-cloud nativos: La gestión de infraestructura en múltiples nubes (AWS, Azure, GCP) desde un mismo conjunto de herramientas será aún más fluida.
  4. Serverless y edge computing: La automatización se expandirá hacia funciones serverless (Lambda, Cloud Functions) y nodos edge (Cloudflare Workers, AWS Wavelength).

Conclusión

La combinación de Terraform y Ansible sigue siendo, en 2025, la solución más potente y flexible para la automatización de infraestructura. Mientras Terraform proporciona una base sólida y declarativa para el aprovisionamiento de recursos, Ansible añade la capa de configuración y orquestación necesaria para que esos recursos funcionen según lo esperado. Juntos, permiten despliegues repetibles, seguros y escalables, ya sea en un entorno local, en la nube o en un híbrido.

Para los profesionales de SysAdmin y DevOps, dominar ambas herramientas no solo es una habilidad valiosa, sino una inversión a largo plazo en la eficiencia y la fiabilidad de los sistemas que gestionan. La infraestructura como código ya no es el futuro: es el presente, y Terraform + Ansible son las herramientas que lo hacen posible.

[TIP] Si estás empezando, crea un proyecto pequeño (por ejemplo, un servidor web simple) y automatiza todo el ciclo: aprovisionamiento con Terraform, configuración con Ansible y despliegue continuo con un pipeline. La práctica es la mejor manera de dominar estas herramientas.

¿Necesitas ayuda?Son dos de nuestros técnicos, Agustín y Mikel, y están disponibles para resolver cualquier problema.

Hablar con ellos ahora
Agustín y Mikel