PyPI 官网下载 | aws-cdk.core-1.65.0.tar.gz

## AWS Cloud Development Kit Core Library <!--BEGIN STABILITY BANNER-->---   --- <!--END STABILITY BANNER--> This library includes the basic building blocks of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) (AWS CDK). It defines the core classes that are used in the rest of the AWS Construct Library. See the [AWS CDK Developer Guide](https://docs.aws.amazon.com/cdk/latest/guide/home.html) for information of most of the capabilities of this library. The rest of this README will only cover topics not already covered in the Developer Guide. ## Stacks and Stages A `Stack` is the smallest physical unit of deployment, and maps directly onto a CloudFormation Stack. You define a Stack by defining a subclass of `Stack` -- let's call it `MyStack` -- and instantiating the constructs that make up your application in `MyStack`'s constructor. You then instantiate this stack one or more times to define different instances of your application. For example, you can instantiate it once using few and cheap EC2 instances for testing, and once again using more and bigger EC2 instances for production. When your application grows, you may decide that it makes more sense to split it out across multiple `Stack` classes. This can happen for a number of reasons: * You could be starting to reach the maximum number of resources allowed in a single stack (this is currently 200). * You could decide you want to separate out stateful resources and stateless resources into separate stacks, so that it becomes easy to tear down and recreate the stacks that don't have stateful resources. * There could be a single stack with resources (like a VPC) that are shared between multiple instances of other stacks containing your applications. As soon as your conceptual application starts to encompass multiple stacks, it is convenient to wrap them in another construct that represents your logical application. You can then treat that new unit the same way you used to be able to treat a single stack: by instantiating it multiple times for different instances of your application. You can define a custom subclass of `Construct`, holding one or more `Stack`s, to represent a single logical instance of your application. As a final note: `Stack`s are not a unit of reuse. They describe physical deployment layouts, and as such are best left to application builders to organize their deployments with. If you want to vend a reusable construct, define it as a subclasses of `Construct`: the consumers of your construct will decide where to place it in their own stacks. ## 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, synthesizer=None, terminationProtection=None, analyticsReporting=None): super().__init__(scope, id, description=description, env=env, stackName=stackName, tags=tags, synthesizer=synthesizer, terminationProtection=terminationProtection, analyticsReporting=analyticsReporting) 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. ## Durations To make specifications of time intervals unambiguous, a single class called `Duration` is used throughout the AWS Construct Library by all constructs that that take a time interval as a parameter (be it for a timeout, a rate, or something else). An instance of Duration is constructed by using one of the static factory methods on it: ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 Duration.seconds(300)# 5 minutes Duration.minutes(5)# 5 minutes Duration.hours(1)# 1 hour Duration.days(7)# 7 days Duration.parse("PT5M") ``` ## Size (Digital Information Quantity) To make specification of digital storage quantities unambiguous, a class called `Size` is available. An instance of `Size` is initialized through one of its static factory methods: ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 Size.kibibytes(200)# 200 KiB Size.mebibytes(5)# 5 MiB Size.gibibytes(40)# 40 GiB Size.tebibytes(200)# 200 TiB Size.pebibytes(3) ``` Instances of `Size` created with one of the units can be converted into others. By default, conversion to a higher unit will fail if the conversion does not produce a whole number. This can be overridden by unsetting `integral` property. ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 Size.mebibytes(2).to_kibibytes()# yields 2048 Size.kibibytes(2050).to_mebibyte(integral=False) ``` ## Secrets To help avoid accidental storage of secrets as plain text, we use the `SecretValue` type to represent secrets. Any construct that takes a value that should be a secret (such as a password or an access key) will take a parameter of type `SecretValue`. The best practice is to store secrets in AWS Secrets Manager and reference them using `SecretValue.secretsManager`: ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 secret = SecretValue.secrets_manager("secretId", json_field="password", # optional: key of a JSON field to retrieve (defaults to all content), version_id="id", # optional: id of the version (default AWSCURRENT) version_stage="stage" ) ``` Using AWS Secrets Manager is the recommended way to reference secrets in a CDK app. `SecretValue` also supports the following secret sources: * `SecretValue.plainText(secret)`: stores the secret as plain text in your app and the resulting template (not recommended). * `SecretValue.ssmSecure(param, version)`: refers to a s