AWS Lambda

Le service de calcul sans serveur qui vous permet d'exécuter du code à la demande, sans provisionner ni gérer de serveurs, tout en ne payant que pour le temps de calcul réellement utilisé.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'AWS Lambda ?

Imaginez AWS Lambda comme un assistant digital intelligent qui attend patiemment vos instructions. Dès que vous lui demandez d'accomplir une tâche spécifique, il se met au travail instantanément, puis retourne en veille une fois le travail terminé.

Traditionnellement, pour faire fonctionner une application, vous devez louer ou acheter un serveur qui tourne 24h/24, 7j/7, même quand personne n'utilise votre application. C'est comme payer un employé à temps plein pour une tâche qui ne prend que quelques minutes par jour.

Avec Lambda, vous ne payez que lorsque votre code s'exécute réellement – à la milliseconde près. C'est comme avoir un assistant qui ne facture que le temps exact passé sur vos tâches.

Pourquoi Lambda est révolutionnaire ?

Économies substantielles

Pas besoin de payer pour du temps d'inactivité. Si votre application est utilisée quelques minutes par jour, vous ne payez que pour ces minutes.

Mise à l'échelle automatique

Qu'il y ait 10 ou 10 000 utilisateurs simultanés, Lambda s'adapte instantanément sans intervention de votre part.

Simplicité

Plus besoin de gérer des serveurs, de s'inquiéter des mises à jour de sécurité ou des pannes matérielles. Concentrez-vous uniquement sur votre code.

Polyvalence

Lambda peut être déclenché par une multitude d'événements : requêtes web, modifications de fichiers, alertes, événements planifiés, et bien plus encore.

En résumé, AWS Lambda a transformé la façon dont les développeurs conçoivent et déploient leurs applications, en permettant de se concentrer sur la création de fonctionnalités plutôt que sur la gestion d'infrastructure, tout en réduisant considérablement les coûts pour de nombreux cas d'utilisation.

Pour les développeurs

Fonctionnement technique

AWS Lambda est un service de calcul serverless qui exécute votre code en réponse à des événements et gère automatiquement les ressources de calcul sous-jacentes. Vous écrivez votre code sous forme de fonctions relativement courtes et ciblées, puis AWS s'occupe de tout le reste.

Les concepts fondamentaux

Modèle d'exécution

Chaque fonction Lambda est exécutée dans un environnement d'exécution isolé, avec ses propres ressources allouées en fonction de la configuration. Lorsqu'une fonction est invoquée, AWS Lambda lance un conteneur pour exécuter votre code, puis le gèle ou le termine selon les besoins.

Fonction Lambda de base en Node.js

// Exemple de fonction Lambda basique en Node.js
exports.handler = async (event, context) => {
  console.log('Événement reçu:', JSON.stringify(event, null, 2));
  
  try {
    // Traitement de l'événement
    const result = processEvent(event);
    
    // Retourner une réponse formatée
    return {
      statusCode: 200,
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        message: 'Opération réussie',
        data: result
      })
    };
  } catch (error) {
    console.error('Erreur:', error);
    
    // Retourner une erreur formatée
    return {
      statusCode: 500,
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        message: 'Erreur lors du traitement',
        errorDetails: error.message
      })
    };
  }
};

function processEvent(event) {
  // Logique métier ici
  if (event.httpMethod === 'GET') {
    return { action: 'read', timestamp: new Date().toISOString() };
  } else if (event.httpMethod === 'POST') {
    return { action: 'create', data: event.body, timestamp: new Date().toISOString() };
  } else {
    throw new Error(`Méthode HTTP non supportée: ${event.httpMethod}`);
  }
}

Déclencheurs et événements

Les fonctions Lambda peuvent être invoquées par une variété de déclencheurs : API Gateway pour les requêtes HTTP, S3 pour les événements de fichiers, EventBridge pour les événements planifiés, SNS pour les notifications, et bien plus encore.

Gestionnaire d'événements S3

