Concepto clave

En DevOps, infraestructura como código (IaC) significa definir y gestionar recursos de infraestructura mediante archivos de configuración, en lugar de hacerlo manualmente. Terraform es una herramienta de IaC que permite crear, modificar y versionar infraestructura de manera predecible y repetible. Imagina que construir una infraestructura en la nube es como armar un mueble de IKEA: en lugar de improvisar con herramientas, sigues instrucciones detalladas (el código) que garantizan el mismo resultado cada vez.

Para una aplicación web escalable en AWS, Terraform automatiza el despliegue de componentes como instancias EC2, balanceadores de carga, bases de datos RDS y grupos de autoescalado. Esto elimina la deriva de configuración (diferencias entre entornos) y acelera el tiempo de entrega. En un proyecto real, un DevOps Engineer usa Terraform para mantener la infraestructura alineada con el ciclo de desarrollo, permitiendo cambios rápidos y rollbacks seguros.

Cómo funciona en la práctica

El flujo de trabajo con Terraform sigue un ciclo: escribir código, planificar cambios, aplicarlos y destruir recursos cuando ya no son necesarios. Para desplegar una aplicación web escalable, comenzamos definiendo un proveedor (AWS) y luego recursos específicos. Por ejemplo, primero configuramos una VPC con subredes públicas y privadas, luego añadimos un balanceador de carga que distribuye tráfico a instancias EC2 en un grupo de autoescalado, y finalmente una base de datos RDS en una subred privada para aislamiento.

Paso a paso: 1) Instalar Terraform y configurar credenciales de AWS. 2) Crear archivos .tf con definiciones de recursos. 3) Ejecutar terraform init para inicializar el proyecto. 4) Ejecutar terraform plan para revisar cambios. 5) Ejecutar terraform apply para desplegar. 6) Usar terraform destroy para limpiar. Este proceso asegura que la infraestructura sea idempotente: aplicarlo múltiples veces produce el mismo estado deseado.

Código en acción

Aquí un ejemplo funcional de un archivo main.tf que define una VPC y un grupo de seguridad básico en AWS. Este es el "antes" para sentar las bases:

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

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  enable_dns_support = true
  enable_dns_hostnames = true
  tags = {
    Name = "web-app-vpc"
  }
}

resource "aws_security_group" "web_sg" {
  name        = "web-security-group"
  description = "Security group for web instances"
  vpc_id      = aws_vpc.main.id
  
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

Después de agregar escalabilidad, podemos extenderlo con un grupo de autoescalado. Este es el "después" con mejoras:

resource "aws_launch_template" "web_lt" {
  name_prefix   = "web-template"
  image_id      = "ami-0c55b159cbfafe1f0"  # Amazon Linux 2
  instance_type = "t2.micro"
  vpc_security_group_ids = [aws_security_group.web_sg.id]
  
  user_data = base64encode(<<-EOF
    #!/bin/bash
    yum update -y
    yum install -y httpd
    systemctl start httpd
    systemctl enable httpd
    echo "
Hello from Terraform!
" > /var/www/html/index.html
  EOF)
}

resource "aws_autoscaling_group" "web_asg" {
  desired_capacity     = 2
  max_size             = 5
  min_size             = 1
  vpc_zone_identifier  = [aws_subnet.public1.id, aws_subnet.public2.id]
  launch_template {
    id      = aws_launch_template.web_lt.id
    version = "$Latest"
  }
  tag {
    key                 = "Name"
    value               = "web-instance"
    propagate_at_launch = true
  }
}

Errores comunes

• No usar state remoto: Al trabajar en equipo, guardar el archivo de estado (terraform.tfstate) localmente causa conflictos. Solución: Usar un backend como S3 con bloqueo DynamoDB para compartir estado de forma segura.
• Hardcodear valores: Incluir credenciales o IDs de AMI directamente en el código es inseguro y poco mantenible. Solución: Usar variables o sistemas de gestión de secretos como AWS Secrets Manager.
• Ignorar el plan: Aplicar cambios sin revisar terraform plan puede llevar a modificaciones no deseadas. Solución: Siempre ejecutar y verificar el plan antes de apply.
• No versionar el código: No usar control de versiones (como Git) para los archivos .tf dificulta la colaboración y el rollback. Solución: Integrar Terraform con un repositorio Git desde el inicio.
• Sobredimensionar recursos: Definir instancias muy grandes o muchas réplicas incrementa costos innecesariamente. Solución: Empezar con configuraciones mínimas y ajustar basado en métricas de uso.

Checklist de dominio

1. Configurar correctamente el proveedor AWS en Terraform con credenciales seguras.
2. Definir una VPC con subredes públicas y privadas para aislamiento de red.
3. Implementar un grupo de autoescalado que ajuste instancias EC2 basado en carga.
4. Integrar un balanceador de carga (ALB) para distribuir tráfico a instancias web.
5. Desplegar una base de datos RDS en subredes privadas con seguridad adecuada.
6. Usar variables y outputs para hacer el código reutilizable entre entornos.
7. Gestionar el estado de Terraform en un backend remoto para trabajo en equipo.

Despliega una aplicación web básica con autoescalado en AWS usando Terraform

Sigue estos pasos para crear una infraestructura escalable que sirva una página web simple. Asegúrate de tener una cuenta de AWS con credenciales configuradas localmente.

1. Crea un directorio para el proyecto y dentro, un archivo main.tf. Define el proveedor AWS con región us-east-1.
2. Añade recursos para una VPC con CIDR 10.0.0.0/16 y dos subredes públicas en zonas de disponibilidad diferentes (ej. us-east-1a y us-east-1b).
3. Define un grupo de seguridad que permita tráfico HTTP (puerto 80) desde cualquier IP y todo el tráfico saliente.
4. Crea un template de lanzamiento que use una AMI de Amazon Linux 2 (ej. ami-0c55b159cbfafe1f0) e incluya user_data para instalar Apache y servir un archivo HTML.
5. Implementa un grupo de autoescalado con 2 instancias deseadas, mínimo 1 y máximo 5, usando el template y distribuyendo en las subredes públicas.
6. Ejecuta terraform init, luego terraform plan para revisar, y finalmente terraform apply para desplegar.
7. Verifica el despliegue accediendo a la IP pública de una instancia EC2 en tu navegador. Destruye los recursos con terraform destroy al finalizar.

• Usa aws_subnet para definir las subredes con map_public_ip_on_launch = true para que sean públicas.
• En user_data, asegúrate de codificar en base64 el script de bash para la instalación.
• Consulta la documentación de Terraform para AWS si necesitas sintaxis específica de recursos.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.