Comment utiliser l'API AWS Lambda pour le Serverless en 2026

En bref

L'API AWS Lambda permet aux développeurs de déployer, gérer et invoquer des fonctions sans serveur de manière programmatique. Elle utilise l'authentification IAM, des points de terminaison RESTful pour la gestion des fonctions, des options d'invocation asynchrone et synchrone, avec des limites de concurrence au niveau du compte. Ce guide couvre la configuration de l'authentification, le déploiement de fonctions, les modèles d'invocation, la cartographie des sources d'événements et les stratégies d'architecture sans serveur pour la production.

Introduction

AWS Lambda traite des milliards de requêtes chaque mois pour plus d'un million d'utilisateurs actifs. Pour les développeurs qui créent des applications sans serveur, des outils d'automatisation ou des architectures événementielles, l'intégration de l'API Lambda n'est pas facultative : elle est essentielle pour l'infrastructure en tant que code et les pipelines CI/CD.

Voici la réalité : les équipes qui gèrent manuellement plus de 50 fonctions Lambda perdent 10 à 15 heures par semaine en déploiements, mises à jour de configuration et surveillance. Une intégration solide de l'API Lambda automatise les déploiements, met en œuvre des versions bleu-vert et permet une mise à l'échelle dynamique basée sur la demande.

Ce guide vous explique le processus complet d'intégration de l'API AWS Lambda. Vous apprendrez l'authentification IAM, la création et le déploiement de fonctions, les modèles d'invocation (synchrone/asynchrone), la cartographie des sources d'événements, les architectures en couches et les stratégies de déploiement en production. À la fin, vous disposerez d'une intégration Lambda prête pour la production.

Qu'est-ce que l'API AWS Lambda ?

AWS Lambda fournit une API RESTful pour la gestion des fonctions de calcul sans serveur. L'API gère :

• La création, la mise à jour et la suppression de fonctions
• Le déploiement et le versioning du code
• L'invocation de fonctions (synchrone et asynchrone)
• La cartographie des sources d'événements (SQS, Kinesis, DynamoDB, S3)
• La gestion des couches pour le code partagé
• La configuration des alias et du routage
• La gestion de la concurrence et de la capacité réservée
• L'intégration de la journalisation et de la surveillance

Fonctionnalités Clés

Support des Runtimes Lambda

Vue d'ensemble de l'architecture API

Lambda utilise la structure d'API des services AWS :

https://lambda.{region}.amazonaws.com/2015-03-31/

Versions de l'API

Démarrer : Configuration de l'authentification

Étape 1 : Créer un compte AWS et un utilisateur IAM

Avant d'accéder à l'API :

1. Visiter la Console AWS
2. Créer un compte AWS
3. Aller à Console IAM > Utilisateurs > Créer un utilisateur
4. Attacher les politiques d'exécution Lambda

Étape 2 : Générer les informations d'identification IAM

Créez des clés d'accès pour un accès programmatique :

# AWS CLI method
aws iam create-access-key --user-name lambda-deployer

# Output: Store these securely
{
  "AccessKey": {
    "AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
    "SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
  }
}

Note de sécurité : Stockez les informations d'identification de manière sécurisée :

# ~/.aws/credentials
[lambda-deployer]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

# Or use environment variables
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
export AWS_DEFAULT_REGION="us-east-1"

Étape 3 : Comprendre AWS Signature Version 4

Toutes les requêtes de l'API Lambda nécessitent une signature SigV4 :

const crypto = require('crypto');

class AWSSigner {
  constructor(accessKeyId, secretAccessKey, region, service = 'lambda') {
    this.accessKeyId = accessKeyId;
    this.secretAccessKey = secretAccessKey;
    this.region = region;
    this.service = service;
  }

  sign(request, body = null) {
    const now = new Date();
    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, '');
    const dateStamp = amzDate.slice(0, 8);