// Fonction Lambda qui traite des événements S3
exports.handler = async (event, context) => {
  console.log('Événement S3 reçu:', JSON.stringify(event, null, 2));
  
  // Extraire les informations du bucket et de l'objet
  const s3Event = event.Records[0].s3;
  const bucketName = s3Event.bucket.name;
  const objectKey = decodeURIComponent(s3Event.object.key.replace(/\+/g, ' '));
  
  console.log(`Fichier ${objectKey} a été modifié dans le bucket ${bucketName}`);
  
  try {
    // Importer le SDK AWS (préinstallé dans l'environnement Lambda)
    const AWS = require('aws-sdk');
    const s3 = new AWS.S3();
    
    // Récupérer l'objet S3
    const params = {
      Bucket: bucketName,
      Key: objectKey
    };
    
    const { Body } = await s3.getObject(params).promise();
    const fileContent = Body.toString('utf-8');
    
    // Traiter le contenu du fichier (exemple: compter les lignes)
    const lineCount = fileContent.split('\n').length;
    
    // Enregistrer des métadonnées sur le fichier
    const metadataParams = {
      Bucket: bucketName,
      Key: objectKey,
      Metadata: {
        'line-count': String(lineCount),
        'processed-at': new Date().toISOString()
      },
      MetadataDirective: 'REPLACE'
    };
    
    await s3.copyObject(metadataParams).promise();
    
    console.log(`Traitement terminé. Fichier ${objectKey} contient ${lineCount} lignes.`);
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: 'Traitement S3 terminé avec succès',
        file: objectKey,
        lineCount: lineCount
      })
    };
    
  } catch (error) {
    console.error('Erreur lors du traitement du fichier S3:', error);
    throw error;
  }
}

Langages et environnements d'exécution

AWS Lambda prend en charge plusieurs langages de programmation, notamment Node.js, Python, Java, Go, .NET Core, et Ruby. Chaque environnement d'exécution fournit un ensemble de bibliothèques et d'outils spécifiques au langage.

Fonction Lambda en Python

# Fonction Lambda en Python pour traiter des données
import json
import boto3
import os
import uuid
from datetime import datetime

# Initialiser les clients AWS
dynamodb = boto3.resource('dynamodb')
sns = boto3.client('sns')

# Récupérer les variables d'environnement
TABLE_NAME = os.environ['TABLE_NAME']
NOTIFICATION_TOPIC_ARN = os.environ['NOTIFICATION_TOPIC_ARN']

# Référence à la table DynamoDB
table = dynamodb.Table(TABLE_NAME)

def lambda_handler(event, context):
    print(f"Événement reçu: {json.dumps(event)}")
    
    try:
        # Extraire les données de l'événement (par exemple, d'un API Gateway)
        body = json.loads(event.get('body', '{}'))
        
        # Valider les données requises
        if 'username' not in body or 'email' not in body:
            return {
                'statusCode': 400,
                'body': json.dumps({
                    'message': 'Les champs username et email sont obligatoires'
                })
            }
        
        # Créer un nouvel enregistrement
        timestamp = datetime.utcnow().isoformat()
        item_id = str(uuid.uuid4())
        
        item = {
            'id': item_id,
            'username': body['username'],
            'email': body['email'],
            'createdAt': timestamp,
            'updatedAt': timestamp
        }
        
        # Ajouter des champs optionnels
        if 'fullName' in body:
            item['fullName'] = body['fullName']
        
        # Sauvegarder dans DynamoDB
        table.put_item(Item=item)
        
        # Envoyer une notification
        sns.publish(
            TopicArn=NOTIFICATION_TOPIC_ARN,
            Subject='Nouvel utilisateur créé',
            Message=json.dumps({
                'event': 'USER_CREATED',
                'data': item
            })
        )
        
        # Retourner la réponse
        return {
            'statusCode': 201,
            'headers': {
                'Content-Type': 'application/json'
            },
            'body': json.dumps({
                'message': 'Utilisateur créé avec succès',
                'id': item_id
            })
        }
        
    except Exception as e:
        print(f"Erreur: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps({
                'message': 'Erreur interne du serveur',
                'error': str(e)
            })
        }

