aws-cdk-lib 2.179.0__py3-none-any.whl → 2.180.0__py3-none-any.whl

aws_cdk/aws_lambda/__init__.py

@@ -23047,25 +23047,20 @@ class StartingPosition(enum.Enum):
 
     Example::
 
-        from aws_cdk.aws_lambda_event_sources import ManagedKafkaEventSource
+        import aws_cdk.aws_kinesis as kinesis
+        from aws_cdk.aws_lambda_event_sources import KinesisConsumerEventSource
         
         # my_function: lambda.Function
         
         
-        # Your MSK cluster arn
-        cluster_arn = "arn:aws:kafka:us-east-1:0123456789019:cluster/SalesCluster/abcd1234-abcd-cafe-abab-9876543210ab-4"
-        
-        # The Kafka topic you want to subscribe to
-        topic = "some-cool-topic"
-        my_function.add_event_source(ManagedKafkaEventSource(
-            cluster_arn=cluster_arn,
-            topic=topic,
-            starting_position=lambda_.StartingPosition.TRIM_HORIZON,
-            filters=[
-                lambda_.FilterCriteria.filter({
-                    "string_equals": lambda_.FilterRule.is_equal("test")
-                })
-            ]
+        stream = kinesis.Stream(self, "MyStream")
+        stream_consumer = kinesis.StreamConsumer(self, "MyStreamConsumer",
+            stream=stream,
+            stream_consumer_name="MyStreamConsumer"
+        )
+        my_function.add_event_source(KinesisConsumerEventSource(stream_consumer,
+            batch_size=100,  # default
+            starting_position=lambda_.StartingPosition.TRIM_HORIZON
         ))
     '''
 

aws_cdk/aws_lambda_event_sources/__init__.py

@@ -244,7 +244,7 @@ behavior:
 * **startingPosition**: Will determine where to begin consumption. 'LATEST' will start at the most recent record and ignore all records that arrived prior to attaching the event source, 'TRIM_HORIZON' will start at the oldest record and ensure you process all available data, while 'AT_TIMESTAMP' will start reading records from a specified time stamp. Note that 'AT_TIMESTAMP' is only supported for Amazon Kinesis streams.
 * **startingPositionTimestamp**: The time stamp from which to start reading. Used in conjunction with **startingPosition** when set to 'AT_TIMESTAMP'.
 * **tumblingWindow**: The duration in seconds of a processing window when using streams.
-* **enabled**: If the DynamoDB Streams event source mapping should be enabled. The default is true.
+* **enabled**: If the event source mapping should be enabled. The default is true.
 
 ```python
 import aws_cdk.aws_kinesis as kinesis
@@ -260,6 +260,26 @@ my_function.add_event_source(KinesisEventSource(stream,
 ))
 ```
 
+To use a dedicated-throughput consumer with enhanced fan-out
+
+```python
+import aws_cdk.aws_kinesis as kinesis
+from aws_cdk.aws_lambda_event_sources import KinesisConsumerEventSource
+
+# my_function: lambda.Function
+
+
+stream = kinesis.Stream(self, "MyStream")
+stream_consumer = kinesis.StreamConsumer(self, "MyStreamConsumer",
+    stream=stream,
+    stream_consumer_name="MyStreamConsumer"
+)
+my_function.add_event_source(KinesisConsumerEventSource(stream_consumer,
+    batch_size=100,  # default
+    starting_position=lambda_.StartingPosition.TRIM_HORIZON
+))
+```
+
 ## Kafka
 
 You can write Lambda functions to process data either from [Amazon MSK](https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html) or a [self managed Kafka](https://docs.aws.amazon.com/lambda/latest/dg/kafka-smaa.html) cluster.
@@ -486,7 +506,9 @@ from ..aws_ec2 import (
     IVpc as _IVpc_f30d5663,
     SubnetSelection as _SubnetSelection_e57d76df,
 )
-from ..aws_kinesis import IStream as _IStream_4e2457d2
+from ..aws_kinesis import (
+    IStream as _IStream_4e2457d2, IStreamConsumer as _IStreamConsumer_019d062e
+)
 from ..aws_kms import IKey as _IKey_5f11635f
 from ..aws_lambda import (
     DlqDestinationConfig as _DlqDestinationConfig_5fe54cfa,
@@ -3493,6 +3515,127 @@ class DynamoEventSourceProps(StreamEventSourceProps):
         )
 
 
+class KinesisConsumerEventSource(
+    StreamEventSource,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_lambda_event_sources.KinesisConsumerEventSource",
+):
+    '''Use an Amazon Kinesis stream consumer as an event source for AWS Lambda.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_kinesis as kinesis
+        from aws_cdk.aws_lambda_event_sources import KinesisConsumerEventSource
+        
+        # my_function: lambda.Function
+        
+        
+        stream = kinesis.Stream(self, "MyStream")
+        stream_consumer = kinesis.StreamConsumer(self, "MyStreamConsumer",
+            stream=stream,
+            stream_consumer_name="MyStreamConsumer"
+        )
+        my_function.add_event_source(KinesisConsumerEventSource(stream_consumer,
+            batch_size=100,  # default
+            starting_position=lambda_.StartingPosition.TRIM_HORIZON
+        ))
+    '''
+
+    def __init__(
+        self,
+        stream_consumer: _IStreamConsumer_019d062e,
+        *,
+        starting_position_timestamp: typing.Optional[jsii.Number] = None,
+        bisect_batch_on_error: typing.Optional[builtins.bool] = None,
+        filter_encryption: typing.Optional[_IKey_5f11635f] = None,
+        filters: typing.Optional[typing.Sequence[typing.Mapping[builtins.str, typing.Any]]] = None,
+        max_record_age: typing.Optional[_Duration_4839e8c3] = None,
+        metrics_config: typing.Optional[typing.Union[_MetricsConfig_48ab59c4, typing.Dict[builtins.str, typing.Any]]] = None,
+        on_failure: typing.Optional[_IEventSourceDlq_5e2c6ad9] = None,
+        parallelization_factor: typing.Optional[jsii.Number] = None,
+        report_batch_item_failures: typing.Optional[builtins.bool] = None,
+        retry_attempts: typing.Optional[jsii.Number] = None,
+        tumbling_window: typing.Optional[_Duration_4839e8c3] = None,
+        starting_position: _StartingPosition_c0a4852c,
+        batch_size: typing.Optional[jsii.Number] = None,
+        enabled: typing.Optional[builtins.bool] = None,
+        max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''
+        :param stream_consumer: -
+        :param starting_position_timestamp: The time from which to start reading, in Unix time seconds. Default: - no timestamp
+        :param bisect_batch_on_error: If the function returns an error, split the batch in two and retry. Default: false
+        :param filter_encryption: Add Customer managed KMS key to encrypt Filter Criteria. Default: - none
+        :param filters: Add filter criteria option. Default: - None
+        :param max_record_age: The maximum age of a record that Lambda sends to a function for processing. Valid Range: - Minimum value of 60 seconds - Maximum value of 7 days The default value is -1, which sets the maximum age to infinite. When the value is set to infinite, Lambda never discards old records. Record are valid until it expires in the event source. Default: -1
+        :param metrics_config: Configuration for enhanced monitoring metrics collection When specified, enables collection of additional metrics for the stream event source. Default: - Enhanced monitoring is disabled
+        :param on_failure: An Amazon SQS queue or Amazon SNS topic destination for discarded records. Default: - discarded records are ignored
+        :param parallelization_factor: The number of batches to process from each shard concurrently. Valid Range: - Minimum value of 1 - Maximum value of 10 Default: 1
+        :param report_batch_item_failures: Allow functions to return partially successful responses for a batch of records. Default: false
+        :param retry_attempts: Maximum number of retry attempts Valid Range: * Minimum value of 0 * Maximum value of 10000. The default value is -1, which sets the maximum number of retries to infinite. When MaximumRetryAttempts is infinite, Lambda retries failed records until the record expires in the event source. Default: -1
+        :param tumbling_window: The size of the tumbling windows to group records sent to DynamoDB or Kinesis Valid Range: 0 - 15 minutes. Default: - None
+        :param starting_position: Where to begin consuming the stream.
+        :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
+        :param enabled: If the stream event source mapping should be enabled. Default: true
+        :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5d4436c01738e680b66bbfda741235beea5eb51d1e287ec05ae0c58abfa41f1a)
+            check_type(argname="argument stream_consumer", value=stream_consumer, expected_type=type_hints["stream_consumer"])
+        props = KinesisEventSourceProps(
+            starting_position_timestamp=starting_position_timestamp,
+            bisect_batch_on_error=bisect_batch_on_error,
+            filter_encryption=filter_encryption,
+            filters=filters,
+            max_record_age=max_record_age,
+            metrics_config=metrics_config,
+            on_failure=on_failure,
+            parallelization_factor=parallelization_factor,
+            report_batch_item_failures=report_batch_item_failures,
+            retry_attempts=retry_attempts,
+            tumbling_window=tumbling_window,
+            starting_position=starting_position,
+            batch_size=batch_size,
+            enabled=enabled,
+            max_batching_window=max_batching_window,
+            provisioned_poller_config=provisioned_poller_config,
+        )
+
+        jsii.create(self.__class__, self, [stream_consumer, props])
+
+    @jsii.member(jsii_name="bind")
+    def bind(self, target: _IFunction_6adb0ab8) -> None:
+        '''Called by ``lambda.addEventSource`` to allow the event source to bind to this function.
+
+        :param target: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__7cd6beafb45fd5092320f505d4c975a198986b37261f8d9700231eee9d820412)
+            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
+        return typing.cast(None, jsii.invoke(self, "bind", [target]))
+
+    @builtins.property
+    @jsii.member(jsii_name="eventSourceMappingArn")
+    def event_source_mapping_arn(self) -> builtins.str:
+        '''The ARN for this EventSourceMapping.'''
+        return typing.cast(builtins.str, jsii.get(self, "eventSourceMappingArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="eventSourceMappingId")
+    def event_source_mapping_id(self) -> builtins.str:
+        '''The identifier for this EventSourceMapping.'''
+        return typing.cast(builtins.str, jsii.get(self, "eventSourceMappingId"))
+
+    @builtins.property
+    @jsii.member(jsii_name="streamConsumer")
+    def stream_consumer(self) -> _IStreamConsumer_019d062e:
+        return typing.cast(_IStreamConsumer_019d062e, jsii.get(self, "streamConsumer"))
+
+
 class KinesisEventSource(
     StreamEventSource,
     metaclass=jsii.JSIIMeta,
@@ -4164,6 +4307,7 @@ __all__ = [
     "DynamoEventSource",
     "DynamoEventSourceProps",
     "KafkaEventSourceProps",
+    "KinesisConsumerEventSource",
     "KinesisEventSource",
     "KinesisEventSourceProps",
     "ManagedKafkaEventSource",
@@ -4501,6 +4645,35 @@ def _typecheckingstub__ec371d5e4612e8923bbdcc024d90e26915d64be2dc40151f22fc41139
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5d4436c01738e680b66bbfda741235beea5eb51d1e287ec05ae0c58abfa41f1a(
+    stream_consumer: _IStreamConsumer_019d062e,
+    *,
+    starting_position_timestamp: typing.Optional[jsii.Number] = None,
+    bisect_batch_on_error: typing.Optional[builtins.bool] = None,
+    filter_encryption: typing.Optional[_IKey_5f11635f] = None,
+    filters: typing.Optional[typing.Sequence[typing.Mapping[builtins.str, typing.Any]]] = None,
+    max_record_age: typing.Optional[_Duration_4839e8c3] = None,
+    metrics_config: typing.Optional[typing.Union[_MetricsConfig_48ab59c4, typing.Dict[builtins.str, typing.Any]]] = None,
+    on_failure: typing.Optional[_IEventSourceDlq_5e2c6ad9] = None,
+    parallelization_factor: typing.Optional[jsii.Number] = None,
+    report_batch_item_failures: typing.Optional[builtins.bool] = None,
+    retry_attempts: typing.Optional[jsii.Number] = None,
+    tumbling_window: typing.Optional[_Duration_4839e8c3] = None,
+    starting_position: _StartingPosition_c0a4852c,
+    batch_size: typing.Optional[jsii.Number] = None,
+    enabled: typing.Optional[builtins.bool] = None,
+    max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__7cd6beafb45fd5092320f505d4c975a198986b37261f8d9700231eee9d820412(
+    target: _IFunction_6adb0ab8,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__9f81acc98c12b4967363bdd43130a7e674a566679a7b200f5ccd6a0ae313ad2e(
     stream: _IStream_4e2457d2,
     *,