Ini adalah Panduan Pengembang AWS CDK v2. CDKV1 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.
Pengantar AWS CDK tumpukan
AWS CDK Tumpukan adalah unit tunggal terkecil dari penyebaran. Ini merupakan kumpulan sumber AWS daya yang Anda definisikan menggunakan CDK konstruksi. Saat Anda menerapkan CDK aplikasi, sumber daya dalam CDK tumpukan akan digunakan bersama sebagai AWS CloudFormation tumpukan. Untuk mempelajari lebih lanjut tentang AWS CloudFormation tumpukan, lihat Mengelola AWS sumber daya 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 CDK tumpukan 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)
}
//...
Contoh sebelumnya hanya mendefinisikan tumpukan. Untuk membuat tumpukan, tumpukan harus dipakai dalam konteks aplikasi AndaCDK. Pola yang umum adalah mendefinisikan CDK aplikasi Anda dan menginisialisasi tumpukan Anda pada file terpisah, yang dikenal sebagai file aplikasi.
Berikut ini adalah contoh yang membuat CDK tumpukan bernamaMyCdkStack. Di sini, CDK aplikasi MyCdkStack dibuat dan dipakai dalam konteks aplikasi:
- TypeScript
-
#!/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', {
});
- JavaScript
-
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { MyCdkStack } = require('../lib/my-cdk-stack');
const app = new cdk.App();
new MyCdkStack(app, 'MyCdkStack', {
});
- Python
-
Terletak diapp.py:
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from my_cdk.my_cdk_stack import MyCdkStack
app = cdk.App()
MyCdkStack(app, "MyCdkStack",)
app.synth()
- Java
-
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
import java.util.Arrays;
public class MyCdkApp {
public static void main(final String[] args) {
App app = new App();
new MyCdkStack(app, "MyCdkStack", StackProps.builder()
.build());
app.synth();
}
}
- C#
-
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace MyCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new MyCdkStack(app, "MyCdkStack", new StackProps
{});
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"
)
// ...
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewMyCdkStack(app, "MyCdkStack", &MyCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
// ...
Contoh berikut membuat CDK aplikasi yang berisi dua tumpukan:
- 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();
- 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 MyFirstStackProps struct {
awscdk.StackProps
}
func NewMyFirstStack(scope constructs.Construct, id string, props *MyFirstStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
myFirstStack := awscdk.NewStack(scope, &id, &sprops)
// The code that defines your stack goes here
return myFirstStack
}
type MySecondStackProps struct {
awscdk.StackProps
}
func NewMySecondStack(scope constructs.Construct, id string, props *MySecondStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
mySecondStack := awscdk.NewStack(scope, &id, &sprops)
// The code that defines your stack goes here
return mySecondStack
}
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewMyFirstStack(app, "MyFirstStack", &MyFirstStackProps{
awscdk.StackProps{
Env: env(),
},
})
NewMySecondStack(app, "MySecondStack", &MySecondStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
// ...
Tentang tumpukan API
StackObjek menyediakan kayaAPI, termasuk yang berikut:
-
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 JSON string 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.
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)
}
// ...
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.
- 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"
});
Bekerja dengan tumpukan nest
Tumpukan bersarang adalah CDK tumpukan 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.
Perubahan postur keamanan tidak ditampilkan sebelum penerapan untuk tumpukan bersarang. Informasi ini hanya ditampilkan untuk tumpukan tingkat atas.
