Wo Sie Umgebungen angeben können Vorrang der Umgebung mit dem AWS CDK Wann müssen Umgebungen angegeben werden Wie spezifiziert man Umgebungen mit dem AWS CDK Überlegungen bei der Konfiguration von Umgebungen mit dem AWS CDK Beispiele

Konfigurieren Sie Umgebungen für die Verwendung mit dem AWS CDK

Sie können AWS Umgebungen auf verschiedene Arten konfigurieren, um sie mit dem zu verwenden AWS Cloud Development Kit (AWS CDK). Die beste Methode zur Verwaltung von AWS Umgebungen hängt von Ihren spezifischen Anforderungen ab.

Jeder CDK Stack in Ihrer Anwendung muss irgendwann einer Umgebung zugeordnet werden, um zu bestimmen, wo der Stack bereitgestellt wird.

Eine Einführung in AWS Umgebungen finden Sie unterUmgebungen für die AWS CDK.

Themen

Wo Sie Umgebungen angeben können
Vorrang der Umgebung mit dem AWS CDK
Wann müssen Umgebungen angegeben werden
Wie spezifiziert man Umgebungen mit dem AWS CDK
Überlegungen bei der Konfiguration von Umgebungen mit dem AWS CDK
Beispiele

Wo Sie Umgebungen angeben können

Sie können Umgebungen in Anmeldeinformationen und Konfigurationsdateien angeben oder indem Sie die env Eigenschaft des Stack Konstrukts aus der AWS Construct-Bibliothek verwenden.

Anmeldeinformationen und Konfigurationsdateien

Sie können das AWS Command Line Interface (AWS CLI) verwenden, um config Dateien zu erstellencredentials, in denen Ihre AWS Umgebungsinformationen gespeichert, organisiert und verwaltet werden. Weitere Informationen zu diesen Dateien finden Sie im AWS Command Line Interface Benutzerhandbuch unter Konfiguration und Einstellungen für Anmeldeinformationsdateien.

Die in diesen Dateien gespeicherten Werte sind nach Profilen organisiert. Wie Sie Ihre Profile und die Schlüssel-Wert-Paare in diesen Dateien benennen, hängt von Ihrer Methode zur Konfiguration des programmatischen Zugriffs ab. Weitere Informationen zu den verschiedenen Methoden finden Sie unter. Konfigurieren Sie Sicherheitsanmeldedaten für AWS CDKCLI

Im Allgemeinen AWS CDK löst der AWS-Konto Informationen aus Ihrer credentials Datei und AWS-Region Informationen aus Ihrer config Datei auf.

Sobald Sie Ihre credentials config Dateien konfiguriert haben, können Sie die Umgebung angeben, die mit dem verwendet werden soll AWS CDK CLI und durch Umgebungsvariablen.

env-Eigenschaft des Stack-Konstrukts

Sie können die Umgebung für jeden Stapel angeben, indem Sie die env Eigenschaft des Stack Konstrukts verwenden. Diese Eigenschaft definiert ein Konto und eine Region, die verwendet werden sollen. Sie können hartcodierte Werte an diese Eigenschaft übergeben oder Umgebungsvariablen übergeben, die von der CDK angeboten werden.

Um Umgebungsvariablen zu übergeben, verwenden Sie die AWS_DEFAULT_REGION Umgebungsvariablen AWS_DEFAULT_ACCOUNT und. Diese Umgebungsvariablen können Werte aus Ihren config Dateien credentials und übergeben. Sie können auch Logik in Ihrem CDK Code verwenden, um die Werte dieser Umgebungsvariablen zu bestimmen.

Vorrang der Umgebung mit dem AWS CDK

Wenn Sie mehrere Methoden zur Angabe von Umgebungen verwenden, gilt AWS CDK für die folgende Priorität:

Hartcodierte Werte, die mit der env Eigenschaft des Konstrukts angegeben werden. Stack
AWS_DEFAULT_ACCOUNTund AWS_DEFAULT_REGION Umgebungsvariablen, die mit der env Eigenschaft des Stack Konstrukts angegeben sind.
Dem Profil zugeordnete Umgebungsinformationen aus Ihren credentials und config Dateien, die an die übergeben wurden CDK CLI mit der --profile Option.
Das default Profil aus Ihren credentials und config Dateien.

