# packages

pkgId: af841bdcbd5694beb68e8dfb55c72aa4fe83ce7a919a87ce5a162c2308c68548
name: python-cdk-sops-secrets
arch: src
version: 1.15.0
epoch: 0
release: 1
summary: CDK Constructs that syncs your sops secrets into AWS SecretsManager secrets.
url: https://constructs.dev/packages/cdk-sops-secrets
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-sops-secrets-1.15.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/dbsystel/cdk-sops-secrets/blob/main/img/banner-dl-small.png?raw=true">
  <p/>

  ![stability](https://img.shields.io/badge/Stability-stable-green) 
  [![release](https://github.com/dbsystel/cdk-sops-secrets/actions/workflows/release.yml/badge.svg)](https://github.com/dbsystel/cdk-sops-secrets/actions/workflows/release.yml)<br>

  [![cdk-construct-hub](https://img.shields.io/badge/CDK-ConstructHub-blue)](https://constructs.dev/packages/cdk-sops-secrets)<br>
  [![npm](https://img.shields.io/npm/v/cdk-sops-secrets.svg)](https://www.npmjs.com/package/cdk-sops-secrets) 
  [![npm downloads](https://img.shields.io/npm/dw/cdk-sops-secrets)](https://www.npmjs.com/package/cdk-sops-secrets)<br>
  [![pypi](https://img.shields.io/pypi/v/cdk-sops-secrets.svg)](https://pypi.org/project/cdk-sops-secrets) 
  [![pypi downloads](https://img.shields.io/pypi/dw/cdk-sops-secrets)](https://pypi.org/project/cdk-sops-secrets)<br>

  [![codecov](https://codecov.io/gh/dbsystel/cdk-sops-secrets/branch/main/graph/badge.svg?token=OT7P7HQHXB)](https://codecov.io/gh/dbsystel/cdk-sops-secrets)  
  [![security-vulnerabilities](https://img.shields.io/github/issues-search/dbsystel/cdk-sops-secrets?color=%23ff0000&label=security-vulnerabilities&query=is%3Aissue%20is%3Aopen%20label%3A%22Mend%3A%20dependency%20security%20vulnerability%22)](https://github.com/dbsystel/cdk-sops-secrets/issues?q=is%3Aissue+is%3Aopen+label%3A%22security+vulnerability%22) 



  This construct library provides a replacement for CDK SecretsManager secrets, with extended functionality for Mozilla/sops.

  <p/><center><img src="img/flow.drawio.svg"></center><p/>
  Using this library it is possible to populate Secrets with values from a Mozilla/sops file without additional scripts and steps in the CI stage. Thereby transformations like JSON conversion of YAML files and transformation into a flat, JSONPath like structure will be performed, but can be disabled.

  Secrets filled in this way can be used immediately within the CloudFormation stack and dynamic references. This construct should handle all dependencies, if you use the `secretValueFromJson()` or `secretValue()` call to access secret values.

  This way, secrets can be securely stored in git repositories and easily synchronized into AWS SecretsManager secrets.



  You can consider this package as stable. Updates will follow [Semantic Versioning](https://semver.org/).<br>
  Nevertheless, I would recommend pinning the exact version of this library in your `package.json`.



  * [AWS](https://aws.amazon.com/): I think you already knew it, but this construct will only work with an AWS account.

  * [KMS Key](https://aws.amazon.com/kms/?nc1=h_ls): It makes most sense to encrypt your secrets with AWS KMS if you want to sync and use the secret content afterwards in your AWS account.
  * [mozilla/sops](https://github.com/mozilla/sops): This construct assumes that you store your secrets encrypted via sops in your git repository.
  * [CDK](https://aws.amazon.com/cdk/?nc1=h_ls): As this is a CDK construct, it's only useful if you use the CloudDevelopmentToolkit.



  1. Create a Mozilla/sops secrets file (encrypted with an already existing KMS key) and place it somewhere in your git repository
  2. Create a secret with the SopsSecret construct inside your app

     ```python
     const secret = new SopsSecret(stack, 'SopsComplexSecretJSON', {
       sopsFilePath: 'secets/sopsfile-encrypted.json',
     });
     ```
  3. Optional: Access the secret via dynamic references

     ```python
     secret.secretValueFromJson('json.path.dotted.notation.accessor[0]').toString(),
     ```



  Even if using the main functionality should be done in 3 lines of code, there are more options to configure the constructs of this library. If you want to get an Overview of all available configuration options take a look at the [documentation at the CDK ConstructHub](https://constructs.dev/packages/cdk-sops-secrets).

  The most useful settings will be explained in the further chapters:



  If you have the need to just upload a sops encrypted binary file, just name your sops encrypted file *.binary, or specify the option "binary" as format.

  ```python
  const secret = new SopsSecret(this, 'SopsComplexSecretJSON', {
    ...
    sopsFilePath: 'secrets/sopsfile-encrypted.binary',
  });
  ```

  or

  ```python
  const secret = new SopsSecret(this, 'SopsComplexSecretJSON', {
    ...
    sopsFilePath: 'secrets/sopsfile-encrypted.something',
    sopsFileFormat: 'binary',
  });
  ```



  While creating the secret or updating the entries of a secret, the native CDK function `cdk.FileSystem.fingerprint(...)` is used to generate the version information of the AWS SecretsManager secret.
  Therefore, it is possible to reference the entries from a specific AWS SecretsManager version.

  ```python
  const versionId = cdk.FileSystem.fingerprint(`./sops/SomeSecrets.json`)
  const passphrase = ecs.Secret.fromSecretsManagerVersion(secretMgmt, { versionId: versionId }, 'MY_PRIVATE_PASSPHRASE')

  const container = TaskDef.addContainer('Container', {
     secrets: {
       MY_PRIVATE_PASSPHRASE: passphrase,
     },
  });
  ```



  As default behavior, the SopsSecret (via the SopsSync) will convert all content to JSON and flatten its structure. This is useful, because the AWS SecretsManager has some limitations if it comes to YAML and/or complex objects and decimal values. Even if you can store YAML, complex objects and even binaries in AWS SecretsManager secrets, you can't access their values via the SecretsManager API — you can only return them as is. So accessing (nested) values or values from YAML files won't be possible via [dynamic references](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html) in CloudFormation (and CDK). That's why I decided that conversion to JSON, flatten the structure and stringify all values should be the default behavior. But you can turn off all of these conversion steps:

  ```python
  const secret = new SopsSecret(this, 'SopsComplexSecretJSON', {
    convertToJSON: false, // disable converting the encrypted content to JSON
    stringify: false, // disable stringifying all values
    flatten: false, // disable flattening of the object structure
    sopsFilePath: 'secrets/sopsfile-encrypted.json',
  });
  ```



  Sometimes it can be necessary to access the IAM role of the SopsSync provider. If this is the case, you should create the provider before creating the SopsSecret, and pass the provider to it like this:

  ```python
  // Create the provider
  const provider = new SopsSyncProvider(this, 'CustomSopsSyncProvider');
  // Grant whatever you need to the provider
  const myExtraKmsKey = Key.fromKeyArn(this, 'MyExtraKmsKey', 'YourKeyArn');
  myExtraKmsKey.grantDecrypt(provider);
  // create the secret and pass the the provider to it
  const secret = new SopsSecret(this, 'SopsComplexSecretJSON', {
    sopsProvider: provider,
    secretName: 'myCoolSecret',
    sopsFilePath: 'secrets/sopsfile-encrypted.json',
  });
  ```



  Internally, SopsSync uses a lambda function. In some environments it may be necessary to place this lambda function into a VPC and configure subnets and/or security groups for it.
  This can be done by creating a custom `SopsSyncProvider`, setting the required networking configuration and passing it to the secret like this:

  ```python
  // Create the provider
  const provider = new SopsSyncProvider(this, 'CustomSopsSyncProvider', {
    vpc: myVpc,
    vpcSubnets: subnetSelection,
    securityGroups: [mySecurityGroup],
  });
  // create the secret and pass the the provider to it
  const secret = new SopsSecret(this, 'SopsSecret', {
    sopsProvider: provider,
    secretName: 'myCoolSecret',
    sopsFilePath: 'secrets/sopsfile-encrypted.json',
  });
  ```



  I decided, that the default behavior should be "INLINE" because of the following consideration:

  * Fewer permissions: If we use inline content instead of a S3 asset, the SopsSyncProvider does not need permissions to access the asset bucket and its KMS key.
  * Faster: If we don't have to upload and download things from and to S3, it should be a little faster.
  * Interchangeable: As we use the same information to generate the version of the secret, no new version of the secret should be created, if you change from INLINE to ASSET or vice versa, even if the CloudFormation resource updates.
  * I personally think sops files are not that big, that we should run into limits, but if so — we can change to asset `uploadType`.

  You can change the uplaodType via the properties:

  ```python
  const secret = new SopsSecret(this, 'SopsWithAssetUpload', {
    sopsFilePath: 'secrets/sopsfile-encrypted.json',
    uploadType: UploadType.ASSET, // instead of the default UploadType.INLINE
  });
  ```





  Even if this construct has some unit and integration tests performed, there can be bugs and issues. As everything is performed by a cloudformation custom resource provider, a good starting point is the log of the corresponding lambda function. It should be located in your AWS Account under Cloudwatch -> Log groups:

  `/aws/lambda/<YOUR-STACK-NAME>-SingletonLambdaSopsSyncProvider<SOMETHINGsomething1234>`



  Only very basic dotenv syntax is working right now. Only single line values are accepted. The format must match:

  ```dotenv
  key=value
  ```

  comments must be a single line, not after value assignments.



  This error message (and failed sync) is related to the  mozilla/sops issues [#948](https://github.com/mozilla/sops/issues/948) and [#634](https://github.com/mozilla/sops/issues/634). You must not create your secret with the `--aws-profile` flag. This profile will be written to your sops filed and is required in every runtime environment. You have to define the profile to use via the environment variable `AWS_PROFILE` instead, to avoid this.



  The lambda asset code is generated relative to the path of the index.ts in this package. With tools like nx this can lead to wrong results, so that the asset could not be found.

  You can override the asset path via the [cdk.json](https://docs.aws.amazon.com/cdk/v2/guide/get_context_var.html) or via the flag `-c`of the cdk cli.

  The context used for this override is `sops_sync_provider_asset_path`.

  So for example you can use

  ```bash
  cdk deploy -c "sops_sync_provider_asset_path=some/path/asset.zip"
  ```

  or in your cdk.json

  ```json
  {
    "context": {
      "sops_sync_provider_asset_path": "some/path/asset.zip"
    }
  }
  ```



  That's possible since version 1.8.0. You can reference the file in S3 like:

  ```python
  new SopsSecret(stack, 'SopsSecret', {
    sopsS3Bucket: 'testbucket',
    sopsS3Key: 'secret.json',
    sopsFileFormat: 'json',
    // ...
  });
  ```

  Passing those values as CloudFormation parameters should also be possible:

  ```python

  const sopsS3BucketParam = new CfnParameter(this, "s3BucketName", {
    type: "String",
    description: "The name of the Amazon S3 bucket where your sopsFile was uploaded."});

  const sopsS3KeyParam = new CfnParameter(this, "s3KeyName", {
    type: "String",
    description: "The name of the key of the sopsFile inside the Amazon S3 bucket."});

  new SopsSecret(stack, 'SopsSecret', {
    sopsS3Bucket: sopsS3BucketParam.valueAsString,
    sopsS3Key: sopsS3KeyParam.valueAsString,
    sopsFileFormat: 'json',
    // ...
  });
  ```



  I have created this project to solve a recurring problem of syncing Mozilla/sops secrets into AWS SecretsManager in a convenient, secure way.

  Other than that, or perhaps more importantly, my goal was to learn new things:

  * Write a Golang lambda
  * Writing unit tests incl. mocks in Golang
  * Reproducible builds of Golang binaries (byte-by-byte identical)
  * Build reproducible zips (byte-by-byte identical)
  * Release a NPM package
  * Setting up projects with projen
  * CI/CD with GitHub actions
  * CDK unit and integration tests



  The problem this Construct addresses is so good, already two other implementations exist:

  * [isotoma/sops-secretsmanager-cdk](https://github.com/isotoma/sops-secretsmanager-cdk): Does nearly the same. Uses CustomResource, wraps the sops CLI, does not support flatten. Found it after I published my solution to NPM :-/
  * [taimos/secretsmanager-versioning](https://github.com/taimos/secretsmanager-versioning): Different approach on the same problem. This is a CLI tool with very nice integration into CDK and also handles git versioning information.



  The Apache-2.0 license. Please have a look at the [LICENSE](LICENSE) and [LICENSE-3RD-PARTY](LICENSE-3RD-PARTY).


pkgId: 5a3dd9122b14fd62629ae0eb9f61e332fe0deb233baec73483d00e30f268565e
name: python-cdk-spot-one
arch: src
version: 2.0.328
epoch: 0
release: 1
summary: One spot instance with EIP and defined duration. No interruption.
url: https://github.com/pahud/cdk-spot-one.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-spot-one-2.0.328-1.src.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-spot-one.svg)](https://badge.fury.io/js/cdk-spot-one)
  [![PyPI version](https://badge.fury.io/py/cdk-spot-one.svg)](https://badge.fury.io/py/cdk-spot-one)
  ![Release](https://github.com/pahud/cdk-spot-one/workflows/Release/badge.svg)



  One spot instance with EIP and defined duration. No interruption.



  Use the npm dist tag to opt in CDKv1 or CDKv2:

  ```sh
  // for CDKv2
  npm install cdk-spot-one
  or
  npm install cdk-spot-one@latest

  // for CDKv1
  npm install cdk-spot-one@cdkv1
  ```



  Sometimes we need an Amazon EC2 instance with static fixed IP for testing or development purpose for a duration of
  time(probably hours). We need to make sure during this time, no interruption will occur and we don't want to pay
  for on-demand rate. `cdk-spot-one` helps you reserve one single spot instance with pre-allocated or new
  Elastic IP addresses(EIP) with defined `blockDuration`, during which time the spot instance will be secured with no spot interruption.

  Behind the scene, `cdk-spot-one` provisions a spot fleet with capacity of single instance for you and it associates the EIP with this instance. The spot fleet is reserved as spot block with `blockDuration` from one hour up to six hours to ensure the high availability for your spot instance.

  Multiple spot instances are possible by simply specifying the `targetCapacity` construct property, but we only associate the EIP with the first spot instance at this moment.

  Enjoy your highly durable one spot instance with AWS CDK!



  This library provides two major constructs:



  * Create a spot instance **without** any fleet
  * Does **NOT** support [Spot Block](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html#fixed-duration-spot-instances)
  * Support `stop` or `hibernate` instance

  Scenario: To leverage the `stop` or `hibernate` capabilities of the spot instance to persist the data in the ebs volume.



  * Create a spot instance with a [Spot Fleet](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet.html)
  * Support [Spot Block](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html#fixed-duration-spot-instances)
  * Does **NOT** support `stop` or `hibernate` instance

  Scenario: To ensure the availability with no disruption with defined period up to 6 hours.





  ```python
  import { SpotInstance, AmazonMachineImage } from 'cdk-spot-one';

  // Default use Amazon Linux 2
  new SpotInstance(stack, 'SpotInstance');


  // Custom Id use Ubuntu 20.04 Arm64 Server.
  new SpotInstance(stack, 'SpotInstanceUbuntu', {
        vpc,
        customAmiId: AmazonMachineImage.UBUNTU_20_04_ARM64.getImage(stack).imageId,
        defaultInstanceType: new InstanceType('t4g.medium'),
        keyName,
        blockDeviceMappings: [{ deviceName: '/dev/sda1', ebs: { volumeSize: 20 } }],
        additionalUserData: ['curl -fsSL https://get.docker.com -o get-docker.sh', 'sudo sh get-docker.sh'],
      });
  ```



  ```python
  import { SpotFleet } from 'cdk-spot-one';

  // create the first fleet for one hour and associate with our existing EIP
  const fleet = new SpotFleet(stack, 'SpotFleet')

  // configure the expiration after 1 hour
  fleet.expireAfter(Duration.hours(1))


  // create the 2nd fleet with single Gravition 2 instance for 6 hours and associate with new EIP
  const fleet2 = new SpotFleet(stack, 'SpotFleet2', {
    blockDuration: BlockDuration.SIX_HOURS,
    eipAllocationId: 'eipalloc-0d1bc6d85895a5410',
    defaultInstanceType: new InstanceType('c6g.large'),
    vpc: fleet.vpc,
  })
  // configure the expiration after 6 hours
  fleet2.expireAfter(Duration.hours(6))

  // print the instanceId from each spot fleet
  new CfnOutput(stack, 'SpotFleetInstanceId', { value: fleet.instanceId })
  new CfnOutput(stack, 'SpotFleet2InstanceId', { value: fleet2.instanceId })
  ```



  ```python
  const fleet = new SpotFleet(stack, 'SpotFleet', {
    blockDuration: BlockDuration.NONE,
  })
  ```

  NOTE: This kind of spot instance will be interrupted by AWS. However the fleet is using type [maintain](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet.html#spot-fleet-allocation-strategy), the fleet can be refulfilled.



  `cdk-spot-one` selects the latest Amazon Linux 2 AMI for your `ARM64` instances. Simply select the instance types with the `defaultInstanceType` property and the `SpotFleet` will auto configure correct AMI for the instance.

  ```python
  defaultInstanceType: new InstanceType('c6g.large')
  ```



  See https://github.com/pahud/cdk-spot-one/issues/270#issuecomment-877152685



  You may connect to the spot instance with [Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-sessions-start.html).

  ```sh

  $ session-manager-plugin

  $ aws ssm start-session --target INSTANCE_ID
  ```



  By default the `cdk-spot-one` does not bind any SSH public key for you on the instance. You are encouraged to use `ec2-instance-connect` to send your public key from local followed by one-time SSH connect.

  For example:

  ```sh
  pubkey="$HOME/.ssh/aws_2020_id_rsa.pub"
  echo "sending public key to ${instanceId}"
  aws ec2-instance-connect send-ssh-public-key --instance-id ${instanceId} --instance-os-user ec2-user \
  --ssh-public-key file://${pubkey} --availability-zone ${az}
  ```



  To connect to the instance, run `npx ec2-connect` as below:

  ```sh
  $ npx ec2-connect i-01f827ab9de7b93a9
  ```

  or

  ```sh
  $ npx ec2-connect i-01f827ab9de7b93a9 ~/.ssh/other_public_key_path
  ```

  If you are using different SSH public key(default is ~/.ssh/id_rsa.pub)


pkgId: 0e8b99d811ac3a4cd268609294ba9cedfaa0a6ac20b160ee83a7030a23e4cd44
name: python-cdk-ssm-document
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: CDK Construct for managing SSM Documents
url: https://github.com/udondan/cdk-ssm-document
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-ssm-document-3.1.1-1.src.rpm
checksum_type: sha256
description:
     AWSTemplateFormatVersion: "2010-09-09"
     Resources:
       SSMDocExecutionRole:
         Type: AWS::IAM::Role
         Properties:
           RoleName: CFN-Resource-Custom-SSM-Document
           AssumeRolePolicyDocument:
             Version: "2012-10-17"
             Statement:
               - Effect: Allow
                 Principal:
                   Service: lambda.amazonaws.com
                 Action: sts:AssumeRole
           ManagedPolicyArns:
             - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
             - Ref: SSMDocExecutionPolicy
       SSMDocExecutionPolicy:
         Type: AWS::IAM::ManagedPolicy
         Properties:
           ManagedPolicyName: CFN-Resource-Custom-SSM-Document
           PolicyDocument:
             Version: "2012-10-17"
             Statement:
               - Effect: Allow
                 Action:
                   - ssm:ListDocuments
                   - ssm:ListTagsForResource
                 Resource: "*"
               - Effect: Allow
                 Action:
                   - ssm:CreateDocument
                   - ssm:AddTagsToResource
                 Resource: "*"
                 Condition:
                   StringEquals:
                     aws:RequestTag/CreatedByCfnCustomResource: CFN::Resource::Custom::SSM-Document
               - Effect: Allow
                 Action:
                   - ssm:DeleteDocument
                   - ssm:DescribeDocument
                   - ssm:GetDocument
                   - ssm:ListDocumentVersions
                   - ssm:ModifyDocumentPermission
                   - ssm:UpdateDocument
                   - ssm:UpdateDocumentDefaultVersion
                   - ssm:AddTagsToResource
                   - ssm:RemoveTagsFromResource
                 Resource: "*"
                 Condition:
                   StringEquals:
                     aws:ResourceTag/CreatedByCfnCustomResource: CFN::Resource::Custom::SSM-Document
       SSMDocFunction:
         Type: AWS::Lambda::Function
         Properties:
           FunctionName: CFN-Resource-Custom-SSM-Document-Manager
           Code:
             S3Bucket: example-bucket
             S3Key: code.zip
           Handler: index.handler
           Runtime: nodejs10.x
           Timeout: 3
           Role: !GetAtt SSMDocExecutionRole.Arn
       MyDocument:
         Type: Custom::SSM-Document
         Properties:
           Name: MyDocument
           ServiceToken: !GetAtt SSMDocFunction.Arn
           StackName: !Ref AWS::StackName
           UpdateDefaultVersion: true # default: true
           Content:
             schemaVersion: "2.2"
             description: Echo Hello World!
             parameters:
               text:
                 type: String
                 description: Text to echo
                 default: Hello World!
             mainSteps:
               - name: echo
                 action: aws:runShellScript
                 inputs:
                   runCommand:
                     - echo "{{text}}"
                 precondition:
                   StringEquals:
                     - platformType
                     - Linux
           DocumentType: Command # default: Command
           TargetType: / # default: /
           Tags:
             CreatedByCfnCustomResource: CFN::Resource::Custom::SSM-Document # required, see above policy conditions
     ```


pkgId: e36546d62681ccf2a70832c35dd06d20f20dd6b905fd0df39f924cbc7583bf71
name: python-cdk-toolkit
arch: src
version: 0.0.89
epoch: 0
release: 1
summary: AWS Cloud Development Toolkit
url: http://pypi.python.org/pypi/cdk-toolkit/
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-toolkit-0.0.89-1.src.rpm
checksum_type: sha256
description:
  AWS CDK Toolkit


  [ ] CICD
      [X] CodeCommit - Create CodeCommit Repository
      [ ] CodeCommit - Existing CodeCommit Repository
      [X] CodeBuild - Docker Image Builder
      [ ] CodeDeploy - EKS
      [ ] CodeDeploy - ECS
      [ ] CodeDeploy - Lambda
      [ ] CodePipeline - Source, Build, Deploy
  [ ] CONNECTION
      [ ] VPC - Create VPC
      [ ] VPC - Existing VPC
  [ ] CONTAINER
      [X] ECR - Create ECR Repository
      [ ] ECR - Existing ECR Repository
      [ ] EKS - Create EKS Cluster
      [ ] EKS - Existing EKS Cluster
      [ ] EKS - Deploy Kubernetes Dashboard
  [ ] DATABASE
      [ ] RDS - Create PostGres RDS Instance
      [ ] RDS - Existing PostGres RDS Instance
      [ ] RDS - Create PostGres Users, Tables, Functions
      [ ] DynamoDB - Create DynamoDB Instance
      [ ] DynamoDB - Existing DynamoDB Instance
      [ ] DynamoDB - Create DynamoDB Users, Tables, Etc.
  [ ] DATALAKE
      [ ] LakeFormation - Register S3 Bucket
      [ ] LakeFormation - S3 Bucket Glue Crawler
  [ ] NOTEBOOK
      [ ] SageMaker - Create SageMaker Instance
      [ ] SageMaker - Create SageMaker ML Model Endpoint
  [ ] NOTIFICATION
      [ ] SNS - Create SNS Topic
      [ ] SQS - Create SQS Topic
  [ ] PERMISSION
      [ ] IAM - Create an IAM Service Role
      [ ] IAM - Add IAM Service Role Inline Permissions
  [ ] SERVERLESS
      [ ] Lambda - Create Lambda Function
  [ ] STORAGE
      [X] S3 - Create S3 Bucket






  ```bash
  npm install -g aws-cdk
  ```


  ```bash
  mkdir cdk-proj
  cd cdk-proj
  ```


  ```bash
  cdk init app --language python
  python3 -m venv .venv
  source .venv/bin/activate
  python3 -m pip install -r requirements.txt
  ```



  ```python
  from aws_cdk import (
      Stack,
  )
  from constructs import Construct

  from cdk_toolkit import storage

  class CdkProjStack(Stack):
      def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
          super().__init__(scope, construct_id, **kwargs)
          bucket_name = "cdk-proj-bucket-name-test"
          s3_bucket = storage.createS3Bucket(self, bucket_name, versioned=False)
  ```


  ```python

  import aws_cdk as cdk
  from aws_cdk import Aws, Stack, Tags

  from cdk_proj.cdk_proj_stack import CdkProjStack


  app = cdk.App()


  AWS_ACCOUNT_NUMBER="111111111"
  AWS_ACCOUNT_REGION="us-west-2"
  cdk_environment = cdk.Environment(account=AWS_ACCOUNT_NUMBER, region=AWS_ACCOUNT_REGION)


  CdkProjStack(app, "CdkProjStack", env=cdk_environment)

  app.synth()

  ```


  ```
  AWS_ACCOUNT_NUMBER=111111111
  AWS_ACCOUNT_REGION=us-west-2
  cdk bootstrap aws://$AWS_ACCOUNT_NUMBER/$AWS_ACCOUNT_REGION ---toolkit-stack-name CDK-TOOLKIT --qualifier cdktoolkit
  ```


  ```

  cdk diff


  cdk deploy


  cdk destroy
  ```




  [Federated Multi-Account Access for AWS CodeCommit](https://aws.amazon.com/blogs/devops/federated-multi-account-access-for-aws-codecommit/)

  [AWS CDK API Documentation](https://docs.aws.amazon.com/cdk/api/v2/python/modules.html)

  [AWS CDK + EKS!!!!!!!!!!!](https://aws.amazon.com/getting-started/guides/deploy-webapp-eks/)


  https://blog.dennisokeeffe.com/blog/2021-08-12-deploying-an-eks-fargate-cluster-with-the-aws-cdk


pkgId: 4ce7353a3398450d05543f52ef37e318c029dd9f5dc3c3bd0d12af1de0eccd5c
name: python-cdk-triggers
arch: src
version: 0.1.35
epoch: 0
release: 1
summary: Execute AWS Lambda handlers during deployments of AWS CDK stacks
url: https://github.com/awslabs/cdk-triggers.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-triggers-0.1.35-1.src.rpm
checksum_type: sha256
description:
  Please refer to the official AWS CDK documentation:

  * [Documentation](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.triggers-readme.html)
  * [Source Code](https://github.com/aws/aws-cdk/tree/master/packages/%40aws-cdk/triggers)



  ```python
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  import * as triggers from 'aws-cdk-lib/triggers';
  import { Stack } from 'aws-cdk-lib';
  import { Construct } from 'constructs';

  declare const stack: Stack;
  declare const resource1: Construct;
  declare const resource2: Construct;

  new triggers.TriggerFunction(stack, 'MyTrigger', {
    runtime: lambda.Runtime.NODEJS_12_X,
    handler: 'index.handler',
    code: lambda.Code.fromAsset(__dirname + '/my-trigger'),
    executeAfter: [resource1, resource2],
  });
  ```



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: d485c0060eae928c218d110e87c4564c94d931b5302c1a3953c2315955a0ec99
name: python-cdk-tweet-queue
arch: src
version: 2.0.630
epoch: 0
release: 1
summary: Defines an SQS queue with tweet stream from a search
url: https://github.com/cdklabs/cdk-tweet-queue
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-tweet-queue-2.0.630-1.src.rpm
checksum_type: sha256
description:
  This is an [AWS CDK](https://github.com/awslabs/aws-cdk) construct library which
  allows you to get a feed of Twitter search results into an SQS queue. It works
  by periodically polling the freely available [Twitter Standard Search
  API](https://developer.twitter.com/en/docs/tweets/search/api-reference/get-search-tweets.html) and
  sending all new tweets to an SQS queue.

  Inspired by
  [@jlhood](https://github.com/awslabs/aws-serverless-twitter-event-source/commits?author=jlhood)'s
  [aws-serverless-twitter-event-source](https://github.com/awslabs/aws-serverless-twitter-event-source)



  ![](https://github.com/eladb/cdk-tweet-queue/raw/main/images/architecture.png)

  1. A CloudWatch Event Rule triggers the poller AWS Lambda function periodically
  2. The poller reads the last checkpoint from a DynamoDB table (if exists)
  3. The poller issues a Twitter search query for all new tweets
  4. The poller enqueues all tweets to an SQS queue
  5. The poller stores the ID of the last tweet into the DynamoDB checkpoint table.
  6. Rinse & repeat.



  To issue a Twitter search request, you will need to
  [apply](https://developer.twitter.com/en/apply-for-access.html) for a Twitter
  developer account, and obtain API keys through by defining a [new
  application](http://twitter.com/oauth_clients/new).

  The Twitter API keys are read by the poller from an [AWS Secrets
  Manager](https://aws.amazon.com/secrets-manager/) entry. The entry must contain
  the following attributes: `consumer_key`, `consumer_secret`, `access_token_key`
  and `access_token_secret` (exact names).

  1. Create a new AWS Secrets Manager entry for your API keys
  2. Fill in the key values as shown below:
     ![](https://github.com/eladb/cdk-tweet-queue/raw/main/images/secretsmanager.png)
  3. Store the key
  4. Obtain the ARN of the secret (you will need it soon).



  Use `npm` to install the module in your CDK project. This will also add it to
  your `package.json` file.

  ```console
  $ npm install cdk-tweet-queue
  ```

  Add a `TweetQueue` to your CDK stack:

  ```python
  import { TweetQueue } from 'cdk-tweet-queue';

  const queue = new TweetQueue(this, 'TweetStream', {
    // this is the ARN of the secret you stored
    secretArn: 'arn:aws:secretsmanager:us-east-1:1234567891234:secret:xxxxxxxxx'

    // twitter search query
    // see https://developer.twitter.com/en/docs/tweets/search/guides/standard-operators
    query: '#awscdk',

    // optional properties
    intervalMin: 60,          // optional: polling interval in minutes
    retentionPeriodSec: 60,   // optional: queue retention period
    visibilityTimeoutSec: 60, // optional: queue visilibity timeout
  });
  ```

  Now, `queue` is an `sqs.Queue` object and can be used anywhere a queue is
  accepted. For example, you could process the queue messages using an AWS Lambda
  function by setting up an SQS event source mapping.



  The project is managed by [projen](https://github.com/projen/projen) and offers the following commands:

  * `yarn projen` - Synthesize the project configuration.
  * `yarn compile` - Compile all source code.
  * `yarn test` - Run all tests.
  * `yarn build` - Complie, test, and package the module.



  There is also an integration test that can be executed by running the following commands. You will need to set the `TWEET_QUEUE_SECRET_ARN` environment variable in order for the test to be able to use your Twitter API keys.

  ```console
  $ yarn integ:deploy
  ```

  Don't forget to destroy:

  ```console
  $ yarn integ:destroy
  ```

  You can also run any cdk command on the integration test application by running:

  ```console
  yarn integ <command>
  ```



  Apache-2.0


pkgId: eba3995af6327ddd2c8661f01961bca1a9bde163e6290664b9d1bc1f3ce70ae1
name: python-cdk-vpc-endpoint-with-private-ip
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: CDK Construct for a VPC Endpoint with private IPs
url: https://github.com/badmintoncryer/cdk-vpc-endpoint-with-private-ip.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-vpc-endpoint-with-private-ip-0.0.3-1.src.rpm
checksum_type: sha256
description:
  This is a CDK construct that retrieves the private IP address of an Interface VPC Endpoint:

  [![View on Construct Hub](https://constructs.dev/badge?package=cdk-vpc-endpoint-with-private-ip)](https://constructs.dev/packages/cdk-vpc-endpoint-with-private-ip)
  [![Open in Visual Studio Code](https://img.shields.io/static/v1?logo=visualstudiocode&label=&message=Open%20in%20Visual%20Studio%20Code&labelColor=2c2c32&color=007acc&logoColor=007acc)](https://open.vscode.dev/badmintoncryer/cdk-vpc-endpoint-with-private-ip)
  [![npm version](https://badge.fury.io/js/cdk-vpc-endpoint-with-private-ip.svg)](https://badge.fury.io/js/cdk-vpc-endpoint-with-private-ip)
  [![Build Status](https://github.com/badmintoncryer/cdk-vpc-endpoint-with-private-ip/actions/workflows/build.yml/badge.svg)](https://github.com/badmintoncryer/cdk-vpc-endpoint-with-private-ip/actions/workflows/build.yml)
  [![Release Status](https://github.com/badmintoncryer/cdk-vpc-endpoint-with-private-ip/actions/workflows/release.yml/badge.svg)](https://github.com/badmintoncryer/cdk-vpc-endpoint-with-private-ip/actions/workflows/release.yml)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![npm downloads](https://img.shields.io/npm/dm/cdk-vpc-endpoint-with-private-ip.svg?style=flat)](https://www.npmjs.com/package/cdk-vpc-endpoint-with-private-ip)



  ![Architecture](./images/architecture.png)



  ```bash
  npm install cdk-vpc-endpoint-with-private-ip
  ```



  You can create an interface VPC endpoint and retrive its private IP addresses using the `VpcEndpointWithPrivateIp` construct.

  The `ec2.InterfaceVpcEndpointProps` can be passed to the construct to configure the interface VPC endpoint.

  ```python
  import { InterfaceVpcEndpointWithPrivateIp } from 'cdk-vpc-endpoint-with-private-ip';
  import * as ec2 from 'aws-cdk-lib/aws-ec2';

  declare const vpc: ec2.IVpc;

  const endpoint = new InterfaceVpcEndpointWithPrivateIp(this, 'Endpoint', {
    vpc,
    service: ec2.InterfaceVpcEndpointAwsService.S3,
  });

  const privateIps = endpoint.privateIps;
  ```

  **Note**: `privateIps` is an array of CDK Tokens, and the actual IP addresses are not determined until the stack is deployed.



  I am greatly referencing the content of [this post](https://qiita.com/k_bobchin/items/c016cc65912a905b90ef).


pkgId: cb27637b874a06c5ad7bc6a6675d211d1d2bc1823f64559643999fdb2f6ce36d
name: python-cdk-wordpress
arch: src
version: 0.0.1000
epoch: 0
release: 1
summary: cdk-wordpress
url: https://github.com/clarencetw/cdk-wordpress.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk-wordpress-0.0.1000-1.src.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-wordpress.svg)](https://www.npmjs.com/package/cdk-wordpress)
  [![PyPI version](https://badge.fury.io/py/cdk-wordpress.svg)](https://pypi.org/project/cdk-wordpress)
  ![Release](https://github.com/clarencetw/cdk-wordpress/workflows/Release/badge.svg)

  ![npm](https://img.shields.io/npm/dt/cdk-wordpress?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-wordpress?label=pypi&color=blue)

  A CDK construct library to deploy WordPress



  Install your package manager:

  ```sh
  yarn add cdk-wordpress
  ```



  ```python
  import { WordPress } from "cdk-wordpress";

  const wordpress = new WordPress(stack, "WordPressEcs");

  // Get WordPress endpoint
  new CfnOutput(stack, "Endpoint", { value: wordpress.endpoint });
  ```



  ```bash
  cdk deploy
  ```



  ```bash
  cdk destroy
  ```


pkgId: 40c01764e6eea7eeda8a839e2190decb644a1e25cea6468a6674ca7c33ffa7a7
name: python-cdk8s
arch: src
version: 2.69.11
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-core.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-2.69.11-1.src.rpm
checksum_type: sha256
summary:
  This is the core library of Cloud Development Kit (CDK) for Kubernetes (cdk8s). cdk8s apps synthesize into standard Kubernetes manifests which can be applied to any Kubernetes cluster.

description:
  [![build](https://github.com/cdk8s-team/cdk8s-core/workflows/release/badge.svg)](https://github.com/cdk8s-team/cdk8s-core/actions/workflows/release.yml)
  [![npm version](https://badge.fury.io/js/cdk8s.svg)](https://badge.fury.io/js/cdk8s)
  [![PyPI version](https://badge.fury.io/py/cdk8s.svg)](https://badge.fury.io/py/cdk8s)
  [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.cdk8s/cdk8s/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.cdk8s/cdk8s)

  **cdk8s** is a software development framework for defining Kubernetes
  applications using rich object-oriented APIs. It allows developers to leverage
  the full power of software in order to define abstract components called
  "constructs" which compose Kubernetes resources or other constructs into
  higher-level abstractions.

  > **Note:** This repository is the "core library" of cdk8s, with logic for synthesizing Kubernetes manifests using the [constructs framework](https://github.com/aws/constructs). It is published to NPM as [`cdk8s`](https://www.npmjs.com/package/cdk8s) and should not be confused with the cdk8s command-line tool [`cdk8s-cli`](https://www.npmjs.com/package/cdk8s-cli). For more general information about cdk8s, please see [cdk8s.io](https://cdk8s.io), or visit the umbrella repository located at [cdk8s-team/cdk8s](https://github.com/cdk8s-team/cdk8s).



  See [cdk8s.io](https://cdk8s.io).



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team/cdk8s).


pkgId: 65396dcc40f94fe2398a177ceb33feec4d7a45750a11707f56bdbd3b09eaa4dd
name: python-cdk8s-awscdk-resolver
arch: src
version: 0.0.187
epoch: 0
release: 1
summary: @cdk8s/awscdk-resolver
url: https://github.com/cdk8s-team/cdk8s-awscdk-resolver.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-awscdk-resolver-0.0.187-1.src.rpm
checksum_type: sha256
description:
  The `AwsCdkResolver` is able to resolve any [`CfnOutput`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)
  defined by your AWS CDK application. In this example, we create an S3 `Bucket` with the AWS CDK, and pass its (deploy time generated)
  name as an environment variable to a Kubernetes `CronJob` resource.

  ```python
  import * as aws from 'aws-cdk-lib';
  import * as k8s from 'cdk8s';
  import * as kplus from 'cdk8s-plus-27';

  import { AwsCdkResolver } from '@cdk8s/awscdk-resolver';

  const awsApp = new aws.App();
  const stack = new aws.Stack(awsApp, 'aws');

  const k8sApp = new k8s.App({ resolvers: [new AwsCdkResolver()] });
  const manifest = new k8s.Chart(k8sApp, 'Manifest');

  const bucket = new aws.aws_s3.Bucket(stack, 'Bucket');
  const bucketName = new aws.CfnOutput(stack, 'BucketName', {
    value: bucket.bucketName,
  });

  new kplus.CronJob(manifest, 'CronJob', {
    schedule: k8s.Cron.daily(),
    containers: [{
      image: 'job',
      envVariables: {
        // directly passing the value of the `CfnOutput` containing
        // the deploy time bucket name
        BUCKET_NAME: kplus.EnvValue.fromValue(bucketName.value),
      }
   }]
  });

  awsApp.synth();
  k8sApp.synth();
  ```

  During cdk8s synthesis, the custom resolver will detect that `bucketName.value` is not a concrete value,
  but rather a value of a `CfnOutput`. It will then perform AWS service calls in order to fetch the
  actual value from the deployed infrastructure in your account. This means that in order
  for `cdk8s synth` to succeed, it must be executed *after* the AWS CDK resources
  have been deployed. So your deployment workflow should (conceptually) be:

  1. `cdk deploy`
  2. `cdk8s synth`

  > Note that the `AwsCdkResolver` is **only** able to fetch tokens that have a `CfnOutput` defined for them.



  Since running `cdk8s synth` will now require performing AWS service calls, it must have access
  to a set of AWS credentials. Following are the set of actions the credentials must allow:

  * `cloudformation:DescribeStacks`

  Note that the actions cdk8s require are far more scoped down than those normally required for the
  deployment of AWS CDK applications. It is therefore recommended to not reuse the same set of credentials,
  and instead create a scoped down `ReadOnly` role dedicated for cdk8s resolvers.



  As we've seen, your `cdk8s` application needs access to the objects defined in your cloud application. If both applications
  are defined within the same file, this is trivial to achieve. If they are in different files, a simple `import` statement will suffice.
  However, what if the applications are managed in two separate repositories? This makes it a little trickier, but still possible.

  In this scenario, `cdk.ts` in the AWS CDK application, stored in a dedicated repository.

  ```python
  import * as aws from 'aws-cdk-lib';

  const awsApp = new aws.App();
  const stack = new aws.Stack(awsApp, 'aws');

  const bucket = new aws.aws_s3.Bucket(stack, 'Bucket');
  const bucketName = new aws.CfnOutput(stack, 'BucketName', {
    value: bucket.bucketName,
  });

  awsApp.synth();
  ```

  In order for the `cdk8s` application to have cross repository access, the AWS CDK object instances that we want to expose need to be available
  via a package repository. To do this, break up the AWS CDK application into the following files:

  `app.ts`

  ```python
  import * as aws from 'aws-cdk-lib';

  const awsApp = new aws.App();
  const stack = new aws.Stack(awsApp, 'aws');

  const bucket = new aws.aws_s3.Bucket(stack, 'Bucket');
  // export the thing we want to have available for cdk8s applications
  export const bucketName = new aws.CfnOutput(stack, 'BucketName', {
    value: bucket.bucketName,
  });

  // note that we don't call awsApp.synth here
  ```

  `main.ts`

  ```python
  import { awsApp } from './app.ts'

  awsApp.synth();
  ```

  Now, publish the `app.ts` file to a package manager, so that your `cdk8s` application can install and import it.
  This approach might be somewhat counter intuitive, because normally we only publish classes to the package manager,
  not instances. Indeed, these types of applications introduce a new use-case that requires the sharing of instances.
  Conceptually, this is no different than writing state<sup>*</sup> to an SSM parameter or an S3 bucket, and it allows us to remain
  in the boundaries of our programming language, and the typing guarantees it provides.

  > <sup>*</sup> Actually, we are only publishing instructions for fetching state, not the state itself.

  Assuming `app.ts` was published as the `my-cdk-app` package, our `cdk8s` application will now look like so:

  ```python
  import * as k8s from 'cdk8s';
  import * as kplus from 'cdk8s-plus-27';

  // import the desired instance from the AWS CDK app.
  import { bucketName } from 'my-cdk-app';

  import { AwsCdkResolver } from '@cdk8s/awscdk-resolver';

  const k8sApp = new k8s.App({ resolvers: [new AwsCdkResolver()] });
  const manifest = new k8s.Chart(k8sApp, 'Manifest');

  new kplus.CronJob(manifest, 'CronJob', {
    schedule: k8s.Cron.daily(),
    containers: [{
      image: 'job',
      envVariables: {
        // directly passing the value of the `CfnOutput` containing
        // the deploy time bucket name
        BUCKET_NAME: kplus.EnvValue.fromValue(bucketName.value),
      }
   }]
  });

  k8sApp.synth();
  ```


pkgId: 2151d698145e51c66a24d599d557181e3c1d4cc5cb8ecd79627cf30a4f352215
name: python-cdk8s-cdktf-resolver
arch: src
version: 0.0.118
epoch: 0
release: 1
summary: @cdk8s/cdktf-resolver
url: https://github.com/cdk8s-team/cdk8s-cdktf-resolver.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-cdktf-resolver-0.0.118-1.src.rpm
checksum_type: sha256
description:
  The `CdkTfResolver` is able to resolve any [`TerraformOutput`](https://developer.hashicorp.com/terraform/cdktf/concepts/variables-and-outputs#output-values)
  defined by your CDKTF application. In this example, we create an S3 `Bucket` with the CDKTF, and pass its (deploy time generated)
  name as an environment variable to a Kubernetes `CronJob` resource.

  ```python
  import * as tf from "cdktf";
  import * as aws from "@cdktf/provider-aws";
  import * as k8s from 'cdk8s';
  import * as kplus from 'cdk8s-plus-26';

  import { CdkTfResolver } from '@cdk8s/cdktf-resolver';

  const awsApp = new tf.App();
  const stack = new tf.TerraformStack(awsApp, 'aws');

  const k8sApp = new k8s.App({ resolvers: [new resolver.CdktfResolver({ app: awsApp })] });
  const manifest = new k8s.Chart(k8sApp, 'Manifest', { resolver });

  const bucket = new aws.s3Bucket.S3Bucket(stack, 'Bucket');
  const bucketName = new tf.TerraformOutput(constrcut, 'BucketName', {
    value: bucket.bucket,
  });

  new kplus.CronJob(manifest, 'CronJob', {
    schedule: k8s.Cron.daily(),
    containers: [{
      image: 'job',
      envVariables: {
        // directly passing the value of the `TerraformOutput` containing
        // the deploy time bucket name
        BUCKET_NAME: kplus.EnvValue.fromValue(bucketName.value),
      }
   }]
  });

  awsApp.synth();
  k8sApp.synth();
  ```

  During cdk8s synthesis, the custom resolver will detect that `bucketName.value` is not a concrete value,
  but rather a value of a `TerraformOutput`. It will then perform `cdktf` CLI commands in order to fetch the
  actual value from the deployed infrastructure in your account. This means that in order
  for `cdk8s synth` to succeed, it must be executed *after* the CDKTF resources
  have been deployed. So your deployment workflow should (conceptually) be:

  1. `cdktf deploy`
  2. `cdk8s synth`

  > Note that the `CdkTfResolver` is **only** able to fetch tokens that have a `TerraformOutput` defined for them.



  Since running `cdk8s synth` will now require reading terraform outputs, it must have permissions to do so.
  In case a remote state file is used, this means providing a set of credentials for the account that have access
  to where the state is stored. This will vary depending on your cloud provider, but in most cases will involve giving
  read permissions on a blob storage device (e.g S3 bucket).

  Note that the permissions cdk8s require are far more scoped down than those normally required for the
  deployment of CDKTF applications. It is therefore recommended to not reuse the same set of credentials,
  and instead create a scoped down `ReadOnly` role dedicated for cdk8s resolvers.

  Following are the set of commands the resolver will execute:

  * [`cdktf output`](https://developer.hashicorp.com/terraform/cdktf/cli-reference/commands#output)



  As we've seen, your `cdk8s` application needs access to the objects defined in your cloud application. If both applications
  are defined within the same file, this is trivial to achieve. If they are in different files, a simple `import` statement will suffice.
  However, what if the applications are managed in two separate repositories? This makes it a little trickier, but still possible.

  In this scenario, `cdktf.ts` in the CDKTF application, stored in a dedicated repository.

  ```python
  import * as tf from "cdktf";
  import * as aws from "@cdktf/provider-aws";

  import { CdkTfResolver } from '@cdk8s/cdktf-resolver';

  const awsApp = new tf.App();
  const stack = new tf.TerraformStack(awsApp, 'aws');

  const bucket = new aws.s3Bucket.S3Bucket(stack, 'Bucket');
  const bucketName = new tf.TerraformOutput(constrcut, 'BucketName', {
    value: bucket.bucket,
  });

  awsApp.synth();
  ```

  In order for the `cdk8s` application to have cross repository access, the CDKTF object instances
  that we want to expose need to be available via a package repository. To do this, break up the
  CDKTF application into the following files:

  `app.ts`

  ```python
  import * as tf from "cdktf";
  import * as aws from "@cdktf/provider-aws";

  import { CdkTfResolver } from '@cdk8s/cdktf-resolver';

  // export the app so we can pass it to the cdk8s resolver
  export const awsApp = new tf.App();
  const stack = new tf.TerraformStack(awsApp, 'aws');

  const bucket = new aws.s3Bucket.S3Bucket(stack, 'Bucket');
  // export the thing we want to have available for cdk8s applications
  export const bucketName = new tf.TerraformOutput(constrcut, 'BucketName', {
    value: bucket.bucket,
  });

  // note that we don't call awsApp.synth here
  ```

  `main.ts`

  ```python
  import { awsApp } from './app.ts'

  awsApp.synth();
  ```

  Now, publish the `app.ts` file to a package manager, so that your `cdk8s` application can install and import it.
  This approach might be somewhat counter intuitive, because normally we only publish classes to the package manager,
  not instances. Indeed, these types of applications introduce a new use-case that requires the sharing of instances.
  Conceptually, this is no different than writing state<sup>*</sup> to an SSM parameter or an S3 bucket, and it allows us to remain
  in the boundaries of our programming language, and the typing guarantees it provides.

  > <sup>*</sup> Actually, we are only publishing instructions for fetching state, not the state itself.

  Assuming `app.ts` was published as the `my-cdktf-app` package, our `cdk8s` application will now look like so:

  ```python
  import * as k8s from 'cdk8s';
  import * as kplus from 'cdk8s-plus-27';

  // import the desired instance from the CDKTF app.
  import { bucketName, awsApp } from 'my-cdktf-app';

  import { CdkTfResolver } from '@cdk8s/cdktf-resolver';

  const k8sApp = new k8s.App({ resolvers: [new resolver.CdktfResolver({ app: awsApp })] });
  const manifest = new k8s.Chart(k8sApp, 'Manifest');

  new kplus.CronJob(manifest, 'CronJob', {
    schedule: k8s.Cron.daily(),
    containers: [{
      image: 'job',
      envVariables: {
        // directly passing the value of the `TerraformOutput` containing
        // the deploy time bucket name
        BUCKET_NAME: kplus.EnvValue.fromValue(bucketName.value),
      }
   }]
  });

  k8sApp.synth();
  ```


pkgId: bbfae4f331d30831c9045b7d60b3680602930143066be5adf25bd10875ec5cbb
name: python-cdk8s-grafana
arch: src
version: 0.1.658
epoch: 0
release: 1
summary: Grafana construct for cdk8s.
url: https://github.com/cdk8s-team/cdk8s-grafana.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-grafana-0.1.658-1.src.rpm
checksum_type: sha256
description:
  [![View on Construct Hub](https://constructs.dev/badge?package=cdk8s-grafana)](https://constructs.dev/packages/cdk8s-grafana)

  cdk8s-grafana is a library that lets you easily define a Grafana service for
  your kubernetes cluster along with associated dashboards and datasources, using
  a high level API.



  To apply the resources generated by this construct, the Grafana operator must be
  installed on your cluster. See
  [https://operatorhub.io/operator/grafana-operator](https://operatorhub.io/operator/grafana-operator) for full installation
  instructions.

  The following will define a Grafana cluster connected to a Prometheus
  datasource:

  ```python
  import { Grafana } from 'cdk8s-grafana';

  // inside your chart:
  const grafana = new Grafana(this, 'my-grafana', {
    defaultDataSource: {
      name: 'Prometheus',
      type: 'prometheus',
      access: 'proxy',
      url: 'http://prometheus-service:9090',
    }
  });
  ```

  Basic aspects of a dashboard can be customized:

  ```python
  const github = grafana.addDatasource('github', ...);
  const dashboard = grafana.addDashboard('my-dashboard', {
    title: 'My Dashboard',
    refreshRate: Duration.seconds(10),
    timeRange: Duration.hours(6), // show metrics from now-6h to now
    plugins: [
      {
        name: 'grafana-piechart-panel',
        version: '1.3.6',
      }
    ],
  });
  ```

  Note: the kubernetes grafana operator only supports one Grafana instance per
  namespace (see https://github.com/grafana-operator/grafana-operator/issues/174).
  This may require specifying namespaces explicitly, e.g.:

  ```python
  const devGrafana = new Grafana(this, 'my-grafana', {
    namespace: 'dev',
  });
  const prodGrafana = new Grafana(this, 'my-grafana', {
    namespace: 'prod',
  });
  ```

  The grafana operator must be installed in each namespace for the resources in
  that namespace to be recognized.



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more
  information.



  This project is licensed under the Apache-2.0 License.


pkgId: 3ccab9a124e7dc02799fd1b6c130fc0da3f81bd1d80d0e649299ff323fc0b2dc
name: python-cdk8s-image
arch: src
version: 0.2.644
epoch: 0
release: 1
summary: Build & Push local docker images inside CDK8s applications
url: https://github.com/cdk8s-team/cdk8s-image.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-image-0.2.644-1.src.rpm
checksum_type: sha256
description:
  An `Image` construct which takes care of building & pushing docker images that
  can be used in [CDK8s](https://github.com/awslabs/cdk8s) apps.

  The following example will build the docker image from `Dockerfile` under the
  `my-app` directory, push it to a local registry and then define a Kubernetes
  deployment that deploys containers that run this image.

  ```python
  const image = new Image(this, 'image', {
    dir: `${__dirname}/my-app`,
    registry: 'localhost:5000'
  });

  new Deployment(this, 'deployment', {
    containers: [ new Container({ image: image.url }) ],
  });
  ```



  All contributions are celebrated.



  Licensed under [Apache 2.0](./LICENSE).


pkgId: 881e10027854708bff22bf6418938160218c3f875a8738c5b3ece1286ba1465e
name: python-cdk8s-jenkins
arch: src
version: 0.0.459
epoch: 0
release: 1
summary: Jenkins construct for CDK8s
url: https://github.com/cdk8s-team/cdk8s-jenkins.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-jenkins-0.0.459-1.src.rpm
checksum_type: sha256
description:
  `cdk8s-jenkins` is a library that lets you easily define a manifest for deploying a Jenkins instance to your Kubernetes cluster.



  This library uses a Custom Resource Definition provided by jenkins, and thus requires both the CRD and the operator to be installed on the cluster.
  You can set this up by,

  1. Apply the Custom Resource Definition(CRD) for jenkins on your Kubernetes cluster.

  ```
  kubectl apply -f https://raw.githubusercontent.com/jenkinsci/kubernetes-operator/master/config/crd/bases/jenkins.io_jenkins.yaml
  ```

  1. Install the Jenkins Operator on your Kubernetes cluster.

  ```
  kubectl apply -f https://raw.githubusercontent.com/jenkinsci/kubernetes-operator/master/deploy/all-in-one-v1alpha2.yaml
  ```

  > For more information regarding applying jenkins crd and installing jenkins operator, please refer [jenkins official documentaion](https://jenkinsci.github.io/kubernetes-operator/docs/getting-started/latest/installing-the-operator/).



  The library provides a high level `Jenkins` construct to provision a Jenkins instance.
  You can just instantiate the Jenkins instance and that would add a Jenkins resource to the kubernetes manifest.

  The library provide a set of defaults, so provisioning a basic Jenkins instance requires no configuration:

  ```python
  import { Jenkins } from 'cdk8s-jenkins';

  // inside your chart:
  const jenkins = new Jenkins(this, 'my-jenkins');
  ```

  The library also enables configuring the following parmeters for the Jenkins instance:



  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    metadata: {
      namespace: 'jenkins-namespace',
      labels: { customApp: 'my-jenkins' },
    },
  });
  ```



  This allows you to toggle CSRF Protection for Jenkins.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    disableCsrfProtection: true,
  });
  ```



  These are the plugins required by the jenkins operator.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    basePlugins: [{
      name: 'configuration-as-code',
      version: '1.55',
      }],
  });
  ```

  You can also utilize `addBasePlugins` function to add base plugins to jenkins configuration after initialization.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins');
  jenkins.addBasePlugins([{
    name: 'workflow-api',
    version: '2.76',
  }]);
  ```



  These are the plugins that you can add to your jenkins instance.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    plugins: [{
      name: 'simple-theme-plugin',
      version: '0.7',
      }],
  });
  ```

  You can also utilize `addPlugins` function to add plugins to jenkins configuration after initialization.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins');
  jenkins.addPlugins([{
    name: 'simple-theme-plugin',
    version: '0.7',
  }]);
  ```



  You can define list of jenkins seed job configurations here. For more info you can take look at [jenkins documentation](https://jenkinsci.github.io/kubernetes-operator/docs/getting-started/latest/configuring-seed-jobs-and-pipelines/).

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    seedJobs: [{
      id: 'jenkins-operator',
      targets: 'cicd/jobs/*.jenkins',
      description: 'Jenkins Operator repository',
      repositoryBranch: 'master',
      repositoryUrl: 'https://github.com/jenkinsci/kubernetes-operator.git',
      }],
  });
  ```

  You can also utilize `addSeedJobs` function to add seed jobs to jenkins configuration after initialization.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins');
  jenkins.addSeedJobs([{
    id: 'jenkins-operator',
    targets: 'cicd/jobs/*.jenkins',
    description: 'Jenkins Operator repository',
    repositoryBranch: 'master',
    repositoryUrl: 'https://github.com/jenkinsci/kubernetes-operator.git',
  }]);
  ```



  You can utilize escape hatches to make changes to the configurations that are not yet exposed by the library.

  For instance, if you would like to update the version of a base plugin:

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins');
  const jenkinsApiObject = ApiObject.of(jenkins);
  jenkinsApiObject.addJsonPatch(JsonPatch.replace('/spec/master/basePlugins/1', {
    name: 'workflow-job',
    version: '3.00',
  }));
  ```

  For more information regarding escape hatches, take a look at [cdk8s documentation](https://cdk8s.io/docs/latest/concepts/escape-hatches/).



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more
  information.



  This project is licensed under the Apache-2.0 License.


pkgId: adfd84f939dd375377a63d6240f2291f9ffb7fdaa2cb8a470ed0f4d796932afd
name: python-cdk8s-operator
arch: src
version: 0.1.315
epoch: 0
release: 1
summary: Create Kubernetes CRD Operators using CDK8s Constructs
url: https://github.com/cdk8s-team/cdk8s-operator.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-operator-0.1.315-1.src.rpm
checksum_type: sha256
description:
  apiVersion: "v1"
  kind: "Pod"
  metadata:
    name: "my-collection-pod-1-c89f58d7"
  spec:
    containers:
      - env: []
        image: "paulbouwer/hello-kubernetes"
        imagePullPolicy: "Always"
        name: "main"
        ports: []
        volumeMounts: []


pkgId: d0dc606fc7299895f1fea311d59978d873ae15087bf30693a9289d7d977fb16c
name: python-cdk8s-plone
arch: src
version: 0.0.43
epoch: 0
release: 1
summary: Provides a CMS Plone Backend and Frontend for Kubernetes with cdk8s
url: https://github.com/bluedynamics/cdk8s-plone.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plone-0.0.43-1.src.rpm
checksum_type: sha256
description:
  This chart provides a library to bootstrap a Plone deployment on a Kubernetes cluster using the [CDK8S](https://cdk8s.io) framework.

  It provides

  * Backend (as API with `plone.volto` or as Classic-UI)
  * Frontend (Plone-Volto, a ReactJS based user interface)
  * Varnish using kube-httpcache. It includes a way to invalidate varnish cluster (optional)



  To use this library, create a new CDK8S project (or use an existing one)

  ```bash
  cdk8s init typescript-app
  ```

  Then add the following dependency to `package.json`:

  ```json
  {
    "dependencies": {
      "@bluedynamics/cdk8s-plone": "*"
    }
  }
  ```

  Run `npm install` to install the new dependency.



  Todo: Document in details how to install.

  ```bash
  cdk8s init python-app
  ```

  Python package name is [cdk8s-plone](https://pypi.org/project/cdk8s-plone/).



  With `cdk8s-cli` installed, create a new project:

  ```bash
  cdk8s sythn
  ```

  Add the following code to your `main.ts`:

  ```python
  ...
  import { Plone } from '@bluedynamics/cdk8s-plone';
  ...
      super(scope, id, props);

      // define resources here
      new Plone(this, 'Plone', {});
  ...
  ```

  Run `npm run build ` to generate the Kubernetes manifests.
  The manifests are stored in the `dist` directory.

  For more have a look at the [example project](https://github.com/bluedynamics/cdk8s-plone-example).



  Clone the repository and install the dependencies:

  ```bash
  ```

  nvm use lts/*
  corepack enable
  npx projen

  ```

  Then run the following command to run the test:

  ```bash
  npx projen test
  ```


pkgId: a4bc8e63dfa837741ce585dac93f758f26a7cba31239b382e3f2a040c69d51f1
name: python-cdk8s-plus-17
arch: src
version: 0.33.0
epoch: 0
release: 1
summary: High level abstractions on top of cdk8s
url: https://github.com/awslabs/cdk8s.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-17-0.33.0-1.src.rpm
checksum_type: sha256
description:
  > ![Experimental](https://img.shields.io/badge/experimental-important.svg?style=for-the-badge)<br><br>
  > This library is in very early stages of development, as such, and in correspondence with a `0.x` semantic major version line, its `API` is
  > likely to rapidly change in breaking ways. It is therefore not recommended to use library for production workloads.

  **cdk8s+** is a software development framework that provides high level abstractions for authoring Kubernetes applications.
  Built on top of the auto generated building blocks provided by [cdk8s](../cdk8s), this library includes a hand crafted *construct*
  for each native kubernetes object, exposing richer API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/awslabs/cdk8s).


pkgId: 885970d801346b084a40f1e8a29da82c8bce6a9d8cd797a832e54e6d5544759b
name: python-cdk8s-plus-20
arch: src
version: 2.0.0b11
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-20-2.0.0b11-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-20 synthesizes Kubernetes manifests for Kubernetes 1.20.0

description:
  ![Stability:Beta](https://img.shields.io/badge/stability-beta-orange)
  [![cdk8s-plus-22](https://img.shields.io/github/workflow/status/cdk8s-team/cdk8s-plus/release-k8s.22?label=cdk8s-plus-22&logo=GitHub)](https://github.com/cdk8s-team/cdk8s-plus/actions/workflows/release-k8s.22.yml)
  [![cdk8s-plus-21](https://img.shields.io/github/workflow/status/cdk8s-team/cdk8s-plus/release-k8s.21?label=cdk8s-plus-21&logo=GitHub)](https://github.com/cdk8s-team/cdk8s-plus/actions/workflows/release-k8s.21.yml)
  [![cdk8s-plus-20](https://img.shields.io/github/workflow/status/cdk8s-team/cdk8s-plus/release-k8s.20?label=cdk8s-plus-20&logo=GitHub)](https://github.com/cdk8s-team/cdk8s-plus/actions/workflows/release-k8s.20.yml)

  | k8s version | npm (JS/TS) | PyPI (Python) | NuGet (C#) | Maven (Java) | Go |
  | --- | --- | --- | --- | --- | --- |
  | 1.20.0 | [Link](https://www.npmjs.com/package/cdk8s-plus-20) | [Link](https://pypi.org/project/cdk8s-plus-20/) | [Link](https://www.nuget.org/packages/Org.Cdk8s.Plus20) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-20) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.20) |
  | 1.21.0 | [Link](https://www.npmjs.com/package/cdk8s-plus-21) | [Link](https://pypi.org/project/cdk8s-plus-21/) | [Link](https://www.nuget.org/packages/Org.Cdk8s.Plus21) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-21) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.21) |
  | 1.22.0 | [Link](https://www.npmjs.com/package/cdk8s-plus-22) | [Link](https://pypi.org/project/cdk8s-plus-22/) | [Link](https://www.nuget.org/packages/Org.Cdk8s.Plus22) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-22) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.22) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 9d65cb04200651110ac11fe2325cdd531398fbe2173d7776cab1fa0afab74637
name: python-cdk8s-plus-22
arch: src
version: 2.0.0rc158
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-22-2.0.0rc158-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-22 synthesizes Kubernetes manifests for Kubernetes 1.22.0

description:
  ![Stability:Beta](https://img.shields.io/badge/stability-beta-orange)
  [![cdk8s-plus-22](https://img.shields.io/github/workflow/status/cdk8s-team/cdk8s-plus/release-k8s.22?label=cdk8s-plus-22&logo=GitHub)](https://github.com/cdk8s-team/cdk8s-plus/actions/workflows/release-k8s.22.yml)
  [![cdk8s-plus-23](https://img.shields.io/github/workflow/status/cdk8s-team/cdk8s-plus/release-k8s.23?label=cdk8s-plus-23&logo=GitHub)](https://github.com/cdk8s-team/cdk8s-plus/actions/workflows/release-k8s.23.yml)
  [![cdk8s-plus-24](https://img.shields.io/github/workflow/status/cdk8s-team/cdk8s-plus/release-k8s.24?label=cdk8s-plus-24&logo=GitHub)](https://github.com/cdk8s-team/cdk8s-plus/actions/workflows/release-k8s.24.yml)

  | k8s version | npm (JS/TS) | PyPI (Python) | Maven (Java) | Go |
  | --- | --- | --- | --- | --- |
  | 1.22.0 | [Link](https://www.npmjs.com/package/cdk8s-plus-22) | [Link](https://pypi.org/project/cdk8s-plus-22/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-22) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.22) |
  | 1.23.0 | [Link](https://www.npmjs.com/package/cdk8s-plus-23) | [Link](https://pypi.org/project/cdk8s-plus-23/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-23) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.23) |
  | 1.24.0 | [Link](https://www.npmjs.com/package/cdk8s-plus-24) | [Link](https://pypi.org/project/cdk8s-plus-24/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-24) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.24) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 566954b4cbd8e7137f5a16872af709bd2bf01f1bddcea2cfcb3bbbd01d9b0e83
name: python-cdk8s-plus-23
arch: src
version: 2.4.30
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-23-2.4.30-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-23 synthesizes Kubernetes manifests for Kubernetes 1.23.0

description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)
  [![cdk8s-plus-23](https://img.shields.io/github/workflow/status/cdk8s-team/cdk8s-plus/release-k8s.23?label=cdk8s-plus-23&logo=GitHub)](https://github.com/cdk8s-team/cdk8s-plus/actions/workflows/release-k8s.23.yml)
  [![cdk8s-plus-24](https://img.shields.io/github/workflow/status/cdk8s-team/cdk8s-plus/release-k8s.24?label=cdk8s-plus-24&logo=GitHub)](https://github.com/cdk8s-team/cdk8s-plus/actions/workflows/release-k8s.24.yml)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.21.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-21) | [Link](https://pypi.org/project/cdk8s-plus-21/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-21) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.21) |
  | 1.22.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-22) | [Link](https://pypi.org/project/cdk8s-plus-22/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-22) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.22) |
  | 1.23.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-23) | [Link](https://pypi.org/project/cdk8s-plus-23/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-23) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.23) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: c35e91f96be2237c4e7f647af5860cf3c732056c422344d961ebb825c52916b3
name: python-cdk8s-plus-24
arch: src
version: 2.12.1
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-24-2.12.1-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-24 synthesizes Kubernetes manifests for Kubernetes 1.24.0

description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.22.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-22) | [Link](https://pypi.org/project/cdk8s-plus-22/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-22) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.22) |
  | 1.23.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-23) | [Link](https://pypi.org/project/cdk8s-plus-23/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-23) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.23) |
  | 1.24.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-24) | [Link](https://pypi.org/project/cdk8s-plus-24/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-24) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.24) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: a81ba0624b0d1037ffd3878a690a9cfd7dc98149e0478dcf1060797e36574d85
name: python-cdk8s-plus-25
arch: src
version: 2.22.79
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-25-2.22.79-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-25 synthesizes Kubernetes manifests for Kubernetes 1.25.0

description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.23.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-23) | [Link](https://pypi.org/project/cdk8s-plus-23/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-23) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.23) |
  | 1.24.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-24) | [Link](https://pypi.org/project/cdk8s-plus-24/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-24) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.24) |
  | 1.25.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-25) | [Link](https://pypi.org/project/cdk8s-plus-25/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-25) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.25) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 0247890cd29f2abbc101e94b90bff388da25d63cf60f85a477dc2ac553aa1fc8
name: python-cdk8s-plus-26
arch: src
version: 2.18.90
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-26-2.18.90-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-26 synthesizes Kubernetes manifests for Kubernetes 1.26.0

description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.24.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-24) | [Link](https://pypi.org/project/cdk8s-plus-24/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-24) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.24) |
  | 1.25.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-25) | [Link](https://pypi.org/project/cdk8s-plus-25/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-25) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.25) |
  | 1.26.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-26) | [Link](https://pypi.org/project/cdk8s-plus-26/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-26) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.26) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 9002c4eb24272dcb995fbd5c0500ef365f89d467fa57b6d5e29845235c9181d2
name: python-cdk8s-plus-27
arch: src
version: 2.9.5
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-27-2.9.5-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-27 synthesizes Kubernetes manifests for Kubernetes 1.27.0

description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.25.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-25) | [Link](https://pypi.org/project/cdk8s-plus-25/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-25) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.25) |
  | 1.26.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-26) | [Link](https://pypi.org/project/cdk8s-plus-26/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-26) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.26) |
  | 1.27.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-27) | [Link](https://pypi.org/project/cdk8s-plus-27/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-27) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.27) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 1aede0bcd07241581bf187ad06da24e2323db60448927f21c0a4b5102b94b888
name: python-cdk8s-plus-28
arch: src
version: 2.5.6
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-28-2.5.6-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-28 synthesizes Kubernetes manifests for Kubernetes 1.28.0

description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.26.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-26) | [Link](https://pypi.org/project/cdk8s-plus-26/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-26) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.26) |
  | 1.27.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-27) | [Link](https://pypi.org/project/cdk8s-plus-27/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-27) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.27) |
  | 1.28.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-28) | [Link](https://pypi.org/project/cdk8s-plus-28/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-28) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.28) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 1b70465229796604d336bd23214f172140f10aafa019a2f2542eb63bde578fe9
name: python-cdk8s-plus-29
arch: src
version: 2.5.6
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-29-2.5.6-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-29 synthesizes Kubernetes manifests for Kubernetes 1.29.0

description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.27.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-27) | [Link](https://pypi.org/project/cdk8s-plus-27/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-27) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.27) |
  | 1.28.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-28) | [Link](https://pypi.org/project/cdk8s-plus-28/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-28) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.28) |
  | 1.29.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-29) | [Link](https://pypi.org/project/cdk8s-plus-29/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-29) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.29) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 4c0e14e1fd941ea261346d65181a0c2323ba569c331273c94d295047e38cec27
name: python-cdk8s-plus-30
arch: src
version: 2.2.8
epoch: 0
release: 1
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-plus-30-2.2.8-1.src.rpm
checksum_type: sha256
summary:
  cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-30 synthesizes Kubernetes manifests for Kubernetes 1.30.0

description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.28.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-28) | [Link](https://pypi.org/project/cdk8s-plus-28/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-28) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.28) |
  | 1.29.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-29) | [Link](https://pypi.org/project/cdk8s-plus-29/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-29) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.29) |
  | 1.30.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-30) | [Link](https://pypi.org/project/cdk8s-plus-30/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-30) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.30) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 88eb9109a907c01fac42bcb4a03593ea4cb4752db692486c89ae99bf2c9f4c7a
name: python-cdk8s-redis
arch: src
version: 0.1.790
epoch: 0
release: 1
summary: Basic implementation of a Redis construct for cdk8s.
url: https://github.com/cdk8s-team/cdk8s-redis.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-redis-0.1.790-1.src.rpm
checksum_type: sha256
description:
  > Redis constructs for cdk8s

  Basic implementation of a Redis construct for cdk8s. Contributions are welcome!



  The following will define a Redis cluster with a primary and 2 replicas:

  ```python
  import { Redis } from 'cdk8s-redis';

  // inside your chart:
  const redis = new Redis(this, 'my-redis');
  ```

  DNS names can be obtained from `redis.primaryHost` and `redis.replicaHost`.

  You can specify how many replicas to define:

  ```python
  new Redis(this, 'my-redis', {
    replicas: 4
  });
  ```

  Or, you can specify no replicas:

  ```python
  new Redis(this, 'my-redis', {
    replicas: 0
  });
  ```



  Distributed under the [Apache 2.0](./LICENSE) license.


pkgId: df36eca994da6b2ca96ae23ba37ddb167584603b866ae8cdb001bc2afbd1e136
name: python-cdk8s-valheim
arch: src
version: 0.0.270
epoch: 0
release: 1
summary: A package that vends a Valheim server chart.
url: https://github.com/awlsring/cdk8s-valheim.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdk8s-valheim-0.0.270-1.src.rpm
checksum_type: sha256
description:
  This is a [CDK8s](https://cdk8s.io/) project that defines a Kubernetes deployment for [Valheim](https://www.valheimgame.com/) using the [lloesche/valheim-server](https://github.com/lloesche/valheim-server-docker) image.



  A default deployment can be created with:

  ```python
  new ValheimChart(app, 'valheim')
  ```

  Default deployment will produce a server configured with all default [environment variables](https://github.com/lloesche/valheim-server-docker#environment-variables). The container will request resources for the games minimum recommended specs of 2 CPU and 4GB of memory.

  Settings can be customized by passing in a `ValheimChartProps` object. This will allow you to configure all supported environment customizations and container configurations

  ```python
  new ValheimChart(app, 'valheim', {
    server: {
      name: 'K8S Valheim',
      worldName: 'K8S',
      password: {
        raw: 'password',
      },
    },
  })
  ```



  By default, the server will store its data on a host path. This is not recommended as your world data can easily be lost.

  This chart allows for storing the data on a PersistentVolumeClaim. Two pvcs can be created, one for the world data and one for the configuration. The world data is mounted at `/opt/valheim/data` directory and the configuration is mounted at `/config` directory.

  To create these, the PVCs can be configured as follows:

  ```python
  new ValheimChart(app, 'valheim'. {
      persistence: {
      server: {
        storageClass: "my-class",
      },
      config: {
        storageClass: "my-class",
      },
    },
  })
  ```


pkgId: 5e8f1a6489bab345892d16ba659e5084a610e63452a4fff2e9a52022c5957d84
name: python-cdkactions
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Cloud Development Kit for GitHub Actions
url: https://github.com/ArmaanT/cdkactions.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdkactions-0.2.3-1.src.rpm
checksum_type: sha256
description:
  See the [main README](https://github.com/ArmaanT/cdkactions/) for an overview of cdkactions.

  See the [API reference](https://github.com/ArmaanT/cdkactions/blob/master/packages/cdkactions/API.md) for detailed information about the cdkactions constructs.



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).


pkgId: 1240aea1480823cf193658ac888d5495ce762b50de0713b33f07b3d8361a59db
name: python-cdklabs.appsync-utils
arch: src
version: 0.0.550
epoch: 0
release: 1
summary: Utilities for creating appsync apis using aws-cdk
url: https://github.com/cdklabs/awscdk-appsync-utils.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.appsync-utils-0.0.550-1.src.rpm
checksum_type: sha256
description:
  This package contains various utilities for definining GraphQl Apis via AppSync using the [aws-cdk](https://github.com/aws/aws-cdk).



  `CodeFirstSchema` offers the ability to generate your schema in a code-first
  approach. A code-first approach offers a developer workflow with:

  * **modularity**: organizing schema type definitions into different files
  * **reusability**: removing boilerplate/repetitive code
  * **consistency**: resolvers and schema definition will always be synced

  The code-first approach allows for **dynamic** schema generation. You can
  generate your schema based on variables and templates to reduce code
  duplication.

  ```python
  import { GraphqlApi } from '@aws-cdk/aws-appsync-alpha';
  import { CodeFirstSchema } from 'awscdk-appsync-utils';

  const schema = new CodeFirstSchema();
  const api = new GraphqlApi(this, 'api', { name: 'myApi', schema });

  schema.addType(new ObjectType('demo', {
    definition: { id: GraphqlType.id() },
  }));
  ```



  To showcase the code-first approach. Let's try to model the following schema segment.

  ```gql
  interface Node {
    id: String
  }

  type Query {
    allFilms(after: String, first: Int, before: String, last: Int): FilmConnection
  }

  type FilmNode implements Node {
    filmName: String
  }

  type FilmConnection {
    edges: [FilmEdge]
    films: [Film]
    totalCount: Int
  }

  type FilmEdge {
    node: Film
    cursor: String
  }
  ```

  Above we see a schema that allows for generating paginated responses. For example,
  we can query `allFilms(first: 100)` since `FilmConnection` acts as an intermediary
  for holding `FilmEdges` we can write a resolver to return the first 100 films.

  In a separate file, we can declare our object types and related functions.
  We will call this file `object-types.ts` and we will have created it in a way that
  allows us to generate other `XxxConnection` and `XxxEdges` in the future.

  ```python
  import { GraphqlType, InterfaceType, ObjectType } from 'awscdk-appsync-utils';
  const pluralize = require('pluralize');

  export const args = {
    after: GraphqlType.string(),
    first: GraphqlType.int(),
    before: GraphqlType.string(),
    last: GraphqlType.int(),
  };

  export const Node = new InterfaceType('Node', {
    definition: { id: GraphqlType.string() }
  });
  export const FilmNode = new ObjectType('FilmNode', {
    interfaceTypes: [Node],
    definition: { filmName: GraphqlType.string() }
  });

  export function generateEdgeAndConnection(base: ObjectType) {
    const edge = new ObjectType(`${base.name}Edge`, {
      definition: { node: base.attribute(), cursor: GraphqlType.string() }
    });
    const connection = new ObjectType(`${base.name}Connection`, {
      definition: {
        edges: edge.attribute({ isList: true }),
        [pluralize(base.name)]: base.attribute({ isList: true }),
        totalCount: GraphqlType.int(),
      }
    });
    return { edge: edge, connection: connection };
  }
  ```

  Finally, we will go to our `cdk-stack` and combine everything together
  to generate our schema.

  ```python
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const api = new appsync.GraphqlApi(this, 'Api', {
    name: 'demo',
  });

  const objectTypes = [ Node, FilmNode ];

  const filmConnections = generateEdgeAndConnection(FilmNode);

  api.addQuery('allFilms', new ResolvableField({
    returnType: filmConnections.connection.attribute(),
    args: args,
    dataSource: api.addNoneDataSource('none'),
    requestMappingTemplate: dummyRequest,
    responseMappingTemplate: dummyResponse,
  }));

  api.addType(Node);
  api.addType(FilmNode);
  api.addType(filmConnections.edge);
  api.addType(filmConnections.connection);
  ```

  Notice how we can utilize the `generateEdgeAndConnection` function to generate
  Object Types. In the future, if we wanted to create more Object Types, we can simply
  create the base Object Type (i.e. Film) and from there we can generate its respective
  `Connections` and `Edges`.

  Check out a more in-depth example [here](https://github.com/BryanPan342/starwars-code-first).



  One of the benefits of GraphQL is its strongly typed nature. We define the
  types within an object, query, mutation, interface, etc. as **GraphQL Types**.

  GraphQL Types are the building blocks of types, whether they are scalar, objects,
  interfaces, etc. GraphQL Types can be:

  * [**Scalar Types**](https://docs.aws.amazon.com/appsync/latest/devguide/scalars.html): Id, Int, String, AWSDate, etc.
  * [**Object Types**](#Object-Types): types that you generate (i.e. `demo` from the example above)
  * [**Interface Types**](#Interface-Types): abstract types that define the base implementation of other
    Intermediate Types

  More concretely, GraphQL Types are simply the types appended to variables.
  Referencing the object type `Demo` in the previous example, the GraphQL Types
  is `String!` and is applied to both the names `id` and `version`.



  `Directives` are attached to a field or type and affect the execution of queries,
  mutations, and types. With AppSync, we use `Directives` to configure authorization.
  Appsync utils provide static functions to add directives to your CodeFirstSchema.

  * `Directive.iam()` sets a type or field's authorization to be validated through `Iam`
  * `Directive.apiKey()` sets a type or field's authorization to be validated through a `Api Key`
  * `Directive.oidc()` sets a type or field's authorization to be validated through `OpenID Connect`
  * `Directive.cognito(...groups: string[])` sets a type or field's authorization to be validated
    through `Cognito User Pools`

    * `groups` the name of the cognito groups to give access

  To learn more about authorization and directives, read these docs [here](https://docs.aws.amazon.com/appsync/latest/devguide/security.html).



  While `GraphqlType` is a base implementation for GraphQL fields, we have abstractions
  on top of `GraphqlType` that provide finer grain support.



  `Field` extends `GraphqlType` and will allow you to define arguments. [**Interface Types**](#Interface-Types) are not resolvable and this class will allow you to define arguments,
  but not its resolvers.

  For example, if we want to create the following type:

  ```gql
  type Node {
    test(argument: string): String
  }
  ```

  The CDK code required would be:

  ```python
  import { Field, GraphqlType, InterfaceType } from 'awscdk-appsync-utils';

  const field = new Field({
    returnType: GraphqlType.string(),
    args: {
      argument: GraphqlType.string(),
    },
  });
  const type = new InterfaceType('Node', {
    definition: { test: field },
  });
  ```



  `ResolvableField` extends `Field` and will allow you to define arguments and its resolvers.
  [**Object Types**](#Object-Types) can have fields that resolve and perform operations on
  your backend.

  You can also create resolvable fields for object types.

  ```gql
  type Info {
    node(id: String): String
  }
  ```

  The CDK code required would be:

  ```python
  declare const api: appsync.GraphqlApi;
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const info = new ObjectType('Info', {
    definition: {
      node: new ResolvableField({
        returnType: GraphqlType.string(),
        args: {
          id: GraphqlType.string(),
        },
        dataSource: api.addNoneDataSource('none'),
        requestMappingTemplate: dummyRequest,
        responseMappingTemplate: dummyResponse,
      }),
    },
  });
  ```

  To nest resolvers, we can also create top level query types that call upon
  other types. Building off the previous example, if we want the following graphql
  type definition:

  ```gql
  type Query {
    get(argument: string): Info
  }
  ```

  The CDK code required would be:

  ```python
  declare const api: appsync.GraphqlApi;
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const query = new ObjectType('Query', {
    definition: {
      get: new ResolvableField({
        returnType: GraphqlType.string(),
        args: {
          argument: GraphqlType.string(),
        },
        dataSource: api.addNoneDataSource('none'),
        requestMappingTemplate: dummyRequest,
        responseMappingTemplate: dummyResponse,
      }),
    },
  });
  ```

  Learn more about fields and resolvers [here](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html).



  Intermediate Types are defined by Graphql Types and Fields. They have a set of defined
  fields, where each field corresponds to another type in the system. Intermediate
  Types will be the meat of your GraphQL Schema as they are the types defined by you.

  Intermediate Types include:

  * [**Interface Types**](#Interface-Types)
  * [**Object Types**](#Object-Types)
  * [**Enum Types**](#Enum-Types)
  * [**Input Types**](#Input-Types)
  * [**Union Types**](#Union-Types)



  **Interface Types** are abstract types that define the implementation of other
  intermediate types. They are useful for eliminating duplication and can be used
  to generate Object Types with less work.

  You can create Interface Types ***externally***.

  ```python
  const node = new InterfaceType('Node', {
    definition: {
      id: GraphqlType.string({ isRequired: true }),
    },
  });
  ```

  To learn more about **Interface Types**, read the docs [here](https://graphql.org/learn/schema/#interfaces).



  **Object Types** are types that you declare. For example, in the [code-first example](#code-first-example)
  the `demo` variable is an **Object Type**. **Object Types** are defined by
  GraphQL Types and are only usable when linked to a GraphQL Api.

  You can create Object Types in two ways:

  1. Object Types can be created ***externally***.

     ```python
     const schema = new CodeFirstSchema();
     const api = new appsync.GraphqlApi(this, 'Api', {
       name: 'demo',
       schema,
     });
     const demo = new ObjectType('Demo', {
       definition: {
         id: GraphqlType.string({ isRequired: true }),
         version: GraphqlType.string({ isRequired: true }),
       },
     });

     schema.addType(demo);
     ```

     > This method allows for reusability and modularity, ideal for larger projects.
     > For example, imagine moving all Object Type definition outside the stack.

     `object-types.ts` - a file for object type definitions

     ```python
     import { ObjectType, GraphqlType } from 'awscdk-appsync-utils';
     export const demo = new ObjectType('Demo', {
       definition: {
         id: GraphqlType.string({ isRequired: true }),
         version: GraphqlType.string({ isRequired: true }),
       },
     });
     ```

     `cdk-stack.ts` - a file containing our cdk stack

     ```python
     declare const schema: CodeFirstSchema;
     schema.addType(demo);
     ```
  2. Object Types can be created ***externally*** from an Interface Type.

     ```python
     const node = new InterfaceType('Node', {
       definition: {
         id: GraphqlType.string({ isRequired: true }),
       },
     });
     const demo = new ObjectType('Demo', {
       interfaceTypes: [ node ],
       definition: {
         version: GraphqlType.string({ isRequired: true }),
       },
     });
     ```

     > This method allows for reusability and modularity, ideal for reducing code duplication.

  To learn more about **Object Types**, read the docs [here](https://graphql.org/learn/schema/#object-types-and-fields).



  **Enum Types** are a special type of Intermediate Type. They restrict a particular
  set of allowed values for other Intermediate Types.

  ```gql
  enum Episode {
    NEWHOPE
    EMPIRE
    JEDI
  }
  ```

  > This means that wherever we use the type Episode in our schema, we expect it to
  > be exactly one of NEWHOPE, EMPIRE, or JEDI.

  The above GraphQL Enumeration Type can be expressed in CDK as the following:

  ```python
  declare const api: GraphqlApi;
  const episode = new EnumType('Episode', {
    definition: [
      'NEWHOPE',
      'EMPIRE',
      'JEDI',
    ],
  });
  api.addType(episode);
  ```

  To learn more about **Enum Types**, read the docs [here](https://graphql.org/learn/schema/#enumeration-types).



  **Input Types** are special types of Intermediate Types. They give users an
  easy way to pass complex objects for top level Mutation and Queries.

  ```gql
  input Review {
    stars: Int!
    commentary: String
  }
  ```

  The above GraphQL Input Type can be expressed in CDK as the following:

  ```python
  declare const api: appsync.GraphqlApi;
  const review = new InputType('Review', {
    definition: {
      stars: GraphqlType.int({ isRequired: true }),
      commentary: GraphqlType.string(),
    },
  });
  api.addType(review);
  ```

  To learn more about **Input Types**, read the docs [here](https://graphql.org/learn/schema/#input-types).



  **Union Types** are a special type of Intermediate Type. They are similar to
  Interface Types, but they cannot specify any common fields between types.

  **Note:** the fields of a union type need to be `Object Types`. In other words, you
  can't create a union type out of interfaces, other unions, or inputs.

  ```gql
  union Search = Human | Droid | Starship
  ```

  The above GraphQL Union Type encompasses the Object Types of Human, Droid and Starship. It
  can be expressed in CDK as the following:

  ```python
  declare const api: appsync.GraphqlApi;
  const string = GraphqlType.string();
  const human = new ObjectType('Human', { definition: { name: string } });
  const droid = new ObjectType('Droid', { definition: { name: string } });
  const starship = new ObjectType('Starship', { definition: { name: string } }););
  const search = new UnionType('Search', {
    definition: [ human, droid, starship ],
  });
  api.addType(search);
  ```

  To learn more about **Union Types**, read the docs [here](https://graphql.org/learn/schema/#union-types).



  Every schema requires a top level Query type. By default, the schema will look
  for the `Object Type` named `Query`. The top level `Query` is the **only** exposed
  type that users can access to perform `GET` operations on your Api.

  To add fields for these queries, we can simply run the `addQuery` function to add
  to the schema's `Query` type.

  ```python
  declare const api: appsync.GraphqlApi;
  declare const filmConnection: InterfaceType;
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const string = GraphqlType.string();
  const int = GraphqlType.int();
  api.addQuery('allFilms', new ResolvableField({
    returnType: filmConnection.attribute(),
    args: { after: string, first: int, before: string, last: int},
    dataSource: api.addNoneDataSource('none'),
    requestMappingTemplate: dummyRequest,
    responseMappingTemplate: dummyResponse,
  }));
  ```

  To learn more about top level operations, check out the docs [here](https://docs.aws.amazon.com/appsync/latest/devguide/graphql-overview.html).



  Every schema **can** have a top level Mutation type. By default, the schema will look
  for the `ObjectType` named `Mutation`. The top level `Mutation` Type is the only exposed
  type that users can access to perform `mutable` operations on your Api.

  To add fields for these mutations, we can simply run the `addMutation` function to add
  to the schema's `Mutation` type.

  ```python
  declare const api: appsync.GraphqlApi;
  declare const filmNode: ObjectType;
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const string = GraphqlType.string();
  const int = GraphqlType.int();
  api.addMutation('addFilm', new ResolvableField({
    returnType: filmNode.attribute(),
    args: { name: string, film_number: int },
    dataSource: api.addNoneDataSource('none'),
    requestMappingTemplate: dummyRequest,
    responseMappingTemplate: dummyResponse,
  }));
  ```

  To learn more about top level operations, check out the docs [here](https://docs.aws.amazon.com/appsync/latest/devguide/graphql-overview.html).



  Every schema **can** have a top level Subscription type. The top level `Subscription` Type
  is the only exposed type that users can access to invoke a response to a mutation. `Subscriptions`
  notify users when a mutation specific mutation is called. This means you can make any data source
  real time by specify a GraphQL Schema directive on a mutation.

  **Note**: The AWS AppSync client SDK automatically handles subscription connection management.

  To add fields for these subscriptions, we can simply run the `addSubscription` function to add
  to the schema's `Subscription` type.

  ```python
  declare const api: appsync.GraphqlApi;
  declare const film: InterfaceType;

  api.addSubscription('addedFilm', new Field({
    returnType: film.attribute(),
    args: { id: GraphqlType.id({ isRequired: true }) },
    directives: [Directive.subscribe('addFilm')],
  }));
  ```

  To learn more about top level operations, check out the docs [here](https://docs.aws.amazon.com/appsync/latest/devguide/real-time-data.html).



  The SourceApiAssociationMergeOperation construct provides the ability to merge a source api to a Merged Api
  and invoke a merge within a Cloudformation custom resource. If the merge operation fails with a conflict, the
  Cloudformation update will fail and rollback the changes to the source API in the stack.

  ```python
  import * as cdk from 'aws-cdk-lib';

  const sourceApi1ToMerge = new appsync.GraphqlApi(this, 'FirstSourceAPI', {
    name: 'FirstSourceAPI',
    definition: appsync.Definition.fromFile(path.join(__dirname, 'appsync.merged-api-1.graphql')),
  });

  const sourceApi2ToMerge = new appsync.GraphqlApi(this, 'SecondSourceAPI', {
    name: 'SecondSourceAPI',
    definition: appsync.Definition.fromFile(path.join(__dirname, 'appsync.merged-api-2.graphql')),
  });

  const remoteMergedApi = appsync.GraphqlApi.fromGraphqlApiAttributes(this, 'ImportedMergedApi', {
    graphqlApiId: 'MyApiId',
    graphqlApiArn: 'MyApiArn',
  });

  const remoteExecutionRole = iam.Role.fromRoleArn(this, 'ExecutionRole', 'arn:aws:iam::ACCOUNT:role/MyExistingRole');
  const association1 = new appsync.SourceApiAssociation(this, 'SourceApiAssociation1', {
     sourceApi: sourceApi1ToMerge,
     mergedApi: remoteMergedApi,
     mergeType: appsync.MergeType.MANUAL_MERGE,
     mergedApiExecutionRole: remoteExecutionRole,
  });

  const association2 = new appsync.SourceApiAssociation(this, 'SourceApiAssociation2', {
     sourceApi: sourceApi2ToMerge,
     mergedApi: remoteMergedApi,
     mergeType: appsync.MergeType.MANUAL_MERGE,
     mergedApiExecutionRole: remoteExecutionRole,
  });

  // The version id can be any identifier defined by the developer. Changing the version identifier allows you to control
  // whether a merge operation will take place during deployment.
  SourceApiAssociationMergeOperation(this, 'MergeOperation1', {
    sourceApiAssociation: association1,
    versionIdentifier: '1',
  });

  // Optionally, you can add the alwaysMergeOnStackUpdate flag instead which will ensure that the merge operation occurs
  // during every stack update, regardless if there was a change or not. Note that this may lead to merge operations that
  //do not actually change the MergedAPI.
  SourceApiAssociationMergeOperation(this, 'MergeOperation2', {
    sourceApiAssociation: association2,
    alwaysMergeOnStackUpdate: true,
  });
  ```



  This library leans towards high level and experimental features for appsync cdk users. If you have an idea for additional utilities please create an issue describing the feature.

  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: 0304dd7b4ce68b6697bfe41b7d66d8ff4adebec35217f40b14b2261ea83bc156
name: python-cdklabs.aws-data-solutions-framework
arch: src
version: 1.15.1
epoch: 0
release: 1
summary: L3 CDK Constructs used to build data solutions with AWS
url: https://awslabs.github.io/data-solutions-framework-on-aws/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.aws-data-solutions-framework-1.15.1-1.src.rpm
checksum_type: sha256
description:
  Data solutions framework on AWS (DSF on AWS) is a framework for implementation and delivery of data solutions with built-in AWS best practices. DSF on AWS is an abstraction atop AWS services based on [AWS Cloud Development Kit](https://aws.amazon.com/cdk/) (CDK) L3 constructs, packaged as a library.

  ➡️ **More information on our [website](https://awslabs.github.io/data-solutions-framework-on-aws)**


pkgId: 4cfc7ead5aa4677aff1930d94b86d3389e552458096e06c223d5d67876856098
name: python-cdklabs.cdk-amazonmq
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: @cdklabs/cdk-amazonmq
url: https://github.com/cdklabs/cdk-amazonmq.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-amazonmq-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Higher level constructs for ActiveMQ Brokers | ![Experimental](https://img.shields.io/badge/experimental-important.svg?style=for-the-badge)
  Higher level constructs for RabbitMQ Bokers  | ![Experimental](https://img.shields.io/badge/experimental-important.svg?style=for-the-badge)
  > **Experimental:** Higher level constructs in this module are experimental and
  > under active development. They are subject to non-backward compatible changes or removal in any
  > future version. These are not subject to the [Semantic Versioning](https://semver.org/) model and
  > breaking changes will be announced in the release notes. This means that while you may use them,


pkgId: e78f68400081ba98ac1b0f5fde38e65feba1bc3e051524b4ef116b1ce6926445
name: python-cdklabs.cdk-aws-iot-thing-certificate-policy
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Creates an AWS IoT thing, certificate, policy, and associates the three together
url: https://github.com/cdklabs/cdk-aws-iot-thing-certificate-policy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-aws-iot-thing-certificate-policy-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  [![View on Construct Hub](https://constructs.dev/badge?package=%40cdklabs%2Fcdk-aws-iot-thing-certificate-policy)](https://constructs.dev/packages/@cdklabs/cdk-aws-iot-thing-certificate-policy)
  An [L3 CDK construct](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html#constructs_lib) to create and associate a singular AWS IoT Thing, Certificate, and IoT Policy. The construct also retrieves and returns AWS IoT account specific details such as the AWS IoT data endpoint and the AWS IoT Credential provider endpoint.
  The certificate and its private key are stored as AWS Systems Manager Parameter Store parameters that can be retrieved via the AWS Console or programmatically via construct members.


  ```shell
  npm install @cdklabs/cdk-aws-iot-thing-certificate-policy
  ```

  ```shell
  pip install cdklabs.cdk-aws-iot-thing-certificate-policy
  ```

  ```xml
  // add this to your pom.xml
  <dependency>
      <groupId>io.github.cdklabs</groupId>
      <artifactId>cdk-aws-iot-thing-certificate-policy</artifactId>
      <version>0.0.0</version> // replace with version
  </dependency>
  ```

  ```plaintext
  dotnet add package Cdklabs.CdkAwsIotThingCertificatePolicy --version X.X.X
  ```

  ```go
  // Add this
  import "github.com/cdklabs/cdk-aws-iot-thing-certificate-policy-go/cdklabscdkawsiotthingcertificatepolicy"
  ```

  ```python
  from cdklabs.cdk_aws_iot_thing_certificate_policy import PolicyMapping, PolicyMapping
  import aws_cdk as cdk
  from cdklabs.cdk_aws_iot_thing_certificate_policy import IotThingCertificatePolicy






  minimal_iot_policy = """{
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Action": ["iot:Connect"],
        "Resource": "arn:aws:iot:{{region}}:{{account}}:client/{{thingname}}"
      },
      {
        "Effect": "Allow",
        "Action": ["iot:Publish"],
        "Resource": [
          "arn:aws:iot:{{region}}:{{account}}:topic/{{thingname}}/*"
        ]
      },
      {
        "Effect": "Allow",
        "Action": ["iot:Subscribe"],
        "Resource": [
          "arn:aws:iot:{{region}}:{{account}}:topicfilter/{{thingname}}/*"
        ]
      },
      {
        "Effect": "Allow",
        "Action": ["iot:Receive"],
        "Resource": [
          "arn:aws:iot:{{region}}:{{account}}:topic/{{thingname}}/*"
        ]
      }
    ]
  }"""
  app = cdk.App()




  foo_thing = IotThingCertificatePolicy(app, "MyFooThing",
      thing_name="foo-thing",  # Name to assign to AWS IoT thing, and value for {{thingname}} in policy template
      iot_policy_name="foo-iot-policy",  # Name to assign to AWS IoT policy
      iot_policy=minimal_iot_policy,  # Policy with or without substitution parameters from above
      encryption_algorithm="ECC",  # Algorithm to use to private key (RSA or ECC)
      policy_parameter_mapping=[PolicyMapping(
          name="region",
          value=cdk.Fn.ref("AWS::Region")
      ), PolicyMapping(
          name="account",
          value=cdk.Fn.ref("AWS::AccountId")
      )
      ],
      
      
      x509_subject="CN=foo-thing,OU=Information Security,O=ACME Inc.,L=Detroit,ST=Michigan,C=US"
  )

  cdk.CfnOutput(app, "ThingArn",
      value=foo_thing.thing_arn
  )


  cdk.CfnOutput(app, "IotEndpoint",
      value=foo_thing.data_ats_endpoint_address
  )
  ```


pkgId: 108bf60704af63b5b77019f6a9ef76a4c375edb40532dfe1a6f51c48e1ad67b0
name: python-cdklabs.cdk-aws-sagemaker-role-manager
arch: src
version: 0.0.30
epoch: 0
release: 1
summary: Create roles and policies for ML Activities and ML Personas
url: https://github.com/cdklabs/cdk-aws-sagemaker-role-manager
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-aws-sagemaker-role-manager-0.0.30-1.src.rpm
checksum_type: sha256
description:
  ```python
  import { Stack } from 'aws-cdk-lib';
  import { Activity } from '@cdklabs/cdk-aws-sagemaker-role-manager';

  const stack = new Stack(app, 'CdkRoleManagerDemo');

  const activity = Activity.manageJobs(stack, 'id1', {
      rolesToPass: [iam.Role.fromRoleName('Enter Name')],
      subnets: [ec2.Subnet.fromSubnetId('Enter Id')],
      securityGroups: [ec2.SecurityGroup.fromSecurityGroupId('Enter Id')],
      dataKeys: [kms.Key.fromKeyArn('Enter Key Arn')],
      volumeKeys: [kms.Key.fromKeyArn('Enter Key Arn')],
  });

  activity.createRole(stack, 'role id', 'Enter Name');
  ```



  ```python
  import { Stack } from 'aws-cdk-lib';
  import { Activity } from '@cdklabs/cdk-aws-sagemaker-role-manager';

  const stack = new Stack(app, 'CdkRoleManagerDemo');

  const activity = Activity.manageJobs(this, 'id1', {
      rolesToPass: [iam.Role.fromRoleName('Enter Name')],
  });

  activity.createRole(this, 'role id', 'Enter Name', 'Enter Description');
  ```



  ```python
  import { Stack } from 'aws-cdk-lib';
  import { Activity, Persona } from '@cdklabs/cdk-aws-sagemaker-role-manager';

  const stack = new Stack(app, 'CdkRoleManagerDemo');

  let persona = new Persona(this, 'persona id', {
      activities: [
          Activity.useStudioApps(),
          Activity.manageJobs(this, 'id1', {rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.manageModels(this, 'id2', {rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.manageExperiments(this, 'id3', {}),
          Activity.searchExperiments(this, 'id4', {}),
          Activity.accessBuckets(this, 'id5', {buckets: [s3.S3Bucket.fromBucketName('Enter Name')]})
      ],
      subnets: [ec2.Subnet.fromSubnetId('Enter Id')],
      securityGroups: [ec2.SecurityGroup.fromSecurityGroupId('Enter Id')],
      dataKeys: [kms.Key.fromKeyArn('Enter Key Arn')],
      volumeKeys: [kms.Key.fromKeyArn('Enter Key Arn')],
  });

  persona.createRole(this, 'role id', 'Enter Name', 'Enter Description');
  ```



  ```python
  import { Stack } from 'aws-cdk-lib';
  import { Activity, Persona } from '@cdklabs/cdk-aws-sagemaker-role-manager';

  const stack = new Stack(app, 'CdkRoleManagerDemo');

  // Please see below how to create the Data Scientist ML Persona using its ML Activities.
  // You can update the following list with changes matching your usecase.
  let persona = new Persona(this, 'persona id', {
      activities: [
          Activity.useStudioApps(),
          Activity.manageJobs(this, 'id1', {rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.manageModels(this, 'id2', {rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.manageExperiments(this, 'id3', {}),
          Activity.searchExperiments(this, 'id4', {}),
          Activity.accessBuckets(this, 'id5', {buckets: [s3.S3Bucket.fromBucketName('Enter Name')]})
      ],
  });

  // We can create a role with Data Scientist persona permissions
  const role = persona.createRole(this, 'role id', 'Enter Name', 'Enter Description');
  ```



  ```python
  import { Stack } from 'aws-cdk-lib';
  import { Activity, Persona } from '@cdklabs/cdk-aws-sagemaker-role-manager';

  const stack = new Stack(app, 'CdkRoleManagerDemo');

  let persona = new Persona(this, 'persona id', {
      activities: [
          Activity.useStudioApps(this, 'id1', {}),
          Activity.manageModels(this, 'id2', {rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.manageEndpoints(this, 'id3',{rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.managePipelines(this, 'id4', {rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.searchExperiments(this, 'id5', {})
      ],
      subnets: [ec2.Subnet.fromSubnetId('Enter Id')],
      securityGroups: [ec2.SecurityGroup.fromSecurityGroupId('Enter Id')],
      dataKeys: [kms.Key.fromKeyArn('Enter Key Arn')],
      volumeKeys: [kms.Key.fromKeyArn('Enter Key Arn')],
  });

  const role = persona.createRole(this, 'role id', 'Enter Name', 'Enter Description');
  ```



  ```python
  import { Stack } from 'aws-cdk-lib';
  import { Activity, Persona } from '@cdklabs/cdk-aws-sagemaker-role-manager';

  const stack = new Stack(app, 'CdkRoleManagerDemo');

  let persona = new Persona(this, 'persona id', {
      activities: [
          Activity.useStudioApps(this, 'id1', {}),
          Activity.manageModels(this, 'id2', {rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.manageEndpoints(this, 'id3',{rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.managePipelines(this, 'id4', {rolesToPass: [iam.Role.fromRoleName('Enter Name')]}),
          Activity.searchExperiments(this, 'id5', {})
      ],
  });

  const role = persona.createRole(this, 'role id', 'Enter Name', 'Enter Description');
  ```



  | ML Activity Name | ML Activity Interface           | ML Activity Description                                                                                   | ML Activity Required Parameters |
  |------------------|---------------------------------|-----------------------------------------------------------------------------------------------------------|---------------------------------|
  | Access Required AWS Services          | Activity.accessAwsServices()    | Permissions to access S3, ECR, Cloudwatch and EC2. Required for execution roles for jobs and endpoints.   | ecrRepositories, s3Buckets      |
  | Run Studio Applications         | Activity.runStudioApps()        | Permissions to operate within a Studio environment. Required for domain and user-profile execution roles. | rolesToPass                     |
  | Manage ML Jobs          | Activity.manageJobs()           | Permissions to manage SageMaker jobs across their lifecycles.                                             | rolesToPass                     |
  | Manage Models          | Activity.manageModels()         | 	Permissions to manage SageMaker models and Model Registry.                                               | rolesToPass                     |
  | Manage Endpoints        | Activity.manageEndpoints()      | Permissions to manage SageMaker Endpoint deployments and updates.                                         | No required parameters          |
  | Manage Pipelines         | Activity.managePipelines()      | Permissions to manage SageMaker Pipelines and pipeline executions.                                        | rolesToPass                     |
  | Manage Experiments         | Activity.manageExperiments()    | 	Permissions to manage experiments and trials.                                                            | No required parameters          |
  | Search and visualize experiments         | Activity.visualizeExperiments() | Permissions to audit, query lineage and visualize experiments.                                            | No required parameters          |
  | 	Manage Model Monitoring         | Activity.monitorModels()        | Permissions to manage monitoring schedules for SageMaker Model Monitor.                                   | rolesToPass                     |
  | S3 Full Access        | Activity.accessS3AllResources() | 	Permissions to perform all S3 operations                                                                 | No required parameters          |
  | S3 Bucket Access         | Activity.accessS3Buckets()      | Permissions to perform operations on specified buckets.                                                   | s3Buckets                       |
  | 	Query Athena Workgroups        | Activity.queryAthenaGroups()    | Permissions to execute and manage Amazon Athena queries.                                                  | athenaWorkgroupNames            |
  | 	Manage Glue Tables       | Activity.manageGlueTables()     | 	Permissions to create and manage Glue tables for SageMaker Feature Store and Data Wrangler.                                                                                                          | s3Buckets, glueDatabaseNames                     |



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: c82bd2f9a5f3ad8e0801daf8cf547594a241a55690bf37ac09c315ab1efd23c1
name: python-cdklabs.cdk-cicd-wrapper
arch: src
version: 0.2.16
epoch: 0
release: 1
url: https://github.com/cdklabs/cdk-cicd-wrapper.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-cicd-wrapper-0.2.16-1.src.rpm
checksum_type: sha256
summary:
  This repository contains the infrastructure as code to wrap your AWS CDK project with CI/CD around it.

description:
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

  The [CDK CI/CD Wrapper](https://cdklabs.github.io/cdk-cicd-wrapper/) is a comprehensive solution that streamlines the delivery of your AWS Cloud Development Kit (CDK) applications. It provides a robust and standardized multi-stage CI/CD pipeline, ensuring high quality and confidence throughout the development and deployment process.



  * [Introduction](#introduction)
  * [Features](#features)
  * [Getting Started](#getting-started)

    * [Prerequisites](#prerequisites)
    * [Installation](#installation)
  * [Usage](#usage)

    * [Defining Stages](#defining-stages)
    * [Configuring Stacks](#configuring-stacks)
    * [Customizing CI/CD Steps](#customizing-cicd-steps)
  * [Contributing](#contributing)
  * [License](#license)



  The CDK CI/CD Wrapper builds upon the success of the [aws-cdk-cicd-boot-sample](https://github.com/aws-samples/aws-cdk-cicd-boot-sample) and takes it a step further by providing additional tools and features to simplify and standardize the multi-stage CI/CD process for your Infrastructure as Code (IaC) projects.



  * **Multi-staged CI/CD Pipeline**: Seamlessly deploy your CDK applications across multiple stages (e.g., DEV, INT, PROD) and AWS accounts.
  * **Security Scanning**: Perform security scanning on dependencies and codebase, blocking the pipeline in case of CVE findings.
  * **License Management**: Manage licenses for NPM and Python dependencies, ensuring compliance with your organization's policies.
  * **Private NPM Registry**: Securely store and utilize private NPM libraries.
  * **Customizable Pipeline**: Tailor the CI/CD pipeline to your project's specific needs with built-in dependency injection.
  * **Workbench Deployment**: Develop and experiment with your solutions in isolation before introducing them to the delivery pipeline.
  * **Pre/Post Deploy Hooks**: Execute custom scripts before and after deployments in each stage (e.g., unit tests, functional tests, load testing).
  * **Centralized Compliance Logs**: Store compliance logs in pre-configured S3 buckets on a per-stage/environment basis.
  * **Lambda Layer Support**: Build and scan dependencies for Python Lambda Layers.





  Before you begin, ensure that you have the following dependencies installed:

  * AWS Account (RES/DEV/INT/PROD)
  * macOS or Cloud9 with Ubuntu Server 22.04 LTS Platform in the RES Account
  * Bash/ZSH terminal
  * Docker version >= 24.0.x
  * AWS CLI v2 ([installation guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html))
  * AWS credentials and profiles for each environment in `~/.aws/config` ([configuration guide](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html))
  * Node.js >= v18.17._ && NPM >= v10.2._
  * jq command-line JSON processor (jq-1.7)

  For developing Python Lambdas, you'll also need:

  * Python >= 3.11
  * Pipenv 2023.* ([installation guide](https://pipenv.pypa.io/en/latest/))



  1. Clone the CDK CI/CD Wrapper repository:

     ```bash
     git clone https://github.com/your-repo/cdk-cicd-wrapper.git
     cd cdk-cicd-wrapper
     ```
  2. Install the required dependencies:

     ```bash
     npm install
     ```





  The CDK CI/CD Wrapper comes with a default set of stages (DEV, INT, PROD), but you can easily extend or modify these stages to suit your project's needs. Follow the step-by-step guide in the documentation to define your desired stages.



  Configure the CDK stacks you want to deploy in each stage. The CDK CI/CD Wrapper allows you to specify which stacks should be deployed in each stage, giving you granular control over your deployment process.



  Tailor the CI/CD pipeline to meet your project's specific requirements. The CDK CI/CD Wrapper provides built-in dependency injection, allowing you to customize the CI/CD steps seamlessly.



  Contributions to the CDK CI/CD Wrapper are welcome! If you'd like to contribute, please follow the guidelines outlined in the [CONTRIBUTING.md](CONTRIBUTING.md) file.



  This project is licensed under the [Apache 2.0 License](LICENSE).


pkgId: f6e0df5c51722d6d7f5cd5cd60360e0b39cdc8ea659616f144c0281b0f5aaaed
name: python-cdklabs.cdk-enterprise-iac
arch: src
version: 0.0.512
epoch: 0
release: 1
summary: @cdklabs/cdk-enterprise-iac
url: https://github.com/cdklabs/cdk-enterprise-iac.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-enterprise-iac-0.0.512-1.src.rpm
checksum_type: sha256
description:
  Generated API.md below:
  <details>
      <summary>Expand to view API docs</summary><!--
  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  SPDX-License-Identifier: Apache-2.0
  -->

  Utilities for using CDK within enterprise constraints.

  Typescript
  ```zsh
  npm install @cdklabs/cdk-enterprise-iac
  ```
  Python
  ```zsh
  pip install cdklabs.cdk-enterprise-iac
  ```

  Within large enterprises, builders can come up against enterprise imposed constraints when deploying on AWS.
  This could be simple things such as "All IAM roles must have a specific Permissions Boundary attached".
  This could also be more restrictive such as strict separation of duties, only allowing certain teams the ability to deploy specific AWS resources (e.g. Networking team can deploy VPCs, Subnets, and route tables. Security team can deploy IAM resources. Developers can deploy Compute. DBAs can deploy Databases, etc.)
  Enterprises with very restrictive environments like these would benefit from taking a closer look at their policies to see how they can allow builders to safely deploy resources with less friction. However in many enterprises this is easier said than done, and builders are still expected to deliver.
  This project is meant to reduce friction for builders working within these enterprise constraints while the enterprise determines what policies make the most sense for their organization, and is in no way prescriptive.

  There are many tools available, all detailed in [`API.md`](./API.md).
  A few examples of these tools below:

  Example for `AddPermissionBoundary` in Typescript project.
  ```python

  import aws_cdk as cdk
  from ...lib.my_project_stack import MyStack
  from aws_cdk import Aspects
  from cdklabs.cdk_enterprise_iac import AddPermissionBoundary
  app = cdk.App()
  MyStack(app, "MyStack")
  Aspects.of(app).add(
      AddPermissionBoundary(
          permissions_boundary_policy_name="MyPermissionBoundaryName",
          instance_profile_prefix="MY_PREFIX_",  # optional, Defaults to ''
          policy_prefix="MY_POLICY_PREFIX_",  # optional, Defaults to ''
          role_prefix="MY_ROLE_PREFIX_"
      ))
  ```
  Example for `AddPermissionBoundary` in Python project.
  ```python
  import aws_cdk as cdk
  from cdklabs.cdk_enterprise_iac import AddPermissionBoundary
  from test_py.test_py_stack import TestPyStack
  app = cdk.App()
  TestPyStack(app, "TestPyStack")
  cdk.Aspects.of(app).add(AddPermissionBoundary(
      permissions_boundary_policy_name="MyPermissionBoundaryName",
      instance_profile_prefix="MY_PREFIX_",  # optional, Defaults to ""
      policy_prefix="MY_POLICY_PREFIX_",  # optional, Defaults to ""
      role_prefix="MY_ROLE_PREFIX_"  # optional, Defaults to ""
  ))
  app.synth()
  ```

  In many enterprises, there are separate teams with different IAM permissions than developers deploying CDK applications.
  For example there might be a networking team with permissions to deploy `AWS::EC2::SecurityGroup` and `AWS::EC2::EIP`, or a security team with permissions to deploy `AWS::IAM::Role` and `AWS::IAM::Policy`, but the developers deploying the CDK don't have those permissions.
  When a developer doesn't have permissions to deploy necessary resources in their CDK application, writing good code becomes difficult to manage when a cdk deploy will quickly error due to not being able to deploy something like an `AWS::IAM::Role` which is foundational to any project deployed into AWS.
  An enterprise should *allow* builders to deploy these resources via CDK for [many reasons](https://github.com/aws/aws-cdk/wiki/Security-And-Safety-Dev-Guide#allowing-creation-of-iam-roles-without-privilege-escalation), and can use [Permissions Boundaries](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) to prevent privilege escalation. For enterprises that haven't yet utilized Permissions Boundaries, the `ResourceExtractor` can make it easier for builders to write good CDK while complying with enterprise policies.
  Using the `ResourceExtractor` Aspect, developers can write their CDK code as though they had sufficient IAM permissions, but extract those resources into a separate stack for an external team to deploy on their behalf.
  Take the following example stack:
  ```python

  from aws_cdk import App, Aspects, RemovalPolicy, Stack
  from aws_cdk.aws_lambda import Code, Function, Runtime
  from aws_cdk.aws_s3 import Bucket
  app = App()
  app_stack = Stack(app, "MyAppStack")
  func = Function(app_stack, "TestLambda",
      code=Code.from_asset(path.join(__dirname, "lambda-handler")),
      handler="index.handler",
      runtime=Runtime.PYTHON_3_11
  )
  bucket = Bucket(app_stack, "TestBucket",
      auto_delete_objects=True,
      removal_policy=RemovalPolicy.DESTROY
  )
  bucket.grant_read_write(func)
  app.synth()
  ```
  The synthesized Cloudformation would include *all* AWS resources required, including resources a developer might not have permissions to deploy
  The above example would include the following snippet in the synthesized Cloudformation
  ```yaml
  TestLambdaServiceRoleC28C2D9C:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action: 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
        Version: 2012-10-17
      
    TestLambda2F70C45E:
      Type: 'AWS::Lambda::Function'
      Properties:
        Role: !GetAtt
          - TestLambdaServiceRoleC28C2D9C
          - Arn
        
  ```
  While including `bucket.grantReadWrite(func)` in the CDK application ensures an IAM role with least privilege IAM policies for the application, the creation of IAM resources such as Roles and Policies may be restricted to a security team, resulting in the synthesized Cloudformation template not being deployable by a developer.
  Using the `ResourceExtractor`, we can pull out an arbitrary list of Cloudformation resources that a developer *doesn't* have permissions to provision, and create a separate stack that can be sent to a security team.
  ```python

  from aws_cdk import App, Aspects, RemovalPolicy, Stack
  from aws_cdk.aws_lambda import Code, Function, Runtime
  from aws_cdk.aws_s3 import Bucket

  from cdklabs.cdk_enterprise_iac import ResourceExtractor
  app = App()
  app_stack = Stack(app, "MyAppStack")

  extracted_stack = Stack(app, "ExtractedStack")
  func = Function(app_stack, "TestLambda",
      code=Code.from_asset(path.join(__dirname, "lambda-handler")),
      handler="index.handler",
      runtime=Runtime.PYTHON_3_11
  )
  bucket = Bucket(app_stack, "TestBucket",
      auto_delete_objects=True,
      removal_policy=RemovalPolicy.DESTROY
  )
  bucket.grant_read_write(func)

  synthed_app = app.synth()

  Aspects.of(app).add(
      ResourceExtractor(
          
          stack_artifacts=synthed_app.stacks,
          
          resource_types_to_extract=["AWS::IAM::Role", "AWS::IAM::Policy", "AWS::IAM::ManagedPolicy", "AWS::IAM::InstanceProfile"
          ],
          
          extract_destination_stack=extracted_stack
      ))

  app.synth(force=True)
  ```
  In the example above, *all* resources are created in the `appStack`, and an empty `extractedStack` is also created.
  We apply the `ResourceExtractor` Aspect, specifying the Cloudformation resource types the developer is unable to deploy due to insufficient IAM permissions.
  Now when we list stacks in the CDK project, we can see an added stack
  ```zsh
  $ cdk ls
  MyAppStack
  ExtractedStack
  ```
  Taking a look at these synthesized stacks, in the `ExtractedStack` we'll find:
  ```yaml
  Resources:
    TestLambdaServiceRoleC28C2D9C:
      Type: 'AWS::IAM::Role'
      Properties:
        AssumeRolePolicyDocument:
          Statement:
            - Action: 'sts:AssumeRole'
              Effect: Allow
              Principal:
                Service: lambda.amazonaws.com
          Version: 2012-10-17
        
  Outputs:
    ExportAppStackTestLambdaServiceRoleC28C2D9C:
      Value:
        'Fn::GetAtt':
          - TestLambdaServiceRoleC28C2D9C
          - Arn
      Export:
        Name: 'AppStack:TestLambdaServiceRoleC28C2D9C'  # Exported name
  ```
  And inside the synthesized `MyAppStack` template:
  ```yaml
  Resources:
    TestLambda2F70C45E:
      Type: 'AWS::Lambda::Function'
      Properties:
        Role: !ImportValue 'AppStack:TestLambdaServiceRoleC28C2D9C'  # Using ImportValue instrinsic function to use pre-created IAM role
        
  ```
  In this scenario, a developer is able to provide an external security team with sufficient IAM privileges to deploy the `ExtractedStack`.
  Once deployed, a developer can run `cdk deploy MyAppStack` without errors due to insufficient IAM privileges

  When resources are extracted from a stack, there must be a method to reference the resources that have been extracted.
  There are three methods (see `ResourceExtractorShareMethod` enum)
  * `CFN_OUTPUT`
  * `SSM_PARAMETER`
  * `API_LOOKUP`

  The default sharing method is `CFN_OUTPUT`, which uses Cloudformation Export/Import to Export values in the extracted stack (see [Outputs](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html)), and use the [Fn::ImportValue](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html) intrinsic function to reference those values.
  This works fine, but some teams may prefer a looser coupling between the extracted stack deployed by an external team and the rest of the CDK infrastructure.

  In this method, the extracted stack generates Parameters in AWS Systems Manager Parameter Store, and modifies the CDK application to look up the generated parameter using [`aws_ssm.StringParameter.valueFromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ssm.StringParameter.html#static-valuewbrfromwbrlookupscope-parametername) at synthesis time.
  Example on using this method:
  ```python

  from cdklabs.cdk_enterprise_iac import ResourceExtractor, ResourceExtractorShareMethod
  Aspects.of(app).add(
      ResourceExtractor(
          stack_artifacts=synthed_app.stacks,
          resource_types_to_extract=["AWS::IAM::Role", "AWS::IAM::Policy", "AWS::IAM::ManagedPolicy", "AWS::IAM::InstanceProfile"
          ],
          extract_destination_stack=extracted_stack,
          value_share_method=ResourceExtractorShareMethod.SSM_PARAMETER
      ))
  ```

  The `API_LOOKUP` sharing method is a work in progress, and not yet supported

  Some resources that get extracted might reference resources that aren't yet created.
  In our example CDK application we include the line
  ```python

  bucket.grant_read_write(func)
  ```
  This creates an `AWS::IAM::Policy` that includes the necessary Actions scoped down to the S3 bucket.
  When the `AWS::IAM::Policy` is extracted, it's unable to use `Ref` or `Fn::GetAtt` to reference the S3 bucket since the S3 bucket wasn't extracted.
  In this case we substitute the reference with a "partial ARN" that makes a best effort to scope the resources in the IAM policy statement to the ARN of the yet-to-be created S3 bucket.
  There are multiple resource types supported out of the box (found in [`createDefaultTransforms`](src/patches/resource-extractor/resourceTransformer.ts)). In the event you have a resource not yet supported, you'll receive a `MissingTransformError`. In this case you can either open an [issue](https://github.com/cdklabs/cdk-enterprise-iac/issues) with the resource in question, or you can include the `additionalTransforms` property.
  Consider the following:
  ```python

  vpc = Vpc(stack, "TestVpc")
  db = DatabaseInstance(stack, "TestDb",
      vpc=vpc,
      engine=DatabaseInstanceEngine.POSTGRES
  )
  func = Function(stack, "TestLambda", {
      "code": Code.from_asset(path.join(__dirname, "lambda-handler")),
      "handler": "index.handler",
      "runtime": Runtime.PYTHON_3_11
  })
  db.secret.grant_read(func)
  synthed_app = app.synth()
  Aspects.of(app).add(
      ResourceExtractor(
          extract_destination_stack=extracted_stack,
          stack_artifacts=synthed_app.stacks,
          value_share_method=ResourceExtractorShareMethod.CFN_OUTPUT,
          resource_types_to_extract=["AWS::IAM::Role", "AWS::IAM::Policy"],
          additional_transforms={
              "AWS::SecretsManager::SecretTargetAttachment": f"arn:{Aws.PARTITION}:secretsmanager:{Aws.REGION}:{Aws.ACCOUNT_ID}:secret:some-expected-value*"
          }
      ))
  app.synth(force=True)
  ```
  In this case, there is a `AWS::SecretsManager::SecretTargetAttachment` generated to complete the final link between a Secrets Manager secret and the associated database by adding the database connection information to the secret JSON, which returns the ARN of the generated secret.
  In the context of extracting the IAM policy, we want to tell the `ResourceExtractor` how to handle the resource section of the IAM policy statement so that it is scoped down sufficiently.
  In this case rather than using a `Ref: LogicalIdForTheSecretTargetAttachment` we construct the ARN we want to use.
  Details in [API.md](API.md)


pkgId: e7a902eafafbc431cabe09d76a5b7bd24715e7d4ce3a8b50023397d59dd3c711
name: python-cdklabs.cdk-ethereum-node
arch: src
version: 0.0.626
epoch: 0
release: 1
summary: CDK construct to deploy an Ethereum node running on Amazon Managed Blockchain
url: https://github.com/cdklabs/cdk-ethereum-node.git
rpm_license: MIT-0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-ethereum-node-0.0.626-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/github/license/cdklabs/cdk-ethereum-node?color=green)](https://opensource.org/licenses/MIT)
  [![release](https://img.shields.io/github/v/release/cdklabs/cdk-ethereum-node?color=green)](https://github.com/cdklabs/cdk-ethereum-node/releases)
  [![npm:version](https://img.shields.io/npm/v/@cdklabs/cdk-ethereum-node?color=blue)](https://www.npmjs.com/package/@cdklabs/cdk-ethereum-node)
  [![PyPi:version](https://img.shields.io/pypi/v/cdklabs.cdk-ethereum-node?color=blue)](https://pypi.org/project/cdklabs.cdk-ethereum-node/)
  [![Maven:version](https://img.shields.io/maven-central/v/io.github.cdklabs/cdk-ethereum-node?color=blue&label=maven)](https://central.sonatype.dev/artifact/io.github.cdklabs/cdk-ethereum-node/0.0.61)
  [![NuGet:version](https://img.shields.io/nuget/v/Cdklabs.CdkEthereumNode?color=blue)](https://www.nuget.org/packages/Cdklabs.CdkEthereumNode)

  This repository contains a CDK construct to deploy an Ethereum node running
  on Amazon Managed Blockchain. The following networks are supported:

  * Mainnet (default)
  * Testnet: Goerli
  * Testnet: Rinkeby
  * Testnet: Ropsten



  Note that this construct requires [AWS CDK v2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_install).



  ```bash
  npm install --save @cdklabs/cdk-ethereum-node
  ```



  ```bash
  pip3 install cdklabs.cdk-ethereum-node
  ```



  Add the following to `pom.xml`:

  ```xml
  <dependency>
    <groupId>io.github.cdklabs</groupId>
    <artifactId>cdk-ethereum-node</artifactId>
  </dependency>
  ```



  ```bash
  dotnet add package Cdklabs.CdkEthereumNode
  ```



  A minimally complete deployment is shown below. By default,
  a `bc.t3.large` node will be created on the Ethereum Mainnet.

  ```python
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import { EthereumNode, Network, InstanceType } from '@cdklabs/cdk-ethereum-node';

  export class MyStack extends Stack {
    constructor(scope: Construct, id: string, props?: StackProps) {
      super(scope, id, props);
      new EthereumNode(this, 'Example');
    }
  }
  ```

  The equivalent Python code is as follows:

  ```python
  from aws_cdk import Stack
  from cdklabs.cdk_ethereum_node import EthereumNode

  class MyStack(Stack):
      def __init__(self, scope, id, **kwargs):
          super().__init__(scope, id, **kwargs)
          EthereumNode(self, 'Example')
  ```

  The following is a more complex instantiation illustrating some of the node configuration options available.

  ```python
  new EthereumNode(this, 'Example', {
    network: Network.ROPSTEN,
    availabilityZone: 'us-east-1b',
    instanceType: InstanceType.BURSTABLE3_LARGE,
  });
  ```

  See the [API Documentation](API.md) for details on all available input and output parameters.



  * [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html)
  * [Amazon Managed Blockchain](https://aws.amazon.com/managed-blockchain/)
  * [Ethereum](https://ethereum.org/en/developers/docs/)



  Pull requests are welcomed. Please review the [Contributing Guidelines](CONTRIBUTING.md)
  and the [Code of Conduct](CODE_OF_CONDUCT.md).



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  * Trinity Key (trinikey@amazon.com)
  * Marc Gozali (gozalim@amazon.com)



  This project is licensed under the MIT-0 License. See the [LICENSE](LICENSE) file for details.


pkgId: 9244ed4be803ff094c8edae76142c2326543c0f1bb0c041b696f539d1cbbfe72
name: python-cdklabs.cdk-hyperledger-fabric-network
arch: src
version: 0.8.719
epoch: 0
release: 1
summary: CDK construct to deploy a Hyperledger Fabric network running on Amazon Managed Blockchain
url: https://github.com/cdklabs/cdk-hyperledger-fabric-network.git
rpm_license: MIT-0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-hyperledger-fabric-network-0.8.719-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/github/license/cdklabs/cdk-hyperledger-fabric-network?color=green)](https://opensource.org/licenses/MIT)
  [![release](https://img.shields.io/github/v/release/cdklabs/cdk-hyperledger-fabric-network?color=green)](https://github.com/cdklabs/cdk-hyperledger-fabric-network/releases)
  [![npm:version](https://img.shields.io/npm/v/@cdklabs/cdk-hyperledger-fabric-network?color=blue)](https://www.npmjs.com/package/@cdklabs/cdk-hyperledger-fabric-network)
  [![PyPi:version](https://img.shields.io/pypi/v/cdklabs.cdk-hyperledger-fabric-network?color=blue)](https://pypi.org/project/cdklabs.cdk-hyperledger-fabric-network/)
  [![Maven:version](https://img.shields.io/maven-central/v/io.github.cdklabs/cdk-hyperledger-fabric-network?color=blue&label=maven)](https://central.sonatype.dev/artifact/io.github.cdklabs/cdk-hyperledger-fabric-network/0.8.147)
  [![NuGet:version](https://img.shields.io/nuget/v/Cdklabs.CdkHyperledgerFabricNetwork?color=blue)](https://www.nuget.org/packages/Cdklabs.CdkHyperledgerFabricNetwork)

  This repository contains a CDK construct to deploy a Hyperledger Fabric network
  running on Amazon Managed Blockchain. It builds out a member and its nodes, a VPC
  and associated endpoint to access them, and a set of users enrolled on the network.

  The following functionality is planned for future releases:

  * Create channels on nodes
  * Instantiate chaincode on nodes



  Note that this construct requires [AWS CDK v2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_install).



  ```bash
  npm install --save @cdklabs/cdk-hyperledger-fabric-network
  ```



  ```bash
  pip3 install cdklabs.cdk-hyperledger-fabric-network
  ```



  Add the following to `pom.xml`:

  ```xml
  <dependency>
    <groupId>io.github.cdklabs</groupId>
    <artifactId>cdk-hyperledger-fabric-network</artifactId>
  </dependency>
  ```



  ```bash
  dotnet add package Cdklabs.CdkHyperledgerFabricNetwork
  ```



  A minimally complete deployment is shown below. By default, a standard network
  will be created running Hyperledger Fabric 1.4 with a single `bc.t3.small` node.

  ```python
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import { HyperledgerFabricNetwork } from '@cdklabs/cdk-hyperledger-fabric-network';

  class MyStack extends Stack {
    constructor(scope: Construct, id: string, props?: StackProps) {
      super(scope, id, props);
      new HyperledgerFabricNetwork(this, 'Example', {
        networkName: 'MyNetwork',
        memberName: 'MyMember',
      });
    }
  }
  ```

  The equivalent Python code is as follows:

  ```python
  from aws_cdk import Stack
  from cdklabs.cdk_hyperledger_fabric_network import HyperledgerFabricNetwork

  class MyStack(Stack):
      def __init__(self, scope, id, **kwargs):
          super().__init__(scope, id, **kwargs)
          HyperledgerFabricNetwork(
              self, 'Example',
              network_name='MyNetwork',
              member_name='MyMember',
          )
  ```

  The following is a more complex instantiation illustrating some of the options available.

  ```python
  new HyperledgerFabricNetwork(this, 'Example', {
    networkName: 'MyNetwork',
    networkDescription: 'This is my Hyperledger Fabric network',
    memberName: 'MyMember',
    networkDescription: 'This is my Hyperledger Fabric member',
    frameworkVersion: hyperledger.FrameworkVersion.VERSION_1_2,
    proposalDurationInHours: 48,
    thresholdPercentage: 75,
    nodes: [
      {
        availabilityZone: 'us-east-1a',
        instanceType: hyperledger.InstanceType.STANDARD5_LARGE,
      },
      {
        availabilityZone: 'us-east-1b',
        instanceType: hyperledger.InstanceType.STANDARD5_LARGE,
      },
    ],
    users: [
      { userId: 'AppUser1', affilitation: 'MyMember' },
      { userId: 'AppUser2', affilitation: 'MyMember.department1' },
    ],
  });
  ```

  See the [API Documentation](API.md) for details on all available input and output parameters.



  * [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html)
  * [Amazon Managed Blockchain](https://aws.amazon.com/managed-blockchain/)
  * [Hyperledger Fabric](https://hyperledger-fabric.readthedocs.io/)
  * [Node Fabric SDK](https://hyperledger.github.io/fabric-sdk-node/release-1.4/index.html)
  * [Fabric Chaincode Node](https://hyperledger.github.io/fabric-chaincode-node/)



  Pull requests are welcomed. Please review the [Contributing Guidelines](CONTRIBUTING.md)
  and the [Code of Conduct](CODE_OF_CONDUCT.md).



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  * Jud Neer (judneer@amazon.com)
  * Vignesh Rajasingh (vrajasin@amazon.com)



  This project is licensed under the MIT-0 License. See the [LICENSE](LICENSE) file for details.


pkgId: 05a0204aecdf8512ee53bb228ac770e50e094731a3488e138a7b5f91fd6cefae
name: python-cdklabs.cdk-ssm-documents
arch: src
version: 0.0.47
epoch: 0
release: 1
summary: @cdklabs/cdk-ssm-documents
url: https://github.com/cdklabs/cdk-ssm-documents.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-ssm-documents-0.0.47-1.src.rpm
checksum_type: sha256
description:
  This library provides a code-based utility for implementing SSM Documents. The SSM Document objects can be used to print YAML/JSON documents and to mimic document processing locally.

  This library abstracts SSM Documents at a high level, with each step as well as the document itself being objects. The properties needed to build these objects correlate to the settings that apply to them, making them simple to make.
  This library can be used to test your document locally before deploying it to SSM.

  Since the library is written in JSII, it can be exported to other languages that support JSII (Java, Python).

  This is what you'd use if you wanted to:

  1. The ability to test without deploying resources or executing an actual SSM on AWS.
  2. Reusability of steps between documents by reusing existing items
  3. Create logical higher-level groupings of reusable groups of steps ("Patterns")
  4. Simple to use interface for writing documents
  5. Import existing documents from a file (or string) and mimic them locally to test them.





  Typescript usage (Execute AWS API Step)...
  The below creates the AutomationDocument in an AWS CDK stack.

  ```python
  import { AutomationDocument } from './automation-document';

  export class HelloWorld extends Stack {
    constructor(app: Construct, id: string) {
      super(app, id);

      // Create AutomationDocument
      const myDoc = new AutomationDocument(this, "MyDoc", {
        documentFormat: DocumentFormat.JSON,
        documentName: "MyDoc",
        docInputs: [Input.ofTypeString('MyInput', { defaultValue: 'a' })],
      });

      // Define your steps...
      myDoc.addStep(new PauseStep(this, "MyPauseStep", {
        name: "MyPauseStep",
        explicitNextStep: StepRef.fromName("step1") // Optional (will default to next added step)
      }));

      myDoc.addStep(new ExecuteScriptStep(this, "MyExecuteStep", {
        name: "step1",
        language: ScriptLanguage.python(PythonVersion.VERSION_3_11, 'my_func'),
        code: ScriptCode.fromFile(resolve("test/test_file.py")),
        // OR ScriptCode.inline("def my_func(args, context):\n  return {'MyReturn': args['MyInput'] + '-suffix'}\n"),
        outputs: [{
          outputType: DataTypeEnum.STRING,
          name: "MyFuncOut",
          selector: "$.Payload.MyReturn"
        }],
        onFailure: OnFailure.abort(),
        inputPayload: { MyInput: StringVariable.of('MyInput') },
      }));
    }
  }
  ```



  You can deploy the above document using CDK.
  To print the above document object as a JSON (or YAML), do the following:

  ```python
  const myDocJson = myDoc.print(); // Print YAML by setting the documentFormat to YAML
  ```



  To run the document object in simulation mode, use the below. Simulation mode does NOT hit the SSM API, rather it mimics the execution that will happen in an SSM execution. The run happens locally and allows you to mock the calls to external services (AWS APIs for example) or to invoke those services using your local credentials.

  ```python
  import { Simulation } from './simulation';

  const myDocJson = Simulation.ofAutomation(myDoc, {}).simulate({ MyInput: "FooBar" });
  ```



  Below is an example of how to use the library to create Command documents.
  Simulation for command documents is not yet supported for all command plugins.
  You can use a Docker image/container as a playground for testing the Command document execution for the supported plugins.

  In this example there is a complete CDK stack. Notice that the `CommandDocument` is saved as a field so that it can be tested from the test code.

  ```python
  export class HelloCdkStack extends Stack {
    readonly myCommandDoc: CommandDocument;
    constructor(scope: Construct, id: string, props?: StackProps) {
      super(scope, id, props);
      this.myCommandDoc = new CommandDocument(this, "MyCommandDoc", {
        docInputs: [Input.ofTypeString('FirstCommand', { defaultValue: 'a' })],
      })
      const runScriptStep = new RunShellScriptStep(this, "MyShellScript", {
        runCommand: [
          StringVariable.of("FirstCommand"),
          HardCodedString.of("mkdir asdf"),
        ],
      });
      this.myCommandDoc.addStep(runScriptStep);
    }
  }
  ```

  Below is an example of how you would run a simulation against the above `CommandDocument`.

  Currently, `bash` must be available in the container or the executions against the docker will not succeed.

  ```python
  test('Test command doc', () => {
    const app = new cdk.App();
    const stack = new HelloCdk.HelloCdkStack(app, 'MyTestStack');
    // 1. $ docker pull amazonlinux
    // 2. $ docker run -di amazonlinux
    const simulation = Simulation.ofCommand(stack.myCommandDoc, {
      simulationPlatform: Platform.LINUX,
      environment: DockerEnvironment.fromContainer('MY_CONTAINER_ID')
    });
    simulation.simulate({FirstCommand: 'mkdir foobar'})
    // 3. The document should run the first command (create 'foobar') and create file 'asdf'
    // 4. $ docker exec -it <container name> bash
    // 5. Ensure that 'asdf' and 'foobar' were written to /tmp
  });
  ```



  In typical CDK style, you can assemble often used groups of steps into higher level Constructs.

  Consider if you typically create AutomationDocuments that start with logging the time and end with logging the total time taken. You can create a high-level Automation Document and extend that when you implement an Automation.

  See the `TimedDocument` class to see such implementation.

  Or consider the case of multiple steps that are always run together such as rebooting and instance and waiting for it to be active.

  The below example is copied from the `RebootInstanceAndWait` class:

  ```python
  export class RebootInstanceAndWait extends CompositeAutomationStep {

    readonly reboot: AwsApiStep;
    readonly describe: WaitForResourceStep;

    constructor(scope: Construct, id: string, instanceId: IStringVariable) {
      super(scope, id);
      this.reboot = new AwsApiStep(this, 'RebootInstances', {
        service: AwsService.EC2,
        pascalCaseApi: 'RebootInstances',
        apiParams: { InstanceIds: [instanceId] },
        outputs: [],
      });
      this.describe = new WaitForResourceStep(this, 'DescribeInstances', {
        service: AwsService.EC2,
        pascalCaseApi: 'DescribeInstances',
        apiParams: { InstanceIds: [instanceId] },
        selector: '$.Reservations[0].Instances[0].State.Name',
        desiredValues: ['running'],
      });
    }

    addToDocument(doc: AutomationDocumentBuilder): void {
      doc.addStep(this.reboot);
      doc.addStep(this.describe);
    }
  }
  ```

  Now, you can use `RebootInstanceAndWait` as a step in a document and the child steps will be included.



  Do you have an existing document that you want to convert to code and/or test locally using the simulation?



  Here is an example of how you can import an existing document and then simulate it locally with mocked AWS resources:

  ```python
  // Initialize Mocks
  const sleeper = new MockSleep();
  const awsInvoker = new MockAwsInvoker();
  awsInvoker.whenThen(
      // when invoked with...
      {awsApi: 'listBuckets', awsParams: {}, service: AwsService.S3},
      // then response with...
      {Owner: {ID: "BUCKET_ID"}})

  // ======> Create document from file <=======
  const stack: Stack = new Stack();
  const myAutomationDoc = StringDocument.fromFile(stack, "MyAutomationDoc", 'test/myAutomation.json', {
                                                                          // ======================
  });

  // Execute simulation
  const simOutput = Simulation.ofAutomation(myAutomationDoc, {
    sleepHook: sleeper,
    awsInvoker: awsInvoker
  }).simulate({});

  // Assert simulation result
  assert.deepEqual(awsInvoker.previousInvocations, [
      { awsApi: 'listBuckets', awsParams: {}, service: AwsService.S3 }]);
  assert.deepEqual(sleeper.sleepMilliInvocations, [3000]);
  assert.deepEqual(simOutput.outputs['simulationSteps'], ['MySleep', 'GetBucketId']);
  ```



  You can also grab a string step (or steps) and import them as CDK step constructs.
  This can be used to convert existing documents into CDK with each step defined separately.
  Doing so will allow you do modify steps and reuse them in other documents.

  Here's a simple example of a sleep step copy and pasted from its original yaml:

  ```python
  StringStep.fromYaml(this, `
      name: sleep
      action: aws:sleep
      inputs:
        Duration: PT0M
  `, {});
  ```

  The above will return the CDK construct SleepStep.



  This library provides L2 constructs for IncidentResponse as follows:

  ```python
  new IncidentResponse(this, "MyIncidentResponsePlan", {
        incidentTemplate: IncidentTemplate.critical('EC2 Instance Utilization Impacted', {
          summary: 'EC2 Instance Impacted'
        }),
        actions: [
          IncidentResponseAction.ssmAutomation(myAutomationDoc, ec2CwAlarmRole, {
            parameters: {
              IncidentRecordArn: StringVariable.of('INCIDENT_RECORD_ARN'),
              InvolvedResources: StringVariable.of('INVOLVED_RESOURCES'),
              AutomationAssumeRole: HardCodedString.of(ec2CwAlarmRole.roleArn),
            }
          })
        ]
  });
  ```

  Notice how the `myAutomationDoc` is specified which is a reference to an AutomationDocument created using this library.



  This library currently contains AutomationDocument and CommandDocument steps.
  Simulation for AutomationDocuments is fully supported. Simulation for CommandDocuments is limited.

  Stay tuned!



  * https://github.com/udondan/cdk-ssm-document



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: 0d1fcf9672f71e532e92d3b0d3f7cd35b29e636c82ff6a624630f8b0a219b277
name: python-cdklabs.cdk-validator-cfnguard
arch: src
version: 0.0.60
epoch: 0
release: 1
summary: @cdklabs/cdk-validator-cfnguard
url: https://github.com/cdklabs/cdk-validator-cfnguard.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-validator-cfnguard-0.0.60-1.src.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->


  ```bash
  npm install @cdklabs/cdk-validator-cfnguard
  ```

  ```bash
  pip install cdklabs.cdk-validator-cfnguard
  ```

  ```xml
  // add this to your pom.xml
  <dependency>
      <groupId>io.github.cdklabs</groupId>
      <artifactId>cdk-validator-cfnguard</artifactId>
      <version>0.0.0</version> // replace with version
  </dependency>
  ```

  ```bash
  dotnet add package Cdklabs.CdkValidatorCfnGuard --version X.X.X
  ```

  To use this plugin in your CDK application add it to the CDK App.
  ```python
  App(
      policy_validation_beta1=[
          CfnGuardValidator()
      ]
  )
  ```
  By default the `CfnGuardValidator` plugin comes with the [Control Tower
  proactive
  controls](https://docs.aws.amazon.com/controltower/latest/userguide/proactive-controls.html)
  enabled. In order to disable these rules you can use the
  `controlTowerRulesEnabled: false` property.
  ```python
  CfnGuardValidator(
      control_tower_rules_enabled=False
  )
  ```
  It is also possible to disable individual rules.
  ```python
  CfnGuardValidator(
      disabled_rules=["ct-s3-pr-1"
      ]
  )
  ```

  To provide additional rules to the plugin, provide a list of local
  file or directory paths.
  ```python
  CfnGuardValidator(
      rules=["path/to/local-rules-directory", "path/to/s3/local-rules/my-rule.guard"
      ]
  )
  ```
  If the path provided is a directory then the directory must only
  contain guard rule files, and all rules within the directory will be used.

  The bundled Control Tower proactive controls use CloudFormation Guard
  policies that are also used in managed controls from the Control Tower
  service. You can use these CDK bundled controls without having a Control
  Tower environment in AWS, but there are many benefits to using the two together.
  When you enable Control Tower proactive controls in your Control Tower environment,
  the controls can stop the deployment of non-compliant resources deployed via
  CloudFormation. For more information about managed proactive controls and how they work,
  see the [Control Tower documentation](https://docs.aws.amazon.com/controltower/latest/userguide/proactive-controls.html).
  These CDK bundled controls and managed Control Tower proactive controls are best used together.
  In this scenario you can configure this validation plugin with the same proactive controls that
  are active in your Control Tower cloud environment. You can then quickly gain confidence
  that your CDK application will pass the Control Tower controls by running cdk synth locally
  or in a pipeline as described above.
  Regardless of whether you or your organization use Control Tower, however, you should
  understand the following things about these bundled controls when run locally using this plugin:
  1. These CloudFormation guard policies accept a limited subset of CloudFormation syntax
     for the properties they evaluate. For instance, a property called EncryptionEnabled may
     pass if it is specified with the literal value true, but it may fail if it is specified with
     a reference to a CloudFormation stack parameter instead. Similarly, if a rule checks for a string
     value, it may fail for Fn::Join objects. If you discover that a rule can be bypassed with a
     particular configuration of a resource, please file an issue.
  2. Some rules may check references to other resources, but this reference checking is limited.
     For instance, a rule may require that an access logging bucket is specified for each S3 bucket.
     In this case, the rule can check whether you have passed a reference to a bucket in the same
     template, but it cannot verify that a hardcoded bucket name like "examplebucket" actually refers
     to a real bucket or a bucket you own.
  You can add a layer of security protection by enabling the same proactive controls in your Control Tower
  cloud environment. There are different considerations for using these controls since they operate in a
  different way. For more information, see the [Control Tower proactive controls documentation](https://docs.aws.amazon.com/controltower/latest/userguide/proactive-controls.html).
  If you do not yet have a Control Tower environment, see [What is AWS Control Tower?](https://docs.aws.amazon.com/controltower/latest/userguide/what-is-control-tower.html).

  | ID                                                                                                                                                     | Name                                                                                                                                                                                     | Evaluated Resource Types                                                                            |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
  | [CT.ACM.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/acm-rules.html#ct-acm-pr-1-description)                                        | Require an AWS Private CA certificate to have a single domain name                                                                                                                       | `AWS::CertificateManager::Certificate`<br/>                                                         |
  | [CT.APIGATEWAY.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/api-gateway-rules.html#ct-apigateway-pr-1-description)                  | Require an Amazon API Gateway REST and WebSocket API to have logging activated                                                                                                           | `AWS::ApiGateway::Stage`<br/>                                                                       |
  | [CT.APIGATEWAY.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/api-gateway-rules.html#ct-apigateway-pr-2-description)                  | Require an Amazon API Gateway REST API stage to have AWS X-Ray tracing activated                                                                                                         | `AWS::ApiGateway::Stage`<br/>                                                                       |
  | [CT.APIGATEWAY.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/api-gateway-rules.html#ct-apigateway-pr-3-description)                  | Require that an Amazon API Gateway REST API stage has encryption at rest configured for cache data                                                                                       | `AWS::ApiGateway::Stage`<br/>                                                                       |
  | [CT.APIGATEWAY.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/api-gateway-rules.html#ct-apigateway-pr-4-description)                  | Require an Amazon API Gateway V2 stage to have access logging activated                                                                                                                  | `AWS::ApiGatewayV2::Stage`<br/>                                                                     |
  | [CT.APIGATEWAY.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/api-gateway-rules.html#ct-apigateway-pr-5-description)                  | Require Amazon API Gateway V2 Websocket and HTTP routes to specify an authorization type                                                                                                 | `AWS::ApiGatewayV2::Route`<br/>`AWS::ApiGatewayV2::ApiGatewayManagedOverrides`<br/>                 |
  | [CT.APIGATEWAY.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/api-gateway-rules.html#ct-apigateway-pr-6-description)                  | Require an Amazon API Gateway REST domain to use a security policy that specifies a minimum TLS protocol version of TLSv1.2                                                              | `AWS::ApiGateway::DomainName`<br/>                                                                  |
  | [CT.APPSYNC.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/appsync-rules.html#ct-appsync-pr-1-description)                            | Require an AWS AppSync GraphQL API to have logging enabled                                                                                                                               | `AWS::AppSync::GraphQLApi`<br/>                                                                     |
  | [CT.APPSYNC.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/appsync-rules.html#ct-appsync-pr-2-description)                            | Require an AWS AppSync GraphQL API to be configured with private visibility                                                                                                              | `AWS::AppSync::GraphQLApi`<br/>                                                                     |
  | [CT.APPSYNC.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/appsync-rules.html#ct-appsync-pr-3-description)                            | Require that an AWS AppSync GraphQL API is not authenticated with API keys                                                                                                               | `AWS::AppSync::GraphQLApi`<br/>                                                                     |
  | [CT.APPSYNC.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/appsync-rules.html#ct-appsync-pr-4-description)                            | Require an AWS AppSync GraphQL API cache to have encryption in transit enabled.                                                                                                          | `AWS::AppSync::ApiCache`<br/>                                                                       |
  | [CT.APPSYNC.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/appsync-rules.html#ct-appsync-pr-5-description)                            | Require an AWS AppSync GraphQL API cache to have encryption at rest enabled.                                                                                                             | `AWS::AppSync::ApiCache`<br/>                                                                       |
  | [CT.ATHENA.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/athena-rules.html#ct-athena-pr-1-description)                               | Require an Amazon Athena workgroup to encrypt Athena query results at rest                                                                                                               | `AWS::Athena::WorkGroup`<br/>                                                                       |
  | [CT.ATHENA.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/athena-rules.html#ct-athena-pr-2-description)                               | Require an Amazon Athena workgroup to encrypt Athena query results at rest with an AWS Key Management Service (KMS) key                                                                  | `AWS::Athena::WorkGroup`<br/>                                                                       |
  | [CT.AUTOSCALING.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-1-description)           | Require an Amazon EC2 Auto Scaling group to have multiple Availability Zones                                                                                                             | `AWS::AutoScaling::AutoScalingGroup`<br/>                                                           |
  | [CT.AUTOSCALING.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-2-description)           | Require an Amazon EC2 Auto Scaling group launch configuration to configure Amazon EC2 instances for IMDSv2                                                                               | `AWS::AutoScaling::LaunchConfiguration`<br/>                                                        |
  | [CT.AUTOSCALING.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-3-description)           | Require an Amazon EC2 Auto Scaling launch configuration to have a single-hop metadata response limit                                                                                     | `AWS::AutoScaling::LaunchConfiguration`<br/>                                                        |
  | [CT.AUTOSCALING.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-4-description)           | Require an Amazon EC2 Auto Scaling group associated with an AWS Elastic Load Balancer (ELB) to have ELB health checks activated                                                          | `AWS::AutoScaling::AutoScalingGroup`<br/>                                                           |
  | [CT.AUTOSCALING.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-5-description)           | Require that an Amazon EC2 Auto Scaling group launch configuration does not have Amazon EC2 instances with public IP addresses                                                           | `AWS::AutoScaling::LaunchConfiguration`<br/>                                                        |
  | [CT.AUTOSCALING.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-6-description)           | Require any Amazon EC2 Auto Scaling groups to use multiple instance types                                                                                                                | `AWS::AutoScaling::AutoScalingGroup`<br/>                                                           |
  | [CT.AUTOSCALING.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-8-description)           | Require an Amazon EC2 Auto Scaling group to have EC2 launch templates configured                                                                                                         | `AWS::AutoScaling::AutoScalingGroup`<br/>                                                           |
  | [CT.AUTOSCALING.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-9-description)           | Require an Amazon EBS volume configured through an Amazon EC2 Auto Scaling launch configuration to encrypt data at rest                                                                  | `AWS::AutoScaling::LaunchConfiguration`<br/>                                                        |
  | [CT.AUTOSCALING.PR.10](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-10-description)         | Require an Amazon EC2 Auto Scaling group to use only AWS Nitro instance types when overriding a launch template                                                                          | `AWS::AutoScaling::AutoScalingGroup`<br/>                                                           |
  | [CT.AUTOSCALING.PR.11](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-auto-scaling-rules.html#ct-autoscaling-pr-11-description)         | Require only AWS Nitro instance types that support network traffic encryption between instances to be added to an Amazon EC2 Auto Scaling group, when overriding a launch template       | `AWS::AutoScaling::AutoScalingGroup`<br/>                                                           |
  | [CT.CLOUDFRONT.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-1-description)                   | Require an Amazon CloudFront distribution to have a default root object configured                                                                                                       | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-3-description)                   | Require an Amazon CloudFront distribution to have encryption in transit configured                                                                                                       | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-4-description)                   | Require an Amazon CloudFront distribution to have origin failover configured                                                                                                             | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-5-description)                   | Require any Amazon CloudFront distribution to have logging enabled                                                                                                                       | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-6-description)                   | Require an Amazon CloudFront distribution to use custom SSL/TLS certificates                                                                                                             | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.7](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-7-description)                   | Require an Amazon CloudFront distribution to use SNI to serve HTTPS requests                                                                                                             | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-8-description)                   | Require an Amazon CloudFront distribution to encrypt traffic to custom origins                                                                                                           | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-9-description)                   | Require an Amazon CloudFront distribution to have a security policy of TLSv1.2 as a minimum                                                                                              | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.10](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-10-description)                 | Require any Amazon CloudFront distributions with Amazon S3 backed origins to have origin access control configured                                                                       | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDFRONT.PR.11](https://docs.aws.amazon.com/controltower/latest/userguide/cloudfront-rules.html#ct-cloudfront-pr-11-description)                 | Require an Amazon CloudFront distribution to use updated SSL protocols between edge locations and custom origins                                                                         | `AWS::CloudFront::Distribution`<br/>                                                                |
  | [CT.CLOUDTRAIL.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/cloudtrail-rules.html#ct-cloudtrail-pr-1-description)                   | Require an AWS CloudTrail trail to have encryption at rest activated                                                                                                                     | `AWS::CloudTrail::Trail`<br/>                                                                       |
  | [CT.CLOUDTRAIL.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/cloudtrail-rules.html#ct-cloudtrail-pr-2-description)                   | Require an AWS CloudTrail trail to have log file validation activated                                                                                                                    | `AWS::CloudTrail::Trail`<br/>                                                                       |
  | [CT.CLOUDTRAIL.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/cloudtrail-rules.html#ct-cloudtrail-pr-3-description)                   | Require an AWS CloudTrail trail to have an Amazon CloudWatch log group configuration                                                                                                     | `AWS::CloudTrail::Trail`<br/>                                                                       |
  | [CT.CLOUDTRAIL.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/cloudtrail-rules.html#ct-cloudtrail-pr-4-description)                   | Require an AWS CloudTrail Lake event data store to enable encryption at rest with an AWS KMS key                                                                                         | `AWS::CloudTrail::EventDataStore`<br/>                                                              |
  | [CT.CLOUDWATCH.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/cloudwatch-rules.html#ct-cloudwatch-pr-1-description)                   | Require an Amazon CloudWatch alarm to have an action configured for the alarm state                                                                                                      | `AWS::CloudWatch::Alarm`<br/>                                                                       |
  | [CT.CLOUDWATCH.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/cloudwatch-rules.html#ct-cloudwatch-pr-2-description)                   | Require an Amazon CloudWatch log group to be retained for at least one year                                                                                                              | `AWS::Logs::LogGroup`<br/>                                                                          |
  | [CT.CLOUDWATCH.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/cloudwatch-rules.html#ct-cloudwatch-pr-3-description)                   | Require an Amazon CloudWatch log group to be encrypted at rest with an AWS KMS key                                                                                                       | `AWS::Logs::LogGroup`<br/>                                                                          |
  | [CT.CLOUDWATCH.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/cloudwatch-rules.html#ct-cloudwatch-pr-4-description)                   | Require an Amazon CloudWatch alarm to have actions activated                                                                                                                             | `AWS::CloudWatch::Alarm`<br/>                                                                       |
  | [CT.CODEBUILD.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/codebuild-rules.html#ct-codebuild-pr-1-description)                      | Require OAuth on GitHub or Bitbucket source repository URLs for AWS CodeBuild projects                                                                                                   | `AWS::CodeBuild::Project`<br/>                                                                      |
  | [CT.CODEBUILD.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/codebuild-rules.html#ct-codebuild-pr-2-description)                      | Require any AWS CodeBuild project environment variable to encrypt credentials in environment variables                                                                                   | `AWS::CodeBuild::Project`<br/>                                                                      |
  | [CT.CODEBUILD.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/codebuild-rules.html#ct-codebuild-pr-3-description)                      | Require any AWS CodeBuild project environment to have logging configured                                                                                                                 | `AWS::CodeBuild::Project`<br/>                                                                      |
  | [CT.CODEBUILD.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/codebuild-rules.html#ct-codebuild-pr-4-description)                      | Require any AWS CodeBuild project to deactivate privileged mode when running                                                                                                             | `AWS::CodeBuild::Project`<br/>                                                                      |
  | [CT.CODEBUILD.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/codebuild-rules.html#ct-codebuild-pr-5-description)                      | Require encryption on all AWS CodeBuild project artifacts                                                                                                                                | `AWS::CodeBuild::Project`<br/>                                                                      |
  | [CT.CODEBUILD.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/codebuild-rules.html#ct-codebuild-pr-6-description)                      | Require encryption on all Amazon S3 logs for AWS CodeBuild projects                                                                                                                      | `AWS::CodeBuild::Project`<br/>                                                                      |
  | [CT.DAX.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/dax-rules.html#ct-dax-pr-1-description)                                        | Require encryption at rest for all Amazon DynamoDB Accelerator (DAX) clusters                                                                                                            | `AWS::DAX::Cluster`<br/>                                                                            |
  | [CT.DAX.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/dax-rules.html#ct-dax-pr-2-description)                                        | Require an Amazon DAX cluster to deploy nodes to at least three Availability Zones                                                                                                       | `AWS::DAX::Cluster`<br/>                                                                            |
  | [CT.DAX.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/dax-rules.html#ct-dax-pr-3-description)                                        | Require an Amazon DAX cluster to encrypt data in transit with Transport Layer Security (TLS)                                                                                             | `AWS::DAX::Cluster`<br/>                                                                            |
  | [CT.DMS.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/dms-rules.html#ct-dms-pr-1-description)                                        | Require that a public AWS DMS replication instance is not public                                                                                                                         | `AWS::DMS::ReplicationInstance`<br/>                                                                |
  | [CT.DMS.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/dms-rules.html#ct-dms-pr-2-description)                                        | Require an AWS Database Migration Service (DMS) Endpoint to encrypt connections for source and target endpoints                                                                          | `AWS::DMS::Endpoint`<br/>                                                                           |
  | [CT.DOCUMENTDB.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/documentdb-rules.html#ct-documentdb-pr-1-description)                   | Require an Amazon DocumentDB cluster to be encrypted at rest                                                                                                                             | `AWS::DocDB::DBCluster`<br/>                                                                        |
  | [CT.DOCUMENTDB.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/documentdb-rules.html#ct-documentdb-pr-2-description)                   | Require an Amazon DocumentDB cluster to have a backup retention period greater than or equal to seven days                                                                               | `AWS::DocDB::DBCluster`<br/>                                                                        |
  | [CT.DYNAMODB.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/dynamodb-rules.html#ct-dynamodb-pr-1-description)                         | Require that point-in-time recovery for an Amazon DynamoDB table is activated                                                                                                            | `AWS::DynamoDB::Table`<br/>                                                                         |
  | [CT.DYNAMODB.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/dynamodb-rules.html#ct-dynamodb-pr-2-description)                         | Require an Amazon DynamoDB table to be encrypted at rest using an AWS KMS key                                                                                                            | `AWS::DynamoDB::Table`<br/>                                                                         |
  | [CT.EC2.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-1-description)                                        | Require an Amazon EC2 launch template to have IMDSv2 configured                                                                                                                          | `AWS::EC2::LaunchTemplate`<br/>                                                                     |
  | [CT.EC2.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-2-description)                                        | Require that Amazon EC2 launch templates restrict the token hop limit to a maximum of one                                                                                                | `AWS::EC2::LaunchTemplate`<br/>                                                                     |
  | [CT.EC2.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-3-description)                                        | Require that any Amazon EC2 security group rule does not use the source IP range 0.0.0.0/0 or ::/0 for ports other than 80 and 443                                                       | `AWS::EC2::SecurityGroup`<br/>`AWS::EC2::SecurityGroupIngress`<br/>                                 |
  | [CT.EC2.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-4-description)                                        | Require that any Amazon EC2 security group rule does not use the source IP range 0.0.0.0/0 or ::/0 for specific high-risk ports                                                          | `AWS::EC2::SecurityGroup`<br/>`AWS::EC2::SecurityGroupIngress`<br/>                                 |
  | [CT.EC2.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-5-description)                                        | Require any Amazon EC2 network ACL to prevent ingress from 0.0.0.0/0 to port 22 or port 3389                                                                                             | `AWS::EC2::NetworkAclEntry`<br/>                                                                    |
  | [CT.EC2.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-6-description)                                        | Require that Amazon EC2 transit gateways refuse automatic Amazon VPC attachment requests                                                                                                 | `AWS::EC2::TransitGateway`<br/>                                                                     |
  | [CT.EC2.PR.7](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-7-description)                                        | Require an Amazon EBS volume resource to be encrypted at rest when defined by means of the AWS::EC2::Instance BlockDeviceMappings property or AWS::EC2::Volume resource type             | `AWS::EC2::Instance`<br/>`AWS::EC2::Volume`<br/>                                                    |
  | [CT.EC2.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-8-description)                                        | Require an Amazon EC2 instance to set AssociatePublicIpAddress to false on a new network interface created by means of the NetworkInterfaces property in the AWS::EC2::Instance resource | `AWS::EC2::Instance`<br/>                                                                           |
  | [CT.EC2.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-9-description)                                        | Require any Amazon EC2 launch template not to auto-assign public IP addresses to network interfaces                                                                                      | `AWS::EC2::LaunchTemplate`<br/>                                                                     |
  | [CT.EC2.PR.10](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-10-description)                                      | Require Amazon EC2 launch templates to have Amazon CloudWatch detailed monitoring activated                                                                                              | `AWS::EC2::LaunchTemplate`<br/>                                                                     |
  | [CT.EC2.PR.11](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-11-description)                                      | Require that an Amazon EC2 subnet does not automatically assign public IP addresses                                                                                                      | `AWS::EC2::Subnet`<br/>                                                                             |
  | [CT.EC2.PR.12](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-12-description)                                      | Require an Amazon EC2 instance to specify at most one network interface by means of the NetworkInterfaces property in the AWS::EC2::Instance resource                                    | `AWS::EC2::Instance`<br/>                                                                           |
  | [CT.EC2.PR.13](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-13-description)                                      | Require an Amazon EC2 instance to have detailed monitoring enabled                                                                                                                       | `AWS::EC2::Instance`<br/>                                                                           |
  | [CT.EC2.PR.14](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-14-description)                                      | Require an Amazon EBS volume configured through an Amazon EC2 launch template to encrypt data at rest                                                                                    | `AWS::EC2::LaunchTemplate`<br/>                                                                     |
  | [CT.EC2.PR.15](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-15-description)                                      | Require an Amazon EC2 instance to use an AWS Nitro instance type when creating from the 'AWS::EC2::LaunchTemplate' resource type                                                         | `AWS::EC2::LaunchTemplate`<br/>                                                                     |
  | [CT.EC2.PR.16](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-16-description)                                      | Require an Amazon EC2 instance to use an AWS Nitro instance type when created using the 'AWS::EC2::Instance' resource type                                                               | `AWS::EC2::Instance`<br/>                                                                           |
  | [CT.EC2.PR.17](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-17-description)                                      | Require an Amazon EC2 dedicated host to use an AWS Nitro instance type                                                                                                                   | `AWS::EC2::Host`<br/>                                                                               |
  | [CT.EC2.PR.18](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-18-description)                                      | Require an Amazon EC2 fleet to override only those launch templates with AWS Nitro instance types                                                                                        | `AWS::EC2::EC2Fleet`<br/>                                                                           |
  | [CT.EC2.PR.19](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-19-description)                                      | Require an EC2 instance to use an AWS Nitro instance type that supports encryption in-transit between instances when created using the AWS::EC2::Instance resource type                  | `AWS::EC2::Instance`<br/>                                                                           |
  | [CT.EC2.PR.20](https://docs.aws.amazon.com/controltower/latest/userguide/ec2-rules.html#ct-ec2-pr-20-description)                                      | Require an Amazon EC2 fleet to override only those launch templates with AWS Nitro instance types that support encryption in transit between instances                                   | `AWS::EC2::EC2Fleet`<br/>                                                                           |
  | [CT.ECR.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/ecr-rules.html#ct-ecr-pr-1-description)                                        | Require Amazon ECR repositories to have a lifecycle policy configured                                                                                                                    | `AWS::ECR::Repository`<br/>                                                                         |
  | [CT.ECR.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/ecr-rules.html#ct-ecr-pr-2-description)                                        | Require Amazon ECR private repositories to have image scanning enabled                                                                                                                   | `AWS::ECR::Repository`<br/>                                                                         |
  | [CT.ECR.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/ecr-rules.html#ct-ecr-pr-3-description)                                        | Require Amazon ECR private repositories to have tag immutability enabled                                                                                                                 | `AWS::ECR::Repository`<br/>                                                                         |
  | [CT.ECS.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-1-description)                                        | Require AWS ECS Fargate Services to run on the latest Fargate platform version                                                                                                           | `AWS::ECS::Service`<br/>                                                                            |
  | [CT.ECS.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-2-description)                                        | Require any Amazon ECS cluster to have container insights activated                                                                                                                      | `AWS::ECS::Cluster`<br/>                                                                            |
  | [CT.ECS.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-3-description)                                        | Require any Amazon ECS task definition to specify a user that is not the root                                                                                                            | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.ECS.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-4-description)                                        | Require Amazon ECS tasks to use 'awsvpc' networking mode                                                                                                                                 | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.ECS.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-5-description)                                        | Require an active Amazon ECS task definition to have a logging configuration                                                                                                             | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.ECS.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-6-description)                                        | Require Amazon ECS containers to allow read-only access to the root filesystem                                                                                                           | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.ECS.PR.7](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-7-description)                                        | Require an Amazon ECS task definition to have a specific memory usage limit                                                                                                              | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.ECS.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-8-description)                                        | Require Amazon ECS task definitions to have secure networking modes and user definitions                                                                                                 | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.ECS.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-9-description)                                        | Require Amazon ECS services not to assign public IP addresses automatically                                                                                                              | `AWS::ECS::Service`<br/>                                                                            |
  | [CT.ECS.PR.10](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-10-description)                                      | Require that Amazon ECS task definitions do not share the host's process namespace                                                                                                       | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.ECS.PR.11](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-11-description)                                      | Require an Amazon ECS container to run as non-privileged                                                                                                                                 | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.ECS.PR.12](https://docs.aws.amazon.com/controltower/latest/userguide/ecs-rules.html#ct-ecs-pr-12-description)                                      | Require that Amazon ECS task definitions do not pass secrets as container environment variables                                                                                          | `AWS::ECS::TaskDefinition`<br/>                                                                     |
  | [CT.EKS.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/eks-rules.html#ct-eks-pr-1-description)                                        | Require an Amazon EKS cluster to be configured with public access disabled to the cluster Kubernetes API server endpoint.                                                                | `AWS::EKS::Cluster`<br/>                                                                            |
  | [CT.EKS.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/eks-rules.html#ct-eks-pr-2-description)                                        | Require an Amazon EKS cluster to be configured with secret encryption using AWS Key Management Service (KMS) keys                                                                        | `AWS::EKS::Cluster`<br/>                                                                            |
  | [CT.ELASTICACHE.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/elasticache-rules.html#ct-elasticache-pr-1-description)                | Require an Amazon ElastiCache for Redis cluster to have automatic backups activated                                                                                                      | `AWS::ElastiCache::CacheCluster`<br/>                                                               |
  | [CT.ELASTICACHE.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/elasticache-rules.html#ct-elasticache-pr-2-description)                | Require an Amazon ElastiCache for Redis cluster to have automatic minor version upgrades activated                                                                                       | `AWS::ElastiCache::CacheCluster`<br/>                                                               |
  | [CT.ELASTICACHE.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/elasticache-rules.html#ct-elasticache-pr-3-description)                | Require an Amazon ElastiCache for Redis replication group to have automatic failover activated                                                                                           | `AWS::ElastiCache::ReplicationGroup`<br/>                                                           |
  | [CT.ELASTICACHE.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/elasticache-rules.html#ct-elasticache-pr-4-description)                | Require an Amazon ElastiCache replication group to have encryption at rest activated                                                                                                     | `AWS::ElastiCache::ReplicationGroup`<br/>                                                           |
  | [CT.ELASTICACHE.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/elasticache-rules.html#ct-elasticache-pr-5-description)                | Require an Amazon ElastiCache for Redis replication group to have encryption in transit activated                                                                                        | `AWS::ElastiCache::ReplicationGroup`<br/>                                                           |
  | [CT.ELASTICACHE.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/elasticache-rules.html#ct-elasticache-pr-6-description)                | Require an Amazon ElastiCache cache cluster to use a custom subnet group                                                                                                                 | `AWS::ElastiCache::CacheCluster`<br/>                                                               |
  | [CT.ELASTICACHE.PR.7](https://docs.aws.amazon.com/controltower/latest/userguide/elasticache-rules.html#ct-elasticache-pr-7-description)                | Require an Amazon ElastiCache replication group of earlier Redis versions to have Redis AUTH activated                                                                                   | `AWS::ElastiCache::ReplicationGroup`<br/>                                                           |
  | [CT.ELASTICACHE.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/elasticache-rules.html#ct-elasticache-pr-8-description)                | Require an Amazon ElastiCache replication group of later Redis versions to have RBAC authentication activated                                                                            | `AWS::ElastiCache::ReplicationGroup`<br/>                                                           |
  | [CT.ELASTICBEANSTALK.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/ebs-rules.html#ct-elasticbeanstalk-pr-1-description)              | Require AWS Elastic Beanstalk environments to have enhanced health reporting enabled                                                                                                     | `AWS::ElasticBeanstalk::Environment`<br/>`AWS::ElasticBeanstalk::ConfigurationTemplate`<br/>        |
  | [CT.ELASTICBEANSTALK.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/ebs-rules.html#ct-elasticbeanstalk-pr-2-description)              | Require an AWS Elastic Beanstalk environment to have managed platform updates configured                                                                                                 | `AWS::ElasticBeanstalk::Environment`<br/>`AWS::ElasticBeanstalk::ConfigurationTemplate`<br/>        |
  | [CT.ELASTICBEANSTALK.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/ebs-rules.html#ct-elasticbeanstalk-pr-3-description)              | Require an AWS Elastic Beanstalk environment to have a logging configuration                                                                                                             | `AWS::ElasticBeanstalk::Environment`<br/>`AWS::ElasticBeanstalk::ConfigurationTemplate`<br/>        |
  | [CT.ELASTICFILESYSYSTEM.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/efs-rules.html#ct-elasticfilesysystem-pr-1-description)        | Require an Amazon EFS file system to encrypt file data at rest using AWS KMS                                                                                                             | `AWS::EFS::FileSystem`<br/>                                                                         |
  | [CT.ELASTICFILESYSYSTEM.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/efs-rules.html#ct-elasticfilesysystem-pr-2-description)        | Require an Amazon EFS volume to have an automated backup plan                                                                                                                            | `AWS::EFS::FileSystem`<br/>                                                                         |
  | [CT.ELASTICFILESYSYSTEM.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/efs-rules.html#ct-elasticfilesysystem-pr-3-description)        | Require Amazon EFS access points to have a root directory                                                                                                                                | `AWS::EFS::AccessPoint`<br/>                                                                        |
  | [CT.ELASTICFILESYSYSTEM.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/efs-rules.html#ct-elasticfilesysystem-pr-4-description)        | Require Amazon EFS access points to enforce a user identity                                                                                                                              | `AWS::EFS::AccessPoint`<br/>                                                                        |
  | [CT.ELASTICLOADBALANCING.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-1-description)      | Require any application load balancer listener default actions to redirect all HTTP requests to HTTPS                                                                                    | `AWS::ElasticLoadBalancingV2::Listener`<br/>                                                        |
  | [CT.ELASTICLOADBALANCING.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-2-description)      | Require any Amazon ELB application or network load balancer to have an AWS Certificate Manager certificate                                                                               | `AWS::ElasticLoadBalancingV2::Listener`<br/>`AWS::ElasticLoadBalancingV2::ListenerCertificate`<br/> |
  | [CT.ELASTICLOADBALANCING.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-3-description)      | Require any application load balancer to have defensive or strictest desync mitigation mode activated                                                                                    | `AWS::ElasticLoadBalancingV2::LoadBalancer`<br/>                                                    |
  | [CT.ELASTICLOADBALANCING.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-4-description)      | Require that any application load balancer must be configured to drop HTTP headers                                                                                                       | `AWS::ElasticLoadBalancingV2::LoadBalancer`<br/>                                                    |
  | [CT.ELASTICLOADBALANCING.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-5-description)      | Require that application load balancer deletion protection is activated                                                                                                                  | `AWS::ElasticLoadBalancingV2::LoadBalancer`<br/>                                                    |
  | [CT.ELASTICLOADBALANCING.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-6-description)      | Require that application and network load balancer access logging is activated                                                                                                           | `AWS::ElasticLoadBalancingV2::LoadBalancer`<br/>                                                    |
  | [CT.ELASTICLOADBALANCING.PR.7](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-7-description)      | Require any classic load balancer to have multiple Availability Zones configured                                                                                                         | `AWS::ElasticLoadBalancing::LoadBalancer`<br/>                                                      |
  | [CT.ELASTICLOADBALANCING.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-8-description)      | Require any classic load balancer SSL/HTTPS listener to have a certificate provided by AWS Certificate Manager                                                                           | `AWS::ElasticLoadBalancing::LoadBalancer`<br/>                                                      |
  | [CT.ELASTICLOADBALANCING.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-9-description)      | Require that an AWS ELB application or classic load balancer listener is configured with HTTPS or TLS termination                                                                        | `AWS::ElasticLoadBalancing::LoadBalancer`<br/>                                                      |
  | [CT.ELASTICLOADBALANCING.PR.10](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-10-description)    | Require an ELB application or classic load balancer to have logging activated                                                                                                            | `AWS::ElasticLoadBalancing::LoadBalancer`<br/>                                                      |
  | [CT.ELASTICLOADBALANCING.PR.11](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-11-description)    | Require any ELB classic load balancer to have connection draining activated                                                                                                              | `AWS::ElasticLoadBalancing::LoadBalancer`<br/>                                                      |
  | [CT.ELASTICLOADBALANCING.PR.12](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-12-description)    | Require any ELB classic load balancer SSL/HTTPS listener to have a predefined security policy with a strong configuration                                                                | `AWS::ElasticLoadBalancing::LoadBalancer`<br/>                                                      |
  | [CT.ELASTICLOADBALANCING.PR.13](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-13-description)    | Require any ELB classic load balancer to have cross-zone load balancing activated                                                                                                        | `AWS::ElasticLoadBalancing::LoadBalancer`<br/>                                                      |
  | [CT.ELASTICLOADBALANCING.PR.14](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-14-description)    | Require a Network Load Balancer to have cross-zone load balancing activated                                                                                                              | `AWS::ElasticLoadBalancingV2::LoadBalancer`<br/>                                                    |
  | [CT.ELASTICLOADBALANCING.PR.15](https://docs.aws.amazon.com/controltower/latest/userguide/elb-rules.html#ct-elasticloadbalancing-pr-15-description)    | Require that an Elastic Load Balancing v2 target group does not explicitly disable cross-zone load balancing                                                                             | `AWS::ElasticLoadBalancingV2::TargetGroup`<br/>                                                     |
  | [CT.EMR.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/emr-rules.html#ct-emr-pr-1-description)                                        | Require that an Amazon Elastic MapReduce (EMR) security configuration is configured to encrypt data at rest in Amazon S3                                                                 | `AWS::EMR::SecurityConfiguration`<br/>                                                              |
  | [CT.EMR.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/emr-rules.html#ct-emr-pr-2-description)                                        | Require that an Amazon Elastic MapReduce (EMR) security configuration is configured to encrypt data at rest in Amazon S3 with an AWS KMS key                                             | `AWS::EMR::SecurityConfiguration`<br/>                                                              |
  | [CT.EMR.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/emr-rules.html#ct-emr-pr-3-description)                                        | Require that an Amazon Elastic MapReduce (EMR) security configuration is configured with EBS volume local disk encryption using an AWS KMS key                                           | `AWS::EMR::SecurityConfiguration`<br/>                                                              |
  | [CT.EMR.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/emr-rules.html#ct-emr-pr-4-description)                                        | Require that an Amazon Elastic MapReduce (EMR) security configuration is configured to encrypt data in transit                                                                           | `AWS::EMR::SecurityConfiguration`<br/>                                                              |
  | [CT.GLUE.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/glue-rules.html#ct-glue-pr-1-description)                                     | Require an AWS Glue job to have an associated security configuration                                                                                                                     | `AWS::Glue::Job`<br/>                                                                               |
  | [CT.GUARDDUTY.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/guard-duty-rules.html#ct-guardduty-pr-1-description)                     | Require an Amazon GuardDuty detector to have Amazon S3 protection activated                                                                                                              | `AWS::GuardDuty::Detector`<br/>                                                                     |
  | [CT.IAM.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/iam-rules.html#ct-iam-pr-1-description)                                        | Require that an AWS Identity and Access Management (IAM) inline policy does not have a statement that includes "*" in the Action and Resource elements                                   | `AWS::IAM::Policy`<br/>`AWS::IAM::Role`<br/>`AWS::IAM::User`<br/>`AWS::IAM::Group`<br/>             |
  | [CT.IAM.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/iam-rules.html#ct-iam-pr-2-description)                                        | Require that AWS Identity and Access Management (IAM) customer-managed policies do not contain a statement that includes "*" in the Action and Resource elements                         | `AWS::IAM::ManagedPolicy`<br/>                                                                      |
  | [CT.IAM.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/iam-rules.html#ct-iam-pr-3-description)                                        | Require that AWS Identity and Access Management (IAM) customer-managed policies do not have wildcard service actions                                                                     | `AWS::IAM::ManagedPolicy`<br/>                                                                      |
  | [CT.IAM.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/iam-rules.html#ct-iam-pr-4-description)                                        | Require that an AWS Identity and Access Management (IAM) user does not have an inline or managed policy attached attached                                                                | `AWS::IAM::User`<br/>`AWS::IAM::Policy`<br/>`AWS::IAM::ManagedPolicy`<br/>                          |
  | [CT.IAM.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/iam-rules.html#ct-iam-pr-5-description)                                        | Require that AWS Identity and Access Management (IAM) inline policies do not have wildcard service actions                                                                               | `AWS::IAM::Policy`<br/>`AWS::IAM::Role`<br/>`AWS::IAM::User`<br/>`AWS::IAM::Group`<br/>             |
  | [CT.KINESIS.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/kinesis-rules.html#ct-kinesis-pr-1-description)                            | Require any Amazon Kinesis data stream to have encryption at rest configured                                                                                                             | `AWS::Kinesis::Stream`<br/>                                                                         |
  | [CT.KMS.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/kms-rules.html#ct-kms-pr-1-description)                                        | Require any AWS KMS key to have rotation configured                                                                                                                                      | `AWS::KMS::Key`<br/>                                                                                |
  | [CT.KMS.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/kms-rules.html#ct-kms-pr-2-description)                                        | Require that an AWS KMS asymmetric key with RSA key material used for encryption has a key length greater than 2048 bits                                                                 | `AWS::KMS::Key`<br/>                                                                                |
  | [CT.KMS.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/kms-rules.html#ct-kms-pr-3-description)                                        | Require an AWS KMS key policy to have a statement that limits creation of AWS KMS grants to AWS services                                                                                 | `AWS::KMS::Key`<br/>                                                                                |
  | [CT.LAMBDA.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/lambda-rules.html#ct-lambda-pr-2-description)                               | Require AWS Lambda function policies to prohibit public access                                                                                                                           | `AWS::Lambda::Permission`<br/>                                                                      |
  | [CT.LAMBDA.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/lambda-rules.html#ct-lambda-pr-3-description)                               | Require an AWS Lambda function to be in a customer-managed Amazon Virtual Private Cloud (VPC)                                                                                            | `AWS::Lambda::Function`<br/>                                                                        |
  | [CT.LAMBDA.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/lambda-rules.html#ct-lambda-pr-4-description)                               | Require an AWS Lambda layer permission to grant access to an AWS organization or specific AWS account                                                                                    | `AWS::Lambda::LayerVersionPermission`<br/>                                                          |
  | [CT.LAMBDA.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/lambda-rules.html#ct-lambda-pr-5-description)                               | Require an AWS Lambda function URL to use AWS IAM-based authentication                                                                                                                   | `AWS::Lambda::Url`<br/>                                                                             |
  | [CT.LAMBDA.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/lambda-rules.html#ct-lambda-pr-6-description)                               | Require an AWS Lambda function URL CORS policy to restrict access to specific origins                                                                                                    | `AWS::Lambda::Url`<br/>                                                                             |
  | [CT.MQ.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/mq-rules.html#ct-mq-pr-1-description)                                           | Require an Amazon MQ ActiveMQ broker to use use active/standby deployment mode for high availability                                                                                     | `AWS::AmazonMQ::Broker`<br/>                                                                        |
  | [CT.MQ.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/mq-rules.html#ct-mq-pr-2-description)                                           | Require an Amazon MQ Rabbit MQ broker to use Multi-AZ cluster mode for high availability                                                                                                 | `AWS::AmazonMQ::Broker`<br/>                                                                        |
  | [CT.MSK.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/msk-rules.html#ct-msk-pr-1-description)                                        | Require an Amazon Managed Streaming for Apache Kafka (MSK) cluster to enforce encryption in transit between cluster broker nodes                                                         | `AWS::MSK::Cluster`<br/>                                                                            |
  | [CT.MSK.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/msk-rules.html#ct-msk-pr-2-description)                                        | Require an Amazon Managed Streaming for Apache Kafka (MSK) cluster to be configured with PublicAccess disabled                                                                           | `AWS::MSK::Cluster`<br/>                                                                            |
  | [CT.NEPTUNE.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/neptune-rules.html#ct-neptune-pr-1-description)                            | Require an Amazon Neptune DB cluster to have AWS Identity and Access Management (IAM) database authentication enabled                                                                    | `AWS::Neptune::DBCluster`<br/>                                                                      |
  | [CT.NEPTUNE.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/neptune-rules.html#ct-neptune-pr-2-description)                            | Require an Amazon Neptune DB cluster to have deletion protection enabled                                                                                                                 | `AWS::Neptune::DBCluster`<br/>                                                                      |
  | [CT.NEPTUNE.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/neptune-rules.html#ct-neptune-pr-3-description)                            | Require an Amazon Neptune DB cluster to have storage encryption enabled                                                                                                                  | `AWS::Neptune::DBCluster`<br/>                                                                      |
  | [CT.NEPTUNE.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/neptune-rules.html#ct-neptune-pr-4-description)                            | Require an Amazon Neptune DB cluster to enable Amazon CloudWatch log export for audit logs                                                                                               | `AWS::Neptune::DBCluster`<br/>                                                                      |
  | [CT.NEPTUNE.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/neptune-rules.html#ct-neptune-pr-5-description)                            | Require an Amazon Neptune DB cluster to set a backup retention period greater than or equal to seven days                                                                                | `AWS::Neptune::DBCluster`<br/>                                                                      |
  | [CT.NETWORK-FIREWALL.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/network-firewall-rules.html#ct-network-firewall-pr-1-description) | Require any AWS Network Firewall firewall policy to have an associated rule group                                                                                                        | `AWS::NetworkFirewall::FirewallPolicy`<br/>                                                         |
  | [CT.NETWORK-FIREWALL.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/network-firewall-rules.html#ct-network-firewall-pr-2-description) | Require any AWS Network Firewall firewall policy to drop or forward stateless full packets by default when they do not match a rule                                                      | `AWS::NetworkFirewall::FirewallPolicy`<br/>                                                         |
  | [CT.NETWORK-FIREWALL.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/network-firewall-rules.html#ct-network-firewall-pr-3-description) | Require any AWS Network Firewall firewall policy to drop or forward fragmented packets by default when they do not match a stateless rule                                                | `AWS::NetworkFirewall::FirewallPolicy`<br/>                                                         |
  | [CT.NETWORK-FIREWALL.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/network-firewall-rules.html#ct-network-firewall-pr-4-description) | Require any AWS Network Firewall rule group to contain at least one rule                                                                                                                 | `AWS::NetworkFirewall::RuleGroup`<br/>                                                              |
  | [CT.NETWORK-FIREWALL.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/network-firewall-rules.html#ct-network-firewall-pr-5-description) | Require an AWS Network Firewall firewall to be deployed across multiple Availability Zones                                                                                               | `AWS::NetworkFirewall::Firewall`<br/>                                                               |
  | [CT.OPENSEARCH.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-1-description)                   | Require an Elasticsearch domain to encrypt data at rest                                                                                                                                  | `AWS::Elasticsearch::Domain`<br/>                                                                   |
  | [CT.OPENSEARCH.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-2-description)                   | Require an Elasticsearch domain to be created in a user-specified Amazon VPC                                                                                                             | `AWS::Elasticsearch::Domain`<br/>                                                                   |
  | [CT.OPENSEARCH.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-3-description)                   | Require an Elasticsearch domain to encrypt data sent between nodes                                                                                                                       | `AWS::Elasticsearch::Domain`<br/>                                                                   |
  | [CT.OPENSEARCH.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-4-description)                   | Require an Elasticsearch domain to send error logs to Amazon CloudWatch Logs                                                                                                             | `AWS::Elasticsearch::Domain`<br/>                                                                   |
  | [CT.OPENSEARCH.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-5-description)                   | Require an Elasticsearch domain to send audit logs to Amazon CloudWatch Logs                                                                                                             | `AWS::Elasticsearch::Domain`<br/>                                                                   |
  | [CT.OPENSEARCH.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-6-description)                   | Require an Elasticsearch domain to have zone awareness and at least three data nodes                                                                                                     | `AWS::Elasticsearch::Domain`<br/>                                                                   |
  | [CT.OPENSEARCH.PR.7](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-7-description)                   | Require an Elasticsearch domain to have at least three dedicated master nodes                                                                                                            | `AWS::Elasticsearch::Domain`<br/>                                                                   |
  | [CT.OPENSEARCH.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-8-description)                   | Require an Elasticsearch Service domain to use TLSv1.2                                                                                                                                   | `AWS::Elasticsearch::Domain`<br/>                                                                   |
  | [CT.OPENSEARCH.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-9-description)                   | Require an Amazon OpenSearch Service domain to encrypt data at rest                                                                                                                      | `AWS::OpenSearchService::Domain`<br/>                                                               |
  | [CT.OPENSEARCH.PR.10](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-10-description)                 | Require an Amazon OpenSearch Service domain to be created in a user-specified Amazon VPC                                                                                                 | `AWS::OpenSearchService::Domain`<br/>                                                               |
  | [CT.OPENSEARCH.PR.11](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-11-description)                 | Require an Amazon OpenSearch Service domain to encrypt data sent between nodes                                                                                                           | `AWS::OpenSearchService::Domain`<br/>                                                               |
  | [CT.OPENSEARCH.PR.12](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-12-description)                 | Require an Amazon OpenSearch Service domain to send error logs to Amazon CloudWatch Logs                                                                                                 | `AWS::OpenSearchService::Domain`<br/>                                                               |
  | [CT.OPENSEARCH.PR.13](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-13-description)                 | Require an Amazon OpenSearch Service domain to send audit logs to Amazon CloudWatch Logs                                                                                                 | `AWS::OpenSearchService::Domain`<br/>                                                               |
  | [CT.OPENSEARCH.PR.14](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-14-description)                 | Require an Amazon OpenSearch Service domain to have zone awareness and at least three data nodes                                                                                         | `AWS::OpenSearchService::Domain`<br/>                                                               |
  | [CT.OPENSEARCH.PR.15](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-15-description)                 | Require an Amazon OpenSearch Service domain to use fine-grained access control                                                                                                           | `AWS::OpenSearchService::Domain`<br/>                                                               |
  | [CT.OPENSEARCH.PR.16](https://docs.aws.amazon.com/controltower/latest/userguide/opensearch-rules.html#ct-opensearch-pr-16-description)                 | Require an Amazon OpenSearch Service domain to use TLSv1.2                                                                                                                               | `AWS::OpenSearchService::Domain`<br/>                                                               |
  | [CT.RDS.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-1-description)                                        | Require that an Amazon RDS database instance is configured with multiple Availability Zones                                                                                              | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-2-description)                                        | Require an Amazon RDS database instance or cluster to have enhanced monitoring configured                                                                                                | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-3-description)                                        | Require an Amazon RDS cluster to have deletion protection configured                                                                                                                     | `AWS::RDS::DBCluster`<br/>                                                                          |
  | [CT.RDS.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-4-description)                                        | Require an Amazon RDS database cluster to have AWS IAM database authentication configured                                                                                                | `AWS::RDS::DBCluster`<br/>                                                                          |
  | [CT.RDS.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-5-description)                                        | Require an Amazon RDS database instance to have minor version upgrades configured                                                                                                        | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-6-description)                                        | Require an Amazon RDS database cluster to have backtracking configured                                                                                                                   | `AWS::RDS::DBCluster`<br/>                                                                          |
  | [CT.RDS.PR.7](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-7-description)                                        | Require Amazon RDS database instances to have AWS IAM authentication configured                                                                                                          | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-8-description)                                        | Require an Amazon RDS database instance to have automatic backups configured                                                                                                             | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-9-description)                                        | Require an Amazon RDS database cluster to copy tags to snapshots                                                                                                                         | `AWS::RDS::DBCluster`<br/>                                                                          |
  | [CT.RDS.PR.10](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-10-description)                                      | Require an Amazon RDS database instance to copy tags to snapshots                                                                                                                        | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.11](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-11-description)                                      | Require an Amazon RDS database instance to have a VPC configuration                                                                                                                      | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.12](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-12-description)                                      | Require an Amazon RDS event subscription to have critical cluster events configured                                                                                                      | `AWS::RDS::EventSubscription`<br/>                                                                  |
  | [CT.RDS.PR.13](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-13-description)                                      | Require any Amazon RDS instance to have deletion protection configured                                                                                                                   | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.14](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-14-description)                                      | Require an Amazon RDS database instance to export logs to Amazon CloudWatch Logs by means of the EnableCloudwatchLogsExports property                                                    | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.15](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-15-description)                                      | Require that an Amazon RDS instance does not create DB security groups                                                                                                                   | `AWS::RDS::DBInstance`<br/>`AWS::RDS::DBSecurityGroup`<br/>                                         |
  | [CT.RDS.PR.16](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-16-description)                                      | Require an Amazon RDS database cluster to have encryption at rest configured                                                                                                             | `AWS::RDS::DBCluster`<br/>                                                                          |
  | [CT.RDS.PR.17](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-17-description)                                      | Require an Amazon RDS event notification subscription to have critical database instance events configured                                                                               | `AWS::RDS::EventSubscription`<br/>                                                                  |
  | [CT.RDS.PR.18](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-18-description)                                      | Require an Amazon RDS event notification subscription to have critical database parameter group events configured                                                                        | `AWS::RDS::EventSubscription`<br/>                                                                  |
  | [CT.RDS.PR.19](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-19-description)                                      | Require an Amazon RDS event notifications subscription to have critical database security group events configured                                                                        | `AWS::RDS::EventSubscription`<br/>                                                                  |
  | [CT.RDS.PR.20](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-20-description)                                      | Require an Amazon RDS database instance not to use a database engine default port                                                                                                        | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.21](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-21-description)                                      | Require an Amazon RDS DB cluster to have a unique administrator username                                                                                                                 | `AWS::RDS::DBCluster`<br/>                                                                          |
  | [CT.RDS.PR.22](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-22-description)                                      | Require an Amazon RDS database instance to have a unique administrator username                                                                                                          | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.23](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-23-description)                                      | Require an Amazon RDS database instance to not be publicly accessible                                                                                                                    | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.24](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-24-description)                                      | Require an Amazon RDS database instance to have encryption at rest configured                                                                                                            | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.RDS.PR.25](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-25-description)                                      | Require an Amazon RDS database cluster to export logs to Amazon CloudWatch Logs by means of the EnableCloudwatchLogsExports property                                                     | `AWS::RDS::DBCluster`<br/>                                                                          |
  | [CT.RDS.PR.26](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-26-description)                                      | Require an Amazon RDS DB Proxy to require Transport Layer Security (TLS) connections                                                                                                     | `AWS::RDS::DBProxy`<br/>                                                                            |
  | [CT.RDS.PR.27](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-27-description)                                      | Require an Amazon RDS DB cluster parameter group to require Transport Layer Security (TLS) connections for supported engine types                                                        | `AWS::RDS::DBClusterParameterGroup`<br/>                                                            |
  | [CT.RDS.PR.28](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-28-description)                                      | Require an Amazon RDS DB parameter group to require Transport Layer Security (TLS) connections for supported engine types                                                                | `AWS::RDS::DBParameterGroup`<br/>                                                                   |
  | [CT.RDS.PR.29](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-29-description)                                      | Require an Amazon RDS cluster not be configured to be publicly accessible by means of the 'PubliclyAccessible' property                                                                  | `AWS::RDS::DBCluster`<br/>                                                                          |
  | [CT.RDS.PR.30](https://docs.aws.amazon.com/controltower/latest/userguide/rds-rules.html#ct-rds-pr-30-description)                                      | Require that an Amazon RDS database instance has encryption at rest configured to use a KMS key that you specify for supported engine types                                              | `AWS::RDS::DBInstance`<br/>                                                                         |
  | [CT.REDSHIFT.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-1-description)                         | Require an Amazon Redshift cluster to prohibit public access                                                                                                                             | `AWS::Redshift::Cluster`<br/>                                                                       |
  | [CT.REDSHIFT.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-2-description)                         | Require an Amazon Redshift cluster to have automatic snapshots configured                                                                                                                | `AWS::Redshift::Cluster`<br/>                                                                       |
  | [CT.REDSHIFT.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-3-description)                         | Require an Amazon Redshift cluster to have audit logging configured                                                                                                                      | `AWS::Redshift::Cluster`<br/>                                                                       |
  | [CT.REDSHIFT.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-4-description)                         | Require an Amazon Redshift cluster to have automatic upgrades to major versions configured                                                                                               | `AWS::Redshift::Cluster`<br/>                                                                       |
  | [CT.REDSHIFT.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-5-description)                         | Require an Amazon Redshift cluster to have enhanced VPC routing                                                                                                                          | `AWS::Redshift::Cluster`<br/>                                                                       |
  | [CT.REDSHIFT.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-6-description)                         | Require an Amazon Redshift cluster to have a unique administrator username                                                                                                               | `AWS::Redshift::Cluster`<br/>                                                                       |
  | [CT.REDSHIFT.PR.7](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-7-description)                         | Require an Amazon Redshift cluster to have a unique database name                                                                                                                        | `AWS::Redshift::Cluster`<br/>                                                                       |
  | [CT.REDSHIFT.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-8-description)                         | Require an Amazon Redshift cluster to be encrypted                                                                                                                                       | `AWS::Redshift::Cluster`<br/>                                                                       |
  | [CT.REDSHIFT.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/redshift-rules.html#ct-redshift-pr-9-description)                         | Require that an Amazon Redshift cluster parameter group is configured to use Secure Sockets Layer (SSL) for encryption of data in transit                                                | `AWS::Redshift::ClusterParameterGroup`<br/>                                                         |
  | [CT.S3.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-1-description)                                           | Require an Amazon S3 bucket to have block public access settings configured                                                                                                              | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-2-description)                                           | Require an Amazon S3 bucket to have server access logging configured                                                                                                                     | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-3-description)                                           | Require an Amazon S3 buckets to have versioning configured and a lifecycle policy                                                                                                        | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.4](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-4-description)                                           | Require an Amazon S3 bucket to have event notifications configured                                                                                                                       | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.5](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-5-description)                                           | Require that an Amazon S3 bucket does not manage user access with an access control list (ACL)                                                                                           | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.6](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-6-description)                                           | Require an Amazon S3 bucket to have lifecycle policies configured                                                                                                                        | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.8](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-8-description)                                           | Require that Amazon S3 bucket requests use Secure Sockets Layer                                                                                                                          | `AWS::S3::BucketPolicy`<br/>                                                                        |
  | [CT.S3.PR.9](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-9-description)                                           | Require that an Amazon S3 bucket has S3 Object Lock activated                                                                                                                            | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.10](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-10-description)                                         | Require an Amazon S3 bucket to have server-side encryption configured using an AWS KMS key                                                                                               | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.11](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-11-description)                                         | Require an Amazon S3 bucket to have versioning enabled                                                                                                                                   | `AWS::S3::Bucket`<br/>                                                                              |
  | [CT.S3.PR.12](https://docs.aws.amazon.com/controltower/latest/userguide/s3-rules.html#ct-s3-pr-12-description)                                         | Require an Amazon S3 access point to have a Block Public Access (BPA) configuration with all options set to true                                                                         | `AWS::S3::AccessPoint`<br/>                                                                         |
  | [CT.SAGEMAKER.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/sagemaker-rules.html#ct-sagemaker-pr-1-description)                      | Require an Amazon SageMaker notebook instance to prevent direct internet access                                                                                                          | `AWS::SageMaker::NotebookInstance`<br/>                                                             |
  | [CT.SAGEMAKER.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/sagemaker-rules.html#ct-sagemaker-pr-2-description)                      | Require Amazon SageMaker notebook instances to be deployed within a custom Amazon VPC                                                                                                    | `AWS::SageMaker::NotebookInstance`<br/>                                                             |
  | [CT.SAGEMAKER.PR.3](https://docs.aws.amazon.com/controltower/latest/userguide/sagemaker-rules.html#ct-sagemaker-pr-3-description)                      | Require Amazon SageMaker notebook instances to have root access disallowed                                                                                                               | `AWS::SageMaker::NotebookInstance`<br/>                                                             |
  | [CT.SQS.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/sqs-rules.html#ct-sqs-pr-1-description)                                        | Require any Amazon SQS queue to have a dead-letter queue configured                                                                                                                      | `AWS::SQS::Queue`<br/>                                                                              |
  | [CT.SQS.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/sqs-rules.html#ct-sqs-pr-2-description)                                        | Require any Amazon SQS queue to have encryption at rest configured                                                                                                                       | `AWS::SQS::Queue`<br/>                                                                              |
  | [CT.STEPFUNCTIONS.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/stepfunctions-rules.html#ct-stepfunctions-pr-1-description)          | Require an AWS Step Functions state machine to have logging activated                                                                                                                    | `AWS::StepFunctions::StateMachine`<br/>                                                             |
  | [CT.STEPFUNCTIONS.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/stepfunctions-rules.html#ct-stepfunctions-pr-2-description)          | Require an AWS Step Functions state machine to have AWS X-Ray tracing activated                                                                                                          | `AWS::StepFunctions::StateMachine`<br/>                                                             |
  | [CT.WAF-REGIONAL.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/waf-regional-rules.html#ct-waf-regional-pr-1-description)             | Require any AWS WAF Classic regional rule to have a condition                                                                                                                            | `AWS::WAFRegional::Rule`<br/>                                                                       |
  | [CT.WAF-REGIONAL.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/waf-regional-rules.html#ct-waf-regional-pr-2-description)             | Require any AWS WAF Classic regional web access control list (ACL) to have a rule or rule group                                                                                          | `AWS::WAFRegional::WebACL`<br/>                                                                     |
  | [CT.WAF.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/waf-rules.html#ct-waf-pr-1-description)                                        | Require any AWS WAF Classic global rule to have a condition                                                                                                                              | `AWS::WAF::Rule`<br/>                                                                               |
  | [CT.WAF.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/waf-rules.html#ct-waf-pr-2-description)                                        | Require any AWS WAF Classic global web ACL to have a rule or rule group                                                                                                                  | `AWS::WAF::WebACL`<br/>                                                                             |
  | [CT.WAFV2.PR.1](https://docs.aws.amazon.com/controltower/latest/userguide/wafv2-rules.html#ct-wafv2-pr-1-description)                                  | Require an AWS WAF web ACL to be non-empty                                                                                                                                               | `AWS::WAFv2::WebACL`<br/>                                                                           |
  | [CT.WAFV2.PR.2](https://docs.aws.amazon.com/controltower/latest/userguide/wafv2-rules.html#ct-wafv2-pr-2-description)                                  | Require an AWS WAF rule group to be non-empty                                                                                                                                            | `AWS::WAFv2::RuleGroup`<br/>


pkgId: 4689d769e250336eb22d757bff3106538b9513fcefee09592963f71325901927
name: python-cdklabs.cdk-verified-permissions
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: L2 AWS CDK Constructs for Amazon Verified Permissions
url: https://github.com/cdklabs/cdk-verified-permissions.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.cdk-verified-permissions-0.1.4-1.src.rpm
checksum_type: sha256
description:
  This repo contains the implementation of an L2 CDK Construct for Amazon Verified Permissions



  This construct is still versioned with alpha/v0 major version and we could introduce breaking changes even without a major version bump. Our goal is to keep the API stable & backwards compatible as much as possible but we currently cannot guarantee that. Once we'll publish v1.0.0 the breaking changes will be introduced via major version bumps.





  Define a Policy Store with defaults (No description, No schema & Validation Settings Mode set to OFF):

  ```python
  test = PolicyStore(scope, "PolicyStore")
  ```

  Define a Policy Store without Schema definition (Validation Settings Mode must be set to OFF):

  ```python
  validation_settings_off = {
      "mode": ValidationSettingsMode.OFF
  }
  test = PolicyStore(scope, "PolicyStore",
      validation_settings=validation_settings_off
  )
  ```

  Define a Policy Store with Description and Schema definition (a STRICT Validation Settings Mode is strongly suggested for Policy Stores with schemas):

  ```python
  validation_settings_strict = {
      "mode": ValidationSettingsMode.STRICT
  }
  cedar_json_schema = {
      "PhotoApp": {
          "entity_types": {
              "User": {},
              "Photo": {}
          },
          "actions": {
              "view_photo": {
                  "applies_to": {
                      "principal_types": ["User"],
                      "resource_types": ["Photo"]
                  }
              }
          }
      }
  }
  cedar_schema = {
      "cedar_json": JSON.stringify(cedar_json_schema)
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      schema=cedar_schema,
      validation_settings=validation_settings_strict,
      description="PolicyStore description"
  )
  ```



  If you want to have type safety when defining a schema, you can accomplish this **<ins>only</ins>** in typescript. Simply use the `Schema` type exported by the `@cedar-policy/cedar-wasm`.

  You can also generate simple schemas using the static functions `schemaFromOpenApiSpec` or `schemaFromRestApi` in the PolicyStore construct. This functionality replicates what you can find in the AWS Verified Permissions console.

  Generate a schema from an OpenAPI spec:

  ```python
  validation_settings_strict = {
      "mode": ValidationSettingsMode.STRICT
  }
  cedar_json_schema = PolicyStore.schema_from_open_api_spec("path/to/swaggerfile.json", "UserGroup")
  cedar_schema = {
      "cedar_json": JSON.stringify(cedar_json_schema)
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      schema=cedar_schema,
      validation_settings=validation_settings_strict,
      description="Policy store with schema generated from API Gateway"
  )
  ```

  Generate a schema from a RestApi construct:

  ```python
  validation_settings_strict = {
      "mode": ValidationSettingsMode.STRICT
  }
  cedar_json_schema = PolicyStore.schema_from_rest_api(
      RestApi(scope, "RestApi"), "UserGroup")
  cedar_schema = {
      "cedar_json": JSON.stringify(cedar_json_schema)
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      schema=cedar_schema,
      validation_settings=validation_settings_strict,
      description="Policy store with schema generated from RestApi construct"
  )
  ```



  Define Identity Source with Cognito Configuration and required properties:

  ```python
  user_pool = UserPool(scope, "UserPool") # Creating a new Cognito UserPool
  validation_settings_strict = {
      "mode": ValidationSettingsMode.STRICT
  }
  cedar_json_schema = {
      "PhotoApp": {
          "entity_types": {
              "User": {},
              "Photo": {}
          },
          "actions": {
              "view_photo": {
                  "applies_to": {
                      "principal_types": ["User"],
                      "resource_types": ["Photo"]
                  }
              }
          }
      }
  }
  cedar_schema = {
      "cedar_json": JSON.stringify(cedar_json_schema)
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      schema=cedar_schema,
      validation_settings=validation_settings_strict
  )
  IdentitySource(scope, "IdentitySource",
      configuration=IdentitySourceConfiguration(
          cognito_user_pool_configuration=CognitoUserPoolConfiguration(
              user_pool=user_pool
          )
      ),
      policy_store=policy_store
  )
  ```

  Define Identity Source with Cognito Configuration and all properties:

  ```python
  validation_settings_strict = {
      "mode": ValidationSettingsMode.STRICT
  }
  cedar_json_schema = {
      "PhotoApp": {
          "entity_types": {
              "User": {},
              "Photo": {}
          },
          "actions": {
              "view_photo": {
                  "applies_to": {
                      "principal_types": ["User"],
                      "resource_types": ["Photo"]
                  }
              }
          }
      }
  }
  cedar_schema = {
      "cedar_json": JSON.stringify(cedar_json_schema)
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      schema=cedar_schema,
      validation_settings=validation_settings_strict
  )
  cognito_group_entity_type = "test"
  user_pool = UserPool(scope, "UserPool") # Creating a new Cognito UserPool
  IdentitySource(scope, "IdentitySource",
      configuration=IdentitySourceConfiguration(
          cognito_user_pool_configuration=CognitoUserPoolConfiguration(
              client_ids=["&ExampleCogClientId;"],
              user_pool=user_pool,
              group_configuration=CognitoGroupConfiguration(
                  group_entity_type=cognito_group_entity_type
              )
          )
      ),
      policy_store=policy_store,
      principal_entity_type="PETEXAMPLEabcdefg111111"
  )
  ```

  Define Identity Source with OIDC Configuration and Access Token selection config:

  ```python
  validation_settings_strict = {
      "mode": ValidationSettingsMode.STRICT
  }
  cedar_json_schema = {
      "PhotoApp": {
          "entity_types": {
              "User": {},
              "Photo": {}
          },
          "actions": {
              "view_photo": {
                  "applies_to": {
                      "principal_types": ["User"],
                      "resource_types": ["Photo"]
                  }
              }
          }
      }
  }
  cedar_schema = {
      "cedar_json": JSON.stringify(cedar_json_schema)
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      schema=cedar_schema,
      validation_settings=validation_settings_strict
  )
  issuer = "https://iamanidp.com"
  principal_id_claim = "sub"
  entity_id_prefix = "prefix"
  group_claim = "group"
  group_entity_type = "GroupType"
  IdentitySource(scope, "IdentitySource",
      configuration=IdentitySourceConfiguration(
          open_id_connect_configuration=OpenIdConnectConfiguration(
              issuer=issuer,
              entity_id_prefix=entity_id_prefix,
              group_configuration=OpenIdConnectGroupConfiguration(
                  group_claim=group_claim,
                  group_entity_type=group_entity_type
              ),
              access_token_only=OpenIdConnectAccessTokenConfiguration(
                  audiences=["testAudience"],
                  principal_id_claim=principal_id_claim
              )
          )
      ),
      policy_store=policy_store,
      principal_entity_type="TestType"
  )
  ```

  Define Identity Source with OIDC Configuration and Identity Token selection config:

  ```python
  validation_settings_strict = {
      "mode": ValidationSettingsMode.STRICT
  }
  cedar_json_schema = {
      "PhotoApp": {
          "entity_types": {
              "User": {},
              "Photo": {}
          },
          "actions": {
              "view_photo": {
                  "applies_to": {
                      "principal_types": ["User"],
                      "resource_types": ["Photo"]
                  }
              }
          }
      }
  }
  cedar_schema = {
      "cedar_json": JSON.stringify(cedar_json_schema)
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      schema=cedar_schema,
      validation_settings=validation_settings_strict
  )
  issuer = "https://iamanidp.com"
  entity_id_prefix = "prefix"
  group_claim = "group"
  group_entity_type = "UserGroup"
  principal_id_claim = "sub"
  IdentitySource(scope, "IdentitySource",
      configuration=IdentitySourceConfiguration(
          open_id_connect_configuration=OpenIdConnectConfiguration(
              issuer=issuer,
              entity_id_prefix=entity_id_prefix,
              group_configuration=OpenIdConnectGroupConfiguration(
                  group_claim=group_claim,
                  group_entity_type=group_entity_type
              ),
              identity_token_only=OpenIdConnectIdentityTokenConfiguration(
                  client_ids=[],
                  principal_id_claim=principal_id_claim
              )
          )
      ),
      policy_store=policy_store
  )
  ```



  Load all the `.cedar` files in a given folder and define Policy objects for each of them. All policies will be associated with the same policy store.

  ```python
  validation_settings_strict = {
      "mode": ValidationSettingsMode.STRICT
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      validation_settings=validation_settings_strict
  )
  policy_store.add_policies_from_path("/path/to/my-policies")
  ```

  Define a Policy and add it to a specific Policy Store:

  ```python
  statement = """permit(
      principal,
      action in [MyFirstApp::Action::"Read"],
      resource
  ) when {
      true
  };"""

  description = "Test policy assigned to the test store"
  validation_settings_off = {
      "mode": ValidationSettingsMode.OFF
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      validation_settings=validation_settings_off
  )


  policy = Policy(scope, "MyTestPolicy",
      definition=PolicyDefinitionProperty(
          static=StaticPolicyDefinitionProperty(
              statement=statement,
              description=description
          )
      ),
      policy_store=policy_store
  )
  ```

  Define a policy with a template linked definition:

  ```python
  validation_settings_off = {
      "mode": ValidationSettingsMode.OFF
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      validation_settings=validation_settings_off
  )
  policy_template_statement = """
  permit (
    principal == ?principal,
    action in [TinyTodo::Action::"ReadList", TinyTodo::Action::"ListTasks"],
    resource == ?resource
  );"""
  template = PolicyTemplate(scope, "PolicyTemplate",
      statement=policy_template_statement,
      policy_store=policy_store
  )

  policy = Policy(scope, "MyTestPolicy",
      definition=PolicyDefinitionProperty(
          template_linked=TemplateLinkedPolicyDefinitionProperty(
              policy_template=template,
              principal=EntityIdentifierProperty(
                  entity_id="exampleId",
                  entity_type="exampleType"
              ),
              resource=EntityIdentifierProperty(
                  entity_id="exampleId",
                  entity_type="exampleType"
              )
          )
      ),
      policy_store=policy_store
  )
  ```

  Define a Policy with a statement from file:
  **PLEASE NOTE:** You can specify the description of the policy directly inside the Policy file, using the annotation `@cdkDescription`

  ```python
  description = "Test policy assigned to the test store"
  validation_settings_off = {
      "mode": ValidationSettingsMode.OFF
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      validation_settings=validation_settings_off
  )


  policy_from_file_props = {
      "policy_store": policy_store,
      "path": "/path/to/policy-statement.cedar",
      "description": "the policy description"
  }
  policy = Policy.from_file(scope, "MyTestPolicy", policy_from_file_props)
  ```



  Define a Policy Template referring to a Cedar Statement in local file:

  ```python
  validation_settings_off = {
      "mode": ValidationSettingsMode.OFF
  }
  policy_store = PolicyStore(scope, "PolicyStore",
      validation_settings=validation_settings_off
  )
  template_from_file_props = {
      "policy_store": policy_store,
      "path": "/path/to/template-statement.cedar",
      "description": "Allows sharing photos in full access mode"
  }
  template = PolicyTemplate.from_file(scope, "PolicyTemplate", template_from_file_props)
  ```



  * This project is following the AWS CDK Official Design Guidelines (see https://github.com/aws/aws-cdk/blob/main/docs/DESIGN_GUIDELINES.md) and the AWS CDK New Constructs Creation Guide (see here https://github.com/aws/aws-cdk/blob/main/docs/NEW_CONSTRUCTS_GUIDE.md).
  * Feedback is a gift: if you find something wrong or you've ideas to improve please open an issue or a pull request


pkgId: 302c0303170449f3e2a005625e8c152c366795253ac049776dc5e4f57082c259
name: python-cdklabs.codepipeline-extensions
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: This project is for use in the workshop DOP 402: Get better at building AWS CDK constructs
url: https://github.com/cdklabs/cdk-codepipeline-extensions.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.codepipeline-extensions-0.1.0-1.src.rpm
checksum_type: sha256
description:
  This project is for use in the workshop DOP 402: Get better at building AWS CDK constructs.



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: 6555babfc1f8910c2d25ef351874eb33b3ac32186e7ff19a9a91a97a3a021633
name: python-cdklabs.ecs-codedeploy
arch: src
version: 0.0.336
epoch: 0
release: 1
summary: CDK Constructs for performing ECS Deployments with CodeDeploy
url: https://github.com/cdklabs/cdk-ecs-codedeploy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.ecs-codedeploy-0.0.336-1.src.rpm
checksum_type: sha256
description:
  [![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg)](https://constructs.dev/packages/@cdklabs/cdk-ecs-codedeploy)
  [![npm version](https://badge.fury.io/js/@cdklabs%2Fcdk-ecs-codedeploy.svg)](https://badge.fury.io/js/@cdklabs%2Fcdk-ecs-codedeploy)
  [![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.github.cdklabs/cdk-ecs-codedeploy/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.github.cdklabs/cdk-ecs-codedeploy)
  [![PyPI version](https://badge.fury.io/py/cdklabs.ecs-codedeploy.svg)](https://badge.fury.io/py/cdklabs.ecs-codedeploy)
  [![NuGet version](https://badge.fury.io/nu/Cdklabs.CdkEcsCodeDeploy.svg)](https://badge.fury.io/nu/Cdklabs.CdkEcsCodeDeploy)
  [![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/cdklabs/cdk-ecs-codedeploy)
  [![Mergify](https://img.shields.io/endpoint.svg?url=https://api.mergify.com/badges/cdklabs/cdk-ecs-codedeploy&style=flat)](https://mergify.io)

  This project contains CDK constructs to create CodeDeploy ECS deployments.



  <details><summary><strong>TypeScript</strong></summary>

  ```bash
  yarn add @cdklabs/cdk-ecs-codedeploy
  ```

  </details><details><summary><strong>Java</strong></summary>

  See https://mvnrepository.com/artifact/io.github.cdklabs/cdk-ecs-codedeploy

  </details><details><summary><strong>Python</strong></summary>

  See https://pypi.org/project/cdklabs.ecs-codedeploy/

  </details><details><summary><strong>C#</strong></summary>

  See https://www.nuget.org/packages/Cdklabs.CdkEcsCodeDeploy/

  </details>



  CodeDeploy for ECS can manage the deployment of new task definitions to ECS services.  Only 1 deployment construct can be defined for a given EcsDeploymentGroup.

  ```python




  EcsDeployment(
      deployment_group=deployment_group,
      target_service=TargetService(
          task_definition=task_definition,
          container_name="mycontainer",
          container_port=80
      )
  )
  ```

  The deployment will use the AutoRollbackConfig for the EcsDeploymentGroup unless it is overridden in the deployment:

  ```python




  EcsDeployment(
      deployment_group=deployment_group,
      target_service=TargetService(
          task_definition=task_definition,
          container_name="mycontainer",
          container_port=80
      ),
      auto_rollback=codeDeploy.AutoRollbackConfig(
          failed_deployment=True,
          deployment_in_alarm=True,
          stopped_deployment=False
      )
  )
  ```

  By default, the deployment will timeout after 30 minutes. The timeout value can be overridden:

  ```python




  EcsDeployment(
      deployment_group=deployment_group,
      target_service=TargetService(
          task_definition=task_definition,
          container_name="mycontainer",
          container_port=80
      ),
      timeout=Duration.minutes(60)
  )
  ```



  CodeDeploy can leverage Cloudwatch Alarms to trigger automatic rollbacks. The `ApiCanary` construct simplifies the process for creating CloudWatch Synthetics Canaries to monitor APIs. The following code demonstrates a canary that monitors https://xkcd.com/908/info.0.json and checks the JSON response to assert that `safe_title` has the value of `'The Cloud'`.

  ```python
  canary = ApiCanary(stack, "Canary",
      base_url="https://xkcd.com",
      duration_alarm_threshold=Duration.seconds(5),
      thread_count=5,
      steps=[ApiTestStep(
          name="info",
          path="/908/info.0.json",
          jmes_path="safe_title",
          expected_value="The Cloud"
      )
      ]
  )
  ```



  An L3 construct named `ApplicationLoadBalancedCodeDeployedFargateService` extends [ApplicationLoadBalancedFargateService](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs_patterns.ApplicationLoadBalancedFargateService.html) and adds support for deploying new versions of the service with AWS CodeDeploy. Additionally, an Amazon CloudWatch Synthetic canary is created via the `ApiCanary` construct and is monitored by the CodeDeploy deployment to trigger rollback if the canary begins to alarm.

  ```python



  service = ApplicationLoadBalancedCodeDeployedFargateService(stack, "Service",
      cluster=cluster,
      task_image_options=ApplicationLoadBalancedTaskImageOptions(
          image=image
      ),
      api_test_steps=[ApiTestStep(
          name="health",
          path="/health",
          jmes_path="status",
          expected_value="ok"
      )]
  )
  ```



  ```bash
  yarn install
  yarn build
  yarn test
  ```

  To run an integration test and update the snapshot, run:

  ```bash
  yarn integ:ecs-deployment:deploy
  ```

  To recreate snapshots for integration tests, run:

  ```bash
  yarn integ:snapshot-all
  ```



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: 96e8b611b789e2af329cccf810b0f415cdb4d15436b2da99614ce026022d51ae
name: python-cdklabs.generative-ai-cdk-constructs
arch: src
version: 0.1.274
epoch: 0
release: 1
summary: AWS Generative AI CDK Constructs is a library for well-architected generative AI patterns.
url: https://github.com/awslabs/generative-ai-cdk-constructs
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.generative-ai-cdk-constructs-0.1.274-1.src.rpm
checksum_type: sha256
description:
  [![View on Construct Hub](https://constructs.dev/badge?package=generative-ai-cdk-constructs)](https://constructs.dev/packages/@cdklabs/generative-ai-cdk-constructs)
  [![PyPI version](https://img.shields.io/pypi/v/cdklabs.generative-ai-cdk-constructs)](https://pypi.org/project/cdklabs.generative-ai-cdk-constructs/)
  [![npm version](https://img.shields.io/npm/v/@cdklabs/generative-ai-cdk-constructs)](https://www.npmjs.com/package/@cdklabs/generative-ai-cdk-constructs)
  [![NuGet Version](https://img.shields.io/nuget/v/Cdklabs.GenerativeAiCdkConstructs)](https://nuget.info/packages/Cdklabs.GenerativeAiCdkConstructs)
  [![Maven Central Version](https://img.shields.io/maven-central/v/io.github.cdklabs/generative-ai-cdk-constructs)](https://central.sonatype.com/artifact/io.github.cdklabs/generative-ai-cdk-constructs)
  [![Go Version](https://img.shields.io/github/v/tag/awslabs/generative-ai-cdk-constructs?label=go&color=orange)](https://pkg.go.dev/github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs)

  * [Introduction](#introduction)
  * [CDK Versions](#cdk-versions)
  * [Contributing](#contributing)
  * [Design guidelines and Development guide](#design-guidelines-and-development-guide)
  * [Getting Started](#getting-started)
  * [Catalog](#catalog)
  * [Sample Use Cases](#sample-use-cases)
  * [Additional Resources](#additional-resources)
  * [Contributors](#contributors)
  * [Operational Metrics Collection](#operational-metrics-collection)
  * [Roadmap](#roadmap)
  * [License](#license)
  * [Legal Disclaimer](#legal-disclaimer)

  The AWS Generative AI Constructs Library is an open-source extension of the [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html) that provides multi-service, well-architected patterns for quickly defining solutions in code to create predictable and repeatable infrastructure, called [constructs](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html). The goal of AWS Generative AI CDK Constructs is to help developers build generative AI solutions using pattern-based definitions for their architecture.
  The patterns defined in AWS Generative AI CDK Constructs are high level, multi-service abstractions of AWS CDK constructs that have default configurations based on well-architected best practices. The library is organized into logical modules using object-oriented techniques to create each architectural pattern model.

  AWS Generative AI CDK Constructs and the AWS CDK are independent teams and have different release schedules. Each release of AWS Generative AI CDK Constructs is built against a specific version of the AWS CDK. The [CHANGELOG.md](./CHANGELOG.md) file lists the CDK version associated with each AWS Generative AI Constructs release. For instance, AWS Generative AI CDK Constructs v0.0.0 was built against AWS CDK v2.96.2. This means that to use AWS Generative AI CDK Constructs v0.0.0, your application must include AWS CDK v2.96.2 or later. You can continue to use the latest AWS CDK versions and upgrade the your AWS Generative AI CDK Constructs version when new releases become available.

  Contributions of all kinds are welcome! Check out our [contributor guide](./CONTRIBUTING.md)

  If you want to add a new construct to the library, check out our [design guidelines](./DESIGN_GUIDELINES.md), then follow the [development guide](./DEVELOPER_GUIDE.md)

  <details>
  <summary><i>TypeScript</i></summary>
  * Create or use an existing CDK application in TypeScript.
    * `cdk init app --language typescript`
  * Run `npm install @cdklabs/generative-ai-cdk-constructs`
  * The package should be added to your package.json.
  * Import the library:
    * `import * as genai from '@cdklabs/generative-ai-cdk-constructs';`
  </details><details>
  <summary><i>Python</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language python`
  * Install the package:
    * `pip install cdklabs.generative-ai-cdk-constructs`
  * Import the library:
    * `import cdklabs.generative_ai_cdk_constructs`
  </details><details>
  <summary><i>NuGet</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language csharp`
  * Install the package while in the Visual Studio project:
    * `dotnet add package CdkLabs.GenerativeAICdkConstructs`
  * Use the namespace:
    * `using Cdklabs.GenerativeAiCdkConstructs;`
  </details><details>
  <summary><i>Go</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language go`
  * Get the module:
    * `go get github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs`
  * Import the library:
    * `import "github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs"`
  *NOTE: The [Go distribution repository](https://github.com/cdklabs/generative-ai-cdk-constructs-go), distributes the JSII tar gzipped versioned source from the [source repository](https://github.awslabs/generative-ai-cdk-constructs)*
  </details><details>
  <summary><i>Java</i></summary>
  * Create or use an existing CDK application in Java
    * cdk init app --language java
  * Add the dependency into the `pom.xml`
  ```
  <dependency>
      <groupId>io.github.cdklabs</groupId>
      <artifactId>generative-ai-cdk-constructs</artifactId>
      <version>Get the latest version and insert it here</version>
  </dependency>
  ```
  </details>
  Refer to the documentation for additional guidance on a particular construct: [Catalog](#catalog)

  The following constructs are available in the library:

  | **Construct** |Description| AWS Services used |
  |:-------------|:-------------|:-------------|
  | [Data ingestion pipeline - OpenSearch](./src/patterns/gen-ai/aws-rag-appsync-stepfn-opensearch/README.md) | Ingestion pipeline providing a RAG (retrieval augmented generation) source for storing documents in a knowledge base. | Amazon OpenSearch, AWS Step Functions, Amazon Bedrock, AWS AppSync, AWS Lambda |
  | [Data ingestion pipeline - Kendra](./src/patterns/gen-ai/aws-rag-appsync-stepfn-kendra/README.md) | Ingestion pipeline providing a RAG (retrieval augmented generation) source for storing documents in a knowledge base. | Amazon Kendra, AWS Step Functions, AWS AppSync, AWS Lambda |
  | [Question answering](./src/patterns/gen-ai/aws-qa-appsync-opensearch/README.md) | Utilizing Large Language Models (Anthropic Claude V2.1.) for Question Answering on PDF documents with  RAG (retrieval augmented generation) source and/or long context. Additionally, leveraging Anthropic Claude 3 for visual question answering on images.| Amazon OpenSearch, AWS Lambda, Amazon Bedrock, AWS AppSync |
  | [Summarization](./src/patterns/gen-ai/aws-summarization-appsync-stepfn/README.md) | Document summarization with a large language model (Anthropic Claude V2.1). | AWS Lambda, Amazon Bedrock, AWS AppSync and Amazon ElastiCache for Redis.  |
  | [SageMaker model deployment (JumpStart)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_jumpstart.md) | Deploy a foundation model from Amazon SageMaker JumpStart to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [SageMaker model deployment (Hugging Face)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_hugging_face.md) | Deploy a foundation model from Hugging Face to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [SageMaker model deployment (Custom)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_custom_sagemaker_endpoint.md) | Deploy a foundation model from an S3 location to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [Content Generation](./src/patterns/gen-ai/aws-contentgen-appsync-lambda/README.md) | Generate images from text using Amazon titan-image-generator-v1 or stability.stable-diffusion-xl-v1 model.  | AWS Lambda, Amazon Bedrock, AWS AppSync |
  | [Web crawler](./src/patterns/gen-ai/aws-web-crawler/README.md) | Crawl websites and RSS feeds on a schedule and store changeset data in an Amazon Simple Storage Service bucket.  | AWS Lambda, AWS Batch, AWS Fargate, Amazon DynamoDB  |
  | [Amazon Bedrock Monitoring (Amazon CloudWatch Dashboard)](./src/patterns/gen-ai/aws-bedrock-cw-dashboard/README.md) | Amazon CloudWatch dashboard to monitor model usage from Amazon Bedrock. | Amazon CloudWatch |
  | [TXT to SQL](./src/patterns/gen-ai/aws-text-to-sql/README.md) |  Leverages generative AI capabilities to facilitate natural language-based SQL query generation.  | Amazon Event Bridge, Amazon Bedrock, AWS Lambda, Amazon SQS, AWS Secrets, and database of choice |
  | [LlamaIndex Data Loading](./src/patterns/gen-ai/aws-llama-index-data-loader/README.md) | Use LlamaIndex to load data in preparation for generative AI workloads | Amazon ECS Fargate, Amazon SQS, and AWS Systems Manager Parameters |

  | **Construct** |Description| AWS Services used |
  |:-------------|:-------------|:-------------|
  | [Lambda layer](./src/patterns/gen-ai/aws-langchain-common-layer/README.md) | Python Lambda layer providing dependencies and utilities to develop generative AI applications on AWS. | AWS Lambda, Amazon Bedrock, Amazon SageMaker |
  | [Amazon Bedrock](./src/cdk-lib/bedrock/README.md) | CDK L2 Constructs for Amazon Bedrock. | Amazon Bedrock, Amazon OpenSearch Serverless, AWS Lambda |
  | [Amazon OpenSearch Serverless Vector Collection](./src/cdk-lib/opensearchserverless/README.md) | CDK L2 Constructs to create a vector collection. | Amazon OpenSearch Vector Index |
  | [Amazon OpenSearch Vector Index](./src/cdk-lib/opensearch-vectorindex/README.md) | CDK L1 Custom Resource to create a vector index. | Amazon OpenSearch Serverless, AWS Lambda |

  The official samples repository https://github.com/aws-samples/generative-ai-cdk-constructs-samples includes a collection of functional use case implementations to demonstrate the usage of AWS Generative AI CDK Constructs. These can be used in the same way as architectural patterns, and can be conceptualized as an additional "higher-level" abstraction of those patterns. Those patterns (constructs) are composed together into [stacks](https://docs.aws.amazon.com/cdk/latest/guide/stacks.html), forming a "CDK app".

  | Resource | Type | Description|
  |:-------------|:-------------|:-------------|
  | [AWS re:Invent 2023 - Keynote with Dr. Werner Vogels](https://youtu.be/UTRBVPvzt9w?t=6252) | Keynote | Dr. Werner Vogels, Amazon.com's VP and CTO, announces the AWS Generative AI CDK Constructs during his AWS re:Invent 2023 keynote. |
  | [Workshop - Building Generative AI Apps on AWS with CDK](https://catalog.workshops.aws/building-genai-apps) | Workshop | In this workshop, you will explore how to build a sample generative AI app on AWS using CDK and Generative AI CDK Constructs. |
  | [Build generative AI applications with Amazon Titan Text Premier, Amazon Bedrock, and AWS CDK](https://aws.amazon.com/blogs/machine-learning/build-generative-ai-applications-with-amazon-titan-text-premier-amazon-bedrock-and-aws-cdk/) | Blog post + Code sample | Blog post exploring building and deploying two sample applications powered by Amazon Titan Text Premier using the Generative AI CDK constructs. |
  | [aws-cdk-stack-builder-tool](https://github.com/aws-samples/aws-cdk-stack-builder-tool) | Code sample | AWS CDK Builder is a browser-based tool designed to streamline bootstrapping of Infrastructure as Code (IaC) projects using the AWS Cloud Development Kit (CDK). |
  | [CDK Live! Building generative AI applications and architectures leveraging AWS CDK Constructs!](https://www.youtube.com/watch?v=NI1F4Xxqyr8) | Video | CDK Live! episode focused on building and deploying generative AI applications and architectures on AWS using the AWS Cloud Development Kit (CDK) and the AWS Generative AI CDK Constructs. |
  | [Announcing AWS Generative AI CDK Constructs!](https://aws.amazon.com/blogs/devops/announcing-generative-ai-cdk-constructs/) | Blog post | Blog post announcing the release of the AWS Generative AI CDK Constructs. |
  | [Streamline insurance underwriting with generative AI using Amazon Bedrock](https://aws.amazon.com/blogs/machine-learning/streamline-insurance-underwriting-with-generative-ai-using-amazon-bedrock-part-1/)| Blog post + Code sample | Blog post and code sample discussing how to use AWS generative artificial intelligence (AI) solutions like Amazon Bedrock to improve the underwriting process, including rule validation, underwriting guidelines adherence, and decision justification. |
  | [aws-genai-llm-chatbot](https://github.com/aws-samples/aws-genai-llm-chatbot/tree/main) | Code sample | Multi-Model and Multi-RAG Powered Chatbot Using AWS CDK on AWS allowing you to experiment with a variety of Large Language Models and Multimodal Language Models, settings and prompts in your own AWS account. |
  | [bedrock-claude-chat](https://github.com/aws-samples/bedrock-claude-chat) | Code sample | AWS-native chatbot using Bedrock + Claude (+Mistral). |
  | [amazon-bedrock-rag](https://github.com/aws-samples/amazon-bedrock-rag)| Code sample | Fully managed RAG solution using Knowledge Bases for Amazon Bedrock. |
  | [Amazon Bedrock Multimodal Search](https://github.com/aws-samples/amazon-bedrock-titan-multimodal-search) | Code sample | Multimodal product search app built using Amazon Titan Multimodal Embeddings model. |
  | [Amazon Bedrock Knowledge Bases with Private Data](https://blog.serverlessadvocate.com/amazon-bedrock-knowledge-bases-with-private-data-7685d04ef396)| Blog post + Code sample  | Blog post and associated code sample demonstrating how to integrate Knowledge Bases into Amazon Bedrock to provide foundational models with contextual data from private data sources. |
  | [Automating tasks using Amazon Bedrock Agents and AI](https://blog.serverlessadvocate.com/automating-tasks-using-amazon-bedrock-agents-and-ai-4b6fb8856589) | Blog post + Code sample | Blog post and associated code sample demonstrating how to deploy an Amazon Bedrock Agent and a Knowledge Base through a hotel and spa use case. |
  | [Agents for Amazon Bedrock - Powertools for AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/bedrock_agents/#using-aws-cloud-developer-kit-cdk) | Code sample | Create Agents for Amazon Bedrock using event handlers and auto generation of OpenAPI schemas. |
  | [Text to SQL Bedrock Agent](https://github.com/aws-samples/amazon-bedrock-samples/tree/main/agents-for-bedrock/use-case-examples/text-2-sql-agent-cdk-enhanced) | Code sample | Harnessing the power of natural language processing, the "Text to SQL Bedrock Agent" facilitates the automatic transformation of natural language questions into executable SQL queries. |

  [![contributors](https://contrib.rocks/image?repo=awslabs/generative-ai-cdk-constructs&max=2000)](https://github.com/awslabs/generative-ai-cdk-constructs/graphs/contributors)

  Generative AI CDK Constructs may collect anonymous operational metrics, including: the region a construct is deployed, the name and version of the construct deployed, and related information. We may use the metrics to maintain, provide, develop, and improve the constructs and AWS services.

  Roadmap is available through the [GitHub Project](https://github.com/orgs/awslabs/projects/136)

  Apache-2.0


pkgId: 9c5e86267697a5ac8c04fd7cd4f01f3d9f0a63904d56859a905b56f24af93ca3
name: python-cdklabs.generative-ai-cdk-constructs
arch: src
version: 0.1.281
epoch: 0
release: 1
summary: AWS Generative AI CDK Constructs is a library for well-architected generative AI patterns.
url: https://github.com/awslabs/generative-ai-cdk-constructs
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.generative-ai-cdk-constructs-0.1.281-1.src.rpm
checksum_type: sha256
description:
  [![View on Construct Hub](https://constructs.dev/badge?package=generative-ai-cdk-constructs)](https://constructs.dev/packages/@cdklabs/generative-ai-cdk-constructs)
  [![PyPI version](https://img.shields.io/pypi/v/cdklabs.generative-ai-cdk-constructs)](https://pypi.org/project/cdklabs.generative-ai-cdk-constructs/)
  [![npm version](https://img.shields.io/npm/v/@cdklabs/generative-ai-cdk-constructs)](https://www.npmjs.com/package/@cdklabs/generative-ai-cdk-constructs)
  [![NuGet Version](https://img.shields.io/nuget/v/Cdklabs.GenerativeAiCdkConstructs)](https://nuget.info/packages/Cdklabs.GenerativeAiCdkConstructs)
  [![Maven Central Version](https://img.shields.io/maven-central/v/io.github.cdklabs/generative-ai-cdk-constructs)](https://central.sonatype.com/artifact/io.github.cdklabs/generative-ai-cdk-constructs)
  [![Go Version](https://img.shields.io/github/v/tag/awslabs/generative-ai-cdk-constructs?label=go&color=orange)](https://pkg.go.dev/github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs)

  * [Introduction](#introduction)
  * [CDK Versions](#cdk-versions)
  * [Contributing](#contributing)
  * [Design guidelines and Development guide](#design-guidelines-and-development-guide)
  * [Getting Started](#getting-started)
  * [Catalog](#catalog)
  * [Sample Use Cases](#sample-use-cases)
  * [Additional Resources](#additional-resources)
  * [Contributors](#contributors)
  * [Operational Metrics Collection](#operational-metrics-collection)
  * [Roadmap](#roadmap)
  * [License](#license)
  * [Legal Disclaimer](#legal-disclaimer)

  The AWS Generative AI Constructs Library is an open-source extension of the [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html) that provides multi-service, well-architected patterns for quickly defining solutions in code to create predictable and repeatable infrastructure, called [constructs](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html). The goal of AWS Generative AI CDK Constructs is to help developers build generative AI solutions using pattern-based definitions for their architecture.
  The patterns defined in AWS Generative AI CDK Constructs are high level, multi-service abstractions of AWS CDK constructs that have default configurations based on well-architected best practices. The library is organized into logical modules using object-oriented techniques to create each architectural pattern model.

  AWS Generative AI CDK Constructs and the AWS CDK are independent teams and have different release schedules. Each release of AWS Generative AI CDK Constructs is built against a specific version of the AWS CDK. The [CHANGELOG.md](./CHANGELOG.md) file lists the CDK version associated with each AWS Generative AI Constructs release. For instance, AWS Generative AI CDK Constructs v0.0.0 was built against AWS CDK v2.96.2. This means that to use AWS Generative AI CDK Constructs v0.0.0, your application must include AWS CDK v2.96.2 or later. You can continue to use the latest AWS CDK versions and upgrade the your AWS Generative AI CDK Constructs version when new releases become available.

  Contributions of all kinds are welcome! Check out our [contributor guide](./CONTRIBUTING.md)

  If you want to add a new construct to the library, check out our [design guidelines](./DESIGN_GUIDELINES.md), then follow the [development guide](./DEVELOPER_GUIDE.md)

  <details>
  <summary><i>TypeScript</i></summary>
  * Create or use an existing CDK application in TypeScript.
    * `cdk init app --language typescript`
  * Run `npm install @cdklabs/generative-ai-cdk-constructs`
  * The package should be added to your package.json.
  * Import the library:
    * `import * as genai from '@cdklabs/generative-ai-cdk-constructs';`
  </details><details>
  <summary><i>Python</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language python`
  * Install the package:
    * `pip install cdklabs.generative-ai-cdk-constructs`
  * Import the library:
    * `import cdklabs.generative_ai_cdk_constructs`
  </details><details>
  <summary><i>NuGet</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language csharp`
  * Install the package while in the Visual Studio project:
    * `dotnet add package CdkLabs.GenerativeAICdkConstructs`
  * Use the namespace:
    * `using Cdklabs.GenerativeAiCdkConstructs;`
  </details><details>
  <summary><i>Go</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language go`
  * Get the module:
    * `go get github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs`
  * Import the library:
    * `import "github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs"`
  *NOTE: The [Go distribution repository](https://github.com/cdklabs/generative-ai-cdk-constructs-go), distributes the JSII tar gzipped versioned source from the [source repository](https://github.awslabs/generative-ai-cdk-constructs)*
  </details><details>
  <summary><i>Java</i></summary>
  * Create or use an existing CDK application in Java
    * `cdk init app --language java`
  * Add the dependency into the `pom.xml`
  ```
  <dependency>
      <groupId>io.github.cdklabs</groupId>
      <artifactId>generative-ai-cdk-constructs</artifactId>
      <version>Get the latest version and insert it here</version>
  </dependency>
  ```
  </details>
  Refer to the documentation for additional guidance on a particular construct: [Catalog](#catalog)

  The following constructs are available in the library:

  | **Construct** |Description| AWS Services used |
  |:-------------|:-------------|:-------------|
  | [Data ingestion pipeline - OpenSearch](./src/patterns/gen-ai/aws-rag-appsync-stepfn-opensearch/README.md) | Ingestion pipeline providing a RAG (retrieval augmented generation) source for storing documents in a knowledge base. | Amazon OpenSearch, AWS Step Functions, Amazon Bedrock, AWS AppSync, AWS Lambda |
  | [Data ingestion pipeline - Kendra](./src/patterns/gen-ai/aws-rag-appsync-stepfn-kendra/README.md) | Ingestion pipeline providing a RAG (retrieval augmented generation) source for storing documents in a knowledge base. | Amazon Kendra, AWS Step Functions, AWS AppSync, AWS Lambda |
  | [Question answering](./src/patterns/gen-ai/aws-qa-appsync-opensearch/README.md) | Utilizing Large Language Models (Anthropic Claude V2.1.) for Question Answering on PDF documents with  RAG (retrieval augmented generation) source and/or long context. Additionally, leveraging Anthropic Claude 3 for visual question answering on images.| Amazon OpenSearch, AWS Lambda, Amazon Bedrock, AWS AppSync |
  | [Summarization](./src/patterns/gen-ai/aws-summarization-appsync-stepfn/README.md) | Document summarization with a large language model (Anthropic Claude V2.1). | AWS Lambda, Amazon Bedrock, AWS AppSync and Amazon ElastiCache for Redis.  |
  | [SageMaker model deployment (JumpStart)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_jumpstart.md) | Deploy a foundation model from Amazon SageMaker JumpStart to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [SageMaker model deployment (Hugging Face)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_hugging_face.md) | Deploy a foundation model from Hugging Face to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [SageMaker model deployment (Custom)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_custom_sagemaker_endpoint.md) | Deploy a foundation model from an S3 location to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [Content Generation](./src/patterns/gen-ai/aws-contentgen-appsync-lambda/README.md) | Generate images from text using Amazon titan-image-generator-v1 or stability.stable-diffusion-xl-v1 model.  | AWS Lambda, Amazon Bedrock, AWS AppSync |
  | [Web crawler](./src/patterns/gen-ai/aws-web-crawler/README.md) | Crawl websites and RSS feeds on a schedule and store changeset data in an Amazon Simple Storage Service bucket.  | AWS Lambda, AWS Batch, AWS Fargate, Amazon DynamoDB  |
  | [Amazon Bedrock Monitoring (Amazon CloudWatch Dashboard)](./src/patterns/gen-ai/aws-bedrock-cw-dashboard/README.md) | Amazon CloudWatch dashboard to monitor model usage from Amazon Bedrock. | Amazon CloudWatch |
  | [TXT to SQL](./src/patterns/gen-ai/aws-text-to-sql/README.md) |  Leverages generative AI capabilities to facilitate natural language-based SQL query generation.  | Amazon Event Bridge, Amazon Bedrock, AWS Lambda, Amazon SQS, AWS Secrets, and database of choice |
  | [LlamaIndex Data Loading](./src/patterns/gen-ai/aws-llama-index-data-loader/README.md) | Use LlamaIndex to load data in preparation for generative AI workloads | Amazon ECS Fargate, Amazon SQS, and AWS Systems Manager Parameters |

  | **Construct** |Description| AWS Services used |
  |:-------------|:-------------|:-------------|
  | [Lambda layer](./src/patterns/gen-ai/aws-langchain-common-layer/README.md) | Python Lambda layer providing dependencies and utilities to develop generative AI applications on AWS. | AWS Lambda, Amazon Bedrock, Amazon SageMaker |
  | [Amazon Bedrock](./src/cdk-lib/bedrock/README.md) | CDK L2 Constructs for Amazon Bedrock. | Amazon Bedrock, Amazon OpenSearch Serverless, AWS Lambda |
  | [Amazon OpenSearch Serverless Vector Collection](./src/cdk-lib/opensearchserverless/README.md) | CDK L2 Constructs to create a vector collection. | Amazon OpenSearch Vector Index |
  | [Amazon OpenSearch Vector Index](./src/cdk-lib/opensearch-vectorindex/README.md) | CDK L1 Custom Resource to create a vector index. | Amazon OpenSearch Serverless, AWS Lambda |

  The official samples repository https://github.com/aws-samples/generative-ai-cdk-constructs-samples includes a collection of functional use case implementations to demonstrate the usage of AWS Generative AI CDK Constructs. These can be used in the same way as architectural patterns, and can be conceptualized as an additional "higher-level" abstraction of those patterns. Those patterns (constructs) are composed together into [stacks](https://docs.aws.amazon.com/cdk/latest/guide/stacks.html), forming a "CDK app".

  | Resource | Type | Description|
  |:-------------|:-------------|:-------------|
  | [AWS re:Invent 2023 - Keynote with Dr. Werner Vogels](https://youtu.be/UTRBVPvzt9w?t=6252) | Keynote | Dr. Werner Vogels, Amazon.com's VP and CTO, announces the AWS Generative AI CDK Constructs during his AWS re:Invent 2023 keynote. |
  | [Workshop - Building Generative AI Apps on AWS with CDK](https://catalog.workshops.aws/building-genai-apps) | Workshop | In this workshop, you will explore how to build a sample generative AI app on AWS using CDK and Generative AI CDK Constructs. |
  | [Workshop - Hands on AWS CDK Generative AI Constructs](https://catalog.us-east-1.prod.workshops.aws/workshops/84c00416-19b6-44c3-8d18-cc172361af41/en-US) | Workshop | In this workshop you will deploy projects that use CDK constructs from this library. Projects are from the [amazon-bedrock-samples](https://github.com/aws-samples/amazon-bedrock-samples/tree/main) Github Repository. |
  | [Build generative AI applications with Amazon Titan Text Premier, Amazon Bedrock, and AWS CDK](https://aws.amazon.com/blogs/machine-learning/build-generative-ai-applications-with-amazon-titan-text-premier-amazon-bedrock-and-aws-cdk/) | Blog post + Code sample | Blog post exploring building and deploying two sample applications powered by Amazon Titan Text Premier using the Generative AI CDK constructs. |
  | [aws-cdk-stack-builder-tool](https://github.com/aws-samples/aws-cdk-stack-builder-tool) | Code sample | AWS CDK Builder is a browser-based tool designed to streamline bootstrapping of Infrastructure as Code (IaC) projects using the AWS Cloud Development Kit (CDK). |
  | [CDK Live! Building generative AI applications and architectures leveraging AWS CDK Constructs!](https://www.youtube.com/watch?v=NI1F4Xxqyr8) | Video | CDK Live! episode focused on building and deploying generative AI applications and architectures on AWS using the AWS Cloud Development Kit (CDK) and the AWS Generative AI CDK Constructs. |
  | [Announcing AWS Generative AI CDK Constructs!](https://aws.amazon.com/blogs/devops/announcing-generative-ai-cdk-constructs/) | Blog post | Blog post announcing the release of the AWS Generative AI CDK Constructs. |
  | [Streamline insurance underwriting with generative AI using Amazon Bedrock](https://aws.amazon.com/blogs/machine-learning/streamline-insurance-underwriting-with-generative-ai-using-amazon-bedrock-part-1/)| Blog post + Code sample | Blog post and code sample discussing how to use AWS generative artificial intelligence (AI) solutions like Amazon Bedrock to improve the underwriting process, including rule validation, underwriting guidelines adherence, and decision justification. |
  | [aws-genai-llm-chatbot](https://github.com/aws-samples/aws-genai-llm-chatbot/tree/main) | Code sample | Multi-Model and Multi-RAG Powered Chatbot Using AWS CDK on AWS allowing you to experiment with a variety of Large Language Models and Multimodal Language Models, settings and prompts in your own AWS account. |
  | [bedrock-claude-chat](https://github.com/aws-samples/bedrock-claude-chat) | Code sample | AWS-native chatbot using Bedrock + Claude (+Mistral). |
  | [amazon-bedrock-rag](https://github.com/aws-samples/amazon-bedrock-rag)| Code sample | Fully managed RAG solution using Knowledge Bases for Amazon Bedrock. |
  | [Amazon Bedrock Multimodal Search](https://github.com/aws-samples/amazon-bedrock-titan-multimodal-search) | Code sample | Multimodal product search app built using Amazon Titan Multimodal Embeddings model. |
  | [Amazon Bedrock Knowledge Bases with Private Data](https://blog.serverlessadvocate.com/amazon-bedrock-knowledge-bases-with-private-data-7685d04ef396)| Blog post + Code sample  | Blog post and associated code sample demonstrating how to integrate Knowledge Bases into Amazon Bedrock to provide foundational models with contextual data from private data sources. |
  | [Automating tasks using Amazon Bedrock Agents and AI](https://blog.serverlessadvocate.com/automating-tasks-using-amazon-bedrock-agents-and-ai-4b6fb8856589) | Blog post + Code sample | Blog post and associated code sample demonstrating how to deploy an Amazon Bedrock Agent and a Knowledge Base through a hotel and spa use case. |
  | [Agents for Amazon Bedrock - Powertools for AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/bedrock_agents/#using-aws-cloud-developer-kit-cdk) | Code sample | Create Agents for Amazon Bedrock using event handlers and auto generation of OpenAPI schemas. |
  | [Text to SQL Bedrock Agent](https://github.com/aws-samples/amazon-bedrock-samples/tree/main/agents-for-bedrock/use-case-examples/text-2-sql-agent-cdk-enhanced) | Code sample | Harnessing the power of natural language processing, the "Text to SQL Bedrock Agent" facilitates the automatic transformation of natural language questions into executable SQL queries. |

  [![contributors](https://contrib.rocks/image?repo=awslabs/generative-ai-cdk-constructs&max=2000)](https://github.com/awslabs/generative-ai-cdk-constructs/graphs/contributors)

  Generative AI CDK Constructs may collect anonymous operational metrics, including: the region a construct is deployed, the name and version of the construct deployed, and related information. We may use the metrics to maintain, provide, develop, and improve the constructs and AWS services.

  Roadmap is available through the [GitHub Project](https://github.com/orgs/awslabs/projects/136)

  Apache-2.0


pkgId: 1a858cceb94b5704de981546a4ed44a55079a19dcecf1909dd21f051324d1490
name: python-cdklabs.generative-ai-cdk-constructs
arch: src
version: 0.1.286
epoch: 0
release: 1
summary: AWS Generative AI CDK Constructs is a library for well-architected generative AI patterns.
url: https://github.com/awslabs/generative-ai-cdk-constructs
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdklabs.generative-ai-cdk-constructs-0.1.286-1.src.rpm
checksum_type: sha256
description:
  [![View on Construct Hub](https://constructs.dev/badge?package=generative-ai-cdk-constructs)](https://constructs.dev/packages/@cdklabs/generative-ai-cdk-constructs)
  [![PyPI version](https://img.shields.io/pypi/v/cdklabs.generative-ai-cdk-constructs)](https://pypi.org/project/cdklabs.generative-ai-cdk-constructs/)
  [![npm version](https://img.shields.io/npm/v/@cdklabs/generative-ai-cdk-constructs)](https://www.npmjs.com/package/@cdklabs/generative-ai-cdk-constructs)
  [![NuGet Version](https://img.shields.io/nuget/v/Cdklabs.GenerativeAiCdkConstructs)](https://nuget.info/packages/Cdklabs.GenerativeAiCdkConstructs)
  [![Maven Central Version](https://img.shields.io/maven-central/v/io.github.cdklabs/generative-ai-cdk-constructs)](https://central.sonatype.com/artifact/io.github.cdklabs/generative-ai-cdk-constructs)
  [![Go Version](https://img.shields.io/github/v/tag/awslabs/generative-ai-cdk-constructs?label=go&color=orange)](https://pkg.go.dev/github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs)

  * [Introduction](#introduction)
  * [CDK Versions](#cdk-versions)
  * [Contributing](#contributing)
  * [Design guidelines and Development guide](#design-guidelines-and-development-guide)
  * [Getting Started](#getting-started)
  * [Catalog](#catalog)
  * [Sample Use Cases](#sample-use-cases)
  * [Additional Resources](#additional-resources)
  * [Contributors](#contributors)
  * [Operational Metrics Collection](#operational-metrics-collection)
  * [Roadmap](#roadmap)
  * [License](#license)
  * [Legal Disclaimer](#legal-disclaimer)

  The AWS Generative AI Constructs Library is an open-source extension of the [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html) that provides multi-service, well-architected patterns for quickly defining solutions in code to create predictable and repeatable infrastructure, called [constructs](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html). The goal of AWS Generative AI CDK Constructs is to help developers build generative AI solutions using pattern-based definitions for their architecture.
  The patterns defined in AWS Generative AI CDK Constructs are high level, multi-service abstractions of AWS CDK constructs that have default configurations based on well-architected best practices. The library is organized into logical modules using object-oriented techniques to create each architectural pattern model.

  AWS Generative AI CDK Constructs and the AWS CDK are independent teams and have different release schedules. Each release of AWS Generative AI CDK Constructs is built against a specific version of the AWS CDK. The [CHANGELOG.md](./CHANGELOG.md) file lists the CDK version associated with each AWS Generative AI Constructs release. For instance, AWS Generative AI CDK Constructs v0.0.0 was built against AWS CDK v2.96.2. This means that to use AWS Generative AI CDK Constructs v0.0.0, your application must include AWS CDK v2.96.2 or later. You can continue to use the latest AWS CDK versions and upgrade the your AWS Generative AI CDK Constructs version when new releases become available.

  Contributions of all kinds are welcome! Check out our [contributor guide](./CONTRIBUTING.md)

  If you want to add a new construct to the library, check out our [design guidelines](./DESIGN_GUIDELINES.md), then follow the [development guide](./DEVELOPER_GUIDE.md)

  <details>
  <summary><i>TypeScript</i></summary>
  * Create or use an existing CDK application in TypeScript.
    * `cdk init app --language typescript`
  * Run `npm install @cdklabs/generative-ai-cdk-constructs`
  * The package should be added to your package.json.
  * Import the library:
    * `import * as genai from '@cdklabs/generative-ai-cdk-constructs';`
  </details><details>
  <summary><i>Python</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language python`
  * Install the package:
    * `pip install cdklabs.generative-ai-cdk-constructs`
  * Import the library:
    * `import cdklabs.generative_ai_cdk_constructs`
  </details><details>
  <summary><i>NuGet</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language csharp`
  * Install the package while in the Visual Studio project:
    * `dotnet add package CdkLabs.GenerativeAICdkConstructs`
  * Use the namespace:
    * `using Cdklabs.GenerativeAiCdkConstructs;`
  </details><details>
  <summary><i>Go</i></summary>
  * Create or use an existing CDK application in Python
    * `cdk init app --language go`
  * Get the module:
    * `go get github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs`
  * Import the library:
    * `import "github.com/cdklabs/generative-ai-cdk-constructs-go/generative-ai-cdk-constructs"`
  *NOTE: The [Go distribution repository](https://github.com/cdklabs/generative-ai-cdk-constructs-go), distributes the JSII tar gzipped versioned source from the [source repository](https://github.awslabs/generative-ai-cdk-constructs)*
  </details><details>
  <summary><i>Java</i></summary>
  * Create or use an existing CDK application in Java
    * `cdk init app --language java`
  * Add the dependency into the `pom.xml`
  ```
  <dependency>
      <groupId>io.github.cdklabs</groupId>
      <artifactId>generative-ai-cdk-constructs</artifactId>
      <version>Get the latest version and insert it here</version>
  </dependency>
  ```
  </details>
  Refer to the documentation for additional guidance on a particular construct: [Catalog](#catalog)

  The following constructs are available in the library:

  | **Construct** |Description| AWS Services used |
  |:-------------|:-------------|:-------------|
  | [Data ingestion pipeline - OpenSearch](./src/patterns/gen-ai/aws-rag-appsync-stepfn-opensearch/README.md) | Ingestion pipeline providing a RAG (retrieval augmented generation) source for storing documents in a knowledge base. | Amazon OpenSearch, AWS Step Functions, Amazon Bedrock, AWS AppSync, AWS Lambda |
  | [Question answering](./src/patterns/gen-ai/aws-qa-appsync-opensearch/README.md) | Utilizing Large Language Models (Anthropic Claude V2.1.) for Question Answering on PDF documents with  RAG (retrieval augmented generation) source and/or long context. Additionally, leveraging Anthropic Claude 3 for visual question answering on images.| Amazon OpenSearch, AWS Lambda, Amazon Bedrock, AWS AppSync |
  | [Summarization](./src/patterns/gen-ai/aws-summarization-appsync-stepfn/README.md) | Document summarization with a large language model (Anthropic Claude V2.1). | AWS Lambda, Amazon Bedrock, AWS AppSync and Amazon ElastiCache for Redis.  |
  | [SageMaker model deployment (JumpStart)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_jumpstart.md) | Deploy a foundation model from Amazon SageMaker JumpStart to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [SageMaker model deployment (Hugging Face)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_hugging_face.md) | Deploy a foundation model from Hugging Face to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [SageMaker model deployment (Custom)](./src/patterns/gen-ai/aws-model-deployment-sagemaker/README_custom_sagemaker_endpoint.md) | Deploy a foundation model from an S3 location to an Amazon SageMaker endpoint. | Amazon SageMaker |
  | [Content Generation](./src/patterns/gen-ai/aws-contentgen-appsync-lambda/README.md) | Generate images from text using Amazon titan-image-generator-v1 or stability.stable-diffusion-xl-v1 model.  | AWS Lambda, Amazon Bedrock, AWS AppSync |
  | [Amazon Bedrock Monitoring (Amazon CloudWatch Dashboard)](./src/patterns/gen-ai/aws-bedrock-cw-dashboard/README.md) | Amazon CloudWatch dashboard to monitor model usage from Amazon Bedrock. | Amazon CloudWatch |
  | [TXT to SQL](./src/patterns/gen-ai/aws-text-to-sql/README.md) |  Leverages generative AI capabilities to facilitate natural language-based SQL query generation.  | Amazon Event Bridge, Amazon Bedrock, AWS Lambda, Amazon SQS, AWS Secrets, and database of choice |
  | [LlamaIndex Data Loading](./src/patterns/gen-ai/aws-llama-index-data-loader/README.md) | Use LlamaIndex to load data in preparation for generative AI workloads | Amazon ECS Fargate, Amazon SQS, and AWS Systems Manager Parameters |

  | **Construct** |Description| AWS Services used |
  |:-------------|:-------------|:-------------|
  | [Lambda layer](./src/patterns/gen-ai/aws-langchain-common-layer/README.md) | Python Lambda layer providing dependencies and utilities to develop generative AI applications on AWS. | AWS Lambda, Amazon Bedrock, Amazon SageMaker |
  | [Amazon Bedrock](./src/cdk-lib/bedrock/README.md) | CDK L2 Constructs for Amazon Bedrock. | Amazon Bedrock, Amazon OpenSearch Serverless, AWS Lambda |
  | [Amazon OpenSearch Serverless Vector Collection](./src/cdk-lib/opensearchserverless/README.md) | CDK L2 Constructs to create a vector collection. | Amazon OpenSearch Vector Index |
  | [Amazon OpenSearch Vector Index](./src/cdk-lib/opensearch-vectorindex/README.md) | CDK L1 Custom Resource to create a vector index. | Amazon OpenSearch Serverless, AWS Lambda |

  The official [samples repository](https://github.com/aws-samples/generative-ai-cdk-constructs-samples) includes a collection of functional use case implementations to demonstrate the usage of AWS Generative AI CDK Constructs. These can be used in the same way as architectural patterns, and can be conceptualized as an additional "higher-level" abstraction of those patterns. Those patterns (constructs) are composed together into [stacks](https://docs.aws.amazon.com/cdk/latest/guide/stacks.html), forming a "CDK app".

  | Resource | Type | Description|
  |:-------------|:-------------|:-------------|
  | [AWS re:Invent 2023 - Keynote with Dr. Werner Vogels](https://youtu.be/UTRBVPvzt9w?t=6252) | Keynote | Dr. Werner Vogels, Amazon.com's VP and CTO, announces the AWS Generative AI CDK Constructs during his AWS re:Invent 2023 keynote. |
  | [Workshop - Building Generative AI Apps on AWS with CDK](https://catalog.workshops.aws/building-genai-apps) | Workshop | In this workshop, you will explore how to build a sample generative AI app on AWS using CDK and Generative AI CDK Constructs. |
  | [Workshop - Hands on AWS CDK Generative AI Constructs](https://catalog.us-east-1.prod.workshops.aws/workshops/84c00416-19b6-44c3-8d18-cc172361af41/en-US) | Workshop | In this workshop you will deploy projects that use CDK constructs from this library. Projects are from the [amazon-bedrock-samples](https://github.com/aws-samples/amazon-bedrock-samples/tree/main) Github Repository. |
  | [Build generative AI applications with Amazon Titan Text Premier, Amazon Bedrock, and AWS CDK](https://aws.amazon.com/blogs/machine-learning/build-generative-ai-applications-with-amazon-titan-text-premier-amazon-bedrock-and-aws-cdk/) | Blog post + Code sample | Blog post exploring building and deploying two sample applications powered by Amazon Titan Text Premier using the Generative AI CDK constructs. |
  | [aws-cdk-stack-builder-tool](https://github.com/aws-samples/aws-cdk-stack-builder-tool) | Code sample | AWS CDK Builder is a browser-based tool designed to streamline bootstrapping of Infrastructure as Code (IaC) projects using the AWS Cloud Development Kit (CDK). |
  | [CDK Live! Building generative AI applications and architectures leveraging AWS CDK Constructs!](https://www.youtube.com/watch?v=NI1F4Xxqyr8) | Video | CDK Live! episode focused on building and deploying generative AI applications and architectures on AWS using the AWS Cloud Development Kit (CDK) and the AWS Generative AI CDK Constructs. |
  | [Announcing AWS Generative AI CDK Constructs!](https://aws.amazon.com/blogs/devops/announcing-generative-ai-cdk-constructs/) | Blog post | Blog post announcing the release of the AWS Generative AI CDK Constructs. |
  | [Streamline insurance underwriting with generative AI using Amazon Bedrock](https://aws.amazon.com/blogs/machine-learning/streamline-insurance-underwriting-with-generative-ai-using-amazon-bedrock-part-1/)| Blog post + Code sample | Blog post and code sample discussing how to use AWS generative artificial intelligence (AI) solutions like Amazon Bedrock to improve the underwriting process, including rule validation, underwriting guidelines adherence, and decision justification. |
  | [aws-genai-llm-chatbot](https://github.com/aws-samples/aws-genai-llm-chatbot/tree/main) | Code sample | Multi-Model and Multi-RAG Powered Chatbot Using AWS CDK on AWS allowing you to experiment with a variety of Large Language Models and Multimodal Language Models, settings and prompts in your own AWS account. |
  | [bedrock-claude-chat](https://github.com/aws-samples/bedrock-claude-chat) | Code sample | AWS-native chatbot using Bedrock + Claude (+Mistral). |
  | [amazon-bedrock-rag](https://github.com/aws-samples/amazon-bedrock-rag)| Code sample | Fully managed RAG solution using Knowledge Bases for Amazon Bedrock. |
  | [Amazon Bedrock Multimodal Search](https://github.com/aws-samples/amazon-bedrock-titan-multimodal-search) | Code sample | Multimodal product search app built using Amazon Titan Multimodal Embeddings model. |
  | [Amazon Bedrock Knowledge Bases with Private Data](https://blog.serverlessadvocate.com/amazon-bedrock-knowledge-bases-with-private-data-7685d04ef396)| Blog post + Code sample  | Blog post and associated code sample demonstrating how to integrate Knowledge Bases into Amazon Bedrock to provide foundational models with contextual data from private data sources. |
  | [Automating tasks using Amazon Bedrock Agents and AI](https://blog.serverlessadvocate.com/automating-tasks-using-amazon-bedrock-agents-and-ai-4b6fb8856589) | Blog post + Code sample | Blog post and associated code sample demonstrating how to deploy an Amazon Bedrock Agent and a Knowledge Base through a hotel and spa use case. |
  | [Agents for Amazon Bedrock - Powertools for AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/bedrock_agents/#using-aws-cloud-developer-kit-cdk) | Code sample | Create Agents for Amazon Bedrock using event handlers and auto generation of OpenAPI schemas. |
  | [Text to SQL Bedrock Agent](https://github.com/aws-samples/amazon-bedrock-samples/tree/main/agents-for-bedrock/use-case-examples/text-2-sql-agent-cdk-enhanced) | Code sample | Harnessing the power of natural language processing, the "Text to SQL Bedrock Agent" facilitates the automatic transformation of natural language questions into executable SQL queries. |

  [![contributors](https://contrib.rocks/image?repo=awslabs/generative-ai-cdk-constructs&max=2000)](https://github.com/awslabs/generative-ai-cdk-constructs/graphs/contributors)

  Generative AI CDK Constructs may collect anonymous operational metrics, including: the region a construct is deployed, the name and version of the construct deployed, and related information. We may use the metrics to maintain, provide, develop, and improve the constructs and AWS services.

  Roadmap is available through the [GitHub Project](https://github.com/orgs/awslabs/projects/136)

  Apache-2.0


pkgId: af7f7990da0e7295004fa3a3c952d3656c829ad522b0e0e016ff26f85fd1b984
name: python-cdktf
arch: src
version: 0.20.10
epoch: 0
release: 1
summary: Cloud Development Kit for Terraform
url: https://github.com/hashicorp/terraform-cdk
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-0.20.10-1.src.rpm
checksum_type: sha256
description:
  cdktf is a framework for defining cloud infrastructure using Terraform providers and modules. It allows for
  users to define infrastructure resources using higher-level programming languages.



  Install dependencies

  ```bash
  yarn install
  ```

  Build the package

  ```bash
  yarn build
  ```

  [Learn More](https://cdk.tf/docs)


pkgId: c5eb0dbc9530fecbacb223edf663bda52563b0356c09cbd3eb6511cd60398c88
name: python-cdktf-cdk8s
arch: src
version: 0.10.42
epoch: 0
release: 1
summary: A compatibility layer for using cdk8s constructs within Terraform CDK.
url: https://github.com/cdktf/cdktf-cdk8s.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdk8s-0.10.42-1.src.rpm
checksum_type: sha256
description:
  ![Status: Tech Preview](https://img.shields.io/badge/status-experimental-EAAA32) [![Releases](https://img.shields.io/github/release/cdktf/cdktf-cdk8s.svg)](https://github.com/cdktf/cdktf-cdk8s/releases)
  [![LICENSE](https://img.shields.io/github/license/cdktf/cdktf-cdk8s.svg)](https://github.com/cdktf/cdktf-cdk8s/blob/main/LICENSE)
  [![build](https://github.com/cdktf/cdktf-cdk8s/actions/workflows/build.yml/badge.svg)](https://github.com/cdktf/cdktf-cdk8s/actions/workflows/build.yml)

  A compatibility layer for using [cdk8s](https://cdk8s.io/) constructs within Terraform CDK.

  The cdk8s adapter is in technical preview, which means it's a community supported project. It still requires extensive testing and polishing to mature into a HashiCorp officially supported project. Please [file issues](https://github.com/cdktf/cdktf-cdk8s/issues/new/choose) generously and detail your experience while using the library. We welcome your feedback.

  By using the software in this repository, you acknowledge that:

  * The cdk8s adapter is still in development, may change, and has not been released as a commercial product by HashiCorp and is not currently supported in any way by HashiCorp.
  * The cdk8s adapter is provided on an "as-is" basis, and may include bugs, errors, or other issues.
  * The cdk8s adapter is NOT INTENDED FOR PRODUCTION USE, use of the Software may result in unexpected results, loss of data, or other unexpected results, and HashiCorp disclaims any and all liability resulting from use of the cdk8s adapter.
  * HashiCorp reserves all rights to make all decisions about the features, functionality and commercial release (or non-release) of the cdk8s adapter, at any time and without any obligation or liability whatsoever.



  * `cdktf` >= 0.20.0
  * `cdk8s` >= 2.8.0
  * `constructs` >= 10.3.0



  ```python
  import { App, TerraformStack } from "cdktf";
  import { App as CDK8sApp, Chart } from "cdk8s";
  import { CDK8sProvider } from "cdktf-cdk8s";

  import { MyCdk8sChart } from "./my-cdk8s-chart";

  export class MyKubernetesStack extends TerraformStack {
    constructor(scope: Construct, name: string) {
      super(scope, name);

      const cdk8sApp = new CDK8sApp();

      // Configure your cdk8s application like usual
      new HelloKube(cdk8sApp, "my-chart");

      // For properties see https://registry.terraform.io/providers/hashicorp/kubernetes/latest/docs
      // Extends on the Provider class from @cdktf/provider-kubernetes
      new CDK8sProvider(this, "cdk8s-dev", {
        configPath: "./kubeconfig.yaml",
        configContext: "my-dev-cluster",

        // Only the cdk8sApp property is added
        // There is no need to run synth on the cdk8sApp, this is done by the provider
        cdk8sApp,
      });
    }
  }

  const app = new App();
  new MyStack(app, "cdktf-cdk8s");
  app.synth();
  ```



  We welcome your contribution. Please understand that the experimental nature of this repository means that contributing code may be a bit of a moving target. If you have an idea for an enhancement or bug fix, and want to take on the work yourself, please first [create an issue](https://github.com/cdktf/cdktf-cdk8s/issues/new/choose) so that we can discuss the implementation with you before you proceed with the work.

  You can review our [contribution guide](https://github.com/cdktf/.github/blob/main/CONTRIBUTING.md) to begin.


pkgId: a566ba937e752cdac8c6551f0426d114a54d6428376a2d7e2b511959e0bbd877
name: python-cdktf-cdktf-provider-acme
arch: src
version: 11.7.0
epoch: 0
release: 1
summary: Prebuilt acme Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-acme.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-acme-11.7.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.26.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-acme](https://www.npmjs.com/package/@cdktf/provider-acme).

  `npm install @cdktf/provider-acme`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-acme](https://pypi.org/project/cdktf-cdktf-provider-acme).

  `pipenv install cdktf-cdktf-provider-acme`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme).

  `dotnet add package HashiCorp.Cdktf.Providers.Acme`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-acme</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-acme-go`](https://github.com/cdktf/cdktf-provider-acme-go) package.

  `go get github.com/cdktf/cdktf-provider-acme-go/acme/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-acme-go/blob/main/acme/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-acme).



  This project is explicitly not tracking the Terraform acme provider version 1:1. In fact, it always tracks `latest` of `~> 2.10` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.26.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: c4fad4af191f85a4adf962e3496c6aae01e69ff2779b788a32c136ab0278430b
name: python-cdktf-cdktf-provider-acme
arch: src
version: 11.9.0
epoch: 0
release: 1
summary: Prebuilt acme Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-acme.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-acme-11.9.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.28.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-acme](https://www.npmjs.com/package/@cdktf/provider-acme).

  `npm install @cdktf/provider-acme`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-acme](https://pypi.org/project/cdktf-cdktf-provider-acme).

  `pipenv install cdktf-cdktf-provider-acme`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme).

  `dotnet add package HashiCorp.Cdktf.Providers.Acme`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-acme</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-acme-go`](https://github.com/cdktf/cdktf-provider-acme-go) package.

  `go get github.com/cdktf/cdktf-provider-acme-go/acme/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-acme-go/blob/main/acme/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-acme).



  This project is explicitly not tracking the Terraform acme provider version 1:1. In fact, it always tracks `latest` of `~> 2.10` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.28.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 63e5c8fca12a9afb2d563252af1f9badfcfe09e0ee54800cfacd510e5a5001fb
name: python-cdktf-cdktf-provider-acme
arch: src
version: 11.9.1
epoch: 0
release: 1
summary: Prebuilt acme Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-acme.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-acme-11.9.1-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.28.1/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-acme](https://www.npmjs.com/package/@cdktf/provider-acme).

  `npm install @cdktf/provider-acme`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-acme](https://pypi.org/project/cdktf-cdktf-provider-acme).

  `pipenv install cdktf-cdktf-provider-acme`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme).

  `dotnet add package HashiCorp.Cdktf.Providers.Acme`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-acme</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-acme-go`](https://github.com/cdktf/cdktf-provider-acme-go) package.

  `go get github.com/cdktf/cdktf-provider-acme-go/acme/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-acme-go/blob/main/acme/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-acme).



  This project is explicitly not tracking the Terraform acme provider version 1:1. In fact, it always tracks `latest` of `~> 2.10` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.28.1)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 7dee0c8fccee24911dbc0801db28e978d6309bf1d04d979239a5e34196fa08ac
name: python-cdktf-cdktf-provider-ad
arch: src
version: 8.0.1
epoch: 0
release: 1
summary: Prebuilt ad Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-ad.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-ad-8.0.1-1.src.rpm
checksum_type: sha256
description:
  HashiCorp made the decision to stop publishing new versions of prebuilt [Terraform ad provider](https://registry.terraform.io/providers/hashicorp/ad/0.4.4) bindings for [CDK for Terraform](https://cdk.tf) on January 18, 2024. As such, this repository has been archived and is no longer supported in any way by HashiCorp. Previously-published versions of this prebuilt provider will still continue to be available on their respective package managers (e.g. npm, PyPi, Maven, NuGet), but these will not be compatible with new releases of `cdktf` past `0.20.0` and are no longer eligible for commercial support.

  As a reminder, you can continue to use the `hashicorp/ad` provider in your CDK for Terraform (CDKTF) projects, even with newer versions of CDKTF, but you will need to generate the bindings locally. The easiest way to do so is to use the [`provider add` command](https://developer.hashicorp.com/terraform/cdktf/cli-reference/commands#provider-add), optionally with the `--force-local` flag enabled:

  `cdktf provider add hashicorp/ad --force-local`

  For more information and additional examples, check out our documentation on [generating provider bindings manually](https://cdk.tf/imports).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-ad](https://www.npmjs.com/package/@cdktf/provider-ad).

  `npm install @cdktf/provider-ad`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-ad](https://pypi.org/project/cdktf-cdktf-provider-ad).

  `pipenv install cdktf-cdktf-provider-ad`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Ad](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Ad).

  `dotnet add package HashiCorp.Cdktf.Providers.Ad`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-ad](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-ad).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-ad</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-ad-go`](https://github.com/cdktf/cdktf-provider-ad-go) package.

  `go get github.com/cdktf/cdktf-provider-ad-go/ad/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-ad-go/blob/main/ad/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-ad).


pkgId: 03210ec593c04db5e972de1357804e444ed04c824d067a51510896d70c918e9e
name: python-cdktf-cdktf-provider-archive
arch: src
version: 10.2.0
epoch: 0
release: 1
summary: Prebuilt archive Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-archive.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-archive-10.2.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform archive provider](https://registry.terraform.io/providers/hashicorp/archive/2.6.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-archive](https://www.npmjs.com/package/@cdktf/provider-archive).

  `npm install @cdktf/provider-archive`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-archive](https://pypi.org/project/cdktf-cdktf-provider-archive).

  `pipenv install cdktf-cdktf-provider-archive`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Archive](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Archive).

  `dotnet add package HashiCorp.Cdktf.Providers.Archive`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-archive](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-archive).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-archive</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-archive-go`](https://github.com/cdktf/cdktf-provider-archive-go) package.

  `go get github.com/cdktf/cdktf-provider-archive-go/archive/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-archive-go/blob/main/archive/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-archive).



  This project is explicitly not tracking the Terraform archive provider version 1:1. In fact, it always tracks `latest` of `~> 2.2` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform archive provider](https://registry.terraform.io/providers/hashicorp/archive/2.6.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 113acb50f70f5299d5442f3c3084696070c7d54c2e04da91832d0b22cf7ed039
name: python-cdktf-cdktf-provider-archive
arch: src
version: 10.3.0
epoch: 0
release: 1
summary: Prebuilt archive Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-archive.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-archive-10.3.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform archive provider](https://registry.terraform.io/providers/hashicorp/archive/2.7.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-archive](https://www.npmjs.com/package/@cdktf/provider-archive).

  `npm install @cdktf/provider-archive`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-archive](https://pypi.org/project/cdktf-cdktf-provider-archive).

  `pipenv install cdktf-cdktf-provider-archive`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Archive](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Archive).

  `dotnet add package HashiCorp.Cdktf.Providers.Archive`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-archive](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-archive).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-archive</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-archive-go`](https://github.com/cdktf/cdktf-provider-archive-go) package.

  `go get github.com/cdktf/cdktf-provider-archive-go/archive/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-archive-go/blob/main/archive/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-archive).



  This project is explicitly not tracking the Terraform archive provider version 1:1. In fact, it always tracks `latest` of `~> 2.2` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform archive provider](https://registry.terraform.io/providers/hashicorp/archive/2.7.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: ac1edbf07ed099eb148f23834d71d5f5ed6f2f19af98acb17d520e2b4d472a71
name: python-cdktf-cdktf-provider-aws
arch: src
version: 19.37.0
epoch: 0
release: 1
summary: Prebuilt aws Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-aws.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-aws-19.37.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.71.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-aws](https://www.npmjs.com/package/@cdktf/provider-aws).

  `npm install @cdktf/provider-aws`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-aws](https://pypi.org/project/cdktf-cdktf-provider-aws).

  `pipenv install cdktf-cdktf-provider-aws`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws).

  `dotnet add package HashiCorp.Cdktf.Providers.Aws`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-aws</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-aws-go`](https://github.com/cdktf/cdktf-provider-aws-go) package.

  `go get github.com/cdktf/cdktf-provider-aws-go/aws/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-aws-go/blob/main/aws/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-aws).



  This project is explicitly not tracking the Terraform aws provider version 1:1. In fact, it always tracks `latest` of `~> 5.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.71.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 6d6b915f8dad2e673f9370de86f726429440d1eeca8a1494ac6603c5b2477cc9
name: python-cdktf-cdktf-provider-aws
arch: src
version: 19.41.1
epoch: 0
release: 1
summary: Prebuilt aws Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-aws.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-aws-19.41.1-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.75.1/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-aws](https://www.npmjs.com/package/@cdktf/provider-aws).

  `npm install @cdktf/provider-aws`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-aws](https://pypi.org/project/cdktf-cdktf-provider-aws).

  `pipenv install cdktf-cdktf-provider-aws`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws).

  `dotnet add package HashiCorp.Cdktf.Providers.Aws`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-aws</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-aws-go`](https://github.com/cdktf/cdktf-provider-aws-go) package.

  `go get github.com/cdktf/cdktf-provider-aws-go/aws/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-aws-go/blob/main/aws/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-aws).



  This project is explicitly not tracking the Terraform aws provider version 1:1. In fact, it always tracks `latest` of `~> 5.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.75.1)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 85e4dbbafc8b6f61ac4743ff376e49394cc6f5cc80a81c614b296aeba34e702a
name: python-cdktf-cdktf-provider-aws
arch: src
version: 19.42.0
epoch: 0
release: 1
summary: Prebuilt aws Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-aws.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-aws-19.42.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.76.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-aws](https://www.npmjs.com/package/@cdktf/provider-aws).

  `npm install @cdktf/provider-aws`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-aws](https://pypi.org/project/cdktf-cdktf-provider-aws).

  `pipenv install cdktf-cdktf-provider-aws`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws).

  `dotnet add package HashiCorp.Cdktf.Providers.Aws`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-aws</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-aws-go`](https://github.com/cdktf/cdktf-provider-aws-go) package.

  `go get github.com/cdktf/cdktf-provider-aws-go/aws/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-aws-go/blob/main/aws/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-aws).



  This project is explicitly not tracking the Terraform aws provider version 1:1. In fact, it always tracks `latest` of `~> 5.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.76.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: c18b068a3e33d91f013034f21bc9da813a4487ec242625f4d406b008270edee9
name: python-cdktf-cdktf-provider-aws
arch: src
version: 19.44.0
epoch: 0
release: 1
summary: Prebuilt aws Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-aws.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-aws-19.44.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.78.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-aws](https://www.npmjs.com/package/@cdktf/provider-aws).

  `npm install @cdktf/provider-aws`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-aws](https://pypi.org/project/cdktf-cdktf-provider-aws).

  `pipenv install cdktf-cdktf-provider-aws`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws).

  `dotnet add package HashiCorp.Cdktf.Providers.Aws`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-aws</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-aws-go`](https://github.com/cdktf/cdktf-provider-aws-go) package.

  `go get github.com/cdktf/cdktf-provider-aws-go/aws/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-aws-go/blob/main/aws/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-aws).



  This project is explicitly not tracking the Terraform aws provider version 1:1. In fact, it always tracks `latest` of `~> 5.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.78.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: c03c80c97c26bd4585ca0d5d5db1a46075b58c14fa78e320abacb1a739175b76
name: python-cdktf-cdktf-provider-aws
arch: src
version: 19.45.0
epoch: 0
release: 1
summary: Prebuilt aws Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-aws.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-aws-19.45.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.79.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-aws](https://www.npmjs.com/package/@cdktf/provider-aws).

  `npm install @cdktf/provider-aws`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-aws](https://pypi.org/project/cdktf-cdktf-provider-aws).

  `pipenv install cdktf-cdktf-provider-aws`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws).

  `dotnet add package HashiCorp.Cdktf.Providers.Aws`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-aws</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-aws-go`](https://github.com/cdktf/cdktf-provider-aws-go) package.

  `go get github.com/cdktf/cdktf-provider-aws-go/aws/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-aws-go/blob/main/aws/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-aws).



  This project is explicitly not tracking the Terraform aws provider version 1:1. In fact, it always tracks `latest` of `~> 5.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.79.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 22e805a5a9dc124c2706a8393823e91b578289d62709416e6c5814557c815da8
name: python-cdktf-cdktf-provider-azuread
arch: src
version: 13.0.0
epoch: 0
release: 1
summary: Prebuilt azuread Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-azuread.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-azuread-13.0.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform azuread provider](https://registry.terraform.io/providers/hashicorp/azuread/3.0.2/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-azuread](https://www.npmjs.com/package/@cdktf/provider-azuread).

  `npm install @cdktf/provider-azuread`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-azuread](https://pypi.org/project/cdktf-cdktf-provider-azuread).

  `pipenv install cdktf-cdktf-provider-azuread`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Azuread](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Azuread).

  `dotnet add package HashiCorp.Cdktf.Providers.Azuread`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-azuread](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-azuread).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-azuread</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-azuread-go`](https://github.com/cdktf/cdktf-provider-azuread-go) package.

  `go get github.com/cdktf/cdktf-provider-azuread-go/azuread/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-azuread-go/blob/main/azuread/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-azuread).



  This project is explicitly not tracking the Terraform azuread provider version 1:1. In fact, it always tracks `latest` of `~> 3.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform azuread provider](https://registry.terraform.io/providers/hashicorp/azuread/3.0.2)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 118d484bc203224a391a06c8a84ade3f3834dc8ae3e0fd9a2da71a4c560c6a1a
name: python-cdktf-cdktf-provider-azurerm
arch: src
version: 13.10.0
epoch: 0
release: 1
summary: Prebuilt azurerm Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-azurerm.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-azurerm-13.10.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform azurerm provider](https://registry.terraform.io/providers/hashicorp/azurerm/4.10.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-azurerm](https://www.npmjs.com/package/@cdktf/provider-azurerm).

  `npm install @cdktf/provider-azurerm`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-azurerm](https://pypi.org/project/cdktf-cdktf-provider-azurerm).

  `pipenv install cdktf-cdktf-provider-azurerm`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Azurerm](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Azurerm).

  `dotnet add package HashiCorp.Cdktf.Providers.Azurerm`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-azurerm](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-azurerm).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-azurerm</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-azurerm-go`](https://github.com/cdktf/cdktf-provider-azurerm-go) package.

  `go get github.com/cdktf/cdktf-provider-azurerm-go/azurerm/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-azurerm-go/blob/main/azurerm/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-azurerm).



  This project is explicitly not tracking the Terraform azurerm provider version 1:1. In fact, it always tracks `latest` of `~> 4.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform azurerm provider](https://registry.terraform.io/providers/hashicorp/azurerm/4.10.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: ef2ba1e44c2fb69de01d576ababcfc29d54d30b7b9a6e73064588850e7cf8fa1
name: python-cdktf-cdktf-provider-azurerm
arch: src
version: 13.11.0
epoch: 0
release: 1
summary: Prebuilt azurerm Provider for Terraform CDK (cdktf)
url: https://github.com/cdktf/cdktf-provider-azurerm.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cdktf-cdktf-provider-azurerm-13.11.0-1.src.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform azurerm provider](https://registry.terraform.io/providers/hashicorp/azurerm/4.11.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-azurerm](https://www.npmjs.com/package/@cdktf/provider-azurerm).

  `npm install @cdktf/provider-azurerm`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-azurerm](https://pypi.org/project/cdktf-cdktf-provider-azurerm).

  `pipenv install cdktf-cdktf-provider-azurerm`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Azurerm](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Azurerm).

  `dotnet add package HashiCorp.Cdktf.Providers.Azurerm`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-azurerm](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-azurerm).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-azurerm</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-azurerm-go`](https://github.com/cdktf/cdktf-provider-azurerm-go) package.

  `go get github.com/cdktf/cdktf-provider-azurerm-go/azurerm/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-azurerm-go/blob/main/azurerm/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-azurerm).



  This project is explicitly not tracking the Terraform azurerm provider version 1:1. In fact, it always tracks `latest` of `~> 4.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform azurerm provider](https://registry.terraform.io/providers/hashicorp/azurerm/4.11.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


