Abilitazione delle applicazioni su Lambda

Impostazione della struttura del progetto

Creazione di una directory per la funzione Lambda

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

Creazione di una struttura di progetto Maven

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

Creazione di un Dockerfile

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

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 progetto dovrebbe essere simile a questo: .

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

Creazione e implementazione dell'immagine di container

Impostazione delle 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 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, aggiungi tag e invia un'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

Creazione e configurazione della funzione Lambda

Crea una nuova funzione utilizzando la console Lambda.

Seleziona Immagine del container come opzione di implementazione.

Scegli Sfoglia immagini per selezionare la tua immagine Amazon ECR.

Test e verifiche: testa la tua Lambda con un semplice evento. Se l'integrazione del livello 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.

Impostazione della struttura del progetto

Creazione di una directory per l'immagine del container della funzione Lambda

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

Creazione di un Dockerfile

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

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 progetto dovrebbe essere simile a questo: .

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

Creazione e implementazione dell'immagine di container

Impostazione delle 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 codice Function.cs come segue:

Aggiorna il codice dotnet-lambda-function.csproj come segue:

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

Creazione e implementazione dell'immagine di container

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

Creazione di un repository Amazon ECR (se necessario)

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

Creazione, aggiunta di tag e invio di un'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

Creazione e configurazione della funzione Lambda

Crea una nuova funzione utilizzando la console Lambda.

Seleziona Immagine del container come opzione di implementazione.

Scegli Sfoglia immagini per selezionare la tua immagine Amazon ECR.

Test e verifiche: testa la tua Lambda con un semplice evento. Se l'integrazione del livello 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.

Impostazione della struttura del progetto

Creazione di una directory per l'immagine del container della funzione Lambda

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

Creazione di un Dockerfile

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

# 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 della funzione Lambda

Crea un file index.js con i seguenti contenuti:

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 progetto dovrebbe essere simile a questa:

.
├── Dockerfile
└── index.js

Creazione e implementazione dell'immagine di container

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

Creazione di un repository Amazon ECR (se necessario)

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

Creazione, aggiunta di tag e invio di un'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

Creazione e configurazione della funzione Lambda

Crea una nuova funzione utilizzando la console Lambda.

Seleziona Immagine del container come opzione di implementazione.

Scegli Sfoglia immagini per selezionare la tua immagine Amazon ECR.

Test e verifiche: testa la tua Lambda con un semplice evento. Se l'integrazione del livello 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.

Impostazione della struttura del progetto

Creazione di una directory per l'immagine del container della funzione Lambda

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

Creazione di un Dockerfile

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

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

Codice della funzione Lambda

Crea la funzione Lambda in un file 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)}'
            })
        }

La struttura del progetto dovrebbe essere simile a questa:

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

Creazione e implementazione dell'immagine di container

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

Creazione di un repository Amazon ECR (se necessario)

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

Creazione, aggiunta di tag e invio di un'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

Creazione e configurazione della funzione Lambda

Crea una nuova funzione utilizzando la console Lambda.

Seleziona Immagine del container come opzione di implementazione.

Scegli Sfoglia immagini per selezionare la tua immagine Amazon ECR.

Test e verifiche: testa la tua Lambda con un semplice evento. Se l'integrazione del livello 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.