# eb-event-management

Part of **EB**

<!-- intent-backlink:auto -->

> 💡 **Path Selection**: This skill is one implementation path for [Manage event sources and targets](../../intent/eb-manage-targets/SKILL.md). If you're unsure which path to take, check the routing skill first.

# EventBridge Event Management

## Capabilities Overview

| Sub-capability | Calling Mode | Description |
|--------|----------|------|
| Create Event Source | Synchronous | Creates an external event source in EventBridge, supporting various data sources such as RabbitMQ, Kafka, SLS, OSS, and HTTP endpoints. |
| Delete Event Source | Synchronous | Deletes an event source from an EventBridge event bus. |
| List Event Sources | Synchronous | Queries all Alibaba Cloud service event sources, returning detailed information about each event source. |
| List User Defined Event Sources | Synchronous | Queries all custom event sources in EventBridge, returning detailed information about each source. |
| Update Event Source Configuration | Synchronous | Updates the configuration of an event source in EventBridge, supporting various event source types. |
| Create or Update Event Targets | Synchronous | Create or update event targets for a specified rule in EventBridge with retry strategies and dead-letter queues. |
| List Event Targets | Synchronous | Queries all event targets of an event rule in Alibaba Cloud EventBridge. |
| Query Event Traces | Synchronous | Queries event traces in EventBridge to track the delivery and processing of events across event buses, rules, and targets. |
| Query Event Content | Synchronous | Queries the content of an event in EventBridge by specifying the event bus name, event ID, and optionally the event source. |
| Query Event Trace by ID | Synchronous | Queries event traces by event ID in EventBridge, returning detailed information about the event. |
| Query Events | Synchronous | Queries events from the event center using a REST API with filtering, sorting, and pagination. |
| Query Events by Time Range | Synchronous | Queries events delivered to an event bus within a specified time range. |
| Publish Events | Synchronous | Publishes one or more events to an event bus in EventBridge using CloudEvents specification. |
| Create Catalog | Synchronous | Create a catalog for organizing event data with Name, Type, Provider, Comment, and Properties fields. |
| Create Namespace | Synchronous | Create a namespace for event organization with Catalog, Name, Comment, and properties fields. |
| Create Table | Synchronous | Create a table structure for event data with retention policies and column definitions. |
| Create Agent | Synchronous | Create an agent for event processing with Name, Description, Prompt, and Metadata fields. |
| Get Conversation Details | Synchronous | Retrieve details about an event conversation including Id, Title, CreatedAt, UpdatedAt, and Status. |
| Manage Event Rules | Synchronous | Perform comprehensive operations on event rules including creation, listing, and deletion. |
| Configure Event Target | Synchronous | Set parameters and options for event delivery targets with transformation and retry strategies. |
| Transform Event Payload | Synchronous | Modify event data before delivery using transformation rules like Complete Event, Partial Event, Constant, and Template. |
| Manage Event Targets | Synchronous | Create, delete, and query event targets for rules using the TypeScript SDK. |
| Publish Cloud Photos Events | Synchronous | Publish events from Cloud Photos service to EventBridge through ActionTrail. |
| Publish DBAudit Events | Synchronous | Publish database audit events to EventBridge through ActionTrail. |
| Publish DLF Events | Synchronous | Publish Data Lake Formation events to EventBridge monitored by CloudMonitor. |
| Publish Database File System Events | Synchronous | Publish events from Database File System to EventBridge through ActionTrail. |
| Monitor Elastic Container Instance Events | Synchronous | Monitor events from Elastic Container Instance service published through ActionTrail. |
| Publish EDAS Application Change Events | Synchronous | Publish Enterprise Distributed Application Service application change events to EventBridge. |
| Publish Edge Node Service Events | Synchronous | Publish Edge Node Service events to EventBridge through ActionTrail and Cloud Monitor. |
| Publish Edge Security Acceleration Events | Synchronous | Publish Edge Security Acceleration events to EventBridge through ActionTrail. |
| Monitor Elasticsearch Events | Synchronous | Monitor Alibaba Cloud Elasticsearch service events from ActionTrail and CloudConfig. |
| Publish Fraud Detection Events | Synchronous | Publish Fraud Detection service events to EventBridge through ActionTrail. |
| Publish Interactive Analytics Events | Synchronous | Publish Interactive Analytics service events to EventBridge through ActionTrail. |
| Monitor IoT Platform Events | Synchronous | Monitor IoT Platform service events from ActionTrail and Cloud Monitor. |
| Receive Microservices Engine Events | Synchronous | Receive events from Microservices Engine service published to EventBridge. |
| Publish File Storage NAS Events | Synchronous | Publish File Storage NAS events to EventBridge through ActionTrail and Cloud Config. |
| Publish CloudOps Orchestration Events | Synchronous | Publish CloudOps Orchestration Service events to EventBridge. |
| Publish OSS Events | Synchronous | Publish Object Storage Service events to EventBridge with detailed bucket and object information. |
| Publish Performance Testing Events | Synchronous | Publish Performance Testing service events to EventBridge through ActionTrail. |
| Subscribe to PrivateLink Events | Synchronous | Subscribe to PrivateLink service events published through Cloud Monitor and CloudConfig. |
| Publish Quick BI Events | Synchronous | Publish Quick BI service events to EventBridge through ActionTrail. |
| Monitor RAM Access Control Events | Synchronous | Monitor Resource Access Management events published to EventBridge. |
| Ingest Serverless App Engine Events | Synchronous | Ingest and publish Serverless App Engine events to EventBridge. |
| Publish Server Load Balancer Events | Synchronous | Publish Server Load Balancer events to EventBridge through ActionTrail, Cloud Monitor, and Cloud Config. |
| Publish Security Center Events | Synchronous | Publish Security Center service events to EventBridge through ActionTrail. |
| Publish Server Guard Events | Synchronous | Publish Server Guard service events to EventBridge through ActionTrail. |
| Publish Smart Access Gateway Events | Synchronous | Publish Smart Access Gateway events to EventBridge through ActionTrail and Cloud Monitor. |
| Publish Time Series Database Events | Synchronous | Publish Time Series Database events to EventBridge through Cloud Config integration. |
| Publish Tablestore Events | Synchronous | Publish Tablestore service events to EventBridge through ActionTrail. |
| Publish VPC Events | Synchronous | Publish Virtual Private Cloud events to EventBridge through ActionTrail and CloudConfig. |
| Filter Events by Pattern | Synchronous | Apply message filtering syntax to filter events based on patterns with prefix/suffix, numeric ranges, and IP CIDR blocks. |