    // Task 1: Create canonical request
    const hashedPayload = body ? crypto.createHash('sha256').update(body).digest('hex') : 'UNSIGNED-PAYLOAD';
    const canonicalUri = request.path;
    const canonicalQuerystring = request.query || '';
    const canonicalHeaders = `host:${request.host}\nx-amz-date:${amzDate}\n`;
    const signedHeaders = 'host;x-amz-date';
    const canonicalRequest = `${request.method}\n${canonicalUri}\n${canonicalQuerystring}\n${canonicalHeaders}\n${signedHeaders}\n${hashedPayload}`;

    // Task 2: Create string to sign
    const algorithm = 'AWS4-HMAC-SHA256';
    const credentialScope = `${dateStamp}/${this.region}/${this.service}/aws4_request`;
    const hash = crypto.createHash('sha256').update(canonicalRequest).digest('hex');
    const stringToSign = `${algorithm}\n${amzDate}\n${credentialScope}\n${hash}`;

    // Task 3: Calculate signature
    const kDate = this.hmac(`AWS4${this.secretAccessKey}`, dateStamp);
    const kRegion = this.hmac(kDate, this.region);
    const kService = this.hmac(kRegion, this.service);
    const kSigning = this.hmac(kService, 'aws4_request');
    const signature = this.hmac(kSigning, stringToSign, 'hex');

    // Task 4: Add authorization header
    const authorizationHeader = `${algorithm} Credential=${this.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;

    return {
      'Authorization': authorizationHeader,
      'X-Amz-Date': amzDate,
      'X-Amz-Content-Sha256': hashedPayload
    };
  }

  hmac(key, string, encoding = 'buffer') {
    return crypto.createHmac('sha256', key).update(string).digest(encoding);
  }
}

// Usage
const signer = new AWSSigner(
  process.env.AWS_ACCESS_KEY_ID,
  process.env.AWS_SECRET_ACCESS_KEY,
  'us-east-1'
);

Étape 4 : Créer un client API Lambda

const LAMBDA_BASE_URL = 'https://lambda.us-east-1.amazonaws.com/2015-03-31';

const lambdaRequest = async (path, options = {}) => {
  const url = new URL(`${LAMBDA_BASE_URL}${path}`);
  const method = options.method || 'GET';
  const body = options.body ? JSON.stringify(options.body) : null;

  const signer = new AWSSigner(
    process.env.AWS_ACCESS_KEY_ID,
    process.env.AWS_SECRET_ACCESS_KEY,
    'us-east-1'
  );

  const headers = signer.sign({ method, host: 'lambda.us-east-1.amazonaws.com', path }, body);

  const response = await fetch(url.toString(), {
    method,
    headers: {
      'Content-Type': 'application/json',
      ...headers,
      ...options.headers
    },
    body
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Lambda API Error: ${error.Message}`);
  }

  return response.json();
};

// Usage
const functions = await lambdaRequest('/functions');
console.log(`Found ${functions.Functions.length} functions`);

Alternative : Utiliser le SDK AWS

Pour une utilisation en production, le SDK AWS gère la signature automatiquement :

const { LambdaClient, ListFunctionsCommand, CreateFunctionCommand, InvokeCommand } = require('@aws-sdk/client-lambda');

const lambda = new LambdaClient({ region: 'us-east-1' });

// List functions
const listCommand = new ListFunctionsCommand({});
const result = await lambda.send(listCommand);

// Create function
const createCommand = new CreateFunctionCommand({
  FunctionName: 'my-function',
  Runtime: 'nodejs20.x',
  Role: 'arn:aws:iam::123456789012:role/lambda-execution-role',
  Handler: 'index.handler',
  Code: {
    S3Bucket: 'my-bucket',
    S3Key: 'function.zip'
  }
});

const fn = await lambda.send(createCommand);

Gestion des fonctions

Création d'une fonction

Créez une fonction Lambda via l'API :

