Abilita le tue applicazioni su Lambda

Imposta la struttura del progetto

Crea una directory per la tua funzione Lambda

mkdir java-appsignals-container-lambda && \
cd java-appsignals-container-lambda

Crea una struttura di progetto Maven

mkdir -p src/main/java/com/example/java/lambda
mkdir -p src/main/resources

Crea Dockerfile

Scarica e integra il supporto OpenTelemetry Layer with Application Signals direttamente nell'immagine del tuo contenitore Lambda. A tale scopo, viene creato il Dockerfile file.

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

Codice funzione Lambda: crea un file Java per il tuo gestore Lambda all'indirizzo src/main/java/com/example/lambda/App.java:

Il tuo progetto dovrebbe assomigliare a:

.
├── Dockerfile
├── pom.xml
└── src
    └── main
        ├── java
        │   └── com
        │       └── example
        │           └── java
        │               └── lambda
        │                   └── App.java
        └── resources

Crea e distribuisci l'immagine del contenitore

Imposta le variabili di 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)

Autenticazione con ECR

Innanzitutto con l'ECR pubblico (per l'immagine di base):

aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws

Quindi con il tuo ECR privato:

aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com

Crea, tagga e pubblica la tua immagine

# 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

Creare e configurare la funzione Lambda

Crea una nuova funzione utilizzando la console Lambda.

Seleziona l'immagine del contenitore come opzione di distribuzione.

Scegli Browse images per selezionare la tua immagine Amazon ECR.

Test e verifiche: testa la tua Lambda con un semplice evento. Se l'integrazione dei livelli ha esito positivo, la Lambda viene visualizzata nella mappa dei servizi di Application Signals.

Vedrai tracce e metriche per la tua funzione Lambda nella CloudWatch console.

Imposta la struttura del progetto

Crea una directory per l'immagine del contenitore della funzione Lambda

mkdir dotnet-appsignals-container-lambda && \
cd dotnet-appsignals-container-lambda

Crea Dockerfile

Scarica e integra il supporto OpenTelemetry Layer with Application Signals direttamente nell'immagine del tuo contenitore Lambda. A tale scopo, viene creato il Dockerfile file.

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

Codice della funzione Lambda: inizializza il tuo progetto Lambda utilizzando il modello Lambda .NET: AWS

# 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

Il tuo progetto dovrebbe assomigliare a:

.
├── 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

Crea e distribuisci l'immagine del contenitore

Imposta le variabili di 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)

Aggiorna il Function.cs codice per:

Aggiorna il dotnet-lambda-function.csproj codice per:

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

Crea e distribuisci l'immagine del contenitore

Imposta le variabili di 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)

Autenticazione con Amazon ECR pubblico

aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws

Autenticazione con Amazon ECR privato

aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com

Crea un repository Amazon ECR (se necessario)

aws ecr create-repository \
    --repository-name lambda-appsignals-demo \
    --region $AWS_REGION

Crea, tagga e invia la tua immagine

# 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

Creare e configurare la funzione Lambda

Crea una nuova funzione utilizzando la console Lambda.

Seleziona l'immagine del contenitore come opzione di distribuzione.

Scegli Browse images per selezionare la tua immagine Amazon ECR.

Test e verifiche: testa la tua Lambda con un semplice evento. Se l'integrazione dei livelli ha esito positivo, la Lambda viene visualizzata nella mappa dei servizi di Application Signals.

Vedrai tracce e metriche per la tua funzione Lambda nella CloudWatch console.

Imposta la struttura del progetto

Crea una directory per l'immagine del contenitore della funzione Lambda

mkdir nodejs-appsignals-container-lambda &&\
cd nodejs-appsignals-container-lambda

Crea Dockerfile

Scarica e integra il supporto OpenTelemetry Layer with Application Signals direttamente nell'immagine del tuo contenitore Lambda. A tale scopo, viene creato il Dockerfile file.

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

Codice funzione Lambda

Crea un index.js file con il seguente contenuto:

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;
};

La struttura del tuo progetto dovrebbe assomigliare a questa:

.
├── Dockerfile
└── index.js

Crea e distribuisci l'immagine del contenitore

Imposta le variabili di 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)

Autenticazione con Amazon ECR pubblico

aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws

Autenticazione con Amazon ECR privato

aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com

Crea un repository Amazon ECR (se necessario)

aws ecr create-repository \
    --repository-name lambda-appsignals-demo \
    --region $AWS_REGION

Crea, tagga e invia la tua immagine

# 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

Creare e configurare la funzione Lambda

Crea una nuova funzione utilizzando la console Lambda.

Seleziona l'immagine del contenitore come opzione di distribuzione.

Scegli Browse images per selezionare la tua immagine Amazon ECR.

Test e verifiche: testa la tua Lambda con un semplice evento. Se l'integrazione dei livelli ha esito positivo, la Lambda viene visualizzata nella mappa dei servizi di Application Signals.

Vedrai tracce e metriche per la tua funzione Lambda nella CloudWatch console.

Imposta la struttura del progetto

Crea una directory per l'immagine del contenitore della funzione Lambda

mkdir python-appsignals-container-lambda &&\
cd python-appsignals-container-lambda

Crea Dockerfile

Scarica e integra il supporto OpenTelemetry Layer with Application Signals direttamente nell'immagine del tuo contenitore Lambda. A tale scopo, viene creato il Dockerfile file.

Codice funzione Lambda

Crea la tua funzione Lambda in un app.py file:

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)}'
            })
        }

La struttura del tuo progetto dovrebbe assomigliare a questa:

.
├── Dockerfile
├── app.py
└── instructions.md

Crea e distribuisci l'immagine del contenitore

Imposta le variabili di 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)

Autenticazione con Amazon ECR pubblico

aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws

Autenticazione con Amazon ECR privato

aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com

Crea un repository Amazon ECR (se necessario)

aws ecr create-repository \
    --repository-name lambda-appsignals-demo \
    --region $AWS_REGION

Crea, tagga e invia la tua immagine

# 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

Creare e configurare la funzione Lambda

Crea una nuova funzione utilizzando la console Lambda.

Seleziona l'immagine del contenitore come opzione di distribuzione.

Scegli Browse images per selezionare la tua immagine Amazon ECR.

Test e verifiche: testa la tua Lambda con un semplice evento. Se l'integrazione dei livelli ha esito positivo, la Lambda viene visualizzata nella mappa dei servizi di Application Signals.

Vedrai tracce e metriche per la tua funzione Lambda nella CloudWatch console.