Pengantar AWS CDK tumpukan

Mode fokus

Pengantar AWS CDK tumpukan - AWS Cloud Development Kit (AWS CDK) v2

Ini adalah Panduan Pengembang AWS CDK v2. CDK v1 yang lebih lama memasuki pemeliharaan pada 1 Juni 2022 dan mengakhiri dukungan pada 1 Juni 2023.

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Ini adalah Panduan Pengembang AWS CDK v2. CDK v1 yang lebih lama memasuki pemeliharaan pada 1 Juni 2022 dan mengakhiri dukungan pada 1 Juni 2023.

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

AWS CDK Tumpukan adalah unit tunggal terkecil dari penyebaran. Ini merupakan kumpulan AWS sumber daya yang Anda tentukan menggunakan konstruksi CDK. Saat Anda menerapkan aplikasi CDK, sumber daya dalam tumpukan CDK akan digunakan bersama sebagai tumpukan. AWS CloudFormation Untuk mempelajari lebih lanjut tentang AWS CloudFormation tumpukan, lihat Mengelola sumber daya AWS sebagai satu unit dengan AWS CloudFormation tumpukan di AWS CloudFormation Panduan Pengguna.

Anda mendefinisikan tumpukan dengan memperluas atau mewarisi dari konstruksi. Stack Contoh berikut adalah pola umum untuk mendefinisikan tumpukan CDK pada file terpisah, yang dikenal sebagai file tumpukan. Di sini, kita memperluas atau mewarisi Stack kelas dan mendefinisikan konstruktor yang menerimascope,, id dan. props Kemudian, kita memanggil konstruktor Stack kelas dasar menggunakan super dengan yang diterimascope,id, dan: props

TypeScript


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class MyCdkStack extends cdk.Stack { 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) { 
    super(scope, id, props); 
    
    // Define your constructs here

  }
}

JavaScript


const { Stack } = require('aws-cdk-lib');

class MyCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define your constructs here

  }
}

module.exports = { MyCdkStack }

Python


from aws_cdk import (
  Stack,
)
from constructs import Construct

class MyCdkStack(Stack):

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

    # Define your constructs here

Java


package com.myorg;

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

public class MyCdkStack extends Stack {
  public MyCdkStack(final Construct scope, final String id) {  
    this(scope, id, null);
  }
  
  public MyCdkStack(final Construct scope, final String id, final StackProps props) {
    super(scope, id, props);

    // Define your constructs here
  }
}

C#


using Amazon.CDK; 
using Constructs;

namespace MyCdk
{
  public class MyCdkStack : Stack
  {
    internal MyCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
    {
      // Define your constructs here
    }
  }
}

Go


package main

import (
	"github.com/aws/aws-cdk-go/awscdk/v2"
	"github.com/aws/constructs-go/constructs/v10"
	"github.com/aws/jsii-runtime-go"
)

type CdkDemoAppStackProps struct {
	awscdk.StackProps
}

func NewCdkDemoAppStack(scope constructs.Construct, id string, props *CdkDemoAppStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	stack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	return stack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	NewCdkDemoAppStack(app, "CdkDemoAppStack", &CdkDemoAppStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	app.Synth(nil)
} 

//...

anchor anchor anchor anchor anchor anchor


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class MyCdkStack extends cdk.Stack { 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) { 
    super(scope, id, props); 
    
    // Define your constructs here

  }
}

Contoh sebelumnya hanya mendefinisikan tumpukan. Untuk membuat tumpukan, itu harus dipakai dalam konteks aplikasi CDK Anda. Pola umum adalah mendefinisikan aplikasi CDK Anda dan menginisialisasi tumpukan Anda pada file terpisah, yang dikenal sebagai file aplikasi.

Berikut ini adalah contoh yang membuat tumpukan CDK bernamaMyCdkStack. Di sini, aplikasi CDK MyCdkStack dibuat dan dipakai dalam konteks aplikasi:

anchor anchor anchor anchor anchor anchor


#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { MyCdkStack } from '../lib/my-cdk-stack';

const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});

Contoh berikut membuat aplikasi CDK yang berisi dua tumpukan:

anchor anchor anchor anchor anchor anchor


const app = new App();

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

app.synth();

Tentang stack API

StackObjek menyediakan API kaya, termasuk yang berikut ini:

