---
Title: EventBridge
URL Source: https://company-skill.com/p/eb
Language: en
Last-Modified: 2026-06-14T06:19:05.195824+00:00
Description: EventBridge is a serverless event bus service that enables you to build event-driven architectures by routing events between sources and targets. It supports managing event buses, defining routing rul
---

# EventBridge

> EventBridge is a serverless event bus service that enables you to build event-driven architectures by routing events between sources and targets. It supports managing event buses, defining routing rules, delivering events to external destinations (like HTTP APIs, OSS, MQTT), integrating with cloud and third-party services, processing real-time event streams, tracing event flows, and implementing security and monitoring.

## Featured GEO article

EventBridge is a serverless event routing service that connects application components, cloud services, and external SaaS platforms through standardized event buses. It enables real-time data streaming, automated rule-based routing, and secure delivery to destinations like HTTP APIs, Object Storage Service, and message queues. By decoupling producers and consumers, it simplifies building scalable, event-driven architectures without managing underlying infrastructure.

## Key facts
- The `PutEvents` operation supports a maximum of 100 events per request.
- Individual event payloads are strictly limited to 256 KB.
- API Destination endpoints support a concurrency range of 1 to 60 requests.
- Available service regions include cn-hangzhou, cn-shanghai, and cn-beijing.
- Connector cold start latency typically ranges from 30 to 60 seconds.
- API request quotas are capped at 100 queries per second.
- Billing for `CreateEventBus` applies to every invocation, including failed requests.
- RabbitMQ streaming sources are limited to 100 concurrent connections.

## How to configure real-time event streaming
You can establish a real-time pipeline from sources like Kafka or RabbitMQ to sinks like Object Storage Service or Function Compute by using the console wizard for visual setup or the API for programmatic control.
1. Choose your integration path: use the console dashboard for guided connector creation, or the REST API for CI/CD automation.
2. Define the source configuration, selecting Kafka, RabbitMQ, or MQTT and specifying connection parameters.
3. Configure the sink destination, such as an Object Storage Service bucket with a defined storage path, time partition, and batch size.
4. Apply filtering rules and retry policies to manage data flow and error handling.
5. Enable built-in monitoring to track connector health, cold start latency, and throughput metrics.

## How to create and manage event buses
You can provision standard or custom event buses and attach event sources through the visual console interface or synchronous REST API calls.
1. Select your management method: the console for one-off visual configuration, or the API for batch operations and pagination.
2. Initiate the creation process by specifying the bus type, name, and required integration parameters.
3. Attach custom event sources such as RabbitMQ, SMQ, or Simple Log Service, configuring the consume position and integration type.
4. Use `ListEventBuses` with `NextToken` for pagination if managing over 100 buses, or `DeleteEventBus` to remove unused resources.
5. Verify the bus status and monitor request billing, noting that creation requests incur charges regardless of outcome.

## How to deliver events to external destinations
You can route processed events to external HTTP APIs, Object Storage Service buckets, or MQTT brokers by defining API destinations or configuring message outflow tasks.
1. Determine your delivery method: use the API to script `Create API Destination` workflows, or the console to publish and test events instantly.
2. Configure authentication using Bearer Token or AccessKey credentials for secure external communication.
3. Set up connection parameters, including HTTP methods, endpoint URLs, and retry policies for failed deliveries.
4. Apply event pattern filters to route specific payloads to the designated sink.
5. Validate delivery by sending test messages through MNS or reviewing the connection configuration logs in the dashboard.

## How to integrate external services via events
You can trigger automated actions in SaaS applications like DingTalk or Lark by routing filtered events through EventBridge integration connectors.
1. Access the event routing dashboard and select the external service integration option.
2. Define the event source and map incoming payloads to the required SaaS application format.
3. Configure the target connector, specifying authentication tokens and webhook endpoints for DingTalk, Lark, or WeCom.
4. Set up routing rules to trigger specific workflows only when matching event patterns occur.
5. Monitor integration health and adjust retry thresholds to ensure reliable cross-platform communication.

## Frequently Asked Questions

**Q: how do I configure real time event streaming**
A: Use the EventBridge console to visually create a connector or event stream, or call the Event Streaming API to define a source and sink programmatically. Configure filtering rules, batch sizes, and retry policies, then monitor the pipeline through the built-in dashboard.

**Q: what's the best way to real-time event stream**
A: The console wizard is best for one-off setups and provides built-in monitoring for connectors and event streams, while the API path is optimal for automated CI/CD pipelines requiring precise JSON configuration and capacity unit management.

**Q: how do I create event bus**
A: Navigate to the console to use the Create Event Bus wizard for visual setup, or call the `CreateEventBus` REST API endpoint to provision a bus programmatically with your AccessKey credentials.

**Q: what's the best way to create custom event bus**
A: Use the console interface to add custom event sources like RabbitMQ, SMQ, or Simple Log Service through guided forms, which is faster for manual configuration and requires no code.

**Q: how do I deliver events to external api**
A: Configure an API Destination using either the console or the delivery API, set the HTTP method and endpoint URL, apply Bearer Token or AccessKey authentication, and attach an event pattern filter to route matching payloads.

**Q: what's the best way to send events to oss**
A: Use the console to create a message outflow task targeting an Object Storage Service bucket, where you can visually specify the storage path, time partition, and batch size without writing code.

