EventBridge avancé CDK 2026 (55 chars)

Introduction

Amazon EventBridge est le service AWS pivotal pour router des événements à l'échelle, reliant S3, Lambda, DynamoDB et services tiers via des bus événementiels. En 2026, avec l'essor du serverless, il excelle dans les architectures event-driven, filtrant des millions d'événements par seconde sans polling. Ce tutoriel avancé vous guide pour créer un bus custom, des règles avec matching JSON avancé, des schémas registry, et des targets Lambda avec dead-letter queues. Imaginez un pipeline où un upload S3 déclenche une analyse ML via EventBridge : c'est cette puissance que nous implémentons via AWS CDK pour une IaC reproductible. À la fin, vous déployez un système résilient, monitoré, prêt pour la prod. (142 mots)

Prérequis

Compte AWS avec droits IAM administrateur (ou CDK deploy)
Node.js 20+ et AWS CDK 2.140+ installé
AWS CLI v2 configuré (aws configure)
Connaissances avancées en TypeScript, Lambda et événements JSON
Région AWS eu-west-1 pour cet exemple

Bootstrap CDK et init projet

terminal-setup.sh

npm install -g aws-cdk@2
mkdir eventbridge-advanced && cd eventbridge-advanced
cdk init app --language typescript
npm install aws-cdk-lib constructs @aws-sdk/client-eventbridge
cdk bootstrap aws://$(aws sts get-caller-identity --query Account --output text)/eu-west-1

Ce script installe CDK globalement, initialise un projet TypeScript vide, ajoute les libs CDK et EventBridge SDK, puis bootstrappe l'environnement pour les assets comme Lambda zips. Évitez les régions sans support EventBridge ; testez avec cdk ls.

Structure du stack CDK

Nous créons un stack EventBridgeStack avec un bus custom, une règle filtrant des événements user.signup d'un pattern spécifique, un schéma registry pour validation, et un Lambda target avec DLQ. Le CDK synthétise en CloudFormation pour une gestion déclarative.

Stack EventBus et règle basique

lib/eventbridge-stack.ts

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as events from 'aws-cdk-lib/aws-events';
import * as targets from 'aws-cdk-lib/aws-events-targets';
import * as lambda from 'aws-cdk-lib/aws-lambda';

export class EventBridgeStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const eventBus = new events.EventBus(this, 'CustomEventBus', {
      eventBusName: 'MyAdvancedEventBus'
    });

    const handler = new lambda.Function(this, 'EventHandler', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index.handler',
      code: lambda.Code.fromInline('exports.handler = (event) => { console.log(event); return { statusCode: 200 }; };')
    });

    const rule = eventBus.addRule(this, 'SignupRule', {
      ruleName: 'user-signup-rule',
      eventPattern: {
        source: ['myapp'],
        detailType: ['user.signup'],
        detail: {
          userType: ['premium']
        }
      }
    });

    rule.addTarget(new targets.LambdaFunction(handler));
  }
}

Ce stack crée un EventBus custom nommé 'MyAdvancedEventBus', un Lambda inline simple comme target, et une règle matching les événements myapp:user.signup où detail.userType=premium. Le pattern JSON filtre précisément ; grant permissions auto via CDK.

Ajout de schéma et DLQ

Analogie : Un schéma EventBridge agit comme un contrat JSON strict, validant les payloads entrants comme un Pydantic pour Python. Nous l'enregistrons dans le Schema Registry et l'associons à la règle pour rejeter les événements malformés.

Schéma registry et DLQ avancée

user-signup-schema.json

{
  "type": "object",
  "title": "UserSignupSchema",
  "required": ["userId", "email", "userType"],
  "properties": {
    "userId": { "type": "string", "pattern": "^[a-zA-Z0-9]{10,}$" },
    "email": { "type": "string", "format": "email" },
    "userType": { "type": "string", "enum": ["basic", "premium"] },
    "metadata": { "type": "object" }
  }
}

Ce schéma JSON valide les événements signup : userId alphanumérique >10 chars, email valide, userType enum. Importez-le via CLI ou CDK pour associer à la règle ; non-conformes vont en DLQ SQS auto-créée.

Intégration schéma et DLQ dans stack

lib/eventbridge-stack-enhanced.ts

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as events from 'aws-cdk-lib/aws-events';
import * as schemas from 'aws-cdk-lib/aws-eventschemas';
import * as targets from 'aws-cdk-lib/aws-events-targets';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as sqs from 'aws-cdk-lib/aws-sqs';
import * as iam from 'aws-cdk-lib/aws-iam';

export class EventBridgeStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const eventBus = new events.EventBus(this, 'CustomEventBus', { eventBusName: 'MyAdvancedEventBus' });

    const schema = new schemas.CfnRegistrySchema(this, 'SignupSchema', {
      registryName: 'MySchemaRegistry',
      schemaName: 'UserSignup',
      type: 'OpenApi3',
      content: JSON.stringify({
        openapi: '3.0.0',
        components: { schemas: { UserSignup: { /* schéma JSON ci-dessus converti */ type: 'object', properties: { userId: {type:'string'}, email:{type:'string'}, userType:{type:'string'} } } } }
      })
    });

    const dlq = new sqs.Queue(this, 'DLQ');

    const handler = new lambda.Function(this, 'EventHandler', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index.handler',
      code: lambda.Code.fromInline('exports.handler = async (event) => { console.log(JSON.stringify(event, null, 2)); return { statusCode: 200 }; };'),
      deadLetterQueueEnabled: true,
      deadLetterQueue: dlq
    });

    eventBus.grantPutEventsTo(handler);

    const rule = eventBus.addRule(this, 'SignupRule', {
      ruleName: 'user-signup-rule',
      eventPattern: {
        source: ['myapp'],
        detailType: ['user.signup'],
        detail: {
          userType: ['premium']
        }
      },
      deadLetterQueue: dlq
    });

    rule.addTarget(new targets.LambdaFunction(handler));
  }
}

