# packages

pkgId: 8df449e551666069bffc32de644fa44cb537781bab7ce1dc9d82025f11a68831
name: python-aws-solutions-constructs.aws-alb-lambda
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for Application Load Balancer to AWS Lambda integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-alb-lambda-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_alb_lambda`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-alb-lambda`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.alblambda`|

  This AWS Solutions Construct implements an an Application Load Balancer to an AWS Lambda function
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { AlbToLambda, AlbToLambdaProps } from '@aws-solutions-constructs/aws-alb-lambda';
  import * as acm from 'aws-cdk-lib/aws-certificatemanager';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  // Obtain a pre-existing certificate from your account
  const certificate = acm.Certificate.fromCertificateArn(
      this,
      'existing-cert',
      "arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012"
  );
  const constructProps: AlbToLambdaProps = {
    lambdaFunctionProps: {
      code: lambda.Code.fromAsset(`lambda`),
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler'
    },
    listenerProps: {
      certificates: [certificate]
    },
    publicApi: true
  };
  // Note - all alb constructs turn on ELB logging by default, so require that an environment including account
  // and region be provided when creating the stack
  //
  // new MyStack(app, 'id', {env: {account: '123456789012', region: 'us-east-1' }});
  new AlbToLambda(this, 'new-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_alb_lambda import AlbToLambda, AlbToLambdaProps
  from aws_cdk import (
      aws_certificatemanager as acm,
      aws_lambda as _lambda,
      aws_elasticloadbalancingv2 as alb,
      Stack
  )
  from constructs import Construct

  certificate = acm.Certificate.from_certificate_arn(
    self,
    'existing-cert',
    "arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012"
  )




  AlbToLambda(self, 'new-construct',
              lambda_function_props=_lambda.FunctionProps(
                  runtime=_lambda.Runtime.PYTHON_3_7,
                  code=_lambda.Code.from_asset('lambda'),
                  handler='index.handler',
              ),
              listener_props=alb.BaseApplicationListenerProps(
                  certificates=[certificate]
              ),
              public_api=True)
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.elasticloadbalancingv2.*;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.alblambda.*;
  // Obtain a pre-existing certificate from your account
  ListenerCertificate listenerCertificate = ListenerCertificate
          .fromArn("arn:aws:acm:us-east-1:123456789012:certificate/11112222-3333-1234-1234-123456789012");
  // Note - all alb constructs turn on ELB logging by default, so require that an environment including account
  // and region be provided when creating the stack
  //
  // new MyStack(app, "id", StackProps.builder()
  //         .env(Environment.builder()
  //                 .account("123456789012")
  //                 .region("us-east-1")
  //                 .build());
  new AlbToLambda(this, "AlbToLambdaPattern", new AlbToLambdaProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .listenerProps(new BaseApplicationListenerProps.Builder()
                  .certificates(List.of(listenerCertificate))
                  .build())
          .publicApi(true)
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | loadBalancerProps? | [elasticloadbalancingv2.ApplicationLoadBalancerProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticloadbalancingv2.ApplicationLoadBalancerProps.html) | Optional custom properties for a new loadBalancer. Providing both this and existingLoadBalancer is an error. This cannot specify a VPC, it will use the VPC in existingVpc or the VPC created by the construct. |
  | existingLoadBalancerObj? | [elasticloadbalancingv2.ApplicationLoadBalancer](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticloadbalancingv2.ApplicationLoadBalancer.html) | Existing Application Load Balancer to incorporate into the construct architecture. Providing both this and loadBalancerProps is an error. The VPC containing this loadBalancer must match the VPC provided in existingVpc. |
  | listenerProps? | [ApplicationListenerProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticloadbalancingv2.ApplicationListenerProps.html) | Props to define the listener. Must be provided when adding the listener to an ALB (eg - when creating the alb), may not be provided when adding a second target to an already established listener. When provided, must include either a certificate or protocol: HTTP |
  | targetProps? | [ApplicationTargetGroupProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticloadbalancingv2.ApplicationTargetGroupProps.html) | Optional custom properties for a new target group. While this is a standard attribute of props for ALB constructs, there are few pertinent properties for a Lambda target. |
  | ruleProps? | [AddRuleProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticloadbalancingv2.AddRuleProps.html) | Rules for directing traffic to the target being created. May not be specified for the first listener added to an ALB, and must be specified for the second target added to a listener. Add a second target by instantiating this construct a second time and providing the existingAlb from the first instantiation. |
  | vpcProps? | [ec2.VpcProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by the new ALB and any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|Optional user provided props to override the default props for the Lambda function.|
  | existingVpc? | [ec2.IVpc](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | logAlbAccessLogs? | boolean| Whether to turn on Access Logs for the Application Load Balancer. Uses an S3 bucket with associated storage costs.Enabling Access Logging is a best practice. default - true |
  | albLoggingBucketProps? | [s3.BucketProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html) | Optional properties to customize the bucket used to store the ALB Access Logs. Supplying this and setting logAccessLogs to false is an error. @default - none |
  | publicApi | boolean | Whether the construct is deploying a private or public API. This has implications for the VPC and ALB. |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [ec2.IVpc](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or providedb by the client) |
  | loadBalancer | [elasticloadbalancingv2.ApplicationLoadBalancer](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticloadbalancingv2.ApplicationLoadBalancer.html) | The Load Balancer used by the construct (whether created by the construct or provided by the client) |
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda function used in the pattern.|
  | listener | [`elb.ApplicationListener`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticloadbalancingv2.ApplicationListener.html) | The listener used by this pattern. |

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Creates or configures an Application Load Balancer with:
    * Required listeners
    * New target group with routing rules if appropriate

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: d1aa2d123d1faa137ddb0e704cc59a79e8779af4ddccc5a179ef968e9f100443
name: python-aws-solutions-constructs.aws-apigateway-dynamodb
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS API Gateway and Amazon DynamoDB integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-apigateway-dynamodb-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_apigateway_dynamodb`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-apigateway-dynamodb`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.apigatewaydynamodb`|

  This AWS Solutions Construct implements an Amazon API Gateway REST API connected to Amazon DynamoDB table.
  Here is a minimal deployable pattern definition in:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { ApiGatewayToDynamoDBProps, ApiGatewayToDynamoDB } from "@aws-solutions-constructs/aws-apigateway-dynamodb";
  new ApiGatewayToDynamoDB(this, 'test-api-gateway-dynamodb-default', {});
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_apigateway_dynamodb import ApiGatewayToDynamoDB
  from aws_cdk import Stack
  from constructs import Construct
  ApiGatewayToDynamoDB(self, 'test-api-gateway-dynamodb-default')
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.apigatewaydynamodb.*;
  new ApiGatewayToDynamoDB(this, "test-api-gateway-dynamodb-default", new ApiGatewayToDynamoDBProps.Builder()
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |dynamoTableProps?|[`dynamodb.TableProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.TableProps.html)|Optional user provided props to override the default props for DynamoDB Table.|
  |existingTableObj?|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Existing instance of DynamoDB table object, providing both this and `dynamoTableProps` will cause an error.|
  |apiGatewayProps?|[`api.RestApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApiProps.html)|Optional user-provided props to override the default props for the API Gateway.|
  |resourceName?|`string`|Optional name of the resource on the API Gateway. Defaults to the table's partitionKeyName|
  |allowCreateOperation?|`boolean`|Whether to deploy an API Gateway Method for POST HTTP operations on the DynamoDB table (i.e. dynamodb:PutItem).|
  |createRequestTemplate?|`string`|API Gateway Request Template for the create method for the default `application/json` content-type. This property is required if the `allowCreateOperation` property is set to true.|
  |additionalCreateRequestTemplates?|`{ [contentType: string]: string; }`|Optional Create Request Templates for content-types other than `application/json`. Use the `createRequestTemplate` property to set the request template for the `application/json` content-type. This property can only be specified if the `allowCreateOperation` property is set to true.|
  |createIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the create method. This property can only be specified if the `allowCreateOperation` property is set to true.|
  |createMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the create action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |allowReadOperation?|`boolean`|Whether to deploy an API Gateway Method for GET HTTP operations on DynamoDB table (i.e. dynamodb:Query).|
  |readRequestTemplate?|`string`|API Gateway Request Template for the read method for the default `application/json` content-type. The default template only supports a partition key and not partition + sort keys.|
  |additionalReadRequestTemplates?|`{ [contentType: string]: string; }`|Optional Read Request Templates for content-types other than `application/json`. Use the `readRequestTemplate` property to set the request template for the `application/json` content-type.|
  |readIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the read method.|
  |allowUpdateOperation?|`boolean`|Whether to deploy API Gateway Method for PUT HTTP operations on DynamoDB table (i.e. dynamodb:UpdateItem).|
  |readMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the read action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |updateRequestTemplate?|`string`|API Gateway Request Template for the update method. This property is required if the `allowUpdateOperation` property is set to true.|
  |additionalUpdateRequestTemplates?|`{ [contentType: string]: string; }`|Optional Update Request Templates for content-types other than `application/json`. Use the `updateRequestTemplate` property to set the request template for the `application/json` content-type. This property can only be specified if the `allowUpdateOperation` property is set to true.|
  |updateIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the update method. This property can only be specified if the `allowUpdateOperation` property is set to true.|
  |updateMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the update action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |allowDeleteOperation?|`boolean`|Whether to deploy API Gateway Method for DELETE HTTP operations on DynamoDB table (i.e. dynamodb:DeleteItem).|
  |deleteRequestTemplate?|`string`|API Gateway Request Template for the delete method for the default `application/json` content-type. |
  |additionalDeleteRequestTemplates?|`{ [contentType: string]: string; }`|Optional Delete request templates for content-types other than `application/json`. Use the `deleteRequestTemplate` property to set the request template for the `application/json` content-type. This property can only be specified if the `allowDeleteOperation` property is set to true.|
  |deleteIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the delete method. This property can only be specified if the `allowDeleteOperation` property is set to true.|
  |deleteMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the delete action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |apiGateway|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|Returns an instance of the api.RestApi created by the construct.|
  |apiGatewayRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway.|
  |dynamoTable|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Returns an instance of dynamodb.Table created by the construct.|
  |apiGatewayCloudWatchRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway for CloudWatch access.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|

  This construct allows you to implement four DynamoDB API operations, CREATE/READ/UPDATE/DELETE (corresponding the HTTP POST/GET/PUT/DELETE requests respectively). They are completely independent and each follows the same pattern:
  * Setting `allowCreateOperation` to true will implement the `application/json` content-type with default request and response templates
  * The request template for `application/json` requests can be customized using the `createRequestTemplate` prop value
  * *Additional* request templates can be specified using the `additionalCreateRequestTemplates` prop value. Note - these DO NOT replace the `application/json` content-type
  * Customized integration responses can be specified for any content type in the `createIntegrationResponses` prop value.
  Supplying any of these values without setting allowCreateOperation to true will result in an error. This pattern is the same for all four API operations.

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Deploy an edge-optimized API endpoint
  * Enable CloudWatch logging for API Gateway
  * Configure least privilege access IAM role for API Gateway
  * Set the default authorizationType for all API methods to IAM
  * Enable X-Ray Tracing

  * Set the billing mode for DynamoDB Table to On-Demand (Pay per request)
  * Enable server-side encryption for DynamoDB Table using AWS managed KMS Key
  * Creates a partition key called 'id' for DynamoDB Table
  * Retain the Table when deleting the CloudFormation stack
  * Enable continuous backups and point-in-time recovery


pkgId: 9e3187e2c2ee9e6920890bcaadd58eed3f32d610de7312b8094f1b38d11c44b5
name: python-aws-solutions-constructs.aws-apigateway-iot
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK constructs to proxy communication to IotCore using a APIGateway(REST).
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-apigateway-iot-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_apigateway_iot`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-apigateway-iot`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.apigatewayiot`|

  This AWS Solutions Construct implements an Amazon API Gateway REST API connected to AWS IoT pattern.
  This construct creates a scalable HTTPS proxy between API Gateway and AWS IoT. This comes in handy when wanting to allow legacy devices that do not support the MQTT or MQTT/Websocket protocol to interact with the AWS IoT platform.
  This implementation enables write-only messages to be published on given MQTT topics, and also supports shadow updates of HTTPS devices to allowed things in the device registry. It does not involve Lambda functions for proxying messages, and instead relies on direct API Gateway to AWS IoT integration which supports both JSON messages as well as binary messages.
  Here is a minimal deployable pattern definition, note that the ATS endpoint for IoT must be used to avoid SSL certificate issues:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { ApiGatewayToIot } from '@aws-solutions-constructs/aws-apigateway-iot';
  new ApiGatewayToIot(this, 'ApiGatewayToIotPattern', {
      iotEndpoint: 'a1234567890123-ats'
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_apigateway_iot import ApiGatewayToIot
  from aws_cdk import Stack
  from constructs import Construct
  ApiGatewayToIot(self, 'ApiGatewayToIotPattern',
      iot_endpoint='a1234567890123-ats'
  )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.apigatewayiot.*;
  new ApiGatewayToIot(this, "ApiGatewayToIotPattern", new ApiGatewayToIotProps.Builder()
          .iotEndpoint("a1234567890123-ats")
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |iotEndpoint|`string`|The AWS IoT endpoint subdomain to integrate the API Gateway with (e.g a1234567890123-ats). Note that this must point to the ATS endpoint to avoid SSL certificate trust issues. The endpoint can be retrieved by running `aws iot describe-endpoint --endpoint-type iot:Data-ATS`.|
  |apiGatewayCreateApiKey?|`boolean`|If set to `true`, an API Key is created and associated to a UsagePlan. User should specify `x-api-key` header while accessing RestApi. Default value set to `false`|
  |apiGatewayExecutionRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|IAM Role used by the API Gateway to access AWS IoT. If not specified, a default role is created with wildcard ('*') access to all topics and things.|
  |apiGatewayProps?|[`api.restApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApiProps.html)|Optional user-provided props to override the default props for the API Gateway.|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |apiGateway|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|Returns an instance of the API Gateway REST API created by the pattern.|
  |apiGatewayRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway.|
  |apiGatewayCloudWatchRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway for CloudWatch access.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Deploy an edge-optimized API Endpoint
  * Creates API Resources with `POST` Method to publish messages to IoT Topics
  * Creates API Resources with `POST` Method to publish messages to ThingShadow & NamedShadows
  * Enable CloudWatch logging for API Gateway
  * Configure IAM role for API Gateway with access to all topics and things
  * Set the default authorizationType for all API methods to IAM
  * Enable X-Ray Tracing
  * Creates a UsagePlan and associates to `prod` stage
  Below is a description of the different resources and methods exposed by the API Gateway after deploying the Construct. See the [Examples](#examples) section for more information on how to easily test these endpoints using `curl`.
  |Method         | Resource              | Query parameter(s) |  Return code(s)   |  Description|
  |-------------- | --------------------- | ------------------ | ----------------- | -----------------|
  |  **POST**     |  `/message/<topics>`  |      **qos**       |   `200/403/500`   | By calling this endpoint, you need to pass the topics on which you would like to publish (e.g `/message/device/foo`).|
  |  **POST**     | `/shadow/<thingName>` |      **None**      |   `200/403/500`   | This route allows to update the shadow document of a thing, given its `thingName` using Unnamed (classic) shadow type. The body shall comply with the standard shadow structure comprising a `state` node and associated `desired` and `reported` nodes. See the [Updating device shadows](#updating-device-shadows) section for an example.|
  |  **POST**     | `/shadow/<thingName>/<shadowName>` |      **None**      |   `200/403/500`   | This route allows to update the named shadow document of a thing, given its `thingName` and the `shadowName` using the Named shadow type. The body shall comply with the standard shadow structure comprising a `state` node and associated `desired` and `reported` nodes. See the [Updating named shadows](#updating-named-shadows) section for an example.|


pkgId: 4e1afdc09fb6efdda8b47f4e80fc194384d680331915b6d689bf7ecc29671a49
name: python-aws-solutions-constructs.aws-apigateway-kinesisstreams
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK Constructs for AWS API Gateway and Amazon Kinesis Data Streams integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-apigateway-kinesisstreams-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_apigateway_kinesisstreams`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-apigateway-kinesisstreams`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.apigatewaykinesisstreams`|

  This AWS Solutions Construct implements an Amazon API Gateway connected to an Amazon Kinesis Data Stream pattern.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { ApiGatewayToKinesisStreams, ApiGatewayToKinesisStreamsProps } from '@aws-solutions-constructs/aws-apigateway-kinesisstreams';
  new ApiGatewayToKinesisStreams(this, 'test-apigw-kinesis', {});
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_apigateway_kinesisstreams import ApiGatewayToKinesisStreams
  from aws_cdk import Stack
  from constructs import Construct
  ApiGatewayToKinesisStreams(self, 'test-apigw-kinesis')
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.apigatewaykinesisstreams.*;
  new ApiGatewayToKinesisStreams(this, "test-apigw-kinesis", new ApiGatewayToKinesisStreamsProps.Builder()
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |apiGatewayProps?|[`api.RestApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApiProps.html)|Optional user-provided props to override the default props for the API Gateway.|
  |putRecordRequestTemplate?|`string`|API Gateway request template for the PutRecord action. If not provided, a default one will be used.|
  |additionalPutRecordRequestTemplates?|`{ [contentType: string]: string; }`|Optional PutRecord Request Templates for content-types other than `application/json`. Use the `putRecordRequestTemplate` property to set the request template for the `application/json` content-type.|
  |putRecordRequestModel?|[`api.ModelOptions`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.ModelOptions.html)|API Gateway request model for the PutRecord action. If not provided, a default one will be created.|
  |putRecordIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the PutRecord action.|
  |putRecordMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the putRecord action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |putRecordsRequestTemplate?|`string`|API Gateway request template for the PutRecords action. If not provided, a default one will be used.|
  |additionalPutRecordsRequestTemplates?|`{ [contentType: string]: string; }`|Optional PutRecords Request Templates for content-types other than `application/json`. Use the `putRecordsRequestTemplate` property to set the request template for the `application/json` content-type.|
  |putRecordsRequestModel?|[`api.ModelOptions`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.ModelOptions.html)| API Gateway request model for the PutRecords action. If not provided, a default one will be created.|
  |putRecordsIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the PutRecords action.|
  |putRecordsMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the putRecords action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |existingStreamObj?|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Existing instance of Kinesis Stream, providing both this and `kinesisStreamProps` will cause an error.|
  |kinesisStreamProps?|[`kinesis.StreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.StreamProps.html)|Optional user-provided props to override the default props for the Kinesis stream.|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|
  |createCloudWatchAlarms|`boolean`|Whether to create recommended CloudWatch alarms for Kinesis Data Stream. Default value is set to `true`|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |apiGateway|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|Returns an instance of the API Gateway REST API created by the pattern.|
  |apiGatewayRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway.|
  |apiGatewayCloudWatchRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway for CloudWatch access.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|
  |kinesisStream|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Returns an instance of the Kinesis stream created or used by the pattern.|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns an array of recommended CloudWatch Alarms created by the construct for Kinesis Data stream|

  | **Method** | **Request Path** | **Request Body** | **Stream Action** | **Description** |
  |:-------------|:----------------|-----------------|-----------------|-----------------|
  |POST|`/record`| `{ "data": "Hello World!", "partitionKey": "pk001" }` |`kinesis:PutRecord`|Writes a single data record into the stream.|
  |POST|`/records`| `{ "records": [{ "data": "abc", "partitionKey": "pk001" }, { "data": "xyz", "partitionKey": "pk001" }] }` |`kinesis:PutRecords`|Writes multiple data records into the stream in a single call.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Deploy an edge-optimized API endpoint
  * Enable CloudWatch logging for API Gateway
  * Configure least privilege access IAM role for API Gateway
  * Set the default authorizationType for all API methods to IAM
  * Enable X-Ray Tracing
  * Validate request body before passing data to Kinesis

  * Configure least privilege access IAM role for Kinesis Stream
  * Enable server-side encryption for Kinesis Stream using AWS Managed KMS Key


pkgId: 0460fbfb2d0f6db661d9e234d65c2ec2f5fb7f18803c1cc59c05c595bdf2791d
name: python-aws-solutions-constructs.aws-apigateway-lambda
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK constructs for defining an interaction between an API Gateway and a Lambda function.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-apigateway-lambda-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_apigateway_lambda`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-apigateway-lambda`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.apigatewaylambda`|

  This AWS Solutions Construct implements an Amazon API Gateway REST API connected to an AWS Lambda function pattern.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { ApiGatewayToLambda } from '@aws-solutions-constructs/aws-apigateway-lambda';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new ApiGatewayToLambda(this, 'ApiGatewayToLambdaPattern', {
    lambdaFunctionProps: {
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset(`lambda`)
    }
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_apigateway_lambda import ApiGatewayToLambda
  from aws_cdk import (
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct
  ApiGatewayToLambda(self, 'ApiGatewayToLambdaPattern',
              lambda_function_props=_lambda.FunctionProps(
                  runtime=_lambda.Runtime.PYTHON_3_9,
                  handler='index.handler',
                  code=_lambda.Code.from_asset('lambda')
              )
              )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.apigatewaylambda.*;
  new ApiGatewayToLambda(this, "ApiGatewayToLambdaPattern", new ApiGatewayToLambdaProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |apiGatewayProps?|[`api.LambdaRestApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaRestApi.html)|Optional user-provided props to override the default props for the API.|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda function created by the pattern.|
  |apiGateway|[`api.LambdaRestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaRestApi.html)|Returns an instance of the API Gateway REST API created by the pattern.|
  |apiGatewayCloudWatchRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway for CloudWatch access.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Deploy an edge-optimized API endpoint
  * Enable CloudWatch logging for API Gateway
  * Configure least privilege access IAM role for API Gateway
  * Set the default authorizationType for all API methods to IAM
  * Enable X-Ray Tracing

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: 4a153aede57c8a10edc9fd9c86aff031012e365b1442ce4f697eb77d41030dcc
name: python-aws-solutions-constructs.aws-apigateway-sagemakerendpoint
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK Constructs for AWS API Gateway and Amazon SageMaker Endpoint integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-apigateway-sagemakerendpoint-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_apigateway_sagemakerendpoint`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-apigateway-sagemakerendpoint`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.apigatewaysagemakerendpoint`|

  This AWS Solutions Construct implements an Amazon API Gateway connected to an Amazon SageMaker endpoint pattern.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { ApiGatewayToSageMakerEndpoint, ApiGatewayToSageMakerEndpointProps } from '@aws-solutions-constructs/aws-apigateway-sagemakerendpoint';
  // Below is an example VTL (Velocity Template Language) mapping template for mapping the Api GET request to the Sagemaker POST request
  const requestTemplate = `
  {
      "instances": [
          
          
          
          
          {"in0": [$user_id], "in1": [$item]}
              $esc.newline
          
      ]
  }`
  // Replace 'my-endpoint' with your Sagemaker Inference Endpoint
  new ApiGatewayToSageMakerEndpoint(this, 'test-apigw-sagemakerendpoint', {
    endpointName: 'my-endpoint',
    resourcePath: '{user_id}',
    requestMappingTemplate: requestTemplate
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_apigateway_sagemakerendpoint import ApiGatewayToSageMakerEndpoint
  from aws_cdk import Stack
  from constructs import Construct

  request_template = """
  {
      "instances": [
          
          
          
          
          {"in0": [$user_id], "in1": [$item]}
              $esc.newline
          
      ]
  }"""

  ApiGatewayToSageMakerEndpoint(self, 'test-apigw-sagemakerendpoint',
                                  endpoint_name='my-endpoint',
                                  resource_path='{user_id}',
                                  request_mapping_template=request_template
                                  )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.apigatewaysagemakerendpoint.*;
  // Create an example VTL (Velocity Template Language) mapping template for mapping the Api GET request to the Sagemaker POST request
  final String requestTemplate = "{"
          + "\"instances\": ["
          + "# set( $user_id = $input.params(\"user_id\") )"
          + "# set( $items = $input.params(\"items\") )"
          + "# foreach( $item in $items.split(\",\") )"
          + "# if( $foreach.hasNext ),#end"
          + "{\"in0\": [$user_id], \"in1\": [$item]}"
          + "    $esc.newline"
          + "# end"
          + "]"
          + "}";
  // Replace ""my-endpoint"" with your Sagemaker Inference Endpoint
  new ApiGatewayToSageMakerEndpoint(this, "ApiGatewayToSageMakerEndpointPattern",
          new ApiGatewayToSageMakerEndpointProps.Builder()
                  .endpointName("my-endpoint")
                  .resourcePath("{user_id}")
                  .requestMappingTemplate(requestTemplate)
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |apiGatewayProps?|[`api.RestApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApiProps.html)|Optional user-provided props to override the default props for the API Gateway.|
  |apiGatewayExecutionRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|IAM Role used by API Gateway to invoke the SageMaker endpoint. If not specified, a default role is created with access to `endpointName`.|
  |endpointName|`string`|Name of the deployed SageMaker inference endpoint.|
  |resourceName?|`string`|Optional resource name where the GET method will be available.|
  |resourcePath|`string`|Resource path for the GET method. The variable defined here can be referenced in `requestMappingTemplate`.|
  |requestMappingTemplate|`string`|Mapping template to convert GET requests for the default `application/json` content-type received on the REST API to POST requests expected by the SageMaker endpoint.|
  |additionalRequestTemplates|`{ [contentType: string]: string; }`|Optional Request Templates for content-types other than `application/json`. Use the `requestMappingTemplate` property to set the request template for the `application/json` content-type.|
  |responseMappingTemplate?|`string`|Optional mapping template to convert responses received from the SageMaker endpoint.|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |apiGateway|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|Returns an instance of the API Gateway REST API created by the pattern.|
  |apiGatewayRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway.|
  |apiGatewayCloudWatchRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway for CloudWatch access.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|

  > **Note**: Each SageMaker endpoint is unique, and the response from the API will depend on the deployed model. The example given below assumes the sample from [this blog post](https://aws.amazon.com/blogs/machine-learning/creating-a-machine-learning-powered-rest-api-with-amazon-api-gateway-mapping-templates-and-amazon-sagemaker/). For a reference on how that'd be implemented, please refer to [integ.apigateway-sagemakerendpoint-overwrite.ts](test/integ.apigateway-sagemakerendpoint-overwrite.ts).
  | **Method** | **Request Path** | **Query String** | **SageMaker Action** | **Description** |
  |:-------------|:----------------|-----------------|-----------------|-----------------|
  |GET|`/321`| `items=101,131,162` |`sagemaker:InvokeEndpoint`|Retrieves the predictions for a specific user and items.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Deploy an edge-optimized API endpoint
  * Enable CloudWatch logging for API Gateway
  * Configure least privilege access IAM role for API Gateway
  * Set the default authorizationType for all API methods to IAM
  * Enable X-Ray Tracing
  * Validate request parameters before passing data to SageMaker


pkgId: 210a612430f370a493ced3782df47998514176792828a695d74f5bb5232a0410
name: python-aws-solutions-constructs.aws-apigateway-sqs
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK constructs for defining an interaction between an AWS Lambda function and an Amazon S3 bucket.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-apigateway-sqs-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_apigateway_sqs`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-apigateway-sqs`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.apigatewaysqs`|

  This AWS Solutions Construct implements an Amazon API Gateway connected to an Amazon SQS queue pattern.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { ApiGatewayToSqs, ApiGatewayToSqsProps } from "@aws-solutions-constructs/aws-apigateway-sqs";
  new ApiGatewayToSqs(this, 'ApiGatewayToSqsPattern', {});
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_apigateway_sqs import ApiGatewayToSqs
  from aws_cdk import Stack
  from constructs import Construct
  ApiGatewayToSqs(self, 'ApiGatewayToSqsPattern')
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.apigatewaysqs.*;
  new ApiGatewayToSqs(this, "ApiGatewayToSqsPattern", new ApiGatewayToSqsProps.Builder()
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |apiGatewayProps?|[`api.RestApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApiProps.html)|Optional user-provided props to override the default props for the API Gateway.|
  |queueProps?|[`sqs.QueueProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.QueueProps.html)|Optional user-provided props to override the default props for the queue.|
  |deployDeadLetterQueue?|`boolean`|Whether to deploy a secondary queue to be used as a dead letter queue. Defaults to `true`.|
  |maxReceiveCount|`number`|The number of times a message can be unsuccessfully dequeued before being moved to the dead-letter queue.|
  |allowCreateOperation?|`boolean`|Whether to deploy an API Gateway Method for POST HTTP operations on the queue (i.e. sqs:SendMessage).|
  |createRequestTemplate?|`string`|API Gateway Request Template for the create method for the default `application/json` content-type. This property is required if the `allowCreateOperation` property is set to true.|
  |additionalCreateRequestTemplates?|`{ [contentType: string]: string; }`|Optional Create Request Templates for content-types other than `application/json`. Use the `createRequestTemplate` property to set the request template for the `application/json` content-type. This property can only be specified if the `allowCreateOperation` property is set to true.|
  |createIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the create method. This property can only be specified if the `allowCreateOperation` property is set to true.|
  |createMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the create action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |allowReadOperation?|`boolean`|Whether to deploy an API Gateway Method for GET HTTP operations on the queue (i.e. sqs:ReceiveMessage).|
  |readRequestTemplate?|`string`|API Gateway Request Template for the read method for the default `application/json` content-type.|
  |additionalReadRequestTemplates?|`{ [contentType: string]: string; }`|Optional Read Request Templates for content-types other than `application/json`. Use the `readRequestTemplate` property to set the request template for the `application/json` content-type.|
  |readIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the read method.|
  |readMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the read action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |allowDeleteOperation?|`boolean`|Whether to deploy an API Gateway Method for HTTP DELETE operations on the queue (i.e. sqs:DeleteMessage).|
  |deleteRequestTemplate?|`string`|API Gateway Request Template for THE delete method for the default `application/json` content-type. This property can only be specified if the `allowDeleteOperation` property is set to true.|
  |additionalDeleteRequestTemplates?|`{ [contentType: string]: string; }`|Optional Delete request templates for content-types other than `application/json`. Use the `deleteRequestTemplate` property to set the request template for the `application/json` content-type. This property can only be specified if the `allowDeleteOperation` property is set to true.|
  |deleteIntegrationResponses?|[`api.IntegrationResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.IntegrationResponse.html)|Optional, custom API Gateway Integration Response for the delete method. This property can only be specified if the `allowDeleteOperation` property is set to true.|
  |deleteMethodResponses?|[`api.MethodResponses[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodResponse.html)| Optional, custom API Gateway Method Responses for the delete action. default: [{  statusCode: "200",  responseParameters: {    "method.response.header.Content-Type": true  }},{  statusCode: "500",  responseParameters: {    "method.response.header.Content-Type": true  } } ]|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|
  |enableEncryptionWithCustomerManagedKey?|`boolean`|If no key is provided, this flag determines whether the queue is encrypted with a new CMK or an AWS managed key. This flag is ignored if any of the following are defined: queueProps.encryptionMasterKey, encryptionKey or encryptionKeyProps.|
  |encryptionKey?|[`kms.Key`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html)|An optional, imported encryption key to encrypt the SQS Queue with.|
  |encryptionKeyProps?|[`kms.KeyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html#construct-props)|Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SQS queue with.|
  |messageSchema?|{ [contentType: string]: [api.JsonSchema](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.JsonSchema.html); }|Optional schema to define format of incoming message in API request body. Example: { "application/json": { schema: api.JsonSchemaVersion.DRAFT4, title: 'pollResponse', type: api.JsonSchemaType.OBJECT, required: ['firstProperty', 'antotherProperty'], additionalProperties: false, properties: { firstProperty: { type: api.JsonSchemaType.STRING }, antotherProperty: { type: api.JsonSchemaType.STRING } } } Only relevant for create operation, if allowCreateOperation is not true, then supplying this is an error. Sending this value causes this construct to turn on validation for the request body. @default - None|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |apiGateway|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|Returns an instance of the API Gateway REST API created by the pattern.|
  |apiGatewayRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway.|
  |apiGatewayCloudWatchRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway for CloudWatch access.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|
  |sqsQueue|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|Returns an instance of the SQS queue created by the pattern.|
  |deadLetterQueue?|[`sqs.DeadLetterQueue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.DeadLetterQueue.html)|Returns an instance of the DeadLetterQueue created by the pattern.|

  | **Method** | **Request Path** | **Request Body** | **Queue Action** | **Description** |
  |:-------------|:----------------|-----------------|-----------------|-----------------|
  |GET|`/`| |`sqs::ReceiveMessage`|Retrieves a message from the queue.|
  |POST|`/`| `{ "data": "Hello World!" }` |`sqs::SendMessage`|Delivers a message to the queue.|
  |DELETE|`/message?receiptHandle=[value]`||`sqs::DeleteMessage`|Deletes a specified message from the queue|

  This construct allows you to implement four DynamoDB API operations, CREATE/READ/DELETE (corresponding the HTTP POST/GET/DELETE requests respectively). They are completely independent and each follows the same pattern:
  * Setting `allowCreateOperation` to true will implement the `application/json` content-type with default request and response templates
  * The request template for `application/json` requests can be customized using the `createRequestTemplate` prop value
  * *Additional* request templates can be specified using the `additionalCreateRequestTemplates` prop value. Note - these DO NOT replace the `application/json` content-type
  * Customized integration responses can be specified for any content type in the `createIntegrationResponses` prop value.
  Supplying any of these values without setting allowCreateOperation to true will result in an error. This pattern is the same for all four API operations.

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Deploy an edge-optimized API endpoint
  * Enable CloudWatch logging for API Gateway
  * Configure least privilege access IAM role for API Gateway
  * Set the default authorizationType for all API methods to IAM
  * Enable X-Ray Tracing

  * Deploy SQS dead-letter queue for the source SQS Queue
  * Enable server-side encryption for source SQS Queue using AWS Managed KMS Key
  * Enforce encryption of data in transit


pkgId: fb0b5631da99c8a7b9158d9a53f3176511974ef0727d52139a430e1ebbe2907b
name: python-aws-solutions-constructs.aws-apigatewayv2websocket-sqs
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK constructs for defining an interaction between an AWS Lambda function and an Amazon S3 bucket.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-apigatewayv2websocket-sqs-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_apigatewayv2websocket_sqs`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-apigatewayv2websocket-sqs`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.apigatewayv2websocketsqs`|

  This AWS Solutions Construct implements an Amazon API Gateway WebSocket connected to an Amazon SQS queue pattern.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from "constructs";
  import { Stack, StackProps } from "aws-cdk-lib";
  import {
  	ApiGatewayV2WebSocketToSqs,
  	ApiGatewayV2WebSocketToSqsProps,
  } from "@aws-solutions-constructs/aws-apigatewayv2websocket-sqs";
  import { WebSocketLambdaAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
  const authorizer = new WebSocketLambdaAuthorizer('Authorizer', authHandler);
  new ApiGateApiGatewayV2WebSocketToSqswayToSqs(this, "ApiGatewayV2WebSocketToSqsPattern", {
  	webSocketApiProps: {
  		connectRouteOptions: {
  			integration: new WebSocketLambdaIntegration("ConnectIntegration", connectLambda),
  			authorizer: authorizer,
  		},
  		disconnectRouteOptions: {
  			integration: new WebSocketLambdaIntegration("DisconnectIntegration", disconnectLambda),
  		},
  	},
          createDefaultRoute: true
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_apigateway_sqs import ApiGatewayV2WebSocketToSqs
  from aws_cdk.aws_apigatewayv2_authorizers import WebSocketLambdaAuthorizer
  from aws_cdk import Stack
  from constructs import Construct
  authorizer = WebSocketLambdaAuthorizer("Authorizer", auth_handler)
  ApiGatewayV2WebSocketToSqs(self, 'ApiGatewayV2WebSocketToSqsPattern',
      connect_route_options=apigwv2.WebSocketRouteOptions(
          integration=WebSocketLambdaIntegration("ConnectIntegration", connect_lambda),
          authorizer=authorizer
      ),
      disconnect_route_options=apigwv2.WebSocketRouteOptions(
          integration=WebSocketLambdaIntegration("DisConnectIntegration", disconnect_lambda),
      ),
      create_default_route=True
  )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.aws_apigatewayv2_authorizers.*;
  import software.amazon.awscdk.aws_apigatewayv2_integrations.*;
  import software.amazon.awsconstructs.services.apigatewaysqs.*;
  new ApiGatewayV2WebSocketToSqs(this, "ApiGatewayV2WebSocketToSqsPattern", new ApiGatewayV2WebSocketToSqsProps.Builder()
          .webSocketApiProps(new WebSocketApiProps.Builder()
                  .connectRouteOptions(new WebSocketRouteOptions.builder()
                          .integration(new WebSocketLambdaIntegration("ConnectIntegration", connect_lambda)))
                  .disconnectRouteOptions(new WebSocketRouteOptions.builder()
                          .integration(new WebSocketLambdaIntegration("DisConnectIntegration", disconnect_lambda)))
                  .createDefaultRoute(true)
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingWebSocketApi?|[`apigwv2.WebSocketApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigatewayv2.WebSocketApi.html)|Optional API Gateway WebSocket instance. Providing both existingWebSocketApi and webSocketApiProps will cause an error.|
  |webSocketApiProps?|[`apigwv2.WebSocketApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigatewayv2.WebSocketApiProps.html)|Optional user-provided props to override the default props for the API Gateway. Providing both existingWebSocketApi and webSocketApiProps will cause an error.|
  |queueProps?|[`sqs.QueueProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.QueueProps.html)|Optional user-provided props to override the default props for the queue. Providing both existingQueueObj and queueProps will cause an error.|
  |existingQueueObj?|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|Optional existing instance of SQS Queue. Providing both existingQueueObj and queueProps will cause an error.|
  |deployDeadLetterQueue?|`boolean`|Whether to deploy a secondary queue to be used as a dead letter queue. Defaults to `true`.|
  |deadLetterQueueProps?|[`sqs.QueueProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.QueueProps.html)|Optional properties to use for creating dead letter queue. Note that if you are creating a FIFO Queue, the dead letter queue should also be FIFO.|
  |maxReceiveCount|`number`|The number of times a message can be unsuccessfully dequeued before being moved to the dead-letter queue.|
  |createDefaultRoute?|`boolean`|Whether to create a default route. At least one of createDefaultRoute or customRouteName must be provided. If set to true, then it will use the value supplied with `defaultRouteRequestTemplate`.|
  |defaultRouteRequestTemplate?|`{ [contentType: string]: string }`|Optional user provided API Gateway Request Template for the default route and/ or customRoute (if customRouteName is provided). This property will only be used if createDefaultRoute is `true`. If createDefaultRoute is `true` and this property is not provided, the construct will create the default route with the following VTL mapping `"Action=SendMessage&MessageGroupId=$input.path('$.MessageGroupId')&MessageDeduplicationId=$context.requestId&MessageAttribute.1.Name=connectionId&MessageAttribute.1.Value.StringValue=$context.connectionId&MessageAttribute.1.Value.DataType=String&MessageAttribute.2.Name=requestId&MessageAttribute.2.Value.StringValue=$context.requestId&MessageAttribute.2.Value.DataType=String&MessageBody=$util.urlEncode($input.json($util.escapeJavaScript('$').replaceAll(\"\\\\'\",\"'\")))"`.|
  |defaultIamAuthorization?|`boolean`|Add IAM authorization to the $connect path by default. Only set this to false if: 1) If plan to provide an authorizer with the `$connect` route; or 2) The API should be open (no authorization) (AWS recommends against deploying unprotected APIs). If an authorizer is specified in connectRouteOptions, this parameter is ignored and no default IAM authorizer will be created. |
  |customRouteName?|`string`|The name of the route that will be sent through WebSocketApiProps.routeSelectionExpression when invoking the WebSocket endpoint. At least one of createDefaultRoute or customRouteName must be provided. |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |webSocketApi|[`apigwv2.WebSocketApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigatewayv2.WebSocketApi.html)|Returns an instance of the API Gateway WebSocket API created by the pattern.|
  |apiGatewayRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway.|
  |webSocketStage|[`apigwv2.WebSocketStage`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigatewayv2.WebSocketStage.html)|Returns an instance of the WebSocketStage created by the construct.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|
  |sqsQueue|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|Returns an instance of the SQS queue created by the pattern.|
  |deadLetterQueue?|[`sqs.DeadLetterQueue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.DeadLetterQueue.html)|Returns an instance of the DeadLetterQueue created by the pattern.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Deploy a WebSocket endpoint
  * Enable CloudWatch logging for API Gateway
  * Configure least privilege access IAM role for API Gateway
  * Enable X-Ray Tracing

  * Deploy SQS dead-letter queue for the source SQS Queue
  * Enable server-side encryption for source SQS Queue using AWS Managed KMS Key
  * Enforce encryption of data in transit


pkgId: 61cfb287ffa1b1c92972aec08b8dfc83c256c0ddd3a80d183776fb765ab22f3c
name: python-aws-solutions-constructs.aws-cloudfront-apigateway
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Cloudfront to AWS API Gateway integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-cloudfront-apigateway-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_cloudfront_apigateway`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-cloudfront-apigateway`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.cloudfrontapigateway`|

  This AWS Solutions Construct implements an AWS CloudFront fronting an Amazon API Gateway REST API.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { CloudFrontToApiGateway } from '@aws-solutions-constructs/aws-cloudfront-apigateway';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  import * as api from 'aws-cdk-lib/aws-apigateway';
  const lambdaProps: lambda.FunctionProps = {
    code: lambda.Code.fromAsset(`lambda`),
    runtime: lambda.Runtime.NODEJS_16_X,
    handler: 'index.handler'
  };
  const lambdafunction = new lambda.Function(this, 'LambdaFunction', lambdaProps);
  const apiGatewayProps: api.LambdaRestApiProps = {
    handler: lambdafunction,
    endpointConfiguration: {
      types: [api.EndpointType.REGIONAL]
    },
    defaultMethodOptions: {
      authorizationType: api.AuthorizationType.NONE
    }
  };
  const apiGateway = new api.LambdaRestApi(this, 'LambdaRestApi', apiGatewayProps);
  new CloudFrontToApiGateway(this, 'test-cloudfront-apigateway', {
    existingApiGatewayObj: apiGateway
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_cloudfront_apigateway import CloudFrontToApiGateway
  from aws_cdk import (
      aws_lambda as _lambda,
      aws_apigateway as api,
      Stack
  )
  from constructs import Construct
  lambda_function = _lambda.Function(self, 'LambdaFunction',
                                      code=_lambda.Code.from_asset(
                                          'lambda'),
                                      runtime=_lambda.Runtime.PYTHON_3_9,
                                      handler='index.handler')
  api_gateway = api.LambdaRestApi(self, 'LambdaRestApi',
                                  handler=lambda_function,
                                  endpoint_configuration=api.EndpointConfiguration(
                                      types=[api.EndpointType.REGIONAL]
                                  ),
                                  default_method_options=api.MethodOptions(
                                      authorization_type=api.AuthorizationType.NONE
                                  ))
  CloudFrontToApiGateway(self, 'test-cloudfront-apigateway',
                          existing_api_gateway_obj=api_gateway
                          )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awscdk.services.apigateway.*;
  import software.amazon.awsconstructs.services.cloudfrontapigateway.*;
  final Function lambdaFunction = Function.Builder.create(this, "IndexHandler")
          .runtime(Runtime.NODEJS_16_X)
          .code(Code.fromAsset("lambda"))
          .handler("index.handler")
          .build();
  final LambdaRestApi apiGateway = LambdaRestApi.Builder.create(this, "myapi")
          .handler(lambdaFunction)
          .endpointConfiguration(new EndpointConfiguration.Builder()
                  .types(List.of(EndpointType.REGIONAL))
                  .build())
          .build();
  new CloudFrontToApiGateway(this, "test-cloudfront-apigateway", new CloudFrontToApiGatewayProps.Builder()
          .existingApiGatewayObj(apiGateway)
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingApiGatewayObj|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|The regional API Gateway that will be fronted with the CloudFront|
  |cloudFrontDistributionProps?|[`cloudfront.DistributionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.DistributionProps.html)|Optional user provided props to override the default props for CloudFront Distribution|
  |insertHttpSecurityHeaders?|`boolean`|Optional user provided props to turn on/off the automatic injection of best practice HTTP security headers in all responses from CloudFront|
  | responseHeadersPolicyProps?   | [`cloudfront.ResponseHeadersPolicyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.ResponseHeadersPolicyProps.html) | Optional user provided configuration that cloudfront applies to all http responses.|
  |cloudFrontLoggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the CloudFront Logging Bucket.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |cloudFrontWebDistribution|[`cloudfront.Distribution`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.Distribution.html)|Returns an instance of cloudfront.Distribution created by the construct|
  |apiGateway|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|Returns an instance of the API Gateway REST API created by the pattern.|
  |cloudFrontFunction?|[`cloudfront.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.Function.html)|Returns an instance of the Cloudfront function created by the pattern.|
  |cloudFrontLoggingBucket|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3-readme.html)|Returns an instance of the logging bucket for CloudFront Distribution.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure Access logging for CloudFront Distribution
  * Enable automatic injection of best practice HTTP security headers in all responses from CloudFront Distribution

  * User provided API Gateway object is used as-is
  * Enable X-Ray Tracing


pkgId: 33e949288d12ec61dc258dc3f78be8b310524683e93904ddabe2c708b71f423a
name: python-aws-solutions-constructs.aws-cloudfront-apigateway-lambda
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Cloudfront to AWS API Gateway to AWS Lambda integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-cloudfront-apigateway-lambda-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_cloudfront_apigateway_lambda`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-cloudfront-apigateway-lambda`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.cloudfrontapigatewaylambda`|

  This AWS Solutions Construct implements an AWS CloudFront fronting an Amazon API Gateway Lambda backed REST API.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { CloudFrontToApiGatewayToLambda } from '@aws-solutions-constructs/aws-cloudfront-apigateway-lambda';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new CloudFrontToApiGatewayToLambda(this, 'test-cloudfront-apigateway-lambda', {
    lambdaFunctionProps: {
      code: lambda.Code.fromAsset(`lambda`),
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler'
    },
    apiGatewayProps: {
      defaultMethodOptions: {
        authorizationType: api.AuthorizationType.NONE
      }
    },
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_cloudfront_apigateway_lambda import CloudFrontToApiGatewayToLambda
  from aws_cdk import (
    aws_lambda as _lambda,
    aws_apigateway as apigw,
    Stack
  )
  from constructs import Construct
          CloudFrontToApiGatewayToLambda(
              self, 'CloudFrontApiGatewayToLambda',
              lambda_function_props=_lambda.FunctionProps(
                  runtime=_lambda.Runtime.PYTHON_3_7,
                  code=_lambda.Code.from_asset('lambda'),
                  handler='hello.handler',
              ),
              
              
              
              
              api_gateway_props=apigw.RestApiProps(
                  default_method_options=apigw.MethodOptions(
                      authorization_type=apigw.AuthorizationType.NONE
                  )
              )
          )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.cloudfrontapigatewaylambda.*;
  import software.amazon.awsconstructs.services.cloudfrontapigatewaylambda.CloudFrontToApiGatewayToLambdaProps;
  new CloudFrontToApiGatewayToLambda(this, "ApiGatewayToLambdaPattern", new CloudFrontToApiGatewayToLambdaProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X) // execution environment
                  .code(Code.fromAsset("lambda")) // code loaded from the `lambda` directory (under root, next to `src`)
                  .handler("hello.handler") // file is `hello`, function is `handler`
                  .build())
          // NOTE - we use RestApiProps here because the actual type, LambdaRestApiProps requires
          // the handler function which does not yet exist. As RestApiProps is a subset of of LambdaRestApiProps
          // (although does not *extend* that interface) this works fine when the props object reaches the
          // underlying TypeScript code that implements Constructs
          .apiGatewayProps(new RestApiProps.Builder()
                  .defaultMethodOptions(new MethodOptions.Builder()
                          .authorizationType(AuthorizationType.NONE)
                          .build())
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|Optional user provided props to override the default props for the Lambda function.|
  |apiGatewayProps?|[`api.LambdaRestApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaRestApiProps.html)|User provided props to override the default props for the API Gateway. As of release 2.48.0, clients must include this property with `defaultMethodOptions: { authorizationType: string }` specified. See Issue1043 in the github repo https://github.com/awslabs/aws-solutions-constructs/issues/1043 |
  |cloudFrontDistributionProps?|[`cloudfront.DistributionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.DistributionProps.html)|Optional user provided props to override the default props for CloudFront Distribution|
  |insertHttpSecurityHeaders?|`boolean`|Optional user provided props to turn on/off the automatic injection of best practice HTTP security headers in all responses from CloudFront|
  | responseHeadersPolicyProps?   | [`cloudfront.ResponseHeadersPolicyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.ResponseHeadersPolicyProps.html) | Optional user provided configuration that cloudfront applies to all http responses.                                                         |
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|Optional user provided props to override the default props for for the CloudWatchLogs LogGroup.|
  |cloudFrontLoggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the CloudFront Logging Bucket.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |cloudFrontWebDistribution|[`cloudfront.Distribution`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.Distribution.html)|Returns an instance of cloudfront.Distribution created by the construct|
  |cloudFrontFunction?|[`cloudfront.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.Function.html)|Returns an instance of the Cloudfront function created by the pattern.|
  |cloudFrontLoggingBucket|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3-readme.html)|Returns an instance of the logging bucket for CloudFront Distribution.|
  |apiGateway|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|Returns an instance of the API Gateway REST API created by the pattern.|
  |apiGatewayCloudWatchRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway for CloudWatch access.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda function created by the pattern.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure Access logging for CloudFront Distribution
  * Enable automatic injection of best practice HTTP security headers in all responses from CloudFront Distribution

  * Deploy a regional API endpoint
  * Enable CloudWatch logging for API Gateway
  * Configure least privilege access IAM role for API Gateway
  * Set the default authorizationType for all API methods to NONE
  * Enable X-Ray Tracing

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: 6964791d03978956b03e85b6d0eec19770e7e6a41b0da39d986f891c4593e66e
name: python-aws-solutions-constructs.aws-cloudfront-mediastore
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK Constructs for Amazon CloudFront to AWS Elemental MediaStore integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-cloudfront-mediastore-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_cloudfront_mediastore`|
  |![TypeScript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) TypeScript|`@aws-solutions-constructs/aws-cloudfront-mediastore`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.cloudfrontmediastore`|

  This AWS Solutions Construct implements an Amazon CloudFront distribution to an AWS Elemental MediaStore container.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { CloudFrontToMediaStore } from '@aws-solutions-constructs/aws-cloudfront-mediastore';
  new CloudFrontToMediaStore(this, 'test-cloudfront-mediastore-default', {});
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_cloudfront_mediastore import CloudFrontToMediaStore
  from aws_cdk import Stack
  from constructs import Construct
  CloudFrontToMediaStore(self, 'test-cloudfront-mediastore-default')
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.cloudfrontmediastore.*;
  new CloudFrontToMediaStore(this, "test-cloudfront-mediastore-default", new CloudFrontToMediaStoreProps.Builder()
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingMediaStoreContainerObj?|[`mediastore.CfnContainer`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_mediastore.CfnContainer.html)|Optional user provided MediaStore container to override the default MediaStore container.|
  |mediaStoreContainerProps?|[`mediastore.CfnContainerProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_mediastore.CfnContainerProps.html)|Optional user provided props to override the default props for the MediaStore Container.|
  |cloudFrontDistributionProps?|[`cloudfront.DistributionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.DistributionProps.html)|`any`|Optional user provided props to override the default props for the CloudFront Distribution.|
  |insertHttpSecurityHeaders?|`boolean`|Optional user provided props to turn on/off the automatic injection of best practice HTTP security headers in all responses from CloudFront|
  | responseHeadersPolicyProps?   | [`cloudfront.ResponseHeadersPolicyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.ResponseHeadersPolicyProps.html) | Optional user provided configuration that cloudfront applies to all http responses.|
  |cloudFrontLoggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the CloudFront Logging Bucket.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |cloudFrontWebDistribution|[`cloudfront.Distribution`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.Distribution.html)|Returns an instance of cloudfront.Distribution created by the construct.|
  |mediaStoreContainer|[`mediastore.CfnContainer`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_mediastore.CfnContainer.html)|Returns an instance of mediastore.CfnContainer.|
  |cloudFrontLoggingBucket|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket as the logging bucket for the CloudFront Web Distribution.|
  |cloudFrontOriginRequestPolicy|[`cloudfront.OriginRequestPolicy`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.OriginRequestPolicy.html)|Returns an instance of cloudfront.OriginRequestPolicy created by the construct for the CloudFront Web Distribution.|
  |cloudFrontOriginAccessIdentity?|[`cloudfront.OriginAccessIdentity`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.OriginAccessIdentity.html)|Returns an instance of cloudfront.OriginAccessIdentity created by the construct for the CloudFront Web Distribution origin custom headers and the MediaStore Container policy.|
  |cloudFrontFunction?|[`cloudfront.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.Function.html)|Returns an instance of the Cloudfront function created by the pattern.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure access logging for CloudFront Web Distribution
  * Enable CloudFront Origin Request Policy for AWS Elemental MediaStore Container
  * Set `User-Agent` custom header with CloudFront Origin Access Identity
  * Enable automatic injection of best practice HTTP security headers in all responses from CloudFront Distribution

  * Set the deletion policy to retain the resource
  * Set the container name with the CloudFormation stack name
  * Set the default [Container Cross-origin resource sharing (CORS) policy](https://docs.aws.amazon.com/mediastore/latest/ug/cors-policy.html)
  * Set the default [Object Life Cycle policy](https://docs.aws.amazon.com/mediastore/latest/ug/policies-object-lifecycle.html)
  * Set the default [Container Policy](https://docs.aws.amazon.com/mediastore/latest/ug/policies.html) to allow only `aws:UserAgent` with CloudFront Origin Access Identity
  * Set the default [Metric Policy](https://docs.aws.amazon.com/mediastore/latest/ug/policies-metric.html)
  * Enable the access logging


pkgId: 12930f4d6824e7970c0723680dff560b976077a1d7bf0eac00538c7458c6ee4a
name: python-aws-solutions-constructs.aws-cloudfront-s3
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Cloudfront to AWS S3 integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-cloudfront-s3-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_cloudfront_s3`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-cloudfront-s3`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.cloudfronts3`|

  This AWS Solutions Construct provisions an Amazon CloudFront Distribution that serves objects from an AWS S3 Bucket via an Origin Access Control (OAC).
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { CloudFrontToS3 } from '@aws-solutions-constructs/aws-cloudfront-s3';
  new CloudFrontToS3(this, 'test-cloudfront-s3', {});
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_cloudfront_s3 import CloudFrontToS3
  from aws_cdk import Stack
  from constructs import Construct
  CloudFrontToS3(self, 'test-cloudfront-s3')
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.cloudfronts3.*;
  new CloudFrontToS3(this, "test-cloudfront-s3", new CloudFrontToS3Props.Builder()
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |cloudFrontDistributionProps?|[`cloudfront.DistributionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.DistributionProps.html)|Optional user provided props to override the default props for CloudFront Distribution|
  |insertHttpSecurityHeaders?|`boolean`|Optional user provided props to turn on/off the automatic injection of best practice HTTP security headers in all responses from CloudFront|
  |responseHeadersPolicyProps?   | [`cloudfront.ResponseHeadersPolicyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.ResponseHeadersPolicyProps.html) | Optional user provided configuration that cloudfront applies to all http responses.|
  |originPath?|`string`|Optional user provided props to provide an[originPath](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront_origins.S3OriginProps.html#originpath) that CloudFront appends to the origin domain name when CloudFront requests content from the origin. The string should start with a `/`, for example: `/production`. Default value is `'/'`|
  |existingBucketObj?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Existing instance of S3 content bucket object or interface. If this is provided, then also providing bucketProps will cause an error. |
  |bucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 content bucket. Note - to log S3 access for this bucket to an existing S3 bucket, put the existing log bucket in bucketProps: `serverAccessLogsBucket`|
  |logS3AccessLogs?| boolean|Whether to turn on Access Logging for the S3 bucket. Creates an S3 bucket with associated storage costs for the logs. Enabling Access Logging is a best practice. default - true|
  |loggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Logging Bucket.|
  |cloudFrontLoggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the CloudFront Logging Bucket. Note: to use an existing bucketto  hold CloudFront logs, pass the existing log bucket in |
  |logCloudFrontAccessLog|`boolean`|Optional - Whether to maintain access logs for the CloudFront Logging bucket. Specifying false for this while providing info about the log bucket will cause an error. Default = true |
  |cloudFrontLoggingBucketAccessLogBucketProps|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the CloudFront Log Bucket Access Log bucket. Providing both this and `existingcloudFrontLoggingBucketAccessLogBucket` will cause an error. To provide an existing bucket to accept these logs, pass the existing bucket in `cloudFrontLoggingBucketProps::serverAccessLogBucket`|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |cloudFrontWebDistribution|[`cloudfront.Distribution`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.Distribution.html)|Returns an instance of cloudfront.Distribution created by the construct.|
  |cloudFrontFunction?|[`cloudfront.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudfront.Function.html)|Returns an instance of the Cloudfront function created by the construct.|
  |originAccessControl?|[`cloudfront.CfnOriginAccessControl`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.cloudfront.CfnOriginAccessControl.html)|Returns an instance of cloudfront.CfnOriginAccessControl created by the construct.|
  |s3BucketInterface|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Returns an instance of s3.IBucket created by the construct.|
  |s3Bucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct. IMPORTANT: If `existingBucketObj` was provided in Pattern Construct Props, this property will be `undefined`|
  |s3LoggingBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct as the logging bucket for the primary bucket.|
  |cloudFrontLoggingBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|The S3 bucket created by the construct to hold CloudFront logs. Only populated if the construct creates the bucket (not if an existing bucket is passed in via DistributionProps)|
  |cloudFrontLoggingBucketAccessLogBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|The S3 bucket containing the S3 access logs for the CloudFront log bucket. Only populated if the construct creates the bucket (not if the bucket is passed in via `cloudFrontLoggingBucketProps::serverAccessLogBucket`|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure Access logging for CloudFront Distribution
  * Enable automatic injection of best practice HTTP security headers in all responses from CloudFront Distribution
  * CloudFront originPath set to `'/'`

  * Configure Access logging for S3 Bucket
  * Enable server-side encryption for S3 Bucket using AWS managed KMS Key
  * Enforce encryption of data in transit
  * Turn on the versioning for S3 Bucket
  * Don't allow public access for S3 Bucket
  * Retain the S3 Bucket when deleting the CloudFormation stack
  * Applies Lifecycle rule to move noncurrent object versions to Glacier storage after 90 days


pkgId: b89d3f8f5740f7636a236202873b57ad8e936f1daa0d108d33ace420fefb4476
name: python-aws-solutions-constructs.aws-cognito-apigateway-lambda
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Cognito to AWS API Gateway to AWS Lambda integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-cognito-apigateway-lambda-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_cognito_apigateway_lambda`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-cognito-apigateway-lambda`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.cognitoapigatewaylambda`|

  This AWS Solutions Construct implements an Amazon Cognito securing an Amazon API Gateway Lambda backed REST APIs pattern.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { CognitoToApiGatewayToLambda } from '@aws-solutions-constructs/aws-cognito-apigateway-lambda';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new CognitoToApiGatewayToLambda(this, 'test-cognito-apigateway-lambda', {
    lambdaFunctionProps: {
      code: lambda.Code.fromAsset(`lambda`),
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler'
    }
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_cognito_apigateway_lambda import CognitoToApiGatewayToLambda
  from aws_cdk import (
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct
  CognitoToApiGatewayToLambda(self, 'test-cognito-apigateway-lambda',
                              lambda_function_props=_lambda.FunctionProps(
                                  code=_lambda.Code.from_asset('lambda'),
                                  runtime=_lambda.Runtime.PYTHON_3_9,
                                  handler='index.handler'
                              )
                              )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.cognitoapigatewaylambda.*;
  new CognitoToApiGatewayToLambda(this, "test-cognito-apigateway-lambda",
          new CognitoToApiGatewayToLambdaProps.Builder()
                  .lambdaFunctionProps(new FunctionProps.Builder()
                          .runtime(Runtime.NODEJS_16_X)
                          .code(Code.fromAsset("lambda"))
                          .handler("index.handler")
                          .build())
                  .build());
  ```
  If you are defining resources and methods on your API (e.g. proxy = false), then you must call addAuthorizers() after the API is fully defined to ensure every method is protected. Here is an example:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { CognitoToApiGatewayToLambda } from '@aws-solutions-constructs/aws-cognito-apigateway-lambda';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  const construct = new CognitoToApiGatewayToLambda(this, 'test-cognito-apigateway-lambda', {
      lambdaFunctionProps: {
          code: lambda.Code.fromAsset(`lambda`),
          runtime: lambda.Runtime.NODEJS_16_X,
          handler: 'index.handler'
      },
      apiGatewayProps: {
          proxy: false
      }
  });
  const resource = construct.apiGateway.root.addResource('foobar');
  resource.addMethod('POST');
  // Mandatory to call this method to Apply the Cognito Authorizers on all API methods
  construct.addAuthorizers();
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_cognito_apigateway_lambda import CognitoToApiGatewayToLambda
  from aws_cdk import (
      aws_lambda as _lambda,
      aws_apigateway as api,
      Stack
  )
  from constructs import Construct
  from typing import Any

  gateway_props = dict[Any, Any]
  construct = CognitoToApiGatewayToLambda(self, 'test-cognito-apigateway-lambda',
                                          lambda_function_props=_lambda.FunctionProps(
                                              code=_lambda.Code.from_asset(
                                                  'lambda'),
                                              runtime=_lambda.Runtime.PYTHON_3_9,
                                              handler='index.handler'
                                          ),
                                          api_gateway_props=gateway_props(
                                              proxy=False
                                          )
                                          )
  resource = construct.api_gateway.root.add_resource('foobar')
  resource.add_method('POST')

  construct.add_authorizers()
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Optional;
  import software.amazon.awscdk.*;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awscdk.services.apigateway.IResource;
  import software.amazon.awsconstructs.services.cognitoapigatewaylambda.*;
  // Overriding LambdaRestApiProps with type Any
  Map<String, Optional<?>> gatewayProps = new HashMap<String, Optional<?>>();
  gatewayProps.put("proxy", Optional.of(false));
  final CognitoToApiGatewayToLambda construct = new CognitoToApiGatewayToLambda(this,
          "test-cognito-apigateway-lambda",
          new CognitoToApiGatewayToLambdaProps.Builder()
                  .lambdaFunctionProps(new FunctionProps.Builder()
                          .runtime(Runtime.NODEJS_16_X)
                          .code(Code.fromAsset("lambda"))
                          .handler("index.handler")
                          .build())
                  .apiGatewayProps(gatewayProps)
                  .build());
  final IResource resource = construct.getApiGateway().getRoot().addResource("foobar");
  resource.addMethod("POST");
  // Mandatory to call this method to Apply the Cognito Authorizers on all API methods
  construct.addAuthorizers();
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |apiGatewayProps?|[`api.LambdaRestApiProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaRestApi.html)|Optional user provided props to override the default props for API Gateway|
  |cognitoUserPoolProps?|[`cognito.UserPoolProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPoolProps.html)|Optional user provided props to override the default props for Cognito User Pool|
  |cognitoUserPoolClientProps?|[`cognito.UserPoolClientProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPoolClientProps.html)|Optional user provided props to override the default props for Cognito User Pool Client|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |userPool|[`cognito.UserPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPool.html)|Returns an instance of cognito.UserPool created by the construct|
  |userPoolClient|[`cognito.UserPoolClient`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPoolClient.html)|Returns an instance of cognito.UserPoolClient created by the construct|
  |apiGateway|[`api.RestApi`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RestApi.html)|Returns an instance of api.RestApi created by the construct|
  |apiGatewayCloudWatchRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for API Gateway for CloudWatch access.|
  |apiGatewayLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for API Gateway access logging to CloudWatch.|
  |apiGatewayAuthorizer|[`api.CfnAuthorizer`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.CfnAuthorizer.html)|Returns an instance of the api.CfnAuthorizer created by the construct for API Gateway methods authorization.|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of lambda.Function created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Set password policy for User Pools
  * Enforce the advanced security mode for User Pools

  * Deploy an edge-optimized API endpoint
  * Enable CloudWatch logging for API Gateway
  * Configure least privilege access IAM role for API Gateway
  * Set the default authorizationType for all API methods to Cognito User Pool
  * Enable X-Ray Tracing

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: c4ee495cc9978df734777802b3c575b077615fda60e965a48f2273c20570106d
name: python-aws-solutions-constructs.aws-dynamodbstreams-lambda
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK Constructs for AWS DynamoDB Streams to AWS Lambda integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-dynamodbstreams-lambda-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_dynamodbstreams_lambda`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-dynamodbstreams-lambda`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.dynamodbstreamslambda`|

  This AWS Solutions Construct implements a pattern Amazon DynamoDB table with stream to invoke the AWS Lambda function  with the least privileged permissions.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { DynamoDBStreamsToLambdaProps,  DynamoDBStreamsToLambda} from '@aws-solutions-constructs/aws-dynamodbstreams-lambda';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new DynamoDBStreamsToLambda(this, 'test-dynamodbstreams-lambda', {
    lambdaFunctionProps: {
        code: lambda.Code.fromAsset(`lambda`),
        runtime: lambda.Runtime.NODEJS_16_X,
        handler: 'index.handler'
    },
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_dynamodbstreams_lambda import DynamoDBStreamsToLambda
  from aws_cdk import (
    aws_lambda as _lambda,
    Stack
  )
  from constructs import Construct
  DynamoDBStreamsToLambda(self, 'test-dynamodbstreams-lambda',
                          lambda_function_props=_lambda.FunctionProps(
                              code=_lambda.Code.from_asset('lambda'),
                              runtime=_lambda.Runtime.PYTHON_3_9,
                              handler='index.handler'
                          )
                          )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.dynamodbstreamslambda.*;
  new DynamoDBStreamsToLambda(this, "test-dynamodbstreams-lambda",
          new DynamoDBStreamsToLambdaProps.Builder()
                  .lambdaFunctionProps(new FunctionProps.Builder()
                          .runtime(Runtime.NODEJS_16_X)
                          .code(Code.fromAsset("lambda"))
                          .handler("index.handler")
                          .build())
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |dynamoTableProps?|[`dynamodb.TableProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.TableProps.html)|Optional user provided props to override the default props for DynamoDB Table|
  |existingTableInterface?|[`dynamodb.ITable`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.ITable.html)|Existing instance of DynamoDB table object or interface, providing both this and `dynamoTableProps` will cause an error.|
  |dynamoEventSourceProps?|[`aws-lambda-event-sources.DynamoEventSourceProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_event_sources.DynamoEventSourceProps.html)|Optional user provided props to override the default props for DynamoDB Event Source|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |dynamoTableInterface|[`dynamodb.ITable`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.ITable.html)|Returns an instance of dynamodb.ITable created by the construct|
  |dynamoTable?|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Returns an instance of dynamodb.Table created by the construct. IMPORTANT: If existingTableInterface was provided in Pattern Construct Props, this property will be `undefined`|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of lambda.Function created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Set the billing mode for DynamoDB Table to On-Demand (Pay per request)
  * Enable server-side encryption for DynamoDB Table using AWS managed KMS Key
  * Creates a partition key called 'id' for DynamoDB Table
  * Retain the Table when deleting the CloudFormation stack
  * Enable continuous backups and point-in-time recovery

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Enable Failure-Handling features like enable bisect on function Error, set defaults for Maximum Record Age (24 hours) & Maximum Retry Attempts (500) and deploy SQS dead-letter queue as destination on failure
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: 541bca6f6fc072c4004aeea3529b5b77b8edb4180f6dc2cccee99a3c693e2c7d
name: python-aws-solutions-constructs.aws-dynamodbstreams-lambda-elasticsearch-kibana
arch: src
version: 2.74.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
checksum_type: sha256
summary:
  CDK Constructs for Amazon Dynamodb streams to AWS Lambda to AWS Elasticsearch with Kibana integration

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_dynamodbstreams_elasticsearch_kibana`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-dynamodbstreams-lambda-elasticsearch-kibana`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.dynamodbstreamslambdaelasticsearchkibana`|

  This AWS Solutions Construct implements Amazon DynamoDB table with stream, AWS Lambda function and Amazon Elasticsearch Service with the least privileged permissions.
  **Some cluster configurations (e.g VPC access) require the existence of the `AWSServiceRoleForAmazonElasticsearchService` Service-Linked Role in your account.**
  **You will need to create the service-linked role using the AWS CLI once in any account using this construct (it may have already been run to support other stacks):**
  ```
  aws iam create-service-linked-role --aws-service-name es.amazonaws.com
  ```
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Aws } from 'aws-cdk-lib';
  import { DynamoDBStreamsToLambdaToElasticSearchAndKibana, DynamoDBStreamsToLambdaToElasticSearchAndKibanaProps } from '@aws-solutions-constructs/aws-dynamodbstreams-lambda-elasticsearch-kibana';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  const constructProps: DynamoDBStreamsToLambdaToElasticSearchAndKibanaProps = {
    lambdaFunctionProps: {
      code: lambda.Code.fromAsset(`lambda`),
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler'
    },
    domainName: 'test-domain',
    // TODO: Ensure the Cognito domain name is globally unique
    cognitoDomainName: 'globallyuniquedomain' + Aws.ACCOUNT_ID
  };
  new DynamoDBStreamsToLambdaToElasticSearchAndKibana(this, 'test-dynamodbstreams-lambda-elasticsearch-kibana', constructProps);
  ```
  Python
  ```Python
  from aws_solutions_constructs.aws_dynamodbstreams_lambda_elasticsearch_kibana import DynamoDBStreamsToLambdaToElasticSearchAndKibana, DynamoDBStreamsToLambdaToElasticSearchAndKibanaProps
  from aws_cdk import (
      Stack,
      aws_lambda as _lambda,
      Aws,
  )
  from constructs import Construct
  DynamoDBStreamsToLambdaToElasticSearchAndKibana(
      self, 'test-dynamodbstreams-lambda-elasticsearch-kibana',
      lambda_function_props=_lambda.FunctionProps(
          code=_lambda.Code.from_asset('lambda'),
          runtime=_lambda.Runtime.PYTHON_3_9,
          handler='index.handler'
      ),
      domain_name='test-domain',
      
      cognito_domain_name='globallyuniquedomain' + Aws.ACCOUNT_ID)
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Aws;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.dynamodbstreamslambdaelasticsearchkibana.*;
  new DynamoDBStreamsToLambdaToElasticSearchAndKibana(this, "test-dynamodb-stream-lambda-elasticsearch-kibana",
          new DynamoDBStreamsToLambdaToElasticSearchAndKibanaProps.Builder()
                  .lambdaFunctionProps(new FunctionProps.Builder()
                          .runtime(Runtime.NODEJS_16_X)
                          .code(Code.fromAsset("lambda"))
                          .handler("index.handler")
                          .build())
                  .domainName("test-domain")
                  .cognitoDomainName("globallyuniquedomain" + Aws.ACCOUNT_ID)
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |dynamoTableProps?|[`dynamodb.TableProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.TableProps.html)|Optional user provided props to override the default props for DynamoDB Table|
  |existingTableInterface?|[`dynamodb.ITable`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.ITable.html)|Existing instance of DynamoDB table object or interface, providing both this and `dynamoTableProps` will cause an error.|
  |dynamoEventSourceProps?|[`aws-lambda-event-sources.DynamoEventSourceProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_event_sources.DynamoEventSourceProps.html)|Optional user provided props to override the default props for DynamoDB Event Source|
  |esDomainProps?|[`elasticsearch.CfnDomainProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticsearch.CfnDomainProps.html)|Optional user provided props to override the default props for the Elasticsearch Service|
  |domainName|`string`|Domain name for the Cognito and the Elasticsearch Service|
  |cognitoDomainName?|`string`|Optional Cognito Domain Name, if provided it will be used for Cognito Domain, and domainName will be used for the Elasticsearch Domain.|
  |deploySqsDlqQueue?|`boolean`|Whether to deploy a SQS dead letter queue when a data record reaches the Maximum Retry Attempts or Maximum Record Age, its metadata like shard ID and stream ARN will be sent to an SQS queue.|
  |sqsDlqQueueProps?|[`sqs.QueueProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.QueueProps.html)|Optional user provided properties for the SQS dead letter queue|
  |createCloudWatchAlarms?|`boolean`|Whether to create recommended CloudWatch alarms|
  | existingVpc? | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An existing VPC in which to deploy the construct. Providing both this and `vpcProps` is an error.|
  | deployVpc? |`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|
  | vpcProps? |[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user-provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the Construct, so any values for those properties supplied here will be overridden. If `deployVpc?` is not `true` then this property will be ignored. |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |dynamoTableInterface|[`dynamodb.ITable`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.ITable.html)|Returns an instance of dynamodb.ITable created by the construct|
  |dynamoTable?|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Returns an instance of dynamodb.Table created by the construct. IMPORTANT: If existingTableInterface was provided in Pattern Construct Props, this property will be `undefined`|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of lambda.Function created by the construct|
  |userPool|[`cognito.UserPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPool.html)|Returns an instance of cognito.UserPool created by the construct|
  |userPoolClient|[`cognito.UserPoolClient`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPoolClient.html)|Returns an instance of cognito.UserPoolClient created by the construct|
  |identityPool|[`cognito.CfnIdentityPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.CfnIdentityPool.html)|Returns an instance of cognito.CfnIdentityPool created by the construct|
  |elasticsearchDomain|[`elasticsearch.CfnDomain`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticsearch.CfnDomain.html)|Returns an instance of elasticsearch.CfnDomain created by the construct|
  |elasticsearchDomain|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of iam.Role created by the construct for elasticsearch.CfnDomain|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns a list of cloudwatch.Alarm created by the construct|
  | vpc? |[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)| Returns an instance of the VPC created by the pattern, if `deployVpc?` is `true`, or `existingVpc?` is provided.                 |

  This pattern requires a lambda function that can post data into the Elasticsearch from DynamoDB stream. A sample function is provided [here](https://github.com/awslabs/aws-solutions-constructs/blob/master/source/patterns/%40aws-solutions-constructs/aws-dynamodbstreams-lambda-elasticsearch-kibana/test/lambda/index.js).

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Set the billing mode for DynamoDB Table to On-Demand (Pay per request)
  * Enable server-side encryption for DynamoDB Table using AWS managed KMS Key
  * Creates a partition key called 'id' for DynamoDB Table
  * Retain the Table when deleting the CloudFormation stack
  * Enable continuous backups and point-in-time recovery

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Enable Failure-Handling features like enable bisect on function Error, set defaults for Maximum Record Age (24 hours) & Maximum Retry Attempts (500) and deploy SQS dead-letter queue as destination on failure
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)

  * Set password policy for User Pools
  * Enforce the advanced security mode for User Pools

  * Deploy best practices CloudWatch Alarms for the Elasticsearch Domain
  * Secure the Kibana dashboard access with Cognito User Pools
  * Enable server-side encryption for Elasticsearch Domain using AWS managed KMS Key
  * Enable node-to-node encryption for Elasticsearch Domain
  * Configure the cluster for the Amazon ES domain

location_href:
  Packages/python-aws-solutions-constructs.aws-dynamodbstreams-lambda-elasticsearch-kibana-2.74.0-1.src.rpm


pkgId: 1225c7d7161bcd332b9880152cd9c439266e0920b20c0262b9ba221ff889f5de
name: python-aws-solutions-constructs.aws-eventbridge-kinesis-firehose-s3
arch: src
version: 2.73.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-eventbridge-kinesis-firehose-s3-2.73.0-1.src.rpm
checksum_type: sha256
summary:
  CDK Constructs for Amazon CloudWatch Events Rule to Amazon Kinesis Firehose to Amazon S3 integration.

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_eventbridge_kinesisfirehose_s3`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-eventbridge-kinesisfirehose-s3`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.eventbridgekinesisfirehoses3`|

  This AWS Solutions Construct implements an Amazon EventBridge Rule to send data to an Amazon Kinesis Data Firehose delivery stream connected to an Amazon S3 bucket.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Duration } from 'aws-cdk-lib';
  import { EventbridgeToKinesisFirehoseToS3, EventbridgeToKinesisFirehoseToS3Props } from '@aws-solutions-constructs/aws-eventbridge-kinesisfirehose-s3';
  import * as events from 'aws-cdk-lib/aws-events';
  const EventbridgeToKinesisFirehoseToS3Props: EventbridgeToKinesisFirehoseToS3Props = {
    eventRuleProps: {
      schedule: events.Schedule.rate(Duration.minutes(5))
    }
  };
  new EventbridgeToKinesisFirehoseToS3(this, 'test-eventbridge-firehose-s3', EventbridgeToKinesisFirehoseToS3Props);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_eventbridge_kinesis_firehose_s3 import EventbridgeToKinesisFirehoseToS3, EventbridgeToKinesisFirehoseToS3Props
  from aws_cdk import (
      aws_events as events,
      Duration,
      Stack
  )
  from constructs import Construct
  EventbridgeToKinesisFirehoseToS3(self, 'test-eventbridge-firehose-s3',
                                  event_rule_props=events.RuleProps(
                                      schedule=events.Schedule.rate(
                                          Duration.minutes(5))
                                  ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.Duration;
  import software.amazon.awscdk.services.events.*;
  import software.amazon.awsconstructs.services.eventbridgekinesisfirehoses3.*;
  new EventbridgeToKinesisFirehoseToS3(this, "test-eventbridge-firehose-s3",
          new EventbridgeToKinesisFirehoseToS3Props.Builder()
                  .eventRuleProps(new RuleProps.Builder()
                          .schedule(Schedule.rate(Duration.minutes(5)))
                          .build())
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingEventBusInterface?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)| Optional user-provided custom EventBus for construct to use. Providing both this and `eventBusProps` results an error.|
  |eventBusProps?|[`events.EventBusProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.EventBusProps.html)|Optional user-provided properties to override the default properties when creating a custom EventBus. Setting this value to `{}` will create a custom EventBus using all default properties. If neither this nor `existingEventBusInterface` is provided the construct will use the `default` EventBus. Providing both this and `existingEventBusInterface` results an error.|
  |eventRuleProps|[`events.RuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.RuleProps.html)|User provided eventRuleProps to override the defaults.|
  |kinesisFirehoseProps?|[`kinesisfirehose.CfnDeliveryStreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStreamProps.html)|Optional user provided props to override the default props for Kinesis Firehose Delivery Stream|
  |existingBucketObj?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Existing instance of S3 Bucket object. If this is provided, then also providing bucketProps is an error. |
  |bucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|User provided props to override the default props for the S3 Bucket.|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|
  |loggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Logging Bucket.|
  |logS3AccessLogs?| boolean|Whether to turn on Access Logging for the S3 bucket. Creates an S3 bucket with associated storage costs for the logs. Enabling Access Logging is a best practice. default - true|
  NOTE: `existingLoggingBucketObj` has been deprecated - to specify an existing Log Bucket, use `bucketProps.serverAccessLogsBucket`.

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |eventBus?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)|Returns the instance of events.IEventBus used by the construct|
  |eventsRule|[`events.Rule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.Rule.html)|Returns an instance of events.Rule created by the construct.|
  |kinesisFirehose|[`kinesisfirehose.CfnDeliveryStream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStream.html)|Returns an instance of kinesisfirehose.CfnDeliveryStream created by the construct|
  |s3Bucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct|
  |s3LoggingBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct as the logging bucket for the primary bucket.|
  |eventsRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for Events Rule|
  |kinesisFirehoseRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for Kinesis Data Firehose delivery stream|
  |kinesisFirehoseLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for Kinesis Data Firehose delivery stream|
  |s3BucketInterface|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Returns an instance of s3.IBucket created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for Amazon EventBridge Rule to publish to the Kinesis Firehose Delivery Stream.

  * Enable CloudWatch logging for Kinesis Firehose
  * Configure least privilege access IAM role for Amazon Kinesis Firehose

  * Configure Access logging for S3 Bucket
  * Enable server-side encryption for S3 Bucket using AWS managed KMS Key
  * Turn on the versioning for S3 Bucket
  * Don't allow public access for S3 Bucket
  * Retain the S3 Bucket when deleting the CloudFormation stack
  * Applies Lifecycle rule to move noncurrent object versions to Glacier storage after 90 days


pkgId: ecd91b5f5f120031aeff146b882bbbd508ac1fc08dd03626ed29a64b202a3161
name: python-aws-solutions-constructs.aws-eventbridge-kinesis-streams
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for deploying Amazon CloudWatch Events Rule that invokes Amazon Kinesis Data Stream
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-eventbridge-kinesis-streams-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_eventbridge_kinesisstreams`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-eventbridge-kinesisstreams`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.eventbridgekinesisstreams`|

  This AWS Solutions Construct implements an Amazon EventBridge rule to send data to an Amazon Kinesis Data Stream
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Duration } from 'aws-cdk-lib';
  import { EventbridgeToKinesisStreams, EventbridgeToKinesisStreamsProps } from "@aws-solutions-constructs/aws-eventbridge-kinesisstreams";
  import * as events from 'aws-cdk-lib/aws-events';
  const constructProps: EventbridgeToKinesisStreamsProps = {
    eventRuleProps: {
      schedule: events.Schedule.rate(Duration.minutes(5)),
    }
  };
  new EventbridgeToKinesisStreams(this, 'test-eventbridge-kinesis-streams', constructProps);
  ```
  Python
  ```Python
  from aws_solutions_constructs.aws_eventbridge_kinesis_streams import EventbridgeToKinesisStreams, EventbridgeToKinesisStreamsProps
  from aws_cdk import (
      aws_events as events,
      Duration,
      Stack
  )
  from constructs import Construct
  EventbridgeToKinesisStreams(self, 'test-eventbridge-kinesis-streams',
      event_rule_props=events.RuleProps(
          schedule=events.Schedule.rate(Duration.minutes(5)),
      ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.Duration;
  import software.amazon.awscdk.services.events.*;
  import software.amazon.awsconstructs.services.eventbridgekinesisstreams.*;
  new EventbridgeToKinesisStreams(this, "test-eventbridge-kinesis-streams",
          new EventbridgeToKinesisStreamsProps.Builder()
                  .eventRuleProps(new RuleProps.Builder()
                          .schedule(Schedule.rate(Duration.minutes(5)))
                          .build())
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingEventBusInterface?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)| Optional user-provided custom EventBus for construct to use. Providing both this and `eventBusProps` results an error.|
  |eventBusProps?|[`events.EventBusProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.EventBusProps.html)|Optional user-provided properties to override the default properties when creating a custom EventBus. Setting this value to `{}` will create a custom EventBus using all default properties. If neither this nor `existingEventBusInterface` is provided the construct will use the `default` EventBus. Providing both this and `existingEventBusInterface` results an error.|
  |eventRuleProps|[`events.RuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.RuleProps.html)|User provided eventRuleProps to override the defaults. |
  |existingStreamObj?|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Existing instance of Kinesis Stream, providing both this and `kinesisStreamProps` will cause an error.|
  |kinesisStreamProps?|[`kinesis.StreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.StreamProps.html)|Optional user-provided props to override the default props for the Kinesis stream. |
  |createCloudWatchAlarms|`boolean`|Whether to create recommended CloudWatch alarms. |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |eventBus?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)|Returns the instance of events.IEventBus used by the construct|
  |eventsRule|[`events.Rule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.Rule.html)|Returns an instance of events.Rule created by the construct.|
  |kinesisStream|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Returns an instance of the Kinesis stream created by the pattern.|
  |eventsRole?|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for events rule.|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns an instance of the cloudwatch.Alarm[] created by the construct.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for EventBridge Rule to publish to the Kinesis Data Stream.

  * Enable server-side encryption for Kinesis Data Stream using AWS Managed KMS Key.


pkgId: abf76e48bd4858a17218b825a3a7d42e022d64fda641c0ef9165e1e138d70a58
name: python-aws-solutions-constructs.aws-eventbridge-lambda
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for deploying AWS Events Rule that inveokes AWS Lambda
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-eventbridge-lambda-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_eventbridge_lambda`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-eventbridge-lambda`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.eventbridgelambda`|

  This AWS Solutions Construct implements an AWS EventBridge rule and an AWS Lambda function.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Duration } from 'aws-cdk-lib';
  import { EventbridgeToLambdaProps, EventbridgeToLambda } from '@aws-solutions-constructs/aws-eventbridge-lambda';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  import * as events from 'aws-cdk-lib/aws-events';
  const constructProps: EventbridgeToLambdaProps = {
    lambdaFunctionProps: {
      code: lambda.Code.fromAsset(`lambda`),
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler'
    },
    eventRuleProps: {
      schedule: events.Schedule.rate(Duration.minutes(5))
    }
  };
  new EventbridgeToLambda(this, 'test-eventbridge-lambda', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_eventbridge_lambda import EventbridgeToLambda, EventbridgeToLambdaProps
  from aws_cdk import (
      aws_lambda as _lambda,
      aws_events as events,
      Duration,
      Stack
  )
  from constructs import Construct
  EventbridgeToLambda(self, 'test-eventbridge-lambda',
                      lambda_function_props=_lambda.FunctionProps(
                          code=_lambda.Code.from_asset('lambda'),
                          runtime=_lambda.Runtime.PYTHON_3_9,
                          handler='index.handler'
                      ),
                      event_rule_props=events.RuleProps(
                          schedule=events.Schedule.rate(
                              Duration.minutes(5))
                      ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.Duration;
  import software.amazon.awscdk.services.events.*;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.eventbridgelambda.*;
  new EventbridgeToLambda(this, "test-eventbridge-lambda",
          new EventbridgeToLambdaProps.Builder()
                  .lambdaFunctionProps(new FunctionProps.Builder()
                          .runtime(Runtime.NODEJS_16_X)
                          .code(Code.fromAsset("lambda"))
                          .handler("index.handler")
                          .build())
                  .eventRuleProps(new RuleProps.Builder()
                          .schedule(Schedule.rate(Duration.minutes(5)))
                          .build())
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |existingEventBusInterface?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)| Optional user-provided custom EventBus for construct to use. Providing both this and `eventBusProps` results an error.|
  |eventBusProps?|[`events.EventBusProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.EventBusProps.html)|Optional user-provided properties to override the default properties when creating a custom EventBus. Setting this value to `{}` will create a custom EventBus using all default properties. If neither this nor `existingEventBusInterface` is provided the construct will use the `default` EventBus. Providing both this and `existingEventBusInterface` results an error.|
  |eventRuleProps|[`events.RuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.RuleProps.html)|User provided eventRuleProps to override the defaults|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |eventBus?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)|Returns the instance of events.IEventBus used by the construct|
  |eventsRule|[`events.Rule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.Rule.html)|Returns an instance of events.Rule created by the construct|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of lambda.Function created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Grant least privilege permissions to EventBridge rule to trigger the Lambda Function

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
  * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: 39588be338770ae810b0ec6cd4ba08424bc13b550705af51c2ff16dcd93abcc0
name: python-aws-solutions-constructs.aws-eventbridge-sns
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK Constructs for deploying AWS Events Rule that invokes AWS SNS
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-eventbridge-sns-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_eventbridge_sns`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-eventbridge-sns`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.eventbridgesns`|

  This AWS Solutions Construct implements an AWS Events rule and an AWS SNS Topic.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Duration } from 'aws-cdk-lib';
  import * as events from 'aws-cdk-lib/aws-events';
  import * as iam from 'aws-cdk-lib/aws-iam';
  import { EventbridgeToSnsProps, EventbridgeToSns } from "@aws-solutions-constructs/aws-eventbridge-sns";
  const constructProps: EventbridgeToSnsProps = {
    eventRuleProps: {
      schedule: events.Schedule.rate(Duration.minutes(5))
    }
  };
  const constructStack = new EventbridgeToSns(this, 'test-construct', constructProps);
  // Grant yourself permissions to use the Customer Managed KMS Key
  const policyStatement = new iam.PolicyStatement({
    actions: ["kms:Encrypt", "kms:Decrypt"],
    effect: iam.Effect.ALLOW,
    principals: [new iam.AccountRootPrincipal()],
    resources: ["*"]
  });
  constructStack.encryptionKey?.addToResourcePolicy(policyStatement);
  ```
  Python
  ```Python
  from aws_solutions_constructs.aws_eventbridge_sns import EventbridgeToSns, EventbridgeToSnsProps
  from aws_cdk import (
      aws_events as events,
      aws_iam as iam,
      Duration,
      Stack
  )
  from constructs import Construct
  construct_stack = EventbridgeToSns(self, 'test-construct',
                                      event_rule_props=events.RuleProps(
                                          schedule=events.Schedule.rate(
                                              Duration.minutes(5))
                                      ))

  policy_statement = iam.PolicyStatement(
      actions=["kms:Encrypt", "kms:Decrypt"],
      effect=iam.Effect.ALLOW,
      principals=[iam.AccountRootPrincipal()],
      resources=["*"]
  )
  construct_stack.encryption_key.add_to_resource_policy(policy_statement)
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.Duration;
  import software.amazon.awscdk.services.events.*;
  import software.amazon.awscdk.services.iam.*;
  import software.amazon.awsconstructs.services.eventbridgesns.*;
  final EventbridgeToSns constructStack = new EventbridgeToSns(this, "test-construct",
          new EventbridgeToSnsProps.Builder()
                  .eventRuleProps(new RuleProps.Builder()
                          .schedule(Schedule.rate(Duration.minutes(5)))
                          .build())
                  .build());
  // Grant yourself permissions to use the Customer Managed KMS Key
  final PolicyStatement policyStatement = PolicyStatement.Builder.create()
          .actions(List.of("kms:Encrypt", "kms:Decrypt"))
          .effect(Effect.ALLOW)
          .principals(List.of(new AccountRootPrincipal()))
          .resources(List.of("*"))
          .build();
  constructStack.getEncryptionKey().addToResourcePolicy(policyStatement);
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |eventRuleProps|[`events.RuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.RuleProps.html)|User provided eventRuleProps to override the defaults. |
  |existingTopicObj?|[`sns.Topic`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of SNS Topic object, providing both this and `topicProps` will cause an error.|
  |topicProps?|[`sns.TopicProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sns.TopicProps.html)|User provided props to override the default props for the SNS Topic. |
  |existingEventBusInterface?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)| Optional user-provided custom EventBus for construct to use. Providing both this and `eventBusProps` results an error.|
  |eventBusProps?|[`events.EventBusProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.EventBusProps.html)|Optional user-provided properties to override the default properties when creating a custom EventBus. Setting this value to `{}` will create a custom EventBus using all default properties. If neither this nor `existingEventBusInterface` is provided the construct will use the `default` EventBus. Providing both this and `existingEventBusInterface` results an error.|
  |enableEncryptionWithCustomerManagedKey?|`boolean`|If no key is provided, this flag determines whether the SNS Topic is encrypted with a new CMK or an AWS managed key. This flag is ignored if any of the following are defined: topicProps.masterKey, encryptionKey or encryptionKeyProps.|
  |encryptionKey?|[`kms.Key`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html)|An optional, imported encryption key to encrypt the SNS Topic with.|
  |encryptionKeyProps?|[`kms.KeyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html#construct-props)|Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SNS Topic with.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |eventBus?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)|Returns the instance of events.IEventBus used by the construct|
  |eventsRule|[`events.Rule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.Rule.html)|Returns an instance of events.Rule created by the construct|
  |snsTopic|[`sns.Topic`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sns.Topic.html)|Returns an instance of sns.Topic created by the construct|
  |encryptionKey?|[`kms.Key`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html)|Returns an instance of kms Key used for the SNS Topic.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Grant least privilege permissions to EventBridge Rule to publish to the SNS Topic.

  * Configure least privilege access permissions for SNS Topic.
  * Enable server-side encryption forSNS Topic using Customer managed KMS Key.
  * Enforce encryption of data in transit.


pkgId: 2a4c8f97447bb944a81b205a36ebda6a9f1c0e867b2478dd7853a5473b5d3cce
name: python-aws-solutions-constructs.aws-eventbridge-sqs
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for deploying AWS Eventbridge that invokes AWS SQS
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-eventbridge-sqs-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_eventbridge_sqs`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-eventbridge-sqs`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.eventbridgesqs`|

  This AWS Solutions Construct implements an Amazon EventBridge rule and an AWS SQS Queue.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Duration } from 'aws-cdk-lib';
  import * as events from 'aws-cdk-lib/aws-events';
  import * as iam from 'aws-cdk-lib/aws-iam';
  import { EventbridgeToSqsProps, EventbridgeToSqs } from "@aws-solutions-constructs/aws-eventbridge-sqs";
  const constructProps: EventbridgeToSqsProps = {
    eventRuleProps: {
      schedule: events.Schedule.rate(Duration.minutes(5))
    }
  };
  const constructStack = new EventbridgeToSqs(this, 'test-construct', constructProps);
  // Grant yourself permissions to use the Customer Managed KMS Key
  const policyStatement = new iam.PolicyStatement({
    actions: ["kms:Encrypt", "kms:Decrypt"],
    effect: iam.Effect.ALLOW,
    principals: [new iam.AccountRootPrincipal()],
    resources: ["*"]
  });
  constructStack.encryptionKey?.addToResourcePolicy(policyStatement);
  ```
  Python
  ```Python
  from aws_solutions_constructs.aws_eventbridge_sqs import EventbridgeToSqsProps, EventbridgeToSqs
  from aws_cdk import (
      aws_events as events,
      aws_iam as iam,
      Duration,
      Stack
  )
  from constructs import Construct
  construct_stack = EventbridgeToSqs(self, 'test-construct',
                                      event_rule_props=events.RuleProps(
                                          schedule=events.Schedule.rate(
                                              Duration.minutes(5))
                                      ))

  policy_statement = iam.PolicyStatement(
      actions=["kms:Encrypt", "kms:Decrypt"],
      effect=iam.Effect.ALLOW,
      principals=[iam.AccountRootPrincipal()],
      resources=["*"]
  )
  construct_stack.encryption_key.add_to_resource_policy(policy_statement)
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.Duration;
  import software.amazon.awscdk.services.events.*;
  import software.amazon.awscdk.services.iam.*;
  import software.amazon.awsconstructs.services.eventbridgesqs.*;
  final EventbridgeToSqs constructStack = new EventbridgeToSqs(this, "test-construct",
          new EventbridgeToSqsProps.Builder()
                  .eventRuleProps(new RuleProps.Builder()
                          .schedule(Schedule.rate(Duration.minutes(5)))
                          .build())
                  .build());
  // Grant yourself permissions to use the Customer Managed KMS Key
  final PolicyStatement policyStatement = PolicyStatement.Builder.create()
          .actions(List.of("kms:Encrypt", "kms:Decrypt"))
          .effect(Effect.ALLOW)
          .principals(List.of(new AccountRootPrincipal()))
          .resources(List.of("*"))
          .build();
  constructStack.getEncryptionKey().addToResourcePolicy(policyStatement);
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingEventBusInterface?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)| Optional user-provided custom EventBus for construct to use. Providing both this and `eventBusProps` results an error.|
  |eventBusProps?|[`events.EventBusProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.EventBusProps.html)|Optional user-provided properties to override the default properties when creating a custom EventBus. Setting this value to `{}` will create a custom EventBus using all default properties. If neither this nor `existingEventBusInterface` is provided the construct will use the `default` EventBus. Providing both this and `existingEventBusInterface` results an error.|
  |eventRuleProps|[`events.RuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.RuleProps.html)|User provided eventRuleProps to override the defaults. |
  |existingQueueObj?|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|An optional, existing SQS queue to be used instead of the default queue. Providing both this and `queueProps` will cause an error.|
  |queueProps?|[`sqs.QueueProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.QueueProps.html)|User provided props to override the default props for the SQS Queue. |
  |enableQueuePurging?|`boolean`|Whether to grant additional permissions to the Lambda function enabling it to purge the SQS queue. Defaults to `false`.|
  |deployDeadLetterQueue?|`boolean`|Whether to create a secondary queue to be used as a dead letter queue. Defaults to `true`.|
  |deadLetterQueueProps?|[`sqs.QueueProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.QueueProps.html)|Optional user-provided props to override the default props for the dead letter queue. Only used if the `deployDeadLetterQueue` property is set to true.|
  |maxReceiveCount?|`number`|The number of times a message can be unsuccessfully dequeued before being moved to the dead letter queue. Defaults to `15`.|
  |enableEncryptionWithCustomerManagedKey?|`boolean`|If no key is provided, this flag determines whether the queue is encrypted with a new CMK or an AWS managed key. This flag is ignored if any of the following are defined: queueProps.encryptionMasterKey, encryptionKey or encryptionKeyProps.|
  |encryptionKey?|[`kms.Key`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html)|An optional, imported encryption key to encrypt the SQS Queue with.|
  |encryptionKeyProps?|[`kms.KeyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html#construct-props)|Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SQS queue with.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |eventBus?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)|Returns the instance of events.IEventBus used by the construct|
  |eventsRule|[`events.Rule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.Rule.html)|Returns an instance of events.Rule created by the construct|
  |sqsQueue|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|Returns an instance of sqs.Queue created by the construct|
  |encryptionKey?|[`kms.Key`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html)|Returns an instance of kms Key used for the SQS queue.|
  |deadLetterQueue?|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|Returns an instance of the dead-letter SQS queue created by the pattern.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Grant least privilege permissions to EventBridge rule to publish to the SQS Queue.

  * Deploy SQS dead-letter queue for the source SQS Queue.
  * Enable server-side encryption for source SQS Queue using Customer managed KMS Key.
  * Enforce encryption of data in transit.


pkgId: 3423435f8c9d823de311554a3e71d583cf725162c9f3c1bc8dfb10fc4d4c2948
name: python-aws-solutions-constructs.aws-eventbridge-stepfunctions
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for deploying AWS Events Rule that invokes AWS Step Functions
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-eventbridge-stepfunctions-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_eventbridge_stepfunctions`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-eventbridge-stepfunctions`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.eventbridgestepfunctions`|

  This AWS Solutions Construct implements an AWS Events rule and an AWS Step Functions State Machine
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Duration } from 'aws-cdk-lib';
  import { EventbridgeToStepfunctions, EventbridgeToStepfunctionsProps } from '@aws-solutions-constructs/aws-eventbridge-stepfunctions';
  import * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions';
  import * as events from 'aws-cdk-lib/aws-events';
  const startState = new stepfunctions.Pass(this, 'StartState');
  const constructProps: EventbridgeToStepfunctionsProps = {
    stateMachineProps: {
      definition: startState
    },
    eventRuleProps: {
      schedule: events.Schedule.rate(Duration.minutes(5))
    }
  };
  new EventbridgeToStepfunctions(this, 'test-eventbridge-stepfunctions-stack', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_eventbridge_stepfunctions import EventbridgeToStepfunctions, EventbridgeToStepfunctionsProps
  from aws_cdk import (
      aws_stepfunctions as stepfunctions,
      aws_events as events,
      Duration,
      Stack
  )
  from constructs import Construct
  startState = stepfunctions.Pass(self, 'StartState')
  EventbridgeToStepfunctions(self, 'test-eventbridge-stepfunctions-stack',
                              state_machine_props=stepfunctions.StateMachineProps(
                                  definition=startState
                              ),
                              event_rule_props=events.RuleProps(
                                  schedule=events.Schedule.rate(
                                      Duration.minutes(5))
                              ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.Duration;
  import software.amazon.awscdk.services.events.*;
  import software.amazon.awscdk.services.stepfunctions.*;
  import software.amazon.awsconstructs.services.eventbridgestepfunctions.*;
  final Pass startState = new Pass(this, "StartState");
  new EventbridgeToStepfunctions(this,
          "test-eventbridge-stepfunctions-stack",
          new EventbridgeToStepfunctionsProps.Builder()
                  .stateMachineProps(new StateMachineProps.Builder()
                          .definition(startState)
                          .build())
                  .eventRuleProps(new RuleProps.Builder()
                          .schedule(Schedule.rate(Duration.minutes(5)))
                          .build())
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |stateMachineProps|[`sfn.StateMachineProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.StateMachineProps.html)|Optional user provided props to override the default props for sfn.StateMachine|
  |existingEventBusInterface?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)| Optional user-provided custom EventBus for construct to use. Providing both this and `eventBusProps` results an error.|
  |eventBusProps?|[`events.EventBusProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.EventBusProps.html)|Optional user-provided properties to override the default properties when creating a custom EventBus. Setting this value to `{}` will create a custom EventBus using all default properties. If neither this nor `existingEventBusInterface` is provided the construct will use the `default` EventBus. Providing both this and `existingEventBusInterface` results an error.|
  |eventRuleProps|[`events.RuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.RuleProps.html)|User provided eventRuleProps to override the defaults|
  |createCloudWatchAlarms|`boolean`|Whether to create recommended CloudWatch alarms|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |eventBus?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)|Returns the instance of events.IEventBus used by the construct|
  |eventsRule|[`events.Rule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.Rule.html)|Returns an instance of events.Rule created by the construct|
  |stateMachine|[`sfn.StateMachine`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.StateMachine.html)|Returns an instance of sfn.StateMachine created by the construct|
  |stateMachineLogGroup|[`logs.ILogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.ILogGroup.html)|Returns an instance of the ILogGroup created by the construct for StateMachine|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns a list of cloudwatch.Alarm created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Grant least privilege permissions to CloudWatch Events to trigger the Lambda Function

  * Enable CloudWatch logging for API Gateway
  * Deploy best practices CloudWatch Alarms for the Step Function


pkgId: 238944af4b635a5fa26b8a4a1425a37451a6417e4d6af96cfd7cceeb9e2baba8
name: python-aws-solutions-constructs.aws-fargate-dynamodb
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to Amazon DynamoDB integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-dynamodb-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_dynamodb`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-dynamodb`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargatedynamodb`|

  This AWS Solutions Construct implements an AWS Fargate service that can write/read to an Amazon DynamoDB table
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToDynamoDB, FargateToDynamoDBProps } from '@aws-solutions-constructs/aws-fargate-dynamodb';
  const constructProps: FargateToDynamoDBProps = {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
  };
  new FargateToDynamoDB(stack, 'test-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_dynamodb import FargateToDynamoDB, FargateToDynamoDBProps
  from aws_cdk import (
      Stack
  )
  from constructs import Construct
  FargateToDynamoDB(self, 'test_construct',
              public_api=True,
              ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.fargatedynamodb.*;
  new FargateToDynamoDB(this, "test-construct", new FargateToDynamoDBProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | `boolean` | Whether the construct is deploying a private or public API. This has implications for the VPC. |
  | vpcProps? | [`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  | existingVpc? | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | clusterProps? | [`ecs.ClusterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | `string` | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | `string` | The version of the image to use from the repository. Defaults to 'Latest' |
  | containerDefinitionProps? | [`ecs.ContainerDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [`ecs.FargateTaskDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct  (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [`ecs.FargateServiceProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  | existingContainerDefinitionObject? | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the existingFargateServiceObject |
  | dynamoTableProps?	| [`dynamodb.TableProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.TableProps.html)|Optional user provided props to override the default props for DynamoDB Table.|
  |existingTableInterface?|[`dynamodb.ITable`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.ITable.html)|Existing instance of DynamoDB table object or interface, providing both this and `dynamoTableProps` will cause an error.|
  | tablePermissions?	|`string`|Optional table permissions to grant to the Fargate service. One of the following may be specified: `All`, `Read`, `ReadWrite`, `Write`.|
  |tableArnEnvironmentVariableName?|`string`|Optional Name for the container environment variable set to the ARN for the DynamoDB table. Default: DYNAMODB_TABLE_ARN |
  |tableEnvironmentVariableName?|`string`|Optional Name for the container environment variable set to the DynamoDB table name. Default: DYNAMODB_TABLE_NAME |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or provided by the client) |
  | service | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The AWS Fargate service used by this construct (whether created by this construct or passed to this construct at initialization) |
  | container | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  |dynamoTableInterface|[`dynamodb.ITable`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.ITable.html)|Returns an instance of `dynamodb.ITable` created by the construct or the interface provided in existingTableInterface.|
  |dynamoTable?|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Returns an instance of `dynamodb.Table` created by the construct. IMPORTANT: If existingTableInterface was provided in Pattern Construct Props, this property will be `undefined`.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Sets up an AWS Fargate service
    * Uses the existing service if provided
    * Creates a new service if none provided.
      * Service will run in isolated subnets if available, then private subnets if available and finally public subnets
    * Adds environment variables to the container with the ARN and Name of the DynamoDB table
    * Add permissions to the container IAM role allowing it to publish to the DynamoDB table

  * Sets up an Amazon DynamoDB table
    * Uses an existing table if one is provided, otherwise creates a new one
  * Adds an Interface Endpoint to the VPC for DynamoDB (the service by default runs in Isolated or Private subnets)


pkgId: 87c5df61c013727d62b41ada0983b6af20bec6c664f381f04b37f0e24e53a407
name: python-aws-solutions-constructs.aws-fargate-eventbridge
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to Amazon Eventbridge integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-eventbridge-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_eventbridge`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-eventbridge`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargateeventbridge`|
  This AWS Solutions Construct implements an AWS Fargate service connected to an Amazon EventBridge.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToEventbridge, FargateToEventbridgeProps } from '@aws-solutions-constructs/aws-fargate-eventbridge';
  const constructProps: FargateToEventbridgeProps = {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
  };
  new FargateToEventbridge(this, 'test-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_eventbridge import FargateToEventbridge, FargateToEventbridgeProps
  from aws_cdk import (
      Stack
  )
  from constructs import Construct
  FargateToEventbridge(self, 'test_construct',
              public_api=True,
              ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.fargateeventbridge.*;
  new FargateToEventbridge(this, "test_construct", new FargateToEventbridgeProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | boolean | Whether the construct is deploying a private or public API. This has implications for the VPC. |
  | vpcProps? | [ec2.VpcProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  | existingVpc? | [ec2.IVpc](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | clusterProps? | [ecs.ClusterProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | `string` | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | `string` | The version of the image to use from the repository. Defaults to 'Latest'|
  | containerDefinitionProps? | [ecs.ContainerDefinitionProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [ecs.FargateTaskDefinitionProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct  (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [ecs.FargateServiceProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [ecs.FargateService](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  | existingContainerDefinitionObject? | [ecs.ContainerDefinition](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the existingFargateServiceObject |
  | existingEventBusInterface? | [`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)| Optional user-provided custom event bus for construct to use. Providing both this and `eventBusProps` results an error.|
  | eventBusProps?	| [`events.EventBusProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.EventBusProps.html)|Optional user-provided properties to override the default properties when creating a custom event bus. Setting this value to `{}` will create a custom event bus using all default properties. If neither this nor `existingEventBusInterface` is provided the construct will use the `default` event bus. Providing both this and `existingEventBusInterface` results an error.|
  |eventBusEnvironmentVariableName?|`string`|Optional Name for the container environment variable set to the DynamoDB table name. Default: EVENTBUS_NAME|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [ec2.IVpc](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or provided by the client) |
  | service | [ecs.FargateService](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The AWS Fargate service used by this construct (whether created by this construct or passed to this construct at initialization) |
  | container | [ecs.ContainerDefinition](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  | eventBus?	| [`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)|Returns the instance of `events.IEventBus` used by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Sets up an AWS Fargate service
    * Uses the existing service if provided
    * Creates a new service if none provided.
      * Service will run in isolated subnets if available, then private subnets if available and finally public subnets
  * Adds environment variables to the container with the Name of the event bus
    * Default: EVENTBUS_NAME
  * Add permissions to the container IAM role allowing it to put events in the EventBridge event bus

  * Sets up an Amazon EventBridge event bus
    * Uses an existing event bus if one is provided, otherwise creates a new one if `eventBusProps` is provided
    * If neither `eventBusProps` nor `existingEventBusInterface` is provided, the construct will use the `default` event bus.
  * Adds an Interface Endpoint to the VPC for EventBridge (the service by default runs in Isolated or Private subnets)


pkgId: e862d373502c85f7e0a8788d242e1483e385a72a625c7a6196678f24a8b4a84e
name: python-aws-solutions-constructs.aws-fargate-kinesisfirehose
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to Amazon Kinesis Firehose integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-kinesisfirehose-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_kinesisfirehose`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-kinesisfirehose`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargatekinesisfirehose`|

  This AWS Solutions Construct deploys an AWS Fargate Service that can put records on an Amazon Firehose Delivery Stream.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToKinesisFirehoseProps } from '@aws-solutions-constructs/aws-fargate-kinesisfirehose';
  import * as fargate from 'aws-cdk-lib/aws-fargate';
  // The construct requires an existing Firehose Delivery Stream, this can be created in raw CDK or extracted
  // from a previously instantiated construct that created an Firehose Delivery Stream
  const existingFirehoseDeliveryStream = previouslyCreatedKinesisFirehoseToS3Construct.kinesisFirehose;
  new FargateToKinesisFirehose(this, 'FargateToKinesisFirehose', {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
    existingKinesisFirehose: existingFirehoseDeliveryStream
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_kinesisfirehose import FargateToKinesisFirehose
  from aws_cdk import (
      aws_fargate as _fargate,
      Stack
  )
  from constructs import Construct


  existingFirehoseDeliveryStream = previouslyCreatedKinesisFirehoseToS3Construct.kinesisFirehose;
  FargateToKinesisFirehose(self, 'FargateToKinesisFirehose',
                            public_api=True,
                            ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
                            existingKinesisFirehose=existingFirehoseDeliveryStream
                         )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.fargate.*;
  import software.amazon.awscdk.services.fargate.eventsources.*;
  import software.amazon.awscdk.services.fargate.Runtime;
  import software.amazon.awsconstructs.services.fargatekinesisfirehose.*;
  // The construct requires an existing Firehose Delivery Stream, this can be created in raw CDK or extracted
  // from a previously instantiated construct that created an Firehose Delivery Stream
  existingFirehoseDeliveryStream = previouslyCreatedKinesisFirehoseToS3Construct.kinesisFirehose;
  new FargateToKinesisFirehose(this, "FargateToKinesisFirehose", new FargateToKinesisFirehoseProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .existingKinesisFirehose(existingFirehoseDeliveryStream)
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | `boolean` | True if the VPC provisioned by this construct should contain Public/Private Subnets, otherwise False for the VPC to contain Isolated Subnets only. Note this property is ignored if an existing VPC is specified in the existingVpc property. If you are getting a container from a public repo, this must be true so the repo can be accessed from the network. |
  | vpcProps? | [`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a new VPC the construct will create. Providing both this and `existingVpc` is an error. An Amazon Kinesis Firehose Interface Endpoint will be added to this VPC. |
  | existingVpc? | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the Fargate Service. Providing both this and `vpcProps` is an error. If the client provides an existing Fargate Service in the `existingFargateServiceObject` property, this value must be the VPC where the service is running. An Amazon Kinesis Firehose Interface Endpoint will be added to this VPC. |
  | clusterProps? | [`ecs.ClusterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | `string` | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | `string` | The version of the image to use from the repository. Defaults to 'Latest' |
  | containerDefinitionProps? | [`ecs.ContainerDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service. (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [`ecs.FargateTaskDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct. (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [`ecs.FargateServiceProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  | existingContainerDefinitionObject? | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the `existingFargateServiceObject`. |
  |existingKinesisFirehose|[kinesisfirehose.CfnDeliveryStream](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStream.html)|An existing Kinesis Firehose Delivery Stream to which the Fargate container can put data. Note - the delivery stream construct must have already been created and have the deliveryStreamName set. This construct will *not* create a new Delivery Stream.|
  |firehoseEnvironmentVariableName?|`string`|Optional Name for the Fargate container environment variable set to the name of the delivery stream. Default: FIREHOSE_DELIVERYSTREAM_NAME |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The new or existing VPC used by the construct. |
  | fargateService | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The new or existing AWS Fargate service used by this construct. |
  | container | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  |kinesisFirehose|[kinesisfirehose.CfnDeliveryStream](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStream.html)|The Kinesis Firehose Delivery Stream used by the construct.|

  Out of the box implementation of the Construct without any overrides will set the following defaults:

  * An AWS Fargate Service running in the isolated subnets of a new VPC
  * Minimally-permissive IAM role for the Fargate Service to put records on the Firehose Delivery Stream
  * Sets an Environment Variable named FIREHOSE_DELIVERYSTREAM_NAME that holds the Firehose Delivery Stream Name, which is a required property of the Kinesis Firehose SDK when making calls to it

  * This construct must be provided a configured Firehose Data Stream construct, it does not change this Stream.


pkgId: f9c4e5135e4b7ffe2cbc2eba4105159601a8990691085f44e8e58599ca3e6deb
name: python-aws-solutions-constructs.aws-fargate-kinesisstreams
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to an Amazon Kinesis Data Stream
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-kinesisstreams-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_kinesisstreams`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-kinesisstreams`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargatekinesisstreams`|

  This AWS Solutions Construct deploys an AWS Fargate Service that can put records on an Amazon Kinesis Data Stream.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToKinesisStreamsProps } from '@aws-solutions-constructs/aws-fargate-kinesisstreams';
  import * as fargate from 'aws-cdk-lib/aws-fargate';
  new FargateToKinesisStreams(this, 'FargateToKinesisStreams', {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_kinesisstreams import FargateToKinesisStreams
  from aws_cdk import (
      aws_fargate as _fargate,
      Stack
  )
  from constructs import Construct
  FargateToKinesisStreams(self, 'FargateToKinesisStreams',
                            public_api=True,
                            ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo"
                         )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.fargate.*;
  import software.amazon.awscdk.services.fargate.eventsources.*;
  import software.amazon.awscdk.services.fargate.Runtime;
  import software.amazon.awsconstructs.services.fargatekinesisstreams.*;
  new FargateToKinesisStreams(this, "FargateToKinesisStreams", new FargateToKinesisStreamsProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | `boolean` | True if the VPC provisioned by this construct should contain Public/Private Subnets, otherwise False for the VPC to contain Isolated Subnets only. Note this property is ignored if an existing VPC is specified in the `existingVpc` property. |
  | vpcProps? | [`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a new VPC the construct will create. Providing both this and `existingVpc` is an error. An Amazon Kinesis Streams Interface Endpoint will be added to this VPC. |
  | existingVpc? | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the Fargate Service. Providing both this and `vpcProps` is an error. If the client provides an existing Fargate Service in the `existingFargateServiceObject` property, this value must be the VPC where the service is running. An Amazon Kinesis Streams Interface Endpoint will be added to this VPC. |
  | clusterProps? | [`ecs.ClusterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | `string` | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | `string` | The version of the image to use from the repository. Defaults to 'Latest' |
  | containerDefinitionProps? | [`ecs.ContainerDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service. (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [`ecs.FargateTaskDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct. (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [`ecs.FargateServiceProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  | existingContainerDefinitionObject? | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the `existingFargateServiceObject`. |
  |existingStreamObj?|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html) | Existing instance of a Kinesis Data Stream. Providing both this and `kinesisStreamProps` will cause an error. |
  |kinesisStreamProps?|[`kinesis.StreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.StreamProps.html) | Optional user-provided props to override the default props for the Kinesis Data Stream. Providing both this and `existingStreamObj` will cause an error. |
  | createCloudWatchAlarms |`boolean` | Whether to create recommended CloudWatch Alarms for the Kinesis Stream (defaults to true). |
  | streamEnvironmentVariableName? | `string` | Optional Name to override the Fargate Service default environment variable name that holds the Kinesis Data Stream name value. Default: KINESIS_DATASTREAM_NAME |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The new or existing VPC used by the construct. |
  | service | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The new or existing AWS Fargate service used by this construct. |
  | container | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  | kinesisStream | [`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html) | The new or existing Kinesis Data Stream used by this construct. |
  | cloudwatchAlarms? | [`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html) | Returns the CloudWatch Alarms created to monitor the Kinesis Data Stream.|

  Out of the box implementation of the Construct without any overrides will set the following defaults:

  * An AWS Fargate Service running in the isolated subnets of a new VPC
  * Minimally-permissive IAM role for the Fargate Service to put records on the Kinesis Data Stream
  * Sets an Environment Variable named KINESIS_DATASTREAM_NAME that holds the Kinesis Data Stream Name, which is a required property of the Kinesis Data Streams SDK when making calls to it

  * Enable server-side encryption for the Kinesis Data Stream using an AWS Managed CMK
  * Deploy best practices CloudWatch Alarms for the Kinesis Data Stream
  * An Interface Endpoint on the VPC for private communication between the Fargate Service and the Kinesis Data Stream


pkgId: e2e5482b1bf751313326591fe46ad4436e42d13d6588798ac2983c46f79a075c
name: python-aws-solutions-constructs.aws-fargate-opensearch
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to Amazon OpenSearch Service
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-opensearch-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_opensearch`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-opensearch`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargateopensearch`|

  This AWS Solutions Construct implements an AWS Fargate service that can write/read to an Amazon OpenSearch Service domain.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToOpenSearch, FargateToOpenSearchProps } from '@aws-solutions-constructs/aws-fargate-opensearch';
  const constructProps: FargateToOpenSearchProps = {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
    openSearchDomainName: 'testdomain',
    // TODO: Ensure the Cognito domain name is globally unique
    cognitoDomainName: 'globallyuniquedomain' + Aws.ACCOUNT_ID
  };
  new FargateToOpenSearch(this, 'test-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_opensearch import FargateToOpenSearch, FargateToOpenSearchProps
  from aws_cdk import (
      Stack
  )
  from constructs import Construct
  FargateToOpenSearch(self, 'test_construct',
              public_api=True,
              ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
              open_search_domain_name='testdomain',
              
              cognito_domain_name='globallyuniquedomain' + Aws.ACCOUNT_ID)
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.fargateopensearch.*;
  new FargateToOpenSearch(this, "test_construct", new FargateToOpenSearchProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo"
          .openSearchDomainName("testdomain")
          // TODO: Ensure the Cognito domain name is globally unique
          .cognitoDomainName("globallyuniquedomain" + Aws.ACCOUNT_ID)
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | `boolean` | Whether the construct is deploying a private or public API. This has implications for the VPC. |
  | vpcProps? | [`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  | existingVpc? | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | clusterProps? | [`ecs.ClusterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | `string` | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | `string` | The version of the image to use from the repository. Defaults to 'Latest'. |
  | containerDefinitionProps? | [`ecs.ContainerDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service (defaults found in fargate-defaults.ts). |
  | fargateTaskDefinitionProps? | [`ecs.FargateTaskDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct  (defaults found in fargate-defaults.ts). |
  | fargateServiceProps? | [`ecs.FargateServiceProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps.|
  | existingContainerDefinitionObject? | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the existingFargateServiceObject.|
  |openSearchDomainProps?|[`opensearchservice.CfnDomainProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_opensearchservice.CfnDomainProps.html)|Optional user provided props to override the default props for the OpenSearch Service.|
  |openSearchDomainName|`string`|Domain name for the OpenSearch Service.|
  |cognitoDomainName?|`string`|Optional Amazon Cognito domain name. If omitted the Amazon Cognito domain will default to the OpenSearch Service domain name.|
  |createCloudWatchAlarms?|`boolean`|Whether to create the recommended CloudWatch alarms.|
  |domainEndpointEnvironmentVariableName?|`string`|Optional name for the OpenSearch Service domain endpoint environment variable set for the Lambda function. Default is `DOMAIN_ENDPOINT`.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or provided by the client). |
  | service | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The AWS Fargate service used by this construct (whether created by this construct or passed to this construct at initialization). |
  | container | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  |userPool|[`cognito.UserPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPool.html)|Returns an instance of `cognito.UserPool` created by the construct.|
  |userPoolClient|[`cognito.UserPoolClient`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPoolClient.html)|Returns an instance of `cognito.UserPoolClient` created by the construct.|
  |identityPool|[`cognito.CfnIdentityPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.CfnIdentityPool.html)|Returns an instance of `cognito.CfnIdentityPool` created by the construct.|
  |openSearchDomain|[`opensearchservice.CfnDomain`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_opensearchservice.CfnDomain.html)|Returns an instance of `opensearch.CfnDomain` created by the construct.|
  |openSearchRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of `iam.Role` created by the construct for `opensearch.CfnDomain`.|
  |cloudWatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns a list of `cloudwatch.Alarm` created by the construct.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Sets up an AWS Fargate service
    * Uses the existing service if provided
    * Creates a new service if none provided
      * Service will run in isolated subnets if available, then private subnets if available and finally public subnets
    * Adds environment variables to the container with the OpenSearch Service domain endpoint
    * Add permissions to the container IAM role allowing it to write/read to the OpenSearch Service domain endpoint

  * Set password policy for User Pools
  * Enforce the advanced security mode for User Pools

  * Deploy best practices CloudWatch Alarms for the OpenSearch Service domain
  * Secure the OpenSearch Service dashboard access with Cognito User Pools
  * Enable server-side encryption for OpenSearch Service domain using AWS managed KMS Key
  * Enable node-to-node encryption for the OpenSearch Service domain
  * Configure the cluster for the OpenSearch Service domain


pkgId: c65ae58f8a2f2c5adc7650a8e9fe4a22c1704734466240f7c9aae2f29c7dcb15
name: python-aws-solutions-constructs.aws-fargate-s3
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to Amazon S3 integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-s3-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_s3`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-s3`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargates3`|

  This AWS Solutions Construct implements an AWS Fargate service that can write/read to an Amazon S3 Bucket
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToS3, FargateToS3Props } from '@aws-solutions-constructs/aws-fargate-s3';
  const constructProps: FargateToS3Props = {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
  };
  new FargateToS3(this, 'test-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_s3 import FargateToS3, FargateToS3Props
  from aws_cdk import (
      Stack
  )
  from constructs import Construct
  FargateToS3(self, 'test_construct',
              public_api=True,
              ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.fargates3.*;
  new FargateToS3(this, "test_construct", new FargateToS3Props.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | boolean | Whether the construct is deploying a private or public API. This has implications for the VPC. |
  | vpcProps? | [ec2.VpcProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  | existingVpc? | [ec2.IVpc](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | clusterProps? | [ecs.ClusterProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | string | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | string | The version of the image to use from the repository. Defaults to 'Latest' |
  | containerDefinitionProps? | [ecs.ContainerDefinitionProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [ecs.FargateTaskDefinitionProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct  (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [ecs.FargateServiceProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [ecs.FargateService](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  | existingContainerDefinitionObject? | [ecs.ContainerDefinition](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the existingFargateServiceObject |
  |existingBucketInterface?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Existing S3 Bucket interface. Providing this property and `bucketProps` results in an error.|
  |bucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Bucket.|
  |loggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Logging Bucket.|
  |logS3AccessLogs?| boolean|Whether to turn on Access Logging for the S3 bucket. Creates an S3 bucket with associated storage costs for the logs. Enabling Access Logging is a best practice. default - true|
  |bucketPermissions?|`string[]`|Optional bucket permissions to grant to the Fargate service. One or more of the following may be specified: `Delete`, `Read`, and `Write`. Default is ["Read", "Write"] which includes `[s3:GetObject*, s3:GetBucket*, s3:List*, s3:DeleteObject*, s3:PutObject*, s3:Abort*]`.|
  |bucketArnEnvironmentVariableName?|string|Optional Name for the container environment variable set to the bucket ARN. Default: S3_BUCKET_ARN |
  |bucketEnvironmentVariableName?|string|Optional Optional Name for the container environment variable set to the bucket name. Default: S3_BUCKET_NAME |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [ec2.IVpc](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or provided by the client) |
  | service | [ecs.FargateService](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The AWS Fargate service used by this construct (whether created by this construct or passed to this construct at initialization) |
  | container | [ecs.ContainerDefinition](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  | s3Bucket? |[s3.IBucket](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Returns an instance of s3.Bucket created by the construct|
  | s3BucketInterface |[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Returns an instance of s3.IBucket created by the construct|
  | s3LoggingBucket?	| [s3.Bucket](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Sets up an AWS Fargate service
    * Uses the existing service if provided
    * Creates a new service if none provided.
      * Service will run in isolated subnets if available, then private subnets if available and finally public subnets
    * Adds environment variables to the container with the ARN and Name of the S3 Bucket
    * Add permissions to the container IAM role allowing it to publish to the S3 Bucket

  * Sets up an Amazon S3 Bucket
    * Uses an existing bucket if one is provided, otherwise creates a new one
  * Adds an Interface Endpoint to the VPC for S3 (the service by default runs in Isolated or Private subnets)


pkgId: 8823e9665515afbcc63339e6a66426c9e6076d405b51013d26b3fb884c0cdc5f
name: python-aws-solutions-constructs.aws-fargate-secretsmanager
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to Amazon Secrets Manager integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-secretsmanager-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_secretsmanager`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-secretsmanager`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargatesecretsmanager`|

  This AWS Solutions Construct implements an AWS Fargate service that can write/read to an AWS Secrets Manager
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToSecretsmanager, FargateToSecretsmanagerProps } from '@aws-solutions-constructs/aws-fargate-secretsmanager';
  const constructProps: FargateToSecretsmanagerProps = {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
  };
  new FargateToSecretsmanager(stack, 'test-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_secretsmanager import FargateToSecretsmanager, FargateToSecretsmanagerProps
  from aws_cdk import (
      Stack
  )
  from constructs import Construct
  FargateToSecretsmanager(self, 'test_construct',
              public_api=True,
              ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.fargatesecretsmanager.*;
  new FargateToSecretsmanager(this, "test-construct", new FargateToSecretsmanagerProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | `boolean` | Whether the construct is deploying a private or public API. This has implications for the VPC. |
  | vpcProps? | [`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  | existingVpc? | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | clusterProps? | [`ecs.ClusterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | `string` | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | `string` | The version of the image to use from the repository. Defaults to 'Latest' |
  | containerDefinitionProps? | [`ecs.ContainerDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [`ecs.FargateTaskDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct  (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [`ecs.FargateServiceProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  | existingContainerDefinitionObject? | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the existingFargateServiceObject |
  |secretProps?|[`secretsmanager.SecretProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_secretsmanager.SecretProps.html)|Optional user provided props to override the default props for Secrets Manager|
  |existingSecretObj?|[`secretsmanager.Secret`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_secretsmanager.Secret.html)|Existing instance of Secrets Manager Secret object, If this is set then the secretProps is ignored|
  |grantWriteAccess?|`boolean`|Optional write access to the Secret for the Fargate service (Read-Only by default)
  |secretEnvironmentVariableName?|`string`|Optional Name for the container environment variable set to the ARN of the secret. Default: SECRET_ARN |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or provided by the client) |
  | service | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The AWS Fargate service used by this construct (whether created by this construct or passed to this construct at initialization) |
  | container | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  |secret|[`secretsmanager.Secret`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_secretsmanager.Secret.html)|Returns an instance of `secretsmanager.Secret` created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Sets up an AWS Fargate service
    * Uses the existing service if provided
    * Creates a new service if none provided.
      * Service will run in isolated subnets if available, then private subnets if available and finally public subnets
    * Adds environment variables to the container with the ARN and Name of the Secrets Manager secret
    * Add permissions to the container IAM role allowing it to publish to the Secrets Manager secret

  * Sets up an Amazon Secrets Manager secret
    * Uses an existing secret if one is provided, otherwise creates a new one
      * (default) random name
      * (default) random value
  * Adds an Interface Endpoint to the VPC for Secrets Manager (the service by default runs in Isolated or Private subnets)
  * Retain the Secret when deleting the CloudFormation stack


pkgId: 3a56562d94b9c44132a727ac2b49097f4945a4616093237aba32b52bbfa6ec4e
name: python-aws-solutions-constructs.aws-fargate-sns
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to Amazon SNS integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-sns-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_sns`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-sns`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargatesns`|

  This AWS Solutions Construct implements an AWS Fargate service that can write to an Amazon SNS topic
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToSns, FargateToSnsProps } from '@aws-solutions-constructs/aws-fargate-sns';
  const constructProps: FargateToSnsProps = {
      publicApi: true,
      ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo"
  };
  new FargateToSns(this, 'test-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_sns import FargateToSns, FargateToSnsProps
  from aws_cdk import (
      Stack
  )
  from constructs import Construct
  FargateToSns(self, 'test_construct',
              public_api=True,
              ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.fargatesns.*;
  new FargateToSns(this, "test_construct", new FargateToSnsProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | boolean | Whether the construct is deploying a private or public API. This has implications for the VPC. |
  | vpcProps? | [ec2.VpcProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  | existingVpc? | [ec2.IVpc](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | clusterProps? | [ecs.ClusterProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | string | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | string | The version of the image to use from the repository. Defaults to 'Latest' |
  | containerDefinitionProps? | [ecs.ContainerDefinitionProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [ecs.FargateTaskDefinitionProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct  (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [ecs.FargateServiceProps | any](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [ecs.FargateService](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  | existingContainerDefinitionObject? | [ecs.ContainerDefinition](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the existingFargateServiceObject |
  |existingTopicObj?|[sns.Topic](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sns.Topic.html)|Existing instance of SNS Topic object, providing both this and `topicProps` will cause an error.|
  |topicProps?|[sns.TopicProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sns.TopicProps.html)|Optional user provided properties to override the default properties for the SNS topic.|
  |topicArnEnvironmentVariableName?|string|Optional Name for the container environment variable set to the ARN of the topic. Default: SNS_TOPIC_ARN |
  |topicNameEnvironmentVariableName?|string|Optional Name for the container environment variable set to the name of the topic. Default: SNS_TOPIC_NAME |
  |enableEncryptionWithCustomerManagedKey?|`boolean`|If no key is provided, this flag determines whether the SNS Topic is encrypted with a new CMK or an AWS managed key. This flag is ignored if any of the following are defined: topicProps.masterKey, encryptionKey or encryptionKeyProps.|
  |encryptionKey?|[`kms.Key`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html)|An optional, imported encryption key to encrypt the SNS Topic with.|
  |encryptionKeyProps?|[`kms.KeyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html#construct-props)|Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SNS Topic with.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [ec2.IVpc](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or provided by the client) |
  | service | [ecs.FargateService](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The AWS Fargate service used by this construct (whether created by this construct or passed to this construct at initialization) |
  | container | [ecs.ContainerDefinition](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  |snsTopic|[`sns.Topic`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sns.Topic.html)|Returns an instance of the SNS topic created by the pattern.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Sets up an AWS Fargate service
    * Uses the existing service if provided
    * Creates a new service if none provided.
      * Service will run in isolated subnets if available, then private subnets if available and finally public subnets
    * Adds environment variables to the container with the ARN and Name of the SNS topic
    * Add permissions to the container IAM role allowing it to publish to the SNS topic

  * Sets up an Amazon SNS topic
    * Uses an existing topic if one is provided, otherwise creates a new one
  * Adds an Interface Endpoint to the VPC for SNS (the service by default runs in Isolated or Private subnets)


pkgId: 495520e89ea2f5d48aa4f32da74c1c53d0bd4eca720ff4e7dbd60a61c3a4103d
name: python-aws-solutions-constructs.aws-fargate-ssmstringparameter
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to AWS SSM Parameter Store Integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-ssmstringparameter-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_ssmstringparameter`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-ssmstringparameter`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargatessmstringparameter`|

  This AWS Solutions Construct implements an AWS Fargate service that can read/write to an AWS Systems Manager String Parameter
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToSsmstringparameter, FargateToSsmstringparameterProps } from '@aws-solutions-constructs/aws-fargate-ssmstringparameter';
  const constructProps: FargateToSsmstringparameterProps = {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
    stringParameterProps: { stringValue: "test-string-value" }
  };
  new FargateToSsmstringparameter(stack, 'test-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_ssmstringparameter import FargateToSsmstringparameter, FargateToSsmstringparameterProps
  from aws_cdk import (
      Stack,
      aws_ssm as ssm
  )
  from constructs import Construct
  FargateToSsmstringparameter(self, 'test_construct',
              public_api=True,
              ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
              string_parameter_props=ssm.StringParameterProps(
                string_value="test-string-value"))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.ssm.*;
  import software.amazon.awsconstructs.services.fargatessmstringparameter.*;
  new FargateToSsmstringparameter(this, "test-construct", new FargateToSsmstringparameterProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .stringParameterProps(new StringParameterProps.Builder()
                          .stringValue("test-string-value")
                          .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | `boolean` | Whether the construct is deploying a private or public API. This has implications for the VPC. |
  | vpcProps? | [`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  | existingVpc? | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | clusterProps? | [`ecs.ClusterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | `string` | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | `string` | The version of the image to use from the repository. Defaults to 'Latest' |
  | containerDefinitionProps? | [`ecs.ContainerDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [`ecs.FargateTaskDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct  (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [`ecs.FargateServiceProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  | existingFargateServiceObject? | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  | existingContainerDefinitionObject? | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the existingFargateServiceObject |
  |existingStringParameterObj?|[`ssm.StringParameter`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ssm.StringParameter.html)|Existing instance of SSM String parameter object, providing both this and `stringParameterProps` will cause an error|
  |stringParameterProps?|[`ssm.StringParameterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ssm.StringParameterProps.html)|Optional user provided props to override the default props for SSM String parameter. If existingStringParameterObj is not set stringParameterProps is required. The only supported [`ssm.StringParameterProps.type`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ssm.StringParameterProps.html#type) is [`STRING`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ssm.ParameterType.html#string) if a different value is provided it will be overridden.|
  |stringParameterPermissions?|`string`|Optional SSM String parameter permissions to grant to the Fargate service. One of the following may be specified: "Read", "ReadWrite".
  |stringParameterEnvironmentVariableName?|`string`|Optional Name for the container environment variable set to the SSM parameter name. Default: SSM_STRING_PARAMETER_NAME |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or provided by the client) |
  | service | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The AWS Fargate service used by this construct (whether created by this construct or passed to this construct at initialization) |
  | container | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  |stringParameter|[`ssm.StringParameter`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ssm.StringParameter.html)|Returns an instance of `ssm.StringParameter` created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Sets up an AWS Fargate service
    * Uses the existing service if provided
    * Creates a new service if none provided.
      * Service will run in isolated subnets if available, then private subnets if available and finally public subnets
    * Adds environment variables to the container with the ARN and Name of the SSM parameter
    * Add permissions to the container IAM role allowing it to read/write to the SSM parameter

  * Sets up an AWS SSM String Parameter
    * Uses an existing parameter if one is provided, otherwise creates a new one
  * Adds an Interface Endpoint to the VPC for SSM parameter (the service by default runs in Isolated or Private subnets)


pkgId: 8dac17cc20f1124df51028a0bdd5d6de08b62907f052bffaa759b5afb7aa2db9
name: python-aws-solutions-constructs.aws-fargate-stepfunctions
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Fargate to Amazon Step Functions integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-fargate-stepfunctions-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_fargate_stepfunctions`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-fargate-stepfunctions`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.fargatestepfunctions`|

  This AWS Solutions Construct implements an AWS Fargate service that can execute an AWS Step Functions state machine
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { FargateToStepfunctions, FargateToStepfunctionsProps } from '@aws-solutions-constructs/aws-fargate-stepfunctions';
  import * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions';
  const startState = new stepfunctions.Pass(this, 'StartState');
  const constructProps: FargateToStepfunctionsProps = {
    publicApi: true,
    ecrRepositoryArn: "arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
    stateMachineProps: {
        definition: startState
      }
  };
  new FargateToStepfunctions(this, 'test-construct', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_fargate_stepfunctions import FargateToStepfunctions, FargateToStepfunctionsProps
  from aws_cdk import (
      aws_stepfunctions as stepfunctions,
      Stack
  )
  from constructs import Construct
  start_state = stepfunctions.Pass(self, 'start_state')
  FargateToStepfunctions(self, 'test_construct',
              public_api=True,
              ecr_repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo",
              state_machine_props=stepfunctions.StateMachineProps(
                definition=start_state))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.fargatestepfunctions.*;
  import software.amazon.awscdk.services.stepfunctions.*;
  start_state = stepfunctions.Pass(self, 'start_state')
  new FargateToStepfunctions(this, "test-construct", new FargateToStepfunctionsProps.Builder()
          .publicApi(true)
          .ecrRepositoryArn("arn:aws:ecr:us-east-1:123456789012:repository/your-ecr-repo")
          .stateMachineProps(new StateMachineProps.Builder()
                          .definition(startState)
                          .build()
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | publicApi | `boolean` | Whether the construct is deploying a private or public API. This has implications for the VPC. |
  | vpcProps? | [`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html) | Optional custom properties for a VPC the construct will create. This VPC will be used by any Private Hosted Zone the construct creates (that's why loadBalancerProps and privateHostedZoneProps can't include a VPC). Providing both this and existingVpc is an error. |
  | existingVpc? | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | An existing VPC in which to deploy the construct. Providing both this and vpcProps is an error. If the client provides an existing load balancer and/or existing Private Hosted Zone, those constructs must exist in this VPC. |
  | clusterProps? | [`ecs.ClusterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ClusterProps.html) | Optional properties to create a new ECS cluster. To provide an existing cluster, use the cluster attribute of fargateServiceProps. |
  | ecrRepositoryArn? | `string` | The arn of an ECR Repository containing the image to use to generate the containers. Either this or the image property of containerDefinitionProps must be provided. format: arn:aws:ecr:*region*:*account number*:repository/*Repository Name* |
  | ecrImageVersion? | `string` | The version of the image to use from the repository. Defaults to 'Latest' |
  | containerDefinitionProps? | [`ecs.ContainerDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinitionProps.html) | Optional props to define the container created for the Fargate Service (defaults found in fargate-defaults.ts) |
  | fargateTaskDefinitionProps? | [`ecs.FargateTaskDefinitionProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinitionProps.html) | Optional props to define the Fargate Task Definition for this construct  (defaults found in fargate-defaults.ts) |
  | fargateServiceProps? | [`ecs.FargateServiceProps \| any`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateServiceProps.html) | Optional values to override default Fargate Task definition properties (fargate-defaults.ts). The construct will default to launching the service is the most isolated subnets available (precedence: Isolated, Private and Public). Override those and other defaults here. |
  |existingFargateServiceObject? | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | A Fargate Service already instantiated (probably by another Solutions Construct). If this is specified, then no props defining a new service can be provided, including: ecrImageVersion, containerDefinitionProps, fargateTaskDefinitionProps, ecrRepositoryArn, fargateServiceProps, clusterProps |
  |existingContainerDefinitionObject? | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | A container definition already instantiated as part of a Fargate service. This must be the container in the existingFargateServiceObject |
  |stateMachineProps|[`sfn.StateMachineProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.StateMachineProps.html)|User provided props to override the default props for sfn.StateMachine.|
  | createCloudWatchAlarms? | `boolean`|Whether to create recommended CloudWatch alarms. Default is true.|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|Optional user provided props to override the default props for for the CloudWatchLogs LogGroup.|
  |stateMachineEnvironmentVariableName?|`string`|Optional Name for the container environment variable set to the ARN of the state machine. Default: STATE_MACHINE_ARN |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  | vpc | [`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html) | The VPC used by the construct (whether created by the construct or provided by the client) |
  | service | [`ecs.FargateService`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.FargateService.html) | The AWS Fargate service used by this construct (whether created by this construct or passed to this construct at initialization) |
  | container | [`ecs.ContainerDefinition`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.ContainerDefinition.html) | The container associated with the AWS Fargate service in the service property. |
  | stateMachine| [`sfn.StateMachine`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.StateMachine.html)|Returns an instance of `sfn.StateMachine` created by the construct.|
  | stateMachineLogGroup|[`logs.ILogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.ILogGroup.html)|Returns an instance of the `logs.ILogGroup` created by the construct for StateMachine.|
  | cloudwatchAlarms? | [`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns a list of `cloudwatch.Alarm` created by the construct.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Sets up an AWS Fargate service
    * Uses the existing service if provided
    * Creates a new service if none provided.
      * Service will run in isolated subnets if available, then private subnets if available and finally public subnets
  * Adds an environment variable to the container containing the ARN of the state machine
    * Default name is `STATE_MACHINE_ARN`
  * Add permissions to the container IAM role allowing it to start the execution of a state machine

  * Sets up an AWS Step Functions state machine
    * Uses an existing state machine if one is provided, otherwise creates a new one
  * Adds an Interface Endpoint to the VPC for Step Functions (the service by default runs in Isolated or Private subnets)
  * Enables CloudWatch logging


pkgId: a9d9199dfc8b0d36a2b962cc1d9b75391d2e1d80628b4b445a3e68155a81ba2d
name: python-aws-solutions-constructs.aws-iot-kinesisfirehose-s3
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS IoT to AWS Kinesis Firehose to AWS S3 integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-iot-kinesisfirehose-s3-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_iot_kinesisfirehose_s3`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-iot-kinesisfirehose-s3`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.iotkinesisfirehoses3`|

  This AWS Solutions Construct implements an AWS IoT MQTT topic rule to send data to an Amazon Kinesis Data Firehose delivery stream connected to an Amazon S3 bucket.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { IotToKinesisFirehoseToS3Props, IotToKinesisFirehoseToS3 } from '@aws-solutions-constructs/aws-iot-kinesisfirehose-s3';
  const constructProps: IotToKinesisFirehoseToS3Props = {
      iotTopicRuleProps: {
          topicRulePayload: {
              ruleDisabled: false,
              description: "Persistent storage of connected vehicle telematics data",
              sql: "SELECT * FROM 'connectedcar/telemetry/#'",
              actions: []
          }
      }
  };
  new IotToKinesisFirehoseToS3(this, 'test-iot-firehose-s3', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_iot_kinesisfirehose_s3 import IotToKinesisFirehoseToS3Props, IotToKinesisFirehoseToS3
  from aws_cdk import (
      aws_iot as iot,
      Stack
  )
  from constructs import Construct
  IotToKinesisFirehoseToS3(self, 'test_iot_firehose_s3',
                          iot_topic_rule_props=iot.CfnTopicRuleProps(
                              topic_rule_payload=iot.CfnTopicRule.TopicRulePayloadProperty(
                                  rule_disabled=False,
                                  description="Persistent storage of connected vehicle telematics data",
                                  sql="SELECT * FROM 'connectedcar/telemetry/#'",
                                  actions=[]
                              )
                          ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.iot.*;
  import software.amazon.awscdk.services.iot.CfnTopicRule.TopicRulePayloadProperty;
  import software.amazon.awsconstructs.services.iotkinesisfirehoses3.*;
  new IotToKinesisFirehoseToS3(this, "test-iot-firehose-s3", new IotToKinesisFirehoseToS3Props.Builder()
          .iotTopicRuleProps(new CfnTopicRuleProps.Builder()
                  .topicRulePayload(new TopicRulePayloadProperty.Builder()
                          .ruleDisabled(false)
                          .description("Persistent storage of connected vehicle telematics data")
                          .sql("SELECT * FROM 'connectedcar/telemetry/#'")
                          .actions(List.of())
                          .build())
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |iotTopicRuleProps|[`iot.CfnTopicRuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRuleProps.html)|User provided CfnTopicRuleProps to override the defaults|
  |kinesisFirehoseProps?|[`kinesisfirehose.CfnDeliveryStreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStreamProps.html)|Optional user provided props to override the default props for Kinesis Firehose Delivery Stream|
  |existingBucketObj?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Existing instance of S3 Bucket object, providing both this and `bucketProps` will cause an error.|
  |bucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|User provided props to override the default props for the S3 Bucket. If this is provided, then also providing bucketProps is an error. |
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|User provided props to override the default props for for the CloudWatchLogs LogGroup.|
  |loggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Logging Bucket.|
  |logS3AccessLogs? | boolean|Whether to turn on Access Logging for the S3 bucket. Creates an S3 bucket with associated storage costs for the logs. Enabling Access Logging is a best practice. default - true|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |kinesisFirehose|[`kinesisfirehose.CfnDeliveryStream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStream.html)|Returns an instance of kinesisfirehose.CfnDeliveryStream created by the construct|
  |s3Bucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct|
  |s3LoggingBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct as the logging bucket for the primary bucket.|
  |iotTopicRule|[`iot.CfnTopicRule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRule.html)|Returns an instance of iot.CfnTopicRule created by the construct|
  |iotActionsRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for IoT Rule|
  |kinesisFirehoseRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for Kinesis Data Firehose delivery stream|
  |kinesisFirehoseLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the LogGroup created by the construct for Kinesis Data Firehose delivery stream|
  |s3BucketInterface|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Returns an instance of s3.IBucket created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for Amazon IoT

  * Enable CloudWatch logging for Kinesis Firehose
  * Configure least privilege access IAM role for Amazon Kinesis Firehose

  * Configure Access logging for S3 Bucket
  * Enable server-side encryption for S3 Bucket using AWS managed KMS Key
  * Enforce encryption of data in transit
  * Turn on the versioning for S3 Bucket
  * Don't allow public access for S3 Bucket
  * Retain the S3 Bucket when deleting the CloudFormation stack
  * Applies Lifecycle rule to move noncurrent object versions to Glacier storage after 90 days


pkgId: 2665f209732a1b6c46f57a0531cef5954f738daa656fba1e1d1e781c1bdb4ca4
name: python-aws-solutions-constructs.aws-iot-kinesisstreams
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK Constructs for AWS IoT to AWS Kinesis Data Stream.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-iot-kinesisstreams-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_iot_kinesisstreams`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-iot-kinesisstreams`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.iotkinesisstreams`|

  This AWS Solutions Construct implements an AWS IoT MQTT topic rule to send data to an Amazon Kinesis Data Stream.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { IotToKinesisStreamsProps, IotToKinesisStreams } from '@aws-solutions-constructs/aws-iot-kinesisstreams';
  const constructProps: IotToKinesisStreamsProps = {
    iotTopicRuleProps: {
      topicRulePayload: {
        ruleDisabled: false,
        description: "Sends data to kinesis data stream",
        sql: "SELECT * FROM 'solutions/construct'",
        actions: []
      }
    }
  };
  new IotToKinesisStreams(this, 'test-iot-kinesisstreams', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_iot_kinesisstreams import IotToKinesisStreamsProps, IotToKinesisStreams
  from aws_cdk import (
      aws_iot as iot,
      Stack
  )
  from constructs import Construct
  IotToKinesisStreams(self, 'test-iot-kinesisstreams',
                      iot_topic_rule_props=iot.CfnTopicRuleProps(
                          topic_rule_payload=iot.CfnTopicRule.TopicRulePayloadProperty(
                              rule_disabled=False,
                              description="Sends data to kinesis data stream",
                              sql="SELECT * FROM 'solutions/construct'",
                              actions=[]
                          )
                      ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.iot.*;
  import software.amazon.awscdk.services.iot.CfnTopicRule.TopicRulePayloadProperty;
  import software.amazon.awsconstructs.services.iotkinesisstreams.*;
  new IotToKinesisStreams(this, "test-iot-kinesisstreams", new IotToKinesisStreamsProps.Builder()
          .iotTopicRuleProps(new CfnTopicRuleProps.Builder()
                  .topicRulePayload(new TopicRulePayloadProperty.Builder()
                          .ruleDisabled(false)
                          .description("Sends data to kinesis data stream")
                          .sql("SELECT * FROM 'solutions/construct'")
                          .actions(List.of())
                          .build())
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |iotTopicRuleProps|[`iot.CfnTopicRuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRuleProps.html)|User provided CfnTopicRuleProps to override the defaults|
  |existingStreamObj?|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Existing instance of Kinesis Stream, providing both this and `kinesisStreamProps` will cause an error.|
  |kinesisStreamProps?|[`kinesis.StreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.StreamProps.html)|Optional user-provided props to override the default props for the Kinesis data stream, providing both this and `existingStreamObj` will cause an error|
  |createCloudWatchAlarms|`boolean`|Whether to create recommended CloudWatch alarms for Kinesis Data Stream. Default value is set to `true`|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |iotTopicRule|[`iot.CfnTopicRule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRule.html)|Returns an instance of iot.CfnTopicRule created by the construct|
  |iotActionsRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for IoT Rule|
  |kinesisStream|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Returns an instance of the Kinesis stream created by the construct.|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns an array of recommended CloudWatch Alarms created by the construct for Kinesis Data stream|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for Amazon IoT Rule

  * Configure recommended CloudWatch Alarms for Amazon Kinesis Data Stream
  * Configure least privilege access IAM role for Amazon Kinesis Data Stream


pkgId: 490bfa71e627a642d9dd9afc69406abdc21a6aab918a97d54a40ed64cb0a2692
name: python-aws-solutions-constructs.aws-iot-lambda
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS IoT to AWS Lambda integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-iot-lambda-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_iot_lambda`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-iot-lambda`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.iotlambda`|

  This AWS Solutions Construct implements an AWS IoT MQTT topic rule and an AWS Lambda function pattern.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { IotToLambdaProps, IotToLambda } from '@aws-solutions-constructs/aws-iot-lambda';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  const constructProps: IotToLambdaProps = {
    lambdaFunctionProps: {
      code: lambda.Code.fromAsset(`lambda`),
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler'
    },
    iotTopicRuleProps: {
      topicRulePayload: {
        ruleDisabled: false,
        description: "Processing of DTC messages from the AWS Connected Vehicle Solution.",
        sql: "SELECT * FROM 'connectedcar/dtc/#'",
        actions: []
      }
    }
  };
  new IotToLambda(this, 'test-iot-lambda-integration', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_iot_lambda import IotToLambdaProps, IotToLambda
  from aws_cdk import (
      aws_iot as iot,
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct
  IotToLambda(self, 'test_iot_lambda',
              lambda_function_props=_lambda.FunctionProps(
                  code=_lambda.Code.from_asset('lambda'),
                  runtime=_lambda.Runtime.PYTHON_3_9,
                  handler='index.handler'
              ),
              iot_topic_rule_props=iot.CfnTopicRuleProps(
                  topic_rule_payload=iot.CfnTopicRule.TopicRulePayloadProperty(
                      rule_disabled=False,
                      description="Sends data to kinesis data stream",
                      sql="SELECT * FROM 'solutions/construct'",
                      actions=[]
                  )
              ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awscdk.services.iot.*;
  import software.amazon.awscdk.services.iot.CfnTopicRule.TopicRulePayloadProperty;
  import software.amazon.awsconstructs.services.iotlambda.*;
  new IotToLambda(this, "test-iot-lambda-integration", new IotToLambdaProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .iotTopicRuleProps(new CfnTopicRuleProps.Builder()
                  .topicRulePayload(new TopicRulePayloadProperty.Builder()
                          .ruleDisabled(false)
                          .description("Processing of DTC messages from the AWS Connected Vehicle Solution.")
                          .sql("SELECT * FROM 'connectedcar/dtc/#'")
                          .actions(List.of())
                          .build())
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |iotTopicRuleProps?|[`iot.CfnTopicRuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRuleProps.html)|User provided CfnTopicRuleProps to override the defaults|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |iotTopicRule|[`iot.CfnTopicRule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRule.html)|Returns an instance of iot.CfnTopicRule created by the construct|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of lambda.Function created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for Amazon IoT

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: f65160bedb4e79ef078ad95963708bddf36234e1c0795971b5af756d002792d4
name: python-aws-solutions-constructs.aws-iot-lambda-dynamodb
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS IoT to AWS Lambda to AWS DyanmoDB integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-iot-lambda-dynamodb-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_iot_lambda_dynamodb`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-iot-lambda-dynamodb`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.iotlambdadynamodb`|

  This AWS Solutions Construct implements an AWS IoT topic rule, an AWS Lambda function and Amazon DynamoDB table with the least privileged permissions.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { IotToLambdaToDynamoDBProps, IotToLambdaToDynamoDB } from '@aws-solutions-constructs/aws-iot-lambda-dynamodb';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  const constructProps: IotToLambdaToDynamoDBProps = {
    lambdaFunctionProps: {
        code: lambda.Code.fromAsset(`lambda`),
        runtime: lambda.Runtime.NODEJS_16_X,
        handler: 'index.handler'
    },
    iotTopicRuleProps: {
        topicRulePayload: {
            ruleDisabled: false,
            description: "Processing of DTC messages from the AWS Connected Vehicle Solution.",
            sql: "SELECT * FROM 'connectedcar/dtc/#'",
            actions: []
        }
    }
  };
  new IotToLambdaToDynamoDB(this, 'test-iot-lambda-dynamodb-stack', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_iot_lambda_dynamodb import IotToLambdaToDynamoDB
  from aws_cdk import (
      aws_iot as iot,
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct
  IotToLambdaToDynamoDB(self, 'test-iot-lambda-dynamodb-stack',
              lambda_function_props=_lambda.FunctionProps(
                  code=_lambda.Code.from_asset('lambda'),
                  runtime=_lambda.Runtime.PYTHON_3_9,
                  handler='index.handler'
              ),
              iot_topic_rule_props=iot.CfnTopicRuleProps(
                  topic_rule_payload=iot.CfnTopicRule.TopicRulePayloadProperty(
                      rule_disabled=False,
                      description="Processing of DTC messages from the AWS Connected Vehicle Solution.",
                      sql="SELECT * FROM 'connectedcar/dtc/#'",
                      actions=[]
                  )
              ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awscdk.services.iot.*;
  import software.amazon.awscdk.services.iot.CfnTopicRule.TopicRulePayloadProperty;
  import software.amazon.awsconstructs.services.iotlambdadynamodb.*;
  new IotToLambdaToDynamoDB(this, "test-iot-lambda-dynamodb-stack", new IotToLambdaToDynamoDBProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .iotTopicRuleProps(new CfnTopicRuleProps.Builder()
                  .topicRulePayload(new TopicRulePayloadProperty.Builder()
                          .ruleDisabled(false)
                          .description("Processing of DTC messages from the AWS Connected Vehicle Solution.")
                          .sql("SELECT * FROM 'connectedcar/dtc/#'")
                          .actions(List.of())
                          .build())
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |iotTopicRuleProps|[`iot.CfnTopicRuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRuleProps.html)|User provided props to override the default props|
  |dynamoTableProps?|[`dynamodb.TableProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.TableProps.html)|Optional user provided props to override the default props for DynamoDB Table|
  |tablePermissions?|`string`|Optional table permissions to grant to the Lambda function. One of the following may be specified: `All`, `Read`, `ReadWrite`, `Write`.|
  |existingTableObj?|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Existing instance of DynamoDB table object, providing both this and `dynamoTableProps` will cause an error.|
  |tableEnvironmentVariableName?|`string`|Optional Name for the Lambda function environment variable set to the name of the DynamoDB table. Default: DDB_TABLE_NAME |
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources and a Gateway Endpoint will be created in the VPC for Amazon DynamoDB. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user-provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the pattern, so any values for those properties supplied here will be overridden. If `deployVpc` is not `true` then this property will be ignored.|
  |deployVpc?|`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |iotTopicRule|[`iot.CfnTopicRule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRule.html)|Returns an instance of iot.CfnTopicRule created by the construct|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of lambda.Function created by the construct|
  |dynamoTable|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Returns an instance of dynamodb.Table created by the construct|
  |vpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface on the VPC used by the pattern (if any). This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for Amazon IoT

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)

  * Set the billing mode for DynamoDB Table to On-Demand (Pay per request)
  * Enable server-side encryption for DynamoDB Table using AWS managed KMS Key
  * Creates a partition key called 'id' for DynamoDB Table
  * Retain the Table when deleting the CloudFormation stack
  * Enable continuous backups and point-in-time recovery


pkgId: 8bac4ec7ac5cc7b6ee899448ff788a84df0b9ca9fbe7d06cdcfb6fc2cf8c0cac
name: python-aws-solutions-constructs.aws-iot-sqs
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK Constructs for AWS IoT to AWS SQS integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-iot-sqs-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_iot_sqs`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-iot-sqs`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.iotsqs`|

  This AWS Solutions Construct implements an AWS IoT MQTT topic rule and an AWS SQS Queue pattern.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { IotToSqsProps, IotToSqs } from '@aws-solutions-constructs/aws-iot-sqs';
  const constructProps: IotToSqsProps = {
    iotTopicRuleProps: {
      topicRulePayload: {
        ruleDisabled: false,
        description: "Testing the IotToSqs Pattern",
        sql: "SELECT * FROM 'iot/sqs/#'",
        actions: []
      }
    }
  };
  new IotToSqs(this, 'test-iot-sqs-integration', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_iot_sqs import IotToSqs
  from aws_cdk import (
      aws_iot as iot,
      Stack
  )
  from constructs import Construct
  IotToSqs(self, 'test_iot_sqs',
      iot_topic_rule_props=iot.CfnTopicRuleProps(
          topic_rule_payload=iot.CfnTopicRule.TopicRulePayloadProperty(
              rule_disabled=False,
              description="Testing the IotToSqs Pattern",
              sql="SELECT * FROM 'iot/sqs/#'",
              actions=[]
          )
      ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import java.util.List;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.iot.*;
  import software.amazon.awscdk.services.iot.CfnTopicRule.TopicRulePayloadProperty;
  import software.amazon.awsconstructs.services.iotsqs.*;
  new IotToSqs(this, "test_iot_sqs", new IotToSqsProps.Builder()
          .iotTopicRuleProps(new CfnTopicRuleProps.Builder()
                  .topicRulePayload(new TopicRulePayloadProperty.Builder()
                          .ruleDisabled(false)
                          .description("Testing the IotToSqs Pattern")
                          .sql("SELECT * FROM 'iot/sqs/#'")
                          .actions(List.of())
                          .build())
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |iotTopicRuleProps|[`iot.CfnTopicRuleProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRuleProps.html)|User provided CfnTopicRuleProps to override the defaults|
  |existingQueueObj?|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|Existing instance of SQS queue object, providing both this and `queueProps` will cause an error.|
  |queueProps?|[`sqs.QueueProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.QueueProps.html)|User provided props to override the default props for the SQS queue.|
  |deadLetterQueueProps?|[`sqs.QueueProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.QueueProps.html)|Optional user provided properties for the dead letter queue.|
  |deployDeadLetterQueue?|`boolean`|Whether to deploy a secondary queue to be used as a dead letter queue. Default `true`.|
  |maxReceiveCount?|`number`|The number of times a message can be unsuccessfully dequeued before being moved to the dead-letter queue. Required field if `deployDeadLetterQueue`=`true`.|
  |enableEncryptionWithCustomerManagedKey?|`boolean`|If no key is provided, this flag determines whether the queue is encrypted with a new CMK or an AWS managed key. This flag is ignored if any of the following are defined: queueProps.encryptionMasterKey, encryptionKey or encryptionKeyProps.|
  |encryptionKey?|[`kms.Key`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html)|An optional, imported encryption key to encrypt the SQS Queue with.|
  |encryptionKeyProps?|[`kms.KeyProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html#construct-props)|Optional user provided properties to override the default properties for the KMS encryption key used to encrypt the SQS queue with.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |encryptionKey?|[`kms.Key`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kms.Key.html)|Returns an instance of `kms.Key` used for the SQS queue.|
  |iotActionsRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of `iam.Role` created by the construct, which allows IoT to publish messages to the SQS Queue|
  |sqsQueue|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|Returns an instance of `sqs.Queue` created by the construct|
  |deadLetterQueue?|[`sqs.Queue`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html)|Returns an instance of the dead-letter SQS queue created by the pattern.|
  |iotTopicRule|[`iot.CfnTopicRule`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iot.CfnTopicRule.html)|Returns an instance of `iot.CfnTopicRule` created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure an IoT Rule to send messages to the SQS Queue

  * Configure least privilege access IAM role for Amazon IoT to be able to publish messages to the SQS Queue

  * Deploy a dead-letter queue for the source queue.
  * Enable server-side encryption for the source queue using a customer-managed AWS KMS key.
  * Enforce encryption of data in transit.


pkgId: 098a6d414384c03c873e66e5da4c9f98f05c96c86b295a3f4affe215805b9812
name: python-aws-solutions-constructs.aws-kinesis-firehose-s3
arch: src
version: 2.72.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-kinesis-firehose-s3-2.72.0-1.src.rpm
checksum_type: sha256
summary:
  CDK constructs for defining an interaction between an Amazon Kinesis Data Firehose delivery stream and an Amazon S3 bucket.

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_kinesis_firehose_s3`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-kinesisfirehose-s3`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.kinesisfirehoses3`|

  This AWS Solutions Construct implements an Amazon Kinesis Data Firehose delivery stream connected to an Amazon S3 bucket.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { KinesisFirehoseToS3 } from '@aws-solutions-constructs/aws-kinesisfirehose-s3';
  new KinesisFirehoseToS3(this, 'test-firehose-s3', {});
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_kinesis_firehose_s3 import KinesisFirehoseToS3
  from aws_cdk import Stack
  from constructs import Construct
  KinesisFirehoseToS3(self, 'test_firehose_s3')
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.kinesisfirehoses3.*;
  new KinesisFirehoseToS3(this, "test_firehose_s3", new KinesisFirehoseToS3Props.Builder()
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |bucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Bucket.|
  |existingBucketObj?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Optional existing instance of S3 Bucket. If this is provided, then also providing bucketProps is an error. |
  |existingLoggingBucketObj?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Optional existing instance of logging S3 Bucket for the S3 Bucket created by the pattern.|
  |kinesisFirehoseProps?|[`kinesisfirehose.CfnDeliveryStreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStreamProps.html)|`any`|Optional user provided props to override the default props for Kinesis Firehose Delivery Stream.|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|Optional user provided props to override the default props for for the CloudWatchLogs LogGroup.|
  |loggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Logging Bucket.|
  |logS3AccessLogs?| boolean|Whether to turn on Access Logging for the S3 bucket. Creates an S3 bucket with associated storage costs for the logs. Enabling Access Logging is a best practice. default - true|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |kinesisFirehose|[`kinesisfirehose.CfnDeliveryStream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStream.html)|Returns an instance of kinesisfirehose.CfnDeliveryStream created by the construct|
  |kinesisFirehoseLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the logs.LogGroup created by the construct for Kinesis Data Firehose delivery stream|
  |kinesisFirehoseRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for Kinesis Data Firehose delivery stream|
  |s3Bucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct|
  |s3LoggingBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct as the logging bucket for the primary bucket|
  |s3BucketInterface|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Returns an instance of s3.IBucket created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Enable CloudWatch logging for Kinesis Firehose
  * Configure least privilege access IAM role for Amazon Kinesis Firehose

  * Configure Access logging for S3 Bucket
  * Enable server-side encryption for S3 Bucket using AWS managed KMS Key
  * Enforce encryption of data in transit
  * Turn on the versioning for S3 Bucket
  * Don't allow public access for S3 Bucket
  * Retain the S3 Bucket when deleting the CloudFormation stack
  * Applies Lifecycle rule to move noncurrent object versions to Glacier storage after 90 days


pkgId: 45affc4aee35c726cf0538d68143db38678268c9192bfbf0efde56d94507e246
name: python-aws-solutions-constructs.aws-kinesis-streams-gluejob
arch: src
version: 2.73.0
epoch: 0
release: 1
summary: CDK Constructs for streaming data from AWS Kinesis Data Stream for Glue ETL custom Job processing
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-kinesis-streams-gluejob-2.73.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**: | <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span> |
  | :--------------------------- | :------------------------------------------------------------------------------------------------ |
  <div style="height:8px"></div>
  | **Language**                                                                                   | **Package**                                                    |
  | :--------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
  | ![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python             | `aws_solutions_constructs.aws_kinesis_streams_gluejob`         |
  | ![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript | `@aws-solutions-constructs/aws-kinesisstreams-gluejob`         |
  | ![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java                   | `software.amazon.awsconstructs.services.kinesisstreamsgluejob` |

  This AWS Solutions Construct deploys a Kinesis Stream and configures a AWS Glue Job to perform custom ETL transformation with the appropriate resources/properties for interaction and security. It also creates an S3 bucket where the python script for the AWS Glue Job can be uploaded.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import * as glue from "@aws-cdk/aws-glue";
  import * as s3assets from "@aws-cdk/aws-s3-assets";
  import { KinesisstreamsToGluejob } from "@aws-solutions-constructs/aws-kinesisstreams-gluejob";
  const fieldSchema: glue.CfnTable.ColumnProperty[] = [
    {
      name: "id",
      type: "int",
      comment: "Identifier for the record",
    },
    {
      name: "name",
      type: "string",
      comment: "Name for the record",
    },
    {
      name: "address",
      type: "string",
      comment: "Address for the record",
    },
    {
      name: "value",
      type: "int",
      comment: "Value for the record",
    },
  ];
  const customEtlJob = new KinesisstreamsToGluejob(this, "CustomETL", {
    glueJobProps: {
      command: {
        name: "gluestreaming",
        pythonVersion: "3",
      },
    },
    fieldSchema: fieldSchema,
    etlCodeAsset: new s3assets.Asset(this, "ScriptLocation", {
      path: `${__dirname}/../etl/transform.py`,
    }),
  });
  ```

  | **Name**            | **Type**                                                                                                                      | **Description**                                                                                                  |
  | :------------------ | :---------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
  | existingStreamObj?  | [`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)                          | Existing instance of Kinesis Stream, providing both this and `kinesisStreamProps` will cause an error.           |
  | kinesisStreamProps? | [`kinesis.StreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.StreamProps.html)                | Optional user-provided props to override the default props for the Kinesis stream.                               |
  | glueJobProps?       | [`cfnJob.CfnJobProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnJobProps.html)                    | User provided props to override the default props for the AWS Glue Job.                                          |
  | existingGlueJob?    | [`cfnJob.CfnJob`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnJob.html)                              | Existing instance of AWS Glue Job, providing both this and `glueJobProps` will cause an error.                   |
  | fieldSchema?        | [`CfnTable.ColumnProperty[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnTable.ColumnProperty.html) | User provided schema structure to create an AWS Glue Table.                                                      |
  | existingTable?      | [`CfnTable`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnTable.html)                                 | Existing instance of AWS Glue Table. If this is set, tableProps and fieldSchema are ignored.                     |
  | tableProps?         | [`CfnTableProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.TableProps.html)                          | User provided AWS Glue Table props to override default props used to create a Glue Table.                        |
  | existingDatabase?   | [`CfnDatabase`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnDatabase.html)                           | Existing instance of AWS Glue Database. If this is set, then databaseProps is ignored.                           |
  | databaseProps?      | [`CfnDatabaseProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnDatabaseProps.html)                 | User provided Glue Database Props to override the default props used to create the Glue Database.                |
  | outputDataStore?    | [`SinkDataStoreProps`](#sinkdatastoreprops)                                                                                   | User provided properties for S3 bucket that stores Glue Job output. Current datastore types supported is only S3. |
  |createCloudWatchAlarms?|`boolean`|Whether to create recommended CloudWatch alarms for Kinesis Data Stream. Default value is set to `true`.|
  | etlCodeAsset?       | [s3assets.Asset](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3_assets.Asset.html)                               | User provided instance of the Asset class that represents the ETL code on the local filesystem                    |

  | **Name**                | **Type**                                                                                          | **Description**                                                                                                |
  | :---------------------- | :------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
  | existingS3OutputBucket? | [`Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)           | Existing instance of S3 bucket where the data should be written. Providing both this and `outputBucketProps` will cause an error. |
  | outputBucketProps       | [`BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html) | User provided bucket properties to create the S3 bucket to store the output from the AWS Glue Job.             |
  | datastoreType           | [`SinkStoreType`](#sinkstoretype)                                                                 | Sink data store type.                                                                                          |

  Enumeration of data store types that could include S3, DynamoDB, DocumentDB, RDS or Redshift. Current construct implementation only supports S3, but potential to add other output types in the future.
  | **Name** | **Type** | **Description** |
  | :------- | :------- | --------------- |
  | S3       | `string` | S3 storage type |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |kinesisStream|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Returns an instance of the Kinesis stream created or used by the pattern.|
  |glueJob|[`CfnJob`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnJob.html)|Returns an instance of AWS Glue Job created by the construct.|
  |glueJobRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the IAM Role created by the construct for the Glue Job.|
  |database|[`CfnDatabase`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnDatabase.html)|Returns an instance of AWS Glue Database created by the construct.|
  |table|[`CfnTable`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_glue.CfnTable.html)|Returns an instance of the AWS Glue Table created by the construct|
  |outputBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3-readme.html)|Returns an instance of the output bucket created by the construct for the AWS Glue Job.|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns an array of recommended CloudWatch Alarms created by the construct for Kinesis Data stream.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for Kinesis Stream
  * Enable server-side encryption for Kinesis Stream using AWS Managed KMS Key
  * Deploy best practices CloudWatch Alarms for the Kinesis Stream

  * Create a Glue Security Config that configures encryption for CloudWatch, Job Bookmarks, and S3. CloudWatch and Job Bookmarks are encrypted using AWS Managed KMS Key created for AWS Glue Service. The S3 bucket is configured with SSE-S3 encryption mode
  * Configure service role policies that allow AWS Glue to read from Kinesis Data Streams

  * Create an AWS Glue database. An AWS Glue Table will be added to the database. This table defines the schema for the records buffered in the Amazon Kinesis Data Streams

  * Create an AWS Glue table. The table schema definition is based on the JSON structure of the records buffered in the Amazon Kinesis Data Streams

  * A job execution role that has privileges to 1) read the ETL script from the S3 bucket location, 2) read records from the Kinesis Stream, and 3) execute the Glue Job

  * An S3 bucket to store the output of the ETL transformation. This bucket will be passed as an argument to the created glue job so that it can be used in the ETL script to write data into it

  * A CloudWatch Alarm to report when consumer application is reading data slower than expected
  * A CloudWatch Alarm to report when consumer record processing is falling behind (to avoid risk of data loss due to record expiration)

  ![Architecture Diagram](architecture.png)

  A sample use case which uses this pattern is available under [`use_cases/aws-custom-glue-etl`](https://github.com/awslabs/aws-solutions-constructs/tree/master/source/use_cases/aws-custom-glue-etl).
  © Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.


pkgId: 167762e9b28b7d0e199a490b17c9c438220e6c26ddab476fd633e8ab992f6e22
name: python-aws-solutions-constructs.aws-kinesis-streams-kinesis-firehose-s3
arch: src
version: 2.72.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-kinesis-streams-kinesis-firehose-s3-2.72.0-1.src.rpm
checksum_type: sha256
summary:
  CDK constructs for defining an interaction between an Amazon Kinesis Data Stream (KDS), Amazon Kinesis Data Firehose (KDF) delivery stream and an Amazon S3 bucket.

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_kinesisstreams_kinesisfirehose_s3`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-kinesis-streams-kinesis-firehose-s3`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.kinesisstreamskinesisfirehoses3`|

  This AWS Solutions Construct implements an Amazon Kinesis Data Stream (KDS) connected to Amazon Kinesis Data Firehose (KDF) delivery stream connected to an Amazon S3 bucket.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { KinesisStreamsToKinesisFirehoseToS3 } from '@aws-solutions-constructs/aws-kinesisstreams-kinesisfirehose-s3';
  new KinesisStreamsToKinesisFirehoseToS3(this, 'test-stream-firehose-s3', {});
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_kinesis_streams_kinesis_firehose_s3 import KinesisStreamsToKinesisFirehoseToS3
  from aws_cdk import Stack
  from constructs import Construct
  KinesisStreamsToKinesisFirehoseToS3(self, 'test_stream_firehose_s3')
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awsconstructs.services.kinesisstreamskinesisfirehoses3.*;
  new KinesisStreamsToKinesisFirehoseToS3(this, "test_stream_firehose_s3", new KinesisStreamsToKinesisFirehoseToS3Props.Builder()
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |bucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Bucket.|
  |createCloudWatchAlarms?|`boolean`|Optional whether to create recommended CloudWatch alarms.|
  |existingBucketObj?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Optional existing instance of S3 Bucket object. If this is provided, then also providing bucketProps is an error. |
  |existingLoggingBucketObj?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Optional existing instance of logging S3 Bucket object for the S3 Bucket created by the pattern.|
  |existingStreamObj?|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Optional existing instance of Kinesis Stream, providing both this and `kinesisStreamProps` will cause an error.|
  |kinesisFirehoseProps?|[`kinesisfirehose.CfnDeliveryStreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStreamProps.html)|`any`|Optional user provided props to override the default props for Kinesis Firehose Delivery Stream.|
  |kinesisStreamProps?|[`kinesis.StreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.StreamProps.html)|Optional user-provided props to override the default props for the Kinesis stream.|
  |logGroupProps?|[`logs.LogGroupProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroupProps.html)|Optional user provided props to override the default props for for the CloudWatchLogs LogGroup.|
  |loggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Logging Bucket.|
  |logS3AccessLogs?| boolean|Whether to turn on Access Logging for the S3 bucket. Creates an S3 bucket with associated storage costs for the logs. Enabling Access Logging is a best practice. default - true|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns a list of cloudwatch.Alarm created by the construct|
  |kinesisFirehose|[`kinesisfirehose.CfnDeliveryStream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStream.html)|Returns an instance of kinesisfirehose.CfnDeliveryStream created by the construct|
  |kinesisFirehoseLogGroup|[`logs.LogGroup`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_logs.LogGroup.html)|Returns an instance of the logs.LogGroup created by the construct for Kinesis Data Firehose delivery stream|
  |kinesisFirehoseRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for Kinesis Data Firehose delivery stream|
  |kinesisStream|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Returns an instance of the Kinesis stream created by the pattern|
  |kinesisStreamRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for Kinesis stream|
  |s3Bucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct|
  |s3LoggingBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct as the logging bucket for the primary bucket|
  |s3BucketInterface|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Returns an instance of s3.IBucket created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for Kinesis Stream
  * Enable server-side encryption for Kinesis Stream using AWS Managed KMS Key
  * Deploy best practices CloudWatch Alarms for the Kinesis Stream

  * Enable CloudWatch logging for Kinesis Firehose
  * Configure least privilege access IAM role for Amazon Kinesis Firehose

  * Configure Access logging for S3 Bucket
  * Enable server-side encryption for S3 Bucket using AWS managed KMS Key
  * Enforce encryption of data in transit
  * Turn on the versioning for S3 Bucket
  * Don't allow public access for S3 Bucket
  * Retain the S3 Bucket when deleting the CloudFormation stack
  * Applies Lifecycle rule to move noncurrent object versions to Glacier storage after 90 days


pkgId: cdea23b21ecf2bacd393f587310b69562ffb9c86b5cde92fa3097ca30848b4af
name: python-aws-solutions-constructs.aws-kinesis-streams-lambda
arch: src
version: 2.72.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-kinesis-streams-lambda-2.72.0-1.src.rpm
checksum_type: sha256
summary:
  CDK constructs for defining an interaction between an Amazon Kinesis Data Stream and an AWS Lambda function.

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws-kinesis-streams-lambda`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-kinesisstreams-lambda`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.kinesisstreamslambda`|

  This AWS Solutions Construct deploys a Kinesis Stream and Lambda function with the appropriate resources/properties for interaction and security.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { KinesisStreamsToLambda } from '@aws-solutions-constructs/aws-kinesisstreams-lambda';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new KinesisStreamsToLambda(this, 'KinesisToLambdaPattern', {
    kinesisEventSourceProps: {
      startingPosition: lambda.StartingPosition.TRIM_HORIZON,
      batchSize: 1
    },
    lambdaFunctionProps: {
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset(`lambda`)
    }
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_kinesis_streams_lambda import KinesisStreamsToLambda
  from aws_cdk import (
      aws_lambda as _lambda,
      aws_lambda_event_sources as sources,
      aws_kinesis as kinesis,
      Stack
  )
  from constructs import Construct
  KinesisStreamsToLambda(self, 'KinesisToLambdaPattern',
                          kinesis_event_source_props=sources.KinesisEventSourceProps(
                              starting_position=_lambda.StartingPosition.TRIM_HORIZON,
                              batch_size=1
                          ),
                          lambda_function_props=_lambda.FunctionProps(
                              runtime=_lambda.Runtime.PYTHON_3_9,
                              handler='index.handler',
                              code=_lambda.Code.from_asset(
                                  'lambda')
                          )
                          )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.eventsources.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.kinesisstreamslambda.*;
  new KinesisStreamsToLambda(this, "KinesisToLambdaPattern", new KinesisStreamsToLambdaProps.Builder()
          .kinesisEventSourceProps(new KinesisEventSourceProps.Builder()
                  .startingPosition(StartingPosition.TRIM_HORIZON)
                  .batchSize(1)
                  .build())
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |kinesisStreamProps?|[`kinesis.StreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.StreamProps.html)|Optional user-provided props to override the default props for the Kinesis stream.|
  |existingStreamObj?|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Existing instance of Kinesis Stream, providing both this and `kinesisStreamProps` will cause an error.|
  |kinesisEventSourceProps?|[`aws-lambda-event-sources.KinesisEventSourceProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda_event_sources.KinesisEventSourceProps.html)|Optional user-provided props to override the default props for the Lambda event source mapping.|
  |createCloudWatchAlarms|`boolean`|Whether to create recommended CloudWatch alarms|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |kinesisStream|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Returns an instance of the Kinesis stream created by the pattern.|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda function created by the pattern.|
  |kinesisStreamRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of the iam.Role created by the construct for Kinesis stream.|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns a list of cloudwatch.Alarm created by the construct|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure least privilege access IAM role for Kinesis Stream
  * Enable server-side encryption for Kinesis Stream using AWS Managed KMS Key
  * Deploy best practices CloudWatch Alarms for the Kinesis Stream

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Enable Failure-Handling features like enable bisect on function Error, set defaults for Maximum Record Age (24 hours) & Maximum Retry Attempts (500) and deploy SQS dead-letter queue as destination on failure
  * Set Environment Variables
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: 7b4d596f3ffe3fdc83ddc29e895d844b9e53095eb8d7fa5ec3d3057b5839e613
name: python-aws-solutions-constructs.aws-lambda-dynamodb
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Lambda to AWS DynamoDB integration.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-dynamodb-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_lambda_dynamodb`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-lambda-dynamodb`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.lambdadynamodb`|

  This AWS Solutions Construct implements the AWS Lambda function and Amazon DynamoDB table with the least privileged permissions.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { LambdaToDynamoDBProps, LambdaToDynamoDB } from '@aws-solutions-constructs/aws-lambda-dynamodb';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  const constructProps: LambdaToDynamoDBProps = {
    lambdaFunctionProps: {
      code: lambda.Code.fromAsset(`lambda`),
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler'
    },
  };
  new LambdaToDynamoDB(this, 'test-lambda-dynamodb-stack', constructProps);
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_lambda_dynamodb import LambdaToDynamoDBProps, LambdaToDynamoDB
  from aws_cdk import (
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct
  LambdaToDynamoDB(self, 'test_lambda_dynamodb_stack',
                      lambda_function_props=_lambda.FunctionProps(
                          code=_lambda.Code.from_asset(
                              'lambda'),
                          runtime=_lambda.Runtime.PYTHON_3_9,
                          handler='index.handler'
                      ))
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.lambdadynamodb.*;
  new LambdaToDynamoDB(this, "test_lambda_dynamodb_stack", new LambdaToDynamoDBProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |dynamoTableProps?|[`dynamodb.TableProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.TableProps.html)|Optional user provided props to override the default props for DynamoDB Table|
  |existingTableObj?|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Existing instance of DynamoDB table object, providing both this and `dynamoTableProps` will cause an error.|
  |tablePermissions?|`string`|Optional table permissions to grant to the Lambda function. One of the following may be specified: `All`, `Read`, `ReadWrite`, `Write`.|
  |tableEnvironmentVariableName?|`string`|Optional Name for the Lambda function environment variable set to the name of the DynamoDB table. Default: DDB_TABLE_NAME |
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources and a Gateway Endpoint will be created in the VPC for Amazon DynamoDB. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user-provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the pattern, so any values for those properties supplied here will be overridden. If `deployVpc` is not `true` then this property will be ignored.|
  |deployVpc?|`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of lambda.Function created by the construct|
  |dynamoTable|[`dynamodb.Table`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb.Table.html)|Returns an instance of dynamodb.Table created by the construct|
  |vpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface on the VPC used by the pattern (if any). This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * (default) DDB_TABLE_NAME
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)

  * Set the billing mode for DynamoDB Table to On-Demand (Pay per request)
  * Enable server-side encryption for DynamoDB Table using AWS managed KMS Key
  * Creates a partition key called 'id' for DynamoDB Table
  * Retain the Table when deleting the CloudFormation stack
  * Enable continuous backups and point-in-time recovery


pkgId: 0f13623446433e21667e4ba463b53405b735df2d53e523a42b9303e304a1b710
name: python-aws-solutions-constructs.aws-lambda-elasticachememcached
arch: src
version: 2.74.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-elasticachememcached-2.74.0-1.src.rpm
checksum_type: sha256
summary:
  CDK constructs for defining an interaction between an AWS Lambda function and an Amazon Elasticache memcached cache.

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_lambda_elasticachememcached`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-lambda-elasticachememcached`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.lambdaelasticachememcached`|

  This AWS Solutions Construct implements an AWS Lambda function connected to an Amazon Elasticache Memcached cluster.
  Here is a minimal deployable pattern definition :
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { LambdaToElasticachememcached } from '@aws-solutions-constructs/aws-lambda-elasticachememcached';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new LambdaToElasticachememcached(this, 'LambdaToElasticachememcachedPattern', {
      lambdaFunctionProps: {
          runtime: lambda.Runtime.NODEJS_16_X,
          handler: 'index.handler',
          code: lambda.Code.fromAsset(`lambda`)
      }
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_lambda_elasticachememcached import LambdaToElasticachememcached
  from aws_cdk import (
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct
  LambdaToElasticachememcached(self, 'LambdaToCachePattern',
          lambda_function_props=_lambda.FunctionProps(
              code=_lambda.Code.from_asset('lambda'),
              runtime=_lambda.Runtime.PYTHON_3_9,
              handler='index.handler'
          )
          )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.lambdaelasticachememcached.*;
  new LambdaToElasticachememcached(this, "LambdaToCachePattern", new LambdaToElasticachememcachedProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|Optional user provided props to override the default props for the Lambda function.|
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources and an Interface Endpoint will be created in the VPC for Amazon Elasticache. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user provided properties to override the default properties for the new VPC. `subnetConfiguration` is set by the pattern, so any values for those properties supplied here will be overridden. |
  | cacheEndpointEnvironmentVariableName?| string | Optional Name for the Lambda function environment variable set to the cache endpoint. Default: CACHE_ENDPOINT |
  | cacheProps? | [`cache.CfnCacheClusterProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticache.CfnCacheClusterProps.html) | Optional user provided props to override the default props for the Elasticache Cluster. Providing both this and `existingCache` will cause an error. |
  | existingCache? | [`cache.CfnCacheCluster`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticache.CfnCacheCluster.html#attrconfigurationendpointport) | Existing instance of Elasticache Cluster object, providing both this and `cacheProps` will cause an error. If you provide this, you must provide the associated VPC in existingVpc. |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda function used by the pattern.|
  |vpc |[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface on the VPC used by the pattern. This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|
  | cache | [`cache.CfnCacheCluster`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticache.CfnCacheCluster.html#attrconfigurationendpointport) | The Elasticache Memcached cluster used by the construct. |

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Attached to self referencing security group to grant access to cache
  * Set Environment Variables
    * (default) CACHE_ENDPOINT
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)

  * Creates multi node, cross-az cluster by default
    * 2 cache nodes, type: cache.t3.medium
  * Self referencing security group attached to cluster endpoint


pkgId: 3b2d747272ff9bc624925d1ee7a36376f5e0080b9e53165137e4083c94c3d935
name: python-aws-solutions-constructs.aws-lambda-elasticsearch-kibana
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Lambda to AWS Elasticsearch with Kibana integration
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-elasticsearch-kibana-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_lambda_elasticsearch_kibana`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-lambda-elasticsearch-kibana`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.lambdaelasticsearchkibana`|

  This AWS Solutions Construct implements an AWS Lambda function and Amazon Elasticsearch Service with the least privileged permissions.
  **Some cluster configurations (e.g VPC access) require the existence of the `AWSServiceRoleForAmazonElasticsearchService` Service-Linked Role in your account.**
  **You will need to create the service-linked role using the AWS CLI once in any account using this construct (it may have already been run to support other stacks):**
  ```
  aws iam create-service-linked-role --aws-service-name es.amazonaws.com
  ```
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Aws } from 'aws-cdk-lib';
  import { LambdaToElasticSearchAndKibana } from '@aws-solutions-constructs/aws-lambda-elasticsearch-kibana';
  import * as lambda from "aws-cdk-lib/aws-lambda";
  const lambdaProps: lambda.FunctionProps = {
    code: lambda.Code.fromAsset(`lambda`),
    runtime: lambda.Runtime.NODEJS_16_X,
    handler: 'index.handler'
  };
  new LambdaToElasticSearchAndKibana(this, 'sample', {
    lambdaFunctionProps: lambdaProps,
    domainName: 'testdomain',
    // TODO: Ensure the Cognito domain name is globally unique
    cognitoDomainName: 'globallyuniquedomain' + Aws.ACCOUNT_ID
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_lambda_elasticsearch_kibana import LambdaToElasticSearchAndKibana
  from aws_cdk import (
      aws_lambda as _lambda,
      Aws,
      Stack
  )
  from constructs import Construct
  lambda_props = _lambda.FunctionProps(
      code=_lambda.Code.from_asset('lambda'),
      runtime=_lambda.Runtime.PYTHON_3_9,
      handler='index.handler'
  )
  LambdaToElasticSearchAndKibana(self, 'sample',
                              lambda_function_props=lambda_props,
                              domain_name='testdomain',
                              
                              cognito_domain_name='globallyuniquedomain' + Aws.ACCOUNT_ID
                              )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.Aws;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.lambdaelasticsearchkibana.*;
  new LambdaToElasticSearchAndKibana(this, "sample",
          new LambdaToElasticSearchAndKibanaProps.Builder()
                  .lambdaFunctionProps(new FunctionProps.Builder()
                          .runtime(Runtime.NODEJS_16_X)
                          .code(Code.fromAsset("lambda"))
                          .handler("index.handler")
                          .build())
                  .domainName("testdomain")
                  // TODO: Ensure the Cognito domain name is globally unique
                  .cognitoDomainName("globallyuniquedomain" + Aws.ACCOUNT_ID)
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |esDomainProps?|[`elasticsearch.CfnDomainProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticsearch.CfnDomainProps.html)|Optional user provided props to override the default props for the Elasticsearch Service|
  |domainName|`string`|Domain name for the Cognito and the Elasticsearch Service|
  |cognitoDomainName?|`string`|Optional Cognito Domain Name, if provided it will be used for Cognito Domain, and domainName will be used for the Elasticsearch Domain|
  |createCloudWatchAlarms?|`boolean`|Whether to create recommended CloudWatch alarms|
  |domainEndpointEnvironmentVariableName?|`string`|Optional Name for the ElasticSearch domain endpoint environment variable set for the Lambda function.|
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the pattern, so any values for those properties supplied here will be overridden. If `deployVpc` is not `true` then this property will be ignored.|
  |deployVpc?|`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of `lambda.Function` created by the construct|
  |userPool|[`cognito.UserPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPool.html)|Returns an instance of `cognito.UserPool` created by the construct|
  |userPoolClient|[`cognito.UserPoolClient`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPoolClient.html)|Returns an instance of `cognito.UserPoolClient` created by the construct|
  |identityPool|[`cognito.CfnIdentityPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.CfnIdentityPool.html)|Returns an instance of `cognito.CfnIdentityPool` created by the construct|
  |elasticsearchDomain|[`elasticsearch.CfnDomain`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_elasticsearch.CfnDomain.html)|Returns an instance of `elasticsearch.CfnDomain` created by the construct|
  |elasticsearchRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of `iam.Role` created by the construct for `elasticsearch.CfnDomain`|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns a list of `cloudwatch.Alarm` created by the construct|
  |vpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface on the VPC used by the pattern (if any). This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|

  This pattern requires a lambda function that can post data into the Elasticsearch. A sample function is provided [here](https://github.com/awslabs/aws-solutions-constructs/blob/master/source/patterns/%40aws-solutions-constructs/aws-lambda-elasticsearch-kibana/test/lambda/index.js).

  Out of the box implementation of the Construct without any overrides will set the following defaults:

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for Node.js Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * (default) DOMAIN_ENDPOINT
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED

  * Set password policy for User Pools
  * Enforce the advanced security mode for User Pools

  * Deploy best practices CloudWatch Alarms for the Elasticsearch Service domain
  * Secure the Kibana dashboard access with Cognito User Pools
  * Enable server-side encryption for the Elasticsearch Service domain using AWS managed KMS Key
  * Enable node-to-node encryption for the Elasticsearch Service domain
  * Configure the cluster for the Elasticsearch Service domain


pkgId: 3d06d0b7a814d67a09de8c1b1b106d550bca4c7a7eee8260818389c37e4fd072
name: python-aws-solutions-constructs.aws-lambda-eventbridge
arch: src
version: 2.73.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-eventbridge-2.73.0-1.src.rpm
checksum_type: sha256
summary:
  CDK constructs for defining an interaction between an AWS Lambda function and an Amazon EventBridge.

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_lambda_eventbridge`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-lambda-eventbridge`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.lambdaeventbridge`|

  This AWS Solutions Construct implements an AWS Lambda function connected to an Amazon EventBridge.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Aws } from 'aws-cdk-lib';
  import { LambdaToEventbridge, LambdaToEventbridgeProps } from "@aws-solutions-constructs/aws-lambda-eventbridge";
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new LambdaToEventbridge(this, 'LambdaToEventbridgePattern', {
    lambdaFunctionProps: {
      runtime: lambda.Runtime.NODEJS_16_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset(`lambda`)
    }
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_lambda_eventbridge import LambdaToEventbridge
  from aws_cdk import (
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct
  LambdaToEventbridge(self, 'LambdaToEventbridgePattern',
                      lambda_function_props=_lambda.FunctionProps(
                          code=_lambda.Code.from_asset('lambda'),
                          runtime=_lambda.Runtime.PYTHON_3_9,
                          handler='index.handler'
                      )
                      )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.lambdaeventbridge.*;
  new LambdaToEventbridge(this, "LambdaToEventbridgePattern", new LambdaToEventbridgeProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|An optional, existing Lambda function to be used instead of the default function. Providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|Optional user-provided properties to override the default properties for the Lambda function. |
  |existingEventBusInterface?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)| Optional user-provided custom EventBus for construct to use. Providing both this and `eventBusProps` results an error.|
  |eventBusProps?|[`events.EventBusProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.EventBusProps.html)|Optional user-provided properties to override the default properties when creating a custom EventBus. Setting this value to `{}` will create a custom EventBus using all default properties. If neither this nor `existingEventBusInterface` is provided the construct will use the `default` EventBus. Providing both this and `existingEventBusInterface` results an error.|
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources and an Interface Endpoint will be created in the VPC for Amazon EventBridge. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user-provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the pattern, so any values for those properties supplied here will be overridden. If `deployVpc` is not `true` then this property will be ignored.|
  |deployVpc?|`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|
  |eventBusEnvironmentVariableName?|`string`|Optional Name for the Lambda function environment variable set to the name of the Event bus. Default: EVENTBUS_NAME |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda function created by the pattern.|
  |eventBus?|[`events.IEventBus`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_events.IEventBus.html)|Returns the instance of events.IEventBus used by the construct|
  |vpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface on the VPC used by the pattern (if any). This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure limited privilege access IAM role for Lambda function.
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function.
  * Allow the function to put events to EventBus (custom EventBus can be used by specifying `existingEventBusInterface` or `eventBusProps` property).
  * Enable X-Ray Tracing
  * Set Environment Variables
    * EVENTBUS_NAME
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)


pkgId: 33ad6666821635498c69978324b73bb3720202fd9e86de85373f6c948dc89733
name: python-aws-solutions-constructs.aws-lambda-kendra
arch: src
version: 2.74.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-kendra-2.74.0-1.src.rpm
checksum_type: sha256
summary:
  CDK constructs for defining an interaction between an AWS Lambda function and an existing Amazon Kinesis Firehose Delivery Stream.

description:
  ![Stability: Experimental](https://img.shields.io/badge/stability-Experimental-important.svg?style=for-the-badge)
  > All classes are under active development and subject to non-backward compatible changes or removal in any
  > future version. These are not subject to the [Semantic Versioning](https://semver.org/) model.


pkgId: a2bb9e3ecb61f101df4c19127eff09e392f5c4122d6e1a46f23bec390a9cb3cc
name: python-aws-solutions-constructs.aws-lambda-kinesis-streams
arch: src
version: 2.74.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-kinesis-streams-2.74.0-1.src.rpm
checksum_type: sha256
summary:
  CDK constructs for defining an interaction between an AWS Lambda Function and an Amazon Kinesis Data Stream.

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_lambda_kinesis_stream`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-lambda-kinesisstreams`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.lambdakinesisstreams`|

  This AWS Solutions Construct deploys an AWS Lambda Function that can put records on an Amazon Kinesis Data Stream.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { LambdaToKinesisStreamsProps } from '@aws-solutions-constructs/aws-lambda-kinesisstreams';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new LambdaToKinesisStreams(this, 'LambdaToKinesisStreams', {
    lambdaFunctionProps: {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset(`lambda`)
    }
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_lambda_kinesis_stream import LambdaToKinesisStreams
  from aws_cdk import (
      aws_lambda as _lambda,
      aws_kinesis as kinesis,
      Stack
  )
  from constructs import Construct
  LambdaToKinesisStreams(self, 'LambdaToKinesisStreams',
                          lambda_function_props=_lambda.FunctionProps(
                            runtime=_lambda.Runtime.PYTHON_3_9,
                            handler='index.handler',
                            code=_lambda.Code.from_asset('lambda')
                          )
                        )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.eventsources.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.lambdakinesisstreams.*;
  new LambdaToKinesisStreams(this, "LambdaToKinesisStreams", new LambdaToKinesisStreamsProps.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_18_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of a Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda Function.|
  |existingStreamObj?|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Existing instance of a Kinesis Data Stream, providing both this and `kinesisStreamProps` will cause an error.|
  |kinesisStreamProps?|[`kinesis.StreamProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.StreamProps.html)|Optional user-provided props to override the default props for the Kinesis Data Stream.|
  |createCloudWatchAlarms|`boolean`|Whether to create recommended CloudWatch Alarms (defaults to true).|
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources and an Interface Endpoint will be created in the VPC for Amazon Kinesis Streams. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user-provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the pattern, so any values for those properties supplied here will be overridden. If `deployVpc` is not `true` then this property will be ignored.|
  |deployVpc?|`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|
  |streamEnvironmentVariableName?|`string`|Optional Name to override the Lambda Function default environment variable name that holds the Kinesis Data Stream name value. Default: KINESIS_DATASTREAM_NAME |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda Function.|
  |kinesisStream|[`kinesis.Stream`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesis.Stream.html)|Returns an instance of the Kinesis Data Stream.|
  |cloudwatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns the CloudWatch Alarms created to monitor the Kinesis Data Stream.|
  |vpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface to the VPC used by the pattern (if any). This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|

  Out of the box implementation of the Construct without any overrides will set the following defaults:

  * Minimally-permissive IAM role for the Lambda Function to put records on the Kinesis Data Stream
  * Enable X-Ray Tracing
  * Sets an Environment Variable named KINESIS_DATASTREAM_NAME that holds the Kinesis Data Stream Name, which is a required property Kinesis Data Streams SDK when making calls to it

  * Enable server-side encryption for the Kinesis Data Stream using AWS Managed CMK
  * Deploy best practices CloudWatch Alarms for the Kinesis Data Stream


pkgId: 22bb6b02e0fa5b188ba09d76555cc9462a5d79d398e9ef129dcc4dc2a1860e26
name: python-aws-solutions-constructs.aws-lambda-kinesisfirehose
arch: src
version: 2.74.0
epoch: 0
release: 1
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-kinesisfirehose-2.74.0-1.src.rpm
checksum_type: sha256
summary:
  CDK constructs for defining an interaction between an AWS Lambda function and an existing Amazon Kinesis Firehose Delivery Stream.

description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_lambda_kinesisfirehose`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-lambda-kinesisfirehose`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.lambdakinesisfirehose`|

  This AWS Solutions Construct implements an AWS Lambda function connected to an existing Amazon Kinesis Firehose Delivery Stream.
  Here is a minimal deployable pattern definition :
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { LambdaToS3 } from '@aws-solutions-constructs/aws-lambda-kinesisfirehose';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  // The construct requires an existing Firehose Delivery Stream, this can be created in raw CDK or extracted
  // from a previously instantiated construct that created an Firehose Delivery Stream
  const existingFirehoseDeliveryStream = previouslyCreatedKinesisFirehoseToS3Construct.kinesisFirehose;
  new LambdaToKinesisFirehose(this, 'LambdaToFirehosePattern', {
    lambdaFunctionProps: {
        runtime: lambda.Runtime.NODEJS_16_X,
        handler: 'index.handler',
        code: lambda.Code.fromAsset(`lambda`)
    },
    existingKinesisFirehose: existingFirehoseDeliveryStream
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_lambda_kinesisfirehose import LambdaToKinesisFirehose
  from aws_cdk import (
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct


  existingFirehoseDeliveryStream = previouslyCreatedKinesisFirehoseToS3Construct.kinesisFirehose;
  LambdaToKinesisFirehose(self, 'LambdaToFirehosePattern',
          existingKinesisFirehose=existingFirehoseDeliveryStream,
          lambda_function_props=_lambda.FunctionProps(
              code=_lambda.Code.from_asset('lambda'),
              runtime=_lambda.Runtime.PYTHON_3_9,
              handler='index.handler'
          )
          )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.lambdakinesisfirehose.*;
  // The construct requires an existing Firehose Delivery Stream, this can be created in raw CDK or extracted
  // from a previously instantiated construct that created an Firehose Delivery Stream
  existingFirehoseDeliveryStream = previouslyCreatedKinesisFirehoseToS3Construct.kinesisFirehose;
  new LambdaToKinesisFirehose(this, "LambdaToFirehosePattern", new LambdaToKinesisFirehoseProps.Builder()
          .existingKinesisFirehose(existingFirehoseDeliveryStream)
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|Optional user provided props to override the default props for the Lambda function.|
  |existingKinesisFirehose|[kinesisfirehose.CfnDeliveryStream](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStream.html)|An existing Kinesis Firehose Delivery Stream to which the Lambda function can put data. Note - the delivery stream construct must have already been created and have the deliveryStreamName set. This construct will *not* create a new Delivery Stream.|
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources and an Interface Endpoint will be created in the VPC for Amazon Kinesis Data Firehose. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the pattern, so any values for those properties supplied here will be overridden. If `deployVpc` is not `true` then this property will be ignored.|
  |deployVpc?|`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|
  |firehoseEnvironmentVariableName?|`string`|Optional Name for the Lambda function environment variable set to the name of the delivery stream. Default: FIREHOSE_DELIVERYSTREAM_NAME |

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda function created by the pattern.|
  |kinesisFirehose|[kinesisfirehose.CfnDeliveryStream](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisfirehose.CfnDeliveryStream.html)|The Kinesis Firehose Delivery Stream used by the construct.|
  |vpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface on the VPC used by the pattern (if any). This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * (default) FIREHOSE_DELIVERYSTREAM_NAME
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED

  * This construct must be provided a configured Stream construct, it does not change this Stream.


pkgId: 116b14a05cd973c13493f76e4e8b161c6e11e0574bd6f8990eea81726fe51da8
name: python-aws-solutions-constructs.aws-lambda-opensearch
arch: src
version: 2.74.0
epoch: 0
release: 1
summary: CDK Constructs for AWS Lambda to Amazon OpenSearch Service
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-opensearch-2.74.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_lambda_opensearch`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-lambda-opensearch`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.lambdaopensearch`|

  This AWS Solutions Construct implements an AWS Lambda function and Amazon OpenSearch Service with the least privileged permissions.
  Here is a minimal deployable pattern definition:
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps, Aws } from 'aws-cdk-lib';
  import { LambdaToOpenSearch } from '@aws-solutions-constructs/aws-lambda-opensearch';
  import * as lambda from "aws-cdk-lib/aws-lambda";
  const lambdaProps: lambda.FunctionProps = {
    code: lambda.Code.fromAsset(`lambda`),
    runtime: lambda.Runtime.NODEJS_16_X,
    handler: 'index.handler'
  };
  new LambdaToOpenSearch(this, 'sample', {
    lambdaFunctionProps: lambdaProps,
    openSearchDomainName: 'testdomain',
    // TODO: Ensure the Cognito domain name is globally unique
    cognitoDomainName: 'globallyuniquedomain' + Aws.ACCOUNT_ID
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_lambda_opensearch import LambdaToOpenSearch
  from aws_cdk import (
      aws_lambda as _lambda,
      Aws,
      Stack
  )
  from constructs import Construct
  lambda_props = _lambda.FunctionProps(
      code=_lambda.Code.from_asset('lambda'),
      runtime=_lambda.Runtime.PYTHON_3_9,
      handler='index.handler'
  )
  LambdaToOpenSearch(self, 'sample',
                              lambda_function_props=lambda_props,
                              open_search_domain_name='testdomain',
                              
                              cognito_domain_name='globallyuniquedomain' + Aws.ACCOUNT_ID
                              )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.Aws;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.lambdaopensearch.*;
  new LambdaToOpenSearch(this, "sample",
          new LambdaToOpenSearchProps.Builder()
                  .lambdaFunctionProps(new FunctionProps.Builder()
                          .runtime(Runtime.NODEJS_16_X)
                          .code(Code.fromAsset("lambda"))
                          .handler("index.handler")
                          .build())
                  .openSearchDomainName("testdomain")
                  // TODO: Ensure the Cognito domain name is globally unique
                  .cognitoDomainName("globallyuniquedomain" + Aws.ACCOUNT_ID)
                  .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|User provided props to override the default props for the Lambda function.|
  |openSearchDomainProps?|[`opensearchservice.CfnDomainProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_opensearchservice.CfnDomainProps.html)|Optional user provided props to override the default props for the OpenSearch Service.|
  |openSearchDomainName|`string`|Domain name for the OpenSearch Service.|
  |cognitoDomainName?|`string`|Optional Amazon Cognito domain name. If omitted the Amazon Cognito domain will default to the OpenSearch Service domain name.|
  |createCloudWatchAlarms?|`boolean`|Whether to create the recommended CloudWatch alarms.|
  |domainEndpointEnvironmentVariableName?|`string`|Optional name for the OpenSearch domain endpoint environment variable set for the Lambda function. Default is `DOMAIN_ENDPOINT`.|
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the pattern, so any values for those properties supplied here will be overridden. If `deployVpc` is not `true` then this property will be ignored.|
  |deployVpc?|`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of `lambda.Function` created by the construct|
  |userPool|[`cognito.UserPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPool.html)|Returns an instance of `cognito.UserPool` created by the construct|
  |userPoolClient|[`cognito.UserPoolClient`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.UserPoolClient.html)|Returns an instance of `cognito.UserPoolClient` created by the construct|
  |identityPool|[`cognito.CfnIdentityPool`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cognito.CfnIdentityPool.html)|Returns an instance of `cognito.CfnIdentityPool` created by the construct|
  |openSearchDomain|[`opensearchservice.CfnDomain`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_opensearchservice.CfnDomain.html)|Returns an instance of `opensearch.CfnDomain` created by the construct|
  |openSearchRole|[`iam.Role`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.Role.html)|Returns an instance of `iam.Role` created by the construct for `opensearch.CfnDomain`|
  |cloudWatchAlarms?|[`cloudwatch.Alarm[]`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch.Alarm.html)|Returns a list of `cloudwatch.Alarm` created by the construct|
  |vpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface on the VPC used by the pattern (if any). This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|

  This pattern requires a lambda function that can post data into the OpenSearch. A sample function is provided [here](https://github.com/awslabs/aws-solutions-constructs/blob/master/source/patterns/%40aws-solutions-constructs/aws-lambda-opensearch/test/lambda/index.js).

  Out of the box implementation of the Construct without any overrides will set the following defaults:

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for Node.js Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * (default) DOMAIN_ENDPOINT
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED

  * Set password policy for User Pools
  * Enforce the advanced security mode for User Pools

  * Deploy best practices CloudWatch Alarms for the OpenSearch Service domain
  * Secure the OpenSearch Service dashboard access with Cognito User Pools
  * Enable server-side encryption for OpenSearch Service domain using AWS managed KMS Key
  * Enable node-to-node encryption for the OpenSearch Service domain
  * Configure the cluster for the OpenSearch Service domain


pkgId: e9974328518817f74786eefab38fb8e1d910896f0e4dd5316978aefac0381da8
name: python-aws-solutions-constructs.aws-lambda-s3
arch: src
version: 2.72.0
epoch: 0
release: 1
summary: CDK constructs for defining an interaction between an AWS Lambda function and an Amazon S3 bucket.
url: https://github.com/awslabs/aws-solutions-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aws-solutions-constructs.aws-lambda-s3-2.72.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  | **Reference Documentation**:| <span style="font-weight: normal">https://docs.aws.amazon.com/solutions/latest/constructs/</span>|
  |:-------------|:-------------|
  <div style="height:8px"></div>
  | **Language**     | **Package**        |
  |:-------------|-----------------|
  |![Python Logo](https://docs.aws.amazon.com/cdk/api/latest/img/python32.png) Python|`aws_solutions_constructs.aws_lambda_s3`|
  |![Typescript Logo](https://docs.aws.amazon.com/cdk/api/latest/img/typescript32.png) Typescript|`@aws-solutions-constructs/aws-lambda-s3`|
  |![Java Logo](https://docs.aws.amazon.com/cdk/api/latest/img/java32.png) Java|`software.amazon.awsconstructs.services.lambdas3`|

  This AWS Solutions Construct implements an AWS Lambda function connected to an Amazon S3 bucket.
  Here is a minimal deployable pattern definition :
  Typescript
  ```python
  import { Construct } from 'constructs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { LambdaToS3 } from '@aws-solutions-constructs/aws-lambda-s3';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  new LambdaToS3(this, 'LambdaToS3Pattern', {
      lambdaFunctionProps: {
          runtime: lambda.Runtime.NODEJS_16_X,
          handler: 'index.handler',
          code: lambda.Code.fromAsset(`lambda`)
      }
  });
  ```
  Python
  ```python
  from aws_solutions_constructs.aws_lambda_s3 import LambdaToS3
  from aws_cdk import (
      aws_lambda as _lambda,
      Stack
  )
  from constructs import Construct
  LambdaToS3(self, 'LambdaToS3Pattern',
          lambda_function_props=_lambda.FunctionProps(
              code=_lambda.Code.from_asset('lambda'),
              runtime=_lambda.Runtime.PYTHON_3_9,
              handler='index.handler'
          )
          )
  ```
  Java
  ```java
  import software.constructs.Construct;
  import software.amazon.awscdk.Stack;
  import software.amazon.awscdk.StackProps;
  import software.amazon.awscdk.services.lambda.*;
  import software.amazon.awscdk.services.lambda.Runtime;
  import software.amazon.awsconstructs.services.lambdas3.*;
  new LambdaToS3(this, "LambdaToS3Pattern", new LambdaToS3Props.Builder()
          .lambdaFunctionProps(new FunctionProps.Builder()
                  .runtime(Runtime.NODEJS_16_X)
                  .code(Code.fromAsset("lambda"))
                  .handler("index.handler")
                  .build())
          .build());
  ```

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |existingLambdaObj?|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Existing instance of Lambda Function object, providing both this and `lambdaFunctionProps` will cause an error.|
  |lambdaFunctionProps?|[`lambda.FunctionProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.FunctionProps.html)|Optional user provided props to override the default props for the Lambda function.|
  |existingBucketObj?|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Existing instance of S3 Bucket object. If this is provided, then also providing bucketProps is an error. |
  |bucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Bucket.|
  |bucketPermissions?|`string[]`|Optional bucket permissions to grant to the Lambda function. One or more of the following may be specified: `Delete`, `Put`, `Read`, `ReadWrite`, `Write`.|
  |existingVpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|An optional, existing VPC into which this pattern should be deployed. When deployed in a VPC, the Lambda function will use ENIs in the VPC to access network resources and an Interface Endpoint will be created in the VPC for Amazon S3. If an existing VPC is provided, the `deployVpc` property cannot be `true`. This uses `ec2.IVpc` to allow clients to supply VPCs that exist outside the stack using the [`ec2.Vpc.fromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) method.|
  |vpcProps?|[`ec2.VpcProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.VpcProps.html)|Optional user provided properties to override the default properties for the new VPC. `enableDnsHostnames`, `enableDnsSupport`, `natGateways` and `subnetConfiguration` are set by the pattern, so any values for those properties supplied here will be overridden. If `deployVpc` is not `true` then this property will be ignored.|
  |deployVpc?|`boolean`|Whether to create a new VPC based on `vpcProps` into which to deploy this pattern. Setting this to true will deploy the minimal, most private VPC to run the pattern:<ul><li> One isolated subnet in each Availability Zone used by the CDK program</li><li>`enableDnsHostnames` and `enableDnsSupport` will both be set to true</li></ul>If this property is `true` then `existingVpc` cannot be specified. Defaults to `false`.|
  |bucketEnvironmentVariableName?|`string`|Optional Name for the Lambda function environment variable set to the name of the bucket. Default: S3_BUCKET_NAME |
  |loggingBucketProps?|[`s3.BucketProps`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)|Optional user provided props to override the default props for the S3 Logging Bucket.|
  |logS3AccessLogs?| boolean|Whether to turn on Access Logging for the S3 bucket. Creates an S3 bucket with associated storage costs for the logs. Enabling Access Logging is a best practice. default - true|

  | **Name**     | **Type**        | **Description** |
  |:-------------|:----------------|-----------------|
  |lambdaFunction|[`lambda.Function`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)|Returns an instance of the Lambda function created by the pattern.|
  |s3Bucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of the S3 bucket created by the pattern.|
  |s3LoggingBucket?|[`s3.Bucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)|Returns an instance of s3.Bucket created by the construct as the logging bucket for the primary bucket.|
  |vpc?|[`ec2.IVpc`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html)|Returns an interface on the VPC used by the pattern (if any). This may be a VPC created by the pattern or the VPC supplied to the pattern constructor.|
  |s3BucketInterface|[`s3.IBucket`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html)|Returns an instance of s3.IBucket created by the construct.|

  Out of the box implementation of the Construct without any override will set the following defaults:

  * Configure limited privilege access IAM role for Lambda function
  * Enable reusing connections with Keep-Alive for NodeJs Lambda function
  * Enable X-Ray Tracing
  * Set Environment Variables
    * (default) S3_BUCKET_NAME
    * AWS_NODEJS_CONNECTION_REUSE_ENABLED (for Node 10.x and higher functions)

  * Configure Access logging for S3 Bucket
  * Enable server-side encryption for S3 Bucket using AWS managed KMS Key
  * Enforce encryption of data in transit
  * Turn on the versioning for S3 Bucket
  * Don't allow public access for S3 Bucket
  * Retain the S3 Bucket when deleting the CloudFormation stack
  * Applies Lifecycle rule to move noncurrent object versions to Glacier storage after 90 days