Déploiement et Infrastructure as Code

Les fonctions Lambda peuvent être déployées manuellement via la console AWS, mais sont souvent gérées avec des outils IaC (Infrastructure as Code) comme AWS CloudFormation, AWS SAM, ou le framework Serverless.

Template CloudFormation pour Lambda et API Gateway

AWSTemplateFormatVersion: '2010-09-09'
Description: 'Template CloudFormation pour déployer une fonction Lambda avec API Gateway'

Resources:
  # Rôle IAM pour Lambda
  LambdaExecutionRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
      Policies:
        - PolicyName: S3Access
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - 's3:GetObject'
                  - 's3:PutObject'
                  - 's3:PutObjectTagging'
                Resource: !Sub 'arn:aws:s3:::${DataBucket}/*'

  # Fonction Lambda
  ProcessingFunction:
    Type: 'AWS::Lambda::Function'
    Properties:
      FunctionName: 'data-processing-function'
      Handler: 'index.handler'
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile: |
          exports.handler = async (event) => {
            console.log('Événement reçu:', JSON.stringify(event, null, 2));
            // Logique de traitement
            return {
              statusCode: 200,
              body: JSON.stringify({ message: 'Traitement réussi' })
            };
          };
      Runtime: 'nodejs18.x'
      Timeout: 30
      MemorySize: 256
      Environment:
        Variables:
          BUCKET_NAME: !Ref DataBucket
          LOG_LEVEL: 'INFO'
      Tags:
        - Key: Environment
          Value: Production
        - Key: Service
          Value: DataProcessing

  # API Gateway REST API
  ApiGateway:
    Type: 'AWS::ApiGateway::RestApi'
    Properties:
      Name: 'data-processing-api'
      Description: 'API pour le service de traitement de données'

  # Méthode et ressource d'API
  ApiResource:
    Type: 'AWS::ApiGateway::Resource'
    Properties:
      ParentId: !GetAtt ApiGateway.RootResourceId
      PathPart: 'process'
      RestApiId: !Ref ApiGateway

  ApiMethod:
    Type: 'AWS::ApiGateway::Method'
    Properties:
      HttpMethod: 'POST'
      ResourceId: !Ref ApiResource
      RestApiId: !Ref ApiGateway
      AuthorizationType: 'NONE'
      Integration:
        Type: 'AWS_PROXY'
        IntegrationHttpMethod: 'POST'
        Uri: !Sub 'arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${ProcessingFunction.Arn}/invocations'

  # Permission pour API Gateway d'invoquer Lambda
  LambdaApiPermission:
    Type: 'AWS::Lambda::Permission'
    Properties:
      Action: 'lambda:InvokeFunction'
      FunctionName: !Ref ProcessingFunction
      Principal: 'apigateway.amazonaws.com'
      SourceArn: !Sub 'arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${ApiGateway}/*/POST/process'

  # Déploiement de l'API
  ApiDeployment:
    Type: 'AWS::ApiGateway::Deployment'
    DependsOn: ApiMethod
    Properties:
      RestApiId: !Ref ApiGateway
      StageName: 'prod'

  # Bucket S3 pour stocker les données
  DataBucket:
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: !Sub 'data-processing-bucket-${AWS::AccountId}'
      VersioningConfiguration:
        Status: Enabled

Outputs:
  ApiEndpoint:
    Description: 'URL de l'API'
    Value: !Sub 'https://${ApiGateway}.execute-api.${AWS::Region}.amazonaws.com/prod/process'
  
  LambdaFunction:
    Description: 'Nom de la fonction Lambda'
    Value: !Ref ProcessingFunction
  
  S3Bucket:
    Description: 'Nom du bucket S3'
    Value: !Ref DataBucket

Exemple de configuration avec le framework Serverless :

Configuration Serverless Framework

# serverless.yml
service: user-service