## API Calling Patterns

### Authentication
Use AccessKey authentication with the `Authorization` header.

- Header format: `Authorization: acs <AccessKeyId>:<Signature>`
- Environment variable: `ALIBABA_CLOUD_ACCESS_KEY_ID` and `ALIBABA_CLOUD_ACCESS_KEY_SECRET`
- The signature is generated using HMAC-SHA1 with the AccessKeySecret.

### Service Endpoint
EventBridge APIs use region-specific endpoints with the pattern:

`https://{account-id}.eventbridge.{region}.aliyuncs.com`

Common regions include:
- `cn-hangzhou` (China Hangzhou)
- `cn-shanghai` (China Shanghai) 
- `cn-beijing` (China Beijing)

For global API access, use:
- China: `https://api.aliyun.com/api/eventbridge/2020-04-01/{operation}`
- International: `https://api.alibabacloud.com/api/eventbridge/2020-04-01/{operation}`

### Synchronous API Pattern
All EventBridge Event Management APIs follow a synchronous calling pattern:

1. **Construct the request**: Prepare the HTTP request with proper headers (`Authorization`, `x-eventbridge-version: 2020-04-01`, `Content-Type`) and JSON body containing required parameters.
2. **Send the request**: Make a POST request to the appropriate endpoint URL.
3. **Receive immediate response**: The API returns a JSON response immediately with either success data or error information.
4. **Handle the response**: Parse the response to check the `Success` field and handle any errors indicated by the `Code` and `Message` fields.

No polling or async handling is required as all operations complete synchronously.

## Parameter Reference

### Create Event Source

