Concepto clave

Integrar monitoreo con CloudWatch y alertas en Terraform es como instalar un sistema de seguridad en tu casa. No solo quieres saber si alguien entra (métricas), sino también recibir una alerta inmediata cuando algo anda mal. En AWS, CloudWatch es el servicio central de monitoreo que recopila métricas, logs y eventos de tus recursos. Con Terraform, defines estas configuraciones como código, asegurando que cada despliegue incluya el monitoreo adecuado desde el inicio.

Imagina que despliegas un servidor web. Sin monitoreo, podrías tener problemas de rendimiento o caídas sin notificaciones. Con CloudWatch, configuras métricas como uso de CPU, latencia de red y solicitudes HTTP. Las alertas (CloudWatch Alarms) actúan como sensores que disparan acciones cuando se superan umbrales, como notificaciones por SNS o ejecución de Auto Scaling. Esto transforma tu infraestructura de "estática" a "autónoma", capaz de reaccionar a cambios en tiempo real.

Cómo funciona en la práctica

Para integrar monitoreo en Terraform, sigues un flujo estructurado. Primero, identificas los recursos críticos en tu infraestructura AWS, como instancias EC2, bases de datos RDS o balanceadores de carga ALB. Luego, defines métricas clave para cada recurso, como CPUUtilization para EC2 o DatabaseConnections para RDS. En Terraform, usas el provider AWS para crear recursos de CloudWatch, como metric_alarms y dashboards.

Un ejemplo paso a paso: 1) Configura el provider AWS en Terraform con credenciales adecuadas. 2) Define un recurso aws_cloudwatch_metric_alarm para monitorear el uso de CPU de una instancia EC2. 3) Establece umbrales, como alertar si la CPU supera el 80% por 5 minutos. 4) Conecta la alerta a un tema SNS para enviar notificaciones por email. 5) Prueba el despliegue con terraform apply y verifica en la consola AWS. Este proceso asegura que el monitoreo sea repeatable y versionado junto con tu infraestructura.

Codigo en accion

Aquí tienes un ejemplo funcional que monitorea una instancia EC2 y configura una alerta. Antes de esto, asegúrate de tener una instancia EC2 creada con Terraform (por ejemplo, usando aws_instance).

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

# Recurso para la instancia EC2 (asumiendo que ya existe)
resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  tags = {
    Name = "WebServer"
  }
}

# Crear un tema SNS para notificaciones
resource "aws_sns_topic" "alerts_topic" {
  name = "ec2-cpu-alerts"
}

# Suscripción al tema SNS para enviar emails (configura manualmente en AWS Console o con otro recurso)
# En la práctica, podrías usar aws_sns_topic_subscription para automatizar.

# Configurar una alarma de CloudWatch para monitorear CPU
resource "aws_cloudwatch_metric_alarm" "high_cpu_alarm" {
  alarm_name          = "high-cpu-usage"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = 2
  metric_name         = "CPUUtilization"
  namespace           = "AWS/EC2"
  period              = 300  # 5 minutos en segundos
  statistic           = "Average"
  threshold           = 80.0
  alarm_description   = "Alerta cuando el uso de CPU supera el 80% por 10 minutos"
  alarm_actions       = [aws_sns_topic.alerts_topic.arn]
  dimensions = {
    InstanceId = aws_instance.web_server.id
  }
}

# Dashboard de CloudWatch para visualizar métricas
resource "aws_cloudwatch_dashboard" "main_dashboard" {
  dashboard_name = "ec2-monitoring-dashboard"
  dashboard_body = jsonencode({
    widgets = [
      {
        type = "metric"
        properties = {
          metrics = [
            ["AWS/EC2", "CPUUtilization", "InstanceId", aws_instance.web_server.id]
          ]
          period = 300
          stat   = "Average"
          region = "us-east-1"
          title  = "Uso de CPU de la Instancia EC2"
        }
      }
    ]
  })
}

Después de aplicar este código con terraform apply, tendrás una instancia EC2 monitoreada con una alerta de CPU y un dashboard. Para mejorarlo, podrías refactorizar agregando más métricas o integrando con servicios como Lambda para acciones automáticas.

Errores comunes

No configurar dimensiones correctamente en alarmas: CloudWatch necesita dimensiones como InstanceId para asociar métricas a recursos específicos. Si omites esto, la alarma no funcionará. Siempre verifica los IDs en la consola AWS.
Usar periodos de evaluación muy cortos: Configurar evaluation_periods muy bajos (ej., 1) puede causar alertas falsas por picos temporales. Usa al menos 2-3 periodos para estabilidad.
Olvidar permisos IAM: Terraform necesita permisos para crear recursos de CloudWatch y SNS. Asegúrate de que tu rol o usuario IAM tenga políticas como CloudWatchFullAccess y SNSFullAccess (o versiones más restrictivas).
No probar alertas: Desplegar sin simular condiciones de alerta (ej., carga de CPU) deja brechas. Usa herramientas como stress-ng en EC2 para pruebas.
Ignorar costos: CloudWatch tiene costos por métricas personalizadas y dashboards. Monitorea solo lo esencial y usa métricas estándar cuando sea posible.

Checklist de dominio

Definir al menos una alarma de CloudWatch para un recurso AWS usando Terraform.
Configurar un tema SNS y conectar alertas para notificaciones.
Crear un dashboard de CloudWatch con métricas clave visualizadas.
Validar que las dimensiones en alarmas coincidan con IDs de recursos reales.
Probar una alerta simulando una condición de umbral (ej., alto uso de CPU).
Revisar costos estimados de CloudWatch en la consola AWS.
Documentar la configuración de monitoreo en el repositorio de Terraform.

Despliega una infraestructura con monitoreo completo para un servidor web

En este ejercicio, crearás una infraestructura básica en AWS con Terraform que incluya una instancia EC2 y monitoreo con CloudWatch. Sigue estos pasos:

Prepara tu entorno: Asegúrate de tener Terraform instalado y credenciales AWS configuradas (ej., con AWS CLI).
Crea un nuevo directorio para el proyecto y un archivo main.tf. Copia el código del ejemplo anterior y ajusta la región a una de tu preferencia (ej., eu-west-1).
Modifica el código para agregar una segunda alarma que monitoree el estado de la instancia (métrica StatusCheckFailed). Configúrala para alertar si hay fallos por 1 minuto.
Agrega un dashboard adicional que muestre ambas métricas (CPUUtilization y StatusCheckFailed) en un solo widget.
Ejecuta terraform init, luego terraform plan para revisar los cambios, y finalmente terraform apply para desplegar.
Verifica en la consola AWS que la instancia EC2, las alarmas y el dashboard se hayan creado correctamente.
Simula una alerta: Conecta a la instancia EC2 via SSH y ejecuta un comando de carga de CPU (ej., stress-ng --cpu 4 --timeout 60s si está instalado) para disparar la alarma de CPU.
Documenta el proceso en un archivo README.md con capturas de pantalla de las alertas activas.

Pistas

Usa la documentación de AWS para encontrar los nombres exactos de las métricas, como 'StatusCheckFailed' para EC2.
Recuerda que las dimensiones en alarmas deben incluir el InstanceId; puedes referenciarlo con aws_instance.web_server.id.
Para dashboards, el dashboard_body debe ser un JSON válido; usa jsonencode en Terraform para evitar errores de sintaxis.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Integrar Monitoreo con CloudWatch y Alertas