# eb-event-integration

Part of **EB**

# EventBridge Event Integration Console Guide

## Operations Overview

| Operation | Console Navigation Path | Prerequisites | Description |
|-----------|------------------------|---------------|-------------|
| Activate EventBridge and Grant Permissions | Alibaba Cloud > Middleware > Applications Integration > EventBridge | You have an Alibaba Cloud account. | Enable the EventBridge service and accept the service agreement. |
| Connect Custom Event Source | Console > EventBridge > Event Rules > Create Rule | EventBridge and SMQ activated with permissions; SMQ queue created. | Create an event rule to route custom application events to SMQ. |
| Connect Alibaba Cloud Service as Event Source | Console > EventBridge > Event Buses > default > Event Rules > Create Rule | EventBridge and SMQ activated; SMQ queue created; ECS disk in valid state. | Create a rule to receive system events (e.g., ECS snapshot completion) and send to SMQ. |
| Trigger HTTP API for New DingTalk Members | Console > EventBridge > Custom Event Bus > Create Custom Event Bus | DingTalk admin account; EventBridge and Function Compute activated. | Set up a workflow that triggers an HTTP API when new DingTalk members join. |
| Push Events to Lark | Console > EventBridge > Custom Event Bus > Create Custom Event Bus | Lark account and group; EventBridge activated. | Configure EventBridge to send event notifications to a Lark chat group via webhook. |
| Push Events to WeCom | Console > EventBridge > Custom Event Bus > Create Custom Event Bus | WeCom account and group; EventBridge activated. | Configure EventBridge to send event notifications to a WeCom group chat via webhook. |
| Integrate Applications Using HTTP Event Targets | EventBridge > Event Buses > Select bus > Targets > Add Target > HTTP | Existing event bus; publicly accessible HTTPS endpoint. | Set up an external application as an event target using an HTTP endpoint. |
| Trigger Jenkins Builds with API Destination | Integration Center > API destinations | Jenkins installed with Notification plugin. | Use EventBridge API destinations to trigger Jenkins CI/CD pipelines. |
| 2Dfire Open Platform Integration | Console > EventBridge > Event Sources > Create Event Source | 2Dfire Open Platform developer account. | Connect 2Dfire as an HTTP event source to process business events like new orders. |
| Integration with HUAWEI CLOUD Cloud Eye | Console > EventBridge > Event Sources > Create Event Source (HTTP/HTTPS) > SMN > Topic Management > Create Topic > Create Subscription > CES > Alarm > Create Alarm Rule | HUAWEI CLOUD account with access to EventBridge, SMN, and Cloud Eye consoles. | Receive monitoring alerts from HUAWEI CLOUD Cloud Eye via EventBridge. |
| Integrate Auth0 | Console > EventBridge > Event Sources > Create HTTP/HTTPS Trigger | Auth0 account with Management Dashboard access. | Set up Auth0 as an HTTP event source using webhooks for user registration events. |
| Integrate Dynatrace with EventBridge | Settings > Integration > Problem notifications | Dynatrace account. | Receive Dynatrace problem notifications in EventBridge via webhook. |
| GitHub Integration | Console > EventBridge > Event Buses > Create Custom Event Bus > Integrate with External Services > GitHub Integration | EventBridge activated; GitHub account. | Receive GitHub repository events (e.g., push) via webhook in EventBridge. |
| Integrate with Gitee | Console > EventBridge > Event Sources > Create HTTP Event Source | Gitee account with code repository. | Receive Gitee code repository events via webhook in EventBridge. |
| Grafana Integration | Alerting > Notification channels > Add channel | EventBridge activated; Grafana account. | Forward Grafana alert notifications to EventBridge via webhook. |
| Jenkins Integration | Console > EventBridge > Event Sources > Create Event Source | Jenkins installed with Notification plugin. | Connect Jenkins as an HTTP event source to send build/job events to EventBridge. |
| Integrate SAP BTP with EventBridge | Console > EventBridge > Event Sources > Create Custom HTTP/HTTPS Event Source | SAP Universal ID with BTP Cockpit access. | Set up bidirectional integration between SAP BTP and EventBridge. |
| Shopify Integration | Console > EventBridge > Event Sources > Create Event Source | Shopify account. | Receive Shopify e-commerce events (e.g., product creation) via webhook. |
| Teambition Integration | Console > EventBridge > Event Sources > Create Custom Event Source | Teambition account. | Receive project management events from Teambition via webhook. |
| Observability Platform Integration | Console > Monitoring > Overview | account. | Receive monitoring events from via HTTP event source. |
| Yuque Integration | Yuque Console > Dashboard > Knowledge Base > Settings > Message Hook List | Yuque account; EventBridge HTTP event source configured. | Receive document/knowledge base events from Yuque via webhook. |
| Integrate Zoho CRM with EventBridge | Console > EventBridge > Event Buses > [Custom Event Bus] > Event Tracking | EventBridge activated; Zoho CRM account. | Route Zoho CRM events (e.g., new leads) to EventBridge via webhook. |
| Integrate Partner Event Sources | Console > EventBridge > Partner Event Sources > Create Partner Event Source | Alibaba Cloud account; partner application supporting EventBridge. | Connect certified partner applications (e.g., GitHub, Salesforce) as event sources. |
| Store New DingTalk Member Information in Database | Console > EventBridge > Event Buses > Create Custom Event Bus | DingTalk admin account; EventBridge activated; ECS security group created. | Automate database updates in RDS for MySQL when new DingTalk members are added. |
| Push Events from RocketMQ to Function Compute | Console > EventBridge > Event Buses > [Custom Event Bus Name] > Add Custom Event Source | EventBridge, Function Compute, and RocketMQ activated with resources created. | Route messages from ApsaraMQ for RocketMQ to Function Compute serverless functions. |
| Create RocketMQ Custom Event Source | Console > EventBridge > Custom Event Sources > Create Custom Event Source | ApsaraMQ for RocketMQ and EventBridge activated; resources created. | Create a custom event source to ingest messages from ApsaraMQ for RocketMQ. |
| Create Kafka Event Source | Console > EventBridge > Event Buses > Event Sources | ApsaraMQ for Kafka and EventBridge activated; resources created. | Create a custom event source to pull messages from ApsaraMQ for Kafka topics. |
| Create Custom Connectors | Console > EventBridge > Connectors > Create Connector | EventBridge instance active; external service details available. | Create reusable connectors for integrating with external HTTP/REST endpoints. |
| Configure Data Cleansing | Console > Message Integration > Tasks > Create Task | ApsaraMQ for RocketMQ instance created; Function Compute enabled. | Set up message transformation tasks (splitting, mapping, enrichment) in RocketMQ. |
| OSS Connector | Console > OSS > Buckets > Create Bucket | EventBridge, SAE, VPC, and Kafka activated with resources created. | Create a connector to synchronize data between Kafka and OSS using JDBC. |
| Synchronize MySQL Data to Kafka | Console > EventBridge > Connector Integration > Streaming Task List > Create Task | EventBridge, OSS, SAE, VPC, and Kafka activated with resources created. | Use a JDBC connector to sync MySQL data to Kafka topics. |
| MongoDB Connector | Console > EventBridge > Streaming Tasks > Create Task | EventBridge, OSS, SAE, VPC, and Kafka activated with resources created. | Create a MongoDB Kafka connector for bidirectional data sync. |
| Route Data to MaxCompute | Console > EventBridge > Event Flows > Create Event Flow | EventBridge, Function Compute, and MaxCompute activated with permissions. | Route Kafka messages to MaxCompute for data analysis. |
| Route Data to OSS | EventBridge > Streaming Tasks > Create Task | Kafka source and OSS bucket configured; network connectivity established. | Export Kafka topic data to OSS objects with time-based partitioning. |
| Back up Data to Elasticsearch | Console > EventBridge > Data Backup > Create Backup Rule | EventBridge, Function Compute, and Elasticsearch activated. | Back up message data from Kafka to Elasticsearch for retrieval. |
| Back up Data to MaxCompute | Console > EventBridge > Data Backup > Create Backup Rule | EventBridge, Function Compute, and MaxCompute activated. | Back up message data from Kafka to MaxCompute for cost-effective analysis. |
| Back up Data to OSS | Console > EventBridge > Data Backup > Create Backup Rule | EventBridge, Function Compute, and OSS activated. | Back up message data from Kafka to OSS for archiving. |
| Publish and Route Custom Application Events | Console > EventBridge > Custom Event Buses > Create Custom Event Bus | EventBridge and MNS activated; MNS queue created. | Design event-driven architectures with custom event buses and SDK sources. |
| Push Events from SMQ to Function Compute | Console > EventBridge > Event Buses > [Custom Event Bus Name] > Add Custom Event Source | EventBridge, Function Compute, and SMQ activated with resources created. | Trigger serverless functions from Simple Message Queue (SMQ) events. |
| Route Cloud Conferencing Events | Console > EventBridge > Event Buses > default > Event Rules > Create Event Rule | EventBridge and Cloud Conferencing activated in supported regions. | Process online meeting status events through HTTP gateways. |
| Build Event-Driven RAG Ingestion Pipeline | Console > EventBridge > Event Stream > Create Event Stream | Model Studio, DashVector, OSS, and Function Compute activated with API keys. | Create an automated RAG pipeline that generates embeddings on OSS file uploads. |
| Multi-source RAG Data Pipeline | Console > EventBridge > Event Streaming > Create Event Streaming | Alibaba Cloud account with API keys for Model Studio and DashVector. | Construct efficient data pipelines for AI-powered retrieval systems. |
| AI Data Inference | Console > EventBridge > Event Streaming > Create Stream | EventBridge, MQTT, and Model Studio activated; API key generated. | Process events with AI-powered data inference (e.g., sensitive data masking). |

