Über den Stapel API Arbeiten mit -Stacks

Einführung in AWS CDK Stacks

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

//...

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:

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

Ü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)
}

// ...

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.

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.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Apps

CDKStufen