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 20+

# 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 : nodejs20.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 20
- 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: nodejs20.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: nodejs20.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.

Articles Connexes

• Claude Code × AWS S3 Automatisation des Opérations
• Claude Code × AWS DynamoDB Conception de Schéma
• Guide Complet des Bonnes Pratiques de Sécurité avec Claude Code

Références

• Documentation Officielle AWS Lambda
• Documentation Officielle AWS SAM
• AWS SDK pour JavaScript v3