const createFunction = async (functionConfig) => {
  const response = await lambdaRequest('/functions', {
    method: 'POST',
    body: {
      FunctionName: functionConfig.name,
      Runtime: functionConfig.runtime || 'nodejs20.x',
      Role: functionConfig.roleArn,
      Handler: functionConfig.handler || 'index.handler',
      Code: {
        S3Bucket: functionConfig.s3Bucket,
        S3Key: functionConfig.s3Key
      },
      Description: functionConfig.description || '',
      Timeout: functionConfig.timeout || 3,
      MemorySize: functionConfig.memorySize || 128,
      Environment: {
        Variables: functionConfig.environment || {}
      },
      Tags: functionConfig.tags || {}
    }
  });

  return response;
};

// Usage
const fn = await createFunction({
  name: 'order-processor',
  roleArn: 'arn:aws:iam::123456789012:role/lambda-execution-role',
  handler: 'index.handler',
  runtime: 'nodejs20.x',
  s3Bucket: 'my-deployments-bucket',
  s3Key: 'order-processor/v1.0.0.zip',
  description: 'Process orders from SQS queue',
  timeout: 30,
  memorySize: 512,
  environment: {
    DB_HOST: 'db.example.com',
    LOG_LEVEL: 'info'
  }
});

console.log(`Function created: ${fn.FunctionArn}`);

Téléchargement direct du code

Pour les petites fonctions (moins de 50 Mo compressées) :

const fs = require('fs');
const path = require('path');

const createFunctionWithZip = async (functionName, zipPath) => {
  const zipBuffer = fs.readFileSync(zipPath);
  const base64Code = zipBuffer.toString('base64');

  const response = await lambdaRequest('/functions', {
    method: 'POST',
    body: {
      FunctionName: functionName,
      Runtime: 'nodejs20.x',
      Role: 'arn:aws:iam::123456789012:role/lambda-execution-role',
      Handler: 'index.handler',
      Code: {
        ZipFile: base64Code
      }
    }
  });

  return response;
};

// Package function
// zip -r function.zip index.js node_modules/
await createFunctionWithZip('my-function', './function.zip');

Mise à jour du code de la fonction

Déployez une nouvelle version du code :

const updateFunctionCode = async (functionName, updateConfig) => {
  const response = await lambdaRequest(`/functions/${functionName}/code`, {
    method: 'PUT',
    body: {
      S3Bucket: updateConfig.s3Bucket,
      S3Key: updateConfig.s3Key,
      Publish: updateConfig.publish || false
    }
  });

  return response;
};

// Usage
const updated = await updateFunctionCode('order-processor', {
  s3Bucket: 'my-deployments-bucket',
  s3Key: 'order-processor/v1.1.0.zip',
  publish: true // Create new version
});

console.log(`Updated to version: ${updated.Version}`);

Mise à jour de la configuration de la fonction

Modifiez le délai d'expiration, la mémoire, l'environnement :

const updateFunctionConfig = async (functionName, config) => {
  const response = await lambdaRequest(`/functions/${functionName}/configuration`, {
    method: 'PUT',
    body: {
      Runtime: config.runtime,
      Handler: config.handler,
      Description: config.description,
      Timeout: config.timeout,
      MemorySize: config.memorySize,
      Environment: {
        Variables: config.environment
      }
    }
  });

  return response;
};

// Usage
const updated = await updateFunctionConfig('order-processor', {
  timeout: 60,
  memorySize: 1024,
  environment: {
    DB_HOST: 'new-db.example.com',
    LOG_LEVEL: 'debug'
  }
});

Suppression d'une fonction

Supprimez la fonction :

const deleteFunction = async (functionName, qualifier = null) => {
  const path = qualifier
    ? `/functions/${functionName}?Qualifier=${qualifier}`
    : `/functions/${functionName}`;

  await lambdaRequest(path, { method: 'DELETE' });
  console.log(`Function ${functionName} deleted`);
};

Invocation de fonctions

Invocation synchrone (requête-réponse)

