# eb-event-routing

Part of **EB**

# EventBridge Event Routing Console Guide

## Operations Overview

| Operation | Console Navigation Path | Prerequisites | Description |
|-----------|------------------------|---------------|-------------|
| Create Event Rule | Console > EventBridge > Event Rules > Create Event Rule | An event bus must be created; permissions to manage rules | Creates a new rule to route events based on defined patterns |
| Delete Event Rule | Console > EventBridge > Custom Event Buses > Select Bus > Rules > Delete Rule | None | Removes an existing event rule from the system |
| Edit Event Rule | Console > EventBridge > Event Rules > Edit Rule | An existing event rule must be created | Modifies configuration of an existing event rule |
| Enable Event Rule | Console > EventBridge > Rules > Enable Rule | None | Activates a disabled event rule |
| View Event Rule Details | Console > EventBridge > Event Rules > View Rule Details | An event rule must already be created | Displays detailed configuration of an event rule |
| Route Events to Function Compute | Console > EventBridge > Event Buses | EventBridge activated; Function Compute function created | Configures event rules to trigger Function Compute functions |
| Route Events to HTTP Endpoint | Console > EventBridge > Rules > Create Rule | EventBridge activated with required permissions | Sends events to a custom HTTP endpoint |
| Route Events to HTTPS Endpoint | Console > EventBridge > Event Buses > [Custom Event Bus] > Actions > Publish Event | EventBridge activated; custom event bus created | Securely sends events to an HTTPS endpoint |
| Route Events to DingTalk | Console > EventBridge > Event Rules > Create Event Rule | EventBridge activated; DingTalk chatbot configured | Sends event notifications to DingTalk chat groups |
| Route Events to Email | Console > EventBridge > Event Buses > Event Rules > Create Rule | EventBridge activated; Direct Mail sender address created | Sends event notifications via Direct Mail email service |
| Route Events to Another Event Bus | Console > EventBridge > Event Buses > Create Rule | EventBridge activated with required permissions | Forwards events from one event bus to another |
| Route Events to Lark | Console > EventBridge > Event Rules > Create Event Rule | EventBridge activated; Lark chatbot created | Sends event notifications to Lark chat groups |
| Route Events to Log Service | Console > EventBridge > Event Rules > Create Event Rule | EventBridge and Log Service activated; Project and Logstore created | Ingests events into Log Service for analysis |
| Route Events to MaxCompute | Console > EventBridge > Event Rules > Create Event Rule | EventBridge activated; MaxCompute project and table created | Stores event data in MaxCompute tables |
| Route Events to OSS | Console > EventBridge > Event Buses > [Custom Event Bus] > Create Event Rule | EventBridge and OSS activated; OSS bucket created | Archives or stores event payloads in OSS buckets |
| Route Events to Message Service (MNS) | Console > EventBridge > Rules > Create Rule | EventBridge activated; MNS queue created | Delivers events to MNS queues for asynchronous processing |
| Route Events to SMS | Console > Short Message Service > Statistics > Delivery Records | EventBridge activated; SMS signature and template approved | Sends SMS notifications based on event triggers |
| Route Events to Tablestore | Console > EventBridge > Event Buses > Event Sources > Add Event Source | EventBridge and Tablestore activated; Tablestore instance and table created | Stores structured event data in Tablestore |
| Route Events to WeCom | Console > EventBridge > Event Rules > Create Rule | EventBridge activated; WeCom chatbot webhook URL available | Sends event notifications to WeCom workspaces |
| Route Events to Database | Console > EventBridge > Event Buses > Event Sources / Event Rules | EventBridge activated; ApsaraDB RDS for MySQL instance created | Inserts or updates database records based on events |
| Route Events to Voice Calls | Console > EventBridge > Event Buses > [Your Event Bus] > Event Rules > Create Event Rule | EventBridge activated; contact created for voice notifications | Triggers automated voice calls based on events |
| Route Events to RocketMQ | Console > EventBridge > Rules > Create Rule | EventBridge and RocketMQ activated; RocketMQ instance, topic, and group ID created | Publishes events to ApsaraMQ for RocketMQ topics |
| Route Events to RabbitMQ | Console > EventBridge > Event Rules > Create Event Rule | EventBridge activated; RabbitMQ instance, vhost, and queue created | Publishes events to ApsaraMQ for RabbitMQ queues |
| Route Events to Knative Service | Console > EventBridge > Event Buses > [Your Event Bus] > Actions > Publish Event | EventBridge activated; Knative service deployed | Triggers serverless Knative services with events |
| Route Events to CloudFlow | Console > CloudFlow > Workflows | EventBridge and CloudFlow activated; workflow created | Triggers CloudFlow workflows based on events |
| Route Events to API Destinations | Console > EventBridge > Event Buses > [Event Bus Name] > Event Sources / Event Rules | EventBridge activated; custom event bus created | Sends events to external APIs using configured destinations |
| Route Messages via Event Stream | Console > EventBridge > Event Streams > Create Event Stream | EventBridge account active; event source and target configured | Uses event streams to route messages between systems |
| Route Events Across Accounts | Console > EventBridge > Event Buses > default > Rules > Create Rule | Receiver account has RAM role with proper trust policy | Configures cross-account event routing between Alibaba Cloud accounts |
| Publish an Event | Console > EventBridge > Event Buses | Custom event bus and event source configured | Publishes an event to a custom event bus for testing |
| Route Events to RocketMQ with Offset Reset | Console > EventBridge > Event Buses > Create Event Bus | RocketMQ 4.x or 5.x instance created | Routes events to Message Queue for RocketMQ with offset reset capability |
| Create RocketMQ to RabbitMQ Outflow Task | Console > EventBridge > Message Outflow Tasks > Create Task | RocketMQ and RabbitMQ instances purchased and running | Synchronizes data from RocketMQ to RabbitMQ |
| Route Kafka Messages | Console > EventBridge > Event Streams > Create Event Stream | EventBridge activated; Kafka instance running | Uses event streams to route messages between Kafka instances |
| Route RabbitMQ Messages | Console > EventBridge > Event Streams | EventBridge activated; RabbitMQ instance in 'Running' state | Routes messages between RabbitMQ instances using event streams |
| Route ApsaraMQ for RocketMQ Messages | Console > EventBridge > Event Streams > Create Event Stream | EventBridge activated; RocketMQ instance running | Forwards messages between RocketMQ instances |
| Route SMQ Messages | Console > EventBridge > Event Streams > Create Event Stream | EventBridge activated; SMQ queues created | Routes messages between Simple Message Queue instances |
| Dynamic Routing | Console > EventBridge > Message Outflow > Create Task | Region selected; access to EventBridge service | Configures dynamic routing rules for messages |
| Route Messages Across Regions | Console > Message Integration > Message Inflow or Message Outflow | None | Routes messages across different regions |
| Route Messages Across Resources | Console > EventBridge > Message Outflow > Create Migration Task | Valid region selected; access to EventBridge and messaging services | Routes messages across different resources and instances |
| Route from Self-hosted to Cloud | Console > EventBridge > Message Source Inflow | Self-managed RocketMQ cluster with accessible endpoint; Alibaba Cloud RocketMQ instance | Routes messages from self-hosted cluster to cloud instance |

