

Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 gewartet und der Support wurde am 1. Juni 2023 eingestellt.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS CDK-CLI-Referenz
<a name="cli"></a>

Das AWS Cloud Development Kit (AWS CDK) Command Line Interface (AWS CDK CLI), auch bekannt als CDK Toolkit, ist das wichtigste Tool für die Interaktion mit Ihrer CDK-App. AWS Es führt Ihre App aus, fragt das von Ihnen definierte Anwendungsmodell ab und erstellt und implementiert die vom CDK generierten Vorlagen. AWS CloudFormation AWS Es bietet auch andere Funktionen, die für die Erstellung und Arbeit mit CDK-Projekten nützlich sind. AWS Dieses Thema enthält Informationen zu häufigen Anwendungsfällen der CDK-CLI.

Die CDK-CLI wird mit dem Node Package Manager installiert. In den meisten Fällen empfehlen wir, es global zu installieren.

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

**Tipp**  
Wenn Sie regelmäßig mit mehreren Versionen des AWS CDK arbeiten, sollten Sie erwägen, eine passende Version der CDK-CLI in einzelnen CDK-Projekten zu installieren. Um dies zu tun, lassen Sie den Befehl `-g` aus. `npm install` Verwenden Sie es dann`npx aws-cdk`, um es aufzurufen. Dadurch wird die lokale Version ausgeführt, falls eine existiert, und falls nicht, wird auf eine globale Version zurückgegriffen.

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

Alle CDK-CLI-Befehle beginnen mit`cdk`, gefolgt von einem Unterbefehl (`list`, `synthesize``deploy`, usw.). Einige Unterbefehle haben eine kürzere Version (`ls`, usw.)`synth`, die gleichwertig ist. Optionen und Argumente folgen dem Unterbefehl in beliebiger Reihenfolge.

Eine Beschreibung aller Unterbefehle, Optionen und Argumente finden Sie in der [AWS CDK-CLI-Befehlsreferenz](ref-cli-cmd.md).

## Geben Sie Optionen und ihre Werte an
<a name="cli-options"></a>

Befehlszeilenoptionen beginnen mit zwei Bindestrichen ()`--`. Einige häufig verwendete Optionen haben Synonyme aus einem Buchstaben, die mit einem einzelnen Bindestrich beginnen (z. B. `--app` hat ein Synonym). `-a` Die Reihenfolge der Optionen in einem CDK-CLI-Befehl ist nicht wichtig.

Alle Optionen akzeptieren einen Wert, der dem Optionsnamen folgen muss. Der Wert kann durch Leerzeichen oder ein Gleichheitszeichen `=` vom Namen getrennt werden. Die folgenden beiden Optionen sind gleichwertig.

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

Einige Optionen sind Flags (Boolesche Werte). Sie können `true` oder `false` als ihren Wert angeben. Wenn Sie keinen Wert angeben, wird der Wert als `true` Sie können dem Optionsnamen auch implizit ein Präfix voranstellen`false`. `no-`

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

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

Einige Optionen, nämlich`--context`, `--parameters``--plugin`, und `--tags``--trust`, können mehrfach angegeben werden, um mehrere Werte anzugeben. Es wird darauf hingewiesen, dass sie die CDK-CLI-Hilfe `[array]` eingegeben haben. Beispiel:

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

## Integrierte Hilfe
<a name="cli-help"></a>

Die CDK-CLI hat eine integrierte Hilfe. Allgemeine Hilfe zum Tool und eine Liste der bereitgestellten Unterbefehle finden Sie, indem Sie Folgendes eingeben:

```
cdk --help
```

Um beispielsweise Hilfe für einen bestimmten Unterbefehl zu erhalten`deploy`, geben Sie ihn vor dem `--help` Flag an.

```
cdk deploy --help
```

Problem `cdk version` beim Anzeigen der Version der CDK-CLI. Geben Sie diese Informationen an, wenn Sie Support anfordern.

## Versionsberichterstattung
<a name="version-reporting"></a>

Um einen Einblick in die Verwendung des AWS CDK zu erhalten, werden die von AWS CDK-Anwendungen verwendeten Konstrukte anhand einer als identifizierten Ressource gesammelt und gemeldet. ` AWS::CDK::Metadata` Weitere Informationen finden Sie unter [Konfigurieren der Berichterstattung über AWS CDK-Nutzungsdaten](usage-data.md).

## Authentifizierung mit AWS
<a name="cli-auth"></a>

Je nach Umgebung und verfügbarem Zugriff gibt es verschiedene Möglichkeiten, den programmatischen AWS Zugriff auf AWS Ressourcen zu konfigurieren.

Informationen zur Auswahl Ihrer Authentifizierungsmethode und deren Konfiguration für die CDK-CLI finden [Sie unter Sicherheitsanmeldedaten für die AWS CDK-CLI konfigurieren](configure-access.md).

