Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Abilitazione delle applicazioni su Lambda È possibile abilitare Application Signals per le funzioni Lambda. Application Signals strumenta automaticamente le funzioni Lambda utilizzando le librerie AWS Distro for OpenTelemetry (ADOT) avanzate, fornite tramite un livello Lambda. Questo AWS Lambda Layer per OpenTelemetry pacchetti e distribuisce le librerie necessarie per la strumentazione automatica per Application Signals. Oltre a supportare Application Signals, questo layer Lambda è anche un componente del OpenTelemetry supporto Lambda e fornisce funzionalità di tracciamento. È possibile migliorare l'osservabilità di Lambda anche utilizzando la ricerca delle transazioni, che consente di acquisire intervalli di traccia per l'invocazione della funzione Lambda senza campionamento. Questa funzionalità consente di raccogliere intervalli per le funzioni, indipendentemente dal flag `sampled` nella propagazione del contesto di traccia. Ciò garantisce che non vi sia alcun impatto aggiuntivo sui servizi dipendenti a valle. Abilitando la ricerca delle transazioni su Lambda, ottieni una visibilità completa sulle prestazioni delle tue funzioni e puoi risolvere i problemi che si verificano raramente. Per iniziare, consulta [Transaction Search](CloudWatch-Transaction-Search.md) **Topics** + [Nozioni di base](#Application-Signals-Enable-Lambda-Methods-Getting-Started) + [Usa la console CloudWatch Application Signals](#Enable-Lambda-CWConsole) + [Utilizzo della console Lambda](#Enable-Lambda-LambdaConsole) + [Abilita Application Signals su Lambda utilizzando AWS CDK](#CloudWatch-Application-Signals-Lambda-CDK) + [Abilita i segnali applicativi su Lambda utilizzando il Model Context Protocol (MCP)](#CloudWatch-Application-Signals-Lambda-MCP) + [(Facoltativo) Monitoraggio dell'integrità delle applicazioni](#CloudWatch-Application-Signals-Monitor-Lambda) + [Abilita manualmente Application Signals.](#Enable-Lambda-Manually) + [Disabilitazione manuale di Application Signals](#Disable-Lambda-Manually) + [Configurazione di Application Signals](#Configuring-Lambda-AppSignals) + [AWS Lambda Layer per OpenTelemetry ARNs](#Enable-Lambda-Layers) + [Implementazione delle funzioni Lambda utilizzando il container Amazon ECR](#containerized-lambda) ## Nozioni di base Esistono tre metodi per abilitare Application Signals per le funzioni Lambda. Dopo aver abilitato Application Signals per una funzione Lambda, occorrono alcuni minuti prima che la telemetria di tale funzione venga visualizzata nella console Application Signals. + Usa la console Application Signals CloudWatch + Utilizzo della console Lambda + Aggiungi manualmente il AWS Lambda Layer per OpenTelemetry al runtime della funzione Lambda. Ciascuno di questi metodi aggiunge il AWS Lambda Layer for OpenTelemetry alla tua funzione. ## Usa la console CloudWatch Application Signals Segui questi passaggi per utilizzare la console Application Signals per abilitare Application Signals per una funzione Lambda. 1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Nel riquadro di navigazione, scegli **Application Signals**, **Servizi**. 1. Nell'area dell'elenco dei **Servizi**, scegli **Abilita Application Signals**. 1. Scegli il titolo **Lambda**. 1. Seleziona ogni funzione che desideri abilitare per Application Signals, quindi scegli **Fine**. ## Utilizzo della console Lambda Segui questi passaggi per utilizzare la console Lambda per abilitare Application Signals per una funzione Lambda. 1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Nel pannello di navigazione, scegli **Funzioni**, quindi scegli il nome della funzione che desideri abilitare. 1. Scegli la scheda **Configurazione** e quindi **Strumenti di monitoraggio e operazioni**. 1. Scegli **Modifica**. 1. Nella sezione **Segnali CloudWatch applicativi e raggi X**, seleziona sia **Raccogli automaticamente le tracce delle applicazioni e le metriche standard delle applicazioni con Application Signals** sia **Raccogli automaticamente le tracce del servizio Lambda per la visibilità end-to-end** con X-Ray. . 1. Scegli **Save** (Salva). ## Abilita Application Signals su Lambda utilizzando AWS CDK Se non hai ancora abilitato Application Signals in questo account, devi concedere ad Application Signals le autorizzazioni necessarie per scoprire i tuoi servizi. Per ulteriori informazioni, consulta [Abilitazione di Application Signals in un account](CloudWatch-Application-Signals-Enable.md). 1. Abilitazione di Application Signals per le applicazioni ``` import { aws_applicationsignals as applicationsignals } from 'aws-cdk-lib'; const cfnDiscovery = new applicationsignals.CfnDiscovery(this, 'ApplicationSignalsServiceRole', { } ); ``` La CloudFormation risorsa Discovery concede ad Application Signals le seguenti autorizzazioni: + `xray:GetServiceGraph` + `logs:StartQuery` + `logs:GetQueryResults` + `cloudwatch:GetMetricData` + `cloudwatch:ListMetrics` + `tag:GetResources` Per ulteriori informazioni su questo ruolo, consulta [Autorizzazioni di ruolo collegate al servizio per Application Signals CloudWatch](using-service-linked-roles.md#service-linked-role-signals). 1. Aggiungi la policy IAM `CloudWatchLambdaApplicationSignalsExecutionRolePolicy` alla funzione 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. Sostituisci `$AWS_LAMBDA_LAYER_FOR_OTEL_ARN` con l'attuale [AWS Lambda Layer for OpenTelemetry ARN](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) per la tua regione. ``` fn.addLayers(LayerVersion.fromLayerVersionArn( this, 'AwsLambdaLayerForOtel', '$AWS_LAMBDA_LAYER_FOR_OTEL_ARN' )) fn.addEnvironment("AWS_LAMBDA_EXEC_WRAPPER", "/opt/otel-instrument"); ``` ## Abilita i segnali applicativi su Lambda utilizzando il Model Context Protocol (MCP) Puoi utilizzare il server CloudWatch Application Signals Model Context Protocol (MCP) per abilitare Application Signals sulle tue funzioni Lambda tramite interazioni IA conversazionali. Ciò fornisce un'interfaccia in linguaggio naturale per configurare il monitoraggio di Application Signals. Il server MCP automatizza il processo di abilitazione comprendendo i requisiti dell'utente e generando la configurazione appropriata. Invece di seguire manualmente i passaggi della console o scrivere codice CDK, puoi semplicemente descrivere cosa vuoi abilitare. ### Prerequisiti Prima di utilizzare il server MCP per abilitare Application Signals, assicuratevi di avere: + Un ambiente di sviluppo che supporti MCP (come Kiro, Claude Desktop, VSCode con estensioni MCP o altri strumenti compatibili con MCP) + Il server MCP CloudWatch Application Signals configurato nel tuo IDE. Per istruzioni di configurazione dettagliate, consultate la documentazione del [server MCP di CloudWatch Application Signals](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server). ### Utilizzo del server MCP Dopo aver configurato il server MCP CloudWatch Application Signals nell'IDE, puoi richiedere indicazioni sull'abilitazione utilizzando istruzioni in linguaggio naturale. Sebbene l'assistente di codifica sia in grado di dedurre il contesto dalla struttura del progetto, fornire dettagli specifici nelle istruzioni aiuta a garantire una guida più accurata e pertinente. Includi informazioni come il linguaggio di programmazione della funzione Lambda, il nome della funzione e i percorsi assoluti del codice della funzione Lambda e del codice dell'infrastruttura. **Istruzioni sulle migliori pratiche (specifiche e complete):** ``` "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" ``` **Suggerimenti meno efficaci:** ``` "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 ``` **Modello rapido:** ``` "Enable Application Signals for my [LANGUAGE] Lambda function. Function code: [ABSOLUTE_PATH_TO_FUNCTION] IaC code: [ABSOLUTE_PATH_TO_IAC]" ``` ### Vantaggi dell'utilizzo del server MCP L'utilizzo del server MCP CloudWatch Application Signals offre diversi vantaggi: + **Interfaccia in linguaggio naturale:** descrivi cosa vuoi abilitare senza memorizzare comandi o sintassi di configurazione + **Guida sensibile al contesto:** il server MCP comprende l'ambiente specifico dell'utente e fornisce consigli personalizzati + **Errori ridotti:** la generazione automatizzata della configurazione riduce al minimo gli errori di digitazione manuale + **Configurazione più rapida:** passa più rapidamente dall'intenzione all'implementazione + **Strumento di apprendimento:** guarda le configurazioni generate e scopri come funziona Application Signals Per ulteriori informazioni sulla configurazione e l'utilizzo del server MCP CloudWatch Application Signals, consultate la documentazione del server [MCP](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server). ## (Facoltativo) Monitoraggio dell'integrità delle applicazioni Dopo aver abilitato le applicazioni su Lambda, è possibile monitorarne l'integrità. Per ulteriori informazioni, consulta [Monitoraggio dell'integrità operativa delle applicazioni con Application Signals](Services.md). ## Abilita manualmente Application Signals. Segui questi passaggi per abilitare manualmente Application Signals per una funzione Lambda. 1. Aggiungi il AWS Lambda Layer per OpenTelemetry al tuo runtime Lambda. Per trovare il layer ARN per la tua regione, consulta [ADOT Lambda Layer](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns). ARNs 1. Aggiunta della variabile di ambiente `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument` Aggiungi la variabile di ambiente `LAMBDA_APPLICATION_SIGNALS_REMOTE_ENVIRONMENT` per configurare ambienti Lambda personalizzati. Per impostazione predefinita, gli ambienti Lambda sono configurati per `lambda:default`. 1. Collega la policy IAM AWS gestita **CloudWatchLambdaApplicationSignalsExecutionRolePolicy**al ruolo di esecuzione Lambda. 1. (Facoltativo) Ti consigliamo di abilitare il tracciamento attivo Lambda per ottenere un'esperienza di tracciamento migliore. Per ulteriori informazioni, consulta [Visualizzare le chiamate alla funzione Lambda utilizzando](https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html). AWS X-Ray ## Disabilitazione manuale di Application Signals Per disabilitare manualmente Application Signals for a Lambda, rimuovi il AWS Lambda Layer for dal runtime Lambda e OpenTelemetry rimuovi la variabile di ambiente. `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument` ## Configurazione di Application Signals Puoi utilizzare questa sezione per configurare Application Signals in Lambda. **Raggruppamento di più funzioni Lambda in un unico servizio** La variabile di ambiente `OTEL_SERVICE_NAME` imposta il nome del servizio. Questo verrà visualizzato come nome del servizio per l'applicazione nei pannelli di controllo di Application Signals. Puoi assegnare lo stesso nome di servizio a più funzioni Lambda e queste verranno unite in un unico servizio in Application Signals. Se non si fornisce un valore per questa chiave, viene utilizzato il nome della funzione Lambda predefinito. **Campionamento** Per impostazione predefinita, la strategia di campionamento delle tracce è basata sui genitori. È possibile modificare la strategia di campionamento impostando le variabili di ambiente `OTEL_TRACES_SAMPLER`. Ad esempio, imposta la frequenza di campionamento delle tracce al 30%. ``` OTEL_TRACES_SAMPLER=traceidratio OTEL_TRACES_SAMPLER_ARG=0.3 ``` Per ulteriori informazioni, vedere [Specificazione delle variabili di OpenTelemetry ambiente](https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/). **Abilitazione di tutta l'instrumentazione della libreria** Per ridurre gli avvii a freddo di Lambda, per impostazione predefinita, solo la strumentazione AWS SDK e HTTP è abilitata per Python, Node e Java. Puoi impostare delle variabili di ambiente per abilitare l'instrumentazione per altre librerie utilizzate nella tua funzione Lambda. + Python: `OTEL_PYTHON_DISABLED_INSTRUMENTATIONS=none` + Node: `OTEL_NODE_DISABLED_INSTRUMENTATIONS=none` + Java: `OTEL_INSTRUMENTATION_COMMON_DEFAULT_ENABLED=true` ## AWS Lambda Layer per OpenTelemetry ARNs Per l'elenco completo di AWS Lambda Layer for per OpenTelemetry ARNs regione e runtime, consulta [ADOT Lambda ARNs Layer](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) nella AWS distribuzione per la documentazione. OpenTelemetry Il layer è disponibile per i runtime Python, Node.js, .NET e Java. ## Implementazione delle funzioni Lambda utilizzando il container Amazon ECR Le funzioni Lambda implementate come immagini di container non supportano i livelli Lambda nel modo tradizionale. Quando si utilizzano immagini di container, non è possibile collegare un livello come si farebbe con altri metodi di implementazione di Lambda. È invece necessario incorporare manualmente il contenuto del livello nell'immagine del container durante il processo di creazione. ------ #### [ Java ] Puoi imparare a integrare AWS Lambda Layer for OpenTelemetry nella tua funzione Java Lambda containerizzata, scaricare `layer.zip` l'artefatto e integrarlo nel contenitore di funzioni Java Lambda per abilitare il monitoraggio dei segnali applicativi. **Prerequisiti** + AWS CLI configurato con le tue credenziali + Docker installato + Queste istruzioni presuppongono l'utilizzo di una piattaforma x86\_64 1. **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 ``` 1. **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"] ``` **Nota** Il `layer.zip` file contiene la OpenTelemetry strumentazione necessaria per il supporto di AWS Application Signals per monitorare la funzione Lambda. Le fasi di estrazione del livello garantiscono: La corretta estrazione dei contenuti di layer.zip in `/opt/ directory` La ricezione delle autorizzazioni di esecuzioni appropriate da parte dello script `otel-instrument` La rimozione del file temporaneo layer.zip per ridurre le dimensioni dell'immagine 1. **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 ``` 1. **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 ``` 1. **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. 1. **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. **Risoluzione dei problemi** Se Application Signals non funziona, verifica gli aspetti seguenti: + Controlla i registri delle funzioni per eventuali errori relativi alla strumentazione OpenTelemetry + Verifica se la variabile di ambiente `AWS_LAMBDA_EXEC_WRAPPER` è impostata correttamente + Assicurati che l'estrazione del livello nel file Docker sia stata completata correttamente + Verifica se le autorizzazioni IAM sono collegate correttamente + Se necessario, aumenta le impostazioni di *Timeout e memoria* nella configurazione generale della funzione Lambda ------ #### [ .Net ] Puoi imparare come integrare il supporto OpenTelemetry Layer with Application Signals nella tua funzione.Net Lambda containerizzata, scaricare l'`layer.zip`artefatto e integrarlo nella funzione.Net Lambda per abilitare il monitoraggio degli Application Signals. **Prerequisiti** + AWS CLI configurato con le tue credenziali + Docker installato + SDK .Net 8 + Queste istruzioni presuppongono l'utilizzo di una piattaforma x86\_64 1. **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 ``` 1. **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"] ``` **Nota** Il `layer.zip` file contiene la OpenTelemetry strumentazione necessaria per il supporto di AWS Application Signals per monitorare la funzione Lambda. Le fasi di estrazione del livello garantiscono: La corretta estrazione dei contenuti di layer.zip in `/opt/ directory` La ricezione delle autorizzazioni di esecuzioni appropriate da parte dello script `otel-instrument` La rimozione del file temporaneo layer.zip per ridurre le dimensioni dell'immagine 1. **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 ``` 1. **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: ``` net8.0>/TargetFramework> enable enable true Lambda true true ``` 1. **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 ``` 1. **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. 1. **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. **Risoluzione dei problemi** Se Application Signals non funziona, verifica gli aspetti seguenti: + Controlla i registri delle funzioni per eventuali errori relativi alla strumentazione OpenTelemetry + Verifica se la variabile di ambiente `AWS_LAMBDA_EXEC_WRAPPER` è impostata correttamente + Assicurati che l'estrazione del livello nel file Docker sia stata completata correttamente + Verifica se le autorizzazioni IAM sono collegate correttamente + Se necessario, aumenta le impostazioni di *Timeout e memoria* nella configurazione generale della funzione Lambda ------ #### [ Node.js ] Puoi imparare come integrare il supporto OpenTelemetry Layer with Application Signals nella funzione Lambda Node.js containerizzata, scaricare l'`layer.zip`artefatto e integrarlo nella funzione Lambda Node.js per abilitare il monitoraggio di Application Signals. **Prerequisiti** + AWS CLI configurato con le tue credenziali + Docker installato + Queste istruzioni presuppongono l'utilizzo di una piattaforma x86\_64 1. **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 ``` 1. **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" ] ``` **Nota** Il `layer.zip` file contiene la OpenTelemetry strumentazione necessaria per il supporto di AWS Application Signals per monitorare la funzione Lambda. Le fasi di estrazione del livello garantiscono: La corretta estrazione dei contenuti di layer.zip in `/opt/ directory` La ricezione delle autorizzazioni di esecuzioni appropriate da parte dello script `otel-instrument` La rimozione del file temporaneo layer.zip per ridurre le dimensioni dell'immagine 1. **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 ``` 1. **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 ``` 1. **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. 1. **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. **Risoluzione dei problemi** Se Application Signals non funziona, verifica gli aspetti seguenti: + Controlla i registri delle funzioni per eventuali errori relativi alla strumentazione OpenTelemetry + Verifica se la variabile di ambiente `AWS_LAMBDA_EXEC_WRAPPER` è impostata correttamente + Assicurati che l'estrazione del livello nel file Docker sia stata completata correttamente + Verifica se le autorizzazioni IAM sono collegate correttamente + Se necessario, aumenta le impostazioni di *Timeout e memoria* nella configurazione generale della funzione Lambda ------ #### [ Python ] Puoi imparare come integrare il supporto OpenTelemetry Layer with Application Signals nella tua funzione Python Lambda containerizzata, scaricare l'`layer.zip`artefatto e integrarlo nella tua funzione Python Lambda per abilitare il monitoraggio di Application Signals. **Prerequisiti** + AWS CLI configurato con le tue credenziali + Docker installato + Queste istruzioni presuppongono l'utilizzo di una piattaforma x86\_64 1. **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 ``` 1. **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" ] ``` **Nota** Il `layer.zip` file contiene la OpenTelemetry strumentazione necessaria per il supporto di AWS Application Signals per monitorare la funzione Lambda. Le fasi di estrazione del livello garantiscono: La corretta estrazione dei contenuti di layer.zip in `/opt/ directory` La ricezione delle autorizzazioni di esecuzioni appropriate da parte dello script `otel-instrument` La rimozione del file temporaneo layer.zip per ridurre le dimensioni dell'immagine 1. **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 ``` 1. **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 ``` 1. **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. 1. **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. **Risoluzione dei problemi** Se Application Signals non funziona, verifica gli aspetti seguenti: + Controlla i registri delle funzioni per eventuali errori relativi alla strumentazione OpenTelemetry + Verifica se la variabile di ambiente `AWS_LAMBDA_EXEC_WRAPPER` è impostata correttamente + Assicurati che l'estrazione del livello nel file Docker sia stata completata correttamente + Verifica se le autorizzazioni IAM sono collegate correttamente + Se necessario, aumenta le impostazioni di *Timeout e memoria* nella configurazione generale della funzione Lambda ------