Wählen Sie Ihre Cookie-Einstellungen aus

Wir verwenden essentielle Cookies und ähnliche Tools, die für die Bereitstellung unserer Website und Services erforderlich sind. Wir verwenden Performance-Cookies, um anonyme Statistiken zu sammeln, damit wir verstehen können, wie Kunden unsere Website nutzen, und Verbesserungen vornehmen können. Essentielle Cookies können nicht deaktiviert werden, aber Sie können auf „Anpassen“ oder „Ablehnen“ klicken, um Performance-Cookies abzulehnen.

Wenn Sie damit einverstanden sind, verwenden AWS und zugelassene Drittanbieter auch Cookies, um nützliche Features der Website bereitzustellen, Ihre Präferenzen zu speichern und relevante Inhalte, einschließlich relevanter Werbung, anzuzeigen. Um alle nicht notwendigen Cookies zu akzeptieren oder abzulehnen, klicken Sie auf „Akzeptieren“ oder „Ablehnen“. Um detailliertere Entscheidungen zu treffen, klicken Sie auf „Anpassen“.

Einführung in AWS CDK Stacks

Fokusmodus

Auf dieser Seite

Einführung in AWS CDK Stacks - AWS Cloud Development Kit (AWS CDK) v2

Dies ist der AWS CDK v2-Entwicklerhandbuch. Die ältere CDK Version 1 wurde am 1. Juni 2022 in die Wartung aufgenommen und der Support wurde am 1. Juni 2023 eingestellt.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Dies ist der AWS CDK v2-Entwicklerhandbuch. Die ältere CDK Version 1 wurde am 1. Juni 2022 in die Wartung aufgenommen und der Support wurde am 1. Juni 2023 eingestellt.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Ein AWS CDK Stack ist die kleinste einzelne Bereitstellungseinheit. Er stellt eine Sammlung von AWS Ressourcen dar, die Sie mithilfe von CDK Konstrukten definieren. Wenn Sie CDK Apps bereitstellen, werden die Ressourcen innerhalb eines CDK Stacks zusammen als AWS CloudFormation Stapel bereitgestellt. Weitere Informationen zu AWS CloudFormation Stacks finden Sie im AWS CloudFormation Benutzerhandbuch unter AWSRessourcen als eine Einheit mit AWS CloudFormation Stacks verwalten.

Sie definieren einen Stapel, indem Sie das Konstrukt erweitern oder von ihm erben. Stack Das folgende Beispiel ist ein gängiges Muster für die Definition eines CDK Stacks in einer separaten Datei, einer sogenannten Stack-Datei. Hier erweitern oder erben wir die Stack Klasse und definieren einen Konstruktor, der scopeid, und akzeptiert. props Dann rufen wir den Stack Basisklassenkonstruktor auf, indem wir super mit den empfangenenscope,, und: id 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) } //...
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 } }

Das vorherige Beispiel hat nur einen Stack definiert. Um den Stack zu erstellen, muss er im Kontext Ihrer CDK App instanziiert werden. Ein gängiges Muster besteht darin, Ihre CDK App zu definieren und Ihren Stack in einer separaten Datei zu initialisieren, die als Anwendungsdatei bezeichnet wird.

Im Folgenden finden Sie ein Beispiel, das einen CDK Stack mit dem Namen MyCdkStack erstellt. Hier wird die CDK App erstellt und MyCdkStack im Kontext der App instanziiert:

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

Befindet sich in: app.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) } // ...
#!/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', { });

Im folgenden Beispiel wird eine CDK App erstellt, die zwei Stapel enthält:

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) } // ...
const app = new App(); new MyFirstStack(app, 'stack1'); new MySecondStack(app, 'stack2'); app.synth();

Über den Stapel API

