Coletando métricas de CPU e memória para MicroVMs do AWS Lambda

Por Eric Heinz, Ben Freiberg e Ayush Kulkarni, Software Development Engineers na Amazon Web Services.

A maioria dos serviços de produção na AWS usa pelo menos duas métricas principais para a saúde do serviço – utilização de CPU e memória. A quantidade de CPU e memória usada pelo host (neste caso, uma MicroVM) pode indicar sinais de escalabilidade ou ineficiências em sua aplicação. Se você está executando uma carga de trabalho de produção em MicroVMs do AWS Lambda, é recomendado ter observabilidade nessas dimensões. E a maneira mais fácil de coletar essas métricas é com o Amazon CloudWatch Agent.

Esta publicação mostra como coletar métricas de CPU e memória de dentro da MicroVM usando o CloudWatch Agent.

Como coletar métricas de CPU e memória em sua MicroVM

Para observar como uma carga de trabalho usa CPU e memória ao longo do tempo, execute o CloudWatch Agent dentro da MicroVM. Como uma imagem de MicroVM é um snapshot completo do sistema operacional, você pode iniciar o agente durante a criação da imagem, ou seja, ele já estará em execução no momento em que uma MicroVM for iniciada a partir dessa imagem. Isso significa latência de inicialização zero e configuração única: configure o CloudWatch Agent uma vez na imagem, e cada MicroVM que for iniciada a partir dela já terá uma pilha de monitoramento em execução.

Para configurar o CloudWatch Agent, você modificará o ZIP contendo sua aplicação e Dockerfile, e construirá uma imagem de MicroVM. Uma vez que você execute uma MicroVM a partir da imagem, três métricas serão emitidas (cpu_usage_active, cpu_usage_idle, mem_used_percent) sob uma dimensão ImageName preenchida a partir de uma variável de ambiente injetada pelo Lambda.

Variáveis de ambiente injetadas pelo Lambda

O runtime de MicroVMs do Lambda expõe automaticamente essas variáveis de ambiente para sua aplicação:

O exemplo abaixo usa AWS_LAMBDA_MICROVM_IMAGE_NAME como uma dimensão de métrica para que você possa monitorar métricas por imagem de MicroVM.

Configurando dimensões de métricas personalizadas a partir de variáveis de ambiente

O Amazon CloudWatch Agent usa telegraf para processar métricas e opentelemetry-collector (OTel) para exportá-las. Normalmente, você configura o agente usando um arquivo cwagent.json, que o tradutor de configuração do agente converte em um arquivo TOML do telegraf e um arquivo YAML do OTel para o processo usar na inicialização.

Nesta publicação, pulamos a configuração JSON e criamos os arquivos telegraf e OTel diretamente. Isso nos permite definir dinamicamente uma dimensão de métrica personalizada a partir de uma variável de ambiente usando a sintaxe ${env:VAR} do OTel. A configuração do telegraf define quais métricas coletar, enquanto a configuração do OTel resolve a variável de ambiente no início do processo e a anexa como uma dimensão.

Configurando o CloudWatch Agent

Nesta seção, cobrimos como configurar o CloudWatch Agent para relatar métricas de CPU e memória para MicroVMs iniciadas a partir de sua imagem de MicroVM.

Passo 1: Configure o plugin telegraf para emitir métricas de CPU e memória

Crie um arquivo cwagent.toml para definir a configuração do telegraf para emitir métricas de CPU e memória a cada minuto:

[agent]
  interval = "60s"
  flush_interval = "60s"
  omit_hostname = true

[[inputs.cpu]]
  totalcpu = true
  percpu = false
  report_active = true
  fieldpass = ["usage_active", "usage_idle"]

[[inputs.mem]]
  fieldpass = ["used_percent"]

A métrica used_percent relata o uso de memória como uma porcentagem da memória total dentro da MicroVM. O Telegraf deriva isso de MemAvailable em /proc/meminfo. Quando sua aplicação libera memória (via free()), used_percent diminui de acordo.