## Operations Steps

### Activate EventBridge and Grant Permissions

**Navigation**: Alibaba Cloud > Middleware > Applications Integration > EventBridge

**Prerequisites**:
- You have an Alibaba Cloud account.

1. Log on to the Alibaba Cloud official website. In the top navigation bar, choose **Middleware** (menu) > **Applications Integration** (menu) > **EventBridge** (menu).
   - Element: **EventBridge** (menu) — location: top navigation bar

2. On the EventBridge product page, click **Activate** (button).
   - Element: **Activate** (button) — location: product page

3. Carefully read the **EventBridge (Pay-As-You-Go) Service Agreement** (checkbox), select it, and then click **Activate** (button) again.
   - Element: **EventBridge (Pay-As-You-Go) Service Agreement** (checkbox) — location: service agreement section
   - Notes: After activation, you are redirected to the EventBridge console.

### Connect Custom Event Source

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

**Prerequisites**:
- EventBridge is activated, and the required permissions are granted to a RAM user.
- Simple Message Queue (SMQ) is activated and the required permissions are granted to a RAM user.
- A queue is created in SMQ.

1. Click **Event Rules** (link) in the left-side navigation pane.
   - Element: **Event Rules** (link) — location: left-side navigation pane

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

3. Enter a rule name in the **Rule Name** (text_input) field and a description in the **Description** (text_input) field in the Basic step of the wizard.
   - Element: **Rule Name** (text_input) — location: main content area

