Comprendre le modèle d'exécution de Lambda

Applications serverless avec AWS Lambda

Claudio Canales

Senior DevOps Engineer

Exécution automatique

AWS piloté par événements

Lambda exécute du code lorsqu'un événement survient.
Exemple : upload S3 -> redimensionner l'image.
Déclencheurs variés, même schéma.

Au repos jusqu'au déclenchement

Idle -> événement -> exéc. -> arrêt

Idle : rien ne s'exécute.
Événement : le handler s'exécute, puis s'arrête.

Analogie lampe à détection de mouvement pour Lambda

Comme une lampe détecteur : idle jusqu'au déclenchement.
Le trigger passe de « off » à « on ».

Qu'est-ce qu'AWS Lambda ?

AWS Lambda en bref

Service de calcul piloté par événements.
Mise à l'échelle automatique selon la demande.
Paiement à l'usage (temps d'exécution).

Comment Lambda exécute votre code

Flux d'exécution de Lambda

Une source d'événements déclenche Lambda.
Lambda transmet un payload d'événement au handler.
Le handler renvoie un résultat.

Mise à l'échelle selon la demande

La montée en charge crée plus d'environnements

Plus d'événements : plus d'invocations parallèles.
Lambda crée plus d'environnements.
Cold starts possibles par nouvel environnement.

La fonction handler

def lambda_handler(event, context):
    # Your code here
    return {
        'statusCode': 200,
        'body': 'Hello from Lambda!'
    }

event : payload d'entrée (JSON).
context : métadonnées d'exécution.
return : sortie (succès/échec).

Le handler reçoit event et context

L'objet event

Payload d'événement de stockage objet

Événement S3 : bucket + clé d'objet.

# event["Records"][0]["s3"]
{
  "bucket": {"name": "my-bucket"},
  "object": {"key": "data.csv"}
}

Même travail : extraire l'essentiel.

Payload d'événement de requête HTTP

Événement API : méthode, chemin, corps.

# API request event
{
  "httpMethod": "POST",
  "path": "/users",
  "body": "{\"name\": \"John\"}"
}

Déclencheurs différents, JSON différent.

L'objet context

def lambda_handler(event, context):
    time_left = (
        context.get_remaining_time_in_millis()
    )
    request_id = context.aws_request_id

get_remaining_time_in_millis Temps restant avant le timeout.
aws_request_id ID de requête pour le traçage des logs.

Exécution sans état

Réutilisation à chaud vs réinitialisation

Chaque invocation est indépendante.
Réutilisation possible, non garantie.
Stocker l'état hors de Lambda.

counter = 0

def lambda_handler(event, context):
    global counter
    counter += 1  # may reset
    return counter

Cold starts

Chronologie d'un cold start

Nouvel environnement d'exécution.
Chargement du code et des dépendances.
Initialisation, puis handler.

Warm starts

Chronologie d'un warm start

Réutilisation d'un environnement existant.
La plupart des initialisations sont ignorées.
Le handler démarre plus vite.

Init, invoke, freeze

Cycle de vie de l'environnement d'exécution

Init s'exécute une fois par environnement.
Le handler s'exécute à chaque invocation.
Entre les exécutions, l'env. peut geler.

Optimiser les cold starts

# init (une fois par env)
import boto3
s3 = boto3.client('s3')

# handler (à chaque invocation)
def lambda_handler(event, context):
    return {"statusCode": 200}

Init une fois vs handler à chaque invocation

Placez imports et clients SDK hors du handler.

Passons à la pratique !

Applications serverless avec AWS Lambda