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 EKS mit einem Workflow
<a name="deploy-action-eks"></a>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  ```
  codecatalyst-eks-project
  ```

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

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

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

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

  ```
  codecatalyst-eks-environment
  ```

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

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

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

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

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

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

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

**Um eine Entwicklungsumgebung zu starten**

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

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

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

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

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

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

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

**Um kubectl zu installieren und zu konfigurieren**

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

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

1. Geben Sie ein:

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

1. Geben Sie ein:

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

1. Geben Sie ein:

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

1. Geben Sie ein:

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

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

   Sie haben es jetzt installiert`kubectl`.

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

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

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

1. Geben Sie ein:

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

1. Geben Sie ein:

   ```
   eksctl version
   ```

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

   Sie haben es jetzt installiert`eksctl`.

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

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

   ```
   aws --version
   ```

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

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

**Um das zu konfigurieren AWS CLI**

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

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

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

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

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

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

      ```
      codecatalyst-eks-user
      ```

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

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

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

      ```
      codecatalyst-eks-user
      ```

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

      ```
      codecatalyst-eks-user
      ```

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

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

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

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

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

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

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

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

1. Erstellen Sie wie folgt einen Berechtigungssatz:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   1. Melden Sie sich ab AWS.

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

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

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

        *one-time-password*

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

**Bevor Sie beginnen**

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

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

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

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

1. Erstellen Sie einen Cluster und Knoten:

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

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

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

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

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

   ```
   kubectl cluster-info
   ```

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

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

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

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

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

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

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

1. Erstellen Sie ein leeres Repository in Amazon ECR:

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

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

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

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

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

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

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

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

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

Die Ordnerstruktur sieht wie folgt aus:

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

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

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

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

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

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

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

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

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

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

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

1. Hinzufügen, Festschreiben und Push:

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

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

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

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

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

**Um das Dockerfile hinzuzufügen**

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

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

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

1. Hinzufügen, Festschreiben und Push:

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

   Das Dockerfile wird zu Ihrem Repository hinzugefügt.

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

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

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

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

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

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

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

1. Hinzufügen, Festschreiben und Push:

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

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

Sie haben jetzt alle Ihre Quelldateien hinzugefügt.

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

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

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

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

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

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

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

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

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

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

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

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

****  

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

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

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

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

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

****  

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

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

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

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

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

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

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

   ```
   cd /projects
   ```

1. Geben Sie ein:

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

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

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

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

1. Geben Sie ein:

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

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

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

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

1. Geben Sie ein: 

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

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

1. Geben Sie ein:

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

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

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

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

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

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

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

**7. Um die Bereitstellungsrolle zu erstellen**

1. Geben Sie ein:

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

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

1. Geben Sie ein:

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

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

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

1. Geben Sie ein:

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

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

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

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

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

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

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

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

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

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

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

1. Wählen Sie den Anzeigenamen.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  Eine Meldung ähnlich der folgenden wird angezeigt:

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

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

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

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

   Die ConfigMap Datei wird auf dem Bildschirm angezeigt.

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

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

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

   Einzelheiten finden Sie unter [Aktivieren des IAM-Prinzipalzugriffs auf Ihren Cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) im **Amazon EKS-Benutzerhandbuch**.

Sie haben jetzt der Bereitstellungsrolle und damit der Aktion **Deploy to Amazon EKS** `system:masters` Berechtigungen für Ihren Kubernetes-Cluster erteilt.

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

In diesem Schritt erstellen Sie einen Workflow, der Ihre Quelldateien zu einem Docker-Image zusammenbaut und das Image dann in Tree-Pods in Ihrem Amazon EKS-Cluster bereitstellt.

Der Workflow besteht aus den folgenden Bausteinen, die nacheinander ausgeführt werden:
+ Ein Trigger — Dieser Trigger startet die Workflow-Ausführung automatisch, wenn Sie eine Änderung an Ihr Quell-Repository übertragen. Weitere Informationen zu Auslösern finden Sie unter [Automatisches Starten einer Workflow-Ausführung mithilfe von Triggern](workflows-add-trigger.md).
+ Eine Build-Aktion (`BuildBackend`) — Beim Auslösen erstellt die Aktion das Docker-Image mithilfe der Dockerfile und überträgt das Image an Amazon ECR. Die Build-Aktion aktualisiert auch die `$IMAGE_TAG` Variablen `$REPOSITORY_URI` und in der `deployment.yaml` Datei mit den richtigen Werten und erstellt dann ein Ausgabeartefakt aus dieser Datei und allen anderen Dateien im Ordner. `Kubernetes` In diesem Tutorial ist die einzige Datei im `Kubernetes` Ordner, `deployment.yaml` aber Sie könnten weitere Dateien hinzufügen. Das Artefakt wird als Eingabe für die Bereitstellungsaktion verwendet, die als Nächstes folgt.

  Weitere Informationen zur Build-Aktion finden Sie unter[Bauen mit Workflows](build-workflow-actions.md).