Wann müssen Umgebungen angegeben werden

Wenn Sie mit dem entwickelnCDK, definieren Sie zunächst CDK Stacks, die Konstrukte enthalten, die Ressourcen repräsentieren AWS . Als Nächstes synthetisieren Sie jeden CDK Stapel zu einer Vorlage. AWS CloudFormation Anschließend stellen Sie die CloudFormation Vorlage in Ihrer Umgebung bereit. Wie Sie Umgebungen angeben, bestimmt, wann Ihre Umgebungsinformationen angewendet werden, und kann sich auf CDK Verhalten und Ergebnisse auswirken.

Geben Sie Umgebungen bei der Vorlagensynthese an

Wenn Sie Umgebungsinformationen mithilfe der env Eigenschaft des Stack Konstrukts angeben, werden Ihre Umgebungsinformationen bei der Template-Synthese verwendet. Wird ausgeführt cdk synth oder cdk deploy erzeugt eine umgebungsspezifische Vorlage CloudFormation .

Wenn Sie Umgebungsvariablen innerhalb der env Eigenschaft verwenden, müssen Sie die --profile Option mit verwenden CDK CLI Befehle zur Übergabe des Profils mit Ihren Umgebungsinformationen aus Ihren Anmeldeinformationen und Konfigurationsdateien. Diese Informationen werden dann bei der Vorlagensynthese verwendet, um eine umgebungsspezifische Vorlage zu erstellen.

Die in der CloudFormation Vorlage enthaltenen Umgebungsinformationen haben Vorrang vor anderen Methoden. Wenn Sie beispielsweise eine andere Umgebung angebencdk deploy --profile profile, wird das Profil ignoriert.

Wenn Sie Umgebungsinformationen auf diese Weise bereitstellen, können Sie in Ihrer CDK App umgebungsabhängigen Code und Logik verwenden. Das bedeutet auch, dass die synthetisierte Vorlage je nach Maschine, Benutzer oder Sitzung, unter der sie synthetisiert wurde, unterschiedlich sein kann. Dieser Ansatz ist während der Entwicklung oft akzeptabel oder wünschenswert, wird jedoch nicht für den produktiven Einsatz empfohlen.

Geben Sie Umgebungen bei der Stack-Bereitstellung an

Wenn Sie keine Umgebung mithilfe der env Eigenschaft des Stack Konstrukts angeben, wird CDK CLI erzeugt bei der Synthese ein umweltunabhängiges Template CloudFormation . Anschließend können Sie die Umgebung angeben, in der die Bereitstellung erfolgen soll, indem Sie. cdk deploy --profile profile

Wenn Sie bei der Bereitstellung einer umgebungsunabhängigen Vorlage kein Profil angeben, wird CDK CLI wird versuchen, bei der Bereitstellung Umgebungswerte aus Ihrem default Profil credentials und config den Dateien zu verwenden.

Wenn Umgebungsinformationen bei der Bereitstellung nicht verfügbar sind, versucht AWS CloudFormation es, Umgebungsinformationen bei der Bereitstellung anhand von umgebungsbezogenen Attributen wie stack.accountstack.region, und stack.availabilityZones aufzulösen.

Bei umgebungsunabhängigen Stacks können Konstrukte innerhalb des Stacks keine Umgebungsinformationen verwenden, und Sie können keine Logik verwenden, die Umgebungsinformationen benötigt. Sie können beispielsweise keinen Code schreiben if (stack.region ==== 'us-east-1') oder Konstruktmethoden verwenden, für die Umgebungsinformationen erforderlich sind, wie z. Vpc.fromLookup Um diese Funktionen verwenden zu können, müssen Sie eine Umgebung mit der env Eigenschaft angeben.

Bei umgebungsunabhängigen Stacks verfügt jedes Konstrukt, das Availability Zones verwendet, über zwei Availability Zones, sodass der Stack in jeder Region bereitgestellt werden kann.

Wie spezifiziert man Umgebungen mit dem AWS CDK

Spezifizieren Sie hartcodierte Umgebungen für jeden Stack

Verwenden Sie die env Eigenschaft des Stack Konstrukts, um AWS Umgebungswerte für Ihren Stack anzugeben. Im Folgenden wird ein Beispiel gezeigt:

TypeScript


const envEU  = { account: '2383838383', region: 'eu-west-1' };
const envUSA = { account: '8373873873', region: 'us-west-2' };

new MyFirstStack(app, 'first-stack-us', { env: envUSA });
new MyFirstStack(app, 'first-stack-eu', { env: envEU });

JavaScript


const envEU  = { account: '2383838383', region: 'eu-west-1' };
const envUSA = { account: '8373873873', region: 'us-west-2' };

new MyFirstStack(app, 'first-stack-us', { env: envUSA });
new MyFirstStack(app, 'first-stack-eu', { env: envEU });

Python


env_EU = cdk.Environment(account="8373873873", region="eu-west-1")
env_USA = cdk.Environment(account="2383838383", region="us-west-2")

MyFirstStack(app, "first-stack-us", env=env_USA)
MyFirstStack(app, "first-stack-eu", env=env_EU)

Java


public class MyApp {

    // Helper method to build an environment
    static Environment makeEnv(String account, String region) {
        return Environment.builder()
                .account(account)
                .region(region)
                .build();
    }

    public static void main(final String argv[]) {
        App app = new App();

        Environment envEU = makeEnv("8373873873", "eu-west-1");
        Environment envUSA = makeEnv("2383838383", "us-west-2");
        
        new MyFirstStack(app, "first-stack-us", StackProps.builder()
                .env(envUSA).build());
        new MyFirstStack(app, "first-stack-eu", StackProps.builder()
                .env(envEU).build());
 
        app.synth();
    }
}

C#


Amazon.CDK.Environment makeEnv(string account, string region)
{
    return new Amazon.CDK.Environment
    {
        Account = account,
        Region = region
    };
}

var envEU = makeEnv(account: "8373873873", region: "eu-west-1");
var envUSA = makeEnv(account: "2383838383", region: "us-west-2");

new MyFirstStack(app, "first-stack-us", new StackProps { Env=envUSA });
new MyFirstStack(app, "first-stack-eu", new StackProps { Env=envEU });

Go


env_EU := awscdk.Environment{
	Account: jsii.String("8373873873"),
	Region:  jsii.String("eu-west-1"),
}

env_USA := awscdk.Environment{
	Account: jsii.String("2383838383"),
	Region:  jsii.String("us-west-2"),
}

MyFirstStack(app, "first-stack-us", &awscdk.StackProps{
	Env: &env_USA,
})

MyFirstStack(app, "first-stack-eu", &awscdk.StackProps{
	Env: &env_EU,
})

Wir empfehlen diesen Ansatz für Produktionsumgebungen. Indem Sie die Umgebung auf diese Weise explizit angeben, können Sie sicherstellen, dass der Stack immer in der spezifischen Umgebung bereitgestellt wird.

Geben Sie Umgebungen mithilfe von Umgebungsvariablen an

Das AWS CDK stellt zwei Umgebungsvariablen bereit, die Sie in Ihrem CDK Code verwenden können: CDK_DEFAULT_ACCOUNT undCDK_DEFAULT_REGION. Wenn Sie diese Umgebungsvariablen innerhalb der env Eigenschaft Ihrer Stack-Instance verwenden, können Sie Umgebungsinformationen aus Ihren Anmeldeinformationen und Konfigurationsdateien mit dem Befehl übergeben CDK CLI --profileOption.

Im Folgenden finden Sie ein Beispiel für die Angabe dieser Umgebungsvariablen:

TypeScript

Greifen Sie über das process Objekt von Node auf Umgebungsvariablen zu.

Anmerkung

Sie benötigen das DefinitelyTyped Modul zur Verwendung process in TypeScript. cdk initinstalliert dieses Modul für Sie. Sie sollten dieses Modul jedoch manuell installieren, wenn Sie mit einem Projekt arbeiten, das vor dem Hinzufügen erstellt wurde, oder wenn Sie Ihr Projekt nicht mit eingerichtet habencdk init.


npm install @types/node


new MyDevStack(app, 'dev', { 
  env: { 
    account: process.env.CDK_DEFAULT_ACCOUNT, 
    region: process.env.CDK_DEFAULT_REGION 
}});

JavaScript

Greifen Sie über das process Objekt von Node auf Umgebungsvariablen zu.


