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 ai comandi CDK CLI
<a name="ref-cli-cmd"></a>

Questa sezione contiene informazioni di riferimento sui comandi per l'interfaccia a riga di comando (CLI) del AWS Cloud Development Kit (AWS CDK). La CLI CDK viene anche chiamata CDK Toolkit.

## Utilizzo
<a name="ref-cli-cmd-usage"></a>

```
$ cdk <command> <arguments> <options>
```

## Comandi
<a name="ref-cli-cmd-commands"></a><a name="ref-cli-cmd-commands-acknowledge"></a>

 ` acknowledge ack `   
Riconosci un avviso per numero di emissione e impedisci che venga nuovamente visualizzato.<a name="ref-cli-cmd-commands-bootstrap"></a>

 ` bootstrap `   
Prepara un AWS ambiente per le implementazioni CDK distribuendo lo stack di bootstrap CDK, denominato, nell'ambiente. `CDKToolkit` AWS <a name="ref-cli-cmd-commands-context"></a>

 ` context `   
Gestisci i valori di contesto memorizzati nella cache per la tua applicazione CDK.<a name="ref-cli-cmd-commands-deploy"></a>

 ` deploy `   
Implementa uno o più stack CDK nel tuo ambiente. AWS <a name="ref-cli-cmd-commands-destroy"></a>

 ` destroy `   
Elimina uno o più stack CDK dal tuo ambiente. AWS <a name="ref-cli-cmd-commands-diff"></a>

 ` diff `   
Esegui una differenza per vedere le modifiche all'infrastruttura tra gli stack CDK.<a name="ref-cli-cmd-commands-docs"></a>

 ` docs doc `   
Apri la documentazione CDK nel tuo browser.<a name="ref-cli-cmd-commands-doctor"></a>

 ` doctor `   
Consulta e visualizza informazioni utili sul progetto CDK locale e sull'ambiente di sviluppo.<a name="ref-cli-cmd-commands-drift"></a>

 ` drift `   
Rileva eventuali variazioni di configurazione per le risorse che definisci, gestisci e distribuisci utilizzando CDK.<a name="ref-cli-cmd-commands-flags"></a>

 ` flags `   
Visualizza e modifica le configurazioni dei feature flag per la CLI CDK.<a name="ref-cli-cmd-commands-import"></a>

 ` import `   
Utilizzate le importazioni di AWS CloudFormation risorse per importare le AWS risorse esistenti in uno stack CDK.<a name="ref-cli-cmd-commands-init"></a>

 ` init `   
Crea un nuovo progetto CDK da un modello.<a name="ref-cli-cmd-commands-list"></a>

 ` list, ls `   
Elenca tutti gli stack CDK e le relative dipendenze da un'app CDK.<a name="ref-cli-cmd-commands-metadata"></a>

 ` metadata `   
Visualizza i metadati associati a uno stack CDK.<a name="ref-cli-cmd-commands-migrate"></a>

 ` migrate `   
Migra AWS risorse, AWS CloudFormation stack e AWS CloudFormation modelli in un nuovo progetto CDK.<a name="ref-cli-cmd-commands-notices"></a>

 ` notices `   
Visualizza gli avvisi per la tua applicazione CDK.<a name="ref-cli-cmd-commands-refactor"></a>

 ` refactor `   
Conservate le risorse distribuite durante il refactoring del codice nell'applicazione CDK.<a name="ref-cli-cmd-commands-synthesize"></a>

 ` synthesize, synth `   
Sintetizza un'app CDK per produrre un assembly cloud, incluso un modello per ogni stack. AWS CloudFormation <a name="ref-cli-cmd-commands-watch"></a>

 ` watch `   
Monitora continuamente un progetto CDK locale per verificare eventuali modifiche, eseguire distribuzioni e hotswap.

## Opzioni globali
<a name="ref-cli-cmd-options"></a>

Le seguenti opzioni sono compatibili con tutti i comandi CDK CLI.<a name="ref-cli-cmd-options-app"></a>

 `--app, -a <STRING>`   
Fornisci il comando per eseguire l'app o la directory di assemblaggio cloud.  
 *Campo obbligatorio*: sì<a name="ref-cli-cmd-options-asset-metadata"></a>

 `--asset-metadata <BOOLEAN>`   
Includi `aws:asset:*` AWS CloudFormation i metadati per le risorse che utilizzano risorse.  
 *Required*: No  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-options-build"></a>

 `--build <STRING>`   
Comando per eseguire una build di pre-sintesi.  
 *Required*: No<a name="ref-cli-cmd-options-ca-bundle-path"></a>

 `--ca-bundle-path <STRING>`   
Percorso di un certificato CA da utilizzare per la convalida delle richieste HTTPS.  
Se questa opzione non viene fornita, la CLI CDK leggerà dalla `AWS_CA_BUNDLE` variabile di ambiente.  
 *Campo obbligatorio*: sì<a name="ref-cli-cmd-options-ci"></a>

 `--ci <BOOLEAN>`   
Indica che i comandi CDK CLI vengono eseguiti in un ambiente di integrazione continua (CI).  
Questa opzione modifica il comportamento della CLI CDK per adattarsi meglio alle operazioni automatizzate tipiche delle pipeline CI.  
Quando si fornisce questa opzione, i log vengono inviati invece di. `stdout` `stderr`  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-context"></a>

 `--context, -c <ARRAY>`   
Aggiungi parametri di stringa contestuali come coppie chiave-valore.<a name="ref-cli-cmd-options-debug"></a>

 `--debug <BOOLEAN>`   
Abilita informazioni di debug dettagliate. Questa opzione produce un output dettagliato che include molti più dettagli su ciò che la CLI CDK sta facendo dietro le quinte.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-ec2creds"></a>

 `--ec2creds, -i <BOOLEAN>`   
Imponi alla CLI CDK di provare a recuperare le credenziali dell'istanza Amazon EC2 .  
Per impostazione predefinita, la CLI CDK indovina lo stato dell' EC2 istanza Amazon.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento dei comandi per la CLI CDK.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-ignore-errors"></a>

 `--ignore-errors <BOOLEAN>`   
Ignora gli errori di sintesi, che probabilmente produrranno un output non valido.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-json"></a>

 `--json, -j <BOOLEAN>`   
Utilizzate JSON anziché YAML per i AWS CloudFormation modelli stampati su standard output (). `stdout`  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-lookups"></a>

 `--lookups <BOOLEAN>`   
Esegui ricerche contestuali.  
La sintesi avrà esito negativo se questo valore è valido `false` e se è necessario eseguire ricerche di contesto.  
 *Required*: No  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-options-no-color"></a>

 `--no-color <BOOLEAN>`   
Rimuovi il colore e altri stili dall'output della console.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-notices"></a>

 `--notices <BOOLEAN>`   
Mostra gli avvisi pertinenti.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-output"></a>

 `--output, -o <STRING>`   
Specificate la directory in cui inviare l'assembly cloud sintetizzato.  
 *Campo obbligatorio*: sì  
 *Valore predefinito*: `cdk.out` <a name="ref-cli-cmd-options-path-metadata"></a>

 `--path-metadata <BOOLEAN>`   
Includi `aws::cdk::path` AWS CloudFormation i metadati per ogni risorsa.  
 *Required*: No  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-options-plugin"></a>

 `--plugin, -p <ARRAY>`   
Nome o percorso di un pacchetto di nodi che estende le funzionalità CDK. Questa opzione può essere fornita più volte in un unico comando.  
Puoi configurare questa opzione nel `cdk.json` file del progetto o `~/.cdk.json` sul tuo computer di sviluppo locale:  

```
{
   // ...
   "plugin": [
      "module_1",
      "module_2"
   ],
   // ...
}
```
 *Required*: No<a name="ref-cli-cmd-options-profile"></a>

 `--profile <STRING>`   
Specificate il nome del AWS profilo, contenente le informazioni AWS sull'ambiente, da utilizzare con la CLI CDK.  
 *Campo obbligatorio*: sì<a name="ref-cli-cmd-options-proxy"></a>

 `--proxy <STRING>`   
Usa il proxy indicato.  
Se questa opzione non viene fornita, la CLI CDK leggerà dalla `HTTPS_PROXY` variabile di ambiente.  
 *Campo obbligatorio*: sì  
 *Valore predefinito*: letto dalla variabile di `HTTPS_PROXY` ambiente.<a name="ref-cli-cmd-options-role-arn"></a>

 `--role-arn, -r <STRING>`   
L'ARN del ruolo IAM che la CLI CDK assumerà durante l'interazione. AWS CloudFormation  
 *Required*: No<a name="ref-cli-cmd-options-staging"></a>

 `--staging <BOOLEAN>`   
Copia le risorse nella directory di output.  
Specificate `false` per impedire la copia delle risorse nella directory di output. Ciò consente alla CLI AWS SAM di fare riferimento ai file sorgente originali durante l'esecuzione del debug locale.  
 *Required*: No  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-options-strict"></a>

 `--strict <BOOLEAN>`   
Non costruite pile che contengano avvisi.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-trace"></a>

 `--trace <BOOLEAN>`   
Stampa la traccia per gli avvisi relativi agli stack.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-verbose"></a>

 `--verbose, -v <COUNT>`   
Mostra i registri di debug. È possibile specificare questa opzione più volte per aumentare la verbosità.  
 *Required*: No<a name="ref-cli-cmd-options-version"></a>

 `--version <BOOLEAN>`   
Mostra il numero di versione della CLI CDK.  
 *Required*: No  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-options-version-reporting"></a>

 `--version-reporting <BOOLEAN>`   
Includi la ` AWS::CDK::Metadata` risorsa nei modelli sintetizzati AWS CloudFormation .  
 *Required*: No  
 *Valore predefinito*: `true` 

## Fornitura e configurazione delle opzioni
<a name="ref-cli-cmd-configure"></a>

È possibile passare le opzioni tramite argomenti della riga di comando. Per la maggior parte delle opzioni, è possibile configurarle in un `cdk.json` file di configurazione. Quando si utilizzano più fonti di configurazione, la CLI CDK rispetta la seguente priorità:

1.  **Valori della riga di comando**: qualsiasi opzione fornita nella riga di comando sovrascrive le opzioni configurate nei file. `cdk.json`

1.  File di **configurazione del progetto: il `cdk.json` file** nella directory del progetto CDK.

1.  **File di configurazione utente**: il `cdk.json` file che si trova `~/.cdk.json` sul computer locale.

## Passaggio di opzioni dalla riga di comando
<a name="ref-cli-cmd-pass"></a><a name="ref-cli-cmd-pass-bool"></a>

 **Passaggio di valori booleani**   
Per le opzioni che accettano un valore booleano, è possibile specificarle nei seguenti modi:  
+ Uso `true` e `false` valori: fornite il valore booleano con il comando. Di seguito è riportato un esempio:

  ```
  $ cdk deploy --watch=true
  $ cdk deploy --watch=false
  ```
+ Fornisci la controparte dell'opzione: modifica il nome dell'opzione aggiungendo o specificando `no` un valore. `false` Di seguito è riportato un esempio:

  ```
  $ cdk deploy --watch
  $ cdk deploy --no-watch
  ```
+ Per le opzioni il cui valore predefinito è `true` o`false`, non è necessario fornire l'opzione a meno che non si desideri modificare l'impostazione predefinita.

# `cdk acknowledge`
<a name="ref-cli-cmd-ack"></a>

Conferma un avviso per numero di emissione e nascondilo per impedirne la visualizzazione successiva.

Ciò è utile per nascondere gli avvisi che sono stati risolti o che non ti riguardano.

I riconoscimenti vengono salvati a livello di progetto CDK. Se confermi una notifica in un progetto CDK, questa verrà comunque visualizzata in altri progetti fino a quando non verrà confermata.

## Utilizzo
<a name="ref-cli-cmd-ack-usage"></a>

```
$ cdk acknowledge <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-ack-args"></a><a name="ref-cli-cmd-ack-args-notice-id"></a>

 **ID dell'avviso**   
L'ID dell'avviso.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-ack-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-ack-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento relative al `cdk acknowledge` comando.

## Esempi
<a name="ref-cli-cmd-ack-examples"></a>

### Riconosci e nascondi un avviso che viene visualizzato quando si esegue un altro comando CDK CLI
<a name="ref-cli-cmd-ack-examples-1"></a>

```
$ cdk deploy
... # Normal output of the command

NOTICES

16603   Toggling off auto_delete_objects for Bucket empties the bucket

        Overview: If a stack is deployed with an S3 bucket with
                  auto_delete_objects=True, and then re-deployed with
                  auto_delete_objects=False, all the objects in the bucket
                  will be deleted.

        Affected versions: <1.126.0.

        More information at: https://github.com/aws/aws-cdk/issues/16603


17061   Error when building EKS cluster with monocdk import

        Overview: When using monocdk/aws-eks to build a stack containing
                  an EKS cluster, error is thrown about missing
                  lambda-layer-node-proxy-agent/layer/package.json.

        Affected versions: >=1.126.0 <=1.130.0.

        More information at: https://github.com/aws/aws-cdk/issues/17061

$ cdk acknowledge 16603
```

# `cdk bootstrap`
<a name="ref-cli-cmd-bootstrap"></a>

Prepara un AWS ambiente per le implementazioni CDK distribuendo lo stack di bootstrap CDK, denominato, nell'ambiente. `CDKToolkit` AWS 

Lo stack bootstrap è uno CloudFormation stack che fornisce un bucket Amazon S3 e un repository Amazon ECR nell'ambiente. AWS La CLI AWS CDK utilizza queste risorse per archiviare modelli sintetizzati e risorse correlate durante la distribuzione.

## Utilizzo
<a name="ref-cli-cmd-bootstrap-usage"></a>

```
$ cdk bootstrap <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-bootstrap-args"></a><a name="ref-cli-cmd-bootstrap-args-env"></a>

 ** AWS ambiente**   
L' AWS ambiente di destinazione in cui distribuire lo stack di bootstrap nel seguente formato:. `aws://<account-id>/<region>`  
Esempio: `aws://123456789012/us-east-1`   
Questo argomento può essere fornito più volte in un unico comando per distribuire lo stack di bootstrap in più ambienti.  
Per impostazione predefinita, la CLI CDK avvierà tutti gli ambienti a cui si fa riferimento nell'app CDK o determinerà un ambiente dalle sorgenti predefinite. Questo potrebbe essere un ambiente specificato utilizzando l'`--profile`opzione, dalle variabili di ambiente o dalle fonti AWS CLI predefinite.

