Metadata-Version: 2.1
Name: aws-cdk.aws-cloudformation
Version: 1.27.0
Summary: CDK Constructs for AWS CloudFormation
Home-page: https://github.com/aws/aws-cdk
Author: Amazon Web Services
License: Apache-2.0
Project-URL: Source, https://github.com/aws/aws-cdk.git
Description: ## AWS CloudFormation Construct Library
        
        <!--BEGIN STABILITY BANNER-->---
        
        
        ![Stability: Stable](https://img.shields.io/badge/stability-Stable-success.svg?style=for-the-badge)
        
        ---
        <!--END STABILITY BANNER-->
        
        This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.
        
        ### Custom Resources
        
        Custom Resources are CloudFormation resources that are implemented by
        arbitrary user code. They can do arbitrary lookups or modifications
        during a CloudFormation synthesis run.
        
        You will typically use Lambda to implement a Construct implemented as a
        Custom Resource (though SNS topics can be used as well). Your Lambda function
        will be sent a `CREATE`, `UPDATE` or `DELETE` message, depending on the
        CloudFormation life cycle. It will perform whatever actions it needs to, and
        then return any number of output values which will be available as attributes
        of your Construct. In turn, those can be used as input to other Constructs in
        your model.
        
        In general, consumers of your Construct will not need to care whether
        it is implemented in term of other CloudFormation resources or as a
        custom resource.
        
        Note: when implementing your Custom Resource using a Lambda, use
        a `SingletonLambda` so that even if your custom resource is instantiated
        multiple times, the Lambda will only get uploaded once.
        
        #### Example
        
        The following shows an example of a declaring Custom Resource that copies
        files into an S3 bucket during deployment (the implementation of the actual
        Lambda handler is elided for brevity).
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        class CopyOperation(Construct):
            def __init__(self, parent, name, *, sourceBucket, targetBucket):
                super().__init__(parent, name)
        
                lambda_provider = lambda.SingletonFunction(self, "Provider",
                    uuid="f7d4f730-4ee1-11e8-9c2d-fa7ae01bbebc",
                    runtime=lambda.Runtime.PYTHON_3_7,
                    code=lambda.Code.from_asset("../copy-handler"),
                    handler="index.handler",
                    timeout=Duration.seconds(60)
                )
        
                CustomResource(self, "Resource",
                    provider=CustomResourceProvider.from_lambda(lambda_provider),
                    properties={
                        "source_bucket_arn": source_bucket.bucket_arn,
                        "target_bucket_arn": target_bucket.bucket_arn
                    }
                )
        ```
        
        The [aws-cdk-examples repository](https://github.com/aws-samples/aws-cdk-examples) has
        examples for adding custom resources.
        
        #### References
        
        See the following section of the docs on details to write Custom Resources:
        
        * [Introduction](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-custom-resources.html)
        * [Reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/crpg-ref.html)
        * [Code Reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-code.html)
        
        ### Nested Stacks
        
        [Nested stacks](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html) are stacks created as part of other stacks. You create a nested stack within another stack by using the `NestedStack` construct.
        
        As your infrastructure grows, common patterns can emerge in which you declare the same components in multiple templates. You can separate out these common components and create dedicated templates for them. Then use the resource in your template to reference other templates, creating nested stacks.
        
        For example, assume that you have a load balancer configuration that you use for most of your stacks. Instead of copying and pasting the same configurations into your templates, you can create a dedicated template for the load balancer. Then, you just use the resource to reference that template from within other templates.
        
        The following example will define a single top-level stack that contains two nested stacks: each one with a single Amazon S3 bucket:
        
        ```python
        # Example automatically generated. See https://github.com/aws/jsii/issues/826
        from aws_cdk.core import Stack, Construct, StackProps
        import aws_cdk.aws_cloudformation as cfn
        import aws_cdk.aws_s3 as s3
        
        class MyNestedStack(cfn.NestedStack):
            def __init__(self, scope, id, *, parameters=None, timeout=None, notifications=None):
                super().__init__(scope, id, parameters=parameters, timeout=timeout, notifications=notifications)
        
                s3.Bucket(self, "NestedBucket")
        
        class MyParentStack(Stack):
            def __init__(self, scope, id, *, description=None, env=None, stackName=None, tags=None):
                super().__init__(scope, id, description=description, env=env, stackName=stackName, tags=tags)
        
                MyNestedStack(self, "Nested1")
                MyNestedStack(self, "Nested2")
        ```
        
        Resources references across nested/parent boundaries (even with multiple levels of nesting) will be wired by the AWS CDK
        through CloudFormation parameters and outputs. When a resource from a parent stack is referenced by a nested stack,
        a CloudFormation parameter will automatically be added to the nested stack and assigned from the parent; when a resource
        from a nested stack is referenced by a parent stack, a CloudFormation output will be automatically be added to the
        nested stack and referenced using `Fn::GetAtt "Outputs.Xxx"` from the parent.
        
        Nested stacks also support the use of Docker image and file assets.
        
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: JavaScript
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Typing :: Typed
Classifier: Development Status :: 5 - Production/Stable
Classifier: License :: OSI Approved
Requires-Python: >=3.6
Description-Content-Type: text/markdown