## Step-by-Step Instructions

### Create Event Rule

**Navigation**: Console > EventBridge > Event Rules > Create Event Rule

**Prerequisites**:
- An event bus must be created before creating an event rule
- Permissions to create and manage event rules are required

1. Click the **Create Event Rule** button
   - Element: **Create Event Rule** (button) — top-right corner of the Event Rules page

2. Select the event bus from the dropdown menu
   - Element: **Event Bus** (dropdown) — main content area
   - Notes: Only event buses with write permissions are listed

3. Define the event pattern using JSON format or visual editor
   - Element: **Event Pattern** (text_input) — main content area
   - Notes: Use the visual editor for simple patterns; use JSON for complex conditions

4. Add a target by clicking **Add Target**
   - Element: **Add Target** (button) — bottom of the form
   - Notes: You can add up to 50 targets per rule

5. Select the target type from the list (e.g., Lambda, SNS, SQS)
   - Element: **Target Type** (dropdown) — target configuration panel
   - Notes: Each target type has specific configuration fields

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Rule Name | text | Yes | — | A unique name for the event rule |
| Description | text | No | — | Optional description to help identify the purpose of the rule |
| Event Pattern | text | Yes | — | Defines which events trigger this rule. Can be specified in JSON or visual editor |
| Target Type | dropdown | Yes | Lambda, Amazon SNS, Amazon SQS, Kinesis Data Firehose, Step Functions, EventBridge Pipes | The service that receives the event when the rule is triggered |

### Delete Event Rule

**Navigation**: Console > EventBridge > Custom Event Buses > Select Bus > Rules > Delete Rule

1. Click on the event rule you want to delete in the list of rules.
   - Element: **event rule** (link) — main content area

2. Click the **Delete** button located in the top-right corner of the rule details panel.
   - Element: **Delete** (button) — top-right corner

3. In the confirmation dialog, click **OK** to proceed with deletion.
   - Element: **OK** (button) — Note message

4. In the Verify Account Security dialog box, click **Get Verification Code** to receive a code via SMS or email.
   - Element: **Get Verification Code** (button) — Verify Account Security dialog box

5. Enter the verification code received into the **Verification Code** field.
   - Element: **Verification Code** (text_input) — Verify Account Security dialog box

