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.

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