Stack.of(construct)— Metode statis yang mengembalikan Stack di mana konstruksi didefinisikan. Ini berguna jika Anda perlu berinteraksi dengan tumpukan dari dalam konstruksi yang dapat digunakan kembali. Panggilan gagal jika tumpukan tidak dapat ditemukan dalam ruang lingkup.
stack.stackName(Python:stack_name) — Mengembalikan nama fisik tumpukan. Seperti disebutkan sebelumnya, semua AWS CDK tumpukan memiliki nama fisik yang AWS CDK dapat diselesaikan selama sintesis.
stack.regiondan stack.account — Kembalikan AWS Wilayah dan akun, masing-masing, ke mana tumpukan ini akan digunakan. Properti ini mengembalikan salah satu dari yang berikut:
- Akun atau Wilayah secara eksplisit ditentukan saat tumpukan ditentukan
- Token yang disandikan string yang menyelesaikan parameter AWS CloudFormation semu untuk akun dan Wilayah untuk menunjukkan bahwa tumpukan ini adalah lingkungan agnostik
Untuk informasi tentang bagaimana lingkungan ditentukan untuk tumpukan, lihatLingkungan untuk AWS CDK.
stack.addDependency(stack)(Python: stack.add_dependency(stack) — Dapat digunakan untuk secara eksplisit mendefinisikan urutan ketergantungan antara dua tumpukan. Urutan ini dihormati oleh cdk deploy perintah saat menerapkan beberapa tumpukan sekaligus.
stack.tags— Mengembalikan TagManageryang dapat Anda gunakan untuk menambah atau menghapus tag tingkat tumpukan. Manajer tag ini menandai semua sumber daya di dalam tumpukan, dan juga menandai tumpukan itu sendiri saat dibuat AWS CloudFormation.
stack.partition, stack.urlSuffix (Python:url_suffix), (stack.stackIdPython:stack_id), dan (stack.notificationArnPython:notification_arn) — Kembalikan token yang menyelesaikan parameter semu masing-masing AWS CloudFormation , seperti. { "Ref": "AWS::Partition" } Token ini dikaitkan dengan objek tumpukan tertentu sehingga AWS CDK kerangka kerja dapat mengidentifikasi referensi cross-stack.
stack.availabilityZones(Python:availability_zones) — Mengembalikan set Availability Zones yang tersedia di lingkungan tempat tumpukan ini digunakan. Untuk tumpukan agnostik lingkungan, ini selalu mengembalikan array dengan dua Availability Zones. Untuk tumpukan khusus lingkungan, AWS CDK kueri lingkungan dan menampilkan set persis Availability Zone yang tersedia di Wilayah yang Anda tentukan.
stack.parseArn(arn)dan stack.formatArn(comps) (Python:parse_arn,format_arn) - Dapat digunakan untuk bekerja dengan Amazon Resource Names ()ARNs.
stack.toJsonString(obj)(Python:to_json_string) - Dapat digunakan untuk memformat objek arbitrer sebagai string JSON yang dapat disematkan dalam template. AWS CloudFormation Objek dapat menyertakan token, atribut, dan referensi, yang hanya diselesaikan selama penerapan.
stack.templateOptions(Python:template_options) — Gunakan untuk menentukan opsi AWS CloudFormation template, seperti Transform, Description, dan Metadata, untuk tumpukan Anda.

Menggunakan tumpukan

Tumpukan digunakan sebagai AWS CloudFormation tumpukan ke lingkungan AWS . Lingkungan mencakup spesifik Akun AWS dan Wilayah AWS.

Saat Anda menjalankan cdk synth perintah untuk aplikasi dengan beberapa tumpukan, rakitan cloud menyertakan templat terpisah untuk setiap instance tumpukan. Bahkan jika dua tumpukan adalah contoh dari kelas yang sama, AWS CDK memancarkannya sebagai dua templat individual.

Anda dapat mensintesis setiap template dengan menentukan nama tumpukan dalam perintah. cdk synth Contoh berikut mensintesis template untukstack1:


$ cdk synth stack1

Pendekatan ini secara konseptual berbeda dari bagaimana AWS CloudFormation template biasanya digunakan, di mana template dapat digunakan beberapa kali dan diparameterisasi melalui parameter.AWS CloudFormation Meskipun AWS CloudFormation parameter dapat didefinisikan dalam AWS CDK, mereka umumnya tidak disarankan karena AWS CloudFormation parameter diselesaikan hanya selama penerapan. Ini berarti Anda tidak dapat menentukan nilainya dalam kode Anda.

Misalnya, untuk menyertakan sumber daya secara kondisional di aplikasi berdasarkan nilai parameter, Anda harus menyiapkan AWS CloudFormation kondisi dan menandai sumber daya dengannya. Ini AWS CDK mengambil pendekatan di mana templat konkret diselesaikan pada waktu sintesis. Oleh karena itu, Anda dapat menggunakan if pernyataan untuk memeriksa nilai untuk menentukan apakah sumber daya harus didefinisikan atau beberapa perilaku harus diterapkan.

catatan

AWS CDK Ini memberikan resolusi sebanyak mungkin selama waktu sintesis untuk memungkinkan penggunaan bahasa pemrograman Anda secara idiomatik dan alami.

Seperti konstruksi lainnya, tumpukan dapat disusun bersama menjadi beberapa kelompok. Kode berikut menunjukkan contoh layanan yang terdiri dari tiga tumpukan: bidang kontrol, bidang data, dan tumpukan pemantauan. Konstruksi layanan didefinisikan dua kali: sekali untuk lingkungan beta dan sekali untuk lingkungan produksi.

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();
    }
}

