Skip to content
Learni
Voir tous les tutoriels
Cloud AWS

Comment implémenter AWS Lambda SnapStart en 2026

18 minEXPERT
AWS LambdaSnapStartJava ServerlessSAM CLI
Read in English

Introduction

AWS Lambda SnapStart, lancé pour Java 11/17/21, révolutionne les performances en créant un snapshot de l'environnement runtime après initialisation. Cela réduit les cold starts de jusqu'à 90% (de secondes à millisecondes), idéal pour APIs à fort trafic ou microservices critiques. Contrairement aux Provisioned Concurrency (coûteux), SnapStart est gratuit et automatique post-déploiement.

Pourquoi l'utiliser en 2026 ? Avec l'essor des apps serverless scalables, les cold starts tuent l'expérience utilisateur. Ce tutoriel expert vous guide pas-à-pas : de la config Maven à un déploiement SAM complet, avec monitoring CloudWatch. Vous obtiendrez un handler Java fonctionnel, prêt pour production. Analogie : imaginez un moteur de voiture pré-chauffé – prêt à rugir instantanément. Prêt à booster vos Lambdas ? (128 mots)

Prérequis

  • AWS CLI v2 configurée avec aws configure
  • SAM CLI v1.100+ (brew install aws-sam-cli ou équivalent)
  • JDK 21+ (Amazon Corretto recommandé)
  • Maven 3.9+ (mvn --version)
  • Compte AWS avec permissions Lambda/SnapStart
  • Connaissances avancées en Java serverless et SAM

Initialiser le projet Maven

terminal-init.sh
mkdir lambda-snapstart-demo && cd lambda-snapstart-demo
sam init --runtime java21 --name snapstart-demo --template sam-ep-hello-world --location .

SAM init crée un squelette Java 21 avec template.yaml basique. Cela génère src/ et template.yaml. Utilisez java21 pour SnapStart (Java 17/21 supportés). Évitez provided runtime sans SAM pour la compatibilité.

Configurer Maven pour SnapStart

Modifiez pom.xml pour inclure les dépendances Lambda et activer la compilation native-agnostique. SnapStart requiert une initialisation explicite dans le handler.

pom.xml complet

pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>snapstart-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-lambda-java-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-lambda-java-events</artifactId>
            <version>3.11.5</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.17.2</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Ce pom.xml inclut aws-lambda-java pour handlers, Jackson pour JSON, et shade-plugin pour uber-jar. Crucial : shade évite les conflits de classes lors du snapshot. Testez avec mvn clean package – génère target/snapstart-demo-1.0-SNAPSHOT.jar.

Handler Java avec pré-init SnapStart

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 com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class Handler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    // Classe pour pré-init SnapStart
    public static class Initializer {
        public static void init() {
            // Simulations de workloads lourds : DB pools, caches, etc.
            System.out.println("SnapStart Pré-Init: Chargement des ressources...");
            try {
                Thread.sleep(2000); // Simule init lente (2s)
                // Ex: HikariCP pool, Caffeine cache, etc.
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("SnapStart Pré-Init terminée.");
        }
    }

    static {
        Initializer.init(); // Exécuté UNE FOIS lors du snapshot
    }

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        Map<String, String> headers = new HashMap<>();
        headers.put("Content-Type", "application/json");

        APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent()
                .withHeaders(headers);

        try {
            JsonNode body = objectMapper.readTree(input.getBody());
            String name = body.has("name") ? body.get("name").asText() : "Monde";
            String result = String.format("Bonjour, %s! Temps init: %d ms", name, System.currentTimeMillis());

            Map<String, Object> responseBody = new HashMap<>();
            responseBody.put("message", result);
            responseBody.put("timestamp", System.currentTimeMillis());

            response.withStatusCode(200)
                    .withBody(objectMapper.writeValueAsString(responseBody));
        } catch (Exception e) {
            response.withStatusCode(500)
                    .withBody("{\"error\": \"" + e.getMessage() + "\"}");
        }
        return response;
    }
}

