

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à.

# AWS Riferimento alla CLI CDK
<a name="cli"></a>

L'interfaccia a riga di comando (AWS CDK) del AWS Cloud Development Kit (AWS CDK), nota anche come CDK Toolkit, è lo strumento principale per interagire con l'app CDK. AWS Esegue la tua app, interroga il modello di applicazione che hai definito e produce e distribuisce i modelli generati dal CDK. AWS CloudFormation AWS Fornisce anche altre funzionalità utili per creare e lavorare con progetti CDK. AWS Questo argomento contiene informazioni sui casi d'uso comuni della CLI CDK.

La CLI CDK viene installata con Node Package Manager. Nella maggior parte dei casi, consigliamo di installarlo a livello globale.

```
npm install -g aws-cdk             # install latest version
npm install -g aws-cdk@X.YY.Z      # install specific version
```

**Suggerimento**  
Se lavori regolarmente con più versioni del AWS CDK, prendi in considerazione l'installazione di una versione corrispondente della CLI CDK nei singoli progetti CDK. Per fare ciò, `-g` omettete dal comando. `npm install` Quindi usa `npx aws-cdk` per invocarlo. Questo esegue la versione locale se ne esiste una, tornando a una versione globale in caso contrario.

## Comandi CDK CLI
<a name="cli-commands"></a>

Tutti i comandi CDK CLI iniziano `cdk` con, seguito da un sottocomando `list` (`synthesize`,`deploy`, ecc.). Alcuni sottocomandi hanno una versione più breve (`ls`,`synth`, ecc.) che è equivalente. Le opzioni e gli argomenti seguono il sottocomando in qualsiasi ordine.

Per una descrizione di tutti i sottocomandi, le opzioni e gli argomenti, consultate il riferimento ai comandi [AWS CDK CLI](ref-cli-cmd.md).

## Specificate le opzioni e i relativi valori
<a name="cli-options"></a>

Le opzioni della riga di comando iniziano con due trattini ()`--`. Alcune opzioni utilizzate di frequente hanno sinonimi composti da una sola lettera che iniziano con un solo trattino (ad esempio, `--app` ha un sinonimo). `-a` L'ordine delle opzioni in un comando CDK CLI non è importante.

Tutte le opzioni accettano un valore, che deve seguire il nome dell'opzione. Il valore può essere separato dal nome con uno spazio bianco o con un segno di uguale. `=` Le due opzioni seguenti sono equivalenti.

```
--toolkit-stack-name MyBootstrapStack
--toolkit-stack-name=MyBootstrapStack
```

Alcune opzioni sono bandiere (booleane). È possibile specificare `true` o `false` specificare il loro valore. Se non si fornisce un valore, il valore viene considerato uguale a`true`. È inoltre possibile aggiungere al nome dell'opzione il prefisso «`no-`da `false` implicare».

```
# sets staging flag to true
--staging
--staging=true
--staging true

# sets staging flag to false
--no-staging
--staging=false
--staging false
```

Alcune opzioni, vale a dire`--context`,`--parameters`, e `--plugin` `--tags``--trust`, possono essere specificate più di una volta per specificare più valori. Questi sono indicati come `[array]` digitati nella guida della CLI di CDK. Esempio:

```
cdk bootstrap --tags costCenter=0123 --tags responsibleParty=jdoe
```

## Aiuto integrato
<a name="cli-help"></a>

La CLI CDK dispone di una guida integrata. È possibile visualizzare una guida generale sull'utilità e un elenco dei sottocomandi forniti eseguendo:

```
cdk --help
```

Per visualizzare l'aiuto relativo a un particolare sottocomando, ad esempio`deploy`, specificatelo prima del flag. `--help`

```
cdk deploy --help
```

Problema `cdk version` per visualizzare la versione della CLI CDK. Fornisci queste informazioni quando richiedi assistenza.

## Reportistica delle versioni
<a name="version-reporting"></a>

Per ottenere informazioni su come viene utilizzato il AWS CDK, i costrutti utilizzati dalle applicazioni AWS CDK vengono raccolti e riportati utilizzando una risorsa identificata come. ` AWS::CDK::Metadata` Per ulteriori informazioni, consulta [Configurare la reportistica dei dati di utilizzo di AWS CDK.](usage-data.md)

## Autenticazione con AWS
<a name="cli-auth"></a>

Esistono diversi modi in cui è possibile configurare l'accesso programmatico alle AWS risorse, a seconda dell'ambiente e dell' AWS accesso a disposizione.

Per scegliere il metodo di autenticazione e configurarlo per la CLI CDK, [consulta Configurare le credenziali di sicurezza per la AWS](configure-access.md) CLI CDK.