Go


package main

import (
	"github.com/aws/aws-cdk-go/awscdk/v2"
	"github.com/aws/constructs-go/constructs/v10"
	"github.com/aws/jsii-runtime-go"
)

type ControlPlaneStackProps struct {
	awscdk.StackProps
}

func NewControlPlaneStack(scope constructs.Construct, id string, props *ControlPlaneStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	ControlPlaneStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return ControlPlaneStack
}

type DataPlaneStackProps struct {
	awscdk.StackProps
}

func NewDataPlaneStack(scope constructs.Construct, id string, props *DataPlaneStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	DataPlaneStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return DataPlaneStack
}

type MonitoringStackProps struct {
	awscdk.StackProps
}

func NewMonitoringStack(scope constructs.Construct, id string, props *MonitoringStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	MonitoringStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	// The code that defines your stack goes here

	return MonitoringStack
}

type MyServiceStackProps struct {
	awscdk.StackProps
	Prod bool
}

func NewMyServiceStack(scope constructs.Construct, id string, props *MyServiceStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	MyServiceStack := awscdk.NewStack(scope, jsii.String(id), &sprops)

	NewControlPlaneStack(MyServiceStack, "cp", &ControlPlaneStackProps{
		StackProps: sprops,
	})
	NewDataPlaneStack(MyServiceStack, "data", &DataPlaneStackProps{
		StackProps: sprops,
	})
	NewMonitoringStack(MyServiceStack, "mon", &MonitoringStackProps{
		StackProps: sprops,
	})

	return MyServiceStack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	betaProps := MyServiceStackProps{
		StackProps: awscdk.StackProps{
			Env: env(),
		},
		Prod: false,
	}

	NewMyServiceStack(app, "beta", &betaProps)

	prodProps := MyServiceStackProps{
		StackProps: awscdk.StackProps{
			Env: env(),
		},
		Prod: true,
	}

	NewMyServiceStack(app, "prod", &prodProps)

	app.Synth(nil)
}

// ...

anchor anchor anchor anchor anchor anchor


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();

AWS CDK Aplikasi ini akhirnya terdiri dari enam tumpukan, tiga untuk setiap lingkungan:


$ cdk ls
    
betacpDA8372D3
betadataE23DB2BA
betamon632BD457
prodcp187264CE
proddataF7378CE5
prodmon631A1083

Nama fisik AWS CloudFormation tumpukan secara otomatis ditentukan oleh AWS CDK berdasarkan jalur konstruksi tumpukan di pohon. Secara default, nama tumpukan berasal dari ID konstruksi Stack objek. Namun, Anda dapat menentukan nama eksplisit dengan menggunakan stackName prop (dalam Python,stack_name), sebagai berikut.

anchor anchor anchor anchor anchor


new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });

Bekerja dengan tumpukan nest

Tumpukan bersarang adalah tumpukan CDK yang Anda buat di dalam tumpukan lain, yang dikenal sebagai tumpukan induk. Anda membuat tumpukan bersarang menggunakan konstruksi. NestedStack

Dengan menggunakan tumpukan bersarang, Anda dapat mengatur sumber daya di beberapa tumpukan. Tumpukan bersarang juga menawarkan jalan di sekitar batas AWS CloudFormation 500 sumber daya untuk tumpukan. Tumpukan bersarang dihitung sebagai hanya satu sumber daya di tumpukan yang berisi itu. Namun, dapat berisi hingga 500 sumber daya, termasuk tumpukan bersarang tambahan.

Ruang lingkup tumpukan bersarang harus berupa Stack atau NestedStack konstruksi. Tumpukan bersarang tidak perlu dideklarasikan secara leksikal di dalam tumpukan induknya. Anda hanya perlu meneruskan tumpukan induk sebagai parameter pertama (scope) saat membuat instance tumpukan bersarang. Selain pembatasan ini, mendefinisikan konstruksi dalam tumpukan bersarang bekerja persis sama seperti di tumpukan biasa.

Pada waktu sintesis, tumpukan bersarang disintesis ke AWS CloudFormation templatnya sendiri, yang diunggah ke bucket AWS CDK pementasan saat penerapan. Tumpukan bersarang terikat pada tumpukan induknya dan tidak diperlakukan sebagai artefak penerapan independen. Mereka tidak terdaftar olehcdk list, dan mereka tidak dapat digunakan olehcdk deploy.

Referensi antara tumpukan induk dan tumpukan bersarang secara otomatis diterjemahkan ke parameter tumpukan dan output dalam AWS CloudFormation templat yang dihasilkan, seperti halnya referensi tumpukan silang.