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 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 **