4. Set the filter parameter to **Custom** (radio) and select the custom event source from the drop-down list.
   - Element: **Custom** (radio) — location: Filter step

5. Specify an event pattern in the **Event Pattern** (text_input) code editor and proceed to the next step.
   - Element: **Event Pattern** (text_input) — location: code editor in Filter step

6. In the Targets step, configure **SMQ** (dropdown) as the service type, select the queue, and set the body to **Original** (dropdown).
   - Element: **SMQ** (dropdown) — location: Targets step
   - Notes: You can configure up to five event targets for an event rule.

7. Click **Create** (button) to finalize the event rule.
   - Element: **Create** (button) — location: bottom of the Targets step

8. Find the rule on the Event Rules page and click **Delete** (button) in the Operations column.
   - Element: **Delete** (button) — location: Operations column

9. On the Custom Event Bus page, find the event bus to delete and click **Delete** (button) in the Operations column.
   - Element: **Delete** (button) — location: Operations column
   - Notes: Make sure no event source is associated with the event bus; otherwise, deletion will fail with an error message.

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Rule Name | text_input | Yes | — | The name of the event rule. |
| Description | text_input | No | — | A description for the event rule. |
| Service Type | dropdown | Yes | SMQ | The service that will receive the event. |
| Queue | dropdown | Yes | — | The SMQ queue to which the event will be sent. |
| Body | dropdown | Yes | Original | Specifies how the event body is delivered to the target. |

### Connect Alibaba Cloud Service as Event Source

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