Amélioration : ajoute Schema Registry OpenAPI3 (simulé du JSON), DLQ SQS pour retries, et grants IAM auto. Le schéma valide au runtime ; événements invalides routés DLQ. CDK gère les deps cross-service.

Déploiement et configuration app

Dans bin/eventbridge-advanced.ts, instanciez le stack : new EventBridgeStack(app, 'EventBridgeStack', { env: { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'eu-west-1' } });. Exécutez npm run build && cdk deploy.

Test avec AWS CLI PutEvents

test-events.sh

EVENT_DATA='{"source":"myapp","detail-type":"user.signup","detail":{"userId":"user123abcde","email":"user@premium.com","userType":"premium"}}'
aws events put-events --entries '{"EventBusName":"MyAdvancedEventBus","Source":"myapp","DetailType":"user.signup","Detail":"'$EVENT_DATA'"}' --region eu-west-1

# Événement invalide pour DLQ
aws events put-events --entries '{"EventBusName":"MyAdvancedEventBus","Source":"myapp","DetailType":"user.signup","Detail":"{\"userType\":\"invalid\"}"}' --region eu-west-1

# Vérif DLQ
aws sqs receive-message --queue-url $(aws sqs get-queue-attributes --queue-url $(aws events describe-event-bus --name MyAdvancedEventBus --query 'DeadLetterQueueArn' --output text | cut -d: -f7-) --attribute-names ApproximateNumberOfMessages --output text | grep -o 'https[^ ]*') --region eu-west-1

Ce script envoie un événement valide (match règle, traite Lambda) et un invalide (DLQ). receive-message check DLQ ; adaptez URL. Logs Lambda via CloudWatch pour debug.

Lambda handler avancé avec parsing

lambda/index.ts

import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';

export const handler = async (event: any): Promise<any> => {
  console.log('Event reçu:', JSON.stringify(event, null, 2));

  const detail = JSON.parse(event.detail || '{}');
  if (detail.userType !== 'premium') {
    throw new Error('User non premium');
  }

  // Simule traitement async (ex: appel DynamoDB)
  await new Promise(resolve => setTimeout(resolve, 100));

  return {
    statusCode: 200,
    body: JSON.stringify({ message: `Traitement OK pour ${detail.userId}`, processedAt: new Date().toISOString() })
  };
};

Handler Node.js 20 parse event.detail, valide userType, simule async. Erreurs -> DLQ auto. Packagez via esbuild ou CDK Asset pour prod ; logs structurés pour X-Ray.

Monitoring avec CloudWatch alarms

lib/monitoring-addons.ts

import * as cdk from 'aws-cdk-lib';
import * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';
import * as events from 'aws-cdk-lib/aws-events';
// Dans le stack :
const eventBus = /* ... */;
new cloudwatch.Alarm(this, 'HighFailedInvocations', {
  metric: eventBus.metricFailedInvocations(),
  threshold: 5,
  evaluationPeriods: 2,
  alarmDescription: 'Plus de 5 invocations échouées par période'
});
new cloudwatch.Alarm(this, 'DLQDepthAlarm', {
  metric: dlq.metricApproximateNumberOfMessagesVisible(),
  threshold: 10,
  evaluationPeriods: 1
});

Ajoute alarms CW sur failed invocations EventBridge et DLQ depth. Seuil 5/2 périodes pour bus, 10 pour DLQ. Intégrez SNS pour alerts ; metricId pour dashboards custom.

Bonnes pratiques

Filtrage avancé : Utilisez detail-map pour nested JSON ; testez patterns via Console EventBridge.
Sécurité : Appliquez least-privilege IAM via CDK grantPutEventsTo ; activez encryption KMS sur bus.
Scalabilité : Batchez targets multiples (Lambda + StepFunctions) ; utilisez Partner Events pour SaaS.
Schéma first : Toujours registry pour evolution safe ; versionnez schemas.
Replay : Archivez événements S3 pour replay en cas de bug.

Erreurs courantes à éviter

Oublier eventBus.grantPutEventsTo(target) : Producers échouent 403.
Patterns trop larges : {"source":["*"]} surcharge Lambda ; affinez avec detail.userId[0] == "A".
Pas de DLQ : Événements perdus sur Lambda throttle ; toujours deadLetterQueueEnabled: true.
Schémas non-associés : Validation ignorée ; liez via schemaId dans rule.

Pour aller plus loin

Docs AWS : EventBridge Developer Guide
CDK Patterns : AWS Samples GitHub
Avancé : Intégrez Pipes pour transform ETL.

Découvrez nos formations AWS Learni pour certif Architect Pro.

Comment implémenter Amazon EventBridge avancé en 2026