Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Réchauffez les clients du SDK dans le AWS SDK for Java 2.x
Utilisez l'`SdkWarmUp`utilitaire du AWS SDK for Java 2.x pour réchauffer vos clients du SDK lors de l'initialisation de l'application. Cela réduit la latence de la première demande traitée par votre application après le démarrage ou la restauration.
Un échauffement permet de tester le chemin de requête du SDK (création d'un client et appel d'une opération) avant que votre application ne gère le trafic réel. Vous l'utilisez avec des fonctionnalités de point de contrôle et de restauration telles que Lambda. [ SnapStart ](https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html) Ces fonctionnalités prennent un instantané de votre application initialisée, puis restaurent à partir de cet instantané pour réduire la latence lors des démarrages à froid.
Sans cela`SdkWarmUp`, vous devez écrire votre propre code d'échauffement avant chaque point de contrôle, ce qui est fastidieux. Avec`SdkWarmUp`, vous passez un seul appel pour réchauffer tous vos clients. Vous pouvez activer tous les clients SDK de votre chemin de classe, ou uniquement les clients spécifiques utilisés par votre application.
Dans cette rubrique, vous allez apprendre à configurer et à utiliser `SdkWarmUp` avec CRaC et AWS Lambda SnapStart. Pour plus d'informations sur les autres techniques permettant de réduire le temps de démarrage sur Lambda, consultez[Réduisez le temps de démarrage du SDK pour AWS Lambda](lambda-optimize-starttime.md).
## L' SdkWarmUp API
`SdkWarmUp`fait partie du `sdk-core` module, il est donc disponible pour tous les clients du service sans dépendance supplémentaire. Configurez votre projet pour utiliser la version 2.54.0 ou ultérieure du AWS SDK for Java 2.x. Appelez ensuite l'une des deux méthodes statiques décrites dans les sections suivantes. Lorsque vous appelez l'une ou l'autre `SdkWarmUp` des méthodes, effectuez un appel réseau pour réchauffer le client HTTP. Pour réchauffer le client du service, celui-ci utilise une réponse locale prédéfinie. Il n'a pas besoin AWS d'informations d'identification ni d'autorisations IAM et n'entraîne aucun frais. AWS
### Réchauffez tous les clients du SDK sur le classpath
La `warmUp()` méthode découvre tous les clients du service SDK sur le chemin de classe et les réchauffe, ainsi que les clients HTTP qu'ils utilisent. Utilisez cette méthode lorsque vous dépendez d'un petit nombre de modules de service et que vous appelez la plupart des clients qu'ils fournissent. L'exemple Java de code suivant appelle `warmUp()` sans argument :
```
import software.amazon.awssdk.core.warmup.SdkWarmUp;
SdkWarmUp.warmUp();
```
Cette méthode s'exécute au plus une fois par machine virtuelle Java. Après un appel réussi, les appels suivants sont immédiatement renvoyés.
### Réchauffer des clients SDK spécifiques
La `warmUp(Class... clients)` méthode réchauffe uniquement les clients que vous nommez. Transmettez une classe client synchrone pour réchauffer le chemin synchrone, ou une classe client asynchrone pour réchauffer le chemin asynchrone.
Utilisez cette méthode lorsque votre chemin de classe contient plus de clients de service que le nombre d'appels de votre application. Cela se produit par exemple lorsqu'une dépendance introduit des modules de service que vous n'utilisez pas. En ne nommant que les clients dont vous avez besoin, le temps de préchauffage est proportionnel à l'utilisation réelle de votre application plutôt qu'à votre chemin de classe complet. L'exemple de Java code suivant réchauffe uniquement les `DynamoDbClient` classes `S3Client` et :
```
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);
```
## À utiliser SdkWarmUp avec Lambda SnapStart
[AWS Lambda SnapStart](https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html)améliore les performances de démarrage des Java fonctions. Lorsque vous publiez une nouvelle version d'une fonction, Lambda l' SnapStart initialise et prend un instantané de l'état de la mémoire et du disque. Il met ensuite le cliché en cache pour le réutiliser. Pour plus d'informations sur les environnements d'exécution pris en charge et sur la manière SnapStart d'activer votre fonction, consultez le Guide * du *AWS Lambda développeur.
Comme Lambda prend le cliché après l'exécution du constructeur de votre gestionnaire, appelez-le`SdkWarmUp.warmUp()`. L'instantané inclut ensuite vos clients préchauffés, et chaque appel restauré à partir de l'instantané bénéficie de l'échauffement. L'exemple de Java code suivant appelle un `SdkWarmUp.warmUp()` constructeur de gestionnaire Lambda :
```
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.
}
}
```
Si votre fonction doit exécuter du code personnalisé avant que Lambda ne prenne le snapshot ou après la restauration, implémentez des hooks SnapStart d'exécution. Pour plus d'informations, consultez les hooks [ SnapStart d'exécution pour Java ](https://docs.aws.amazon.com/lambda/latest/dg/snapstart-runtime-hooks-java.html) dans le Guide du *AWS Lambda développeur*.
## Utilisation SdkWarmUp avec le CRAc autonome
Vous pouvez également utiliser CRaC directement `SdkWarmUp` avec, dans une application qui gère ses propres points de contrôle. Cette section indique la place de l'appel de préchauffage dans une application déjà configurée pourCRaC. Pour configurer une application pourCRaC, consultez le support [ Step-by-step du CRAC ](https://github.com/CRaC/docs/blob/master/STEP-BY-STEP.md) surGitHub. Cette procédure pas à pas couvre les distributions JDK prises en charge, les prérequis de la plate-forme et la `org.crac:crac` dépendance requise par les interfaces de cycle de vie.
### Échauffez-vous avant le point de contrôle
Appelez `SdkWarmUp.warmUp()` pendant l'initialisation, avant de passer le point de contrôle. Votre application s'enregistre déjà en tant que CRAC `Resource` pour fermer et rouvrir les connexions autour du point de contrôle. Ajoutez l'appel d'échauffement au même constructeur, comme indiqué dans l'exemple de Java code suivant :
```
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.
}
}
```
**Note**
CRAc ne prend aucun point de contrôle lorsqu'un descripteur de fichier est ouvert. Si vous utilisez le client AWS CRT-based HTTP, il ne suffit pas de fermer vos clients de service à elle seule, car le client maintient une boucle d'événements partagée ouverte. Relancez-le `beforeCheckpoint` comme indiqué dans l'exemple de code Java suivant :
```
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();
}
```
Les clients HTTP Netty Apache basés et basés libèrent leurs ressources lorsque vous fermez le client de service. Aucun démontage supplémentaire n'est donc nécessaire.
Prenez le poste de contrôle comme vous le feriez normalement.
## Ressources supplémentaires
Les ressources suivantes fournissent plus d'informations sur les sujets abordés dans cette section :
+ [Documentation du CRAc sur ](https://github.com/CRaC/docs) GitHub