Invoquez la fonction et attendez la réponse :

const invokeFunction = async (functionName, payload, qualifier = null) => {
  const path = qualifier
    ? `/functions/${functionName}/invocations?Qualifier=${qualifier}`
    : `/functions/${functionName}/invocations`;

  const response = await lambdaRequest(path, {
    method: 'POST',
    headers: {
      'X-Amz-Invocation-Type': 'RequestResponse', // Synchronous
      'X-Amz-Log-Type': 'Tail' // Include logs
    },
    body: payload
  });

  // Parse response
  const result = JSON.parse(Buffer.from(response.Payload).toString());
  const logs = Buffer.from(response.LogResult, 'base64').toString();

  return { result, logs };
};

// Usage
const { result, logs } = await invokeFunction('order-processor', {
  orderId: 'ORD-12345',
  customerId: 'CUST-67890',
  items: [
    { sku: 'PROD-001', quantity: 2 },
    { sku: 'PROD-002', quantity: 1 }
  ]
});

console.log(`Result: ${JSON.stringify(result)}`);
console.log(`Logs:\n${logs}`);

Invocation asynchrone (sans attente)

Invoquez la fonction sans attendre :

const invokeAsync = async (functionName, payload) => {
  const response = await lambdaRequest(`/functions/${functionName}/invocations`, {
    method: 'POST',
    headers: {
      'X-Amz-Invocation-Type': 'Event', // Asynchronous
      'X-Amz-Log-Type': 'None'
    },
    body: payload
  });

  return {
    statusCode: response.StatusCode,
    executionId: response['X-Amz-Execution-Id']
  };
};

// Usage - trigger async processing
const result = await invokeAsync('email-sender', {
  to: 'customer@example.com',
  template: 'order-confirmation',
  data: { orderId: 'ORD-12345' }
});

console.log(`Async invocation ID: ${result.executionId}`);

Invocation à blanc (Dry Run)

Testez les autorisations sans exécuter :

const dryRunInvocation = async (functionName) => {
  const response = await lambdaRequest(`/functions/${functionName}/invocations`, {
    method: 'POST',
    headers: {
      'X-Amz-Invocation-Type': 'DryRun'
    }
  });

  return response;
};

// Usage - verify IAM permissions
try {
  await dryRunInvocation('order-processor');
  console.log('Invocation permissions OK');
} catch (error) {
  console.error('Permission denied:', error.message);
}

Types de réponse d'invocation

Gestion des versions et des alias

Publication de versions

Créez une version immuable de la fonction :

const publishVersion = async (functionName, description = null) => {
  const response = await lambdaRequest(`/functions/${functionName}/versions`, {
    method: 'POST',
    body: description ? { Description: description } : {}
  });

  return response;
};

// Usage
const version = await publishVersion('order-processor', 'v1.2.0 - Add tax calculation');
console.log(`Published version: ${version.Version}`);

Création d'alias

Créez un pointeur nommé vers une version :

const createAlias = async (functionName, aliasName, version, description = null) => {
  const response = await lambdaRequest(`/functions/${functionName}/aliases`, {
    method: 'POST',
    body: {
      Name: aliasName,
      FunctionVersion: version,
      Description: description
    }
  });

  return response;
};

// Usage - Create production alias
const prodAlias = await createAlias('order-processor', 'prod', '5', 'Production version');
console.log(`Alias ARN: ${prodAlias.AliasArn}`);

Déplacement de trafic avec la configuration de routage

Déplacez progressivement le trafic vers la nouvelle version :

const updateAliasWithRouting = async (functionName, aliasName, routingConfig) => {
  const response = await lambdaRequest(`/functions/${functionName}/aliases/${aliasName}`, {
    method: 'PUT',
    body: {
      RoutingConfig: {
        AdditionalVersionWeights: routingConfig
      }
    }
  });

  return response;
};