**Prerequisites**:
- EventBridge is activated, and the required permissions are granted to a RAM user.
- Simple Message Queue (SMQ) is activated and the required permissions are granted to a RAM user.
- A queue is created in SMQ.
- ECS disk is in 'In Use' or 'Unattached' state.
- If disk is 'In Use', the ECS instance must be in 'Running' or 'Stopped' state.

1. On the Event Buses page, find the system event bus and click its name **default** (link).
   - Element: **default** (link) — location: Event Buses page

2. In the left-side navigation pane, click **Event Rules** (link). On the page that appears, click **Create Rule** (button).
   - Element: **Create Rule** (button) — location: left-side navigation panel

3. In the Create Rule wizard, perform the following steps: In the Configure Basic Info step, enter a rule name in the **Name** (text_input) field and a rule description in the **Description** (text_input) field. Then, click **Next Step** (button).
   - Element: **Next Step** (button) — location: Configure Basic Info step

4. In the Configure Event Pattern step, select **acs.ecs Elastic Compute Service (ECS)** (dropdown) from the Event Source drop-down list and **ecs:Snapshot:CreateSnapshotCompleted Completion of Snapshot Creation** (dropdown) from the Event Type drop-down list, specify an event pattern in the **Pattern Content** (text_input) code editor, and then click **Next Step** (button).
   - Element: **Next Step** (button) — location: Configure Event Pattern step

5. In the Configure Targets step, configure the event target. Then, click **Create** (button).
   - Element: **Create** (button) — location: Configure Targets step
   - Notes: You can configure up to five event targets for an event rule.

6. On the Queues page, find the queue to which you routed the events and choose **Send Messages** (link) in the Actions column.
   - Element: **Send Messages** (link) — location: Actions column

7. In the Receive Message section, click **Receive Message** (button).
   - Element: **Receive Message** (button) — location: Receive Message section
   - Notes: The sample code shows received event format.

8. On the Event Rules page, find the rule that you want to delete and choose **More > Delete** (link) in the Operations column. Then, follow the prompted instructions to complete the process.
   - Element: **Delete** (link) — location: Operations column

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Name | text_input | Yes | — | Enter a name for the event rule. |
| Description | text_input | No | — | Enter a description for the event rule. |
| Event Source | dropdown | Yes | acs.ecs Elastic Compute Service (ECS) | Select the Alibaba Cloud service that generates the event. |
| Event Type | dropdown | Yes | ecs:Snapshot:CreateSnapshotCompleted Completion of Snapshot Creation | Select the type of event to trigger the rule. |
| Pattern Content | text_input | No | — | Specify the event pattern in JSON format. |
| Service Type | dropdown | Yes | SMQ | Select the service type for the event target. |
| Queue | dropdown | Yes | — | Select the SMQ queue to receive the event. |
| Message Body | dropdown | Yes | Complete Event | Select the message body format to send. |

### Trigger HTTP API for New DingTalk Members

**Navigation**: Console > EventBridge > Custom Event Bus > Create Custom Event Bus

**Prerequisites**:
- Register a DingTalk account and create a DingTalk team as an administrator
- Activate EventBridge and grant required permissions
- Activate Alibaba Cloud Function Compute

1. Log in to the **EventBridge console** (link) and select a region
   - Element: **EventBridge console** (link) — location: top navigation bar

2. Click on the **Custom Event Bus** (menu) section and then click **Create Custom Event Bus** (button)
   - Element: **Custom Event Bus** (menu) — location: left-side navigation pane

3. Set the event bus name and description, then click **Next** (button)
   - Element: **Next** (button) — location: top-right corner

4. On the **Event Source** tab, set the event source type to **HTTP/HTTPS Trigger** (radio), request method to **HTTPS** (radio), and request type to **POST** (radio). Then click **Next** (button)
   - Element: **Next** (button) — location: top-right corner

5. On the **Rule** tab, click **Ignore** (button) and confirm to create the event bus without an event rule or target
   - Element: **Ignore** (button) — location: center of screen
   - Notes: The webhook URL from this step will be used in DingTalk

6. Log in to the DingTalk Open Platform and navigate to **Open Capabilities > Connection Platform** (menu)
   - Element: **Open Capabilities > Connection Platform** (menu) — location: top navigation bar

7. Select **My Connection Streams** (menu) from the left-side navigation pane
   - Element: **My Connection Streams** (menu) — location: left-side navigation pane

