Skip to content
Learni
View all tutorials
AWS

Comment activer AWS Lambda SnapStart en 2026

12 minBEGINNER
AWS LambdaSnapStartSAM CLIJavaServerless

Introduction

AWS Lambda SnapStart est une fonctionnalité révolutionnaire lancée en 2022 et optimisée en 2026, qui réduit les temps de démarrage à froid (cold starts) des fonctions Lambda écrites en Java de plus de 90 % en moyenne. Contrairement aux cold starts classiques, où l'environnement d'exécution (JVM) se initialise à chaque invocation, SnapStart crée un snapshot de la JVM pré-initialisée, stocké de manière immuable.

Pourquoi est-ce crucial ? Dans un monde serverless, les cold starts impactent la latence utilisateur et les coûts (plus d'invocations pour compenser). Pour une API e-commerce par exemple, passer de 2 secondes à 200 ms change tout. Ce tutoriel beginner vous guide pas à pas : de la création d'une fonction Java simple à l'activation de SnapStart via AWS SAM, avec benchmarks concrets. À la fin, vous maîtriserez cette feature pour des Lambdas production-ready. Temps estimé : 20 minutes.

Prérequis

  • Compte AWS gratuit (avec region us-east-1 pour SnapStart)
  • AWS CLI v2 installé et configuré (aws configure)
  • SAM CLI v1.100+ (sam --version)
  • JDK 11 ou 17 (x86_64, pas ARM)
  • Maven 3.9+ (pour build Java)
  • Git pour cloner les exemples optionnels

Installer et vérifier SAM CLI

terminal
# Installation rapide via script officiel (Linux/Mac)
# curl -L https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip -o sam.zip
# unzip sam.zip -d sam-installation
# sudo ./sam-installation/install

# Vérification
sam --version
aws --version

# Configurer AWS si pas fait
aws configure set region us-east-1
aws sts get-caller-identity

Ce script installe SAM CLI, l'outil officiel pour développer et déployer des Lambdas localement. Vérifiez les versions : SAM doit être >=1.100 pour SnapStart v2. La région us-east-1 est requise car SnapStart n'est pas disponible partout ; get-caller-identity confirme votre authentification IAM.

Créer le projet SAM de base

Nous utilisons AWS SAM pour sa simplicité : un template.yaml qui définit la stack CloudFormation. Créez un projet 'hello-world' en Java 17, architecture x86_64, sans SnapStart initialement.

Initialiser le projet SAM

terminal
sam init --runtime java17 --name snapstart-demo --app-template hello-world --location . --use-image
cd snapstart-demo

# Aperçu du template.yaml généré
cat template.yaml

# Build initial (crée .aws-sam)
sam build

sam init génère un boilerplate complet : handler Java, pom.xml pour Maven, et template.yaml. --use-image utilise des conteneurs pour un build reproductible. sam build compile le code en artefacts prêts pour le déploiement, créant le dossier .aws-sam/build.

Handler Java de base (sans optimisation)

snapstart-demo/hello-world/app/src/main/java/com/example/Handler.java
package com.example;

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 java.util.HashMap;
import java.util.Map;

public class Handler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        context.getLogger().log("COLD START détecté: " + context.getLogger().logGroupName());

        Map<String, String> headers = new HashMap<>();
        headers.put("Content-Type", "application/json");

        APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent()
                .withHeaders(headers)
                .withStatusCode(200)
                .withBody("{\"message\": \"Hello sans SnapStart! Temps init: " + System.currentTimeMillis() + "\"}");

        return response;
    }
}

Ce handler simple répond à une requête API Gateway avec JSON. Il loggue pour détecter les cold starts (via logGroupName()). Copiez-collez ce code pour remplacer le boilerplate ; il simule du travail lourd en loguant le timestamp, idéal pour mesurer les latences.

Déployer sans SnapStart et tester

Attention : Créez un rôle IAM pour SAM via sam deploy --guided. Notez l'URL API Gateway générée.

Déploiement initial (sans SnapStart)

terminal
# Premier déploiement guidé
sam deploy --guided --stack-name snapstart-demo --capabilities CAPABILITY_IAM --resolve-s3

# Récupérer l'URL API Gateway (remplacez <stack> par snapstart-demo)
API_URL=$(aws cloudformation describe-stacks --stack-name snapstart-demo --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text)
echo "URL: $API_URL"

# Test cold start (attendre 15min d'inactivité pour cold)
curl "$API_URL/GET/" -w "%{time_total} secondes\n"