Der empfohlene Ansatz für neue Benutzer, die sich lokal entwickeln und von ihrem Arbeitgeber keine Authentifizierungsmethode erhalten, ist die Einrichtung von AWS IAM Identity Center. Diese Methode beinhaltet die Installation der AWS CLI, um die Konfiguration zu vereinfachen und sich regelmäßig beim AWS Zugriffsportal anzumelden. Wenn Sie sich für diese Methode entscheiden, sollte Ihre Umgebung die folgenden Elemente enthalten, nachdem Sie das Verfahren für die [IAM Identity Center-Authentifizierung](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) im Referenzhandbuch * AWS SDKs und im Tools-Referenzhandbuch* abgeschlossen haben:
+ Die AWS CLI, mit der Sie eine AWS Access-Portal-Sitzung starten, bevor Sie Ihre Anwendung ausführen.
+ Eine [gemeinsam genutzte AWS Konfigurationsdatei](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) mit einem `[default]` Profil mit einer Reihe von Konfigurationswerten, auf die vom AWS CDK aus verwiesen werden kann. Informationen zum Speicherort dieser Datei finden Sie unter [Speicherort der gemeinsam genutzten Dateien](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) im Referenzhandbuch * AWS SDKs und im Tools-Referenzhandbuch.*
+ Die gemeinsam genutzte `config` Datei legt die [Regionseinstellung](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html) fest. Dadurch wird die AWS Standardregion festgelegt, die das AWS CDK und die CDK-CLI für AWS Anfragen verwenden.
+ Die CDK-CLI verwendet die [SSO-Token-Provider-Konfiguration](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#feature-sso-credentials-profile) des Profils, um Anmeldeinformationen abzurufen, bevor Anfragen an AWS gesendet werden. Der `sso_role_name` Wert, bei dem es sich um eine IAM-Rolle handelt, die mit einem IAM Identity Center-Berechtigungssatz verbunden ist, sollte den Zugriff auf die in Ihrer Anwendung verwendeten AWS Dienste ermöglichen.

  Die folgende `config` Beispieldatei zeigt ein Standardprofil, das mit der Konfiguration des SSO-Token-Anbieters eingerichtet wurde. Die `sso_session` Einstellung des Profils bezieht sich auf den benannten [`sso-session`Abschnitt](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#section-session). Der `sso-session` Abschnitt enthält Einstellungen zum Initiieren einer AWS Access-Portal-Sitzung.

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

### Starten Sie eine AWS Access-Portal-Sitzung
<a name="accessportal"></a>

Bevor Sie auf AWS Dienste zugreifen können, benötigen Sie eine aktive AWS Zugriffsportalsitzung, damit die CDK-CLI die IAM Identity Center-Authentifizierung zur Auflösung von Anmeldeinformationen verwenden kann. Abhängig von Ihrer konfigurierten Sitzungslänge läuft Ihr Zugriff irgendwann ab und die CDK-CLI wird auf einen Authentifizierungsfehler stoßen. Führen Sie den folgenden Befehl in der AWS CLI aus, um sich beim AWS Access Portal anzumelden.

```
aws sso login
```

Wenn Ihre SSO-Token-Provider-Konfiguration ein benanntes Profil anstelle des Standardprofils verwendet, lautet der Befehl`aws sso login --profile <NAME>`. Geben Sie dieses Profil auch an, wenn Sie `cdk` Befehle mit der `--profile` Option oder der `AWS_PROFILE` Umgebungsvariablen ausgeben.

Führen Sie den folgenden AWS CLI-Befehl aus, um zu testen, ob Sie bereits eine aktive Sitzung haben.

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

In der Antwort auf diesen Befehl sollten das in der freigegebenen `config`-Datei konfigurierte IAM-Identity-Center-Konto und der Berechtigungssatz angegeben werden.

**Anmerkung**  
Wenn Sie bereits über eine aktive AWS Access-Portal-Sitzung verfügen und diese ausführen`aws sso login`, müssen Sie keine Anmeldeinformationen angeben.  
Beim Anmeldevorgang werden Sie möglicherweise aufgefordert, der AWS CLI Zugriff auf Ihre Daten zu gewähren. Da die AWS CLI auf dem SDK für Python aufbaut, können Berechtigungsnachrichten Variationen des `botocore` Namens enthalten.

## Geben Sie die Region und andere Konfigurationen an
<a name="cli-environment"></a>

Die CDK-CLI muss die AWS Region kennen, in der Sie die Bereitstellung durchführen, und darüber, wie Sie sich authentifizieren. AWS Dies wird für Bereitstellungsvorgänge und zum Abrufen von Kontextwerten während der Synthese benötigt. Ihr Konto und Ihre Region bilden zusammen die *Umgebung*.

Die Region kann mithilfe von Umgebungsvariablen oder in Konfigurationsdateien angegeben werden. Dies sind dieselben Variablen und Dateien, die von anderen AWS Tools wie der AWS CLI und den verschiedenen verwendet werden AWS SDKs. Die CDK-CLI sucht in der folgenden Reihenfolge nach diesen Informationen.
+ Die `AWS_DEFAULT_REGION`-Umgebungsvariable
+ Ein benanntes Profil, das in der AWS `config` Standarddatei definiert und mit der `--profile` Option für `cdk` Befehle angegeben wurde.
+ Der `[default]` Abschnitt der AWS `config` Standarddatei.

Neben der Angabe der AWS Authentifizierung und einer Region im `[default]` Abschnitt können Sie auch einen oder mehrere `[profile <NAME>]` Abschnitte hinzufügen, in denen sich der Name des Profils `<NAME>` befindet. Weitere Informationen zu benannten Profilen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im * AWS SDKs Referenzhandbuch zu Tools*.

Die AWS `config` Standarddatei befindet sich unter `~/.aws/config` (MacOS/Linux) oder `%USERPROFILE%\.aws\config` (Windows). Einzelheiten und alternative Speicherorte finden Sie unter [Speicherort der gemeinsam genutzten Konfigurationsdateien und Anmeldeinformationen im Referenzhandbuch](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) für * AWS SDKs Tools* 

Die Umgebung, die Sie in Ihrer AWS CDK-App mithilfe der `env` Stack-Eigenschaft angeben, wird bei der Synthese verwendet. Es wird verwendet, um eine umgebungsspezifische AWS CloudFormation Vorlage zu generieren, und während der Bereitstellung überschreibt es das Konto oder die Region, das mit einer der vorherigen Methoden angegeben wurde. Weitere Informationen finden Sie unter [Umgebungen für](environments.md) das CDK. AWS 

**Anmerkung**  
Das AWS CDK verwendet Anmeldeinformationen aus denselben Quelldateien wie andere AWS Tools SDKs, einschließlich der [AWS Befehlszeilenschnittstelle](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html). Das AWS CDK kann sich jedoch etwas anders verhalten als diese Tools. Es verwendet das AWS SDK für den Einsatz JavaScript unter der Haube. Vollständige Informationen zum Einrichten von Anmeldeinformationen für das AWS SDK für JavaScript finden Sie unter [Anmeldeinformationen einrichten](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials.html).

Sie können optional die Option `--role-arn` (oder`-r`) verwenden, um den ARN einer IAM-Rolle anzugeben, die für die Bereitstellung verwendet werden soll. Diese Rolle muss von dem verwendeten AWS Konto übernommen werden können.

## Geben Sie den App-Befehl an
<a name="cli-app-command"></a>

Für viele Funktionen der CDK-CLI müssen eine oder mehrere AWS CloudFormation Vorlagen synthetisiert werden, was wiederum die Ausführung Ihrer Anwendung erfordert. Das AWS CDK unterstützt Programme, die in einer Vielzahl von Sprachen geschrieben wurden. Daher verwendet es eine Konfigurationsoption, um genau den Befehl anzugeben, der zum Ausführen Ihrer App erforderlich ist. Diese Option kann auf zwei Arten angegeben werden.

Erstens und am häufigsten kann sie mithilfe des `app` Schlüssels in der Datei angegeben werden`cdk.json`. Dies befindet sich im Hauptverzeichnis Ihres AWS CDK-Projekts. Die CDK-CLI bietet einen entsprechenden Befehl, wenn Sie ein neues Projekt mit `cdk init` erstellen. Hier ist zum Beispiel das `cdk.json` aus einem neuen TypeScript Projekt.

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

Die CDK-CLI sucht `cdk.json` im aktuellen Arbeitsverzeichnis, wenn sie versucht, Ihre App auszuführen. Aus diesem Grund können Sie im Hauptverzeichnis Ihres Projekts eine Shell für die Ausgabe von CDK-CLI-Befehlen geöffnet lassen.

Die CDK-CLI sucht auch nach dem App-Schlüssel in `~/.cdk.json` (d. h. in Ihrem Home-Verzeichnis), wenn sie ihn nicht finden kann. `./cdk.json` Das Hinzufügen des App-Befehls hier kann nützlich sein, wenn Sie normalerweise mit CDK-Code in derselben Sprache arbeiten.

Wenn du dich in einem anderen Verzeichnis befindest oder wenn du deine App mit einem anderen Befehl als dem in ausführen möchtest`cdk.json`, verwende die Option `--app` (oder`-a`), um ihn anzugeben.

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

Bei der Bereitstellung können Sie auch ein Verzeichnis angeben, das synthetisierte Cloud-Assemblys enthält`cdk.out`, z. B. als Wert von`--app`. Die angegebenen Stacks werden von diesem Verzeichnis aus bereitgestellt; die App wird nicht synthetisiert.

## Geben Sie Stapel an
<a name="cli-stacks"></a>

Viele CDK-CLI-Befehle (zum Beispiel`cdk deploy`) funktionieren mit Stacks, die in Ihrer App definiert sind. Wenn Ihre App nur einen Stack enthält, geht die CDK-CLI davon aus, dass Sie diesen meinen, wenn Sie keinen Stack explizit angeben.

Andernfalls müssen Sie den Stack oder die Stacks angeben, mit denen Sie arbeiten möchten. Sie können dies tun, indem Sie die gewünschten Stacks einzeln nach ID in der Befehlszeile angeben. Denken Sie daran, dass die ID der Wert ist, der durch das zweite Argument angegeben wird, wenn Sie den Stack instanziieren.

```
cdk synth PipelineStack LambdaStack
```

Sie können auch Platzhalter verwenden, um anzugeben, IDs dass sie einem Muster entsprechen.
+  `?`entspricht einem beliebigen einzelnen Zeichen
+  `*`entspricht einer beliebigen Anzahl von Zeichen (`*`allein entspricht allen Stapeln)
+  `**`entspricht allem in einer Hierarchie

Sie können die `--all` Option auch verwenden, um alle Stapel anzugeben.

Wenn Ihre App [CDK Pipelines](cdk-pipeline.md) verwendet, versteht die CDK-CLI Ihre Stacks und Stages als Hierarchie. Außerdem entsprechen die `--all` Option und der `*` Platzhalter nur Stacks der obersten Ebene. Um alle Stapel abzugleichen, verwenden Sie. `**` Wird auch verwendet`**`, um alle Stapel unter einer bestimmten Hierarchie anzugeben.

Wenn Sie Platzhalter verwenden, setzen Sie das Muster in Anführungszeichen oder maskieren Sie die Platzhalter mit. `\` Wenn Sie dies nicht tun, versucht Ihre Shell möglicherweise, das Muster auf die Namen der Dateien im aktuellen Verzeichnis zu erweitern. Im besten Fall wird dies nicht das tun, was Sie erwarten. Im schlimmsten Fall könnten Sie Stacks bereitstellen, die Sie nicht beabsichtigt hatten. Dies ist unter Windows nicht unbedingt erforderlich, da Platzhalter `cmd.exe` nicht erweitert werden, ist aber dennoch eine bewährte Methode.

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

**Anmerkung**  
Die Reihenfolge, in der Sie die Stapel angeben, entspricht nicht unbedingt der Reihenfolge, in der sie verarbeitet werden. Die CDK-CLI berücksichtigt Abhängigkeiten zwischen Stacks, wenn sie entscheidet, in welcher Reihenfolge sie verarbeitet werden sollen. Nehmen wir zum Beispiel an, dass ein Stapel einen Wert verwendet, der von einem anderen erzeugt wird (z. B. den ARN einer im zweiten Stack definierten Ressource). In diesem Fall wird der zweite Stapel aufgrund dieser Abhängigkeit vor dem ersten synthetisiert. Sie können Abhängigkeiten zwischen Stacks manuell hinzufügen, indem Sie die Methode des Stacks ` [addDependency()](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html#addwbrdependencytarget-reason) ` verwenden.

## Bootstrap für deine Umgebung AWS
<a name="cli-bootstrap"></a>

Für die Bereitstellung von Stacks mit dem CDK müssen spezielle, dedizierte AWS CDK-Ressourcen bereitgestellt werden. Der `cdk bootstrap` Befehl erstellt die erforderlichen Ressourcen für Sie. Sie müssen das Bootstrap nur ausführen, wenn Sie einen Stack bereitstellen, der diese dedizierten Ressourcen benötigt. Einzelheiten finden Sie unter [AWS CDK-Bootstrapping](bootstrapping.md).

```
cdk bootstrap
```

Wenn der `cdk bootstrap` Befehl ohne Argumente ausgegeben wird, wie hier gezeigt, synthetisiert er die aktuelle App und bootet die Umgebungen, in denen die Stacks bereitgestellt werden. Wenn die App umgebungsunabhängige Stacks enthält, die nicht explizit eine Umgebung angeben, werden das Standardkonto und die Region oder die mit angegebene Umgebung gebootet. `--profile`

Außerhalb einer App müssen Sie die Umgebung, für die ein Bootstrap erstellt werden soll, explizit angeben. Sie können dies auch tun, um eine Umgebung zu booten, die nicht in Ihrer App oder Ihrem lokalen Profil angegeben ist. AWS Die Anmeldeinformationen müssen für das angegebene Konto und die angegebene Region konfiguriert sein (z. B. in`~/.aws/credentials`). Sie können ein Profil angeben, das die erforderlichen Anmeldeinformationen enthält.

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

**Wichtig**  
Jede Umgebung (Kombination aus Konto und Region), in der Sie einen solchen Stack bereitstellen, muss separat gebootet werden.

Für das, was das AWS CDK in den Bootstrap-Ressourcen speichert, können AWS Gebühren anfallen. Darüber hinaus wird bei Verwendung ein AWS KMS-Schlüssel erstellt`--bootstrap-customer-key`, für den ebenfalls Gebühren pro Umgebung anfallen.

**Anmerkung**  
In früheren Versionen der Bootstrap-Vorlage wurde standardmäßig ein KMS-Schlüssel erstellt. Um Gebühren zu vermeiden, starten Sie das System erneut mit. `--no-bootstrap-customer-key`

**Anmerkung**  
CDK CLI v2 unterstützt nicht die ursprüngliche Bootstrap-Vorlage, die als Legacy-Template bezeichnet wird und standardmäßig mit CDK v1 verwendet wird.

**Wichtig**  
Die moderne Bootstrap-Vorlage gewährt praktisch jedem Konto in der Liste die `--cloudformation-execution-policies` damit verbundenen Berechtigungen. AWS `--trust` Standardmäßig werden dadurch die Lese- und Schreibberechtigungen für alle Ressourcen im Bootstrap-Konto erweitert. Stellen Sie sicher, dass [Sie den Bootstrapping-Stack mit Richtlinien und vertrauenswürdigen Konten konfigurieren](bootstrapping-customizing.md), mit denen Sie vertraut sind.

## Erstellen Sie eine neue App
<a name="cli-init"></a>

Um eine neue App zu erstellen, erstellen Sie ein Verzeichnis dafür und geben Sie dann innerhalb des Verzeichnisses das Problem ein`cdk init`.

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

Die unterstützten Sprachen (<LANGUAGE>) sind:


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

<TEMPLATE>ist eine optionale Vorlage. Wenn die gewünschte Vorlage *App* (Standard) ist, können Sie sie weglassen. Die verfügbaren Vorlagen sind:


| Vorlage | Description | 
| --- | --- | 
|   `app`(Standard)  |  Erzeugt eine leere AWS CDK-App.  | 
|   `sample-app`   |  Erstellt eine AWS CDK-App mit einem Stack, der eine Amazon SQS SQS-Warteschlange und ein Amazon SNS SNS-Thema enthält.  | 

Die Vorlagen verwenden den Namen des Projektordners, um Namen für Dateien und Klassen in Ihrer neuen App zu generieren.

## Stapel auflisten
<a name="cli-list"></a>

Um eine Liste IDs der Stacks in Ihrer AWS CDK-Anwendung zu sehen, geben Sie einen der folgenden entsprechenden Befehle ein:

```
cdk list
cdk ls
```

Wenn Ihre Anwendung [CDK-Pipeline-Stacks enthält, zeigt die CDK-CLI Stacknamen entsprechend ihrer Position in der Pipeline-Hierarchie](cdk-pipeline.md) als Pfade an. (Zum Beispiel`PipelineStack`, `PipelineStack/Prod` und.) `PipelineStack/Prod/MyService`

Wenn Ihre App viele Stapel enthält, können Sie einen vollständigen oder teilweisen Stapel IDs der aufzulistenden Stapel angeben. Weitere Informationen finden Sie unter Stapel [angeben](#cli-stacks).

Fügen Sie das `--long` Flag hinzu, um weitere Informationen zu den Stacks zu erhalten, einschließlich der Stack-Namen und ihrer Umgebungen (AWS Konto und Region).

## Synthetisieren Sie Stapel
<a name="cli-synth"></a>

Der `cdk synthesize` Befehl (fast immer abgekürzt`synth`) synthetisiert einen in Ihrer App definierten Stack zu einer Vorlage. CloudFormation 

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

**Anmerkung**  
Die CDK-CLI führt Ihre App tatsächlich aus und synthetisiert vor den meisten Vorgängen (z. B. beim Bereitstellen oder Vergleichen von Stacks) neue Vorlagen. Diese Vorlagen werden standardmäßig im Verzeichnis gespeichert. `cdk.out` Der `cdk synth` Befehl druckt einfach die generierten Vorlagen für einen oder mehrere angegebene Stapel.

Alle verfügbaren Optionen finden `cdk synth --help` Sie unter. Einige der am häufigsten verwendeten Optionen werden im folgenden Abschnitt behandelt.

### Geben Sie Kontextwerte an
<a name="cli-specify-context"></a>

Verwenden Sie die `-c` Option `--context` oder, um Werte für den [Laufzeitkontext](context.md) an Ihre CDK-App zu übergeben.

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

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

Bei der Bereitstellung mehrerer Stacks werden die angegebenen Kontextwerte normalerweise an alle übergeben. Wenn Sie möchten, können Sie für jeden Stack unterschiedliche Werte angeben, indem Sie dem Kontextwert den Stacknamen voranstellen.

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

### Geben Sie das Anzeigeformat an
<a name="cli-specify-format"></a>

Standardmäßig wird die synthetisierte Vorlage im YAML-Format angezeigt. Fügen Sie das `--json` Flag hinzu, um es stattdessen im JSON-Format anzuzeigen.

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

### Geben Sie das Ausgabeverzeichnis an
<a name="cli-specify-output"></a>

Fügen Sie die Option `--output` (`-o`) hinzu, um die synthetisierten Vorlagen in ein anderes Verzeichnis als `cdk.out` zu schreiben.

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

## Stapel bereitstellen
<a name="cli-deploy"></a>

Der `cdk deploy` Unterbefehl stellt einen oder mehrere angegebene Stacks für Ihr Konto bereit. AWS 

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

**Anmerkung**  
Die CDK-CLI führt Ihre App aus und synthetisiert neue AWS CloudFormation Vorlagen, bevor Sie etwas bereitstellen. Daher können die meisten Befehlszeilenoptionen, die Sie mit verwenden können `cdk synth` (z. B.`--context`), auch mit verwendet werden. `cdk deploy`

Alle verfügbaren Optionen finden `cdk deploy --help` Sie unter. Einige der nützlichsten Optionen werden im folgenden Abschnitt behandelt.

### Synthese überspringen
<a name="cli-deploy-nosynth"></a>

Der `cdk deploy` Befehl synthetisiert normalerweise die Stapel Ihrer App vor der Bereitstellung, um sicherzustellen, dass die Bereitstellung die neueste Version Ihrer App widerspiegelt. Wenn Sie wissen, dass Sie Ihren Code seit der letzten Version nicht geändert haben`cdk synth`, können Sie den redundanten Syntheseschritt bei der Bereitstellung unterdrücken. Geben Sie dazu in der `--app` Option das `cdk.out` Verzeichnis Ihres Projekts an.

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

### Deaktivieren Sie den Rollback
<a name="cli-deploy-norollback"></a>

 AWS CloudFormation hat die Fähigkeit, Änderungen rückgängig zu machen, sodass Bereitstellungen atomar sind. Das bedeutet, dass sie entweder erfolgreich sind oder als Ganzes scheitern. Das AWS CDK erbt diese Fähigkeit, weil es Vorlagen synthetisiert und bereitstellt. AWS CloudFormation 

Rollback stellt sicher, dass sich Ihre Ressourcen jederzeit in einem konsistenten Zustand befinden, was für Produktionsstapel von entscheidender Bedeutung ist. Während Sie Ihre Infrastruktur noch entwickeln, sind einige Ausfälle jedoch unvermeidlich, und das Zurücksetzen fehlgeschlagener Bereitstellungen kann Sie verlangsamen.

Aus diesem Grund können Sie mit der CDK-CLI das Rollback deaktivieren, indem Sie Ihrem `cdk deploy` Befehl `--no-rollback` etwas hinzufügen. Mit diesem Flag werden fehlgeschlagene Bereitstellungen nicht rückgängig gemacht. Stattdessen bleiben Ressourcen, die vor der ausgefallenen Ressource bereitgestellt wurden, bestehen, und die nächste Bereitstellung beginnt mit der ausgefallenen Ressource. Sie werden viel weniger Zeit damit verbringen, auf Bereitstellungen zu warten, und viel mehr Zeit mit der Entwicklung Ihrer Infrastruktur verbringen.

### Wechseln im laufenden Betrieb
<a name="cli-deploy-hotswap"></a>

Verwenden Sie die `--hotswap` Markierung mit`cdk deploy`, um zu versuchen, Ihre AWS Ressourcen direkt zu aktualisieren, anstatt einen AWS CloudFormation Änderungssatz zu generieren und ihn bereitzustellen. Wenn Hot-Swapping nicht möglich ist, wird auf die AWS CloudFormation Bereitstellung zurückgegriffen.

Derzeit unterstützt Hot-Swapping Lambda-Funktionen, Step Functions Functions-Zustandsmaschinen und Amazon ECS-Container-Images. Das `--hotswap` Flag deaktiviert auch Rollback (impliziert). `--no-rollback`

**Wichtig**  
Hot-Swapping wird für Produktionsbereitstellungen nicht empfohlen.

### Modus „Ansehen“
<a name="cli-deploy-watch"></a>

Der Watch-Modus (`cdk deploy --watch`oder `cdk watch` kurz) der CDK-CLI überwacht kontinuierlich die Quelldateien und Assets Ihrer CDK-App auf Änderungen. Es führt sofort eine Bereitstellung der angegebenen Stacks durch, wenn eine Änderung erkannt wird.

Standardmäßig verwenden diese Bereitstellungen das `--hotswap` Flag, das die Bereitstellung von Änderungen an Lambda-Funktionen beschleunigt. Es wird auch auf die Bereitstellung über zurückgegriffen, AWS CloudFormation falls Sie die Infrastrukturkonfiguration geändert haben. Wenn Sie `cdk watch` immer vollständige AWS CloudFormation Bereitstellungen durchführen möchten, fügen Sie das `--no-hotswap` Flag zu `cdk watch` hinzu.

Alle Änderungen, die während `cdk watch` der Ausführung einer Bereitstellung vorgenommen werden, werden zu einer einzigen Bereitstellung zusammengefasst, die beginnt, sobald die Bereitstellung abgeschlossen ist.

Im Überwachungsmodus wird anhand des `"watch"` Schlüssels im Projekt bestimmt`cdk.json`, welche Dateien überwacht werden sollen. Standardmäßig handelt es sich bei diesen Dateien um Ihre Anwendungsdateien und -ressourcen. Dies kann jedoch geändert werden, indem Sie die `"exclude"` Einträge `"include"` und im `"watch"` Schlüssel ändern. Die folgende `cdk.json` Datei zeigt ein Beispiel für diese Einträge.

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

 `cdk watch`führt den `"build"` Befehl von aus`cdk.json`, um Ihre App vor der Synthese zu erstellen. Wenn für Ihre Bereitstellung Befehle erforderlich sind, um Ihren Lambda-Code (oder etwas anderes, das nicht in Ihrer CDK-App enthalten ist) zu erstellen oder zu verpacken, fügen Sie sie hier hinzu.

Platzhalter im Git-Stil, sowohl als auch`**`, können in den `"watch"` Tasten `*` und verwendet werden. `"build"` Jeder Pfad wird relativ zum übergeordneten Verzeichnis von interpretiert. `cdk.json` Der Standardwert von `include` ist`**/*`, d. h. alle Dateien und Verzeichnisse im Stammverzeichnis des Projekts. `exclude`ist optional.

**Wichtig**  
Der Überwachungsmodus wird für Produktionsbereitstellungen nicht empfohlen.

### Geben Sie Parameter an AWS CloudFormation
<a name="cli-specify-parameters"></a>

Die CDK-CLI unterstützt die Angabe von AWS CloudFormation [Parametern](parameters.md) bei der Bereitstellung. Sie können diese in der Befehlszeile nach dem `--parameters` Flag angeben.

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

Um mehrere Parameter zu definieren, verwenden Sie mehrere `--parameters` Flags.

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

Wenn Sie mehrere Stacks bereitstellen, können Sie für jeden Stack einen anderen Wert für jeden Parameter angeben. Stellen Sie dazu dem Namen des Parameters den Stacknamen und einen Doppelpunkt voran. Andernfalls wird derselbe Wert an alle Stacks übergeben.

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

Standardmäßig behält das AWS CDK Werte von Parametern aus früheren Bereitstellungen bei und verwendet sie in späteren Bereitstellungen, sofern sie nicht explizit angegeben wurden. Verwenden Sie das `--no-previous-parameters` Flag, um zu verlangen, dass alle Parameter angegeben werden.

### Geben Sie die Ausgabedatei an
<a name="cli-specify-outputs-file"></a>

Wenn Ihr Stack AWS CloudFormation Ausgaben deklariert, werden diese normalerweise nach Abschluss der Bereitstellung auf dem Bildschirm angezeigt. Um sie in eine Datei im JSON-Format zu schreiben, verwenden Sie das `--outputs-file` Flag.

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

### Genehmigen Sie sicherheitsrelevante Änderungen
<a name="cli-security"></a>

Um Sie vor unbeabsichtigten Änderungen zu schützen, die sich auf Ihre Sicherheitslage auswirken, fordert die CDK-CLI Sie auf, sicherheitsrelevante Änderungen zu genehmigen, bevor Sie sie implementieren. Sie können den Grad der Änderung angeben, für den eine Genehmigung erforderlich ist:

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

 `<LEVEL>` kann einer der folgenden sein:


| Begriff | Bedeutung | 
| --- | --- | 
|   `never`   |  Eine Genehmigung ist niemals erforderlich  | 
|   `any-change`   |  Erfordert eine Genehmigung für jede IAM oder Änderung security-group-related  | 
|   `broadening`(Standard)  |  Erfordert eine Genehmigung, wenn IAM-Anweisungen oder Verkehrsregeln hinzugefügt werden; für Löschungen ist keine Genehmigung erforderlich  | 

Die Einstellung kann auch in der Datei konfiguriert werden. `cdk.json`

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

## Stapel vergleichen
<a name="cli-diff"></a>

Der `cdk diff` Befehl vergleicht die aktuelle Version eines in Ihrer App definierten Stacks (und seine Abhängigkeiten) mit den bereits bereitgestellten Versionen oder mit einer gespeicherten AWS CloudFormation Vorlage und zeigt eine Liste der Änderungen an.

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

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

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

So vergleichen Sie die Stacks Ihrer App mit der vorhandenen Bereitstellung:

```
cdk diff MyStack
```

So vergleichen Sie die Stacks Ihrer App mit einer gespeicherten CloudFormation Vorlage:

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

## Importiere vorhandene Ressourcen in einen Stack
<a name="cli-import"></a>

Sie können den `cdk import` Befehl verwenden, um Ressourcen CloudFormation für einen bestimmten AWS CDK-Stack unter die Verwaltung zu stellen. [Dies ist nützlich, wenn Sie zu AWS CDK migrieren oder Ressourcen zwischen Stacks verschieben oder ihre logische ID ändern. verwendet Ressourcenimporte. `cdk import` CloudFormation ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import.html) Die [Liste der Ressourcen, die importiert werden können,](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import-supported-resources.html) finden Sie hier.

Gehen Sie wie folgt vor, um eine vorhandene Ressource in einen AWS CDK-Stack zu importieren:
+ Stellen Sie sicher, dass die Ressource derzeit von keinem anderen CloudFormation Stack verwaltet wird. Ist dies der Fall, legen Sie zunächst die Entfernungsrichtlinie auf den Stapel fest, `RemovalPolicy.RETAIN` in dem sich die Ressource gerade befindet, und führen Sie eine Bereitstellung durch. Entfernen Sie dann die Ressource aus dem Stapel und führen Sie eine weitere Bereitstellung durch. Durch diesen Vorgang wird sichergestellt, dass die Ressource nicht mehr von verwaltet wird, sie wird CloudFormation aber nicht gelöscht.
+ Führen Sie a aus`cdk diff`, um sicherzustellen, dass keine ausstehenden Änderungen am AWS CDK-Stack vorliegen, in den Sie Ressourcen importieren möchten. Die einzigen Änderungen, die bei einem „Import“ -Vorgang zulässig sind, sind das Hinzufügen neuer Ressourcen, die Sie importieren möchten.
+ Fügen Sie Konstrukte für die Ressourcen hinzu, die Sie in Ihren Stack importieren möchten. Wenn Sie beispielsweise einen Amazon S3 S3-Bucket importieren möchten, fügen Sie etwas hinzu wie`new s3.Bucket(this, 'ImportedS3Bucket', {});`. Nehmen Sie keine Änderungen an anderen Ressourcen vor.

  Sie müssen auch sicherstellen, dass der Status, den die Ressource derzeit hat, exakt in der Definition modelliert wird. Achten Sie beim Beispiel des Buckets darauf, AWS KMS-Schlüssel, Lebenszyklusrichtlinien und alles andere, was für den Bucket relevant ist, mit einzubeziehen. Wenn Sie dies nicht tun, führen nachfolgende Aktualisierungsvorgänge möglicherweise nicht zu Ihren Erwartungen.

  Sie können wählen, ob Sie den physischen Bucket-Namen angeben möchten oder nicht. Wir empfehlen normalerweise, keine Ressourcennamen in Ihre AWS CDK-Ressourcendefinitionen aufzunehmen, damit es einfacher wird, Ihre Ressourcen mehrfach bereitzustellen.
+ Führen Sie `cdk import <STACKNAME>`.
+ Wenn die Ressourcennamen nicht in Ihrem Modell enthalten sind, werden Sie von der CLI aufgefordert, die tatsächlichen Namen der Ressourcen, die Sie importieren, zu übergeben. Danach beginnt der Import.
+ Wenn ein Erfolg `cdk import` gemeldet wird, wird die Ressource jetzt von AWS CDK und CloudFormation verwaltet. Alle nachfolgenden Änderungen, die Sie an den Ressourceneigenschaften in Ihrer AWS CDK-App und der Construct-Konfiguration vornehmen, werden bei der nächsten Bereitstellung angewendet.
+ Um zu überprüfen, ob die Ressourcendefinition in Ihrer AWS CDK-App dem aktuellen Status der Ressource entspricht, können Sie einen Vorgang [zur Erkennung von CloudFormation Abweichungen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html) starten.

Diese Funktion unterstützt derzeit nicht den Import von Ressourcen in verschachtelte Stacks.

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

Standardwerte für viele CDK-CLI-Befehlszeilenflags können in einer `cdk.json` Projektdatei oder in der `.cdk.json` Datei in Ihrem Benutzerverzeichnis gespeichert werden. Im Folgenden finden Sie eine alphabetische Referenz zu den unterstützten Konfigurationseinstellungen.


| Key (Schlüssel) | Hinweise | CDK-CLI-Option | 
| --- | --- | --- | 
|   `app`   |  Der Befehl, der die CDK-Anwendung ausführt.  |   `--app`   | 
|   `assetMetadata`   |  Falls`false`, fügt CDK Ressourcen, die Assets verwenden, keine Metadaten hinzu.  |   `--no-asset-metadata`   | 
|   `bootstrapKmsKeyId`   |  Setzt die ID des AWS KMS-Schlüssels außer Kraft, der zur Verschlüsselung des Amazon S3 S3-Bereitstellungs-Buckets verwendet wurde.  |   `--bootstrap-kms-key-id`   | 
|   `build`   |  Der Befehl, der die CDK-Anwendung vor der Synthese kompiliert oder erstellt. Nicht erlaubt in. `~/.cdk.json`  |   `--build`   | 
|   `browser`   |  Der Befehl zum Starten eines Webbrowsers für den `cdk docs` Unterbefehl.  |   `--browser`   | 
|   `context`   |  Siehe [Kontextwerte und AWS CDK](context.md). Kontextwerte in einer Konfigurationsdatei werden von nicht gelöscht. `cdk context --clear` (Die CDK-CLI platziert zwischengespeicherte Kontextwerte in`cdk.context.json`.)  |   `--context`   | 
|   `debug`   |  Falls`true`, gibt CDK CLI detailliertere Informationen aus, die für das Debuggen nützlich sind.  |   `--debug`   | 
|   `language`   |  Die Sprache, die für die Initialisierung neuer Projekte verwendet werden soll.  |   `--language`   | 
|   `lookups`   |  Falls`false`, sind keine Kontext-Lookups zulässig. Die Synthese schlägt fehl, wenn Kontext-Lookups durchgeführt werden müssen.  |   `--no-lookups`   | 
|   `notices`   |  Wenn`false`, unterdrückt die Anzeige von Meldungen über Sicherheitslücken, Regressionen und nicht unterstützte Versionen.  |   `--no-notices`   | 
|   `output`   |  Der Name des Verzeichnisses, in das die synthetisierte Cloud-Assembly ausgegeben wird (Standard). `"cdk.out"`  |   `--output`   | 
|   `outputsFile`   |  Die Datei, in die AWS CloudFormation Ausgaben von bereitgestellten Stacks geschrieben werden (im `JSON` Format).  |   `--outputs-file`   | 
|   `pathMetadata`   |  Falls`false`, werden CDK-Pfad-Metadaten nicht zu synthetisierten Vorlagen hinzugefügt.  |   `--no-path-metadata`   | 
|   `plugin`   |  JSON-Array, das die Paketnamen oder lokalen Pfade von Paketen angibt, die das CDK erweitern  |   `--plugin`   | 
|   `profile`   |  Name des AWS Standardprofils, das für die Angabe der Region und der Kontoanmeldedaten verwendet wird.  |   `--profile`   | 
|   `progress`   |  Wenn auf gesetzt`"events"`, zeigt die CDK-CLI alle AWS CloudFormation Ereignisse während der Bereitstellung an und nicht einen Fortschrittsbalken.  |   `--progress`   | 
|   `requireApproval`   |  Standardgenehmigungsstufe für Sicherheitsänderungen. Weitere Informationen finden Sie unter [Sicherheitsrelevante Änderungen genehmigen](#cli-security)   |   `--require-approval`   | 
|   `rollback`   |  Falls`false`, werden fehlgeschlagene Bereitstellungen nicht rückgängig gemacht.  |   `--no-rollback`   | 
|   `staging`   |  Falls`false`, werden die Assets nicht in das Ausgabeverzeichnis kopiert (wird für das lokale Debuggen der Quelldateien mit AWS SAM verwendet).  |   `--no-staging`   | 
|   `tags`   |   `JSON`Objekt, das Tags (Schlüssel-Wert-Paare) für den Stapel enthält.  |   `--tags`   | 
|   `toolkitBucketName`   |  Der Name des Amazon S3 S3-Buckets, der für die Bereitstellung von Ressourcen wie Lambda-Funktionen und Container-Images verwendet wird (siehe [Bootstrap für Ihre AWS Umgebung](#cli-bootstrap)).  |   `--toolkit-bucket-name`   | 
|   `toolkitStackName`   |  Der Name des Bootstrap-Stacks (siehe [Bootstrap](#cli-bootstrap) für Ihre Umgebung). AWS   |   `--toolkit-stack-name`   | 
|   `versionReporting`   |  Falls`false`, deaktiviert die Versionsberichterstattung.  |   `--no-version-reporting`   | 
|   `watch`   |  JSON-Objekt, das `"exclude"` Schlüssel `"include"` und Schlüssel enthält, die angeben, welche Dateien bei Änderungen eine Neuerstellung des Projekts auslösen sollen (oder nicht). Siehe [Überwachungsmodus](#cli-deploy-watch).  |   `--watch`   | 