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à.
# Riscalda i client SDK nel AWS SDK for Java 2.x
Usa l'`SdkWarmUp`utilità in dotazione AWS SDK for Java 2.x per riscaldare i tuoi client SDK durante l'inizializzazione dell'applicazione. Ciò riduce la latenza della prima richiesta gestita dall'applicazione dopo l'avvio o il ripristino.
Un riscaldamento esercita il percorso di richiesta dell'SDK (creazione di un client e richiamo di un'operazione) prima che l'applicazione gestisca il traffico reale. Lo usi con funzionalità di checkpoint e ripristino come Lambda. [ SnapStart ](https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html) Queste funzionalità scattano un'istantanea dell'applicazione inizializzata, quindi eseguono il ripristino da tale istantanea per ridurre la latenza di avvio a freddo.
In caso contrario`SdkWarmUp`, è necessario scrivere il proprio codice di riscaldamento prima di ogni checkpoint, il che è complicato. Con`SdkWarmUp`, fai una sola chiamata per scaldare tutti i tuoi clienti. Puoi riscaldare tutti i client SDK sul tuo classpath o solo i client specifici utilizzati dalla tua applicazione.
In questo argomento, imparerai a configurare e utilizzare con e. `SdkWarmUp` CRaC AWS Lambda SnapStart Per ulteriori informazioni su altre tecniche che riducono i tempi di avvio su Lambda, consulta[Riduci i tempi di avvio dell'SDK per AWS Lambda](lambda-optimize-starttime.md).
## L' SdkWarmUp API
`SdkWarmUp`fa parte del `sdk-core` modulo, quindi è disponibile per tutti i client di servizio senza una dipendenza aggiuntiva. Configura il tuo progetto per utilizzare la versione 2.54.0 o successiva di. AWS SDK for Java 2.x Chiamate quindi uno dei due metodi statici descritti nelle sezioni seguenti. Quando chiami uno dei due metodi, `SdkWarmUp` effettua una chiamata di rete per riscaldare il client HTTP. Per riscaldare il client di servizio, utilizza una risposta locale predefinita. Non richiede AWS credenziali o autorizzazioni IAM e non comporta costi. AWS
### Riscalda tutti i client SDK sul classpath
Il `warmUp()` metodo rileva tutti i client del servizio SDK sul classpath e riscalda ciascuno di essi, insieme ai client HTTP che utilizzano. Utilizzate questo metodo quando dipendete da un numero limitato di moduli di servizio e chiamate la maggior parte dei client che forniscono. Il seguente esempio di Java codice chiama `warmUp()` senza argomenti:
```
import software.amazon.awssdk.core.warmup.SdkWarmUp;
SdkWarmUp.warmUp();
```
Questo metodo viene eseguito al massimo una volta per JVM. Dopo una chiamata riuscita, le chiamate successive vengono restituite immediatamente.
### Riscalda client SDK specifici
Il `warmUp(Class... clients)` metodo riscalda solo i client nominati. Passa una classe client sincrona per riscaldare il percorso sincrono o una classe client asincrono per riscaldare il percorso asincrono.
Utilizzate questo metodo quando il classpath contiene più client di servizio rispetto alle chiamate dell'applicazione. Ad esempio, ciò accade quando una dipendenza introduce moduli di servizio che non utilizzi. Assegnando un nome solo ai client necessari, il tempo di riscaldamento è proporzionale all'utilizzo effettivo dell'applicazione anziché al percorso di classe completo. Il seguente esempio di Java codice riscalda solo le classi e: `S3Client` `DynamoDbClient`
```
import software.amazon.awssdk.core.warmup.SdkWarmUp;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
SdkWarmUp.warmUp(S3Client.class, DynamoDbClient.class);
```
## Usare SdkWarmUp con Lambda SnapStart
[AWS Lambda SnapStart](https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html)migliora le prestazioni di avvio delle Java funzioni. Quando si pubblica una nuova versione di una funzione, Lambda la SnapStart inizializza e scatta un'istantanea della memoria e dello stato del disco. Quindi memorizza nella cache l'istantanea per il riutilizzo. Per informazioni sui runtime supportati e su come attivare la tua funzione, consulta la Guida SnapStart per gli sviluppatori. *AWS Lambda *
Poiché Lambda scatta l'istantanea dopo l'esecuzione del costruttore del gestore, chiama il costruttore. `SdkWarmUp.warmUp()` L'istantanea include quindi i client riscaldati e ogni chiamata che viene ripristinata dall'istantanea beneficia del riscaldamento. Il seguente esempio di Java codice chiama un costruttore di gestori Lambda: `SdkWarmUp.warmUp()`
```
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import software.amazon.awssdk.core.warmup.SdkWarmUp;
public class MyHandler implements RequestHandler {
public MyHandler() {
SdkWarmUp.warmUp();
// Your other initialization here.
}
@Override
public String handleRequest(String input, Context context) {
// Your handler logic here.
}
}
```
Se la tua funzione deve eseguire codice personalizzato prima che Lambda scatti l'istantanea o dopo il ripristino, implementa gli hook di runtime. SnapStart Per ulteriori informazioni, consulta [ SnapStart runtime hooks for Java ](https://docs.aws.amazon.com/lambda/latest/dg/snapstart-runtime-hooks-java.html) nella Developer Guide. *AWS Lambda *
## Da usare SdkWarmUp con cRAC standalone
È inoltre possibile CRaC utilizzarlo direttamente `SdkWarmUp` con, in un'applicazione che gestisce i propri checkpoint. Questa sezione mostra a cosa appartiene la chiamata di riscaldamento in un'applicazione per la quale è già configurata. CRaC Per configurare un'applicazione perCRaC, vedere il supporto [ per ](https://github.com/CRaC/docs/blob/master/STEP-BY-STEP.md) Step-by-step CRac su. GitHub Questa procedura dettagliata copre le distribuzioni JDK supportate, i prerequisiti della piattaforma e la `org.crac:crac` dipendenza richiesta dalle interfacce del ciclo di vita.
### Riscaldati prima del checkpoint
Chiama `SdkWarmUp.warmUp()` durante l'inizializzazione, prima di passare al checkpoint. L'applicazione si registra già come CRac `Resource` per chiudere e riaprire le connessioni attorno al checkpoint. Aggiungete la chiamata di riscaldamento allo stesso costruttore, come mostrato nel seguente esempio di codice: Java
```
import org.crac.Context;
import org.crac.Core;
import org.crac.Resource;
import software.amazon.awssdk.core.warmup.SdkWarmUp;
public class MyApp implements Resource {
public MyApp() {
SdkWarmUp.warmUp();
// Your other initialization here.
Core.getGlobalContext().register(this);
}
@Override
public void beforeCheckpoint(Context context) throws Exception {
// Close your service clients here.
}
@Override
public void afterRestore(Context context) throws Exception {
// Create your service clients again here.
}
}
```
**Nota**
CRac non richiede un checkpoint mentre un qualsiasi descrittore di file è aperto. Se si utilizza il client AWS CRT-based HTTP, chiudere i client di servizio da soli non è sufficiente, perché il client mantiene aperto un ciclo di eventi condiviso. Rilasciatelo `beforeCheckpoint` come mostrato nel seguente esempio di codice Java:
```
import org.crac.Context;
import org.crac.Resource;
import software.amazon.awssdk.crt.CrtResource;
import software.amazon.awssdk.crt.io.EventLoopGroup;
@Override
public void beforeCheckpoint(Context context) {
EventLoopGroup.closeStaticDefault();
CrtResource.waitForNoResources();
}
```
I client HTTP Netty Apache basati e basati rilasciano le proprie risorse quando si chiude il client di servizio, quindi non è necessario smontare ulteriormente.
Effettua il checkpoint come faresti normalmente.
## Risorse aggiuntive
Le seguenti risorse forniscono ulteriori informazioni sugli argomenti trattati in questa sezione:
+ [Documentazione ](https://github.com/CRaC/docs) del CRac su GitHub