スタック - AWS Cloud Development Kit (AWS CDK) v2
スタックの定義 スタックの操作

これは AWS CDK v2 開発者ガイドです。古い CDK v1 は 2022 年 6 月 1 日にメンテナンスを開始し、2023 年 6 月 1 日にサポートを終了しました。

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

スタック

AWS Cloud Development Kit (AWS CDK) スタックは、 AWS リソースを定義する 1 つ以上の構成要素の集合です。各 CDK スタックは CDK アプリ内の 1 AWS CloudFormation つのスタックを表します。デプロイ時には、スタック内の構成はスタックと呼ばれる 1 つのユニットとしてプロビジョニングされます。 AWS CloudFormation AWS CloudFormation スタックについて詳しくは、『ユーザーガイド』の「スタックの使い方」を参照してください。AWS CloudFormation

CDK AWS CloudFormation スタックはスタックを通じて実装されるため、 AWS CloudFormation クォータと制限が適用されます。詳細については、クォータをご覧ください。AWS CloudFormation

スタックの定義

スタックはアプリのコンテキスト内で定義されます。Stack AWS スタックはコンストラクトライブラリのクラスを使用して定義します。スタックは以下のいずれかの方法で定義できます。

  • アプリのスコープ内で直接。

  • ツリー内の任意の構成要素によって間接的に。

以下の例では、2 つのスタックを含む CDK アプリを定義しています。

TypeScript
const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();
JavaScript
const app = new App();

new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');

app.synth();
Python
app = App()

MyFirstStack(app, 'stack1')
MySecondStack(app, 'stack2')

app.synth()
Java
App app = new App();

new MyFirstStack(app, "stack1");
new MySecondStack(app, "stack2");

app.synth();
C#
var app = new App();

new MyFirstStack(app, "stack1");
new MySecondStack(app, "stack2");

app.Synth();

以下の例は、別のファイルでスタックを定義する一般的なパターンです。ここでは、Stackクラスを拡張または継承し、、scope、idを受け入れるコンストラクターを定義しています。props次に、受け取った、、Stacksuperを使用して基本クラスのコンストラクターを呼び出します。scope id props

TypeScript
class HelloCdkStack extends Stack {
  constructor(scope: App, id: string, props?: StackProps) {
    super(scope, id, props);

    //...
  }
}
JavaScript
class HelloCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    //...
  }
}
Python
class HelloCdkStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        # ...
Java
public class HelloCdkStack extends Stack {
    public HelloCdkStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        // ...
    }
}
C#
public class HelloCdkStack : Stack
{
    public HelloCdkStack(Construct scope, string id, IStackProps props=null) : base(scope, id, props)
    {
        //...
    }
}
Go
func HelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
 var sprops awscdk.StackProps
 if props != nil {
  sprops = props.StackProps
 }
 stack := awscdk.NewStack(scope, &id, &sprops)

  return stack
}

次の例では、単一の Amazon S3 MyFirstStack バケットを含むという名前のスタッククラスを宣言しています。

TypeScript
class MyFirstStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    new s3.Bucket(this, 'MyFirstBucket');
  }
}
JavaScript
class MyFirstStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    new s3.Bucket(this, 'MyFirstBucket');
  }
}
Python
class MyFirstStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs):
        super().__init__(scope, id, **kwargs)

        s3.Bucket(self, "MyFirstBucket")
Java
public class MyFirstStack extends Stack {
    public MyFirstStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public MyFirstStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);
        
        new Bucket(this, "MyFirstBucket");
    }
}
C#
public class MyFirstStack : Stack
{
    public MyFirstStack(Stack scope, string id, StackProps props = null) : base(scope, id, props)
    {
        new Bucket(this, "MyFirstBucket");
    }
}
Go
func MyFirstStack(scope constructs.Construct, id string, props *MyFirstStackProps) awscdk.Stack {
  var sprops awscdk.StackProps
  if props != nil {
    sprops = props.StackProps
  }
  stack := awscdk.NewStack(scope, &id, &sprops)
	
  s3.NewBucket(stack, jsii.String("MyFirstBucket"), &s3.BucketProps{})
  return stack
}

