Claude Code × AWS Lambda Guide Complet | De la Génération de Fonctions à l'Automatisation du Déploiement

Avez-vous déjà vécu ces situations lors du développement AWS Lambda ? Les définitions de types pour les handlers sont fastidieuses, vous devez rechercher les politiques IAM à chaque fois, vous avez oublié comment écrire des templates SAM… Claude Code résout tout cela d’un coup.

De l’implémentation de fonctions Lambda à la génération de politiques IAM, en passant par les tests locaux et le déploiement en production — nous parcourons chaque étape du développement ultra-rapide d’AWS Lambda avec Claude Code à l’aide d’exemples de code concrets.

Pourquoi Claude Code × AWS Lambda ?

Les « parties fastidieuses » du développement Lambda sont presque entièrement du code répétitif (boilerplate).

Définitions de types pour les fonctions handler (APIGatewayProxyHandler, S3Handler …)
Gestion des erreurs et formats de réponse
Conception de politiques IAM selon le principe du moindre privilège
Rédaction de templates SAM / CloudFormation
Configuration de l’environnement de test local

Claude Code génère tout cela avec une simple phrase comme « Je veux une Lambda qui fait X ». Combiné avec AWS CLI et SAM CLI, vous pouvez exécuter tout le processus, de la génération de code au déploiement, en une seule fois.

Configuration de l’Environnement

# Vérifier les outils nécessaires
aws --version        # AWS CLI v2
sam --version        # SAM CLI 1.100+
node --version       # Node.js 24+

# Configurer les identifiants AWS (si pas encore configurés)
aws configure
# → Access Key ID, Secret Access Key, Region (eu-west-3), Output (json)

<!-- Ajouter au CLAUDE.md -->
## Configuration AWS
- Région par défaut : eu-west-3 (Paris)
- Runtime Lambda : nodejs24.x
- Outil de déploiement : AWS SAM
- Répertoire source : src/functions/
- Template SAM : template.yaml
- Nom du stack : my-app-{dev|staging|prod}

## Directives de Politique IAM
- Appliquer strictement le principe du moindre privilège
- Ne pas utiliser de caractères génériques (*)
- Spécifier les ARN de ressources de manière concrète

Exemple 1 : API Gateway + Lambda (REST API)

Le modèle le plus fondamental — une Lambda qui reçoit des requêtes HTTP et les traite.

Instructions pour Claude Code

claude -p "
Quand une requête GET arrive sur /users/{userId},
récupérer les informations utilisateur depuis la table DynamoDB Users et les retourner.
Implémenter la fonction Lambda en TypeScript.

- Runtime : Node.js 24
- Nom de table : UsersTable (reçu via variable d'environnement)
- Gestion des erreurs : retourner les réponses 404/500 appropriées
- Définitions de types : utiliser @types/aws-lambda
- Sortie vers : src/functions/getUser/index.ts
"

Implémentation Générée

// src/functions/getUser/index.ts
import {
  APIGatewayProxyHandler,
  APIGatewayProxyResult,
} from "aws-lambda";
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";

const client = new DynamoDBClient({ region: process.env.AWS_REGION });
const ddb = DynamoDBDocumentClient.from(client);

const response = (statusCode: number, body: unknown): APIGatewayProxyResult => ({
  statusCode,
  headers: {
    "Content-Type": "application/json",
    "Access-Control-Allow-Origin": "*",
  },
  body: JSON.stringify(body),
});

export const handler: APIGatewayProxyHandler = async (event) => {
  const userId = event.pathParameters?.userId;

  if (!userId) {
    return response(400, { error: "userId is required" });
  }

  try {
    const result = await ddb.send(
      new GetCommand({
        TableName: process.env.USERS_TABLE!,
        Key: { userId },
      })
    );

    if (!result.Item) {
      return response(404, { error: `User '${userId}' not found` });
    }

    return response(200, result.Item);
  } catch (err) {
    console.error("DynamoDB error:", err);
    return response(500, { error: "Internal server error" });
  }
};

Le Template SAM Est Également Généré Automatiquement

# template.yaml (extrait)
GetUserFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: src/functions/getUser/index.handler
    Runtime: nodejs24.x
    Timeout: 10
    Environment:
      Variables:
        USERS_TABLE: !Ref UsersTable
    Policies:
      - DynamoDBReadPolicy:
          TableName: !Ref UsersTable
    Events:
      GetUserApi:
        Type: Api
        Properties:
          Path: /users/{userId}
          Method: GET

UsersTable:
  Type: AWS::DynamoDB::Table
  Properties:
    TableName: !Sub "${AWS::StackName}-users"
    BillingMode: PAY_PER_REQUEST
    AttributeDefinitions:
      - AttributeName: userId
        AttributeType: S
    KeySchema:
      - AttributeName: userId
        KeyType: HASH

Exemple 2 : Lambda avec Déclencheur d’Événement S3

Une Lambda déclenchée par des chargements de fichiers pour exécuter des traitements.

// src/functions/generateThumbnail/index.ts
import { S3Handler } from "aws-lambda";
import { S3Client, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
import sharp from "sharp";

const s3 = new S3Client({ region: process.env.AWS_REGION });

export const handler: S3Handler = async (event) => {
  const record = event.Records[0];
  const bucket = record.s3.bucket.name;
  const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, " "));

  // Ignorer le préfixe thumbnails/ (prévenir la boucle infinie)
  if (key.startsWith("thumbnails/")) return;

  const { Body } = await s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
  const buffer = Buffer.from(await Body!.transformToByteArray());

  const thumbnail = await sharp(buffer)
    .resize(200, 200, { fit: "cover" })
    .webp({ quality: 85 })
    .toBuffer();

  const thumbnailKey = `thumbnails/${key.replace(/\.[^.]+$/, ".webp")}`;
  await s3.send(
    new PutObjectCommand({
      Bucket: bucket,
      Key: thumbnailKey,
      Body: thumbnail,
      ContentType: "image/webp",
    })
  );

  console.log(`Miniature créée : s3://${bucket}/${thumbnailKey}`);
};

