# Habilitar aplicações no Lambda Você pode habilitar o Application Signals para as funções do Lambda. O Application Signals instrumentaliza automaticamente as funções do Lambda usando bibliotecas aprimoradas do AWS Distro para OpenTelemetry (ADOT), fornecidas por meio de uma camada do Lambda. Essa camada do AWS Lambda para OpenTelemetry empacota e implanta as bibliotecas necessárias para a instrumentação automática do Application Signals. Além de ser compatível com o Application Signals, essa camada do Lambda também é um componente do suporte ao Lambda OpenTelemetry e fornece funcionalidade de rastreamento. Também é possível aprimorar a observabilidade do Lambda usando o Transaction Search, que permite capturar todas as extensões de rastreamento para invocação da função do Lambda sem amostragem. Esse recurso permite que você colete extensões das funções, não afetadas pelo sinalizador `sampled` na propagação do contexto de rastreamento. Isso garante que não haja impacto adicional nos serviços dependentes a jusante. Ao habilitar o Transaction Search no Lambda, você obtém visibilidade completa da performance da função e pode solucionar problemas que ocorrem raramente. Para começar, consulte o [Transaction Search](CloudWatch-Transaction-Search.md) **Topics** + [Introdução](#Application-Signals-Enable-Lambda-Methods-Getting-Started) + [Usar o console do CloudWatch Application Signals](#Enable-Lambda-CWConsole) + [Usar o console do Lambda](#Enable-Lambda-LambdaConsole) + [Habilitar o Application Signals no Lambda usando o AWS CDK](#CloudWatch-Application-Signals-Lambda-CDK) + [Habilitar o Application Signals no Lambda usando o protocolo de contexto para modelos (MCP)](#CloudWatch-Application-Signals-Lambda-MCP) + [(Opcional) Monitorar a integridade da aplicação](#CloudWatch-Application-Signals-Monitor-Lambda) + [Habilite manualmente o Application Signals.](#Enable-Lambda-Manually) + [Desabilitar manualmente o Application Signals](#Disable-Lambda-Manually) + [Configuração do Application Signals](#Configuring-Lambda-AppSignals) + [ARNs da camada do AWS Lambda para OpenTelemetry](#Enable-Lambda-Layers) + [Implementar funções do Lambda usando um contêiner do Amazon ECR](#containerized-lambda) ## Introdução Há três métodos para habilitar o Application Signals das funções do Lambda. Depois de habilitar o Application Signals para uma função do Lambda, leva alguns minutos para que a telemetria dessa função apareça no console do Application Signals. + Usar o console do CloudWatch Application Signals + Usar o console do Lambda + Adicione manualmente a camada do AWS Lambda para OpenTelemetry ao runtime da função do Lambda. Cada um desses métodos adiciona uma camada do AWS Lambda para OpenTelemetry à função. ## Usar o console do CloudWatch Application Signals Use estas etapas para usar o console do Application Signals para habilitar o Application Signals para uma função do Lambda. 1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação, escolha **Application Signals** e, em seguida, **Serviços**. 1. Na área da lista de **Serviços**, escolha **Habilitar o Application Signals**. 1. Escolha o bloco **Lambda**. 1. Selecione cada função que você deseja habilitar do Application Signals e escolha **Concluído**. ## Usar o console do Lambda Realize estas etapas para usar o console do Lambda para habilitar o Application Signals para uma função do Lambda. 1. Abra o console AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. No painel de navegação, escolha **Funções** e, em seguida, escolha o nome da função que você deseja habilitar. 1. Escolha a guia **Configuração** e depois **Ferramentas de monitoramento e operações**. 1. Escolha **Editar**. 1. Na seção **CloudWatch Application Signals e X-Ray**, selecione **Coletar automaticamente rastreamentos de aplicações e métricas de aplicações padrão com o Application Signals** e **Coletar automaticamente rastreamentos de serviços do Lambda para visibilidade de ponta a ponta com o X-Ray**. 1. Escolha **Salvar**. ## Habilitar o Application Signals no Lambda usando o AWS CDK Caso ainda não tenha habilitado o Application Signals nessa conta, você deve conceder as permissões necessárias para o Application Signals descobrir seus serviços. Para obter mais informações, consulte [Habilitar o Application Signals na conta](CloudWatch-Application-Signals-Enable.md). 1. Habilitar o Application Signals para aplicações ``` import { aws_applicationsignals as applicationsignals } from 'aws-cdk-lib'; const cfnDiscovery = new applicationsignals.CfnDiscovery(this, 'ApplicationSignalsServiceRole', { } ); ``` O recurso Discovery CloudFormation concede as seguintes permissões ao Application Signals: + `xray:GetServiceGraph` + `logs:StartQuery` + `logs:GetQueryResults` + `cloudwatch:GetMetricData` + `cloudwatch:ListMetrics` + `tag:GetResources` Para obter mais informações sobre essa função, consulte [Permissões de perfis vinculados ao serviço para o CloudWatch Application Signals](using-service-linked-roles.md#service-linked-role-signals). 1. Adicione a política do IAM `CloudWatchLambdaApplicationSignalsExecutionRolePolicy` à função do Lambda. ``` const fn = new Function(this, 'DemoFunction', { code: Code.fromAsset('$YOUR_LAMBDA.zip'), runtime: Runtime.PYTHON_3_12, handler: '$YOUR_HANDLER' }) fn.role?.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName('CloudWatchLambdaApplicationSignalsExecutionRolePolicy')); ``` 1. Substitua `$AWS_LAMBDA_LAYER_FOR_OTEL_ARN` pelo [ARN da camada de OpenTelemetry do AWS Lambda](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) na região. ``` fn.addLayers(LayerVersion.fromLayerVersionArn( this, 'AwsLambdaLayerForOtel', '$AWS_LAMBDA_LAYER_FOR_OTEL_ARN' )) fn.addEnvironment("AWS_LAMBDA_EXEC_WRAPPER", "/opt/otel-instrument"); ``` ## Habilitar o Application Signals no Lambda usando o protocolo de contexto para modelos (MCP) Você pode usar o servidor MCP (protocolo de contexto para modelos) do CloudWatch Application Signals para habilitar o Application Signals nas funções do Lambda por meio de interações conversacionais de IA. Isso fornece uma interface de linguagem natural para configurar o monitoramento do Application Signals. O servidor MCP automatiza o processo de habilitação compreendendo os requisitos e gerando a configuração apropriada. Em vez de seguir as etapas do console manualmente ou escrever código de CDK, você pode simplesmente descrever o que deseja habilitar. ### Pré-requisitos Antes de usar o servidor MCP para habilitar o Application Signals, certifique-se de ter: + Um ambiente de desenvolvimento compatível com MCP (como Kiro, Claude Desktop, VSCode com extensões MCP ou outras ferramentas compatíveis com MCP) + O servidor MCP do Application Signals do CloudWatch configurado no IDE. Para obter instruções detalhadas de configuração, consulte a documentação do [servidor MCP do Application Signals do CloudWatch](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server). ### Usar um servidor MCP Depois de configurar o servidor MCP do CloudWatch Application Signals no IDE, você pode solicitar orientação sobre a habilitação usando prompts em linguagem natural. Embora o assistente de codificação possa inferir o contexto da estrutura do projeto, fornecer detalhes específicos nas instruções ajuda a garantir uma orientação mais precisa e relevante. Inclua informações como a linguagem de programação da função do Lambda, o nome da função e os caminhos absolutos para o código da função e o código de infraestrutura do Lambda. **Prompts de acordo com as práticas recomendadas (específicos e completos):** ``` "Enable Application Signals for my Python Lambda function. My function code is in /home/user/order-processor/lambda and IaC is in /home/user/order-processor/terraform" "I want to add observability to my Node.js Lambda function 'checkout-handler'. The function code is at /Users/dev/checkout-function and the CDK infrastructure is at /Users/dev/checkout-function/cdk" "Help me instrument my Java Lambda function with Application Signals. Function directory: /opt/apps/payment-lambda CDK infrastructure: /opt/apps/payment-lambda/cdk" ``` **Prompts menos eficazes:** ``` "Enable monitoring for my Lambda" → Missing: language, paths "Enable Application Signals. My code is in ./src and IaC is in ./infrastructure" → Problem: Relative paths instead of absolute paths "Enable Application Signals for my Lambda at /home/user/myfunction" → Missing: programming language ``` **Modelo rápido:** ``` "Enable Application Signals for my [LANGUAGE] Lambda function. Function code: [ABSOLUTE_PATH_TO_FUNCTION] IaC code: [ABSOLUTE_PATH_TO_IAC]" ``` ### Benefícios de usar o servidor MCP O uso do servidor MCP do CloudWatch Application Signals oferece várias vantagens: + **Interface em linguagem natural:** descreva o que você deseja habilitar sem memorizar comandos nem sintaxe de configuração + **Orientação contextual:** o servidor MCP compreende seu ambiente específico e fornece recomendações personalizadas + **Menos erros:** a geração automatizada de configuração minimiza os erros da digitação manual + **Configuração mais rápida:** passe da intenção à implementação mais rapidamente + **Ferramenta de aprendizagem:** veja as configurações geradas e entenda como o Application Signals funciona Para saber mais sobre a configuração e o uso do servidor MCP do CloudWatch Application Signals, consulte a [documentação do servidor MCP](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server). ## (Opcional) Monitorar a integridade da aplicação Depois de habilitar as aplicações no Lambda, você pode monitorar a integridade da aplicação. Para obter mais informações, consulte [Monitorar a integridade operacional das suas aplicações com o Application Signals](Services.md). ## Habilite manualmente o Application Signals. Use estas etapas para habilitar manualmente o Application Signals para uma função do Lambda. 1. Adicione a camada do AWS Lambda para OpenTelemetry ao runtime do Lambda. Para encontrar o ARN da camada para a região, consulte [ARNs da camada de ADOT do Lambda](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns). 1. Adicionar a variável de ambiente `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument` Adicione a variável de ambiente `LAMBDA_APPLICATION_SIGNALS_REMOTE_ENVIRONMENT` para configurar ambientes personalizados do Lambda. Por padrão, os ambientes lambda são configurados como `lambda:default`. 1. Anexar a política do IAM **CloudWatchLambdaApplicationSignalsExecutionRolePolicy** gerenciada pela AWS ao perfil de execução do Lambda. 1. (Opcional) Recomendamos que você habilite o rastreamento ativo do Lambda para obter uma melhor experiência de rastreamento. Para obter mais informações, consulte [Visualizar as invocações da função do Lambda usando o AWS X-Ray](https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html). ## Desabilitar manualmente o Application Signals Para desabilitar manualmente o Application Signals para uma função do Lambda, remova a camada do AWS Lambda para OpenTelemetry do runtime do Lambda e remova a variável de ambiente `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument`. ## Configuração do Application Signals Você pode usar esta seção para configurar o Application Signals no Lambda. **Como agrupar várias funções do Lambda em um serviço** A variável de ambiente `OTEL_SERVICE_NAME` define o nome do serviço. Isso será exibido como o nome do serviço para a aplicação nos painéis do Application Signals. Você poderá atribuir o mesmo nome de serviço a várias funções do Lambda, e elas serão mescladas em um único serviço no Application Signals. Quando você não fornecer um valor para essa chave, o nome padrão da função do Lambda será usado. **Amostragem** Por padrão, a estratégia de amostragem de rastreamento é baseada no pai. Você pode ajustar a estratégia de amostragem ao definir variáveis de ambiente `OTEL_TRACES_SAMPLER`. Por exemplo, defina a taxa de amostragem de rastreamento como 30%. ``` OTEL_TRACES_SAMPLER=traceidratio OTEL_TRACES_SAMPLER_ARG=0.3 ``` Para obter mais informações, consulte [OpenTelemetry Environment Variable Specification](https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/). **Como habilitar todas as instrumentações da biblioteca** Para reduzir inicializações a frio do Lambda, por padrão, somente as instrumentações do AWS SDK e de HTTP estão habilitadas para Python, Node e Java. Você pode definir variáveis de ambiente para habilitar a instrumentação para outras bibliotecas usadas na função do Lambda. + Python – `OTEL_PYTHON_DISABLED_INSTRUMENTATIONS=none` + Nó: `OTEL_NODE_DISABLED_INSTRUMENTATIONS=none` + Java – `OTEL_INSTRUMENTATION_COMMON_DEFAULT_ENABLED=true` ## ARNs da camada do AWS Lambda para OpenTelemetry Para obter a lista completa dos ARNs de camada de OpenTelemetry do AWS Lambda por região e runtime, consulte [ARNs da camada de ADOT do Lambda](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) na documentação do AWS Distro para OpenTelemetry. A camada está disponível para os runtimes Python, Node.js, .NET e Java. ## Implementar funções do Lambda usando um contêiner do Amazon ECR As funções do Lambda implantadas como imagens de contêiner não oferecem suporte a camadas do Lambda da maneira tradicional. Ao usar imagens de contêiner, você não pode anexar uma camada como faria com outros métodos de implantação do Lambda. Em vez disso, você deve incorporar manualmente o conteúdo da camada na imagem do contêiner durante o processo de criação. ------ #### [ Java ] Você pode aprender como integrar a camada do AWS Lambda para OpenTelemetry à função Java do Lambda em contêiner, baixar o artefato `layer.zip` e integrá-lo ao contêiner da função Java do Lambda para habilitar o monitoramento do Application Signals. **Pré-requisitos** + AWS CLI, configurada com suas credenciais + Docker instalado + Estas instruções pressupõem que você esteja na plataforma x86\$164 1. **Configurar a estrutura do projeto** Criar um diretório para a função do Lambda ``` mkdir java-appsignals-container-lambda && \ cd java-appsignals-container-lambda ``` Criar uma estrutura de projeto Maven ``` mkdir -p src/main/java/com/example/java/lambda mkdir -p src/main/resources ``` 1. **Criar um Dockerfile** Baixe e integre a camada do OpenTelemetry com suporte ao Application Signals diretamente na imagem de contêiner do Lambda. Para fazer isso, o arquivo `Dockerfile` é criado. ``` FROM public.ecr.aws/lambda/java:21 # Install utilities RUN dnf install -y unzip wget maven # Download the OpenTelemetry Layer with AppSignals Support RUN wget https://github.com/aws-observability/aws-otel-java-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip # Extract and include Lambda layer contents RUN mkdir -p /opt && \ unzip /tmp/layer.zip -d /opt/ && \ chmod -R 755 /opt/ && \ rm /tmp/layer.zip # Copy and build function code COPY pom.xml ${LAMBDA_TASK_ROOT} COPY src ${LAMBDA_TASK_ROOT}/src RUN mvn clean package -DskipTests # Copy the JAR file to the Lambda runtime directory (from inside the container) RUN mkdir -p ${LAMBDA_TASK_ROOT}/lib/ RUN cp ${LAMBDA_TASK_ROOT}/target/function.jar ${LAMBDA_TASK_ROOT}/lib/ # Set the handler CMD ["com.example.java.lambda.App::handleRequest"] ``` **nota** O arquivo `layer.zip` contém a instrumentação necessária do OpenTelemetry para o suporte do AWS Application Signals para monitorar a função do Lambda. As etapas de extração da camada garantem que: O conteúdo do layer.zip seja extraído corretamente para o `/opt/ directory` O script `otel-instrument` receba as permissões de execução adequadas O arquivo temporário layer.zip seja removido para manter o tamanho da imagem menor 1. **Código da função do Lambda**: criar um arquivo Java para o manipulador do Lambda em `src/main/java/com/example/lambda/App.java:` Seu projeto será semelhante ao seguinte: ``` . ├── Dockerfile ├── pom.xml └── src └── main ├── java │ └── com │ └── example │ └── java │ └── lambda │ └── App.java └── resources ``` 1. **Criar e implantar a imagem do contêiner** **Configurar variáveis de ambiente** ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` **Autenticar com ECR** Primeiro com ECR público (para imagem base): ``` aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws ``` Depois, com seu ECR privado: ``` aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com ``` **Criar, marcar e enviar a imagem por push** ``` # Build the Docker image docker build -t lambda-appsignals-demo . # Tag the image docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest # Push the image docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest ``` 1. **Criar e configurar a função do Lambda** Crie uma função usando o console do Lambda. Selecione **Imagem de contêiner** como a opção de implantação. Escolha **Procurar imagens** para selecionar a imagem do Amazon ECR. 1. **Testes e verificações: teste o Lambda com um evento simples. Se a integração da camada for bem-sucedida, o Lambda será exibido sob o mapa dos serviços do Application Signals.** Você verá rastreamentos e métricas para a função do Lambda no console do CloudWatch. **Solução de problemas do** Se o Application Signals não estiver funcionando, verifique o seguinte: + Verificar os logs de função em busca de erros relacionados à instrumentação do OpenTelemetry + Verificar se a variável de ambiente `AWS_LAMBDA_EXEC_WRAPPER` está definida corretamente + Certificar-se de que a extração da camada no arquivo Docker foi concluída com sucesso + Confirmar se as permissões do IAM estão anexadas corretamente + Se necessário, aumentar as definições de *tempo limite e memória* na configuração geral da função do Lambda ------ #### [ .Net ] Você pode aprender como integrar a camada do OpenTelemetry com suporte do Application Signals à função .NET do Lambda em contêiner, baixar o artefato `layer.zip` e integrá-lo à função .NET do Lambda para habilitar o monitoramento do Application Signals. **Pré-requisitos** + AWS CLI, configurada com suas credenciais + Docker instalado + SDK do .Net 8 + Estas instruções pressupõem que você esteja na plataforma x86\$164 1. **Configurar a estrutura do projeto** Criar um diretório para a imagem do contêiner da função do Lambda ``` mkdir dotnet-appsignals-container-lambda && \ cd dotnet-appsignals-container-lambda ``` 1. **Criar um Dockerfile** Baixe e integre a camada do OpenTelemetry com suporte ao Application Signals diretamente na imagem de contêiner do Lambda. Para fazer isso, o arquivo `Dockerfile` é criado. ``` FROM public.ecr.aws/lambda/dotnet:8 # Install utilities RUN dnf install -y unzip wget dotnet-sdk-8.0 which # Add dotnet command to docker container's PATH ENV PATH="/usr/lib64/dotnet:${PATH}" # Download the OpenTelemetry Layer with AppSignals Support RUN wget https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip # Extract and include Lambda layer contents RUN mkdir -p /opt && \ unzip /tmp/layer.zip -d /opt/ && \ chmod -R 755 /opt/ && \ rm /tmp/layer.zip WORKDIR ${LAMBDA_TASK_ROOT} # Copy the project files COPY dotnet-lambda-function/src/dotnet-lambda-function/*.csproj ${LAMBDA_TASK_ROOT}/ COPY dotnet-lambda-function/src/dotnet-lambda-function/Function.cs ${LAMBDA_TASK_ROOT}/ COPY dotnet-lambda-function/src/dotnet-lambda-function/aws-lambda-tools-defaults.json ${LAMBDA_TASK_ROOT}/ # Install dependencies and build the application RUN dotnet restore # Use specific runtime identifier and disable ReadyToRun optimization RUN dotnet publish -c Release -o out --self-contained false /p:PublishReadyToRun=false # Copy the published files to the Lambda runtime directory RUN cp -r out/* ${LAMBDA_TASK_ROOT}/ CMD ["dotnet-lambda-function::dotnet_lambda_function.Function::FunctionHandler"] ``` **nota** O arquivo `layer.zip` contém a instrumentação necessária do OpenTelemetry para o suporte do AWS Application Signals para monitorar a função do Lambda. As etapas de extração da camada garantem que: O conteúdo do layer.zip seja extraído corretamente para o `/opt/ directory` O script `otel-instrument` receba as permissões de execução adequadas O arquivo temporário layer.zip seja removido para manter o tamanho da imagem menor 1. **Código da função do Lambda**: inicialize o projeto do Lambda usando o modelo .NET do AWS Lambda: ``` # Install the Lambda templates if you haven't already dotnet new -i Amazon.Lambda.Templates # Create a new Lambda project dotnet new lambda.EmptyFunction -n dotnet-lambda-function ``` Seu projeto será semelhante ao seguinte: ``` . ├── Dockerfile └── dotnet-lambda-function ├── src │ └── dotnet-lambda-function │ ├── Function.cs │ ├── Readme.md │ ├── aws-lambda-tools-defaults.json │ └── dotnet-lambda-function.csproj └── test └── dotnet-lambda-function.Tests ├── FunctionTest.cs └── dotnet-lambda-function.Tests.csproj ``` 1. **Criar e implantar a imagem do contêiner** **Configurar variáveis de ambiente** ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` Atualize o código `Function.cs` para: Atualize o código `dotnet-lambda-function.csproj` para: ``` net8.0>/TargetFramework> enable enable true Lambda true true ``` 1. **Criar e implantar a imagem do contêiner** Configurar variáveis de ambiente ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` Autenticar com o Amazon ECR público ``` aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws ``` Autenticar com o Amazon ECR privado ``` aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com ``` Criar um repositório do Amazon ECR (se necessário) ``` aws ecr create-repository \ --repository-name lambda-appsignals-demo \ --region $AWS_REGION ``` Criar, marcar e enviar a imagem por push ``` # Build the Docker image docker build -t lambda-appsignals-demo . # Tag the image docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest # Push the image docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest 5. Create and Configure the Lambda Function ``` 1. **Criar e configurar a função do Lambda** Crie uma função usando o console do Lambda. Selecione **Imagem de contêiner** como a opção de implantação. Escolha **Procurar imagens** para selecionar a imagem do Amazon ECR. 1. **Testes e verificações: teste o Lambda com um evento simples. Se a integração da camada for bem-sucedida, o Lambda será exibido sob o mapa dos serviços do Application Signals.** Você verá rastreamentos e métricas para a função do Lambda no console do CloudWatch. **Solução de problemas do** Se o Application Signals não estiver funcionando, verifique o seguinte: + Verificar os logs de função em busca de erros relacionados à instrumentação do OpenTelemetry + Verificar se a variável de ambiente `AWS_LAMBDA_EXEC_WRAPPER` está definida corretamente + Certificar-se de que a extração da camada no arquivo Docker foi concluída com sucesso + Confirmar se as permissões do IAM estão anexadas corretamente + Se necessário, aumentar as definições de *tempo limite e memória* na configuração geral da função do Lambda ------ #### [ Node.js ] Você pode aprender como integrar a camada do OpenTelemetry com suporte do Application Signals à função Node.js do Lambda em contêiner, baixar o artefato `layer.zip` e integrá-lo à função Node.js do Lambda para habilitar o monitoramento do Application Signals. **Pré-requisitos** + AWS CLI, configurada com suas credenciais + Docker instalado + Estas instruções pressupõem que você esteja na plataforma x86\$164 1. **Configurar a estrutura do projeto** Criar um diretório para a imagem do contêiner da função do Lambda ``` mkdir nodejs-appsignals-container-lambda &&\ cd nodejs-appsignals-container-lambda ``` 1. **Criar um Dockerfile** Baixe e integre a camada do OpenTelemetry com suporte ao Application Signals diretamente na imagem de contêiner do Lambda. Para fazer isso, o arquivo `Dockerfile` é criado. ``` # Dockerfile FROM public.ecr.aws/lambda/nodejs:22 # Install utilities RUN dnf install -y unzip wget # Download the OpenTelemetry Layer with AppSignals Support RUN wget https://github.com/aws-observability/aws-otel-js-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip # Extract and include Lambda layer contents RUN mkdir -p /opt && \ unzip /tmp/layer.zip -d /opt/ && \ chmod -R 755 /opt/ && \ rm /tmp/layer.zip # Install npm dependencies RUN npm init -y RUN npm install # Copy function code COPY *.js ${LAMBDA_TASK_ROOT}/ # Set the CMD to your handler CMD [ "index.handler" ] ``` **nota** O arquivo `layer.zip` contém a instrumentação necessária do OpenTelemetry para o suporte do AWS Application Signals para monitorar a função do Lambda. As etapas de extração da camada garantem que: O conteúdo do layer.zip seja extraído corretamente para o `/opt/ directory` O script `otel-instrument` receba as permissões de execução adequadas O arquivo temporário layer.zip seja removido para manter o tamanho da imagem menor 1. **Código da função do Lambda** Crie um arquivo `index.js` com o seguinte conteúdo: ``` const { S3Client, ListBucketsCommand } = require('@aws-sdk/client-s3'); // Initialize S3 client const s3Client = new S3Client({ region: process.env.AWS_REGION }); exports.handler = async function(event, context) { console.log('Received event:', JSON.stringify(event, null, 2)); console.log('Handler initializing:', exports.handler.name); const response = { statusCode: 200, body: {} }; try { // List S3 buckets const command = new ListBucketsCommand({}); const data = await s3Client.send(command); // Extract bucket names const bucketNames = data.Buckets.map(bucket => bucket.Name); response.body = { message: 'Successfully retrieved buckets', buckets: bucketNames }; } catch (error) { console.error('Error listing buckets:', error); response.statusCode = 500; response.body = { message: `Error listing buckets: ${error.message}` }; } return response; }; ``` A estrutura do projeto deve ser semelhante a esta: ``` . ├── Dockerfile └── index.js ``` 1. **Criar e implantar a imagem do contêiner** **Configurar variáveis de ambiente** ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` Autenticar com o Amazon ECR público ``` aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws ``` Autenticar com o Amazon ECR privado ``` aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com ``` Criar um repositório do Amazon ECR (se necessário) ``` aws ecr create-repository \ --repository-name lambda-appsignals-demo \ --region $AWS_REGION ``` Criar, marcar e enviar a imagem por push ``` # Build the Docker image docker build -t lambda-appsignals-demo . # Tag the image docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest # Push the image docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest 5. Create and Configure the Lambda Function ``` 1. **Criar e configurar a função do Lambda** Crie uma função usando o console do Lambda. Selecione **Imagem de contêiner** como a opção de implantação. Escolha **Procurar imagens** para selecionar a imagem do Amazon ECR. 1. **Testes e verificações: teste o Lambda com um evento simples. Se a integração da camada for bem-sucedida, o Lambda será exibido sob o mapa dos serviços do Application Signals.** Você verá rastreamentos e métricas para a função do Lambda no console do CloudWatch. **Solução de problemas do** Se o Application Signals não estiver funcionando, verifique o seguinte: + Verificar os logs de função em busca de erros relacionados à instrumentação do OpenTelemetry + Verificar se a variável de ambiente `AWS_LAMBDA_EXEC_WRAPPER` está definida corretamente + Certificar-se de que a extração da camada no arquivo Docker foi concluída com sucesso + Confirmar se as permissões do IAM estão anexadas corretamente + Se necessário, aumentar as definições de *tempo limite e memória* na configuração geral da função do Lambda ------ #### [ Python ] Você pode aprender como integrar a camada do OpenTelemetry com suporte do Application Signals à função Python do Lambda em contêiner, baixar o artefato `layer.zip` e integrá-lo à função Python do Lambda para habilitar o monitoramento do Application Signals. **Pré-requisitos** + AWS CLI, configurada com suas credenciais + Docker instalado + Estas instruções pressupõem que você esteja na plataforma x86\$164 1. **Configurar a estrutura do projeto** Criar um diretório para a imagem do contêiner da função do Lambda ``` mkdir python-appsignals-container-lambda &&\ cd python-appsignals-container-lambda ``` 1. **Criar um Dockerfile** Baixe e integre a camada do OpenTelemetry com suporte ao Application Signals diretamente na imagem de contêiner do Lambda. Para fazer isso, o arquivo `Dockerfile` é criado. ``` # Dockerfile FROM public.ecr.aws/lambda/python:3.13 # Copy function code COPY app.py ${LAMBDA_TASK_ROOT} # Install unzip and wget utilities RUN dnf install -y unzip wget # Download the OpenTelemetry Layer with AppSignals Support RUN wget https://github.com/aws-observability/aws-otel-python-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip # Extract and include Lambda layer contents RUN mkdir -p /opt && \ unzip /tmp/layer.zip -d /opt/ && \ chmod -R 755 /opt/ && \ rm /tmp/layer.zip # Set the CMD to your handler CMD [ "app.lambda_handler" ] ``` **nota** O arquivo `layer.zip` contém a instrumentação necessária do OpenTelemetry para o suporte do AWS Application Signals para monitorar a função do Lambda. As etapas de extração da camada garantem que: O conteúdo do layer.zip seja extraído corretamente para o `/opt/ directory` O script `otel-instrument` receba as permissões de execução adequadas O arquivo temporário layer.zip seja removido para manter o tamanho da imagem menor 1. **Código da função do Lambda** Crie a função do Lambda em um arquivo `app.py`: ``` import json import boto3 def lambda_handler(event, context): """ Sample Lambda function that can be used in a container image. Parameters: ----------- event: dict Input event data context: LambdaContext Lambda runtime information Returns: __ dict Response object """ print("Received event:", json.dumps(event, indent=2)) # Create S3 client s3 = boto3.client('s3') try: # List buckets response = s3.list_buckets() # Extract bucket names buckets = [bucket['Name'] for bucket in response['Buckets']] return { 'statusCode': 200, 'body': json.dumps({ 'message': 'Successfully retrieved buckets', 'buckets': buckets }) } except Exception as e: print(f"Error listing buckets: {str(e)}") return { 'statusCode': 500, 'body': json.dumps({ 'message': f'Error listing buckets: {str(e)}' }) } ``` A estrutura do projeto deve ser semelhante a esta: ``` . ├── Dockerfile ├── app.py └── instructions.md ``` 1. **Criar e implantar a imagem do contêiner** **Configurar variáveis de ambiente** ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` Autenticar com o Amazon ECR público ``` aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws ``` Autenticar com o Amazon ECR privado ``` aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com ``` Criar um repositório do Amazon ECR (se necessário) ``` aws ecr create-repository \ --repository-name lambda-appsignals-demo \ --region $AWS_REGION ``` Criar, marcar e enviar a imagem por push ``` # Build the Docker image docker build -t lambda-appsignals-demo . # Tag the image docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest # Push the image docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest 5. Create and Configure the Lambda Function ``` 1. **Criar e configurar a função do Lambda** Crie uma função usando o console do Lambda. Selecione **Imagem de contêiner** como a opção de implantação. Escolha **Procurar imagens** para selecionar a imagem do Amazon ECR. 1. **Testes e verificações: teste o Lambda com um evento simples. Se a integração da camada for bem-sucedida, o Lambda será exibido sob o mapa dos serviços do Application Signals.** Você verá rastreamentos e métricas para a função do Lambda no console do CloudWatch. **Solução de problemas do** Se o Application Signals não estiver funcionando, verifique o seguinte: + Verificar os logs de função em busca de erros relacionados à instrumentação do OpenTelemetry + Verificar se a variável de ambiente `AWS_LAMBDA_EXEC_WRAPPER` está definida corretamente + Certificar-se de que a extração da camada no arquivo Docker foi concluída com sucesso + Confirmar se as permissões do IAM estão anexadas corretamente + Se necessário, aumentar as definições de *tempo limite e memória* na configuração geral da função do Lambda ------