Réchauffez les clients du SDK dans le AWS SDK for Java 2.x

Utilisez l'SdkWarmUputilitaire 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 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 celaSdkWarmUp, vous devez écrire votre propre code d'échauffement avant chaque point de contrôle, ce qui est fastidieux. AvecSdkWarmUp, 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, consultezRéduisez le temps de démarrage du SDK pour AWS Lambda.

L' SdkWarmUp API

SdkWarmUpfait 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<? extends SdkClient>... 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 SnapStartamé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-leSdkWarmUp.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<String, String> {

    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 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 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<? extends Resource> context) throws Exception {
        // Close your service clients here.
    }

    @Override
    public void afterRestore(Context<? extends Resource> context) throws Exception {
        // Create your service clients again here.
    }
}

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<? extends Resource> context) {
    EventLoopGroup.closeStaticDefault();
    CrtResource.waitForNoResources();
}

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 :