Concepto clave

En el mundo de la infraestructura como código, Terraform actúa como el arquitecto que diseña planos detallados para construir y mantener edificios (recursos cloud). Desplegar instancias EC2 y grupos de seguridad en AWS es como construir una casa segura: necesitas definir la estructura (instancia) y las medidas de seguridad (grupo de seguridad) de manera precisa y repetible.

Imagina que eres un constructor que trabaja en múltiples proyectos. En lugar de dibujar planos a mano cada vez, usas plantillas digitales que garantizan que cada casa tenga las mismas características y cumpla con los códigos de construcción. Terraform hace lo mismo con tu infraestructura: define recursos como EC2 (servidores virtuales) y grupos de seguridad (firewalls) en archivos de configuración, permitiéndote recrear ententeros idénticos en cualquier momento.

Cómo funciona en la práctica

Para desplegar una instancia EC2 con Terraform, sigues un flujo estructurado que asegura consistencia. Primero, defines el proveedor AWS en tu archivo de configuración, especificando la región y credenciales. Luego, creas un grupo de seguridad que controle el tráfico de red hacia y desde tu instancia. Finalmente, defines la instancia EC2, asociándola al grupo de seguridad y configurando detalles como el tipo de instancia y la AMI (Amazon Machine Image).

Un ejemplo paso a paso incluye: 1) Inicializar Terraform con terraform init para descargar dependencias, 2) Planificar con terraform plan para revisar cambios, y 3) Aplicar con terraform apply para crear los recursos. Este proceso garantiza que cada despliegue sea predecible y evita errores manuales comunes en la consola de AWS.

Código en acción

Aquí tienes un ejemplo funcional que despliega una instancia EC2 con un grupo de seguridad básico. Este código es copiable y ejecutable en un entorno con Terraform configurado.

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

resource "aws_security_group" "web_sg" {
  name        = "web-security-group"
  description = "Permite tráfico HTTP y SSH"

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    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"]
  }
}

resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"  # Amazon Linux 2 AMI en us-east-1
  instance_type = "t2.micro"
  security_groups = [aws_security_group.web_sg.name]

  tags = {
    Name = "WebServerTerraform"
  }
}

Para mejorar este código y hacerlo más mantenible, puedes refactorizarlo usando variables. Aquí el antes y después:

Antes: Valores fijos en el código.

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

Después: Uso de variables para mayor flexibilidad.

variable "instance_type" {
  description = "Tipo de instancia EC2"
  default     = "t2.micro"
}

variable "ami_id" {
  description = "ID de la AMI"
  default     = "ami-0c55b159cbfafe1f0"
}

resource "aws_instance" "web_server" {
  ami           = var.ami_id
  instance_type = var.instance_type
}

Errores comunes

Olvidar definir egress en grupos de seguridad: Por defecto, Terraform no permite tráfico saliente si no se especifica. Esto puede bloquear conexiones necesarias. Siempre incluye una regla egress con protocolo "-1" para permitir todo el tráfico saliente, o define reglas específicas según tu caso.
Usar AMIs no disponibles en la región: Cada AMI es específica de una región AWS. Si usas un ID de AMI de us-west-2 en us-east-1, Terraform fallará. Verifica la AMI en la consola de AWS o usa data sources para buscarla dinámicamente.
No gestionar dependencias implícitas: Terraform crea recursos en paralelo cuando puede. Si una instancia EC2 depende de un grupo de seguridad, asegúrate de referenciarlo correctamente (como en security_groups = [aws_security_group.web_sg.name]) para que Terraform entienda el orden.
Ignorar el estado de Terraform: El archivo terraform.tfstate guarda el estado de tu infraestructura. No lo modifiques manualmente ni lo excluyas del control de versiones sin un backend remoto, ya que puede causar inconsistencias.
Sobreescribir tags manualmente: Si modificas tags de recursos en la consola de AWS, Terraform puede revertirlos en el próximo apply. Define todos los tags en la configuración para mantener el control.

Checklist de dominio

Puedo escribir un archivo Terraform que despliegue una instancia EC2 con un grupo de seguridad personalizado.
Sé cómo usar variables para hacer mi código más flexible y reutilizable.
Entiendo la importancia de las reglas ingress y egress en grupos de seguridad y puedo configurarlas correctamente.
Puedo ejecutar terraform init, plan, y apply sin errores para crear recursos en AWS.
Reconozco y evito errores comunes como AMIs regionales o dependencias mal definidas.
Sé cómo agregar tags a mis recursos para mejor organización y costeo.
Puedo destruir recursos de manera segura usando terraform destroy cuando ya no son necesarios.

Despliega una instancia EC2 con un grupo de seguridad mejorado

En este ejercicio, crearás una instancia EC2 en AWS usando Terraform, con un grupo de seguridad que permita tráfico específico y use variables para personalización. Sigue estos pasos:

Crea un nuevo directorio para tu proyecto Terraform y navega a él en tu terminal.
Dentro del directorio, crea un archivo llamado main.tf y define el proveedor AWS para la región us-east-1.
Define una variable llamada allowed_cidr con un valor por defecto de "192.168.1.0/24" para restringir el acceso SSH.
Crea un recurso aws_security_group llamado app_sg que permita:
- Entrada en el puerto 22 (SSH) solo desde la CIDR definida en la variable.
- Entrada en el puerto 80 (HTTP) desde cualquier dirección (0.0.0.0/0).
- Salida en todos los puertos hacia cualquier dirección.
Crea un recurso aws_instance llamado app_server con:
- AMI: ami-0c55b159cbfafe1f0 (Amazon Linux 2 en us-east-1).
- Tipo de instancia: t2.micro.
- Asociación al grupo de seguridad app_sg.
- Un tag Name con valor "AppServerExercise".
Ejecuta terraform init para inicializar el proyecto.
Ejecuta terraform plan para revisar los recursos a crear y asegúrate de que no haya errores.
Ejecuta terraform apply y confirma con yes para desplegar la infraestructura.
Verifica en la consola de AWS que la instancia EC2 y el grupo de seguridad se hayan creado correctamente.

Pistas

Recuerda que las variables en Terraform se definen con un bloque 'variable' y se referencian con 'var.nombre_variable'.
Asegurate de que las reglas ingress usen 'cidr_blocks' con la variable para SSH y un valor fijo para HTTP.
Si encuentras errores en 'terraform plan', revisa la sintaxis HCL y la disponibilidad de la AMI en la region especificada.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Desplegar Instancias EC2 y Grupos de Seguridad