ただし、このコードではスタックを宣言しただけです。 AWS CloudFormation スタックを実際にテンプレートに統合してデプロイするには、スタックをインスタンス化する必要があります。また、すべての CDK コンストラクトと同様に、何らかのコンテキストでインスタンス化する必要があります。Appこれがそのコンテキストです。

AWS CDK 標準開発テンプレートを使用している場合、スタックはオブジェクトをインスタンス化したのと同じファイルにインスタンス化されます。App

TypeScript

プロジェクトのフォルダーにある、プロジェクトにちなんだ名前 (例:hello-cdk.ts) のファイル。bin

JavaScript

binプロジェクトのフォルダーにある、プロジェクトにちなんだ名前 (例:hello-cdk.js) のファイル。

Python

app.pyプロジェクトのメインディレクトリにあるファイル。

Java

たとえばProjectNameApp.javaHelloCdkApp.java、という名前のファイルは、src/mainディレクトリの奥深くにネストされています。

C#

たとえばsrc\ProjectNamesrc\HelloCdk\Program.cs、Program.cs以下の名前のファイル。

スタック API

Stack オブジェクトには、次のような豊富な API が用意されています。

  • Stack.of(construct)— コンストラクトが定義されている Stack を返す静的メソッド。これは、再利用可能なコンストラクト内からスタックを操作する必要がある場合に便利です。スコープ内にスタックが見つからない場合、呼び出しは失敗します。

  • stack.stackName(Python:stack_name) — スタックの物理名を返します。前述のように、 AWS CDK AWS CDK すべてのスタックには合成時に解決できる物理名があります。

  • stack.regionと stack.account — AWS このスタックがデプロイされるリージョンとアカウントをそれぞれ返します。これらのプロパティは以下のいずれかを返します。

    • スタックの定義時に明示的に指定されたアカウントまたはリージョン。

    • AWS CloudFormation このスタックが環境に依存しないことを示すために、アカウントとリージョンの疑似パラメータに変換される文字列でエンコードされたトークン

    スタックの環境がどのように決定されるかについては、を参照してください。環境

  • stack.addDependency(stack)(Python: stack.add_dependency(stack) — 2 つのスタック間の依存順序を明示的に定義するために使用できます。複数のスタックを一度にデプロイする場合、cdk deployコマンドはこの順序を尊重します。

  • stack.tags— TagManagerスタックレベルのタグを追加または削除するために使用できるを返します。このタグマネージャーは、スタック内のすべてのリソースにタグを付け、作成したスタック自体にもタグを付けます。 AWS CloudFormation

  • stack.partition、stack.urlSuffix (Python:url_suffix)、stack.stackId (Python:stack_id)、stack.notificationArn (Python:notification_arn) — AWS CloudFormation のようなそれぞれの疑似パラメータに変換されるトークンを返します。{ "Ref": "AWS::Partition" }これらのトークンは特定のスタックオブジェクトに関連付けられるため、 AWS CDK フレームワークはスタック間の参照を識別できます。

  • stack.availabilityZones(Python:availability_zones) — このスタックがデプロイされている環境で利用可能なアベイラビリティーゾーンのセットを返します。環境に依存しないスタックの場合、これは常に 2 つのアベイラビリティーゾーンを含む配列を返します。環境固有のスタックの場合、 AWS CDK は環境にクエリを実行し、指定したリージョンで使用可能なアベイラビリティーゾーンの正確なセットを返します。

  • stack.parseArn(arn)および stack.formatArn(comps) (Python:parse_arn,format_arn) — Amazon リソースネーム (ARN) を操作するために使用できます。

  • stack.toJsonString(obj)(Python:to_json_string) — 任意のオブジェクトを JSON 文字列としてフォーマットし、 AWS CloudFormation テンプレートに埋め込むことができます。オブジェクトにはトークン、属性、参照を含めることができますが、これらはデプロイ時にのみ解決されます。

  • stack.templateOptions(Python:template_options) — スタックの変換、説明、 AWS CloudFormation メタデータなどのテンプレートオプションを指定するために使用します。

スタックの操作

CDK アプリ内のすべてのスタックを一覧表示するには、コマンドを使用します。cdk ls前の例では次のように出力されます。

stack1
stack2

AWS CloudFormation AWS スタックはスタックの一部として環境にデプロイされます。環境は特定の AND を対象としています AWS アカウント 。 AWS リージョン

cdk synth複数のスタックがあるアプリケーションに対してコマンドを実行すると、クラウドアセンブリにはスタックインスタンスごとに個別のテンプレートが含まれます。2 つのスタックが同じクラスのインスタンスであっても、は 2 AWS CDK つの個別のテンプレートとして出力します。

コマンドでスタック名を指定することで、各テンプレートを合成できます。cdk synth次の例では stack1 のテンプレートを合成しています。

$ cdk synth stack1

このアプローチは、 AWS CloudFormation テンプレートを複数回デプロイし、パラメーターを使用してパラメーター化できる通常のテンプレートの使用方法とは概念的に異なります。AWS CloudFormation AWS CloudFormation パラメータはで定義できますが、パラメータは展開中にのみ解決されるため AWS CDK AWS CloudFormation 、一般的には推奨されません。つまり、コード内でその値を判断することはできないということです。

たとえば、パラメータ値に基づいて条件付きでリソースをアプリに組み込むには、AWS CloudFormation 条件を設定してリソースにタグを付ける必要があります。は、 AWS CDK 具体的なテンプレートを合成時に解決するというアプローチを採用しています。そのため、if ステートメントを使用して値をチェックし、リソースを定義すべきか、何らかの動作を適用すべきかを判断できます。

注記

AWS CDK これにより、合成時にできる限り高い分解能が得られ、プログラミング言語を慣用的かつ自然に使用できるようになります。

他の構成と同様に、スタックはまとめてグループにまとめることができます。以下のコードは、コントロールプレーン、データプレーン、モニタリングスタックの 3 つのスタックで構成されるサービスの例を示しています。サービス構成は 2 回定義されます。1 回はベータ環境用、もう 1 回は本番環境用です。

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 このアプリは最終的に環境ごとに 3 つずつ、合計 6 つのスタックで構成されます。

$ cdk ls
    
betacpDA8372D3
betadataE23DB2BA
betamon632BD457
prodcp187264CE
proddataF7378CE5
prodmon631A1083

AWS CloudFormation スタックの物理名は、 AWS CDK ツリー内のスタックのコンストラクトパスに基づいて自動的に決定されます。デフォルトでは、Stackスタックの名前はオブジェクトのコンストラクト ID から派生します。ただし、次のように stackName prop (Python ではstack_name) を使用して明示的な名前を指定できます。

TypeScript
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });
JavaScript
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });
Python
MyStack(self, "not:a:stack:name", stack_name="this-is-stack-name")
Java
new MyStack(this, "not:a:stack:name", StackProps.builder()
    .StackName("this-is-stack-name").build());
