Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Tutoriel : Connectez-vous depuis une application conteneurisée hébergée sur Amazon Elastic Kubernetes Service
<a name="EKS-tutorial"></a>

Ce didacticiel explique les étapes nécessaires à la configuration d'un cluster Amazon Elastic Kubernetes Service (Amazon EKS) afin d'héberger une application conteneurisée qui se connecte à Amazon Keyspaces à l'aide de l'authentification Sigv4.

Amazon EKS est un service géré qui élimine le besoin d'installer, d'exploiter et de maintenir votre propre plan de contrôle Kubernetes. [Kubernetes](https://kubernetes.io/docs/concepts/overview/) est un système open source qui automatise la gestion, la mise à l’échelle et le déploiement d’applications conteneurisées.

Ce didacticiel fournit step-by-step des conseils pour configurer, créer et déployer une application Java conteneurisée sur Amazon EKS. Dans la dernière étape, vous exécutez l'application pour écrire des données dans une table Amazon Keyspaces.

**Topics**
+ [Conditions requises pour se connecter d'Amazon EKS à Amazon Keyspaces](EKS-tutorial-prerequisites.md)
+ [Étape 1 : configurer le cluster Amazon EKS et configurer les autorisations IAM](EKS-tutorial-step1.md)
+ [Étape 2 : Configuration de l'application](EKS-tutorial-step2.md)
+ [Étape 3 : créer l'image de l'application et télécharger le fichier Docker dans votre référentiel Amazon ECR](EKS-tutorial-step3.md)
+ [Étape 4 : Déployer l'application sur Amazon EKS et écrire des données dans votre table](EKS-tutorial-step4.md)
+ [Étape 5 : Nettoyage (facultatif)](EKS-tutorial-step5.md)

# Conditions requises pour se connecter d'Amazon EKS à Amazon Keyspaces
<a name="EKS-tutorial-prerequisites"></a>

**Créez les AWS ressources suivantes avant de commencer le didacticiel :**

1. Avant de commencer ce didacticiel, suivez les instructions de AWS configuration indiquées dans[Accès à Amazon Keyspaces (pour Apache Cassandra)](accessing.md). Ces étapes incluent l'inscription AWS et la création d'un Gestion des identités et des accès AWS (IAM) principal ayant accès à Amazon Keyspaces. 

1. Créez un espace de touches Amazon Keyspaces avec le nom `aws` et une table avec le nom dans `user` lequel vous pouvez écrire depuis l'application conteneurisée exécutée dans Amazon EKS plus loin dans ce didacticiel. Vous pouvez le faire avec AWS CLI ou en utilisant`cqlsh`.

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

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

   Pour confirmer que le keyspace a été créé, vous pouvez utiliser la commande suivante.

   ```
   aws keyspaces list-keyspaces
   ```

   Pour créer la table, vous pouvez utiliser la commande suivante.

   ```
   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}]'
   ```

   Pour confirmer que votre table a été créée, vous pouvez utiliser la commande suivante.

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

   Pour plus d'informations, voir [créer un espace de touches](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-keyspace.html) et [créer une table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-table.html) dans la *référence des AWS CLI commandes*.

------
#### [ 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
   );
   ```

   Pour vérifier que votre table a été créée, vous pouvez utiliser l'instruction suivante.

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

   Votre table doit être répertoriée dans le résultat de cette instruction. Notez qu'il peut y avoir un délai avant que la table ne soit créée. Pour de plus amples informations, veuillez consulter [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create).

------

1. Créez un cluster Amazon EKS avec un nœud de **type Fargate - Linux.** Fargate est un moteur de calcul sans serveur qui vous permet de déployer des pods Kubernetes sans gérer les instances Amazon Amazon EC2. Pour suivre ce didacticiel sans avoir à mettre à jour le nom du cluster dans tous les exemples de commandes, créez un cluster portant ce nom en `my-eks-cluster` suivant les instructions de la section [Getting started with Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html), `eksctl` dans le *guide de l'utilisateur Amazon EKS*. Lorsque votre cluster est créé, vérifiez que vos nœuds et les deux pods par défaut fonctionnent et fonctionnent correctement. Vous pouvez le faire à l'aide de la commande suivante.

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

   Vous devriez voir quelque chose de similaire à cette sortie.

   ```
   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. Installez Docker. Pour savoir comment installer Docker sur une instance Amazon EC2, [consultez la section Installer](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#getting-started-cli-prereqs) Docker dans le guide de l'utilisateur d'Amazon Elastic Container Registry. 

   Docker est disponible pour plusieurs systèmes d'exploitation, notamment les distributions Linux les plus modernes, comme Ubuntu et même MacOS et Windows. Pour en savoir plus sur la façon d'installer Docker sur votre système d'exploitation, consultez le [guide d'installation Docker](https://docs.docker.com/engine/install/#installation). 

1. créer un référentiel Amazon ECR ; Amazon ECR est un service de registre d'images de conteneurs AWS géré que vous pouvez utiliser avec votre CLI préférée pour envoyer, extraire et gérer des images Docker. Pour plus d'informations sur les référentiels Amazon ECR, consultez le guide de l'[utilisateur d'Amazon Elastic Container Registry](https://docs.aws.amazon.com/AmazonECR/latest/userguide/). Vous pouvez utiliser la commande suivante pour créer un référentiel portant ce nom`my-ecr-repository`.

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

Après avoir effectué les étapes préalables, passez à[Étape 1 : configurer le cluster Amazon EKS et configurer les autorisations IAM](EKS-tutorial-step1.md).

# Étape 1 : configurer le cluster Amazon EKS et configurer les autorisations IAM
<a name="EKS-tutorial-step1"></a>

**Configurez le cluster Amazon EKS et créez les ressources IAM nécessaires pour permettre à un compte de service Amazon EKS de se connecter à votre table Amazon Keyspaces**

1. Créez un fournisseur Open ID Connect (OIDC) pour le cluster Amazon EKS. Cela est nécessaire pour utiliser les rôles IAM pour les comptes de service. Pour plus d'informations sur les fournisseurs OIDC et sur la façon de les créer, consultez la section [Création d'un fournisseur OIDC IAM pour votre cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) dans le guide de l'utilisateur *Amazon EKS*.

   1. Créez votre fournisseur d'identité OIDC IAM pour votre cluster avec la commande suivante. Cet exemple suppose que le nom de votre cluster est`my-eks-cluster`. Si vous avez un cluster portant un nom différent, n'oubliez pas de le mettre à jour dans toutes les commandes futures.

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

   1. Vérifiez que le fournisseur d'identité OIDC a été enregistré auprès d'IAM à l'aide de la commande suivante.

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

      La sortie doit ressembler à ceci. Prenez note du nom de ressource Amazon (ARN) de l'OIDC, vous en aurez besoin à l'étape suivante lorsque vous créerez une politique de confiance pour le compte de service.

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

1. Créez un compte de service pour le cluster Amazon EKS. Les comptes de service fournissent une identité pour les processus exécutés dans un *Pod*. Un Pod est l'objet Kubernetes le plus petit et le plus simple que vous puissiez utiliser pour déployer une application conteneurisée. Créez ensuite un rôle IAM que le compte de service peut assumer pour obtenir des autorisations d'accès aux ressources. Vous pouvez accéder à n'importe quel AWS service à partir d'un Pod configuré pour utiliser un compte de service pouvant assumer un rôle IAM avec des autorisations d'accès à ce service.

   1. Créez un nouvel espace de noms pour le compte de service. Un espace de noms permet d'isoler les ressources du cluster créées pour ce didacticiel. Vous pouvez créer un nouvel espace de noms à l'aide de la commande suivante.

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

   1. Pour utiliser un espace de noms personnalisé, vous devez l'associer à un profil Fargate. Le code suivant en est un exemple.

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

   1. Créez un compte de service dont le nom figure `my-eks-serviceaccount` dans l'espace de noms `my-eks-namespace` de votre cluster Amazon EKS à l'aide de la commande suivante.

      ```
      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. Exécutez la commande suivante pour créer un fichier de politique de confiance qui indique au rôle IAM de faire confiance à votre compte de service. Cette relation de confiance est requise avant qu'un mandant puisse assumer un rôle. Vous devez apporter les modifications suivantes au fichier :
      + Pour le`Principal`, entrez l'ARN renvoyé par IAM à la `list-open-id-connect-providers` commande. L'ARN contient votre numéro de compte et votre région.
      + Dans l'`condition`instruction, remplacez le Région AWS et l'identifiant OIDC.
      + Vérifiez que le nom du compte de service et l'espace de noms sont corrects.

      Vous devez joindre le fichier de politique de confiance à l'étape suivante lorsque vous créez le rôle IAM.

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

      Facultatif : vous pouvez également ajouter plusieurs entrées dans les `StringLike` conditions `StringEquals` ou pour permettre à plusieurs comptes de service ou espaces de noms d'assumer le rôle. Pour autoriser votre compte de service à assumer un rôle IAM dans un autre AWS compte, consultez la section [Autorisations IAM entre comptes](https://docs.aws.amazon.com/eks/latest/userguide/cross-account-access.html) dans le guide de l'utilisateur *Amazon EKS*.

1. Créez un rôle IAM avec le nom `my-iam-role` que le compte de service Amazon EKS doit assumer. Joignez le fichier de politique de confiance créé lors de la dernière étape au rôle. La politique de confiance spécifie le compte de service et le fournisseur OIDC auxquels le rôle IAM peut faire confiance. 

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

1. Attribuez les autorisations du rôle IAM à Amazon Keyspaces en joignant une politique d'accès. 

   1. Joignez une politique d'accès pour définir les actions que le rôle IAM peut effectuer sur des ressources Amazon Keyspaces spécifiques. Pour ce didacticiel, nous utilisons la politique AWS gérée`AmazonKeyspacesFullAccess`, car notre application va écrire des données dans votre table Amazon Keyspaces. À titre de bonne pratique, il est toutefois recommandé de créer des politiques d'accès personnalisées qui mettent en œuvre le principe du moindre privilège. Pour de plus amples informations, veuillez consulter [Comment Amazon Keyspaces fonctionne avec 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
      ```

      Vérifiez que la politique a été correctement attachée au rôle IAM à l'aide de l'instruction suivante.

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

      La sortie doit ressembler à ceci.

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

   1. Annotez le compte de service avec l'Amazon Resource Name (ARN) du rôle IAM qu'il peut assumer. Assurez-vous de mettre à jour l'ARN du rôle avec votre identifiant de compte.

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

1. Vérifiez que le rôle IAM et le compte de service sont correctement configurés.

   1. Vérifiez que la politique de confiance du rôle IAM est correctement configurée à l'aide de l'instruction suivante.

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

      La sortie doit ressembler à ceci.

      ```
      {
          "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. Vérifiez que le compte de service Amazon EKS est annoté avec le rôle IAM.

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

      La sortie doit ressembler à ceci.

      ```
      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> 
      [...]
      ```

Après avoir créé le compte de service Amazon EKS, le rôle IAM et configuré les relations et les autorisations requises, passez à[Étape 2 : Configuration de l'application](EKS-tutorial-step2.md).

# Étape 2 : Configuration de l'application
<a name="EKS-tutorial-step2"></a>

Au cours de cette étape, vous allez créer votre application qui se connecte à Amazon Keyspaces à l'aide du plugin SigV4. [Vous pouvez consulter et télécharger l'exemple d'application Java depuis le dépôt d'exemples de code Amazon Keyspaces sur Github.](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/eks) Vous pouvez également suivre le processus en utilisant votre propre application, en vous assurant de terminer toutes les étapes de configuration.

**Configurez votre application et ajoutez les dépendances requises.**

1. Vous pouvez télécharger l'exemple d'application Java en clonant le référentiel Github à l'aide de la commande suivante.

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

1. Après avoir téléchargé le dépôt Github, décompressez le fichier téléchargé et accédez au `resources` répertoire du fichier. `application.conf`

   1. **Configuration de l'application**

      Au cours de cette étape, vous configurez le plugin d'authentification SigV4. Vous pouvez utiliser l'exemple suivant dans votre application. Si ce n'est pas déjà fait, vous devez générer vos clés d'accès IAM (un identifiant de clé d'accès et une clé d'accès secrète) et les enregistrer dans votre fichier de AWS configuration ou en tant que variables d'environnement. Pour obtenir des instructions complètes, consultez [Informations d'identification requises par AWS CLI le AWS SDK ou le plugin Amazon Keyspaces SigV4 pour les pilotes clients Cassandra](SigV4_credentials.md). Mettez à jour la AWS région et le point de terminaison du service pour Amazon Keyspaces selon les besoins. Pour plus de points de terminaison de service, voir[Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md). Remplacez l'emplacement du truststore, le nom du truststore et le mot de passe du truststore par les vôtres.

      ```
      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. **Ajoutez la dépendance du module STS.**

      Cela permet d'utiliser un `WebIdentityTokenCredentialsProvider` qui renvoie les AWS informations d'identification que l'application doit fournir pour que le compte de service puisse assumer le rôle IAM. Vous pouvez le faire en vous basant sur l'exemple suivant.

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

   1. **Ajoutez la dépendance SigV4.**

       Ce package implémente le plugin d'authentification SigV4 qui est nécessaire pour s'authentifier auprès d'Amazon Keyspaces

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

1. **Ajoutez une dépendance de journalisation.**

    Sans journaux, il est impossible de résoudre les problèmes de connexion. Dans ce didacticiel, nous l'utilisons `slf4j` comme framework de journalisation et nous l'utilisons `logback.xml` pour stocker la sortie du journal. Nous avons défini le niveau de journalisation `debug` sur pour établir la connexion. Vous pouvez utiliser l'exemple suivant pour ajouter la dépendance.

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

   Vous pouvez utiliser l'extrait de code suivant pour configurer la journalisation.

   ```
   <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>
   ```
**Note**  
Ce `debug` niveau est nécessaire pour étudier les défaillances de connexion. Une fois que vous vous êtes connecté avec succès à Amazon Keyspaces depuis votre application, vous pouvez modifier le niveau de journalisation en fonction de vos `info` besoins`warning`. 

# Étape 3 : créer l'image de l'application et télécharger le fichier Docker dans votre référentiel Amazon ECR
<a name="EKS-tutorial-step3"></a>

Au cours de cette étape, vous compilez l'exemple d'application, vous créez une image Docker et vous envoyez l'image dans votre référentiel Amazon ECR.

**Créez votre application, créez une image Docker et soumettez-la à Amazon Elastic Container Registry**

1. Définissez des variables d'environnement pour la version qui définissent votre Région AWS. Remplacez les régions dans les exemples par les vôtres.

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

1. Compilez votre application avec Apache Maven version 3.6.3 ou supérieure à l'aide de la commande suivante.

   ```
   mvn clean install
   ```

   Cela crée un `JAR` fichier avec toutes les dépendances incluses dans le `target` répertoire.

1. Récupérez l'URI de votre référentiel ECR nécessaire pour l'étape suivante à l'aide de la commande suivante. Assurez-vous de mettre à jour la région avec celle que vous avez utilisée.

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

   La sortie doit ressembler à celle de l'exemple suivant.

   ```
   "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. À partir du répertoire racine de l'application, créez l'image Docker en utilisant l'URI du référentiel indiqué à la dernière étape. Modifiez le fichier Docker selon vos besoins. Dans la commande build, assurez-vous de remplacer votre identifiant de compte et de Région AWS définir la région dans laquelle se trouve le référentiel `my-ecr-repository` Amazon ECR. 

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

1. Récupérez un jeton d'authentification pour envoyer l'image Docker vers Amazon ECR. Vous pouvez le faire à l'aide de la commande suivante.

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

1. Tout d'abord, vérifiez les images existantes dans votre référentiel Amazon ECR. Vous pouvez utiliser la commande suivante :

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

   Ensuite, placez l'image Docker dans le dépôt. Vous pouvez utiliser la commande suivante :

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

# Étape 4 : Déployer l'application sur Amazon EKS et écrire des données dans votre table
<a name="EKS-tutorial-step4"></a>

Dans cette étape du didacticiel, vous configurez le déploiement d'Amazon EKS pour votre application, puis vous confirmez que l'application est en cours d'exécution et qu'elle peut se connecter à Amazon Keyspaces.

Pour déployer une application sur Amazon EKS, vous devez configurer tous les paramètres pertinents dans un fichier appelé`deployment.yaml`. Ce fichier est ensuite utilisé par Amazon EKS pour déployer l'application. Les métadonnées du fichier doivent contenir les informations suivantes :
+ **Nom de l'application** : nom de l'application. Pour ce tutoriel, nous utilisons`my-keyspaces-app`.
+ Espace de noms **Kubernetes : espace de noms** du cluster Amazon EKS. Pour ce tutoriel, nous utilisons`my-eks-namespace`.
+ Le **nom du compte de service Amazon EKS** est le nom du compte de service Amazon EKS. Pour ce tutoriel, nous utilisons`my-eks-serviceaccount`.
+ **nom de l'image** : nom de l'image de l'application. Pour ce tutoriel, nous utilisons`my-keyspaces-app`.
+ **URI de l'image** : URI de l'image Docker d'Amazon ECR.
+  **AWS identifiant de compte :** votre identifiant de AWS compte.
+ ARN du **rôle IAM : ARN** du rôle IAM créé pour que le compte de service puisse l'assumer. Pour ce tutoriel, nous utilisons`my-iam-role`.
+ **Région AWS du cluster Amazon EKS** dans lequel Région AWS vous avez créé votre cluster Amazon EKS.

Au cours de cette étape, vous déployez et exécutez l'application qui se connecte à Amazon Keyspaces et écrit des données dans la table.

1. Configurez le fichier `deployment.yaml`. Vous devez remplacer les valeurs suivantes :
   + `name`
   + `namespace`
   + `serviceAccountName`
   + `image`
   + `AWS_ROLE_ARN value`
   + Le Région AWS in `CASSANDRA_HOST`
   + `AWS_REGION`

   Vous pouvez utiliser le fichier suivant comme exemple.

   ```
   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. Déployez `deployment.yaml`.

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

   La sortie doit ressembler à ceci.

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

1. Vérifiez l'état du Pod dans votre espace de noms du cluster Amazon EKS. 

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

   La sortie doit ressembler à cet exemple.

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

   Pour plus de détails, vous pouvez utiliser la commande suivante.

   ```
   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. Consultez les journaux du Pod pour vérifier que votre application est en cours d'exécution et qu'elle peut se connecter à votre table Amazon Keyspaces. Vous pouvez le faire à l'aide de la commande suivante. Assurez-vous de remplacer le nom de votre déploiement.

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

   Vous devriez pouvoir voir les entrées du journal de l'application confirmant la connexion à Amazon Keyspaces, comme dans l'exemple ci-dessous.

   ```
   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. Exécutez la requête CQL suivante sur votre table Amazon Keyspaces pour confirmer qu'une ligne de données a été écrite dans votre table :

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

   Vous devriez voir la sortie suivante :

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

# Étape 5 : Nettoyage (facultatif)
<a name="EKS-tutorial-step5"></a>

Suivez ces étapes pour supprimer toutes les ressources créées dans ce didacticiel.

**Supprimer les ressources créées dans ce didacticiel**

1. Supprimez votre déploiement. Pour ce faire, vous pouvez utiliser la commande suivante.

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

1. Supprimez le cluster Amazon EKS et tous les pods qu'il contient. Cela supprime également les ressources associées telles que le compte de service et le fournisseur d'identité OIDC. Pour ce faire, vous pouvez utiliser la commande suivante.

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

1. Supprimez le rôle IAM utilisé pour le compte de service Amazon EKS avec des autorisations d'accès à Amazon Keyspaces. Tout d'abord, vous devez supprimer la politique gérée attachée au rôle.

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

   Vous pouvez ensuite supprimer le rôle à l'aide de la commande suivante.

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

   Pour plus d'informations, consultez [la section Suppression d'un rôle IAM (AWS CLI)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli) dans le guide de l'*utilisateur IAM*. 

1. Supprimez le référentiel Amazon ECR, y compris toutes les images qui y sont stockées. Vous pouvez le faire à l'aide de la commande suivante.

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

   Notez que l'`force`indicateur est nécessaire pour supprimer un dépôt contenant des images. Pour supprimer d'abord votre image, vous pouvez le faire à l'aide de la commande suivante. 

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

   Pour plus d'informations, consultez [Supprimer une image](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-delete-image) dans le guide de l'utilisateur d'Amazon Elastic Container Registry.

1. Supprimez le keyspace et le tableau Amazon Keyspaces. La suppression de l'espace-clavier entraîne automatiquement la suppression de toutes les tables qu'il contient. Pour ce faire, vous pouvez utiliser l'une des options suivantes.

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

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

   Pour confirmer que le keyspace a été supprimé, vous pouvez utiliser la commande suivante.

   ```
   aws keyspaces list-keyspaces
   ```

   Pour supprimer d'abord le tableau, vous pouvez utiliser la commande suivante.

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

   Pour confirmer que votre table a été supprimée, vous pouvez utiliser la commande suivante.

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

   Pour plus d'informations, voir [supprimer un espace de touches](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-keyspace.html) et [supprimer une table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-table.html) dans le manuel de *référence des AWS CLI commandes*.

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

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

   Pour vérifier que vos espaces clés ont été supprimés, vous pouvez utiliser l'instruction suivante.

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

   Votre espace de touche ne doit pas être répertorié dans le résultat de cette instruction. Notez qu'il peut y avoir un délai avant que les espaces clés ne soient supprimés. Pour de plus amples informations, veuillez consulter [DROP KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.drop).

   Pour supprimer d'abord le tableau, vous pouvez utiliser la commande suivante.

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

   Pour confirmer que votre table a été supprimée, vous pouvez utiliser la commande suivante.

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

   Votre table ne doit pas être répertoriée dans le résultat de cette instruction. Notez qu'il peut y avoir un délai avant que la table ne soit supprimée. Pour de plus amples informations, veuillez consulter [DROP TABLE](cql.ddl.table.md#cql.ddl.table.drop).

------