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à.
# Compilazione di funzioni Lambda con Java
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
com.amazonaws
aws-lambda-java-log4j2
1.5.1
software.amazon.lambda.durable
aws-durable-execution-sdk-java
1.0.1
```
------
**Importante**
Non utilizzare componenti privati dell'API JDK, come campi, metodi o classi di tipo privato. I componenti dell'API non pubblici possono cambiare o essere rimossi in qualsiasi aggiornamento e causare l'interruzione dell'applicazione.
**Per creare una funzione Java**
1. Aprire la [console Lambda](https://console.aws.amazon.com/lambda).
1. Scegli **Crea funzione**.
1. Configura le impostazioni seguenti:
+ **Nome della funzione**: inserisci il nome della funzione.
+ **Runtime**: scegli **Java 25**.
1. Scegli **Crea funzione**.
La console crea una funzione Lambda con una classe del gestore denominata `Hello`. Poiché Java è un linguaggio compilato, non è possibile visualizzare o modificare il codice sorgente nella console Lambda, ma è possibile modificarne la configurazione, invocarla e configurare i trigger.
**Nota**
Per iniziare a sviluppare applicazioni nel tuo ambiente locale, distribuisci una delle [applicazioni di esempio](java-samples.md) disponibili nell' GitHub archivio di questa guida.
La classe `Hello` ha una funzione denominata `handleRequest` che richiede un oggetto evento e un oggetto contesto. Questa è la [funzione del gestore](java-handler.md) chiamata da Lambda quando la funzione viene richiamata. Il runtime della funzione Lambda riceve gli eventi di chiamata da e li passa al gestore. Nella configurazione della funzione il valore del gestore è `example.Hello::handleRequest`.
Per aggiornare il codice di funzione, crea un pacchetto di distribuzione costituito da un archivio .zip contenente il codice di funzione. Man mano che lo sviluppo della tua funzione procede vorrai memorizzare il tuo codice di funzione nel controllo del codice sorgente, aggiungere le librerie e automatizzare le distribuzioni. Inizia [creando un pacchetto di distribuzione](java-package.md) e aggiornando il codice dalla riga di comando.
Il runtime della funzione passa un oggetto contesto al gestore, oltre all'evento di chiamata. L'[oggetto contesto](java-context.md) contiene ulteriori informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione. Altre informazioni sono disponibili con le variabili di ambiente.
La funzione Lambda include un gruppo di CloudWatch log Logs. Il runtime della funzione invia i dettagli su ogni chiamata a Logs. CloudWatch Si trasmette qualsiasi [log che la tua funzione emette](java-logging.md) durante la chiamata. Se la funzione restituisce un errore, Lambda formatta l'errore e lo restituisce al chiamante.
**Topics**
+ [Definire l'handler della funzione Lambda in Java](java-handler.md)
+ [Distribuisci funzioni Lambda per Java con archivi di file .zip o JAR](java-package.md)
+ [Distribuisci funzioni Java Lambda con immagini di container](java-image.md)
+ [Utilizzo dei livelli per le funzioni Lambda in Java](java-layers.md)
+ [Personalizzare la serializzazione per le funzioni Lambda Java](java-custom-serialization.md)
+ [Personalizzare il comportamento di avvio del runtime Java per le funzioni Lambda](java-customization.md)
+ [Utilizzo dell'oggetto di contesto Lambda per recuperare le informazioni sulla funzione Java](java-context.md)
+ [Registrare e monitorare funzioni Lambda in Java](java-logging.md)
+ [Strumentazione del codice Java in AWS Lambda](java-tracing.md)
+ [Esempi di applicazioni Java per AWS Lambda](java-samples.md)
# Definire l'handler della funzione Lambda in Java
└ build.gradle OR pom.xml
```
Puoi usare Maven o Gradle per creare il tuo progetto e gestire le dipendenze.
La logica principale del gestore per la funzione risiede in un file Java all'interno della directory. `src/main/java/example` In questo esempio viene assegnato un nome a questo file`OrderHandler.java`. Oltre a questo file, è possibile includere classi Java aggiuntive in base alle esigenze. Quando distribuisci la tua funzione in Lambda, assicurati di specificare la classe Java che contiene il metodo del gestore principale che Lambda deve invocare durante una chiamata.
## Esempio di codice della funzione Lambda
{
private static final S3Client S3_CLIENT = S3Client.builder().build();
/**
* Record to model the input event.
*/
public record Order(String orderId, double amount, String item) {}
@Override
public String handleRequest(Order event, Context context) {
try {
// Access environment variables
String bucketName = System.getenv("RECEIPT_BUCKET");
if (bucketName == null || bucketName.isEmpty()) {
throw new IllegalArgumentException("RECEIPT_BUCKET environment variable is not set");
}
// Create the receipt content and key destination
String receiptContent = String.format("OrderID: %s\nAmount: $%.2f\nItem: %s",
event.orderId(), event.amount(), event.item());
String key = "receipts/" + event.orderId() + ".txt";
// Upload the receipt to S3
uploadReceiptToS3(bucketName, key, receiptContent);
context.getLogger().log("Successfully processed order " + event.orderId() +
" and stored receipt in S3 bucket " + bucketName);
return "Success";
} catch (Exception e) {
context.getLogger().log("Failed to process order: " + e.getMessage());
throw new RuntimeException(e);
}
}
private void uploadReceiptToS3(String bucketName, String key, String receiptContent) {
try {
PutObjectRequest putObjectRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(key)
.build();
// Convert the receipt content to bytes and upload to S3
S3_CLIENT.putObject(putObjectRequest, RequestBody.fromBytes(receiptContent.getBytes(StandardCharsets.UTF_8)));
} catch (S3Exception e) {
throw new RuntimeException("Failed to upload receipt to S3: " + e.awsErrorDetails().errorMessage(), e);
}
}
}
```
Questo file `OrderHandler.java` contiene le sezioni seguenti:
+ `package example`: In Java, può essere qualsiasi cosa, ma deve corrispondere alla struttura di directory del progetto. Qui, lo usiamo `package example` perché la struttura delle cartelle è`src/main/java/example`.
+ `import`istruzioni: consente di importare le classi Java richieste dalla funzione Lambda.
+ `public class OrderHandler ...`: definisce la classe Java e deve essere una [definizione di classe valida](#java-handler-signatures).
+ `private static final S3Client S3_CLIENT ...`: Questo inizializza un client S3 al di fuori di qualsiasi metodo della classe. Questo fa sì che Lambda esegua questo codice durante la fase di [inizializzazione](lambda-runtime-environment.md#runtimes-lifecycle-ib).
+ block: definisce la forma dell'evento di input previsto in questa struttura Go.
+ `public String handleRequest(Order event, Context context)`: questo è il **metodo dell'handler principale**, che contiene la logica principale dell'applicazione.
+ `private void uploadReceiptToS3(...) {}`: questo è un metodo helper a cui fa riferimento il metodo dell'handler principale `handleRequest`.
### File build.gradle e pom.xml di esempio
4.0.0
com.example
example-java
jar
1.0-SNAPSHOT
example-java-function
UTF-8
21
21
com.amazonaws
aws-lambda-java-core
1.2.3
software.amazon.awssdk
s3
2.28.29
org.slf4j
slf4j-nop
2.0.16
maven-surefire-plugin
3.5.2
org.apache.maven.plugins
maven-shade-plugin
3.4.1
false
*:*
META-INF/*
META-INF/versions/**
package
shade
org.apache.maven.plugins
maven-compiler-plugin
3.13.0
21
```
------
Affinché questa funzione funzioni correttamente, il suo [ruolo di esecuzione](lambda-intro-execution-role.md) deve consentire l'`s3:PutObject`azione. Inoltre, assicuratevi di definire la variabile di `RECEIPT_BUCKET` ambiente. Dopo una chiamata riuscita, il bucket Amazon S3 dovrebbe contenere un file di ricevuta.
**Nota**
Questa funzione può richiedere impostazioni di configurazione aggiuntive per funzionare correttamente senza timeout. Si consiglia di configurare 256 MB di memoria e un timeout di 10 secondi. [La prima chiamata potrebbe richiedere più tempo a causa di un avvio a freddo.](lambda-runtime-environment.md#cold-start-latency) Le chiamate successive dovrebbero essere eseguite molto più velocemente grazie al riutilizzo dell'ambiente di esecuzione.
## Definizioni di classe valide per i gestori Java
` Il tipo di input è il `Order` record che definiamo all'interno della classe e il tipo di output è`String`.
```
public class OrderHandler implements RequestHandler {
...
}
```
Quando si utilizza questa interfaccia, il runtime Java deserializza l'evento in un oggetto con il tipo di input e serializza l'output in testo. Utilizzare questa interfaccia quando la serializzazione integrata funziona con i tipi di input e output.
Per utilizzare la propria serializzazione, implementare l'interfaccia `RequestStreamHandler`. Con questa interfaccia, Lambda passa al gestore un flusso di input e un flusso di output. Il gestore legge i byte dal flusso di input, scrive nel flusso di output e restituisce il valore void. Per un esempio di questo utilizzo del runtime Java 21, vedete [HandlerStream.java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic/src/main/java/example/HandlerStream.java).
Se lavori solo con tipi di base e generici (ad esempio `String` `Integer``List`, o`Map`) nella tua funzione Java, non è necessario implementare un'interfaccia. Ad esempio, se la funzione riceve un `Map` input e restituisce un`String`, la definizione della classe e la firma del gestore potrebbero essere simili alle seguenti:
```
public class ExampleHandler {
public String handleRequest(Map input, Context context) {
...
}
}
```
Inoltre, quando non implementate un'interfaccia, l'oggetto [context](java-context.md) è facoltativo. Ad esempio, la definizione della classe e la firma dell'handler potrebbero essere simili alle seguenti:
```
public class NoContextHandler {
public String handleRequest(Map input) {
...
}
}
```
## Convenzioni di denominazione dei gestori
. **— Ad esempio,`example.OrderHandler`.
Per le funzioni Lambda in Java che non implementano l'`RequestStreamHandler`interfaccia `RequestHandler` or, puoi usare qualsiasi nome per l'handler. Quando distribuisci la tua funzione in Lambda, specifica il gestore principale nella configurazione della funzione nel seguente formato:
+ **. **::** — Ad esempio,`example.Handler::mainHandler`.
## Definizione e accesso all'oggetto evento di input
`, `List`, `List`, e così via. – L'evento è un array JSON. Il runtime lo deserializza in un oggetto del tipo o dell'interfaccia specificati.
+ `InputStream`: l'evento è un tipo qualsiasi di JSON. Il runtime passa un flusso di byte del documento al gestore senza modifiche. Si deserializza l'output di input e scrittura in un flusso di output.
+ Tipo di libreria: per gli eventi inviati dai servizi AWS, utilizzare i tipi nella libreria [aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events). Ad esempio, se la tua funzione Lambda viene richiamata da Amazon Simple Queue Service (SQS), usa l'oggetto come input. `SQSEvent`
## Accesso e utilizzo dell'oggetto contestuale Lambda
` `pom.xml`
```
software.amazon.awssdk
s3
2.28.29
```
**Nota**
Questa potrebbe non essere la versione più recente dell'SDK. Scegli la versione dell'SDK appropriata per la tua applicazione.
Quindi, importa le dipendenze direttamente nella tua classe Java:
```
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;
```
Il codice di esempio inizializza quindi un client Amazon S3 come segue:
```
private static final S3Client S3_CLIENT = S3Client.builder().build();
```
In questo esempio, abbiamo inizializzato il nostro client Amazon S3 nella funzione per evitare di doverlo inizializzare ogni volta che richiamiamo la nostra funzione. Dopo aver configurato e inizializzato il client SDK, puoi utilizzarlo per interagire con altri servizi. AWS Il codice di esempio richiama l'`PutObject`API Amazon S3 nel modo seguente:
```
PutObjectRequest putObjectRequest = PutObjectRequest.builder()
.bucket(bucketName)
.key(key)
.build();
// Convert the receipt content to bytes and upload to S3
S3_CLIENT.putObject(putObjectRequest, RequestBody.fromBytes(receiptContent.getBytes(StandardCharsets.UTF_8)));
```
## Accesso alle variabili d'ambiente
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
com.amazonaws
aws-lambda-java-log4j2
1.5.1
software.amazon.lambda.durable
aws-durable-execution-sdk-java
1.0.1
```
------
Per creare un pacchetto di distribuzione, compila il codice della funzione e le dipendenze in un singolo file .zip o un file di archivio Java (JAR). Per Gradle, [utilizza il tipo di build `Zip`](#java-package-gradle). Per Apache Maven, [utilizza il plugin Maven Shade](#java-package-maven). Per caricare il pacchetto di distribuzione, usa la console Lambda, l'API Lambda o (). AWS Serverless Application Model AWS SAM
**Nota**
Per mantenere contenute le dimensioni del pacchetto di distribuzione, raggruppa le dipendenze della funzione in livelli. I livelli consentono di gestire le dipendenze in modo indipendente, possono essere utilizzate da più funzioni e possono essere condivisi con altri account. Per ulteriori informazioni, consulta [Gestione delle dipendenze Lambda con i livelli](chapter-layers.md).
## Creazione di un pacchetto di distribuzione con Gradle
org.apache.maven.plugins
maven-shade-plugin
3.2.2
false
package
shade
```
Per compilare il pacchetto di distribuzione, utilizzare il comando `mvn package`.
```
[INFO] Scanning for projects...
[INFO] -----------------------< com.example:java-maven >-----------------------
[INFO] Building java-maven-function 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
...
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ java-maven ---
[INFO] Building jar: target/java-maven-1.0-SNAPSHOT.jar
[INFO]
[INFO] --- maven-shade-plugin:3.2.2:shade (default) @ java-maven ---
[INFO] Including com.amazonaws:aws-lambda-java-core:jar:1.2.2 in the shaded jar.
[INFO] Including com.amazonaws:aws-lambda-java-events:jar:3.11.1 in the shaded jar.
[INFO] Including joda-time:joda-time:jar:2.6 in the shaded jar.
[INFO] Including com.google.code.gson:gson:jar:2.8.6 in the shaded jar.
[INFO] Replacing original artifact with shaded artifact.
[INFO] Replacing target/java-maven-1.0-SNAPSHOT.jar with target/java-maven-1.0-SNAPSHOT-shaded.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8.321 s
[INFO] Finished at: 2020-03-03T09:07:19Z
[INFO] ------------------------------------------------------------------------
```
Questo comando genera un file JAR nella directory `target`.
**Nota**
Se stai lavorando con un [JAR multi-rilascio (MRJAR)](https://openjdk.org/jeps/238), devi includere l'MRJAR (ossia il JAR shaded prodotto dal plug-in Maven Shade) nella directory `lib` e comprimerlo prima di caricare il pacchetto di implementazione in Lambda. In caso contrario, Lambda potrebbe non decomprimere correttamente il file JAR, facendo sì che il file `MANIFEST.MF` venga ignorato.
Se si utilizza la libreria appender (`aws-lambda-java-log4j2`), è necessario configurare anche un trasformatore per il plugin Maven Shade. La libreria del trasformatore combina le versioni di un file di cache presenti sia nella libreria appender che in Log4j.
**Example pom.xml: configurazione del plugin con l'appender Log4j 2**
```
org.apache.maven.plugins
maven-shade-plugin
3.2.2
false
package
shade
com.github.edwgiz
maven-shade-plugin.log4j2-cachefile-transformer
2.13.0
```
## Caricamento di un pacchetto di implementazione con la console Lambda
{
public String handleRequest(Object input, Context context) {
return "Hello world!";
}
}
```
1. Apri il file `build.gradle`. Se stai utilizzando il codice della funzione di esempio del passaggio precedente, sostituisci il contenuto di `build.gradle` con il seguente. Se utilizzi un codice di funzione personalizzato, modifica il file `build.gradle` secondo necessità.
**Example build.gradle (Groovy DSL)**
```
plugins {
id 'java'
}
group 'com.example'
version '1.0-SNAPSHOT'
sourceCompatibility = 1.8
repositories {
mavenCentral()
}
dependencies {
implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
}
jar {
manifest {
attributes 'Main-Class': 'com.example.App'
}
}
```
1. Il comando `gradle init` del passaggio 2 ha anche generato un caso di test fittizio nella directory `app/test`. Ai fini di questo tutorial, salta l'esecuzione dei test eliminando la directory `/test`.
1. Compilare il progetto.
```
gradle build
```
1. Nella directory root del progetto (`/example`), crea un Dockerfile con la seguente configurazione:
+ Imposta la proprietà `FROM` sull'[URI dell'immagine di base](https://gallery.ecr.aws/lambda/java).
+ Utilizza il comando COPY per copiare il codice della funzione e le dipendenze di runtime in `{LAMBDA_TASK_ROOT}`, una [variabile d'ambiente definita da Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Imposta l'argomento `CMD` specificando il gestore della funzione Lambda.
Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/java:21
# Copy function code and runtime dependencies from Gradle layout
COPY app/build/classes/java/main ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "com.example.App::handleRequest" ]
```
1. Crea l'immagine Docker con il comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). L'esempio seguente assegna un nome all'immagine `docker-image` e le assegna il [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Per rendere l'immagine compatibile con Lambda, è necessario utilizzare l'`--provenance=false`opzione.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Nota**
Il comando specifica l’opzione `--platform linux/amd64` per garantire che il container sia compatibile con l'ambiente di esecuzione di Lambda, indipendentemente dall'architettura della macchina di sviluppo. Se intendi creare una funzione Lambda utilizzando l'architettura del set di ARM64 istruzioni, assicurati di modificare il comando per utilizzare invece l'`--platform linux/arm64`opzione.
------
### (Facoltativo) Test dell'immagine in locale
` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.
```
docker tag docker-image:test :latest
```
Esempio:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Esegui il comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) per implementare la tua immagine locale sul repository Amazon ECR. Assicurati di includere `:latest` alla fine dell'URI del repository.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Crea un ruolo di esecuzione](lambda-intro-execution-role.md#permissions-executionrole-api) per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.
1. Creazione della funzione Lambda Per `ImageUri`, specifica l'URI del repository creato in precedenza. Assicurati di includere `:latest` alla fine dell'URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Nota**
È possibile creare una funzione utilizzando un'immagine in un AWS account diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta [Autorizzazioni multiaccount Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Richiama la funzione.
```
aws lambda invoke --function-name hello-world response.json
```
Dovresti ottenere una risposta simile a questa:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Per vedere l'output della funzione, controlla il file `response.json`.
Per aggiornare il codice della funzione, devi creare nuovamente l'immagine, caricare la nuova immagine nell'archivio Amazon ECR e quindi utilizzare il [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per distribuire l'immagine nella funzione Lambda.
Lambda risolve il tag dell'immagine in un digest di immagine specifico. Ciò significa che se punti il tag immagine utilizzato per implementare la funzione su una nuova immagine in Amazon ECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.
Per distribuire la nuova immagine nella stessa funzione Lambda, è necessario utilizzare [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)il comando, anche se il tag dell'immagine in Amazon ECR rimane lo stesso. Nell'esempio seguente, l'opzione `--publish` crea una nuova versione della funzione utilizzando l'immagine del container aggiornata.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime
com.amazonaws
aws-lambda-java-runtime-interface-client
2.3.2
```
Per i dettagli del pacchetto, consulta la pagina [Client di interfaccia di runtime AWS Lambda Java](https://mvnrepository.com/artifact/com.amazonaws/aws-lambda-java-runtime-interface-client) nel Maven Central Repository. È inoltre possibile esaminare il codice sorgente del client dell'interfaccia di runtime nel GitHub repository [AWS Lambda Java Support Libraries](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-runtime-interface-client).
L'esempio seguente dimostra come creare un'immagine di container per Java utilizzando un'[immagine Amazon Corretto](https://gallery.ecr.aws/amazoncorretto/amazoncorretto). Amazon Corretto è una distribuzione pronta per la produzione gratuita, con un ambiente multipiattaforma di Open Java Development Kit (OpenJDK). Il progetto Maven include il client di interfaccia di runtime come dipendenza.
### Prerequisiti
4.0.0
example
hello-lambda
jar
1.0-SNAPSHOT
hello-lambda
http://maven.apache.org
1.8
1.8
com.amazonaws
aws-lambda-java-runtime-interface-client
2.3.2
org.apache.maven.plugins
maven-dependency-plugin
3.1.2
copy-dependencies
package
copy-dependencies
```
1. Apri la directory `myapp/src/main/java/com/example/myapp` e cerca il file `App.java`. Questo è il codice per la funzione Lambda. Sostituisci il codice con il seguente.
**Example gestore della funzione**
```
package example;
public class App {
public static String sayHello() {
return "Hello world!";
}
}
```
1. Il comando `mvn -B archetype:generate` del passaggio 1 ha anche generato un test case fittizio nella directory `src/test`. Ai fini di questo tutorial, salta l'esecuzione dei test eliminando la directory `/test` generata interamente.
1. Torna alla directory principale del progetto e crea un nuovo Dockerfile. Il Dockerfile di esempio seguente utilizza un'[immagine Amazon Corretto](https://gallery.ecr.aws/amazoncorretto/amazoncorretto). Amazon Corretto è una distribuzione multi-piattaforma gratuita e pronta per la produzione di OpenJDK.
+ Imposta la proprietà `FROM` sull'URI dell'immagine di base.
+ Imposta l'`ENTRYPOINT` sul modulo su cui desideri che il container Docker venga eseguito all'avvio. In questo caso, il modulo è il client di interfaccia di runtime.
+ Imposta l'argomento `CMD` specificando il gestore della funzione Lambda.
Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.
**Example Dockerfile**
```
FROM public.ecr.aws/amazoncorretto/amazoncorretto:21 as base
# Configure the build environment
FROM base as build
RUN yum install -y maven
WORKDIR /src
# Cache and copy dependencies
ADD pom.xml .
RUN mvn dependency:go-offline dependency:copy-dependencies
# Compile the function
ADD . .
RUN mvn package
# Copy the function artifact and dependencies onto a clean base
FROM base
WORKDIR /function
COPY --from=build /src/target/dependency/*.jar ./
COPY --from=build /src/target/*.jar ./
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "/usr/bin/java", "-cp", "./*", "com.amazonaws.services.lambda.runtime.api.client.AWSLambda" ]
# Pass the name of the function handler as an argument to the runtime
CMD [ "example.App::sayHello" ]
```
1. Crea l'immagine Docker con il comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). L'esempio seguente assegna un nome all'immagine `docker-image` e le assegna il [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Per rendere l'immagine compatibile con Lambda, è necessario utilizzare l'`--provenance=false`opzione.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Nota**
Il comando specifica l’opzione `--platform linux/amd64` per garantire che il container sia compatibile con l'ambiente di esecuzione di Lambda, indipendentemente dall'architettura della macchina di sviluppo. Se intendi creare una funzione Lambda utilizzando l'architettura del set di ARM64 istruzioni, assicurati di modificare il comando per utilizzare invece l'`--platform linux/arm64`opzione.
### (Facoltativo) Test dell'immagine in locale
` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.
```
docker tag docker-image:test :latest
```
Esempio:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Esegui il comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) per implementare la tua immagine locale sul repository Amazon ECR. Assicurati di includere `:latest` alla fine dell'URI del repository.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Crea un ruolo di esecuzione](lambda-intro-execution-role.md#permissions-executionrole-api) per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.
1. Creazione della funzione Lambda Per `ImageUri`, specifica l'URI del repository creato in precedenza. Assicurati di includere `:latest` alla fine dell'URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Nota**
È possibile creare una funzione utilizzando un'immagine in un AWS account diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta [Autorizzazioni multiaccount Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Richiama la funzione.
```
aws lambda invoke --function-name hello-world response.json
```
Dovresti ottenere una risposta simile a questa:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Per vedere l'output della funzione, controlla il file `response.json`.
Per aggiornare il codice della funzione, devi creare nuovamente l'immagine, caricare la nuova immagine nell'archivio Amazon ECR e quindi utilizzare il [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per distribuire l'immagine nella funzione Lambda.
Lambda risolve il tag dell'immagine in un digest di immagine specifico. Ciò significa che se punti il tag immagine utilizzato per implementare la funzione su una nuova immagine in Amazon ECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.
Per distribuire la nuova immagine nella stessa funzione Lambda, è necessario utilizzare [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)il comando, anche se il tag dell'immagine in Amazon ECR rimane lo stesso. Nell'esempio seguente, l'opzione `--publish` crea una nuova versione della funzione utilizzando l'immagine del container aggiornata.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Utilizzo dei livelli per le funzioni Lambda in Java
` sezione utilizza il [maven-dependency-plugin](https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-dependency-plugin)per creare file JAR separati per ogni dipendenza invece di raggrupparli in un unico uber-jar. Se vuoi creare un uber-jar, usa il. [maven-shade-plugin](https://maven.apache.org/plugins/maven-shade-plugin/)
**Example pom.xml**
```
com.fasterxml.jackson.core
jackson-databind
2.17.0
org.apache.maven.plugins
maven-compiler-plugin
3.13.0
21
21
21
org.apache.maven.plugins
maven-dependency-plugin
3.6.1
copy-dependencies
package
copy-dependencies
${project.build.directory}/lib
```
1. Compilare il progetto. Questo comando crea tutti i file JAR di dipendenza nella directory. `target/lib/`
```
mvn clean package
```
1. Crea la struttura di directory richiesta per il tuo livello:
```
mkdir -p java/lib
```
1. Copia i file JAR delle dipendenze nella `java/lib` directory:
```
cp target/lib/*.jar java/lib/
```
1. Comprimi il contenuto del livello:
------
#### [ Linux/macOS ]
```
zip -r layer.zip java/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\java -DestinationPath .\layer.zip
```
------
La struttura delle cartelle del file.zip dovrebbe essere simile alla seguente:
```
java/
└── lib/
├── jackson-databind-2.17.0.jar
├── jackson-core-2.17.0.jar
└── jackson-annotations-2.17.0.jar
```
**Nota**
Assicurati che il tuo file.zip includa la `java` directory a livello principale al `lib` suo interno. Questa struttura assicura che Lambda possa localizzare e importare le tue librerie. Ogni dipendenza viene conservata come file JAR separato anziché raggruppata in un uber-jar.
## Crea il layer in Lambda
, Void>{
@Override
public Void handleRequest(Map event, Context context)
{
LambdaLogger logger = context.getLogger();
logger.log("EVENT TYPE: " + event.getClass());
return null;
}
}
```
La funzione registra il tipo di classe dell'evento in entrata prima di restituire `null`.
**Example Output log**
```
EVENT TYPE: class java.util.LinkedHashMap
```
L'interfaccia per l'oggetto contesto è disponibile nella libreria [aws-lambda-java-core](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-core). È possibile implementare questa interfaccia per creare una classe di contesto per il test. L'esempio seguente mostra una classe di contesto che restituisce valori fittizi per la maggior parte delle proprietà e un logger di test funzionante.
**Example [src/test/java/example/TestContext.java](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-basic/src/test/java/example/TestContext.java)**
```
package example;
import [com.amazonaws.services.lambda.runtime.Context](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/Context.java);
import [com.amazonaws.services.lambda.runtime.CognitoIdentity](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/CognitoIdentity.java);
import [com.amazonaws.services.lambda.runtime.ClientContext](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/ClientContext.java);
import [com.amazonaws.services.lambda.runtime.LambdaLogger](https://github.com/aws/aws-lambda-java-libs/blob/master/aws-lambda-java-core/src/main/java/com/amazonaws/services/lambda/runtime/LambdaLogger.java);
public class TestContext implements Context{
public TestContext() {}
public String getAwsRequestId(){
return new String("495b12a8-xmpl-4eca-8168-160484189f99");
}
public String getLogGroupName(){
return new String("/aws/lambda/my-function");
}
public String getLogStreamName(){
return new String("2020/02/26/[$LATEST]704f8dxmpla04097b9134246b8438f1a");
}
public String getFunctionName(){
return new String("my-function");
}
public String getFunctionVersion(){
return new String("$LATEST");
}
public String getInvokedFunctionArn(){
return new String("arn:aws:lambda:us-east-2:123456789012:function:my-function");
}
public CognitoIdentity getIdentity(){
return null;
}
public ClientContext getClientContext(){
return null;
}
public int getRemainingTimeInMillis(){
return 300000;
}
public int getMemoryLimitInMB(){
return 512;
}
public LambdaLogger getLogger(){
return new TestLogger();
}
}
```
Per ulteriori informazioni sulla registrazione, consulta [Registrare e monitorare funzioni Lambda in Java](java-logging.md).
## Contesto nelle applicazioni di esempio
{
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public String handleRequest(Object event, Context context)
{
LambdaLogger logger = context.getLogger();
String response = new String("SUCCESS");
// log execution details
logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
logger.log("CONTEXT: " + gson.toJson(context));
// process event
logger.log("EVENT: " + gson.toJson(event));
return response;
}
}
```
**Example Formato dei log**
```
START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST
ENVIRONMENT VARIABLES:
{
"_HANDLER": "example.Handler",
"AWS_EXECUTION_ENV": "AWS_Lambda_java8",
"AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
...
}
CONTEXT:
{
"memoryLimit": 512,
"awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
"functionName": "java-console",
...
}
EVENT:
{
"records": [
{
"messageId": "19dd0b57-xmpl-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
...
}
]
}
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Duration: 198.50 ms Billed Duration: 724 ms Memory Size: 512 MB Max Memory Used: 90 MB Init Duration: 524.75 ms
```
Il runtime di Java registra `START`, `END` e `REPORT` per ogni chiamata. La riga del report fornisce i seguenti dettagli:
**Campi dati della riga REPORT**
+ **RequestId**— L'ID univoco della richiesta per la chiamata.
+ **Durata** – La quantità di tempo che il metodo del gestore della funzione impiega durante l'elaborazione dell'evento.
+ **Durata fatturata** – La quantità di tempo fatturata per la chiamata.
+ **Dimensioni memoria** – La quantità di memoria allocata per la funzione.
+ **Quantità max utilizzata** – La quantità di memoria utilizzata dalla funzione. Quando le invocazioni condividono un ambiente di esecuzione, Lambda riporta la memoria massima utilizzata in tutte le invocazioni. Questo comportamento potrebbe comportare un valore riportato superiore al previsto.
+ **Durata Init** – Per la prima richiesta servita, la quantità di tempo impiegato dal runtime per caricare la funzione ed eseguire il codice al di fuori del metodo del gestore.
+ **XRAY TraceId** [— Per le richieste tracciate, l'ID di traccia.AWS X-Ray](services-xray.md)
+ **SegmentId**— Per le richieste tracciate, l'ID del segmento X-Ray.
+ **Campionato** – Per le richieste tracciate, il risultato del campionamento.
## Utilizzo dei controlli di registrazione avanzati di Lambda con Java
%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n
```
Puoi decidere di configurare gli output dei log di Log4j2 in testo normale o JSON specificando un layout sotto i tag `` e ``.
Con questa configurazione, in modalità di testo, ogni riga è preceduta da data, ora, ID richiesta, livello di log e nome della classe. In modalità JSON, viene utilizzato `` con una configurazione fornita insieme alla libreria `aws-lambda-java-log4j2`.
SLF4J è una libreria di facciate per la registrazione del codice Java. Nel codice della funzione, si utilizza SLF4 J logger factory per recuperare un logger con metodi per i livelli di registro come e. `info()` `warn()` Nella configurazione di build, includi la libreria di registrazione e l'adattatore SLF4 J nel classpath. Modificando le librerie nella configurazione di build, è possibile modificare il tipo di logger senza modificare il codice della funzione. SLF4J è necessario per acquisire i log dall'SDK for Java.
Nel codice di esempio seguente, la classe handler utilizza SLF4 J per recuperare un logger.
**Example [src/main/java/example/HandlerS3.java — Registrazione](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/java-events/src/main/java/example/HandlerS3.java) con J SLF4**
```
package example;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
import static org.apache.logging.log4j.CloseableThreadContext.put;
public class HandlerS3 implements RequestHandler{
private static final Logger logger = LoggerFactory.getLogger(HandlerS3.class);
@Override
public String handleRequest(S3Event event, Context context) {
for(var record : event.getRecords()) {
try (var loggingCtx = put("awsRegion", record.getAwsRegion())) {
loggingCtx.put("eventName", record.getEventName());
loggingCtx.put("bucket", record.getS3().getBucket().getName());
loggingCtx.put("key", record.getS3().getObject().getKey());
logger.info("Handling s3 event");
}
}
return "Ok";
}
}
```
Questo codice genera output log simili al seguente:
**Example Formato dei log**
```
{
"timestamp": "2023-11-15T16:56:00.815Z",
"level": "INFO",
"message": "Handling s3 event",
"logger": "example.HandlerS3",
"AWSRequestId": "0bced576-3936-4e5a-9dcd-db9477b77f97",
"awsRegion": "eu-south-1",
"bucket": "java-logging-test-input-bucket",
"eventName": "ObjectCreated:Put",
"key": "test-folder/"
}
```
La configurazione di build richiede le dipendenze di runtime dall'appender Lambda e dall'adattatore J SLF4 e le dipendenze di implementazione su Log4j2.
**Example build.gradle – Registrazione delle dipendenze**
```
dependencies {
...
'com.amazonaws:aws-lambda-java-log4j2:[1.6.0,)',
'com.amazonaws:aws-lambda-java-events:[3.11.3,)',
'org.apache.logging.log4j:log4j-layout-template-json:[2.17.1,)',
'org.apache.logging.log4j:log4j-slf4j2-impl:[2.19.0,)',
...
}
```
Quando esegui localmente il codice per i test, l'oggetto contestuale con il logger Lambda non è disponibile e non esiste alcun ID richiesta che possa essere utilizzato dall'appender Lambda. Per configurazioni di test di esempio, consulta le applicazioni di esempio nella sezione successiva.
## Utilizzo di altri strumenti di registrazione e librerie
```
In caso di esito positivo, vedrai questa risposta:
```
{"message":"hello world"}
```
1. Per ottenere i log per la funzione, esegui [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Per ulteriori informazioni, consulta l'argomento relativo all'[utilizzo dei log](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) nella *Guida per sviluppatori AWS Serverless Application Model *.
```
sam logs --stack-name sam-app
```
L'output del log ha la struttura seguente:
```
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.095000 INIT_START Runtime Version: java:11.v15 Runtime Version ARN: arn:aws:lambda:eu-central-1::runtime:0a25e3e7a1cc9ce404bc435eeb2ad358d8fa64338e618d0c224fe509403583ca
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.114000 Picked up JAVA_TOOL_OPTIONS: -XX:+TieredCompilation -XX:TieredStopAtLevel=1
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.793000 Transforming org/apache/logging/log4j/core/lookup/JndiLookup (lambdainternal.CustomerClassLoader@1a6c5a9e)
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:35.252000 START RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765 Version: $LATEST
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.531000 {
"_aws": {
"Timestamp": 1675416276051,
"CloudWatchMetrics": [
{
"Namespace": "sam-app-powerools-java",
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
],
"Dimensions": [
[
"Service",
"FunctionName"
]
]
}
]
},
"function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
"traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
"FunctionName": "sam-app-HelloWorldFunction-y9Iu1FLJJBGD",
"functionVersion": "$LATEST",
"ColdStart": 1.0,
"Service": "service_undefined",
"logStreamId": "2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
"executionEnvironment": "AWS_Lambda_java11"
}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.974000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.AWSXRayRecorder
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.config.DaemonConfiguration
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 INFO: Environment variable AWS_XRAY_DAEMON_ADDRESS is set. Emitting to daemon on address XXXX.XXXX.XXXX.XXXX:2000.
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.331000 09:24:37.294 [main] INFO helloworld.App - {"version":null,"resource":"/hello","path":"/hello/","httpMethod":"GET","headers":{"Accept":"*/*","CloudFront-Forwarded-Proto":"https","CloudFront-Is-Desktop-Viewer":"true","CloudFront-Is-Mobile-Viewer":"false","CloudFront-Is-SmartTV-Viewer":"false","CloudFront-Is-Tablet-Viewer":"false","CloudFront-Viewer-ASN":"16509","CloudFront-Viewer-Country":"IE","Host":"XXXX.execute-api.eu-central-1.amazonaws.com","User-Agent":"curl/7.86.0","Via":"2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)","X-Amz-Cf-Id":"t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q==","X-Amzn-Trace-Id":"Root=1-63dcd2d1-25f90b9d1c753a783547f4dd","X-Forwarded-For":"XX.XXX.XXX.XX, XX.XXX.XXX.XX","X-Forwarded-Port":"443","X-Forwarded-Proto":"https"},"multiValueHeaders":{"Accept":["*/*"],"CloudFront-Forwarded-Proto":["https"],"CloudFront-Is-Desktop-Viewer":["true"],"CloudFront-Is-Mobile-Viewer":["false"],"CloudFront-Is-SmartTV-Viewer":["false"],"CloudFront-Is-Tablet-Viewer":["false"],"CloudFront-Viewer-ASN":["16509"],"CloudFront-Viewer-Country":["IE"],"Host":["XXXX.execute-api.eu-central-1.amazonaws.com"],"User-Agent":["curl/7.86.0"],"Via":["2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)"],"X-Amz-Cf-Id":["t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q=="],"X-Amzn-Trace-Id":["Root=1-63dcd2d1-25f90b9d1c753a783547f4dd"],"X-Forwarded-For":["XXX, XXX"],"X-Forwarded-Port":["443"],"X-Forwarded-Proto":["https"]},"queryStringParameters":null,"multiValueQueryStringParameters":null,"pathParameters":null,"stageVariables":null,"requestContext":{"accountId":"XXX","stage":"Prod","resourceId":"at73a1","requestId":"ba09ecd2-acf3-40f6-89af-fad32df67597","operationName":null,"identity":{"cognitoIdentityPoolId":null,"accountId":null,"cognitoIdentityId":null,"caller":null,"apiKey":null,"principalOrgId":null,"sourceIp":"54.240.197.236","cognitoAuthenticationType":null,"cognitoAuthenticationProvider":null,"userArn":null,"userAgent":"curl/7.86.0","user":null,"accessKey":null},"resourcePath":"/hello","httpMethod":"GET","apiId":"XXX","path":"/Prod/hello/","authorizer":null},"body":null,"isBase64Encoded":false}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.351000 09:24:37.351 [main] INFO helloworld.App - Retrieving https://checkip.amazonaws.com
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.313000 {
"function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
"traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
"xray_trace_id": "1-63dcd2d1-25f90b9d1c753a783547f4dd",
"functionVersion": "$LATEST",
"Service": "service_undefined",
"logStreamId": "2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
"executionEnvironment": "AWS_Lambda_java11"
}
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 END RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765
2025/09/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 REPORT RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765 Duration: 4118.98 ms Billed Duration: 5275 ms Memory Size: 512 MB Max Memory Used: 152 MB Init Duration: 1155.47 ms
XRAY TraceId: 1-63dcd2d1-25f90b9d1c753a783547f4dd SegmentId: 3a028fee19b895cb Sampled: true
```
1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
```
sam delete
```
### Gestione della conservazione dei log
```
In caso di esito positivo, vedrai questa risposta:
```
{"message":"hello world"}
```
1. Per ottenere le tracce per la funzione, esegui [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
L'output della traccia ha il seguente aspetto:
```
New XRay Service Graph
Start time: 2025-02-03 14:31:48+01:00
End time: 2025-02-03 14:31:48+01:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-y9Iu1FLJJBGD - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 5.587
Reference Id: 1 - client - sam-app-HelloWorldFunction-y9Iu1FLJJBGD - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 3] at (2025-02-03T14:31:48.500000) with id (1-63dd0cc4-3c869dec72a586875da39777) and duration (5.603s)
- 5.587s - sam-app-HelloWorldFunction-y9Iu1FLJJBGD [HTTP: 200]
- 4.053s - sam-app-HelloWorldFunction-y9Iu1FLJJBGD
- 1.181s - Initialization
- 4.037s - Invocation
- 1.981s - ## handleRequest
- 1.840s - ## getPageContents
- 0.000s - Overhead
```
1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
```
sam delete
```
## Utilizzo di Powertools per AWS Lambda (Java) e AWS CDK per il tracciamento
4.0.0
helloworld
Function
jar
1.0-SNAPSHOT
Function
http://maven.apache.org
11
11
2.17.2
junit
junit
3.8.1
test
software.amazon.lambda
powertools-tracing
1.3.0
software.amazon.lambda
powertools-metrics
1.3.0
software.amazon.lambda
powertools-logging
1.3.0
com.amazonaws
aws-lambda-java-core
1.2.2
com.amazonaws
aws-lambda-java-events
3.11.1
org.codehaus.mojo
aspectj-maven-plugin
1.14.0
${maven.compiler.source}
${maven.compiler.target}
${maven.compiler.target}
software.amazon.lambda
powertools-tracing
software.amazon.lambda
powertools-metrics
software.amazon.lambda
powertools-logging
compile
org.apache.maven.plugins
maven-shade-plugin
3.4.1
package
shade
false
function
com.github.edwgiz
maven-shade-plugin.log4j2-cachefile-transformer
2.15
```
1. Crea la directory `hello-world\app\src\main\resource` e crea `log4j.xml` per la configurazione del log.
```
mkdir -p src/main/resource
cd src/main/resource
touch log4j.xml
```
1. Apri `log4j.xml` e aggiungi il seguente codice.
```
```
1. Apri `App.java` dalla directory `hello-world\app\Function\src\main\java\helloworld` e sostituisci il codice esistente con il codice seguente. Questo è il codice per la funzione Lambda.
```
package helloworld;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import software.amazon.lambda.powertools.logging.Logging;
import software.amazon.lambda.powertools.metrics.Metrics;
import software.amazon.lambda.powertools.tracing.CaptureMode;
import software.amazon.lambda.powertools.tracing.Tracing;
import static software.amazon.lambda.powertools.tracing.CaptureMode.*;
/**
* Handler for requests to Lambda function.
*/
public class App implements RequestHandler {
Logger log = LogManager.getLogger(App.class);
@Logging(logEvent = true)
@Tracing(captureMode = DISABLED)
@Metrics(captureColdStart = true)
public APIGatewayProxyResponseEvent handleRequest(final APIGatewayProxyRequestEvent input, final Context context) {
Map headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("X-Custom-Header", "application/json");
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent()
.withHeaders(headers);
try {
final String pageContents = this.getPageContents("https://checkip.amazonaws.com");
String output = String.format("{ \"message\": \"hello world\", \"location\": \"%s\" }", pageContents);
return response
.withStatusCode(200)
.withBody(output);
} catch (IOException e) {
return response
.withBody("{}")
.withStatusCode(500);
}
}
@Tracing(namespace = "getPageContents")
private String getPageContents(String address) throws IOException {
log.info("Retrieving {}", address);
URL url = new URL(address);
try (BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()))) {
return br.lines().collect(Collectors.joining(System.lineSeparator()));
}
}
}
```
1. Apri `HelloWorldStack.java` dalla directory `hello-world\src\main\java\com\myorg` e sostituisci il codice esistente con il codice seguente. Questo codice utilizza [Lambda Constructor](https://docs.aws.amazon.com/cdk/api/v1/java/aws_cdk.aws_lambda.html) e [ApiGatewayv2 Constructor](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigatewayv2-readme.html) per creare un'API REST e una funzione Lambda.
```
package com.myorg;
import software.amazon.awscdk.*;
import software.amazon.awscdk.services.apigatewayv2.alpha.*;
import software.amazon.awscdk.services.apigatewayv2.integrations.alpha.HttpLambdaIntegration;
import software.amazon.awscdk.services.apigatewayv2.integrations.alpha.HttpLambdaIntegrationProps;
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.FunctionProps;
import software.amazon.awscdk.services.lambda.Runtime;
import software.amazon.awscdk.services.lambda.Tracing;
import software.amazon.awscdk.services.logs.RetentionDays;
import software.amazon.awscdk.services.s3.assets.AssetOptions;
import software.constructs.Construct;
import java.util.Arrays;
import java.util.List;
import static java.util.Collections.singletonList;
import static software.amazon.awscdk.BundlingOutput.ARCHIVED;
public class HelloWorldStack extends Stack {
public HelloWorldStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloWorldStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
List functionPackagingInstructions = Arrays.asList(
"/bin/sh",
"-c",
"cd Function " +
"&& mvn clean install " +
"&& cp /asset-input/Function/target/function.jar /asset-output/"
);
BundlingOptions.Builder builderOptions = BundlingOptions.builder()
.command(functionPackagingInstructions)
.image(Runtime.JAVA_11.getBundlingImage())
.volumes(singletonList(
// Mount local .m2 repo to avoid download all the dependencies again inside the container
DockerVolume.builder()
.hostPath(System.getProperty("user.home") + "/.m2/")
.containerPath("/root/.m2/")
.build()
))
.user("root")
.outputType(ARCHIVED);
Function function = new Function(this, "Function", FunctionProps.builder()
.runtime(Runtime.JAVA_11)
.code(Code.fromAsset("app", AssetOptions.builder()
.bundling(builderOptions
.command(functionPackagingInstructions)
.build())
.build()))
.handler("helloworld.App::handleRequest")
.memorySize(1024)
.tracing(Tracing.ACTIVE)
.timeout(Duration.seconds(10))
.logRetention(RetentionDays.ONE_WEEK)
.build());
HttpApi httpApi = new HttpApi(this, "sample-api", HttpApiProps.builder()
.apiName("sample-api")
.build());
httpApi.addRoutes(AddRoutesOptions.builder()
.path("/")
.methods(singletonList(HttpMethod.GET))
.integration(new HttpLambdaIntegration("function", function, HttpLambdaIntegrationProps.builder()
.payloadFormatVersion(PayloadFormatVersion.VERSION_2_0)
.build()))
.build());
new CfnOutput(this, "HttpApi", CfnOutputProps.builder()
.description("Url for Http Api")
.value(httpApi.getApiEndpoint())
.build());
}
}
```
1. Apri `pom.xml` dalla directory `hello-world` e sostituisci il codice esistente con il codice seguente.
```
4.0.0
com.myorg
hello-world
0.1
UTF-8
2.70.0
[10.0.0,11.0.0)
5.7.1
org.apache.maven.plugins
maven-compiler-plugin
3.8.1
1.8
1.8
org.codehaus.mojo
exec-maven-plugin
3.0.0
com.myorg.HelloWorldApp
software.amazon.awscdk
aws-cdk-lib
${cdk.version}
software.constructs
constructs
${constructs.version}
org.junit.jupiter
junit-jupiter
${junit.version}
test
software.amazon.awscdk
apigatewayv2-alpha
${cdk.version}-alpha.0
software.amazon.awscdk
apigatewayv2-integrations-alpha
${cdk.version}-alpha.0
```
1. Assicurati di essere nella directory `hello-world` e implementa l'applicazione.
```
cdk deploy
```
1. Ottieni l'URL dell'applicazione implementata:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`HttpApi`].OutputValue' --output text
```
1. Richiama l'endpoint dell'API:
```
curl -X GET
```
In caso di esito positivo, vedrai questa risposta:
```
{"message":"hello world"}
```
1. Per ottenere le tracce per la funzione, esegui [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
L'output della traccia ha il seguente aspetto:
```
New XRay Service Graph
Start time: 2025-02-03 14:59:50+00:00
End time: 2025-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2025-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Questo è un endpoint API pubblico accessibile su Internet. È consigliabile eliminare l'endpoint dopo il test.
```
cdk destroy
```
## Utilizzo di ADOT per strumentare le funzioni Java