C#
new MyStack(this, "not:a:stack:name", new StackProps
{
    StackName = "this-is-stack-name"
});

ネストされたスタック

NestedStackこの構造は、スタックの AWS CloudFormation 500 リソースの制限を回避する方法を提供します。ネストされたスタックは、そのスタックを含むスタック内の 1 つのリソースとしてのみカウントされます。ただし、追加のネストされたスタックを含め、最大 500 個のリソースを含むことができます。

ネストされたスタックのスコープは OR コンストラクトでなければなりません。Stack NestedStackネストされたスタックは、親スタック内で字句的に宣言する必要はありません。ネストされたスタックをインスタンス化するときに、親スタックを最初のパラメーター (scope) として渡すだけで済みます。この制限を除けば、ネストされたスタックでのコンストラクトの定義は、通常のスタックとまったく同じように機能します。

合成時に、 AWS CloudFormation ネストされたスタックは独自のテンプレートに合成され、 AWS CDK デプロイ時にステージングバケットにアップロードされます。ネストされたスタックは親スタックにバインドされ、独立したデプロイアーティファクトとしては扱われません。これらはによって一覧表示されずcdk list、によるデプロイもできません。cdk deploy

親スタックとネストされたスタックの間の参照は、他のクロススタック参照と同様に、 AWS CloudFormation 生成されたテンプレートのスタックパラメータと出力に自動的に変換されます。

警告

セキュリティ体制の変更は、ネストされたスタックのデプロイ前には表示されません。この情報は最上位のスタックにのみ表示されます。