| Parameter | Type | Required | Default | Constraints | Description |
|------|------|------|--------|------|------|
| EventSourceName | string | true | | | The name of the event source. |
| EventBusName | string | true | | | The name of the event bus associated with the event source. |
| Description | string | false | | | The description of the event source. |
| LinkedExternalSource | boolean | false | | | Specifies whether to connect to an external data source. |
| ExternalSourceType | string | false | | | The type of the external data source. |
| SourceMNSParameters | object | false | | | Parameters for the Message Service (MNS) event source. |
| SourceRocketMQParameters | object | false | | | Parameters for the Message Queue for Apache RocketMQ event source. |
| SourceRabbitMQParameters | object | false | | | Parameters for the Message Queue for RabbitMQ event source. |
| SourceSLSParameters | object | false | | | Parameters for the Simple Log Service (SLS) event source. |
| SourceHttpEventParameters | object | false | | | Parameters for an HTTP endpoint event source. |
| SourceScheduledEventParameters | object | false | | | Parameters for a scheduled event source. |
| SourceKafkaParameters | object | false | | | Parameters for the Message Queue for Apache Kafka event source. |
| SourceOSSEventParameters | object | false | | | Parameters for the Object Storage Service (OSS) event source. |

### Publish Events

| Parameter | Type | Required | Default | Constraints | Description |
|------|------|------|--------|------|------|
| specversion | string | true | | | The version of the CloudEvents specification. |
| id | string | true | | | The ID of the event. |
| source | string | true | | | The event source. |
| time | timestamp | true | | | The time when the event occurred. |
| type | string | true | | | The type of the event. |
| aliyuneventbusname | string | true | | | The name of the event bus that receives the event. |
| datacontenttype | string | false | | | The content type of the data parameter. Set to application/json. |
| data | struct | false | | | The content of the event. |
| subject | string | false | | | The subject of the event. |

### Query Event Traces

| Parameter | Type | Required | Default | Constraints | Description |
|------|------|------|--------|------|------|
| EventBusName | string | true | | | The name of the event bus. |
| EventId | string | true | | | The event ID. |

### Create or Update Event Targets

| Parameter | Type | Required | Default | Constraints | Description |
|------|------|------|--------|------|------|
| EventBusName | string | true | | | The name of the event bus. |
| RuleName | string | true | | | The name of the event rule. |
| Targets | array<object> | true | | | A list of event targets to create or update. |
| Id | string | true | | | The custom ID of the event target. |
| Type | string | true | | | The type of the event target. |
| Endpoint | string | false | | | The endpoint of the event target. |
| PushRetryStrategy | string | false | | one of: BACKOFF_RETRY, EXPONENTIAL_DECAY_RETRY | The retry strategy for pushing events. |
| DeadLetterQueue | object | false | | | The dead-letter queue for failed events. |
| ErrorsTolerance | string | false | | one of: ALL, NONE | The fault tolerance policy. |
| ParamList | array<object> | false | | | A list of parameters for the event target. |
| ConcurrentConfig | object | false | | | The concurrency control settings. |

### Filter Events by Pattern

| Parameter | Type | Required | Default | Constraints | Description |
|------|------|------|--------|------|------|
| source | string | false | | | The source of the event for pattern matching. |
| subject | string | false | | | The subject of the event for pattern matching. |
| data | object | false | | | The data payload containing nested fields for matching. |
| c-count | number | false | | range -1.0e9 to +1.0e9, accurate to 15 digits with up to 6 decimal places | A numeric field for range matching. |
| d-count | number | false | | range -1.0e9 to +1.0e9, accurate to 15 digits with up to 6 decimal places | A numeric field for comparison operators. |
| x-limit | number | false | | range -1.0e9 to +1.0e9, accurate to 15 digits with up to 6 decimal places | A numeric field for exact or anything-but matching. |
| state | string | false | | | A string field for exact value, anything-but, or prefix/suffix matching. |
| source-ip | string | false | | Only IPv4 addresses supported | An IP address field for CIDR notation matching. |

## Code Examples

### Create MNS Event Source - Bash - China

```bash
POST /openapi/createEventSource HTTP/1.1
Host: 164901546557****.eventbridge.cn-hangzhou.aliyuncs.com
Date: Sat, 18 Apr 2020 05:30:41 GMT
x-eventbridge-version: 2020-04-01
Authorization: acs vZ3VL0SuJdHi****:Jo2PbT******azYAYoYslKLvWzg=
Content-Type: application/json;charset=UTF-8
Content-Length: 26

{
    "EventSourceName":"mymns.source",
    "Description":"Event source of the MNS type",
    "SourceMNSParameters":{
        "RegionId":"cn-zhangjiakou",
        "QueueName":"MyQueue",
        "IsBase64Decode":true
    },
     "EventBusName":"my-event-bus"
}
```