L'approccio consigliato per i nuovi utenti che si sviluppano localmente, ai quali non viene fornito un metodo di autenticazione dal datore di lavoro, consiste nel configurare IAM Identity Center. AWS Questo metodo include l'installazione della AWS CLI per facilitare la configurazione e per accedere regolarmente al portale di AWS accesso. Se scegli questo metodo, il tuo ambiente dovrebbe contenere i seguenti elementi dopo aver completato la procedura per l'[autenticazione di IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) nella * AWS SDKs and Tools Reference Guide:*
+ La AWS CLI, che viene utilizzata per avviare una sessione del portale di AWS accesso prima di eseguire l'applicazione.
+ Un [file di AWS configurazione condiviso](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) con un `[default]` profilo con un set di valori di configurazione a cui è possibile fare riferimento dal CDK. AWS Per trovare la posizione di questo file, consulta [Posizione dei file condivisi nella Guida](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) di riferimento *agli strumenti AWS SDKs e strumenti*.
+ Il `config` file condiviso imposta l'impostazione [della regione](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html). Questo imposta la AWS regione predefinita utilizzata da AWS CDK e CDK CLI per le richieste. AWS 
+ La CLI CDK utilizza la configurazione del [provider di token SSO del](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#feature-sso-credentials-profile) profilo per acquisire le credenziali prima di inviare richieste a. AWS Il `sso_role_name` valore, che è un ruolo IAM connesso a un set di autorizzazioni IAM Identity Center, dovrebbe consentire l'accesso ai AWS servizi utilizzati nell'applicazione.

  Il seguente `config` file di esempio mostra un profilo predefinito impostato con la configurazione del provider di token SSO. L'`sso_session`impostazione del profilo si riferisce alla [`sso-session`sezione](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#section-session) denominata. La `sso-session` sezione contiene le impostazioni per avviare una sessione del portale di AWS accesso.

  ```
  [default]
  sso_session = <my-sso>
  sso_account_id = <111122223333>
  sso_role_name = <SampleRole>
  region = <us-east-1>
  output = <json>
  
  [sso-session <my-sso>]
  sso_region = <us-east-1>
  sso_start_url = <https://provided-domain.awsapps.com/start>
  sso_registration_scopes = sso:account:access
  ```

### Avviare una sessione del portale di AWS accesso
<a name="accessportal"></a>

Prima di accedere ai AWS servizi, è necessaria una sessione attiva del portale di AWS accesso affinché la CLI CDK utilizzi l'autenticazione IAM Identity Center per risolvere le credenziali. A seconda della durata della sessione configurata, l'accesso alla fine scadrà e la CLI CDK riscontrerà un errore di autenticazione. Esegui il seguente comando nella AWS CLI per accedere al portale di AWS accesso.

```
aws sso login
```

Se la configurazione del provider di token SSO utilizza un profilo denominato anziché il profilo predefinito, il comando è. `aws sso login --profile <NAME>` Specificate inoltre questo profilo quando emettete `cdk` comandi utilizzando l'`--profile`opzione o la variabile di `AWS_PROFILE` ambiente.

Per verificare se hai già una sessione attiva, esegui il seguente comando AWS CLI.

```
aws sts get-caller-identity
```

La risposta a questo comando dovrebbe restituire l'account IAM Identity Center e il set di autorizzazioni configurati nel file `config` condiviso.

**Nota**  
Se hai già una sessione attiva del portale di AWS accesso ed esegui`aws sso login`, non ti verrà richiesto di fornire credenziali.  
La procedura di accesso potrebbe richiedere all'utente di consentire l'accesso ai dati da parte della AWS CLI. Poiché la AWS CLI è basata sull'SDK per Python, i messaggi di autorizzazione possono contenere variazioni del nome. `botocore`

## Specificare la regione e altre configurazioni
<a name="cli-environment"></a>

La CLI CDK deve conoscere AWS la regione in cui stai distribuendo e come autenticarti. AWS Ciò è necessario per le operazioni di distribuzione e per recuperare i valori di contesto durante la sintesi. Insieme, l'account e la regione costituiscono l'*ambiente.*

La regione può essere specificata utilizzando variabili di ambiente o nei file di configurazione. Queste sono le stesse variabili e gli stessi file utilizzati da altri AWS strumenti come la AWS CLI e vari. AWS SDKs La CLI CDK cerca queste informazioni nell'ordine seguente.
+ Variabile di ambiente `AWS_DEFAULT_REGION`
+ Un profilo denominato definito nel AWS `config` file standard e specificato utilizzando l'`--profile`opzione sui `cdk` comandi.
+ La `[default]` sezione del AWS `config` file standard.

Oltre a specificare AWS l'autenticazione e una regione nella `[default]` sezione, puoi anche aggiungere una o più `[profile <NAME>]` sezioni, dove `<NAME>` è il nome del profilo. Per ulteriori informazioni sui profili denominati, consulta [File di configurazione e credenziali condivisi](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) nella Guida di riferimento *agli strumenti AWS SDKs e agli strumenti*.

Il AWS `config` file standard si trova in `~/.aws/config` (macOS/Linux) o `%USERPROFILE%\.aws\config` (Windows). *Per dettagli e posizioni alternative, consulta [Posizione dei file di configurazione e credenziali condivisi nella Guida di riferimento di and](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) Tools AWS SDKs * 

L'ambiente specificato nell'app AWS CDK utilizzando la `env` proprietà dello stack viene utilizzato durante la sintesi. Viene utilizzato per generare un AWS CloudFormation modello specifico per l'ambiente e, durante la distribuzione, sostituisce l'account o la regione specificati con uno dei metodi precedenti. [Per ulteriori informazioni, consulta Environments for the CDK. AWS](environments.md)

**Nota**  
Il AWS CDK utilizza le credenziali degli stessi file sorgente AWS degli altri strumenti SDKs, inclusa l'interfaccia a riga di [AWS comando](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html). Tuttavia, il AWS CDK potrebbe comportarsi in modo leggermente diverso da questi strumenti. Utilizza l' AWS SDK per essere utilizzato JavaScript sotto il cofano. [Per i dettagli completi sulla configurazione delle credenziali per l' AWS SDK per JavaScript, consulta Impostazione delle credenziali.](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials.html)

Facoltativamente, puoi utilizzare l'opzione `--role-arn` (or`-r`) per specificare l'ARN di un ruolo IAM da utilizzare per la distribuzione. Questo ruolo deve essere assunto dall' AWS account utilizzato.

## Specificare il comando dell'app
<a name="cli-app-command"></a>

Molte funzionalità della CLI CDK richiedono la sintesi di uno o AWS CloudFormation più modelli, il che a sua volta richiede l'esecuzione dell'applicazione. Il AWS CDK supporta programmi scritti in diversi linguaggi. Pertanto, utilizza un'opzione di configurazione per specificare l'esatto comando necessario per eseguire l'app. Questa opzione può essere specificata in due modi.

Innanzitutto, e più comunemente, può essere specificata utilizzando la `app` chiave all'interno del file`cdk.json`. Si trova nella directory principale del progetto AWS CDK. La CLI CDK fornisce un comando appropriato per la creazione di un nuovo progetto con. `cdk init` Ecco, ad esempio, il `cdk.json` brano tratto da un nuovo TypeScript progetto.

```
{
  "app": "npx ts-node bin/hello-cdk.ts"
}
```

La CLI CDK `cdk.json` cerca nella directory di lavoro corrente quando tenta di eseguire l'app. Per questo motivo, potresti tenere aperta una shell nella directory principale del tuo progetto per l'emissione di comandi CDK CLI.

La CLI CDK cerca anche la chiave dell'app (cioè `~/.cdk.json` nella tua home directory) se non riesce a trovarla. `./cdk.json` Aggiungere qui il comando dell'app può essere utile se di solito lavori con codice CDK nella stessa lingua.

Se ti trovi in un'altra directory o desideri eseguire l'app utilizzando un comando diverso da quello in`cdk.json`, usa l'opzione `--app` (or`-a`) per specificarlo.

```
cdk --app "npx ts-node bin/hello-cdk.ts" ls
```

Durante la distribuzione, puoi anche specificare una directory contenente assembly cloud sintetizzati, ad esempio`cdk.out`, come valore di. `--app` Gli stack specificati vengono distribuiti da questa directory; l'app non viene sintetizzata.

## Specificare gli stack
<a name="cli-stacks"></a>

Molti comandi CDK CLI (ad esempio`cdk deploy`) funzionano sugli stack definiti nell'app. Se la tua app contiene solo uno stack, la CLI CDK presuppone che tu intenda quello se non specifichi uno stack in modo esplicito.

Altrimenti, devi specificare lo stack o gli stack con cui vuoi lavorare. È possibile farlo specificando singolarmente gli stack desiderati per ID sulla riga di comando. Ricorda che l'ID è il valore specificato dal secondo argomento quando crei un'istanza dello stack.

```
cdk synth PipelineStack LambdaStack
```

Potete anche usare i caratteri jolly per specificare IDs che corrispondono a un pattern.
+  `?`corrisponde a qualsiasi carattere singolo
+  `*`corrisponde a qualsiasi numero di caratteri (`*`da solo corrisponde a tutte le pile)
+  `**`corrisponde a tutto ciò che è in una gerarchia

Puoi anche usare l'`--all`opzione per specificare tutti gli stack.

Se la tua app utilizza [CDK Pipelines, la CLI CDK](cdk-pipeline.md) interpreta i tuoi stack e le tue fasi come una gerarchia. Inoltre, l'`--all`opzione e la jolly corrispondono solo agli stack di primo livello. `*` Per abbinare tutte le pile, usa. `**` Utilizzalo anche `**` per indicare tutte le pile in una particolare gerarchia.

Quando usate i caratteri jolly, racchiudete il pattern tra virgolette o uscite dai caratteri jolly con. `\` Se non lo fate, la vostra shell potrebbe cercare di espandere il pattern ai nomi dei file nella directory corrente. Nella migliore delle ipotesi, questo non farà quello che ti aspetti; nel peggiore dei casi, potresti distribuire stack che non avevi intenzione di fare. Questo non è strettamente necessario su Windows perché `cmd.exe` non espande i caratteri jolly, ma è comunque una buona pratica.

```
cdk synth "*Stack"    # PipelineStack, LambdaStack, etc.
cdk synth 'Stack?'    # StackA, StackB, Stack1, etc.
cdk synth \*          # All stacks in the app, or all top-level stacks in a CDK Pipelines app
cdk synth '**'        # All stacks in a CDK Pipelines app
cdk synth 'PipelineStack/Prod/**'   # All stacks in Prod stage in a CDK Pipelines app
```

**Nota**  
L'ordine in cui si specificano gli stack non è necessariamente l'ordine in cui verranno elaborati. La CLI CDK tiene conto delle dipendenze tra gli stack quando decide l'ordine in cui elaborarli. Ad esempio, supponiamo che uno stack utilizzi un valore prodotto da un altro (come l'ARN di una risorsa definita nel secondo stack). In questo caso, il secondo stack viene sintetizzato prima del primo a causa di questa dipendenza. È possibile aggiungere dipendenze tra gli stack manualmente utilizzando il metodo dello stack. ` [addDependency()](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html#addwbrdependencytarget-reason) `

## Avvia il tuo ambiente AWS
<a name="cli-bootstrap"></a>

L'implementazione degli stack con il CDK richiede il provisioning di risorse AWS CDK speciali dedicate. Il `cdk bootstrap` comando crea le risorse necessarie per te. È necessario eseguire il bootstrap solo se si distribuisce uno stack che richiede queste risorse dedicate. Vedi [AWS CDK](bootstrapping.md) bootstrapping per i dettagli.

```
cdk bootstrap
```

Se emesso senza argomenti, come mostrato qui, il `cdk bootstrap` comando sintetizza l'app corrente e avvia gli ambienti in cui verranno distribuiti i suoi stack. Se l'app contiene stack indipendenti dall'ambiente, che non specificano esplicitamente un ambiente, l'account e la regione predefiniti vengono avviati oppure l'ambiente specificato viene utilizzato. `--profile`

All'esterno di un'app, è necessario specificare in modo esplicito l'ambiente da avviare. Puoi farlo anche per avviare un ambiente non specificato nella tua app o nel tuo profilo locale. AWS Le credenziali devono essere configurate (ad esempio in`~/.aws/credentials`) per l'account e la regione specificati. È possibile specificare un profilo che contenga le credenziali richieste.

```
cdk bootstrap <ACCOUNT-NUMBER>/<REGION> # e.g.
cdk bootstrap 1111111111/us-east-1
cdk bootstrap --profile test 1111111111/us-east-1
```

**Importante**  
Ogni ambiente (combinazione account/regione) in cui viene distribuito tale stack deve essere avviato separatamente.

È possibile che vengano AWS addebitati costi per ciò che il CDK archivia nelle risorse avviate. AWS Inoltre, se si utilizza`--bootstrap-customer-key`, verrà creata una chiave AWS KMS, che comporta anche addebiti per ambiente.

**Nota**  
Le versioni precedenti del modello bootstrap creavano una chiave KMS per impostazione predefinita. Per evitare addebiti, riavvia il sistema utilizzando. `--no-bootstrap-customer-key`

**Nota**  
CDK CLI v2 non supporta il modello di bootstrap originale, soprannominato modello legacy, utilizzato di default con CDK v1.

**Importante**  
Il moderno modello di bootstrap concede in modo efficace le autorizzazioni implicite da a qualsiasi account presente nell'elenco. `--cloudformation-execution-policies` AWS `--trust` Per impostazione predefinita, questo estende le autorizzazioni di lettura e scrittura a qualsiasi risorsa nell'account avviato. Assicurati di [configurare lo stack di bootstrap](bootstrapping-customizing.md) con politiche e account affidabili con cui ti senti a tuo agio.

## Crea una nuova app
<a name="cli-init"></a>

Per creare una nuova app, crea una cartella corrispondente, quindi, all'interno della directory, emetti`cdk init`.

```
mkdir my-cdk-app
cd my-cdk-app
cdk init <TEMPLATE> --language <LANGUAGE>
```

Le lingue supportate (<LANGUAGE>) sono:


| Codice | Lingua | 
| --- | --- | 
|   `typescript`   |  TypeScript  | 
|   `javascript`   |  JavaScript  | 
|   `python`   |  Python  | 
|   `java`   |  Java  | 
|   `csharp`   |  C\$1  | 
|   `Go`   |  Go  | 

<TEMPLATE>è un modello opzionale. Se il modello desiderato è *app*, l'impostazione predefinita, puoi ometterlo. I modelli disponibili sono:


| Modello | Description | 
| --- | --- | 
|   `app`(impostazione predefinita)  |  Crea un'app AWS CDK vuota.  | 
|   `sample-app`   |  Crea un'app AWS CDK con uno stack contenente una coda Amazon SQS e un argomento Amazon SNS.  | 

I modelli utilizzano il nome della cartella del progetto per generare nomi per file e classi all'interno della nuova app.

## Elenca gli stack
<a name="cli-list"></a>

Per visualizzare un elenco IDs degli stack presenti nell'applicazione AWS CDK, immettete uno dei seguenti comandi equivalenti:

```
cdk list
cdk ls
```

Se l'applicazione contiene stack [CDK](cdk-pipeline.md) Pipelines, la CLI CDK visualizza i nomi degli stack come percorsi in base alla loro posizione nella gerarchia delle pipeline. (Ad esempio, e.) `PipelineStack` `PipelineStack/Prod` `PipelineStack/Prod/MyService`

Se l'app contiene molti stack, puoi specificare lo stack completo o parziale IDs degli stack da elencare. [Per ulteriori informazioni, consulta Specificare gli stack.](#cli-stacks)

Aggiungi il `--long` flag per visualizzare ulteriori informazioni sugli stack, inclusi i nomi degli stack e i relativi ambienti (AWS account e regione).

## Sintetizza gli stack
<a name="cli-synth"></a>

Il `cdk synthesize` comando (quasi sempre abbreviato`synth`) sintetizza uno stack definito nell'app in un modello. CloudFormation 

```
cdk synth         # if app contains only one stack
cdk synth MyStack
cdk synth Stack1 Stack2
cdk synth "*"     # all stacks in app
```

**Nota**  
La CLI CDK esegue effettivamente l'app e sintetizza nuovi modelli prima della maggior parte delle operazioni (ad esempio durante la distribuzione o il confronto degli stack). Questi modelli sono memorizzati per impostazione predefinita nella directory. `cdk.out` Il `cdk synth` comando stampa semplicemente i modelli generati per uno o più stack specificati.

Vedi tutte `cdk synth --help` le opzioni disponibili. Alcune delle opzioni utilizzate più di frequente sono trattate nella sezione seguente.

### Specificare i valori di contesto
<a name="cli-specify-context"></a>

Utilizzate l'`-c`opzione `--context` o per passare i valori [di contesto di runtime](context.md) all'app CDK.

```
# specify a single context value
cdk synth --context key=value MyStack

# specify multiple context values (any number)
cdk synth --context key1=value1 --context key2=value2 MyStack
```

Quando si distribuiscono più stack, i valori di contesto specificati vengono normalmente passati a tutti. Se lo desideri, puoi specificare valori diversi per ogni stack anteponendo il nome dello stack al valore di contesto.

```
# different context values for each stack
cdk synth --context Stack1:key=value Stack2:key=value Stack1 Stack2
```

### Specificate il formato di visualizzazione
<a name="cli-specify-format"></a>

Per impostazione predefinita, il modello sintetizzato viene visualizzato in formato YAML. Aggiungi invece il `--json` flag per visualizzarlo in formato JSON.

```
cdk synth --json MyStack
```

### Specificate la directory di output
<a name="cli-specify-output"></a>

Aggiungete l'opzione `--output` (`-o`) per scrivere i modelli sintetizzati in una directory diversa da. `cdk.out`

```
cdk synth --output=~/templates
```

## Distribuisci pile
<a name="cli-deploy"></a>

Il `cdk deploy` sottocomando distribuisce uno o più stack specificati nel tuo account. AWS 

```
cdk deploy        # if app contains only one stack
cdk deploy MyStack
cdk deploy Stack1 Stack2
cdk deploy "*"    # all stacks in app
```

**Nota**  
La CLI CDK esegue l'app e sintetizza AWS CloudFormation nuovi modelli prima di distribuire qualsiasi cosa. Pertanto, è possibile utilizzare anche la maggior parte delle opzioni della riga di comando con cui è possibile utilizzare `cdk synth` (ad esempio`--context`). `cdk deploy`

Vedi tutte `cdk deploy --help` le opzioni disponibili. Alcune delle opzioni più utili sono illustrate nella sezione seguente.

### Salta la sintesi
<a name="cli-deploy-nosynth"></a>

Il `cdk deploy` comando normalmente sintetizza gli stack dell'app prima della distribuzione per assicurarsi che la distribuzione rifletta la versione più recente dell'app. Se sai di non aver modificato il codice dall'ultima modifica`cdk synth`, puoi eliminare la fase di sintesi ridondante durante la distribuzione. A tale scopo, specificate la `cdk.out` directory del progetto nell'opzione. `--app`

```
cdk deploy --app cdk.out StackOne StackTwo
```

### Disabilita il rollback
<a name="cli-deploy-norollback"></a>

 AWS CloudFormation ha la capacità di annullare le modifiche in modo che le distribuzioni siano atomiche. Ciò significa che hanno successo o falliscono nel loro complesso. Il AWS CDK eredita questa funzionalità perché sintetizza e distribuisce modelli. AWS CloudFormation 

Rollback assicura che le risorse siano sempre in uno stato coerente, il che è fondamentale per gli stack di produzione. Tuttavia, mentre state ancora sviluppando l'infrastruttura, alcuni guasti sono inevitabili e il ripristino delle implementazioni fallite può rallentare le vostre attività.

Per questo motivo, la CLI CDK consente di disabilitare il rollback `--no-rollback` aggiungendolo al comando. `cdk deploy` Con questo flag, le distribuzioni fallite non vengono ripristinate. Le risorse distribuite prima della risorsa guasta rimangono invece valide e la distribuzione successiva inizia con la risorsa guasta. Dedicherai molto meno tempo ad aspettare le implementazioni e molto più tempo a sviluppare la tua infrastruttura.

### Sostituzione a caldo
<a name="cli-deploy-hotswap"></a>

Usa il `--hotswap` flag con `cdk deploy` per cercare di aggiornare direttamente AWS le tue risorse invece di generare un set di AWS CloudFormation modifiche e distribuirlo. La distribuzione passa alla AWS CloudFormation distribuzione se l'hot swap non è possibile.

Attualmente l'hot swapping supporta funzioni Lambda, macchine a stati Step Functions e immagini di container Amazon ECS. Il `--hotswap` flag disabilita anche il rollback (cioè implica). `--no-rollback`

**Importante**  
L'hot-swapping non è consigliato per le implementazioni di produzione.

### modalità Watch
<a name="cli-deploy-watch"></a>

La modalità watch (`cdk deploy --watch`o in breve) della CLI CDK monitora continuamente i file sorgente e le risorse dell'app CDK `cdk watch` per rilevare eventuali modifiche. Esegue immediatamente una distribuzione degli stack specificati quando viene rilevata una modifica.

Per impostazione predefinita, queste distribuzioni utilizzano il `--hotswap` flag, che accelera l'implementazione delle modifiche alle funzioni Lambda. Inoltre, se AWS CloudFormation hai modificato la configurazione dell'infrastruttura, ritorna alla distribuzione completa. Per eseguire `cdk watch` sempre AWS CloudFormation distribuzioni complete, aggiungi il `--no-hotswap` flag a. `cdk watch`

Tutte le modifiche apportate mentre `cdk watch` è già in esecuzione una distribuzione vengono combinate in un'unica distribuzione, che inizia non appena viene completata la distribuzione in corso.

La modalità di visualizzazione utilizza la `"watch"` chiave del progetto `cdk.json` per determinare quali file monitorare. Per impostazione predefinita, questi file sono i file e le risorse dell'applicazione, ma possono essere modificati modificando le `"exclude"` voci `"include"` and nella `"watch"` chiave. Il `cdk.json` file seguente mostra un esempio di queste voci.

```
{
  "app": "mvn -e -q compile exec:java",
  "watch": {
    "include": "src/main/**",
    "exclude": "target/*"
  }
}
```

 `cdk watch`esegue il `"build"` comando da `cdk.json` per creare l'app prima della sintesi. Se la distribuzione richiede comandi per creare o impacchettare il codice Lambda (o qualsiasi altra cosa non presente nell'app CDK), aggiungilo qui.

I caratteri jolly in stile Git, entrambi `*` e`**`, possono essere usati nei tasti and. `"watch"` `"build"` Ogni percorso viene interpretato in relazione alla directory principale di. `cdk.json` Il valore predefinito di `include` è`**/*`, ovvero tutti i file e le directory nella directory principale del progetto. `exclude`è facoltativo.

**Importante**  
La modalità Watch non è consigliata per le implementazioni di produzione.

### Specificare i parametri AWS CloudFormation
<a name="cli-specify-parameters"></a>

La CLI CDK supporta la AWS CloudFormation [specificazione](parameters.md) dei parametri durante la distribuzione. È possibile fornirli nella riga di comando dopo il flag. `--parameters`

```
cdk deploy MyStack --parameters uploadBucketName=UploadBucket
```

Per definire più parametri, utilizzate più `--parameters` flag.

```
cdk deploy MyStack --parameters uploadBucketName=UpBucket --parameters downloadBucketName=DownBucket
```

Se state distribuendo più stack, potete specificare un valore diverso di ogni parametro per ogni stack. A tale scopo, aggiungete al nome del parametro il nome dello stack e i due punti. Altrimenti, lo stesso valore viene passato a tutti gli stack.

```
cdk deploy MyStack YourStack --parameters MyStack:uploadBucketName=UploadBucket --parameters YourStack:uploadBucketName=UpBucket
```

Per impostazione predefinita, il AWS CDK conserva i valori dei parametri delle distribuzioni precedenti e li utilizza nelle distribuzioni successive se non sono specificati in modo esplicito. Utilizzate il `--no-previous-parameters` flag per richiedere che tutti i parametri siano specificati.

### Specificare il file di output
<a name="cli-specify-outputs-file"></a>

Se lo stack dichiara degli AWS CloudFormation output, questi vengono normalmente visualizzati sullo schermo al termine della distribuzione. Per scriverli in un file in formato JSON, usa il flag. `--outputs-file`

```
cdk deploy --outputs-file outputs.json MyStack
```

### Approva le modifiche relative alla sicurezza
<a name="cli-security"></a>

Per proteggervi da modifiche non intenzionali che influiscono sul vostro livello di sicurezza, la CLI CDK richiede di approvare le modifiche relative alla sicurezza prima di distribuirle. Puoi specificare il livello di modifica che richiede l'approvazione:

```
cdk deploy --require-approval <LEVEL>
```

 `<LEVEL>`Il valore di può essere uno dei seguenti:


| Termine | Significato | 
| --- | --- | 
|   `never`   |  L'approvazione non è mai richiesta  | 
|   `any-change`   |  Richiede l'approvazione di qualsiasi IAM o security-group-related modifica  | 
|   `broadening`(impostazione predefinita)  |  Richiede l'approvazione quando vengono aggiunte le istruzioni IAM o le regole del traffico; le rimozioni non richiedono l'approvazione  | 

L'impostazione può essere configurata anche nel `cdk.json` file.

```
{
  "app": "...",
  "requireApproval": "never"
}
```

## Confronta gli stack
<a name="cli-diff"></a>

Il `cdk diff` comando confronta la versione corrente di uno stack (e le relative dipendenze) definita nell'app con le versioni già distribuite o con un AWS CloudFormation modello salvato e visualizza un elenco di modifiche.

```
Stack HelloCdkStack
IAM Statement Changes
┌───┬──────────────────────────────┬────────┬──────────────────────────────┬──────────────────────────────┬───────────┐
│   │ Resource                     │ Effect │ Action                       │ Principal                    │ Condition │
├───┼──────────────────────────────┼────────┼──────────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${Custom::S3AutoDeleteObject │ Allow  │ sts:AssumeRole               │ Service:lambda.amazonaws.com │           │
│   │ sCustomResourceProvider/Role │        │                              │                              │           │
│   │ .Arn}                        │        │                              │                              │           │
├───┼──────────────────────────────┼────────┼──────────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${MyFirstBucket.Arn}         │ Allow  │ s3:DeleteObject*             │ {aws}:${Custom::S3AutoDeleteOb │           │
│   │ ${MyFirstBucket.Arn}/*       │        │ s3:GetBucket*                │ jectsCustomResourceProvider/ │           │
│   │                              │        │ s3:GetObject*                │ Role.Arn}                    │           │
│   │                              │        │ s3:List*                     │                              │           │
└───┴──────────────────────────────┴────────┴──────────────────────────────┴──────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬────────────────────────────────────────────────────────┬────────────────────────────────────────────────────────┐
│   │ Resource                                               │ Managed Policy ARN                                     │
├───┼────────────────────────────────────────────────────────┼────────────────────────────────────────────────────────┤
│ + │ ${Custom::S3AutoDeleteObjectsCustomResourceProvider/Ro │ {"Fn::Sub":"arn:${{aws}::Partition}:iam::aws:policy/serv │
│   │ le}                                                    │ ice-role/AWSLambdaBasicExecutionRole"}                 │
└───┴────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)

Parameters
[+] Parameter AssetParameters/4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392/S3Bucket AssetParameters4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392S3BucketBF7A7F3F: {"Type":"String","Description":"S3 bucket for asset \"4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392\""}
[+] Parameter AssetParameters/4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392/S3VersionKey AssetParameters4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392S3VersionKeyFAF93626: {"Type":"String","Description":"S3 key for asset version \"4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392\""}
[+] Parameter AssetParameters/4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392/ArtifactHash AssetParameters4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392ArtifactHashE56CD69A: {"Type":"String","Description":"Artifact hash for asset \"4cd61014b71160e8c66fe167e43710d5ba068b80b134e9bd84508cf9238b2392\""}

Resources
[+] {aws}::S3::BucketPolicy MyFirstBucket/Policy MyFirstBucketPolicy3243DEFD
[+] Custom::S3AutoDeleteObjects MyFirstBucket/AutoDeleteObjectsCustomResource MyFirstBucketAutoDeleteObjectsCustomResourceC52FCF6E
[+] {aws}::IAM::Role Custom::S3AutoDeleteObjectsCustomResourceProvider/Role CustomS3AutoDeleteObjectsCustomResourceProviderRole3B1BD092
[+] {aws}::Lambda::Function Custom::S3AutoDeleteObjectsCustomResourceProvider/Handler CustomS3AutoDeleteObjectsCustomResourceProviderHandler9D90184F
[~] {aws}::S3::Bucket MyFirstBucket MyFirstBucketB8884501
 ├─ [~] DeletionPolicy
 │   ├─ [-] Retain
 │   └─ [+] Delete
 └─ [~] UpdateReplacePolicy
     ├─ [-] Retain
     └─ [+] Delete
```

Per confrontare gli stack dell'app con la distribuzione esistente:

```
cdk diff MyStack
```

Per confrontare gli stack della tua app con un modello salvato CloudFormation :

```
cdk diff --template ~/stacks/MyStack.old MyStack
```

## Importa le risorse esistenti in uno stack
<a name="cli-import"></a>

È possibile utilizzare il `cdk import` comando per gestire le risorse di un particolare CloudFormation AWS stack CDK. [Questo è utile se state migrando a AWS CDK o state spostando risorse tra gli stack o cambiando il loro id logico. Utilizza le importazioni di risorse. `cdk import` CloudFormation ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import.html) Consulta l'[elenco delle risorse che possono essere](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import-supported-resources.html) importate qui.

Per importare una risorsa esistente in uno stack AWS CDK, procedi nel seguente modo:
+ Assicurati che la risorsa non sia attualmente gestita da nessun altro CloudFormation stack. In caso affermativo, imposta innanzitutto la politica di rimozione sullo stack `RemovalPolicy.RETAIN` in cui si trova attualmente la risorsa ed esegui una distribuzione. Quindi, rimuovi la risorsa dallo stack ed esegui un'altra distribuzione. Questo processo assicurerà che la risorsa non sia più gestita da CloudFormation ma non la elimini.
+ Esegui un comando `cdk diff` per assicurarti che non vi siano modifiche in sospeso allo stack AWS CDK in cui desideri importare le risorse. Le uniche modifiche consentite in un'operazione di «importazione» sono l'aggiunta di nuove risorse da importare.
+ Aggiungi costrutti per le risorse che desideri importare nel tuo stack. Ad esempio, se desideri importare un bucket Amazon S3, aggiungi qualcosa come. `new s3.Bucket(this, 'ImportedS3Bucket', {});` Non apportate modifiche a nessun'altra risorsa.

  È inoltre necessario assicurarsi di modellare esattamente lo stato attuale della risorsa nella definizione. Per l'esempio del bucket, assicurati di includere le chiavi AWS KMS, le politiche del ciclo di vita e qualsiasi altra cosa pertinente al bucket. In caso contrario, le successive operazioni di aggiornamento potrebbero non funzionare come previsto.

  Puoi scegliere se includere o meno il nome fisico del bucket. Di solito consigliamo di non includere i nomi delle risorse nelle definizioni delle risorse AWS CDK in modo che diventi più facile distribuire le risorse più volte.
+ Esegui `cdk import <STACKNAME>`.
+ Se i nomi delle risorse non sono presenti nel modello, la CLI richiederà di inserire i nomi effettivi delle risorse che stai importando. Dopodiché, inizia l'importazione.
+ Quando viene `cdk import` segnalato un esito positivo, la risorsa viene ora gestita da AWS CDK e CloudFormation. Qualsiasi modifica successiva apportata alle proprietà delle risorse nell'app AWS CDK, la configurazione del costrutto verrà applicata alla distribuzione successiva.
+ Per confermare che la definizione della risorsa nell'app AWS CDK corrisponda allo stato attuale della risorsa, puoi avviare un'operazione di rilevamento delle [CloudFormation deviazioni](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html).

Questa funzionalità attualmente non supporta l'importazione di risorse in pile annidate.

## Configurazione () `cdk.json`
<a name="cli-config"></a>

I valori predefiniti per molti flag della riga di comando CDK CLI possono essere memorizzati nel file `cdk.json` di un progetto o nel file `.cdk.json` nella directory utente. Di seguito è riportato un riferimento alfabetico alle impostazioni di configurazione supportate.


| Chiave | Note | Opzione CDK CLI | 
| --- | --- | --- | 
|   `app`   |  Il comando che esegue l'applicazione CDK.  |   `--app`   | 
|   `assetMetadata`   |  Se`false`, CDK non aggiunge metadati alle risorse che utilizzano risorse.  |   `--no-asset-metadata`   | 
|   `bootstrapKmsKeyId`   |  Sostituisce l'ID della chiave AWS KMS utilizzata per crittografare il bucket di distribuzione di Amazon S3.  |   `--bootstrap-kms-key-id`   | 
|   `build`   |  Il comando che compila o crea l'applicazione CDK prima della sintesi. Non consentito in. `~/.cdk.json`  |   `--build`   | 
|   `browser`   |  Il comando per l'avvio di un browser Web per il `cdk docs` sottocomando.  |   `--browser`   | 
|   `context`   |  Vedi [Valori di contesto e CDK. AWS](context.md) I valori di contesto in un file di configurazione non verranno cancellati da. `cdk context --clear` (La CLI CDK inserisce i valori di contesto memorizzati nella cache). `cdk.context.json`  |   `--context`   | 
|   `debug`   |  Se`true`, CDK CLI emette informazioni più dettagliate utili per il debug.  |   `--debug`   | 
|   `language`   |  Il linguaggio da usare per inizializzare nuovi progetti.  |   `--language`   | 
|   `lookups`   |  Se`false`, non sono consentite ricerche contestuali. La sintesi avrà esito negativo se è necessario eseguire ricerche di contesto.  |   `--no-lookups`   | 
|   `notices`   |  If`false`, sopprime la visualizzazione dei messaggi relativi a vulnerabilità di sicurezza, regressioni e versioni non supportate.  |   `--no-notices`   | 
|   `output`   |  Il nome della directory in cui verrà emesso l'assembly cloud sintetizzato (impostazione predefinita). `"cdk.out"`  |   `--output`   | 
|   `outputsFile`   |  Il file in cui verranno scritti AWS CloudFormation gli output degli stack distribuiti (in formato). `JSON`  |   `--outputs-file`   | 
|   `pathMetadata`   |  Se`false`, i metadati del percorso CDK non vengono aggiunti ai modelli sintetizzati.  |   `--no-path-metadata`   | 
|   `plugin`   |  Array JSON che specifica i nomi dei pacchetti o i percorsi locali dei pacchetti che estendono il CDK  |   `--plugin`   | 
|   `profile`   |  Nome del AWS profilo predefinito utilizzato per specificare la regione e le credenziali dell'account.  |   `--profile`   | 
|   `progress`   |  Se impostato su`"events"`, la CLI CDK visualizza AWS CloudFormation tutti gli eventi durante la distribuzione, anziché una barra di avanzamento.  |   `--progress`   | 
|   `requireApproval`   |  Livello di approvazione predefinito per le modifiche alla sicurezza. Vedi [Approvazione delle modifiche relative alla sicurezza](#cli-security)   |   `--require-approval`   | 
|   `rollback`   |  Se`false`, le distribuzioni fallite non vengono ripristinate.  |   `--no-rollback`   | 
|   `staging`   |  Se`false`, le risorse non vengono copiate nella directory di output (utilizzate per il debug locale dei file sorgente con SAM). AWS   |   `--no-staging`   | 
|   `tags`   |   `JSON`oggetto contenente tag (coppie chiave-valore) per lo stack.  |   `--tags`   | 
|   `toolkitBucketName`   |  [Il nome del bucket Amazon S3 utilizzato per distribuire risorse come funzioni Lambda e immagini di container (vedi Bootstrap your environment). AWS](#cli-bootstrap)  |   `--toolkit-bucket-name`   | 
|   `toolkitStackName`   |  [Il nome dello stack di bootstrap (vedi Bootstrap your environment). AWS](#cli-bootstrap)  |   `--toolkit-stack-name`   | 
|   `versionReporting`   |  Se`false`, disattiva la segnalazione delle versioni.  |   `--no-version-reporting`   | 
|   `watch`   |  Oggetti JSON contenenti `"include"` `"exclude"` chiavi che indicano quali file devono (o non devono) attivare una ricostruzione del progetto quando vengono modificati. Vedi modalità [Watch](#cli-deploy-watch).  |   `--watch`   | 