Habilitar aplicações no Lambda

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

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"]

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

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

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.

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.

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

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"]

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

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:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0>/TargetFramework>
   <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
    <AWSProjectType>Lambda</AWSProjectType>
    
    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
    
    <PublishReadyToRun>true</PublishReadyToRun>
 </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Amazon.Lambda.Core" Version="2.5.0" />
    <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="2.4.4" />
    <PackageReference Include="AWSSDK.S3" Version="3.7.305.23" />
  </ItemGroup>
</Project>

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

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.

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.

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

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" ]

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

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

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.

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.

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

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.

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

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

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.

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.