Amazon CodeCatalyst ist nicht mehr offen für Neukunden. Bestandskunden können den Service weiterhin wie gewohnt nutzen. Weitere Informationen finden Sie unter [Wie migriert man von CodeCatalyst](migration.md).

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.

# Bereitstellung mit Workflows
<a name="deploy"></a>



Mithilfe von [CodeCatalyst Workflows](workflow.md) können Sie Anwendungen und andere Ressourcen für verschiedene Ziele wie Amazon ECS und mehr bereitstellen. AWS Lambda

## Wie stelle ich eine Anwendung bereit?
<a name="deploy-concepts"></a>

Um eine Anwendung oder Ressource bereitzustellen CodeCatalyst, erstellen Sie zunächst einen Workflow und geben dann darin eine Bereitstellungsaktion an. Eine *Bereitstellungsaktion* ist ein Workflow-Baustein, der definiert, *was* Sie bereitstellen möchten, *wo* Sie es bereitstellen möchten und *wie* Sie es bereitstellen möchten (z. B. mithilfe eines blue/green Schemas). Sie fügen Ihrem Workflow mithilfe des visuellen Editors oder YAML-Editors der CodeCatalyst Konsole eine Bereitstellungsaktion hinzu.

Die allgemeinen Schritte zur Bereitstellung einer Anwendung oder Ressource lauten wie folgt.

**So stellen Sie eine Anwendung bereit (Aufgaben auf hoher Ebene)**

1. In Ihrem CodeCatalyst Projekt **fügen Sie Quellcode** für eine Anwendung hinzu, die Sie bereitstellen möchten. Weitere Informationen finden Sie unter [Speichern von Quellcode in Repositorys für ein Projekt in CodeCatalyst](source-repositories.md).

1. In Ihrem CodeCatalyst Projekt **fügen Sie eine Umgebung** hinzu, die das Ziel AWS-Konto und die optionale Amazon Virtual Private Cloud (VPC) definiert, für die Sie die Bereitstellung durchführen möchten. Weitere Informationen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md).

1. In Ihrem CodeCatalyst Projekt **erstellen Sie einen Workflow**. In diesem Workflow definieren Sie, wie Ihre Anwendung erstellt, getestet und bereitgestellt werden soll. Weitere Informationen finden Sie unter [Erste Schritte mit Workflows](workflows-getting-started.md).

1. Im Workflow **fügen Sie einen Auslöser**, eine **Build-Aktion** und optional eine **Testaktion** hinzu. Weitere Informationen finden Sie unter [Automatisches Starten einer Workflow-Ausführung mithilfe von Triggern](workflows-add-trigger.md), [Hinzufügen der Build-Aktion](build-add-action.md) und [Testaktion hinzufügen](test-add-action.md).

1. Im Workflow **fügen Sie eine Bereitstellungsaktion** hinzu. Sie können aus mehreren CodeCatalyst bereitgestellten Bereitstellungsaktionen für Ihre Anwendung für verschiedene Ziele wählen, z. B. Amazon ECS. (Sie können auch eine Build-Aktion oder eine GitHub Aktion verwenden, um Ihre Anwendung bereitzustellen. Weitere Informationen zur Build-Aktion und zu GitHub Aktionen finden Sie unter[Alternativen zur Bereitstellung von Aktionen](#deploy-concepts-alternatives).)

1. Sie **starten den Workflow** entweder manuell oder automatisch über einen Trigger. Der Workflow führt die Build-, Test- und Bereitstellungsaktionen nacheinander aus, um Ihre Anwendung und Ressourcen auf dem Ziel bereitzustellen. Weitere Informationen finden Sie unter [Manuelles Starten einer Workflow-Ausführung](workflows-manually-start.md).

## Liste der Bereitstellungsaktionen
<a name="deploy-concepts-action-supported"></a>

Die folgenden Bereitstellungsaktionen sind verfügbar:
+  CloudFormation Stack bereitstellen — Diese Aktion erstellt einen CloudFormation Stack auf der AWS Grundlage einer [CloudFormation Vorlage](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) oder [AWS Serverless Application Model Vorlage](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html), die Sie bereitstellen. Weitere Informationen finden Sie unter [Einen CloudFormation Stack bereitstellen](deploy-action-cfn.md).
+ In Amazon ECS bereitstellen — Diese Aktion registriert eine von Ihnen bereitgestellte [Aufgabendefinitionsdatei](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions). Weitere Informationen finden Sie unter [Bereitstellung auf Amazon ECS mit einem Workflow](deploy-action-ecs.md).
+ Auf Kubernetes-Cluster bereitstellen — Diese Aktion stellt eine Anwendung in einem Amazon Elastic Kubernetes Service Service-Cluster bereit. Weitere Informationen finden Sie unter [Bereitstellung auf Amazon EKS mit einem Workflow](deploy-action-eks.md).
+ AWS CDK [bereitstellen — Diese Aktion stellt eine App bereit in.AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_concepts) AWS Weitere Informationen finden Sie unter [Eine AWS CDK App mit einem Workflow bereitstellen](cdk-dep-action.md).

**Anmerkung**  
Es gibt andere CodeCatalyst Aktionen, mit denen Ressourcen bereitgestellt werden können. Sie gelten jedoch nicht als *Bereitstellungsaktionen*, da ihre Bereitstellungsinformationen nicht auf der Seite **Umgebungen** angezeigt werden. Weitere Informationen zur Seite „**Umgebungen**“ und zum Anzeigen von Bereitstellungen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md) und[Bereitstellungsinformationen anzeigen](deploy-view-deployment-info.md).

## Vorteile von Bereitstellungsaktionen
<a name="deploy-concepts-why-use"></a>

Die Verwendung von Bereitstellungsaktionen innerhalb eines Workflows hat die folgenden Vorteile:
+ **Bereitstellungsverlauf** — Sehen Sie sich einen Verlauf Ihrer Bereitstellungen an, um Änderungen an Ihrer bereitgestellten Software besser verwalten und kommunizieren zu können. 
+ **Rückverfolgbarkeit** — Verfolgen Sie den Status Ihrer Bereitstellungen über die CodeCatalyst Konsole und sehen Sie, wann und wo die einzelnen Anwendungsversionen bereitgestellt wurden.
+ **Rollbacks** — Machen Sie Bereitstellungen automatisch rückgängig, wenn Fehler auftreten. Sie können auch Alarme konfigurieren, um Bereitstellungs-Rollbacks zu aktivieren.
+ **Überwachung** — Beobachten Sie Ihre Implementierung, während sie die verschiedenen Phasen Ihres Workflows durchläuft.
+ **Integration mit anderen CodeCatalyst Funktionen** — Speichern Sie den Quellcode und erstellen, testen und implementieren Sie ihn — alles von einer einzigen Anwendung aus.

## Alternativen zur Bereitstellung von Aktionen
<a name="deploy-concepts-alternatives"></a>

Sie müssen keine Bereitstellungsaktionen verwenden, obwohl sie empfohlen werden, da sie die im vorherigen Abschnitt beschriebenen Vorteile bieten. Stattdessen können Sie die folgenden [CodeCatalyst Aktionen](workflows-actions.md#workflows-actions-types-cc) verwenden:
+ Eine **Build-Aktion**.

  In der Regel verwenden Sie Build-Aktionen, wenn Sie eine Bereitstellung auf einem Ziel durchführen möchten, für das es keine entsprechende Bereitstellungsaktion gibt, oder wenn Sie mehr Kontrolle über das Bereitstellungsverfahren haben möchten. Weitere Informationen zur Verwendung von Build-Aktionen zur Bereitstellung von Ressourcen finden Sie unter[Bauen mit Workflows](build-workflow-actions.md).
+ Eine **GitHub Aktion**.

  Sie können eine [GitHub Aktion](workflows-actions.md#workflows-actions-types-github) innerhalb eines CodeCatalyst Workflows verwenden, um Anwendungen und Ressourcen bereitzustellen (anstelle einer CodeCatalyst Aktion). Informationen zur Verwendung von GitHub Aktionen innerhalb eines CodeCatalyst Workflows finden Sie unter [Integration mit GitHub Aktionen](integrations-github-actions.md)

Sie können auch die folgenden AWS Dienste verwenden, um Ihre Anwendung bereitzustellen, wenn Sie dafür keinen CodeCatalyst Workflow verwenden möchten:
+ AWS CodeDeploy — siehe [Was ist CodeDeploy?](https://docs.aws.amazon.com/codedeploy/latest/userguide/welcome.html)
+ AWS CodeBuild und AWS CodePipeline — siehe [Was ist AWS CodeBuild?](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html) und [Was ist AWS CodePipeline?](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)
+ CloudFormation — siehe [Was ist CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)

Verwenden Sie CodeDeploy CodeBuild, CodePipeline, und CloudFormation Services für komplexe Unternehmensbereitstellungen.

**Topics**
+ [Wie stelle ich eine Anwendung bereit?](#deploy-concepts)
+ [Liste der Bereitstellungsaktionen](#deploy-concepts-action-supported)
+ [Vorteile von Bereitstellungsaktionen](#deploy-concepts-why-use)
+ [Alternativen zur Bereitstellung von Aktionen](#deploy-concepts-alternatives)
+ [Bereitstellung auf Amazon ECS mit einem Workflow](deploy-action-ecs.md)
+ [Bereitstellung auf Amazon EKS mit einem Workflow](deploy-action-eks.md)
+ [Einen CloudFormation Stack bereitstellen](deploy-action-cfn.md)
+ [Eine AWS CDK App mit einem Workflow bereitstellen](cdk-dep-action.md)
+ [Bootstrapping einer AWS CDK App mit einem Workflow](cdk-boot-action.md)
+ [Veröffentlichen von Dateien in Amazon S3 mit einem Workflow](s3-pub-action.md)
+ [Einsatz in AWS-Konten und VPCs](deploy-environments.md)
+ [Anzeige der App-URL im Workflow-Diagramm](deploy-app-url.md)
+ [Ein Bereitstellungsziel entfernen](deploy-remove-target.md)
+ [Verfolgen des Bereitstellungsstatus nach Commit](track-changes.md)
+ [Bereitstellungsprotokolle anzeigen](deploy-deployment-logs.md)
+ [Bereitstellungsinformationen anzeigen](deploy-view-deployment-info.md)

# Bereitstellung auf Amazon ECS mit einem Workflow
<a name="deploy-action-ecs"></a>

In diesem Abschnitt wird beschrieben, wie eine containerisierte Anwendung mithilfe eines Workflows in einem Amazon Elastic Container Service-Cluster bereitgestellt wird. CodeCatalyst Um dies zu erreichen, müssen Sie Ihrem Workflow die Aktion **Deploy to Amazon ECS** hinzufügen. Diese Aktion registriert eine von Ihnen bereitgestellte [Aufgabendefinitionsdatei](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions). Nach der Registrierung wird die Aufgabendefinition von Ihrem [Amazon ECS-Service instanziiert, der in Ihrem [Amazon ECS-Cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) ausgeführt wird. Das „Instanziieren einer Aufgabendefinition“ entspricht der Bereitstellung einer Anwendung in Amazon ECS.

Um diese Aktion verwenden zu können, müssen Sie einen Amazon ECS-Cluster, einen Service und eine Aufgabendefinitionsdatei bereit haben.

Weitere Informationen zu Amazon ECS finden Sie im *Amazon Elastic Container Service Developer Guide*.

**Tipp**  
Ein Tutorial, das Ihnen zeigt, wie Sie die Aktion **Deploy to Amazon ECS** verwenden, finden Sie unter[Tutorial: Bereitstellen einer Anwendung in Amazon ECS](deploy-tut-ecs.md).

**Tipp**  
Um ein funktionierendes Beispiel für die Aktion **Deploy to Amazon ECS** zu erhalten, erstellen Sie ein Projekt entweder mit der **Node.js API mit AWS Fargate** oder der **Java-API mit AWS Fargate** Blueprint. Weitere Informationen finden Sie unter [Ein Projekt mit einem Blueprint erstellen](projects-create.md#projects-create-console-template).

**Topics**
+ [Runtime-Image, das von der Aktion „In Amazon ECS bereitstellen“ verwendet wird](#deploy-action-ecs-runtime)
+ [Tutorial: Bereitstellen einer Anwendung in Amazon ECS](deploy-tut-ecs.md)
+ [Aktion „In Amazon ECS bereitstellen“ hinzufügen](deploy-action-ecs-adding.md)
+ [Variablen „In Amazon ECS bereitstellen“](deploy-action-ecs-variables.md)
+ [Aktion „In Amazon ECS bereitstellen“ YAML](deploy-action-ref-ecs.md)

## Runtime-Image, das von der Aktion „In Amazon ECS bereitstellen“ verwendet wird
<a name="deploy-action-ecs-runtime"></a>

Die Aktion **Deploy to Amazon ECS** wird auf einem [Image vom November 2022](build-images.md#build.previous-image) ausgeführt. Weitere Informationen finden Sie unter [Aktive Bilder](build-images.md#build-curated-images).

# Tutorial: Bereitstellen einer Anwendung in Amazon ECS
<a name="deploy-tut-ecs"></a>

In diesem Tutorial erfahren Sie, wie Sie mithilfe eines Workflows, Amazon ECS und einiger anderer AWS Services eine serverlose Anwendung in Amazon Elastic Container Service (Amazon ECS) bereitstellen. Bei der bereitgestellten Anwendung handelt es sich um eine einfache Hello World-Website, die auf einem Docker-Image des Apache-Webservers basiert. Das Tutorial führt Sie durch die erforderlichen Vorbereitungsarbeiten, z. B. die Einrichtung eines Clusters, und beschreibt anschließend, wie Sie einen Workflow für die Erstellung und Bereitstellung der Anwendung erstellen.

**Tipp**  
Anstatt sich durch dieses Tutorial zu arbeiten, können Sie einen Blueprint verwenden, der ein vollständiges Amazon ECS-Setup für Sie durchführt. Sie müssen entweder die **Node.js API mit AWS Fargate oder die **Java API mit AWS Fargate**** Blueprint verwenden. Weitere Informationen finden Sie unter [Ein Projekt mit einem Blueprint erstellen](projects-create.md#projects-create-console-template).

**Topics**
+ [Voraussetzungen](#deploy-tut-ecs-prereqs)
+ [Schritt 1: Richten Sie einen AWS Benutzer ein und AWS CloudShell](#deploy-tut-ecs-user-cloudshell)
+ [Schritt 2: Stellen Sie eine Platzhalteranwendung in Amazon ECS bereit](#deploy-tut-ecs-placeholder)
+ [Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository](#deploy-tut-ecs-ecr)
+ [Schritt 4: AWS Rollen erstellen](#deploy-tut-ecs-build-deploy-roles)
+ [Schritt 5: AWS Rollen hinzufügen CodeCatalyst](#deploy-tut-ecs-import-roles)
+ [Schritt 6: Erstellen Sie ein Quell-Repository](#deploy-tut-ecs-source-repo)
+ [Schritt 7: Quelldateien hinzufügen](#deploy-tut-ecs-source-files)
+ [Schritt 8: Erstellen Sie einen Workflow und führen Sie ihn aus](#deploy-tut-ecs-workflow)
+ [Schritt 9: Nehmen Sie eine Änderung an Ihren Quelldateien vor](#deploy-tut-ecs-change)
+ [Bereinigen](#deploy-tut-ecs-cleanup)

## Voraussetzungen
<a name="deploy-tut-ecs-prereqs"></a>

Bevor Sie beginnen:
+ Sie benötigen einen CodeCatalyst **Bereich** mit einem verbundenen AWS Konto. Weitere Informationen finden Sie unter [Erstellen einer Umgebung](spaces-create.md).
+ In Ihrem Bereich benötigen Sie ein leeres Projekt mit dem Namen:

  ```
  codecatalyst-ecs-project
  ```

  Verwenden Sie die Option **Von vorne beginnen**, um dieses Projekt zu erstellen.

  Weitere Informationen finden Sie unter [Ein leeres Projekt in Amazon erstellen CodeCatalyst](projects-create.md#projects-create-empty).
+ In Ihrem Projekt benötigen Sie eine CodeCatalyst **Umgebung** mit dem Namen:

  ```
  codecatalyst-ecs-environment
  ```

  Konfigurieren Sie diese Umgebung wie folgt:
  + Wählen Sie einen beliebigen Typ aus, z. B. „Keine **Produktion**“.
  + Connect dein AWS Konto damit.
  + Wählen Sie für die **Standard-IAM-Rolle eine** beliebige Rolle aus. Sie werden später eine andere Rolle angeben.

  Weitere Informationen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md).

## Schritt 1: Richten Sie einen AWS Benutzer ein und AWS CloudShell
<a name="deploy-tut-ecs-user-cloudshell"></a>

Der erste Schritt in diesem Tutorial besteht darin AWS IAM Identity Center, einen Benutzer zu erstellen und eine AWS CloudShell Instanz als dieser Benutzer zu starten. Für die Dauer dieses Tutorials CloudShell ist dies Ihr Entwicklungscomputer, auf dem Sie AWS Ressourcen und Dienste konfigurieren. Löschen Sie diesen Benutzer, nachdem Sie das Tutorial abgeschlossen haben.

**Anmerkung**  
Verwenden Sie für dieses Tutorial nicht Ihren Root-Benutzer. Sie müssen einen separaten Benutzer erstellen, da sonst später Probleme bei der Ausführung von Aktionen in der AWS Command Line Interface (CLI) auftreten können.

Weitere Informationen zu IAM Identity Center-Benutzern finden Sie im *AWS IAM Identity Center Benutzerhandbuch* und im *AWS CloudShell Benutzerhandbuch*. CloudShell 

**So erstellen Sie einen IAM Identity Center-Benutzer**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS IAM Identity Center Konsole unter [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/).
**Anmerkung**  
Stellen Sie sicher, dass Sie sich mit dem anmelden AWS-Konto , der mit Ihrem CodeCatalyst Bereich verbunden ist. Sie können überprüfen, welches Konto verbunden ist, indem Sie zu Ihrem Bereich navigieren und den Tab **AWS-Konten** auswählen. Weitere Informationen finden Sie unter [Erstellen einer Umgebung](spaces-create.md).

1. Wählen Sie im Navigationsbereich **Users (Benutzer)** und dann **Add User (Benutzer hinzufügen)** aus.

1. Geben Sie im Feld **Nutzername** Folgendes ein:

   ```
   CodeCatalystECSUser
   ```

1. Wählen Sie unter **Passwort** die Option **Einmalpasswort generieren aus, das Sie mit diesem Benutzer teilen können**.

1. Geben Sie in den **Feldern **E-Mail-Adresse** und E-Mail-Adresse bestätigen** eine E-Mail-Adresse ein, die noch nicht in IAM Identity Center existiert.

1. Geben Sie in die Felder **Vorname** und **Nachname** Folgendes ein:

   ```
   CodeCatalystECSUser
   ```

1. Behalten Sie im Feld **Anzeigename** den automatisch generierten Namen bei:

   ```
   CodeCatalystECSUser CodeCatalystECSUser
   ```

1. Wählen Sie **Weiter** aus.

1. Wählen Sie auf der Seite „**Benutzer zu Gruppen hinzufügen**“ die Option **Weiter** aus.

1. Überprüfen Sie auf der Seite **Benutzer überprüfen und hinzufügen** die Informationen und wählen Sie **Benutzer hinzufügen** aus.

   Ein Dialogfeld mit einem **Einmalkennwort** wird angezeigt.

1. Wählen Sie **Kopieren** und fügen Sie dann die Anmeldeinformationen ein, einschließlich der URL des AWS Zugriffsportals und des Einmalkennworts.

1. Klicken Sie auf **Schließen**.

**So erstellen Sie einen Berechtigungssatz**

Sie weisen diesen Berechtigungssatz `CodeCatalystECSUser` später zu.

1. Wählen Sie im Navigationsbereich die Option **Berechtigungssätze** und dann **Berechtigungssatz erstellen** aus.

1. Wählen Sie **Vordefinierter Berechtigungssatz** und dann aus **AdministratorAccess**. Diese Richtlinie gewährt allen volle Berechtigungen AWS-Services. 

1. Wählen Sie **Weiter** aus.

1. Geben Sie im Feld **Name des Berechtigungssatzes** Folgendes ein:

   ```
   CodeCatalystECSPermissionSet
   ```

1. Wählen Sie **Weiter** aus.

1. **Überprüfen Sie auf der Seite Überprüfen und erstellen** die Informationen und wählen Sie **Erstellen** aus.

**Um den Berechtigungssatz zuzuweisen CodeCatalyst ECSUser**

1. Wählen Sie im Navigationsbereich das Kontrollkästchen neben dem aus **AWS-Konten**, bei dem Sie derzeit angemeldet sind AWS-Konto , und aktivieren Sie es anschließend.

1. Wählen Sie **Benutzer oder Gruppen zuweisen** aus.

1. Wählen Sie die Registerkarte **Users**.

1. Aktivieren Sie das Kontrollkästchen neben`CodeCatalystECSUser`.

1. Wählen Sie **Weiter** aus.

1. Aktivieren Sie das Kontrollkästchen neben`CodeCatalystECSPermissionSet`.

1. Wählen Sie **Weiter** aus.

1. Überprüfen Sie die Informationen und wählen Sie **Senden** aus.

   Sie haben sie nun `CodeCatalystECSPermissionSet` zugewiesen `CodeCatalystECSUser` und an Sie AWS-Konto gebunden.

**Um sich abzumelden und wieder anzumelden als CodeCatalyst ECSUser**

1. Bevor Sie sich abmelden, stellen Sie sicher, dass Sie die URL des AWS Zugriffsportals sowie den Benutzernamen und das Einmalpasswort für haben`CodeCatalystECSUser`. Sie hätten diese Informationen früher in einen Texteditor kopieren sollen.
**Anmerkung**  
Wenn Ihnen diese Informationen nicht vorliegen, rufen Sie die `CodeCatalystECSUser` Detailseite im IAM Identity Center auf und wählen Sie **Passwort zurücksetzen**, **Einmalpasswort generieren [...]** , und klicken **Sie erneut auf Passwort zurücksetzen**, um die Informationen auf dem Bildschirm anzuzeigen.

1. Melden Sie sich ab AWS.

1. Fügen Sie die URL des AWS Zugangsportals in die Adressleiste Ihres Browsers ein.

1. Melden Sie sich mit dem Benutzernamen und dem Einmalpasswort für an`CodeCatalystECSUser`.

1. Geben Sie **unter Neues Passwort** ein Passwort ein und wählen Sie **Neues Passwort festlegen** aus.

   Auf dem Bildschirm erscheint ein **AWS-Konto**Feld.

1. Wählen Sie **AWS-Konto**und wählen Sie dann den Namen des Benutzers und des AWS-Konto Berechtigungssatzes aus, dem Sie den `CodeCatalystECSUser` Benutzer zugewiesen haben.

1. Wählen Sie neben dem `CodeCatalystECSPermissionSet` die Option **Verwaltungskonsole** aus.

   Das AWS-Managementkonsole erscheint. Sie sind jetzt `CodeCatalystECSUser` mit den entsprechenden Berechtigungen angemeldet.

**Um eine AWS CloudShell Instance zu starten**

1. Wählen Sie wie `CodeCatalystECSUser` in der oberen Navigationsleiste das AWS Symbol (![\[AWS icon\]](http://docs.aws.amazon.com/de_de/codecatalyst/latest/userguide/images/deploy/aws-logo.png)).

   Die Hauptseite von wird AWS-Managementkonsole angezeigt.

1. Wählen Sie in der oberen Navigationsleiste das AWS CloudShell Symbol (![\[CloudShell icon\]](http://docs.aws.amazon.com/de_de/codecatalyst/latest/userguide/images/deploy/CloudShell.png)).

   CloudShell öffnet. Warten Sie, bis die CloudShell Umgebung erstellt ist.
**Anmerkung**  
Wenn Sie das CloudShell Symbol nicht sehen, vergewissern Sie sich, dass Sie sich in einer [Region befinden, die von unterstützt wird CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available). In diesem Tutorial wird davon ausgegangen, dass Sie sich in der Region USA West (Oregon) befinden.

**Um zu überprüfen, ob der installiert AWS CLI ist**

1. Geben Sie im CloudShell Terminal Folgendes ein:

   ```
   aws --version
   ```

1. Vergewissern Sie sich, dass eine Version angezeigt wird.

   Der AWS CLI ist bereits für den aktuellen Benutzer konfiguriert`CodeCatalystECSUser`, sodass keine AWS CLI Schlüssel und Anmeldeinformationen konfiguriert werden müssen, wie dies normalerweise der Fall ist.

## Schritt 2: Stellen Sie eine Platzhalteranwendung in Amazon ECS bereit
<a name="deploy-tut-ecs-placeholder"></a>

In diesem Abschnitt stellen Sie manuell eine Platzhalteranwendung in Amazon ECS bereit. Diese Platzhalteranwendung wird durch die Hello World-Anwendung ersetzt, die in Ihrem Workflow bereitgestellt wird. Die Platzhalteranwendung ist Apache Web Server.

Weitere Informationen zu Amazon ECS finden Sie im *Amazon Elastic Container Service Developer Guide*.

Führen Sie die folgenden Schritte durch, um die Platzhalteranwendung bereitzustellen.<a name="deploy-tut-ecs-create-task-execution-role"></a>

**Um die Rolle zur Aufgabenausführung zu erstellen**

Diese Rolle gewährt Amazon ECS die AWS Fargate Erlaubnis, API-Aufrufe in Ihrem Namen durchzuführen. 

1. Erstellen Sie eine Vertrauensrichtlinie:

   1. Geben Sie in AWS CloudShell den folgenden Befehl ein:

      ```
      cat > codecatalyst-ecs-trust-policy.json
      ```

      Im CloudShell Terminal erscheint eine blinkende Aufforderung.

   1. Geben Sie an der Eingabeaufforderung den folgenden Code ein:

------
#### [ JSON ]

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
              "Service": "ecs-tasks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }
      ```

------

   1. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer (`}`).

   1. Drücken Sie dann **Enter** und**Ctrl\$1d**, um die Datei zu speichern und cat zu beenden.

1. Erstellen Sie eine Rolle zur Aufgabenausführung:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-task-execution-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Hängen Sie die AWS verwaltete `AmazonECSTaskExecutionRolePolicy` Richtlinie an die Rolle an:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-task-execution-role \
         --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
   ```

1. Zeigen Sie die Details der Rolle an:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-task-execution-role
   ```

1. Notieren Sie sich den `"Arn":` Wert der Rolle, zum Beispiel`arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role`. Sie benötigen diesen Amazon-Ressourcennamen (ARN) später.

**Erstellen eines Amazon ECS-Clusters**

Dieser Cluster wird die Apache-Platzhalteranwendung und später die Hello World-Anwendung enthalten. 

1. Wie in `CodeCatalystECSUser` AWS CloudShell, erstellen Sie einen leeren Cluster:

   ```
   aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
   ```

1. (Optional) Stellen Sie sicher, dass der Cluster erfolgreich erstellt wurde:

   ```
   aws ecs list-clusters
   ```

   Der ARN des `codecatalyst-ecs-cluster` Clusters sollte in der Liste erscheinen, was auf eine erfolgreiche Erstellung hinweist.

**Um eine Aufgabendefinitionsdatei zu erstellen**

Die Aufgabendefinitionsdatei gibt an, dass das Docker-Image (`httpd:2.4`) des [Apache 2.4-Webservers](https://hub.docker.com/_/httpd) ausgeführt werden soll, von DockerHub dem abgerufen wird.

1. Wie in `CodeCatalystECSUser` AWS CloudShell, erstellen Sie eine Aufgabendefinitionsdatei:

   ```
   cat > taskdef.json
   ```

1. Fügen Sie den folgenden Code an der Eingabeaufforderung ein:

   ```
   {
       "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               "image": "httpd:2.4",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "cpu": "256",
       "family": "codecatalyst-ecs-task-def",
       "memory": "512",
       "networkMode": "awsvpc"
   }
   ```

   Ersetzen Sie im vorherigen Code *arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role*

   mit dem ARN der Aufgabenausführungsrolle, die Sie notiert haben[Um die Rolle zur Aufgabenausführung zu erstellen](#deploy-tut-ecs-create-task-execution-role).

1. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer (`}`).

1. Drücken Sie dann **Enter** und**Ctrl\$1d**, um die Datei zu speichern und cat zu beenden.

**Um die Aufgabendefinitionsdatei bei Amazon ECS zu registrieren**

1. Wie in `CodeCatalystECSUser` AWS CloudShell, registrieren Sie die Aufgabendefinition:

   ```
   aws ecs register-task-definition \
       --cli-input-json file://taskdef.json
   ```

1. (Optional) Stellen Sie sicher, dass die Aufgabendefinition registriert wurde:

   ```
   aws ecs list-task-definitions
   ```

   Die `codecatalyst-ecs-task-def` Aufgabendefinition sollte in der Liste erscheinen.

**Um den Amazon ECS-Service zu erstellen**

Der Amazon ECS-Service führt die Aufgaben (und die zugehörigen Docker-Container) der Apache-Platzhalteranwendung und später der Hello World-Anwendung aus.

1. Wechseln Sie außerdem zur Amazon Elastic Container Service-Konsole, falls Sie dies noch nicht getan haben. `CodeCatalystECSUser`

1. Wählen Sie den Cluster aus, den Sie zuvor erstellt haben,`codecatalyst-ecs-cluster`.

1. Wählen Sie auf der Registerkarte **Dienste** die Option **Erstellen** aus.

1. Gehen Sie auf der Seite **Erstellen** wie folgt vor:

   1. Behalten Sie alle Standardeinstellungen mit Ausnahme der im Folgenden aufgeführten bei.

   1. Wählen Sie unter **Launch type (Starttyp)** **FARGATE** aus.

   1. Wählen Sie unter **Aufgabendefinition** in der Dropdownliste **Familie** die folgenden Optionen aus:

      `codecatalyst-ecs-task-def`

   1. Geben Sie als **Dienstname** Folgendes ein:

      ```
      codecatalyst-ecs-service
      ```

   1. Geben Sie für **Gewünschte Aufgaben** Folgendes ein:

      ```
      3
      ```

      In diesem Tutorial startet jede Aufgabe einen einzelnen Docker-Container.

   1. Erweitern Sie den Bereich **Netzwerk**.

   1. Wählen Sie für **VPC** eine beliebige VPC aus.

   1. Wählen Sie für **Subnetze** ein beliebiges Subnetz aus.
**Anmerkung**  
Geben Sie nur ein Subnetz an. Das ist alles, was für dieses Tutorial benötigt wird.
**Anmerkung**  
Wenn Sie keine VPC und kein Subnetz haben, erstellen Sie sie. Weitere Informationen finden [Sie unter Erstellen einer VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) und [Erstellen eines Subnetzes in Ihrer VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet) im *Amazon VPC-Benutzerhandbuch*.

   1. Wählen Sie für **Sicherheitsgruppe** die Option **Create a new security group** aus und gehen Sie dann wie folgt vor:

      1. Geben Sie als **Namen der Sicherheitsgruppe** Folgendes ein:

         ```
         codecatalyst-ecs-security-group
         ```

      1. Geben Sie als **Beschreibung der Sicherheitsgruppe** Folgendes ein:

         ```
         CodeCatalyst ECS security group
         ```

      1. Wählen Sie **Regel hinzufügen** aus. Wählen Sie für **Typ** die Option **HTTP** und für **Quelle** die Option **Anywhere** aus.

   1. Wählen Sie unten **Create** aus.

   1. Warten Sie, bis der Dienst erstellt wurde. Dies kann einige Minuten dauern.

1. Wählen Sie die Registerkarte **Aufgaben** und dann die Schaltfläche „Aktualisieren“. Vergewissern Sie sich, dass die Spalte **Letzter Status** für alle drei Aufgaben auf Wird **ausgeführt** gesetzt ist.

**(Optional) Um zu überprüfen, ob Ihre Apache-Platzhalteranwendung ausgeführt wird**

1. Wählen Sie auf der Registerkarte **Aufgaben** eine der drei Aufgaben aus.

1. Wählen Sie im Feld **Öffentliche IP** die Option **Open Address** aus.

   Eine `It Works!` Seite wird angezeigt. Dies weist darauf hin, dass der Amazon ECS-Service erfolgreich eine Aufgabe gestartet hat, die einen Docker-Container mit dem Apache-Image gestartet hat.

   An dieser Stelle des Tutorials haben Sie manuell einen Amazon ECS-Cluster, eine Service- und Aufgabendefinition sowie eine Apache-Platzhalteranwendung bereitgestellt. Nachdem Sie all diese Elemente eingerichtet haben, sind Sie nun bereit, einen Workflow zu erstellen, der die Apache-Platzhalteranwendung durch die Hello World-Anwendung des Tutorials ersetzt.

## Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository
<a name="deploy-tut-ecs-ecr"></a>

In diesem Abschnitt erstellen Sie ein privates Image-Repository in Amazon Elastic Container Registry (Amazon ECR). In diesem Repository wird das Docker-Image des Tutorials gespeichert, das das zuvor bereitgestellte Apache-Platzhalter-Image ersetzt. 

Weitere Informationen zu Amazon ECR finden Sie im *Amazon Elastic Container Registry User Guide*.

**Um ein Bild-Repository in Amazon ECR zu erstellen**

1. Wie in `CodeCatalystECSUser` AWS CloudShell, ein leeres Repository in Amazon ECR erstellen:

   ```
   aws ecr create-repository --repository-name codecatalyst-ecs-image-repo
   ```

1. Zeigen Sie die Details des Amazon ECR-Repositorys an:

   ```
   aws ecr describe-repositories \
         --repository-names codecatalyst-ecs-image-repo
   ```

1. Notieren Sie sich den `“repositoryUri”:` Wert, zum Beispiel. `111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo`

   Sie benötigen ihn später, wenn Sie das Repository zu Ihrem Workflow hinzufügen. 

## Schritt 4: AWS Rollen erstellen
<a name="deploy-tut-ecs-build-deploy-roles"></a>

In diesem Abschnitt erstellen Sie AWS IAM-Rollen, die Ihr CodeCatalyst Workflow benötigt, um zu funktionieren. Diese Rollen sind:
+ **Build-Rolle** — Erteilt der CodeCatalyst Build-Aktion (im Workflow) die Berechtigung, auf Ihr AWS Konto zuzugreifen und in Amazon ECR und Amazon EC2 zu schreiben.
+ **Rolle bereitstellen** — Erteilt der Aktion CodeCatalyst **Deploy to ECS** (im Workflow) die Berechtigung, auf Ihr AWS Konto, Amazon ECS und einige andere AWS Services zuzugreifen.

Weitere Informationen zu IAM-Rollen finden Sie unter [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) im *AWS Identity and Access Management Benutzerhandbuch*.

**Anmerkung**  
Um Zeit zu sparen, können Sie anstelle der beiden zuvor aufgeführten Rollen eine einzelne `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle, die so genannte Rolle, erstellen. Weitere Informationen finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über sehr umfangreiche Berechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. In diesem Tutorial wird davon ausgegangen, dass Sie die beiden zuvor aufgeführten Rollen erstellen.

Um die Build- und Deploy-Rollen zu erstellen, können Sie entweder die AWS-Managementkonsole oder die verwenden AWS CLI.

------
#### [ AWS-Managementkonsole ]

Gehen Sie wie folgt vor, um die Build- und Deploy-Rollen zu erstellen.

**Um eine Build-Rolle zu erstellen**

1. Erstellen Sie wie folgt eine Richtlinie für die Rolle:

   1. Melden Sie sich an bei AWS.

   1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

   1. Wählen Sie im Navigationsbereich **Richtlinien**.

   1. Wählen Sie **Richtlinie erstellen** aus.

   1. Wählen Sie den Tab **JSON**.

   1. Löschen Sie den vorhandenen Code.

   1. Fügen Sie folgenden Code ein:

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "ecr:*",
                      "ec2:*"
                  ],
                  "Resource": "*"
              }
          ]
      }
      ```

------
**Anmerkung**  
Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

      ```
      "Resource": "*"
      ```

   1. Wählen Sie **Next: Tags** (Weiter: Tags) aus.

   1. Klicken Sie auf **Weiter: Prüfen**.

   1. Geben Sie im Feld **Name** Folgendes ein:

      ```
      codecatalyst-ecs-build-policy
      ```

   1. Wählen Sie **Richtlinie erstellen** aus.

      Sie haben jetzt eine Berechtigungsrichtlinie erstellt.

1. Erstellen Sie die Build-Rolle wie folgt:

   1. Wählen Sie im Navigationsbereich **Rollen** und dann **Rolle erstellen**.

   1. Wählen Sie **Benutzerdefinierte Vertrauensrichtlinie**.

   1. Löschen Sie die bestehende benutzerdefinierte Vertrauensrichtlinie.

   1. Fügen Sie die folgende benutzerdefinierte Vertrauensrichtlinie hinzu:

   1. Wählen Sie **Weiter** aus.

   1. Suchen Sie **unter Berechtigungsrichtlinien** nach `codecatalyst-ecs-build-policy` und aktivieren Sie das entsprechende Kontrollkästchen.

   1. Wählen Sie **Weiter** aus.

   1. Geben Sie **als Rollenname** Folgendes ein:

      ```
      codecatalyst-ecs-build-role
      ```

   1. Geben Sie **als Rollenbeschreibung** Folgendes ein:

      ```
      CodeCatalyst ECS build role
      ```

   1. Wählen Sie **Rolle erstellen** aus.

   Sie haben jetzt eine Build-Rolle mit einer Berechtigungsrichtlinie und einer Vertrauensrichtlinie erstellt.

1. Rufen Sie den ARN für die Build-Rolle wie folgt ab:

   1. Wählen Sie im Navigationsbereich **Rollen**.

   1. Geben Sie im Suchfeld den Namen der Rolle ein, die Sie gerade erstellt haben (`codecatalyst-ecs-build-role`).

   1. Wählen Sie die Rolle aus der Liste aus.

      Die **Übersichtsseite** der Rolle wird angezeigt.

   1. Kopieren Sie oben den **ARN-Wert**. Sie benötigen sie später.

**Um eine Bereitstellungsrolle zu erstellen**

1. Erstellen Sie wie folgt eine Richtlinie für die Rolle:

   1. Melden Sie sich an bei AWS.

   1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

   1. Wählen Sie im Navigationsbereich **Richtlinien**.

   1. Wählen Sie **Richtlinie erstellen** aus.

   1. Wählen Sie den Tab **JSON**.

   1. Löschen Sie den vorhandenen Code.

   1. Fügen Sie folgenden Code ein:

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**Anmerkung**  
Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung. Sie können die Richtlinie dann anhand des Ressourcennamens einschränken, sobald sie verfügbar ist.  

      ```
      "Resource": "*"
      ```

   1. Wählen Sie **Next: Tags** (Weiter: Tags) aus.

   1. Klicken Sie auf **Weiter: Prüfen**.

   1. Geben Sie im Feld **Name** Folgendes ein:

      ```
      codecatalyst-ecs-deploy-policy
      ```

   1. Wählen Sie **Richtlinie erstellen** aus.

      Sie haben jetzt eine Berechtigungsrichtlinie erstellt.

1. Erstellen Sie die Bereitstellungsrolle wie folgt:

   1. Wählen Sie im Navigationsbereich **Rollen** und dann **Rolle erstellen**.

   1. Wählen Sie **Benutzerdefinierte Vertrauensrichtlinie**.

   1. Löschen Sie die bestehende benutzerdefinierte Vertrauensrichtlinie.

   1. Fügen Sie die folgende benutzerdefinierte Vertrauensrichtlinie hinzu:

   1. Wählen Sie **Weiter** aus.

   1. Suchen Sie **unter Berechtigungsrichtlinien** nach `codecatalyst-ecs-deploy-policy` und aktivieren Sie das entsprechende Kontrollkästchen.

   1. Wählen Sie **Weiter** aus.

   1. Geben Sie **als Rollenname** Folgendes ein:

      ```
      codecatalyst-ecs-deploy-role
      ```

   1. Geben Sie **als Rollenbeschreibung** Folgendes ein:

      ```
      CodeCatalyst ECS deploy role
      ```

   1. Wählen Sie **Rolle erstellen** aus.

   Sie haben jetzt eine Bereitstellungsrolle mit einer Vertrauensrichtlinie erstellt.

1. Rufen Sie den ARN für die Bereitstellungsrolle wie folgt ab:

   1. Wählen Sie im Navigationsbereich **Rollen**.

   1. Geben Sie im Suchfeld den Namen der Rolle ein, die Sie gerade erstellt haben (`codecatalyst-ecs-deploy-role`).

   1. Wählen Sie die Rolle aus der Liste aus.

      Die **Übersichtsseite** der Rolle wird angezeigt.

   1. Kopieren Sie oben den **ARN-Wert**. Sie benötigen sie später.

------
#### [ AWS CLI ]

Führen Sie die folgenden Verfahren aus, um die Build- und Deploy-Rollen zu erstellen.

**Um eine Vertrauensrichtlinie für beide Rollen zu erstellen**

Wie in `CodeCatalystECSUser` AWS CloudShell, erstellen Sie eine Vertrauensrichtliniendatei:

1. Erstellen Sie die Datei:

   ```
   cat > codecatalyst-ecs-trust-policy.json
   ```

1. Fügen Sie an der Terminal-Eingabeaufforderung den folgenden Code ein:

1. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer (`}`).

1. Drücken Sie dann **Enter** und**Ctrl\$1d**, um die Datei zu speichern und cat zu beenden.

**Um die Build-Richtlinie und die Build-Rolle zu erstellen**

1. Erstellen Sie die Build-Richtlinie:

   1. Wie in `CodeCatalystECSUser` AWS CloudShell, erstellen Sie eine Build-Richtliniendatei:

      ```
      cat > codecatalyst-ecs-build-policy.json
      ```

   1. Geben Sie an der Eingabeaufforderung den folgenden Code ein:

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "ecr:*",
                      "ec2:*"
                  ],
                  "Resource": "*"
              }
          ]
      }
      ```

------

   1. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer (`}`).

   1. Drücken Sie dann **Enter** und**Ctrl\$1d**, um die Datei zu speichern und cat zu beenden.

1. Fügen Sie die Build-Richtlinie hinzu zu AWS:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-ecs-build-policy \
       --policy-document file://codecatalyst-ecs-build-policy.json
   ```

1. Notieren Sie sich in der Befehlsausgabe den `"arn":` Wert, zum Beispiel`arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy`. Sie benötigen diesen ARN später.

1. Erstellen Sie die Build-Rolle und fügen Sie ihr die Vertrauensrichtlinie hinzu:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-build-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Hängen Sie die Build-Richtlinie an die Build-Rolle an:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-build-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy
   ```

   Wo *arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy* wird durch den ARN der Build-Richtlinie ersetzt, die Sie zuvor notiert haben.

1. Zeigen Sie die Details der Build-Rolle an:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-build-role
   ```

1. Notieren Sie sich den `"Arn":` Wert der Rolle, zum Beispiel`arn:aws:iam::111122223333:role/codecatalyst-ecs-build-role`. Sie benötigen diesen ARN später.

**Um die Bereitstellungsrichtlinie und die Bereitstellungsrolle zu erstellen**

1. Erstellen Sie eine Bereitstellungsrichtlinie:

   1. Erstellen Sie AWS CloudShell unter eine Bereitstellungsrichtliniendatei:

      ```
      cat > codecatalyst-ecs-deploy-policy.json
      ```

   1. Geben Sie an der Eingabeaufforderung den folgenden Code ein:

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**Anmerkung**  
Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

      ```
      "Resource": "*"
      ```

   1. Platzieren Sie den Cursor hinter der letzten geschweiften Klammer ()`}`.

   1. Drücken Sie dann **Enter** und**Ctrl\$1d**, um die Datei zu speichern und cat zu beenden.

1. Fügen Sie die Bereitstellungsrichtlinie hinzu zu AWS:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-ecs-deploy-policy \
       --policy-document file://codecatalyst-ecs-deploy-policy.json
   ```

1. Notieren Sie sich in der Befehlsausgabe den `"arn":` Wert der Bereitstellungsrichtlinie, `arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy` z. B. Sie benötigen diesen ARN später.

1. Erstellen Sie die Bereitstellungsrolle und fügen Sie ihr die Vertrauensrichtlinie hinzu:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-deploy-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Hängen Sie die Bereitstellungsrichtlinie an die Bereitstellungsrolle an, wo sie durch den ARN der Bereitstellungsrichtlinie ersetzt *arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy* wird, die Sie zuvor notiert haben.

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-deploy-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy
   ```

1. Zeigen Sie die Details der Bereitstellungsrolle an:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-deploy-role
   ```

1. Notieren Sie sich den `"Arn":` Wert der Rolle, zum Beispiel`arn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role`. Sie benötigen diesen ARN später.

------

## Schritt 5: AWS Rollen hinzufügen CodeCatalyst
<a name="deploy-tut-ecs-import-roles"></a>

In diesem Schritt fügen Sie der CodeCatalyst Kontoverbindung in Ihrem Bereich die Build-Rolle (`codecatalyst-ecs-build-role``codecatalyst-ecs-deploy-role`) und die Bereitstellungsrolle () hinzu.

**Um deiner Kontoverbindung Rollen zum Erstellen und Bereitstellen hinzuzufügen**

1. Navigieren CodeCatalyst Sie darin zu Ihrem Bereich.

1. Wählen Sie **AWS accounts (-Konten)**. Eine Liste der Kontoverbindungen wird angezeigt.

1. Wählen Sie die Kontoverbindung aus, die dem AWS Konto entspricht, in dem Sie Ihre Build- und Deploy-Rollen erstellt haben.

1. Wählen Sie in der ** AWS Managementkonsole die Option Rollen verwalten aus**.

   Die Seite „**IAM-Rolle zu Amazon CodeCatalyst Space hinzufügen**“ wird angezeigt. Möglicherweise müssen Sie sich anmelden, um auf die Seite zuzugreifen.

1. Wählen Sie **Eine bestehende Rolle hinzufügen, die Sie in IAM erstellt haben**.

   Eine Dropdownliste wird angezeigt. In der Liste werden alle IAM-Rollen mit einer Vertrauensrichtlinie angezeigt, die die Dienstprinzipale `codecatalyst-runner.amazonaws.com` und die `codecatalyst.amazonaws.com` Dienstprinzipale umfasst.

1. Wählen Sie `codecatalyst-ecs-build-role` in der Dropdownliste die Option Rolle **hinzufügen** aus.
**Anmerkung**  
Wenn Sie das sehen`The security token included in the request is invalid`, liegt es möglicherweise daran, dass Sie nicht über die richtigen Berechtigungen verfügen. Um dieses Problem zu beheben, melden Sie sich ab und melden Sie sich mit dem AWS Konto wieder an, das Sie bei der Erstellung Ihres CodeCatalyst Bereichs verwendet haben. AWS 

1. Wählen Sie „**IAM-Rolle hinzufügen**“, wählen Sie „**Eine bestehende Rolle hinzufügen, die Sie in IAM erstellt haben**“ und wählen Sie in der Drop-down-Liste die Option aus. `codecatalyst-ecs-deploy-role` Wählen Sie **Rolle hinzufügen** aus.

   Sie haben jetzt die Build- und Deploy-Rollen zu Ihrem Bereich hinzugefügt.

1. Kopieren Sie den Wert des ** CodeCatalyst Amazon-Anzeigenamens**. Sie benötigen diesen Wert später, wenn Sie Ihren Workflow erstellen.

## Schritt 6: Erstellen Sie ein Quell-Repository
<a name="deploy-tut-ecs-source-repo"></a>

In diesem Schritt erstellen Sie ein Quell-Repository in CodeCatalyst. In diesem Repository werden die Quelldateien des Tutorials gespeichert, z. B. die Aufgabendefinitionsdatei.

Weitere Informationen zu Quell-Repositorys finden Sie unter[Erstellen eines Quell-Repositorys](source-repositories-create.md).

**Um ein Quell-Repository zu erstellen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Navigieren Sie zu Ihrem Projekt,`codecatalyst-ecs-project`.

1. Wählen Sie im Navigationsbereich **Code** und dann **Quell-Repositories** aus. 

1. Wählen **Sie Repository hinzufügen** und anschließend **Repository erstellen** aus.

1. Geben Sie im Feld **Repository-Name** Folgendes ein:

   ```
   codecatalyst-ecs-source-repository
   ```

1. Wählen Sie **Erstellen** aus.

## Schritt 7: Quelldateien hinzufügen
<a name="deploy-tut-ecs-source-files"></a>

In diesem Abschnitt fügen Sie die Hello World-Quelldateien zu Ihrem CodeCatalyst Repository hinzu. `codecatalyst-ecs-source-repository` Sie bestehen aus:
+ Eine `index.html` Datei — Zeigt eine Hello World-Nachricht im Browser an. 
+ Ein Dockerfile — Beschreibt das Basis-Image, das für Ihr Docker-Image verwendet werden soll, und die Docker-Befehle, die darauf angewendet werden sollen. 
+ Eine `taskdef.json` Datei — Definiert das Docker-Image, das beim Starten von Aufgaben in Ihrem Cluster verwendet werden soll.

Die Ordnerstruktur sieht wie folgt aus:

```
.
|— public-html
|  |— index.html
|— Dockerfile
|— taskdef.json
```

**Anmerkung**  
Die folgenden Anweisungen zeigen Ihnen, wie Sie die Dateien mithilfe der CodeCatalyst Konsole hinzufügen. Sie können jedoch auch Git verwenden, wenn Sie dies bevorzugen. Details hierzu finden Sie unter [Klonen eines Quell-Repositorys](source-repositories-clone.md). 

**Topics**
+ [index.html](#deploy-tut-ecs-source-files-index)
+ [Dockerfile](#deploy-tut-ecs-source-files-dockerfile)
+ [taskdef.json](#deploy-tut-ecs-source-files-taskdef)

### index.html
<a name="deploy-tut-ecs-source-files-index"></a>

Die `index.html` Datei zeigt im Browser eine Hello World-Nachricht an. 

**Um die Datei index.html hinzuzufügen**

1. Gehen Sie in der CodeCatalyst Konsole zu Ihrem Quell-Repository,`codecatalyst-ecs-source-repository`.

1. Wählen Sie **unter Dateien** die Option **Datei erstellen** aus.

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   public-html/index.html
   ```
**Wichtig**  
Stellen Sie sicher, dass Sie das `public-html/` Präfix angeben, um einen Ordner mit demselben Namen zu erstellen. Das `index.html` wird sich voraussichtlich in diesem Ordner befinden.

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   <html>
     <head>
       <title>Hello World</title>
       <style>
         body {
         background-color: black;
         text-align: center;
         color: white;
         font-family: Arial, Helvetica, sans-serif;
         }  
       </style>
     </head>
     <body>
       <h1>Hello World</h1>
     </body>
   </html>
   ```

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Das `index.html` wird Ihrem Repository in einem `public-html` Ordner hinzugefügt. 

### Dockerfile
<a name="deploy-tut-ecs-source-files-dockerfile"></a>

Das Dockerfile beschreibt das zu verwendende Basis-Decker-Image und die darauf anzuwendenden Docker-Befehle. [Weitere Informationen zum Dockerfile finden Sie in der Dockerfile-Referenz.](https://docs.docker.com/engine/reference/builder/)

Das hier angegebene Dockerfile gibt an, das Apache 2.4-Basisimage () zu verwenden. `httpd` Es enthält auch Anweisungen zum Kopieren einer `index.html` aufgerufenen Quelldatei in einen Ordner auf dem Apache-Server, der Webseiten bereitstellt. Die `EXPOSE` Anweisung in der Dockerfile teilt Docker mit, dass der Container auf Port 80 lauscht.

**Um das Dockerfile hinzuzufügen**

1. Wählen Sie in Ihrem Quell-Repository die Option Datei **erstellen** aus.

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   Dockerfile
   ```

   Geben Sie keine Dateierweiterung an.
**Wichtig**  
Das Dockerfile muss sich im Stammordner Ihres Repositorys befinden. Der `Docker build` Befehl des Workflows erwartet, dass es dort vorhanden ist.

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80
   ```

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Das Dockerfile wird Ihrem Repository hinzugefügt. 

### taskdef.json
<a name="deploy-tut-ecs-source-files-taskdef"></a>

Die `taskdef.json` Datei, die Sie in diesem Schritt hinzufügen, ist dieselbe wie die, in der Sie bereits angegeben haben, [Schritt 2: Stellen Sie eine Platzhalteranwendung in Amazon ECS bereit](#deploy-tut-ecs-placeholder) mit dem folgenden Unterschied:

Anstatt einen fest codierten Docker-Imagenamen im `image:` Feld (`httpd:2.4`) anzugeben, verwendet die Aufgabendefinition hier einige Variablen, um das Bild zu bezeichnen: und. `$REPOSITORY_URI` `$IMAGE_TAG` Diese Variablen werden durch echte Werte ersetzt, die durch die Build-Aktion des Workflows generiert wurden, wenn Sie den Workflow in einem späteren Schritt ausführen.

Einzelheiten zu den Aufgabendefinitionsparametern finden Sie unter [Aufgabendefinitionsparameter](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) im *Amazon Elastic Container Service Developer Guide*.

**Um die Datei taskdef.json hinzuzufügen**

1. **Wählen Sie in Ihrem Quell-Repository die Option Datei erstellen aus.**

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   taskdef.json
   ```

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced 
               # by the workflow at build time (see the build action in the 
               # workflow)
               "image": $REPOSITORY_URI:$IMAGE_TAG,
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "codecatalyst-ecs-task-def"
   }
   ```

   Ersetzen Sie im vorherigen Code

   *arn:aws:iam::account\$1ID:role/codecatalyst-ecs-task-execution-role*

   mit dem ARN der Aufgabenausführungsrolle, die Sie notiert haben[Um die Rolle zur Aufgabenausführung zu erstellen](#deploy-tut-ecs-create-task-execution-role).

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Die `taskdef.json` Datei wird Ihrem Repository hinzugefügt. 

## Schritt 8: Erstellen Sie einen Workflow und führen Sie ihn aus
<a name="deploy-tut-ecs-workflow"></a>

In diesem Schritt erstellen Sie einen Workflow, der Ihre Quelldateien zu einem Docker-Image zusammenbaut und das Image dann in Ihrem Amazon ECS-Cluster bereitstellt. Diese Bereitstellung ersetzt die bestehende Apache-Platzhalteranwendung.

Der Workflow besteht aus den folgenden Bausteinen, die nacheinander ausgeführt werden:
+ Ein Trigger — Dieser Trigger startet die Workflow-Ausführung automatisch, wenn Sie eine Änderung an Ihr Quell-Repository übertragen. Weitere Informationen zu Auslösern finden Sie unter [Automatisches Starten einer Workflow-Ausführung mithilfe von Triggern](workflows-add-trigger.md).
+ Eine Build-Aktion (`BuildBackend`) — Beim Auslösen erstellt die Aktion das Docker-Image mithilfe der Dockerfile und überträgt das Image an Amazon ECR. Die Build-Aktion aktualisiert auch das `taskdef.json` mit dem richtigen `image` Feldwert und erstellt dann ein Ausgabeartefakt dieser Datei. Dieses Artefakt wird als Eingabe für die Bereitstellungsaktion verwendet, die als Nächstes folgt.

  Weitere Informationen zur Build-Aktion finden Sie unter[Bauen mit Workflows](build-workflow-actions.md).
+ Eine Bereitstellungsaktion (`DeployToECS`) — Nach Abschluss der Build-Aktion sucht die Bereitstellungsaktion nach dem von der Build-Aktion (`TaskDefArtifact`) generierten Ausgabeartefakt, findet dessen Inhalt und registriert es bei Ihrem Amazon ECS-Service. `taskdef.json` Der Service folgt dann den Anweisungen in der `taskdef.json` Datei, um drei Amazon ECS-Aufgaben — und zugehörige Hello World Docker-Container — in Ihrem Amazon ECS-Cluster auszuführen. 

**So erstellen Sie ein Workflow**

1. **Wählen Sie in der CodeCatalyst Konsole im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie Workflow **erstellen** aus.

1. Wählen Sie für **Quell-Repository** die Option`codecatalyst-ecs-source-repository`.

1. Wählen Sie für **Branch** die Option`main`.

1. Wählen Sie **Erstellen** aus.

1. Löschen Sie den YAML-Beispielcode.

1. Fügen Sie den folgenden YAML-Code hinzu:
**Anmerkung**  
Im folgenden YAML-Code können Sie die `Connections:` Abschnitte weglassen, wenn Sie möchten. Wenn Sie diese Abschnitte weglassen, müssen Sie sicherstellen, dass die im Feld **Standard-IAM-Rolle angegebene Rolle** in Ihrer Umgebung die Berechtigungen und Vertrauensrichtlinien beider Rollen enthält, die unter beschrieben sind. [Schritt 5: AWS Rollen hinzufügen CodeCatalyst](#deploy-tut-ecs-import-roles) Weitere Informationen zum Einrichten einer Umgebung mit einer Standard-IAM-Rolle finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)

   ```
   Name: codecatalyst-ecs-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo
           - Name: IMAGE_TAG
             Value: ${WorkflowSource.CommitId}
       Configuration:
         Steps:
           #pre_build:
           - Run: echo Logging in to Amazon ECR...
           - Run: aws --version
           - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
           #build:
           - Run: echo Build started on `date`
           - Run: echo Building the Docker image...
           - Run: docker build -t $REPOSITORY_URI:latest .
           - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
           #post_build:
           - Run: echo Build completed on `date`
           - Run: echo Pushing the Docker images...
           - Run: docker push $REPOSITORY_URI:latest
           - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
           # Replace the variables in taskdef.json
           - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat taskdef.json
           # The output artifact will be a zip file that contains a task definition file.
       Outputs:
         Artifacts:
           - Name: TaskDefArtifact
             Files: 
               - taskdef.json
     DeployToECS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/ecs-deploy@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-deploy-role
       Inputs:
         Sources: []
         Artifacts:
           - TaskDefArtifact
       Configuration:
         region: us-west-2
         cluster: codecatalyst-ecs-cluster
         service: codecatalyst-ecs-service
         task-definition: taskdef.json
   ```

   Ersetzen Sie im vorherigen Code:
   + Beide Instanzen von *codecatalyst-ecs-environment* mit dem Namen der Umgebung, in der Sie erstellt haben[Voraussetzungen](#deploy-tut-ecs-prereqs).
   + Beide Instanzen von *codecatalyst-account-connection* mit dem Anzeigenamen Ihrer Kontoverbindung. Der Anzeigename kann eine Zahl sein. Weitere Informationen finden Sie unter [Schritt 5: AWS Rollen hinzufügen CodeCatalyst](#deploy-tut-ecs-import-roles).
   + *codecatalyst-ecs-build-role*mit dem Namen der Build-Rolle, in der Sie sie erstellt haben[Schritt 4: AWS Rollen erstellen](#deploy-tut-ecs-build-deploy-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo*(in der `Value:` Eigenschaft) mit der URI des Amazon ECR-Repositorys, in [Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository](#deploy-tut-ecs-ecr) dem Sie es erstellt haben.
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(im `Run: aws ecr` Befehl) mit der URI des Amazon ECR-Repositorys ohne das Bildsuffix ()`/codecatalyst-ecs-image-repo`.
   + *codecatalyst-ecs-deploy-role*mit dem Namen der Bereitstellungsrolle, in der Sie sie erstellt haben. [Schritt 4: AWS Rollen erstellen](#deploy-tut-ecs-build-deploy-roles)
   + Beide Instanzen von *us-west-2* mit Ihrem AWS Regionalcode. Eine Liste der Regionalcodes finden Sie unter [Regionale Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) in der *Allgemeine AWS-Referenz*.
**Anmerkung**  
Wenn Sie sich entschieden haben, keine Build- und Deploy-Rollen zu erstellen, ersetzen Sie *codecatalyst-ecs-build-role* und *codecatalyst-ecs-deploy-role* durch den Namen der `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle. Weitere Informationen über diese Rolle finden Sie unter [Schritt 4: AWS Rollen erstellen](#deploy-tut-ecs-build-deploy-roles).
**Tipp**  
Anstatt die `sed` Befehle `find` und und zu verwenden, die im vorherigen Workflow-Code gezeigt wurden, um das Repository und den Namen des Images zu aktualisieren, können Sie zu diesem Zweck die **Amazon ECS-Aufgabendefinitionsaktion rendern** verwenden. Weitere Informationen finden Sie unter [Ändern einer Amazon ECS-Aufgabendefinition](render-ecs-action.md).

1. (Optional) Wählen Sie „**Validieren**“, um sicherzustellen, dass der YAML-Code gültig ist, bevor Sie ihn festschreiben.

1. Wählen Sie **Commit** (Übergeben).

1. Geben Sie im Dialogfeld „**Workflow bestätigen**“ Folgendes ein:

   1. Entfernen Sie **bei Nachricht bestätigen** den Text und geben Sie Folgendes ein:

      ```
      Add first workflow
      ```

   1. Wählen Sie für **Repository**`codecatalyst-ecs-source-repository`.

   1. Wählen Sie als **Branch-Name** die Option main aus.

   1. Wählen Sie **Commit** (Übergeben).

   Sie haben jetzt einen Workflow erstellt. Eine Workflow-Ausführung wird aufgrund des oben im Workflow definierten Triggers automatisch gestartet. Insbesondere, als Sie die `workflow.yaml` Datei in Ihr Quell-Repository übernommen (und per Push übertragen) haben, hat der Trigger die Workflow-Ausführung gestartet.

**Um den Fortschritt der Workflow-Ausführung zu sehen**

1. **Wählen Sie im Navigationsbereich der CodeCatalyst Konsole **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Workflow aus, den Sie gerade erstellt haben,. `codecatalyst-ecs-workflow`

1. Wählen Sie **BuildBackend**, ob Sie den Baufortschritt sehen möchten.

1. Wählen Sie **DeployToECS**, um den Fortschritt der Bereitstellung zu sehen.

   Weitere Informationen zum Anzeigen von Ausführungsdetails finden Sie unter[Status und Details der Workflow-Ausführung anzeigen](workflows-view-run.md).

**Um die Bereitstellung zu überprüfen**

1. Öffnen Sie die Amazon ECS Classic-Konsole unter [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1. Wählen Sie Ihren Cluster,`codecatalyst-ecs-cluster`.

1. Wählen Sie die Registerkarte **Tasks** aus. 

1. Wählen Sie eine der drei Aufgaben.

1. Wählen Sie im Feld **Öffentliche IP** die Option **Open Address** aus.

   Im Browser wird eine Seite „Hello World“ angezeigt, die darauf hinweist, dass der Amazon ECS-Service Ihre Anwendung erfolgreich bereitgestellt hat.

## Schritt 9: Nehmen Sie eine Änderung an Ihren Quelldateien vor
<a name="deploy-tut-ecs-change"></a>

In diesem Abschnitt nehmen Sie eine Änderung an der `index.html` Datei in Ihrem Quell-Repository vor. Diese Änderung veranlasst den Workflow, ein neues Docker-Image zu erstellen, es mit einer Commit-ID zu kennzeichnen, es an Amazon ECR weiterzuleiten und es in Amazon ECS bereitzustellen. 

**Um die Datei index.html zu ändern**

1. Wählen Sie in der CodeCatalyst Konsole im Navigationsbereich **Code**, dann **Quell-Repositories** und anschließend Ihr Repository aus. `codecatalyst-ecs-source-repository`

1. Klicken Sie auf `public-html` und danach auf `index.html`.

   Der Inhalt von `index.html` wird angezeigt.

1. Wählen Sie **Bearbeiten** aus. 

1. Ändern Sie in Zeile 14 den `Hello World` Text in`Tutorial complete!`.

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Durch den Commit wird ein neuer Workflow-Lauf gestartet. 

1. (Optional) Gehen Sie zur Hauptseite Ihres Quell-Repositorys, wählen Sie **Commits anzeigen** und notieren Sie sich die Commit-ID für die `index.html` Änderung.

1. Beobachten Sie den Fortschritt der Bereitstellung:

   1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

   1. Wählen Sie`codecatalyst-ecs-workflow`, ob Sie die letzte Ausführung anzeigen möchten.

   1. Wählen Sie und **DeployToECS **BuildBackend****, um den Fortschritt der Workflow-Ausführung zu sehen.

1. Stellen Sie wie folgt sicher, dass Ihre Anwendung aktualisiert wurde:

   1. Öffnen Sie die Amazon ECS Classic-Konsole unter [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

   1. Wählen Sie Ihren Cluster,`codecatalyst-ecs-cluster`.

   1. Wählen Sie die Registerkarte **Tasks** aus. 

   1. Wählen Sie eine der drei Aufgaben.

   1. Wählen Sie im Feld **Öffentliche IP** die Option **Open Address** aus.

      Eine `Tutorial complete!` Seite wird angezeigt.

1. (Optional) Wechseln Sie in AWS zur Amazon ECR-Konsole und überprüfen Sie, ob das neue Docker-Image mit der Commit-ID aus Schritt 6 gekennzeichnet wurde.

## Bereinigen
<a name="deploy-tut-ecs-cleanup"></a>

Bereinigen Sie die in diesem Tutorial verwendeten Dateien und Dienste, um zu vermeiden, dass dafür Gebühren anfallen.

Im AWS-Managementkonsole, bereinigen Sie in dieser Reihenfolge:

1. Gehen Sie in Amazon ECS wie folgt vor:

   1. Löschen`codecatalyst-ecs-service`.

   1. Löschen`codecatalyst-ecs-cluster`.

   1. Abmelden`codecatalyst-ecs-task-definition`.

1. Löschen `codecatalyst-ecs-image-repo` Sie in Amazon ECR.

1. Löschen `codecatalyst-ecs-security-group` Sie in Amazon EC2.

1. Löschen Sie im IAM Identity Center:

   1. `CodeCatalystECSUser`

   1. `CodeCatalystECSPermissionSet`

Bereinigen Sie in der CodeCatalyst Konsole wie folgt:

1. Löschen`codecatalyst-ecs-workflow`.

1. Löschen`codecatalyst-ecs-environment`.

1. Löschen`codecatalyst-ecs-source-repository`.

1. Löschen`codecatalyst-ecs-project`.

In diesem Tutorial haben Sie gelernt, wie Sie mithilfe eines CodeCatalyst Workflows und einer Aktion „In Amazon ECS bereitstellen“ eine Anwendung für einen **Amazon ECS-Service bereitstellen**.

# Aktion „In Amazon ECS bereitstellen“ hinzufügen
<a name="deploy-action-ecs-adding"></a>

Verwenden Sie die folgenden Anweisungen, um die Aktion **Deploy to Amazon ECS** zu Ihrem Workflow hinzuzufügen. 

------
#### [ Visual ]

**Um die Aktion „In Amazon ECS bereitstellen“ mit dem visuellen Editor hinzuzufügen**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie oben links **\$1 Aktionen**, um den Aktionskatalog zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der Aktion **Deploy to Amazon ECS** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie **Deploy to Amazon ECS**. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Herunterladen**“, um [den Quellcode der Aktion anzuzeigen](workflows-view-source.md#workflows-view-source.title).
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Füllen Sie auf den Registerkarten **Eingaben** und **Konfiguration** die Felder nach Ihren Bedürfnissen aus. Eine Beschreibung der einzelnen Felder finden Sie unter[Aktion „In Amazon ECS bereitstellen“ YAML](deploy-action-ref-ecs.md). Diese Referenz enthält detaillierte Informationen zu jedem Feld (und dem entsprechenden YAML-Eigenschaftswert), wie es sowohl im YAML- als auch im visuellen Editor angezeigt wird.

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit** aus.

------
#### [ YAML ]

**Um die Aktion „In Amazon ECS bereitstellen“ mit dem YAML-Editor hinzuzufügen**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Wählen Sie links oben **\$1 Aktionen aus, um den Aktionskatalog** zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der Aktion **Deploy to Amazon ECS** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie **Deploy to Amazon ECS**. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Herunterladen**“, um [den Quellcode der Aktion anzuzeigen](workflows-view-source.md#workflows-view-source.title).
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Ändern Sie die Eigenschaften im YAML-Code nach Ihren Bedürfnissen. Eine Erläuterung der einzelnen verfügbaren Eigenschaften finden Sie in der[Aktion „In Amazon ECS bereitstellen“ YAML](deploy-action-ref-ecs.md).

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit** aus.

------

# Variablen „In Amazon ECS bereitstellen“
<a name="deploy-action-ecs-variables"></a>

Die Aktion **Deploy to Amazon ECS** erzeugt und setzt zur Laufzeit die folgenden Variablen. Diese werden als *vordefinierte Variablen* bezeichnet.

Hinweise zum Verweisen auf diese Variablen in einem Workflow finden Sie unter[Verwenden vordefinierter Variablen](workflows-using-predefined-variables.md).


| Key (Schlüssel) | Value (Wert) | 
| --- | --- | 
|  Cluster  |  Der Name des Amazon ECS-Clusters, auf dem während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `codecatalyst-ecs-cluster`  | 
|  Bereitstellungsplattform  |  Der Name der Bereitstellungsplattform. Fest codiert auf. `AWS:ECS`  | 
|  Service nicht zulässig  |  Der Name des Amazon ECS-Service, für den während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `codecatalyst-ecs-service`  | 
|  task-definition-arn  |  Der Amazon-Ressourcenname (ARN) der Aufgabendefinition, die während der Workflow-Ausführung registriert wurde. Beispiel: `arn:aws:ecs:us-west-2:111122223333:task-definition/codecatalyst-task-def:8`Der Wert `:8` im vorherigen Beispiel gibt die Revision an, die registriert wurde.  | 
|  Bereitstellungs-URL  |  Ein Link zur Registerkarte **Ereignisse** der Amazon ECS-Konsole, auf der Sie Details zur Amazon ECS-Bereitstellung im Zusammenhang mit der Workflow-Ausführung einsehen können. Beispiel: `https://console.aws.amazon.com/ecs/home?region=us-west-2#/clusters/codecatalyst-ecs-cluster/services/codecatalyst-ecs-service/events`  | 
|  Region  |  Der Regionalcode von AWS-Region , für den während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `us-west-2`  | 

# Aktion „In Amazon ECS bereitstellen“ YAML
<a name="deploy-action-ref-ecs"></a>

Im Folgenden finden Sie die YAML-Definition der Aktion **Deploy to Amazon ECS**. Informationen zur Verwendung dieser Aktion finden Sie unter[Bereitstellung auf Amazon ECS mit einem Workflow](deploy-action-ecs.md).

Diese Aktionsdefinition ist als Abschnitt in einer umfassenderen Workflow-Definitionsdatei vorhanden. Weitere Informationen über diese Datei finden Sie unter [YAML-Workflow-Definition](workflow-reference.md).

**Anmerkung**  
Die meisten der folgenden YAML-Eigenschaften haben entsprechende Benutzeroberflächenelemente im visuellen Editor. Verwenden Sie **Strg\$1F**, um nach einem UI-Element zu suchen. Das Element wird mit der zugehörigen YAML-Eigenschaft aufgelistet.

```
# The workflow definition starts here.
# See Eigenschaften der obersten Ebene for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  ECSDeployAction\$1nn: 
    Identifier: aws/ecs-deploy@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - task-definition-artifact
    Configuration: 
      region: us-east-1 
      cluster: ecs-cluster
      service: ecs-service
      task-definition: task-definition-path
      force-new-deployment: false|true
      codedeploy-appspec: app-spec-file-path
      codedeploy-application: application-name
      codedeploy-deployment-group: deployment-group-name
      codedeploy-deployment-description: deployment-description
```

## ECSDeployAction
<a name="deploy.action.ecs.name"></a>

(Erforderlich)

Geben Sie den Namen der Aktion an. Alle Aktionsnamen müssen innerhalb des Workflows eindeutig sein. Aktionsnamen sind auf alphanumerische Zeichen (a-z, A-Z, 0-9), Bindestriche (-) und Unterstriche (\$1) beschränkt. Leerzeichen sind nicht erlaubt. Sie können keine Anführungszeichen verwenden, um Sonderzeichen und Leerzeichen in Aktionsnamen zuzulassen.

Standard: `ECSDeployAction_nn`.

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**Anzeigename der Aktion**

## Identifier
<a name="deploy.action.ecs.identifier"></a>

(*ECSDeployAction*/**Identifier**)

(Erforderlich)

Identifiziert die Aktion. Ändern Sie diese Eigenschaft nicht, es sei denn, Sie möchten die Version ändern. Weitere Informationen finden Sie unter [Angabe der zu verwendenden Aktionsversion](workflows-action-versions.md).

Standard: `aws/ecs-deploy@v1`.

**Entsprechende Benutzeroberfläche: ECSDeploy Workflow-Diagram/action\$1nn/ aws/ecs-deploy @v1 label**

## DependsOn
<a name="deploy.action.ecs.dependson"></a>

(*ECSDeployAction*/**DependsOn**)

(Optional)

Geben Sie eine Aktion, eine Aktionsgruppe oder ein Gate an, die erfolgreich ausgeführt werden müssen, damit diese Aktion ausgeführt werden kann.

Weitere Hinweise zur Funktion „Hängt davon ab“ finden Sie unter. [Aktionen sequenzieren](workflows-depends-on.md)

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Hängt davon ab**“ — optional

## Compute
<a name="deploy.action.ecs.computename"></a>

(*ECSDeployAction*/**Compute**)

(Optional)

Die Rechen-Engine, die zur Ausführung Ihrer Workflow-Aktionen verwendet wurde. Sie können die Berechnung entweder auf Workflow-Ebene oder auf Aktionsebene angeben, aber nicht beide. Wenn auf Workflow-Ebene angegeben, gilt die Rechenkonfiguration für alle im Workflow definierten Aktionen. Auf Workflow-Ebene können Sie auch mehrere Aktionen auf derselben Instanz ausführen. Weitere Informationen finden Sie unter [Rechenleistung für mehrere Aktionen gemeinsam nutzen](compute-sharing.md).

Entsprechende Benutzeroberfläche: *keine*

## Type
<a name="deploy.action.ecs.computetype"></a>

(*ECSDeployAction*/Compute/**Type**)

(Erforderlich, wenn [Compute](#deploy.action.ecs.computename) es enthalten ist)

Der Typ der Compute Engine. Sie können einen der folgenden Werte verwenden:
+ **EC2** (visueller Editor) oder `EC2` (YAML-Editor)

  Optimiert für Flexibilität bei Aktionsläufen.
+ **Lambda** (visueller Editor) oder `Lambda` (YAML-Editor)

  Optimierte Startgeschwindigkeiten für Aktionen.

Weitere Informationen zu Datentypen finden Sie unter [Berechnungstypen](workflows-working-compute.md#compute.types).

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Berechnungstyp**

## Fleet
<a name="deploy.action.ecs.computefleet"></a>

(*ECSDeployAction*/Compute/**Fleet**)

(Optional)

Geben Sie die Maschine oder Flotte an, auf der Ihr Workflow oder Ihre Workflow-Aktionen ausgeführt werden sollen. Bei bedarfsgesteuerten Flotten stellt der Workflow zu Beginn einer Aktion die benötigten Ressourcen bereit, und die Maschinen werden zerstört, wenn die Aktion abgeschlossen ist. Beispiele für Flotten auf Abruf:`Linux.x86-64.Large`,. `Linux.x86-64.XLarge` Weitere Informationen zu Flotten auf Abruf finden Sie unter. [Eigenschaften von On-Demand-Flotten](workflows-working-compute.md#compute.on-demand)

Bei bereitgestellten Flotten konfigurieren Sie eine Reihe von dedizierten Maschinen, um Ihre Workflow-Aktionen auszuführen. Diese Maschinen bleiben inaktiv und können sofort Aktionen ausführen. Weitere Informationen zu bereitgestellten Flotten finden Sie unter. [Eigenschaften von bereitgestellten Flotten](workflows-working-compute.md#compute.provisioned-fleets)

Wenn `Fleet` es weggelassen wird, ist die Standardeinstellung. `Linux.x86-64.Large`

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Compute Fleet**

## Timeout
<a name="deploy.action.ecs.timeout"></a>

(*ECSDeployAction*/**Timeout**)

(Optional)

Geben Sie an, wie lange die Aktion in Minuten (YAML-Editor) oder Stunden und Minuten (visueller Editor) ausgeführt werden kann, bevor die Aktion CodeCatalyst beendet wird. Das Minimum beträgt 5 Minuten und das Maximum ist unter beschrieben[Kontingente für Workflows in CodeCatalyst](workflows-quotas.md). Das Standard-Timeout entspricht dem maximalen Timeout.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Timeout“ — optional**

## Environment
<a name="deploy.action.ecs.environment"></a>

(*ECSDeployAction*/**Environment**)

(Erforderlich)

Geben Sie die CodeCatalyst Umgebung an, die für die Aktion verwendet werden soll. Die Aktion stellt eine Verbindung mit der AWS-Konto optionalen Amazon VPC her, die in der ausgewählten Umgebung angegeben ist. Die Aktion verwendet die in der Umgebung angegebene Standard-IAM-Rolle, um sich mit der Amazon VPC zu verbinden AWS-Konto, und verwendet die in der [Amazon VPC-Verbindung angegebene IAM-Rolle, um eine Verbindung zur Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) herzustellen.

**Anmerkung**  
Wenn die Standard-IAM-Rolle nicht über die für die Aktion erforderlichen Berechtigungen verfügt, können Sie die Aktion so konfigurieren, dass sie eine andere Rolle verwendet. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

Weitere Informationen zu Umgebungen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md) und[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Name
<a name="deploy.action.ecs.environment.name"></a>

(*ECSDeployAction*/Environment/**Name**)

(Erforderlich, wenn [Environment](#deploy.action.ecs.environment) es enthalten ist)

Geben Sie den Namen einer vorhandenen Umgebung an, die Sie der Aktion zuordnen möchten.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Connections
<a name="deploy.action.ecs.environment.connections"></a>

(*ECSDeployAction*/Environment/**Connections**)

(Optional in neueren Versionen der Aktion; in älteren Versionen erforderlich)

Geben Sie die Kontoverbindung an, die der Aktion zugeordnet werden soll. Sie können unter maximal eine Kontoverbindung angeben`Environment`.

Wenn Sie keine Kontoverbindung angeben:
+ Die Aktion verwendet die AWS-Konto Verbindung und die Standard-IAM-Rolle, die in der Umgebung in der CodeCatalyst Konsole angegeben sind. Informationen zum Hinzufügen einer Kontoverbindung und einer Standard-IAM-Rolle zur Umgebung finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)
+ Die Standard-IAM-Rolle muss die Richtlinien und Berechtigungen enthalten, die für die Aktion erforderlich sind. **Informationen zu diesen Richtlinien und Berechtigungen finden Sie in der Beschreibung der Role-Eigenschaft in der YAML-Definitionsdokumentation der Aktion.**

Weitere Informationen zu Kontoverbindungen finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md). Hinweise zum Hinzufügen einer Kontoverbindung zu einer Umgebung finden Sie unter[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Name
<a name="deploy.action.ecs.environment.connections.name"></a>

(*ECSDeployAction*/Environment/Connections/**Name**)

(Erforderlich, wenn [Connections](#deploy.action.ecs.environment.connections) es enthalten ist)

Geben Sie den Namen der Kontoverbindung an.

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Role
<a name="deploy.action.ecs.environment.connections.role"></a>

(*ECSDeployAction*/Environment/Connections/**Role**)

(Erforderlich, wenn [Connections](#deploy.action.ecs.environment.connections) es enthalten ist)

Geben Sie den Namen der IAM-Rolle an, auf die die Aktion **Deploy to Amazon ECS** für den Zugriff AWS verwendet. Stellen Sie sicher, dass Sie [die Rolle zu Ihrem CodeCatalyst Bereich hinzugefügt](ipa-connect-account-addroles.md) haben und dass die Rolle die folgenden Richtlinien enthält.

Wenn Sie keine IAM-Rolle angeben, verwendet die Aktion die Standard-IAM-Rolle, die in der [Umgebung](deploy-environments.md) in der CodeCatalyst Konsole aufgeführt ist. Wenn Sie die Standardrolle in der Umgebung verwenden, stellen Sie sicher, dass sie über die folgenden Richtlinien verfügt.
+ Die folgende Berechtigungsrichtlinie:
**Warnung**  
Beschränken Sie die Berechtigungen auf diejenigen, die in der folgenden Richtlinie aufgeführt sind. Die Verwendung einer Rolle mit umfassenderen Berechtigungen kann ein Sicherheitsrisiko darstellen.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [{
      "Action":[
        "ecs:DescribeServices",
        "ecs:CreateTaskSet",
        "ecs:DeleteTaskSet",
        "ecs:ListClusters",
        "ecs:RegisterTaskDefinition",
        "ecs:UpdateServicePrimaryTaskSet",
        "ecs:UpdateService",
        "elasticloadbalancing:DescribeTargetGroups",
        "elasticloadbalancing:DescribeListeners",
        "elasticloadbalancing:ModifyListener",
        "elasticloadbalancing:DescribeRules",
        "elasticloadbalancing:ModifyRule",
        "lambda:InvokeFunction",
        "lambda:ListFunctions",
        "cloudwatch:DescribeAlarms",
        "sns:Publish",
        "sns:ListTopics", 
        "s3:GetObject",
        "s3:GetObjectVersion",
        "codedeploy:CreateApplication", 
        "codedeploy:CreateDeployment", 
        "codedeploy:CreateDeploymentGroup", 
        "codedeploy:GetApplication", 
        "codedeploy:GetDeployment", 
        "codedeploy:GetDeploymentGroup", 
        "codedeploy:ListApplications", 
        "codedeploy:ListDeploymentGroups", 
        "codedeploy:ListDeployments", 
        "codedeploy:StopDeployment", 
        "codedeploy:GetDeploymentTarget", 
        "codedeploy:ListDeploymentTargets", 
        "codedeploy:GetDeploymentConfig", 
        "codedeploy:GetApplicationRevision", 
        "codedeploy:RegisterApplicationRevision", 
        "codedeploy:BatchGetApplicationRevisions", 
        "codedeploy:BatchGetDeploymentGroups", 
        "codedeploy:BatchGetDeployments", 
        "codedeploy:BatchGetApplications", 
        "codedeploy:ListApplicationRevisions", 
        "codedeploy:ListDeploymentConfigs", 
        "codedeploy:ContinueDeployment"           
     ],
     "Resource":"*",
     "Effect":"Allow"
  },{"Action":[
        "iam:PassRole"
     ],
     "Effect":"Allow",
     "Resource":"*",
     "Condition":{"StringLike":{"iam:PassedToService":[
              "ecs-tasks.amazonaws.com",
              "codedeploy.amazonaws.com"
           ]
        }
     }
  }]
  }
  ```

------
**Anmerkung**  
Wenn die Rolle zum ersten Mal verwendet wird, verwenden Sie den folgenden Platzhalter in der Ressourcenrichtlinienanweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

  ```
  "Resource": "*"
  ```
+ Die folgende benutzerdefinierte Vertrauensrichtlinie:

**Anmerkung**  
Sie können die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle mit dieser Aktion verwenden, wenn Sie möchten. Weitere Informationen über diese Rolle finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über volle Zugriffsberechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. 

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte Environment/account/role „Konfiguration“ /' '/ Rolle**

## Inputs
<a name="deploy.action.ecs.inputs"></a>

(*ECSDeployAction*/**Inputs**)

(Optional)

`Inputs`In diesem Abschnitt werden die Daten definiert, die während einer `ECSDeployAction` Workflow-Ausführung benötigt werden.

**Anmerkung**  
Pro Aktion „**Deploy to Amazon ECS**“ ist nur eine Eingabe (entweder eine Quelle oder ein Artefakt) zulässig.

Entsprechende Benutzeroberfläche: Registerkarte „**Eingaben**“

## Sources
<a name="deploy.action.ecs.inputs.sources"></a>

(*ECSDeployAction*/Inputs/**Sources**)

(Erforderlich, wenn Ihre Aufgabendefinitionsdatei in einem Quell-Repository gespeichert ist)

Wenn Ihre Aufgabendefinitionsdatei in einem Quell-Repository gespeichert ist, geben Sie die Bezeichnung dieses Quell-Repositorys an. Derzeit ist das einzige unterstützte Label`WorkflowSource`.

Wenn Ihre Aufgabendefinitionsdatei nicht in einem Quell-Repository enthalten ist, muss sie sich in einem Artefakt befinden, das durch eine andere Aktion generiert wurde.

Weitere Informationen zu Quellen finden Sie unter [Quell-Repositorys mit Workflows verbinden](workflows-sources.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„Quellen“ — optional**

## Artifacts - input
<a name="deploy.action.ecs.inputs.artifacts"></a>

(*ECSDeployAction*/Inputs/**Artifacts**)

(Erforderlich, wenn Ihre Aufgabendefinitionsdatei in einem [Ausgabeartefakt](workflows-working-artifacts-output.md) einer vorherigen Aktion gespeichert ist)

Wenn die Aufgabendefinitionsdatei, die Sie bereitstellen möchten, in einem Artefakt enthalten ist, das durch eine vorherige Aktion generiert wurde, geben Sie dieses Artefakt hier an. Wenn Ihre Aufgabendefinitionsdatei nicht in einem Artefakt enthalten ist, muss sie sich in Ihrem Quell-Repository befinden.

Weitere Informationen zu Artefakten, einschließlich Beispielen, finden Sie unter. [Artefakte und Dateien zwischen Aktionen teilen](workflows-working-artifacts.md)

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/„**Artefakte“ — optional**

## Configuration
<a name="deploy.action.ecs.configuration"></a>

(*ECSDeployAction*/**Configuration**)

(Erforderlich)

Ein Abschnitt, in dem Sie die Konfigurationseigenschaften der Aktion definieren können.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration**“

## region
<a name="deploy.action.ecs.region"></a>

(Configuration/**region**)

(Erforderlich)

Geben Sie die AWS Region an, in der sich Ihr Amazon ECS-Cluster und -Service befinden. Eine Liste der Regionscodes finden Sie unter [Regionale Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) in der. *Allgemeine AWS-Referenz*

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Region“**

## cluster
<a name="deploy.action.ecs.cluster"></a>

(*ECSDeployAction*/Configuration/**cluster**)

(Erforderlich)

Geben Sie den Namen eines vorhandenen Amazon ECS-Clusters an. Mit der Aktion **Deploy to Amazon ECS** wird Ihre containerisierte Anwendung als Aufgabe in diesem Cluster bereitgestellt. Weitere Informationen zu Amazon ECS-Clustern finden Sie unter [Clusters](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters) im *Amazon Elastic Container Service Developer Guide*.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Cluster“**

## service
<a name="deploy.action.ecs.service"></a>

(*ECSDeployAction*/Configuration/**service**)

(Erforderlich)

Geben Sie den Namen eines vorhandenen Amazon ECS-Service an, der die Aufgabendefinitionsdatei instanziieren wird. Dieser Service muss sich unter dem im Feld angegebenen Cluster befinden. `cluster` Weitere Informationen zu Amazon ECS-Services finden Sie unter [Amazon ECS-Services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) im *Amazon Elastic Container Service Developer Guide*.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Service“**

## task-definition
<a name="deploy.action.ecs.task.definition"></a>

(*ECSDeployAction*/Configuration/**task-definition**)

(Erforderlich)

Geben Sie den Pfad zu einer vorhandenen Aufgabendefinitionsdatei an. Wenn sich die Datei in Ihrem Quell-Repository befindet, ist der Pfad relativ zum Stammordner des Quell-Repositorys. Wenn sich Ihre Datei in einem Artefakt aus einer früheren Workflow-Aktion befindet, ist der Pfad relativ zum Artefakt-Stammordner. Weitere Informationen zu Aufgabendefinitionsdateien finden Sie unter [Aufgabendefinitionen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) im *Amazon Elastic Container Service Developer Guide*.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration/Aufgabendefinition**“

## force-new-deployment
<a name="deploy.action.ecs.forcenewdeployment"></a>

(*ECSDeployAction*/Configuration/**force-new-deployment**)

(Erforderlich)

Wenn diese Option aktiviert ist, kann der Amazon ECS-Service neue Bereitstellungen ohne Änderungen der Servicedefinition starten. Wenn eine Bereitstellung erzwungen wird, stoppt der Service alle aktuell ausgeführten Aufgaben und startet neue Aufgaben. Weitere Informationen zum Erzwingen neuer Bereitstellungen finden Sie unter [Aktualisieren eines Service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service.html) im *Amazon Elastic Container Service Developer Guide*.

Standard: `false`

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**Neue Bereitstellung des Dienstes erzwingen**

## codedeploy-appspec
<a name="deploy.action.ecs.codedeploy.appspec"></a>

(*ECSDeployAction*/Configuration/**codedeploy-appspec**)

(Erforderlich, wenn Sie Ihren Amazon ECS-Service für die Verwendung von blue/green Bereitstellungen konfiguriert haben, andernfalls weglassen)

Geben Sie den Namen und den Pfad zu einer vorhandenen CodeDeploy Anwendungsspezifikationsdatei (AppSpec) an. Diese Datei muss sich im Stammverzeichnis Ihres CodeCatalyst Quell-Repositorys befinden. Weitere Informationen zu AppSpec Dateien finden Sie unter [CodeDeploy Anwendungsspezifikationsdateien (AppSpec)](https://docs.aws.amazon.com/codedeploy/latest/userguide/application-specification-files.html) im *AWS CodeDeploy Benutzerhandbuch*.

**Anmerkung**  
Geben Sie nur CodeDeploy Informationen an, wenn Sie Ihren Amazon ECS-Service für die Durchführung von blue/green Bereitstellungen konfiguriert haben. Lassen Sie bei fortlaufenden Update-Bereitstellungen (Standard) die Informationen weg. CodeDeploy Weitere Informationen zu Amazon ECS-Bereitstellungen finden Sie unter [Amazon ECS-Bereitstellungstypen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) im *Amazon Elastic Container Service Developer Guide*.

**Anmerkung**  
Die **CodeDeploy**Felder sind möglicherweise im visuellen Editor ausgeblendet. Informationen dazu, wie sie angezeigt werden, finden Sie unter[Warum fehlen CodeDeploy Felder im visuellen Editor?](troubleshooting-workflows.md#troubleshooting-workflows-codedeploy).

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**CodeDeploy AppSpec**

## codedeploy-application
<a name="deploy.action.ecs.codedeploy.application"></a>

(*ECSDeployAction*/Configuration/**codedeploy-application**)

(Erforderlich, wenn `codedeploy-appspec` es enthalten ist)

Geben Sie den Namen einer vorhandenen CodeDeploy Anwendung an. Weitere Informationen zu CodeDeploy Anwendungen finden Sie [ CodeDeployim *AWS CodeDeploy Benutzerhandbuch* unter Arbeiten mit Anwendungen](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/AnwendungCodeDeploy “**

## codedeploy-deployment-group
<a name="deploy.action.ecs.codedeploy.deploymentgroup"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-group**)

(Erforderlich, wenn `codedeploy-appspec` es enthalten ist)

Geben Sie den Namen einer vorhandenen CodeDeploy Bereitstellungsgruppe an. Weitere Informationen zu CodeDeploy Bereitstellungsgruppen finden Sie [ CodeDeployim *AWS CodeDeploy Benutzerhandbuch* unter Arbeiten mit Bereitstellungsgruppen](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html).

Entsprechende Benutzeroberfläche: Registerkarte „**CodeDeploy Konfiguration/Bereitstellungsgruppe**“

## codedeploy-deployment-description
<a name="deploy.action.ecs.codedeploy.deploymentdescription"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-description**)

(Optional)

Geben Sie eine Beschreibung der Bereitstellung an, die durch diese Aktion erstellt wird. Weitere Informationen finden Sie [ CodeDeployim *AWS CodeDeploy Benutzerhandbuch* unter Arbeiten mit Bereitstellungen](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments.html).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ und Beschreibung der Bereitstellung CodeDeploy **

# Bereitstellung auf Amazon EKS mit einem Workflow
<a name="deploy-action-eks"></a>

**Tipp**  
Ein Tutorial, das Ihnen zeigt, wie Sie die **Cluster-Aktion Deploy to Kubernetes** verwenden, finden Sie unter. [Tutorial: Bereitstellen einer Anwendung in Amazon EKS](deploy-tut-eks.md)

In diesem Abschnitt wird beschrieben, wie Sie eine containerisierte Anwendung mithilfe eines Workflows in einem Kubernetes-Cluster bereitstellen. CodeCatalyst Um dies zu erreichen, müssen Sie Ihrem Workflow die Aktion Auf **Kubernetes-Cluster bereitstellen** hinzufügen. Diese Aktion stellt Ihre Anwendung in einem Kubernetes-Cluster bereit, den Sie in Amazon Elastic Kubernetes Service (EKS) mithilfe einer oder mehrerer Kubernetes-Manifestdateien eingerichtet haben. Ein Beispielmanifest finden Sie unter. [deployment.yaml](deploy-tut-eks.md#deploy-tut-eks-source-files-deployment-yml) [Tutorial: Bereitstellen einer Anwendung in Amazon EKS](deploy-tut-eks.md)

Weitere Informationen zu Kubernetes finden Sie in der [Kubernetes-Dokumentation](https://kubernetes.io/docs/home/).

Weitere Informationen zu Amazon EKS finden Sie unter [Was ist Amazon EKS?](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) im *Amazon EKS-Benutzerhandbuch*.

**Topics**
+ [So funktioniert die Aktion „Im Kubernetes-Cluster bereitstellen“](#deploy-action-eks-howitworks)
+ [Runtime-Image, das von der Aktion „In Amazon EKS bereitstellen“ verwendet wird](#deploy-action-eks-runtime)
+ [Tutorial: Bereitstellen einer Anwendung in Amazon EKS](deploy-tut-eks.md)
+ [Aktion „Im Kubernetes-Cluster bereitstellen“ hinzufügen](deploy-action-eks-adding.md)
+ [Variablen „Im Kubernetes-Cluster bereitstellen“](deploy-action-eks-variables.md)
+ [Aktion „Im Kubernetes-Cluster bereitstellen“ YAML](deploy-action-ref-eks.md)

## So funktioniert die Aktion „Im Kubernetes-Cluster bereitstellen“
<a name="deploy-action-eks-howitworks"></a>

Der **Cluster „Auf Kubernetes bereitstellen**“ funktioniert wie folgt:

1. Zur Laufzeit installiert die Aktion das `kubectl` Kubernetes-Hilfsprogramm auf dem CodeCatalyst Computer, auf dem die Aktion ausgeführt wird. Die Aktion ist so konfiguriert`kubectl`, dass sie auf den Amazon EKS-Cluster verweist, den Sie bei der Konfiguration der Aktion angegeben haben. Das `kubectl` Hilfsprogramm ist erforderlich, um den `kubectl apply` Befehl als Nächstes auszuführen.

1. Die Aktion führt den `kubectl apply -f my-manifest.yaml` Befehl aus, der die Anweisungen *my-manifest.yaml* zur Bereitstellung Ihrer Anwendung als Satz von Containern und Pods im konfigurierten Cluster ausführt. Weitere Informationen zu diesem Befehl finden Sie im Thema [kubectl apply in der *Kubernetes-Referenzdokumentation*](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply).

## Runtime-Image, das von der Aktion „In Amazon EKS bereitstellen“ verwendet wird
<a name="deploy-action-eks-runtime"></a>

Die Aktion In **Amazon EKS bereitstellen** wird auf einem [Image vom November 2022](build-images.md#build.previous-image) ausgeführt. Weitere Informationen finden Sie unter [Aktive Bilder](build-images.md#build-curated-images).

# Tutorial: Bereitstellen einer Anwendung in Amazon EKS
<a name="deploy-tut-eks"></a>

In diesem Tutorial erfahren Sie, wie Sie mithilfe eines CodeCatalyst Amazon-Workflows, Amazon EKS und einiger anderer Services eine containerisierte Anwendung in Amazon Elastic Kubernetes Service bereitstellen. AWS Bei der bereitgestellten Anwendung handelt es sich um ein einfaches „Hello, World\$1“ Website, die auf einem Docker-Image des Apache-Webservers basiert. Das Tutorial führt Sie durch die erforderlichen Vorbereitungsarbeiten wie das Einrichten einer Entwicklungsmaschine und eines Amazon EKS-Clusters und beschreibt anschließend, wie Sie einen Workflow erstellen, um die Anwendung zu erstellen und sie im Cluster bereitzustellen.

Nach Abschluss der ersten Bereitstellung werden Sie im Tutorial angewiesen, eine Änderung an Ihrer Anwendungsquelle vorzunehmen. Diese Änderung führt dazu, dass ein neues Docker-Image erstellt und mit neuen Revisionsinformationen in Ihr Docker-Image-Repository übertragen wird. Die neue Version des Docker-Images wird dann in Amazon EKS bereitgestellt.

**Tipp**  
Anstatt sich durch dieses Tutorial zu arbeiten, können Sie einen Blueprint verwenden, der ein vollständiges Amazon EKS-Setup für Sie durchführt. Sie müssen den **EKS App Deployment** Blueprint verwenden. Weitere Informationen finden Sie unter [Ein Projekt mit einem Blueprint erstellen](projects-create.md#projects-create-console-template).

**Topics**
+ [Voraussetzungen](#deploy-tut-eks-prereqs)
+ [Schritt 1: Richten Sie Ihren Entwicklungscomputer ein](#deploy-tut-eks-dev-env-create)
+ [Schritt 2: Erstellen Sie einen Amazon EKS-Cluster](#deploy-tut-eks-cluster)
+ [Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository](#deploy-tut-eks-ecr)
+ [Schritt 4: Quelldateien hinzufügen](#deploy-tut-eks-source-files)
+ [Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles)
+ [Schritt 6: AWS Rollen hinzufügen zu CodeCatalyst](#deploy-tut-eks-import-roles)
+ [Schritt 7: Aktualisieren Sie das ConfigMap](#deploy-tut-eks-configmap)
+ [Schritt 8: Erstellen Sie einen Workflow und führen Sie ihn aus](#deploy-tut-eks-workflow)
+ [Schritt 9: Nehmen Sie eine Änderung an Ihren Quelldateien vor](#deploy-tut-eks-change)
+ [Bereinigen](#deploy-tut-eks-cleanup)

## Voraussetzungen
<a name="deploy-tut-eks-prereqs"></a>

Bevor Sie mit diesem Tutorial beginnen:
+ Sie benötigen einen CodeCatalyst **Amazon-Bereich** mit einem verbundenen AWS Konto. Weitere Informationen finden Sie unter [Erstellen einer Umgebung](spaces-create.md).
+ In Ihrem Bereich benötigen Sie ein leeres Projekt mit dem Namen:

  ```
  codecatalyst-eks-project
  ```

  Verwenden Sie die Option **Von vorne beginnen**, um dieses Projekt zu erstellen.

  Weitere Informationen finden Sie unter [Ein leeres Projekt in Amazon erstellen CodeCatalyst](projects-create.md#projects-create-empty).
+ In Ihrem Projekt benötigen Sie ein leeres CodeCatalyst **Quell-Repository** mit dem Namen:

  ```
  codecatalyst-eks-source-repository
  ```

  Weitere Informationen finden Sie unter [Speichern Sie Code mit Quell-Repositorys in und arbeiten Sie gemeinsam daran CodeCatalystSpeichern Sie Code mit Quell-Repositorys und arbeiten Sie gemeinsam daran](source.md).
+ In Ihrem Projekt benötigen Sie eine CodeCatalyst **CI/CD-Umgebung** (keine Entwicklungsumgebung) namens:

  ```
  codecatalyst-eks-environment
  ```

  Konfigurieren Sie diese Umgebung wie folgt:
  + Wählen Sie einen beliebigen Typ aus, z. B. „Keine **Produktion**“.
  + Connect dein AWS Konto damit. 
  + Wählen Sie für die **Standard-IAM-Rolle eine** beliebige Rolle aus. Sie werden später eine andere Rolle angeben.

  Weitere Informationen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md).

## Schritt 1: Richten Sie Ihren Entwicklungscomputer ein
<a name="deploy-tut-eks-dev-env-create"></a>

Der erste Schritt in diesem Tutorial besteht darin, einen Entwicklungscomputer mit einigen Tools zu konfigurieren, die Sie in diesem Tutorial verwenden werden. Diese Tools sind:
+ das `eksctl` Hilfsprogramm — für die Cluster-Erstellung
+ das `kubectl` Hilfsprogramm — eine Voraussetzung für `eksctl`
+ das AWS CLI — auch eine Voraussetzung für `eksctl`

Sie können diese Tools auf Ihrem vorhandenen Entwicklungscomputer installieren, falls Sie einen haben, oder Sie können eine CodeCatalyst Entwicklungsumgebung verwenden, die cloudbasiert ist. Der Vorteil einer CodeCatalyst Entwicklungsumgebung besteht darin, dass sie einfach hoch- und heruntergefahren werden kann und in andere CodeCatalyst Dienste integriert ist, sodass Sie dieses Tutorial in weniger Schritten durcharbeiten können.

In diesem Tutorial wird davon ausgegangen, dass Sie eine CodeCatalyst Entwicklungsumgebung verwenden.

Die folgenden Anweisungen beschreiben eine schnelle Methode, um eine CodeCatalyst Entwicklungsumgebung zu starten und sie mit den erforderlichen Tools zu konfigurieren. Eine ausführliche Anleitung finden Sie unter:
+ [Erstellen einer Entwicklungsumgebung](devenvironment-create.md) in dieser Anleitung.
+ [Installation von kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) im **Amazon EKS-Benutzerhandbuch**.
+ [Installation oder Aktualisierung von eksctl](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) im **Amazon EKS-Benutzerhandbuch**.
+ [Installation oder Aktualisierung der neuesten Version von, die AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) im *AWS Command Line Interface Benutzerhandbuch* beschrieben ist.

**Um eine Entwicklungsumgebung zu starten**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Navigieren Sie zu Ihrem Projekt,`codecatalyst-eks-project`.

1. Wählen Sie im Navigationsbereich **Code** und dann **Quell-Repositories** aus. 

1. Wählen Sie den Namen Ihres Quell-Repositorys,`codecatalyst-eks-source-repository`.

1. Wählen Sie oben **Create Dev Environment** und dann **AWS Cloud9 (im Browser)** aus.

1. Vergewissern Sie sich, dass **In vorhandenem Zweig und **Hauptbereich** arbeiten** ausgewählt sind, und wählen Sie dann **Create** aus.

   Ihre Entwicklungsumgebung wird in einem neuen Browser-Tab gestartet, in den Ihr Repository (`codecatalyst-eks-source-repository`) geklont wird.

**Um kubectl zu installieren und zu konfigurieren**

1. Geben Sie im Dev Environment-Terminal Folgendes ein:

   ```
   curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
   ```

1. Geben Sie ein:

   ```
   chmod +x ./kubectl
   ```

1. Geben Sie ein:

   ```
   mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
   ```

1. Geben Sie ein:

   ```
   echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
   ```

1. Geben Sie ein:

   ```
   kubectl version --short --client
   ```

1. Vergewissern Sie sich, dass eine Version angezeigt wird.

   Sie haben es jetzt installiert`kubectl`.

**Um eksctl zu installieren und zu konfigurieren**
**Anmerkung**  
`eksctl`ist nicht unbedingt erforderlich, da Sie stattdessen verwenden `kubectl` können. `eksctl`Hat jedoch den Vorteil, dass ein Großteil der Clusterkonfiguration automatisiert wird, und ist daher das für dieses Tutorial empfohlene Tool.

1. Geben Sie im Dev Environment-Terminal Folgendes ein:

   ```
   curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
   ```

1. Geben Sie ein:

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. Geben Sie ein:

   ```
   eksctl version
   ```

1. Vergewissern Sie sich, dass eine Version angezeigt wird.

   Sie haben es jetzt installiert`eksctl`.

**Um zu überprüfen, ob das installiert AWS CLI ist**

1. Geben Sie im Dev Environment-Terminal Folgendes ein:

   ```
   aws --version
   ```

1. Überprüfen Sie, ob eine Version angezeigt wird, um zu überprüfen, ob die installiert AWS CLI ist.

   Führen Sie die verbleibenden Verfahren aus, um die AWS CLI mit den erforderlichen Zugriffsberechtigungen zu konfigurieren AWS.

**Um das zu konfigurieren AWS CLI**

Sie müssen das AWS CLI mit Zugriffsschlüsseln und einem Sitzungstoken konfigurieren, um ihm Zugriff auf AWS Dienste zu gewähren. Die folgenden Anweisungen bieten eine schnelle Möglichkeit, die Schlüssel und das Token zu konfigurieren. Wenn Sie jedoch detaillierte Anweisungen wünschen, finden Sie [AWS CLI im *AWS Command Line Interface Benutzerhandbuch* unter Konfiguration von](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).

1. Erstellen Sie wie folgt einen IAM Identity Center-Benutzer:

   1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS IAM Identity Center Konsole unter [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/).

      (Möglicherweise müssen Sie **Aktivieren** auswählen, wenn Sie sich noch nie bei IAM Identity Center angemeldet haben.)
**Anmerkung**  
Stellen Sie sicher, dass Sie sich mit dem anmelden AWS-Konto , der mit Ihrem CodeCatalyst Bereich verbunden ist. Sie können überprüfen, welches Konto verbunden ist, indem Sie zu Ihrem Bereich navigieren und den Tab **AWS-Konten** auswählen. Weitere Informationen finden Sie unter [Erstellen einer Umgebung](spaces-create.md).

   1. Wählen Sie im Navigationsbereich **Users (Benutzer)** und dann **Add User (Benutzer hinzufügen)** aus.

   1. Geben Sie im Feld **Nutzername** Folgendes ein:

      ```
      codecatalyst-eks-user
      ```

   1. Wählen Sie unter **Passwort** die Option **Einmalpasswort generieren aus, das Sie mit diesem Benutzer teilen können**.

   1. Geben Sie in den **Feldern **E-Mail-Adresse** und E-Mail-Adresse bestätigen** eine E-Mail-Adresse ein, die noch nicht in IAM Identity Center existiert.

   1. Geben Sie im Feld **Vorname** Folgendes ein:

      ```
      codecatalyst-eks-user
      ```

   1. Geben Sie im Feld **Nachname** Folgendes ein:

      ```
      codecatalyst-eks-user
      ```

   1. Behalten **Sie im Feld Anzeigename** Folgendes bei:

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

   1. Wählen Sie **Weiter** aus.

   1. Wählen Sie auf der Seite „**Benutzer zu Gruppen hinzufügen**“ die Option **Weiter** aus.

   1. Überprüfen Sie auf der Seite **Benutzer überprüfen und hinzufügen** die Informationen und wählen Sie **Benutzer hinzufügen** aus.

      Ein Dialogfeld mit einem **Einmalkennwort** wird angezeigt.

   1. Wählen Sie **Kopieren** und fügen Sie dann die Anmeldeinformationen in eine Textdatei ein. Die Anmeldeinformationen bestehen aus der URL des AWS Zugriffsportals, einem Benutzernamen und einem Einmalkennwort.

   1. Klicken Sie auf **Schließen**.

1. Erstellen Sie wie folgt einen Berechtigungssatz:

   1. Wählen Sie im Navigationsbereich die Option **Berechtigungssätze** und dann **Berechtigungssatz erstellen** aus.

   1. Wählen Sie **Vordefinierter Berechtigungssatz** und dann aus **AdministratorAccess**. Diese Richtlinie gewährt allen volle Berechtigungen AWS-Services. 

   1. Wählen Sie **Weiter** aus.

   1. Entfernen Sie im Feld **Name des Berechtigungssatzes** den Wert `AdministratorAccess` und geben Sie Folgendes ein:

      ```
      codecatalyst-eks-permission-set
      ```

   1. Wählen Sie **Weiter** aus.

   1. **Überprüfen Sie auf der Seite Überprüfen und erstellen** die Informationen und wählen Sie **Erstellen** aus.

1. Weisen Sie den Berechtigungssatz wie folgt zu`codecatalyst-eks-user`:

   1. Wählen Sie im Navigationsbereich die Option aus **AWS-Konten**, und aktivieren Sie dann das Kontrollkästchen neben dem AWS-Konto , bei dem Sie derzeit angemeldet sind.

   1. Wählen Sie **Benutzer oder Gruppen zuweisen** aus.

   1. Wählen Sie die Registerkarte **Users**.

   1. Aktivieren Sie das Kontrollkästchen neben`codecatalyst-eks-user`.

   1. Wählen Sie **Weiter** aus.

   1. Aktivieren Sie das Kontrollkästchen neben`codecatalyst-eks-permission-set`.

   1. Wählen Sie **Weiter** aus.

   1. Überprüfen Sie die Informationen und wählen Sie **Senden** aus.

      Sie haben sie nun `codecatalyst-eks-permission-set` zugewiesen `codecatalyst-eks-user` und an Sie AWS-Konto gebunden.

1. Rufen Sie `codecatalyst-eks-user` die Zugriffsschlüssel und das Sitzungstoken wie folgt ab:

   1. Stellen Sie sicher, dass Sie die URL des AWS Zugriffsportals sowie den Benutzernamen und das Einmalpasswort für haben`codecatalyst-eks-user`. Sie hätten diese Informationen früher in einen Texteditor kopieren sollen.
**Anmerkung**  
Wenn Ihnen diese Informationen nicht vorliegen, rufen Sie die `codecatalyst-eks-user` Detailseite im IAM Identity Center auf und wählen Sie **Passwort zurücksetzen**, **Einmalpasswort generieren [...]** , und klicken **Sie erneut auf Passwort zurücksetzen**, um die Informationen auf dem Bildschirm anzuzeigen.

   1. Melden Sie sich ab AWS.

   1. Fügen Sie die URL des AWS Zugangsportals in die Adressleiste Ihres Browsers ein.

   1. Melden Sie sich an mit:
      + **Nutzername**:

        ```
        codecatalyst-eks-user
        ```
      + **Passwort**:

        *one-time-password*

   1. Geben **Sie unter Neues Passwort einrichten** ein neues Passwort ein und wählen Sie **Neues Passwort festlegen** aus.

      Auf dem Bildschirm erscheint ein **AWS-Konto**Feld.

   1. Wählen Sie **AWS-Konto**und wählen Sie dann den Namen des Benutzers und des AWS-Konto Berechtigungssatzes aus, dem Sie den `codecatalyst-eks-user` Benutzer zugewiesen haben.

   1. Wählen Sie neben `codecatalyst-eks-permission-set` **Befehlszeile oder programmatischer Zugriff** aus.

   1. Kopieren Sie die Befehle in der Mitte der Seite. Sie sehen etwa wie folgt aus:

      ```
      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
      export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
      export AWS_SESSION_TOKEN="session-token"
      ```

      ... wo *session-token* ist eine lange zufällige Zeichenfolge.

1. Fügen Sie die Zugriffsschlüssel und das AWS CLI Sitzungstoken wie folgt zur hinzu:

   1. Kehren Sie zu Ihrer CodeCatalyst Entwicklungsumgebung zurück.

   1. Fügen Sie an der Terminal-Eingabeaufforderung die Befehle ein, die Sie kopiert haben. Drücken Sie die **Eingabetaste**.

      Sie haben das jetzt AWS CLI mit Zugriffsschlüsseln und einem Sitzungstoken konfiguriert. Sie können es jetzt verwenden AWS CLI , um die für dieses Tutorial erforderlichen Aufgaben zu erledigen.
**Wichtig**  
Wenn Sie während dieses Tutorials zu irgendeinem Zeitpunkt Meldungen sehen, die den folgenden ähneln:  
`Unable to locate credentials. You can configure credentials by running "aws configure".`  
Oder:  
`ExpiredToken: The security token included in the request is expired`  
... das liegt daran, dass Ihre AWS CLI Sitzung abgelaufen ist. Führen Sie in diesem Fall den `aws configure` Befehl *nicht* aus. Verwenden Sie stattdessen die Anweisungen in Schritt 4 dieses Verfahrens, das mit „Aktualisieren `Obtain codecatalyst-eks-user's access key and session token` Sie Ihre Sitzung“ beginnt.

## Schritt 2: Erstellen Sie einen Amazon EKS-Cluster
<a name="deploy-tut-eks-cluster"></a>

In diesem Abschnitt erstellen Sie einen Cluster in Amazon EKS. Die folgenden Anweisungen beschreiben eine schnelle Methode zum Erstellen des Clusters mithilfe von`eksctl`. Wenn Sie jedoch detaillierte Anweisungen wünschen, finden Sie unter:
+ [Erste Schritte mit eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) im **Amazon EKS-Benutzerhandbuch**

  oder
+ [Erste Schritte mit der Konsole und AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) im **Amazon EKS-Benutzerhandbuch** (dieses Thema enthält `kubectl` Anweisungen zum Erstellen des Clusters) 

**Anmerkung**  
[Private Cluster](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) werden von der CodeCatalyst Integration mit Amazon EKS nicht unterstützt.

**Bevor Sie beginnen**

Stellen Sie sicher, dass Sie die folgenden Aufgaben auf Ihrem Entwicklungscomputer abgeschlossen haben:
+ Das `eksctl` Hilfsprogramm wurde installiert.
+ Das `kubectl` Hilfsprogramm wurde installiert.
+ Habe das installiert AWS CLI und mit Zugriffsschlüsseln und einem Sitzungstoken konfiguriert.

Informationen zur Ausführung dieser Aufgaben finden Sie unter[Schritt 1: Richten Sie Ihren Entwicklungscomputer ein](#deploy-tut-eks-dev-env-create).

**So erstellen Sie einen Cluster**
**Wichtig**  
Verwenden Sie nicht die Benutzeroberfläche des Amazon EKS-Service, um den Cluster zu erstellen, da der Cluster dann nicht korrekt konfiguriert wird. Verwenden Sie das `eksctl` Hilfsprogramm, wie in den folgenden Schritten beschrieben.

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

1. Erstellen Sie einen Cluster und Knoten:

   ```
   eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
   ```

   Wobei Folgendes gilt:
   + *codecatalyst-eks-cluster*wird durch den Namen ersetzt, den Sie Ihrem Cluster geben möchten.
   + *us-west-2*wird durch Ihre Region ersetzt.

   Nach 10 bis 20 Minuten erscheint eine Meldung, die der folgenden ähnelt: 

   `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready`
**Anmerkung**  
Während AWS der Erstellung Ihres Clusters werden mehrere `waiting for CloudFormation stack` Meldungen angezeigt. Das ist normal.

1. Stellen Sie sicher, dass Ihr Cluster erfolgreich erstellt wurde:

   ```
   kubectl cluster-info
   ```

   Es wird eine Meldung ähnlich der folgenden angezeigt, die auf eine erfolgreiche Clustererstellung hinweist:

   ```
   Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
   CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ```

## Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository
<a name="deploy-tut-eks-ecr"></a>

In diesem Abschnitt erstellen Sie ein privates Image-Repository in Amazon Elastic Container Registry (Amazon ECR). Dieses Repository speichert das Docker-Image für das Tutorial.

Weitere Informationen zu Amazon ECR finden Sie im *Amazon Elastic Container Registry User Guide*.

**Um ein Bild-Repository in Amazon ECR zu erstellen**

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

1. Erstellen Sie ein leeres Repository in Amazon ECR:

   ```
   aws ecr create-repository --repository-name codecatalyst-eks-image-repo
   ```

   *codecatalyst-eks-image-repo*Ersetzen Sie es durch den Namen, den Sie dem Amazon ECR-Repository geben möchten.

   In diesem Tutorial wird davon ausgegangen, dass Sie Ihrem Repository `codecatalyst-eks-image-repo` einen Namen gegeben haben.

1. Zeigen Sie die Details des Amazon ECR-Repositorys an:

   ```
   aws ecr describe-repositories \
         --repository-names codecatalyst-eks-image-repo
   ```

1. Notieren Sie sich den `“repositoryUri”:` Wert, zum Beispiel. `111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo`

   Sie benötigen ihn später, wenn Sie das Repository zu Ihrem Workflow hinzufügen. 

## Schritt 4: Quelldateien hinzufügen
<a name="deploy-tut-eks-source-files"></a>

In diesem Abschnitt fügen Sie Anwendungsquelldateien zu Ihrem Quell-Repository hinzu (`codecatalyst-eks-source-repository`). Sie bestehen aus:
+ Eine `index.html` Datei — Zeigt ein „Hallo, Welt\$1“ Nachricht im Browser.
+ Ein Dockerfile — Beschreibt das Basis-Image, das für Ihr Docker-Image verwendet werden soll, und die Docker-Befehle, die darauf angewendet werden sollen.
+ Eine `deployment.yaml` Datei — Das Kubernetes-Manifest, das den Kubernetes-Service und die Bereitstellung definiert. 

Die Ordnerstruktur sieht wie folgt aus:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

**Topics**
+ [index.html](#deploy-tut-eks-source-files-index)
+ [Dockerfile](#deploy-tut-eks-source-files-dockerfile)
+ [deployment.yaml](#deploy-tut-eks-source-files-deployment-yml)

### index.html
<a name="deploy-tut-eks-source-files-index"></a>

In der `index.html` Datei wird die Meldung „Hello, World\$1“ angezeigt Nachricht im Browser. 

**Um die Datei index.html hinzuzufügen**

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

1. Erstellen Sie in `codecatalyst-eks-source-repository` einen Ordner mit dem Namen`public-html`.

1. Erstellen Sie in `/public-html` eine Datei namens `index.html` mit dem folgenden Inhalt:

   ```
   <html>
     <head>
       <title>Hello World</title>
       <style>
         body {
         background-color: black;
         text-align: center;
         color: white;
         font-family: Arial, Helvetica, sans-serif;
         }  
       </style>
     </head>
     <body>
       <h1>Hello, World!</h1>
     </body>
   </html>
   ```

1. Geben Sie an der Terminal-Eingabeaufforderung Folgendes ein:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. Hinzufügen, Festschreiben und Push:

   ```
   git add .
   git commit -m "add public-html/index.html"
   git push
   ```

   Das `index.html` wird Ihrem Repository in einem `public-html` Ordner hinzugefügt. 

### Dockerfile
<a name="deploy-tut-eks-source-files-dockerfile"></a>

Das Dockerfile beschreibt das zu verwendende Basis-Decker-Image und die darauf anzuwendenden Docker-Befehle. [Weitere Informationen zum Dockerfile finden Sie in der Dockerfile-Referenz.](https://docs.docker.com/engine/reference/builder/)

Das hier angegebene Dockerfile gibt an, dass das Apache 2.4-Basisimage () verwendet werden soll. `httpd` Es enthält auch Anweisungen zum Kopieren einer `index.html` aufgerufenen Quelldatei in einen Ordner auf dem Apache-Server, der Webseiten bereitstellt. Die `EXPOSE` Anweisung in der Dockerfile teilt Docker mit, dass der Container auf Port 80 lauscht.

**Um das Dockerfile hinzuzufügen**

1. Erstellen Sie in `codecatalyst-eks-source-repository` eine Datei namens `Dockerfile` mit dem folgenden Inhalt:

   ```
   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80
   ```

   Geben Sie keine Dateierweiterung an.
**Wichtig**  
Das Dockerfile muss sich im Stammordner Ihres Repositorys befinden. Der `Docker build` Befehl des Workflows erwartet, dass es dort vorhanden ist.

1. Hinzufügen, Festschreiben und Push:

   ```
   git add .
   git commit -m "add Dockerfile"
   git push
   ```

   Das Dockerfile wird zu Ihrem Repository hinzugefügt.

### deployment.yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

In diesem Abschnitt fügen Sie Ihrem Repository eine `deployment.yaml` Datei hinzu. Die `deployment.yaml` Datei ist ein Kubernetes-Manifest, das zwei auszuführende Kubernetes-Ressourcentypen oder *-arten* definiert: einen „Dienst“ und eine „Bereitstellung“.
+ Der „Service“ stellt einen Load Balancer in Amazon EC2 bereit. Der Load Balancer stellt Ihnen eine mit dem Internet verbundene öffentliche URL und einen Standardport (Port 80) zur Verfügung, über den Sie zu „Hello, World\$1“ navigieren können Anwendung. 
+ Bei der „Bereitstellung“ werden drei Pods bereitgestellt, und jeder Pod enthält einen Docker-Container mit dem Namen „Hello, World\$1“ Anwendung. Die drei Pods werden auf den Knoten bereitgestellt, die bei der Erstellung des Clusters erstellt wurden.

Das Manifest in diesem Tutorial ist kurz. Ein Manifest kann jedoch eine beliebige Anzahl von Kubernetes-Ressourcentypen wie Pods, Jobs, Ingresses und Netzwerkrichtlinien enthalten. Außerdem können Sie mehrere Manifestdateien verwenden, wenn Ihre Bereitstellung komplex ist.

**Um eine deployment.yaml-Datei hinzuzufügen**

1. Erstellen Sie in einen `codecatalyst-eks-source-repository` Ordner mit dem Namen. `Kubernetes`

1. Erstellen Sie in `/Kubernetes` eine Datei namens `deployment.yaml` mit dem folgenden Inhalt:

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: my-service
     labels:
       app: my-app
   spec:
     type: LoadBalancer
     selector:
       app: my-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-deployment
     labels:
       app: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: codecatalyst-eks-container
           # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
           image: $REPOSITORY_URI:$IMAGE_TAG
           ports:
           - containerPort: 80
   ```

1. Hinzufügen, Festschreiben und Push:

   ```
   git add .
   git commit -m "add Kubernetes/deployment.yaml"
   git push
   ```

   Die `deployment.yaml` Datei wird Ihrem Repository in einem Ordner mit dem Namen hinzugefügt`Kubernetes`. 

Sie haben jetzt alle Ihre Quelldateien hinzugefügt.

Nehmen Sie sich einen Moment Zeit, um Ihre Arbeit zu überprüfen und sicherzustellen, dass Sie alle Dateien in den richtigen Ordnern abgelegt haben. Die Ordnerstruktur ist wie folgt:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

## Schritt 5: AWS Rollen erstellen
<a name="deploy-tut-eks-roles"></a>

In diesem Abschnitt erstellen Sie AWS IAM-Rollen, die Ihr CodeCatalyst Workflow benötigt, um zu funktionieren. Diese Rollen sind:
+ **Build-Rolle** — Erteilt der CodeCatalyst Build-Aktion (im Workflow) die Berechtigung, auf Ihr AWS Konto zuzugreifen und in Amazon ECR und Amazon EC2 zu schreiben.
+ **Rolle bereitstellen** — Erteilt der **Cluster-Aktion CodeCatalyst Deploy to Kubernetes** (im Workflow) die Berechtigung, auf Ihr AWS Konto und Amazon EKS zuzugreifen.

*Weitere Informationen zu IAM-Rollen finden Sie unter [IAM-Rollen im Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).AWS Identity and Access Management *

**Anmerkung**  
Um Zeit zu sparen, können Sie anstelle der beiden zuvor aufgeführten Rollen eine einzelne `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle, die so genannte Rolle, erstellen. Weitere Informationen finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über sehr umfangreiche Berechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. In diesem Tutorial wird davon ausgegangen, dass Sie die beiden zuvor aufgeführten Rollen erstellen.

Führen Sie die folgenden Verfahren aus, um die Build- und Deploy-Rollen zu erstellen.

**1. Um eine Vertrauensrichtlinie für beide Rollen zu erstellen**

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

1. Erstellen Sie im `Cloud9-long-string` Verzeichnis eine Datei namens `codecatalyst-eks-trust-policy.json` mit dem folgenden Inhalt:

**2. Um die Build-Richtlinie für die Build-Rolle zu erstellen**
+ Erstellen Sie im `Cloud9-long-string` Verzeichnis eine Datei namens `codecatalyst-eks-build-policy.json` mit dem folgenden Inhalt:

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "ecr:*",
                  "ec2:*"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**Anmerkung**  
Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

  ```
  "Resource": "*"
  ```

**3. Um die Bereitstellungsrichtlinie für die Bereitstellungsrolle zu erstellen**
+ Erstellen Sie im `Cloud9-long-string` Verzeichnis eine Datei namens `codecatalyst-eks-deploy-policy.json` mit dem folgenden Inhalt:

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**Anmerkung**  
Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

  ```
  "Resource": "*"
  ```

Sie haben Ihrer Entwicklungsumgebung jetzt drei Richtliniendokumente hinzugefügt. Ihre Verzeichnisstruktur sieht jetzt wie folgt aus:

```
|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json
```

**4. Um die Build-Richtlinie hinzuzufügen AWS**

1. Geben Sie im Dev Environment-Terminal Folgendes ein:

   ```
   cd /projects
   ```

1. Geben Sie ein:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-eks-build-policy \
       --policy-document file://codecatalyst-eks-build-policy.json
   ```

1. Drücken Sie die **Eingabetaste**.

1. Notieren Sie sich den `"arn":` Wert in der Befehlsausgabe, zum Beispiel`arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy`. Sie benötigen diesen ARN später.

**5. Um die Bereitstellungsrichtlinie hinzuzufügen AWS**

1. Geben Sie ein:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-eks-deploy-policy \
       --policy-document file://codecatalyst-eks-deploy-policy.json
   ```

1. Drücken Sie die **Eingabetaste**.

1. Notieren Sie sich in der Befehlsausgabe den `"arn":` Wert der Bereitstellungsrichtlinie, `arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy` z. B. Sie benötigen diesen ARN später.

**6. Um die Build-Rolle zu erstellen**

1. Geben Sie ein: 

   ```
   aws iam create-role \
         --role-name codecatalyst-eks-build-role \
         --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
   ```

1. Drücken Sie die **Eingabetaste**.

1. Geben Sie ein:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-eks-build-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy
   ```

   Wo *arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy* wird durch den ARN der Build-Richtlinie ersetzt, die Sie zuvor notiert haben.

1. Drücken Sie die **Eingabetaste**.

1. Geben Sie an der Terminal-Eingabeaufforderung Folgendes ein:

   ```
   aws iam get-role \
         --role-name codecatalyst-eks-build-role
   ```

1. Drücken Sie die **Eingabetaste**.

1. Notieren Sie sich den `"Arn":` Wert der Rolle, zum Beispiel`arn:aws:iam::111122223333:role/codecatalyst-eks-build-role`. Sie benötigen diesen ARN später.

**7. Um die Bereitstellungsrolle zu erstellen**

1. Geben Sie ein:

   ```
   aws iam create-role \
         --role-name codecatalyst-eks-deploy-role \
         --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
   ```

1. Drücken Sie die **Eingabetaste**.

1. Geben Sie ein:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-eks-deploy-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy
   ```

   Wo *arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy* wird durch den ARN der Bereitstellungsrichtlinie ersetzt, die Sie zuvor notiert haben.

1. Drücken Sie die **Eingabetaste**.

1. Geben Sie ein:

   ```
   aws iam get-role \
         --role-name codecatalyst-eks-deploy-role
   ```

1. Drücken Sie die **Eingabetaste**.

1. Notieren Sie sich den `"Arn":` Wert der Rolle, zum Beispiel`arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role`. Sie benötigen diesen ARN später.

Sie haben jetzt Build- und Deploy-Rollen erstellt und diese notiert ARNs.

## Schritt 6: AWS Rollen hinzufügen zu CodeCatalyst
<a name="deploy-tut-eks-import-roles"></a>

In diesem Schritt fügen Sie die Build-Rolle (`codecatalyst-eks-build-role`) und die Bereitstellungsrolle (`codecatalyst-eks-deploy-role`) zu der Rolle hinzu AWS-Konto , die Sie mit Ihrem Bereich verbunden haben. Dadurch sind die Rollen für die Verwendung in Ihrem Workflow verfügbar.

**Um Build- und Deploy-Rollen zu Ihrem hinzuzufügen AWS-Konto**

1. Navigieren Sie in der CodeCatalyst Konsole zu Ihrem Bereich.

1. Wählen Sie oben **Einstellungen** aus.

1. Wählen Sie im Navigationsbereich **AWS Konten** aus. Eine Liste von Konten wird angezeigt.

1. Kopieren Sie in die Spalte ** CodeCatalyst Amazon-Anzeigename** den Anzeigenamen der AWS-Konto Stelle, in der Sie Ihre Build- und Deploy-Rollen erstellt haben. (Es könnte eine Zahl sein.) Sie benötigen diesen Wert später, wenn Sie Ihren Workflow erstellen.

1. Wählen Sie den Anzeigenamen.

1. Wählen Sie in der ** AWS Managementkonsole die Option Rollen verwalten aus**.

   Die Seite „**IAM-Rolle zu Amazon CodeCatalyst Space hinzufügen**“ wird angezeigt. Möglicherweise müssen Sie sich anmelden, um auf die Seite zuzugreifen.

1. Wählen Sie **Eine bestehende Rolle hinzufügen, die Sie in IAM erstellt haben**.

   Eine Dropdownliste wird angezeigt. In der Liste werden die Build- und Deploy-Rollen sowie alle anderen IAM-Rollen mit einer Vertrauensrichtlinie angezeigt, die auch die Dienstprinzipale `codecatalyst-runner.amazonaws.com` und die `codecatalyst.amazonaws.com` Dienstprinzipale umfasst.

1. Fügen Sie aus der Dropdownliste Folgendes hinzu:
   + `codecatalyst-eks-build-role`
   + `codecatalyst-eks-deploy-role`
**Anmerkung**  
Wenn Sie das sehen`The security token included in the request is invalid`, liegt es möglicherweise daran, dass Sie nicht über die richtigen Berechtigungen verfügen. Um dieses Problem zu beheben, melden Sie sich ab und melden Sie sich mit dem AWS Konto wieder an, das Sie bei der Erstellung Ihres CodeCatalyst Bereichs verwendet haben. AWS 

1. Kehren Sie zur CodeCatalyst Konsole zurück und aktualisieren Sie die Seite.

   Die Rollen Build und Deploy sollten jetzt unter **IAM-Rollen** angezeigt werden.

   Diese Rollen sind jetzt für die Verwendung in CodeCatalyst Workflows verfügbar.

## Schritt 7: Aktualisieren Sie das ConfigMap
<a name="deploy-tut-eks-configmap"></a>

Sie müssen die Bereitstellungsrolle, die Sie in [Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles) der `ConfigMap` Kubernetes-Datei erstellt haben, hinzufügen, damit die **Cluster-Aktion Deploy to Kubernetes (in Ihrem Workflow) auf Ihren Cluster** zugreifen und mit ihm interagieren kann. Sie können `eksctl` oder verwenden, `kubectl` um diese Aufgabe auszuführen.

**Um die ConfigMap Kubernetes-Datei mit eksctl zu konfigurieren**
+ Geben Sie im Dev Environment-Terminal Folgendes ein: 

  ```
  eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
  ```

  Wobei Folgendes gilt:
  + *codecatalyst-eks-cluster*wird durch den Clusternamen des Amazon EKS-Clusters ersetzt.
  +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*wird durch den ARN der Bereitstellungsrolle ersetzt, in der Sie erstellt haben[Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).
  +  *codecatalyst-eks-deploy-role*(neben`--username`) wird durch den Namen der Bereitstellungsrolle ersetzt, in der Sie sie erstellt haben[Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).
**Anmerkung**  
Wenn Sie sich entschieden haben, keine Bereitstellungsrolle zu erstellen, *codecatalyst-eks-deploy-role* ersetzen Sie sie durch den Namen der `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle. Weitere Informationen über diese Rolle finden Sie unter [Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).
  +  *us-west-2*wird durch Ihre Region ersetzt.

  Einzelheiten zu diesem Befehl finden Sie unter [IAM-Benutzer und -Rollen verwalten](https://eksctl.io/usage/iam-identity-mappings/).

  Eine Meldung ähnlich der folgenden wird angezeigt:

  ```
  2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
  2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
  ```

**Um die ConfigMap Kubernetes-Datei mit kubectl zu konfigurieren**

1. Geben Sie im Dev Environment-Terminal Folgendes ein:

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

   Die ConfigMap Datei wird auf dem Bildschirm angezeigt.

1. Fügen Sie den Text in roter Kursivschrift hinzu:

   ```
   # Please edit the object below. Lines beginning with a '#' will be ignored,
   # and an empty file will abort the edit. If an error occurs while saving this file will be
   # reopened with the relevant failures.
   #
   apiVersion: v1
   data:
     mapRoles: |
       - groups:
         - system:bootstrappers
         - system:nodes
         rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
         username: system:node:{{EC2PrivateDNSName}}
       - groups:
         - system:masters
         rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
         username: codecatalyst-eks-deploy-role
     mapUsers: |
       []
   kind: ConfigMap
   metadata:
     creationTimestamp: "2023-06-08T19:04:39Z"
     managedFields:
     ...
   ```

   Wobei Folgendes gilt:
   +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*wird durch den ARN der Bereitstellungsrolle ersetzt, in der Sie erstellt haben[Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles). 
   +  *codecatalyst-eks-deploy-role*(neben`username:`) wird durch den Namen der Bereitstellungsrolle ersetzt, in der Sie sie erstellt haben[Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).
**Anmerkung**  
Wenn Sie sich entschieden haben, keine Bereitstellungsrolle zu erstellen, *codecatalyst-eks-deploy-role* ersetzen Sie sie durch den Namen der `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle. Weitere Informationen über diese Rolle finden Sie unter [Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).

   Einzelheiten finden Sie unter [Aktivieren des IAM-Prinzipalzugriffs auf Ihren Cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) im **Amazon EKS-Benutzerhandbuch**.

Sie haben jetzt der Bereitstellungsrolle und damit der Aktion **Deploy to Amazon EKS** `system:masters` Berechtigungen für Ihren Kubernetes-Cluster erteilt.

## Schritt 8: Erstellen Sie einen Workflow und führen Sie ihn aus
<a name="deploy-tut-eks-workflow"></a>

In diesem Schritt erstellen Sie einen Workflow, der Ihre Quelldateien zu einem Docker-Image zusammenbaut und das Image dann in Tree-Pods in Ihrem Amazon EKS-Cluster bereitstellt.

Der Workflow besteht aus den folgenden Bausteinen, die nacheinander ausgeführt werden:
+ Ein Trigger — Dieser Trigger startet die Workflow-Ausführung automatisch, wenn Sie eine Änderung an Ihr Quell-Repository übertragen. Weitere Informationen zu Auslösern finden Sie unter [Automatisches Starten einer Workflow-Ausführung mithilfe von Triggern](workflows-add-trigger.md).
+ Eine Build-Aktion (`BuildBackend`) — Beim Auslösen erstellt die Aktion das Docker-Image mithilfe der Dockerfile und überträgt das Image an Amazon ECR. Die Build-Aktion aktualisiert auch die `$IMAGE_TAG` Variablen `$REPOSITORY_URI` und in der `deployment.yaml` Datei mit den richtigen Werten und erstellt dann ein Ausgabeartefakt aus dieser Datei und allen anderen Dateien im Ordner. `Kubernetes` In diesem Tutorial ist die einzige Datei im `Kubernetes` Ordner, `deployment.yaml` aber Sie könnten weitere Dateien hinzufügen. Das Artefakt wird als Eingabe für die Bereitstellungsaktion verwendet, die als Nächstes folgt.

  Weitere Informationen zur Build-Aktion finden Sie unter[Bauen mit Workflows](build-workflow-actions.md).
+ Eine Bereitstellungsaktion (`DeployToEKS`) — Nach Abschluss der Build-Aktion sucht die Bereitstellungsaktion nach dem von der Build-Aktion (`Manifests`) generierten Ausgabeartefakt und findet die darin enthaltene `deployment.yaml` Datei. Die Aktion folgt dann den Anweisungen in der `deployment.yaml` Datei, um drei Pods auszuführen, von denen jeder ein einzelnes „Hello, World\$1“ enthält Docker-Container — in Ihrem Amazon EKS-Cluster. 

**So erstellen Sie ein Workflow**

1. Gehen Sie zur Konsole. CodeCatalyst 

1. Navigiere zu deinem Projekt (`codecatalyst-eks-project`).

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie Workflow **erstellen** aus.

1. Wählen Sie für **Quell-Repository** die Option`codecatalyst-eks-source-repository`.

1. Wählen Sie für **Branch** die Option`main`.

1. Wählen Sie **Erstellen** aus.

1. Löschen Sie den YAML-Beispielcode.

1. Fügen Sie den folgenden YAML-Code hinzu, um eine neue Workflow-Definitionsdatei zu erstellen:
**Anmerkung**  
Weitere Informationen zur Workflow-Definitionsdatei finden Sie unter[YAML-Workflow-Definition](workflow-reference.md).
**Anmerkung**  
Im folgenden YAML-Code können Sie die `Connections:` Abschnitte weglassen, wenn Sie möchten. Wenn Sie diese Abschnitte weglassen, müssen Sie sicherstellen, dass die im Feld **Standard-IAM-Rolle angegebene Rolle** in Ihrer Umgebung die Berechtigungen und Vertrauensrichtlinien beider Rollen enthält, die unter beschrieben sind. [Schritt 6: AWS Rollen hinzufügen zu CodeCatalyst](#deploy-tut-eks-import-roles) Weitere Informationen zum Einrichten einer Umgebung mit einer Standard-IAM-Rolle finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)

   ```
   Name: codecatalyst-eks-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo
           - Name: IMAGE_TAG
             Value: ${WorkflowSource.CommitId}
       Configuration:
         Steps:
           #pre_build:
           - Run: echo Logging in to Amazon ECR...
           - Run: aws --version
           - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
           #build:
           - Run: echo Build started on `date`
           - Run: echo Building the Docker image...
           - Run: docker build -t $REPOSITORY_URI:latest .
           - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
           #post_build:
           - Run: echo Build completed on `date`
           - Run: echo Pushing the Docker images...
           - Run: docker push $REPOSITORY_URI:latest
           - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
           # Replace the variables in deployment.yaml
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat Kubernetes/*
           # The output artifact will be a zip file that contains Kubernetes manifest files.
       Outputs:
         Artifacts:
           - Name: Manifests
             Files: 
               - "Kubernetes/*"
     DeployToEKS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/kubernetes-deploy@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-deploy-role
       Inputs:
         Artifacts:
           - Manifests
       Configuration:
         Namespace: default
         Region: us-west-2
         Cluster: codecatalyst-eks-cluster
         Manifests: Kubernetes/
   ```

   Ersetzen Sie im vorherigen Code:
   + Beide Instanzen von *codecatalyst-eks-environment* mit dem Namen der Umgebung, in der Sie erstellt haben[Voraussetzungen](#deploy-tut-eks-prereqs).
   + Beide Instanzen von *codecatalyst-account-connection* mit dem Anzeigenamen Ihrer Kontoverbindung. Der Anzeigename kann eine Zahl sein. Weitere Informationen finden Sie unter [Schritt 6: AWS Rollen hinzufügen zu CodeCatalyst](#deploy-tut-eks-import-roles).
   + *codecatalyst-eks-build-role*mit dem Namen der Build-Rolle, in der Sie sie erstellt haben[Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo*(in der `Value:` Eigenschaft) mit der URI des Amazon ECR-Repositorys, in [Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository](#deploy-tut-eks-ecr) dem Sie es erstellt haben.
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(im `Run: aws ecr` Befehl) mit der URI des Amazon ECR-Repositorys ohne das Bildsuffix ()`/codecatalyst-eks-image-repo`.
   + *codecatalyst-eks-deploy-role*mit dem Namen der Bereitstellungsrolle, in der Sie sie erstellt haben. [Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles)
   + Beide Instanzen von *us-west-2* mit Ihrem AWS Regionalcode. Eine Liste der Regionalcodes finden Sie unter [Regionale Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html) in der *Allgemeine AWS-Referenz*.
**Anmerkung**  
Wenn Sie sich entschieden haben, keine Build- und Deploy-Rollen zu erstellen, ersetzen Sie *codecatalyst-eks-build-role* und *codecatalyst-eks-deploy-role* durch den Namen der `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle. Weitere Informationen über diese Rolle finden Sie unter [Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).

1. (Optional) Wählen Sie „**Validieren**“, um sicherzustellen, dass der YAML-Code gültig ist, bevor Sie ihn festschreiben.

1. Wählen Sie **Commit** (Übergeben).

1. Geben Sie im Dialogfeld „**Workflow bestätigen**“ Folgendes ein:

   1. Entfernen Sie **bei Nachricht bestätigen** den Text und geben Sie Folgendes ein:

      ```
      Add first workflow
      ```

   1. Wählen Sie für **Repository**`codecatalyst-eks-source-repository`.

   1. Wählen Sie als **Branch-Name** die Option main aus.

   1. Wählen Sie **Commit** (Übergeben).

   Sie haben jetzt einen Workflow erstellt. Eine Workflow-Ausführung wird aufgrund des oben im Workflow definierten Triggers automatisch gestartet. Insbesondere, als Sie die `workflow.yaml` Datei in Ihr Quell-Repository übernommen (und per Push übertragen) haben, hat der Trigger die Workflow-Ausführung gestartet.

**Um den Fortschritt der Workflow-Ausführung zu sehen**

1. **Wählen Sie im Navigationsbereich der CodeCatalyst Konsole **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Workflow aus, den Sie gerade erstellt haben,. `codecatalyst-eks-workflow`

1. Wählen Sie **BuildBackend**, ob Sie den Baufortschritt sehen möchten.

1. Wählen Sie **DeployToEKS**, um den Fortschritt der Bereitstellung zu sehen.

   Weitere Informationen zum Anzeigen von Ausführungsdetails finden Sie unter[Status und Details der Workflow-Ausführung anzeigen](workflows-view-run.md).

**Um die Bereitstellung zu überprüfen**

1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie links unten **Load Balancers** aus.

1. Wählen Sie den Load Balancer aus, der als Teil Ihrer Kubernetes-Bereitstellung erstellt wurde. **Wenn Sie sich nicht sicher sind, welchen Load Balancer Sie wählen sollen, suchen Sie auf der Registerkarte „Tags“ nach den folgenden Tags:**
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. Wählen Sie den richtigen Load Balancer aus und wählen Sie den Tab **Beschreibung** aus.

1. Kopieren Sie den **DNS-Namenswert** und fügen Sie ihn in die Adressleiste Ihres Browsers ein.

   Das „Hallo, Welt\$1“ In Ihrem Browser wird eine Webseite angezeigt, die darauf hinweist, dass Sie Ihre Anwendung erfolgreich bereitgestellt haben.

## Schritt 9: Nehmen Sie eine Änderung an Ihren Quelldateien vor
<a name="deploy-tut-eks-change"></a>

In diesem Abschnitt nehmen Sie eine Änderung an der `index.html` Datei in Ihrem Quell-Repository vor. Diese Änderung veranlasst den Workflow, ein neues Docker-Image zu erstellen, es mit einer Commit-ID zu kennzeichnen, es an Amazon ECR weiterzuleiten und es in Amazon ECS bereitzustellen. 

**Um die Datei index.html zu ändern**

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

1. Wechseln Sie an der Terminal-Eingabeaufforderung zu Ihrem Quell-Repository:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  Rufen Sie die neuesten Workflow-Änderungen ab:

   ```
   git pull
   ```

1. Öffnen Sie `codecatalyst-eks-source-repository/public-html/index.html`.

1. Ändern Sie in Zeile 14 den `Hello, World!` Text in`Tutorial complete!`.

1. Hinzufügen, Festschreiben und Push:

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   Eine Workflow-Ausführung wird automatisch gestartet.

1. (Optional) Geben Sie Folgendes ein:

   ```
   git show HEAD
   ```

   Notieren Sie sich die Commit-ID für die `index.html` Änderung. Diese Commit-ID wird dem Docker-Image zugeordnet, das durch die Workflow-Ausführung bereitgestellt wird, die Sie gerade gestartet haben.

1. Beobachten Sie den Fortschritt der Bereitstellung:

   1. **Wählen Sie in der CodeCatalyst Konsole im Navigationsbereich **CI/CD** und dann Workflows aus.**

   1. Wählen Sie`codecatalyst-eks-workflow`, ob Sie die letzte Ausführung anzeigen möchten.

   1. Wählen Sie und **DeployToEKS **BuildBackend****, um den Fortschritt der Workflow-Ausführung zu sehen.

1. Stellen Sie wie folgt sicher, dass Ihre Anwendung aktualisiert wurde:

   1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. Wählen Sie links unten **Load Balancers** aus.

   1. Wählen Sie den Load Balancer aus, der als Teil Ihrer Kubernetes-Bereitstellung erstellt wurde.

   1. Kopieren Sie den **DNS-Namenswert** und fügen Sie ihn in die Adressleiste Ihres Browsers ein.

      Das 'Tutorial ist abgeschlossen\$1 ' In Ihrem Browser wird eine Webseite angezeigt, die darauf hinweist, dass Sie erfolgreich eine neue Version Ihrer Anwendung bereitgestellt haben.

1. (Optional) Wechseln Sie in AWS zur Amazon ECR-Konsole und überprüfen Sie, ob das neue Docker-Image mit der Commit-ID aus Schritt 7 dieses Verfahrens gekennzeichnet wurde.

## Bereinigen
<a name="deploy-tut-eks-cleanup"></a>

Sie sollten Ihre Umgebung bereinigen, damit Ihnen die in diesem Tutorial verwendeten Speicher- und Rechenressourcen nicht unnötig in Rechnung gestellt werden.

**So räumen Sie auf**

1. Löschen Sie Ihren Cluster:

   1. Geben Sie im Dev Environment-Terminal Folgendes ein:

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     Wobei Folgendes gilt:
     + *us-west-2*wird durch Ihre Region ersetzt.
     + *codecatalyst-eks-cluster*wird durch den Namen des Clusters ersetzt, den Sie erstellt haben.

     Nach 5-10 Minuten werden der Cluster und die zugehörigen Ressourcen gelöscht, einschließlich, aber nicht beschränkt auf CloudFormation Stacks, Knotengruppen (in Amazon EC2) und Load Balancer.
**Wichtig**  
Wenn der `eksctl delete cluster` Befehl nicht funktioniert, müssen Sie möglicherweise Ihre AWS Anmeldeinformationen oder Ihre Anmeldeinformationen aktualisieren. `kubectl` Wenn Sie sich nicht sicher sind, welche Anmeldeinformationen Sie aktualisieren sollen, aktualisieren Sie zuerst die AWS Anmeldeinformationen. Informationen zum Aktualisieren Ihrer AWS Anmeldeinformationen finden Sie unter[Wie behebe ich die Fehler „Anmeldeinformationen konnten nicht gefunden werden“ und ExpiredToken „“?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks). Informationen zum Aktualisieren Ihrer `kubectl` Anmeldeinformationen finden Sie unter[Wie behebe ich die Fehler „Es konnte keine Verbindung zum Server hergestellt werden“?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks).

1. Bereinigen Sie in der AWS Konsole wie folgt:

   1. Löschen `codecatalyst-eks-image-repo` Sie in Amazon ECR.

   1. Löschen Sie im IAM Identity Center:

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. Löschen Sie in IAM:
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. Bereinigen Sie in der CodeCatalyst Konsole wie folgt:

   1. Löschen`codecatalyst-eks-workflow`.

   1. Löschen`codecatalyst-eks-environment`.

   1. Löschen`codecatalyst-eks-source-repository`.

   1. Löschen Sie Ihre Entwicklungsumgebung.

   1. Löschen`codecatalyst-eks-project`.

In diesem Tutorial haben Sie gelernt, wie Sie mithilfe eines CodeCatalyst Workflows und einer **Cluster-Aktion „Deploy to Kubernetes“ eine Anwendung für einen Amazon EKS-Service bereitstellen**.

# Aktion „Im Kubernetes-Cluster bereitstellen“ hinzufügen
<a name="deploy-action-eks-adding"></a>

Verwenden Sie die folgenden Anweisungen, um die Aktion „In **Kubernetes-Cluster bereitstellen“ zu Ihrem Workflow** hinzuzufügen. 

**Bevor Sie beginnen**

Bevor Sie Ihrem Workflow die **Cluster-Aktion „In Kubernetes bereitstellen**“ hinzufügen, müssen Sie Folgendes vorbereitet haben:

**Tipp**  
Folgen Sie den Anweisungen unter, um diese Voraussetzungen schnell einzurichten. [Tutorial: Bereitstellen einer Anwendung in Amazon EKS](deploy-tut-eks.md)
+ Ein Kubernetes-Cluster in Amazon EKS. Informationen zu Clustern finden Sie unter [Amazon EKS-Cluster](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) im **Amazon EKS-Benutzerhandbuch**.
+ Mindestens ein Dockerfile, das beschreibt, wie Sie Ihre Anwendung zu einem Docker-Image zusammenstellen. [Weitere Informationen zu Dockerfiles finden Sie in der Dockerfile-Referenz.](https://docs.docker.com/engine/reference/builder/)
+ *Mindestens eine Kubernetes-Manifestdatei, die in der Kubernetes-Dokumentation als *Konfigurationsdatei oder Konfiguration* bezeichnet wird.* Weitere Informationen finden Sie in der [Kubernetes-Dokumentation unter Ressourcen verwalten](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/).
+ Eine IAM-Rolle, die der **Cluster-Aktion Deploy to Kubernetes die Möglichkeit gibt, auf Ihren Amazon EKS-Cluster** zuzugreifen und mit ihm zu interagieren. Weitere Informationen erhalten Sie unter dem Thema [Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role) im [Aktion „Im Kubernetes-Cluster bereitstellen“ YAML](deploy-action-ref-eks.md).

  Nachdem Sie diese Rolle erstellt haben, müssen Sie sie hinzufügen zu:
  + Ihre Kubernetes-Datei ConfigMap . Informationen zum Hinzufügen einer Rolle zu einer ConfigMap Datei finden Sie unter [Aktivieren des IAM-Prinzipalzugriffs auf Ihren Cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) im **Amazon EKS-Benutzerhandbuch**.
  + CodeCatalyst. Informationen zum Hinzufügen einer IAM-Rolle zu finden Sie CodeCatalyst unter[Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md).
+ Ein CodeCatalyst Raum, ein Projekt und eine Umgebung. Der Bereich und die Umgebung müssen beide mit dem AWS Konto verbunden sein, in dem Sie Ihre Anwendung bereitstellen werden. Weitere Informationen finden Sie unter [Erstellen einer Umgebung](spaces-create.md), [Ein leeres Projekt in Amazon erstellen CodeCatalyst](projects-create.md#projects-create-empty) und [Einsatz in AWS-Konten und VPCs](deploy-environments.md).
+ Ein Quell-Repository, das von unterstützt wird CodeCatalyst. Das Repository speichert Ihre Anwendungsquelldateien, Dockerfiles und Kubernetes-Manifeste. Weitere Informationen finden Sie unter [Speichern Sie Code mit Quell-Repositorys in und arbeiten Sie gemeinsam daran CodeCatalystSpeichern Sie Code mit Quell-Repositorys und arbeiten Sie gemeinsam daran](source.md).

------
#### [ Visual ]

**Um die Aktion „Im Kubernetes-Cluster bereitstellen“ mit dem visuellen Editor hinzuzufügen**

1. [Öffnen Sie die Konsole unter https://codecatalyst.aws/. CodeCatalyst ](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie oben links **\$1 Aktionen**, um den Aktionskatalog zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der **Cluster-Aktion Deploy to Kubernetes** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie Auf **Kubernetes-Cluster bereitstellen** aus. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Herunterladen**“, um [den Quellcode der Aktion anzuzeigen](workflows-view-source.md#workflows-view-source.title).
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Füllen Sie auf den Registerkarten **Eingaben** und **Konfiguration** die Felder nach Ihren Bedürfnissen aus. Eine Beschreibung der einzelnen Felder finden Sie unter[Aktion „Im Kubernetes-Cluster bereitstellen“ YAML](deploy-action-ref-eks.md). Diese Referenz enthält detaillierte Informationen zu jedem Feld (und dem entsprechenden YAML-Eigenschaftswert), wie es sowohl im YAML- als auch im visuellen Editor angezeigt wird.

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit** aus.

------
#### [ YAML ]

**Um die Aktion „Im Kubernetes-Cluster bereitstellen“ mit dem YAML-Editor hinzuzufügen**

1. [Öffnen Sie die Konsole unter https://codecatalyst.aws/. CodeCatalyst ](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Wählen Sie links oben **\$1 Aktionen aus, um den Aktionskatalog** zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der **Cluster-Aktion Deploy to Kubernetes** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie Auf **Kubernetes-Cluster bereitstellen** aus. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Herunterladen**“, um [den Quellcode der Aktion anzuzeigen](workflows-view-source.md#workflows-view-source.title).
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Ändern Sie die Eigenschaften im YAML-Code nach Ihren Bedürfnissen. Eine Erläuterung der einzelnen verfügbaren Eigenschaften finden Sie in der[Aktion „Im Kubernetes-Cluster bereitstellen“ YAML](deploy-action-ref-eks.md).

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit** aus.

------

# Variablen „Im Kubernetes-Cluster bereitstellen“
<a name="deploy-action-eks-variables"></a>

Die **Cluster-Aktion „Auf Kubernetes bereitstellen**“ erzeugt und legt zur Laufzeit die folgenden Variablen fest. Diese werden als *vordefinierte* Variablen bezeichnet.

Hinweise zum Verweisen auf diese Variablen in einem Workflow finden Sie unter[Verwenden vordefinierter Variablen](workflows-using-predefined-variables.md).


| Key (Schlüssel) | Value (Wert) | 
| --- | --- | 
|  Cluster  |  Der Amazon.com-Ressourcenname (ARN) des Amazon EKS-Clusters, auf dem während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster`  | 
|  Bereitstellungsplattform  |  Der Name der Bereitstellungsplattform. Fest codiert auf. `AWS:EKS`  | 
|  Metadaten  |  Reserved Instances. Metadaten im JSON-Format, die sich auf den Cluster beziehen, der während der Workflow-Ausführung bereitgestellt wurde.  | 
|  Namespace  |  Der Kubernetes-Namespace, in dem der Cluster bereitgestellt wurde. Beispiel: `default`  | 
|  Ressourcen  |  Reserved Instances. Metadaten im JSON-Format, die sich auf die Ressourcen beziehen, die während der Workflow-Ausführung bereitgestellt wurden.  | 
|  server  |  Der Name des API-Serverendpunkts, den Sie für die Kommunikation mit Ihrem Cluster mithilfe von Verwaltungstools wie verwenden können. `kubectl` Weitere Informationen zum API-Serviceendpunkt finden Sie unter [Zugriffskontrolle für Amazon EKS-Cluster-Endpunkte](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) im **Amazon EKS-Benutzerhandbuch**. Beispiel: `https://random-string.gr7.us-west-2.eks.amazonaws.com`  | 

# Aktion „Im Kubernetes-Cluster bereitstellen“ YAML
<a name="deploy-action-ref-eks"></a>

Im Folgenden finden Sie die YAML-Definition der Cluster-Aktion **Deploy to Kubernetes**. Informationen zur Verwendung dieser Aktion finden Sie unter. [Bereitstellung auf Amazon EKS mit einem Workflow](deploy-action-eks.md)

Diese Aktionsdefinition ist als Abschnitt in einer umfassenderen Workflow-Definitionsdatei vorhanden. Weitere Informationen über diese Datei finden Sie unter [YAML-Workflow-Definition](workflow-reference.md).

**Anmerkung**  
Die meisten der folgenden YAML-Eigenschaften haben entsprechende Benutzeroberflächenelemente im visuellen Editor. Verwenden Sie **Strg\$1F**, um nach einem UI-Element zu suchen. Das Element wird mit der zugehörigen YAML-Eigenschaft aufgelistet.

```
# The workflow definition starts here.
# See Eigenschaften der obersten Ebene for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  DeployToKubernetesCluster\$1nn: 
    Identifier: aws/kubernetes-deploy@v1
    DependsOn:
      - build-action
    Compute:  
        - Type: EC2 | Lambda
        - Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: DeployToEKS
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - manifest-artifact
    Configuration:
      Namespace: namespace
      Region: us-east-1 
      Cluster: eks-cluster
      Manifests: manifest-path
```

## DeployToKubernetesCluster
<a name="deploy.action.eks.name"></a>

(Erforderlich)

Geben Sie den Namen der Aktion an. Alle Aktionsnamen müssen innerhalb des Workflows eindeutig sein. Aktionsnamen sind auf alphanumerische Zeichen (a-z, A-Z, 0-9), Bindestriche (-) und Unterstriche (\$1) beschränkt. Leerzeichen sind nicht erlaubt. Sie können keine Anführungszeichen verwenden, um Sonderzeichen und Leerzeichen in Aktionsnamen zuzulassen.

Standard: `DeployToKubernetesCluster_nn`.

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**Anzeigename der Aktion**

## Identifier
<a name="deploy.action.eks.identifier"></a>

(*DeployToKubernetesCluster*/**Identifier**)

(Erforderlich)

Identifiziert die Aktion. Ändern Sie diese Eigenschaft nur, wenn Sie die Version ändern möchten. Weitere Informationen finden Sie unter [Angabe der zu verwendenden Aktionsversion](workflows-action-versions.md).

Standard: `aws/kubernetes-deploy@v1`.

**Entsprechende Benutzeroberfläche: Workflow-Diagram/ DeployToKubernetesCluster \$1nn/ aws/kubernetes-deploy @v1 label**

## DependsOn
<a name="deploy.action.eks.dependson"></a>

(*DeployToKubernetesCluster*/**DependsOn**)

(Optional)

Geben Sie eine Aktion, eine Aktionsgruppe oder ein Gate an, die erfolgreich ausgeführt werden müssen, damit diese Aktion ausgeführt werden kann.

Weitere Hinweise zur Funktion „Hängt davon ab“ finden Sie unter. [Aktionen sequenzieren](workflows-depends-on.md)

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Hängt davon ab**“ — optional

## Compute
<a name="deploy.action.eks.computename"></a>

(*DeployToKubernetesCluster*/**Compute**)

(Optional)

Die Rechen-Engine, mit der Ihre Workflow-Aktionen ausgeführt wurden. Sie können die Berechnung entweder auf Workflow-Ebene oder auf Aktionsebene angeben, aber nicht beide. Wenn auf Workflow-Ebene angegeben, gilt die Rechenkonfiguration für alle im Workflow definierten Aktionen. Auf Workflow-Ebene können Sie auch mehrere Aktionen auf derselben Instanz ausführen. Weitere Informationen finden Sie unter [Rechenleistung für mehrere Aktionen gemeinsam nutzen](compute-sharing.md).

Entsprechende Benutzeroberfläche: *keine*

## Type
<a name="deploy.action.eks.computetype"></a>

(*DeployToKubernetesCluster*/Compute/**Type**)

([Compute](#deploy.action.eks.computename)Erforderlich, falls enthalten)

Der Typ der Compute Engine. Sie können einen der folgenden Werte verwenden:
+ **EC2** (visueller Editor) oder `EC2` (YAML-Editor)

  Optimiert für Flexibilität bei Aktionsläufen.
+ **Lambda** (visueller Editor) oder `Lambda` (YAML-Editor)

  Optimierte Startgeschwindigkeiten für Aktionen.

Weitere Informationen zu Datentypen finden Sie unter [Berechnungstypen](workflows-working-compute.md#compute.types).

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Berechnungstyp**

## Fleet
<a name="deploy.action.eks.computefleet"></a>

(*DeployToKubernetesCluster*/Compute/**Fleet**)

(Optional)

Geben Sie die Maschine oder Flotte an, auf der Ihr Workflow oder Ihre Workflow-Aktionen ausgeführt werden sollen. Bei bedarfsgesteuerten Flotten stellt der Workflow zu Beginn einer Aktion die benötigten Ressourcen bereit, und die Maschinen werden zerstört, wenn die Aktion abgeschlossen ist. Beispiele für Flotten auf Abruf:`Linux.x86-64.Large`,. `Linux.x86-64.XLarge` Weitere Informationen zu Flotten auf Abruf finden Sie unter. [Eigenschaften von On-Demand-Flotten](workflows-working-compute.md#compute.on-demand)

Bei bereitgestellten Flotten konfigurieren Sie eine Reihe von dedizierten Maschinen, um Ihre Workflow-Aktionen auszuführen. Diese Maschinen bleiben inaktiv und können sofort Aktionen ausführen. Weitere Informationen zu bereitgestellten Flotten finden Sie unter. [Eigenschaften von bereitgestellten Flotten](workflows-working-compute.md#compute.provisioned-fleets)

Wenn nicht angegeben, `Fleet` ist die Standardeinstellung. `Linux.x86-64.Large`

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Compute Fleet**

## Timeout
<a name="deploy.action.eks.timeout"></a>

(*DeployToKubernetesCluster*/**Timeout**)

(Optional)

Geben Sie an, wie lange die Aktion in Minuten (YAML-Editor) oder Stunden und Minuten (visueller Editor) ausgeführt werden kann, bevor die Aktion CodeCatalyst beendet wird. Das Minimum beträgt 5 Minuten und das Maximum ist unter beschrieben[Kontingente für Workflows in CodeCatalyst](workflows-quotas.md). Das Standard-Timeout entspricht dem maximalen Timeout.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Timeout“ — optional**

## Environment
<a name="deploy.action.eks.environment"></a>

(*DeployToKubernetesCluster*/**Environment**)

(Erforderlich)

Geben Sie die CodeCatalyst Umgebung an, die für die Aktion verwendet werden soll. Die Aktion stellt eine Verbindung mit der AWS-Konto optionalen Amazon VPC her, die in der ausgewählten Umgebung angegeben ist. Die Aktion verwendet die in der Umgebung angegebene Standard-IAM-Rolle, um sich mit der Amazon VPC zu verbinden AWS-Konto, und verwendet die in der [Amazon VPC-Verbindung angegebene IAM-Rolle, um eine Verbindung zur Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) herzustellen.

**Anmerkung**  
Wenn die Standard-IAM-Rolle nicht über die für die Aktion erforderlichen Berechtigungen verfügt, können Sie die Aktion so konfigurieren, dass sie eine andere Rolle verwendet. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

Weitere Informationen zu Umgebungen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md) und[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Name
<a name="deploy.action.eks.environment.name"></a>

(*DeployToKubernetesCluster*/Environment/**Name**)

(Erforderlich, falls [Environment](#deploy.action.eks.environment) enthalten)

Geben Sie den Namen einer vorhandenen Umgebung an, die Sie der Aktion zuordnen möchten.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Connections
<a name="deploy.action.eks.environment.connections"></a>

(*DeployToKubernetesCluster*/Environment/**Connections**)

(Optional in neueren Versionen der Aktion; in älteren Versionen erforderlich)

Geben Sie die Kontoverbindung an, die der Aktion zugeordnet werden soll. Sie können unter maximal eine Kontoverbindung angeben`Environment`.

Wenn Sie keine Kontoverbindung angeben:
+ Die Aktion verwendet die AWS-Konto Verbindung und die Standard-IAM-Rolle, die in der Umgebung in der CodeCatalyst Konsole angegeben sind. Informationen zum Hinzufügen einer Kontoverbindung und einer Standard-IAM-Rolle zur Umgebung finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)
+ Die Standard-IAM-Rolle muss die Richtlinien und Berechtigungen enthalten, die für die Aktion erforderlich sind. **Informationen zu diesen Richtlinien und Berechtigungen finden Sie in der Beschreibung der Role-Eigenschaft in der YAML-Definitionsdokumentation der Aktion.**

Weitere Informationen zu Kontoverbindungen finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md). Hinweise zum Hinzufügen einer Kontoverbindung zu einer Umgebung finden Sie unter[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Name
<a name="deploy.action.eks.environment.connections.name"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Name**)

(Optional)

Geben Sie den Namen der Kontoverbindung an.

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Role
<a name="deploy.action.eks.environment.connections.role"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Role**)

(Erforderlich, falls enthalten[Connections](#deploy.action.eks.environment.connections))

Geben Sie den Namen der IAM-Rolle an, auf die die **Clusteraktion Deploy to Kubernetes** zugreift. AWS Stellen Sie sicher, dass Sie [die Rolle zu Ihrem CodeCatalyst Bereich hinzugefügt](ipa-connect-account-addroles.md) haben und dass die Rolle die folgenden Richtlinien enthält.

Wenn Sie keine IAM-Rolle angeben, verwendet die Aktion die Standard-IAM-Rolle, die in der [Umgebung](deploy-environments.md) in der CodeCatalyst Konsole aufgeführt ist. Wenn Sie die Standardrolle in der Umgebung verwenden, stellen Sie sicher, dass sie über die folgenden Richtlinien verfügt.
+ Die folgende Berechtigungsrichtlinie:
**Warnung**  
Beschränken Sie die Berechtigungen auf die in der folgenden Richtlinie angegebenen. Die Verwendung einer Rolle mit umfassenderen Berechtigungen kann ein Sicherheitsrisiko darstellen.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**Anmerkung**  
Wenn die Rolle zum ersten Mal verwendet wird, verwenden Sie den folgenden Platzhalter in der Ressourcenrichtlinienanweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

  ```
  "Resource": "*"
  ```
+ Die folgende benutzerdefinierte Vertrauensrichtlinie:

Stellen Sie sicher, dass diese Rolle hinzugefügt wurde zu:
+ Ihre Kontoverbindung. Weitere Informationen zum Hinzufügen einer IAM-Rolle zu einer Kontoverbindung finden Sie unter[Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md).
+ Ihr Kubernetes ConfigMap. Weitere Informationen zum Hinzufügen einer IAM-Rolle zu einer ConfigMap finden Sie in der Dokumentation unter [Verwalten von IAM-Benutzern und -Rollen](https://eksctl.io/usage/iam-identity-mappings/). `eksctl`

**Tipp**  
Anweisungen [Tutorial: Bereitstellen einer Anwendung in Amazon EKS](deploy-tut-eks.md) zum Hinzufügen einer IAM-Rolle zu einer Kontoverbindung finden Sie auch unter. ConfigMap

**Anmerkung**  
Sie können die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle mit dieser Aktion verwenden, wenn Sie möchten. Weitere Informationen über diese Rolle finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über volle Zugriffsberechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. 

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte Environment/account/role „Konfiguration“ /' '/ Rolle**

## Inputs
<a name="deploy.action.eks.inputs"></a>

(*DeployToKubernetesCluster*/**Inputs**)

(Erforderlich, falls enthalten[Connections](#deploy.action.eks.environment.connections))

`Inputs`In diesem Abschnitt werden die Daten definiert, die während einer Workflow-Ausführung `DeployToKubernetesCluster` benötigt werden.

**Anmerkung**  
Pro Aktion „In **Amazon EKS bereitstellen**“ ist nur eine Eingabe (entweder eine Quelle oder ein Artefakt) zulässig.

Entsprechende Benutzeroberfläche: Registerkarte „**Eingaben**“

## Sources
<a name="deploy.action.eks.inputs.sources"></a>

(*DeployToKubernetesCluster*/Inputs/**Sources**)

(Erforderlich, wenn Ihre Manifestdatei in einem Quell-Repository gespeichert ist)

Wenn Ihre Kubernetes-Manifestdatei (en) in einem Quell-Repository gespeichert sind, geben Sie die Bezeichnung dieses Quell-Repositorys an. Derzeit ist das einzige unterstützte Label. `WorkflowSource`

Wenn Ihre Manifestdateien nicht in einem Quell-Repository enthalten sind, müssen sie sich in einem Artefakt befinden, das durch eine andere Aktion generiert wurde.

Weitere Informationen zu Quellen finden Sie unter [Quell-Repositorys mit Workflows verbinden](workflows-sources.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„Quellen“ — optional**

## Artifacts - input
<a name="deploy.action.eks.inputs.artifacts"></a>

(*DeployToKubernetesCluster*/Inputs/**Artifacts**)

(Erforderlich, wenn Ihre Manifestdatei in einem [Ausgabeartefakt](workflows-working-artifacts-output.md) einer früheren Aktion gespeichert ist)

Wenn die Kubernetes-Manifestdatei (en) in einem Artefakt enthalten sind, das durch eine vorherige Aktion generiert wurde, geben Sie dieses Artefakt hier an. Wenn Ihre Manifestdateien nicht in einem Artefakt enthalten sind, müssen sie sich in Ihrem Quell-Repository befinden.

Weitere Informationen zu Artefakten, einschließlich Beispielen, finden Sie unter. [Artefakte und Dateien zwischen Aktionen teilen](workflows-working-artifacts.md)

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/„**Artefakte“ — optional**

## Configuration
<a name="deploy.action.eks.configuration"></a>

(*DeployToKubernetesCluster*/**Configuration**)

(Erforderlich)

Ein Abschnitt, in dem Sie die Konfigurationseigenschaften der Aktion definieren können.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration**“

## Namespace
<a name="deploy.action.eks.namespace"></a>

(*DeployToKubernetesCluster*/Configuration/**Namespace**)

(Optional)

Geben Sie den Kubernetes-Namespace an, in dem Ihre Kubernetes-Anwendung bereitgestellt wird. Verwenden Sie diese Option`default`, wenn Sie in Ihrem Cluster keine Namespaces verwenden. Weitere Informationen zu Namespaces finden Sie in der Kubernetes-Dokumentation unter [Unterteilung Ihres Clusters mithilfe](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces) von Kubernetes-Namespaces.

Wenn Sie den Namespace weglassen, wird der Wert von verwendet. `default`

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Namespace“**

## Region
<a name="deploy.action.eks.region"></a>

(*DeployToKubernetesCluster*/Configuration/**Region**)

(Erforderlich)

Geben Sie die AWS Region an, in der sich Ihr Amazon EKS-Cluster und -Service befinden. Eine Liste der Regionscodes finden Sie unter [Regionale Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes) in der. *Allgemeine AWS-Referenz*

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Region“**

## Cluster
<a name="deploy.action.eks.cluster"></a>

(*DeployToKubernetesCluster*/Configuration/**Cluster**)

(Erforderlich)

Geben Sie den Namen eines vorhandenen Amazon EKS-Clusters an. Mit der Aktion „**Auf Kubernetes-Cluster** bereitstellen“ wird Ihre containerisierte Anwendung in diesem Cluster bereitgestellt. Weitere Informationen zu Amazon EKS-Clustern finden Sie unter [Clusters](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) im **Amazon EKS-Benutzerhandbuch**.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Cluster“**

## Manifests
<a name="deploy.action.eks.manifest"></a>

(*DeployToKubernetesCluster*/Configuration/**Manifests**)

(Erforderlich)

*Geben Sie den Pfad zu Ihren Kubernetes-Manifestdateien im YAML-Format an, die in der Kubernetes-Dokumentation als *Konfigurationsdateien, *Konfigurationsdateien* oder einfach als Konfigurationen* bezeichnet werden.*

Wenn Sie mehrere Manifestdateien verwenden, platzieren Sie sie in einem einzigen Ordner und verweisen Sie auf diesen Ordner. Manifestdateien werden von Kubernetes alphanumerisch verarbeitet. Stellen Sie daher sicher, dass Sie Dateinamen mit steigenden Zahlen oder Buchstaben voranstellen, um die Verarbeitungsreihenfolge zu kontrollieren. Beispiel:

`00-namespace.yaml`

`01-deployment.yaml`

Wenn sich Ihre Manifestdateien in Ihrem Quell-Repository befinden, ist der Pfad relativ zum Stammordner des Quell-Repositorys. Wenn sich die Dateien in einem Artefakt aus einer früheren Workflow-Aktion befinden, ist der Pfad relativ zum Artefakt-Stammordner. 

Beispiele:

`Manifests/`

`deployment.yaml`

`my-deployment.yml`

Verwenden Sie keine Platzhalter (). `*`

**Anmerkung**  
[Helm-Diagramme](https://helm.sh/docs/topics/charts/) und [Anpassungsdateien](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/) werden nicht unterstützt.

Weitere Informationen zu Manifestdateien finden Sie in der [Kubernetes-Dokumentation unter Organisieren von Ressourcenkonfigurationen](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Manifeste“**

# Einen CloudFormation Stack bereitstellen
<a name="deploy-action-cfn"></a>

In diesem Abschnitt wird beschrieben, wie Sie einen AWS CloudFormation Stack mithilfe eines CodeCatalyst Workflows bereitstellen. Um dies zu erreichen, müssen Sie Ihrem Workflow die Aktion ** CloudFormation Stack bereitstellen** hinzufügen. Die Aktion stellt einen CloudFormation Stapel von Ressourcen bereit, der auf einer von Ihnen bereitgestellten Vorlage AWS basiert. Die Vorlage kann eine sein:
+ CloudFormation Vorlage — Weitere Informationen finden Sie unter [Mit CloudFormation Vorlagen arbeiten](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html).
+ AWS SAM Vorlage — Weitere Informationen finden Sie in der [AWS Serverless Application Model (AWS SAM) -Spezifikation](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html).
**Anmerkung**  
Um eine AWS SAM Vorlage verwenden zu können, müssen Sie zuerst Ihre AWS SAM Anwendung mithilfe des `[sam package](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)` Vorgangs paketieren. Ein Tutorial, das Ihnen zeigt, wie Sie dieses Verpacken im Rahmen eines CodeCatalyst Amazon-Workflows automatisch durchführen, finden Sie unter[Tutorial: Eine serverlose Anwendung bereitstellen](deploy-tut-lambda.md).

Wenn der Stapel bereits vorhanden ist, führt die Aktion den CloudFormation `[CreateChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html)` Vorgang und dann den `[ExecuteChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html)` Vorgang aus. Die Aktion wartet dann auf die Bereitstellung der Änderungen und markiert sich je nach Ergebnis entweder als erfolgreich oder als fehlgeschlagen.

Verwenden Sie die Aktion ** CloudFormation Stack bereitstellen**, wenn Sie bereits über eine CloudFormation AWS SAM Oder-Vorlage verfügen, die Ressourcen enthält, die Sie bereitstellen möchten, oder wenn Sie planen, im Rahmen einer [Workflow-Build-Aktion](build-add-action.md) mithilfe von Tools wie AWS SAM und [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)automatisch eine Vorlage zu generieren.

Es gibt keine Einschränkungen hinsichtlich der Vorlage, die Sie verwenden können — unabhängig davon, welche Vorlage Sie verwenden können, CloudFormation oder die AWS SAM Sie zusammen mit der Aktion „** CloudFormation Stack bereitstellen**“ verwenden können.

**Tipp**  
Ein Tutorial, das Ihnen zeigt, wie Sie eine serverlose Anwendung mithilfe der Aktion „** CloudFormation Stack bereitstellen“ bereitstellen**, finden Sie unter. [Tutorial: Eine serverlose Anwendung bereitstellen](deploy-tut-lambda.md)

**Topics**
+ [Runtime-Image, das von der Aktion „Stack bereitstellen“ CloudFormation verwendet wird](#deploy-action-cfn-runtime)
+ [Tutorial: Eine serverlose Anwendung bereitstellen](deploy-tut-lambda.md)
+ [Aktion „ CloudFormation Stapel bereitstellen“ hinzufügen](deploy-action-cfn-adding.md)
+ [Rollbacks konfigurieren](deploy-consumption-enable-alarms.md)
+ [CloudFormation 'Stack'-Variablen bereitstellen](deploy-action-cfn-variables.md)
+ [Aktion CloudFormation 'Stack bereitstellen' YAML](deploy-action-ref-cfn.md)

## Runtime-Image, das von der Aktion „Stack bereitstellen“ CloudFormation verwendet wird
<a name="deploy-action-cfn-runtime"></a>

Die Aktion ** CloudFormation Stack bereitstellen** wird auf einem [Image vom November 2022](build-images.md#build.previous-image) ausgeführt. Weitere Informationen finden Sie unter [Aktive Bilder](build-images.md#build-curated-images).

# Tutorial: Eine serverlose Anwendung bereitstellen
<a name="deploy-tut-lambda"></a>

In diesem Tutorial erfahren Sie, wie Sie mithilfe eines Workflows eine serverlose Anwendung als CloudFormation Stack erstellen, testen und bereitstellen.

Die Anwendung in diesem Tutorial ist eine einfache Webanwendung, die eine „Hello World“ -Nachricht ausgibt. Es besteht aus einer AWS Lambda Funktion und einem Amazon API Gateway, und Sie erstellen es mit der [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html), einer Erweiterung von [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).

**Topics**
+ [Voraussetzungen](#deploy-tut-lambda-cfn-prereqs)
+ [Schritt 1: Erstellen Sie ein Quell-Repository](#deploy-tut-lambda-cfn-source)
+ [Schritt 2: AWS Rollen erstellen](#deploy-tut-lambda-cfn-roles)
+ [Schritt 3: AWS Rollen hinzufügen CodeCatalyst](#deploy-tut-lambda-cfn-roles-add)
+ [Schritt 4: Erstellen Sie einen Amazon S3 S3-Bucket](#deploy-tut-lambda-cfn-s3)
+ [Schritt 5: Quelldateien hinzufügen](#deploy-tut-lambda-cfn-files)
+ [Schritt 6: Einen Workflow erstellen und ausführen](#deploy-tut-lambda-cfn-workflow)
+ [Schritt 7: Nehmen Sie eine Änderung vor](#deploy-tut-lambda-cfn-change)
+ [Bereinigen](#deploy-tut-lambda-cfn-clean-up)

## Voraussetzungen
<a name="deploy-tut-lambda-cfn-prereqs"></a>

Bevor Sie beginnen:
+ Sie benötigen einen CodeCatalyst **Bereich** mit einem verbundenen AWS Konto. Weitere Informationen finden Sie unter [Erstellen einer Umgebung](spaces-create.md).
+ In Ihrem Bereich benötigen Sie ein leeres Projekt mit dem Namen:

  ```
  codecatalyst-cfn-project
  ```

  Verwenden Sie die Option **Von vorne beginnen**, um dieses Projekt zu erstellen.

  Weitere Informationen finden Sie unter [Ein leeres Projekt in Amazon erstellen CodeCatalyst](projects-create.md#projects-create-empty).
+ In Ihrem Projekt benötigen Sie eine CodeCatalyst **Umgebung** mit dem Namen:

  ```
  codecatalyst-cfn-environment
  ```

  Konfigurieren Sie diese Umgebung wie folgt:
  + Wählen Sie einen beliebigen Typ, z. B. „Keine **Produktion**“.
  + Connect dein AWS Konto damit.
  + Wählen Sie für die **Standard-IAM-Rolle eine** beliebige Rolle aus. Sie werden später eine andere Rolle angeben.

  Weitere Informationen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md).

## Schritt 1: Erstellen Sie ein Quell-Repository
<a name="deploy-tut-lambda-cfn-source"></a>

In diesem Schritt erstellen Sie ein Quell-Repository in CodeCatalyst. Dieses Repository wird verwendet, um die Quelldateien des Tutorials zu speichern, z. B. die Lambda-Funktionsdatei. 

Weitere Hinweise zu Quell-Repositorys finden Sie unter. [Erstellen eines Quell-Repositorys](source-repositories-create.md)

**Um ein Quell-Repository zu erstellen**

1. Wählen Sie im Navigationsbereich **Code** und dann **Quell-Repositories** aus. CodeCatalyst 

1. Wählen **Sie Repository hinzufügen** und anschließend **Repository erstellen** aus.

1. Geben Sie im Feld **Repository-Name** Folgendes ein:

   ```
   codecatalyst-cfn-source-repository
   ```

1. Wählen Sie **Erstellen** aus.

Sie haben jetzt ein Repository mit dem Namen erstellt`codecatalyst-cfn-source-repository`.

## Schritt 2: AWS Rollen erstellen
<a name="deploy-tut-lambda-cfn-roles"></a>

In diesem Schritt erstellen Sie die folgenden AWS IAM-Rollen:
+ **Rolle bereitstellen** — Erteilt der Aktion „** CloudFormation Stack CodeCatalyst bereitstellen**“ die Berechtigung, auf Ihr AWS Konto und Ihren CloudFormation Dienst zuzugreifen, in dem Sie Ihre serverlose Anwendung bereitstellen werden. Die Aktion ** CloudFormation Stack bereitstellen** ist Teil Ihres Workflows.
+ **Build-Rolle** — Erteilt der CodeCatalyst Build-Aktion die Berechtigung, auf Ihr AWS Konto zuzugreifen und in Amazon S3 zu schreiben, wo Ihr serverloses Anwendungspaket gespeichert wird. Die Build-Aktion ist Teil Ihres Workflows.
+ **Stack-Rolle** — Erteilt die CloudFormation Berechtigung zum Lesen und Ändern der Ressourcen, die in der AWS SAM Vorlage angegeben sind, die Sie später bereitstellen werden. Erteilt auch die Erlaubnis für CloudWatch.

Weitere Informationen zu IAM-Rollen finden Sie unter [IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) im *AWS Identity and Access Management Benutzerhandbuch*.

**Anmerkung**  
Um Zeit zu sparen, können Sie anstelle der drei zuvor aufgeführten Rollen eine einzelne `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle, die so genannte Rolle, erstellen. Weitere Informationen finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über sehr umfangreiche Berechtigungen verfügt, die ein Sicherheitsrisiko darstellen können. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. In diesem Tutorial wird davon ausgegangen, dass Sie die drei zuvor aufgeführten Rollen erstellen.

**Anmerkung**  
Eine [Lambda-Ausführungsrolle](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) ist ebenfalls erforderlich, aber Sie müssen sie jetzt nicht erstellen, da die `sam-template.yml` Datei sie für Sie erstellt, wenn Sie den Workflow in Schritt 5 ausführen.



**Um eine Bereitstellungsrolle zu erstellen**

1. Erstellen Sie wie folgt eine Richtlinie für die Rolle:

   1. Melden Sie sich an bei AWS.

   1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

   1. Wählen Sie im Navigationsbereich **Richtlinien**.

   1. Wählen Sie **Richtlinie erstellen** aus.

   1. Wählen Sie den Tab **JSON**.

   1. Löschen Sie den vorhandenen Code.

   1. Fügen Sie folgenden Code ein:
**Anmerkung**  
Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

      ```
      "Resource": "*"
      ```

   1. Wählen Sie **Next: Tags** (Weiter: Tags) aus.

   1. Klicken Sie auf **Weiter: Prüfen**.

   1. Geben Sie im Feld **Name** Folgendes ein:

      ```
      codecatalyst-deploy-policy
      ```

   1. Wählen Sie **Richtlinie erstellen** aus.

      Sie haben jetzt eine Berechtigungsrichtlinie erstellt.

1. Erstellen Sie die Bereitstellungsrolle wie folgt:

   1. Wählen Sie im Navigationsbereich **Rollen** und dann **Rolle erstellen**.

   1. Wählen Sie **Benutzerdefinierte Vertrauensrichtlinie**.

   1. Löschen Sie die bestehende benutzerdefinierte Vertrauensrichtlinie.

   1. Fügen Sie die folgende benutzerdefinierte Vertrauensrichtlinie hinzu:

   1. Wählen Sie **Weiter** aus.

   1. Suchen Sie **unter Berechtigungsrichtlinien** nach dem entsprechenden Kontrollkästchen `codecatalyst-deploy-policy` und aktivieren Sie es.

   1. Wählen Sie **Weiter** aus.

   1. Geben Sie **als Rollenname** Folgendes ein:

      ```
      codecatalyst-deploy-role
      ```

   1. Geben Sie **als Rollenbeschreibung** Folgendes ein:

      ```
      CodeCatalyst deploy role
      ```

   1. Wählen Sie **Rolle erstellen** aus.

   Sie haben jetzt eine Bereitstellungsrolle mit einer Vertrauensrichtlinie und einer Berechtigungsrichtlinie erstellt.

1. Rufen Sie den ARN für die Bereitstellungsrolle wie folgt ab:

   1. Wählen Sie im Navigationsbereich **Rollen**.

   1. Geben Sie im Suchfeld den Namen der Rolle ein, die Sie gerade erstellt haben (`codecatalyst-deploy-role`).

   1. Wählen Sie die Rolle aus der Liste aus.

      Die **Übersichtsseite** der Rolle wird angezeigt.

   1. Kopieren Sie oben den **ARN-Wert**.

   Sie haben jetzt die Bereitstellungsrolle mit den entsprechenden Berechtigungen erstellt und ihren ARN abgerufen.

**Um eine Build-Rolle zu erstellen**

1. Erstellen Sie wie folgt eine Richtlinie für die Rolle:

   1. Melden Sie sich an bei AWS.

   1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

   1. Wählen Sie im Navigationsbereich **Richtlinien**.

   1. Wählen Sie **Richtlinie erstellen** aus.

   1. Wählen Sie den Tab **JSON**.

   1. Löschen Sie den vorhandenen Code.

   1. Fügen Sie folgenden Code ein:
**Anmerkung**  
Wenn die Rolle zum ersten Mal zum Ausführen von Workflow-Aktionen verwendet wird, verwenden Sie den Platzhalter in der Ressourcenrichtlinien-Anweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

      ```
      "Resource": "*"
      ```

   1. Wählen Sie **Next: Tags** (Weiter: Tags) aus.

   1. Klicken Sie auf **Weiter: Prüfen**.

   1. Geben Sie im Feld **Name** Folgendes ein:

      ```
      codecatalyst-build-policy
      ```

   1. Wählen Sie **Richtlinie erstellen** aus.

      Sie haben jetzt eine Berechtigungsrichtlinie erstellt.

1. Erstellen Sie die Build-Rolle wie folgt:

   1. Wählen Sie im Navigationsbereich **Rollen** und dann **Rolle erstellen**.

   1. Wählen Sie **Benutzerdefinierte Vertrauensrichtlinie**.

   1. Löschen Sie die bestehende benutzerdefinierte Vertrauensrichtlinie.

   1. Fügen Sie die folgende benutzerdefinierte Vertrauensrichtlinie hinzu:

   1. Wählen Sie **Weiter** aus.

   1. Suchen Sie **unter Berechtigungsrichtlinien** nach dem entsprechenden Kontrollkästchen `codecatalyst-build-policy` und aktivieren Sie es.

   1. Wählen Sie **Weiter** aus.

   1. Geben Sie **als Rollenname** Folgendes ein:

      ```
      codecatalyst-build-role
      ```

   1. Geben Sie **als Rollenbeschreibung** Folgendes ein:

      ```
      CodeCatalyst build role
      ```

   1. Wählen Sie **Rolle erstellen** aus.

   Sie haben jetzt eine Build-Rolle mit einer Vertrauensrichtlinie und einer Berechtigungsrichtlinie erstellt.

1. Rufen Sie den ARN für die Build-Rolle wie folgt ab:

   1. Wählen Sie im Navigationsbereich **Rollen**.

   1. Geben Sie im Suchfeld den Namen der Rolle ein, die Sie gerade erstellt haben (`codecatalyst-build-role`).

   1. Wählen Sie die Rolle aus der Liste aus.

      Die **Übersichtsseite** der Rolle wird angezeigt.

   1. Kopieren Sie oben den **ARN-Wert**.

   Sie haben jetzt die Build-Rolle mit den entsprechenden Berechtigungen erstellt und ihren ARN abgerufen.<a name="deploy-tut-lambda-cfn-roles-stack"></a>

**Um eine Stack-Rolle zu erstellen**

1. Melden Sie sich AWS mit dem Konto an, in dem Sie Ihren Stack bereitstellen möchten.

1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

1. Erstellen Sie die Stack-Rolle wie folgt:

   1. Wählen Sie im Navigationsbereich **Rollen** aus.

   1. Wählen Sie **Create role** (Rolle erstellen) aus.

   1. Wählen Sie einen **AWS -Service** aus.

   1. Wählen **Sie im Abschnitt Anwendungsfall** eine Option **CloudFormation**aus der Drop-down-Liste aus.

   1. Wählen Sie das Optionsfeld **CloudFormation**.

   1. Wählen Sie unten **Weiter** aus.

   1. Suchen Sie mithilfe des Suchfeldes nach den folgenden Berechtigungsrichtlinien und aktivieren Sie dann die entsprechenden Kontrollkästchen.
**Anmerkung**  
Wenn Sie nach einer Richtlinie suchen und sie nicht angezeigt wird, wählen Sie **Filter löschen** aus und versuchen Sie es erneut.
      + **CloudWatchFullAccess**
      + **AWS CloudFormationFullAccess**
      + **IAMFullAccess**
      + **AWS Lambda\$1 FullAccess**
      + **APIGatewayAmazon-Administrator**
      + **Amazon S3 FullAccess**
      + **AmazonEC2ContainerRegistryFullAccess**

      Die erste Richtlinie ermöglicht den Zugriff auf Stack-Rollbacks, CloudWatch um Stack-Rollbacks zu aktivieren, wenn ein Alarm auftritt.

      Die verbleibenden Richtlinien ermöglichen den AWS SAM Zugriff auf die Dienste und Ressourcen im Stack, die in diesem Tutorial bereitgestellt werden. Weitere Informationen finden Sie unter [Berechtigungen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-permissions.html) im *AWS Serverless Application Model Entwicklerhandbuch*.

   1. Wählen Sie **Weiter** aus.

   1. Geben Sie **als Rollenname** Folgendes ein:

      ```
      codecatalyst-stack-role
      ```

   1. Wählen Sie **Rolle erstellen** aus.

1. Rufen Sie den ARN der Stack-Rolle wie folgt ab:

   1. Wählen Sie im Navigationsbereich **Rollen**.

   1. Geben Sie im Suchfeld den Namen der Rolle ein, die Sie gerade erstellt haben (`codecatalyst-stack-role`).

   1. Wählen Sie die Rolle aus der Liste aus.

   1. Kopieren Sie im Abschnitt **Zusammenfassung** den **ARN-Wert**. Sie benötigen sie später.

   Sie haben jetzt die Stack-Rolle mit den entsprechenden Berechtigungen erstellt und ihren ARN abgerufen.

## Schritt 3: AWS Rollen hinzufügen CodeCatalyst
<a name="deploy-tut-lambda-cfn-roles-add"></a>

In diesem Schritt fügen Sie der CodeCatalyst Kontoverbindung in Ihrem Bereich die Build-Rolle (`codecatalyst-build-role``codecatalyst-deploy-role`) und die Bereitstellungsrolle () hinzu.

**Anmerkung**  
Sie müssen die Stack-Rolle (`codecatalyst-stack-role`) nicht zur Verbindung hinzufügen. Das liegt daran, dass die Stack-Rolle von *CloudFormation*(nicht CodeCatalyst) verwendet wird, *nachdem* bereits eine Verbindung zwischen CodeCatalyst und AWS unter Verwendung der Deploy-Rolle hergestellt wurde. Da die Stack-Rolle nicht für den CodeCatalyst Zugriff verwendet wird AWS, muss sie keiner Kontoverbindung zugeordnet werden.

**Um Ihrer Kontoverbindung Rollen hinzuzufügen, zu erstellen und bereitzustellen**

1. Navigieren CodeCatalyst Sie darin zu Ihrem Bereich.

1. Wählen Sie **AWS accounts (-Konten)**. Eine Liste der Kontoverbindungen wird angezeigt.

1. Wählen Sie die Kontoverbindung aus, die dem AWS Konto entspricht, in dem Sie Ihre Build- und Deploy-Rollen erstellt haben.

1. Wählen Sie in der ** AWS Managementkonsole die Option Rollen verwalten aus**.

   Die Seite „**IAM-Rolle zu Amazon CodeCatalyst Space hinzufügen**“ wird angezeigt. Möglicherweise müssen Sie sich anmelden, um auf die Seite zuzugreifen.

1. Wählen Sie **Eine bestehende Rolle hinzufügen, die Sie in IAM erstellt haben**.

   Eine Dropdownliste wird angezeigt. In der Liste werden alle IAM-Rollen mit einer Vertrauensrichtlinie angezeigt, die die Dienstprinzipale `codecatalyst-runner.amazonaws.com` und die `codecatalyst.amazonaws.com` Dienstprinzipale umfasst.

1. Wählen Sie in der Dropdownliste die Option und `codecatalyst-build-role` anschließend Rolle **hinzufügen** aus.

1. Wählen Sie **IAM-Rolle hinzufügen** aus, wählen Sie **Vorhandene Rolle hinzufügen, die Sie in IAM erstellt haben**, und wählen Sie in der Drop-down-Liste die Option aus. `codecatalyst-deploy-role` Wählen Sie **Rolle hinzufügen** aus.

   Sie haben jetzt die Build- und Deploy-Rollen zu Ihrem Bereich hinzugefügt.

1. Kopieren Sie den Wert des ** CodeCatalyst Amazon-Anzeigenamens**. Sie benötigen diesen Wert später, wenn Sie Ihren Workflow erstellen.

## Schritt 4: Erstellen Sie einen Amazon S3 S3-Bucket
<a name="deploy-tut-lambda-cfn-s3"></a>

In diesem Schritt erstellen Sie einen Amazon S3 S3-Bucket, in dem Sie die ZIP-Datei des Bereitstellungspakets Ihrer serverlosen Anwendung speichern.

**So erstellen Sie einen Amazon-S3-Bucket**

1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Wählen Sie im Hauptbereich **Create Bucket** aus.

1. Geben Sie als **Bucket-Namen** Folgendes ein:

   ```
   codecatalyst-cfn-s3-bucket
   ```

1. Wählen Sie unter **AWS -Region** eine Region aus. In diesem Tutorial wird davon ausgegangen, dass Sie **US West (Oregon) us-west-2** ausgewählt haben. Informationen zu den von Amazon S3 unterstützten Regionen finden Sie unter [Amazon Simple Storage Service-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/s3.html) in der *Allgemeine AWS-Referenz*.

1. Wählen Sie unten auf der Seite die Option **Bucket erstellen** aus.

Sie haben jetzt einen Bucket mit dem Namen **codecatalyst-cfn-s3-bucket** in der Region USA West (Oregon) us-west-2 erstellt.

## Schritt 5: Quelldateien hinzufügen
<a name="deploy-tut-lambda-cfn-files"></a>

In diesem Schritt fügen Sie Ihrem CodeCatalyst Quell-Repository mehrere Anwendungsquelldateien hinzu. Der `hello-world` Ordner enthält die Anwendungsdateien, die Sie bereitstellen werden. Der `tests` Ordner enthält Komponententests. Die Ordnerstruktur ist wie folgt:

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

### .npmignore-Datei
<a name="deploy-tut-lambda-cfn-files-npmignore"></a>

Die `.npmignore` Datei gibt an, welche Dateien und Ordner npm aus dem Anwendungspaket ausschließen soll. In diesem Tutorial schließt npm den `tests` Ordner aus, da er nicht Teil der Anwendung ist.

**Um die Datei „.npmignore“ hinzuzufügen**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wähle dein Projekt, `codecatalyst-cfn-project`

1. Wählen Sie im Navigationsbereich **Code** und dann **Quell-Repositories** aus.

1. Wählen Sie aus der Liste der Quell-Repositorys Ihr Repository aus. `codecatalyst-cfn-source-repository` 

1. Wählen Sie unter **Dateien** die Option **Datei erstellen** aus.

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   .npmignore
   ```

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   tests/*
   ```

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Sie haben jetzt eine Datei mit dem Namen `.npmignore` im Stammverzeichnis Ihres Repositorys erstellt.

### package.json-Datei
<a name="deploy-tut-lambda-cfn-files-package-json"></a>

Die `package.json` Datei enthält wichtige Metadaten zu Ihrem Node-Projekt wie Projektname, Versionsnummer, Beschreibung, Abhängigkeiten und andere Details, die beschreiben, wie Sie mit Ihrer Anwendung interagieren und sie ausführen.

Die `package.json` in diesem Tutorial enthaltene Liste enthält eine Liste von Abhängigkeiten und ein `test` Skript. Das Testskript macht Folgendes:
+ Unter Verwendung von [Mocha](https://mochajs.org/) führt das Testskript die in angegebenen Komponententests aus `hello-world/tests/unit/` und schreibt die Ergebnisse mithilfe des [Xunit-Reporters]() in eine `junit.xml` Datei.
+ [Unter Verwendung von [Istanbul (NYC)](https://istanbul.js.org/) generiert das Testskript mithilfe des Clover Reporters einen Bericht über die Codeabdeckung (`clover.xml`).](https://openclover.org/doc/manual/4.2.0/general--about-openclover.html) Weitere Informationen finden Sie in der [Istanbul-Dokumentation unter Verwenden alternativer Reporter](https://istanbul.js.org/docs/advanced/alternative-reporters/#clover).

**Um die Datei package.json hinzuzufügen**

1. **Wählen Sie in Ihrem Repository unter **Dateien** die Option Datei erstellen aus.**

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   package.json
   ```

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   {
     "name": "hello_world",
     "version": "1.0.0",
     "description": "hello world sample for NodeJS",
     "main": "app.js",
     "repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
     "author": "SAM CLI",
     "license": "MIT",
     "dependencies": {
       "axios": "^0.21.1",
       "nyc": "^15.1.0"
     },
     "scripts": {
       "test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
     },
     "devDependencies": {
       "aws-sdk": "^2.815.0",
       "chai": "^4.2.0",
       "mocha": "^8.2.1"
     }
   }
   ```

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Sie haben jetzt eine Datei mit dem Namen `package.json` zum Stammverzeichnis des Repositorys hinzugefügt.

### Datei sam-template.yml
<a name="deploy-tut-lambda-cfn-files-sam-template-yml"></a>

Die `sam-template.yml` Datei enthält die Anweisungen für die Bereitstellung der Lambda-Funktion und des API Gateway und deren gemeinsame Konfiguration. Sie folgt der [AWS Serverless Application Model Vorlagenspezifikation](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html), die die CloudFormation Vorlagenspezifikation erweitert.

In diesem Tutorial verwenden Sie eine AWS SAM Vorlage anstelle einer regulären CloudFormation Vorlage, da sie einen hilfreichen [AWS: :Serverless: :Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) Ressourcentyp AWS SAM bietet. Dieser Typ führt viele behind-the-scenes Konfigurationen durch, die Sie normalerweise ausschreiben müssen, um die grundlegende Syntax zu verwenden. CloudFormation Beispielsweise `AWS::Serverless::Function` erstellt der eine Lambda-Funktion, eine Lambda-Ausführungsrolle und Ereignisquellenzuordnungen, mit denen die Funktion gestartet wird. Sie müssen all das programmieren, wenn Sie es mit Basic schreiben möchten. CloudFormation

In diesem Tutorial wird zwar eine vorgefertigte Vorlage verwendet, Sie können jedoch eine Vorlage als Teil Ihres Workflows mithilfe einer Build-Aktion generieren. Weitere Informationen finden Sie unter [Einen CloudFormation Stack bereitstellen](deploy-action-cfn.md).

**Um die Datei sam-template.yml hinzuzufügen**

1. **Wählen Sie in Ihrem Repository unter **Dateien** die Option Datei erstellen aus.**

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   sam-template.yml
   ```

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: >
     serverless-api
   
     Sample SAM Template for serverless-api
     
   # More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
   Globals:
     Function:
       Timeout: 3
   
   Resources:
     HelloWorldFunction:
       Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
       Properties:
         CodeUri: hello-world/
         Handler: app.lambdaHandler
         Runtime: nodejs12.x
         Events:
           HelloWorld:
             Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
             Properties:
               Path: /hello
               Method: get
   
   Outputs:
     # ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
     # Find out about other implicit resources you can reference within AWS SAM at
     # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
     HelloWorldApi:
       Description: "API Gateway endpoint URL for the Hello World function"
       Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
     HelloWorldFunction:
       Description: "Hello World Lambda function ARN"
       Value: !GetAtt HelloWorldFunction.Arn
     HelloWorldFunctionIamRole:
       Description: "Implicit Lambda execution role created for the Hello World function"
       Value: !GetAtt HelloWorldFunctionRole.Arn
   ```

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Sie haben jetzt eine Datei mit `sam-template.yml` dem Namen im Stammordner Ihres Repositorys hinzugefügt.

### Datei setup-sam.sh
<a name="deploy-tut-lambda-cfn-files-setup-sam"></a>

Die `setup-sam.sh` Datei enthält Anweisungen zum Herunterladen und Installieren des AWS SAM CLI-Dienstprogramms. Der Workflow verwendet dieses Hilfsprogramm, um die `hello-world` Quelle zu verpacken.

**Um die Datei setup-sam.sh hinzuzufügen**

1. Wählen Sie in Ihrem Repository unter **Dateien** die Option **Datei erstellen** aus.

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   setup-sam.sh
   ```

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   #!/usr/bin/env bash
   echo "Setting up sam"
   
   yum install unzip -y
   
   curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
   unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory
   
   ./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2
   ```

   Ersetzen Sie den Code im vorherigen Code *us-west-2* durch Ihre AWS Region.

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Sie haben jetzt eine Datei mit dem Namen `setup-sam.sh` zum Stammverzeichnis des Repositorys hinzugefügt.

### Datei app.js
<a name="deploy-tut-lambda-cfn-files-app-js"></a>

Das `app.js` enthält den Lambda-Funktionscode. In diesem Tutorial gibt der Code den Text `hello world` zurück.

**Um die Datei app.js hinzuzufügen**

1. Wählen Sie in Ihrem Repository unter **Dateien** die Option **Datei erstellen** aus.

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   hello-world/app.js
   ```

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   // const axios = require('axios')
   // const url = 'http://checkip.amazonaws.com/';
   let response;
   
   /**
    *
    * Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
    * @param {Object} event - API Gateway Lambda Proxy Input Format
    *
    * Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html 
    * @param {Object} context
    *
    * Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
    * @returns {Object} object - API Gateway Lambda Proxy Output Format
    * 
    */
   exports.lambdaHandler = async (event, context) => {
       try {
           // const ret = await axios(url);
           response = {
               'statusCode': 200,
               'body': JSON.stringify({
                   message: 'hello world',
                   // location: ret.data.trim()
               })
           }
       } catch (err) {
           console.log(err);
           return err;
       }
   
       return response
   };
   ```

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Sie haben jetzt einen Ordner mit dem Namen `hello-world` und eine Datei mit dem Namen erstellt`app.js`.

### Datei test-handler.js
<a name="deploy-tut-lambda-cfn-files-test-handler-js"></a>

Die `test-handler.js` Datei enthält Komponententests für die Lambda-Funktion.

**Um die Datei test-handler.js hinzuzufügen**

1. Wählen Sie in Ihrem Repository unter **Dateien** die Option **Datei erstellen** aus.

1. Geben Sie als **Dateiname** Folgendes ein:

   ```
   hello-world/tests/unit/test-handler.js
   ```

1. Geben Sie in das Textfeld den folgenden Code ein:

   ```
   'use strict';
   
   const app = require('../../app.js');
   const chai = require('chai');
   const expect = chai.expect;
   var event, context;
   
   describe('Tests index', function () {
       it('verifies successful response', async () => {
           const result = await app.lambdaHandler(event, context)
   
           expect(result).to.be.an('object');
           expect(result.statusCode).to.equal(200);
           expect(result.body).to.be.an('string');
   
           let response = JSON.parse(result.body);
   
           expect(response).to.be.an('object');
           expect(response.message).to.be.equal("hello world");
           // expect(response.location).to.be.an("string");
       });
   });
   ```

1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

   Sie haben jetzt eine Datei mit `test-handler.js` dem Namen unter dem `hello-world/tests/unit` Ordner hinzugefügt.

Sie haben jetzt alle Ihre Quelldateien hinzugefügt.

Nehmen Sie sich einen Moment Zeit, um Ihre Arbeit zu überprüfen und sicherzustellen, dass Sie alle Dateien in den richtigen Ordnern abgelegt haben. Die Ordnerstruktur ist wie folgt:

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

## Schritt 6: Einen Workflow erstellen und ausführen
<a name="deploy-tut-lambda-cfn-workflow"></a>

In diesem Schritt erstellen Sie einen Workflow, der Ihren Lambda-Quellcode verpackt und bereitstellt. Der Workflow besteht aus den folgenden Bausteinen, die sequentiell ausgeführt werden:
+ Ein Trigger — Dieser Trigger startet die Workflow-Ausführung automatisch, wenn Sie eine Änderung an Ihr Quell-Repository übertragen. Weitere Informationen zu Auslösern finden Sie unter [Automatisches Starten einer Workflow-Ausführung mithilfe von Triggern](workflows-add-trigger.md).
+ Eine Testaktion (`Test`) — Beim Trigger installiert diese Aktion den [Node-Paketmanager (npm)](https://www.npmjs.com/) und führt dann den `npm run test` Befehl aus. Dieser Befehl weist npm an, das in der `test` Datei definierte Skript auszuführen. `package.json` Das `test` Skript wiederum führt die Komponententests aus und generiert zwei Berichte: einen Testbericht (`junit.xml`) und einen Bericht über die Codeabdeckung (`clover.xml`). Weitere Informationen finden Sie unter [package.json-Datei](#deploy-tut-lambda-cfn-files-package-json).

  Als Nächstes wandelt die Testaktion die XML-Berichte in CodeCatalyst Berichte um und zeigt sie in der CodeCatalyst Konsole auf der Registerkarte **Berichte** der Testaktion an.

  Weitere Informationen zur Testaktion finden Sie unter[Testen mit WorkflowsTesten mit Workflows](test-workflow-actions.md).
+ Eine Build-Aktion (`BuildBackend`) — Nach Abschluss der Testaktion lädt die Build-Aktion die AWS SAM CLI herunter und installiert sie, packt die `hello-world` Quelle und kopiert das Paket in Ihren Amazon S3 S3-Bucket, wo es vom Lambda-Service erwartet wird. Die Aktion gibt auch eine neue AWS SAM Vorlagendatei namens aus `sam-template-packaged.yml` und platziert sie in einem Ausgabeartefakt namens. `buildArtifact`

  Weitere Informationen zur Build-Aktion finden Sie unter[Bauen mit Workflows](build-workflow-actions.md).
+ Eine Bereitstellungsaktion (`DeployCloudFormationStack`) — Nach Abschluss der Build-Aktion sucht die Bereitstellungsaktion nach dem von der Build-Aktion (`buildArtifact`) generierten Ausgabeartefakt, findet die darin enthaltene AWS SAM Vorlage und führt dann die Vorlage aus. Die AWS SAM Vorlage erstellt einen Stack, der die serverlose Anwendung bereitstellt.

**So erstellen Sie ein Workflow**

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie Workflow **erstellen** aus.

1. Wählen Sie für **Quell-Repository**`codecatalyst-cfn-source-repository`.

1. Wählen Sie für **Branch**`main`.

1. Wählen Sie **Erstellen** aus.

1. Löschen Sie den YAML-Beispielcode.

1. Fügen Sie den folgenden YAML-Code hinzu:
**Anmerkung**  
Im folgenden YAML-Code können Sie die `Connections:` Abschnitte weglassen, wenn Sie möchten. Wenn Sie diese Abschnitte weglassen, müssen Sie sicherstellen, dass die im Feld **Standard-IAM-Rolle angegebene Rolle** in Ihrer Umgebung die Berechtigungen und Vertrauensrichtlinien beider Rollen enthält, die unter beschrieben sind. [Schritt 2: AWS Rollen erstellen](#deploy-tut-lambda-cfn-roles) Weitere Informationen zum Einrichten einer Umgebung mit einer Standard-IAM-Rolle finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)

   ```
   Name: codecatalyst-cfn-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main   
   Actions:
     Test:
       Identifier: aws/managed-test@v1
       Inputs:
         Sources:
           - WorkflowSource
       Outputs:
         Reports:
           CoverageReport:
             Format: CLOVERXML
             IncludePaths:
               - "coverage/*"
           TestReport:
             Format: JUNITXML
             IncludePaths:
               - junit.xml
       Configuration:
         Steps:
           - Run: npm install
           - Run: npm run test  
     BuildBackend:
       Identifier: aws/build@v1
       DependsOn:
         - Test
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-build-role
       Inputs:
         Sources:
           - WorkflowSource
       Configuration: 
         Steps:
           - Run: . ./setup-sam.sh
           - Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
       Outputs:
         Artifacts:
           - Name: buildArtifact
             Files:
               - "**/*"
     DeployCloudFormationStack:
       Identifier: aws/cfn-deploy@v1
       DependsOn: 
         - BuildBackend
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-deploy-role
       Inputs:
         Artifacts:
           - buildArtifact
         Sources: []
       Configuration:
         name: codecatalyst-cfn-stack
         region: us-west-2
         role-arn: arn:aws:iam::111122223333:role/StackRole
         template: ./sam-template-packaged.yml
         capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND
   ```

   Ersetzen Sie im vorherigen Code:
   + Beide Instanzen von *codecatalyst-cfn-environment* mit dem Namen Ihrer Umgebung.
   + Beide Instanzen von *codecatalyst-account-connection* mit dem Anzeigenamen Ihrer Kontoverbindung. Der Anzeigename kann eine Zahl sein. Weitere Informationen finden Sie unter [Schritt 3: AWS Rollen hinzufügen CodeCatalyst](#deploy-tut-lambda-cfn-roles-add).
   + *codecatalyst-build-role*mit dem Namen der Build-Rolle, in der Sie erstellt haben[Schritt 2: AWS Rollen erstellen](#deploy-tut-lambda-cfn-roles).
   + *codecatalyst-cfn-s3-bucket*mit dem Namen des Amazon S3 S3-Buckets, in dem Sie ihn erstellt haben[Schritt 4: Erstellen Sie einen Amazon S3 S3-Bucket](#deploy-tut-lambda-cfn-s3).
   + Beide Instanzen *us-west-2* mit der Region, in der sich Ihr Amazon S3 S3-Bucket befindet (erste Instance), und in der Ihr Stack bereitgestellt wird (zweite Instance). Diese Regionen können unterschiedlich sein. In diesem Tutorial wird davon ausgegangen, dass beide Regionen auf eingestellt sind`us-west-2`. Einzelheiten zu den von Amazon S3 und CloudFormation unterstützten Regionen finden Sie unter [Service-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) in der *Allgemeine AWS-Referenz*.
   + *codecatalyst-deploy-role*mit dem Namen der Bereitstellungsrolle, in [Schritt 2: AWS Rollen erstellen](#deploy-tut-lambda-cfn-roles) der Sie erstellt haben.
   + *codecatalyst-cfn-environment*mit dem Namen der Umgebung, in der Sie erstellt haben[Voraussetzungen](#deploy-tut-lambda-cfn-prereqs).
   + *arn:aws:iam::111122223333:role/StackRole*mit dem Amazon-Ressourcennamen (ARN) der Stack-Rolle, in der Sie erstellt haben[Schritt 2: AWS Rollen erstellen](#deploy-tut-lambda-cfn-roles).
**Anmerkung**  
Wenn Sie sich entschieden haben, keine Build-, Deployment- und Stack-Rollen zu erstellen *codecatalyst-build-role**codecatalyst-deploy-role*, ersetzen Sie, und *arn:aws:iam::111122223333:role/StackRole* durch den Namen oder ARN der `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle. Weitere Informationen über diese Rolle finden Sie unter [Schritt 2: AWS Rollen erstellen](#deploy-tut-lambda-cfn-roles).

   Informationen zu den Eigenschaften des zuvor gezeigten Codes finden Sie unter[Aktion CloudFormation 'Stack bereitstellen' YAML](deploy-action-ref-cfn.md).

1. (Optional) Wählen Sie „**Validieren**“, um sicherzustellen, dass der YAML-Code gültig ist, bevor Sie ihn festschreiben.

1. Wählen Sie **Commit** (Übergeben).

1. Geben Sie im **Dialogfeld „Workflow bestätigen**“ Folgendes ein:

   1. Behalten Sie als **Workflow-Dateiname** die Standardeinstellung bei`codecatalyst-cfn-workflow`.

   1. Geben Sie für **Commit-Nachricht** Folgendes ein:

      ```
      add initial workflow file
      ```

   1. Wählen Sie für **Repository **codecatalyst-cfn-source-repository****.

   1. Wählen Sie als **Branch-Name** die Option **main** aus.

   1. Wählen Sie **Commit** (Übergeben).

   Sie haben jetzt einen Workflow erstellt. Eine Workflow-Ausführung wird aufgrund des oben im Workflow definierten Triggers automatisch gestartet. Insbesondere, als Sie die `codecatalyst-cfn-workflow.yaml` Datei in Ihr Quell-Repository übernommen (und per Push übertragen) haben, hat der Trigger die Workflow-Ausführung gestartet.

**Um den laufenden Workflow-Lauf zu sehen**

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Workflow aus, den Sie gerade erstellt haben:. `codecatalyst-cfn-workflow`

1. Wählen Sie die Registerkarte „**Läufe**“.

1. Wählen Sie in der Spalte **Run-ID** die Run-ID aus.

1. Wählen Sie **Test**, um den Fortschritt der Tests zu sehen.

1. Wählen Sie **BuildBackend**, um den Baufortschritt zu sehen.

1. Wählen Sie **DeployCloudFormationStack**diese Option, um den Fortschritt der Bereitstellung zu sehen.

   Weitere Informationen zum Anzeigen von Ausführungsdetails finden Sie unter[Status und Details der Workflow-Ausführung anzeigen](workflows-view-run.md).

1. Wenn die **DeployCloudFormationStack**Aktion abgeschlossen ist, gehen Sie wie folgt vor:
   + Wenn die Workflow-Ausführung erfolgreich war, fahren Sie mit dem nächsten Verfahren fort.
   + Wenn die Workflow-Ausführung beim **Test** oder bei der **BuildBackend**Aktion fehlgeschlagen ist, wählen Sie **Protokolle** aus, um das Problem zu beheben.
   + Wenn die Workflow-Ausführung bei der **DeployCloudFormationStack**Aktion fehlgeschlagen ist, wählen Sie die Aktion „Bereitstellen“ und anschließend die Registerkarte „**Zusammenfassung**“. Scrollen Sie zum Abschnitt „**CloudFormation Ereignisse**“, um die detaillierte Fehlermeldung anzuzeigen. Wenn ein Rollback aufgetreten ist, löschen Sie den `codecatalyst-cfn-stack` Stack über die CloudFormation Konsole, AWS bevor Sie den Workflow erneut ausführen.

**Um die Bereitstellung zu überprüfen**

1. Wählen Sie nach einer erfolgreichen Bereitstellung in der horizontalen Menüleiste oben die Option **Variablen (7)** aus. (Wählen Sie im Bereich auf der rechten Seite nicht **Variablen** aus.)

1. Fügen Sie **HelloWorldApi**als Nächstes die `https://` URL in einen Browser ein.

   Eine **Hello-World-JSON-Meldung** von der Lambda-Funktion wird angezeigt, die darauf hinweist, dass der Workflow die Lambda-Funktion und das API Gateway erfolgreich bereitgestellt und konfiguriert hat.
**Tipp**  
Sie können diese URL mit einigen kleinen Konfigurationen im Workflow-Diagramm CodeCatalyst anzeigen lassen. Weitere Informationen finden Sie unter [Anzeige der App-URL im Workflow-Diagramm](deploy-app-url.md).

**Um die Ergebnisse der Komponententests und die Codeabdeckung zu überprüfen**

1. Wählen Sie im Workflow-Diagramm **Test** und dann **Berichte** aus.

1. Wählen **TestReport**Sie, ob Sie sich die Ergebnisse der Komponententests oder die Codeabdeckung der getesteten Dateien anzeigen lassen möchten **CoverageReport**, in diesem Fall `app.js` und`test-handler.js`.

**Um die bereitgestellten Ressourcen zu überprüfen**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/). 

1. Beachten Sie die **codecatalyst-cfn-stack**API, die die AWS SAM Vorlage erstellt hat. Der API-Name stammt aus dem `Configuration/name` Wert in der Workflow-Definitionsdatei (`codecatalyst-cfn-workflow.yaml`).

1. Öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Wählen Sie im Navigationsbereich **Funktionen** aus.

1. Wählen Sie Ihre Lambda-Funktion,`codecatalyst-cfn-stack-HelloWorldFunction-string`.

1. Sie können sehen, wie das API Gateway ein Auslöser für die Funktion ist. Diese Integration wurde automatisch nach dem AWS SAM `AWS::Serverless::Function` Ressourcentyp konfiguriert.

## Schritt 7: Nehmen Sie eine Änderung vor
<a name="deploy-tut-lambda-cfn-change"></a>

In diesem Schritt nehmen Sie eine Änderung an Ihrem Lambda-Quellcode vor und übernehmen diese. Mit diesem Commit wird ein neuer Workflow-Lauf gestartet. Bei diesem Lauf wird die neue Lambda-Funktion in einem blaugrünen Schema bereitgestellt, das die in der Lambda-Konsole angegebene Standardkonfiguration zur Verkehrsverlagerung verwendet.

**Um eine Änderung an Ihrer Lambda-Quelle vorzunehmen**

1. Navigieren Sie in CodeCatalyst zu Ihrem Projekt.

1. Wählen Sie im Navigationsbereich **Code** und dann **Quell-Repositories** aus.

1. Wählen Sie Ihr Quell-Repository `codecatalyst-cfn-source-repository` aus.

1. Ändern Sie die Anwendungsdatei:

   1. Wählen Sie den Ordner `hello-world` aus.

   1. Wählen Sie die `app.js` Datei aus.

   1. Wählen Sie **Bearbeiten** aus.

   1. Wechseln Sie in Zeile 23 `hello world` zu**Tutorial complete\$1**.

   1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

      Durch den Commit wird ein Workflow-Lauf gestartet. Dieser Lauf schlägt fehl, weil Sie die Komponententests nicht aktualisiert haben, um die Namensänderung widerzuspiegeln.

1. Aktualisieren Sie die Komponententests:

   1. Wählen Sie `hello-world\tests\unit\test-handler.js`.

   1. Wählen Sie **Bearbeiten** aus.

   1. Wechseln Sie in Zeile 19 `hello world` zu**Tutorial complete\$1**.

   1. Wählen Sie **Commit** und anschließend erneut **Commit** aus.

      Durch den Commit wird ein weiterer Workflow-Lauf gestartet. Dieser Lauf wird erfolgreich sein.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. **Wählen Sie `codecatalyst-cfn-workflow` und wählen Sie dann Runs aus.**

1. Wählen Sie die Lauf-ID des letzten Laufs aus. Es sollte noch in Bearbeitung sein.

1. Wählen Sie **Test** und **BuildBackend**, **DeployCloudFormationStack**um den Fortschritt der Workflow-Ausführung zu sehen.

1. Wenn der Workflow abgeschlossen ist, wählen Sie oben **Variablen (7)** aus.

1. Fügen Sie **HelloWorldApi**als Nächstes die `https://` URL in einen Browser ein.

   Im Browser wird eine `Tutorial complete!` Meldung angezeigt, die darauf hinweist, dass Ihre neue Anwendung erfolgreich bereitgestellt wurde.

## Bereinigen
<a name="deploy-tut-lambda-cfn-clean-up"></a>

Bereinigen Sie die in diesem Tutorial verwendeten Dateien und Dienste, um zu vermeiden, dass dafür Gebühren anfallen.

**Um in der CodeCatalyst Konsole aufzuräumen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Löschen`codecatalyst-cfn-workflow`.

1. Löschen`codecatalyst-cfn-environment`.

1. Löschen`codecatalyst-cfn-source-repository`.

1. Löschen`codecatalyst-cfn-project`.

**Zum Aufräumen in der AWS-Managementkonsole**

1.  CloudFormationAufräumen wie folgt:

   1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

   1. Löschen Sie das `codecatalyst-cfn-stack`.

      Durch das Löschen des Stacks werden alle Tutorial-Ressourcen aus den API Gateway- und Lambda-Diensten entfernt.

1. Bereinigen Sie in Amazon S3 wie folgt:

   1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

   1. Wählen Sie das Symbol `codecatalyst-cfn-s3-bucket`.

   1. Löschen Sie den Inhalt des Buckets.

   1. Löschen Sie den Bucket.

1. Bereinigen Sie in IAM wie folgt:

   1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

   1. Löschen Sie das `codecatalyst-deploy-policy`.

   1. Löschen Sie das `codecatalyst-build-policy`.

   1. Löschen Sie das `codecatalyst-stack-policy`.

   1. Löschen Sie das `codecatalyst-deploy-role`.

   1. Löschen Sie das `codecatalyst-build-role`.

   1. Löschen Sie das `codecatalyst-stack-role`.

In diesem Tutorial haben Sie gelernt, wie Sie eine serverlose Anwendung mithilfe eines CodeCatalyst Workflows und einer CloudFormation Stack-Aktion bereitstellen als ** CloudFormation Stack bereitstellen**.

# Aktion „ CloudFormation Stapel bereitstellen“ hinzufügen
<a name="deploy-action-cfn-adding"></a>

Verwenden Sie die folgenden Anweisungen, um die Aktion ** CloudFormation Stack bereitstellen** zu Ihrem Workflow hinzuzufügen. 

------
#### [ Visual ]

**Um die Aktion „ CloudFormation Stapel bereitstellen“ mit dem visuellen Editor hinzuzufügen**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie oben links **\$1 Aktionen**, um den Aktionskatalog zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der Aktion ** CloudFormation Stack bereitstellen** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie ** CloudFormation Stack bereitstellen** aus. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld gehen Sie wie folgt vor:
     + (Optional) Wählen Sie „**Herunterladen**“, um [den Quellcode der Aktion anzuzeigen](workflows-view-source.md#workflows-view-source.title).
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Füllen Sie auf den Registerkarten **Eingaben** und **Konfiguration** die Felder nach Ihren Bedürfnissen aus. Eine Beschreibung der einzelnen Felder finden Sie unter[Aktion CloudFormation 'Stack bereitstellen' YAML](deploy-action-ref-cfn.md). Diese Referenz enthält detaillierte Informationen zu jedem Feld (und dem entsprechenden YAML-Eigenschaftswert), wie es sowohl im YAML- als auch im visuellen Editor angezeigt wird.

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit** aus.

------
#### [ YAML ]

**Um die Aktion „ CloudFormation Stack bereitstellen“ mit dem YAML-Editor hinzuzufügen**

1. [Öffnen Sie die Konsole unter https://codecatalyst.aws/ CodeCatalyst .](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Wählen Sie links oben **\$1 Aktionen aus, um den Aktionskatalog** zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der Aktion ** CloudFormation Stack bereitstellen** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie ** CloudFormation Stack bereitstellen** aus. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld gehen Sie wie folgt vor:
     + (Optional) Wählen Sie „**Herunterladen**“, um [den Quellcode der Aktion anzuzeigen](workflows-view-source.md#workflows-view-source.title).
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Ändern Sie die Eigenschaften im YAML-Code nach Ihren Bedürfnissen. Eine Erläuterung der einzelnen verfügbaren Eigenschaften finden Sie in der[Aktion CloudFormation 'Stack bereitstellen' YAML](deploy-action-ref-cfn.md).

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit** aus.

------

# Rollbacks konfigurieren
<a name="deploy-consumption-enable-alarms"></a>

Wenn die Aktion ** CloudFormation Stack bereitstellen** fehlschlägt, führt dies standardmäßig CloudFormation dazu, dass der Stack auf den letzten bekannten stabilen Status zurückgesetzt wird. Sie können das Verhalten so ändern, dass Rollbacks nicht nur dann auftreten, wenn die Aktion fehlschlägt, sondern auch, wenn ein bestimmter CloudWatch Amazon-Alarm ausgelöst wird. Weitere Informationen zu CloudWatch Alarmen finden Sie unter [Verwenden von CloudWatch Amazon-Alarmen](https://docs.aws.amazon.com/) im * CloudWatch Amazon-Benutzerhandbuch*.

Sie können auch das Standardverhalten so ändern, dass der Stack CloudFormation nicht zurückgesetzt wird, wenn die Aktion fehlschlägt. 

Verwenden Sie die folgenden Anweisungen, um Rollbacks zu konfigurieren.

**Anmerkung**  
Sie können ein Rollback nicht manuell starten.

------
#### [ Visual ]

**Bevor Sie beginnen**

1. Stellen Sie sicher, dass Sie über einen [Workflow](workflow.md) verfügen, der eine funktionierende Aktion „** CloudFormation Stack bereitstellen**“ beinhaltet. Weitere Informationen finden Sie unter [Einen CloudFormation Stack bereitstellen](deploy-action-cfn.md).

1. Stellen Sie sicher, dass Sie in der **Rolle, die im Feld Stack-Rolle — optional** der Aktion ** CloudFormation Stack bereitstellen** angegeben ist, die **CloudWatchFullAccess**Berechtigung angeben. Informationen zum Erstellen dieser Rolle mit den entsprechenden Berechtigungen finden Sie unter[Schritt 2: AWS Rollen erstellen](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles).

**So konfigurieren Sie Rollback-Alarme für die Aktion „Stack bereitstellen“ CloudFormation**

1. [Öffnen Sie die Konsole unter https://codecatalyst.aws/ CodeCatalyst .](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie Ihre ** CloudFormation Stack-Aktion „Deploy**“.

1. Wählen Sie im Detailbereich **Konfiguration** aus.

1. Erweitern Sie unten die Option **Erweitert**.

1. Wählen Sie unter **Alarm überwachen ARNs** die Option **Alarm hinzufügen** aus.

1. Geben Sie Informationen in die folgenden Felder ein.
   + **Alarm ARN**

     Geben Sie den Amazon-Ressourcennamen (ARN) eines CloudWatch Amazon-Alarms an, der als Rollback-Trigger verwendet werden soll. Beispiel, `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`. Sie können maximal fünf Rollback-Trigger haben.
**Anmerkung**  
Wenn Sie einen CloudWatch Alarm-ARN angeben, müssen Sie auch zusätzliche Berechtigungen konfigurieren, damit die Aktion darauf zugreifen kann CloudWatch. Weitere Informationen finden Sie unter [Rollbacks konfigurieren](#deploy-consumption-enable-alarms).
   + **Dauer der Überwachung**

     Geben Sie einen Zeitraum von 0 bis 180 Minuten an, in dem die angegebenen Alarme CloudFormation überwacht werden. Die Überwachung beginnt, *nachdem* alle Stack-Ressourcen bereitgestellt wurden. Wenn der Alarm innerhalb der angegebenen Überwachungszeit auftritt, CloudFormation schlägt die Bereitstellung fehl und der gesamte Stack-Vorgang wird rückgängig gemacht.

     Standard: 0. CloudFormation überwacht Alarme nur, während die Stack-Ressourcen bereitgestellt werden, nicht danach.

------
#### [ YAML ]

**Um Rollback-Trigger für die Aktion „Stack bereitstellen“ CloudFormation zu konfigurieren**

1. [Öffnen Sie die Konsole unter https://codecatalyst.aws/ CodeCatalyst .](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen eines Workflows, der die Aktion ** CloudFormation Stack bereitstellen** enthält. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Fügen Sie die `monitor-timeout-in-minutes` Eigenschaften `monitor-alarm-arns` und im YAML-Code hinzu, um Rollback-Trigger hinzuzufügen. Eine Erläuterung der einzelnen Eigenschaften finden Sie unter. [Aktion CloudFormation 'Stack bereitstellen' YAML](deploy-action-ref-cfn.md)

1. Stellen Sie sicher, dass Sie in der Rolle, die in der `role-arn` Eigenschaft der Aktion ** CloudFormation Stack bereitstellen** angegeben ist, die **CloudWatchFullAccess**entsprechende Berechtigung angeben. Informationen zum Erstellen dieser Rolle mit den entsprechenden Berechtigungen finden Sie unter[Schritt 2: AWS Rollen erstellen](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles).

------

------
#### [ Visual ]

**So deaktivieren Sie Rollbacks für die Aktion „Stack bereitstellen“ CloudFormation**

1. [Öffnen Sie die Konsole unter https://codecatalyst.aws/ CodeCatalyst .](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen eines Workflows, der die Aktion ** CloudFormation Stack bereitstellen** enthält. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie Ihre ** CloudFormation Stack-Aktion „Deploy**“.

1. Wählen Sie im Detailbereich **Konfiguration** aus.

1. Erweitern Sie unten die Option **Erweitert**.

1. Aktivieren Sie **„Rollback deaktivieren“**.

------
#### [ YAML ]

**Um Rollbacks für die Aktion „Stack bereitstellen“ CloudFormation zu deaktivieren**

1. [Öffnen Sie die Konsole unter https://codecatalyst.aws/ CodeCatalyst .](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen eines Workflows, der die Aktion ** CloudFormation Stack bereitstellen** enthält. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Fügen Sie die `disable-rollback: 1` Eigenschaft im YAML-Code hinzu, um Rollbacks zu verhindern. Eine Erläuterung dieser Eigenschaft finden Sie unter. [Aktion CloudFormation 'Stack bereitstellen' YAML](deploy-action-ref-cfn.md)

------

# CloudFormation 'Stack'-Variablen bereitstellen
<a name="deploy-action-cfn-variables"></a>

Die Aktion „** CloudFormation Stack bereitstellen**“ erzeugt und setzt zur Laufzeit die folgenden Variablen. Diese werden als *vordefinierte Variablen* bezeichnet.

Hinweise zum Verweisen auf diese Variablen in einem Workflow finden Sie unter[Verwenden vordefinierter Variablen](workflows-using-predefined-variables.md).


| Key (Schlüssel) | Value (Wert) | 
| --- | --- | 
|  Bereitstellungsplattform  |  Der Name der Bereitstellungsplattform. Fest codiert auf. `AWS:CloudFormation`  | 
|  Region  |  Der Regionalcode von AWS-Region , für den während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `us-west-2`  | 
|  Stack-ID  |  Der Amazon-Ressourcenname (ARN) des bereitgestellten Stacks. Beispiel: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cfn-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 

# Aktion CloudFormation 'Stack bereitstellen' YAML
<a name="deploy-action-ref-cfn"></a>

Im Folgenden finden Sie die YAML-Definition der ** CloudFormation Stack-Aktion Deploy**. Informationen zur Verwendung dieser Aktion finden Sie unter[Einen CloudFormation Stack bereitstellen](deploy-action-cfn.md).

Diese Aktionsdefinition ist als Abschnitt in einer umfassenderen Workflow-Definitionsdatei vorhanden. Weitere Informationen über diese Datei finden Sie unter [YAML-Workflow-Definition](workflow-reference.md).

**Anmerkung**  
Die meisten der folgenden YAML-Eigenschaften haben entsprechende Benutzeroberflächenelemente im visuellen Editor. Verwenden Sie **Strg\$1F**, um nach einem UI-Element zu suchen. Das Element wird mit der zugehörigen YAML-Eigenschaft aufgelistet.

```
# The workflow definition starts here.
# See Eigenschaften der obersten Ebene for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.    
  DeployCloudFormationStack:  
    Identifier: aws/cfn-deploy@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: DeployRole
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - CloudFormation-artifact
    Configuration:
      name: stack-name
      region: us-west-2
      template: template-path
      role-arn: arn:aws:iam::123456789012:role/StackRole        
      capabilities: CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
      parameter-overrides: KeyOne=ValueOne,KeyTwo=ValueTwo | path-to-JSON-file
      no-execute-changeset: 1|0
      fail-on-empty-changeset: 1|0
      disable-rollback: 1|0
      termination-protection: 1|0
      timeout-in-minutes: minutes
      notification-arns: arn:aws:sns:us-east-1:123456789012:MyTopic,arn:aws:sns:us-east-1:123456789012:MyOtherTopic
      monitor-alarm-arns: arn:aws:cloudwatch::123456789012:alarm/MyAlarm,arn:aws:cloudwatch::123456789012:alarm/MyOtherAlarm
      monitor-timeout-in-minutes: minutes       
      tags: '[{"Key":"MyKey1","Value":"MyValue1"},{"Key":"MyKey2","Value":"MyValue2"}]'
```

## DeployCloudFormationStack
<a name="deploy.action.cfn.deploycloudformationstack"></a>

(Erforderlich)

Geben Sie den Namen der Aktion an. Alle Aktionsnamen müssen innerhalb des Workflows eindeutig sein. Aktionsnamen sind auf alphanumerische Zeichen (a-z, A-Z, 0-9), Bindestriche (-) und Unterstriche (\$1) beschränkt. Leerzeichen sind nicht erlaubt. Sie können keine Anführungszeichen verwenden, um Sonderzeichen und Leerzeichen in Aktionsnamen zuzulassen.

Standard: `DeployCloudFormationStack_nn`.

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**Anzeigename der Aktion**

## Identifier
<a name="deploy.action.cfn.identifier"></a>

(*DeployCloudFormationStack*/**Identifier**)

(Erforderlich)

Identifiziert die Aktion. Ändern Sie diese Eigenschaft nur, wenn Sie die Version ändern möchten. Weitere Informationen finden Sie unter [Angabe der zu verwendenden Aktionsversion](workflows-action-versions.md).

Standard: `aws/cfn-deploy@v1`.

**Entsprechende Benutzeroberfläche: Workflow-Diagram/ DeployCloudFormationStack \$1nn/ aws/cfn-deploy @v1 label**

## DependsOn
<a name="deploy.action.cfn.dependson"></a>

(*DeployCloudFormationStack*/**DependsOn**)

(Optional)

Geben Sie eine Aktion, eine Aktionsgruppe oder ein Gate an, die erfolgreich ausgeführt werden müssen, damit diese Aktion ausgeführt werden kann.

Weitere Hinweise zur Funktion „Hängt davon ab“ finden Sie unter. [Aktionen sequenzieren](workflows-depends-on.md)

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Hängt davon ab**“ — optional

## Compute
<a name="deploy.action.cfn.computename"></a>

(*DeployCloudFormationStack*/**Compute**)

(Optional)

Die Rechen-Engine, mit der Ihre Workflow-Aktionen ausgeführt wurden. Sie können die Berechnung entweder auf Workflow-Ebene oder auf Aktionsebene angeben, aber nicht beide. Wenn auf Workflow-Ebene angegeben, gilt die Rechenkonfiguration für alle im Workflow definierten Aktionen. Auf Workflow-Ebene können Sie auch mehrere Aktionen auf derselben Instanz ausführen. Weitere Informationen finden Sie unter [Rechenleistung für mehrere Aktionen gemeinsam nutzen](compute-sharing.md).

Entsprechende Benutzeroberfläche: *keine*

## Type
<a name="deploy.action.cfn.computetype"></a>

(*DeployCloudFormationStack*/Compute/**Type**)

([Compute](#deploy.action.cfn.computename)Erforderlich, falls enthalten)

Der Typ der Compute Engine. Sie können einen der folgenden Werte verwenden:
+ **EC2** (visueller Editor) oder `EC2` (YAML-Editor)

  Optimiert für Flexibilität bei Aktionsläufen.
+ **Lambda** (visueller Editor) oder `Lambda` (YAML-Editor)

  Optimierte Startgeschwindigkeiten für Aktionen.

Weitere Informationen zu Datentypen finden Sie unter [Berechnungstypen](workflows-working-compute.md#compute.types).

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Berechnungstyp**

## Fleet
<a name="deploy.action.cfn.computefleet"></a>

(*DeployCloudFormationStack*/Compute/**Fleet**)

(Optional)

Geben Sie die Maschine oder Flotte an, auf der Ihr Workflow oder Ihre Workflow-Aktionen ausgeführt werden sollen. Bei bedarfsgesteuerten Flotten stellt der Workflow zu Beginn einer Aktion die benötigten Ressourcen bereit, und die Maschinen werden zerstört, wenn die Aktion abgeschlossen ist. Beispiele für Flotten auf Abruf:`Linux.x86-64.Large`,. `Linux.x86-64.XLarge` Weitere Informationen zu Flotten auf Abruf finden Sie unter. [Eigenschaften von On-Demand-Flotten](workflows-working-compute.md#compute.on-demand)

Bei bereitgestellten Flotten konfigurieren Sie eine Reihe von dedizierten Maschinen, um Ihre Workflow-Aktionen auszuführen. Diese Maschinen bleiben inaktiv und können sofort Aktionen ausführen. Weitere Informationen zu bereitgestellten Flotten finden Sie unter. [Eigenschaften von bereitgestellten Flotten](workflows-working-compute.md#compute.provisioned-fleets)

Wenn `Fleet` es weggelassen wird, ist die Standardeinstellung. `Linux.x86-64.Large`

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Compute Fleet**

## Timeout
<a name="deploy.action.cfn.timeout"></a>

(*DeployCloudFormationStack*/**Timeout**)

(Optional)

Geben Sie an, wie lange die Aktion in Minuten (YAML-Editor) oder Stunden und Minuten (visueller Editor) ausgeführt werden kann, bevor die Aktion CodeCatalyst beendet wird. Das Minimum beträgt 5 Minuten und das Maximum ist unter beschrieben[Kontingente für Workflows in CodeCatalyst](workflows-quotas.md). Das Standard-Timeout entspricht dem maximalen Timeout.

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**Timeout** in Minuten — optional

## Environment
<a name="deploy.action.cfn.environment"></a>

(*DeployCloudFormationStack*/**Environment**)

(Erforderlich)

Geben Sie die CodeCatalyst Umgebung an, die für die Aktion verwendet werden soll. Die Aktion stellt eine Verbindung mit der AWS-Konto optionalen Amazon VPC her, die in der ausgewählten Umgebung angegeben ist. Die Aktion verwendet die in der Umgebung angegebene Standard-IAM-Rolle, um sich mit der Amazon VPC zu verbinden AWS-Konto, und verwendet die in der [Amazon VPC-Verbindung angegebene IAM-Rolle, um eine Verbindung zur Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) herzustellen.

**Anmerkung**  
Wenn die Standard-IAM-Rolle nicht über die für die Aktion erforderlichen Berechtigungen verfügt, können Sie die Aktion so konfigurieren, dass sie eine andere Rolle verwendet. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

Weitere Informationen zu Umgebungen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md) und[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Name
<a name="deploy.action.cfn.environment.name"></a>

(*DeployCloudFormationStack*/Environment/**Name**)

(Erforderlich, falls [Environment](#deploy.action.cfn.environment) enthalten)

Geben Sie den Namen einer vorhandenen Umgebung an, die Sie der Aktion zuordnen möchten.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Connections
<a name="deploy.action.cfn.environment.connections"></a>

(*DeployCloudFormationStack*/Environment/**Connections**)

(Optional in neueren Versionen der Aktion; in älteren Versionen erforderlich)

Geben Sie die Kontoverbindung an, die der Aktion zugeordnet werden soll. Sie können unter maximal eine Kontoverbindung angeben`Environment`.

Wenn Sie keine Kontoverbindung angeben:
+ Die Aktion verwendet die AWS-Konto Verbindung und die Standard-IAM-Rolle, die in der Umgebung in der CodeCatalyst Konsole angegeben sind. Informationen zum Hinzufügen einer Kontoverbindung und einer Standard-IAM-Rolle zur Umgebung finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)
+ Die Standard-IAM-Rolle muss die Richtlinien und Berechtigungen enthalten, die für die Aktion erforderlich sind. **Informationen zu diesen Richtlinien und Berechtigungen finden Sie in der Beschreibung der Role-Eigenschaft in der YAML-Definitionsdokumentation der Aktion.**

Weitere Informationen zu Kontoverbindungen finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md). Hinweise zum Hinzufügen einer Kontoverbindung zu einer Umgebung finden Sie unter[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Name
<a name="deploy.action.cfn.environment.connections.name"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Name**)

(Erforderlich, falls enthalten[Connections](#deploy.action.cfn.environment.connections))

Geben Sie den Namen der Kontoverbindung an.

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Role
<a name="deploy.action.cfn.environment.connections.role"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Role**)

(Erforderlich, falls enthalten[Connections](#deploy.action.cfn.environment.connections))

Geben Sie den Namen der IAM-Rolle an, die von der ** CloudFormation Stack-Aktion Deploy** für den Zugriff auf AWS den CloudFormation Dienst verwendet wird. Stellen Sie sicher, dass Sie [die Rolle zu Ihrem CodeCatalyst Bereich hinzugefügt](ipa-connect-account-addroles.md) haben und dass die Rolle die folgenden Richtlinien enthält.

Wenn Sie keine IAM-Rolle angeben, verwendet die Aktion die Standard-IAM-Rolle, die in der [Umgebung](deploy-environments.md) in der CodeCatalyst Konsole aufgeführt ist. Wenn Sie die Standardrolle in der Umgebung verwenden, stellen Sie sicher, dass sie über die folgenden Richtlinien verfügt.
+ Die folgende Berechtigungsrichtlinie:
**Warnung**  
Beschränken Sie die Berechtigungen auf die in der folgenden Richtlinie angegebenen. Die Verwendung einer Rolle mit umfassenderen Berechtigungen kann ein Sicherheitsrisiko darstellen.
**Anmerkung**  
Wenn die Rolle zum ersten Mal verwendet wird, verwenden Sie den folgenden Platzhalter in der Ressourcenrichtlinienanweisung und grenzen Sie dann die Richtlinie mit dem Ressourcennamen ab, sobald sie verfügbar ist.  

  ```
  "Resource": "*"
  ```
+ Die folgende benutzerdefinierte Vertrauensrichtlinie:

**Anmerkung**  
Sie können die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle mit dieser Aktion verwenden, wenn Sie möchten. Weitere Informationen über diese Rolle finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über volle Zugriffsberechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. 

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte Environment/account/role „Konfiguration“ /' '/ Rolle**

## Inputs
<a name="deploy.action.cfn.inputs"></a>

(*DeployCloudFormationStack*/**Inputs**)

(Optional)

`Inputs`In diesem Abschnitt werden die Daten definiert, die während einer `DeployCloudFormationStack` Workflow-Ausführung benötigt werden.

**Anmerkung**  
Pro ** CloudFormation Stack-Aktion vom Typ Deploy** sind maximal vier Eingaben (eine Quelle und drei Artefakte) zulässig.

Wenn Sie auf Dateien verweisen müssen, die sich in verschiedenen Eingaben befinden (z. B. eine Quelle und ein Artefakt), ist die Quelleingabe die primäre Eingabe und das Artefakt die sekundäre Eingabe. Verweise auf Dateien in sekundären Eingaben benötigen ein spezielles Präfix, um sie von der primären Eingabe zu unterscheiden. Details hierzu finden Sie unter [Beispiel: Referenzieren von Dateien in mehreren Artefakten](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).

**Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“**

## Sources
<a name="deploy.action.cfn.inputs.sources"></a>

(*DeployCloudFormationStack*/Inputs/**Sources**)

(Erforderlich, wenn Ihre AWS SAM Vorlage CloudFormation oder Ihre Vorlage in einem Quell-Repository gespeichert ist)

Wenn Ihre AWS SAM Vorlage CloudFormation oder Ihre Vorlage in einem Quell-Repository gespeichert ist, geben Sie die Bezeichnung dieses Quell-Repositorys an. Derzeit ist das einzige unterstützte Label`WorkflowSource`.

Wenn Ihre AWS SAM Vorlage CloudFormation oder nicht in einem Quell-Repository enthalten ist, muss sie sich in einem Artefakt befinden, das durch eine andere Aktion generiert wurde, oder in einem Amazon S3 S3-Bucket.

Weitere Informationen zu Quellen finden Sie unter [Quell-Repositorys mit Workflows verbinden](workflows-sources.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„Quellen“ — optional**

## Artifacts - input
<a name="deploy.action.cfn.inputs.artifacts"></a>

(*DeployCloudFormationStack*/Inputs/**Artifacts**)

(Erforderlich, wenn Ihre AWS SAM Vorlage CloudFormation oder Ihre Vorlage in einem [Ausgabeartefakt](workflows-working-artifacts-output.md) einer vorherigen Aktion gespeichert ist)

Wenn die AWS SAM Vorlage CloudFormation oder, die Sie bereitstellen möchten, in einem Artefakt enthalten ist, das durch eine vorherige Aktion generiert wurde, geben Sie dieses Artefakt hier an. Wenn Ihre CloudFormation Vorlage nicht in einem Artefakt enthalten ist, muss sie sich in Ihrem Quell-Repository oder in einem Amazon S3 S3-Bucket befinden.

Weitere Informationen zu Artefakten, einschließlich Beispielen, finden Sie unter. [Artefakte und Dateien zwischen Aktionen teilen](workflows-working-artifacts.md)

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/„**Artefakte“ — optional**

## Configuration
<a name="deploy.action.cfn.configuration"></a>

(*DeployCloudFormationStack*/**Configuration**)

(Erforderlich)

Ein Abschnitt, in dem Sie die Konfigurationseigenschaften der Aktion definieren können.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration**“

## name
<a name="deploy.action.cfn.stackname"></a>

(*DeployCloudFormationStack*/Configuration/**name**)

(Erforderlich)

Geben Sie einen Namen für den CloudFormation Stack an, den die Aktion ** CloudFormation Stack bereitstellen** erstellt oder aktualisiert.

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/Name des **Stacks**

## region
<a name="deploy.action.cfn.stackregion"></a>

(*DeployCloudFormationStack*/Configuration/**region**)

(Erforderlich)

Geben Sie an, AWS-Region in welchem Bereich der Stack bereitgestellt werden soll. Eine Liste der Regionscodes finden Sie unter [Regionale Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/Region „Stack“**

## template
<a name="deploy.action.cfn.templatepath"></a>

(*DeployCloudFormationStack*/Configuration/**template**)

(Erforderlich)

Geben Sie den Namen und den Pfad zu Ihrer Datei CloudFormation oder der AWS SAM Vorlagendatei an. Die Vorlage kann im JSON- oder YAML-Format vorliegen und sich in einem Quell-Repository, einem Artefakt aus einer früheren Aktion oder einem Amazon S3 S3-Bucket befinden. Wenn sich die Vorlagendatei in einem Quell-Repository oder Artefakt befindet, ist der Pfad relativ zur Quelle oder zum Artefakt-Stamm. Wenn sich die Vorlage in einem Amazon S3 S3-Bucket befindet, entspricht der Pfad dem **Objekt-URL-Wert** der Vorlage.

Beispiele:

`./MyFolder/MyTemplate.json`

`MyFolder/MyTemplate.yml`

`https://MyBucket.s3.us-west-2.amazonaws.com/MyTemplate.yml`

**Anmerkung**  
Möglicherweise müssen Sie dem Dateipfad der Vorlage ein Präfix hinzufügen, um anzugeben, in welchem Artefakt oder in welcher Quelle die Vorlage gefunden werden soll. Weitere Informationen erhalten Sie unter [Quell-Repository-Dateien referenzieren](workflows-sources-reference-files.md) und [Referenzieren von Dateien in einem Artefakt](workflows-working-artifacts-refer-files.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Vorlage“**

## role-arn
<a name="deploy.action.cfn.stackrolearn"></a>

(*DeployCloudFormationStack*/Configuration/**role-arn**)

(Erforderlich)

Geben Sie den Amazon-Ressourcennamen (ARN) der Stack-Rolle an. CloudFormation verwendet diese Rolle, um auf Ressourcen in Ihrem Stack zuzugreifen und diese zu ändern. Beispiel: `arn:aws:iam::123456789012:role/StackRole`.

Stellen Sie sicher, dass die Stack-Rolle Folgendes beinhaltet:
+ Eine oder mehrere Berechtigungsrichtlinien. Die Richtlinien hängen von den Ressourcen ab, die Sie in Ihrem Stack haben. Wenn Ihr Stack beispielsweise eine AWS Lambda Funktion enthält, müssen Sie Berechtigungen hinzufügen, die Zugriff auf Lambda gewähren. Wenn Sie das unter beschriebene Tutorial befolgt haben[Tutorial: Eine serverlose Anwendung bereitstellen](deploy-tut-lambda.md), enthält es ein Verfahren mit dem Titel, [Um eine Stack-Rolle zu erstellen](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles-stack) das die Berechtigungen auflistet, die die Stack-Rolle benötigt, wenn Sie einen typischen serverlosen Anwendungsstapel bereitstellen.
**Warnung**  
Beschränken Sie die Berechtigungen auf diejenigen, die der CloudFormation Dienst für den Zugriff auf Ressourcen in Ihrem Stack benötigt. Die Verwendung einer Rolle mit umfassenderen Berechtigungen kann ein Sicherheitsrisiko darstellen.
+ Die folgende Vertrauensrichtlinie:

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "",
              "Effect": "Allow",
              "Principal": {
                  "Service": "cloudformation.amazonaws.com"
              },
              "Action": "sts:AssumeRole"
          }
      ]
  }
  ```

------

Ordnen Sie diese Rolle optional Ihrer Kontoverbindung zu. Weitere Informationen zum Zuordnen einer IAM-Rolle zu einer Kontoverbindung finden Sie unter. [Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md) Wenn Sie die Stack-Rolle nicht mit der Kontoverbindung verknüpfen, wird die Stack-Rolle nicht in der Dropdownliste **Stack-Rolle** im Visual Editor angezeigt. Der Rollen-ARN kann jedoch trotzdem mit dem YAML-Editor in dem `role-arn` Feld angegeben werden.

**Anmerkung**  
Sie können die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle mit dieser Aktion verwenden, wenn Sie möchten. Weitere Informationen über diese Rolle finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über volle Zugriffsberechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. 

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ **/Rolle „Stack“ — optional**

## capabilities
<a name="deploy.action.cfn.capabilities"></a>

(*DeployCloudFormationStack*/Configuration/**capabilities**)

(Erforderlich)

Geben Sie eine Liste der IAM-Funktionen an, die für die Erstellung bestimmter CloudFormation Stacks erforderlich sind. In den meisten Fällen können Sie `capabilities` den Standardwert von beibehalten. `CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND`

Wenn Sie `##[error] requires capabilities: [capability-name]` in den Protokollen Ihrer ** CloudFormation Stack-Aktion „Bereitstellen**“ etwas sehen, finden Sie unter Informationen [Wie behebe ich Fehler bei den IAM-Fähigkeiten?](troubleshooting-workflows.md#troubleshooting-workflows-capabilities) zur Behebung des Problems.

*Weitere Informationen zu IAM-Funktionen finden Sie im [IAM-Benutzerhandbuch unter Bestätigung von IAM-Ressourcen in CloudFormation Vorlagen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities).*

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /Erweitert/Funktionen**

## parameter-overrides
<a name="deploy.action.cfn.parameter.overrides"></a>

(*DeployCloudFormationStack*/Configuration/**parameter-overrides**)

(Optional)

Geben Sie in Ihrer CloudFormation AWS SAM Vorlage Parameter an, die keine Standardwerte haben oder für die Sie nicht standardmäßige Werte angeben möchten. Weitere Informationen zu Parametern finden Sie unter [Parameter](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html) im * AWS CloudFormation Benutzerhandbuch*.

Die `parameter-overrides` Unterkunft akzeptiert:
+ Eine JSON-Datei, die die Parameter und Werte enthält.
+ Eine durch Kommas getrennte Liste von Parametern und Werten.

**Um eine JSON-Datei anzugeben**

1. Stellen Sie sicher, dass die JSON-Datei eine der folgenden Syntaxen verwendet:

   ```
   {
     "Parameters": {
       "Param1": "Value1",
       "Param2": "Value2",
       ...
     }
   }
   ```

   Oder...

   ```
   [
     {
        "ParameterKey": "Param1",
        "ParameterValue": "Value1"
     },
     ...
   ]
   ```

   (Es gibt andere Syntaxen, aber sie werden CodeCatalyst zum Zeitpunkt des Schreibens nicht unterstützt.) Weitere Informationen zum Angeben von CloudFormation Parametern in einer JSON-Datei finden Sie unter [Unterstützte JSON-Syntax](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudformation/deploy/index.html#supported-json-syntax) in der *AWS CLI Befehlsreferenz.*

1. Geben Sie den Pfad zur JSON-Datei in einem der folgenden Formate an:
   + Wenn sich Ihre JSON-Datei in einem Ausgabeartefakt einer früheren Aktion befindet, verwenden Sie:

     `file:///artifacts/current-action-name/output-artifact-name/path-to-json-file`

     Einzelheiten finden Sie in **Beispiel 1.**
   + Wenn sich Ihre JSON-Datei in Ihrem Quell-Repository befindet, verwenden Sie:

     `file:///sources/WorkflowSource/path-to-json-file`

     Einzelheiten finden Sie in **Beispiel 2.**

     **Beispiel 1** — Die JSON-Datei befindet sich in einem Ausgabeartefakt

     ```
     ##My workflow YAML
     ...
     Actions:
       MyBuildAction:
         Identifier: aws/build@v1
         Outputs:
           Artifacts:
             - Name: ParamArtifact
               Files:
                 - params.json
         Configuration:
         ...
       MyDeployCFNStackAction:
         Identifier: aws/cfn-deploy@v1
         Configuration:
           parameter-overrides: file:///artifacts/MyDeployCFNStackAction/ParamArtifact/params.json
     ```

     **Beispiel 2** — Die JSON-Datei befindet sich in Ihrem Quell-Repository in einem Ordner namens `my/folder`

     ```
     ##My workflow YAML
     ...
     Actions:
       MyDeployCloudFormationStack:
         Identifier: aws/cfn-deploy@v1
         Inputs:
           Sources:
             - WorkflowSource
         Configuration:
           parameter-overrides: file:///sources/WorkflowSource/my/folder/params.json
     ```

**Um eine durch Kommas getrennte Liste von Parametern zu verwenden**
+ Fügen Sie der `parameter-overrides` Eigenschaft Parameter-Name-Wert-Paare im folgenden Format hinzu:

  `param-1=value-1,param-2=value-2`

  Nehmen wir zum Beispiel die folgende Vorlage an: CloudFormation 

  ```
  ##My CloudFormation template
  
  Description: My CloudFormation template
  
  Parameters:
    InstanceType:
      Description: Defines the Amazon EC2 compute for the production server.
      Type: String
      Default: t2.micro
      AllowedValues:
        - t2.micro
        - t2.small
        - t3.medium
      
  Resources:
  ...
  ```

  ... Sie könnten die `parameter-overrides` Eigenschaft wie folgt festlegen:

  ```
  ##My workflow YAML
  ...
  Actions:
  ...
    DeployCloudFormationStack:
      Identifier: aws/cfn-deploy@v1
      Configuration:
        parameter-overrides: InstanceType=t3.medium,UseVPC=true
  ```
**Anmerkung**  
Sie können einen Parameternamen ohne einen entsprechenden Wert angeben, indem Sie `undefined` ihn als Wert verwenden. Beispiel:  
`parameter-overrides: MyParameter=undefined`  
 Das hat zur Folge, dass bei einem Stack-Update der vorhandene Parameterwert für den angegebenen Parameternamen CloudFormation verwendet wird.

Entsprechende Benutzeroberfläche:
+ **Registerkarte „Konfiguration/Erweitert/Parameterüberschreibungen“**
+ tab/Advanced/Parameter**Überschreibungen der Konfiguration/ Geben Sie Überschreibungen mithilfe einer Datei an**
+ **Überschreibungen der tab/Advanced/Parameter Konfiguration/ Spezifizieren Sie Überschreibungen mithilfe eines Wertesatzes**

## no-execute-changeset
<a name="deploy.action.cfn.noexecutechangeset"></a>

(*DeployCloudFormationStack*/Configuration/**no-execute-changeset**)

(Optional)

Geben Sie an, ob Sie den CloudFormation Änderungssatz erstellen und dann beenden möchten CodeCatalyst , bevor Sie ihn ausführen. Auf diese Weise haben Sie die Möglichkeit, den Änderungssatz in der CloudFormation Konsole zu überprüfen. Wenn Sie feststellen, dass der Änderungssatz gut aussieht, deaktivieren Sie diese Option und führen Sie dann den Workflow erneut aus, sodass Sie den Änderungssatz erstellen und ausführen CodeCatalyst können, ohne ihn anzuhalten. Standardmäßig wird der Änderungssatz erstellt und ausgeführt, ohne ihn anzuhalten. Weitere Informationen finden Sie im CloudFormation [Deploy-Parameter](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) in der *AWS CLI Befehlsreferenz*. Weitere Informationen zum Anzeigen von Änderungssätzen finden Sie im *AWS CloudFormation Benutzerhandbuch* unter [Änderungssätze anzeigen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets-view.html).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /Erweitert/Änderungssatz nicht ausführen**

## fail-on-empty-changeset
<a name="deploy.action.cfn.failonemptychangeset"></a>

(*DeployCloudFormationStack*/Configuration/**fail-on-empty-changeset**)

(Optional)

Geben Sie an, ob die Aktion „** CloudFormation Stack bereitstellen**“ fehlschlagen soll CodeCatalyst , wenn der CloudFormation Änderungssatz leer ist. (Wenn ein Änderungssatz leer ist, bedeutet dies, dass während der letzten Bereitstellung keine Änderungen am Stack vorgenommen wurden.) Standardmäßig kann die Aktion fortgesetzt werden, wenn der Änderungssatz leer ist, und es wird eine `UPDATE_COMPLETE` Meldung zurückgegeben, obwohl der Stack nicht aktualisiert wurde.

Weitere Informationen zu dieser Einstellung finden Sie im CloudFormation [Deploy-Parameter](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) in der *AWS CLI Befehlsreferenz*. Weitere Informationen zu Änderungssätzen finden Sie unter [Aktualisieren von Stacks mithilfe von Änderungssätzen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html) im *AWS CloudFormation Benutzerhandbuch*.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /Erweitert/Fehler bei leerem Changeset**

## disable-rollback
<a name="deploy.action.cfn.disablerollback"></a>

(*DeployCloudFormationStack*/Configuration/**disable-rollback**)

(Optional)

Geben Sie an, ob Sie die Stack-Bereitstellung rückgängig CodeCatalyst machen möchten, falls sie fehlschlägt. Durch das Rollback wird der Stack in den letzten bekannten stabilen Zustand zurückversetzt. Standardmäßig werden Rollbacks aktiviert. Weitere Informationen zu dieser Einstellung finden Sie im CloudFormation [Deploy-Parameter](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) in der *AWS CLI Befehlsreferenz.*

Weitere Informationen dazu, wie die Aktion ** CloudFormation Stack bereitstellen** Rollbacks behandelt, finden Sie unter[Rollbacks konfigurieren](deploy-consumption-enable-alarms.md).

Weitere Informationen zum Rollback eines Stacks finden Sie unter [Optionen für Stack-Fehler](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stack-failure-options.html) im *AWS CloudFormation Benutzerhandbuch*.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /Erweitert/Rollback deaktivieren**

## termination-protection
<a name="deploy.action.cfn.terminationprotection"></a>

(*DeployCloudFormationStack*/Configuration/**termination-protection**)

(Optional)

Geben Sie an, ob der ** CloudFormation Deploy-Stack dem Stack**, den er bereitstellt, einen Kündigungsschutz hinzufügen soll. Wenn ein Benutzer versucht, einen Stack mit aktiviertem Beendigungsschutz zu löschen, schlägt das Löschen fehl und der Stack – einschließlich seines Status – bleibt unverändert. Standardmäßig ist der Kündigungsschutz deaktiviert. Weitere Informationen finden Sie im *AWS CloudFormation Benutzerhandbuch* unter [Einen Stack vor dem Löschen schützen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /„ Erweitert/Kündigungsschutz“**

## timeout-in-minutes
<a name="deploy.action.cfn.timeoutinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**timeout-in-minutes**)

(Optional)

Geben Sie die Zeitspanne in Minuten an, die zur Verfügung stehen CloudFormation soll, bevor bei der Stackerstellung ein Timeout eintritt und der Stack-Status auf gesetzt wird. `CREATE_FAILED` Wenn CloudFormation innerhalb des zugeteilten Zeitraums nicht den gesamten Stack erstellen kann, schlägt die Stack-Erstellung aufgrund des Timeouts fehl und für den Stack wird ein Rollback durchgeführt.

Standardmäßig gibt es keinen Timeout für die Stack-Erstellung. Allerdings gibt es möglicherweise für einzelne Ressourcen einen Timeout, basierend auf der Art des von ihnen implementierten Services. Wenn beispielsweise eine einzelne Ressource in Ihrem Stack abläuft, läuft die Stack-Erstellung ebenfalls aus, auch wenn der von Ihnen angegebene Timeout für die Stack-Erstellung noch nicht erreicht wurde.

**Entsprechende Benutzeroberfläche: Registerkarte CloudFormation „Konfiguration“ /„ Erweitert/Timeout“**

## notification-arns
<a name="deploy.action.cfn.notificationarns"></a>

(*DeployCloudFormationStack*/Configuration/**notification-arns**)

(Optional)

Geben Sie den ARN eines Amazon SNS SNS-Themas an, CodeCatalyst an das Sie Benachrichtigungen senden möchten. Beispiel, `arn:aws:sns:us-east-1:111222333:MyTopic`. Wenn die Aktion „** CloudFormation Stack bereitstellen**“ ausgeführt wird CodeCatalyst , wird CloudFormation für jedes CloudFormation Ereignis, das während der Erstellung oder Aktualisierung des Stacks auftritt, jeweils eine Benachrichtigung gesendet. (Die Ereignisse sind auf der Registerkarte **Ereignisse** der CloudFormation Konsole für den Stack sichtbar.) Sie können bis zu fünf Themen angeben. Weitere Informationen finden Sie unter [Was ist Amazon SNS?](https://docs.aws.amazon.com/sns/latest/dg/welcome.html).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /„ Erweitert/Benachrichtigung“ ARNs**

## monitor-alarm-arns
<a name="deploy.action.cfn.monitoralarmarns"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-alarm-arns**)

(Optional)

Geben Sie den Amazon-Ressourcennamen (ARN) eines CloudWatch Amazon-Alarms an, der als Rollback-Trigger verwendet werden soll. Beispiel, `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`. Sie können maximal fünf Rollback-Trigger haben.

**Anmerkung**  
Wenn Sie einen CloudWatch Alarm-ARN angeben, müssen Sie auch zusätzliche Berechtigungen konfigurieren, damit die Aktion darauf zugreifen kann CloudWatch. Weitere Informationen finden Sie unter [Rollbacks konfigurieren](deploy-consumption-enable-alarms.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /„ Erweitert/Alarm überwachen“ ARNs**

## monitor-timeout-in-minutes
<a name="deploy.action.cfn.monitortimeinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-timeout-in-minutes**)

(Optional)

Geben Sie einen Zeitraum zwischen 0 und 180 Minuten an, in dem die angegebenen Alarme CloudFormation überwacht werden. Die Überwachung beginnt, *nachdem* alle Stack-Ressourcen bereitgestellt wurden. Wenn der Alarm innerhalb der angegebenen Überwachungszeit auftritt, CloudFormation schlägt die Bereitstellung fehl und der gesamte Stack-Vorgang wird rückgängig gemacht.

Standard: 0. CloudFormation überwacht Alarme nur, während die Stack-Ressourcen bereitgestellt werden, nicht danach.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /„ Erweitert/Zeit überwachen“**

## tags
<a name="deploy.action.cfn.tags"></a>

(*DeployCloudFormationStack*/Configuration/**tags**)

(Optional)

Geben Sie Tags an, die an Ihren Stack angehängt werden sollen. CloudFormation Tags sind beliebige Schlüssel-Wert-Paare, die Sie verwenden können, um Ihren Stack für Zwecke wie die Kostenzuweisung zu identifizieren. Weitere Informationen zu Tags und ihrer Verwendung finden Sie unter [Tagging Ihrer Ressourcen](https://docs.aws.amazon.com/) im *Amazon EC2-Benutzerhandbuch*. *Weitere Informationen zum Tagging finden Sie unter [CloudFormation Stack-Optionen einrichten](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html) im AWS CloudFormation Benutzerhandbuch. CloudFormation*

Ein Schlüssel kann alphanumerische Zeichen oder Leerzeichen und bis zu 127 Zeichen enthalten. Ein Wert kann alphanumerische Zeichen oder Leerzeichen und bis zu 255 Zeichen enthalten.

Sie können bis zu 50 eindeutige Tags für jeden Stack hinzufügen.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“ /„ Erweitert/Tags“**

# Eine AWS CDK App mit einem Workflow bereitstellen
<a name="cdk-dep-action"></a>

In diesem Abschnitt wird beschrieben, wie Sie mithilfe eines Workflows eine AWS Cloud Development Kit (AWS CDK) App in Ihrem AWS Konto bereitstellen. Um dies zu erreichen, müssen Sie die **AWS CDK Bereitstellungsaktion** zu Ihrem Workflow hinzufügen. Die **AWS CDK Bereitstellungsaktion** synthetisiert Ihre AWS Cloud Development Kit (AWS CDK) App und stellt sie bereit in. AWS Wenn Ihre App bereits in vorhanden ist AWS, wird sie bei Bedarf durch die Aktion aktualisiert. 

Allgemeine Informationen zum Schreiben von Apps mit dem AWS CDK finden Sie unter [Was ist der AWS CDK?](https://docs.aws.amazon.com/cdk/v2/guide/home.html) im *AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch*.

**Topics**
+ [Wann sollte die Aktion „AWS CDK Bereitstellen“ verwendet werden](#cdk-dep-action-when-to-use)
+ [So funktioniert die Aktion „AWS CDK Bereitstellen“](#cdk-dep-action-how-it-works)
+ [CDK-CLI-Versionen, die von der Aktion „AWS CDK Deploy“ verwendet werden](#cdk-dep-action-cdk-version)
+ [Von der Aktion „Deploy“AWS CDK verwendetes Runtime-Image](#cdk-dep-action-runtime)
+ [Wie viele Stapel kann die Aktion bereitstellen?](#cdk-dep-action-how-many-stacks)
+ [Beispiel: Eine AWS CDK App bereitstellen](cdk-dep-action-example-workflow.md)
+ [Aktion „AWS CDK Deploy“ hinzufügen](cdk-dep-action-add.md)
+ [Variablen 'AWS CDK bereitstellen'](cdk-dep-action-variables.md)
+ [Aktion 'AWS CDK bereitstellen' YAML](cdk-dep-action-ref.md)

## Wann sollte die Aktion „AWS CDK Bereitstellen“ verwendet werden
<a name="cdk-dep-action-when-to-use"></a>

Verwenden Sie diese Aktion AWS CDK, wenn Sie mit dem eine App entwickelt haben und diese nun automatisch als Teil des automatisierten Workflows für kontinuierliche Integration und Bereitstellung (CI/CD) bereitstellen möchten. Möglicherweise möchten Sie Ihre AWS CDK App beispielsweise automatisch bereitstellen, wenn jemand eine Pull-Anfrage zusammenführt, die sich auf Ihre AWS CDK App-Quelle bezieht. 

## So funktioniert die Aktion „AWS CDK Bereitstellen“
<a name="cdk-dep-action-how-it-works"></a>

Die **AWS CDK Bereitstellung** funktioniert wie folgt:

1. [Wenn Sie zur Laufzeit Version 1.0.12 oder früher der Aktion angegeben haben, lädt die Aktion die neueste CDK-CLI (auch AWS CDK Tookit genannt) in das Laufzeitumgebungsabbild herunter. CodeCatalyst ](#cdk-dep-action-runtime)

   Wenn Sie Version 1.0.13 oder höher angegeben haben, ist die Aktion mit einer [bestimmten Version](#cdk-dep-action-cdk-version) der CDK-CLI gebündelt, sodass kein Download stattfindet.

1. Die Aktion verwendet die CDK-CLI, um den `cdk deploy` Befehl auszuführen. Dieser Befehl synthetisiert Ihre AWS CDK App und stellt sie bereit in. AWS*Weitere Informationen zu diesem Befehl finden Sie im Developer Guide unter dem Thema [AWS CDK Toolkit (cdk-Befehl)](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html).AWS Cloud Development Kit (AWS CDK) *

## CDK-CLI-Versionen, die von der Aktion „AWS CDK Deploy“ verwendet werden
<a name="cdk-dep-action-cdk-version"></a>

Die folgende Tabelle zeigt, welche Version der CDK-CLI standardmäßig von verschiedenen Versionen der **AWS CDK Bereitstellungsaktion** verwendet wird.

**Anmerkung**  
Möglicherweise können Sie die Standardeinstellung überschreiben. Weitere Informationen finden Sie unter [CdkCliVersion](cdk-dep-action-ref.md#cdk.dep.cdk.cli.version) im [Aktion 'AWS CDK bereitstellen' YAML](cdk-dep-action-ref.md).


| AWS CDK Aktionsversion „bereitstellen“ | AWS CDK CLI-Version | 
| --- | --- | 
|  1.0.0 — 1.0.12  |  brandneue  | 
|  1.0.13 oder später  |  2.99.1  | 

## Von der Aktion „Deploy“AWS CDK verwendetes Runtime-Image
<a name="cdk-dep-action-runtime"></a>

Die folgende Tabelle zeigt die Runtime-Umgebungs-Images, die zur Ausführung verschiedener Versionen der **AWS CDK Bereitstellungsaktion CodeCatalyst ** verwendet werden. Die Bilder enthalten verschiedene Sätze vorinstallierter Tools. Weitere Informationen finden Sie unter [Aktive Bilder](build-images.md#build-curated-images).

**Anmerkung**  
Wir empfehlen, Ihre **AWS CDK Bereitstellungsaktion** auf Version 2.x zu aktualisieren, um die neuesten Tools nutzen zu können, die auf dem Image vom März 2024 verfügbar sind. Um die Aktion zu aktualisieren, legen Sie ihre `Identifier` Eigenschaft `aws/cdk-deploy@v2` in Ihrer Workflow-Definitionsdatei auf fest. Weitere Informationen finden Sie unter [Aktion 'AWS CDK bereitstellen' YAML](cdk-dep-action-ref.md). 


| Version der AWS CDK Aktion „bereitstellen“ | Images der Laufzeitumgebung | 
| --- | --- | 
|  1.x  |  Bilder vom November 2022  | 
|  2.x  |  Bilder vom März 2024  | 

## Wie viele Stapel kann die Aktion bereitstellen?
<a name="cdk-dep-action-how-many-stacks"></a>

Bei der **AWS CDK Bereitstellung** kann nur ein einziger Stack bereitgestellt werden. Wenn Ihre AWS CDK App aus mehreren Stacks besteht, müssen Sie einen übergeordneten Stack mit verschachtelten Stacks erstellen und den übergeordneten Stapel mithilfe dieser Aktion bereitstellen.

# Beispiel: Eine AWS CDK App bereitstellen
<a name="cdk-dep-action-example-workflow"></a>

Der folgende Beispiel-Workflow umfasst die **AWS CDK Bereitstellungsaktion** zusammen mit der **AWS CDK Bootstrap-Aktion**. Der Workflow besteht aus den folgenden Bausteinen, die nacheinander ausgeführt werden:
+ Ein **Trigger** — Dieser Trigger startet die Workflow-Ausführung automatisch, wenn Sie eine Änderung an Ihr Quell-Repository übertragen. Dieses Repository enthält Ihre AWS CDK App. Weitere Informationen zu Auslösern finden Sie unter [Automatisches Starten einer Workflow-Ausführung mithilfe von Triggern](workflows-add-trigger.md).
+ Eine **AWS CDK Bootstrap-Aktion** (`CDKBootstrap`) — Beim Auslösen stellt die Aktion den `CDKToolkit` Bootstrap-Stack in bereit. AWS Wenn der `CDKToolkit` Stack bereits in der Umgebung vorhanden ist, wird er bei Bedarf aktualisiert. Andernfalls passiert nichts und die Aktion wird als erfolgreich markiert.
+ Eine **AWS CDK Bereitstellungsaktion** (`AWS CDK Deploy`) — Nach Abschluss der **AWS CDK Bootstrap-Aktion** synthetisiert die **AWS CDK Bereitstellungsaktion** Ihren AWS CDK App-Code in einer CloudFormation Vorlage und stellt den in der Vorlage definierten Stack bereit. AWS

**Anmerkung**  
Das folgende Workflow-Beispiel dient der Veranschaulichung und funktioniert ohne zusätzliche Konfiguration nicht.

**Anmerkung**  
Im folgenden YAML-Code können Sie die `Connections:` Abschnitte weglassen, wenn Sie möchten. **Wenn Sie diese Abschnitte weglassen, müssen Sie sicherstellen, dass die im Feld **Standard-IAM-Rolle** angegebene Rolle in Ihrer Umgebung die Berechtigungen und Vertrauensrichtlinien enthält, die für die **AWS CDK Bootstrap** - und Deploy-Aktionen erforderlich sind.AWS CDK ** Weitere Informationen zum Einrichten einer Umgebung mit einer Standard-IAM-Rolle finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md) Weitere Informationen zu den Berechtigungen und Vertrauensrichtlinien, die für die Aktionen **AWS CDK Bootstrap** und **AWS CDK Deploy** erforderlich sind, finden Sie in der Beschreibung der `Role` Eigenschaft im Dokument und. [AWS CDK 'Bootstrap'-Aktion YAML](cdk-boot-action-ref.md) [Aktion 'AWS CDK bereitstellen' YAML](cdk-dep-action-ref.md)

```
Name: codecatalyst-cdk-deploy-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  CDKBootstrap:
    Identifier: aws/cdk-bootstrap@v2
    Inputs:
      Sources:
        - WorkflowSource
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-bootstrap-role
    Configuration:
      Region: us-west-2
        
  CDKDeploy:
    Identifier: aws/cdk-deploy@v2
    DependsOn: 
      - CDKBootstrap
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-deploy-role
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      StackName: my-app-stack
      Region: us-west-2
```

# Aktion „AWS CDK Deploy“ hinzufügen
<a name="cdk-dep-action-add"></a>

 Verwenden Sie die folgenden Anweisungen, um die **AWS CDK Bereitstellungsaktion** zu Ihrem Workflow hinzuzufügen. 

**Bevor Sie beginnen**

Bevor Sie die **AWS CDK Bereitstellungsaktion** zu Ihrem Workflow hinzufügen können, müssen Sie die folgenden Aufgaben ausführen:

1. **Halten Sie eine AWS CDK App bereit**. Sie können Ihre AWS CDK App mit AWS CDK Version 1 oder 2 in jeder Programmiersprache schreiben, die von der unterstützt wird AWS CDK. Stellen Sie sicher, dass Ihre AWS CDK App-Dateien verfügbar sind in:
   + Ein CodeCatalyst [Quell-Repository](source.md) oder 
   + Ein CodeCatalyst [Ausgabeartefakt](workflows-working-artifacts.md), das durch eine andere Workflow-Aktion generiert wurde

1. **Bootstrap für Ihre Umgebung AWS **. Um ein Bootstrap zu erstellen, können Sie:
   + Verwenden Sie eine der Methoden, die im *AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch* unter [How to Bootstrap](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-howto) beschrieben sind.
   + Verwenden Sie die **AWS CDK Bootstrap-Aktion**. Sie können diese Aktion im selben Workflow wie Ihre **AWS CDK Bereitstellung** oder in einem anderen Workflow hinzufügen. Stellen Sie einfach sicher, dass die Bootstrap-Aktion mindestens einmal ausgeführt wird, bevor **AWS CDK Sie die Bereitstellungsaktion** ausführen, damit die erforderlichen Ressourcen vorhanden sind. Weitere Informationen zur **AWS CDK Bootstrap-Aktion** finden Sie unter. [Bootstrapping einer AWS CDK App mit einem Workflow](cdk-boot-action.md)

     *Weitere Informationen zu Bootstrapping finden Sie unter [Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) im Entwicklerhandbuch.AWS Cloud Development Kit (AWS CDK) *

------
#### [ Visual ]

**So fügen Sie die Aktion „AWS CDK Deploy“ mit dem Visual Editor hinzu**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie oben links **\$1 Aktionen**, um den Aktionskatalog zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der **AWS CDK Bereitstellungsaktion** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie **AWS CDK Bereitstellen** aus. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Herunterladen**“, um [den Quellcode der Aktion anzuzeigen](workflows-view-source.md#workflows-view-source.title).
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Füllen Sie auf den Registerkarten **Eingaben** und **Konfiguration** die Felder nach Ihren Bedürfnissen aus. Eine Beschreibung der einzelnen Felder finden Sie unter[Aktion 'AWS CDK bereitstellen' YAML](cdk-dep-action-ref.md). Diese Referenz enthält detaillierte Informationen zu jedem Feld (und dem entsprechenden YAML-Eigenschaftswert), wie es sowohl im YAML- als auch im visuellen Editor angezeigt wird.

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein, und wählen Sie dann erneut **Commit** aus.
**Anmerkung**  
Wenn Ihre **AWS CDK Bereitstellungsaktion** mit einem `npm install` Fehler fehlschlägt, finden Sie unter Informationen [Wie behebe ich „npm install“ -Fehler?](troubleshooting-workflows.md#troubleshooting-workflows-npm) zur Behebung des Fehlers.

------
#### [ YAML ]

**Um die Aktion „AWS CDK Deploy“ mit dem YAML-Editor hinzuzufügen**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Wählen Sie links oben **\$1 Aktionen aus, um den Aktionskatalog** zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der **AWS CDK Bereitstellungsaktion** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie **AWS CDK Bereitstellen** aus. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Herunterladen**“, um [den Quellcode der Aktion anzuzeigen](workflows-view-source.md#workflows-view-source.title).
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Ändern Sie die Eigenschaften im YAML-Code nach Ihren Bedürfnissen. Eine Erläuterung der einzelnen verfügbaren Eigenschaften finden Sie in der[Aktion 'AWS CDK bereitstellen' YAML](cdk-dep-action-ref.md).

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein, und wählen Sie dann erneut **Commit** aus.
**Anmerkung**  
Wenn Ihre **AWS CDK Bereitstellungsaktion** mit einem `npm install` Fehler fehlschlägt, finden Sie unter Informationen [Wie behebe ich „npm install“ -Fehler?](troubleshooting-workflows.md#troubleshooting-workflows-npm) zur Behebung des Fehlers.

------

# Variablen 'AWS CDK bereitstellen'
<a name="cdk-dep-action-variables"></a>

Die Aktion **AWS CDK Deploy** erzeugt und setzt zur Laufzeit die folgenden Variablen. Diese werden als *vordefinierte Variablen* bezeichnet.

Hinweise zum Verweisen auf diese Variablen in einem Workflow finden Sie unter[Verwenden vordefinierter Variablen](workflows-using-predefined-variables.md).


| Key (Schlüssel) | Value (Wert) | 
| --- | --- | 
|  Stack-ID  |  Der Amazon-Ressourcenname (ARN) des AWS CDK Anwendungsstapels, für den während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-app-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  Bereitstellungsplattform  |  Der Name der Bereitstellungsplattform. Fest codiert auf. `AWS:CloudFormation`  | 
|  Region  |  Der Regionalcode von AWS-Region , für den während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `us-west-2`  | 
|  BEREITSTELLUNG ÜBERSPRINGEN  |  Der Wert von `true` gibt an, dass die Bereitstellung Ihres AWS CDK Anwendungsstapels während der Workflow-Ausführung übersprungen wurde. Eine Stack-Bereitstellung wird übersprungen, wenn sich der Stack seit der letzten Bereitstellung nicht geändert hat. Diese Variable wird nur erzeugt, wenn ihr Wert ist`true`. Fest codiert auf. `true`  | 
|  *CloudFormation Variablen*  |  Die Aktion „**AWS CDK Bereitstellen**“ generiert nicht nur die zuvor aufgeführten Variablen, sondern stellt auch *CloudFormation*Ausgabevariablen als *Workflow-Variablen* zur Verwendung in nachfolgenden Workflow-Aktionen zur Verfügung. Standardmäßig macht die Aktion nur die ersten vier (oder weniger) CloudFormation Variablen verfügbar, die sie findet. Um festzustellen, welche verfügbar gemacht werden, führen Sie die **AWS CDK Bereitstellungsaktion** einmal aus und schauen Sie dann auf der Seite mit den Ausführungsdetails auf der Registerkarte **Variablen** nach. Wenn die auf der Registerkarte **Variablen** aufgelisteten Variablen nicht Ihren Wünschen entsprechen, können Sie mithilfe der `CfnOutputVariables` YAML-Eigenschaft andere Variablen konfigurieren. Weitere Informationen finden Sie in der [CfnOutputVariables](cdk-dep-action-ref.md#cdk.dep.cfn.out) Eigenschaftsbeschreibung im[Aktion 'AWS CDK bereitstellen' YAML](cdk-dep-action-ref.md).  | 

# Aktion 'AWS CDK bereitstellen' YAML
<a name="cdk-dep-action-ref"></a>

Im Folgenden finden Sie die YAML-Definition der **AWS CDK Bereitstellungsaktion**. Informationen zur Verwendung dieser Aktion finden Sie unter[Eine AWS CDK App mit einem Workflow bereitstellen](cdk-dep-action.md).

Diese Aktionsdefinition ist als Abschnitt in einer umfassenderen Workflow-Definitionsdatei vorhanden. Weitere Informationen über diese Datei finden Sie unter [YAML-Workflow-Definition](workflow-reference.md).

**Anmerkung**  
Die meisten der folgenden YAML-Eigenschaften haben entsprechende Benutzeroberflächenelemente im visuellen Editor. Verwenden Sie **Strg\$1F**, um nach einem UI-Element zu suchen. Das Element wird mit der zugehörigen YAML-Eigenschaft aufgelistet.

```
# The workflow definition starts here.
# See Eigenschaften der obersten Ebene for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  CDKDeploy\$1nn: 
    Identifier: aws/cdk-deploy@v2
    DependsOn:
      - CDKBootstrap
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_artifact
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      StackName: my-cdk-stack
      Region: us-west-2
      Tags: '{"key1": "value1", "key2": "value2"}'
      Context: '{"key1": "value1", "key2": "value2"}'
      CdkCliVersion: version
      CdkRootPath: directory-containing-cdk.json-file
      CfnOutputVariables: '["CnfOutputKey1","CfnOutputKey2","CfnOutputKey3"]'
      CloudAssemblyRootPath: path-to-cdk.out
```

## CDKDeploy
<a name="cdk.dep.name"></a>

(Erforderlich)

Geben Sie den Namen der Aktion an. Alle Aktionsnamen müssen innerhalb des Workflows eindeutig sein. Aktionsnamen sind auf alphanumerische Zeichen (a-z, A-Z, 0-9), Bindestriche (-) und Unterstriche (\$1) beschränkt. Leerzeichen sind nicht erlaubt. Sie können keine Anführungszeichen verwenden, um Sonderzeichen und Leerzeichen in Aktionsnamen zuzulassen.

Standard: `CDKDeploy_nn`.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration/Aktionsname“**

## Identifier
<a name="cdk.dep.identifier"></a>

(*CDKDeploy*/**Identifier**)

(Erforderlich)

Identifiziert die Aktion. Ändern Sie diese Eigenschaft nur, wenn Sie die Version ändern möchten. Weitere Informationen finden Sie unter [Angabe der zu verwendenden Aktionsversion](workflows-action-versions.md).

**Anmerkung**  
Wenn `aws/cdk-deploy@v2` Sie angeben, wird die Aktion für das [Image vom März 2024](build-images.md#build.default-image) ausgeführt, das neuere Tools wie Node.js 18 enthält. Durch `aws/cdk-deploy@v1` die Angabe wird die Aktion auf dem [Image vom November 2022](build-images.md#build.previous-image) ausgeführt, das ältere Tools wie Node.js 16 enthält.

Standard: `aws/cdk-deploy@v2`.

**Entsprechende Benutzeroberfläche: Workflow-Diagram/ CDKDeploy \$1nn/ aws/cdk-deploy @v2 label**

## DependsOn
<a name="cdk.dep.dependson"></a>

(*CDKDeploy*/**DependsOn**)

(Optional)

**Geben Sie eine Aktion oder Aktionsgruppe an, die erfolgreich ausgeführt werden muss, damit die Bereitstellungsaktion ausgeführt werden kann.AWS CDK ** Wir empfehlen, die **AWS CDK Bootstrap-Aktion** in der `DependsOn` Eigenschaft wie folgt anzugeben:

```
CDKDeploy:
  Identifier: aws/cdk-deploy@v2
  DependsOn:
    - CDKBootstrap
```

**Anmerkung**  
[Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) ist eine zwingende Voraussetzung für die Bereitstellung einer App. AWS CDK **Wenn Sie die **AWS CDK Bootstrap-Aktion** nicht in Ihren Workflow aufnehmen, müssen Sie eine andere Möglichkeit finden, den AWS CDK Bootstrap-Stack bereitzustellen, bevor Sie Ihre Bereitstellungsaktion ausführen.AWS CDK ** Weitere Informationen finden Sie unter [Aktion „AWS CDK Deploy“ hinzufügen](cdk-dep-action-add.md) in [Eine AWS CDK App mit einem Workflow bereitstellen](cdk-dep-action.md).

Weitere Informationen zur Funktion „Hängt davon ab“ finden Sie unter. [Aktionen sequenzieren](workflows-depends-on.md)

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Hängt davon ab**“ — optional

## Compute
<a name="cdk.dep.computename"></a>

(*CDKDeploy*/**Compute**)

(Optional)

Die Rechen-Engine, mit der Ihre Workflow-Aktionen ausgeführt wurden. Sie können die Berechnung entweder auf Workflow-Ebene oder auf Aktionsebene angeben, aber nicht beide. Wenn auf Workflow-Ebene angegeben, gilt die Rechenkonfiguration für alle im Workflow definierten Aktionen. Auf Workflow-Ebene können Sie auch mehrere Aktionen auf derselben Instanz ausführen. Weitere Informationen finden Sie unter [Rechenleistung für mehrere Aktionen gemeinsam nutzen](compute-sharing.md).

Entsprechende Benutzeroberfläche: *keine*

## Type
<a name="cdk.dep.computetype"></a>

(*CDKDeploy*/Compute/**Type**)

([Compute](#cdk.dep.computename)Erforderlich, falls enthalten)

Der Typ der Compute Engine. Sie können einen der folgenden Werte verwenden:
+ **EC2**(visueller Editor) oder `EC2` (YAML-Editor)

  Optimiert für Flexibilität bei Aktionsläufen.
+ **Lambda** (visueller Editor) oder `Lambda` (YAML-Editor)

  Optimierte Startgeschwindigkeiten für Aktionen.

Weitere Informationen zu Datentypen finden Sie unter [Berechnungstypen](workflows-working-compute.md#compute.types).

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Berechnungstyp**

## Fleet
<a name="cdk.dep.computefleet"></a>

(*CDKDeploy*/Compute/**Fleet**)

(Optional)

Geben Sie die Maschine oder Flotte an, auf der Ihr Workflow oder Ihre Workflow-Aktionen ausgeführt werden sollen. Bei bedarfsgesteuerten Flotten stellt der Workflow zu Beginn einer Aktion die benötigten Ressourcen bereit, und die Maschinen werden zerstört, wenn die Aktion abgeschlossen ist. Beispiele für Flotten auf Abruf:`Linux.x86-64.Large`,. `Linux.x86-64.XLarge` Weitere Informationen zu Flotten auf Abruf finden Sie unter. [Eigenschaften von On-Demand-Flotten](workflows-working-compute.md#compute.on-demand)

Bei bereitgestellten Flotten konfigurieren Sie eine Reihe von dedizierten Maschinen, um Ihre Workflow-Aktionen auszuführen. Diese Maschinen bleiben im Leerlauf und sind bereit, Aktionen sofort zu verarbeiten. Weitere Informationen zu bereitgestellten Flotten finden Sie unter. [Eigenschaften von bereitgestellten Flotten](workflows-working-compute.md#compute.provisioned-fleets)

Wenn `Fleet` es weggelassen wird, ist die Standardeinstellung. `Linux.x86-64.Large`

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Compute Fleet**

## Timeout
<a name="cdk.dep.timeout"></a>

(*CDKDeploy*/**Timeout**)

(Erforderlich)

Geben Sie an, wie lange die Aktion in Minuten (YAML-Editor) oder Stunden und Minuten (visueller Editor) ausgeführt werden kann, bevor die Aktion CodeCatalyst beendet wird. Das Minimum beträgt 5 Minuten und das Maximum ist unter beschrieben[Kontingente für Workflows in CodeCatalyst](workflows-quotas.md). Das Standard-Timeout entspricht dem maximalen Timeout.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Timeout“ — optional**

## Inputs
<a name="cdk.dep.inputs"></a>

(*CDKDeploy*/**Inputs**)

(Optional)

Der `Inputs` Abschnitt definiert die Daten, die während einer Workflow-Ausführung `CDKDeploy` benötigt werden.

**Anmerkung**  
Für jede **AWS CDK Bereitstellungsaktion** ist nur eine Eingabe (entweder eine Quelle oder ein Artefakt) zulässig.

Entsprechende Benutzeroberfläche: Registerkarte „**Eingaben**“

## Sources
<a name="cdk.dep.inputs.sources"></a>

(*CDKDeploy*/Inputs/**Sources**)

(Erforderlich, wenn die AWS CDK App, die Sie bereitstellen möchten, in einem Quell-Repository gespeichert ist)

Wenn Ihre AWS CDK App in einem Quell-Repository gespeichert ist, geben Sie die Bezeichnung dieses Quell-Repositorys an. Die **AWS CDK Bereitstellungsaktion** synthetisiert die App in diesem Repository, bevor der Bereitstellungsprozess gestartet wird. Derzeit ist `WorkflowSource` das einzige unterstützte Label.

Wenn Ihre AWS CDK App nicht in einem Quell-Repository enthalten ist, muss sie sich in einem Artefakt befinden, das durch eine andere Aktion generiert wurde.

Weitere Informationen zu Quellen finden Sie unter [Quell-Repositorys mit Workflows verbinden](workflows-sources.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„Quellen“ — optional**

## Artifacts - input
<a name="cdk.dep.inputs.artifacts"></a>

(*CDKDeploy*/Inputs/**Artifacts**)

(Erforderlich, wenn die AWS CDK App, die Sie bereitstellen möchten, in einem [Ausgabeartefakt](workflows-working-artifacts-output.md) einer vorherigen Aktion gespeichert ist)

Wenn Ihre AWS CDK App in einem Artefakt enthalten ist, das durch eine vorherige Aktion generiert wurde, geben Sie dieses Artefakt hier an. Die **AWS CDK Bereitstellungsaktion** synthetisiert die App im angegebenen Artefakt zu einer CloudFormation Vorlage, bevor der Bereitstellungsprozess gestartet wird. Wenn Ihre AWS CDK App nicht in einem Artefakt enthalten ist, muss sie sich in Ihrem Quell-Repository befinden.

Weitere Informationen zu Artefakten, einschließlich Beispielen, finden Sie unter. [Artefakte und Dateien zwischen Aktionen teilen](workflows-working-artifacts.md)

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Artefakte“ — optional**

## Outputs
<a name="cdk.dep.outputs"></a>

(*CDKDeploy*/**Outputs**)

(Optional)

Definiert die Daten, die von der Aktion während einer Workflow-Ausführung ausgegeben werden.

Entsprechende Benutzeroberfläche: Registerkarte „**Ausgaben**“

## Artifacts - output
<a name="cdk.dep.outputs.artifacts"></a>

(*CDKDeploy*/Outputs/**Artifacts**

(Optional)

Geben Sie die durch die Aktion generierten Artefakte an. Sie können diese Artefakte als Eingabe in anderen Aktionen referenzieren.

Weitere Informationen zu Artefakten, einschließlich Beispielen, finden Sie unter[Artefakte und Dateien zwischen Aktionen teilen](workflows-working-artifacts.md).

**Entsprechende Benutzeroberfläche: Registerkarte Ausgaben/Artefakte**

## Name
<a name="cdk.dep.outputs.artifacts.name"></a>

(*CDKDeploy*/Outputs/Artifacts/**Name**)

(Erforderlich, falls [Artifacts - output](#cdk.dep.outputs.artifacts) enthalten)

Geben Sie den Namen des Artefakts an, das die CloudFormation Vorlage enthalten soll, die durch die **AWS CDK Bereitstellungsaktion** zur Laufzeit synthetisiert wird. Der Standardwert ist `cdk_artifact`. Wenn Sie kein Artefakt angeben, synthetisiert die Aktion die Vorlage, speichert sie jedoch nicht in einem Artefakt. Erwägen Sie, die synthetisierte Vorlage in einem Artefakt zu speichern, um sie zu Test- oder Fehlerbehebungszwecken aufzuzeichnen.

**Entsprechende Benutzeroberfläche: Gibt den Namen des tab/Artifacts/Add Artefakts aus/des Build-Artefakts**

## Files
<a name="cdk.dep.outputs.artifacts.files"></a>

(*CDKDeploy*/Outputs/Artifacts/**Files**)

(Erforderlich, wenn es enthalten ist) [Artifacts - output](#cdk.dep.outputs.artifacts)

Geben Sie die Dateien an, die in das Artefakt aufgenommen werden sollen. Sie müssen angeben`"cdk.out/**/*"`, dass die synthetisierte CloudFormation Vorlage Ihrer AWS CDK App eingeschlossen werden soll.

**Anmerkung**  
`cdk.out`ist das Standardverzeichnis, in dem synthetisierte Dateien gespeichert werden. Wenn Sie ein anderes Ausgabeverzeichnis als `cdk.out` in Ihrer `cdk.json` Datei angegeben haben, geben Sie dieses Verzeichnis hier statt an`cdk.out`.

Entsprechende Benutzeroberfläche: Gibt tab/Artifacts/Add **Artefakte/Dateien** aus, die von build erzeugt wurden

## Environment
<a name="cdk.dep.environment"></a>

(*CDKDeploy*/**Environment**)

(Erforderlich)

Geben Sie die CodeCatalyst Umgebung an, die für die Aktion verwendet werden soll. Die Aktion stellt eine Verbindung mit der AWS-Konto optionalen Amazon VPC her, die in der ausgewählten Umgebung angegeben ist. Die Aktion verwendet die in der Umgebung angegebene Standard-IAM-Rolle, um sich mit der Amazon VPC zu verbinden AWS-Konto, und verwendet die in der [Amazon VPC-Verbindung angegebene IAM-Rolle, um eine Verbindung zur Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) herzustellen.

**Anmerkung**  
Wenn die Standard-IAM-Rolle nicht über die für die Aktion erforderlichen Berechtigungen verfügt, können Sie die Aktion so konfigurieren, dass sie eine andere Rolle verwendet. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

Weitere Informationen zu Umgebungen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md) und[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Name
<a name="cdk.dep.environment.name"></a>

(*CDKDeploy*/Environment/**Name**)

(Erforderlich, falls [Environment](#cdk.dep.environment) enthalten)

Geben Sie den Namen einer vorhandenen Umgebung an, die Sie der Aktion zuordnen möchten.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Connections
<a name="cdk.dep.environment.connections"></a>

(*CDKDeploy*/Environment/**Connections**)

(Optional in neueren Versionen der Aktion; in älteren Versionen erforderlich)

Geben Sie die Kontoverbindung an, die der Aktion zugeordnet werden soll. Sie können unter maximal eine Kontoverbindung angeben`Environment`.

Wenn Sie keine Kontoverbindung angeben:
+ Die Aktion verwendet die AWS-Konto Verbindung und die Standard-IAM-Rolle, die in der Umgebung in der CodeCatalyst Konsole angegeben sind. Informationen zum Hinzufügen einer Kontoverbindung und einer Standard-IAM-Rolle zur Umgebung finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)
+ Die Standard-IAM-Rolle muss die Richtlinien und Berechtigungen enthalten, die für die Aktion erforderlich sind. **Informationen zu diesen Richtlinien und Berechtigungen finden Sie in der Beschreibung der Role-Eigenschaft in der YAML-Definitionsdokumentation der Aktion.**

Weitere Informationen zu Kontoverbindungen finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md). Hinweise zum Hinzufügen einer Kontoverbindung zu einer Umgebung finden Sie unter[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Name
<a name="cdk.dep.environment.connections.name"></a>

(*CDKDeploy*/Environment/Connections/**Name**)

(Erforderlich, wenn [Connections](#cdk.dep.environment.connections) es enthalten ist)

Geben Sie den Namen der Kontoverbindung an.

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Role
<a name="cdk.dep.environment.connections.role"></a>

(*CDKDeploy*/Environment/Connections/**Role**)

(Erforderlich, wenn [Connections](#cdk.dep.environment.connections) es enthalten ist)

Geben Sie den Namen der Kontoverbindung an.

Geben Sie den Namen der IAM-Rolle an, mit der die **AWS CDK Bereitstellungsaktion** auf den AWS CDK Anwendungsstapel zugreift AWS und ihn bereitstellt. Stellen Sie sicher, dass Sie [die Rolle zu Ihrem CodeCatalyst Bereich hinzugefügt](ipa-connect-account-addroles.md) haben und dass die Rolle die folgenden Richtlinien enthält.

Wenn Sie keine IAM-Rolle angeben, verwendet die Aktion die Standard-IAM-Rolle, die in der [Umgebung](deploy-environments.md) in der CodeCatalyst Konsole aufgeführt ist. Wenn Sie die Standardrolle in der Umgebung verwenden, stellen Sie sicher, dass sie über die folgenden Richtlinien verfügt.
+ Die folgende Berechtigungsrichtlinie:
**Warnung**  
Beschränken Sie die Berechtigungen auf die in der folgenden Richtlinie angegebenen. Die Verwendung einer Rolle mit umfassenderen Berechtigungen kann ein Sicherheitsrisiko darstellen.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "cloudformation:DescribeStackEvents",
                  "cloudformation:DescribeChangeSet",
                  "cloudformation:DescribeStacks",
                  "cloudformation:ListStackResources"
              ],
              "Resource": "*"
          },
          {
              "Sid": "VisualEditor1",
              "Effect": "Allow",
              "Action": "sts:AssumeRole",
              "Resource": "arn:aws:iam::111122223333:role/cdk-*"
          }
      ]
  }
  ```

------
+ Die folgende benutzerdefinierte Vertrauensrichtlinie:

**Anmerkung**  
Sie können die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle mit dieser Aktion verwenden, wenn Sie möchten. Weitere Informationen über diese Rolle finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über volle Zugriffsberechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. 

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte Environment/account/role „Konfiguration“ /' '/ Rolle**

## Configuration
<a name="cdk.dep.configuration"></a>

(*CDKDeploy*/**Configuration**)

(Erforderlich)

Ein Abschnitt, in dem Sie die Konfigurationseigenschaften der Aktion definieren können.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration**“

## StackName
<a name="cdk.dep.stack.name"></a>

(*CDKDeploy*/Configuration/**StackName**)

(Erforderlich)

Der Name Ihres AWS CDK App-Stacks, wie er in der Einstiegspunktdatei im Verzeichnis Ihrer AWS CDK App erscheint. `bin` Das folgende Beispiel zeigt den Inhalt einer TypeScript Einstiegspunktdatei, wobei der Stackname unter hervorgehoben ist. *red italics* Wenn Ihre Einstiegspunktdatei in einer anderen Sprache ist, sieht sie ähnlich aus.

```
import * as cdk from 'aws-cdk-lib';
import { CdkWorksopTypescriptStack } from '../lib/cdk_workshop_typescript-stack';

const app = new cdk.App();
new CdkWorkshopTypescriptStack(app, 'CdkWorkshopTypescriptStack');
```

Sie können nur einen Stapel angeben.

**Tipp**  
Wenn Sie mehrere Stapel haben, können Sie einen übergeordneten Stapel mit verschachtelten Stacks erstellen. In dieser Aktion können Sie dann den übergeordneten Stapel angeben, um alle Stapel bereitzustellen.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/Name des Stacks**

## Region
<a name="cdk.dep.region"></a>

(*CDKDeploy*/Configuration/**Region**)

(Optional)

Geben Sie an, AWS-Region in welchem Bereich der AWS CDK Anwendungsstapel bereitgestellt werden soll. Eine Liste der Regionscodes finden Sie unter [Regionale Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

Wenn Sie keine Region angeben, wird die **AWS CDK Bereitstellungsaktion** in der Region bereitgestellt, die in Ihrem AWS CDK Code angegeben ist. Weitere Informationen finden Sie im *AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch* unter [Umgebungen](https://docs.aws.amazon.com/cdk/v2/guide/environments.html).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Region“**

## Tags
<a name="cdk.dep.tags"></a>

(*CDKDeploy*/Configuration/**Tags**)

(Optional)

Geben Sie die Tags an, die Sie auf die AWS Ressourcen im AWS CDK Anwendungsstapel anwenden möchten. Tags werden sowohl auf den Stack selbst als auch auf einzelne Ressourcen im Stack angewendet. Weitere Informationen zum Taggen finden Sie unter [Tagging](https://docs.aws.amazon.com/cdk/v2/guide/tagging.html) im *AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch*.

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Tags**

## Context
<a name="cdk.dep.context"></a>

(*CDKDeploy*/Configuration/**Context**)

(Optional)

Geben Sie Kontexte in Form von Schlüssel-Wert-Paaren an, die dem Anwendungsstapel zugeordnet werden sollen. AWS CDK Weitere Informationen zu Kontexten finden Sie unter [Runtime-Kontexte](https://docs.aws.amazon.com/cdk/v2/guide/context.html) im *AWS Cloud Development Kit (AWS CDK) Developer* Guide.

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Kontext**

## CdkCliVersion
<a name="cdk.dep.cdk.cli.version"></a>

(*CDKDeploy*/Configuration/**CdkCliVersion**)

(Optional)

**Diese Eigenschaft ist in Version 1.0.13 oder höher der **AWS CDK Bereitstellungsaktion** und Version 1.0.8 oder höher der Bootstrap-Aktion verfügbar.AWS CDK **

Geben Sie eines der folgenden Elemente an:
+ Die Vollversion der AWS Cloud Development Kit (AWS CDK) Befehlszeilenschnittstelle (CLI) (auch AWS CDK Toolkit genannt), die diese Aktion verwenden soll. Beispiel: `2.102.1`. Erwägen Sie die Angabe einer Vollversion, um Konsistenz und Stabilität beim Erstellen und Bereitstellen Ihrer Anwendung zu gewährleisten.

  Oder
+ `latest`. Erwägen Sie `latest` die Angabe, um die neuesten Funktionen und Korrekturen der CDK-CLI nutzen zu können.

Die Aktion lädt die angegebene Version (oder die neueste Version) der AWS CDK CLI auf das CodeCatalyst [Build-Image](build-images.md) herunter und verwendet dann diese Version, um die Befehle auszuführen, die für die Bereitstellung Ihrer CDK-Anwendung oder das Bootstrap Ihrer AWS Umgebung erforderlich sind.

Eine Liste der unterstützten CDK-CLI-Versionen, die Sie verwenden können, finden Sie unter [AWS CDK Versionen](https://docs.aws.amazon.com/cdk/api/versions.html).

Wenn Sie diese Eigenschaft weglassen, verwendet die Aktion eine AWS CDK Standard-CLI-Version, die in einem der folgenden Themen beschrieben wird:
+ [CDK-CLI-Versionen, die von der Aktion „AWS CDK Deploy“ verwendet werden](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [CDK-CLI-Versionen, die von der Aktion „AWS CDK Bootstrap“ verwendet werden](cdk-boot-action.md#cdk-boot-action-cdk-version)

Entsprechende Benutzeroberfläche: Registerkarte „**AWS CDK Konfiguration/CLI-Version**“

## CdkRootPath
<a name="cdk.dep.cdk.root.path"></a>

(*CDKDeploy*/Configuration/**CdkRootPath**)

(Optional)

Der Pfad zu dem Verzeichnis, das die `cdk.json` Datei Ihres AWS CDK Projekts enthält. Die **AWS CDK Bereitstellungsaktion** wird von diesem Ordner aus ausgeführt, und alle durch die Aktion erstellten Ausgaben werden diesem Verzeichnis hinzugefügt. Falls nicht angegeben, geht die **AWS CDK Bereitstellungsaktion** davon aus, dass sich die `cdk.json` Datei im Stammverzeichnis Ihres AWS CDK Projekts befindet.

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**Verzeichnis, in dem sich die** Datei cdk.json befindet

## CfnOutputVariables
<a name="cdk.dep.cfn.out"></a>

(*CDKDeploy*/Configuration/**CfnOutputVariables**)

(Optional)

Geben Sie an, welche `CfnOutput` Konstrukte in Ihrem AWS CDK Anwendungscode Sie als Workflow-Ausgabevariablen verfügbar machen möchten. Sie können dann in nachfolgenden Aktionen in Ihrem Workflow auf die Workflow-Ausgabevariablen verweisen. Weitere Informationen zu Variablen finden Sie CodeCatalyst unter[Verwenden von Variablen in Workflows](workflows-working-with-variables.md).

Wenn Ihr AWS CDK Anwendungscode beispielsweise so aussieht:

```
import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as s3 from 'aws-cdk-lib/aws-s3';
import { Construct } from 'constructs';
import * as cdk from 'aws-cdk-lib';
export class HelloCdkStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
      removalPolicy: RemovalPolicy.DESTROY,
    });
    new CfnOutput(this, 'bucketName', {
      value: bucket.bucketName,
      description: 'The name of the s3 bucket',
      exportName: 'amzn-s3-demo-bucket',
    });
    const table = new dynamodb.Table(this, 'todos-table', {
      partitionKey: {name: 'todoId', type: dynamodb.AttributeType.NUMBER},
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: RemovalPolicy.DESTROY,
    })
    new CfnOutput(this, 'tableName', {
      value: table.tableName,
      description: 'The name of the dynamodb table',
      exportName: 'myDynamoDbTable',
    });
    ...
  }
}
```

... und deine `CfnOutputVariables` Immobilie sieht so aus:

```
Configuration:
  ...
  CfnOutputVariables: '["bucketName","tableName"]'
```

... dann generiert die Aktion die folgenden Workflow-Ausgabevariablen:


| Key (Schlüssel) | Value (Wert) | 
| --- | --- | 
|  bucketName  |  `bucket.bucketName`  | 
|  tableName  |  `table.tableName`  | 

Sie können dann in nachfolgenden Aktionen auf die `tableName` Variablen `bucketName` und verweisen. Informationen zum Verweisen auf Workflow-Ausgabevariablen in nachfolgenden Aktionen finden Sie unter[Verweisen auf eine vordefinierte Variable](workflows-working-with-variables-reference-output-vars.md).

Wenn Sie in der `CfnOutputVariables` Eigenschaft keine `CfnOutput` Konstrukte angeben, macht die Aktion die ersten vier (oder weniger) gefundenen CloudFormation Ausgabevariablen als Workflow-Ausgabevariablen verfügbar. Weitere Informationen finden Sie unter [Variablen 'AWS CDK bereitstellen'](cdk-dep-action-variables.md).

**Tipp**  
Um eine Liste aller von der Aktion erzeugten CloudFormation Ausgabevariablen zu erhalten, führen Sie den Workflow, der die **AWS CDK Bereitstellungsaktion** enthält, einmal aus und schauen Sie dann auf der Registerkarte **Protokolle** der Aktion nach. Die Protokolle enthalten eine Liste aller mit Ihrer AWS CDK App verknüpften CloudFormation Ausgabevariablen. Sobald Sie wissen, was alle CloudFormation Variablen sind, können Sie mithilfe der `CfnOutputVariables` Eigenschaft angeben, welche Sie in Workflow-Ausgabevariablen konvertieren möchten.

Weitere Informationen zu CloudFormation Ausgabevariablen finden Sie in der Dokumentation zum `CfnOutput` Konstrukt, die in der *AWS Cloud Development Kit (AWS CDK) API-Referenz* unter [class CfnOutput (construct)](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html) verfügbar ist.

Entsprechende Benutzeroberfläche: Registerkarte „**CloudFormation Konfiguration/Ausgabevariablen**“

## CloudAssemblyRootPath
<a name="cdk.dep.cloud"></a>

(*CDKDeploy*/Configuration/**CloudAssemblyRootPath**)

(Optional)

Wenn Sie den Stack Ihrer AWS CDK App bereits zu einer Cloud-Assembly zusammengefasst haben (mithilfe der `cdk synth` Operation), geben Sie den Stammpfad des Cloud-Assembly-Verzeichnisses (`cdk.out`) an. Die CloudFormation Vorlage, die sich im angegebenen Cloud-Assembly-Verzeichnis befindet, wird von der **AWS CDK Bereitstellungsaktion** AWS-Konto mithilfe des `cdk deploy --app` Befehls in Ihnen bereitgestellt. Wenn die `--app` Option vorhanden ist, findet der `cdk synth` Vorgang nicht statt.

Wenn Sie kein Cloud-Assembly-Verzeichnis angeben, führt die **AWS CDK Bereitstellungsaktion** den `cdk deploy` Befehl ohne die `--app` Option aus. Ohne die `--app` Option wird durch den `cdk deploy` Vorgang Ihre AWS CDK App sowohl synthetisiert (`cdk synth`) als auch in Ihrem AWS-Konto bereitgestellt. 

**Warum sollte ich eine bestehende, synthetisierte Cloud-Assembly angeben, wenn die Aktion „AWS CDK Deploy“ die Synthese zur Laufzeit durchführen kann?**

Möglicherweise möchten Sie eine vorhandene, synthetisierte Cloud-Assembly spezifizieren, um:
+ **Stellen Sie sicher, dass bei jeder Ausführung der Aktion „AWS CDK Bereitstellen“ genau derselbe Satz von Ressourcen bereitgestellt wird**

  Wenn Sie keine Cloud-Assembly angeben, ist es möglich, dass die Aktion „**AWS CDK Bereitstellen**“ unterschiedliche Dateien synthetisiert und bereitstellt, je nachdem, wann sie ausgeführt wird. Die **AWS CDK Bereitstellungsaktion** könnte beispielsweise eine Cloud-Assembly mit einem Satz von Abhängigkeiten während einer Testphase und einem anderen Satz von Abhängigkeiten während einer Produktionsphase synthetisieren (wenn sich diese Abhängigkeiten zwischen den Phasen geändert haben). Um eine exakte Parität zwischen dem, was getestet wurde, und dem, was bereitgestellt wird, zu gewährleisten, empfehlen wir, einmal zu synthetisieren und dann das Feld **Pfad zum Cloud-Assembly-Verzeichnis** (visueller Editor) oder die `CloudAssemblyRootPath` Eigenschaft (YAML-Editor) zu verwenden, um die bereits synthetisierte Cloud-Assembly anzugeben.
+ **Verwenden Sie in der App nicht standardmäßige Paketmanager und Tools AWS CDK **

  Während eines `synth` Vorgangs versucht die **AWS CDK Bereitstellungsaktion**, Ihre App mithilfe von Standardtools wie npm oder pip auszuführen. Wenn die Aktion Ihre App mit diesen Tools nicht erfolgreich ausführen kann, findet die Synthese nicht statt und die Aktion schlägt fehl. Um dieses Problem zu umgehen, können Sie die genauen Befehle, die für die erfolgreiche Ausführung Ihrer App erforderlich sind, in der AWS CDK `cdk.json` App-Datei angeben und Ihre App dann mit einer Methode synthetisieren, die nicht die **AWS CDK Bereitstellungsaktion** beinhaltet. Nachdem die Cloud-Assembly generiert wurde, können Sie sie im Feld **Pfad zum Cloud-Assembly-Verzeichnis** (visueller Editor) oder `CloudAssemblyRootPath` Eigenschaft (YAML-Editor) der **AWS CDK Bereitstellungsaktion** angeben. 

Informationen zur Konfiguration der `cdk.json` Datei, sodass sie Befehle für die Installation und Ausführung Ihrer AWS CDK App enthält, finden Sie unter [Angeben des App-Befehls](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-app-command).

*Informationen zu den `cdk synth` Befehlen `cdk deploy` und sowie zu den `--app` Optionen finden Sie unter Stacks [bereitstellen, Stacks](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy) [synthetisieren](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-synth) und [Synthese überspringen](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-nosynth) im Entwicklerhandbuch.AWS Cloud Development Kit (AWS CDK) *

*Informationen zu Cloud-Assemblys finden Sie unter [Cloud Assembly in der API-Referenz](https://docs.aws.amazon.com/cdk/api/v2/docs/cloud-assembly-schema-readme.html).AWS Cloud Development Kit (AWS CDK) *

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**Pfad zum Cloud-Assembly-Verzeichnis**

# Bootstrapping einer AWS CDK App mit einem Workflow
<a name="cdk-boot-action"></a>

In diesem Abschnitt wird beschrieben, wie Sie eine AWS CDK Anwendung mithilfe eines CodeCatalyst Workflows booten. Um dies zu erreichen, müssen Sie Ihrem Workflow die **AWS CDK Bootstrap-Aktion** hinzufügen. [Die **AWS CDK Bootstrap-Aktion** stellt mithilfe der modernen Vorlage einen Bootstrap-Stack in Ihrer AWS Umgebung bereit.](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-template) Wenn bereits ein Bootstrap-Stack vorhanden ist, aktualisiert die Aktion ihn bei Bedarf. Das Vorhandensein eines Bootstrap-Stacks AWS ist eine Voraussetzung für die Bereitstellung einer AWS CDK App.

*Weitere Informationen zu Bootstrapping finden Sie unter [Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) im Entwicklerhandbuch.AWS Cloud Development Kit (AWS CDK) *

**Topics**
+ [Wann sollte die Aktion „Bootstrap“ verwendet werden AWS CDK](#cdk-boot-action-when-to-use)
+ [So funktioniert die Aktion „AWS CDK Bootstrap“](#cdk-boot-action-how-it-works)
+ [CDK-CLI-Versionen, die von der Aktion „AWS CDK Bootstrap“ verwendet werden](#cdk-boot-action-cdk-version)
+ [Von der Aktion „Bootstrap“AWS CDK verwendetes Runtime-Image](#cdk-boot-action-runtime)
+ [Beispiel: Bootstrapping einer App AWS CDK](cdk-boot-action-example-workflow.md)
+ [Die Aktion „AWS CDK Bootstrap“ hinzufügen](cdk-boot-action-add.md)
+ [AWS CDK 'Bootstrap'-Variablen](cdk-boot-action-variables.md)
+ [AWS CDK 'Bootstrap'-Aktion YAML](cdk-boot-action-ref.md)

## Wann sollte die Aktion „Bootstrap“ verwendet werden AWS CDK
<a name="cdk-boot-action-when-to-use"></a>

Verwenden Sie diese Aktion, wenn Sie über einen Workflow verfügen, der eine AWS CDK App bereitstellt, und Sie den Bootstrap-Stack gleichzeitig bereitstellen (und bei Bedarf aktualisieren) möchten. In diesem Fall würden Sie die **AWS CDK Bootstrap-Aktion** demselben Workflow hinzufügen wie dem, der Ihre App bereitstellt. AWS CDK 

Verwenden **Sie diese Aktion nicht**, wenn eine der folgenden Bedingungen zutrifft:
+ Sie haben bereits einen Bootstrap-Stack mit einem anderen Mechanismus bereitgestellt und möchten ihn beibehalten (keine Updates).
+ Sie möchten eine [benutzerdefinierte Bootstrap-Vorlage verwenden, die von der **AWS CDK Bootstrap-Aktion**](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-customizing) nicht unterstützt wird.

## So funktioniert die Aktion „AWS CDK Bootstrap“
<a name="cdk-boot-action-how-it-works"></a>

Der **AWS CDK Bootstrap** funktioniert wie folgt:

1. [Wenn Sie zur Laufzeit Version 1.0.7 oder früher der Aktion angegeben haben, lädt die Aktion die neueste CDK-CLI (auch AWS CDK Tookit genannt) in das Build-Image herunter. CodeCatalyst ](build-images.md)

   Wenn Sie Version 1.0.8 oder höher angegeben haben, ist die Aktion mit einer [bestimmten Version](cdk-dep-action.md#cdk-dep-action-cdk-version) der CDK-CLI gebündelt, sodass kein Download stattfindet.

1. Die Aktion verwendet die CDK-CLI, um den `cdk bootstrap` Befehl auszuführen. *Mit diesem Befehl werden die Bootstrapping-Aufgaben ausgeführt, die im Thema [Bootstrapping im Entwicklerhandbuch](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) beschrieben sind.AWS Cloud Development Kit (AWS CDK) *

## CDK-CLI-Versionen, die von der Aktion „AWS CDK Bootstrap“ verwendet werden
<a name="cdk-boot-action-cdk-version"></a>

Die folgende Tabelle zeigt, welche Version der CDK-CLI standardmäßig von verschiedenen Versionen der **AWS CDK Bootstrap-Aktion** verwendet wird.

**Anmerkung**  
Möglicherweise können Sie die Standardeinstellung überschreiben. Weitere Informationen finden Sie unter [CdkCliVersion](cdk-boot-action-ref.md#cdk.boot.cdk.cli.version) im [AWS CDK 'Bootstrap'-Aktion YAML](cdk-boot-action-ref.md).


| Version der AWS CDK Aktion „Bootstrap“ | AWS CDK CLI-Version | 
| --- | --- | 
|  1.0.0 — 1.0.7  |  brandneue  | 
|  1.0.8 oder später  |  2.99.1  | 

## Von der Aktion „Bootstrap“AWS CDK verwendetes Runtime-Image
<a name="cdk-boot-action-runtime"></a>

Die folgende Tabelle zeigt die Runtime-Umgebungs-Images, die zur Ausführung verschiedener Versionen der **AWS CDK Bootstrap-Aktion CodeCatalyst ** verwendet werden. Die Bilder enthalten verschiedene Sätze vorinstallierter Tools. Weitere Informationen finden Sie unter [Aktive Bilder](build-images.md#build-curated-images).

**Anmerkung**  
Wir empfehlen, Ihre **AWS CDK Bootstrap-Aktion** auf Version 2.x zu aktualisieren, um die neuesten Tools nutzen zu können, die auf dem Image vom März 2024 verfügbar sind. Um die Aktion zu aktualisieren, legen Sie ihre `Identifier` Eigenschaft `aws/cdk-bootstrap@v2` in Ihrer Workflow-Definitionsdatei auf fest. Weitere Informationen finden Sie unter [Aktion 'AWS CDK bereitstellen' YAML](cdk-dep-action-ref.md). 


| Version der AWS CDK Aktion „Bootstrap“ | Bilder der Laufzeitumgebung | 
| --- | --- | 
|  1.x  |  Bilder vom November 2022  | 
|  2.x  |  Bilder vom März 2024  | 

# Beispiel: Bootstrapping einer App AWS CDK
<a name="cdk-boot-action-example-workflow"></a>

Informationen zu einem Workflow, [Beispiel: Eine AWS CDK App bereitstellen](cdk-dep-action-example-workflow.md) der die [Eine AWS CDK App mit einem Workflow bereitstellen](cdk-dep-action.md) **AWS CDK Bootstrap-Aktion** enthält, finden Sie im.

# Die Aktion „AWS CDK Bootstrap“ hinzufügen
<a name="cdk-boot-action-add"></a>

 Verwenden Sie die folgenden Anweisungen, um die **AWS CDK Bootstrap-Aktion** zu Ihrem Workflow hinzuzufügen. 

**Bevor Sie beginnen**

Bevor Sie die **AWS CDK Bootstrap-Aktion** verwenden können, stellen Sie sicher, dass Sie eine AWS CDK App bereit haben. Die Bootstrap-Aktion synthetisiert die AWS CDK App vor dem Bootstrapping. Sie können Ihre App in jeder Programmiersprache schreiben, die von der unterstützt wird. AWS CDK

Stellen Sie sicher, dass Ihre AWS CDK App-Dateien verfügbar sind in:
+ Ein CodeCatalyst [Quell-Repository](source.md) oder 
+ Ein CodeCatalyst [Ausgabeartefakt](workflows-working-artifacts.md), das durch eine andere Workflow-Aktion generiert wurde

------
#### [ Visual ]

**Um die Aktion „AWS CDK Bootstrap“ mit dem visuellen Editor hinzuzufügen**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie oben links **\$1 Aktionen**, um den Aktionskatalog zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der **AWS CDK Bootstrap-Aktion** und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie **AWS CDK Bootstrap.** Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Quelltext** [anzeigen“, um den Quellcode der Aktion](workflows-view-source.md#workflows-view-source.title) anzuzeigen.
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Füllen Sie auf den Registerkarten **Eingaben**, **Konfiguration** und **Ausgaben** die Felder nach Ihren Bedürfnissen aus. Eine Beschreibung der einzelnen Felder finden Sie unter[AWS CDK 'Bootstrap'-Aktion YAML](cdk-boot-action-ref.md). Diese Referenz enthält detaillierte Informationen zu jedem Feld (und dem entsprechenden YAML-Eigenschaftswert), wie es sowohl im YAML- als auch im visuellen Editor angezeigt wird.

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein, und wählen Sie dann erneut **Commit** aus.
**Anmerkung**  
Wenn Ihre **AWS CDK Bootstrap-Aktion** mit einem `npm install` Fehler fehlschlägt, finden Sie weitere Informationen [Wie behebe ich „npm install“ -Fehler?](troubleshooting-workflows.md#troubleshooting-workflows-npm) zur Behebung des Fehlers unter.

------
#### [ YAML ]

**So fügen Sie die Aktion „AWS CDK Bootstrap“ mit dem YAML-Editor hinzu**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Wählen Sie links oben **\$1 Aktionen, um den Aktionskatalog** zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der **AWS CDK Bootstrap-Aktion** und wählen Sie **\$1**, um sie dem Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Ändern Sie die Eigenschaften im YAML-Code nach Ihren Bedürfnissen. Eine Erläuterung der einzelnen verfügbaren Eigenschaften finden Sie in der[AWS CDK 'Bootstrap'-Aktion YAML](cdk-boot-action-ref.md).

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein, und wählen Sie dann erneut **Commit** aus.
**Anmerkung**  
Wenn Ihre **AWS CDK Bootstrap-Aktion** mit einem `npm install` Fehler fehlschlägt, finden Sie weitere Informationen [Wie behebe ich „npm install“ -Fehler?](troubleshooting-workflows.md#troubleshooting-workflows-npm) zur Behebung des Fehlers unter.

------

# AWS CDK 'Bootstrap'-Variablen
<a name="cdk-boot-action-variables"></a>

Die **AWS CDK Bootstrap-Aktion** erzeugt und setzt zur Laufzeit die folgenden Variablen. Diese werden als *vordefinierte Variablen* bezeichnet.

Hinweise zum Verweisen auf diese Variablen in einem Workflow finden Sie unter[Verwenden vordefinierter Variablen](workflows-using-predefined-variables.md).


| Key (Schlüssel) | Value (Wert) | 
| --- | --- | 
|  Bereitstellungsplattform  |  Der Name der Bereitstellungsplattform. Fest codiert auf. `AWS:CloudFormation`  | 
|  Region  |  Der Regionalcode des AWS-Region , für den der AWS CDK Bootstrap-Stack während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `us-west-2`  | 
|  Stack-ID  |  Der Amazon-Ressourcenname (ARN) des bereitgestellten AWS CDK Bootstrap-Stacks. Beispiel: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-bootstrap-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  BEREITSTELLUNG ÜBERSPRINGEN  |  Der Wert von `true` gibt an, dass die Bereitstellung Ihres AWS CDK Bootstrap-Stacks während der Workflow-Ausführung übersprungen wurde. Eine Stack-Bereitstellung wird übersprungen, wenn sich der Stack seit der letzten Bereitstellung nicht geändert hat. Diese Variable wird nur erzeugt, wenn ihr Wert ist`true`. Fest codiert auf. `true`  | 

# AWS CDK 'Bootstrap'-Aktion YAML
<a name="cdk-boot-action-ref"></a>

**Im Folgenden finden Sie die YAML-Definition der Bootstrap-Aktion.AWS CDK ** Informationen zur Verwendung dieser Aktion finden Sie unter. [Bootstrapping einer AWS CDK App mit einem Workflow](cdk-boot-action.md)

Diese Aktionsdefinition ist als Abschnitt in einer umfassenderen Workflow-Definitionsdatei vorhanden. Weitere Informationen über diese Datei finden Sie unter [YAML-Workflow-Definition](workflow-reference.md).

**Anmerkung**  
Die meisten der folgenden YAML-Eigenschaften haben entsprechende Benutzeroberflächenelemente im visuellen Editor. Verwenden Sie **Strg\$1F**, um nach einem UI-Element zu suchen. Das Element wird mit der zugehörigen YAML-Eigenschaft aufgelistet.

```
# The workflow definition starts here.
# See Eigenschaften der obersten Ebene for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.    
  CDKBootstrapAction\$1nn: 
    Identifier: aws/cdk-bootstrap@v2
    DependsOn:
      - action-name
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_bootstrap_artifacts
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      Region: us-west-2
      CdkCliVersion: version
```

## CDKBootstrapAction
<a name="cdk.boot.name"></a>

(Erforderlich)

Geben Sie den Namen der Aktion an. Alle Aktionsnamen müssen innerhalb des Workflows eindeutig sein. Aktionsnamen sind auf alphanumerische Zeichen (a-z, A-Z, 0-9), Bindestriche (-) und Unterstriche (\$1) beschränkt. Leerzeichen sind nicht erlaubt. Sie können keine Anführungszeichen verwenden, um Sonderzeichen und Leerzeichen in Aktionsnamen zuzulassen.

Standard: `CDKBootstrapAction_nn`.

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/**Anzeigename der Aktion**

## Identifier
<a name="cdk.boot.identifier"></a>

(*CDKBootstrapAction*/**Identifier**)

(Erforderlich)

Identifiziert die Aktion. Ändern Sie diese Eigenschaft nicht, es sei denn, Sie möchten die Version ändern. Weitere Informationen finden Sie unter [Angabe der zu verwendenden Aktionsversion](workflows-action-versions.md).

**Anmerkung**  
Wenn `aws/cdk-bootstrap@v2` Sie angeben, wird die Aktion für das [Image vom März 2024](build-images.md#build.default-image) ausgeführt, das neuere Tools wie Node.js 18 enthält. Durch `aws/cdk-bootstrap@v1` die Angabe wird die Aktion auf dem [Image vom November 2022](build-images.md#build.previous-image) ausgeführt, das ältere Tools wie Node.js 16 enthält.

Standard: `aws/cdk-bootstrap@v2`.

**Entsprechende Benutzeroberfläche: Workflow-Diagram/ CDKBootstrapAction \$1nn/ aws/cdk-bootstrap @v2 label**

## DependsOn
<a name="cdk.boot.dependson"></a>

(*CDKBootstrapAction*/**DependsOn**)

(Optional)

Geben Sie eine Aktion, eine Aktionsgruppe oder ein Gate an, die erfolgreich ausgeführt werden müssen, damit diese Aktion ausgeführt werden kann.

Weitere Hinweise zur Funktion „Hängt davon ab“ finden Sie unter. [Aktionen sequenzieren](workflows-depends-on.md)

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Hängt davon ab**“ — optional

## Compute
<a name="cdk.boot.computename"></a>

(*CDKBootstrapAction*/**Compute**)

(Optional)

Die Rechen-Engine, mit der Ihre Workflow-Aktionen ausgeführt wurden. Sie können die Berechnung entweder auf Workflow-Ebene oder auf Aktionsebene angeben, aber nicht beide. Wenn auf Workflow-Ebene angegeben, gilt die Rechenkonfiguration für alle im Workflow definierten Aktionen. Auf Workflow-Ebene können Sie auch mehrere Aktionen auf derselben Instanz ausführen. Weitere Informationen finden Sie unter [Rechenleistung für mehrere Aktionen gemeinsam nutzen](compute-sharing.md).

Entsprechende Benutzeroberfläche: *keine*

## Type
<a name="cdk.boot.computetype"></a>

(*CDKBootstrapAction*/Compute/**Type**)

(Erforderlich, wenn [Compute](#cdk.boot.computename) es enthalten ist)

Der Typ der Compute Engine. Sie können einen der folgenden Werte verwenden:
+ **EC2**(visueller Editor) oder `EC2` (YAML-Editor)

  Optimiert für Flexibilität bei Aktionsläufen.
+ **Lambda** (visueller Editor) oder `Lambda` (YAML-Editor)

  Optimierte Startgeschwindigkeiten für Aktionen.

Weitere Informationen zu Datentypen finden Sie unter [Berechnungstypen](workflows-working-compute.md#compute.types).

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Berechnungstyp**

## Fleet
<a name="cdk.boot.computefleet"></a>

(*CDKBootstrapAction*/Compute/**Fleet**)

(Optional)

Geben Sie die Maschine oder Flotte an, auf der Ihr Workflow oder Ihre Workflow-Aktionen ausgeführt werden sollen. Bei bedarfsgesteuerten Flotten stellt der Workflow zu Beginn einer Aktion die benötigten Ressourcen bereit, und die Maschinen werden zerstört, wenn die Aktion abgeschlossen ist. Beispiele für Flotten auf Abruf:`Linux.x86-64.Large`,. `Linux.x86-64.XLarge` Weitere Informationen zu Flotten auf Abruf finden Sie unter. [Eigenschaften von On-Demand-Flotten](workflows-working-compute.md#compute.on-demand)

Bei bereitgestellten Flotten konfigurieren Sie eine Reihe von dedizierten Maschinen, um Ihre Workflow-Aktionen auszuführen. Diese Maschinen bleiben inaktiv und können sofort Aktionen ausführen. Weitere Informationen zu bereitgestellten Flotten finden Sie unter. [Eigenschaften von bereitgestellten Flotten](workflows-working-compute.md#compute.provisioned-fleets)

Wenn `Fleet` es weggelassen wird, ist die Standardeinstellung. `Linux.x86-64.Large`

**Entsprechende Benutzeroberfläche: Konfiguration tab/Advanced — optional/ Compute Fleet**

## Timeout
<a name="cdk.boot.timeout"></a>

(*CDKBootstrapAction*/**Timeout**)

(Erforderlich)

Geben Sie an, wie lange die Aktion in Minuten (YAML-Editor) oder Stunden und Minuten (visueller Editor) ausgeführt werden kann, bevor die Aktion CodeCatalyst beendet wird. Das Minimum beträgt 5 Minuten und das Maximum ist unter beschrieben[Kontingente für Workflows in CodeCatalyst](workflows-quotas.md). Das Standard-Timeout entspricht dem maximalen Timeout.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Timeout“ — optional**

## Inputs
<a name="cdk.boot.inputs"></a>

(*CDKBootstrapAction*/**Inputs**)

(Optional)

Der `Inputs` Abschnitt definiert die Daten, die die **AWS CDK Bootstrap-Aktion** während einer Workflow-Ausführung benötigt.

Entsprechende Benutzeroberfläche: Registerkarte „**Eingaben**“

**Anmerkung**  
Für jede **AWS CDK Bootstrap-Aktion** ist nur eine Eingabe (entweder eine Quelle oder ein Artefakt) zulässig.

## Sources
<a name="cdk.boot.inputs.sources"></a>

(*CDKBootstrapAction*/Inputs/**Sources**)

(Erforderlich, wenn Ihre AWS CDK App in einem Quell-Repository gespeichert ist)

Wenn Ihre AWS CDK App in einem Quell-Repository gespeichert ist, geben Sie die Bezeichnung dieses Quell-Repositorys an. Die **AWS CDK Bootstrap-Aktion** synthetisiert die App in diesem Repository, bevor der Bootstrapping-Vorgang gestartet wird. Derzeit ist das einzige unterstützte Repository-Label. `WorkflowSource`

Wenn Ihre AWS CDK App nicht in einem Quell-Repository enthalten ist, muss sie sich in einem Artefakt befinden, das durch eine andere Aktion generiert wurde.

Weitere Informationen zu Quellen finden Sie unter [Quell-Repositorys mit Workflows verbinden](workflows-sources.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„Quellen“ — optional**

## Artifacts - input
<a name="cdk.boot.inputs.artifacts"></a>

(*CDKBootstrapAction*/Inputs/**Artifacts**)

(Erforderlich, wenn Ihre AWS CDK App in einem [Ausgabeartefakt](workflows-working-artifacts-output.md) einer früheren Aktion gespeichert ist)

Wenn Ihre AWS CDK App in einem Artefakt enthalten ist, das durch eine vorherige Aktion generiert wurde, geben Sie dieses Artefakt hier an. Die **AWS CDK Bootstrap-Aktion** synthetisiert die App im angegebenen Artefakt zu einer CloudFormation Vorlage, bevor der Bootstrapping-Vorgang gestartet wird. Wenn Ihre AWS CDK App nicht in einem Artefakt enthalten ist, muss sie sich in Ihrem Quell-Repository befinden.

Weitere Informationen zu Artefakten, einschließlich Beispielen, finden Sie unter. [Artefakte und Dateien zwischen Aktionen teilen](workflows-working-artifacts.md)

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Artefakte“ — optional**

## Outputs
<a name="cdk.boot.outputs"></a>

(*CDKBootstrapAction*/**Outputs**)

(Optional)

Definiert die Daten, die von der Aktion während einer Workflow-Ausführung ausgegeben werden.

Entsprechende Benutzeroberfläche: Registerkarte „**Ausgaben**“

## Artifacts - output
<a name="cdk.boot.outputs.artifacts"></a>

(*CDKBootstrapAction*/Outputs/**Artifacts**)

(Optional)

Geben Sie die durch die Aktion generierten Artefakte an. Sie können diese Artefakte als Eingabe in anderen Aktionen referenzieren.

Weitere Informationen zu Artefakten, einschließlich Beispielen, finden Sie unter[Artefakte und Dateien zwischen Aktionen teilen](workflows-working-artifacts.md).

**Entsprechende Benutzeroberfläche: Registerkarte Ausgaben/Artefakte**

## Name
<a name="cdk.boot.outputs.artifacts.name"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Name**)

(Erforderlich, wenn [Artifacts - output](#cdk.boot.outputs.artifacts) es enthalten ist)

Geben Sie den Namen des Artefakts an, das die CloudFormation Vorlage enthalten soll, die zur Laufzeit durch die **AWS CDK Bootstrap-Aktion** synthetisiert wird. Der Standardwert ist `cdk_bootstrap_artifacts`. Wenn Sie kein Artefakt angeben, synthetisiert die Aktion die Vorlage, speichert sie jedoch nicht in einem Artefakt. Erwägen Sie, die synthetisierte Vorlage in einem Artefakt zu speichern, um sie zu Test- oder Fehlerbehebungszwecken aufzuzeichnen.

**Entsprechende Benutzeroberfläche: Gibt den Namen des tab/Artifacts/Add Artefakts aus/des Build-Artefakts**

## Files
<a name="cdk.boot.outputs.artifacts.files"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Files**)

(Erforderlich, wenn es enthalten ist) [Artifacts - output](#cdk.boot.outputs.artifacts)

Geben Sie die Dateien an, die in das Artefakt aufgenommen werden sollen. Sie müssen angeben`"cdk.out/**/*"`, dass die synthetisierte CloudFormation Vorlage Ihrer AWS CDK App eingeschlossen werden soll.

**Anmerkung**  
`cdk.out`ist das Standardverzeichnis, in dem synthetisierte Dateien gespeichert werden. Wenn Sie ein anderes Ausgabeverzeichnis als `cdk.out` in Ihrer `cdk.json` Datei angegeben haben, geben Sie dieses Verzeichnis hier statt an`cdk.out`.

Entsprechende Benutzeroberfläche: Gibt tab/Artifacts/Add **Artefakte/Dateien** aus, die von build erzeugt wurden

## Environment
<a name="cdk.boot.environment"></a>

(*CDKBootstrapAction*/**Environment**)

(Erforderlich)

Geben Sie die CodeCatalyst Umgebung an, die für die Aktion verwendet werden soll. Die Aktion stellt eine Verbindung mit der AWS-Konto optionalen Amazon VPC her, die in der ausgewählten Umgebung angegeben ist. Die Aktion verwendet die in der Umgebung angegebene Standard-IAM-Rolle, um eine Verbindung zur herzustellen AWS-Konto, und verwendet die in der Amazon VPC-Verbindung angegebene IAM-Rolle, um eine [Verbindung zur Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) herzustellen.

**Anmerkung**  
Wenn die Standard-IAM-Rolle nicht über die für die Aktion erforderlichen Berechtigungen verfügt, können Sie die Aktion so konfigurieren, dass sie eine andere Rolle verwendet. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

Weitere Informationen zu Umgebungen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md) und[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Name
<a name="cdk.boot.environment.name"></a>

(*CDKBootstrapAction*/Environment/**Name**)

(Erforderlich, falls [Environment](#cdk.boot.environment) enthalten)

Geben Sie den Namen einer vorhandenen Umgebung an, die Sie der Aktion zuordnen möchten.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Connections
<a name="cdk.boot.environment.connections"></a>

(*CDKBootstrapAction*/Environment/**Connections**)

(Optional in neueren Versionen der Aktion; in älteren Versionen erforderlich)

Geben Sie die Kontoverbindung an, die der Aktion zugeordnet werden soll. Sie können unter maximal eine Kontoverbindung angeben`Environment`.

Wenn Sie keine Kontoverbindung angeben:
+ Die Aktion verwendet die AWS-Konto Verbindung und die Standard-IAM-Rolle, die in der Umgebung in der CodeCatalyst Konsole angegeben sind. Informationen zum Hinzufügen einer Kontoverbindung und einer Standard-IAM-Rolle zur Umgebung finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)
+ Die Standard-IAM-Rolle muss die Richtlinien und Berechtigungen enthalten, die für die Aktion erforderlich sind. **Informationen zu diesen Richtlinien und Berechtigungen finden Sie in der Beschreibung der Role-Eigenschaft in der YAML-Definitionsdokumentation der Aktion.**

Weitere Informationen zu Kontoverbindungen finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md). Hinweise zum Hinzufügen einer Kontoverbindung zu einer Umgebung finden Sie unter[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Name
<a name="cdk.boot.environment.connections.name"></a>

(*CDKBootstrapAction*/Environment/Connections/**Name**)

(Erforderlich, falls enthalten[Connections](#cdk.boot.environment.connections))

Geben Sie den Namen der Kontoverbindung an.

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Role
<a name="cdk.boot.environment.connections.role"></a>

(*CDKBootstrapAction*/Environment/Connections/**Role**)

(Erforderlich, falls enthalten[Connections](#cdk.boot.environment.connections))

Geben Sie den Namen der IAM-Rolle an, mit der die **AWS CDK Bootstrap-Aktion auf den Bootstrap-Stack** zugreift AWS und ihn hinzufügt. Stellen Sie sicher, dass Sie [die Rolle zu Ihrem CodeCatalyst Bereich hinzugefügt](ipa-connect-account-addroles.md) haben und dass die Rolle die folgenden Richtlinien enthält.

Wenn Sie keine IAM-Rolle angeben, verwendet die Aktion die Standard-IAM-Rolle, die in der [Umgebung](deploy-environments.md) in der CodeCatalyst Konsole aufgeführt ist. Wenn Sie die Standardrolle in der Umgebung verwenden, stellen Sie sicher, dass sie über die entsprechenden Richtlinien verfügt.

Sie können die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle mit dieser Aktion verwenden, wenn Sie möchten. Weitere Informationen über diese Rolle finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über volle Zugriffsberechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. 

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte Environment/account/role „Konfiguration“ /' '/ Rolle**

## Configuration
<a name="cdk.boot.configuration"></a>

(*CDKBootstrapAction*/**Configuration**)

(Erforderlich)

Ein Abschnitt, in dem Sie die Konfigurationseigenschaften der Aktion definieren können.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration**“

## Region
<a name="cdk.boot.region"></a>

(*CDKBootstrapAction*/Configuration/**Region**)

(Erforderlich)

Geben Sie an, AWS-Region in welchem Bereich der Bootstrap-Stack bereitgestellt werden soll. Diese Region sollte mit der Region übereinstimmen, in der Ihre AWS CDK App bereitgestellt wird. Eine Liste der Regionscodes finden Sie unter [Regionale Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Region“**

## CdkCliVersion
<a name="cdk.boot.cdk.cli.version"></a>

(*CDKBootstrapAction*/Configuration/**CdkCliVersion**)

(Optional)

**Diese Eigenschaft ist in Version 1.0.13 oder höher der **AWS CDK Bereitstellungsaktion** und Version 1.0.8 oder höher der AWS CDK Bootstrap-Aktion verfügbar.**

Geben Sie eines der folgenden Elemente an:
+ Die Vollversion der AWS Cloud Development Kit (AWS CDK) Befehlszeilenschnittstelle (CLI) (auch AWS CDK Toolkit genannt), die diese Aktion verwenden soll. Beispiel: `2.102.1`. Erwägen Sie die Angabe einer Vollversion, um Konsistenz und Stabilität beim Erstellen und Bereitstellen Ihrer Anwendung zu gewährleisten.

  Oder
+ `latest`. Erwägen Sie `latest` die Angabe, um die neuesten Funktionen und Korrekturen der CDK-CLI nutzen zu können.

Die Aktion lädt die angegebene Version (oder die neueste Version) der AWS CDK CLI auf das CodeCatalyst [Build-Image](build-images.md) herunter und verwendet dann diese Version, um die Befehle auszuführen, die für die Bereitstellung Ihrer CDK-Anwendung oder das Bootstrap Ihrer AWS Umgebung erforderlich sind.

Eine Liste der unterstützten CDK-CLI-Versionen, die Sie verwenden können, finden Sie unter [AWS CDK Versionen](https://docs.aws.amazon.com/cdk/api/versions.html).

Wenn Sie diese Eigenschaft weglassen, verwendet die Aktion eine AWS CDK Standard-CLI-Version, die in einem der folgenden Themen beschrieben wird:
+ [CDK-CLI-Versionen, die von der Aktion „AWS CDK Deploy“ verwendet werden](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [CDK-CLI-Versionen, die von der Aktion „AWS CDK Bootstrap“ verwendet werden](cdk-boot-action.md#cdk-boot-action-cdk-version)

Entsprechende Benutzeroberfläche: Registerkarte „**AWS CDK Konfiguration/CLI-Version**“

# Veröffentlichen von Dateien in Amazon S3 mit einem Workflow
<a name="s3-pub-action"></a>

In diesem Abschnitt wird beschrieben, wie Sie Dateien mithilfe eines CodeCatalyst Workflows in Amazon S3 veröffentlichen. Um dies zu erreichen, müssen Sie Ihrem Workflow die **Amazon S3 S3-Aktion „Veröffentlichen**“ hinzufügen. Die **Amazon S3 S3-Veröffentlichungsaktion** kopiert Dateien aus einem Quellverzeichnis in einen Amazon S3 S3-Bucket. Das Quellverzeichnis kann sich in folgendem Verzeichnis befinden:
+ Ein [Quell-Repository](source.md) oder 
+ Ein [Ausgabeartefakt](workflows-working-artifacts.md), das durch eine andere Workflow-Aktion generiert wurde

**Topics**
+ [Wann sollte die Aktion „Amazon S3 Publish“ verwendet werden](#s3-pub-action-when-to-use)
+ [Von der Aktion „Amazon S3 Publish“ verwendetes Runtime-Image](#s3-pub-action-runtime)
+ [Beispiel: Dateien auf Amazon S3 veröffentlichen](s3-pub-action-example-workflow.md)
+ [Die Aktion „Amazon S3 Publish“ hinzufügen](s3-pub-action-add.md)
+ [Aktion „Amazon S3 veröffentlichen“ YAML](s3-pub-action-ref.md)

## Wann sollte die Aktion „Amazon S3 Publish“ verwendet werden
<a name="s3-pub-action-when-to-use"></a>

Verwenden Sie diese Aktion, wenn:
+ Sie haben einen Workflow, der Dateien generiert, die Sie in Amazon S3 speichern möchten.

  Möglicherweise haben Sie einen Workflow, der eine statische Website erstellt, die Sie in Amazon S3 hosten möchten. In diesem Fall würde Ihr Workflow eine [Build-Aktion](build-add-action.md) zum Erstellen der HTML- und unterstützenden Dateien der Site sowie eine **Amazon S3-Veröffentlichungsaktion** zum Kopieren der Dateien nach Amazon S3 beinhalten.
+ Sie haben ein Quell-Repository, das Dateien enthält, die Sie in Amazon S3 speichern möchten.

  Möglicherweise haben Sie ein Quell-Repository mit Anwendungsquelldateien, die Sie jede Nacht in Amazon S3 archivieren möchten.

## Von der Aktion „Amazon S3 Publish“ verwendetes Runtime-Image
<a name="s3-pub-action-runtime"></a>

Die **Amazon S3 S3-Veröffentlichungsaktion** wird auf einem [Image vom November 2022](build-images.md#build.previous-image) ausgeführt. Weitere Informationen finden Sie unter [Aktive Bilder](build-images.md#build-curated-images).

# Beispiel: Dateien auf Amazon S3 veröffentlichen
<a name="s3-pub-action-example-workflow"></a>

Der folgende Beispiel-Workflow umfasst die **Amazon S3 S3-Veröffentlichungsaktion** zusammen mit einer Build-Aktion. Der Workflow erstellt eine statische Dokumentationswebsite und veröffentlicht sie dann in Amazon S3, wo sie gehostet wird. Der Workflow besteht aus den folgenden Bausteinen, die nacheinander ausgeführt werden:
+ Ein **Trigger** — Dieser Trigger startet die Workflow-Ausführung automatisch, wenn Sie eine Änderung an Ihr Quell-Repository übertragen. Weitere Informationen zu Auslösern finden Sie unter [Automatisches Starten einer Workflow-Ausführung mithilfe von Triggern](workflows-add-trigger.md).
+ Eine **Build-Aktion** (`BuildDocs`) — Beim Trigger erstellt die Aktion eine statische Dokumentationswebsite (`mkdocs build`) und fügt die zugehörigen HTML-Dateien und unterstützenden Metadaten zu einem Artefakt mit dem Namen `MyDocsSite` hinzu. Weitere Informationen zur Build-Aktion finden Sie unter[Bauen mit Workflows](build-workflow-actions.md).
+ Eine **Amazon S3-Veröffentlichungsaktion** (`PublishToS3`) — Nach Abschluss der Build-Aktion kopiert diese Aktion die Site im `MyDocsSite` Artefakt zum Hosten nach Amazon S3.

**Anmerkung**  
Das folgende Workflow-Beispiel dient der Veranschaulichung und funktioniert ohne zusätzliche Konfiguration nicht.

**Anmerkung**  
Im folgenden YAML-Code können Sie den `Connections:` Abschnitt weglassen, wenn Sie möchten. Wenn Sie diesen Abschnitt weglassen, müssen Sie sicherstellen, dass die im Feld **Standard-IAM-Rolle in Ihrer Umgebung angegebene Rolle** die Berechtigungen und Vertrauensrichtlinien enthält, die für die **Amazon S3 S3-Veröffentlichungsaktion** erforderlich sind. Weitere Informationen zum Einrichten einer Umgebung mit einer Standard-IAM-Rolle finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md) Weitere Informationen zu den Berechtigungen und Vertrauensrichtlinien, die für die **Amazon S3 S3-Veröffentlichungsaktion** erforderlich sind, finden Sie in der Beschreibung der [Role](s3-pub-action-ref.md#s3.pub.environment.connections.role) Eigenschaft in der[Aktion „Amazon S3 veröffentlichen“ YAML](s3-pub-action-ref.md).

```
Name: codecatalyst-s3-publish-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  BuildDocs:
    Identifier: aws/build@v1
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      Steps:
        - Run: echo BuildDocs started on `date`
        - Run: pip install --upgrade pip
        - Run: pip install mkdocs
        - Run: mkdocs build
        - Run: echo BuildDocs completed on `date`
    Outputs:
      Artifacts:
      - Name: MyDocsSite
        Files:
          - "site/**/*"
        
  PublishToS3:
    Identifier: aws/s3-publish@v1
    Environment:
      Name: codecatalyst-s3-publish-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-s3-publish-build-role
    Inputs:
      Sources:
        - WorkflowSource
      Artifacts:
        - MyDocsSite
    Configuration:      
      DestinationBucketName: amzn-s3-demo-bucket
      SourcePath: /artifacts/PublishToS3/MyDocSite/site
      TargetPath: my/docs/site
```

# Die Aktion „Amazon S3 Publish“ hinzufügen
<a name="s3-pub-action-add"></a>

 Verwenden Sie die folgenden Anweisungen, um die **Amazon S3 S3-Veröffentlichungsaktion** zu Ihrem Workflow hinzuzufügen. 

------
#### [ Visual ]

**Um die Aktion „Amazon S3 Publish“ mit dem Visual Editor hinzuzufügen**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie oben links **\$1 Aktionen**, um den Aktionskatalog zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der **Amazon S3 S3-Aktion „Veröffentlichen**“ und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie **Amazon S3 Publish**. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Quelltext** [anzeigen“, um den Quellcode der Aktion](workflows-view-source.md#workflows-view-source.title) anzuzeigen.
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Füllen Sie auf den Registerkarten **Eingaben**, **Konfiguration** und **Ausgaben** die Felder nach Ihren Bedürfnissen aus. Eine Beschreibung der einzelnen Felder finden Sie unter[Aktion „Amazon S3 veröffentlichen“ YAML](s3-pub-action-ref.md). Diese Referenz enthält detaillierte Informationen zu jedem Feld (und dem entsprechenden YAML-Eigenschaftswert), wie es sowohl im YAML- als auch im visuellen Editor angezeigt wird.

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein, und wählen Sie dann erneut **Commit** aus.

------
#### [ YAML ]

**Um die Aktion „Amazon S3 Publish“ mit dem YAML-Editor hinzuzufügen**

1. [Öffnen Sie die Konsole unter https://codecatalyst.aws/ CodeCatalyst .](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Wählen Sie links oben **\$1 Aktionen aus, um den Aktionskatalog** zu öffnen.

1. Wählen Sie in der Drop-down-Liste **Amazon** aus CodeCatalyst.

1. Suchen Sie nach der **Amazon S3 S3-Aktion „Veröffentlichen**“ und führen Sie einen der folgenden Schritte aus:
   + Wählen Sie das Pluszeichen (**\$1**), um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

     Oder
   + Wählen Sie **Amazon S3 Publish**. Das Dialogfeld mit den Aktionsdetails wird angezeigt. In diesem Dialogfeld:
     + (Optional) Wählen Sie „**Quelltext** [anzeigen“, um den Quellcode der Aktion](workflows-view-source.md#workflows-view-source.title) anzuzeigen.
     + Wählen Sie **Zum Workflow** hinzufügen, um die Aktion zum Workflow-Diagramm hinzuzufügen und den zugehörigen Konfigurationsbereich zu öffnen.

1. Ändern Sie die Eigenschaften im YAML-Code nach Ihren Bedürfnissen. Eine Erläuterung der einzelnen verfügbaren Eigenschaften finden Sie in der[Aktion „Amazon S3 veröffentlichen“ YAML](s3-pub-action-ref.md).

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein, und wählen Sie dann erneut **Commit** aus.

------

# Aktion „Amazon S3 veröffentlichen“ YAML
<a name="s3-pub-action-ref"></a>

Im Folgenden finden Sie die YAML-Definition der **Amazon S3 S3-Veröffentlichungsaktion**. Informationen zur Verwendung dieser Aktion finden Sie unter[Veröffentlichen von Dateien in Amazon S3 mit einem Workflow](s3-pub-action.md).

Diese Aktionsdefinition ist als Abschnitt in einer umfassenderen Workflow-Definitionsdatei vorhanden. Weitere Informationen über diese Datei finden Sie unter [YAML-Workflow-Definition](workflow-reference.md).

**Anmerkung**  
Die meisten der folgenden YAML-Eigenschaften haben entsprechende Benutzeroberflächenelemente im visuellen Editor. Verwenden Sie **Strg\$1F**, um nach einem UI-Element zu suchen. Das Element wird mit der zugehörigen YAML-Eigenschaft aufgelistet.

```
# The workflow definition starts here.
# See Eigenschaften der obersten Ebene for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.    
  S3Publish\$1nn: 
    Identifier: aws/s3-publish@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
      Variables:
        - Name: variable-name-1
          Value: variable-value-1
        - Name: variable-name-2
          Value: variable-value-2
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      SourcePath: my/source
      DestinationBucketName: amzn-s3-demo-bucket
      TargetPath: my/target
```

## S3Publish
<a name="s3.pub.name"></a>

(Erforderlich)

Geben Sie den Namen der Aktion an. Alle Aktionsnamen müssen innerhalb des Workflows eindeutig sein. Aktionsnamen sind auf alphanumerische Zeichen (a-z, A-Z, 0-9), Bindestriche (-) und Unterstriche (\$1) beschränkt. Leerzeichen sind nicht erlaubt. Sie können keine Anführungszeichen verwenden, um Sonderzeichen und Leerzeichen in Aktionsnamen zuzulassen.

Standard: `S3Publish_nn`.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration/Aktionsname“**

## Identifier
<a name="s3.pub.identifier"></a>

(*S3Publish*/**Identifier**)

(Erforderlich)

Identifiziert die Aktion. Ändern Sie diese Eigenschaft nicht, es sei denn, Sie möchten die Version ändern. Weitere Informationen finden Sie unter [Angabe der zu verwendenden Aktionsversion](workflows-action-versions.md).

Standard: `aws/s3-publish@v1`.

**Entsprechende Benutzeroberfläche: Workflow-Diagram/ S3Publish \$1nn/ aws/s3-publish @v1 label**

## DependsOn
<a name="s3.pub.dependson"></a>

(*S3Publish*/**DependsOn**)

(Optional)

Geben Sie eine Aktion, eine Aktionsgruppe oder ein Gate an, die erfolgreich ausgeführt werden müssen, damit diese Aktion ausgeführt werden kann.

Weitere Hinweise zur Funktion „Hängt davon ab“ finden Sie unter. [Aktionen sequenzieren](workflows-depends-on.md)

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Hängt davon ab**“ — optional

## Compute
<a name="s3.pub.computename"></a>

(*S3Publish*/**Compute**)

(Optional)

Die Rechen-Engine, die zur Ausführung Ihrer Workflow-Aktionen verwendet wurde. Sie können die Berechnung entweder auf Workflow-Ebene oder auf Aktionsebene angeben, aber nicht beide. Wenn auf Workflow-Ebene angegeben, gilt die Rechenkonfiguration für alle im Workflow definierten Aktionen. Auf Workflow-Ebene können Sie auch mehrere Aktionen auf derselben Instanz ausführen. Weitere Informationen finden Sie unter [Rechenleistung für mehrere Aktionen gemeinsam nutzen](compute-sharing.md).

Entsprechende Benutzeroberfläche: *keine*

## Type
<a name="s3.pub.computetype"></a>

(*S3Publish*/Compute/**Type**)

(Erforderlich, wenn [Compute](#s3.pub.computename) es enthalten ist)

Der Typ der Compute Engine. Sie können einen der folgenden Werte verwenden:
+ **EC2**(visueller Editor) oder `EC2` (YAML-Editor)

  Optimiert für Flexibilität bei Aktionsläufen.
+ **Lambda** (visueller Editor) oder `Lambda` (YAML-Editor)

  Optimierte Startgeschwindigkeiten für Aktionen.

Weitere Informationen zu Datentypen finden Sie unter [Berechnungstypen](workflows-working-compute.md#compute.types).

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration/Berechnungstyp**“

## Fleet
<a name="s3.pub.computefleet"></a>

(*S3Publish*/Compute/**Fleet**)

(Optional)

Geben Sie die Maschine oder Flotte an, auf der Ihr Workflow oder Ihre Workflow-Aktionen ausgeführt werden sollen. Bei bedarfsgesteuerten Flotten stellt der Workflow zu Beginn einer Aktion die benötigten Ressourcen bereit, und die Maschinen werden zerstört, wenn die Aktion abgeschlossen ist. Beispiele für Flotten auf Abruf:`Linux.x86-64.Large`,. `Linux.x86-64.XLarge` Weitere Informationen zu Flotten auf Abruf finden Sie unter. [Eigenschaften von On-Demand-Flotten](workflows-working-compute.md#compute.on-demand)

Bei bereitgestellten Flotten konfigurieren Sie eine Reihe von dedizierten Maschinen, um Ihre Workflow-Aktionen auszuführen. Diese Maschinen bleiben inaktiv und können sofort Aktionen ausführen. Weitere Informationen zu bereitgestellten Flotten finden Sie unter. [Eigenschaften von bereitgestellten Flotten](workflows-working-compute.md#compute.provisioned-fleets)

Wenn `Fleet` es weggelassen wird, ist die Standardeinstellung. `Linux.x86-64.Large`

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/„Flotte **berechnen**“

## Timeout
<a name="s3.pub.timeout"></a>

(*S3Publish*/**Timeout**)

(Erforderlich)

Geben Sie an, wie lange die Aktion in Minuten (YAML-Editor) oder Stunden und Minuten (visueller Editor) ausgeführt werden kann, bevor die Aktion CodeCatalyst beendet wird. Das Minimum beträgt 5 Minuten und das Maximum ist unter beschrieben[Kontingente für Workflows in CodeCatalyst](workflows-quotas.md). Das Standard-Timeout entspricht dem maximalen Timeout.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Timeout“ — optional**

## Inputs
<a name="s3.pub.inputs"></a>

(*S3Publish*/**Inputs**)

(Optional)

Der `Inputs` Abschnitt definiert die Daten, die während einer Workflow-Ausführung `S3Publish` benötigt werden.

**Anmerkung**  
Für jede **AWS CDK Bereitstellungsaktion** sind maximal vier Eingaben (eine Quelle und drei Artefakte) zulässig. Variablen werden auf diese Summe nicht angerechnet.

Wenn Sie auf Dateien verweisen müssen, die sich in unterschiedlichen Eingaben befinden (z. B. eine Quelle und ein Artefakt), ist die Quelleingabe die primäre Eingabe und das Artefakt die sekundäre Eingabe. Verweise auf Dateien in sekundären Eingaben benötigen ein spezielles Präfix, um sie von der primären Eingabe zu unterscheiden. Details hierzu finden Sie unter [Beispiel: Referenzieren von Dateien in mehreren Artefakten](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).

**Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“**

## Sources
<a name="s3.pub.inputs.sources"></a>

(*S3Publish*/Inputs/**Sources**)

(Erforderlich, wenn die Dateien, die Sie auf Amazon S3 veröffentlichen möchten, in einem Quell-Repository gespeichert sind)

Wenn die Dateien, die Sie in Amazon S3 veröffentlichen möchten, in einem Quell-Repository gespeichert sind, geben Sie die Bezeichnung dieses Quell-Repositorys an. Derzeit ist das einzige unterstützte Label`WorkflowSource`.

Wenn die Dateien, die Sie in Amazon S3 veröffentlichen möchten, nicht in einem Quell-Repository enthalten sind, müssen sie sich in einem Artefakt befinden, das durch eine andere Aktion generiert wurde.

Weitere Informationen zu Quellen finden Sie unter [Quell-Repositorys mit Workflows verbinden](workflows-sources.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„Quellen“ — optional**

## Artifacts - input
<a name="s3.pub.inputs.artifacts"></a>

(*S3Publish*/Inputs/**Artifacts**)

(Erforderlich, wenn die Dateien, die Sie auf Amazon S3 veröffentlichen möchten, in einem [Ausgabeartefakt](workflows-working-artifacts-output.md) einer vorherigen Aktion gespeichert sind)

Wenn die Dateien, die Sie auf Amazon S3 veröffentlichen möchten, in einem Artefakt enthalten sind, das durch eine vorherige Aktion generiert wurde, geben Sie dieses Artefakt hier an. Wenn Ihre Dateien nicht in einem Artefakt enthalten sind, müssen sie sich in Ihrem Quell-Repository befinden.

Weitere Informationen zu Artefakten, einschließlich Beispielen, finden Sie unter. [Artefakte und Dateien zwischen Aktionen teilen](workflows-working-artifacts.md)

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/„**Artefakte“ — optional**

## Variables - input
<a name="s3.pub.inputs.variables"></a>

(*S3Publish*/Inputs/**Variables**)

(Optional)

Geben Sie eine Sequenz von name/value Paaren an, die die Eingabevariablen definieren, die Sie für die Aktion verfügbar machen möchten. Variablennamen sind auf alphanumerische Zeichen (a-z, A-Z, 0-9), Bindestriche (-) und Unterstriche (\$1) beschränkt. Leerzeichen sind nicht erlaubt. Sie können keine Anführungszeichen verwenden, um Sonderzeichen und Leerzeichen in Variablennamen zuzulassen.

Weitere Informationen zu Variablen, einschließlich Beispielen, finden Sie unter[Verwenden von Variablen in Workflows](workflows-working-with-variables.md).

Entsprechende Benutzeroberfläche: Registerkarte „Eingaben“/„**Variablen“ — optional**

## Environment
<a name="s3.pub.environment"></a>

(*S3Publish*/**Environment**)

(Erforderlich)

Geben Sie die CodeCatalyst Umgebung an, die für die Aktion verwendet werden soll. Die Aktion stellt eine Verbindung mit der AWS-Konto optionalen Amazon VPC her, die in der ausgewählten Umgebung angegeben ist. Die Aktion verwendet die in der Umgebung angegebene Standard-IAM-Rolle, um sich mit der Amazon VPC zu verbinden AWS-Konto, und verwendet die in der [Amazon VPC-Verbindung angegebene IAM-Rolle, um eine Verbindung zur Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) herzustellen.

**Anmerkung**  
Wenn die Standard-IAM-Rolle nicht über die für die Aktion erforderlichen Berechtigungen verfügt, können Sie die Aktion so konfigurieren, dass sie eine andere Rolle verwendet. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

Weitere Informationen zu Umgebungen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md) und[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Name
<a name="s3.pub.environment.name"></a>

(*S3Publish*/Environment/**Name**)

(Erforderlich, wenn [Environment](#s3.pub.environment) es enthalten ist)

Geben Sie den Namen einer vorhandenen Umgebung an, die Sie der Aktion zuordnen möchten.

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration/Umgebung“**

## Connections
<a name="s3.pub.environment.connections"></a>

(*S3Publish*/Environment/**Connections**)

(Optional in neueren Versionen der Aktion; in älteren Versionen erforderlich)

Geben Sie die Kontoverbindung an, die der Aktion zugeordnet werden soll. Sie können unter maximal eine Kontoverbindung angeben`Environment`.

Wenn Sie keine Kontoverbindung angeben:
+ Die Aktion verwendet die AWS-Konto Verbindung und die Standard-IAM-Rolle, die in der Umgebung in der CodeCatalyst Konsole angegeben sind. Informationen zum Hinzufügen einer Kontoverbindung und einer Standard-IAM-Rolle zur Umgebung finden Sie unter. [Erstellen einer Umgebung](deploy-environments-creating-environment.md)
+ Die Standard-IAM-Rolle muss die Richtlinien und Berechtigungen enthalten, die für die Aktion erforderlich sind. **Informationen zu diesen Richtlinien und Berechtigungen finden Sie in der Beschreibung der Role-Eigenschaft in der YAML-Definitionsdokumentation der Aktion.**

Weitere Informationen zu Kontoverbindungen finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md). Hinweise zum Hinzufügen einer Kontoverbindung zu einer Umgebung finden Sie unter[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Name
<a name="s3.pub.environment.connections.name"></a>

(*S3Publish*/Environment/Connections/**Name**)

(Erforderlich, wenn [Connections](#s3.pub.environment.connections) es enthalten ist)

Geben Sie den Namen der Kontoverbindung an.

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte „Konfiguration“/„/Kontoverbindung Environment/account/role AWS **

## Role
<a name="s3.pub.environment.connections.role"></a>

(*S3Publish*/Environment/Connections/**Role**)

(Erforderlich, wenn [Connections](#s3.pub.environment.connections) es enthalten ist)

Geben Sie den Namen der IAM-Rolle an, die die **Amazon S3-Veröffentlichungsaktion** für den Zugriff auf AWS und das Kopieren von Dateien nach Amazon S3 verwendet. Stellen Sie sicher, dass Sie [die Rolle zu Ihrem CodeCatalyst Bereich hinzugefügt](ipa-connect-account-addroles.md) haben und dass die Rolle die folgenden Richtlinien enthält.

Wenn Sie keine IAM-Rolle angeben, verwendet die Aktion die Standard-IAM-Rolle, die in der [Umgebung](deploy-environments.md) in der CodeCatalyst Konsole aufgeführt ist. Wenn Sie die Standardrolle in der Umgebung verwenden, stellen Sie sicher, dass sie über die folgenden Richtlinien verfügt.
+ Die folgende Berechtigungsrichtlinie:
**Warnung**  
Beschränken Sie die Berechtigungen auf diejenigen, die in der folgenden Richtlinie aufgeführt sind. Die Verwendung einer Rolle mit umfassenderen Berechtigungen kann ein Sicherheitsrisiko darstellen.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "s3:PutObject",
                  "s3:ListBucket",
                  "s3:DeleteObject"
              ],
              "Resource": [
                  "arn:aws:s3:::bucket-name",
                  "arn:aws:s3:::bucket-name/*"
              ]
          }
      ]
  }
  ```

------
+ Die folgende benutzerdefinierte Vertrauensrichtlinie:

**Anmerkung**  
Sie können die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle mit dieser Aktion verwenden, wenn Sie möchten. Weitere Informationen über diese Rolle finden Sie unter [Die **CodeCatalystWorkflowDevelopmentRole-*spaceName***Rolle für Ihr Konto und Ihren Bereich erstellen](ipa-iam-roles.md#ipa-iam-roles-service-create). Beachten Sie, dass die `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle über volle Zugriffsberechtigungen verfügt, was ein Sicherheitsrisiko darstellen kann. Wir empfehlen, diese Rolle nur in Tutorials und Szenarien zu verwenden, in denen die Sicherheit weniger wichtig ist. 

Entsprechende Benutzeroberfläche: Je nach Aktionsversion eine der folgenden Optionen:
+ (Neuere Versionen) tab/Environment/What Die Konfiguration ist da*my-environment*? **/Dreipunktmenü/ Rolle wechseln**
+ **(Ältere Versionen) Registerkarte Environment/account/role „Konfiguration“ /' '/ Rolle**

## Configuration
<a name="s3.pub.configuration"></a>

(*S3Publish*/**Configuration**)

(Erforderlich)

Ein Abschnitt, in dem Sie die Konfigurationseigenschaften der Aktion definieren können.

Entsprechende Benutzeroberfläche: Registerkarte „**Konfiguration**“

## SourcePath
<a name="s3.pub.source.directory"></a>

(*S3Publish*/Configuration/**SourcePath**)

(Erforderlich)

Geben Sie den Namen und den Pfad eines Verzeichnisses oder einer Datei an, die Sie in Amazon S3 veröffentlichen möchten. Das Verzeichnis oder die Datei kann sich in einem Quell-Repository oder einem Artefakt aus einer früheren Aktion befinden und ist relativ zum Quell-Repository oder Artefakt-Root.

Beispiele:

Durch die Angabe wird der Inhalt von `/myFolder` nach Amazon S3 `./myFolder/` kopiert, wobei die zugrunde liegende Verzeichnisstruktur beibehalten wird.

Spezifizierung von `./myFolder/myfile.txt` Kopien *nur* `myfile.txt` für Amazon S3. (Die Verzeichnisstruktur wurde entfernt.)

Sie können keine Platzhalter verwenden.

**Anmerkung**  
Möglicherweise müssen Sie dem Verzeichnis- oder Dateipfad ein Präfix hinzufügen, um anzugeben, in welchem Artefakt oder in welcher Quelle es zu finden ist. Weitere Informationen erhalten Sie unter [Quell-Repository-Dateien referenzieren](workflows-sources-reference-files.md) und [Referenzieren von Dateien in einem Artefakt](workflows-working-artifacts-refer-files.md).

**Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/Quellpfad**

## DestinationBucketName
<a name="s3.pub.dest.bucket"></a>

(*S3Publish*/Configuration/**DestinationBucketName**)

(Erforderlich)

Geben Sie den Namen des Amazon S3 S3-Buckets an, in dem Sie Dateien veröffentlichen möchten.

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/„**Ziel-Bucket“ — optional**

## TargetPath
<a name="s3.pub.dest.directory"></a>

(*S3Publish*/Configuration/**TargetPath**)

(Optional)

Geben Sie den Namen und den Pfad des Verzeichnisses in Amazon S3 an, in dem Sie Ihre Dateien veröffentlichen möchten. Wenn das Verzeichnis nicht existiert, wird es erstellt. Der Verzeichnispfad darf den Bucket-Namen nicht enthalten.

Beispiele:

`myS3Folder`

`./myS3Folder/myS3Subfolder`

Entsprechende Benutzeroberfläche: Registerkarte „Konfiguration“/„**Zielverzeichnis“ — optional**

# Einsatz in AWS-Konten und VPCs
<a name="deploy-environments"></a>

Mithilfe von [CodeCatalyst Workflows](workflow.md) können Sie Anwendungen und andere Ressourcen für Target AWS-Konto s und Amazon VPCs in der AWS Cloud bereitstellen. Um diese Bereitstellungen zu ermöglichen, müssen Sie CodeCatalyst Umgebungen einrichten.

Eine CodeCatalyst *Umgebung*, nicht zu verwechseln mit einer [Entwicklungsumgebung](https://docs.aws.amazon.com/codecatalyst/latest/userguide/devenvironment.html), definiert das Ziel AWS-Konto und die optionale Amazon-VPC, mit der ein CodeCatalyst [Workflow](workflow.md) eine Verbindung herstellt. Eine Umgebung definiert auch die [IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html), die ein Workflow benötigt, um auf die AWS Dienste und Ressourcen innerhalb des Zielkontos zuzugreifen.

Sie können mehrere Umgebungen einrichten und ihnen Namen wie „Entwicklung“, „Test“, „Staging“ und „Produktion“ geben. Wenn Sie die Bereitstellung in diesen Umgebungen durchführen, werden Informationen zu den Bereitstellungen auf den Registerkarten CodeCatalyst **Bereitstellungsaktivität** und **Bereitstellungsziele** in der Umgebung angezeigt.

## Erste Schritte mit Umgebungen?
<a name="deploy-environments-get-started"></a>

Die allgemeinen Schritte zum Hinzufügen und Verwenden einer CodeCatalyst Umgebung lauten wie folgt:

1. **Verbinde in deinem CodeCatalyst Bereich ein oder mehrere AWS Konten**. Fügen Sie während dieses Vorgangs die IAM-Rollen hinzu, die Ihr Workflow für den Zugriff auf Ressourcen in Ihrem AWS-Konto benötigt. Weitere Informationen finden Sie unter [Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md).

1. **Erstellen Sie in Ihrem CodeCatalyst Projekt eine Umgebung**, die eine der Rollen AWS-Konto s und IAM aus Schritt 1 enthält. Weitere Informationen finden Sie unter [Erstellen einer Umgebung](deploy-environments-creating-environment.md).

1. Fügen Sie in Ihrem CodeCatalyst Projekt in einem Workflow **eine [Aktion](workflows-actions.md) hinzu, die auf die Umgebung verweist, die** Sie in Schritt 2 erstellt haben. Weitere Informationen finden Sie unter [Aktion zu einem Workflow hinzufügen](workflows-add-action.md).

   Sie haben jetzt eine Umgebung konfiguriert. Die Aktion kann nun Ressourcen in der in der Umgebung AWS-Konto angegebenen Umgebung bereitstellen.

**Anmerkung**  
Sie können der Umgebung auch eine Amazon VPC hinzufügen. Weitere Informationen finden Sie unter [Hinzufügen von VPC-Verbindungen für einen Space](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) im *CodeCatalyst Administrationshandbuch* und[Eine VPC mit einer Umgebung verknüpfen](deploy-environments-associate-vpc.md).

## Können mehrere Umgebungen innerhalb eines einzigen Workflows existieren?
<a name="deploy-environments-multiple"></a>

Ja. Wenn ein Workflow mehrere Aktionen umfasst, kann jeder dieser Aktionen eine Umgebung zugewiesen werden. Sie könnten beispielsweise einen Workflow haben, der zwei Bereitstellungsaktionen umfasst, wobei einer Aktion eine `my-staging-enviroment` Umgebung und einer anderen eine `my-production-environment` Umgebung zugewiesen wird.

## Welche Workflow-Aktionen unterstützen Umgebungen?
<a name="deploy-environments-supported"></a>

Jede Workflow-Aktion, die Ressourcen in der AWS Cloud bereitstellt oder aus anderen Gründen (z. B. Überwachung und Berichterstattung) mit AWS Diensten kommuniziert, unterstützt Umgebungen.

## Welche Aktionen unterstützen die Anzeige ihrer Bereitstellungsinformationen in? CodeCatalyst
<a name="deploy-environments-supported-targets"></a>

Von den Workflow-Aktionen, die Umgebungen unterstützen, unterstützen nur wenige die Anzeige ihrer Bereitstellungsinformationen auf den Seiten **Bereitstellungsaktivität** und **Bereitstellungsziele** der CodeCatalyst Konsole.

Die folgenden Workflow-Aktionen unterstützen die Anzeige ihrer Bereitstellungsinformationen:
+ ** CloudFormation Stack bereitstellen** — Weitere Informationen finden Sie unter [Einen CloudFormation Stack bereitstellen](deploy-action-cfn.md)
+ Auf **Amazon ECS bereitstellen** — Weitere Informationen finden Sie unter [Bereitstellung auf Amazon ECS mit einem Workflow](deploy-action-ecs.md)
+ Auf einem **Kubernetes-Cluster bereitstellen** — Weitere Informationen finden Sie unter [Bereitstellung auf Amazon EKS mit einem Workflow](deploy-action-eks.md)
+ **AWS CDK bereitstellen** — Weitere Informationen finden Sie unter [Eine AWS CDK App mit einem Workflow bereitstellen](cdk-dep-action.md)

## Unterstützte Regionen
<a name="deploy-environments-supported-regions"></a>

Auf der Seite **Umgebungen** können Ressourcen in jeder AWS Region angezeigt werden.

## Ist eine Umgebung verpflichtend?
<a name="deploy-environments-optional-or-mandatory"></a>

Eine Umgebung ist obligatorisch, wenn die Workflow-Aktion, der sie zugewiesen ist, Ressourcen in der AWS Cloud bereitstellt oder aus anderen Gründen (z. B. Überwachung und Berichterstattung) mit AWS Diensten kommuniziert.

Wenn Sie beispielsweise eine Build-Aktion haben, die eine Anwendung erstellt, aber nicht mit Ihrer AWS-Konto oder Amazon VPC kommunizieren muss, müssen Sie der Aktion keine Umgebung zuweisen. Wenn die Build-Aktion jedoch Protokolle an den CloudWatch Amazon-Service in Ihrem sendet AWS-Konto, muss der Aktion eine Umgebung zugewiesen werden. 

**Topics**
+ [Erste Schritte mit Umgebungen?](#deploy-environments-get-started)
+ [Können mehrere Umgebungen innerhalb eines einzigen Workflows existieren?](#deploy-environments-multiple)
+ [Welche Workflow-Aktionen unterstützen Umgebungen?](#deploy-environments-supported)
+ [Welche Aktionen unterstützen die Anzeige ihrer Bereitstellungsinformationen in? CodeCatalyst](#deploy-environments-supported-targets)
+ [Unterstützte Regionen](#deploy-environments-supported-regions)
+ [Ist eine Umgebung verpflichtend?](#deploy-environments-optional-or-mandatory)
+ [Erstellen einer Umgebung](deploy-environments-creating-environment.md)
+ [Eine Umgebung mit einer Aktion verknüpfen](deploy-environments-add-app-to-environment.md)
+ [Eine VPC mit einer Umgebung verknüpfen](deploy-environments-associate-vpc.md)
+ [Einen AWS-Konto mit einer Umgebung verknüpfen](deploy-environments-associate-account.md)
+ [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md)

# Erstellen einer Umgebung
<a name="deploy-environments-creating-environment"></a>

Verwenden Sie die folgenden Anweisungen, um eine Umgebung zu erstellen, die Sie später einer Workflow-Aktion zuordnen können.

**Bevor Sie beginnen**

Sie benötigen Folgendes:
+ Ein CodeCatalyst Leerzeichen. Weitere Informationen finden Sie unter [Richten Sie ein und melden Sie sich an CodeCatalystRichten Sie ein und melden Sie sich an bei CodeCatalyst](setting-up-topnode.md).
+ Ein CodeCatalyst Projekt. Weitere Informationen finden Sie unter [Ein Projekt mit einem Blueprint erstellen](projects-create.md#projects-create-console-template).
+ Eine AWS Kontoverbindung, die die IAM-Rollen enthält, auf die Ihre Workflow-Aktion zugreifen AWS muss. Informationen zum Erstellen einer Kontoverbindung finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md). Sie können maximal eine Kontoverbindung pro Umgebung verwenden.
**Anmerkung**  
Sie können eine Umgebung ohne Kontoverbindung erstellen. Sie müssen jedoch später zurückkommen und die Verbindung hinzufügen.
+ Eine der folgenden CodeCatalyst Rollen:
  + **Bereichsadministrator**
  + **Projektadministrator**
  + **Beitragender**
**Anmerkung**  
Wenn Sie die **Rolle Mitwirkender** haben, können Sie eine Umgebung erstellen, sie jedoch keiner AWS-Konto Verbindung zuordnen. Sie müssen jemanden mit der Rolle **Space-Administrator** oder **Projektadministrator** bitten, die Umgebung einer AWS-Konto Verbindung zuzuordnen.

   Weitere Informationen zu Berechtigungen und Rollen finden Sie unter[Benutzern Projektberechtigungen gewähren](projects-members.md).

**So erstellen Sie eine Umgebung**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Environments aus.**

1. Geben Sie im Feld **Umgebungsname** einen Namen ein, z. B. **Production** oder. **Staging**

1. Wählen Sie **unter Umgebungstyp** eine der folgenden Optionen aus:
   + **Nicht-Produktionsumgebung** — Eine Umgebung, in der Sie Ihre Anwendung testen können, um sicherzustellen, dass sie wie vorgesehen funktioniert, bevor Sie sie in die Produktionsumgebung überführen.
   + **Produktion** — Eine „Live-Umgebung“, die öffentlich verfügbar ist und Ihre fertige Anwendung hostet.

     Wenn Sie „**Produktion**“ wählen, wird auf der Benutzeroberfläche neben allen Aktionen, mit denen die Umgebung verknüpft ist, ein **Produktions-Logo** angezeigt. Anhand des Badges können Sie schnell erkennen, welche Aktionen in der Produktion bereitgestellt werden. Abgesehen vom Aussehen des Badges gibt es keine Unterschiede zwischen Produktions- und Nicht-Produktionsumgebungen.

1. (Optional) Geben Sie **unter Beschreibung** eine Beschreibung ein, z. B. **Production environment for the hello-world app**

1. Wählen Sie unter **AWS-Konto Verbindung — optional** die AWS Kontoverbindung aus, die Sie dieser Umgebung zuordnen möchten. Workflow-Aktionen, denen diese Umgebung zugewiesen ist, können eine Verbindung mit der zugehörigen Umgebung herstellen AWS-Konto. Weitere Informationen zum Erstellen von AWS-Konto Verbindungen in CodeCatalyst finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md).

   Wenn die AWS-Konto Verbindung, die Sie verwenden möchten, nicht aufgeführt ist, liegt das möglicherweise daran, dass sie in Ihrem Projekt nicht zulässig ist. Weitere Informationen finden Sie unter [Konfiguration von projektbeschränkten Kontoverbindungen](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) im * CodeCatalyst Amazon-Administratorhandbuch*.

1. Wählen Sie unter **Standard-IAM-Rolle** die IAM-Rolle aus, die Sie dieser Umgebung zuordnen möchten. Workflow-Aktionen, denen diese Umgebung zugewiesen ist, erben diese IAM-Rolle und können sie verwenden, um eine Verbindung zu Diensten und Ressourcen in Ihrer Umgebung herzustellen. AWS-Konto

   Wenn Sie die Umgebung mehreren Aktionen zuweisen müssen und für diese Aktionen IAM-Rollen erforderlich sind, die sich von der hier angegebenen Standardrolle unterscheiden, können Sie die verschiedenen Rollen auf der Registerkarte **Konfiguration** jeder Aktion mithilfe der Option Rolle **wechseln** angeben. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

   Wenn die IAM-Rolle, die Sie als Standard verwenden möchten, nicht aufgeführt ist, liegt das möglicherweise daran, dass Sie sie Ihrer AWS-Konto Verbindung noch nicht hinzugefügt haben. Informationen zum Hinzufügen einer IAM-Rolle zu einer Kontoverbindung finden Sie unter. [Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md)

1. (Optional) Wählen Sie **VPC VPC-Verbindung** eine VPC-Verbindung aus, die Sie dieser Umgebung zuordnen möchten. Weitere Informationen zum Erstellen von VPC-Verbindungen finden Sie unter [Managing Amazon Virtual Private Clouds](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html) im *Amazon CodeCatalyst Administrator Guide*.

   Wenn die VPC-Verbindung, die Sie verwenden möchten, nicht aufgeführt ist, kann dies daran liegen, dass sie eine AWS-Konto Verbindung enthält, die in Ihrem Projekt nicht zulässig ist. Weitere Informationen finden Sie unter [Konfiguration von projektbeschränkten Kontoverbindungen](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) im * CodeCatalyst Amazon-Administratorhandbuch*.

1. Wählen Sie Umgebung **erstellen**. CodeCatalyst erstellt eine leere Umgebung.

**Nächste Schritte**
+ Nachdem Sie eine Umgebung erstellt haben, können Sie sie einer Workflow-Aktion zuordnen. Weitere Informationen finden Sie unter [Eine Umgebung mit einer Aktion verknüpfen](deploy-environments-add-app-to-environment.md).

# Eine Umgebung mit einer Aktion verknüpfen
<a name="deploy-environments-add-app-to-environment"></a>

Wenn Sie eine Umgebung mit einer [unterstützten Workflow-Aktion](deploy-environments.md#deploy-environments-supported) verknüpfen, werden der Aktion die Standard-IAM-Rolle der Umgebung und die optionale Amazon VPC zugewiesen. AWS-Konto Die Aktion kann dann AWS-Konto mithilfe der IAM-Rolle eine Verbindung herstellen und diese bereitstellen sowie eine Verbindung zur optionalen Amazon-VPC herstellen.

Verwenden Sie die folgenden Anweisungen, um einer Aktion eine Umgebung zuzuordnen.

## Schritt 1: Ordnen Sie die Umgebung einer Workflow-Aktion zu
<a name="deploy-environments-add-app-to-environment-assoc"></a>

Gehen Sie wie folgt vor, um einer Workflow-Aktion eine Umgebung zuzuordnen.

------
#### [ Visual ]

**So verknüpfen Sie mithilfe des visuellen Editors eine Umgebung mit einer Workflow-Aktion**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **Visual**.

1. Wählen Sie im Workflow-Diagramm eine Aktion aus, die von Umgebungen unterstützt wird. Weitere Informationen finden Sie unter [Welche Aktionen unterstützen die Anzeige ihrer Bereitstellungsinformationen in? CodeCatalyst](deploy-environments.md#deploy-environments-supported-targets).

1. Wählen Sie die Registerkarte **Konfiguration** und geben Sie Informationen im Feld **Umgebung** wie folgt an.

   **Umgebung**

   Geben Sie die CodeCatalyst Umgebung an, die für die Aktion verwendet werden soll. Die Aktion stellt eine Verbindung mit der AWS-Konto optionalen Amazon VPC her, die in der ausgewählten Umgebung angegeben ist. Die Aktion verwendet die in der Umgebung angegebene Standard-IAM-Rolle, um eine Verbindung zur herzustellen AWS-Konto, und verwendet die in der Amazon VPC-Verbindung angegebene IAM-Rolle, um eine [Verbindung zur Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) herzustellen.
**Anmerkung**  
Wenn die Standard-IAM-Rolle nicht über die für die Aktion erforderlichen Berechtigungen verfügt, können Sie die Aktion so konfigurieren, dass sie eine andere Rolle verwendet. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

   Weitere Informationen zu Umgebungen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md) und[Erstellen einer Umgebung](deploy-environments-creating-environment.md).

1. (Optional) Ändern Sie die der Aktion zugeordnete IAM-Rolle. Möglicherweise möchten Sie die Rolle ändern, wenn sie die falschen Berechtigungen für die Aktion enthält.

    Um die Rolle zu ändern:

   1. Im Bereich **Was ist drin*my-environment*?** und wählen Sie das vertikale Ellipsensymbol (![\[Ellipsis.\]](http://docs.aws.amazon.com/de_de/codecatalyst/latest/userguide/images/flows/elipsis.png)).

   1. Wählen Sie eine der folgenden Optionen:
      +  **Rolle wechseln**. Wählen Sie diese Option, um die von dieser Aktion verwendete IAM-Rolle zu ändern, und zwar nur für diese Aktion. Andere Aktionen verwenden weiterhin die Standard-IAM-Rolle, die in der zugehörigen Umgebung angegeben ist. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).
      +  **Umgebung bearbeiten.** Wählen Sie diese Option, um die in Ihrer Umgebung aufgeführte Standard-IAM-Rolle zu ändern. Wenn Sie diese Option wählen, beginnt Ihre Aktion — und jede andere Aktion, die mit derselben Umgebung verknüpft ist — die neue Standard-IAM-Rolle zu verwenden.
**Wichtig**  
Seien Sie vorsichtig, wenn Sie die Standard-IAM-Rolle aktualisieren. Das Ändern der Rolle kann dazu führen, dass Aktionen fehlschlagen, wenn die Berechtigungen in der Rolle nicht für alle Aktionen ausreichen, die die Umgebung gemeinsam nutzen.

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit**.

------
#### [ YAML ]

**Um mithilfe des YAML-Editors eine Umgebung mit einer Workflow-Aktion zu verknüpfen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Fügen Sie in der Workflow-Aktion, die Sie einer Umgebung zuordnen möchten, Code hinzu, der dem folgenden ähnelt:

   ```
   action-name:
     Environment:
       Name: environment-name
   ```

   Weitere Informationen finden Sie im [Aktionstypen](workflows-actions.md#workflows-actions-types) Thema. Dieses Thema enthält Links zur Dokumentation für jede Aktion, einschließlich der zugehörigen YAML-Referenz.

1. (Optional) Wenn Sie möchten, dass die Aktion eine andere Rolle als die Standard-IAM-Rolle verwendet, die in der Umgebung aufgeführt ist, fügen Sie einen `Connections:` Abschnitt hinzu, der die Rolle enthält, die Sie verwenden möchten. Weitere Informationen finden Sie unter [Die IAM-Rolle einer Aktion ändern](deploy-environments-switch-role.md).

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit**.

------

## Schritt 2: Füllen Sie die Seite mit den Bereitstellungsaktivitäten aus
<a name="deploy-environments-add-app-to-environment-run"></a>

Nachdem Sie eine Umgebung mit einer Workflow-Aktion verknüpft haben, können Sie die Seiten **Bereitstellungsaktivität** und **Bereitstellungsziele** im Bereich **Umgebungen** der CodeCatalyst Konsole mit Bereitstellungsinformationen füllen. Verwenden Sie die folgenden Anweisungen, um diese Seiten zu füllen.

**Anmerkung**  
Nur bei wenigen Aktionen wird die Anzeige ihrer Bereitstellungsinformationen in der CodeCatalyst Konsole unterstützt. Weitere Informationen finden Sie unter [Welche Aktionen unterstützen die Anzeige ihrer Bereitstellungsinformationen in? CodeCatalyst](deploy-environments.md#deploy-environments-supported-targets).

**Um Bereitstellungsinformationen hinzuzufügen CodeCatalyst**

1. Wenn eine Workflow-Ausführung nicht automatisch gestartet wurde, als Sie Ihre Änderungen übernommen haben[Schritt 1: Ordnen Sie die Umgebung einer Workflow-Aktion zu](#deploy-environments-add-app-to-environment-assoc), starten Sie eine Ausführung manuell wie folgt:

   1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

   1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

   1. Klicken Sie auf **Ausführen**.

   Bei der Workflow-Ausführung wird eine neue Bereitstellung gestartet, CodeCatalyst woraufhin Bereitstellungsinformationen hinzugefügt CodeCatalyst werden müssen.

1. Stellen Sie sicher, dass die Bereitstellungsaktivität zur CodeCatalyst Konsole hinzugefügt wurde:

   1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Environments aus.**

   1. Wählen Sie Ihre Umgebung aus (z. B.`Production`).

   1. Wählen Sie die Registerkarte **Bereitstellungsaktivität** und vergewissern Sie sich, dass eine Bereitstellung den **Status SUCCEED** **hat**. Dies weist darauf hin, dass Ihre Anwendungsressourcen bei einer Workflow-Ausführung erfolgreich bereitgestellt wurden.

   1. Wählen Sie die Registerkarte **Bereitstellungsziele** und überprüfen Sie, ob Ihre Anwendungsressourcen angezeigt werden.

# Eine VPC mit einer Umgebung verknüpfen
<a name="deploy-environments-associate-vpc"></a>

Wenn eine Aktion mit einer Umgebung konfiguriert ist, die über eine VPC-Verbindung verfügt, wird die Aktion in Verbindung mit der VPC ausgeführt, wobei die von der zugehörigen VPC angegebenen Netzwerkregeln und Zugriffsressourcen eingehalten werden. Dieselbe VPC-Verbindung kann von einer oder mehreren Umgebungen verwendet werden.

Verwenden Sie die folgenden Anweisungen, um eine VPC-Verbindung mit einer Umgebung zu verknüpfen.

**So verknüpfen Sie eine VPC-Verbindung mit einer Umgebung**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Environments aus.**

1. Wählen Sie Ihre Umgebung aus (z. B.`Production`).

1. Wählen Sie die Registerkarte **Umgebungseigenschaften**.

1. **Wählen Sie **VPC-Verbindung verwalten**, wählen Sie die gewünschte VPC-Verbindung aus und klicken Sie auf Bestätigen.** Dadurch wird Ihre ausgewählte VPC-Verbindung mit dieser Umgebung verknüpft.
**Anmerkung**  
Wenn die VPC-Verbindung, die Sie verwenden möchten, nicht aufgeführt ist, kann dies daran liegen, dass sie eine AWS-Konto Verbindung enthält, die in Ihrem Projekt nicht zulässig ist. Weitere Informationen finden Sie unter [Konfiguration von projektbeschränkten Kontoverbindungen](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) im * CodeCatalystAmazon-Administratorhandbuch*.

Weitere Informationen finden Sie unter [Managing Amazon Virtual Private Clouds](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html) im *CodeCatalyst Administratorhandbuch*.

# Einen AWS-Konto mit einer Umgebung verknüpfen
<a name="deploy-environments-associate-account"></a>

Verwenden Sie die folgenden Anweisungen, um einen AWS-Konto mit einer Umgebung zu verknüpfen. Wenn Sie einer Umgebung eine AWS-Konto zuordnen, können Workflow-Aktionen, denen die Umgebung zugewiesen ist, eine Verbindung zu der herstellen AWS-Konto.

Weitere Informationen zu Kontoverbindungen finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md).

**Bevor Sie beginnen**

Sie benötigen Folgendes:
+ Eine AWS Kontoverbindung, die die IAM-Rollen enthält, auf die Ihre Workflow-Aktion zugreifen AWS muss. Informationen zum Erstellen einer Kontoverbindung finden Sie unter[Ermöglichen des Zugriffs auf AWS Ressourcen mit verbundenen AWS-Konten](ipa-connect-account.md). Sie können maximal eine Kontoverbindung pro Umgebung verwenden.
+ Eine der folgenden CodeCatalyst Rollen: **Bereichsadministrator** oder **Projektadministrator**. Weitere Informationen finden Sie unter [Benutzern Projektberechtigungen gewähren](projects-members.md).

**Um einer Umgebung eine AWS-Konto Person zuzuordnen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Environments aus.**

1. Wählen Sie Ihre Umgebung aus (z. B.`Production`).

1. Wählen Sie **Umgebung bearbeiten**.

1. Wählen Sie unter **Umgebungseigenschaften** in der Dropdownliste **AWS-Konto Verbindung — optional** die gewünschte Option aus AWS-Konto.

   Wenn die AWS-Konto Verbindung, die Sie verwenden möchten, nicht aufgeführt ist, liegt das möglicherweise daran, dass sie in Ihrem Projekt nicht zulässig ist. Weitere Informationen finden Sie unter [Konfiguration von projektbeschränkten Kontoverbindungen](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html) im * CodeCatalyst Amazon-Administratorhandbuch*.

1. Wählen Sie unter **Standard-IAM-Rolle** die IAM-Rolle aus, die Sie dieser Umgebung zuordnen möchten. Workflow-Aktionen, denen diese Umgebung zugewiesen ist, erben diese IAM-Rolle und können sie verwenden, um eine Verbindung zu Diensten und Ressourcen in Ihrer Umgebung herzustellen. AWS-Konto

   Wenn die IAM-Rolle, die Sie als Standard verwenden möchten, nicht aufgeführt ist, liegt das möglicherweise daran, dass Sie sie Ihrer AWS-Konto Verbindung noch nicht hinzugefügt haben. Informationen zum Hinzufügen einer IAM-Rolle zu einer Kontoverbindung finden Sie unter. [Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md)

# Die IAM-Rolle einer Aktion ändern
<a name="deploy-environments-switch-role"></a>

Wenn Sie einer [Workflow-Aktion eine [Umgebung](deploy-environments.md) zuordnen, erbt die Aktion](workflows-actions.md) standardmäßig die in der Umgebung angegebene IAM-Standardrolle. Sie können dieses Verhalten ändern, sodass die Aktion eine andere Rolle verwendet. Möglicherweise möchten Sie, dass eine Aktion eine andere Rolle verwendet, wenn der Standard-IAM-Rolle die Berechtigungen fehlen, die die Aktion für den Betrieb in der AWS Cloud benötigt.

Um einer Aktion eine andere IAM-Rolle zuzuweisen, können Sie die Option **Rolle wechseln** im visuellen Editor oder die `Connections:` Eigenschaft im YAML-Editor verwenden. Die neue Rolle überschreibt die in der Umgebung angegebene Standard-IAM-Rolle, sodass Sie die Standard-IAM-Rolle unverändert beibehalten können. Möglicherweise möchten Sie die Standard-IAM-Rolle unverändert lassen, falls es andere Aktionen gibt, die sie verwenden.

Verwenden Sie die folgenden Anweisungen, um eine Aktion so zu konfigurieren, dass sie eine andere als die in der Umgebung angegebene IAM-Rolle verwendet.

------
#### [ Visual ]

**So weisen Sie einer Aktion eine andere IAM-Rolle zu (visueller Editor)**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie das Feld für die Aktion aus, deren IAM-Rolle Sie aktualisieren möchten.

1. Wählen Sie die Registerkarte **Konfiguration** aus.

1. Im Bereich **Was ist drin*my-environment*?** Wählen Sie das vertikale Ellipsensymbol (![\[Ellipsis.\]](http://docs.aws.amazon.com/de_de/codecatalyst/latest/userguide/images/flows/elipsis.png)) aus.

1. Wählen Sie **Rolle wechseln** aus.

1. Wählen **Sie im Dialogfeld „Rolle wechseln**“ in der Dropdownliste „**IAM-Rolle**“ die IAM-Rolle aus, die die Aktion verwenden soll. Diese Rolle überschreibt die Standard-IAM-Rolle in der Umgebung. Wenn die Rolle, die Sie verwenden möchten, nicht in der Liste enthalten ist, stellen Sie sicher, dass Sie sie Ihrem Bereich hinzugefügt haben. Weitere Informationen finden Sie unter [Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md).

   Die gewählte Rolle erscheint jetzt in der Liste **Was ist drin*my-environment*?** Feld zusammen mit dem Badge **Definiert im Workflow**. Die Rolle wird auch in der Workflow-Definitionsdatei im `Connections:` Abschnitt angezeigt.

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit**.

------
#### [ YAML ]

**Um einer Aktion eine andere IAM-Rolle zuzuweisen (YAML-Editor)**

1. [Öffnen Sie die CodeCatalyst Konsole unter https://codecatalyst.aws/.](https://codecatalyst.aws/)

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Bearbeiten** aus.

1. Wählen Sie **YAML.**

1. Fügen Sie der Workflow-Aktion, für die Sie eine andere IAM-Rolle verwenden möchten, einen `Connections:` Abschnitt hinzu, der dem folgenden ähnelt:

   ```
   action-name:
     Environment:
       Name: environment-name
       Connections: 
         - Name: account-connection-name
           Role: iam-role-name
   ```

   Ersetzen Sie im vorherigen Code *account-connection-name* durch den Namen der [Kontoverbindung](ipa-connect-account.md), die die IAM-Rolle enthält, und *iam-role-name* durch den Namen der IAM-Rolle, die die Aktion verwenden soll. Diese Rolle überschreibt die Standard-IAM-Rolle in der Umgebung. Stellen Sie sicher, dass Sie die Rolle zu Ihrem Bereich hinzugefügt haben. Weitere Informationen finden Sie unter [Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md).

   Weitere Informationen finden Sie im [Aktionstypen](workflows-actions.md#workflows-actions-types) Thema. Dieses Thema enthält Links zur Dokumentation für jede Aktion, einschließlich der zugehörigen YAML-Referenz.

------

# Anzeige der App-URL im Workflow-Diagramm
<a name="deploy-app-url"></a>

Wenn Ihr Workflow eine Anwendung bereitstellt, können Sie Amazon so konfigurieren, CodeCatalyst dass die URL der Anwendung als anklickbarer Link angezeigt wird. Dieser Link wird in der CodeCatalyst Konsole in der Aktion angezeigt, mit der er bereitgestellt wurde. Das folgende Workflow-Diagramm zeigt die **View-App-URL**, die am Ende einer Aktion angezeigt wird.

![\[App-URL anzeigen\]](http://docs.aws.amazon.com/de_de/codecatalyst/latest/userguide/images/deploy/view-app-url.png)


Indem Sie diese URL in der CodeCatalyst Konsole anklickbar machen, können Sie Ihre Anwendungsbereitstellung schnell überprüfen.

**Anmerkung**  
Die App-URL wird mit der Aktion **Deploy to Amazon ECS** nicht unterstützt.

Um diese Funktion zu aktivieren, fügen Sie Ihrer Aktion eine Ausgabevariable mit einem Namen hinzu`appurl`, der oder enthält`endpointurl`. Sie können einen Namen mit oder ohne verbindenden Bindestrich (`-`), Unterstrich (`_`) oder Leerzeichen (` `) verwenden. Bei der Zeichenfolge wird nicht zwischen Groß- und Kleinschreibung unterschieden. Setzen Sie den Wert der Variablen auf die `https` URL `http` oder die URL Ihrer bereitgestellten Anwendung.

**Anmerkung**  
Wenn Sie eine bestehende Ausgabevariable so aktualisieren`app url`, dass sie die `endpoint url` Zeichenfolge oder die Zeichenfolge enthält, aktualisieren Sie alle Verweise auf diese Variable, sodass sie den neuen Variablennamen verwenden.

Ausführliche Schritte finden Sie in einem der folgenden Verfahren:
+ [Um die App-URL in der Aktion „AWS CDK Bereitstellen“ anzuzeigen](#deploy-app-url-cdk)
+ [Um die App-URL in der Aktion „ CloudFormation Stack bereitstellen“ anzuzeigen](#deploy-app-url-cfn)
+ [Um die App-URL in allen anderen Aktionen anzuzeigen](#deploy-app-url-other)

Wenn Sie mit der Konfiguration der URL fertig sind, stellen Sie sicher, dass sie wie erwartet aussieht, indem Sie die folgenden Anweisungen befolgen:
+ [Um zu überprüfen, ob die Anwendungs-URL hinzugefügt wurde](#deploy-app-url-verify)<a name="deploy-app-url-cdk"></a>

**Um die App-URL in der Aktion „AWS CDK Bereitstellen“ anzuzeigen**

1. Wenn Sie die Aktion „**AWS CDK Bereitstellen**“ verwenden, fügen Sie Ihrem AWS CDK Anwendungscode ein `CfnOutput` Konstrukt (bei dem es sich um ein Schlüssel-Wert-Paar handelt) hinzu:
   + Der Schlüsselname muss oder mit oder `endpointurl` ohne einen verbindenden Bindestrich (`-`), Unterstrich () oder Leerzeichen (`_`) enthalten`appurl`. ` ` Bei der Zeichenfolge wird nicht zwischen Groß- und Kleinschreibung unterschieden.
   + Der Wert muss die `https` URL `http` oder der URL Ihrer bereitgestellten Anwendung sein.

   Ihr AWS CDK Code könnte beispielsweise so aussehen:

   ```
   import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
   import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
   import * as s3 from 'aws-cdk-lib/aws-s3';
   import { Construct } from 'constructs';
   import * as cdk from 'aws-cdk-lib';
   export class HelloCdkStack extends Stack {
     constructor(scope: Construct, id: string, props?: StackProps) {
       super(scope, id, props);
       const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
         removalPolicy: RemovalPolicy.DESTROY,
       });
       new CfnOutput(this, 'APP-URL', {
         value: https://mycompany.myapp.com,
         description: 'The URL of the deployed application',
         exportName: 'myApp',
       });
       ...
     }
   }
   ```

   Weitere Informationen zu dem `CfnOutput` Konstrukt finden Sie unter [Interface CfnOutputProps](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutputProps.html) in der *AWS Cloud Development Kit (AWS CDK) API-Referenz*.

1. Speichern Sie Ihren Code und geben Sie ihn ein.

1. Fahren Sie mit [Um zu überprüfen, ob die Anwendungs-URL hinzugefügt wurde](#deploy-app-url-verify) fort.<a name="deploy-app-url-cfn"></a>

**Um die App-URL in der Aktion „ CloudFormation Stack bereitstellen“ anzuzeigen**

1. Wenn Sie die Aktion ** CloudFormation Stack bereitstellen** verwenden, fügen Sie dem `Outputs` Abschnitt in Ihrer CloudFormation Vorlage oder AWS SAM Vorlage eine Ausgabe mit den folgenden Eigenschaften hinzu:
   + Der Schlüssel (auch logische ID genannt) muss oder mit oder `endpointurl` ohne einen verbindenden Bindestrich (`-`), Unterstrich (`_`) oder Leerzeichen (` `) enthalten`appurl`. Bei der Zeichenfolge wird nicht zwischen Groß- und Kleinschreibung unterschieden.
   + Der Wert muss die `https` URL `http` oder der URL Ihrer bereitgestellten Anwendung sein.

   Ihre CloudFormation Vorlage könnte beispielsweise so aussehen:

   ```
   "Outputs" : {
     "APP-URL" : {
       "Description" : "The URL of the deployed app",
       "Value" : "https://mycompany.myapp.com",
       "Export" : {
         "Name" : "My App"
       }
     }
   }
   ```

   Weitere Informationen zu CloudFormation [Ausgaben](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html) finden Sie im *AWS CloudFormation Benutzerhandbuch* unter Ausgaben.

1. Speichern Sie Ihren Code und geben Sie ihn ein.

1. Fahren Sie mit [Um zu überprüfen, ob die Anwendungs-URL hinzugefügt wurde](#deploy-app-url-verify) fort.<a name="deploy-app-url-other"></a>

**Um die App-URL in allen anderen Aktionen anzuzeigen**

Wenn Sie eine andere Aktion verwenden, um Ihre Anwendung bereitzustellen, z. B. die Build-Aktion oder **GitHub Aktionen**, gehen Sie wie folgt vor, damit die App-URL angezeigt wird.

1. Definieren Sie eine Umgebungsvariable im `Steps` Abschnitt `Inputs` oder der Aktion in der Workflow-Definitionsdatei. Die Variable muss die folgenden Eigenschaften haben:
   + Die `name` muss oder `appurl``endpointurl`, mit oder ohne einen verbindenden Bindestrich (`-`), Unterstrich (`_`) oder Leerzeichen (` `) enthalten. Bei der Zeichenfolge wird nicht zwischen Groß- und Kleinschreibung unterschieden.
   + Der Wert muss die `https` URL `http` oder der URL Ihrer bereitgestellten Anwendung sein.

   Eine Build-Aktion könnte beispielsweise so aussehen:

   ```
   Build-action:
     Identifier: aws/build@v1
     Inputs:
       Variables:
         - Name: APP-URL
           Value: https://mycompany.myapp.com
   ```

   ... oder das:

   ```
   Actions:
     Build:
       Identifier: aws/build@v1
       Configuration:    
         Steps:
           - Run: APP-URL=https://mycompany.myapp.com
   ```

   Weitere Hinweise zur Definition von Umgebungsvariablen finden Sie unter[Definition einer Variablen](workflows-working-with-variables-define-input.md).

1. Exportieren Sie die Variable.

   Ihre Build-Aktion könnte beispielsweise so aussehen:

   ```
   Build-action:
     ...
     Outputs:
       Variables:
         - APP-URL
   ```

   Hinweise zum Exportieren von Variablen finden Sie unter[Eine Variable exportieren, damit sie von anderen Aktionen verwendet werden kann](workflows-working-with-variables-export-input.md).

1. (Optional) Wählen Sie „**Validieren**“, um den YAML-Code des Workflows vor dem Commit zu überprüfen.

1. Wählen Sie **Commit**, geben Sie eine Commit-Nachricht ein und wählen Sie erneut **Commit** aus.

1. Fahren Sie mit [Um zu überprüfen, ob die Anwendungs-URL hinzugefügt wurde](#deploy-app-url-verify) fort.<a name="deploy-app-url-verify"></a>

**Um zu überprüfen, ob die Anwendungs-URL hinzugefügt wurde**
+ Starten Sie eine Workflow-Ausführung, falls diese nicht automatisch gestartet wurde. Bei der neuen Ausführung sollte die App-URL als anklickbarer Link im Workflow-Diagramm angezeigt werden. Weitere Informationen zum Starten von Läufen finden Sie unter[Manuelles Starten einer Workflow-Ausführung](workflows-manually-start.md). 

# Ein Bereitstellungsziel entfernen
<a name="deploy-remove-target"></a>

Sie können ein Bereitstellungsziel wie einen Amazon ECS-Cluster oder CloudFormation -Stack von der Seite „**Bereitstellungsziele**“ in der CodeCatalyst Konsole entfernen.

**Wichtig**  
Wenn Sie ein Bereitstellungsziel entfernen, wird es aus der CodeCatalyst Konsole entfernt, bleibt aber in dem AWS Service verfügbar, der es hostet (sofern es noch existiert).

Erwägen Sie, ein Bereitstellungsziel zu entfernen, wenn das Ziel veraltet ist. CodeCatalyst Ziele könnten in den folgenden Fällen veraltet sein:
+ Sie haben den Workflow gelöscht, der für das Ziel bereitgestellt wurde.
+ Sie haben den Stack oder Cluster geändert, auf dem Sie die Bereitstellung durchführen. 
+ Sie haben den Stack oder Cluster aus dem CloudFormation oder dem Amazon ECS-Service in der AWS Konsole gelöscht.

**Um ein Bereitstellungsziel zu entfernen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Environments aus.**

1. Wählen Sie den Namen der Umgebung aus, die das Bereitstellungsziel enthält, das Sie entfernen möchten. Informationen zu Umgebungen finden Sie unter[Einsatz in AWS-Konten und VPCs](deploy-environments.md).

1. Wählen Sie die Registerkarte **Bereitstellungsziele**.

1. Wählen Sie das Optionsfeld neben dem Bereitstellungsziel, das Sie entfernen möchten.

1. Wählen Sie **Remove (Entfernen)** aus.

   Das Ziel wird von der Seite entfernt.

# Verfolgen des Bereitstellungsstatus nach Commit
<a name="track-changes"></a>

Zu jedem Zeitpunkt im Entwicklungszyklus ist es wichtig, den Bereitstellungsstatus bestimmter Commits zu kennen, z. B. Bugfixes, neue Funktionen oder andere wichtige Änderungen. Stellen Sie sich die folgenden Szenarien vor, in denen die Fähigkeit zur Nachverfolgung des Bereitstellungsstatus für Entwicklungsteams hilfreich ist:
+ Als Entwickler haben Sie einen Fehler behoben und möchten den Status der Implementierung in den Bereitstellungsumgebungen Ihres Teams melden.
+ Als Release-Manager möchten Sie eine Liste der bereitgestellten Commits einsehen, um deren Bereitstellungsstatus nachzuverfolgen und zu melden.

CodeCatalyst bietet eine Ansicht, anhand derer Sie auf einen Blick feststellen können, wo und in welcher Umgebung einzelne Commits oder Änderungen implementiert wurden. Diese Ansicht beinhaltet: 
+ Eine Liste von Commits.
+ Der Status der Bereitstellungen, die die Commits enthalten.
+ Die Umgebungen, in denen die Commits erfolgreich bereitgestellt wurden.
+ Der Status aller Tests, die anhand der Commits in Ihrem CI/CD Workflow ausgeführt wurden.

Das folgende Verfahren beschreibt, wie Sie zu dieser Ansicht navigieren und sie verwenden, um Änderungen in Ihrem Projekt nachzuverfolgen.

**Anmerkung**  
Das Verfolgen des Bereitstellungsstatus per Commit wird nur mit [CodeCatalyst Repositorys](source.md) unterstützt. Du kannst diese Funktion nicht mit einem [GitHub Repository, Bitbucket-Repository oder GitLab Projekt-Repository](extensions.md) verwenden.

**Um den Bereitstellungsstatus per Commit zu verfolgen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. Wählen Sie im Navigationsbereich **CI/CD** und dann **Change** Tracking aus.

1. Wählen Sie in den beiden Dropdownlisten oben im Hauptfenster das Quell-Repository und den Branch aus, die die Commits enthalten, deren Release-Status Sie anzeigen möchten.

1. Wähle „Änderungen **anzeigen**“.

   Eine Liste mit Commits wird angezeigt.

   Für jeden Commit können Sie Folgendes einsehen:
   + Commit-Informationen wie ID, Autor, Nachricht und Datum der Übertragung. Weitere Informationen finden Sie unter [Speichern Sie Code mit Quell-Repositorys in und arbeiten Sie gemeinsam daran CodeCatalystSpeichern Sie Code mit Quell-Repositorys und arbeiten Sie gemeinsam daran](source.md).
   + Der Status der Bereitstellungen in jeder Umgebung. Weitere Informationen finden Sie unter [Einsatz in AWS-Konten und VPCs](deploy-environments.md).
   + Ergebnisse der Tests und der Codeabdeckung. Weitere Informationen finden Sie unter [Testen mit WorkflowsTesten mit Workflows](test-workflow-actions.md).
**Anmerkung**  
Die Ergebnisse der Software Composition Analysis (SCA) werden nicht angezeigt.

1. (Optional) Um weitere Informationen zu den Änderungen im Zusammenhang mit einem bestimmten Commit anzuzeigen, einschließlich der neuesten Bereitstellung und detaillierter Informationen zur Codeabdeckung und zum Komponententest, wählen Sie **Details für diesen Commit anzeigen**.

# Bereitstellungsprotokolle anzeigen
<a name="deploy-deployment-logs"></a>

Sie können Protokolle zu bestimmten Bereitstellungsaktionen einsehen, um Probleme in Amazon zu beheben CodeCatalyst.

Sie können Protokolle ausgehend von einem [Workflow](workflow.md) oder einer [Umgebung](deploy-environments.md) anzeigen.

**Um die Protokolle einer Bereitstellungsaktion ausgehend von einem Workflow anzuzeigen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie **Läufe** aus.

1. Wählen Sie die Workflow-Ausführung aus, mit der Ihre Anwendung bereitgestellt wurde.

1. Wählen Sie im Workflow-Diagramm die Aktion aus, deren Protokolle Sie anzeigen möchten.

1. Wählen Sie die Registerkarte **Protokolle** und erweitern Sie die Abschnitte, um die Protokollmeldungen anzuzeigen.

1. Um weitere Protokolle anzuzeigen, wählen Sie die Registerkarte **Zusammenfassung** und dann **Ansicht in CloudFormation** (falls verfügbar), um dort weitere Protokolle anzuzeigen. Möglicherweise müssen Sie sich anmelden bei AWS.

**Um die Protokolle einer Bereitstellungsaktion ausgehend von einer Umgebung anzuzeigen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Environments aus.**

1. Wählen Sie die Umgebung aus, in der Ihre Anwendung bereitgestellt wurde.

1. Suchen Sie unter **Bereitstellungsaktivität** nach der Spalte **Workflow-Ausführungs-ID** und wählen Sie den Workflow-Lauf aus, der Ihren Stack bereitgestellt hat.

1. Wählen Sie im Workflow-Diagramm die Aktion aus, deren Protokolle Sie anzeigen möchten.

1. Wählen Sie die Registerkarte **Protokolle** und erweitern Sie die Abschnitte, um die Protokollmeldungen anzuzeigen.

1. Um weitere Protokolle anzuzeigen, wählen Sie die Registerkarte **Zusammenfassung** und dann **Ansicht in CloudFormation** (falls verfügbar), um dort weitere Protokolle anzuzeigen. Möglicherweise müssen Sie sich anmelden bei AWS.

# Bereitstellungsinformationen anzeigen
<a name="deploy-view-deployment-info"></a>

Sie können die folgenden Informationen zu einer Bereitstellung in Amazon einsehen CodeCatalyst:
+ Bereitstellungsaktivität, einschließlich Bereitstellungsstatus, Startzeit, Endzeit, Verlauf und Dauer der Ereignisse.
+ Stack-Name AWS-Region, Uhrzeit der letzten Aktualisierung und zugehörige Workflows.
+ Commits und Pull-Requests.
+ Aktionsspezifische Informationen, z. B. CloudFormation Ereignisse und Ausgaben.

[Sie können Bereitstellungsinformationen ausgehend von einem [Workflow](workflow.md), einer [Umgebung](deploy-environments.md) oder einer Workflow-Aktion anzeigen.](workflows-concepts.md#workflows-concepts-actions)

**So zeigen Sie Bereitstellungsinformationen ab einem Workflow an**
+ Gehen Sie zu der Workflow-Ausführung, mit der Ihre Anwendung bereitgestellt wurde. Detaillierte Anweisungen finden Sie unter [Status und Details der Workflow-Ausführung anzeigen](workflows-view-run.md). 

**Um Bereitstellungsinformationen ausgehend von einer Umgebung anzuzeigen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Environments aus.**

1. Wählen Sie die Umgebung aus, in der Ihr Stack bereitgestellt wurde, z. B. `Production`

1. Wählen Sie **Deployment Activity** aus, um den Bereitstellungsverlauf Ihrer Stacks, den Status der Bereitstellungen (z. B. **ERFOLGREICH** ODER **FEHLGESCHLAGEN**) und andere bereitstellungsbezogene Informationen einzusehen.

1. Wählen Sie **Bereitstellungsziel** aus, um Informationen zu den Stacks, Clustern oder anderen Zielen anzuzeigen, die in der Umgebung bereitgestellt wurden. Sie können Informationen wie den Stacknamen, die Region, den Anbieter und die Kennung anzeigen.

**Um Bereitstellungsinformationen ab einer Aktion anzuzeigen**

1. Öffnen Sie die CodeCatalyst Konsole unter [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Wählen Sie Ihr Projekt.

1. **Wählen Sie im Navigationsbereich **CI/CD** und dann Workflows aus.**

1. Wählen Sie den Namen Ihres Workflows. Sie können nach dem Quell-Repository oder dem Branch-Namen filtern, in dem der Workflow definiert ist, oder nach Workflow-Namen oder -Status filtern.

1. Wählen Sie im Workflow-Diagramm die Workflow-Aktion aus, mit der Ihre Anwendung bereitgestellt wurde. Sie könnten beispielsweise wählen **DeployCloudFormationStack**.

1. Im Inhalt des rechten Fensterbereichs finden Sie aktionsspezifische Informationen zur Bereitstellung.