### Publish Custom Event - Python - All Regions

```python
import requests
import json

url = "https://123456789098****.eventbridge.cn-hangzhou.aliyuncs.com/openapi/queryEventTraces"
headers = {
    "x-eventbridge-version": "2020-04-01",
    "Authorization": "acs vZ3VL0SuJdHi****:Jo2PbTj******zYAYoYslKLvWzg=",
    "Content-Type": "application/json;charset=UTF-8"
}
data = {
    "EventBusName": "testBus",
    "EventId": "a5074581-7e74-4e4c-868f-47e7afdf****"
}

response = requests.post(url, headers=headers, data=json.dumps(data))
print(response.json())
```

### Create Event Targets with Transformation - Bash - All Regions

```bash
POST /openapi/createTargets HTTP/1.1
Host: 123456789098****.eventbridge.cn-hangzhou.aliyuncs.com
Date: Sat, 18 Apr 2020 05:30:41 GMT
x-eventbridge-version: 2020-04-01
Authorization: acs vZ3VL0SuJdHi****:Jo2PbTj******zYAYoYslKLvWzg=
Content-Type: application/json;charset=UTF-8
Content-Length: 26

{
    "EventBusName":"default",
    "RuleName":"myRule2",
    "Targets":[
        {
            "Id":"target5",
            "Type":"acs.fc.function",
            "Endpoint":"acs:fc:cn-hangzhou:123456789098****:services/guide.LATEST/functions/HelloFC",
            "PushRetryStrategy":"BACKOFF_RETRY",
            "ParamList":[
                {
                    "resourceKey":"serviceName",
                    "form":"CONSTANT",
                    "value":"guide"
                },
                {
                    "resourceKey":"functionName",
                    "form":"CONSTANT",
                    "value":"HelloFC"
                },
                {
                    "resourceKey":"body",
                    "form":"TEMPLATE",
                    "value":"{\"key\"=\"value\"}",
                    "template":"The value of ${key} is ${value}!"
                }
            ]
        }
    ]
}
```

### List User Defined Event Sources - C# - All Regions

```csharp
using System;
using System.Collections.Generic;
using Tea;

namespace test
{
    public class Client
    {

        /**
         * Uses the CreateClient() function to initialize common request parameters.
         */
        public static AlibabaCloud.SDK.EventBridge.EventBridgeClient CreateClient()
        {
            AlibabaCloud.SDK.EventBridge.Models.Config config = new AlibabaCloud.SDK.EventBridge.Models.Config();
            // Your AccessKey ID.
            config.AccessKeyId = "<accessKeyId>";
            // Your AccessKey secret.
            config.AccessKeySecret = "<accessKeySecret>";
            // Your endpoint.
            config.Endpoint = "<endpoint>";
            return new AlibabaCloud.SDK.EventBridge.EventBridgeClient(config);
        }

        public static void CreateTargetsSample(AlibabaCloud.SDK.EventBridge.EventBridgeClient client)
        {
            try
            {
                AlibabaCloud.SDK.EventBridge.Models.CreateTargetsRequest createTargetsRequest = new AlibabaCloud.SDK.EventBridge.Models.CreateTargetsRequest();
                createTargetsRequest.EventBusName = "demo-bus";
                createTargetsRequest.RuleName = "myRule";
                AlibabaCloud.SDK.EventBridge.Models.TargetEntry targetEntry = new AlibabaCloud.SDK.EventBridge.Models.TargetEntry();
                targetEntry.Id = "1234";
                targetEntry.Endpoint = "http://www.example.com";
                List<AlibabaCloud.SDK.EventBridge.Models.TargetEntry> list = new List<AlibabaCloud.SDK.EventBridge.Models.TargetEntry>
                {
                    targetEntry
                };
                createTargetsRequest.Targets = list;
                AlibabaCloud.SDK.EventBridge.Models.CreateTargetsResponse response = client.CreateTargets(createTargetsRequest);
                Console.WriteLine("--------------------Create targets success--------------------");
                Console.WriteLine(AlibabaCloud.TeaUtil.Common.ToJSONString(response.ToMap()));
            }
            catch (TeaException error)
            {
                Console.WriteLine(error.Message);
            }
            catch (Exception _error)
            {
                TeaException error = new TeaException(new Dictionary<string, object>
                { { "message", _error.Message }
                });
                Console.WriteLine(error.Message);
            }
        }

        static void Main(string[] args)
        {
            AlibabaCloud.SDK.EventBridge.EventBridgeClient client = CreateClient();
            CreateTargetsSample(client);
            Console.ReadKey();
        }

    }
}
```

