Merge branch 'main' into support_putevents_in_apigatewayv2_eventbridge_integrations

Author: mergify[bot]

allowed-breaking-changes.txt

@@ -4023,6 +4023,10 @@ removed:aws-cdk-lib.aws_ecs.AsgCapacityProviderProps.canContainersAccessInstance
 # Exposed struct with a ref interface
 weakened:aws-cdk-lib.aws_batch.OrderedComputeEnvironment
 
+# Weakened guarantees of a data structure that's intended for internal construct usage
+weakened:aws-cdk-lib.aws_ec2.FlowLogDestinationConfig
+weakened:aws-cdk-lib.aws_ecs.ExecuteCommandLogConfiguration
+
 # Revert of PR #36378 which introduced reference interfaces that caused runtime errors
 # https://github.com/aws/aws-cdk/issues/36621
 removed:aws-cdk-lib.aws_apigatewayv2.HttpApiHelper

packages/@aws-cdk/aws-iot-actions-alpha/README.md

@@ -371,6 +371,26 @@ topicRule.addAction(
 );
 ```
 
+You can enable batching to reduce costs and improve efficiency:
+
+```ts
+import { Size } from 'aws-cdk-lib';
+
+declare const topicRule: iot.TopicRule;
+
+topicRule.addAction(
+  new actions.HttpsAction('https://example.com/endpoint', {
+    batchConfig: {
+      maxBatchOpenDuration: Duration.millis(100),
+      maxBatchSize: 5,
+      maxBatchSizeBytes: Size.kibibytes(1),
+    },
+  }),
+);
+```
+
+For more information about the batching configuration, see the [AWS IoT Core documentation](https://docs.aws.amazon.com/iot/latest/developerguide/http_batching.html).
+
 ## Write Data to Open Search Service
 
 The code snippet below creates an AWS IoT Rule that writes data

packages/@aws-cdk/aws-iot-actions-alpha/lib/https-action.ts

@@ -1,4 +1,5 @@
 import * as iot from '@aws-cdk/aws-iot-alpha';
+import { Duration, Size, UnscopedValidationError } from 'aws-cdk-lib';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import { CommonActionProps } from './common-action-props';
 import { singletonActionRole } from './private/role';
@@ -25,6 +26,40 @@ export interface HttpActionHeader {
   readonly value: string;
 }
 
+/**
+ * Configuration for batching HTTP action messages.
+ *
+ * @see https://docs.aws.amazon.com/iot/latest/developerguide/http_batching.html
+ */
+export interface HttpActionBatchConfig {
+  /**
+   * The maximum amount of time an outgoing message waits for other messages to create the batch.
+   *
+   * Must be between 5 ms and 200 ms.
+   *
+   * @default Duration.millis(20)
+   */
+  readonly maxBatchOpenDuration?: Duration;
+
+  /**
+   * The maximum number of messages that are batched together in a single IoT rule action execution.
+   *
+   * Must be between 2 and 10.
+   *
+   * @default 10
+   */
+  readonly maxBatchSize?: number;
+
+  /**
+   * Maximum size of a message batch.
+   *
+   * Must be between 100 bytes and 128 KiB.
+   *
+   * @default Size.kibibytes(5)
+   */
+  readonly maxBatchSizeBytes?: Size;
+}
+
 /**
  * Configuration properties of an HTTPS action.
  *
@@ -45,6 +80,16 @@ export interface HttpsActionProps extends CommonActionProps {
    * Use Sigv4 authorization.
    */
   readonly auth?: HttpActionSigV4Auth;
+
+  /**
+   * Configuration for batching HTTP action messages.
+   *
+   * When provided, batching is automatically enabled.
+   *
+   * @see https://docs.aws.amazon.com/iot/latest/developerguide/http_batching.html
+   * @default - Batching is disabled
+   */
+  readonly batchConfig?: HttpActionBatchConfig;
 }
 
 /**
@@ -56,17 +101,47 @@ export class HttpsAction implements iot.IAction {
   private readonly confirmationUrl?: string;
   private readonly headers?: Array<HttpActionHeader>;
   private readonly auth?: HttpActionSigV4Auth;
+  private readonly batchConfig?: HttpActionBatchConfig;
 
   /**
    * @param url The url to which to send post request.
    * @param props Optional properties to not use default.
    */
-  constructor( url: string, props: HttpsActionProps={}) {
+  constructor(url: string, props: HttpsActionProps = {}) {
     this.url = url;
     this.confirmationUrl = props.confirmationUrl;
     this.headers = props.headers;
     this.role = props.role;
     this.auth = props.auth;
+    this.batchConfig = props.batchConfig;
+
+    this.validateBatchConfig();
+  }
+
+  private validateBatchConfig(): void {
+    if (!this.batchConfig) {
+      return;
+    }
+
+    if (this.batchConfig.maxBatchOpenDuration) {
+      const ms = this.batchConfig.maxBatchOpenDuration.toMilliseconds();
+      if (ms < Duration.millis(5).toMilliseconds() || ms > Duration.millis(200).toMilliseconds()) {
+        throw new UnscopedValidationError(`maxBatchOpenDuration must be between 5 ms and 200 ms, got ${ms} ms`);
+      }
+    }
+
+    if (this.batchConfig.maxBatchSize) {
+      if (this.batchConfig.maxBatchSize < 2 || this.batchConfig.maxBatchSize > 10) {
+        throw new UnscopedValidationError(`maxBatchSize must be between 2 and 10, got ${this.batchConfig.maxBatchSize}`);
+      }
+    }
+
+    if (this.batchConfig.maxBatchSizeBytes) {
+      const bytes = this.batchConfig.maxBatchSizeBytes.toBytes();
+      if (bytes < Size.bytes(100).toBytes() || bytes > Size.kibibytes(128).toBytes()) {
+        throw new UnscopedValidationError(`maxBatchSizeBytes must be between 100 bytes and 128 KiB, got ${bytes} bytes`);
+      }
+    }
   }
 
   /**
@@ -82,13 +157,21 @@ export class HttpsAction implements iot.IAction {
       },
     } : this.auth;
 
+    const batchConfig = this.batchConfig ? {
+      maxBatchOpenMs: this.batchConfig.maxBatchOpenDuration?.toMilliseconds(),
+      maxBatchSize: this.batchConfig.maxBatchSize,
+      maxBatchSizeBytes: this.batchConfig.maxBatchSizeBytes?.toBytes(),
+    } : undefined;
+
     return {
       configuration: {
         http: {
           url: this.url,
           confirmationUrl: this.confirmationUrl,
           headers: this.headers,
           auth: sigV4,
+          enableBatching: this.batchConfig ? true : false,
+          batchConfig,
         },
       },
     };

packages/@aws-cdk/aws-iot-actions-alpha/test/https/https-action.test.ts

@@ -1,5 +1,6 @@
 import * as iot from '@aws-cdk/aws-iot-alpha';
 import * as cdk from 'aws-cdk-lib';
+import { Duration, Size } from 'aws-cdk-lib';
 import { Template, Match } from 'aws-cdk-lib/assertions';
 import * as actions from '../../lib';
 
@@ -159,3 +160,116 @@ test('can set http auth', () => {
     },
   });
 });
+
+describe('batchConfig', () => {
+  test('can set batch config', () => {
+    // GIVEN
+    const stack = new cdk.Stack();
+    const topicRule = new iot.TopicRule(stack, 'TopicRule', {
+      sql: iot.IotSql.fromStringAsVer20160323(
+        "SELECT topic(2) as device_id FROM 'device/+/data'",
+      ),
+    });
+    const expectedUrl = 'https://example.com';
+
+    // WHEN
+    topicRule.addAction(
+      new actions.HttpsAction(expectedUrl, {
+        batchConfig: {
+          maxBatchOpenDuration: Duration.millis(100),
+          maxBatchSize: 5,
+          maxBatchSizeBytes: Size.kibibytes(1),
+        },
+      }),
+    );
+
+    // THEN
+    Template.fromStack(stack).hasResourceProperties('AWS::IoT::TopicRule', {
+      TopicRulePayload: {
+        Actions: [
+          {
+            Http: {
+              Url: expectedUrl,
+              EnableBatching: true,
+              BatchConfig: {
+                MaxBatchOpenMs: 100,
+                MaxBatchSize: 5,
+                MaxBatchSizeBytes: 1024,
+              },
+            },
+          },
+        ],
+      },
+    });
+  });
+
+  test('sets enableBatching to false when batchConfig is not provided', () => {
+    // GIVEN
+    const stack = new cdk.Stack();
+    const topicRule = new iot.TopicRule(stack, 'MyTopicRule', {
+      sql: iot.IotSql.fromStringAsVer20160323(
+        "SELECT topic(2) as device_id FROM 'device/+/data'",
+      ),
+    });
+    const expectedUrl = 'https://example.com';
+
+    // WHEN
+    topicRule.addAction(new actions.HttpsAction(expectedUrl));
+
+    // THEN
+    Template.fromStack(stack).hasResourceProperties('AWS::IoT::TopicRule', {
+      TopicRulePayload: {
+        Actions: [
+          {
+            Http: {
+              Url: expectedUrl,
+              EnableBatching: false,
+            },
+          },
+        ],
+      },
+    });
+  });
+
+  test.each([1, 11])('throws if maxBatchSize is %i', (maxBatchSize) => {
+    // GIVEN
+    const expectedUrl = 'https://example.com';
+
+    // THEN
+    expect(() => {
+      new actions.HttpsAction(expectedUrl, {
+        batchConfig: {
+          maxBatchSize,
+        },
+      });
+    }).toThrow(`maxBatchSize must be between 2 and 10, got ${maxBatchSize}`);
+  });
+
+  test.each([Size.bytes(99), Size.kibibytes(129)])('throws if maxBatchSizeBytes is %s', (maxBatchSizeBytes) => {
+    // GIVEN
+    const expectedUrl = 'https://example.com';
+
+    // THEN
+    expect(() => {
+      new actions.HttpsAction(expectedUrl, {
+        batchConfig: {
+          maxBatchSizeBytes,
+        },
+      });
+    }).toThrow(`maxBatchSizeBytes must be between 100 bytes and 128 KiB, got ${maxBatchSizeBytes.toBytes()} bytes`);
+  });
+
+  test.each([Duration.millis(4), Duration.millis(201)])('throws if maxBatchOpenDuration is %s', (maxBatchOpenDuration) => {
+    // GIVEN
+    const expectedUrl = 'https://example.com';
+
+    // THEN
+    expect(() => {
+      new actions.HttpsAction(expectedUrl, {
+        batchConfig: {
+          maxBatchOpenDuration,
+        },
+      });
+    }).toThrow(`maxBatchOpenDuration must be between 5 ms and 200 ms, got ${maxBatchOpenDuration.toMilliseconds()} ms`);
+  });
+});