// Usage - 10% traffic to version 6, 90% to version 5
await updateAliasWithRouting('order-processor', 'prod', {
  '6': 0.1
});

// After validation, shift to 100%
await updateAliasWithRouting('order-processor', 'prod', {});

Cas d'utilisation des alias

Cartographie des sources d'événements

Création d'un déclencheur SQS

Connectez une file d'attente SQS à Lambda :

const createSQSEventSource = async (functionName, queueArn, batchSize = 10) => {
  const response = await lambdaRequest('/event-source-mappings', {
    method: 'POST',
    body: {
      EventSourceArn: queueArn,
      FunctionName: functionName,
      BatchSize: batchSize,
      Enabled: true
    }
  });

  return response;
};

// Usage
const mapping = await createSQSEventSource(
  'order-processor',
  'arn:aws:sqs:us-east-1:123456789012:orders-queue',
  10
);

console.log(`Event source created: ${mapping.UUID}`);

Création d'un déclencheur DynamoDB Stream

Connectez un flux DynamoDB à Lambda :

const createDynamoDBEventSource = async (functionName, streamArn, startingPosition = 'LATEST') => {
  const response = await lambdaRequest('/event-source-mappings', {
    method: 'POST',
    body: {
      EventSourceArn: streamArn,
      FunctionName: functionName,
      StartingPosition: startingPosition,
      BatchSize: 100,
      BisectBatchOnFunctionError: true,
      MaximumRetryAttempts: 3
    }
  });

  return response;
};

// Usage
await createDynamoDBEventSource(
  'user-analytics',
  'arn:aws:dynamodb:us-east-1:123456789012:table/Users/stream/2026-03-25T00:00:00.000'
);

Types de sources d'événements

Gestion des couches

Création d'une couche

Empaquetez le code/les dépendances partagés :

const createLayer = async (layerName, layerConfig) => {
  const response = await lambdaRequest('/layers', {
    method: 'POST',
    body: {
      LayerName: layerName,
      Description: layerConfig.description,
      CompatibleRuntimes: layerConfig.runtimes,
      Content: {
        S3Bucket: layerConfig.s3Bucket,
        S3Key: layerConfig.s3Key
      }
    }
  });

  return response;
};

// Usage
const layer = await createLayer('shared-utils', {
  description: 'Shared utilities and dependencies',
  runtimes: ['nodejs20.x', 'nodejs18.x'],
  s3Bucket: 'my-layers-bucket',
  s3Key: 'shared-utils/v1.zip'
});

console.log(`Layer ARN: ${layer.LayerArn}`);

Utilisation de couches dans les fonctions

Attachez des couches à la fonction :

const createFunctionWithLayers = async (functionConfig) => {
  const response = await lambdaRequest('/functions', {
    method: 'POST',
    body: {
      FunctionName: functionConfig.name,
      Runtime: functionConfig.runtime,
      Role: functionConfig.roleArn,
      Handler: functionConfig.handler,
      Code: {
        S3Bucket: functionConfig.s3Bucket,
        S3Key: functionConfig.s3Key
      },
      Layers: functionConfig.layers // Array of layer ARNs
    }
  });

  return response;
};

// Usage
await createFunctionWithLayers({
  name: 'api-handler',
  roleArn: 'arn:aws:iam::123456789012:role/lambda-execution-role',
  handler: 'index.handler',
  runtime: 'nodejs20.x',
  s3Bucket: 'my-deployments-bucket',
  s3Key: 'api-handler/v1.0.0.zip',
  layers: [
    'arn:aws:lambda:us-east-1:123456789012:layer:shared-utils:1',
    'arn:aws:lambda:us-east-1:123456789012:layer:aws-sdk:3'
  ]
});

Concurrence et mise à l'échelle

Définition de la concurrence réservée

Réservez de la capacité pour les fonctions critiques :

