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: Connect über eine containerisierte Anwendung her, die auf Amazon Elastic Kubernetes Service gehostet wird
<a name="EKS-tutorial"></a>

Dieses Tutorial führt Sie durch die Schritte, die erforderlich sind, um einen Amazon Elastic Kubernetes Service (Amazon EKS) -Cluster einzurichten, der eine containerisierte Anwendung hostet, die über SigV4-Authentifizierung eine Verbindung zu Amazon Keyspaces herstellt.

Amazon EKS ist ein verwalteter Service, der die Installation, den Betrieb und die Wartung Ihrer eigenen Kubernetes-Steuerebene überflüssig macht. [Kubernetes](https://kubernetes.io/docs/concepts/overview/) ist ein Open-Source-System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von Anwendungen in Containern.

Das Tutorial bietet step-by-step Anleitungen zur Konfiguration, Erstellung und Bereitstellung einer containerisierten Java-Anwendung für Amazon EKS. Im letzten Schritt führen Sie die Anwendung aus, um Daten in eine Amazon Keyspaces-Tabelle zu schreiben.

**Topics**
+ [Voraussetzungen für die Verbindung von Amazon EKS zu Amazon Keyspaces](EKS-tutorial-prerequisites.md)
+ [Schritt 1: Den Amazon EKS-Cluster konfigurieren und IAM-Berechtigungen einrichten](EKS-tutorial-step1.md)
+ [Schritt 2: Konfigurieren Sie die Anwendung](EKS-tutorial-step2.md)
+ [Schritt 3: Erstellen Sie das Anwendungs-Image und laden Sie die Docker-Datei in Ihr Amazon ECR-Repository hoch](EKS-tutorial-step3.md)
+ [Schritt 4: Stellen Sie die Anwendung in Amazon EKS bereit und schreiben Sie Daten in Ihre Tabelle](EKS-tutorial-step4.md)
+ [Schritt 5: (Optional) Aufräumen](EKS-tutorial-step5.md)

# Voraussetzungen für die Verbindung von Amazon EKS zu Amazon Keyspaces
<a name="EKS-tutorial-prerequisites"></a>

**Erstellen Sie die folgenden AWS Ressourcen, bevor Sie mit dem Tutorial beginnen können**

1. Bevor Sie mit diesem Tutorial beginnen, folgen Sie den Anweisungen zur AWS Einrichtung unter[Zugreifen auf Amazon Keyspaces (für Apache Cassandra)](accessing.md). Zu diesen Schritten gehören die Registrierung AWS und Erstellung eines AWS Identity and Access Management (IAM-) Principals mit Zugriff auf Amazon Keyspaces. 

1. Erstellen Sie einen Amazon Keyspaces-Schlüsselraum mit dem Namen `aws` und eine Tabelle mit dem Namen`user`, in die Sie später in diesem Tutorial aus der containerisierten Anwendung, die in Amazon EKS ausgeführt wird, schreiben können. Sie können dies entweder mit oder mithilfe von tun. AWS CLI `cqlsh`

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

   ```
   aws keyspaces create-keyspace --keyspace-name 'aws'
   ```

   Um zu bestätigen, dass der Keyspace erstellt wurde, können Sie den folgenden Befehl verwenden.

   ```
   aws keyspaces list-keyspaces
   ```

   Um die Tabelle zu erstellen, können Sie den folgenden Befehl verwenden.

   ```
   aws keyspaces create-table --keyspace-name 'aws' --table-name 'user' --schema-definition 'allColumns=[
               {name=username,type=text}, {name=fname,type=text},{name=last_update_date,type=timestamp},{name=lname,type=text}],
               partitionKeys=[{name=username}]'
   ```

   Um zu bestätigen, dass Ihre Tabelle erstellt wurde, können Sie den folgenden Befehl verwenden.

   ```
   aws keyspaces list-tables --keyspace-name 'aws'
   ```

   Weitere Informationen finden Sie unter [Create Keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-keyspace.html) und [Create Table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-table.html) in der *AWS CLI Befehlsreferenz.*

------
#### [ cqlsh ]

   ```
   CREATE KEYSPACE aws WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}  AND durable_writes = true;
   CREATE TABLE aws.user (
       username text PRIMARY KEY,
       fname text,
       last_update_date timestamp,
       lname text
   );
   ```

   Um zu überprüfen, ob Ihre Tabelle erstellt wurde, können Sie die folgende Anweisung verwenden.

   ```
   SELECT * FROM system_schema.tables WHERE keyspace_name = "aws";
   ```

   Ihre Tabelle sollte in der Ausgabe dieser Anweisung aufgeführt sein. Beachten Sie, dass es zu Verzögerungen kommen kann, bis die Tabelle erstellt wird. Weitere Informationen finden Sie unter [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create).

------

1. Erstellen Sie einen Amazon EKS-Cluster mit einem **Fargate-Linux-Knotentyp**. Fargate ist eine serverlose Compute-Engine, mit der Sie Kubernetes-Pods bereitstellen können, ohne Amazon Amazon EC2 EC2-Instances verwalten zu müssen. Um diesem Tutorial zu folgen, ohne den Clusternamen in allen Beispielbefehlen aktualisieren zu müssen, erstellen Sie einen Cluster mit dem Namen gemäß den `my-eks-cluster` Anweisungen unter [Erste Schritte mit Amazon EKS — `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) im *Amazon EKS-Benutzerhandbuch*. Stellen Sie bei der Erstellung Ihres Clusters sicher, dass Ihre Knoten und die beiden Standard-Pods laufen und fehlerfrei sind. Sie können dies mit dem folgenden Befehl tun.

   ```
   kubectl get pods -A -o wide
   ```

   Sie sollten etwas Ähnliches wie diese Ausgabe sehen.

   ```
   NAMESPACE     NAME                       READY   STATUS    RESTARTS   AGE   IP          NODE                                                NOMINATED NODE   READINESS GATES
   kube-system   coredns-1234567890-abcde   1/1     Running   0          18m   192.0.2.0   fargate-ip-192-0-2-0.region-code.compute.internal   <none>           <none>
   kube-system   coredns-1234567890-12345   1/1     Running   0          18m   192.0.2.1   fargate-ip-192-0-2-1.region-code.compute.internal   <none>           <none>
   ```

1. Docker-Installation. Anweisungen zur Installation von Docker auf einer Amazon EC2 EC2-Instance finden [Sie unter Docker installieren](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#getting-started-cli-prereqs) im Amazon Elastic Container Registry-Benutzerhandbuch. 

   Docker ist auf vielen verschiedenen Betriebssystemen verfügbar, darunter die meisten modernen Linux-Verteilungen wie Ubuntu und sogar macOS und Windows. Weitere Informationen zur Installation von Docker unter einem bestimmten Betriebssystem finden Sie im [Docker-Installationshandbuch](https://docs.docker.com/engine/install/#installation). 

1. Erstellen Sie ein Amazon-ECR-Repository. Amazon ECR ist ein AWS verwalteter Container-Image-Registry-Service, den Sie mit Ihrer bevorzugten CLI verwenden können, um Docker-Images zu übertragen, abzurufen und zu verwalten. Weitere Informationen zu Amazon ECR-Repositorys finden Sie im [Amazon Elastic Container Registry User Guide](https://docs.aws.amazon.com/AmazonECR/latest/userguide/). Sie können den folgenden Befehl verwenden, um ein Repository mit dem Namen zu erstellen. `my-ecr-repository`

   ```
   aws ecr create-repository --repository-name my-ecr-repository
   ```

Nachdem Sie die erforderlichen Schritte abgeschlossen haben, fahren Sie mit fort[Schritt 1: Den Amazon EKS-Cluster konfigurieren und IAM-Berechtigungen einrichten](EKS-tutorial-step1.md).

# Schritt 1: Den Amazon EKS-Cluster konfigurieren und IAM-Berechtigungen einrichten
<a name="EKS-tutorial-step1"></a>

**Konfigurieren Sie den Amazon EKS-Cluster und erstellen Sie die IAM-Ressourcen, die erforderlich sind, damit ein Amazon EKS-Servicekonto eine Verbindung zu Ihrer Amazon Keyspaces-Tabelle herstellen kann.**

1. Erstellen Sie einen Open ID Connect (OIDC) -Anbieter für den Amazon EKS-Cluster. Dies ist erforderlich, um IAM-Rollen für Dienstkonten zu verwenden. *Weitere Informationen zu OIDC-Anbietern und deren Erstellung finden Sie unter [Erstellen eines IAM-OIDC-Anbieters für Ihren Cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) im Amazon EKS-Benutzerhandbuch.*

   1. Erstellen Sie einen IAM-OIDC-Identitätsanbieter für Ihren Cluster mit dem folgenden Befehl. In diesem Beispiel wird davon ausgegangen, dass Ihr Clustername lautet. `my-eks-cluster` Wenn Sie einen Cluster mit einem anderen Namen haben, denken Sie daran, den Namen in allen future Befehlen zu aktualisieren.

      ```
      eksctl utils associate-iam-oidc-provider --cluster my-eks-cluster --approve 
      ```

   1. Bestätigen Sie mit dem folgenden Befehl, dass der OIDC-Identitätsanbieter bei IAM registriert wurde.

      ```
      aws iam list-open-id-connect-providers --region us-east-1
      ```

      Die Ausgabe sollte in etwa so aussehen. Notieren Sie sich den Amazon Resource Name (ARN) des OIDC. Sie benötigen ihn im nächsten Schritt, wenn Sie eine Vertrauensrichtlinie für das Servicekonto erstellen.

      ```
      {
          "OpenIDConnectProviderList": [
              ..
              {
                  "Arn": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
              }
          ]
      }
      ```

1. Erstellen Sie ein Dienstkonto für den Amazon EKS-Cluster. Dienstkonten bieten eine Identität für Prozesse, die in einem *Pod* ausgeführt werden. Ein Pod ist das kleinste und einfachste Kubernetes-Objekt, mit dem Sie eine containerisierte Anwendung bereitstellen können. Erstellen Sie als Nächstes eine IAM-Rolle, die das Dienstkonto übernehmen kann, um Berechtigungen für Ressourcen zu erhalten. Sie können auf jeden AWS Dienst von einem Pod aus zugreifen, der für die Verwendung eines Dienstkontos konfiguriert wurde, das eine IAM-Rolle mit Zugriffsberechtigungen für diesen Dienst übernehmen kann.

   1. Erstellen Sie einen neuen Namespace für das Dienstkonto. Ein Namespace hilft dabei, Clusterressourcen zu isolieren, die für dieses Tutorial erstellt wurden. Mit dem folgenden Befehl können Sie einen neuen Namespace erstellen.

      ```
      kubectl create namespace my-eks-namespace
      ```

   1. Um einen benutzerdefinierten Namespace zu verwenden, müssen Sie ihn mit einem Fargate-Profil verknüpfen. Der folgende Code ist ein Beispiel dafür.

      ```
      eksctl create fargateprofile \
          --cluster my-eks-cluster \
          --name my-fargate-profile \
          --namespace my-eks-namespace \
          --labels *=*
      ```

   1. Erstellen Sie mithilfe des folgenden Befehls ein Dienstkonto mit dem Namen `my-eks-serviceaccount` im Namespace `my-eks-namespace` für Ihren Amazon EKS-Cluster.

      ```
      cat >my-serviceaccount.yaml <<EOF
      apiVersion: v1
      kind: ServiceAccount
      metadata:
        name: my-eks-serviceaccount
        namespace: my-eks-namespace
      EOF
      kubectl apply -f my-serviceaccount.yaml
      ```

   1. Führen Sie den folgenden Befehl aus, um eine Vertrauensrichtliniendatei zu erstellen, die die IAM-Rolle anweist, Ihrem Servicekonto zu vertrauen. Diese Vertrauensstellung ist erforderlich, bevor ein Principal eine Rolle übernehmen kann. Sie müssen die folgenden Änderungen an der Datei vornehmen:
      + Geben Sie für den `Principal` den ARN ein, den IAM an den `list-open-id-connect-providers` Befehl zurückgegeben hat. Die ARN enthält Ihre Kontonummer und Region.
      + Ersetzen Sie in der `condition` Erklärung die AWS-Region und die OIDC-ID.
      + Vergewissern Sie sich, dass der Name und der Namespace des Dienstkontos korrekt sind.

      Sie müssen die Vertrauensrichtliniendatei im nächsten Schritt anhängen, wenn Sie die IAM-Rolle erstellen.

      ```
      cat >trust-relationship.json <<EOF
      {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
                  },
                  "Action": "sts:AssumeRoleWithWebIdentity",
                  "Condition": {
                      "StringEquals": {
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:my-eks-namespace:my-eks-serviceaccount",
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
                      }
                  }
              }
          ]
      }
      EOF
      ```

      Optional: Sie können den `StringLike` Bedingungen `StringEquals` oder auch mehrere Einträge hinzufügen, damit mehrere Dienstkonten oder Namespaces die Rolle übernehmen können. Informationen dazu, dass Ihr Servicekonto eine IAM-Rolle in einem anderen AWS Konto übernehmen kann, finden Sie unter [Kontoübergreifende IAM-Berechtigungen](https://docs.aws.amazon.com/eks/latest/userguide/cross-account-access.html) im *Amazon EKS-Benutzerhandbuch*.

1. Erstellen Sie eine IAM-Rolle mit dem Namen`my-iam-role`, den das Amazon EKS-Servicekonto annehmen soll. Hängen Sie die im letzten Schritt erstellte Vertrauensrichtlinien-Datei an die Rolle an. Die Vertrauensrichtlinie gibt das Dienstkonto und den OIDC-Anbieter an, denen die IAM-Rolle vertrauen kann. 

   ```
   aws iam create-role --role-name my-iam-role --assume-role-policy-document file://trust-relationship.json --description "EKS service account role"
   ```

1. Weisen Sie Amazon Keyspaces die IAM-Rollenberechtigungen zu, indem Sie eine Zugriffsrichtlinie anhängen. 

   1. Fügen Sie eine Zugriffsrichtlinie hinzu, um die Aktionen zu definieren, die die IAM-Rolle für bestimmte Amazon Keyspaces-Ressourcen ausführen kann. Für dieses Tutorial verwenden wir die AWS verwaltete Richtlinie`AmazonKeyspacesFullAccess`, da unsere Anwendung Daten in Ihre Amazon Keyspaces-Tabelle schreibt. Als bewährte Methode wird jedoch empfohlen, benutzerdefinierte Zugriffsrichtlinien zu erstellen, die das Prinzip der geringsten Rechte umsetzen. Weitere Informationen finden Sie unter [So funktioniert Amazon Keyspaces mit IAM](security_iam_service-with-iam.md).

      ```
      aws iam attach-role-policy --role-name my-iam-role --policy-arn=arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess
      ```

      Bestätigen Sie mit der folgenden Erklärung, dass die Richtlinie erfolgreich an die IAM-Rolle angehängt wurde.

      ```
      aws iam list-attached-role-policies --role-name my-iam-role
      ```

      Die Ausgabe sollte wie folgt aussehen.

      ```
      {
          "AttachedPolicies": [
              {
                  "PolicyName": "AmazonKeyspacesFullAccess",
                  "PolicyArn": "arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess"
              }
          ]
      }
      ```

   1. Versehen Sie das Dienstkonto mit dem Amazon-Ressourcennamen (ARN) der IAM-Rolle, die es annehmen kann. Achten Sie darauf, den Rollen-ARN mit Ihrer Konto-ID zu aktualisieren.

      ```
      kubectl annotate serviceaccount -n my-eks-namespace my-eks-serviceaccount eks.amazonaws.com/role-arn=arn:aws:iam::111122223333:role/my-iam-role
      ```

1. Vergewissern Sie sich, dass die IAM-Rolle und das Dienstkonto korrekt konfiguriert sind.

   1. Stellen Sie mit der folgenden Anweisung sicher, dass die Vertrauensrichtlinie der IAM-Rolle korrekt konfiguriert ist.

      ```
      aws iam get-role --role-name my-iam-role --query Role.AssumeRolePolicyDocument
      ```

      Die Ausgabe sollte in etwa so aussehen.

      ```
      {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
                  },
                  "Action": "sts:AssumeRoleWithWebIdentity",
                  "Condition": {
                      "StringEquals": {
                          "oidc.eks.us-east-1/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com",
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:my-eks-namespace:my-eks-serviceaccount"
                      }
                  }
              }
          ]
      }
      ```

   1. Vergewissern Sie sich, dass das Amazon EKS-Servicekonto mit der IAM-Rolle versehen ist.

      ```
      kubectl describe serviceaccount my-eks-serviceaccount -n my-eks-namespace
      ```

      Die Ausgabe sollte in etwa so aussehen.

      ```
      Name: my-eks-serviceaccount 
      Namespace:my-eks-namespace
      Labels: <none>
      Annotations: eks.amazonaws.com/role-arn: arn:aws:iam::111122223333:role/my-iam-role 
      Image pull secrets: <none> 
      Mountable secrets: <none> 
      Tokens: <none> 
      [...]
      ```

Nachdem Sie das Amazon EKS-Servicekonto und die IAM-Rolle erstellt und die erforderlichen Beziehungen und Berechtigungen konfiguriert haben, fahren Sie mit fort[Schritt 2: Konfigurieren Sie die Anwendung](EKS-tutorial-step2.md).

# Schritt 2: Konfigurieren Sie die Anwendung
<a name="EKS-tutorial-step2"></a>

In diesem Schritt erstellen Sie Ihre Anwendung, die mithilfe des SigV4-Plug-ins eine Verbindung zu Amazon Keyspaces herstellt. [Sie können die Java-Beispielanwendung aus dem Amazon Keyspaces-Beispielcode-Repository auf Github ansehen und herunterladen.](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/eks) Oder Sie können mit Ihrer eigenen Anwendung weitermachen und dabei sicherstellen, dass alle Konfigurationsschritte abgeschlossen sind.

**Konfigurieren Sie Ihre Anwendung und fügen Sie die erforderlichen Abhängigkeiten hinzu.**

1. Sie können die Java-Beispielanwendung herunterladen, indem Sie das Github-Repository mit dem folgenden Befehl klonen.

   ```
   git clone https://github.com/aws-samples/amazon-keyspaces-examples.git
   ```

1. Nachdem Sie das Github-Repo heruntergeladen haben, entpacken Sie die heruntergeladene Datei und navigieren Sie zum `resources` Verzeichnis der Datei. `application.conf`

   1. **Konfiguration der Anwendung**

      In diesem Schritt konfigurieren Sie das SigV4-Authentifizierungs-Plugin. Sie können das folgende Beispiel in Ihrer Anwendung verwenden. Falls Sie dies noch nicht getan haben, müssen Sie Ihre IAM-Zugriffsschlüssel (eine Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel) generieren und sie in Ihrer AWS Konfigurationsdatei oder als Umgebungsvariablen speichern. Detaillierte Anweisungen finden Sie unter [Anmeldeinformationen AWS CLI, die für das AWS SDK oder das Amazon Keyspaces SigV4-Plugin für Cassandra-Client-Treiber erforderlich sind](SigV4_credentials.md). Aktualisieren Sie die AWS Region und den Service-Endpunkt für Amazon Keyspaces nach Bedarf. Weitere Service-Endpunkte finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md) Ersetzen Sie den Truststore-Standort, den Truststore-Namen und das Truststore-Passwort durch Ihr eigenes.

      ```
      datastax-java-driver {
        basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"]
        basic.load-balancing-policy.local-datacenter = "us-east-1"
        advanced.auth-provider {
          class = software.aws.mcs.auth.SigV4AuthProvider
          aws-region = "us-east-1"
        }
        advanced.ssl-engine-factory {
          class = DefaultSslEngineFactory
          truststore-path = "truststore_locationtruststore_name.jks"
          truststore-password = "truststore_password;"
        }
      }
      ```

   1. **Fügen Sie die Abhängigkeit vom STS-Modul hinzu.**

      Dadurch wird die Möglichkeit hinzugefügt`WebIdentityTokenCredentialsProvider`, eine zu verwenden, die die AWS Anmeldeinformationen zurückgibt, die die Anwendung bereitstellen muss, damit das Dienstkonto die IAM-Rolle übernehmen kann. Sie können dies anhand des folgenden Beispiels tun.

      ```
              <dependency>
                  <groupId>com.amazonaws</groupId>
                  <artifactId>aws-java-sdk-sts</artifactId>
                  <version>1.11.717</version> 
              </dependency>
      ```

   1. **Fügen Sie die SigV4-Abhängigkeit hinzu.**

       Dieses Paket implementiert das SigV4-Authentifizierungs-Plugin, das für die Authentifizierung bei Amazon Keyspaces benötigt wird.

      ```
              <dependency>
                  <groupId>software.aws.mcs</groupId>
                  <artifactId>aws-sigv4-auth-cassandra-java-driver-plugin</artifactId>
                  <version>4.0.3</version> 
              </dependency>
      ```

1. **Fügen Sie eine Protokollierungsabhängigkeit hinzu.**

    Ohne Protokolle ist die Behebung von Verbindungsproblemen nicht möglich. In diesem Tutorial verwenden `slf4j` wir das Framework für die Protokollierung und speichern `logback.xml` die Protokollausgabe. Wir setzen die Protokollierungsebene auf`debug`, um die Verbindung herzustellen. Sie können das folgende Beispiel verwenden, um die Abhängigkeit hinzuzufügen.

   ```
           <dependency>
               <groupId>org.slf4j</groupId>
               <artifactId>slf4j-api</artifactId>
               <version>2.0.5</version> 
           </dependency>
   ```

   Sie können den folgenden Codeausschnitt verwenden, um die Protokollierung zu konfigurieren.

   ```
   <configuration>
       <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
           
           <encoder>
               <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
           </encoder>
       </appender>
   
       <root level="debug">
           <appender-ref ref="STDOUT" />
       </rootv
   </configuration>
   ```
**Anmerkung**  
Die `debug` Ebene wird benötigt, um Verbindungsfehler zu untersuchen. Nachdem Sie von Ihrer Anwendung aus erfolgreich eine Verbindung zu Amazon Keyspaces hergestellt haben, können Sie die Protokollierungsebene nach `warning` Bedarf auf `info` oder ändern. 

# Schritt 3: Erstellen Sie das Anwendungs-Image und laden Sie die Docker-Datei in Ihr Amazon ECR-Repository hoch
<a name="EKS-tutorial-step3"></a>

In diesem Schritt kompilieren Sie die Beispielanwendung, erstellen ein Docker-Image und übertragen das Image in Ihr Amazon ECR-Repository.

**Erstellen Sie Ihre Anwendung, erstellen Sie ein Docker-Image und reichen Sie es bei Amazon Elastic Container Registry ein**

1. Legen Sie Umgebungsvariablen für den Build fest, die Ihre AWS-Region definieren. Ersetzen Sie die Regionen in den Beispielen durch Ihre eigenen.

   ```
   export CASSANDRA_HOST=cassandra.us-east-1.amazonaws.com:9142
   export CASSANDRA_DC=us-east-1
   ```

1. Kompilieren Sie Ihre Anwendung mit Apache Maven Version 3.6.3 oder höher mit dem folgenden Befehl.

   ```
   mvn clean install
   ```

   Dadurch wird eine `JAR` Datei erstellt, in der alle Abhängigkeiten im Verzeichnis enthalten sind. `target`

1. Rufen Sie Ihre ECR-Repository-URI, die für den nächsten Schritt benötigt wird, mit dem folgenden Befehl ab. Stellen Sie sicher, dass Sie die Region auf die Region aktualisieren, die Sie verwendet haben.

   ```
   aws ecr describe-repositories --region us-east-1
   ```

   Die Ausgabe sollte wie im folgenden Beispiel aussehen.

   ```
   "repositories": [
    {
    "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/my-ecr-repository",
    "registryId": "111122223333",
    "repositoryName": "my-ecr-repository",
    "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository",
    "createdAt": "2023-11-02T03:46:34+00:00",
    "imageTagMutability": "MUTABLE",
    "imageScanningConfiguration": {
    "scanOnPush": false
    },
    "encryptionConfiguration": {
    "encryptionType": "AES256"
    }
    },
   ```

1. Erstellen Sie das Docker-Image aus dem Stammverzeichnis der Anwendung mit der Repository-URI aus dem letzten Schritt. Ändern Sie die Docker-Datei nach Bedarf. Stellen Sie sicher, dass Sie im Build-Befehl Ihre Konto-ID ersetzen und die Region AWS-Region angeben, in der sich das Amazon ECR-Repository `my-ecr-repository` befindet. 

   ```
   docker build -t 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository:latest .
   ```

1. Rufen Sie ein Authentifizierungstoken ab, um das Docker-Image an Amazon ECR zu übertragen. Sie können dies mit dem folgenden Befehl tun.

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. Suchen Sie zunächst in Ihrem Amazon ECR-Repository nach vorhandenen Bildern. Sie können folgenden Befehl verwenden.

   ```
   aws ecr describe-images --repository-name my-ecr-repository --region us-east-1
   ```

   Dann übertragen Sie das Docker-Image in das Repo. Sie können folgenden Befehl verwenden.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository:latest
   ```

# Schritt 4: Stellen Sie die Anwendung in Amazon EKS bereit und schreiben Sie Daten in Ihre Tabelle
<a name="EKS-tutorial-step4"></a>

In diesem Schritt des Tutorials konfigurieren Sie die Amazon EKS-Bereitstellung für Ihre Anwendung und stellen sicher, dass die Anwendung läuft und eine Verbindung zu Amazon Keyspaces herstellen kann.

Um eine Anwendung in Amazon EKS bereitzustellen, müssen Sie alle relevanten Einstellungen in einer Datei mit dem Namen konfigurieren`deployment.yaml`. Diese Datei wird dann von Amazon EKS zur Bereitstellung der Anwendung verwendet. Die Metadaten in der Datei sollten die folgenden Informationen enthalten:
+ **Anwendungsname** Der Name der Anwendung. Für dieses Tutorial verwenden wir`my-keyspaces-app`.
+ **Kubernetes-Namespace** — der Namespace des Amazon EKS-Clusters. Für dieses Tutorial verwenden wir. `my-eks-namespace`
+ Name des **Amazon EKS-Servicekontos Der Name** des Amazon EKS-Servicekontos. Für dieses Tutorial verwenden wir`my-eks-serviceaccount`.
+ **Bildname** der Name des Anwendungsabbilds. Für dieses Tutorial verwenden wir`my-keyspaces-app`.
+ **Image-URI** Die Docker-Image-URI von Amazon ECR.
+  **AWS Konto-ID** Ihre AWS Konto-ID.
+ **IAM-Rolle ARN** Der ARN der IAM-Rolle, die für das Dienstkonto erstellt wurde. Für dieses Tutorial verwenden wir. `my-iam-role`
+ **AWS-Region des Amazon EKS-Clusters**, in dem AWS-Region Sie Ihren Amazon EKS-Cluster erstellt haben.

In diesem Schritt stellen Sie die Anwendung bereit und führen sie aus, die eine Verbindung zu Amazon Keyspaces herstellt und Daten in die Tabelle schreibt.

1. Konfigurieren Sie die `deployment.yaml`-Datei. Sie müssen die folgenden Werte ersetzen:
   + `name`
   + `namespace`
   + `serviceAccountName`
   + `image`
   + `AWS_ROLE_ARN value`
   + Der AWS-Region Eingang `CASSANDRA_HOST`
   + `AWS_REGION`

   Sie können die folgende Datei als Beispiel verwenden.

   ```
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-keyspaces-app
     namespace: my-eks-namespace
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: my-keyspaces-app
     template:
       metadata:
         labels:
           app: my-keyspaces-app
       spec:
         serviceAccountName: my-eks-serviceaccount
         containers:
         - name: my-keyspaces-app
           image: 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository:latest
           ports:
           - containerPort: 8080
           env:
           - name: CASSANDRA_HOST
             value: "cassandra.us-east-1.amazonaws.com:9142"
           - name: CASSANDRA_DC
             value: "us-east-1"
           - name: AWS_WEB_IDENTITY_TOKEN_FILE
             value: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
           - name: AWS_ROLE_ARN
             value: "arn:aws:iam::111122223333:role/my-iam-role"
           - name: AWS_REGION
             value: "us-east-1"
   ```

1. Stellen Sie `deployment.yaml` bereit.

   ```
   kubectl apply -f deployment.yaml
   ```

   Die Ausgabe sollte so aussehen.

   ```
   deployment.apps/my-keyspaces-app created
   ```

1. Überprüfen Sie den Status des Pods in Ihrem Namespace des Amazon EKS-Clusters. 

   ```
   kubectl get pods -n my-eks-namespace
   ```

   Die Ausgabe sollte diesem Beispiel ähneln.

   ```
   NAME                    READY STATUS RESTARTS AGE
   my-keyspaces-app-123abcde4f-g5hij 1/1 Running 0 75s
   ```

   Für weitere Informationen können Sie den folgenden Befehl verwenden.

   ```
   kubectl describe pod my-keyspaces-app-123abcde4f-g5hij -n my-eks-namespace
   ```

   ```
   Name:                 my-keyspaces-app-123abcde4f-g5hij
   Namespace:            my-eks-namespace
   Priority:             2000001000
   Priority Class Name:  system-node-critical
   Service Account:      my-eks-serviceaccount
   Node:                 fargate-ip-192-168-102-209.ec2.internal/192.168.102.209
   Start Time:           Thu, 23 Nov 2023 12:15:43 +0000
   Labels:               app=my-keyspaces-app
                         eks.amazonaws.com/fargate-profile=my-fargate-profile
                         pod-template-hash=6c56fccc56
   Annotations:          CapacityProvisioned: 0.25vCPU 0.5GB
                         Logging: LoggingDisabled: LOGGING_CONFIGMAP_NOT_FOUND
   Status:               Running
   IP:                   192.168.102.209
   IPs:
     IP:           192.168.102.209
   Controlled By:  ReplicaSet/my-keyspaces-app-6c56fccc56
   Containers:
     my-keyspaces-app:
       Container ID:   containerd://41ff7811d33ae4bc398755800abcdc132335d51d74f218ba81da0700a6f8c67b
       Image:          111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest
       Image ID:       111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository@sha256:fd3c6430fc5251661efce99741c72c1b4b03061474940200d0524b84a951439c
       Port:           8080/TCP
       Host Port:      0/TCP
       State:          Running
         Started:      Thu, 23 Nov 2023 12:15:19 +0000
         Finished:     Thu, 23 Nov 2023 12:16:17 +0000
       Ready:          True
       Restart Count:  1
       Environment:
         CASSANDRA_HOST:               cassandra.us-east-1.amazonaws.com:9142
         CASSANDRA_DC:                 us-east-1
         AWS_WEB_IDENTITY_TOKEN_FILE:  /var/run/secrets/eks.amazonaws.com/serviceaccount/token
         AWS_ROLE_ARN:                 arn:aws:iam::111122223333:role/my-iam-role
         AWS_REGION:                   us-east-1
         AWS_STS_REGIONAL_ENDPOINTS:   regional
       Mounts:
         /var/run/secrets/eks.amazonaws.com/serviceaccount from aws-iam-token (ro)
         /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-fssbf (ro)
   Conditions:
     Type              Status
     Initialized       True 
     Ready             True 
     ContainersReady   True 
     PodScheduled      True 
   Volumes:
     aws-iam-token:
       Type:                    Projected (a volume that contains injected data from multiple sources)
       TokenExpirationSeconds:  86400
     kube-api-access-fssbf:
       Type:                    Projected (a volume that contains injected data from multiple sources)
       TokenExpirationSeconds:  3607
       ConfigMapName:           kube-root-ca.crt
       ConfigMapOptional:       <nil>
       DownwardAPI:             true
   QoS Class:                   BestEffort
   Node-Selectors:              <none>
   Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                                node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
   Events:
     Type     Reason           Age                From               Message
     ----     ------           ----               ----               -------
     Warning  LoggingDisabled  2m13s              fargate-scheduler  Disabled logging because aws-logging configmap was not found. configmap "aws-logging" not found
     Normal   Scheduled        89s                fargate-scheduler  Successfully assigned my-eks-namespace/my-keyspaces-app-6c56fccc56-mgs2m to fargate-ip-192-168-102-209.ec2.internal
     Normal   Pulled           75s                kubelet            Successfully pulled image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest" in 13.027s (13.027s including waiting)
     Normal   Pulling          54s (x2 over 88s)  kubelet            Pulling image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest"
     Normal   Created          54s (x2 over 75s)  kubelet            Created container my-keyspaces-app
     Normal   Pulled           54s                kubelet            Successfully pulled image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest" in 222ms (222ms including waiting)
     Normal   Started          53s (x2 over 75s)  kubelet            Started container my-keyspaces-app
   ```

1. Überprüfen Sie die Protokolle des Pods, um sicherzustellen, dass Ihre Anwendung läuft und eine Verbindung zu Ihrer Amazon Keyspaces-Tabelle herstellen kann. Sie können dies mit dem folgenden Befehl tun. Achten Sie darauf, den Namen Ihrer Bereitstellung zu ersetzen.

   ```
   kubectl logs -f my-keyspaces-app-123abcde4f-g5hij -n my-eks-namespace
   ```

   Sie sollten in der Lage sein, Anwendungsprotokolleinträge zu sehen, die die Verbindung zu Amazon Keyspaces bestätigen, wie im Beispiel unten.

   ```
   2:47:20.553 [s0-admin-0] DEBUG c.d.o.d.i.c.metadata.MetadataManager - [s0] Adding initial contact points [Node(endPoint=cassandra.us-east-1.amazonaws.com/1.222.333.44:9142, hostId=null, hashCode=e750d92)]
   22:47:20.562 [s0-admin-1] DEBUG c.d.o.d.i.c.c.ControlConnection - [s0] Initializing with event types [SCHEMA_CHANGE, STATUS_CHANGE, TOPOLOGY_CHANGE]
   22:47:20.564 [s0-admin-1] DEBUG c.d.o.d.i.core.context.EventBus - [s0] Registering com.datastax.oss.driver.internal.core.metadata.LoadBalancingPolicyWrapper$$Lambda$812/0x0000000801105e88@769afb95 for class com.datastax.oss.driver.internal.core.metadata.NodeStateEvent
   22:47:20.566 [s0-admin-1] DEBUG c.d.o.d.i.c.c.ControlConnection - [s0] Trying to establish a connection to Node(endPoint=cassandra.us-east-1.amazonaws.com/1.222.333.44:9142, hostId=null, hashCode=e750d92)
   ```

1. Führen Sie die folgende CQL-Abfrage in Ihrer Amazon Keyspaces-Tabelle aus, um zu bestätigen, dass eine Datenzeile in Ihre Tabelle geschrieben wurde:

   ```
   SELECT * from aws.user;
   ```

   Die Ausgabe sollte folgendermaßen aussehen:

   ```
   fname    | lname | username | last_update_date 
   ----------+-------+----------+-----------------------------
   random    | k     | test     | 2023-12-07 13:58:31.57+0000
   ```

# Schritt 5: (Optional) Aufräumen
<a name="EKS-tutorial-step5"></a>

Gehen Sie wie folgt vor, um alle in diesem Tutorial erstellten Ressourcen zu entfernen.

**Entfernen Sie die in diesem Tutorial erstellten Ressourcen**

1. Löschen Sie Ihre Bereitstellung. Sie können dazu den folgenden Befehl verwenden.

   ```
   kubectl delete deployment my-keyspaces-app -n my-eks-namespace
   ```

1. Löschen Sie den Amazon EKS-Cluster und alle darin enthaltenen Pods. Dadurch werden auch zugehörige Ressourcen wie das Dienstkonto und der OIDC-Identitätsanbieter gelöscht. Sie können dazu den folgenden Befehl verwenden.

   ```
   eksctl delete cluster --name my-eks-cluster --region us-east-1
   ```

1. Löschen Sie die IAM-Rolle, die für das Amazon EKS-Servicekonto mit Zugriffsberechtigungen für Amazon Keyspaces verwendet wurde. Zunächst müssen Sie die verwaltete Richtlinie entfernen, die der Rolle zugeordnet ist.

   ```
   aws iam detach-role-policy --role-name my-iam-role --policy-arn arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess
   ```

   Anschließend können Sie die Rolle mit dem folgenden Befehl löschen.

   ```
   aws iam delete-role --role-name my-iam-role
   ```

   Weitere Informationen finden Sie unter [Löschen einer IAM-Rolle (AWS CLI)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli) im *IAM-Benutzerhandbuch*. 

1. Löschen Sie das Amazon ECR-Repository einschließlich aller darin gespeicherten Bilder. Sie können dies mit dem folgenden Befehl tun.

   ```
   aws ecr delete-repository \
         --repository-name my-ecr-repository \
         --force \
         --region us-east-1
   ```

   Beachten Sie, dass das `force` Flag erforderlich ist, um ein Repository zu löschen, das Bilder enthält. Um Ihr Bild zuerst zu löschen, können Sie dies mit dem folgenden Befehl tun. 

   ```
   aws ecr batch-delete-image \
         --repository-name my-ecr-repository \
         --image-ids imageTag=latest \
         --region us-east-1
   ```

   Weitere Informationen finden Sie unter [Löschen eines Images](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-delete-image) im Amazon Elastic Container Registry-Benutzerhandbuch.

1. Löschen Sie den Amazon Keyspaces-Schlüsselraum und die Tabelle. Durch das Löschen des Schlüsselraums werden automatisch alle Tabellen in diesem Schlüsselraum gelöscht. Sie können dazu eine der folgenden Optionen verwenden.

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

   ```
   aws keyspaces delete-keyspace --keyspace-name 'aws'
   ```

   Um zu bestätigen, dass der Keyspace gelöscht wurde, können Sie den folgenden Befehl verwenden.

   ```
   aws keyspaces list-keyspaces
   ```

   Um die Tabelle zuerst zu löschen, können Sie den folgenden Befehl verwenden.

   ```
   aws keyspaces delete-table --keyspace-name 'aws' --table-name 'user'
   ```

   Um zu bestätigen, dass Ihre Tabelle gelöscht wurde, können Sie den folgenden Befehl verwenden.

   ```
   aws keyspaces list-tables --keyspace-name 'aws'
   ```

   Weitere Informationen finden Sie unter [Delete Keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-keyspace.html) und [Delete Table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-table.html) in der *AWS CLI Befehlsreferenz.*

------
#### [ cqlsh ]

   ```
   DROP KEYSPACE IF EXISTS "aws";
   ```

   Um zu überprüfen, ob Ihre Schlüsselräume gelöscht wurden, können Sie die folgende Anweisung verwenden.

   ```
   SELECT * FROM system_schema.keyspaces ;
   ```

   Ihr Schlüsselraum sollte in der Ausgabe dieser Anweisung nicht aufgeführt werden. Beachten Sie, dass es zu einer Verzögerung kommen kann, bis die Schlüsselräume gelöscht werden. Weitere Informationen finden Sie unter [SCHLÜSSELRAUM LÖSCHEN](cql.ddl.keyspace.md#cql.ddl.keyspace.drop).

   Um die Tabelle zuerst zu löschen, können Sie den folgenden Befehl verwenden.

   ```
   DROP TABLE "aws.user"
   ```

   Um zu bestätigen, dass Ihre Tabelle gelöscht wurde, können Sie den folgenden Befehl verwenden.

   ```
   SELECT * FROM system_schema.tables WHERE keyspace_name = "aws";
   ```

   Ihre Tabelle sollte in der Ausgabe dieser Anweisung nicht aufgeführt werden. Beachten Sie, dass es zu Verzögerungen kommen kann, bis die Tabelle gelöscht wird. Weitere Informationen finden Sie unter [DROP TABLE](cql.ddl.table.md#cql.ddl.table.drop).

------