+ Eine Bereitstellungsaktion (`DeployToEKS`) — Nach Abschluss der Build-Aktion sucht die Bereitstellungsaktion nach dem von der Build-Aktion (`Manifests`) generierten Ausgabeartefakt und findet die darin enthaltene `deployment.yaml` Datei. Die Aktion folgt dann den Anweisungen in der `deployment.yaml` Datei, um drei Pods auszuführen, von denen jeder ein einzelnes „Hello, World\$1“ enthält Docker-Container — in Ihrem Amazon EKS-Cluster. 

**So erstellen Sie ein Workflow**

1. Gehen Sie zur Konsole. CodeCatalyst 

1. Navigiere zu deinem Projekt (`codecatalyst-eks-project`).

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

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

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

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

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

1. Löschen Sie den YAML-Beispielcode.

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

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

   Ersetzen Sie im vorherigen Code:
   + Beide Instanzen von *codecatalyst-eks-environment* mit dem Namen der Umgebung, in der Sie erstellt haben[Voraussetzungen](#deploy-tut-eks-prereqs).
   + Beide Instanzen von *codecatalyst-account-connection* mit dem Anzeigenamen Ihrer Kontoverbindung. Der Anzeigename kann eine Zahl sein. Weitere Informationen finden Sie unter [Schritt 6: AWS Rollen hinzufügen zu CodeCatalyst](#deploy-tut-eks-import-roles).
   + *codecatalyst-eks-build-role*mit dem Namen der Build-Rolle, in der Sie sie erstellt haben[Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo*(in der `Value:` Eigenschaft) mit der URI des Amazon ECR-Repositorys, in [Schritt 3: Erstellen Sie ein Amazon ECR-Image-Repository](#deploy-tut-eks-ecr) dem Sie es erstellt haben.
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(im `Run: aws ecr` Befehl) mit der URI des Amazon ECR-Repositorys ohne das Bildsuffix ()`/codecatalyst-eks-image-repo`.
   + *codecatalyst-eks-deploy-role*mit dem Namen der Bereitstellungsrolle, in der Sie sie erstellt haben. [Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles)
   + Beide Instanzen von *us-west-2* mit Ihrem AWS Regionalcode. Eine Liste der Regionalcodes finden Sie unter [Regionale Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html) in der *Allgemeine AWS-Referenz*.
**Anmerkung**  
Wenn Sie sich entschieden haben, keine Build- und Deploy-Rollen zu erstellen, ersetzen Sie *codecatalyst-eks-build-role* und *codecatalyst-eks-deploy-role* durch den Namen der `CodeCatalystWorkflowDevelopmentRole-spaceName` Rolle. Weitere Informationen über diese Rolle finden Sie unter [Schritt 5: AWS Rollen erstellen](#deploy-tut-eks-roles).

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

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

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

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

      ```
      Add first workflow
      ```

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

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

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

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

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

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

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

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

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

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

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

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

1. Wählen Sie links unten **Load Balancers** aus.

1. Wählen Sie den Load Balancer aus, der als Teil Ihrer Kubernetes-Bereitstellung erstellt wurde. **Wenn Sie sich nicht sicher sind, welchen Load Balancer Sie wählen sollen, suchen Sie auf der Registerkarte „Tags“ nach den folgenden Tags:**
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. Wählen Sie den richtigen Load Balancer aus und wählen Sie den Tab **Beschreibung** aus.

1. Kopieren Sie den **DNS-Namenswert** und fügen Sie ihn in die Adressleiste Ihres Browsers ein.

   Das „Hallo, Welt\$1“ In Ihrem Browser wird eine Webseite angezeigt, die darauf hinweist, dass Sie Ihre Anwendung erfolgreich bereitgestellt haben.

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

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

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

1. Gehen Sie zu Ihrer Entwicklungsumgebung.

1. Wechseln Sie an der Terminal-Eingabeaufforderung zu Ihrem Quell-Repository:

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

1.  Rufen Sie die neuesten Workflow-Änderungen ab:

   ```
   git pull
   ```

1. Öffnen Sie `codecatalyst-eks-source-repository/public-html/index.html`.

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

1. Hinzufügen, Festschreiben und Push:

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   Eine Workflow-Ausführung wird automatisch gestartet.

1. (Optional) Geben Sie Folgendes ein:

   ```
   git show HEAD
   ```

   Notieren Sie sich die Commit-ID für die `index.html` Änderung. Diese Commit-ID wird dem Docker-Image zugeordnet, das durch die Workflow-Ausführung bereitgestellt wird, die Sie gerade gestartet haben.

1. Beobachten Sie den Fortschritt der Bereitstellung:

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

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

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

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

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

   1. Wählen Sie links unten **Load Balancers** aus.

   1. Wählen Sie den Load Balancer aus, der als Teil Ihrer Kubernetes-Bereitstellung erstellt wurde.

   1. Kopieren Sie den **DNS-Namenswert** und fügen Sie ihn in die Adressleiste Ihres Browsers ein.

      Das 'Tutorial ist abgeschlossen\$1 ' In Ihrem Browser wird eine Webseite angezeigt, die darauf hinweist, dass Sie erfolgreich eine neue Version Ihrer Anwendung bereitgestellt haben.

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

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

Sie sollten Ihre Umgebung bereinigen, damit Ihnen die in diesem Tutorial verwendeten Speicher- und Rechenressourcen nicht unnötig in Rechnung gestellt werden.

**So räumen Sie auf**

1. Löschen Sie Ihren Cluster:

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

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     Wobei Folgendes gilt:
     + *us-west-2*wird durch Ihre Region ersetzt.
     + *codecatalyst-eks-cluster*wird durch den Namen des Clusters ersetzt, den Sie erstellt haben.

     Nach 5-10 Minuten werden der Cluster und die zugehörigen Ressourcen gelöscht, einschließlich, aber nicht beschränkt auf CloudFormation Stacks, Knotengruppen (in Amazon EC2) und Load Balancer.
**Wichtig**  
Wenn der `eksctl delete cluster` Befehl nicht funktioniert, müssen Sie möglicherweise Ihre AWS Anmeldeinformationen oder Ihre Anmeldeinformationen aktualisieren. `kubectl` Wenn Sie sich nicht sicher sind, welche Anmeldeinformationen Sie aktualisieren sollen, aktualisieren Sie zuerst die AWS Anmeldeinformationen. Informationen zum Aktualisieren Ihrer AWS Anmeldeinformationen finden Sie unter[Wie behebe ich die Fehler „Anmeldeinformationen konnten nicht gefunden werden“ und ExpiredToken „“?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks). Informationen zum Aktualisieren Ihrer `kubectl` Anmeldeinformationen finden Sie unter[Wie behebe ich die Fehler „Es konnte keine Verbindung zum Server hergestellt werden“?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks).

1. Bereinigen Sie in der AWS Konsole wie folgt:

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

   1. Löschen Sie im IAM Identity Center:

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. Löschen Sie in IAM:
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. Bereinigen Sie in der CodeCatalyst Konsole wie folgt:

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

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

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

   1. Löschen Sie Ihre Entwicklungsumgebung.

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

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

# Aktion „Im Kubernetes-Cluster bereitstellen“ hinzufügen
<a name="deploy-action-eks-adding"></a>

Verwenden Sie die folgenden Anweisungen, um die Aktion „In **Kubernetes-Cluster bereitstellen“ zu Ihrem Workflow** hinzuzufügen. 

**Bevor Sie beginnen**

Bevor Sie Ihrem Workflow die **Cluster-Aktion „In Kubernetes bereitstellen**“ hinzufügen, müssen Sie Folgendes vorbereitet haben:

**Tipp**  
Folgen Sie den Anweisungen unter, um diese Voraussetzungen schnell einzurichten. [Tutorial: Bereitstellen einer Anwendung in Amazon EKS](deploy-tut-eks.md)
+ Ein Kubernetes-Cluster in Amazon EKS. Informationen zu Clustern finden Sie unter [Amazon EKS-Cluster](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) im **Amazon EKS-Benutzerhandbuch**.
+ Mindestens ein Dockerfile, das beschreibt, wie Sie Ihre Anwendung zu einem Docker-Image zusammenstellen. [Weitere Informationen zu Dockerfiles finden Sie in der Dockerfile-Referenz.](https://docs.docker.com/engine/reference/builder/)
+ *Mindestens eine Kubernetes-Manifestdatei, die in der Kubernetes-Dokumentation als *Konfigurationsdatei oder Konfiguration* bezeichnet wird.* Weitere Informationen finden Sie in der [Kubernetes-Dokumentation unter Ressourcen verwalten](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/).
+ Eine IAM-Rolle, die der **Cluster-Aktion Deploy to Kubernetes die Möglichkeit gibt, auf Ihren Amazon EKS-Cluster** zuzugreifen und mit ihm zu interagieren. Weitere Informationen erhalten Sie unter dem Thema [Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role) im [Aktion „Im Kubernetes-Cluster bereitstellen“ YAML](deploy-action-ref-eks.md).

  Nachdem Sie diese Rolle erstellt haben, müssen Sie sie hinzufügen zu:
  + Ihre Kubernetes-Datei ConfigMap . Informationen zum Hinzufügen einer Rolle zu einer ConfigMap Datei finden Sie unter [Aktivieren des IAM-Prinzipalzugriffs auf Ihren Cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) im **Amazon EKS-Benutzerhandbuch**.
  + CodeCatalyst. Informationen zum Hinzufügen einer IAM-Rolle zu finden Sie CodeCatalyst unter[Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md).
+ Ein CodeCatalyst Raum, ein Projekt und eine Umgebung. Der Bereich und die Umgebung müssen beide mit dem AWS Konto verbunden sein, in dem Sie Ihre Anwendung bereitstellen werden. Weitere Informationen finden Sie unter [Erstellen einer Umgebung](spaces-create.md), [Ein leeres Projekt in Amazon erstellen CodeCatalyst](projects-create.md#projects-create-empty) und [Einsatz in AWS-Konten und VPCs](deploy-environments.md).
+ Ein Quell-Repository, das von unterstützt wird CodeCatalyst. Das Repository speichert Ihre Anwendungsquelldateien, Dockerfiles und Kubernetes-Manifeste. Weitere Informationen finden Sie unter [Speichern Sie Code mit Quell-Repositorys in und arbeiten Sie gemeinsam daran CodeCatalystSpeichern Sie Code mit Quell-Repositorys und arbeiten Sie gemeinsam daran](source.md).

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

**Um die Aktion „Im Kubernetes-Cluster bereitstellen“ mit dem visuellen Editor hinzuzufügen**

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

1. Wählen Sie Ihr Projekt.

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

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

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

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

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

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

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

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

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

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

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

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

**Um die Aktion „Im Kubernetes-Cluster bereitstellen“ mit dem YAML-Editor hinzuzufügen**

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

1. Wählen Sie Ihr Projekt.

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

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

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

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

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

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

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

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

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

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

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

------

# Variablen „Im Kubernetes-Cluster bereitstellen“
<a name="deploy-action-eks-variables"></a>

Die **Cluster-Aktion „Auf Kubernetes bereitstellen**“ erzeugt und legt zur Laufzeit die folgenden Variablen fest. Diese werden als *vordefinierte* Variablen bezeichnet.

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


| Key (Schlüssel) | Value (Wert) | 
| --- | --- | 
|  Cluster  |  Der Amazon.com-Ressourcenname (ARN) des Amazon EKS-Clusters, auf dem während der Workflow-Ausführung bereitgestellt wurde. Beispiel: `arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster`  | 
|  Bereitstellungsplattform  |  Der Name der Bereitstellungsplattform. Fest codiert auf. `AWS:EKS`  | 
|  Metadaten  |  Reserved Instances. Metadaten im JSON-Format, die sich auf den Cluster beziehen, der während der Workflow-Ausführung bereitgestellt wurde.  | 
|  Namespace  |  Der Kubernetes-Namespace, in dem der Cluster bereitgestellt wurde. Beispiel: `default`  | 
|  Ressourcen  |  Reserved Instances. Metadaten im JSON-Format, die sich auf die Ressourcen beziehen, die während der Workflow-Ausführung bereitgestellt wurden.  | 
|  server  |  Der Name des API-Serverendpunkts, den Sie für die Kommunikation mit Ihrem Cluster mithilfe von Verwaltungstools wie verwenden können. `kubectl` Weitere Informationen zum API-Serviceendpunkt finden Sie unter [Zugriffskontrolle für Amazon EKS-Cluster-Endpunkte](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) im **Amazon EKS-Benutzerhandbuch**. Beispiel: `https://random-string.gr7.us-west-2.eks.amazonaws.com`  | 

# Aktion „Im Kubernetes-Cluster bereitstellen“ YAML
<a name="deploy-action-ref-eks"></a>

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

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

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

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

# The action definition starts here.   
  DeployToKubernetesCluster\$1nn: 
    Identifier: aws/kubernetes-deploy@v1
    DependsOn:
      - build-action
    Compute:  
        - Type: EC2 | Lambda
        - Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: DeployToEKS
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - manifest-artifact
    Configuration:
      Namespace: namespace
      Region: us-east-1 
      Cluster: eks-cluster
      Manifests: manifest-path
```

## DeployToKubernetesCluster
<a name="deploy.action.eks.name"></a>

(Erforderlich)

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

Standard: `DeployToKubernetesCluster_nn`.

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

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

(*DeployToKubernetesCluster*/**Identifier**)

(Erforderlich)

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

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

**Entsprechende Benutzeroberfläche: Workflow-Diagram/ DeployToKubernetesCluster \$1nn/ aws/kubernetes-deploy @v1 label**

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

(*DeployToKubernetesCluster*/**DependsOn**)

(Optional)

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

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

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

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

(*DeployToKubernetesCluster*/**Compute**)

(Optional)

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

Entsprechende Benutzeroberfläche: *keine*

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

(*DeployToKubernetesCluster*/Compute/**Type**)

([Compute](#deploy.action.eks.computename)Erforderlich, falls enthalten)

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

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

  Optimierte Startgeschwindigkeiten für Aktionen.

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

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

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

(*DeployToKubernetesCluster*/Compute/**Fleet**)

(Optional)

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

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

Wenn nicht angegeben, `Fleet` ist die Standardeinstellung. `Linux.x86-64.Large`

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

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

(*DeployToKubernetesCluster*/**Timeout**)

(Optional)

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

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

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

(*DeployToKubernetesCluster*/**Environment**)

(Erforderlich)

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

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

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

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

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

(*DeployToKubernetesCluster*/Environment/**Name**)

(Erforderlich, falls [Environment](#deploy.action.eks.environment) enthalten)

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

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

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

(*DeployToKubernetesCluster*/Environment/**Connections**)

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

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

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

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

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

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

(*DeployToKubernetesCluster*/Environment/Connections/**Name**)

(Optional)

Geben Sie den Namen der Kontoverbindung an.

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

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

(*DeployToKubernetesCluster*/Environment/Connections/**Role**)

(Erforderlich, falls enthalten[Connections](#deploy.action.eks.environment.connections))

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

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

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

****  

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

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

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

Stellen Sie sicher, dass diese Rolle hinzugefügt wurde zu:
+ Ihre Kontoverbindung. Weitere Informationen zum Hinzufügen einer IAM-Rolle zu einer Kontoverbindung finden Sie unter[Hinzufügen von IAM-Rollen zu Kontoverbindungen](ipa-connect-account-addroles.md).
+ Ihr Kubernetes ConfigMap. Weitere Informationen zum Hinzufügen einer IAM-Rolle zu einer ConfigMap finden Sie in der Dokumentation unter [Verwalten von IAM-Benutzern und -Rollen](https://eksctl.io/usage/iam-identity-mappings/). `eksctl`

**Tipp**  
Anweisungen [Tutorial: Bereitstellen einer Anwendung in Amazon EKS](deploy-tut-eks.md) zum Hinzufügen einer IAM-Rolle zu einer Kontoverbindung finden Sie auch unter. ConfigMap

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

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

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

(*DeployToKubernetesCluster*/**Inputs**)

(Erforderlich, falls enthalten[Connections](#deploy.action.eks.environment.connections))

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

**Anmerkung**  
Pro Aktion „In **Amazon EKS bereitstellen**“ ist nur eine Eingabe (entweder eine Quelle oder ein Artefakt) zulässig.

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

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

(*DeployToKubernetesCluster*/Inputs/**Sources**)

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

Wenn Ihre Kubernetes-Manifestdatei (en) in einem Quell-Repository gespeichert sind, geben Sie die Bezeichnung dieses Quell-Repositorys an. Derzeit ist das einzige unterstützte Label. `WorkflowSource`

Wenn Ihre Manifestdateien nicht in einem Quell-Repository enthalten sind, müssen sie sich in einem Artefakt befinden, das durch eine andere Aktion generiert wurde.

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

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

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

(*DeployToKubernetesCluster*/Inputs/**Artifacts**)

(Erforderlich, wenn Ihre Manifestdatei in einem [Ausgabeartefakt](workflows-working-artifacts-output.md) einer früheren Aktion gespeichert ist)

Wenn die Kubernetes-Manifestdatei (en) in einem Artefakt enthalten sind, das durch eine vorherige Aktion generiert wurde, geben Sie dieses Artefakt hier an. Wenn Ihre Manifestdateien nicht in einem Artefakt enthalten sind, müssen sie sich in Ihrem Quell-Repository befinden.

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

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

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

(*DeployToKubernetesCluster*/**Configuration**)

(Erforderlich)

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

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

## Namespace
<a name="deploy.action.eks.namespace"></a>

(*DeployToKubernetesCluster*/Configuration/**Namespace**)

(Optional)

Geben Sie den Kubernetes-Namespace an, in dem Ihre Kubernetes-Anwendung bereitgestellt wird. Verwenden Sie diese Option`default`, wenn Sie in Ihrem Cluster keine Namespaces verwenden. Weitere Informationen zu Namespaces finden Sie in der Kubernetes-Dokumentation unter [Unterteilung Ihres Clusters mithilfe](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces) von Kubernetes-Namespaces.

Wenn Sie den Namespace weglassen, wird der Wert von verwendet. `default`

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

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

(*DeployToKubernetesCluster*/Configuration/**Region**)

(Erforderlich)

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

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

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

(*DeployToKubernetesCluster*/Configuration/**Cluster**)

(Erforderlich)

Geben Sie den Namen eines vorhandenen Amazon EKS-Clusters an. Mit der Aktion „**Auf Kubernetes-Cluster** bereitstellen“ wird Ihre containerisierte Anwendung in diesem Cluster bereitgestellt. Weitere Informationen zu Amazon EKS-Clustern finden Sie unter [Clusters](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) im **Amazon EKS-Benutzerhandbuch**.

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

## Manifests
<a name="deploy.action.eks.manifest"></a>

(*DeployToKubernetesCluster*/Configuration/**Manifests**)

(Erforderlich)

*Geben Sie den Pfad zu Ihren Kubernetes-Manifestdateien im YAML-Format an, die in der Kubernetes-Dokumentation als *Konfigurationsdateien, *Konfigurationsdateien* oder einfach als Konfigurationen* bezeichnet werden.*

Wenn Sie mehrere Manifestdateien verwenden, platzieren Sie sie in einem einzigen Ordner und verweisen Sie auf diesen Ordner. Manifestdateien werden von Kubernetes alphanumerisch verarbeitet. Stellen Sie daher sicher, dass Sie Dateinamen mit steigenden Zahlen oder Buchstaben voranstellen, um die Verarbeitungsreihenfolge zu kontrollieren. Beispiel:

`00-namespace.yaml`

`01-deployment.yaml`

Wenn sich Ihre Manifestdateien in Ihrem Quell-Repository befinden, ist der Pfad relativ zum Stammordner des Quell-Repositorys. Wenn sich die Dateien in einem Artefakt aus einer früheren Workflow-Aktion befinden, ist der Pfad relativ zum Artefakt-Stammordner. 

Beispiele:

`Manifests/`

`deployment.yaml`

`my-deployment.yml`

Verwenden Sie keine Platzhalter (). `*`

**Anmerkung**  
[Helm-Diagramme](https://helm.sh/docs/topics/charts/) und [Anpassungsdateien](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/) werden nicht unterstützt.

Weitere Informationen zu Manifestdateien finden Sie in der [Kubernetes-Dokumentation unter Organisieren von Ressourcenkonfigurationen](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations).

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