### Query Events by Time Range - Bash - All Regions

```bash
POST /openapi/queryEventsByPeriod HTTP/1.1
Host: 123456789098****.eventbridge.cn-hangzhou.aliyuncs.com
Date: Sat, 18 Apr 2020 08:30:41 GMT
x-eventbridge-version: 2020-04-01
Authorization: acs vZ3VL0SuJdHi****:Jo2PbTj******zYAYoYslKLvWzg=
Content-Type: application/json;charset=UTF-8
Content-Length: 92

{
  "EventBusName": "testBus",
  "EventSourceName": "testSource",
  "StartTime": 1587173142152,
    "EndTime": 1587173942152
}
```

### Publish Events with CloudEvents Format - Bash - China

```bash
POST /openapi/putEvents HTTP/1.1
Host: 123456789098****.eventbridge.cn-hangzhou.aliyuncs.com
Date: Sat, 18 Apr 2020 05:30:41 GMT
x-eventbridge-version: 2020-04-01
Authorization: acs vZ3VL0SuJdHi****:Jo2PbTjR******YAYoYslKLvWzg=
Content-Type: application/cloudevents-batch+json;charset=UTF-8
Content-Length: 418

[
    {
        "datacontenttype":"application/json",
        "data":"test",
        "subject":"acs:oss:cn-hangzhou:123456789098****:xls-papk/game_apk/123.jpg",
        "specversion":"1.0",
        "aliyuneventbusname":"mybus",
        "id":"a5074581-7e74-4e4c-868f-47e7afdf****",
        "source":"acs.oss",
        "time":"2020-08-24T13:54:05.965Asia/Shanghai",
        "type":"oss:ActionTrail:ApiCall"
    }
]
```

### Manage Event Rules - TypeScript - All Regions

```typescript
import { EventBridgeClient } from '@alicloud/eventbridge-client';

const client = new EventBridgeClient({
  region: 'cn-beijing',
  accessKeyId: 'your-access-key-id',
  secretAccessKey: 'your-secret-access-key'
});

// Create an event rule
await client.createRule({
  ruleName: 'my-rule',
  description: 'A sample rule',
  eventPattern: '{"source":["acs:example"]}'
});

// Disable an event rule
await client.disableRule({ ruleName: 'my-rule' });

// Enable an event rule
await client.enableRule({ ruleName: 'my-rule' });

// Delete an event rule
await client.deleteRule({ ruleName: 'my-rule' });
```

### Event Filtering Pattern Example - JSON - All Regions

```json
{
    "source":[
        {
            "prefix":"acs."
        }
    ],
    "data":{
        "state":[
            {
                "anything-but":"initializing"
            }
        ],
        "source-ip":[
            {
                "cidr":"10.0.0.0/24"
            }
        ],
        "c-count":[
            {
                "numeric":[
                    ">",
                    0,
                    "<=",
                    5
                ]
            }
        ],
        "d-count":[
            {
                "numeric":[
                    "<",
                    10
                ]
            }
        ],
        "x-limit":[
            {
                "anything-but":[
                    100,
                    200,
                    300
                ]
            }
        ]
    }
}
```

## Response Format

```json
{
  "Message": " Remote error. requestId: [A8EFABD2-95B9-1C46-9E01-xxxx], error code: [CreateRelatedResourceFailed], message: [Create related resource failed, EntityNotExist.Role : The role not exists: xxxx. \r\nRequestId : xxxx-168C-54ED-8FEB-BF11CB70AEB7]   ",
  "RequestId": "2922208e-e1c6-43ee-bfd1-aca50263bc8a",
  "Data": {
    "EventSourceARN": "acs:eventbridge:cn-hangzhou:164901546557****:eventbus/my-event-bus/eventsource/mymns.source"
  },
  "Code": "Success",
  "Success": true
}
```

**Key Fields**:
- `Data.EventSourceARN` — The Alibaba Cloud Resource Name of the created event source
- `RequestId` — Unique identifier for the API request
- `Code` — Status code indicating success or failure
- `Success` — Boolean indicating whether the operation succeeded
- `Message` — Detailed error message when the operation fails

