Skip to content
Learni
Voir tous les tutoriels
AWS

Comment implémenter Amazon EventBridge en 2026

18 minEXPERT
AWS CDKIaCServerlessEvent-DrivenAWS EventBridge
Read in English

Introduction

Amazon EventBridge est le bus d'événements serverless d'AWS qui découple les sources (S3, API Gateway, SaaS) des cibles (Lambda, Step Functions). En 2026, il excelle dans les architectures event-driven à l'échelle planétaire, avec une latence <100ms et 100M+ événements/seconde sans provisioning. Contrairement à SQS/SNS, EventBridge utilise un event schema registry natif et des Pipes pour transformer/routeur les flux en temps réel, idéal pour microservices ou IoT.

Pourquoi l'adopter ? Imaginez un e-commerce : un upload S3 déclenche une règle EventBridge filtrant object.key contenant 'images/', route vers une Lambda de redimensionnement, puis un Pipe enrichit avec DynamoDB avant Step Functions. Ce tutoriel expert via CDK déploie un setup complet : bus custom, règle pattern-matching, target Lambda, schéma registry et Pipe de filtrage/transformation. Résultat : 0 maintenance infra, monitoring CloudWatch intégré. Prêt à scaler ? (128 mots)

Prérequis

  • Compte AWS avec IAM admin (ou roles CDK)
  • AWS CLI v2 configuré (aws configure)
  • Node.js 20+ et CDK 2.140+ (npm i -g aws-cdk)
  • Connaissances avancées en TypeScript, Lambda et événements AWS
  • Région us-east-1 (modifiable dans code)

Initialiser le projet CDK

terminal-init.sh
mkdir eventbridge-expert && cd eventbridge-expert
npm init -y
npm install aws-cdk-lib constructs
npm install -D @types/node ts-node cdk-nag typescript
cdk init app --language typescript
npm install @aws-cdk/aws-lambda-nodejs
mkdir lambda-handlers && touch lambda-handlers/index.ts
cdk context --clear

Ce script initialise un projet CDK TypeScript complet, installe les libs essentielles (CDK core, Lambda Node.js) et prépare les dossiers. cdk-nag active les checks de sécurité automatiques. Évitez yarn pour compatibilité CI/CD ; testez avec cdk ls post-init.

Comprendre la stack de base

Nous créons un EventBus custom pour isoler vos événements d'un partenaire SaaS (ex: Stripe webhooks). Une règle match des patterns JSON comme {"detail-type": ["PaymentSucceeded"]}. Le target est une Lambda Node.js asynchrone. Plus loin : schéma registry pour validation et Pipe pour enrichissement.

Créer l'EventBus et la Lambda target

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-nodejs';
import * as logs from 'aws-cdk-lib/aws-logs';

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: 'ExpertEventBus',
    });

    const handler = new lambda.NodejsFunction(this, 'EventHandler', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index',
      entry: 'lambda-handlers/index.ts',
      logRetention: logs.RetentionDays.ONE_WEEK,
    });

    eventBus.grantPutEventsTo(handler);
  }
}

Ce stack définit un EventBus nommé et une Lambda handler avec logs rotatifs. grantPutEventsTo autorise la Lambda à émettre des events (utile pour chaining). Piège : sans eventBusName unique, conflit cross-account ; utilisez cdk-nag pour vérifier Least Privilege.

Implémenter le handler Lambda

lambda-handlers/index.ts
import { APIGatewayProxyHandler } from 'aws-lambda';
import { Context } from 'aws-lambda';

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

  const detail = event.detail || {};
  if (detail.type === 'PaymentSucceeded') {
    // Logique métier : update DynamoDB, notifier Slack
    console.log(`Paiement ID ${detail.paymentId} traité avec succès.`);
  }

  return {
    statusCode: 200,
    body: JSON.stringify({ message: 'Event processed', eventId: event.id }),
  };
};

Handler parse l'event EventBridge standard (avec id, detail). Exemple concret : filtre PaymentSucceeded pour e-commerce. Ajoutez try/catch pour Dead Letter Queue ; testez localement avec sam local invoke avant déploiement.

Ajouter une règle avec pattern-matching

Règles EventBridge filtrent via JSONata-like patterns. Exemple : matcher seulement les paiements >100€ d'un source spécifique. Associez à la Lambda via target.

