堆栈

AWS Cloud Development Kit (AWS CDK) 堆栈是一个或多个结构的集合，用于定义 AWS 资源。每个 CDK 堆栈代表您的 CDK 应用程序中的一个 AWS CloudFormation 堆栈。部署时，堆栈中的构造被配置为一个单元，称为堆栈。 AWS CloudFormation 要了解有关 AWS CloudFormation 堆栈的更多信息，请参阅AWS CloudFormation 用户指南中的使用堆栈。

由于 CDK 堆栈是通过 AWS CloudFormation 堆栈实现的，因此存在 AWS CloudFormation 配额和限制。要了解更多信息，请参阅AWS CloudFormation 配额。

定义堆栈

堆栈是在应用程序的上下文中定义的。您可以使用 AWS 构造库中的Stack类来定义堆栈。可以通过以下任何一种方式定义堆栈：

直接在应用程序的范围内。
通过树中的任何构造间接获得。

以下示例定义了一个包含两个堆栈的 CDK 应用程序：

以下示例是在单独文件上定义堆栈的常用模式。在这里，我们扩展或继承Stack类并定义一个接受scopeid、和的构造函数props。然后，我们使用super接收到的、和scope，id调用基Stack类构造函数props。

以下示例声明了一个名为的堆栈类MyFirstStack，其中包含一个 Amazon S3 存储桶。

但是，此代码仅声明了一个堆栈。要将堆栈实际合成 AWS CloudFormation 模板并进行部署，必须对其进行实例化。而且，像所有 CDK 构造一样，它必须在某些上下文中实例化。App就是那个背景。

如果您使用的是标准 AWS CDK 开发模板，则您的堆栈将在您实例化对象的同一个文件中进行实例化。App

堆栈 API

Stack 对象提供了丰富的 API，包括以下内容：

Stack.of(construct)— 一种静态方法，它返回在其中定义构造的堆栈。如果您需要在可重复使用的构造中与堆栈进行交互，这很有用。如果在作用域中找不到堆栈，则调用将失败。
stack.stackName(Python:stack_name)-返回堆栈的物理名称。如前所述，所有 AWS CDK 堆栈都有一个物理名称， AWS CDK 可以在合成过程中解析。
stack.region和 stack.account — 分别返回将部署此堆栈的 AWS 区域和账户。这些属性返回以下内容之一：
- 定义堆栈时明确指定的账户或区域
- 字符串编码的令牌，可解析为账户和区域的 AWS CloudFormation 伪参数，以表明此堆栈与环境无关
有关如何确定堆栈环境的信息，请参阅环境。
stack.addDependency(stack)(Python: stack.add_dependency(stack) — 可用于明确定义两个堆栈之间的依赖顺序。同时部署多个堆栈时，cdk deploy命令会遵守此顺序。
stack.tags— 返回TagManager可用于添加或删除堆栈级别标签的。此标签管理器会标记堆栈中的所有资源，并在通过创建堆栈时对堆栈本身进行标记 AWS CloudFormation。
stack.partition、stack.urlSuffix (Python:url_suffix)、stack.stackId (Python:notification_arn) 和 stack.notificationArn (Python:) — 返回解析为相应 AWS CloudFormation 伪参数的标记，例如{ "Ref": "AWS::Partition" }。stack_id这些令牌与特定的堆栈对象相关联，因此 AWS CDK 框架可以识别跨堆栈引用。
stack.availabilityZones(Python:availability_zones)-返回部署此堆栈的环境中可用的一组可用区。对于与环境无关的堆栈，这始终会返回一个包含两个可用区的数组。对于特定于环境的堆栈，会 AWS CDK 查询环境并返回您指定的区域中可用的确切可用区集。
stack.parseArn(arn)和 stack.formatArn(comps) (Python:parse_arn,format_arn) — 可用于处理亚马逊资源名称 (ARN)。
stack.toJsonString(obj)(Python:to_json_string)-可用于将任意对象格式化为可以嵌入到 AWS CloudFormation 模板中的 JSON 字符串。该对象可以包含标记、属性和引用，这些标记、属性和引用只能在部署期间解析。
stack.templateOptions(Python:template_options)-用于为堆栈指定 AWS CloudFormation 模板选项，例如转换、描述和元数据。

使用堆栈

要列出 CDK 应用程序中的所有堆栈，请使用命令。cdk ls前面的示例将输出以下内容：

stack1
stack2

堆栈作为 AWS CloudFormation 堆栈的一部分部署到 AWS 环境中。环境涵盖了特定的 AWS 账户和 AWS 区域.

当您为具有多个堆栈的应用程序运行cdk synth命令时，云程序集会为每个堆栈实例包含一个单独的模板。即使这两个堆栈是同一个类的实例，它们也会将它们作为两个单独 AWS CDK 的模板发出。

您可以通过在cdk synth命令中指定堆栈名称来合成每个模板。以下示例合成了 st ack1 的模板。


$ cdk synth stack1

这种方法在概念上与通常使用 AWS CloudFormation 模板的方式不同，在模板中，模板可以多次部署并通过参数进行参数化。AWS CloudFormation尽管可以在中定义 AWS CloudFormation 参数 AWS CDK，但通常不建议使用这些参数，因为 AWS CloudFormation 参数只能在部署期间解析。这意味着您无法在代码中确定它们的值。

例如，要根据参数值有条件地将资源包含在应用程序中，您必须设置AWS CloudFormation 条件并使用该条件标记资源。 AWS CDK 采用的方法是在合成时解析混凝土模板。因此，您可以使用 i f 语句来检查该值，以确定是应定义资源还是应应用某些行为。

注意

在合成期间 AWS CDK 提供尽可能多的分辨率，以实现编程语言的惯用和自然使用。

像任何其他构造一样，堆栈可以组合成组。以下代码显示了由三个堆栈组成的服务示例：控制平面、数据平面和监控堆栈。服务结构定义了两次：一次用于测试环境，另一次用于生产环境。

TypeScript


import { App, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';

interface EnvProps {
  prod: boolean;
}

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope: Construct, id: string, props?: EnvProps) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();

JavaScript


const { App, Stack } = require('aws-cdk-lib');
const { Construct } = require('constructs');

// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}

class MyService extends Construct {

  constructor(scope, id, props) {
  
    super(scope, id);
  
    // we might use the prod argument to change how the service is configured
    new ControlPlane(this, "cp");
    new DataPlane(this, "data");
    new Monitoring(this, "mon");
  }
}

const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });

