Concepts AWS Lambda
Qu'est-ce que Lambda ?
AWS Lambda est un service de calcul serverless qui exécute votre code en réponse à des événements, sans que vous ayez à gérer de serveurs.
┌─────────────────────────────────────────────────────────────┐
│ LAMBDA vs EC2 │
├─────────────────────────────────────────────────────────────┤
│ │
│ EC2 (Serveur) Lambda (Serverless) │
│ ───────────── ────────────────── │
│ │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Serveur │ │ Fonction │ │
│ │ 24/7 │ │ à la │ │
│ │ actif │ │ demande │ │
│ └─────────────┘ └─────────────┘ │
│ │
│ • Vous gérez le serveur • AWS gère l'infra │
│ • Payé même au repos • Payé à l'exécution │
│ • Scaling manuel/ASG • Scaling auto illimité │
│ • Patching requis • Zéro maintenance │
│ • Long running OK • Max 15 minutes │
│ │
│ Coût mensuel (exemple) : │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ EC2 t3.medium 24/7 = ~$30/mois │ │
│ │ Lambda 1M requêtes = ~$0.20/mois │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
Modèle d'Exécution
┌─────────────────────────────────────────────────────────────┐
│ MODÈLE D'EXÉCUTION LAMBDA │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. ÉVÉNEMENT DÉCLENCHEUR │
│ ───────────────────── │
│ • Requête API Gateway │
│ • Upload fichier S3 │
│ • Message SQS │
│ • Événement CloudWatch │
│ • Modification DynamoDB │
│ │
│ 2. INVOCATION │
│ ────────── │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────────────────┐ │
│ │ Trigger │───►│ AWS │───►│ Environnement │ │
│ │ (event) │ │ Lambda │ │ d'exécution │ │
│ └─────────┘ │ Service │ │ │ │
│ └─────────┘ │ ┌───────────────┐ │ │
│ │ │ Votre code │ │ │
│ │ │ (handler) │ │ │
│ │ └───────────────┘ │ │
│ └─────────────────────┘ │
│ │
│ 3. CYCLE DE VIE │
│ ──────────── │
│ │
│ Cold Start Warm Terminé │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │ Init │────────►│ Invoke │──(idle)───►│ Shut │ │
│ │ ~100ms │ │ ~10ms │ │ down │ │
│ └────────┘ └────────┘ └────────┘ │
│ │ │
│ ▼ │
│ Réutilisé si nouvelle │
│ requête arrive vite │
│ │
└─────────────────────────────────────────────────────────────┘
Configuration Lambda
Paramètres Clés
| Paramètre | Description | Valeurs |
|---|---|---|
| Runtime | Langage d'exécution | Python, Node.js, Java, Go, .NET, Ruby |
| Handler | Point d'entrée | fichier.fonction |
| Memory | RAM allouée | 128 MB - 10,240 MB |
| Timeout | Durée max | 1 sec - 15 min |
| Environment | Variables d'env | Clé=Valeur |
| Role | Permissions IAM | ARN du rôle |
Memory et CPU
┌─────────────────────────────────────────────────────────────┐
│ MEMORY = CPU │
├─────────────────────────────────────────────────────────────┤
│ │
│ En Lambda, la mémoire détermine aussi le CPU ! │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Memory CPU Cas d'usage │ │
│ │ ────── ─── ────────── │ │
│ │ 128 MB ~0.08 vCPU Simple, API légère │ │
│ │ 512 MB ~0.33 vCPU Standard │ │
│ │ 1024 MB ~0.58 vCPU Traitement moyen │ │
│ │ 1769 MB 1 vCPU CPU-intensive │ │
│ │ 3008 MB ~1.75 vCPU Heavy processing │ │
│ │ 10240 MB 6 vCPU Max performance │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 💡 Plus de mémoire = plus de CPU = exécution plus rapide │
│ Parfois, plus de mémoire coûte MOINS cher ! │
│ │
│ Exemple : │
│ • 128MB × 10s = 1.25 GB-seconde │
│ • 1024MB × 1.5s = 1.5 GB-seconde (plus rapide, ~même $) │
│ │
└─────────────────────────────────────────────────────────────┘
Triggers (Déclencheurs)
Sources d'Événements
┌─────────────────────────────────────────────────────────────┐
│ TRIGGERS LAMBDA │
├─────────────────────────────────────────────────────────────┤
│ │
│ SYNCHRONES (attendent la réponse) │
│ ───────────────────────────────── │
│ • API Gateway → APIs REST/HTTP │
│ • ALB → Load Balancer │
│ • CloudFront → Lambda@Edge │
│ • Cognito → Auth triggers │
│ │
│ ASYNCHRONES (fire-and-forget) │
│ ───────────────────────────── │
│ • S3 → Upload, delete │
│ • SNS → Messages │
│ • CloudWatch Events → Cron, événements │
│ • SES → Emails │
│ │
│ POLLING (Lambda poll la source) │
│ ─────────────────────────────── │
│ • SQS → Messages queue │
│ • DynamoDB Streams → Changes DB │
│ • Kinesis → Streaming data │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ S3 ──────┐ │ │
│ │ │ │ │
│ │ API ──────┼──────► Lambda ──────► DynamoDB │ │
│ │ │ │ │
│ │ SQS ──────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
Structure du Code
Handler Python
import json
def lambda_handler(event, context):
"""
event : Données de l'événement déclencheur
context : Informations sur l'exécution
"""
# Lire les données de l'événement
print(f"Event: {json.dumps(event)}")
# Informations du contexte
print(f"Function: {context.function_name}")
print(f"Request ID: {context.aws_request_id}")
print(f"Time remaining: {context.get_remaining_time_in_millis()}ms")
# Votre logique ici
name = event.get('name', 'World')
message = f"Hello, {name}!"
# Retourner la réponse
return {
'statusCode': 200,
'body': json.dumps({
'message': message
})
}
Handler Node.js
exports.handler = async (event, context) => {
// Log l'événement
console.log('Event:', JSON.stringify(event, null, 2));
// Votre logique
const name = event.name || 'World';
const message = `Hello, ${name}!`;
// Retourner la réponse
return {
statusCode: 200,
body: JSON.stringify({
message: message
})
};
};
Permissions IAM
┌─────────────────────────────────────────────────────────────┐
│ PERMISSIONS LAMBDA │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. EXECUTION ROLE (ce que Lambda peut faire) │
│ ────────────────────────────────────── │
│ Rôle IAM attaché à la fonction │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Permissions typiques : │ │
│ │ │ │
│ │ • logs:CreateLogGroup │ │
│ │ • logs:CreateLogStream │ │
│ │ • logs:PutLogEvents │ │
│ │ • s3:GetObject (si accès S3) │ │
│ │ • dynamodb:PutItem (si accès DDB) │ │
│ │ • sqs:ReceiveMessage (si trigger SQS) │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 2. RESOURCE-BASED POLICY (qui peut invoquer Lambda) │
│ ───────────────────────────────────────────────── │
│ Permet à d'autres services d'appeler la fonction │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Exemple : S3 peut invoquer cette fonction │ │
│ │ │ │
│ │ Principal: s3.amazonaws.com │ │
│ │ Action: lambda:InvokeFunction │ │
│ │ Condition: bucket = my-bucket │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ Principe du moindre privilège : │
│ ✅ Permissions minimales nécessaires │
│ ❌ Jamais AdministratorAccess sur Lambda │
│ │
└─────────────────────────────────────────────────────────────┘
Tarification
┌─────────────────────────────────────────────────────────────┐
│ TARIFICATION LAMBDA │
├─────────────────────────────────────────────────────────────┤
│ │
│ Vous payez pour : │
│ 1. Nombre de requêtes │
│ 2. Durée d'exécution (GB-secondes) │
│ │
│ GRATUIT (Free Tier permanent) : │
│ • 1 million requêtes/mois │
│ • 400,000 GB-secondes/mois │
│ │
│ AU-DELÀ DU FREE TIER : │
│ • $0.20 par million de requêtes │
│ • $0.0000166667 par GB-seconde │
│ │
│ Exemple de calcul : │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Fonction : 512 MB, 200ms moyenne, 5M requêtes/mois│ │
│ │ │ │
│ │ GB-secondes = 5M × 0.512 GB × 0.2s = 512,000 │ │
│ │ │ │
│ │ Coût requêtes : (5M - 1M) × $0.20/M = $0.80 │ │
│ │ Coût durée : (512K - 400K) × $0.0000166667 │ │
│ │ = 112K × $0.0000166667 = $1.87 │ │
│ │ │ │
│ │ TOTAL : $2.67/mois │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 💡 Très économique pour des charges variables ! │
│ │
└─────────────────────────────────────────────────────────────┘
Résumé
| Concept | Description |
|---|---|
| Serverless | Pas de serveur à gérer |
| Event-driven | Exécuté par des événements |
| Handler | Point d'entrée du code |
| Cold Start | Temps d'initialisation |
| Memory = CPU | Plus de RAM = plus de CPU |
| 15 min max | Limite de durée |
Prochaine section : Création de Fonctions