6. Click **OK** to complete the deletion process.
   - Element: **OK** (button) — Verify Account Security dialog box

### Edit Event Rule

**Navigation**: Console > EventBridge > Event Rules > Edit Rule

**Prerequisites**:
- An existing event rule must be created
- Access permissions for the EventBridge service

1. Navigate to the Event Rules page
   - Element: **Event Rules** (link) — left navigation panel

2. Select the event rule to edit
   - Element: **Rule Name or Rule ID** (link) — main content area

3. Click the **Edit** button
   - Element: **Edit** (button) — top-right corner

4. Modify the event target settings on the Edit Rule page
   - Element: **Edit Rule** (link) — main content area

5. Click **Save** to apply changes
   - Element: **Save** (button) — bottom of the form

### Enable Event Rule

**Navigation**: Console > EventBridge > Rules > Enable Rule

1. Click on the event rule to open its details
   - Element: **Note** (dialog) — top of the page

2. Click **OK** in the Note message
   - Element: **OK** (button) — in the Note message

3. Navigate to the Rules page and verify the status of the event rule
   - Element: **Rules** (tab) — top navigation panel

4. Check the Status column for the event rule
   - Element: **Status** (column) — Rules page table
   - Notes: The status should now be 'Enabled'

### View Event Rule Details

**Navigation**: Console > EventBridge > Event Rules > View Rule Details

**Prerequisites**:
- An event rule must already be created
- Access to the EventBridge console

1. Navigate to the EventBridge console
   - Element: **EventBridge** (menu) — left navigation panel

2. Select the event bus type (system or custom)
   - Element: **System Event Bus / Custom Event Bus** (tab) — top navigation bar

3. Click on the event rule you want to view
   - Element: **Event Rule Name** (link) — main content area

4. Review the rule details including basic information, event pattern, and event targets
   - Element: **Details** (tab) — top navigation bar

### Route Events to Function Compute

**Navigation**: Console > EventBridge > Event Buses

**Prerequisites**:
- Activate EventBridge and grant the required permissions
- Create a service
- Create a function
- Create a project and a Logstore
- Create an SLS trigger
- Collect and import logs

1. Log on to the EventBridge console. In the left navigation pane, click **Event Buses**.
   - Element: **Event Buses** (menu) — left navigation panel

2. In the top navigation bar, select a region. On the Event Buses page, click the name of the target custom event bus.
   - Element: **target custom event bus** (link) — top navigation bar

3. In the left navigation pane, click **Event Sources**, and then click **Add Event Source**.
   - Element: **Add Event Source** (button) — left navigation panel

4. In the Custom Application panel, enter a name and description, select Custom Application for Event Source Type, and then click **OK**.
   - Element: **OK** (button) — bottom of panel

5. Log on to the EventBridge console. In the left navigation pane, click **Event Buses**.
   - Element: **Event Buses** (menu) — left navigation panel

6. In the top navigation bar, select a region. On the Event Buses page, click the name of the target event bus.
   - Element: **target event bus** (link) — top navigation bar

7. In the left navigation pane, click **Event Rules**, and then click **Create Rule**.
   - Element: **Create Rule** (button) — left navigation pane

8. On the Create Rule page, enter a rule name and description in the Basic wizard, and click **Next**.
   - Element: **Next** (button) — bottom of wizard

9. In the Filter wizard, select Custom Event Source for Event Source, select the created source, enter an event pattern, and click **Next**.
   - Element: **Next** (button) — bottom of wizard

10. In the Targets wizard, configure the event target by selecting Function Compute from the drop-down list, choosing the function, setting transformation type to Template, specifying version or alias, selecting invocation method, choosing delivery format, and clicking **Create**.
    - Element: **Create** (button) — bottom of wizard
    - Notes: You can add up to five targets to an event rule.

11. Log on to the EventBridge console. In the left navigation pane, click **Event Buses**.
    - Element: **Event Buses** (menu) — left navigation panel

12. In the top navigation bar, select a region.
    - Element: **region selector** (dropdown) — top navigation bar

13. On the Event Buses page, find the target event bus and click **Send Event** in the Operations column.
    - Element: **Send Event** (button) — Operations column
    - Notes: You can publish events from the console only for custom event buses.

14. In the Send Event panel, select the source you created, enter the event content in the body code editor, and click **OK**.
    - Element: **OK** (button) — bottom of panel
    - Notes: For information about event structure, see Event structure.

15. Log on to the Function Compute console.
    - Element: **Function Compute console** (link) — top navigation

16. In the left navigation pane, click **Function Name**. In the top navigation bar, select the target region.
    - Element: **Function Name** (menu) — left navigation panel

17. On the Function Name page, click the name of the target function.
    - Element: **target function** (link) — main content area

