AWS CDK スタック - AWS Cloud Development Kit (AWS CDK) v2
スタックを定義する方法 スタックの操作

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

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

AWS CDK スタック

AWS Cloud Development Kit (AWS CDK) スタックは、 AWS リソースを定義する 1 つ以上のコンストラクトのコレクションです。各CDKスタックは、CDKアプリ内の AWS CloudFormation スタックを表します。デプロイ時に、スタック内のコンストラクトは、 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。次に、受信した 、、scopeidおよび superで を使用してベースStackクラスコンストラクタを呼び出します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

プロジェクトのbinフォルダ内のプロジェクトにちなんで名付けられたファイル (例: hello-cdk.ts）。

JavaScript

プロジェクトのbinフォルダ内のプロジェクトにちなんで名付けられたファイル (例: hello-cdk.js）。

Python

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

Java

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

C#

Program.cs という名前のファイルsrc\ProjectName。例: src\HelloCdk\Program.cs。

スタック API

スタックオブジェクトはAPI、以下を含む豊富な を提供します。

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

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

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

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

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

    スタックの環境の決定方法については、「」を参照してくださいの環境 AWS CDK。

  • 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 リソースネーム () の操作に使用できますARNs。

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

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

スタックの操作

スタックは、 AWS CloudFormation スタックの一部として AWS 環境 にデプロイされます。環境は、特定の 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 アプリは最終的に 6 つのスタックで構成され、環境ごとに 3 つになります。

$ cdk ls
    
betacpDA8372D3
betadataE23DB2BA
betamon632BD457
prodcp187264CE
proddataF7378CE5
prodmon631A1083

AWS CloudFormation スタックの物理名は、ツリー内のスタックのコンストラクトパス AWS CDK に基づいて によって自動的に決定されます。デフォルトでは、スタックの名前は Stack オブジェクトのコンストラクト ID から取得されます。ただし、次のように prop (Python では stackName 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 個のリソースを含めることができます。

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

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

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

警告

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