## Error Handling

| Error Code (Code) | Description (Description) | Recommended Action (Recommended Action) |
|---------------|--------------------|-----------------------------|
| 400 | Bad Request. The request body is malformed or contains invalid parameters. | Validate your request parameters and ensure they match the required format and constraints. |
| 401 | Unauthorized. The provided credentials are invalid or missing. | Verify your AccessKey ID and Secret are correct and properly configured. |
| 403 | Forbidden. The user does not have sufficient permissions to perform this operation. | Check your RAM permissions and ensure you have the required EventBridge permissions. |
| 404 | Not Found. The specified resource (e.g., event bus) does not exist. | Verify the resource names (event bus, rule, source) exist and are spelled correctly. |
| 429 | Too Many Requests. Rate limit exceeded. Wait before retrying. | Implement exponential backoff and respect the rate limits (typically 100 QPS). |
| 500 | Internal Server Error. An unexpected error occurred on the server side. | Retry the request after a short delay. If persistent, contact support with the RequestId. |
| EventRuleTargetIdDuplicate | The ID of the event target is duplicate. | Use a unique ID for each event target within the same rule. |
| EventSourceNotExist | The event source in request is not exist! | Verify the event source name exists before attempting operations on it. |
| EventBusNotExist | The specified event bus does not exist. | Ensure the event bus is created before publishing events or creating sources/targets. |

### Rate Limits & Retry
- Standard rate limit: 100 QPS per account across most operations
- Event publishing limits: Maximum of 16 events per request, max total size 256 KB, max single event size 64 KB
- For 429 errors, implement exponential backoff starting with a 1-second delay
- Some operations have specific limits (e.g., QueryEventsByPeriod allows max 50 entries per call)

## Environment Requirements

- No specific SDK is required as EventBridge provides REST APIs
- For programmatic access, any HTTP client library can be used
- Environment variables for credentials:
  - `ALIBABA_CLOUD_ACCESS_KEY_ID` - Your AccessKey ID
  - `ALIBABA_CLOUD_ACCESS_KEY_SECRET` - Your AccessKey Secret
- Signature generation requires HMAC-SHA1 implementation (available in most standard libraries)

## FAQ

Q: How do I authenticate API requests to EventBridge?
A: Use AccessKey authentication by setting the `Authorization` header to `acs <AccessKeyId>:<Signature>`, where the signature is generated using HMAC-SHA1 with your AccessKeySecret.

Q: What's the difference between system event sources and custom event sources?
A: System event sources are official Alibaba Cloud services that automatically publish events to EventBridge (like ECS, OSS, RDS). Custom event sources are user-created connections to external systems like RabbitMQ, Kafka, or HTTP endpoints.

Q: How can I debug why my events aren't being delivered to targets?
A: Use the `QueryEventTraces` API with your event ID to see the complete delivery path, including rule matching results and target delivery status with latency information.

Q: What event format does EventBridge expect for custom events?
A: EventBridge uses the CloudEvents 1.0 specification. Required fields include `specversion`, `id`, `source`, `time`, `type`, and `aliyuneventbusname`. The `data` field contains your custom payload.

Q: Can I transform event data before sending to targets?
A: Yes, EventBridge supports four transformation methods: Complete Event (full event), Partial Event (JSONPath extraction), Constant (static value), and Template (dynamic assembly with variables).

## Pricing & Billing

### Billing Model
EventBridge uses a pay-as-you-go billing model charged per API request. Each successful API call counts as one request, regardless of the number of events processed.

### Price Reference

| Tier/Model | Input Price | Output Price | Other Fees |
|-----------|---------|---------|---------|
| standard | 0.0001 / | 0.0001 / |

### Free Tier
Most operations include a free tier of 1000 requests per month. Some specialized operations may have different free quotas (e.g., 100 free calls for certain management operations).

### Usage Limits
- Rate limits: Typically 100 QPS per account
- Event size limits: Max 64 KB per event, 256 KB per batch request
- Event source limits: Varies by source type (e.g., MNS, RocketMQ have their own constraints)
- Target limits: Up to 100 targets per rule

### Billing Notes
- Failed requests are generally not billed, except for some configuration operations
- Cross-region data transfer may incur additional fees
- Event size is calculated based on the actual payload size in bytes
- Free tier resets monthly and doesn't carry over to the next month