Exemple 3 : Lambda Planifiée (EventBridge)

# Configuration EventBridge dans template.yaml
SendReminderFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: src/functions/sendReminder/index.handler
    Runtime: nodejs24.x
    Timeout: 300
    Environment:
      Variables:
        DATABASE_URL: !Sub "{{resolve:secretsmanager:${AWS::StackName}/database-url}}"
        RESEND_API_KEY: !Sub "{{resolve:secretsmanager:${AWS::StackName}/resend-api-key}}"
    Events:
      DailyReminder:
        Type: Schedule
        Properties:
          Schedule: cron(0 0 * * ? *)  # UTC 0:00 = Paris 1:00 (heure d'hiver) / 2:00 (heure d'été)

Laisser Claude Code Concevoir les Politiques IAM

claude -p "
Générer une politique IAM de moindre privilège en JSON pour une Lambda qui a besoin :
- GetObject depuis le bucket S3 my-uploads
- PutItem/UpdateItem sur la table DynamoDB ProcessingJobs
- SendMessage vers la file SQS ProcessingQueue
- Écrire dans CloudWatch Logs

Déduire les ARN spécifiques à partir des noms de ressources fournis.
"

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::my-uploads/*"
    },
    {
      "Effect": "Allow",
      "Action": ["dynamodb:PutItem", "dynamodb:UpdateItem"],
      "Resource": "arn:aws:dynamodb:eu-west-3:*:table/ProcessingJobs"
    },
    {
      "Effect": "Allow",
      "Action": ["sqs:SendMessage"],
      "Resource": "arn:aws:sqs:eu-west-3:*:ProcessingQueue"
    },
    {
      "Effect": "Allow",
      "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
      "Resource": "arn:aws:logs:*:*:log-group:/aws/lambda/*"
    }
  ]
}

Tests Locaux et Déploiement en Production

# Compiler
sam build

# Démarrer l'API localement
sam local start-api --port 3001

# Invocation de test unique
sam local invoke GetUserFunction --event events/get-user.json

# Tout exécuter avec Claude Code
claude -p "
Exécuter sam build,
vérifier les résultats avec sam local invoke GetUserFunction --event events/test-get-user.json.
Si tout est correct, exécuter sam deploy --config-env dev.
"

Les 5 Pièges les Plus Courants

1. Initialisation qui ignore les démarrages à froid (cold starts)

// ❌ Créer le client à l'intérieur du handler à chaque invocation
export const handler = async () => {
  const ddb = new DynamoDBClient({});  // ← instancié à chaque invocation
};

// ✅ Initialiser une fois dans la portée du module
const ddb = DynamoDBDocumentClient.from(new DynamoDBClient({}));
export const handler = async () => { /* réutiliser ddb */ };

2. Laisser le timeout à la valeur par défaut (3 secondes) Pour DynamoDB + APIs externes, définir au moins 10-30 secondes. Toujours configurer selon les exigences réelles de traitement.

3. Écrire les secrets directement dans les variables d’environnement

# ❌ Codé en dur dans le template
Environment:
  Variables:
    DB_PASSWORD: "my-secret"

# ✅ Via Secrets Manager
Environment:
  Variables:
    DB_PASSWORD: !Sub "{{resolve:secretsmanager:myapp/db-password}}"

4. Délais de démarrage à froid avec Lambda dans VPC Placer une Lambda dans un VPC pour la connectivité RDS ajoute plusieurs secondes au démarrage à froid. Résoudre avec Provisioned Concurrency ou RDS Proxy.

5. Packages de déploiement surdimensionnés Packager node_modules ensemble peut atteindre la limite de 250 Mo. Déplacer les bibliothèques partagées vers un Lambda Layer.

Récapitulatif

