CloudWatch Container Insights e Lambda Insights na Prática: Do Básico ao Avançado Já leu

CloudWatch Container Insights: Observabilidade para Contêineres

Container Insights é a solução nativa da AWS para monitorar aplicações containerizadas em ECS e EKS. Diferentemente de métricas padrão, ele oferece visibilidade profunda sobre CPU, memória, I/O de disco e comportamento de rede no nível de container, task e cluster. O agente CloudWatch é implantado como sidecar ou DaemonSet, coletando métricas detalhadas e enviando-as para o CloudWatch Logs e Metrics.

Para ativar Container Insights em um cluster ECS, você precisa configurar o task definition com o agente de monitoramento. Abaixo, um exemplo prático de task definition para uma aplicação Node.js com monitoramento habilitado:

{
  "family": "minha-app-com-insights",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "containerDefinitions": [
    {
      "name": "app",
      "image": "minha-conta.dkr.ecr.us-east-1.amazonaws.com/minha-app:latest",
      "portMappings": [{"containerPort": 3000, "protocol": "tcp"}],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/minha-app",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      }
    },
    {
      "name": "cloudwatch-agent",
      "image": "amazon/cloudwatch-agent:latest",
      "cpu": 64,
      "memory": 128,
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/cloudwatch-agent",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      },
      "environment": [
        {"name": "USE_DEFAULT_CONFIG", "value": "True"},
        {"name": "CW_CONFIG_CONTENT", "value": "{\"metrics\": {\"namespace\": \"ContainerInsights\", \"metrics_collected\": {\"cpu\": {\"measurement\": [{\"name\": \"cpu_usage_idle\", \"rename\": \"CPU_IDLE\"}], \"metrics_collection_interval\": 60}, \"mem\": {\"measurement\": [{\"name\": \"mem_used_percent\"}], \"metrics_collection_interval\": 60}}}}"}
      ]
    }
  ]
}

Consultando Métricas com Insights

Após ativar o monitoramento, você pode consultar métricas usando CloudWatch Logs Insights. Este exemplo retorna o uso de memória médio por container:

fields @timestamp, ContainerName, MemoryUtilized, MemoryReserved
| stats avg(MemoryUtilized) as avg_memory_mb by ContainerName
| sort avg_memory_mb desc

Lambda Insights: Monitoramento de Funções Serverless

Lambda Insights oferece observabilidade automática para funções Lambda sem necessidade de instrumentação manual complexa. A extensão do CloudWatch é anexada à função, capturando métricas de performance, erros, duração e consumo de memória em tempo real. É essencial para identificar gargalos e otimizar custos em arquiteturas serverless.

Habilitar Lambda Insights é simples: você adiciona a camada da extensão e configura as permissões IAM. Aqui está uma função Python com Lambda Insights integrado:

import json
import logging
from aws_lambda_powertools import Logger, Tracer, Metrics
from aws_lambda_powertools.utilities.typing import LambdaContext

logger = Logger()
tracer = Tracer()
metrics = Metrics()

@logger.inject_lambda_context
@tracer.capture_lambda_handler
@metrics.log_cold_start_metric
def lambda_handler(event: dict, context: LambdaContext) -> dict:
    """
    Função com observabilidade automática via Powertools
    """
    metrics.add_metric(name="ProcessedRecords", unit="Count", value=1)

    try:
        # Simular processamento
        records = event.get('Records', [])
        processed = len(records)

        logger.info(f"Processando {processed} registros", extra={"records": records})
        metrics.add_metric(name="SuccessfulRecords", unit="Count", value=processed)

        return {
            'statusCode': 200,
            'body': json.dumps({'message': 'Sucesso', 'processed': processed})
        }
    except Exception as e:
        logger.exception("Erro ao processar registros")
        metrics.add_metric(name="FailedRecords", unit="Count", value=1)
        raise

Para ativar Lambda Insights via CloudFormation:

