Messaging Targets

/**
 * Use an SQS queue as a target for Amazon EventBridge rules
 */
class SqsQueue implements events.IRuleTarget {
  readonly queue: sqs.IQueue;
  
  constructor(queue: sqs.IQueue, props?: SqsQueueProps);
  
  /**
   * Returns a RuleTarget that can be used to trigger this SQS queue
   * as a result from an EventBridge event
   */
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface SqsQueueProps extends TargetBaseProps {
  /**
   * The message to send to the queue
   * @default the entire EventBridge event
   */
  readonly message?: events.RuleTargetInput;
  
  /**
   * Message Group ID for FIFO queues
   * Required for FIFO queues, not used for standard queues
   * @default no message group ID
   */
  readonly messageGroupId?: string;
}

import * as sqs from "@aws-cdk/aws-sqs";
import * as events from "@aws-cdk/aws-events";
import * as targets from "@aws-cdk/aws-events-targets";

// Create SQS queue
const queue = new sqs.Queue(this, "EventQueue", {
  queueName: "event-processing-queue",
});

// Create FIFO queue for ordered processing
const fifoQueue = new sqs.Queue(this, "FifoQueue", {
  queueName: "ordered-events.fifo",
  fifo: true,
  contentBasedDeduplication: true,
});

// Create dead letter queue
const dlq = new sqs.Queue(this, "DeadLetterQueue");

// Create rule for EC2 state changes
const rule = new events.Rule(this, "EC2StateRule", {
  eventPattern: {
    source: ["aws.ec2"],
    detailType: ["EC2 Instance State-change Notification"],
  },
});

// Add SQS target with custom message format
rule.addTarget(new targets.SqsQueue(queue, {
  deadLetterQueue: dlq,
  maxEventAge: Duration.hours(4),
  retryAttempts: 3,
  message: events.RuleTargetInput.fromObject({
    eventId: events.EventField.fromPath("$.id"),
    instanceId: events.EventField.fromPath("$.detail.instance-id"),
    state: events.EventField.fromPath("$.detail.state"),
    timestamp: events.EventField.fromPath("$.time"),
  }),
}));

// Add FIFO queue target with message group ID
rule.addTarget(new targets.SqsQueue(fifoQueue, {
  messageGroupId: "ec2-state-changes",
  message: events.RuleTargetInput.fromPath("$.detail"),
}));

/**
 * Use an SNS topic as a target for Amazon EventBridge rules
 */
class SnsTopic implements events.IRuleTarget {
  readonly topic: sns.ITopic;
  
  constructor(topic: sns.ITopic, props?: SnsTopicProps);
  
  /**
   * Returns a RuleTarget that can be used to trigger this SNS topic
   * as a result from an EventBridge event
   */
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface SnsTopicProps {
  /**
   * The message to send to the topic
   * @default the entire EventBridge event
   */
  readonly message?: events.RuleTargetInput;
}

import * as sns from "@aws-cdk/aws-sns";
import * as snsSubscriptions from "@aws-cdk/aws-sns-subscriptions";
import * as events from "@aws-cdk/aws-events";
import * as targets from "@aws-cdk/aws-events-targets";

// Create SNS topic
const topic = new sns.Topic(this, "AlertTopic", {
  topicName: "security-alerts",
  displayName: "Security Alerts",
});

// Add email subscription
topic.addSubscription(new snsSubscriptions.EmailSubscription("admin@example.com"));

// Create rule for security events
const securityRule = new events.Rule(this, "SecurityRule", {
  eventPattern: {
    source: ["aws.guardduty", "aws.securityhub"],
    detailType: ["GuardDuty Finding", "Security Hub Findings - Imported"],
  },
});

// Add SNS target with formatted message
securityRule.addTarget(new targets.SnsTopic(topic, {
  message: events.RuleTargetInput.fromObject({
    severity: events.EventField.fromPath("$.detail.severity"),
    title: events.EventField.fromPath("$.detail.title"),
    description: events.EventField.fromPath("$.detail.description"),
    account: events.EventField.fromPath("$.account"),
    region: events.EventField.fromPath("$.region"),
    time: events.EventField.fromPath("$.time"),
  }),
}));

// Simple usage with default message (entire event)
const simpleRule = new events.Rule(this, "SimpleRule", {
  eventPattern: {
    source: ["myapp.orders"],
  },
});

simpleRule.addTarget(new targets.SnsTopic(topic));

import * as sqs from "@aws-cdk/aws-sqs";
import * as targets from "@aws-cdk/aws-events-targets";

// Create main queue and dead letter queue
const mainQueue = new sqs.Queue(this, "MainQueue");
const deadLetterQueue = new sqs.Queue(this, "DeadLetterQueue", {
  queueName: "failed-events-dlq",
});

// Configure target with retry policy and DLQ
const queueTarget = new targets.SqsQueue(mainQueue, {
  deadLetterQueue: deadLetterQueue,
  retryAttempts: 3,
  maxEventAge: Duration.hours(2),
});

import * as events from "@aws-cdk/aws-events";

// Transform event to custom format
const customMessage = events.RuleTargetInput.fromObject({
  // Extract specific fields
  eventSource: events.EventField.fromPath("$.source"),
  eventTime: events.EventField.fromPath("$.time"),
  // Add static fields
  environment: "production",
  // Combine fields
  summary: events.EventField.fromPath("$.detail.title") + " in " + events.EventField.fromPath("$.region"),
});

// Use entire event detail
const detailMessage = events.RuleTargetInput.fromPath("$.detail");

// Use entire event
const fullMessage = events.RuleTargetInput.fromEventPath("$");