Le static block avec Initializer.init() s'exécute une seule fois lors du snapshot SnapStart, pré-chargeant ressources (ici simulé). Handler gère API Gateway events avec Jackson. Piège : Évitez les ops réseau en static – elles ne snapshot pas. Cold start sans : ~2s ; avec : <100ms.

Configurer SAM pour SnapStart

Activez SnapStart dans template.yaml via SnapStart: PublishedVersions. SAM build gère le packaging.

template.yaml avec SnapStart

template.yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: AWS Lambda SnapStart Demo

Globals:
  Function:
    Timeout: 30
    MemorySize: 1024
    Runtime: java21
    Architectures:
      - arm64  # x86_64 aussi OK

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: target/snapstart-demo-1.0-SNAPSHOT.jar
      Handler: com.example.Handler::handleRequest
      Runtime: java21
      Events:
        Api:
          Type: Api
          Properties:
            Path: /{proxy+}
            Method: any
      SnapStart:
        ApplyOn: PublishedVersions  # OU RequestResponseVersions
    Metadata:
      BuildMethod: maven
Outputs:
  HelloWorldApi:
    Description: URL de l'API
    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/"
  HelloWorldFunction:
    Description: Nom de la Lambda
    Value: !Ref HelloWorldFunction

SnapStart activé sur PublishedVersions (toutes versions publiées snapshotées). arm64 optimise coûts. Maven BuildMethod automatise shade. Déployez après mvn package. Vérifiez status via AWS Console > Lambda > Snapshots.

Build et déploiement SAM

terminal-deploy.sh
mvn clean package
sam build --use-container
sam deploy --guided --stack-name snapstart-demo-stack --capabilities CAPABILITY_IAM --region us-east-1
sam logs -n HelloWorldFunction --stack-name snapstart-demo-stack --tail

sam build shade le JAR et prépare .aws-sam/. --use-container assure JDK21 consistency. deploy crée stack CloudFormation avec SnapStart. Logs montrent 'SnapStart Pré-Init' une seule fois. Premier invoke crée snapshot (~1min).

Test via AWS CLI

terminal-test.sh
API_URL=$(aws cloudformation describe-stacks --stack-name snapstart-demo-stack --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text)

aws api-gateway test-invoke-method \
  --rest-api-id $(echo $API_URL | cut -d/ -f7) \
  --resource-id $(aws api-gateway get-resources --rest-api-id $(echo $API_URL | cut -d/ -f7) --query 'items[?path=="/{"proxy+"}"][].id' --output text) \
  --http-method POST \
  --body '{"name": "SnapStart Expert"}'

Extrait API URL de stack, teste POST. Mesurez Duration en logs : cold start post-snapshot <100ms. Piège : Premier invoke post-deploy est lent (snapshot creation) – suivants instantanés.

Bonnes pratiques

  • Pré-init sélective : Limitez static à caches/pools ; évitez singletons stateful.
  • Utilisez ARM64 pour 20% perf+ et coûts-.
  • Monitorez Snapshots via CloudWatch Metrics (SnapshotErrors).
  • Versionnez avec PublishedVersions pour CI/CD.
  • Intégrez X-Ray pour tracer init vs invoke.

Erreurs courantes à éviter

  • Static avec IO : Réseau/DB échoue snapshot (use ApplicationLoadBalancer.init()).
  • Oublier mvn shade : ClassNotFound à runtime.
  • Runtime non supporté : SnapStart uniquement Java11/17/21.
  • Pas de logs init : Ajoutez System.out pour debug snapshot.

Pour aller plus loin

Plongez dans notre formation AWS Avancé pour CDK + SnapStart. Docs officielles : AWS Lambda SnapStart. Mesurez perf avec CloudWatch Insights. Contribuez sur GitHub !