AWS EventBridge is a serverless event bus service that lets applications, AWS services and supported SaaS partners publish and react to events in near real-time. The service, formerly CloudWatch Events, is used as the central event hub for event-driven architectures where events are published to a bus and routed by rules to targets such as Lambda functions, SQS queues, CloudWatch Logs, Step Functions and API Destinations. Managing this infrastructure with Terraform provides consistency, version control and automation, with working code at every step for event buses, rules, schedules, targets, retries, dead-letter queues and archives.
What AWS EventBridge Is and Why Terraform Matters
AWS EventBridge is a serverless event bus service that allows you to listen to events from your applications, supported third-party applications and AWS services. It simplifies building event-driven architectures by serving as the central event hub and enabling applications to publish, subscribe to and react to events in near real-time.
AWS EventBridge also provides built-in support for creating schedulers that emit events at scheduled times. The service provides simplified event processing with event buses and rules, cross-account and external event ingestion, schema discovery and event validation, and long-term event storage and replay capabilities.
By leveraging Terraform you can automate EventBridge configurations for consistency and scalability in your AWS environment. Whether integrating AWS services, custom applications or third-party providers, EventBridge provides a robust event-driven architecture for modern cloud-native applications.
Terraform brings consistency, version control and automation to your infrastructure. The configurations follow production best practices and can be extended to match specific requirements. Terraform will create all resources in the correct order, handling dependencies automatically.
Core EventBridge Concepts
EventBridge has three main concepts that are expressed as Terraform resources.
| Concept | Description |
|---|---|
| Event Bus | Where events arrive. The default bus receives events from AWS services in your account; some services, such as S3 object events, require event delivery to EventBridge to be enabled first |
| Rule | Matches events using an event pattern or a schedule expression and determines which targets receive the event |
| Target | The AWS resource that receives the event, for example Lambda, SQS, CloudWatch Logs, Kinesis or Step Functions |
EventBridge can catch events such as when an EC2 instance changes state, when a CodePipeline deployment fails, when an S3 object is created and route them to targets like Lambda functions, SQS queues or Step Functions. EventBridge scheduled rules can also run cron-style scheduled tasks in AWS, although EventBridge Scheduler is the recommended service for new standalone schedules.
Prerequisites and Project Structure
Before creating EventBridge resources with Terraform the following prerequisites are required:
- AWS CLI configured with appropriate permissions
- Terraform installed, version 1.0.0 or later
- Basic understanding of event-driven architectures
- Familiarity with JSON/YAML
A typical project structure for a Terraform EventBridge setup is:
terraform-eventbridge/
├── main.tf
├── variables.tf
├── outputs.tf
├── modules/
│ └── eventbridge/
│ ├── main.tf
│ ├── variables.tf
│ └── outputs.tf
└── patterns/
└── events.json
This structure separates bus definition, policies, rules and targets into modules and keeps event patterns in a dedicated folder for reuse.
Managing Event Buses with Terraform
An Event Bus is the entry point for events. Terraform creates a custom bus with aws_cloudwatch_event_bus and optionally attaches a policy to control who can put events.
Example event bus resource:
hcl
resource "aws_cloudwatch_event_bus" "main" {
name = "${var.project_name}-bus"
tags = merge(
var.tags,
{
Name = "${var.project_name}-bus"
}
)
}
An event bus policy allows cross-account publishing:
hcl
resource "aws_cloudwatch_event_bus_policy" "main" {
event_bus_name = aws_cloudwatch_event_bus.main.name
policy = jsonencode({
Version = "2012-10-17"
Statement = [
{
Sid = "AllowOtherAccountsPutEvents"
Effect = "Allow"
Principal = {
AWS = var.allowed_account_ids
}
Action = "events:PutEvents"
Resource = aws_cloudwatch_event_bus.main.arn
}
]
})
}
Managing Event Buses with Terraform is a core step in the workflow, alongside setting up Terraform for AWS and configuring rules and targets.
Configuring Rules with Event Patterns and Schedules
Rules can be schedule-based or pattern-based. A schedule rule uses a schedule expression:
hcl
resource "aws_cloudwatch_event_rule" "schedule" {
name = "${var.project_name}-schedule"
description = "Schedule-based rule"
event_bus_name = aws_cloudwatch_event_bus.main.name
schedule_expression = "rate(5 minutes)"
tags = merge(
var.tags,
{
Name = "${var.project_name}-schedule"
}
)
}
Pattern-based rules match incoming events using an event pattern. The guide demonstrates how to set up and manage EventBridge rules using Terraform, including event patterns, schedules and targets.
In practice you will use Terraform and Spacelift to create event buses, define rules with event patterns, build scheduled rules with both aws_cloudwatch_event_rule and the dedicated EventBridge Scheduler. This covers configuring EventBridge rules in Terraform and using schedulers with Terraform.
Event Targets, Input Transforms and Dead-Letter Queues
A rule can have multiple targets. Targets can be wired up to Lambda, SQS, CloudWatch Logs and API Destination targets. Event targets in EventBridge using Terraform also support input transformation, retries and dead-letter queues.
A Terraform module example shows targets for orders:
hcl
targets = {
orders = [
{
name = "send-orders-to-sqs"
arn = aws_sqs_queue.queue.arn
dead_letter_arn = aws_sqs_queue.dlq.arn
},
{
name = "send-orders-to-kinesis"
arn = aws_kinesis_stream.this.arn
dead_letter_arn = aws_sqs_queue.dlq.arn
input_transformer = local.kinesis_input_transformer
},
{
name = "log-orders-to-cloudwatch"
arn = aws_cloudwatch_log_group.this.arn
}
]
}
The module supports transform event payloads and set up retries, dead-letter queues and archives with working code at every step.
Terraform Module for EventBridge Resources
A community module creates AWS EventBridge resources with conditional creation and policy attachments.
Capabilities:
| Capability | Details |
|---|---|
| Resources created | bus, rules, targets, permissions, connections, destinations, pipes, schedules and schedule groups |
| Attachment | Attach resources to an existing EventBridge bus |
| Archives and Replays | Support AWS EventBridge Archives and Replays |
| Conditional creation | Conditional creation for many types of resources |
| IAM policies | Support IAM policy attachments and various ways to create and attach additional policies |
Most common use-case which creates custom bus, logging, rules and targets.
Example module usage:
hcl
module "eventbridge" {
source = "terraform-aws-modules/eventbridge/aws"
bus_name = "my-bus"
log_config = {
include_detail = "FULL"
level = "INFO"
}
log_delivery = {
cloudwatch_logs = {
destination_arn = "arn:aws:logs:us-east-1:123456789012:log-group:my-log-group"
}
s3 = {
destination_arn = "arn:aws:s3:::my-log-bucket"
}
}
rules = {
orders = {
description = "Capture all order data"
event_pattern = jsonencode({ "source" : ["myapp.orders"] })
enabled = true
}
}
targets = {
orders = [
{
name = "send-orders-to-sqs"
arn = aws_sqs_queue.queue.arn
dead_letter_arn = aws_sqs_queue.dlq.arn
}
]
}
tags = {
Name = "my-bus"
}
}
A minimal module invocation:
hcl
module "eventbridge" {
source = "terraform-aws-modules/eventbridge/aws"
bus_name = "my-bus"
tags = {
Name = "my-bus"
}
}
Monitoring, Archives, Logging and Operational Workflow
Monitoring EventBridge with Terraform includes setting up monitoring from day one and verifying resources after apply. Always review the plan before applying. Check that only the expected resources will be created. After applying, verify your resources are running correctly.
Logging configuration can be passed to the module:
hcl
log_config = {
include_detail = "FULL"
level = "INFO"
}
log_delivery = {
cloudwatch_logs = { destination_arn = "..." }
s3 = { destination_arn = "..." }
}
Long-term event storage and replay capabilities are supported via Archives and Replays. Schema discovery and event validation help ensure reliable event processing.
The guide walks through building EventBridge rules in Terraform, from simple schedules to complex event patterns with custom event buses. Build event-driven architectures with AWS EventBridge managed by Terraform — custom buses, rules and cross-account events. This tutorial provides production-ready Terraform code you can adapt for your own infrastructure.
This downloads the AWS provider plugin and initializes the backend. Terraform will create all resources in the correct order, handling dependencies automatically.
Best Practices for Integration
Best practices for Terraform and EventBridge integration include:
- Use dedicated EventBridge Scheduler for new standalone schedules rather than classic scheduled rules
- Tag all resources consistently with Name and project tags
- Use dead-letter queues for targets that can fail
- Use input transformers to shape payloads before delivery
- Enable archives for long-term event storage and replay
- Review plans before applying and verify resources after apply
- Set up monitoring from day one
Managing AWS resources with Terraform brings consistency, version control and automation to your infrastructure. The configurations follow production best practices and can be extended to match specific requirements. Start with these foundations and iterate as infrastructure needs evolve.
Conclusion
AWS EventBridge with Terraform provides a repeatable way to build event-driven architectures that span services, accounts and SaaS partners. Terraform codifies event buses, rules with event patterns and schedules, targets with input transforms, dead-letter queues, retries, archives and replays. The module approach accelerates delivery by handling bus creation, logging, rules and targets in a single reusable configuration. Operational discipline around prerequisites, project structure, plan review and post-apply verification ensures the event bus remains reliable and observable as workloads scale. By automating EventBridge with Terraform teams gain versioned, auditable infrastructure for near real-time event routing across AWS and beyond.