new MyDevStack(app, 'dev', { 
  env: { 
    account: process.env.CDK_DEFAULT_ACCOUNT, 
    region: process.env.CDK_DEFAULT_REGION 
}});

Python

Verwenden Sie das environ Wörterbuch des os Moduls, um auf Umgebungsvariablen zuzugreifen.


import os
MyDevStack(app, "dev", env=cdk.Environment(
    account=os.environ["CDK_DEFAULT_ACCOUNT"],
    region=os.environ["CDK_DEFAULT_REGION"]))

Java

Wird verwendetSystem.getenv(), um den Wert einer Umgebungsvariablen abzurufen.


public class MyApp {

    // Helper method to build an environment
    static Environment makeEnv(String account, String region) {
        account = (account == null) ? System.getenv("CDK_DEFAULT_ACCOUNT") : account;
        region = (region == null) ? System.getenv("CDK_DEFAULT_REGION") : region;

        return Environment.builder()
                .account(account)
                .region(region)
                .build();
    }

    public static void main(final String argv[]) {
        App app = new App();

        Environment envEU = makeEnv(null, null);
        Environment envUSA = makeEnv(null, null);
        
        new MyDevStack(app, "first-stack-us", StackProps.builder()
                .env(envUSA).build());
        new MyDevStack(app, "first-stack-eu", StackProps.builder()
                .env(envEU).build());
 
        app.synth();
    }
}

C#

Wird verwendetSystem.Environment.GetEnvironmentVariable(), um den Wert einer Umgebungsvariablen abzurufen.


Amazon.CDK.Environment makeEnv(string account=null, string region=null)
{
    return new Amazon.CDK.Environment
    {
        Account = account ?? System.Environment.GetEnvironmentVariable("CDK_DEFAULT_ACCOUNT"),
        Region = region ?? System.Environment.GetEnvironmentVariable("CDK_DEFAULT_REGION")
    };
}

new MyDevStack(app, "dev", new StackProps { Env = makeEnv() });

Go


import "os"

MyDevStack(app, "dev", &awscdk.StackProps{
	Env: &awscdk.Environment{
		Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")),
		Region:  jsii.String(os.Getenv("CDK_DEFAULT_REGION")),
    },
})

Indem Sie Umgebungen mithilfe von Umgebungsvariablen angeben, können Sie denselben CDK Stack zu AWS CloudFormation Vorlagen für verschiedene Umgebungen synthetisieren lassen. Das bedeutet, dass Sie denselben CDK Stack in verschiedenen AWS Umgebungen bereitstellen können, ohne Ihren CDK Code ändern zu müssen. Sie müssen nur das Profil angeben, das bei der Ausführung verwendet werden sollcdk synth.

Dieser Ansatz eignet sich hervorragend für Entwicklungsumgebungen, wenn derselbe Stack in verschiedenen Umgebungen bereitgestellt wird. Wir empfehlen diesen Ansatz jedoch nicht für Produktionsumgebungen, da derselbe CDK Code je nach Maschine, Benutzer oder Sitzung, unter der er synthetisiert wird, unterschiedliche Vorlagen synthetisieren kann.

Geben Sie Umgebungen anhand Ihrer Anmeldeinformationen und Konfigurationsdateien mit dem CDK CLI

Wenn Sie eine umgebungsunabhängige Vorlage bereitstellen, verwenden Sie die Option mit einem beliebigen --profile CDK CLI Befehl zur Angabe des zu verwendenden Profils. Im Folgenden finden Sie ein Beispiel für die Bereitstellung eines CDK Stacks, der myStack anhand des prod Profils benannt wird, das in den config Dateien credentials und definiert ist:


$ cdk deploy myStack --profile prod

Weitere Informationen zu dieser --profile Option sowie zu anderen CDK CLI Befehle und Optionen finden Sie unterAWS CDK CLI Befehlsreferenz.

Überlegungen bei der Konfiguration von Umgebungen mit dem AWS CDK

Dienste, die Sie mithilfe von Konstrukten in Ihren Stacks definieren, müssen die Region unterstützen, in der Sie die Bereitstellung durchführen. Eine Liste der unterstützten Dienste AWS-Services pro Region finden Sie unter AWS Dienste nach Region.

