Questa è la AWS CDK v2 Developer Guide. Il vecchio CDK v1 è entrato in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configurazione degli ambienti da utilizzare con il AWS CDK
Puoi configurare AWS gli ambienti in diversi modi da utilizzare con il AWS Cloud Development Kit (AWS CDK). Il metodo migliore per gestire AWS gli ambienti varia in base alle esigenze specifiche.
Alla fine, ogni stack CDK dell'applicazione deve essere associato a un ambiente per determinare dove verrà distribuito lo stack.
Per un'introduzione agli AWS ambienti, consulta Environments for the [CDK](environments.md). AWS
## Da dove puoi specificare gli ambienti
È possibile specificare gli ambienti nelle credenziali e nei file di configurazione oppure utilizzando la ` [env](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html#env) ` proprietà del costrutto della `Stack` Construct Library AWS .
### Credenziali e file di configurazione
È possibile utilizzare l'interfaccia a riga di AWS comando (AWS CLI) per creare `config` file `credentials` e archiviare, organizzare e gestire le informazioni AWS sull'ambiente. Per ulteriori informazioni su questi file, consulta [Impostazioni dei file di configurazione e credenziali nella Guida](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) per l'*utente dell'interfaccia a riga di AWS comando*.
I valori memorizzati in questi file sono organizzati per *profili*. Il modo in cui denominate i profili e le coppie chiave-valore in questi file varieranno in base al metodo di configurazione dell'accesso programmatico. Per ulteriori informazioni sui diversi metodi, consulta [Configurare le credenziali di sicurezza per la AWS CLI CDK](configure-access.md).
In generale, il AWS CDK risolve le informazioni sull' AWS account dal `credentials` file e AWS le informazioni sulla regione dal file. `config`
Una volta configurati `config` i file `credentials` e, è possibile specificare l'ambiente da utilizzare con la CLI AWS CDK e tramite le variabili di ambiente.
### proprietà env del costrutto Stack
È possibile specificare l'ambiente per ogni stack utilizzando la ` [env](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html#env) ` proprietà del costrutto. `Stack` Questa proprietà definisce un account e una regione da utilizzare. È possibile passare valori codificati a questa proprietà o passare variabili di ambiente offerte dal CDK.
Per passare le variabili di ambiente, utilizzate le variabili di ambiente e`AWS_DEFAULT_ACCOUNT`. `AWS_DEFAULT_REGION` Queste variabili di ambiente possono trasmettere valori dai tuoi `credentials` `config` file. Puoi anche utilizzare la logica all'interno del codice CDK per determinare i valori di queste variabili di ambiente.
## Precedenza dell'ambiente con il CDK AWS
Se utilizzate più metodi per specificare gli ambienti, il AWS CDK rispetta la seguente precedenza:
1. Valori codificati specificati con la proprietà del costrutto. `env` `Stack`
1. `AWS_DEFAULT_ACCOUNT`e variabili di `AWS_DEFAULT_REGION` ambiente specificate con la `env` proprietà del costrutto. `Stack`
1. Informazioni sull'ambiente associate al profilo dai tuoi `config` file `credentials` e passate alla CLI CDK utilizzando l'`--profile`opzione.
1. Il `default` profilo di Your `credentials` and `config` Files.
## Quando specificare gli ambienti
Quando sviluppate con CDK, iniziate definendo gli stack CDK, che contengono costrutti che rappresentano le risorse. AWS Successivamente, si sintetizza ogni stack CDK in un modello. AWS CloudFormation Quindi distribuisci il modello nel CloudFormation tuo ambiente. Il modo in cui specificate gli ambienti determina quando le informazioni sull'ambiente vengono applicate e può influire sul comportamento e sui risultati di CDK.
### Specificate gli ambienti durante la sintesi del modello
Quando si specificano informazioni sull'ambiente utilizzando la `env` proprietà del `Stack` costrutto, le informazioni sull'ambiente vengono applicate alla sintesi del modello. Esegue `cdk synth` o `cdk deploy` produce un modello specifico per l'ambiente CloudFormation .
Se si utilizzano variabili di ambiente all'interno della `env` proprietà, è necessario utilizzare l'`--profile`opzione con i comandi CDK CLI per passare il profilo contenente le informazioni sull'ambiente dalle credenziali e dai file di configurazione. Queste informazioni verranno quindi applicate alla sintesi del modello per produrre un modello specifico per l'ambiente.
Le informazioni sull'ambiente contenute nel CloudFormation modello hanno la precedenza sugli altri metodi. Ad esempio, se si fornisce un ambiente diverso`cdk deploy --profile `, il profilo verrà ignorato.
Quando fornisci informazioni sull'ambiente in questo modo, puoi utilizzare codice e logica dipendenti dall'ambiente all'interno dell'app CDK. Ciò significa anche che il modello sintetizzato potrebbe essere diverso, in base alla macchina, all'utente o alla sessione in cui viene sintetizzato. Questo approccio è spesso accettabile o auspicabile durante lo sviluppo, ma non è consigliato per l'uso in produzione.
### Specificate gli ambienti durante l'implementazione dello stack
Se non si specifica un ambiente utilizzando la `env` proprietà del `Stack` costrutto, la CLI CDK produrrà un modello indipendente dall'ambiente CloudFormation al momento della sintesi. È quindi possibile specificare l'ambiente in cui eseguire la distribuzione utilizzando. `cdk deploy --profile `
Se non specifichi un profilo durante la distribuzione di un modello indipendente dall'ambiente, la CLI CDK tenterà di utilizzare i valori di ambiente dal profilo del tuo e dai file in fase di implementazione. `default` `credentials` `config`
Se le informazioni sull'ambiente non sono disponibili al momento della distribuzione, AWS CloudFormation tenterà di risolvere le informazioni sull'ambiente durante la distribuzione tramite attributi relativi all'ambiente come, e. `stack.account` `stack.region` `stack.availabilityZones`
Per gli stack indipendenti dall'ambiente, i costrutti all'interno dello stack non possono utilizzare informazioni sull'ambiente e non è possibile utilizzare una logica che richieda informazioni sull'ambiente. Ad esempio, non è possibile scrivere codice simile `if (stack.region ==== 'us-east-1')` o utilizzare metodi di costruzione che richiedono informazioni sull'ambiente come. ` [Vpc.fromLookup](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html#static-fromwbrlookupscope-id-options) ` Per utilizzare queste funzionalità, è necessario specificare un ambiente con la `env` proprietà.
Per gli stack indipendenti dall'ambiente, qualsiasi costrutto che utilizza zone di disponibilità vedrà due zone di disponibilità, che consentono di distribuire lo stack in qualsiasi regione.
## Come specificare AWS gli ambienti con il CDK
### Specificate gli ambienti codificati per ogni stack
Utilizzate la `env` proprietà del `Stack` costrutto per specificare i valori di AWS ambiente per il vostro stack. Di seguito è riportato un esempio:
**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,
})
```
Consigliamo questo approccio per gli ambienti di produzione. Specificando esplicitamente l'ambiente in questo modo, è possibile garantire che lo stack venga sempre distribuito nell'ambiente specifico.
### Specificate gli ambienti utilizzando le variabili di ambiente
Il AWS CDK fornisce due variabili di ambiente che è possibile utilizzare all'interno del codice CDK: `CDK_DEFAULT_ACCOUNT` e. `CDK_DEFAULT_REGION` Quando utilizzi queste variabili di ambiente all'interno della `env` proprietà della tua istanza stack, puoi passare le informazioni sull'ambiente dalle tue credenziali e dai file di configurazione utilizzando l'opzione CDK `--profile` CLI.
Di seguito è riportato un esempio di come specificare queste variabili di ambiente:
**Example**
Accedi alle variabili di ambiente tramite l'`process`oggetto di Node.
È necessario il `DefinitelyTyped` modulo da utilizzare `process` TypeScript. `cdk init`installa questo modulo per te. Tuttavia, dovresti installare questo modulo manualmente se stai lavorando con un progetto creato prima che fosse aggiunto o se non hai configurato il progetto utilizzando`cdk init`.
```
npm install @types/node
```
```
new MyDevStack(app, 'dev', {
env: {
account: process.env.CDK_DEFAULT_ACCOUNT,
region: process.env.CDK_DEFAULT_REGION
}});
```
Accedi alle variabili di ambiente tramite l'`process`oggetto di Node.
```
new MyDevStack(app, 'dev', {
env: {
account: process.env.CDK_DEFAULT_ACCOUNT,
region: process.env.CDK_DEFAULT_REGION
}});
```
Usa il `environ` dizionario del `os` modulo per accedere alle variabili di ambiente.
```
import os
MyDevStack(app, "dev", env=cdk.Environment(
account=os.environ["CDK_DEFAULT_ACCOUNT"],
region=os.environ["CDK_DEFAULT_REGION"]))
```
Usa `System.getenv()` per ottenere il valore di una variabile d'ambiente.
```
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();
}
}
```
Si usa `System.Environment.GetEnvironmentVariable()` per ottenere il valore di una variabile di ambiente.
```
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")),
},
})
```
Specificando gli ambienti utilizzando variabili di ambiente, è possibile fare in modo che lo stesso stack CDK venga sintetizzato in modelli per AWS CloudFormation ambienti diversi. Ciò significa che è possibile distribuire lo stesso stack CDK in AWS ambienti diversi senza dover modificare il codice CDK. È sufficiente specificare il profilo da utilizzare durante l'esecuzione. `cdk synth`
Questo approccio è ideale per gli ambienti di sviluppo quando si implementa lo stesso stack in ambienti diversi. Tuttavia, non consigliamo questo approccio per gli ambienti di produzione poiché lo stesso codice CDK può sintetizzare modelli diversi, a seconda del computer, dell'utente o della sessione in cui viene sintetizzato.
### Specificate gli ambienti dalle vostre credenziali e dai file di configurazione con la CLI CDK
Quando implementate un modello indipendente dall'ambiente, utilizzate l'opzione `--profile` con qualsiasi comando CDK CLI per specificare il profilo da utilizzare. Di seguito è riportato un esempio che implementa uno stack CDK denominato `myStack` utilizzando il profilo definito nei file and: `prod` `credentials` `config`
```
$ cdk deploy --profile
```
Per ulteriori informazioni sull'`--profile`opzione, oltre ad altri comandi e opzioni della CLI CDK, consultate il riferimento ai comandi [AWS CDK CLI](ref-cli-cmd.md).
## Considerazioni sulla configurazione degli ambienti con il CDK AWS
I servizi definiti utilizzando costrutti all'interno degli stack devono supportare la regione in cui si esegue la distribuzione. Per un elenco dei AWS servizi supportati per regione, consulta [AWS Servizi](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) per regione.
È necessario disporre di credenziali IAM ( AWS Identity and Access Management) valide per eseguire distribuzioni di stack con CDK negli ambienti AWS specificati.
## Esempi
### Sintetizza un modello indipendente dall'ambiente da uno stack CDK CloudFormation
In questo esempio, creiamo un modello indipendente dall'ambiente dal nostro stack CDK. CloudFormation Possiamo quindi distribuire questo modello in qualsiasi ambiente.
Quello che segue è il nostro esempio di stack CDK. Questo stack definisce un bucket Amazon S3 e CloudFormation un output dello stack per la regione del bucket. Per questo esempio, non è definito: `env`
**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
}
```
Quando eseguiamo`cdk synth`, la CLI CDK produce CloudFormation un modello con lo pseudo ` AWS::Region` parametro come valore di output per la regione del bucket. Questo parametro verrà risolto al momento della distribuzione:
```
Outputs:
BucketRegion:
Value:
Ref: AWS::Region
```
Per distribuire questo stack in un ambiente specificato nel `dev` profilo delle nostre credenziali e dei nostri file di configurazione, eseguiamo quanto segue:
```
$ cdk deploy CdkAppStack --profile dev
```
Se non specifichiamo un profilo, la CLI CDK tenterà di utilizzare le informazioni sull'ambiente `default` del profilo nelle nostre credenziali e nei file di configurazione.
### Usa la logica per determinare le informazioni sull'ambiente durante la sintesi del modello
In questo esempio, configuriamo la `env` proprietà della nostra `stack` istanza per utilizzare un'espressione valida. Specifichiamo due variabili di ambiente aggiuntive `CDK_DEPLOY_ACCOUNT` e`CDK_DEPLOY_REGION`. Queste variabili di ambiente possono sovrascrivere i valori predefiniti al momento della sintesi, se esistono:
**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,
},
})
```
Con l'ambiente del nostro stack dichiarato in questo modo, possiamo quindi scrivere un breve script o un file batch e impostare le variabili dagli argomenti della riga di comando, quindi chiamare. `cdk deploy` Di seguito è riportato un esempio. Tutti gli argomenti oltre ai primi due vengono passati `cdk deploy` a per specificare le opzioni o gli argomenti della riga di comando:
**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
```
Salva lo script con nome`cdk-deploy-to.sh`, quindi eseguilo `chmod +x cdk-deploy-to.sh` per renderlo eseguibile.
```
@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
}
```
La versione Windows dello script fornisce PowerShell le stesse funzionalità della versione macOS/Linux. Contiene inoltre istruzioni per consentirne l'esecuzione come file batch in modo che possa essere facilmente richiamato da una riga di comando. Dovrebbe essere salvato come`cdk-deploy-to.bat`. Il file `cdk-deploy-to.ps1` verrà creato quando viene richiamato il file batch.
Possiamo quindi scrivere script aggiuntivi che utilizzano `cdk-deploy-to` lo script per la distribuzione in ambienti specifici. Di seguito è riportato un esempio:
**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 %*
```
Di seguito è riportato un esempio che utilizza `cdk-deploy-to` lo script per la distribuzione in più ambienti. Se la prima distribuzione fallisce, il processo si interrompe:
**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 %*
```