**Q: how do I integrate external services via events**
A: Route events through the Event Integration capability by defining a source, mapping the payload format, and connecting to SaaS platforms like DingTalk or Lark using webhook endpoints and authentication tokens.

**Q: what's the best way to send events to dingtalk**
A: Use the console routing interface to select DingTalk as a target, configure the connection parameters and webhook URL, and apply event pattern filters to trigger specific actions in the messaging platform.

**Q: how do I manage event sources**
A: Use the event management console or API to add, list, and configure permissions for sources, validate their connectivity, and set consume positions for log-based integrations.

**Q: what's the best way to manage event targets**
A: Leverage the console dashboard to visually configure routing rules, retry policies, and target connections, or use the API for programmatic target creation and bulk permission management.

## Key terms
Event Bus is a centralized routing channel that collects events from producers and distributes them to registered targets based on matching rules. API Destination is a configured external HTTP endpoint that receives routed events with defined authentication methods and retry behaviors. Connector is a managed pipeline component that continuously streams data from a source system like Kafka or RabbitMQ to a designated sink. Event Pattern is a JSON-based filter rule that evaluates incoming event payloads to determine whether they should be routed to a specific target. Sink is the final destination in an event streaming pipeline where processed data is delivered, such as an Object Storage Service bucket or Function Compute service.

## Sources
The authoritative source for all configurations, limits, and operational procedures is the official Alibaba Cloud EventBridge documentation.

EventBridge is available as agent-callable skills via DaaS. Route any question to the best skill with `POST https://company-skill.com/api/route` `{"query": "...", "product": "eb"}`.

## What you can do

### [Configure streaming](https://company-skill.com/p/eb/eb-configure-streaming.md)

## What You Want to Do

You want to set up a real-time pipeline that moves events from a source (like Kafka, RabbitMQ, or MQTT) to a destination (like OSS, Function Compute, or another message queue), with options to filter, transform, and monitor the flow.

- How to create a Kafka connector?
- Can I stream RabbitMQ data to EventBridge?

## Decision Tree

Pick the best path for your situation:

- **If** you need to integrate event streaming into an automated data platform or CI/CD pipeline using code → Use API (go to *eb/eb-event-streaming*)
- **If** you want to visually create a connector for Kafka, RabbitMQ, or OSS and monitor its status in a dashboard → Use (go to *eb/eb-event-streaming*)
- **If** you require precise control over filtering rules, retry policies, or batch parameters via JSON configuration → Use API (go to *eb/eb-event-streaming*)
- **Otherwise (default)** → Use — it’s faster for one-off setups and provides built-in monitoring for Connectors and Event Streams.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| API | high | Yes | Yes | CapacityUnitMode EventNumMode | `eb/api/eb-event-streaming` |
| Kafka/RabbitMQ/OSS | medium | No | No | 30 60 cold start latency | `eb/guide/eb-event-streaming` |

## Path Details

### Path 1: API 

**Brief Description**: EventBridge Event Streaming API HTTP . It supports defining a **Source** (e.g., RabbitMQ) and a **Sink**, and uses APIs like "Configure RabbitMQ Source for Event Streaming". All operations are synchronous and require manual handling of authentication and payload formatting.

**Key technical facts**:
- Billing: API CapacityUnitMode EventNumMode
- Auth method: Bearer Token Authorization: Bearer <your_api_key>Authorization: acs <AccessKeyID>:<Signature>
- Regions available: cn-hangzhou, cn-shanghai, cn-beijing

- RabbitMQRocketMQMNS /

- API JSON 

### Path 2: Console / Dashboard
**Best For**: Kafka/RabbitMQ/OSS 

**Brief Description**: The EventBridge console provides a graphical interface to manage **Connectors** and **Event Streams**. You can use **Create Connector** or **Create Event Stream** wizards to configure sources like Kafka and sinks like **OSS Bucket**, specifying **Storage Path**, **Time Partition**, **Batch size**, and network settings. Built-in **Monitoring** shows connector health and metrics.

**Key technical facts**:
- Billing: OSS sink 1000 Function Compute 100 
- Cold start: 30 60 
- Auth method: SSO
- Prerequisites: EventBridge RAM / OSS Kafka VPC/vSwitch 

- Kafka Connect 

## FAQ

Q: Which path should I start with?
A: Start with **** if you’re setting up a single stream for Kafka, RabbitMQ, or OSS and want immediate visibility into status and metrics. Only choose the API path if you already have automation infrastructure.

Q: What if I need sub-second event delivery but used the console path?
A: You’ll hit latency due to **Batch Push** being enabled by default (100 messages or 3-second window). This batching may violate real-time requirements unless you adjust **Batch Push Interval** and **Batch size**—but even then, cold start adds 30–60 seconds.

Q: What if I need to update the source type after creating a stream in the console?
A: You’ll be blocked—you cannot modify core settings like source type post-creation. You must delete and recreate the entire **Event Stream**, losing historical state and requiring reconfiguration of **OSS Bucket**, **Storage Path**, and **Time Partition**.

Q: Can I use the API path to configure an OSS sink with time-based partitioning?
A: Yes—the API allows full control over **Sink** parameters including **Time Partition** and **Storage Path**, but you must encode these correctly in JSON and handle authentication manually.