## Opzioni
<a name="ref-cli-cmd-bootstrap-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-bootstrap-options-bootstrap-bucket-name"></a>

 `--bootstrap-bucket-name, --toolkit-bucket-name, -b <STRING>`   
Il nome del bucket Amazon S3 che verrà utilizzato dalla CLI CDK. Questo bucket verrà creato e al momento non deve esistere.  
Fornisci questa opzione per sostituire il nome predefinito del bucket Amazon S3.  
Quando usi questa opzione, potresti dover personalizzare la sintesi. Per ulteriori informazioni, consulta [Personalizzare la sintesi dello stack CDK](configure-synth.md#bootstrapping-custom-synth).  
 *Valore predefinito*: non definito<a name="ref-cli-cmd-bootstrap-options-bootstrap-customer-key"></a>

 `--bootstrap-customer-key <BOOLEAN>`   
Crea una Customer Master Key (CMK) per il bucket bootstrap (ti verrà addebitato un costo, ma puoi personalizzare le autorizzazioni, solo il bootstrap moderno).  
Questa opzione non è compatibile con. `--bootstrap-kms-key-id`  
 *Valore predefinito*: non definito<a name="ref-cli-cmd-bootstrap-options-bootstrap-kms-key-id"></a>

 `--bootstrap-kms-key-id <STRING>`   
L'ID della chiave master AWS KMS da utilizzare per la `SSE-KMS` crittografia.  
Fornisci questa opzione per sovrascrivere la chiave AWS KMS predefinita utilizzata per crittografare il bucket Amazon S3.  
Questa opzione non è compatibile con. `--bootstrap-customer-key`  
 *Valore predefinito*: non definito<a name="ref-cli-cmd-bootstrap-options-cloudformation-execution-policies"></a>

 `--cloudformation-execution-policies <ARRAY>`   
La policy ARNs IAM gestita da allegare al ruolo di implementazione assunto da AWS CloudFormation durante la distribuzione degli stack.  
Per impostazione predefinita, gli stack vengono distribuiti con autorizzazioni amministrative complete utilizzando la policy. `AdministratorAccess`  
È possibile fornire questa opzione più volte in un unico comando. Puoi anche fornire più stringhe ARNs come singola stringa, ARNs separandole da virgole. Di seguito è riportato un esempio:  

```
$ cdk bootstrap --cloudformation-execution-policies "arn:aws:iam::aws:policy/AWSLambda_FullAccess,arn:aws:iam::aws:policy/AWSCodeDeployFullAccess"
```
Per evitare errori di distribuzione, assicurati che le politiche specificate siano sufficienti per tutte le distribuzioni che eseguirai nell'ambiente da avviare.  
Questa opzione si applica solo al bootstrap moderno.  
Il moderno modello di bootstrap concede efficacemente le autorizzazioni implicite da `--cloudformation-execution-policies` a qualsiasi account nell'elenco. 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.
 *Valore predefinito*: `[]` <a name="ref-cli-cmd-bootstrap-options-custom-permissions-boundary"></a>

 `--custom-permissions-boundary, -cpb <STRING>`   
Specificate il nome di un limite di autorizzazioni da utilizzare.  
Questa opzione non è compatibile con. `--example-permissions-boundary`  
 *Valore predefinito*: non definito<a name="ref-cli-cmd-bootstrap-options-example-permissions-boundary"></a>

 `--example-permissions-boundary, -epb <BOOLEAN>`   
Utilizzate il limite delle autorizzazioni di esempio, fornito dal CDK. AWS   
Questa opzione non è compatibile con. `--custom-permissions-boundary`  
La politica sui limiti delle autorizzazioni fornita da CDK deve essere considerata un esempio. Modifica il contenuto e fai riferimento alla politica di esempio se stai testando la funzionalità. Convertitela in una nuova policy per le implementazioni effettive, se non ne esiste già una. La preoccupazione è evitare la deriva. Molto probabilmente, viene mantenuto un limite di autorizzazioni e prevede convenzioni dedicate, denominazione inclusa.  
[Per ulteriori informazioni sulla configurazione delle autorizzazioni, incluso l'utilizzo dei limiti delle autorizzazioni, consulta la Security and Safety Dev Guide.](https://github.com/aws/aws-cdk/wiki/Security-And-Safety-Dev-Guide)  
 Valore predefinito: non *definito*<a name="ref-cli-cmd-bootstrap-options-execute"></a>

 `--execute <BOOLEAN>`   
Configura se eseguire il set di modifiche.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-bootstrap-options-force"></a>

 `--force, -f <BOOLEAN>`   
Avvia sempre il bootstrap, anche se comporterebbe il downgrade della versione del modello di bootstrap.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-bootstrap-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del comando. `cdk bootstrap`<a name="ref-cli-cmd-bootstrap-options-previous-parameters"></a>

 `--previous-parameters <BOOLEAN>`   
Utilizzate i valori precedenti per i parametri esistenti.  
Una volta distribuito un modello di bootstrap con un set di parametri, è necessario impostare questa opzione `false` per modificare qualsiasi parametro nelle distribuzioni future. Quando`false`, è necessario fornire nuovamente tutti i parametri forniti in precedenza.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-bootstrap-options-public-access-block-configuration"></a>

 `--public-access-block-configuration <BOOLEAN>`   
Blocca la configurazione dell'accesso pubblico sul bucket Amazon S3 creato e utilizzato dalla CLI CDK.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-bootstrap-options-qualifier"></a>

 `--qualifier <STRING>`   
Valore di stringa a nove cifre unico per ogni stack di bootstrap. Questo valore viene aggiunto all'ID fisico delle risorse nello stack di bootstrap.  
Fornendo un qualificatore, si evitano conflitti tra i nomi delle risorse durante il provisioning di più stack di bootstrap nello stesso ambiente.  
Quando modificate il qualificatore, l'app CDK deve passare il valore modificato al sintetizzatore dello stack. [Per ulteriori informazioni, consulta Personalizzare la sintesi dello stack CDK.](configure-synth.md#bootstrapping-custom-synth)  
 *Valore predefinito*: `hnb659fds`. Questo valore non ha alcun significato.<a name="ref-cli-cmd-bootstrap-options-show-template"></a>

 `--show-template <BOOLEAN>`   
Invece di eseguire il bootstrap, stampa il modello di bootstrap corrente sullo standard output (). `stdout` È quindi possibile copiare e personalizzare il modello secondo necessità.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-bootstrap-options-tags"></a>

 `--tags, -t <ARRAY>`   
Tag da aggiungere allo stack di bootstrap nel formato di. `KEY=VALUE`  
 *Valore predefinito*: `[]` <a name="ref-cli-cmd-bootstrap-options-template"></a>

 `--template <STRING>`   
Usa il modello del file fornito invece di quello integrato.<a name="ref-cli-cmd-bootstrap-options-termination-protection"></a>

 `--termination-protection <BOOLEAN>`   
Attiva la protezione dalla AWS CloudFormation terminazione nello stack di bootstrap.  
Quando`true`, la protezione dalla terminazione è abilitata. Ciò impedisce che lo stack di bootstrap venga eliminato accidentalmente.  
*Per ulteriori informazioni sulla protezione dalla terminazione, consulta [Proteggere uno stack dall'eliminazione nella Guida per l'](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html)utente. AWS CloudFormation *  
 *Valore predefinito*: non definito<a name="ref-cli-cmd-bootstrap-options-toolkit-stack-name"></a>

 `--toolkit-stack-name <STRING>`   
Il nome dello stack di bootstrap da creare.  
Per impostazione predefinita, `cdk bootstrap` distribuisce uno stack denominato `CDKToolkit` nell'ambiente specificato. AWS Utilizzate questa opzione per fornire un nome diverso per lo stack di bootstrap.  
La CLI CDK utilizza questo valore per verificare la versione dello stack di bootstrap.  
 *Valore predefinito*: `CDKToolkit`   
 *Campo obbligatorio*: sì<a name="ref-cli-cmd-bootstrap-options-trust"></a>

 `--trust <ARRAY>`   
L' AWS account di IDs cui ci si deve fidare per eseguire le distribuzioni in questo ambiente.  
L'account che esegue il bootstrap sarà sempre considerato attendibile.  
Questa opzione richiede che tu fornisca anche. `--cloudformation-execution-policies`  
È possibile fornire questa opzione più volte in un unico comando.  
Questa opzione si applica solo al bootstrap moderno.  
Per aggiungere account affidabili a uno stack di bootstrap esistente, devi specificare tutti gli account attendibili, inclusi quelli che potresti aver fornito in precedenza. Se fornisci solo nuovi account da considerare attendibili, gli account precedentemente attendibili verranno rimossi.  
Di seguito è riportato un esempio in cui vengono considerati attendibili due account:  

```
$ cdk bootstrap aws://123456789012/us-west-2 --trust 234567890123 --trust 987654321098 --cloudformation-execution-policies arn:aws:iam::aws:policy/AdministratorAccess
 ⏳  Bootstrapping environment aws://123456789012/us-west-2...
Trusted accounts for deployment: 234567890123, 987654321098
Trusted accounts for lookup: (none)
Execution policies: arn:aws:iam::aws:policy/AdministratorAccess
CDKToolkit: creating CloudFormation changeset...
 ✅  Environment aws://123456789012/us-west-2 bootstrapped.
```
Il moderno modello di bootstrap concede in modo efficace le autorizzazioni implicite da `--cloudformation-execution-policies` a qualsiasi AWS account nell'elenco. `--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.
 *Valore predefinito*: `[]` <a name="ref-cli-cmd-bootstrap-options-trust-for-lookup"></a>

 `--trust-for-lookup <ARRAY>`   
L' AWS account di IDs cui ci si dovrebbe fidare per la ricerca di valori in questo ambiente.  
Utilizzate questa opzione per autorizzare gli account a sintetizzare gli stack che verranno distribuiti nell'ambiente, senza concedere loro effettivamente il permesso di distribuire direttamente tali stack.  
È possibile fornire questa opzione più volte in un unico comando.  
Questa opzione si applica solo al bootstrap moderno.  
 *Valore predefinito*: `[]` 

## Esempi
<a name="ref-cli-cmd-bootstrap-examples"></a>

### Avvia l' AWS ambiente specificato nel profilo prod
<a name="ref-cli-cmd-bootstrap-examples-1"></a>

```
$ cdk bootstrap --profile prod
```

### Distribuisci lo stack di bootstrap negli ambienti foo e bar
<a name="ref-cli-cmd-bootstrap-examples-2"></a>

```
$ cdk bootstrap --app='node bin/main.js' foo bar
```

### Esporta il modello di bootstrap per personalizzarlo
<a name="ref-cli-cmd-bootstrap-examples-3"></a>

Se hai requisiti specifici che non sono soddisfatti dal modello di bootstrap, puoi personalizzarlo in base alle tue esigenze.

Puoi esportare il modello di bootstrap, modificarlo e distribuirlo utilizzando. AWS CloudFormation Di seguito è riportato un esempio di esportazione del modello esistente:

```
$ cdk bootstrap --show-template > bootstrap-template.yaml
```

Puoi anche indicare alla CLI CDK di utilizzare un modello personalizzato. Di seguito è riportato un esempio:

```
$ cdk bootstrap --template my-bootstrap-template.yaml
```

### Bootstrap con un limite di autorizzazioni. Quindi, rimuovi quel limite di autorizzazioni
<a name="ref-cli-cmd-bootstrap-examples-4"></a>

Per eseguire il bootstrap con un limite di autorizzazioni personalizzato, eseguiamo quanto segue:

```
$ cdk bootstrap --custom-permissions-boundary my-permissions-boundary
```

Per rimuovere il limite delle autorizzazioni, eseguiamo quanto segue:

```
$ cdk bootstrap --no-previous-parameters
```

### Utilizzate un qualificatore per distinguere le risorse create per un ambiente di sviluppo
<a name="ref-cli-cmd-bootstrap-examples-5"></a>

```
$ cdk bootstrap --qualifier dev2024
```

# `cdk context`
<a name="ref-cli-cmd-context"></a>

Gestisci i valori di contesto memorizzati nella cache per la tua applicazione AWS CDK.

 Il *contesto* rappresenta le informazioni sulla configurazione e sull'ambiente che possono influenzare il modo in cui gli stack vengono sintetizzati e distribuiti. Utilizzare `cdk context` per eseguire queste operazioni:
+ Visualizza i valori di contesto configurati.
+ Imposta e gestisci i valori di contesto.
+ Rimuovere i valori di contesto.

## Utilizzo
<a name="ref-cli-cmd-context-usage"></a>

```
$ cdk context <options>
```

## Opzioni
<a name="ref-cli-cmd-context-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-context-options-clear"></a>

 `--clear <BOOLEAN>`   
Cancella tutto il contesto.<a name="ref-cli-cmd-context-options-force"></a>

 `--force, -f <BOOLEAN>`   
Ignora l'errore relativo alla chiave mancante.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-context-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk context` comando.<a name="ref-cli-cmd-context-options-reset"></a>

 `--reset, -e <STRING>`   
La chiave di contesto, o il relativo indice, da reimpostare.

# `cdk deploy`
<a name="ref-cli-cmd-deploy"></a>

Implementa uno o più AWS stack CDK nel tuo ambiente. AWS 

Durante l'implementazione, la CLI CDK emetterà indicatori di avanzamento, simili a quelli che possono essere osservati dalla AWS CloudFormation console.

Se l' AWS ambiente non è avviato, verranno implementati correttamente solo gli stack senza risorse e con modelli sintetizzati inferiori a 51.200 byte.

## Utilizzo
<a name="ref-cli-cmd-deploy-usage"></a>

```
$ cdk deploy <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-deploy-args"></a><a name="ref-cli-cmd-deploy-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dell'app da distribuire.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-deploy-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-deploy-options-all"></a>

 `--all <BOOLEAN>`   
Implementa tutti gli stack nella tua app CDK.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-deploy-options-asset-parallelism"></a>

 `--asset-parallelism <BOOLEAN>`   
Specificate se creare e pubblicare risorse in parallelo.<a name="ref-cli-cmd-deploy-options-asset-prebuild"></a>

 `--asset-prebuild <BOOLEAN>`   
Specificate se creare tutte le risorse prima di distribuire il primo stack. Questa opzione è utile per le build Docker non riuscite.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-deploy-options-build-exclude"></a>

 `--build-exclude, -E <ARRAY>`   
Non ricostruite l'asset con l'ID fornito.  
Questa opzione può essere specificata più volte in un unico comando.  
 *Valore predefinito*: `[]` <a name="ref-cli-cmd-deploy-options-change-set-name"></a>

 `--change-set-name <STRING>`   
Il nome del set di AWS CloudFormation modifiche da creare.  
Questa opzione non è compatibile con`--method='direct'`.<a name="ref-cli-cmd-deploy-options-concurrency"></a>

 `--concurrency <NUMBER>`   
Implementa più stack in parallelo tenendo conto delle dipendenze tra stack. Utilizza questa opzione per velocizzare le implementazioni. Devi comunque tenere conto di altri limiti AWS CloudFormation alla tariffa AWS dell'account.  
Fornisci un numero per specificare il numero massimo di distribuzioni simultanee (in base alla dipendenza) da eseguire.  
 *Valore predefinito*: `1` <a name="ref-cli-cmd-deploy-options-exclusively"></a>

 `--exclusively, -e <BOOLEAN>`   
Implementa solo gli stack richiesti e non include le dipendenze.<a name="ref-cli-cmd-deploy-options-force"></a>

 `--force, -f <BOOLEAN>`   
Quando esegui la distribuzione per aggiornare uno stack esistente, la CLI CDK confronterà il modello e i tag dello stack distribuito con lo stack che sta per essere distribuito. Se non viene rilevata alcuna modifica, la CLI CDK salterà la distribuzione.  
Per ignorare questo comportamento e distribuire sempre gli stack, anche se non viene rilevata alcuna modifica, utilizzate questa opzione.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-deploy-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento relative al comando. `cdk deploy`<a name="ref-cli-cmd-deploy-options-hotswap"></a>

 `--hotswap <BOOLEAN>`   
Implementazioni Hotswap per uno sviluppo più rapido. Questa opzione tenta di eseguire una distribuzione hotswap più rapida, se possibile. Ad esempio, se modifichi il codice di una funzione Lambda nell'app CDK, la CLI CDK aggiornerà la risorsa direttamente tramite il servizio APIs anziché eseguire una distribuzione. CloudFormation   
Se la CLI CDK rileva modifiche che non supportano l'hotswap, tali modifiche verranno ignorate e verrà visualizzato un messaggio. Se preferisci eseguire una CloudFormation distribuzione completa come alternativa, usa invece. `--hotswap-fallback`  
La CLI CDK utilizza le tue credenziali AWS correnti per eseguire le chiamate API. Non assume i ruoli del vostro stack di bootstrap, anche se il flag della `@aws-cdk/core:newStyleStackSynthesis` funzionalità è impostato su. `true` Questi ruoli non dispongono delle autorizzazioni necessarie per aggiornare le AWS risorse direttamente, senza utilizzarle. CloudFormation Per questo motivo, assicurati che le tue credenziali appartengano allo stesso AWS account degli stack su cui esegui le distribuzioni hotswap e che dispongano delle autorizzazioni IAM necessarie per aggiornare le risorse.  
L'hotswapping è attualmente supportato per le seguenti modifiche:  
+ Risorse di codice (incluse immagini Docker e codice in linea), modifiche ai tag e modifiche alla configurazione (sono supportate solo le variabili di descrizione e ambiente) delle funzioni Lambda.
+ Versioni Lambda e modifiche agli alias.
+ Modifiche alla definizione delle macchine a stati AWS Step Functions.
+ Modifiche agli asset dei container dei servizi Amazon ECS.
+ Modifiche agli asset del sito Web delle distribuzioni di bucket Amazon S3.
+ Modifiche all'origine e all'ambiente dei progetti. AWS CodeBuild 
+ Modifiche al modello di mappatura VTL per AWS AppSync resolver e funzioni.
+ Modifiche allo schema per AWS AppSync GraphQL APIs.
L'utilizzo di determinate funzioni CloudFormation intrinseche è supportato come parte di una distribuzione hotswap. Ciò include:  
+  `Ref` 
+  `Fn::GetAtt`— Supportato solo parzialmente. Fai riferimento a [questa implementazione](https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk/lib/api/evaluate-cloudformation-template.ts#L477-L492) per le risorse e gli attributi supportati.
+  `Fn::ImportValue` 
+  `Fn::Join` 
+  `Fn::Select` 
+  `Fn::Split` 
+  `Fn::Sub` 
Questa opzione è compatibile anche con gli stack annidati.  
+ Questa opzione introduce deliberatamente la deriva negli CloudFormation stack per velocizzare le distribuzioni. Per questo motivo, usatela solo per scopi di sviluppo. Non utilizzate questa opzione per le vostre implementazioni di produzione.
+ Questa opzione è considerata sperimentale e potrebbe subire cambiamenti epocali in futuro.
+ I valori predefiniti per alcuni parametri possono essere diversi con il parametro hotswap. Ad esempio, la percentuale minima di integrità di un servizio Amazon ECS sarà attualmente fissata a`0`. Se ciò si verifica, esamina la fonte di conseguenza.
 *Valore predefinito*: `false` <a name="ref-cli-cmd-deploy-options-hotswap-fallback"></a>

 `--hotswap-fallback <BOOLEAN>`   
Questa opzione è simile a`--hotswap`. La differenza è che, se viene rilevata una modifica che lo richiede, `--hotswap-fallback` verrà eseguita una CloudFormation distribuzione completa.  
Per ulteriori informazioni su questa opzione, consulta `--hotswap`.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-deploy-options-ignore-no-stacks"></a>

 `--ignore-no-stacks <BOOLEAN>`   
Esegui una distribuzione anche se l'app CDK non contiene pile.  
Questa opzione è utile nel seguente scenario: potresti avere un'app con più ambienti, come `dev` e. `prod` All'inizio dello sviluppo, l'app prod potrebbe non disporre di risorse o le risorse potrebbero essere commentate. Ciò comporterà un errore di distribuzione con un messaggio che indica che l'app non ha stack. Utilizzare `--ignore-no-stacks` per aggirare questo errore.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-deploy-options-import-existing-resources"></a>

 `--import-existing-resources <BOOLEAN>`   
Importa AWS CloudFormation risorse esistenti e non gestite dal tuo AWS account.  
Quando utilizzi questa opzione, le risorse del tuo AWS CloudFormation modello sintetizzato con lo stesso nome personalizzato delle risorse non gestite esistenti nello stesso account verranno importate nel tuo stack.  
È possibile utilizzare questa opzione per importare risorse esistenti in pile nuove o esistenti.  
È possibile importare risorse esistenti e distribuire nuove risorse con lo stesso `cdk deploy` comando.  
Per ulteriori informazioni sui nomi personalizzati, consulta [Name type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) nella *Guida per l' AWS CloudFormation utente*.  
Per ulteriori informazioni sul `ImportExistingResources` CloudFormation parametro, consulta [AWS CloudFormation Semplifica l'importazione delle risorse con un nuovo parametro per ChangeSets](https://aws.amazon.com/about-aws/whats-new/2023/11/aws-cloudformation-import-parameter-changesets/).  
Per ulteriori informazioni sull'utilizzo di questa opzione, consulta [Importare risorse esistenti](https://github.com/aws/aws-cdk-cli/tree/main/packages/aws-cdk#import-existing-resources) nel *aws-cdk-cli GitHub repository*.<a name="ref-cli-cmd-deploy-options-logs"></a>

 `--logs <BOOLEAN>`   
Mostra Amazon CloudWatch Log nello standard output (`stdout`) per tutti gli eventi di tutte le risorse negli stack selezionati.  
Questa opzione è compatibile solo con`--watch`.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-deploy-options-method"></a>

 `--method, -m <STRING>`   
Configura il metodo per eseguire una distribuzione.  
+  `change-set`— Metodo predefinito. La CLI CDK crea CloudFormation un set di modifiche con le modifiche che verranno distribuite, quindi esegue la distribuzione.
+  `direct`— Non creare un set di modifiche. Applica invece la modifica immediatamente. Questa operazione è in genere più rapida rispetto alla creazione di un set di modifiche, ma si perdono i dettagli sull'avanzamento della distribuzione nell'output della CLI.
+  `prepare-change-set`— Create un set di modifiche ma non eseguite la distribuzione. Ciò è utile se si dispone di strumenti esterni che esamineranno il set di modifiche o se si dispone di un processo di approvazione per i set di modifiche.
 *Valori validi*:`change-set`,, `direct` `prepare-change-set`   
 *Valore predefinito*: `change-set` <a name="ref-cli-cmd-deploy-options-notification-arns"></a>

 `--notification-arns <ARRAY>`   
Gli argomenti ARNs di Amazon SNS che CloudFormation notificheranno gli eventi relativi allo stack.<a name="ref-cli-cmd-deploy-options-outputs-file"></a>

 `--outputs-file, -O <STRING>`   
Il percorso in cui vengono scritti gli output dello stack delle distribuzioni.  
Dopo la distribuzione, gli output dello stack verranno scritti nel file di output specificato in formato JSON.  
Puoi configurare questa opzione nel `cdk.json` file del progetto o `~/.cdk.json` sul tuo computer di sviluppo locale:  

```
{
   "app": "npx ts-node bin/myproject.ts",
   // ...
   "outputsFile": "outputs.json"
}
```
Se vengono distribuiti più stack, gli output vengono scritti nello stesso file di output, organizzato da chiavi che rappresentano il nome dello stack.<a name="ref-cli-cmd-deploy-options-parameters"></a>

 `--parameters <ARRAY>`   
Passa parametri aggiuntivi durante la distribuzione. CloudFormation   
Questa opzione accetta un array nel seguente formato:`STACK:KEY=VALUE`.  
+  `STACK`— Il nome dello stack a cui associare il parametro.
+  `KEY`— Il nome del parametro dello stack.
+  `VALUE`— Il valore da trasmettere al momento della distribuzione.
Se non viene fornito un nome dello stack o se `*` viene fornito come nome dello stack, i parametri verranno applicati a tutti gli stack distribuiti. Se uno stack non utilizza il parametro, la distribuzione avrà esito negativo.  
I parametri non si propagano agli stack annidati. Per passare i parametri agli stack nidificati, utilizzate il costrutto. ` [NestedStack](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.NestedStack.html) `  
 *Valore predefinito*: `{}` <a name="ref-cli-cmd-deploy-options-previous-parameters"></a>

 `--previous-parameters <BOOLEAN>`   
Utilizzate i valori precedenti per i parametri esistenti.  
Quando questa opzione è impostata su`false`, è necessario specificare tutti i parametri in ogni distribuzione.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-deploy-options-progress"></a>

 `--progress <STRING>`   
Configura il modo in cui la CLI CDK mostra l'avanzamento della distribuzione.  
+  `bar`— Visualizza gli eventi di distribuzione dello stack come barra di avanzamento, con gli eventi relativi alla risorsa attualmente distribuita.
+  `events`— Fornisci una cronologia completa, inclusi tutti gli CloudFormation eventi.
Puoi anche configurare questa opzione nel `cdk.json` file del progetto o `~/.cdk.json` sul tuo computer di sviluppo locale:  

```
{
   "progress": "events"
}
```
 *Valori validi*: `bar`, `events`   
 *Valore predefinito*: `bar` <a name="ref-cli-cmd-deploy-options-require-approval"></a>

 `--require-approval <STRING>`   
Specificate quali modifiche sensibili alla sicurezza richiedono l'approvazione manuale.  
+  `any-change`— È richiesta l'approvazione manuale per qualsiasi modifica allo stack.
+  `broadening`— È richiesta l'approvazione manuale se le modifiche comportano un ampliamento delle autorizzazioni o delle regole del gruppo di sicurezza.
+  `never`— L'approvazione non è richiesta.
 *Valori validi*:`any-change`,`broadening`, `never`   
 *Valore predefinito*: `broadening` <a name="ref-cli-cmd-deploy-options-rollback"></a>

 `--rollback` \$1 `--no-rollback`, `-R`   
Durante la distribuzione, se una risorsa non viene creata o aggiornata, la distribuzione tornerà allo stato stabile più recente prima che venga ripristinata la CLI CDK. Tutte le modifiche apportate fino a quel momento verranno annullate. Le risorse create verranno eliminate e gli aggiornamenti apportati verranno ripristinati.  
`--no-rollback`Specificate di disattivare questo comportamento. Se una risorsa non viene creata o aggiornata, la CLI CDK lascerà invariate le modifiche apportate fino a quel momento e le restituirà. Ciò lascerà la distribuzione in uno stato di interruzione e interruzione. Da qui, puoi aggiornare il codice e riprovare a eseguire la distribuzione. Questo può essere utile negli ambienti di sviluppo in cui si eseguono iterazioni rapide.  
Se una distribuzione eseguita `--no-rollback` non riesce e si decide di eseguire il rollback della distribuzione, è possibile utilizzare il `cdk rollback` comando. Per ulteriori informazioni, consulta [cdk rollback.](ref-cli-cmd-rollback.md)  
Con`--no-rollback`, le distribuzioni che causano la sostituzione delle risorse falliranno sempre. È possibile utilizzare questo valore di opzione solo per le distribuzioni che aggiornano o creano nuove risorse.
 *Valore predefinito*: `--rollback` <a name="ref-cli-cmd-deploy-options-toolkit-stack-name"></a>

 `--toolkit-stack-name <STRING>`   
Il nome dello stack CDK Toolkit esistente.  
Per impostazione predefinita, `cdk bootstrap` distribuisce uno stack denominato `CDKToolkit` nell'ambiente specificato. AWS Utilizzate questa opzione per fornire un nome diverso per lo stack di bootstrap.  
La CLI CDK utilizza questo valore per verificare la versione dello stack di bootstrap.<a name="ref-cli-cmd-deploy-options-watch"></a>

 `--watch <BOOLEAN>`   
Osserva continuamente i file di progetto CDK e distribuisci automaticamente gli stack specificati quando vengono rilevate modifiche.  
Questa opzione implica `--hotswap` di default.  
Questa opzione ha un comando CLI CDK equivalente. Per ulteriori informazioni, consulta [cdk](ref-cli-cmd-watch.md) watch.

## Esempi
<a name="ref-cli-cmd-deploy-examples"></a>

### Distribuisci lo stack denominato MyStackName
<a name="ref-cli-cmd-deploy-examples-1"></a>

```
$ cdk deploy MyStackName --app='node bin/main.js'
```

### Distribuisci più stack in un'app
<a name="ref-cli-cmd-deploy-examples-2"></a>

Usa `cdk list` per elencare i tuoi stack:

```
$ cdk list
CdkHelloWorldStack
CdkStack2
CdkStack3
```

Per distribuire tutti gli stack, usa l'opzione: `--all`

```
$ cdk deploy --all
```

Per scegliere quali stack distribuire, fornisci i nomi degli stack come argomenti:

```
$ cdk deploy CdkHelloWorldStack CdkStack3
```

### Distribuisci gli stack di pipeline
<a name="ref-cli-cmd-deploy-examples-3"></a>

`cdk list`Utilizzatelo per mostrare i nomi degli stack come percorsi, mostrando dove si trovano nella gerarchia della pipeline:

```
$ cdk list
PipelineStack
PiplelineStack/Prod
PipelineStack/Prod/MyService
```

Usa l'`--all`opzione o la jolly `*` per distribuire tutti gli stack. Se hai una gerarchia di pile come descritta sopra `--all` e `*` abbinerai solo le pile del livello più alto. Per abbinare tutte le pile della gerarchia, usa. `**`

È possibile combinare questi modelli. Quanto segue distribuisce tutti gli stack dello stage: `Prod`

```
$ cdk deploy PipelineStack/Prod/**
```

### Passa i parametri al momento della distribuzione
<a name="ref-cli-cmd-deploy-examples-4"></a>

Definisci i parametri nel tuo stack CDK. Di seguito è riportato un esempio che crea un parametro denominato `TopicNameParam` per un argomento di Amazon SNS:

```
new sns.Topic(this, 'TopicParameter', {
    topicName: new cdk.CfnParameter(this, 'TopicNameParam').value.toString()
});
```

Per fornire un valore di parametro pari a`parameterized`, esegui quanto segue:

```
$ cdk deploy --parameters "MyStackName:TopicNameParam=parameterized"
```

È possibile sovrascrivere i valori dei parametri utilizzando l'`--force`opzione. Di seguito è riportato un esempio di sovrascrittura del nome dell'argomento di una distribuzione precedente:

```
$ cdk deploy --parameters "MyStackName:TopicNameParam=parameterName" --force
```

### Scrive gli output dello stack in un file dopo la distribuzione
<a name="ref-cli-cmd-deploy-examples-5"></a>

Definisci gli output nel tuo file stack CDK. Di seguito è riportato un esempio che crea un output per una funzione ARN:

```
const fn = new lambda.Function(this, "fn", {
  handler: "index.handler",
  code: lambda.Code.fromInline(`exports.handler = \${handler.toString()}`),
  runtime: lambda.Runtime.NODEJS_LATEST
});

new cdk.CfnOutput(this, 'FunctionArn', {
  value: fn.functionArn,
});
```

Distribuisci lo stack e scrivi gli output su: `outputs.json`

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

Di seguito è riportato un esempio di `outputs.json` post-implementazione:

```
{
  "MyStack": {
    "FunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:MyStack-fn5FF616E3-G632ITHSP5HK"
  }
}
```

In questo esempio, la chiave `FunctionArn` corrisponde all'ID logico dell'`CfnOutput`istanza.

Di seguito è riportato un esempio di `outputs.json` post-distribuzione quando vengono distribuiti più stack:

```
{
  "MyStack": {
    "FunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:MyStack-fn5FF616E3-G632ITHSP5HK"
  },
  "AnotherStack": {
    "VPCId": "vpc-z0mg270fee16693f"
  }
}
```

### Modifica il metodo di distribuzione
<a name="ref-cli-cmd-deploy-examples-6"></a>

Per una distribuzione più rapida, senza utilizzare set di modifiche, usa`--method='direct'`:

```
$ cdk deploy --method='direct'
```

Per creare un set di modifiche ma non distribuirlo, usa. `--method='prepare-change-set'` Per impostazione predefinita, `cdk-deploy-change-set` verrà creato un set di modifiche denominato. Se esiste un set di modifiche precedente con questo nome, verrà sovrascritto. Se non viene rilevata alcuna modifica, viene comunque creato un set di modifiche vuoto.

È inoltre possibile assegnare un nome al set di modifiche. Di seguito è riportato un esempio:

```
$ cdk deploy --method='prepare-change-set' --change-set-name='MyChangeSetName'
```

# `cdk destroy`
<a name="ref-cli-cmd-destroy"></a>

Elimina uno o più stack AWS CDK dal tuo ambiente. AWS 

Quando elimini uno stack, le risorse nello stack verranno distrutte, a meno che non siano state configurate con un of. `DeletionPolicy` `Retain`

Durante l'eliminazione dello stack, questo comando restituirà informazioni sullo stato di avanzamento simili al comportamento. `cdk deploy`

## Utilizzo
<a name="ref-cli-cmd-destroy-usage"></a>

```
$ cdk destroy <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-destroy-args"></a><a name="ref-cli-cmd-destroy-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dall'app da eliminare.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-destroy-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-destroy-options-all"></a>

 `--all <BOOLEAN>`   
Distruggi tutte le pile disponibili.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-destroy-options-exclusively"></a>

 `--exclusively, -e <BOOLEAN>`   
Distrugge solo gli stack richiesti e non include le dipendenze.<a name="ref-cli-cmd-destroy-options-force"></a>

 `--force, -f <BOOLEAN>`   
Non chiedete conferma prima di aver distrutto gli stack.<a name="ref-cli-cmd-destroy-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk destroy` comando.

## Esempi
<a name="ref-cli-cmd-destroy-examples"></a>

### Eliminare una pila denominata MyStackName
<a name="ref-cli-cmd-destroy-examples-1"></a>

```
$ cdk destroy --app='node bin/main.js' <MyStackName>
```

# `cdk diff`
<a name="ref-cli-cmd-diff"></a>

Esegui un diff per vedere le modifiche all'infrastruttura tra gli AWS stack CDK.

Questo comando viene in genere utilizzato per confrontare le differenze tra lo stato attuale degli stack nell'app CDK locale e gli stack distribuiti. Tuttavia, puoi anche confrontare uno stack distribuito con qualsiasi modello locale. AWS CloudFormation 

## Utilizzo
<a name="ref-cli-cmd-diff-usage"></a>

```
$ cdk diff <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-diff-args"></a><a name="ref-cli-cmd-diff-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK della tua app per eseguire una differenza.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-diff-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-diff-options-change-set"></a>

 `--change-set <BOOLEAN>`   
Specificate se creare un set di modifiche per analizzare le sostituzioni delle risorse.  
Quando`true`, la CLI CDK creerà AWS CloudFormation un set di modifiche per visualizzare le modifiche esatte che verranno apportate allo stack. Questo output include se le risorse verranno aggiornate o sostituite. La CLI CDK utilizza il ruolo di distribuzione anziché il ruolo di ricerca per eseguire questa azione.  
Quando`false`, viene eseguita una differenza più rapida ma meno accurata confrontando i modelli. CloudFormation Qualsiasi modifica rilevata alle proprietà che richiedono la sostituzione di risorse verrà visualizzata come una risorsa sostitutiva, anche se la modifica è puramente estetica, ad esempio la sostituzione di un riferimento di risorsa con un ARN codificato.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-diff-options-context-lines"></a>

 `--context-lines <NUMBER>`   
Numero di righe di contesto da includere nel rendering differenziale JSON arbitrario.  
 *Valore predefinito*: `3` <a name="ref-cli-cmd-diff-options-exclusively"></a>

 `--exclusively, -e <BOOLEAN>`   
Solo diff ha richiesto gli stack e non include le dipendenze.<a name="ref-cli-cmd-diff-options-fail"></a>

 `--fail <BOOLEAN>`   
Fallisci ed esci con un codice che indica `1` se vengono rilevate differenze.<a name="ref-cli-cmd-diff-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk diff` comando.<a name="ref-cli-cmd-diff-options-processed"></a>

 `--processed <BOOLEAN>`   
Specificate se effettuare il confronto con il modello con CloudFormation le trasformazioni già elaborate.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-diff-options-quiet"></a>

 `--quiet, -q <BOOLEAN>`   
Non stampate il nome dello stack CDK e il `cdk diff` messaggio predefinito `stdout` quando non vengono rilevate modifiche.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-diff-options-security-only"></a>

 `--security-only <BOOLEAN>`   
Differiscono solo per le modifiche di sicurezza estese.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-diff-options-strict"></a>

 `--strict <BOOLEAN>`   
Modifica `cdk diff` il comportamento per renderlo più preciso o rigoroso. Se impostato su true, la CLI CDK non filtrerà le risorse o i caratteri non ` AWS::CDK::Metadata` ASCII illeggibili.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-diff-options-template"></a>

 `--template <STRING>`   
Il percorso del CloudFormation modello con cui confrontare uno stack CDK.

## Esempi
<a name="ref-cli-cmd-diff-examples"></a>

### Differenza rispetto allo stack attualmente distribuito denominato MyStackName
<a name="ref-cli-cmd-diff-examples-1"></a>

La CLI CDK utilizza i seguenti simboli nell'output diff:
+  `[+]`— Identifica il codice o le risorse che verranno aggiunti se si distribuiscono le modifiche.
+  `[-]`— Identifica il codice o le risorse che verranno rimosse se si implementano le modifiche.
+  `[~]`— Identifica una risorsa o una proprietà che verrà modificata se si implementano le modifiche.

Di seguito è riportato un esempio che mostra una differenza di modifiche locali a una funzione Lambda:

```
$ cdk diff MyStackName
start: Building <asset-hash>:<account:Region>
success: Built <asset-hash>:<account:Region>
start: Publishing <asset-hash>:<account:Region>
success: Published <asset-hash>:<account:Region>
Hold on while we create a read-only change set to get a diff with accurate replacement information (use --no-change-set to use a less accurate but faster template-only diff)
Stack MyStackName
Resources
[~] AWS::Lambda::Function HelloWorldFunction <resource-logical-ID>
 └─ [~] Code
     └─ [~] .ZipFile:
         ├─ [-]
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello World!'),
          };
        };

         └─ [+]
        exports.handler = async function(event) {
          return {
            statusCode: 200,
            body: JSON.stringify('Hello from CDK!'),
          };
        };



✨  Number of stacks with differences: 1
```

Un `[~]` indicatore delle risorse che verranno modificate non sempre significa una sostituzione completa delle risorse:
+ Alcune proprietà della risorsa, ad esempio`Code`, aggiorneranno la risorsa.
+ Alcune proprietà delle risorse, ad esempio`FunctionName`, possono causare la sostituzione completa della risorsa.

### Differenza rispetto a un CloudFormation modello specifico
<a name="ref-cli-cmd-diff-examples-2"></a>

```
$ cdk diff MyStackName --app='node bin/main.js' --template-path='./MyStackNameTemplate.yaml'
```

### Differenzia uno stack locale con lo stack distribuito. Non stampare su stdout se non vengono rilevate modifiche
<a name="ref-cli-cmd-diff-examples-3"></a>

```
$ cdk diff MyStackName --app='node bin/main.js' --quiet
```

# `cdk docs`
<a name="ref-cli-cmd-docs"></a>

Apri la documentazione AWS CDK nel tuo browser.

## Utilizzo
<a name="ref-cli-cmd-docs-usage"></a>

```
$ cdk docs <options>
```

## Opzioni
<a name="ref-cli-cmd-docs-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-docs-options-browser"></a>

 `--browser, -b <STRING>`   
Il comando da utilizzare per aprire il browser, utilizzato `%u` come segnaposto per il percorso del file da aprire.  
 *Valore predefinito*: `open %u` <a name="ref-cli-cmd-docs-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk docs` comando.

## Esempi
<a name="ref-cli-cmd-docs-examples"></a>

### Apri la documentazione AWS CDK in Google Chrome
<a name="ref-cli-cmd-docs-examples-1"></a>

```
$ cdk docs --browser='chrome %u'
```

# `cdk doctor`
<a name="ref-cli-cmd-doctor"></a>

Consulta e visualizza informazioni utili sul progetto AWS CDK locale e sull'ambiente di sviluppo.

Queste informazioni possono aiutare a risolvere i problemi di CDK e devono essere fornite quando si inviano segnalazioni di bug.

## Utilizzo
<a name="ref-cli-cmd-doctor-usage"></a>

```
$ cdk doctor <options>
```

## Opzioni
<a name="ref-cli-cmd-doctor-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-doctor-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento relative al `cdk doctor` comando.

## Esempi
<a name="ref-cli-cmd-doctor-examples"></a>

### Semplice esempio del `cdk doctor` comando
<a name="ref-cli-cmd-doctor-examples-1"></a>

```
$ cdk doctor
ℹ️ CDK Version: 1.0.0 (build e64993a)
ℹ️ AWS environment variables:
  - AWS_EC2_METADATA_DISABLED = 1
  - AWS_SDK_LOAD_CONFIG = 1
```

# `cdk drift`
<a name="ref-cli-cmd-drift"></a>

Rileva le variazioni di configurazione per le risorse che definisci, gestisci e distribuisci utilizzando il AWS Cloud Development Kit (AWS CDK). La deriva si verifica quando la configurazione effettiva di uno stack differisce dalla configurazione prevista, il che si verifica quando le risorse vengono modificate all'esterno di. AWS CloudFormation

Questo comando identifica le risorse che sono state modificate (ad esempio, tramite la AWS console o la AWS CLI) confrontando il loro stato corrente con la configurazione prevista. Queste modifiche possono causare comportamenti imprevisti nell'infrastruttura.

Durante il rilevamento della deriva, la CLI CDK produrrà indicatori e risultati di avanzamento, mostrando:
+ Risorse che si sono discostate dalla configurazione prevista.
+ Il numero totale di risorse con deriva.
+ Un riepilogo che indica se è stata rilevata una deriva nella pila.

**Importante**  
I `cdk diff` comandi `cdk drift` and funzionano in modo diverso:  
 `cdk drift` CloudFormationchiama l'operazione di rilevamento della deriva per confrontare lo stato effettivo delle risorse in AWS («realtà») con la loro configurazione prevista in CloudFormation. Non tutte le AWS risorse supportano il rilevamento della deriva. Per un elenco delle risorse supportate, consulta il [supporto per i tipi di risorse](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import-supported-resources.html) nella *Guida per l' AWS CloudFormation utente*.
 `cdk diff`confronta il CloudFormation modello sintetizzato dal codice CDK locale con il modello dello stack distribuito. CloudFormation 
Da utilizzare `cdk drift` quando è necessario verificare se le risorse sono state modificate all'esterno CloudFormation (ad esempio, tramite la AWS console o la AWS CLI). Da utilizzare `cdk diff` quando si desidera visualizzare in anteprima l'impatto delle modifiche al codice locale sull'infrastruttura prima della distribuzione.

## Utilizzo
<a name="ref-cli-cmd-drift-usage"></a>

```
$ cdk drift <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-drift-args"></a><a name="ref-cli-cmd-drift-args-stack-name"></a>

 **Stack name (Nome stack)**   
Il nome dello stack di cui vuoi verificare la deriva. Lo stack deve essere stato precedentemente distribuito per eseguire CloudFormation il rilevamento della deriva.  
 *Tipo:* stringa  
 *Required*: No  
Se non viene specificato alcuno stack, il rilevamento della deriva verrà eseguito su tutti gli stack definiti nell'app CDK.

## Opzioni
<a name="ref-cli-cmd-drift-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-drift-options-fail"></a>

 `--fail <BOOLEAN>`   
Ritorna con il codice di uscita 1 se viene rilevata una deriva.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-drift-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk drift` comando.

## Esempi
<a name="ref-cli-cmd-drift-examples"></a>

### Controlla la deriva per uno stack specifico
<a name="ref-cli-cmd-drift-examples-stack"></a>

```
$ cdk drift MyStackName
```

Il comando produrrà risultati simili a:

```
Stack MyStackName
Modified Resources
[~] AWS::Lambda::Function MyFunction MyLambdaFunc1234ABCD
 └─ [~] /Description
     ├─ [-] My original hello world Lambda function
     └─ [+] My drifted hello world Lambda function

1 resource has drifted from their expected configuration

✨  Number of resources with drift: 1
```

### Controlla la deriva quando le risorse sono state eliminate
<a name="ref-cli-cmd-drift-examples-deleted"></a>

L'esempio seguente mostra l'aspetto dell'output quando le risorse sono state sia modificate che eliminate:

```
Stack MyStackName
Modified Resources
[~] AWS::Lambda::Function MyFunction MyLambdaFunc1234ABCD
 └─ [~] /Description
     ├─ [-] My original hello world Lambda function
     └─ [+] My drifted hello world Lambda function
Deleted Resources
[-] AWS::CloudWatch::Alarm MyAlarm MyCWAlarmABCD1234

2 resources have drifted from their expected configuration

✨  Number of resources with drift: 2
```

### Controlla la deriva con il codice di uscita
<a name="ref-cli-cmd-drift-examples-fail"></a>

Per fare in modo che il comando restituisca un codice di uscita diverso da zero se viene rilevata una deriva:

```
$ cdk drift MyStackName --fail
```

Ciò è utile nelle pipeline CI/CD per rilevare e rispondere automaticamente alla deriva dell'infrastruttura.

# `cdk flags`
<a name="ref-cli-cmd-flags"></a>

Visualizza e modifica le configurazioni dei feature flag per la CLI CDK.

I flag di funzionalità controllano il comportamento della CLI CDK e possono essere utilizzati per abilitare o disabilitare funzionalità specifiche. Utilizzate il `cdk flags` comando per visualizzare le configurazioni correnti dei feature flag e modificarle secondo necessità.

**avvertimento**  
Il `cdk flags` comando è in fase di sviluppo per il AWS CDK. Le funzionalità correnti di questo comando sono considerate pronte per la produzione e sicure da usare. Tuttavia, l'ambito di questo comando e le relative funzionalità sono soggetti a modifiche. Pertanto, è necessario attivare il consenso fornendo la `unstable=flags` possibilità di utilizzare questo comando.

## Utilizzo
<a name="ref-cli-cmd-flags-usage"></a>

```
$ cdk flags <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-flags-args"></a><a name="ref-cli-cmd-flags-args-flagname"></a>

 **NOME DELLA BANDIERA**   
Il nome del flag di funzionalità specifico che si desidera visualizzare o modificare.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-flags-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-flags-options-set"></a>

 `--set <BOOLEAN>`   
Modifica la configurazione di un flag di funzionalità.<a name="ref-cli-cmd-flags-options-all"></a>

 `--all <BOOLEAN>`   
Modifica o visualizza tutti i flag di funzionalità.<a name="ref-cli-cmd-flags-options-recommended"></a>

 `--recommended <BOOLEAN>`   
Cambia i flag negli stati consigliati.<a name="ref-cli-cmd-flags-options-default"></a>

 `--default <BOOLEAN>`   
Cambia le bandiere in stati predefiniti.<a name="ref-cli-cmd-flags-options-unconfigured"></a>

 `--unconfigured <BOOLEAN>`   
Modifica i flag delle funzionalità non configurati.<a name="ref-cli-cmd-flags-options-value"></a>

 `--value <STRING>`   
Il valore su cui impostare la configurazione dei feature flag.  
 *requireARG: true*<a name="ref-cli-cmd-flags-options-safe"></a>

 `--safe <BOOLEAN>`   
Abilita tutte le funzionalità che non influiscono sull'applicazione.<a name="ref-cli-cmd-flags-options-interactive"></a>

 `--interactive, -i <BOOLEAN>`   
Opzione interattiva per il comando flags.

## Esempi
<a name="ref-cli-cmd-flags-examples"></a>

### Visualizza le configurazioni dei flag delle funzionalità
<a name="ref-cli-cmd-flags-examples-1"></a>

Esegui `cdk flags` per visualizzare un rapporto sulle configurazioni dei tuoi feature flag che differiscono dai nostri stati consigliati. I flag non configurati sono etichettati con `<unset>` per indicare che al momento non hanno alcun valore. Le bandiere vengono visualizzate nel seguente ordine:
+ Bandiere impostate su un valore che non corrisponde al nostro valore consigliato
+ Bandiere che non hai configurato

```
$ cdk flags --unstable=flags
Feature Flag                           Recommended                       User
* @aws-cdk/...                              true                         false
* @aws-cdk/...                              true                         false
* @aws-cdk/...                              true                         <unset>
```

Puoi anche correre `cdk flags --all` per visualizzare un report di tutti i flag di funzionalità nel seguente ordine:
+ Bandiere impostate su un valore che corrisponde al nostro valore consigliato
+ Bandiere impostate su un valore che non corrisponde al nostro valore consigliato
+ Bandiere che non hai configurato

```
$ cdk flags --unstable=flags --all
Feature Flag                              Recommended                     User
@aws-cdk/...                                true                         true
* @aws-cdk/...                              true                         false
* @aws-cdk/...                              true                         false
* @aws-cdk/...                              true                         <unset>
```

### Modifica i valori dei flag delle funzionalità
<a name="ref-cli-cmd-flags-examples-2"></a>

Per modificare i flag delle funzionalità in modo interattivo, esegui `cdk flags --interactive` (o`cdk flags -i`) per visualizzare un elenco di opzioni di menu.

Per modificare ogni flag di funzionalità secondo il valore consigliato, esegui. `cdk flags --set --recommended --all` Questo comando mantiene la configurazione dei feature flag up-to-date con le ultime configurazioni dei feature flag di CDK. Tieni presente che l'esecuzione di questo comando può potenzialmente sovrascrivere i valori configurati esistenti.

```
$ cdk flags --unstable=flags --set --recommended --all
Feature Flag                              Recommended Value            User Value
* @aws-cdk/...                              true                         false
* @aws-cdk/...                              true                         false
* @aws-cdk/...                              true                         <unset>
  Synthesizing...
    Resources
    [~] AWS::S3::Bucket MyBucket
    └─ [~] Properties
        └─ [~] Encryption
                ...
    Number of stacks with differences: 2
  Do you want to accept these changes? (y/n) y
  Resynthesizing...
```

Se vuoi preservare lo stato dei flag configurati esistenti, esegui. `cdk flags --set --recommended --unconfigured` Questa opzione modifica solo i flag delle funzionalità non configurate in base ai valori consigliati.

```
$ cdk flags --unstable=flags --set --recommended --unconfigured
Feature Flag                              Recommended Value            User Value
* @aws-cdk/...                              true                         <unset>
* @aws-cdk/...                              true                         <unset>
  Synthesizing...
    Resources
    [~] AWS::S3::Bucket MyBucket
    └─ [~] Properties
        └─ [~] Encryption
            ├─ [-] None
            └─ [+] ServerSideEncryptionConfiguration:
                    - ...
            ...
    Number of stacks with differences: 2
  Do you want to accept these changes? (y/n) y
  Resynthesizing...
```

Se vuoi assicurarti che i flag di funzionalità non configurati non interferiscano con l'applicazione, esegui il `cdk flags --set --default --unconfigured` comando per riportare i flag non configurati ai valori predefiniti. Ad esempio, se non è configurato, `@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021` viene visualizzata una notifica dopo l'esecuzione. `cdk synth` Tuttavia, se imposti il flag allo stato predefinito (false), verrà configurato, disattivato e non avrà alcun impatto sull'applicazione.

```
$ cdk flags --unstable=flags --set --default --unconfigured
Feature Flag                              Recommended Value            User Value
* @aws-cdk/...                              true                         <unset>
* @aws-cdk/...                              true                         <unset>
  Synthesizing...

  Do you want to accept these changes? (y/n) y
  Resynthesizing...
```

### Ispeziona le bandiere di funzionalità specifiche
<a name="ref-cli-cmd-flags-examples-3"></a>

#### Visualizza ulteriori informazioni su una bandiera
<a name="_view_more_information_about_a_flag"></a>

Oltre a eseguire `cdk flags` e `cdk flags --all` visualizzare la configurazione del flag di funzionalità, potete anche `cdk flags "FLAGNAME"` ispezionare un flag di funzionalità specifico e scoprire a cosa serve il flag. Questo può essere utile nei casi in cui desideri comprendere un particolare flag e il suo impatto sull'applicazione.

```
$ cdk flags --unstable=flags "@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021"
    Description: Enable this feature flag to have cloudfront distributions use the security policy TLSv1.2_2021 by default.
    Recommended Value: true
    User Value: true
```

#### Filtra i flag per sottostringa
<a name="_filter_flags_by_substring"></a>

Puoi anche eseguire l'operazione `cdk flags substring` per visualizzare tutti i flag di funzionalità corrispondenti. Se esiste un solo flag di funzionalità che corrisponde a quella sottostringa, vengono visualizzati dettagli specifici.

```
$ cdk flags --unstable=flags ebs
@aws-cdk/aws-ec2:ebsDefaultGp3Volume
    Description: When enabled, the default volume type of the EBS volume will be GP3
    Recommended Value: true
    User Value: true
```

Se più flag corrispondono alla sottostringa, tutti i flag corrispondenti vengono visualizzati in una tabella. Se si inseriscono più sottostringhe, vengono restituiti tutti i flag corrispondenti che contengono una qualsiasi delle sottostringhe.

```
$ cdk flags --unstable=flags s3 lambda
Feature Flag                              Recommended                     User
* @aws-cdk/s3...                            true                         false
* @aws-cdk/lambda...                        true                         false
* @aws-cdk/lambda...                        true                         <unset>
```

#### Modifica un flag specifico
<a name="_modify_a_specific_flag"></a>

Se devi modificare il valore di un flag e vuoi assicurarti di impostarlo su uno stato corretto e supportato, esegui`cdk flags --set "FLAGNAME" --value="state"`.

```
$ cdk flags --unstable=flags --set "@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021" --value="true"
  Synthesizing...
    Resources
    [~] AWS::CloudFront::Distribution MyDistribution
    └─ [~] Properties
        └─ [~] DefaultSecurityPolicy
            ├─ [-] TLSv1.0
            └─ [+] TLSv1.2_2021
                    - ...
    Number of stacks with differences: 2
  Do you want to accept these changes? (y/n) y
  Resynthesizing...
```

# `cdk gc`
<a name="ref-cli-cmd-gc"></a>

Utilizza il comando CLI (Command Line Interface) del AWS Cloud Development Kit (AWS CDK`cdk gc`) per eseguire la raccolta dei rifiuti sugli asset inutilizzati archiviati nelle risorse del tuo stack di bootstrap. Usa questo comando per visualizzare, gestire ed eliminare le risorse che non ti servono più.

Per gli asset Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3), l'interfaccia a riga di comando CDK controllerà i modelli AWS CloudFormation esistenti nello stesso ambiente per verificare se vi sono riferimenti. Se non vengono citati, verranno considerati inutilizzati e idonei per le azioni di raccolta dei rifiuti.

**avvertimento**  
Il `cdk gc` comando è in fase di sviluppo per il CDK. AWS Le funzionalità correnti di questo comando sono considerate pronte per la produzione e sicure da usare. Tuttavia, l'ambito di questo comando e le relative funzionalità sono soggetti a modifiche. Pertanto, è necessario attivare il consenso fornendo la `unstable=gc` possibilità di utilizzare questo comando.

## Utilizzo
<a name="ref-cli-cmd-gc-usage"></a>

```
$ cdk gc <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-gc-args"></a><a name="ref-cli-cmd-gc-args-env"></a>

 ** AWS ambiente**   
L' AWS ambiente di destinazione su cui eseguire le azioni di raccolta dei rifiuti.  
Quando si fornisce un ambiente, utilizzare il seguente formato:. `aws://<account-id>/<region>` Ad esempio, `aws://<123456789012>/<us-east-1>`.  
Questo argomento può essere fornito più volte in un unico comando per eseguire azioni di raccolta dei rifiuti su più ambienti.  
Per impostazione predefinita, la CLI CDK eseguirà azioni di raccolta dei rifiuti su tutti gli ambienti a cui fai riferimento nell'app CDK o fornisci come argomenti. Se non fornite un ambiente, la CLI CDK determinerà l'ambiente dalle fonti predefinite. Queste fonti includono ambienti specificati utilizzando l'`--profile`opzione, le variabili di ambiente o le fonti AWS CLI predefinite.

## Opzioni
<a name="ref-cli-cmd-gc-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-gc-options-action"></a>

 `--action <STRING>`   
L'azione che viene `cdk gc` eseguita sulle risorse durante una raccolta dei rifiuti.  
+  `delete-tagged`— Elimina le risorse a cui è stata assegnata una data compresa nell'intervallo di giorni di buffer fornito, ma non contrassegna le risorse non utilizzate identificate di recente.
+  `full`— Esegue tutte le azioni di raccolta dei rifiuti. Ciò include l'eliminazione delle risorse entro l'intervallo di giorni di buffer fornito e l'etichettatura delle risorse non utilizzate appena identificate.
+  `print`— Visualizza il numero di risorse inutilizzate al prompt dei comandi ma non apporta alcuna modifica effettiva all'interno dell'ambiente. AWS 
+  `tag`— Etichetta tutte le nuove risorse non utilizzate identificate, ma non elimina le risorse che rientrano nell'intervallo di giorni di buffer fornito.
 *Valori accettati*:`delete-tagged`,,, `full` `print` `tag`   
 *Valore predefinito*: `full` <a name="ref-cli-cmd-gc-options-bootstrap-stack-name"></a>

 `--bootstrap-stack-name <STRING>`   
Il nome dello stack di bootstrap CDK nel tuo ambiente. AWS Fornisci questa opzione se hai personalizzato il nome dello stack di bootstrap. Se utilizzi il nome dello `CDKToolkit` stack predefinito, non devi fornire questa opzione.  
 *Valore predefinito*: `CDKToolkit` <a name="ref-cli-cmd-gc-options-confirm"></a>

 `--confirm <BOOLEAN>`   
Specificate se la CLI CDK richiederà una conferma manuale da parte vostra prima di eliminare qualsiasi risorsa.  
Specificate `false` di eliminare automaticamente le risorse senza richiedere una conferma manuale.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-gc-options-created-buffer-days"></a>

 `--created-buffer-days <NUMBER>`   
Il numero di giorni in cui una risorsa deve esistere prima che sia idonea per le azioni di raccolta dei rifiuti.  
Quando fornite un numero, le risorse che non sono esistite oltre il numero di giorni specificato vengono escluse dalle azioni di raccolta dei rifiuti.  
 *Valore predefinito*: `1` <a name="ref-cli-cmd-gc-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del comando. `cdk gc`<a name="ref-cli-cmd-gc-options-rollback-buffer-days"></a>

 `--rollback-buffer-days <NUMBER>`   
Il numero di giorni in cui una risorsa deve essere etichettata come isolata prima che sia idonea per le azioni di raccolta dei rifiuti.  
Quando fornite un numero, la CLI CDK taggherà le risorse inutilizzate con la data corrente invece di eliminarle. La CLI CDK controllerà anche se alcune risorse sono state taggate durante le esecuzioni precedenti del `cdk gc` comando. Le risorse precedentemente etichettate che rientrano nell'intervallo di giorni di buffer fornito verranno eliminate.  
 *Valore predefinito*: `0` <a name="ref-cli-cmd-gc-options-type"></a>

 `--type <STRING>`   
Il tipo di risorsa bootstrap all'interno dello stack bootstrap su cui eseguire azioni di raccolta dei rifiuti.  
+  `all`— Esegui azioni di raccolta dei rifiuti su tutte le risorse avviate.
+  `ecr`— Esegui azioni di raccolta dei rifiuti sugli asset nel repository Amazon Elastic Container Registry (Amazon ECR) del tuo stack di bootstrap.
+  `s3`— Esegui azioni di raccolta dei rifiuti sugli asset nel bucket Amazon S3 del tuo stack di bootstrap.
 *Valori `all` accettati:,,* `ecr` `s3`   
 *Valore predefinito*: `all` <a name="ref-cli-cmd-gc-options-unstable"></a>

 `--unstable <STRING>`   
Consenti l'utilizzo di comandi CLI CDK che sono ancora in fase di sviluppo.  
Questa opzione è necessaria per utilizzare qualsiasi comando CDK CLI ancora in fase di sviluppo e soggetto a modifiche.  
Questa opzione può essere fornita più volte in un unico comando.  
Da usare`cdk gc`, fornisci`--unstable=gc`.

## Esempi
<a name="ref-cli-cmd-gc-examples"></a>

### Esempi di base
<a name="ref-cli-cmd-gc-examples-basic"></a>

L'esempio seguente richiede una conferma manuale per eseguire azioni di raccolta dei rifiuti predefinite sugli asset nel bucket Amazon S3 dello stack di bootstrap:

```
$ cdk gc --unstable=gc --type=s3

 ⏳  Garbage Collecting environment aws://<account-id>/<region>...
Found 99 assets to delete based off of the following criteria:
- assets have been isolated for > 0 days
- assets were created > 1 days ago

Delete this batch (yes/no/delete-all)?
```

L'esempio seguente esegue azioni di raccolta dei rifiuti su una serie di risorse nel bucket Amazon S3 dello stack di bootstrap. Questo intervallo include risorse che sono state precedentemente etichettate da `cdk gc` per oltre 30 giorni e che sono state create almeno 10 giorni fa. Questo comando richiederà una conferma manuale prima di eliminare qualsiasi risorsa:

```
$ cdk gc --unstable=gc --type=s3 --rollback-buffer-days=30 --created-buffer-days=10
```

L'esempio seguente esegue l'azione di eliminazione degli asset precedentemente etichettati nel bucket Amazon S3 dello stack di bootstrap che sono rimasti inutilizzati per più di 30 giorni:

```
$ cdk gc --unstable=gc --type=s3 --action=delete-tagged --rollback-buffer-days=30
```

# `cdk import`
<a name="ref-cli-cmd-import"></a>

Usa [le importazioni di AWS CloudFormation risorse](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import.html) per importare AWS le risorse esistenti in uno stack CDK.

Con questo comando, puoi prendere le risorse esistenti create con altri metodi e iniziare a gestirle utilizzando il AWS CDK.

Quando si considera di spostare le risorse nella gestione CDK, a volte è accettabile creare nuove risorse, ad esempio con i ruoli IAM, le funzioni Lambda e le regole degli eventi. Per altre risorse, come le risorse stateful come i bucket Amazon S3 e le tabelle DynamoDB, la creazione di nuove risorse può avere un impatto sul servizio. Puoi utilizzarle `cdk import` per importare risorse esistenti con interruzioni minime dei tuoi servizi. Per un elenco delle AWS risorse supportate, consulta [Resource type support](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import-supported-resources.html) nella *Guida per l' AWS CloudFormation utente*.

 **Per importare una risorsa esistente in uno stack CDK**   

1. Esegui un comando `cdk diff` per assicurarti che lo stack CDK non abbia modifiche in sospeso. Quando si esegue un`cdk import`, le uniche modifiche consentite in un'operazione di importazione sono l'aggiunta di nuove risorse da importare.

1. Aggiungi costrutti per le risorse che desideri importare nel tuo stack. Ad esempio, aggiungi quanto segue per un bucket Amazon S3:

   ```
   new s3.Bucket(this, 'ImportedS3Bucket', {});
   ```

   Non aggiungere altre modifiche. È inoltre necessario assicurarsi di modellare esattamente lo stato attuale della risorsa. 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.

1. Esegui `cdk import`. Se nell'app CDK sono presenti più stack, inserisci un nome di stack specifico come argomento.

1. La CLI CDK ti chiederà di inserire i nomi effettivi delle risorse che stai importando. Dopo aver fornito queste informazioni, l'importazione avrà inizio.

1. Quando viene `cdk import` segnalato un esito positivo, la risorsa verrà gestita dal CDK. Eventuali modifiche successive nella configurazione del costrutto si rifletteranno sulla risorsa.

Questa funzionalità presenta attualmente le seguenti limitazioni:
+ L'importazione di risorse in pile annidate non è possibile.
+ Non è possibile verificare se le proprietà specificate sono corrette e complete per la risorsa importata. Prova ad avviare un'operazione di rilevamento della deriva dopo l'importazione.
+ Le risorse che dipendono da altre risorse devono essere importate tutte insieme o singolarmente, nell'ordine corretto. In caso contrario, la CloudFormation distribuzione avrà esito negativo con riferimenti irrisolti.
+ Questo comando utilizza le credenziali del ruolo deploy, necessarie per leggere il bucket di staging crittografato. Ciò richiede la versione 12 del modello di bootstrap, che include le autorizzazioni IAM necessarie per il ruolo di distribuzione.

## Utilizzo
<a name="ref-cli-cmd-import-usage"></a>

```
$ cdk import <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-import-args"></a><a name="ref-cli-cmd-import-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dell'app in cui importare le risorse. Questo argomento può essere fornito più volte in un unico comando.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-import-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-import-options-change-set-name"></a>

 `--change-set-name <STRING>`   
Il nome del set di CloudFormation modifiche da creare.<a name="ref-cli-cmd-import-options-execute"></a>

 `--execute <BOOLEAN>`   
Specificare se eseguire il set di modifiche.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-import-options-force"></a>

 `--force, -f <BOOLEAN>`   
Per impostazione predefinita, la CLI CDK chiude il processo se la differenza del modello include aggiornamenti o eliminazioni. Specificate `true` di ignorare questo comportamento e continuate sempre con l'importazione.<a name="ref-cli-cmd-import-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk import` comando.<a name="ref-cli-cmd-import-options-record-resource-mapping"></a>

 `--record-resource-mapping, -r <STRING>`   
Utilizzate questa opzione per generare una mappatura delle risorse fisiche esistenti rispetto alle risorse CDK che verranno importate. La mappatura verrà scritta nel percorso del file fornito. Non verrà eseguita alcuna operazione di importazione effettiva.<a name="ref-cli-cmd-import-options-resource-mapping"></a>

 `--resource-mapping, -m <STRING>`   
Utilizzate questa opzione per specificare un file che definisca la mappatura delle risorse. La CLI CDK utilizzerà questo file per mappare le risorse fisiche alle risorse da importare invece di chiedertelo in modo interattivo.  
Questa opzione può essere eseguita dagli script.<a name="ref-cli-cmd-import-options-rollback"></a>

 `--rollback <BOOLEAN>`   
Ripristina lo stack allo stato stabile in caso di errore.  
Per specificare`false`, puoi usare `--no-rollback` o`-R`.  
Specificate `false` per iterare più rapidamente. Le distribuzioni contenenti risorse sostitutive falliranno sempre.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-import-options-toolkit-stack-name"></a>

 `--toolkit-stack-name <STRING>`   
Il nome dello stack CDK Toolkit da creare.  
Per impostazione predefinita, `cdk bootstrap` distribuisce uno stack denominato `CDKToolkit` nell'ambiente specificato. AWS Utilizzate questa opzione per fornire un nome diverso per lo stack di bootstrap.  
La CLI CDK utilizza questo valore per verificare la versione dello stack di bootstrap.

# `cdk init`
<a name="ref-cli-cmd-init"></a>

Crea un nuovo progetto AWS CDK da un modello.

## Utilizzo
<a name="ref-cli-cmd-init-usage"></a>

```
$ cdk init <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-init-args"></a><a name="ref-cli-cmd-init-args-template-type"></a>

 **Tipo di modello**   
Il tipo di modello CDK da cui inizializzare un nuovo progetto CDK.  
+  `app`— Modello per un'applicazione CDK.
+  `lib`— Modello per una libreria AWS Construct.
+  `sample-app`— Esempio di applicazione CDK che include alcuni costrutti.
 *Valori validi*:`app`,, `lib` `sample-app` 

## Opzioni
<a name="ref-cli-cmd-init-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-init-options-generate-only"></a>

 `--generate-only <BOOLEAN>`   
Specificate questa opzione per generare file di progetto senza avviare operazioni aggiuntive come la configurazione di un repository git, l'installazione di dipendenze o la compilazione del progetto.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-init-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del comando. `cdk init`<a name="ref-cli-cmd-init-options-language"></a>

 `--language, -l <STRING>`   
La lingua da usare per il nuovo progetto. Questa opzione può essere configurata nel file di `cdk.json` configurazione del progetto o `~/.cdk.json` sul computer di sviluppo locale.  
 *Valori validi*: `csharp``fsharp`,`go`,`java`,`javascript`,`python`, `typescript` <a name="ref-cli-cmd-init-options-list"></a>

 `--list <BOOLEAN>`   
Elenca i tipi di template e le lingue disponibili.

## Esempi
<a name="ref-cli-cmd-init-examples"></a>

### Elenca i tipi di template e le lingue disponibili
<a name="ref-cli-cmd-init-examples-1"></a>

```
$ cdk init --list
Available templates:
* app: Template for a CDK Application
   └─ cdk init app --language=[csharp|fsharp|go|java|javascript|python|typescript]
* lib: Template for a CDK Construct Library
   └─ cdk init lib --language=typescript
* sample-app: Example CDK Application with some constructs
   └─ cdk init sample-app --language=[csharp|fsharp|go|java|javascript|python|typescript]
```

### Crea una nuova app CDK TypeScript dal modello di libreria
<a name="ref-cli-cmd-init-examples-2"></a>

```
$ cdk init lib --language=typescript
```

# `cdk list`
<a name="ref-cli-cmd-list"></a>

Elenca tutti gli stack AWS CDK e le loro dipendenze da un'app CDK.

## Utilizzo
<a name="ref-cli-cmd-list-usage"></a>

```
$ cdk list <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-list-args"></a><a name="ref-cli-cmd-list-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dell'app su cui eseguire questo comando.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-list-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-list-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento relative al `cdk list` comando.<a name="ref-cli-cmd-list-options-long"></a>

 `--long, -l <BOOLEAN>`   
Visualizza le informazioni sull' AWS ambiente per ogni stack.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-list-options-show-dependencies"></a>

 `--show-dependencies, -d <BOOLEAN>`   
Visualizza le informazioni sulla dipendenza dello stack per ogni stack.  
 *Valore predefinito*: `false` 

## Esempi
<a name="ref-cli-cmd-list-examples"></a>

### Elenca tutti gli stack nell'app CDK «node bin/main.js»
<a name="ref-cli-cmd-list-examples-1"></a>

```
$ cdk list --app='node bin/main.js'
Foo
Bar
Baz
```

### Elenca tutti gli stack, inclusi i dettagli AWS dell'ambiente per ogni stack
<a name="ref-cli-cmd-list-examples-"></a>

```
$ cdk list --app='node bin/main.js' --long
-
    name: Foo
    environment:
        name: 000000000000/bermuda-triangle-1
        account: '000000000000'
        region: bermuda-triangle-1
-
    name: Bar
    environment:
        name: 111111111111/bermuda-triangle-2
        account: '111111111111'
        region: bermuda-triangle-2
-
    name: Baz
    environment:
        name: 333333333333/bermuda-triangle-3
        account: '333333333333'
        region: bermuda-triangle-3
```

# `cdk metadata`
<a name="ref-cli-cmd-metadata"></a>

Visualizza i metadati associati a uno stack CDK.

## Utilizzo
<a name="ref-cli-cmd-metadata-usage"></a>

```
$ cdk metadata <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-metadata-args"></a><a name="ref-cli-cmd-metadata-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dell'app per cui visualizzare i metadati.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-metadata-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-metadata-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento relative al `cdk metadata` comando.

# `cdk migrate`
<a name="ref-cli-cdk-migrate"></a>

Migra AWS le risorse, gli AWS CloudFormation stack e i CloudFormation modelli distribuiti in un nuovo progetto CDK. AWS 

Questo comando crea una nuova app CDK che include un singolo stack denominato con il valore fornito utilizzando. `--stack-name` È possibile configurare l'origine della migrazione utilizzando `--from-scan``--from-stack`, o. `--from-path`

Per ulteriori informazioni sull'utilizzo`cdk migrate`, consulta [Migrare risorse e AWS CloudFormation modelli esistenti al AWS CDK](migrate.md).

**Nota**  
Il `cdk migrate` comando è sperimentale e potrebbe subire modifiche sostanziali in futuro.

## Utilizzo
<a name="ref-cli-cdk-migrate-usage"></a>

```
$ cdk migrate <options>
```

## Opzioni
<a name="ref-cli-cdk-migrate-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.

### Opzioni richieste
<a name="ref-cli-cdk-migrate-options-required"></a><a name="ref-cli-cdk-migrate-options-stack-name"></a>

 `--stack-name <STRING>`   
Il nome dello AWS CloudFormation stack che verrà creato all'interno dell'app CDK dopo la migrazione.  
 *Campo obbligatorio*: sì

### Opzioni condizionali
<a name="ref-cli-cdk-migrate-options-conditional"></a><a name="ref-cli-cdk-migrate-options-from-path"></a>

 `--from-path <PATH>`   
Il percorso del AWS CloudFormation modello da migrare. Fornisci questa opzione per specificare un modello locale.  
 *Obbligatorio:* condizionale. Obbligatorio in caso di migrazione da un AWS CloudFormation modello locale.<a name="ref-cli-cdk-migrate-options-from-scan"></a>

 `--from-scan <STRING>`   
Durante la migrazione delle risorse distribuite da un AWS ambiente, utilizzate questa opzione per specificare se avviare una nuova scansione o se la CLI AWS CDK deve utilizzare l'ultima scansione riuscita.  
 *Obbligatorio:* condizionale. Richiesto per la migrazione dalle risorse distribuite. AWS   
 *Valori accettati*:, `most-recent` `new` <a name="ref-cli-cdk-migrate-options-from-stack"></a>

 `--from-stack <BOOLEAN>`   
Fornisci questa opzione per migrare da uno stack distribuito AWS CloudFormation . Utilizzare `--stack-name` per specificare il nome dello stack distribuito. AWS CloudFormation   
 *Obbligatorio:* condizionale. Obbligatorio in caso di migrazione da uno stack distribuito. AWS CloudFormation 

### Opzioni opzionali
<a name="ref-cli-cdk-migrate-options-optional"></a><a name="ref-cli-cdk-migrate-options-account"></a>

 `--account <STRING>`   
L'account da cui recuperare il modello dello AWS CloudFormation stack.  
 *Required*: No  
 *Predefinito*: la CLI AWS CDK ottiene le informazioni sull'account da fonti predefinite.<a name="ref-cli-cdk-migrate-options-compress"></a>

 `--compress <BOOLEAN>`   
Fornite questa opzione per comprimere il progetto CDK generato in un file. `ZIP`  
 *Required*: No<a name="ref-cli-cdk-migrate-options-filter"></a>

 `--filter <ARRAY>`   
Da utilizzare per la migrazione delle risorse distribuite da un account e da una AWS regione. AWS Questa opzione specifica un filtro per determinare quali risorse distribuite migrare.  
Questa opzione accetta una matrice di coppie chiave-valore, dove **key** rappresenta il tipo di filtro e **value rappresenta il valore** da filtrare.  
Sono accettate le seguenti chiavi:  
+  `resource-identifier`— Un identificatore per la risorsa. Il valore può essere l'ID logico o fisico della risorsa. Ad esempio, `resource-identifier="ClusterName"`.
+  `resource-type-prefix`— Il prefisso del tipo di AWS CloudFormation risorsa. Ad esempio, specifica di `resource-type-prefix="AWS::DynamoDB::"` filtrare tutte le risorse Amazon DynamoDB.
+  `tag-key`— La chiave di un tag di risorsa. Ad esempio, `tag-key="myTagKey"`.
+  `tag-value`— Il valore di un tag di risorsa. Ad esempio, `tag-value="myTagValue"`.
Fornisci più coppie chiave-valore per la logica `AND` condizionale. L'esempio seguente filtra per qualsiasi risorsa DynamoDB `myTagKey` etichettata come chiave tag:. `--filter resource-type-prefix="AWS::DynamoDB::", tag-key="myTagKey"`  
Fornisci l'`--filter`opzione più volte in un unico comando per la logica `OR` condizionale. L'esempio seguente filtra per qualsiasi risorsa che sia una risorsa DynamoDB o contrassegnata come chiave tag`myTagKey`:. `--filter resource-type-prefix="AWS::DynamoDB::" --filter tag-key="myTagKey"`  
 *Required*: No<a name="ref-cli-cdk-migrate-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk migrate` comando.<a name="ref-cli-cdk-migrate-options-language"></a>

 `--language <STRING>`   
Il linguaggio di programmazione da utilizzare per il progetto CDK creato durante la migrazione.  
 *Required*: No  
 *Valori validi*:`typescript`,`python`,, `java``csharp`,`go`.  
 *Default*: `typescript` <a name="ref-cli-cdk-migrate-options-output-path"></a>

 `--output-path <PATH>`   
Il percorso di output per il progetto CDK migrato.  
 *Required*: No  
 *Impostazione predefinita*: per impostazione predefinita, la CLI AWS CDK utilizzerà la directory di lavoro corrente.<a name="ref-cli-cdk-migrate-options-region"></a>

 `--region <STRING>`   
La AWS regione da cui recuperare il modello dello AWS CloudFormation stack.  
 *Required*: No  
 *Predefinito*: la CLI AWS CDK AWS ottiene informazioni sulla regione da fonti predefinite.

## Esempi
<a name="ref-cli-cdk-migrate-examples"></a>

### Semplice esempio di migrazione da uno stack CloudFormation
<a name="ref-cli-cdk-migrate-examples-1"></a>

Esegui la migrazione da uno CloudFormation stack distribuito in un ambiente specifico utilizzando. AWS `--from-stack` Fornisci un nome `--stack-name` al tuo nuovo stack CDK. Di seguito è riportato un esempio di migrazione `myCloudFormationStack` a una nuova app CDK che utilizza: TypeScript

```
$ cdk migrate --language typescript --from-stack --stack-name 'myCloudFormationStack'
```

### Semplice esempio di migrazione da un modello locale CloudFormation
<a name="ref-cli-cdk-migrate-examples-2"></a>

Esegui la migrazione da un modello JSON o CloudFormation YAML locale utilizzando. `--from-path` Fornisci un nome `--stack-name` al tuo nuovo stack CDK. Di seguito è riportato un esempio che crea una nuova app CDK TypeScript che include uno `myCloudFormationStack` stack da un file locale: `template.json`

```
$ cdk migrate --stack-name "myCloudFormationStack" --language typescript --from-path "./template.json"
```

### Semplice esempio di migrazione dalle risorse distribuite AWS
<a name="ref-cli-cdk-migrate-examples-3"></a>

Migra AWS le risorse distribuite da un AWS ambiente specifico che non sono associate a uno stack che utilizza. CloudFormation `--from-scan` La CLI CDK utilizza il IaC generator servizio per cercare risorse e generare un modello. Quindi, la CLI CDK fa riferimento al modello per creare la nuova app CDK. Di seguito è riportato un esempio che crea una nuova app CDK TypeScript con un nuovo `myCloudFormationStack` stack contenente risorse migrate: AWS 

```
$ cdk migrate --language typescript --from-scan --stack-name "myCloudFormationStack"
```

# `cdk notices`
<a name="ref-cli-cmd-notices"></a>

Visualizza gli avvisi per la tua applicazione CDK.

Le notifiche possono includere messaggi importanti riguardanti vulnerabilità di sicurezza, regressioni e utilizzo di versioni non supportate.

Questo comando visualizza gli avvisi pertinenti, indipendentemente dal fatto che siano stati riconosciuti o meno. Per impostazione predefinita, gli avvisi pertinenti possono apparire anche dopo ogni comando.

È possibile sopprimere gli avvisi nei seguenti modi:
+ Tramite le opzioni di comando. Di seguito è riportato un esempio:

  ```
  $ cdk deploy --no-notices
  ```
+ Sopprimi tutte le notifiche all'infinito tramite il contesto nel file del progetto: `cdk.json`

  ```
  {
    "notices": false,
    "context": {
      // ...
    }
  }
  ```
+ Riconosci ogni avviso con il comando. `cdk acknowledge`

## Utilizzo
<a name="ref-cli-cmd-notices-usage"></a>

```
$ cdk notices <options>
```

## Opzioni
<a name="ref-cli-cmd-notices-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-notices-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento relative al `cdk notices` comando.

## Esempi
<a name="ref-cli-cmd-notices-examples"></a>

### Esempio di avviso predefinito visualizzato dopo l'esecuzione del comando cdk deploy
<a name="ref-cli-cmd-notices-examples-1"></a>

```
$ cdk deploy

... # Normal output of the command

NOTICES

16603   Toggling off auto_delete_objects for Bucket empties the bucket

        Overview: If a stack is deployed with an S3 bucket with
                  auto_delete_objects=True, and then re-deployed with
                  auto_delete_objects=False, all the objects in the bucket
                  will be deleted.

        Affected versions: <1.126.0.

        More information at: https://github.com/aws/aws-cdk/issues/16603


17061   Error when building EKS cluster with monocdk import

        Overview: When using monocdk/aws-eks to build a stack containing
                  an EKS cluster, error is thrown about missing
                  lambda-layer-node-proxy-agent/layer/package.json.

        Affected versions: >=1.126.0 <=1.130.0.

        More information at: https://github.com/aws/aws-cdk/issues/17061


If you don’t want to see an notice anymore, use "cdk acknowledge ID". For example, "cdk acknowledge 16603"
```

### Semplice esempio di esecuzione del comando cdk notices
<a name="ref-cli-cmd-notices-examples-2"></a>

```
$ cdk notices

NOTICES

16603   Toggling off auto_delete_objects for Bucket empties the bucket

        Overview: if a stack is deployed with an S3 bucket with
                  auto_delete_objects=True, and then re-deployed with
                  auto_delete_objects=False, all the objects in the bucket
                  will be deleted.

        Affected versions: framework: <=2.15.0 >=2.10.0

        More information at: https://github.com/aws/aws-cdk/issues/16603


If you don’t want to see a notice anymore, use "cdk acknowledge <id>". For example, "cdk acknowledge 16603"
```

# `cdk refactor`
<a name="ref-cli-cmd-refactor"></a>

**Importante**  
Il `cdk refactor` comando è in versione di anteprima ed è soggetto a modifiche.  
È necessario fornire l'`--unstable=refactor`opzione quando si utilizza questo comando.

Conserva le risorse distribuite durante il refactoring del codice nella tua applicazione AWS Cloud Development Kit (AWS CDK).

Quando rinomini i costrutti o li sposti tra gli stack del codice CDK, in genere li consideri come nuove risorse, provocando sostituzioni che CloudFormation potrebbero portare a interruzioni del servizio o alla perdita di dati. Il `cdk refactor` comando rileva in modo intelligente queste modifiche e funziona con l'API di refactoring per preservare le risorse CloudFormation aggiornandone al contempo la logica. IDs

Con il `cdk refactor` puoi:
+ Rinomina i costrutti per una maggiore chiarezza nella tua base di codice senza dover sostituire le risorse.
+ Sposta le risorse tra gli stack per migliorare l'organizzazione e la separazione delle preoccupazioni.
+ Riorganizza la gerarchia dei costrutti (ad esempio raggruppando le risorse AWS in un nuovo costrutto L3) preservando al contempo le risorse cloud sottostanti.
+ Aggiorna o passa in sicurezza da una libreria di costruzione all'altra, comprese le dipendenze di terze parti, senza attivare la sostituzione delle risorse in caso di modifica logica tra le versioni. IDs 

Questo comando analizza le modifiche, mostra un elenco di risorse che cambieranno posizione (stack e ID logico) e gestisce il complesso processo di aggiornamento delle CloudFormation risorse mantenendone l'identità e lo stato.

Quando viene eseguito, il comando calcola automaticamente le mappature confrontando il codice corrente con lo stato distribuito. Verifica che l'applicazione CDK contenga esattamente lo stesso set di risorse dello stato distribuito, che differiscono solo nella loro posizione nell'albero di costruzione. Se il comando rileva aggiunte, eliminazioni o modifiche alle risorse, l'operazione di refactoring verrà rifiutata con un messaggio di errore.

Dopo la mappatura del calcolo, il comando mostra le modifiche proposte e, dopo la conferma dell'utente, applica il refactoring. Se viene rilevata un'ambiguità (laddove sono possibili più mappature valide), è possibile fornire un file di override con mappature esplicite per risolvere questi casi.

Per un'introduzione, consulta [Preservare](refactor.md) le risorse distribuite durante il refactoring del codice CDK.

## Utilizzo
<a name="ref-cli-cmd-refactor-usage"></a>

```
$ cdk refactor <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-refactor-args"></a><a name="ref-cli-cmd-refactor-args-stack-id"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dell'app da refactorizzare.  
È possibile specificare più stack IDs per concentrare l'operazione di refactoring su tali stack. Se le risorse vengono spostate tra gli stack e uno di questi stack non è incluso in modo esplicito, il comando refactor includerà automaticamente lo stack aggiuntivo nell'operazione.  
Se non fornisci alcuno stack IDs, tutti gli stack dell'app verranno presi in considerazione per il refactoring.  
 ▬*Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-refactor-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-refactor-options-dry-run"></a>

 `--dry-run`   
Stampa la mappatura sulla console senza applicarla.  
Questa opzione è utile per convalidare le modifiche prima di eseguire effettivamente il refactoring, specialmente quando si lavora con applicazioni complesse. Mostra esattamente quali modifiche verrebbero apportate senza modificare alcuna risorsa.<a name="ref-cli-cmd-refactor-options-force"></a>

 `--force`   
Procedi con il refactoring senza richiedere conferma all'utente.  
Ciò è utile in ambienti interattivi quando si è certi delle modifiche. In ambienti non interattivi come CI/CD le pipeline, la CLI CDK procede automaticamente senza chiedere conferma, quindi questa opzione non è necessaria.<a name="ref-cli-cmd-refactor-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del comando. `cdk refactor`<a name="ref-cli-cmd-refactor-options-override-file"></a>

 `--override-file <FILE>`   
Fornisci eccezioni quando la CLI CDK non è in grado di determinare una risoluzione di refactoring per le risorse. Questo file contiene mappature delle risorse in formato JSON. Di seguito è riportato un esempio:  

```
{
    "environments": [
        {
            "account": "123456789012",
            "region": "us-east-2",
            "resources": {
                "StackA.OldName": "StackB.NewName",
                "StackC.Foo": "StackC.Bar"
            }
        }
    ]
}
```<a name="ref-cli-cmd-refactor-options-revert"></a>

 `--revert <FILE>`   
Ripristina un refactor precedente. È necessario fornire un file di override con le mappature delle risorse.  
Ciò non annulla completamente una precedente operazione di rifattorizzazione. Per ripristinare completamente un refactor, devi ripristinare l'app a uno stato precedente ed eseguire nuovamente il processo di refactoring.

# `cdk rollback`
<a name="ref-cli-cmd-rollback"></a>

Utilizza il comando CLI (Command Line Interface) del AWS Cloud Development Kit (AWS CDK`cdk rollback`) per ripristinare uno stack fallito o in pausa da AWS CloudFormation una distribuzione all'ultimo stato stabile.

**Nota**  
Per utilizzare questo comando, devi avere la versione 23 del modello di bootstrap distribuita nel tuo ambiente. Per ulteriori informazioni, consulta la cronologia delle versioni del modello [Bootstrap.](bootstrapping-env.md#bootstrap-template-history)

Quando si esegue la distribuzione utilizzando`cdk deploy`, per impostazione predefinita, la CLI CDK ripristinerà una distribuzione non riuscita. Se si specifica `--no-rollback` con`cdk deploy`, è possibile utilizzare il `cdk rollback` comando per ripristinare manualmente una distribuzione non riuscita. Questo avvierà un rollback fino all'ultimo stato stabile dello stack.

## Utilizzo
<a name="ref-cli-cmd-rollback-usage"></a>

```
$ cdk rollback <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-rollback-args"></a><a name="ref-cli-cmd-rollback-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dall'app al rollback.  
 *Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-rollback-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-rollback-options-all"></a>

 `--all <BOOLEAN>`   
Effettua il rollback di tutti gli stack nella tua app CDK.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-rollback-options-force"></a>

 `--force, -f <BOOLEAN>`   
Quando si utilizza`cdk rollback`, alcune risorse potrebbero non riuscire a eseguire il rollback. Fornite questa opzione per forzare il rollback di tutte le risorse. Si tratta dello stesso comportamento che si ottiene fornendo l'`--orphan`opzione per ogni risorsa dello stack.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-rollback-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk rollback` comando.<a name="ref-cli-cmd-rollback-options-orphan"></a>

 `--orphan <LogicalId>`   
Quando si utilizza`cdk rollback`, alcune risorse potrebbero non riuscire a eseguire il rollback. In questo caso, puoi provare a forzare il rollback di una risorsa utilizzando questa opzione e fornendo l'ID logico della risorsa che non è riuscita a eseguire il rollback.  
Questa opzione può essere fornita più volte in un unico comando. Di seguito è riportato un esempio:  

```
$ cdk rollback MyStack --orphan MyLambdaFunction --orphan MyLambdaFunction2
```
Per forzare il rollback di tutte le risorse, utilizzate invece l'`--force`opzione.<a name="ref-cli-cmd-rollback-options-toolkit-stack-name"></a>

 `--toolkit-stack-name <STRING>`   
Il nome dello stack CDK Toolkit esistente con cui è stato avviato l'ambiente.  
Per impostazione predefinita, `cdk bootstrap` distribuisce uno stack denominato nell'ambiente specificato. `CDKToolkit` AWS Utilizzate questa opzione per fornire un nome diverso per lo stack di bootstrap.  
La CLI CDK utilizza questo valore per verificare la versione dello stack di bootstrap.<a name="ref-cli-cmd-rollback-options-validate-bootstrap-version"></a>

 `--validate-bootstrap-version <BOOLEAN>`   
Specificate se convalidare la versione dello stack di bootstrap. Fornisci `--validate-bootstrap-version=false` o disattiva `--no-validate-bootsrap-version` questo comportamento.  
 *Valore predefinito*: `true` 

# `cdk synthesize`
<a name="ref-cli-cmd-synth"></a>

Sintetizza un'app CDK per produrre un assemblaggio cloud, incluso un AWS CloudFormation modello per ogni stack.

Gli assembly cloud sono file che includono tutto il necessario per distribuire l'app nel tuo ambiente. AWS Ad esempio, include un CloudFormation modello per ogni stack dell'app e una copia delle risorse di file o delle immagini Docker a cui fai riferimento nell'app.

Se l'app contiene un singolo stack o se viene fornito un singolo stack come argomento, il CloudFormation modello verrà visualizzato anche nello standard output (`stdout`) in formato YAML.

Se l'app contiene più stack, `cdk synth` sintetizzerà l'assembly cloud in. `cdk.out`

## Utilizzo
<a name="ref-cli-cmd-synth-usage"></a>

```
cdk synthesize <arguments> <options>
```

## Argomenti
<a name="ref-cli-cmd-synth-args"></a><a name="ref-cli-cmd-synth-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dell'app da sintetizzare.  
 ▬*Tipo:* stringa  
 *Required*: No

## Opzioni
<a name="ref-cli-cmd-synth-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-synth-options-exclusively"></a>

 `--exclusively, -e <BOOLEAN>`   
Sintetizza solo gli stack richiesti, non include le dipendenze.<a name="ref-cli-cmd-synth-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del comando. `cdk synthesize`<a name="ref-cli-cmd-synth-options-quiet"></a>

 `--quiet, -q <BOOLEAN>`   
Non inviate il CloudFormation modello a`stdout`.  
Questa opzione può essere configurata nel `cdk.json` file del progetto CDK. Di seguito è riportato un esempio:  

```
{
   "quiet": true
}
```
 *Valore predefinito*: `false` <a name="ref-cli-cmd-synth-options-validation"></a>

 `--validation <BOOLEAN>`   
Convalida i CloudFormation modelli generati dopo la sintesi eseguendo controlli aggiuntivi.  
È inoltre possibile configurare questa opzione tramite l'`validateOnSynth`attributo o la variabile di `CDK_VALIDATION` ambiente.  
 *Valore predefinito*: `true` 

## Esempi
<a name="ref-cli-cmd-synth-examples"></a>

### Sintetizza l'assembly cloud per uno stack CDK con ID logico MyStackName e invia il modello su stdout CloudFormation
<a name="ref-cli-cmd-synth-examples-1"></a>

```
$ cdk synth MyStackName
```

### Sintetizza l'assembly cloud per tutti gli stack in un'app CDK e salvali in cdk.out
<a name="ref-cli-cmd-synth-examples-2"></a>

```
$ cdk synth
```

### Sintetizza l'assembly cloud per, ma non include le dipendenze MyStackName
<a name="ref-cli-cmd-synth-examples-3"></a>

```
$ cdk synth MyStackName --exclusively
```

### Sintetizza l'assembly cloud per MyStackName, ma non esporta il modello su stdout CloudFormation
<a name="ref-cli-cmd-synth-examples-4"></a>

```
$ cdk synth MyStackName --quiet
```

# `cdk watch`
<a name="ref-cli-cmd-watch"></a>

Monitora continuamente un progetto AWS CDK locale per verificare le modifiche necessarie per eseguire distribuzioni e hotswap.

Questo comando è simile a`cdk deploy`, tranne per il fatto che può eseguire distribuzioni e hotswap continui tramite un singolo comando.

Questo comando è una scorciatoia per. `cdk deploy --watch`

Per terminare una `cdk watch` sessione, interrompi il processo premendo. `Ctrl+C`

I file che vengono osservati sono determinati dall'`"watch"`impostazione del `cdk.json` file. Ha due sottochiavi `"include"` e `"exclude"` accetta una singola stringa o un array di stringhe. Ogni voce viene interpretata come un percorso relativo alla posizione del `cdk.json` file. Entrambe `*` le opzioni `**` sono accettate.

Se create un progetto utilizzando il `cdk init` comando, `cdk watch` nel `cdk.json` file del progetto viene configurato il seguente comportamento predefinito:
+  `"include"`è impostato su`"**/*"`, che include tutti i file e le directory nella radice del progetto.
+  `"exclude"`è facoltativo, ad eccezione dei file e delle cartelle già ignorati per impostazione predefinita. È costituito da file e directory che iniziano con`.`, la directory di output CDK e la directory. `node_modules`

L'impostazione minima da configurare `watch` è. `"watch": {}`

Se il codice CDK o il codice dell'applicazione richiedono una fase di compilazione prima della distribuzione, `cdk watch` funziona con la `"build"` chiave del `cdk.json` file.

**Importante**  
Questo comando è destinato alla distribuzione rapida durante la fase di sviluppo delle app CDK e non è consigliato per le distribuzioni di produzione.

Le stesse limitazioni di si applica a. `cdk deploy --hotswap` `cdk watch` Per ulteriori informazioni, consulta ` cdk deploy --hotswap `.

## Utilizzo
<a name="ref-cli-cmd-watch-usage"></a>

```
$ cdk watch <arguments> <options>
```

## Arguments (Argomenti)
<a name="ref-cli-cmd-watch-args"></a><a name="ref-cli-cmd-watch-args-stack-name"></a>

 **ID dello stack CDK**   
L'ID di costruzione dello stack CDK dall'app da guardare.  
 ▬*Tipo:* stringa  
 *Obbligatorio:* no

## Opzioni
<a name="ref-cli-cmd-watch-options"></a>

Per un elenco di opzioni globali che funzionano con tutti i comandi CDK CLI, [vedete](ref-cli-cmd.md#ref-cli-cmd-options) Opzioni globali.<a name="ref-cli-cmd-watch-options-build-exclude"></a>

 `--build-exclude, -E <ARRAY>`   
Non ricostruite l'asset con l'ID specificato.  
Questa opzione può essere specificata più volte in un unico comando.  
 *Valore predefinito*: `[]` <a name="ref-cli-cmd-watch-options-change-set-name"></a>

 `--change-set-name <STRING>`   
Il nome del set di CloudFormation modifiche da creare.<a name="ref-cli-cmd-watch-options-concurrency"></a>

 `--concurrency <NUMBER>`   
Implementa e sostituisci più stack in parallelo tenendo conto delle dipendenze tra stack. Utilizza questa opzione per velocizzare le implementazioni. Devi comunque tenere conto di altri limiti CloudFormation alla tariffa AWS dell'account.  
Fornisci un numero per specificare il numero massimo di distribuzioni simultanee (in base alla dipendenza) da eseguire.  
 *Valore predefinito*: `1` <a name="ref-cli-cmd-watch-options-exclusively"></a>

 `--exclusively, -e <BOOLEAN>`   
Implementa solo gli stack richiesti e non include le dipendenze.<a name="ref-cli-cmd-watch-options-force"></a>

 `--force, -f <BOOLEAN>`   
Distribuisci sempre gli stack, anche se i modelli sono identici.  
 *Valore predefinito*: `false` <a name="ref-cli-cmd-watch-options-help"></a>

 `--help, -h <BOOLEAN>`   
Mostra le informazioni di riferimento del `cdk watch` comando.<a name="ref-cli-cmd-watch-options-hotswap"></a>

 `--hotswap <BOOLEAN>`   
Per impostazione predefinita, `cdk watch` utilizza distribuzioni hotswap quando possibile per aggiornare le risorse. La CLI CDK tenterà di eseguire una distribuzione hotswap e non tornerà a una CloudFormation distribuzione completa in caso di esito negativo. Tutte le modifiche rilevate che non possono essere aggiornate tramite un hotswap vengono ignorate.  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-watch-options-hotswap-fallback"></a>

 `--hotswap-fallback <BOOLEAN>`   
Per impostazione predefinita, `cdk watch` tenta di eseguire distribuzioni hotswap e ignora le modifiche che richiedono implementazioni. CloudFormation Se la distribuzione `--hotswap-fallback` hotswap non ha esito positivo, provvedere a eseguire una CloudFormation distribuzione completa.<a name="ref-cli-cmd-watch-options-logs"></a>

 `--logs <BOOLEAN>`   
Per impostazione predefinita, `cdk watch` monitora tutti i gruppi di CloudWatch log dell'applicazione e trasmette gli eventi di registro localmente a. `stdout`  
 *Valore predefinito*: `true` <a name="ref-cli-cmd-watch-options-progress"></a>

 `--progress <STRING>`   
Configura il modo in cui la CLI CDK mostra l'avanzamento della distribuzione.  
+  `bar`— Visualizza gli eventi di distribuzione dello stack come barra di avanzamento, con gli eventi relativi alla risorsa attualmente distribuita.
+  `events`— Fornisci una cronologia completa, inclusi tutti gli CloudFormation eventi.
Puoi anche configurare questa opzione nel `cdk.json` file del progetto o `~/.cdk.json` sul tuo computer di sviluppo locale:  

```
{
   "progress": "events"
}
```
 *Valori validi*: `bar`, `events`   
 *Valore predefinito*: `bar` <a name="ref-cli-cmd-watch-options-rollback"></a>

 `--rollback <BOOLEAN>`   
Durante la distribuzione, se una risorsa non viene creata o aggiornata, la distribuzione tornerà allo stato stabile più recente prima che venga ripristinata la CLI CDK. Tutte le modifiche apportate fino a quel momento verranno annullate. Le risorse create verranno eliminate e gli aggiornamenti apportati verranno ripristinati.  
Usa `--no-rollback` o `-R` disattiva questo comportamento. Se una risorsa non viene creata o aggiornata, la CLI CDK lascerà invariate le modifiche apportate fino a quel momento e le restituirà. Ciò può essere utile negli ambienti di sviluppo in cui si esegue un'iterazione rapida.  
Quando`false`, le distribuzioni che causano la sostituzione delle risorse falliranno sempre. È possibile utilizzare questo valore solo per le distribuzioni che aggiornano o creano nuove risorse.
 *Valore predefinito*: `true` <a name="ref-cli-cmd-watch-options-toolkit-stack-name"></a>

 `--toolkit-stack-name <STRING>`   
Il nome dello stack CDK Toolkit esistente.  
Per impostazione predefinita, `cdk bootstrap` distribuisce uno stack denominato `CDKToolkit` nell'ambiente specificato. AWS Utilizzate questa opzione per fornire un nome diverso per lo stack di bootstrap.  
La CLI CDK utilizza questo valore per verificare la versione dello stack di bootstrap.

## Esempi
<a name="ref-cli-cmd-watch-examples"></a>

### Guarda uno stack CDK con ID logico per le modifiche DevelopmentStack
<a name="ref-cli-cmd-watch-examples-1"></a>

```
$ cdk watch DevelopmentStack
Detected change to 'lambda-code/index.js' (type: change). Triggering 'cdk deploy'
DevelopmentStack: deploying...

 ✅  DevelopmentStack
```

### Configura un file cdk.json per sapere cosa includere ed escludere dal controllo delle modifiche
<a name="ref-cli-cmd-watch-examples-2"></a>

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

### Crea un progetto CDK utilizzando Java prima della distribuzione configurando il file cdk.json
<a name="ref-cli-cmd-watch-examples-3"></a>

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