Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 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.
# Umgebungen für die Verwendung mit dem AWS CDK konfigurieren
Sie können AWS Umgebungen auf verschiedene Arten konfigurieren, um sie mit dem AWS Cloud Development Kit (AWS CDK) zu verwenden. 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 unter [Umgebungen für das AWS CDK](environments.md).
## Von wo aus können Sie Umgebungen angeben
Sie können Umgebungen in Anmeldeinformationen und Konfigurationsdateien angeben oder indem Sie die ` [env](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html#env) ` Eigenschaft des `Stack` Konstrukts aus der AWS Construct-Bibliothek verwenden.
### Anmeldeinformationen und Konfigurationsdateien
Sie können die AWS Befehlszeilenschnittstelle (AWS CLI) verwenden, um `config` Dateien zu erstellen `credentials` und zu verwalten, in denen Ihre AWS Umgebungsinformationen gespeichert, organisiert und verwaltet werden. Weitere Informationen zu diesen Dateien finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) im *Benutzerhandbuch für die AWS Befehlszeilenschnittstelle*.
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 Sicherheitsanmeldedaten für die AWS CDK-CLI konfigurieren](configure-access.md).
Im Allgemeinen löst das AWS CDK AWS Kontoinformationen aus Ihrer `credentials` Datei und AWS Regionsinformationen aus Ihrer Datei auf. `config`
Sobald Sie Ihre `credentials` `config` Dateien konfiguriert haben, können Sie die Umgebung angeben, die mit der AWS CDK-CLI und über Umgebungsvariablen verwendet werden soll.
### env-Eigenschaft des Stack-Konstrukts
Sie können die Umgebung für jeden Stapel angeben, indem Sie die ` [env](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html#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 oder Umgebungsvariablen übergeben, die vom CDK angeboten werden.
Um Umgebungsvariablen zu übergeben, verwenden Sie die Umgebungsvariablen `AWS_DEFAULT_ACCOUNT` und`AWS_DEFAULT_REGION`. 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 beim CDK AWS
Wenn Sie mehrere Methoden zur Angabe von Umgebungen verwenden, hält sich das AWS CDK an die folgende Rangfolge:
1. Hartcodierte Werte, die mit der `env` Eigenschaft des Konstrukts angegeben werden. `Stack`
1. `AWS_DEFAULT_ACCOUNT`und `AWS_DEFAULT_REGION` Umgebungsvariablen, die mit der `env` Eigenschaft des `Stack` Konstrukts angegeben sind.
1. Umgebungsinformationen, die mit dem Profil aus Ihren `credentials` und `config` -Dateien verknüpft sind und mit der `--profile` Option an die CDK-CLI übergeben wurden.
1. Das `default` Profil aus Ihren `config` Dateien `credentials` und.
## Wann müssen Umgebungen angegeben werden
Wenn Sie mit dem CDK entwickeln, 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. Die Art und Weise, wie Sie Umgebungen angeben, bestimmt, wann Ihre Umgebungsinformationen angewendet werden, und kann sich auf das Verhalten und die Ergebnisse von CDK auswirken.
### Geben Sie Umgebungen bei der Vorlagensynthese an
Wenn Sie Umgebungsinformationen mithilfe der `env` Eigenschaft des `Stack` Konstrukts angeben, werden Ihre Umgebungsinformationen bei der Vorlagensynthese 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 CDK-CLI-Befehlen verwenden, um das Profil mit Ihren Umgebungsinformationen aus Ihren Anmeldeinformationen und Konfigurationsdateien zu übergeben. 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 angeben`cdk deploy --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 die Umgebungen bei der Stack-Bereitstellung an
Wenn Sie keine Umgebung mithilfe der `env` Eigenschaft des `Stack` Konstrukts angeben, erstellt die CDK-CLI bei der Synthese eine umgebungsunabhängige Vorlage CloudFormation . Sie können dann die Umgebung angeben, in der die Bereitstellung erfolgen soll, indem Sie. `cdk deploy --profile `
Wenn Sie bei der Bereitstellung einer umgebungsunabhängigen Vorlage kein Profil angeben, versucht die CDK-CLI, Umgebungswerte aus Ihrem `default` `credentials` Profil und den Dateien bei der Bereitstellung zu verwenden. `config`
Wenn Umgebungsinformationen bei der Bereitstellung nicht verfügbar sind, AWS CloudFormation wird versucht, Umgebungsinformationen bei der Bereitstellung mithilfe von umgebungsbezogenen Attributen wie, und aufzulösen. `stack.account` `stack.region` `stack.availabilityZones`
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](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) ` 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 CDK AWS
### 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:
**Example**
```
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 });
```
```
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 });
```
```
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)
```
```
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();
}
}
```
```
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 });
```
```
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` und. `CDK_DEFAULT_REGION` Wenn Sie diese Umgebungsvariablen in der `env` Eigenschaft Ihrer Stack-Instance verwenden, können Sie mithilfe der `--profile` CDK-CLI-Option Umgebungsinformationen aus Ihren Anmeldeinformationen und Konfigurationsdateien übergeben.
Im Folgenden finden Sie ein Beispiel für die Angabe dieser Umgebungsvariablen:
**Example**
Greifen Sie über das `process` Objekt von Node auf Umgebungsvariablen zu.
Sie benötigen das `DefinitelyTyped` Modul zur Verwendung `process` in TypeScript. `cdk init`installiert 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 haben`cdk init`.
```
npm install @types/node
```
```
new MyDevStack(app, 'dev', {
env: {
account: process.env.CDK_DEFAULT_ACCOUNT,
region: process.env.CDK_DEFAULT_REGION
}});
```
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
}});
```
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"]))
```
Wird verwendet`System.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();
}
}
```
Wird verwendet`System.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() });
```
```
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 soll. `cdk 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.
### Spezifizieren Sie Umgebungen anhand Ihrer Anmeldeinformationen und Konfigurationsdateien mit der CDK-CLI
Verwenden Sie bei der Bereitstellung einer umgebungsunabhängigen Vorlage die `--profile` Option mit einem beliebigen CDK-CLI-Befehl, um das zu verwendende Profil anzugeben. Im Folgenden finden Sie ein Beispiel für die Bereitstellung eines CDK-Stacks, der `myStack` anhand des `prod` Profils benannt wird, das in den Dateien und definiert ist: `credentials` `config`
```
$ cdk deploy --profile
```
Weitere Informationen zu dieser `--profile` Option sowie zu anderen CDK-CLI-Befehlen und -Optionen finden Sie in der [AWS CDK-CLI-Befehlsreferenz](ref-cli-cmd.md).
## Überlegungen bei der Konfiguration von Umgebungen mit dem CDK AWS
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 AWS Dienste pro Region finden Sie unter [AWS Dienste nach](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) 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 CDK-Stack CloudFormation
In diesem Beispiel erstellen wir eine CloudFormation umgebungsunabhängige Vorlage aus unserem CDK-Stack. Wir können diese Vorlage dann in jeder Umgebung bereitstellen.
Im Folgenden finden Sie unser Beispiel für einen CDK-Stack. 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:
**Example**
```
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,
});
}
}
```
```
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,
});
}
}
```
```
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
)
```
```
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();
}
}
```
```
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
});
}
}
}
```
```
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 ausführen`cdk synth`, erzeugt die CDK-CLI 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, versucht die CDK-CLI, 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` und`CDK_DEPLOY_REGION`. Diese Umgebungsvariablen können bei der Synthese Standardwerte außer Kraft setzen, sofern sie existieren:
**Example**
```
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
}});
```
```
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
}});
```
```
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"])
)
)
```
```
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();
}
}
```
```
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() });
```
```
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: ®ion,
},
})
```
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 aufrufen`cdk deploy`. Im Folgenden wird ein Beispiel gezeigt. Alle Argumente, die über die ersten beiden hinausgehen, werden übergeben`cdk deploy`, um Befehlszeilenoptionen oder Argumente anzugeben:
**Example**
```
#!/usr/bin/env bash
if [[ $# -ge 2 ]]; then
export CDK_DEPLOY_ACCOUNT=$1
export CDK_DEPLOY_REGION=$2
shift; shift
npx cdk deploy "$@"
exit $?
else
echo 1>&2 "Provide account and region as first two args."
echo 1>&2 "Additional args are passed through to cdk deploy."
exit 1
fi
```
Speichern Sie das Skript unter und führen Sie es dann aus`cdk-deploy-to.sh`, `chmod +x cdk-deploy-to.sh` um es ausführbar zu machen.
```
@findstr /B /V @ %~dpnx0 > %~dpn0.ps1 && powershell -ExecutionPolicy Bypass %~dpn0.ps1 %*
@exit /B %ERRORLEVEL%
if ($args.length -ge 2) {
$env:CDK_DEPLOY_ACCOUNT, $args = $args
$env:CDK_DEPLOY_REGION, $args = $args
npx cdk deploy $args
exit $lastExitCode
} else {
[console]::error.writeline("Provide account and region as first two args.")
[console]::error.writeline("Additional args are passed through to cdk deploy.")
exit 1
}
```
Die Windows-Version des Skripts bietet PowerShell dieselbe Funktionalität wie die MacOS/Linux-Version. Es enthält auch Anweisungen, mit denen es als Batch-Datei ausgeführt werden kann, sodass es einfach von einer Befehlszeile aus aufgerufen werden kann. Sie sollte gespeichert werden als`cdk-deploy-to.bat`. Die Datei `cdk-deploy-to.ps1` wird erstellt, wenn die Batch-Datei aufgerufen wird.
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:
**Example**
```
#!/usr/bin/env bash
# cdk-deploy-to-test.sh
./cdk-deploy-to.sh 123457689 us-east-1 "$@"
```
```
@echo off
rem cdk-deploy-to-test.bat
cdk-deploy-to 135792469 us-east-1 %*
```
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:
**Example**
```
#!/usr/bin/env bash
# cdk-deploy-to-prod.sh
./cdk-deploy-to.sh 135792468 us-west-1 "$@" || exit
./cdk-deploy-to.sh 246813579 eu-west-1 "$@"
```
```
@echo off
rem cdk-deploy-to-prod.bat
cdk-deploy-to 135792469 us-west-1 %* || exit /B
cdk-deploy-to 245813579 eu-west-1 %*
```