Das Stack Objekt bietet umfangreiche API Funktionen, darunter Folgendes:

  • Stack.of(construct)— Eine statische Methode, die den Stack zurückgibt, in dem ein Konstrukt definiert ist. Dies ist nützlich, wenn Sie innerhalb eines wiederverwendbaren Konstrukts mit einem Stapel interagieren müssen. Der Aufruf schlägt fehl, wenn ein Stack im Gültigkeitsbereich nicht gefunden werden kann.

  • stack.stackName(Python:stack_name) — Gibt den physischen Namen des Stacks zurück. Wie bereits erwähnt, haben alle AWS CDK Stacks einen physikalischen Namen, den sie während der Synthese auflösen AWS CDK können.

  • stack.regionund stack.account — Gibt die AWS Region bzw. das Konto zurück, in dem dieser Stack bereitgestellt werden soll. Diese Eigenschaften geben einen der folgenden Werte zurück:

    • Das Konto oder die Region, das bei der Definition des Stacks explizit angegeben wurde

    • Ein string-codiertes Token, das in die AWS CloudFormation Pseudo-Parameter für Account und Region aufgelöst wird, um anzuzeigen, dass dieser Stack umgebungsunabhängig ist

    Hinweise dazu, wie Umgebungen für Stacks bestimmt werden, finden Sie unter. Umgebungen für die AWS CDK

  • stack.addDependency(stack)(Python: stack.add_dependency(stack) — Kann verwendet werden, um die Reihenfolge der Abhängigkeiten zwischen zwei Stacks explizit zu definieren. Diese Reihenfolge wird vom cdk deploy Befehl respektiert, wenn mehrere Stacks gleichzeitig bereitgestellt werden.

  • stack.tags— Gibt einen zurück TagManager, den Sie zum Hinzufügen oder Entfernen von Tags auf Stackebene verwenden können. Dieser Tag-Manager markiert alle Ressourcen innerhalb des Stacks und markiert auch den Stack selbst, wenn er durch diesen erstellt wird. AWS CloudFormation

  • stack.partition, stack.urlSuffix (Python:url_suffix), stack.stackId (Python:stack_id) und stack.notificationArn (Python:notification_arn) — Gibt Tokens zurück, die in die jeweiligen AWS CloudFormation Pseudo-Parameter aufgelöst werden, wie { "Ref": "AWS::Partition" } z. Diese Token sind dem spezifischen Stack-Objekt zugeordnet, sodass das AWS CDK Framework stapelübergreifende Referenzen identifizieren kann.

  • stack.availabilityZones(Python:availability_zones) — Gibt den Satz von Availability Zones zurück, die in der Umgebung verfügbar sind, in der dieser Stack bereitgestellt wird. Bei umgebungsunabhängigen Stacks wird dadurch immer ein Array mit zwei Availability Zones zurückgegeben. Bei umgebungsspezifischen Stacks AWS CDK fragt das System die Umgebung ab und gibt genau den Satz von Availability Zones zurück, die in der von Ihnen angegebenen Region verfügbar sind.

  • stack.parseArn(arn)und stack.formatArn(comps) (Python:parse_arn,format_arn) — Kann verwendet werden, um mit Amazon Resource Names (ARNs) zu arbeiten.

  • stack.toJsonString(obj)(Python:to_json_string) — Kann verwendet werden, um ein beliebiges Objekt als JSON Zeichenfolge zu formatieren, die in eine AWS CloudFormation Vorlage eingebettet werden kann. Das Objekt kann Token, Attribute und Verweise enthalten, die nur während der Bereitstellung aufgelöst werden.

  • stack.templateOptions(Python:template_options) — Wird verwendet, um AWS CloudFormation Vorlagenoptionen wie Transformation, Beschreibung und Metadaten für Ihren Stack anzugeben.

Arbeiten mit -Stacks

Stacks werden als AWS CloudFormation Stapel in einer AWS Umgebung bereitgestellt. Die Umgebung deckt ein bestimmtes AWS-Konto und AWS-Region ab.

Wenn Sie den cdk synth Befehl für eine App mit mehreren Stacks ausführen, enthält die Cloud-Assembly eine separate Vorlage für jede Stack-Instanz. Selbst wenn es sich bei den beiden Stacks um Instanzen derselben Klasse handelt, werden sie als zwei einzelne AWS CDK Vorlagen ausgegeben.

Sie können jede Vorlage synthetisieren, indem Sie den Stacknamen im Befehl angeben. cdk synth Das folgende Beispiel synthetisiert die Vorlage für: stack1

$ cdk synth stack1

Dieser Ansatz unterscheidet sich konzeptionell von der üblichen Verwendung von AWS CloudFormation Vorlagen, bei der eine Vorlage mehrfach bereitgestellt und über Parameter parametrisiert werden kann.AWS CloudFormation AWS CloudFormation Parameter können zwar in der definiert werden AWS CDK, es wird jedoch generell davon abgeraten, da AWS CloudFormation Parameter erst während der Bereitstellung aufgelöst werden. Das bedeutet, dass Sie ihren Wert nicht in Ihrem Code bestimmen können.

Um beispielsweise eine Ressource auf der Grundlage eines Parameterwerts bedingt in Ihre App aufzunehmen, müssen Sie eine AWS CloudFormation Bedingung einrichten und die Ressource damit kennzeichnen. Dabei wird AWS CDK ein Ansatz verfolgt, bei dem konkrete Vorlagen zum Zeitpunkt der Synthese aufgelöst werden. Daher können Sie mithilfe einer if Anweisung den Wert überprüfen, um festzustellen, ob eine Ressource definiert oder ein bestimmtes Verhalten angewendet werden sollte.

Anmerkung

Das AWS CDK bietet während der Synthesedauer so viel Auflösung wie möglich, um eine idiomatische und natürliche Verwendung Ihrer Programmiersprache zu ermöglichen.

Wie jedes andere Konstrukt können Stapel zu Gruppen zusammengesetzt werden. Der folgende Code zeigt ein Beispiel für einen Service, der aus drei Stacks besteht: einer Steuerungsebene, einer Datenebene und Monitoring-Stacks. Das Dienstkonstrukt ist zweimal definiert: einmal für die Betaumgebung und einmal für die Produktionsumgebung.

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

Diese AWS CDK App besteht letztendlich aus sechs Stacks, drei für jede Umgebung:

$ cdk ls betacpDA8372D3 betadataE23DB2BA betamon632BD457 prodcp187264CE proddataF7378CE5 prodmon631A1083

Die physikalischen Namen der AWS CloudFormation Stapel werden automatisch AWS CDK anhand des Konstruktpfads des Stacks im Baum bestimmt. Standardmäßig wird der Name eines Stacks von der Konstrukt-ID des Stack Objekts abgeleitet. Sie können jedoch einen expliziten Namen angeben, indem Sie die stackName Requisite (in Python,stack_name) wie folgt verwenden.

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" });
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });

Arbeiten mit verschachtelten Stacks

Ein verschachtelter Stapel ist ein CDK Stapel, den Sie in einem anderen Stapel erstellen, der als übergeordneter Stapel bezeichnet wird. Sie erstellen verschachtelte Stapel mithilfe des Konstrukts. NestedStack

Durch die Verwendung verschachtelter Stacks können Sie Ressourcen auf mehrere Stapel verteilen. Verschachtelte Stapel bieten auch eine Möglichkeit, das Limit von 500 Ressourcen für Stapel zu umgehen. AWS CloudFormation Ein verschachtelter Stapel zählt nur als eine Ressource in dem Stapel, der ihn enthält. Er kann jedoch bis zu 500 Ressourcen enthalten, einschließlich zusätzlicher verschachtelter Stacks.

Der Gültigkeitsbereich eines verschachtelten Stacks muss ein Stack Oder-Konstrukt sein. NestedStack Der verschachtelte Stapel muss innerhalb seines übergeordneten Stacks nicht lexikalisch deklariert werden. Bei der Instanziierung des verschachtelten Stacks muss nur der übergeordnete Stapel als ersten Parameter (scope) übergeben werden. Abgesehen von dieser Einschränkung funktioniert die Definition von Konstrukten in einem verschachtelten Stack genauso wie in einem normalen Stack.

Zum Zeitpunkt der Synthese wird der verschachtelte Stack zu einer eigenen AWS CloudFormation Vorlage synthetisiert, die bei der Bereitstellung in den AWS CDK Staging-Bucket hochgeladen wird. Verschachtelte Stacks sind an ihren übergeordneten Stapel gebunden und werden nicht als unabhängige Bereitstellungsartefakte behandelt. Sie sind nicht in der Liste aufgeführt und können auch nicht von cdk list bereitgestellt werden. cdk deploy

Verweise zwischen übergeordneten Stacks und verschachtelten Stacks werden automatisch in Stack-Parameter und Ausgaben in den generierten AWS CloudFormation Vorlagen übersetzt, wie bei jeder stapelübergreifenden Referenz.

Warnung

Änderungen der Sicherheitslage werden vor der Bereitstellung für verschachtelte Stacks nicht angezeigt. Diese Informationen werden nur für Stacks der obersten Ebene angezeigt.

DatenschutzNutzungsbedingungen für die WebsiteCookie-Einstellungen
© 2025, Amazon Web Services, Inc. oder Tochtergesellschaften. Alle Rechte vorbehalten.