Sie benötigen gültige AWS Identity and Access Management (IAM) Anmeldeinformationen, um Stack-Bereitstellungen mit dem AWS CDK in Ihren angegebenen Umgebungen durchführen zu können.

Beispiele

Synthetisieren Sie eine umgebungsunabhängige Vorlage aus einem CloudFormation Stapel CDK

In diesem Beispiel erstellen wir eine CloudFormation umgebungsunabhängige Vorlage aus unserem Stack. CDK Wir können diese Vorlage dann in jeder Umgebung bereitstellen.

Das Folgende ist unser CDK Beispielstapel. Dieser Stack definiert einen Amazon S3 S3-Bucket und eine CloudFormation Stack-Ausgabe für die Region des Buckets. Für dieses Beispiel env ist nicht definiert:

TypeScript


export class CdkAppStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Create the S3 bucket
    const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
    
    // Create an output for the bucket's Region
    new cdk.CfnOutput(this, 'BucketRegion', {
      value: bucket.env.region,
    });
  }
}

JavaScript


class CdkAppStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Create the S3 bucket
    const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
    
    // Create an output for the bucket's Region
    new cdk.CfnOutput(this, 'BucketRegion', {
      value: bucket.env.region,
    });
  }
}

Python


class CdkAppStack(cdk.Stack):

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

        # Create the S3 bucket
        bucket = s3.Bucket(self, 'amzn-s3-demo-bucket',
            removal_policy=cdk.RemovalPolicy.DESTROY
        )
        
        # Create an output for the bucket's Region
        cdk.CfnOutput(self, 'BucketRegion',
            value=bucket.env.region
        )

Java


public class CdkAppStack extends Stack {

    public CdkAppStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        // Create the S3 bucket
        Bucket bucket = Bucket.Builder.create(this, "amzn-s3-demo-bucket")
            .removalPolicy(RemovalPolicy.DESTROY)
            .build();
        
        // Create an output for the bucket's Region
        CfnOutput.Builder.create(this, "BucketRegion")
            .value(this.getRegion())
            .build();
    }
}

C#


namespace MyCdkApp
{
    public class CdkAppStack : Stack
    {
        public CdkAppStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            // Create the S3 bucket
            var bucket = new Bucket(this, "amzn-s3-demo-bucket", new BucketProps
            {
                RemovalPolicy = RemovalPolicy.DESTROY
            });
            
            // Create an output for the bucket's Region
            new CfnOutput(this, "BucketRegion", new CfnOutputProps
            {
                Value = this.Region
            });
        }
    }
}

Go


func NewCdkAppStack(scope constructs.Construct, id string, props *CdkAppStackProps) awscdk.Stack {
	stack := awscdk.NewStack(scope, &id, &props.StackProps)

	// Create the S3 bucket
	bucket := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
		RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
	})
	
	// Create an output for the bucket's Region
	awscdk.NewCfnOutput(stack, jsii.String("BucketRegion"), &awscdk.CfnOutputProps{
		Value: stack.Region(),
	})

	return stack
}

Wenn wir rennencdk synth, CDK CLI erzeugt eine CloudFormation Vorlage mit dem Pseudo-Parameter AWS::Region als Ausgabewert für die Region des Buckets. Dieser Parameter wird bei der Bereitstellung behoben:


Outputs:
  BucketRegion:
    Value:
      Ref: AWS::Region

Um diesen Stack in einer Umgebung bereitzustellen, die im dev Profil unserer Anmeldeinformationen und Konfigurationsdateien angegeben ist, führen wir Folgendes aus:


$ cdk deploy CdkAppStack --profile dev

Wenn wir kein Profil angeben, CDK CLI wird versuchen, Umgebungsinformationen aus dem default Profil in unseren Anmeldeinformationen und Konfigurationsdateien zu verwenden.

Verwenden Sie Logik, um Umgebungsinformationen bei der Vorlagensynthese zu ermitteln

In diesem Beispiel konfigurieren wir die env Eigenschaft unserer stack Instanz so, dass sie einen gültigen Ausdruck verwendet. Wir geben zwei zusätzliche Umgebungsvariablen an, CDK_DEPLOY_ACCOUNT undCDK_DEPLOY_REGION. Diese Umgebungsvariablen können bei der Synthese Standardwerte außer Kraft setzen, sofern sie existieren:

TypeScript


new MyDevStack(app, 'dev', { 
  env: { 
    account: process.env.CDK_DEPLOY_ACCOUNT || process.env.CDK_DEFAULT_ACCOUNT, 
    region: process.env.CDK_DEPLOY_REGION || process.env.CDK_DEFAULT_REGION 
}});

JavaScript


new MyDevStack(app, 'dev', { 
  env: { 
    account: process.env.CDK_DEPLOY_ACCOUNT || process.env.CDK_DEFAULT_ACCOUNT, 
    region: process.env.CDK_DEPLOY_REGION || process.env.CDK_DEFAULT_REGION 
}});

Python


MyDevStack(app, "dev", env=cdk.Environment(
    account=os.environ.get("CDK_DEPLOY_ACCOUNT", os.environ["CDK_DEFAULT_ACCOUNT"]),
    region=os.environ.get("CDK_DEPLOY_REGION", os.environ["CDK_DEFAULT_REGION"])

Java


public class MyApp {

    // Helper method to build an environment
    static Environment makeEnv(String account, String region) {
        account = (account == null) ? System.getenv("CDK_DEPLOY_ACCOUNT") : account;
        region = (region == null) ? System.getenv("CDK_DEPLOY_REGION") : region;
        account = (account == null) ? System.getenv("CDK_DEFAULT_ACCOUNT") : account;
        region = (region == null) ? System.getenv("CDK_DEFAULT_REGION") : region;

        return Environment.builder()
                .account(account)
                .region(region)
                .build();
    }

    public static void main(final String argv[]) {
        App app = new App();

        Environment envEU = makeEnv(null, null);
        Environment envUSA = makeEnv(null, null);
        
        new MyDevStack(app, "first-stack-us", StackProps.builder()
                .env(envUSA).build());
        new MyDevStack(app, "first-stack-eu", StackProps.builder()
                .env(envEU).build());
 
        app.synth();
    }
}

C#


Amazon.CDK.Environment makeEnv(string account=null, string region=null)
{
    return new Amazon.CDK.Environment
    {
        Account = account ??
            System.Environment.GetEnvironmentVariable("CDK_DEPLOY_ACCOUNT") ??
            System.Environment.GetEnvironmentVariable("CDK_DEFAULT_ACCOUNT"),
        Region = region ?? 
            System.Environment.GetEnvironmentVariable("CDK_DEPLOY_REGION") ??
            System.Environment.GetEnvironmentVariable("CDK_DEFAULT_REGION")
    };
}

new MyDevStack(app, "dev", new StackProps { Env = makeEnv() });

Go


var account, region string
var b bool

if account, b = os.LookupEnv("CDK_DEPLOY_ACCOUNT"); !b || len(account) == 0 {
	account = os.Getenv("CDK_DEFAULT_ACCOUNT")
}
if region, b = os.LookupEnv("CDK_DEPLOY_REGION"); !b || len(region) == 0 {
	region = os.Getenv("CDK_DEFAULT_REGION")
}

MyDevStack(app, "dev", &awscdk.StackProps{
	Env: &awscdk.Environment{
		Account: &account,
		Region:  &region,
	},
})

Wenn die Umgebung unseres Stacks auf diese Weise deklariert ist, können wir dann ein kurzes Skript oder eine Batch-Datei schreiben, Variablen über Befehlszeilenargumente setzen und dann aufrufencdk deploy. Im Folgenden wird ein Beispiel gezeigt. Alle Argumente, die über die ersten beiden hinausgehen, werden übergebencdk deploy, um Befehlszeilenoptionen oder Argumente anzugeben:

Wir können dann zusätzliche Skripts schreiben, die das cdk-deploy-to Skript für die Bereitstellung in bestimmten Umgebungen verwenden. Im Folgenden wird ein Beispiel gezeigt:

Im Folgenden finden Sie ein Beispiel, in dem das cdk-deploy-to Skript für die Bereitstellung in mehreren Umgebungen verwendet wird. Wenn die erste Bereitstellung fehlschlägt, wird der Prozess gestoppt:

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

Beispiel: Authentifizieren Sie sich mit der automatischen Token-Aktualisierung von IAM Identity Center

Bootstrap deine Umgebung