Introduction

Jusqu'à présent, je n'ai pas mesuré les performances (temps de démarrage à chaud et à froid) des fonctions Lambda à l'aide du runtime Java 21 pour certains cas d'utilisation (comme faire une requête DynamoDB) pour l'architecture arm64 car elle n'a pas pris en charge SnapStart. Lambda avec le runtime Java 21 avec une architecture x86_64 avec SnapStart activé surpassera (encore plus avec une optimisation d'amorçage supplémentaire) Lambda avec une architecture arm64. Mais le 18 juillet 2024, AWS a annoncé qu'AWS Lambda prend désormais en charge SnapStart pour les fonctions Java qui utilisent l'architecture ARM64. Il était donc logique pour moi de commencer à mesurer les temps de démarrage à froid et à chaud, en tenant également compte du choix de l'architecture de la fonction Lambda. On sait qu'avec le paramètre actuel de tarification de la mémoire et la durée d'exécution d'AWS Lambda, Lambda avec l'architecture arm64 sera d'env. 25 % moins cher que Lambda avec une architecture x86_64.

J'ai décidé de créer une série d'articles distincte pour cela et de ne pas ajouter ce sujet à ma série AWS Lambda SnapStart en constante évolution.

Mesure des démarrages à froid et à chaud pour l'exemple d'application

Dans notre expérience, nous réutiliserons l'application présentée dans l'article AWS Lambda SnapStart - Mesure des démarrages à froid de Java 21 Lambda. Voici le code de l’exemple d’application. Il existe essentiellement 2 fonctions Lambda principales qui répondent toutes deux aux requêtes API Gateway pour créer le produit avec l'identifiant donné (voir la fonction Lambda PutProductFunction) et récupérer le produit par l'identifiant donné (voir la fonction Lambda GetProductByIdFunction). Vous pouvez utiliser les deux fonctions Lambda avec et sans SnapStart activé. Il existe une fonction Lambda supplémentaire GetProductByIdWithPrimingFunction que j'ai écrite pour mesurer indépendamment l'effet de l'amorçage des requêtes DynamoDB pour la fonction Lambda activée par SnapStart. Vous pouvez en savoir plus sur l'effet de l'amorçage dans mon article AWS Lambda SnapStart - Mesure de l'amorçage, de la latence de bout en bout et du temps de déploiement.

Pour activer SnapStart sur toutes les fonctions Lambda, veuillez décommenter ce qui suit dans le modèle SAM :

Globals:
  Function:
    CodeUri: target/aws-pure-lambda-snap-start-21-1.0.0-SNAPSHOT.jar
    ...
    SnapStart:
     ApplyOn: PublishedVersions  
   ...

Si je souhaite utiliser SnapStart uniquement pour les fonctions individuelles, mais pas pour toutes les fonctions Lambda, vous devez appliquer cette définition SnapStart au niveau de la fonction Lambda au lieu du niveau de fonction global.

Toutes les fonctions Lambda ont les paramètres suivants comme point de départ :

• Paramètre de mémoire de 1 024 Mo
• Client HTTP Apache par défaut utilisé pour communiquer avec la base de données DynamoDB
• Option de compilation Java "-XX: TieredCompilation -XX:TieredStopAtLevel=1" qui s'est avérée offrir un très bon compromis entre les heures de démarrage à froid et à chaud

Dans le modèle SAM, j'ai ajouté la possibilité de définir l'architecture Lambda dans la section globale des fonctions Lambda comme :

Globals:
  Function:
    CodeUri: target/aws-pure-lambda-snap-start-21-1.0.0-SNAPSHOT.jar
    ...
    Architectures:
      #- arm64
      - x86_64   

Décommentez simplement l'architecture que vous souhaitez utiliser pour vos fonctions Lambda.

Même si Java signifie "écrire une fois, exécuter partout", j'ai quand même compilé et construit le fichier jar d'application pour mes mesures arm64 sur l'instance t4g AWS EC2 avec le processeur Graviton (qui est basé sur l'architecture arm64/aarch64) en installant préalablement Amazon Corretto 21 pour Linux aarch64. Vous pouvez trouver ce pot ici.

J'ai également tout re-mesuré pour l'architecture x86_64 une fois de plus pour obtenir des résultats comparables en utilisant la même dernière version d'exécution de Corretto Java 21 qui, au moment de mes mesures, était Java 21.v17 .

Les résultats de l'expérience ci-dessous étaient basés sur la reproduction de plus de 100 démarrages à froid et d'environ 100 000 démarrages à chaud. Pour cela (et pour les expériences de mon article précédent), j'ai utilisé l'outil de test de charge, mais vous pouvez utiliser l'outil de votre choix, comme Serverless-artillerie ou Postman. Il est également important de savoir que j'ai commencé les mesures juste après le nouveau (re)déploiement du code source de l'application. Veuillez noter qu'il y a également un impact du cache hiérarchisé par instantané sur les démarrages à froid, où les premiers appels sont généralement plus lents, et les suivants deviennent plus rapides jusqu'à ce qu'un certain nombre d'appels soit atteint.

Regroupons maintenant toutes les mesures pour "obtenir le produit par identifiant existant" (fonctions Lambda GetProductByIdFunction et GetProductByIdWithPrimingFunction pour SnapStart activé et mesures d'amorçage).

Heure de démarrage à froid (c) et à chaud (m) en ms :

Conclusion

Dans cet article, nous avons comparé les mesures des temps de démarrage à froid et à chaud de la fonction Lambda se connectant à la base de données DynamoDB pour 3 cas d'utilisation :

• sans SnapStart activé sur la fonction Lambda
• avec SnapStart activé sur la fonction Lambda mais sans optimisation d'amorçage
• avec SnapStart activé sur la fonction Lambda et avec amorçage de la requête DynamoDB

Nous avons constaté qu'en utilisant l'architecture x86_64, tous les temps de démarrage à froid et à chaud étaient inférieurs à ceux de l'architecture arm64. Mais comme le prix Lambda de l'architecture arm64 est 25 % moins cher que l'architecture x86_64 , il introduit un compromis coût-performance très intéressant.

Pour nos mesures, pour les 3 cas d'usage :

• Les temps de démarrage à froid Lambda avec l'architecture arm64 étaient, pour de nombreux percentiles, seulement 10 à 20 % (et seulement dans de très rares cas, 25 à 27 %) plus lents par rapport à l'architecture x86_64.
• Les temps de démarrage à chaud Lambda avec l'architecture arm64 étaient, pour de nombreux percentiles, seulement 5 à 10 % plus lents par rapport à l'architecture x86_64.

Ainsi, le choix de l'architecture arm64 est tout à fait raisonnable pour cet exemple d'application. Comme la prise en charge de SnapStart pour l'architecture arm64 n'a été introduite que récemment, je m'attends également à des améliorations de performances à l'avenir. Veuillez effectuer vos propres mesures pour votre cas d'utilisation !

Dans la partie suivante de l'article, nous effectuerons les mêmes mesures de performances, mais en définissant la mémoire Lambda sur des valeurs différentes entre 256 et 2 048 Mo et en comparant les résultats.