8. From the **New** list, select **Business Stream** (dropdown)
   - Element: **Business Stream** (dropdown) — location: top of page

9. In the **Create Stream** dialog box, enter a name and description, and set **Trigger** to **Official > Contacts > User Added to Contacts** (menu)
   - Element: **User Added to Contacts** (menu) — location: top of dialog

10. Click the **+** icon and select **Network Request** (icon)
    - Element: **Add** (icon) — location: right side of Network Request section

11. Click the arrow icon next to **Network Request** and configure the request parameters
    - Element: **Arrow** (icon) — location: right side of Network Request panel

12. Enter the POST request method and the webhook URL from Step 1, then click **Save** (button)
    - Element: **Save** (button) — location: bottom of panel

13. In the Function Compute console, create a new service with a name and description
    - Element: **Create Service** (button) — location: main content area

14. Configure advanced settings including logging, tracing, role, VPC, and internet access
    - Element: **Advanced Settings** (tab) — location: main content area

15. Click the service name and then click **Create Function** (button)
    - Element: **Create Function** (button) — location: top-right corner

16. Select **Process HTTP Requests** (radio) as the trigger type and use the web code example
    - Element: **Process HTTP Requests** (radio) — location: basic settings section

17. Log in to the EventBridge console and find the custom event bus created in Step 1
    - Element: **EventBridge console** (link) — location: top navigation bar

18. Click the event bus name and navigate to the **Rules** (menu) section
    - Element: **Rules** (menu) — location: left-side navigation pane

19. Click **Create Rule** (button) and configure the rule name and description
    - Element: **Create Rule** (button) — location: top-right corner

20. On the **Filter** tab, set the event source to the custom event source created in Step 1
    - Element: **Custom Event Source** (dropdown) — location: filter section

21. On the **Targets** tab, set the service type to **Function Compute** (dropdown), select the service and function created in Step 3, set the body to **Full Event** (dropdown), and set invocation type to **Sync** (dropdown)
    - Element: **Sync** (dropdown) — location: targets configuration

22. Invite a member to join your DingTalk team
    - Element: **Invite Member** (link) — location: organization management page
    - Notes: Follow the official documentation for adding members

23. Go to the custom event bus details page and click **Event Tracing** (button) to query events
    - Element: **Event Tracing** (button) — location: top-right corner

24. Find the event in the results and click **Trace** (button) to confirm successful delivery
    - Element: **Trace** (button) — location: actions column

25. Log in to the Function Compute console and view the function logs
    - Element: **Function Log** (tab) — location: details page

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Service Name | text | Yes | — | The name of the Function Compute service |
| Description | text | No | — | A brief description of the service |
| Logging | checkbox | No | Enable, Disable | Controls whether function execution logs are sent to Simple Log Service |
| Tracing Analysis | checkbox | No | Enable, Disable | Controls whether to enable Tracing Analysis for function executions |
| Role | dropdown | Yes | — | The RAM role that grants permissions to functions in this service |
| VPC | checkbox | No | Yes, No | Allows functions in this service to access resources in a specified VPC |
| VPC ID | text | No | — | The VPC that functions in this service can access (required if VPC is enabled) |
| VSwitch | text | No | — | The VSwitch within the selected VPC (required if VPC is enabled) |
| Security Group | text | No | — | The security group that controls network access for the functions (required if VPC is enabled) |
| Internet Access | checkbox | No | Yes, No | Allows functions in this service to access the Internet |
| Function Name | text | Yes | — | The name of the Function Compute function |
| Runtime | dropdown | Yes | — | The runtime environment for the function |
| Code Type | dropdown | Yes | Web Code Example | The type of code to use for the function |
| Rule Name | text | Yes | — | The name of the event rule |
| Description | text | No | — | A brief description of the event rule |
| Event Source | dropdown | Yes | — | The custom event source that will trigger the rule |
| Service Type | dropdown | Yes | Function Compute | The type of service that will receive the event |
| Service | dropdown | Yes | — | The Function Compute service that will handle the event |
| Function | dropdown | Yes | — | The Function Compute function that will process the event |
| Body | dropdown | Yes | Full Event | The format of the event payload sent to the function |
| Invocation Type | dropdown | Yes | Sync | The invocation mode for the function |

### Push Events to Lark