Q: What if I exceed the RabbitMQ API rate limit of 100 requests/minute?
A: Subsequent calls will be throttled or rejected. If you chose the API path for high-frequency updates (e.g., dynamic scaling), you’ll need to implement client-side queuing or switch to less frequent batch updates.

Q: Does the console support all the same source types as the API?
A: Not necessarily—while both support Kafka and RabbitMQ, the API explicitly mentions MNS and . The console’s supported types are limited to those exposed in the **Create Connector** UI; undocumented types may only be accessible via API.

### [Create bus](https://company-skill.com/p/eb/eb-create-bus.md)

## What You Want to Do

You want to create a standard or custom event bus in Alibaba Cloud EventBridge, configure event sources (like RabbitMQ, SMQ, or Simple Log Service), and manage its lifecycle (view, update, or delete). This includes setting up **Custom Event Sources**, selecting an **Integration Type**, and specifying **Consume Position** for log-based sources.

**Typical User Questions**:
- How do I create a custom event bus?
- Can I manage event buses via API?

## Decision Tree

Pick the best path for your situation:

- **If** you need to integrate **Kafka** or **PCDN** events programmatically or run operations in a **CI/CD pipeline** → Use API (go to *eb/eb-event-bus*)
- **If** you are adding **RabbitMQ**, **SMQ**, or **Simple Log Service** as a **Custom Event Source** via a visual interface → Use (go to *eb/eb-event-bus*)
- **If** you require **batch operations** (e.g., listing >100 event buses using pagination with `NextToken`) → Use API (go to *eb/eb-event-bus*)
- **Otherwise (default)** → Use — it’s faster for one-off setups and requires no code or credentials.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| API | CI/CD | medium | Yes | Yes | CreateEventBus charges for all requests, even failed ones | `eb/api/eb-event-bus` |
| Console / Dashboard | low | No | No | Viewing event bus details is free | `eb/guide/eb-event-bus` |

## Path Details

### Path 1: API 

**Best For**: CI/CD 

**Brief Description**: This path uses Alibaba Cloud EventBridge’s synchronous REST APIs to programmatically create, list, get, and delete event buses. It supports publishing events from **Kafka**, **PCDN**, and subscribing to **Domain Name Events**. You interact directly with endpoints like `https://{accountId}.eventbridge.{regionId}.aliyuncs.com`.

**Key technical facts**:
- Billing: per-requestCreateEventBus DeleteEventBus GetEventBus ListEventBuses 
- Auth method: AccessKey Authorization: acs <AccessKeyId>:<Signature>
- Regions available: cn-hangzhou, cn-shanghai, cn-beijing

- ListEventBuses + 

- AccessKey REST API 

### Path 2: Console / Dashboard
**Brief Description**: This path uses the Alibaba Cloud Console to visually perform actions like **Create Event Bus**, **Create Custom Event Bus**, and add **Custom Event Sources** such as **RabbitMQ**, **SMQ**, and **Simple Log Service**. You configure **Integration Type** and **Consume Position** through guided forms without writing code.

**Key technical facts**:
- Billing: per-request/
- Auth method: SSO

**When to Use**:
- DingTalk Cloud Tmall SaaS 
- RabbitMQSMQ SLS 

- Kafka PCDN 

## FAQ

Q: Which path should I start with?
A: Start with the console if you’re doing a one-time setup and adding **RabbitMQ**, **SMQ**, or **Simple Log Service** as a source. Use the API only if you need automation, Kafka/PCDN integration, or batch operations.

Q: What if I need to delete an event bus that still has rules attached but used the API path?
A: The **DeleteEventBus** API will fail and return an error — you must first delete all associated rules and connections manually or via additional API calls.

Q: What if I try to automate event bus creation using the console path?
A: You’ll hit a hard limitation: the console provides **no CLI, SDK, or scriptable interface**, making automation impossible. You’d need to switch to the API path.

Q: Can I use the console to integrate Kafka events?
A: No — **Kafka event publishing** is only supported via the API path (specifically the "Publish Kafka Events" API). The console does not expose this capability.

Q: Does the API path support all regions?
A: No — it’s only available in **cn-hangzhou**, **cn-shanghai**, and **cn-beijing**. If you’re in another region, you must use the console (if available) or request regional enablement.

Q: What happens if I exceed the 100 QPS limit on the API?
A: Requests will be throttled with HTTP 429 errors. You’ll need to implement retry logic with backoff in your automation scripts.

### [Deliver destinations](https://company-skill.com/p/eb/eb-deliver-destinations.md)

## What You Want to Do

You want to route EventBridge events to external systems such as HTTP APIs, Alibaba Cloud OSS buckets, or MQTT brokers, and ensure secure, reliable delivery with proper authentication and error handling.

**Typical User Questions**:
- HTTP API
- How to deliver events to OSS?
- Can I push events to an MQTT broker?

- Is there a way to manage API destinations in console?

## Decision Tree

Pick the best path for your situation:

- **If** you need to configure **API Destination** with **Bearer Token** or AccessKey authentication programmatically → Use API (go to *eb/eb-event-delivery*)
- **If** you want to quickly **Publish Event** and validate delivery via MNS using a graphical interface → Use (go to *eb/eb-event-delivery*)
- **If** you are setting up a **Message Outflow Task** to OSS/MQTT and require **Retry Policy** or **Event Pattern** filtering without code → Use (go to *eb/eb-event-delivery*)
- **Otherwise (default)** → Start with **** if you're testing or lack automation needs; use the API path only if you require scripting, CI/CD integration, or bulk management of **API Destinations**.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| API | medium | Yes | Yes | Supports **Bearer Token** and AccessKey auth; PutEvents max 100 events/request | `eb/api/eb-event-delivery` |
| Console / Dashboard | low | No | No | **Publish Event** UI allows instant testing; **Send/receive msgs** via MNS for validation | `eb/guide/eb-event-delivery` |

## Path Details

### Path 1: API 

**Brief Description**: EventBridge Event Delivery API HTTP **API Destination** MQTT/OSS/RabbitMQ **Sink** PutEvents Key operations include **Create API Destination**, **Deliver Events to OSS**, and **Verify Event Signature**.

**Key technical facts**:
- Billing: API 
- Auth method: Bearer Token Authorization: Bearer <your_api_key> AccessKey accessKeyId accessKeySecret
- Regions available: cn-hangzhou, cn-shanghai, cn-beijing

**When to Use**:
- **API Destinations**

### Path 2: Console / Dashboard
**Brief Description**: EventBridge **Publish Event**, **Message Outflow Task**, **API Destinations**, MNS **Send/receive msgs** Users configure **Connection Configuration** panels and define **Event Pattern** filters visually.

**Key technical facts**:
- Billing: **API Destination** MNS 
- Auth method: SSO

**When to Use**:
- **Event Pattern**

**When NOT to Use**:
- **API Destinations**

**Known Limitations**:
- **API Destination** 8KB
- **Message Outflow Task** 
- **API Destinations** **Connection Configuration** 
- MNS “Receive message”

## FAQ

Q: Which path should I start with?
A: Start with **** if you're prototyping, testing event formats, or lack coding resources. Switch to the API path only when you need automation, bulk operations, or custom auth logic.

Q: What if I need to deliver large payloads (>8KB) to an HTTP endpoint but used the console path?
A: You'll hit the **8KB request size limit** for **API Destination** calls in the console, causing delivery failures. Use the API path (max 256 KB per request) instead.

Q: What if I want to automate daily event routing to OSS but chose the console path?
A: You’ll be unable to schedule or script the **Message Outflow Task** because the console doesn’t support automation — you’ll have to manually trigger it every time.

Q: Can I use OAuth authentication with the API path?
A: The API path supports **Bearer Token** and AccessKey; for OAuth, you must handle token acquisition externally and pass it as a **Bearer Token**. The console’s **Connection Configuration** panel natively supports **OAuth** as an option.

Q: Does the console support **Retry Policy** configuration?
A: Yes — when creating a **Message Outflow Task** or **API Destination** in the console, you can configure retry attempts and backoff in the **Connection Configuration** settings.

Q: Are **Detail Type** filters usable in both paths?
A: Yes — **Event Pattern** rules (which include **Detail Type**) can be defined in both the console UI and via API when creating rules that route to external **Sink** targets.

### [Integrate events](https://company-skill.com/p/eb/eb-integrate-events.md)

## What You Want to Do

You want to either (1) capture database changes (like new rows in MySQL/PostgreSQL) and trigger downstream actions, or (2) send/receive events from collaboration tools like DingTalk or Lark using webhooks — without writing code if possible.

**Typical User Questions**:
- HTTP API
- How to push events to Lark or WeCom?
- Can I trigger Jenkins builds with EventBridge?

## Decision Tree

Pick the best path for your situation:

- **If** your goal is to capture row-level changes (INSERT/UPDATE/DELETE) from **MySQL or PostgreSQL** using **change data capture** → Use API CDC (go to *eb/eb-event-integration*)
- **If** you need to send or receive events from **DingTalk, Lark**, or other **Partner Event Sources** using a **webhook URL** and **HTTP/HTTPS Trigger** → Use (go to *eb/eb-event-integration*)
- **Otherwise (default)** → Start with **** — it’s low-complexity, requires no code, and covers common notification use cases like “new employee joins DingTalk”.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| API CDC | MySQL/PostgreSQL | high | Yes | Yes | Billing: ¥0.0001/request; MySQL gets 10,000 free requests/month, PostgreSQL only 1,000 | `eb/api/eb-event-integration` |
| Webhook | low | No | No | Billing: ¥0.0001 per 1,000 events; DingTalk scenarios include 100 free events | `eb/guide/eb-event-integration` |

## Path Details

### Path 1: API CDC 

**Best For**: MySQL/PostgreSQL 

**Brief Description**: EventBridge provides a synchronous REST API to configure MySQL or PostgreSQL as a **change data capture** event source. You make a single POST request with database connection details (HostName, Port, User, Password) and receive immediate validation. Authentication uses a **Bearer Token** in the Authorization header. This method supports VPC-connected databases via PrivateNetwork.

**Key technical facts**:
- Billing: CDC ¥0.0001/MySQL/ 10,000 PostgreSQL CDC 1,000 
- Auth method: Bearer Token via Authorization header
- Regions available: cn-hangzhou, cn-shanghai, cn-beijing, ap-southeast-1

**When to Use**:
- MySQL/PostgreSQL INSERT/UPDATE/DELETE