sam deploy --guided crée la stack CloudFormation avec rôle IAM auto. L'URL est extraite des outputs. curl -w mesure le temps total de réponse ; après 15min d'inactivité, attendez ~1-2s pour cold start classique.

Activer SnapStart dans le template

Modifiez template.yaml pour ajouter SnapStart. Publiez une version $LATEST puis une version numérotée.

Template YAML avec SnapStart activé

snapstart-demo/template.yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: 'snapstart-demo'

Globals:
  Function:
    Timeout: 20
    Runtime: java17
    Architectures:
      - x86_64
    MemorySize: 512
    Environment:
      Variables:
        JAVA_TOOL_OPTIONS: -XX:+TieredCompilation -XX:TieredStopAtLevel=1

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: hello-world/
      Handler: com.example.Handler::handleRequest
      Runtime: java17
      Architectures:
        - x86_64
      Events:
        HelloWorld:
          Type: Api
          Properties:
            Path: /{proxy+}
            Method: any
      SnapStart:
        ApplyOn: PublishedVersions
      Environment:
        Variables:
          JAVA_TOOL_OPTIONS: -Djava.awt.headless=true -XX:InitialRAMFraction=0.5 -XX:MaxRAMFraction=0.7 -XX:+UseContainerSupport
    Metadata: sam-resource-id: HelloWorldFunction

Outputs:
  HelloWorldApi:
    Description: "API Gateway endpoint URL"
    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/"
  HelloWorldFunction:
    Description: "Hello World Lambda Function ARN"
    Value: !GetAtt HelloWorldFunction.Arn
  HelloWorldActiveVersion:
    Description: "Version of Hello World Lambda being invoked"
    Value: !Ref HelloWorldFunction

Clé : SnapStart: ApplyOn: PublishedVersions active SnapStart sur les versions publiées (pas $LATEST). JAVA_TOOL_OPTIONS optimise la JVM pour conteneurs (RAM, headless). Architectures: x86_64 obligatoire. Cela génère un snapshot en ~3min après publication.

Build, deploy et test avec SnapStart

terminal
# Build après modif template
sam build

# Deploy (met à jour la stack)
sam deploy --stack-name snapstart-demo --capabilities CAPABILITY_IAM --no-confirm-changeset --no-fail-on-empty-changeset

# Publier une version (nécessaire pour SnapStart)
aws lambda publish-version --function-name snapstart-demo-HelloWorldFunction-1U5K5Z5Z5Z5Z --description "v1 SnapStart"

# Attendre snapshot (3-5min), updater alias si besoin
aws lambda update-alias --function-name snapstart-demo-HelloWorldFunction-1U5K5Z5Z5Z5Z --name prod --function-version 1

# Test cold start après 15min
curl "$API_URL/GET/" -w "%{time_total} secondes\n"

# Logs pour confirmer (pas de 'COLD START')
aws logs tail /aws/lambda/snapstart-demo-HelloWorldFunction --since 10m

publish-version crée une version immutable ; SnapStart snapshot se génère automatiquement. update-alias pointe 'prod' sur la version. Temps cold start tombe à <300ms. logs tail confirme l'absence de logs cold start.

Bonnes pratiques

  • Optimisez JAVA_TOOL_OPTIONS : Utilisez -XX:MaxRAMFraction=0.7 pour limiter heap à 70% RAM, évitant GC longs.
  • Publiez des versions stables : SnapStart ne fonctionne que sur versions publiées, pas $LATEST ; alias pour prod.
  • Surveillez les snapshots : Via CloudWatch > Lambda > Snapshots (taille ~100MB, gratuit jusqu'à 1GB/fonction).
  • Testez en prod-like : Utilisez X-Ray pour tracer latences ; activez Provisioned Concurrency si trafic bursty.
  • Nettoyez : aws lambda delete-function --function-name arn... et aws cloudformation delete-stack --stack-name snapstart-demo.

Erreurs courantes à éviter

  • Architecture ARM : SnapStart n'est PAS supporté sur arm64 ; forcez x86_64 ou erreur InvalidRuntime.
  • Pas de version publiée : Invocation sur $LATEST ignore SnapStart ; toujours publish-version.
  • Région non supportée : Limité à us-east-1, eu-west-1 etc. ; vérifiez docs AWS.
  • JDK <11 : Obligatoire Java11/17/21 ; snapshot échoue sinon.

Pour aller plus loin