**Navigation**: Console > EventBridge > Custom Event Bus > Create Custom Event Bus

**Prerequisites**:
- You have a Lark account and have created a Lark group.
- EventBridge is activated and the required permissions are granted.

1. Log on to the **EventBridge console** (link).
   - Element: **EventBridge console** (link) — location: top navigation

2. In the left-side navigation pane, select a region and click the **Event Bus** (tab) tab.
   - Element: **Event Bus** (tab) — location: left navigation panel

3. On the Event Bus page, click the **Create Custom Event Bus** (button) button in the 'Create Custom Event Bus' section.
   - Element: **Create Custom Event Bus** (button) — location: main content area

4. In the 'Create Custom Event Bus' panel, configure the name and environment for the custom event bus, then click **Next** (button).
   - Element: **Next** (button) — location: bottom of form

5. In the 'Event Source' step, enter a name for the event source, select **SDK** (dropdown) from the type dropdown, then click **Next** (button).
   - Element: **Next** (button) — location: bottom of form

6. In the 'Event Rule' step, click **Skip Subsequent Steps** (button), then confirm in the dialog box.
   - Element: **Skip Subsequent Steps** (button) — location: main content area
   - Notes: You will create an event rule and an HTTP event target later.

7. Return to the custom event bus overview page and click **Add Event Rule** (button).
   - Element: **Add Event Rule** (button) — location: main content area

8. In the 'Create Event Rule' panel, enter a name for the rule and click **Next** (button).
   - Element: **Next** (button) — location: bottom of form

9. In the 'Filter' step, click **Next** (button) without configuring any filters.
   - Element: **Next** (button) — location: bottom of form
   - Notes: This example does not involve configuring an event pattern.

10. In the 'Targets' step, set Service Type to **HTTPS** (dropdown), paste the Lark webhook URL, set Body to **Template** (dropdown), and configure the parameters.
    - Element: **Add** (button) — location: bottom of form
    - Notes: The template body uses JSON format with placeholders like ${msg_source} and ${msg_type}.

11. On the custom event bus overview page, click **Send Event** (button).
    - Element: **Send Event** (button) — location: main content area

12. In the 'Send Event' panel, select an event source and configure the event body, then click **Confirm** (button).
    - Element: **Confirm** (button) — location: bottom of form

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Name | text | Yes | — | Enter a unique name for the custom event bus. |
| Environment | dropdown | Yes | Production, Development | Select the environment for the event bus. |
| Event Source Name | text | Yes | — | Enter a name for the custom event source. |
| Event Source Type | dropdown | Yes | SDK, CloudMonitor, SLS, RDS | Select the type of event source. |
| Rule Name | text | Yes | — | Enter a name for the event rule. |
| Service Type | dropdown | Yes | HTTPS, MQTT, Kafka | Select the service type for the target. |
| URL | text | Yes | — | Paste the webhook URL from the Lark bot configuration. |
| Body | dropdown | Yes | Raw, Template | Choose whether to send raw data or use a template. |
| Template Parameters | text | No | — | Configure the template using JSON syntax with placeholders. |

### Push Events to WeCom

**Navigation**: Console > EventBridge > Custom Event Bus > Create Custom Event Bus

**Prerequisites**:
- Register a WeCom account and create a WeCom group
- Activate EventBridge and grant required permissions

1. Log on to the **EventBridge console** (link)
   - Element: **EventBridge console** (link) — location: top navigation bar

2. Click the **Custom Event Bus** (menu) option in the left navigation pane
   - Element: **Custom Event Bus** (menu) — location: left navigation panel

3. Select the destination region and click **Create Custom Event Bus** (button)
   - Element: **Create Custom Event Bus** (button) — location: main content area

4. In the wizard, set the event bus name and description, then click **Next** (button)
   - Element: **Next** (button) — location: bottom of wizard

5. Set the event source type to **SDK** (dropdown), then click **Next** (button)
   - Element: **Next** (button) — location: bottom of wizard

6. Click **Skip** (button) in the event rule wizard and confirm in the dialog box
   - Element: **Skip** (button) — location: event rule wizard
   - Notes: Do not create event rules or targets at this time.

7. Return to the custom event bus overview page and click **Add Rule** (button)
   - Element: **Add Rule** (button) — location: top-right corner