Para monitorar métricas de memória adicionais, adicione os seguintes campos à lista fieldpass:

• cached: para bytes de cache de página
• buffered: para bytes de I/O em buffer
• total: para memória total disponível para a MicroVM

Passo 2: Configure o OTel para processar e exportar as métricas para o CloudWatch

Crie um arquivo cwagent.yaml para exportar métricas para o CloudWatch sob o namespace LambdaMicroVms/Application com a dimensão ImageName:

receivers:
  telegraf_cpu: { collection_interval: 60s }
  telegraf_mem: { collection_interval: 60s }

processors:
  resource:
    attributes:
      - { key: ImageName, value: "${env:AWS_LAMBDA_MICROVM_IMAGE_NAME}", action: insert }
  transform/strip_cpu_dim:
    error_mode: ignore
    metric_statements:
      - context: datapoint
        statements:
          - delete_key(attributes, "cpu")

exporters:
  awscloudwatch:
    namespace: LambdaMicroVms/Application
    region: ${env:AWS_REGION}
    resource_to_telemetry_conversion: { enabled: true }

service:
  pipelines:
    metrics:
      receivers:  [telegraf_cpu, telegraf_mem]
      processors: [resource, transform/strip_cpu_dim]
      exporters:  [awscloudwatch]

Nota: delete_key(attributes, "cpu") remove a dimensão de CPU pois apenas o uso agregado é emitido pelo telegraf.

Passo 3: Instale o CloudWatch Agent em seu Dockerfile

FROM public.ecr.aws/lambda/microvms:al2023-minimal

RUN dnf install -y --setopt=install_weak_deps=0 \
        python3 amazon-cloudwatch-agent \
    && dnf clean all

COPY app.py        /app/app.py
COPY cwagent.toml  /etc/cwagent.toml
COPY cwagent.yaml  /etc/cwagent.yaml
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh

CMD ["/entrypoint.sh"]

Passo 4: Configure seu ponto de entrada para iniciar o CloudWatch Agent

#!/usr/bin/env bash
set -euo pipefail

/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent \
    -config     /etc/cwagent.toml \
    -otelconfig /etc/cwagent.yaml &

exec python3 /app/app.py

Requisitos da função de execução

Para gravar as métricas no CloudWatch, certifique-se de que a função de execução da MicroVM tenha permissões cloudwatch:PutMetricData.

Verificando se funciona

aws cloudwatch list-metrics \
    --namespace LambdaMicroVms/Application \
    --dimensions Name=ImageName,Value=mem-python \
    --region us-west-2

Visualizando as métricas

Clique em “All Metrics” e selecione o namespace personalizado LambdaMicroVms/Application.

Conclusão

Nesta publicação, mostramos como configurar e executar o CloudWatch Agent dentro de sua imagem de MicroVM para coletar métricas de CPU e memória. Isso ajuda você a monitorar o uso de recursos, dimensionar corretamente a MicroVM e depurar a saúde do serviço.

Para começar, visite o console do AWS Lambda.

Autores

	Eric Heinz é Software Development Engineer na Amazon Web Services.
	Ben Freiberg é Software Development Engineer na Amazon Web Services.
	Ayush Kulkarni é Software Development Engineer na Amazon Web Services.

Este conteúdo foi traduzido do post original do blog, que pode ser encontrado aqui.

Tradutores

	Rodrigo Peres é Arquiteto de Soluções na AWS, com mais de 20 anos de experiência trabalhando com arquitetura de soluções, desenvolvimento de sistemas e modernização de sistemas legados.
	Daniel Abib é Arquiteto de Soluções Sênior e Especialista em Amazon Bedrock na AWS, com mais de 25 anos trabalhando com gerenciamento de projetos, arquiteturas de soluções escaláveis, desenvolvimento de sistemas e CI/CD, microsserviços, arquitetura Serverless & Containers e especialização em Machine Learning. https://www.linkedin.com/in/danielabib/