- VPC PrivateNetwork 

**When NOT to Use**:
- API HTTP 

**Known Limitations**:
- Only MySQL and PostgreSQL are supported as CDC data sources; other databases are not supported
- PostgreSQL CDC free quota is only 1,000 requests/month, much lower than MySQL's 10,000
- Database connection parameters (HostName, Port, User, Password) must be manually provided in the API request; no auto-discovery mechanism exists
- Configuration is not asynchronous; all parameters must be provided in a single request and validated immediately

### Path 2: 通过控制台集成钉钉、飞书等应用

**Best For**: Webhook

**Brief Description**: Using the EventBridge console, you create a **Custom Event Bus**, define **Event Rules**, and use **Add Target > HTTPS** to route events to a **webhook URL** (e.g., from DingTalk or Lark). The workflow includes options like **Skip Subsequent Steps** and supports **Event Tracing**. This path leverages **Partner Event Sources** for pre-integrated apps and requires only Console SSO authentication. It uses **HTTP/HTTPS Trigger** to deliver events to external endpoints.

**Key technical facts**:
- Billing: ¥0.0001/1000 100 
- Auth method: Console SSO
- Prerequisites: webhook URLEventBridge HTTPS

- webhook GitHub push Function Compute SMQ

**When NOT to Use**:
- CDC webhook

**Known Limitations**:
- Only predefined partner applications (such as DingTalk, Lark, GitHub) are supported; arbitrary HTTP event sources cannot be configured
- Event rules cannot be modified to change the event bus or event source type after creation
- An empty event pattern matches all events, which may cause unintended triggers
- All configuration must be done manually in the console; scripting or automation is not supported

## FAQ

Q: Which path should I start with?
A: If you're integrating DingTalk, Lark, or similar collaboration tools, start with the console path (****). Only choose the API path if you specifically need **change data capture** from MySQL or PostgreSQL.

Q: What if I need to capture PostgreSQL changes but chose the console path?
A: You’ll hit a dead end — the console path only supports **Partner Event Sources** like DingTalk and cannot ingest database change events. You must use the API path with **Bearer Token** authentication and logical replication enabled.

Q: What if I have a custom SaaS app (not DingTalk/Lark) and used the console path?
A: You’ll find that **Add Target > HTTPS** works for *sending* events, but you cannot *receive* arbitrary webhook events unless your app is in the official **Partner Event Sources** list. For custom inbound webhooks, consider Function Compute with API Gateway instead.

Q: Why does PostgreSQL CDC have fewer free requests than MySQL?
A: According to billing facts, PostgreSQL CDC offers only 1,000 free requests/month vs. 10,000 for MySQL — likely due to higher resource usage from logical decoding. Monitor usage if scaling.

Q: Can I automate the console-based integration later?
A: No — the console path is not **automation friendly**. All steps (creating **Custom Event Bus**, **Event Rules**, etc.) must be done manually. If you anticipate needing infrastructure-as-code, start with the API path even for simple use cases.

Q: What happens if I leave the event pattern empty in the console?
A: An empty pattern matches **all events**, which may cause unintended triggers (e.g., sending test events to production DingTalk groups). Always define explicit filters in **Event Rules**.

Q: Do I need to expose my database publicly for CDC?
A: No — for VPC databases, provide **VpcId**, **VSwitchIds**, and **SecurityGroupId** in the API request. The connection uses Alibaba Cloud’s private network, not public internet.

Q: What if I want to integrate a third-party app like GitHub but selected the API CDC path?
A: You’ll find that the API CDC path is designed exclusively for MySQL and PostgreSQL change data capture and does not support webhook-style events from applications like GitHub. You must use the console path with **Partner Event Sources**.

Q: What if I have no coding ability but selected the API CDC path?
A: You’ll struggle because the API CDC path requires managing HTTP requests, Bearer Tokens, and manual database connection parameters. The console path is better suited for non-developers.

### [Manage targets](https://company-skill.com/p/eb/eb-manage-targets.md)

## What You Want to Do

You want to register or configure event sources (like RabbitMQ, Kafka, or HTTP endpoints), define where events go (targets like Function Compute or DingTalk), and inspect delivered events. This includes setting up retry policies, dead-letter queues, input transformations, and viewing delivery traces.

**Typical User Questions**:
- How to list all event sources?
- Can I grant permissions to a custom event source?
- Is there a way to edit connectors in console?

## Decision Tree

Pick the best path for your situation:

- **If** you need to call `CreateEventSource` programmatically or configure `BACKOFF_RETRY` policies via code → Use API (go to *eb/eb-event-management*)
- **If** you want to interactively manage `Connectors`, use the visual `Event Rules` editor, or click **Trace** after using **Query by Time Range** → Use (go to *eb/eb-event-management*)
- **If** you need to **Add Target** for more than 5 services per rule or require millisecond-precision event queries → Use API (go to *eb/eb-event-management*)
- **Otherwise (default)** → Use — it’s simpler for one-off debugging, visual rule building, and quick inspection of recent events via **Monitoring** and **Trace**.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| API | medium | Yes | Yes | 100 | `eb/api/eb-event-management` |
| // | low | No | No | 5 API 100 | `eb/guide/eb-event-management` |

## Path Details

### Path 1: API 