Tâche	Contribution de Claude Code
Implémentation du handler	Générer les définitions de types, la gestion des erreurs et la logique en une seule fois
Template SAM	Sortie automatique des événements, IAM et variables d’environnement
Politique IAM	Générer avec précision des conceptions de moindre privilège
Tests locaux	Automatiser l’exécution de sam invoke et l’évaluation des résultats
Déploiement	Exécuter build + deploy comme un flux de travail unifié

Claude Code prend en charge les parties les plus chronophages du développement Lambda — les définitions de types et la rédaction de templates. Se concentrer sur la logique métier peut multiplier la vitesse d’implémentation par 3 à 5.

Quand Lambda convient ou non

Lambda convient aux tâches courtes, événementielles et rejouables sans danger: API de commande, image après upload S3, rapport EventBridge quotidien, webhooks Stripe ou GitHub. Elle convient mal aux workers longs, connexions persistantes, gros modèles chauds ou WebSocket très stateful. Demandez à Claude Code les raisons pour et contre avant le code.

Termes expliqués simplement

Term	Plain meaning
handler	The function Lambda calls. API Gateway passes an HTTP event; S3 passes an object event.
event	The JSON payload given to Lambda. API Gateway, S3, and EventBridge shapes are different.
least privilege	Grant only the exact actions and resources the function needs.
cold start	The slower first run when Lambda creates a new execution environment.
idempotency	The same event can run twice without duplicate payment, email, or database writes.

Test unitaire copiable pour Node.js 24

// test/getUser.test.ts
import { describe, expect, it, vi } from "vitest";
import type { APIGatewayProxyEvent } from "aws-lambda";

const mockSend = vi.fn();
vi.mock("@aws-sdk/lib-dynamodb", async () => {
  const actual = await vi.importActual<typeof import("@aws-sdk/lib-dynamodb")>("@aws-sdk/lib-dynamodb");
  return { ...actual, DynamoDBDocumentClient: { from: () => ({ send: mockSend }) } };
});

const { handler } = await import("../src/functions/getUser/index");

function event(userId?: string): APIGatewayProxyEvent {
  return {
    pathParameters: userId ? { userId } : null,
    httpMethod: "GET",
    path: userId ? "/users/" + userId : "/users",
    headers: {},
    multiValueHeaders: {},
    queryStringParameters: null,
    multiValueQueryStringParameters: null,
    body: null,
    isBase64Encoded: false,
    requestContext: {} as APIGatewayProxyEvent["requestContext"],
    resource: "/users/{userId}",
    stageVariables: null,
  };
}

describe("getUser Lambda", () => {
  it("returns 200 when the user exists", async () => {
    process.env.USERS_TABLE = "UsersTable";
    mockSend.mockResolvedValueOnce({ Item: { userId: "u-1", name: "Masa" } });

    const res = await handler(event("u-1"), {} as never, vi.fn());

    expect(res.statusCode).toBe(200);
    expect(JSON.parse(res.body).userId).toBe("u-1");
  });

  it("returns 400 when path parameter is missing", async () => {
    const res = await handler(event(), {} as never, vi.fn());
    expect(res.statusCode).toBe(400);
  });
});

Séparer les événements API Gateway, S3 et EventBridge

API Gateway demandestatusCode etbody. S3 lit bucket/key dansRecords. EventBridge inspecte souventsource, detail-type et detail. Nommez précisément le trigger: HTTP API v2, S3 ObjectCreated ou EventBridge schedule.

Variables, Secrets Manager et IAM en moindre privilège

Les variables servent à la configuration commeUSERS_TABLE etAPP_STAGE. Les clés API, mots de passe et secrets webhook vont dans Secrets Manager; Lambda reçoit seulement l’ARN. IAM doit viser des actions et ARN précis.

CloudWatch Logs, retries et idempotence

CloudWatch Logs est le premier diagnostic. Sans logs, vérifiez région, fonction, permissions du rôle et stack. S3, EventBridge et invokes asynchrones peuvent rejouer; utilisez des IDs comme clés d’idempotence.

Prompt de revue sécurité pour Claude Code

Review this AWS Lambda change before production.
Check handler shape, API Gateway/S3/EventBridge event type, IAM least privilege, Secrets Manager usage, CloudWatch Logs, retries, idempotency, cold starts, timeout, memory, and cost risk.
Return blockers first, then recommended fixes, missing tests, and human approvals required before deploy.

CTA monétisation, formation et conseil

ClaudeCodeLab propose formation et conseil pour Lambda, IAM, SAM, audit de logs et gates de revue. Les solos commencent par PDF gratuit et Gumroad; les équipes utilisent formation et conseil pour permissions, approvals et revenus.

Résultat vérifié

J’ai séparé les exemples en handler et tests vérifiables avecnpm test. Pas desam deploy réel car compte, région, ARN et table varient. En production, notezsam validate --lint, sam build, sam local invoke, logs et revue IAM.