app.synth();

Python


from aws_cdk import App, Stack
from constructs import Construct

# imagine these stacks declare a bunch of related resources
class ControlPlane(Stack): pass
class DataPlane(Stack): pass
class Monitoring(Stack): pass

class MyService(Construct):

  def __init__(self, scope: Construct, id: str, *, prod=False):
  
    super().__init__(scope, id)
  
    # we might use the prod argument to change how the service is configured
    ControlPlane(self, "cp")
    DataPlane(self, "data")
    Monitoring(self, "mon")
    
app = App();
MyService(app, "beta")
MyService(app, "prod", prod=True)

app.synth()

Java


package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Stack;
import software.constructs.Construct;

public class MyApp {

    // imagine these stacks declare a bunch of related resources
    static class ControlPlane extends Stack {
        ControlPlane(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class DataPlane extends Stack {
        DataPlane(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class Monitoring extends Stack {
        Monitoring(Construct scope, String id) {
            super(scope, id);
        }
    }

    static class MyService extends Construct {
        MyService(Construct scope, String id) {
            this(scope, id, false);
        }
        
        MyService(Construct scope, String id, boolean prod) {
            super(scope, id);
            
            // we might use the prod argument to change how the service is configured
            new ControlPlane(this, "cp");
            new DataPlane(this, "data");
            new Monitoring(this, "mon");         
        }
    }
    
    public static void main(final String argv[]) {
        App app = new App();

        new MyService(app, "beta");
        new MyService(app, "prod", true);
        
        app.synth();
    }
}

C#


using Amazon.CDK;
using Constructs;

// imagine these stacks declare a bunch of related resources
public class ControlPlane : Stack {
    public ControlPlane(Construct scope, string id=null) : base(scope, id) { }
}

public class DataPlane : Stack {
    public DataPlane(Construct scope, string id=null) : base(scope, id) { }
}

public class Monitoring : Stack
{
    public Monitoring(Construct scope, string id=null) : base(scope, id) { }
}

public class MyService : Construct
{
    public MyService(Construct scope, string id, Boolean prod=false) : base(scope, id)
    {
        // we might use the prod argument to change how the service is configured
        new ControlPlane(this, "cp");
        new DataPlane(this, "data");
        new Monitoring(this, "mon");
    }
}

class Program
{
    static void Main(string[] args)
    {

        var app = new App();
        new MyService(app, "beta");
        new MyService(app, "prod", prod: true);
        app.Synth();
    }
}

该 AWS CDK 应用程序最终由六个堆栈组成，每个环境三个堆栈：


$ cdk ls
    
betacpDA8372D3
betadataE23DB2BA
betamon632BD457
prodcp187264CE
proddataF7378CE5
prodmon631A1083

AWS CloudFormation 堆栈的物理名称由 AWS CDK 基于堆栈在树中的构造路径自动确定。默认情况下，堆栈的名称源自Stack对象的构造 ID。但是，您可以使用 stackName prop（在 Python 中stack_name）指定显式名称，如下所示。

嵌套堆栈

该NestedStack构造提供了一种绕过堆栈的 AWS CloudFormation 500 资源限制的方法。嵌套堆栈仅算作包含它的堆栈中的一个资源。但是，它最多可以包含 500 个资源，包括额外的嵌套堆栈。

嵌套堆栈的作用域必须是Stack或NestedStack构造。嵌套堆栈不需要在其父堆栈中按词法声明。实例化嵌套堆栈时，只需要将父堆栈作为第一个参数 (scope) 传递。除了这个限制之外，在嵌套堆栈中定义构造的工作原理与在普通堆栈中定义构造完全相同。

在合成时，嵌套堆栈会合成到自己的 AWS CloudFormation 模板中，并在部署时将其上传到 AWS CDK 暂存桶。嵌套堆栈绑定到其父堆栈，不会被视为独立的部署工件。它们不是由列出的cdk list，也不能由其部署cdk deploy。

父堆栈和嵌套堆栈之间的引用会自动转换为生成的 AWS CloudFormation 模板中的堆栈参数和输出，就像任何跨堆栈引用一样。

警告

在部署嵌套堆栈之前，不会显示安全状态的变化。此信息仅针对顶级堆栈显示。

Javascript 在您的浏览器中被禁用或不可用。

要使用 Amazon Web Services 文档，必须启用 Javascript。请参阅浏览器的帮助页面以了解相关说明。

文档惯例

应用程序

构造

堆栈

主题

定义堆栈

堆栈 API

使用 堆栈

注意

嵌套堆栈

警告

使用堆栈