Définir règle et target

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-nodejs';
import * as logs from 'aws-cdk-lib/aws-logs';

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: 'ExpertEventBus',
    });

    const handler = new lambda.NodejsFunction(this, 'EventHandler', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index',
      entry: 'lambda-handlers/index.ts',
      logRetention: logs.RetentionDays.ONE_WEEK,
    });

    eventBus.grantPutEventsTo(handler);

    const rule = new events.Rule(this, 'PaymentRule', {
      eventBus,
      eventPattern: {
        source: ['stripe.com'],
        'detail-type': ['PaymentSucceeded'],
        detail: {
          amount: [{ numeric: ['>', 100] }],
        },
      },
    });

    rule.addTarget(new targets.LambdaFunction(handler, {
      event: events.RuleTargetInput.fromEventPath('$.detail'),
    }));
  }
}

Règle match source: stripe.com, detail-type et amount >100. fromEventPath passe $.detail à Lambda (input transformer). Avancé : patterns supportent exists, prefix. Évitez patterns trop larges (coût replay events).

Déployer la stack CDK

terminal-deploy.sh
cdk bootstrap aws://$(aws sts get-caller-identity --query Account --output text)/us-east-1
cdk synth
cdk deploy --require-approval never
aws events list-rules --event-bus-name ExpertEventBus --region us-east-1
aws lambda list-functions --function-version LATEST --region us-east-1

bootstrap prépare l'environnement CDK ; synth/deploy pousse la stack. Vérifiez rules/Lambdas via CLI. Piège : --require-approval never pour CI ; ajoutez --outputs-file stack.json pour ARNs post-deploy.

Intégrer schémas et Pipes

Schema Registry valide events au runtime (OpenAPI/JSON Schema). Pipes transforment (Filter/Enrich) avant target, comme un Stream APIGateway.

Ajouter schéma registry

event-schema.json
{
  "title": "PaymentSucceeded",
  "type": "object",
  "required": ["paymentId", "amount"],
  "properties": {
    "paymentId": { "type": "string" },
    "amount": { "type": "number", "minimum": 0 },
    "status": { "type": "string", "enum": ["succeeded", "failed"] }
  }
}

Schéma JSON Schema pour validation. Importez via Console/AWS CLI : aws eventbridge put-event-source-mapping. Associez à rule pour auto-générer codegen TypeScript. Utile pour cross-team contracts.

Implémenter un Pipe de transformation

lib/eventbridge-stack.ts
import * as pipes from 'aws-cdk-lib/aws-pipes';
// ... (code précédent +)

const pipe = new pipes.CfnPipe(this, 'PaymentPipe', {
  source: eventBus.eventBusArn,
  target: handler.functionArn,
  roleArn: pipeRole.roleArn,
  sourceParameters: {
    eventBridgeParameters: {
      source: eventBus.eventBusName,
    },
  },
  filterCriteria: {
    filter: {
      and_all: [
        { numeric: ['>', 100, '$.detail.amount'] },
        { prefix: ['pay_', '$.detail.paymentId'] },
      ],
    },
  },
});
pipe.node.addDependency(rule);

Pipe filtre amount>100 ET paymentId prefix 'pay_', route vers Lambda. CfnPipe pour features 2026 (CDK L2 en beta). Créez pipeRole IAM avant. Avantage : retry/backpressure intégrés vs règles simples.

Tester l'event via CLI

terminal-test.sh
EVENT_DATA='{"Source":"stripe.com","DetailType":"PaymentSucceeded","Detail":{"paymentId":"pay_123","amount":150,"status":"succeeded"}}'
aws events put-events --entries "{\"EventBusName\":\"ExpertEventBus\",\"Source\":\"test\",\"DetailType\":\"PaymentSucceeded\",\"Detail\":\"$EVENT_DATA\"}" --region us-east-1
echo "Vérifiez CloudWatch Logs du handler Lambda"

Put un event mock ; match la règle/Pipe. Detail JSON stringifié. Scalez avec --entries array. Debug : aws logs filter-log-events --log-group-name /aws/lambda/EventHandler.

Bonnes pratiques

  • IaC only : CDK/Terraform pour versioning/replay ; évitez Console pour prod.
  • Patterns précis : Utilisez numeric, exists pour <1% faux positifs ; testez avec Event Simulator.
  • Dead Letter Queue : Attachez SQS à rules/Pipes pour 100% delivery (max retry 185).
  • Cross-account : Partagez bus via RAM ; audit logs via EventBridge Audit.
  • Coûts : $1/million events ; archivez >90d avec replay.

Erreurs courantes à éviter

  • Pattern syntax : detail: { numeric: ['>', 100] } sans $ path → no match ; validez via Console simulator.
  • Permissions : Oubli lambda:InvokeFunction sur rule role → silent fail ; utilisez cdk-nag Suppress judicieusement.
  • Schema mismatch : Event non-conforme dropé sans log ; activez Event validation + DLQ.
  • Pipe loops : Target émets vers même bus → infinite ; break avec source filter.

Pour aller plus loin