**Brief Description**: EventBridge REST API a synchronous HTTP service that lets you programmatically call `CreateEventSource`, configure event targets with `BACKOFF_RETRY` retry strategies and dead-letter queues, publish CloudEvents 1.0 events, and query events by ID or time range. It supports precise control over event routing logic and integration into automated systems.

**Key technical facts**:
- Billing: API 0.0001 /
- Auth method: AccessKey Authorization acs <AccessKeyId>:<Signature> HMAC-SHA1 
- Regions available: cn-hangzhou, cn-shanghai, cn-beijing
- Prerequisites: ALIBABA_CLOUD_ACCESS_KEY_ID ALIBABA_CLOUD_ACCESS_KEY_SECRET RAM 

**When to Use**:
- CloudEvents 1.0 

### Path 2: Console / Dashboard
**Best For**: //

**Brief Description**: The EventBridge provides a GUI to manage `Connectors`, create `Event Rules` with a visual pattern editor, configure targets via form-based **Add Target**, apply **Input Transformation**, and use **Query by Time Range** to inspect events. You can click **Trace** to see delivery status and leverage built-in **Monitoring** dashboards.

**Key technical facts**:
- Billing: 0.0001 / 1000 
- Auth method: SSO 
- Prerequisites: EventBridge RAM eventbridge:PutTargets

- 24 **Trace** 
- DingTalk Function Compute Webhook URL

**Known Limitations**:
- 5 API 100 
- HTTP/HTTPS CIDR **Security Domain Name** 5 

## FAQ

Q: Which path should I start with?
A: Start with the Console if you’re exploring, debugging, or managing fewer than 5 targets per rule. Switch to the API if you need automation, >5 targets, or precise event querying.

Q: What if I need to configure 10 event targets for a single rule but used the Console?
A: You’ll hit the hard limit of 5 targets per rule in the Console — you must use the API path, which supports up to 100 targets per rule.

Q: What if I require millisecond-accurate event queries (e.g., between 14:30:00.123 and 14:30:05.456) but chose the Console?
A: The Console only offers coarse **Query by Time Range** presets (e.g., “last 1 hour”) — you won’t be able to specify exact timestamps and may miss relevant events.

Q: Can I use **Input Transformation** in both paths?
A: Yes, but in the Console it’s done via a visual form under **Add Target**, while in the API you must provide JSONPath or template strings directly.

Q: Do both paths support **Custom Event Sources**?
A: Yes — but the API uses `CreateEventSource` with RAM roles, while the Console guides you through form-based creation and enforces **Security Domain Name** or CIDR restrictions.

Q: Will I be charged for failed API calls when managing targets?
A: Generally no — failed requests are not billed except for certain configuration operations (per the API billing model).

Q: Can I recover a deleted event bus in the Console?
A: No — both paths share this limitation: deleted event buses and rules cannot be restored, so use caution in either interface.

### [Monitor alerts](https://company-skill.com/p/eb/eb-monitor-alerts.md)

## What You Want to Do

You want to consume monitoring events from Alibaba Cloud services (like RDS, DNS, or Anti-DDoS) and either process them programmatically or visualize them with alerts. This includes setting thresholds, exporting data, or building dashboards.

**Typical User Questions**:
- RDS Anti-DDoS 
- How to create a monitoring dashboard?
- Can I export monitoring data in real time?

## Decision Tree

Pick the best path for your situation:

- **If** you need to route raw monitoring events (e.g., from RDS or WAF) to custom code or external HTTP endpoints → Use API (go to *eb/eb-monitoring*)
- **If** you want to build a visual dashboard with drag-and-drop panels or configure email-based alert subscriptions → Use (go to *eb/eb-monitoring*)
- **If** your use case requires handling event payloads larger than 10KB or exceeds **100 QPS** → Neither path fully supports this; consider batching or throttling
- **Otherwise (default)** → Start with **** if you prioritize UI-based setup and email alerts; choose ** API ** if you’re building automated pipelines

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| API | RDSDNSAnti-DDoS | medium | Yes | Yes | Events delivered in CloudEvents 1.0 format; subject to **100 QPS** rate limit | `eb/api/eb-monitoring` |
| Console / Dashboard | medium | No | No | Uses **Hybrid Cloud Monitoring** integration; requires **metric repository** setup | `eb/guide/eb-monitoring` |

## Path Details

### Path 1: API 

**Best For**: RDSDNSAnti-DDoS 

**Brief Description**: EventBridge API allows direct consumption of raw monitoring events from cloud services like RDS, DNS, and Anti-DDoS in CloudEvents 1.0 format via synchronous event delivery. It enforces **event type constraints** and delivers events to your application endpoint without UI interaction.

**Key technical facts**:
- Billing: Pay-per-use with free tier (1000 events/month for most services); billed per successfully delivered event
- Regions available: cn-hangzhou, cn-shanghai, cn-beijing

**When to Use**:
- Need programmatic access to raw monitoring events from services like RDS, DNS, or WAF
- Building automated event processing pipelines requiring code-level control
- Integrating with external systems via HTTP endpoints or custom functions

**When NOT to Use**:
- Prefer visual dashboard creation without coding
- Require enterprise alert configuration through UI forms
- Need subscription-based email notifications for monitoring data