const putFunctionConcurrency = async (functionName, reservedConcurrentExecutions) => {
  const response = await lambdaRequest(`/functions/${functionName}/concurrency`, {
    method: 'PUT',
    body: {
      ReservedConcurrentExecutions: reservedConcurrentExecutions
    }
  });

  return response;
};

// Usage - Reserve 100 concurrent executions
await putFunctionConcurrency('order-processor', 100);

Limites de concurrence du compte

Liste de contrôle pour le déploiement en production

Avant de déployer en production :

• [ ] Utiliser le SDK AWS pour la signature automatique SigV4
• [ ] Mettre en œuvre le versioning avec des alias
• [ ] Configurer la concurrence réservée pour les fonctions critiques
• [ ] Configurer des files d'attente de lettres mortes (DLQ) pour les invocations asynchrones
• [ ] Activer le traçage X-Ray pour le débogage
• [ ] Configurer le VPC pour l'accès à la base de données
• [ ] Implémenter la journalisation structurée (format JSON)
• [ ] Configurer les alarmes CloudWatch
• [ ] Utiliser des couches pour les dépendances partagées
• [ ] Implémenter une stratégie de déploiement bleu-vert

Cas d'utilisation concrets

Backend d'API

Une entreprise SaaS construit une API REST sans serveur :

• Défi : Trafic variable, mise à l'échelle imprévisible
• Solution : Lambda + API Gateway avec auto-scaling
• Résultat : 99,99 % de disponibilité, 60 % de réduction des coûts par rapport à EC2

Mise en œuvre clé :

• Fonctions Lambda par ressource
• API Gateway pour le routage/l'authentification
• DynamoDB pour le stockage des données
• Concurrence provisionnée pour une latence constante

Pipeline de traitement d'événements

Une plateforme de commerce électronique traite les commandes :

• Défi : Pics de commandes pendant les événements commerciaux
• Solution : SQS + Lambda avec traitement par lots
• Résultat : Aucune commande perdue, gestion des pics 10x

Mise en œuvre clé :

• La file d'attente SQS met en tampon les commandes
• Lambda traite 10 messages/lot
• DLQ pour les messages échoués
• Alertes CloudWatch sur la profondeur de la file d'attente

Conclusion

L'API AWS Lambda offre des capacités de calcul sans serveur complètes. Points clés à retenir :

• Authentification IAM avec signature SigV4 (utiliser le SDK AWS)
• Modèles d'invocation synchrones et asynchrones
• Gestion des versions et des alias pour les déploiements
• Cartographie des sources d'événements pour les architectures sans serveur
• Couches pour le code et les dépendances partagés
• Apidog rationalise les tests API et la collaboration d'équipe

Section FAQ

Comment m'authentifier auprès de l'API Lambda ?

Utilisez les informations d'identification AWS IAM avec la signature Version 4. Le SDK AWS gère la signature automatiquement.

Quelle est la différence entre l'invocation synchrone et asynchrone ?

L'invocation synchrone (RequestResponse) attend l'achèvement de la fonction et renvoie les résultats. L'invocation asynchrone (Event) met la requête en file d'attente et renvoie immédiatement.

Comment fonctionnent les versions Lambda ?

Chaque version publiée est un instantané immuable de votre fonction. Utilisez des alias pour pointer vers des versions spécifiques et permettre le déplacement de trafic.

Que sont les couches Lambda ?

Les couches regroupent le code et les dépendances séparément du code de la fonction, permettant le partage de bibliothèques entre plusieurs fonctions.

Comment réduire les démarrages à froid ?

Utilisez la concurrence provisionnée, des paquets de déploiement plus petits et des langages compilés (Go, Rust) pour les fonctions critiques en latence.

Qu'est-ce que la concurrence réservée ?

La concurrence réservée garantit des créneaux d'exécution pour des fonctions spécifiques, évitant ainsi les problèmes de "voisin bruyant".

Puis-je déclencher Lambda depuis S3 ?

Oui, configurez les notifications d'événements S3 pour invoquer Lambda lors de la création/suppression d'objets.