provider:
  name: aws
  runtime: nodejs18.x
  region: eu-west-3
  stage: ${opt:stage, 'dev'}
  memorySize: 256
  timeout: 10
  
  environment:
    NODE_ENV: ${self:provider.stage}
    DB_TABLE: ${self:service}-${self:provider.stage}
    
  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - dynamodb:Query
            - dynamodb:Scan
            - dynamodb:GetItem
            - dynamodb:PutItem
            - dynamodb:UpdateItem
            - dynamodb:DeleteItem
          Resource: !GetAtt UserTable.Arn

functions:
  createUser:
    handler: src/handlers/createUser.handler
    events:
      - http:
          path: users
          method: post
          cors: true
  
  getUser:
    handler: src/handlers/getUser.handler
    events:
      - http:
          path: users/{id}
          method: get
          cors: true
  
  listUsers:
    handler: src/handlers/listUsers.handler
    events:
      - http:
          path: users
          method: get
          cors: true
  
  updateUser:
    handler: src/handlers/updateUser.handler
    events:
      - http:
          path: users/{id}
          method: put
          cors: true
  
  deleteUser:
    handler: src/handlers/deleteUser.handler
    events:
      - http:
          path: users/{id}
          method: delete
          cors: true

resources:
  Resources:
    UserTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: ${self:provider.environment.DB_TABLE}
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: id
            AttributeType: S
        KeySchema:
          - AttributeName: id
            KeyType: HASH

Considérations de performance et limites

Démarrage à froid - La première exécution d'une fonction après un certain temps d'inactivité peut subir une latence supplémentaire appelée "démarrage à froid"
Mémoire et puissance CPU - La mémoire allouée (128 Mo à 10 Go) détermine également la puissance CPU et influence directement le temps d'exécution
Durée d'exécution - Limitée à 15 minutes maximum, ce qui rend Lambda inadapté pour les tâches de longue durée
Taille du package - Le code déployé, y compris les dépendances, ne peut pas dépasser 250 Mo décompressé ou 50 Mo compressé
Concurrence - Par défaut, 1 000 exécutions simultanées par région, mais cette limite peut être augmentée sur demande
Connexions persistantes - Les connexions aux bases de données ou autres services devraient être maintenues entre les invocations pour éviter les démarrages à froid

Bonnes pratiques

Principe de responsabilité unique - Chaque fonction Lambda devrait avoir un objectif unique et clairement défini
Gestion des dépendances - Minimisez les dépendances externes pour réduire la taille du package et le temps de démarrage
Variables d'environnement - Utilisez-les pour configurer votre fonction sans modifier le code
Journalisation et monitoring - Utilisez CloudWatch Logs et Metrics pour suivre les performances et déboguer
Gestion des erreurs - Implémentez une gestion robuste des erreurs et des stratégies de réessai
Optimisation des coûts - Ajustez la mémoire en fonction des besoins réels de votre fonction pour optimiser le rapport performance/coût
Sécurité - Suivez le principe du moindre privilège pour les rôles IAM associés à vos fonctions

Applications concrètes

Cas d'usage

APIs sans serveur

Couplé avec API Gateway, Lambda permet de créer des API RESTful ou GraphQL complètes sans gérer de serveurs, avec une mise à l'échelle automatique en fonction du trafic.

Traitement de médias à la demande

Redimensionnement d'images, transcodage vidéo avec MediaConvert, génération de vignettes ou extraction de métadonnées déclenchés par des événements S3 lorsque de nouveaux fichiers sont chargés.

ETL et traitement de données

Transformation, validation et chargement de données entre différentes sources, par exemple des fichiers CSV vers DynamoDB, ou des données en temps réel vers un data lake avec AWS Glue.

Automatisation et intégration

Fonctions qui réagissent aux événements EventBridge d'autres services AWS ou webhooks externes, parfait pour l'intégration de systèmes, les notifications via SNS et les workflows automatisés avec Step Functions.

Tâches planifiées

Remplace les traditionnels cron jobs pour exécuter des tâches périodiques comme les sauvegardes, la génération de rapports, ou le nettoyage de bases de données.

Chatbots et assistants virtuels

Combiné avec Amazon Lex, Lambda permet de créer des chatbots intelligents qui répondent aux requêtes des utilisateurs et s'intègrent à d'autres systèmes.