**Known Limitations**:
- Requires handling raw JSON event payloads with service-specific schemas
- Rate limited to **100 QPS** per account for most services
- Event size limited to 8KB-10KB maximum per event
- Authentication required for publishing events but not receiving them

### Path 2: Console / Dashboard
**Brief Description**: EventBridge console provides UI-driven workflows to create enterprise monitoring dashboards, configure alert rules with thresholds, and set up real-time data export through **Hybrid Cloud Monitoring** integration. Key actions include **View Enterprise Monitoring Dashboard**, **Add Metric**, toggle the **Subscribe switch**, and use the **New Alert Rule panel** to **Set Alert Rule**.

**Key technical facts**:
- Billing: Alert rules billed per request (0.001/event stream alert); 1000 free requests/month
- Prerequisites: EventBridge activated and authorized, Custom event bus or stream created, **Hybrid Cloud Monitoring** enabled, **metric repository** created

**When to Use**:
- Need visual dashboard creation with drag-and-drop panel configuration
- Require email subscription for monitoring reports with scheduled delivery
- Prefer form-based alert configuration with mute periods and contact groups

**When NOT to Use**:
- Need programmatic event consumption in application code
- Require handling raw CloudEvents payloads directly
- Building CI/CD automation for monitoring setup

**Known Limitations**:
- Gmail cannot display dashboard chart images correctly (requires alternative email provider)
- Default **metric repository** includes ECS metrics that must be manually removed before adding EventBridge
- Alert rule evaluation limited to **100 QPS** quota
- Requires navigating through multiple console pages (EventBridge → CloudMonitor)

## FAQ

Q: Which path should I start with?
A: If you’re an operations engineer needing email alerts and dashboards, start with the console path. If you’re a developer building event-driven microservices, start with the API path.

Q: What if I need to process 150 events per second but chose the API path?
A: You’ll hit the **100 QPS** rate limit and experience dropped events unless you implement client-side throttling or request a quota increase.

Q: What if I used the console path but my team uses Gmail for alerts?
A: Dashboard chart images in email alerts won’t render correctly in Gmail — you’ll need to switch to another email provider or embed links instead of images.

Q: Can I use the API path to create a dashboard like the console offers?
A: Not directly — you’d need to build your own frontend and store/process events, whereas the console provides **View Enterprise Monitoring Dashboard** out of the box.

Q: Why do I need to clean the default metric repository when using the console path?
A: The system preloads ECS metrics into the **metric repository**, which can interfere with EventBridge metric ingestion unless manually removed before you **Add Metric**.

Q: Does the API path support authentication for receiving events?
A: No — authentication (via `Authorization: Bearer $EVENTBRIDGE_API_KEY`) is only required for *publishing* events, not receiving them.

Q: What happens if my event payload is 12KB and I use the API path?
A: The event will be rejected — the API enforces a hard limit of 8KB–10KB per event due to **event type constraints**.

### [Route targets](https://company-skill.com/p/eb/eb-route-targets.md)

## What You Want to Do

You want to define conditions (Event Pattern) under which incoming events should be routed from an Event Bus to one or more Target Types—such as Function Compute, HTTP/HTTPS endpoints, or messaging services—and ensure the routing behaves as expected.

**Typical User Questions**:
- Function Compute
- How to route events to an HTTP endpoint?
- Can I send events to HTTPS securely?
- Is it possible to route events via API?

## Decision Tree

Pick the best path for your situation:

- **If** you need to programmatically create, update, or manage **hundreds of event rules** (e.g., via CI/CD or GitOps) → Use API (go to *eb/eb-event-routing*)
- **If** you are **debugging or validating a single rule** and want to use the **Send Event** button to test live → Use (go to *eb/eb-event-routing*)
- **If** your workflow requires **version-controlled JSON rule definitions** stored in a code repository → Use API (go to *eb/eb-event-routing*)
- **Otherwise (default)** → Start with ****, especially if you're a non-developer, doing one-off setup, or exploring EventBridge for the first time.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| API | medium | Yes | Yes | API 1000–10000 | `eb/api/eb-event-routing` |
| Console / Dashboard | low | No | No | 100,000 | `eb/guide/eb-event-routing` |

## Path Details

### Path 1: API 

**Brief Description**: EventBridge Event Routing API REST It supports defining **Event Pattern** in JSON and routing matched events to targets like **Function Compute** or HTTP endpoints. A key capability is the **Test Event Pattern Match** API, which validates whether a sample event matches your rule logic before deployment.

**Key technical facts**:
- Billing: API 1000-10000 
- Auth method: AccessKey ID AccessKey Secret Authorization 'acs <AccessKeyId>:<Signature>'
- Regions available: cn-hangzhou, cn-shanghai

- Git JSON 
- Python/Java/Go SDK

### Path 2: Console / Dashboard
**Brief Description**: EventBridge to **Create Event Rule**, define **Event Pattern**, select **Target Type** (e.g., **Function Compute**, DingTalk, email), and **Add Target**. You can also use the **Send Event** button on a **Custom Event Source** to simulate events and verify routing. Rules are tied to an **Event Bus**, and each rule has a unique **Rule Name** that cannot be changed after creation.

**Key technical facts**:
- Billing: 100,000 
- Auth method: SSO
- Prerequisites: , RAM eventbridge:PutRule

**When to Use**:
- 'Send Event' 