8. Enter a custom rule name and click **Next** (button)
   - Element: **Next** (button) — location: bottom of wizard

9. Click **Next** (button) in the filter wizard to skip event pattern configuration
   - Element: **Next** (button) — location: bottom of wizard
   - Notes: In production, configure Event Source and Event Type as needed.

10. Set service type to **HTTPS** (dropdown), paste the WeCom webhook URL, select **Body** as template, and configure parameters and connector
    - Element: **Create** (button) — location: bottom of wizard
    - Notes: Template example provided: msg_source and msg_type from event payload.

11. On the event bus overview page, click **Send Event** (button)
    - Element: **Send Event** (button) — location: top-right corner

12. Select an event source and configure the event body, then click **Confirm** (button)
    - Element: **Confirm** (button) — location: bottom of dialog

| Parameter | Type | Required | Options/Values | Description |
|-----------|------|----------|----------------|-------------|
| Event Bus Name | text | Yes | — | The name of the custom event bus to be created. |
| Description | text | No | — | Optional description for the event bus. |
| Event Source Type | dropdown | Yes | SDK | Specifies the source of events. For this guide, it must be set to 'SDK'. |
| Rule Name | text | Yes | — | A custom name for the event rule. |
| Service Type | dropdown | Yes | HTTPS | The protocol used to deliver events to the target. |
| URL | text | Yes | — | The WeCom webhook URL copied from the robot settings. |
| Body | checkbox | Yes | — | Indicates that the event body will be sent as the request body. |
| Parameters | text | Yes | — | JSON object mapping event fields to template variables. |
| Connector | text | Yes | — | JSON structure defining the message format sent to WeCom. |

## FAQ

Q: Where do I find the webhook URL for my custom event source?
A: After creating a custom event source with HTTP/HTTPS Trigger type, click the **Details** button in the event source list. The webhook URL (labeled "Internet request URL") will be displayed in the configuration panel.

Q: What happens if I leave the event pattern empty in an event rule?
A: If no event pattern is configured, the rule will match all events from the selected event source. This is equivalent to using a "Match All Events" filter.

Q: Can I modify an event rule after it's been created?
A: Yes, you can edit most properties of an event rule after creation by clicking the **Edit** button in the Actions column on the Event Rules page. However, you cannot change the event bus or event source type.

Q: What permissions do I need to create event integrations?
A: Your RAM user needs the AliyunEventBridgeFullAccess policy or equivalent custom permissions to manage event buses, rules, and sources. Additionally, you need permissions for any target services (e.g., Function Compute, SMQ, OSS).

Q: How do I verify that my event integration is working?
A: Use the **Event Tracing** feature on your custom event bus details page to query and inspect delivered events. You can also check logs in target services (e.g., Function Compute logs, SMQ message queues) to confirm receipt.

## Pricing & Billing

### Billing Model
EventBridge uses a pay-as-you-go billing model based on the number of events processed (both input and output). Most operations are billed per request/event.

### Price Reference
| Tier | Input Price | Output Price |
|------|-------------|--------------|
| EventBridge (Pay-As-You-Go) | 0.0001 /1000 | 0.0001 /1000 |
| standard | 0.0001 / | 0.0001 / |
| default | 0.0001 / | — |
| EventBridge | 0.0001 /1000 | 0.0001 /1000 |
| OSS Connector | 0.002 / | 0.002 / |
| Function Compute | charged based on function call fees | — |
| text_embedding_v1 | 0.0001 /tokens | 0.0001 /tokens |
| qwen-turbo | 0.0005 /tokens | 0.001 /tokens |
| qwen-max | 0.002 /tokens | 0.004 /tokens |

### Free Tier
- Monthly free quotas range from 100 to 1,000,000 requests/tokens depending on the specific service and operation:
 - (no free tier) for basic EventBridge activation
 - 1000 for many integration scenarios
 - 10,000 for connector and partner integrations
 - 100 for DingTalk member triggers
 - 100 tokens for AI inference and RAG pipelines

### Billing Notes
- Events are billed per request; asynchronous processing may incur additional charges based on duration.
- Event rule creation and deletion do not incur charges; only event publishing and processing are billed.
- Failed event deliveries are generally not billed (e.g., "").
- RDS for MySQL storage is billed separately at 0.0001 /GB/.
- Function Compute waives function call fees for messaging products and cloud workflows in some scenarios.