Integración de SNS y SQS con CloudWatch

Supervisión y resolución de problemas en AWS

John Q. Martin

Principal Consultant

Conectar alarmas de CloudWatch a SNS

aws cloudwatch put-metric-alarm \
  --alarm-name HighCPUUtilization \
  --metric-name CPUUtilization \
  --namespace AWS/EC2 \
  --statistic Average \
  --period 300 \
  --evaluation-periods 2 \
  --threshold 80 \
  --comparison-operator GreaterThanThreshold \
  --alarm-actions arn:aws:sns:us-east-1:123456789012:production-alerts \
  --ok-actions arn:aws:sns:us-east-1:123456789012:recovery-notifications

Flujo: una alarma de CloudWatch envía mediante --alarm-actions a un tema de SNS, que difunde a suscriptores — Email, SMS, Lambda y SQS

Conceptos clave de SNS

Componentes

SNS usa modelo publicador/suscriptor: temas, publicadores, suscriptores
Tema: canal con nombre; publicadores envían, suscriptores reciben
Publica una vez, se entrega a todos los suscriptores a la vez

Protocolos de suscripción (un tema, muchos endpoints):

Email, SMS
HTTP / HTTPS
Lambda, SQS
Push móvil, Kinesis Firehose

Tipos de temas SNS

Comparación de tipos de temas SNS Standard y FIFO por orden, rendimiento y garantías de entrega

Crear temas de SNS: AWS CLI

Tema Standard

aws sns create-topic \
  --name production-alerts

Tema FIFO

aws sns create-topic \
  --name production-alerts.fifo \
  --attributes FifoTopic=true,\
    ContentBasedDeduplication=true

Con cifrado

aws sns create-topic \
  --name production-alerts \
  --attributes KmsMasterKeyId=alias/aws/sns

Añadir suscriptores Lambda y SMS

Lambda

aws sns subscribe \
  --topic-arn arn:aws:sns:us-east-1:123456789012:production-alerts \
  --protocol lambda \
  --notification-endpoint arn:aws:lambda:us-east-1:123456789012:function:ProcessAlert

SMS

aws sns subscribe \
  --topic-arn arn:aws:sns:us-east-1:123456789012:critical-alerts \
  --protocol sms \
  --notification-endpoint +1234567890

Formato de mensaje SNS desde alarmas de CloudWatch

{
  "AlarmName": "HighCPUUtilization",
  "NewStateValue": "ALARM",
  "OldStateValue": "OK",
  "NewStateReason": "Threshold Crossed: 2 datapoints [85.0, 90.0] were greater than the threshold (80.0).",
  "StateChangeTime": "2026-03-27T10:30:45.123+0000",
  "Trigger": {
    "MetricName": "CPUUtilization",
    "Namespace": "AWS/EC2",
    "Statistic": "AVERAGE",
    "Period": 300,
    "Threshold": 80.0,
    "ComparisonOperator": "GreaterThanThreshold"
  }
}

Filtrado de mensajes en SNS

aws sns set-subscription-attributes \
  --subscription-arn arn:aws:sns:...:production-alerts:abc123 \
  --attribute-name FilterPolicy \
  --attribute-value '{"AlarmName":["HighCPUUtilization"],"NewStateValue":["ALARM"]}'

aws sns set-subscription-attributes \
  --subscription-arn arn:aws:sns:...:production-alerts:abc123 \
  --attribute-name FilterPolicyScope \
  --attribute-value MessageBody

Formateo personalizado de notificaciones con Lambda

def lambda_handler(event, context):
    alarm = json.loads(event['Records'][0]['Sns']['Message'])

    message = f"""
ALERT: {alarm['AlarmName']}
Status: {alarm['NewStateValue']}
Reason: {alarm['NewStateReason']}
Resource: {alarm['Trigger']['Dimensions'][0]['value']}
Runbook: https://wiki.example.com/runbooks/high-cpu
    """

    sns.publish(
        TopicArn='arn:aws:sns:...:formatted-alerts',
        Subject=f"{alarm['AlarmName']}",
        Message=message
    )

Cadena: el tema de alarmas en bruto alimenta una Lambda que formatea un mensaje legible y publica en el tema formatted-alerts para la persona de guardia, mientras los consumidores máquina siguen en el tema en bruto

Arquitectura fan-out con SQS

Arquitectura fan-out donde un mensaje de SNS se entrega a varias colas SQS y a un consumidor Lambda

Configurar fan-out

Cuatro pasos

Crea colas SQS (una por consumidor)
Configura políticas de cola (permitir a SNS enviar mensajes)
Suscribe las colas al tema de SNS
Crea consumidores (encolar, procesar, borrar)

Política de la cola

{
  "Effect": "Allow",
  "Principal": { "Service": "sns.amazonaws.com" },
  "Action": "sqs:SendMessage",
  "Resource": "arn:aws:sqs:...:alarm-logging-queue",
  "Condition": {
    "ArnEquals": {
      "aws:SourceArn": "arn:aws:sns:...:production-alerts"
    }
  }
}

Suscribir colas

Suscribe cada cola

aws sns subscribe \
  --topic-arn arn:aws:sns:...:production-alerts \
  --protocol sqs \
  --notification-endpoint arn:aws:sqs:...:alarm-logging-queue

Procesar mensajes

Patrón de consumidor

response = sqs.receive_message(
    QueueUrl=queue_url,
    MaxNumberOfMessages=10,
    WaitTimeSeconds=20       # Long polling
)
for message in response.get('Messages', []):
    sns_msg = json.loads(message['Body'])
    alarm = json.loads(sns_msg['Message'])
    # Process alarm data
    sqs.delete_message(QueueUrl=queue_url,
                       ReceiptHandle=message['ReceiptHandle'])

Fan-out con filtrado y colas de fallos (DLQ)

Entrega dirigida por suscripción

Cola de tickets: {"NewStateValue":["ALARM"],"Severity":["Critical"]}
Cola de logs: sin filtro (recibe todo)
Cola de métricas: {"MessageType":["Metric"]}

Colas de mensajes fallidos (DLQ)

aws sqs set-queue-attributes \
  --queue-url https://sqs..../alarm-logging-queue \
  --attributes '{
    "RedrivePolicy": "{\"deadLetterTargetArn\":\"arn:aws:sqs:...:alarm-logging-dlq\",\"maxReceiveCount\":\"3\"}"
  }'

SNS vs. SQS: cuándo usar cada uno

Comparación entre envío push de SNS y encolado pull de SQS

Ejemplos de arquitectura

Patrón de alerta simple que envía una notificación de SNS a email

Patrón de procesamiento asíncrono con una API que envía a una cola SQS consumida por un trabajador

Patrón de alertas multicanal donde una alarma se difunde a varios canales de notificación

Patrón de canalización de eventos que enruta un evento origen a varias colas SQS para su procesamiento

Resumen del vídeo

Los temas de SNS entregan notificaciones de alarmas por email, SMS, HTTP, Lambda y SQS
Patrón fan-out: un mensaje de SNS → varias colas SQS para procesamiento paralelo y fiable
El filtrado de mensajes reduce ruido por suscriptor
Las colas de fallos capturan mensajes que no se procesan
SNS para notificaciones push, SQS para procesamiento fiable; ambos para fan-out con fiabilidad

¡Vamos a practicar!

Supervisión y resolución de problemas en AWS