18. On the Function Detail page, click the **Logs** tab, and then click **View Logs** to view the function logs.
    - Element: **View Logs** (button) — Logs tab
    - Notes: Screenshot shows log output.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Rule Name | text | Yes | — | The name of the event rule. |
| Description | text | No | — | A description of the event rule. |
| Event Source | dropdown | Yes | Custom Event Source | Select the source of the event. |
| Event Pattern | text_input | Yes | — | Define the pattern that matches events to be processed. |
| Service Type | dropdown | Yes | Function Compute | Select the service type for the target. |
| Function Name | dropdown | Yes | — | Select the Function Compute function to invoke. |
| Transformation Type | dropdown | Yes | Original, JSONPath, Constant Connector, Template Connector | Choose how to transform the event before sending it to the function. |
| Version or Alias | radio | No | Specific Version, Specific Alias | Specify whether to use a specific function version or alias. |
| Invocation Type | radio | Yes | Synchronous, Asynchronous | Choose the method for invoking the function. |
| Delivery Format | radio | No | Object, ObjectList | Specify how the event is delivered to the downstream function. |

### Route Events to HTTP Endpoint

**Navigation**: Console > EventBridge > Rules > Create Rule

**Prerequisites**:
- Activate EventBridge and grant the required permissions

1. Click on **Rules** in the left-side navigation pane, then click **Create Rule**
   - Element: **Rules** (link) — left-side navigation pane

2. In the Basic wizard, enter a name and description for the rule, then click **Next**
   - Element: **Next** (button) — main content area

3. In the Filter wizard, set Filter to **Custom Event Source**, select the previously created source, enter an event pattern in the code editor, then click **Next**
   - Element: **Next** (button) — main content area
   - Notes: For more information, see 'Event patterns'.

4. In the Targets wizard, configure an HTTP event target by selecting **HTTP** as the service type, entering the endpoint URL, setting the body to **Original**, selecting the network type, and optionally enabling token verification
   - Element: **Next** (button) — main content area
   - Notes: You can add up to five event targets. For VPC-based endpoints, you must also select an existing VPC, vSwitch, and security group. The security group must allow traffic from the vSwitch's CIDR block.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Rule Name | text | Yes | — | The name of the event rule. |
| Description | text | No | — | A description for the event rule. |
| Filter | dropdown | Yes | Custom Event Source | Specifies the type of event filtering. Select 'Custom Event Source' to use a custom event source. |
| Event Pattern | text | Yes | — | A JSON-formatted pattern used to filter incoming events. |
| Service Type | dropdown | Yes | HTTP | The type of target service. Select 'HTTP' to send events to an HTTP endpoint. |
| URL | text | Yes | — | The endpoint URL where events will be sent. |
| Body | dropdown | Yes | Original | Determines how the event body is passed to the target. 'Original' sends the full event as-is. |
| Network Type | dropdown | Yes | Internet Access, VPC | The network type for the HTTP endpoint. Choose 'VPC' if the endpoint is within a private network. |
| VPC | dropdown | Yes | — | Select an existing VPC if using a VPC-based network. |
| vSwitch | dropdown | Yes | — | Select an existing vSwitch within the chosen VPC. |
| Security Group | dropdown | Yes | — | Select a security group that allows inbound traffic from the vSwitch's CIDR block. |
| Token | checkbox | No | — | Enable this to include a token in the HTTP header for authentication. The token is sent with the key 'x-eventbridge-signature-token'. |

## FAQ

Q: Where do I find the event rules management page?
A: Navigate to the EventBridge console, then go to Event Rules in the left navigation panel. From there, you can create, view, edit, or delete event rules.

Q: What happens if I leave the Description field empty when creating a rule?
A: The Description field is optional. Leaving it empty won't affect the functionality of your event rule, but it may make it harder to identify the rule's purpose later.

Q: Can I modify an event rule after creation?
A: Yes, you can edit most aspects of an event rule after creation by navigating to the rule details page and clicking the Edit button. However, some properties like the rule name cannot be changed after creation.

Q: What permissions do I need to manage event rules?
A: You need appropriate RAM permissions to create, edit, delete, and enable event rules. Typically, this includes permissions for eventbridge:PutRule, eventbridge:DeleteRule, eventbridge:EnableRule, and eventbridge:DescribeRule.

Q: How do I test if my event rule is working correctly?
A: For custom event buses, you can use the "Send Event" button in the Operations column to publish a test event. Then verify delivery through the target service's console or by checking Event Tracing in the EventBridge console.

## Pricing & Billing

### Billing Model
per_request

### Price Reference
| Tier | Input Price | Output Price | Other Price |
|------|-------------|--------------|-------------|
| standard | 0.00001 / | — | — |
| default | 0.0001 / | — | — |

### Free Tier
 100,000 

### Billing Notes