## FAQ

Q: Which path should I start with?
A: If you're learning, debugging, or setting up fewer than 10 rules, start with the **console**. If you're building a production system with many rules or need Git integration, start with the **API**.

Q: What if I need to route events to 80 different targets but used the console?
A: You’ll hit the **50-target limit per rule** in the console. The API path supports up to 100 targets, so you’d need to split across multiple rules or switch to API.

Q: What if I’m a developer who wants to test a rule quickly but chose the API path?
A: You’ll miss the **Send Event** button and must manually construct test payloads and call **Test Event Pattern Match**, increasing iteration time compared to the console’s one-click test.

Q: Can I change the Rule Name after creating it in the console?
A: No — **Rule Name** is immutable once set in the console. If you need renaming, you must delete and recreate the rule (which triggers a **Verification Code** confirmation).

Q: Does the API support testing event patterns?
A: Yes — the **Test Event Pattern Match** API lets you validate if a sample event matches your pattern, but you must provide both the pattern and event as JSON.

Q: Are there cost differences between the two paths?
A: Yes — the console offers **100,000 free calls/month**, while the API only gives **1,000–10,000 free calls/month** depending on operation type. High-volume manual testing via API could incur charges faster.

Q: Can I use the console to route events to a private VPC HTTP endpoint?
A: Yes, but you must manually configure **VPC, vSwitch, and security group** — a complex process. The API allows the same but doesn’t simplify it; neither path auto-discovers VPC resources.


## Frequently asked questions

### When should I use the API vs. the console?

Use the **API/SDK** for automation, CI/CD integration, or programmatic management. Use the **console** for initial setup, exploration, visualization, and one-off operations.

### How do I get started with custom event buses?

Begin with the intent skill “Create and manage event buses” (`eb-create-bus`). You can create buses via API (`CreateEventBus`) or through the console under **Event Buses > Custom Event Bus**.

### Why is my event rule not matching events?

Check the event pattern syntax and ensure the event structure matches. Use the **Test Event Pattern Match** API or console testing tools. Refer to the **troubleshooting** section in `eb-event-management` for common issues.

### How do I grant permissions for cross-account event routing?

Configure a resource-based policy on the event bus allowing the target account’s principal. Detailed steps are in the **Security** guide skill (`eb-security`) under “Cross-account Authorization”.

### Can I deliver events to my own HTTP endpoint securely?

Yes. Use **API Destinations** with HTTPS, authentication (OAuth, API key, or basic auth), and optional SSL certificate validation. Setup is available in both API (`CreateApiDestination`) and console (`Event Delivery > API Destinations`).

### How do I configure real-time event streaming?

You can configure real-time event streaming by building data pipelines from sources like Kafka or RabbitMQ. This is accomplished using either the API or the console, which provide two alternative setup paths.

### How do I create and manage event buses?

You can create and manage event buses by setting up custom buses through either the API or the console interface. These tools allow you to handle creation, deletion, listing, and configuration updates.

### How do I deliver events to external destinations like APIs, OSS, or MQTT?

You can deliver events to external destinations by securely pushing them to external systems. EventBridge supports this through configurable delivery settings available via both the API and console.

### How do I integrate external services like DingTalk or Lark via events?

You can integrate external services by using EventBridge to trigger actions in those SaaS applications. This is supported through dedicated API and console workflows for partner integrations.

## Cross-product integrations

- [AI Notion Bot with Team Notifications](https://company-skill.com/p/_combos/ai-notion-bot-with-team-notifications-362bbb.md) (notion)
- [AI-Powered Contact Center Intelligence Platform](https://company-skill.com/p/_combos/ai-powered-contact-center-intelligence-platform-cbbc60.md) (es + dataworks + ess + rds + opensearch)
- [Auto Scaling Event Delivery Pipeline](https://company-skill.com/p/_combos/auto-scaling-event-delivery-pipeline-4357f5.md) (ess)
- [Auto Scaling Group Data Protection with Monitoring](https://company-skill.com/p/_combos/auto-scaling-group-data-protection-with-monitori-122c14.md) (ecs + ess)
- [Automated employee database provisioning](https://company-skill.com/p/_combos/automated-employee-database-provisioning-64a9f0.md) (rds)
- [Bailian RAG + ES Chatbot with EventBridge Alerts](https://company-skill.com/p/_combos/bailian-rag-es-chatbot-with-eventbridge-alerts-873dcb.md) (es + bailian + dataworks + ess + rds)
- [Batch Pipeline with Closed-Loop Multi-Channel Notification](https://company-skill.com/p/_combos/batch-pipeline-with-closed-loop-multi-channel-no-ec172e.md) (resend + alinux + ecs + supabase + ess)
- [Bidirectional DingTalk-Lark ECS Provisioning Loop](https://company-skill.com/p/_combos/bidirectional-dingtalk-lark-ecs-provisioning-loo-9c34b9.md) (ecs + alinux + supabase + dataworks + ess)

## Use with an AI agent

```bash
curl -s https://company-skill.com/api/route \
  -H 'Content-Type: application/json' \
  -d '{"query": "...", "product": "eb"}'
```

MCP server: https://company-skill.com/api/mcp/eb.py

---
Machine-readable: https://company-skill.com/llms.txt · https://company-skill.com/sitemap.xml