Resources:
  MinhaFuncaoLambda:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: minha-funcao-insights
      Runtime: python3.11
      Handler: index.lambda_handler
      Code:
        ZipFile: |
          # código aqui
      Layers:
        - !Sub "arn:aws:lambda:${AWS::Region}:580254703988:layer:LambdaInsightsExtension:21"
      Role: !GetAtt RoleExecucao.Arn

  RoleExecucao:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
        - arn:aws:iam::aws:policy/CloudWatchLambdaInsightsExecutionRolePolicy

Analisando Dados de Lambda Insights

Consulte métricas de execução com este comando AWS CLI:

aws cloudwatch get-metric-statistics \
  --namespace "AWS/Lambda" \
  --metric-name "Duration" \
  --dimensions Name=FunctionName,Value=minha-funcao-insights \
  --start-time 2024-01-15T00:00:00Z \
  --end-time 2024-01-15T23:59:59Z \
  --period 300 \
  --statistics Average,Maximum,Minimum

Integração Avançada: Alertas e Dashboards

Combinar Container Insights e Lambda Insights em um dashboard centralizado amplifica o valor da observabilidade. Criar alarmes inteligentes que correlacionam eventos de múltiplos serviços permite detecção proativa de problemas.

Exemplo de alarme CloudWatch que monitora taxa de erro em Lambda combinada com memória crítica em containers:

import boto3

cw = boto3.client('cloudwatch')

# Alarme para Lambda
cw.put_metric_alarm(
    AlarmName='Lambda-HighErrorRate',
    MetricName='Errors',
    Namespace='AWS/Lambda',
    Statistic='Sum',
    Period=300,
    EvaluationPeriods=1,
    Threshold=10,
    ComparisonOperator='GreaterThanThreshold',
    Dimensions=[{'Name': 'FunctionName', 'Value': 'minha-funcao-insights'}],
    AlarmActions=['arn:aws:sns:us-east-1:123456789:alertas-producao']
)

# Alarme para Container
cw.put_metric_alarm(
    AlarmName='Container-HighMemoryUsage',
    MetricName='MemoryUtilized',
    Namespace='ContainerInsights',
    Statistic='Average',
    Period=60,
    EvaluationPeriods=2,
    Threshold=400,
    ComparisonOperator='GreaterThanThreshold',
    Dimensions=[{'Name': 'ClusterName', 'Value': 'meu-cluster'}],
    AlarmActions=['arn:aws:sns:us-east-1:123456789:alertas-producao']
)

Dashboard unificado em JSON para visualizar ambos os serviços:

{
  "widgets": [
    {
      "type": "metric",
      "properties": {
        "metrics": [
          ["AWS/Lambda", "Duration", {"stat": "Average"}],
          ["AWS/Lambda", "Errors", {"stat": "Sum"}],
          ["ContainerInsights", "MemoryUtilized", {"stat": "Average"}],
          ["ContainerInsights", "CPUUtilized", {"stat": "Average"}]
        ],
        "period": 300,
        "stat": "Average",
        "region": "us-east-1",
        "title": "Visão Geral: Lambda + Containers"
      }
    }
  ]
}

Conclusão

Pontos-chave aprendidos nesta aula:

1. Container Insights fornece observabilidade em nível de container/task através de um agente sidecar, essencial para detectar problemas de performance em aplicações containerizadas antes que afetem usuários.

2. Lambda Insights automatiza a coleta de métricas serverless, e combinado com AWS Lambda Powertools, oferece observabilidade robusta sem overhead significativo de código.

3. Integração e alertas transformam dados em ação — correlacionar eventos entre containers e funções Lambda permite identificar padrões complexos de falha e otimizar arquiteturas híbridas com precisão.

Referências

• AWS CloudWatch Container Insights Documentation
• AWS Lambda Insights User Guide
• AWS Lambda Powertools for Python
• CloudWatch Logs Insights Query Syntax
• AWS Well-Architected Framework: Operational Excellence Pillar