Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Tutorial: Conectarse desde una aplicación contenerizada alojada en Amazon Elastic Kubernetes Service
<a name="EKS-tutorial"></a>

Este tutorial explica los pasos necesarios para configurar un clúster de Amazon Elastic Kubernetes Service (Amazon EKS) para alojar una aplicación en contenedor que se conecte a Amazon Keyspaces mediante la autenticación SigV4.

Amazon EKS es un servicio administrado que elimina la necesidad de instalar, operar y mantener su propio plano de control de Kubernetes. [Kubernetes](https://kubernetes.io/docs/concepts/overview/) es un sistema de código abierto para automatizar la administración, el escalado y la implementación de las aplicaciones en contenedores.

El tutorial proporciona step-by-step instrucciones para configurar, crear e implementar una aplicación Java en contenedores en Amazon EKS. En el último paso, se ejecuta la aplicación para que escriba datos en una tabla de Amazon Keyspaces.

**Topics**
+ [Requisitos previos para conectarse desde Amazon EKS a Amazon Keyspaces](EKS-tutorial-prerequisites.md)
+ [Paso 1: configuración del clúster de Amazon EKS y configuración de los permisos de IAM](EKS-tutorial-step1.md)
+ [Paso 2: configuración de la aplicación](EKS-tutorial-step2.md)
+ [Paso 3: creación de la imagen de la aplicación y subida del archivo de Docker a su repositorio de Amazon ECR](EKS-tutorial-step3.md)
+ [Paso 4: implementación de la aplicación en Amazon EKS y escritura de los datos en la tabla](EKS-tutorial-step4.md)
+ [Paso 5: (opcional) eliminación](EKS-tutorial-step5.md)

# Requisitos previos para conectarse desde Amazon EKS a Amazon Keyspaces
<a name="EKS-tutorial-prerequisites"></a>

**Cree los siguientes AWS recursos antes de empezar con el tutorial**

1. Antes de empezar este tutorial, siga las instrucciones AWS de configuración incluidas en[Acceso a Amazon Keyspaces (para Apache Cassandra)](accessing.md). Estos pasos incluyen la inscripción AWS y la creación de un director AWS Identity and Access Management (IAM) con acceso a Amazon Keyspaces. 

1. Cree un espacio de claves de Amazon Keyspaces con el nombre `aws` y una tabla con el nombre `user` en la que pueda escribir desde la aplicación en contenedores que se ejecuta en Amazon EKS y que aparecerá más adelante en este tutorial. Puede hacerlo con o utilizando AWS CLI . `cqlsh`

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

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

   Para confirmar que el espacio de claves se ha creado, puede utilizar el siguiente comando.

   ```
   aws keyspaces list-keyspaces
   ```

   Para crear la tabla, puede utilizar el siguiente comando.

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

   Para confirmar que la tabla se ha creado, puede utilizar el siguiente comando.

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

   Para obtener más información, consulte [create keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-keyspace.html) y [create table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-table.html) en la *Referencia de comandos de la AWS CLI *.

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

   Para verificar que la tabla se ha creado, puede utilizar la siguiente instrucción.

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

   Su tabla debería aparecer en el resultado de esta instrucción. Tenga en cuenta que puede haber un retraso hasta que se cree la tabla. Para obtener más información, consulte [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create).

------

1. Cree un clúster de Amazon EKS con un tipo de nodo **Fargate - Linux**. Fargate es un motor de computación sin servidor que le permite implementar pods de Kubernetes sin administrar instancias de Amazon EC2. Para seguir este tutorial sin tener que actualizar el nombre del clúster en todos los comandos de ejemplo, cree un clúster con el nombre `my-eks-cluster` siguiendo las instrucciones de [Introducción a Amazon EKS — `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) en la *Guía del usuario de Amazon EKS*. Cuando se haya creado el clúster, compruebe que los nodos y los dos pods predeterminados estén funcionando y en buen estado. Puede hacerlo con el siguiente comando.

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

   Debería ver algo similar a este resultado.

   ```
   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. Instale Docker. Para obtener instrucciones sobre cómo instalar Docker en una instancia de Amazon EC2, consulte [Instalación de Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#getting-started-cli-prereqs) en la Guía del usuario de Amazon Elastic Container Registry. 

   Docker está disponible para muchos sistemas operativos diferentes, incluidas las distribuciones de Linux más modernas, como Ubuntu, e incluso en macOS y Windows. Para obtener más información sobre cómo instalar Docker en su sistema operativo concreto, consulte la [guía de instalación de Docker](https://docs.docker.com/engine/install/#installation). 

1. Cree un repositorio de Amazon ECR. Amazon ECR es un servicio AWS gestionado de registro de imágenes de contenedores que puede utilizar con la CLI que prefiera para insertar, extraer y gestionar imágenes de Docker. Para obtener más información sobre los repositorios de Amazon ECR, consulte la [Guía del usuario de Amazon Elastic Container Registry](https://docs.aws.amazon.com/AmazonECR/latest/userguide/). Puede utilizar el siguiente comando para crear un repositorio con el nombre `my-ecr-repository`.

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

Tras completar los pasos de requisitos previos, continúe con [Paso 1: configuración del clúster de Amazon EKS y configuración de los permisos de IAM](EKS-tutorial-step1.md).

# Paso 1: configuración del clúster de Amazon EKS y configuración de los permisos de IAM
<a name="EKS-tutorial-step1"></a>

**Configuración del clúster de Amazon EKS y cree los recursos de IAM necesarios para permitir que una cuenta de servicio de Amazon EKS se conecte a la tabla de Amazon Keyspaces**

1. Cree un proveedor de Open ID Connect (OIDC) para el clúster de Amazon EKS. Esto es necesario para utilizar los roles de IAM en las cuentas de servicio. Para obtener más información sobre los proveedores de OIDC y cómo crearlos, consulte [Creación de un proveedor de OIDC de IAM para su clúster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) en la *Guía del usuario de Amazon EKS*.

   1. Cree un proveedor de identidad de OIDC de IAM para su clúster con el siguiente comando. Este ejemplo asume que el nombre del clúster es `my-eks-cluster`. Si tiene un clúster con un nombre diferente, recuerde actualizar el nombre en todos los comandos futuros.

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

   1. Confirme que el proveedor de identidades de OIDC se haya registrado en IAM con el siguiente comando.

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

      La salida debería ser similar a la siguiente. Tome nota del nombre de recurso de Amazon (ARN) del OIDC. Lo necesitará en el siguiente paso al crear una política de confianza para la cuenta de servicio.

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

1. Cree una cuenta de servicio para el clúster de Amazon EKS. Las cuentas de servicio proporcionan una identidad para los procesos que se ejecutan en un *Pod*. Un pod es el objeto de Kubernetes más pequeño y sencillo que puede utilizar para implementar una aplicación en contenedores. A continuación, cree un rol de IAM que la cuenta de servicio pueda asumir para obtener permisos de acceso a los recursos. Puede acceder a cualquier AWS servicio desde un pod que se haya configurado para usar una cuenta de servicio que pueda asumir una función de IAM con permisos de acceso a ese servicio.

   1. Cree un nuevo espacio de nombres para la cuenta de servicio. Un espacio de nombres ayuda a aislar los recursos del clúster creados para este tutorial. Puede crear un nuevo espacio de nombres con el siguiente comando.

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

   1. Para usar un espacio de nombres personalizado, debe asociarlo a un perfil de Fargate. El siguiente código es un ejemplo de ello.

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

   1. Cree una cuenta de servicio con el nombre `my-eks-serviceaccount` en el espacio de nombres `my-eks-namespace` para su clúster de Amazon EKS mediante el siguiente comando.

      ```
      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. Ejecute el siguiente comando para crear una política de confianza que indique al rol de IAM que debe confiar en su cuenta de servicio. Esta relación de confianza es necesaria antes de que una entidad principal pueda asumir un rol. Debe realizar las siguientes modificaciones en el archivo:
      + Para `Principal`, introduzca el ARN que IAM devolvió al ejecutar el comando `list-open-id-connect-providers`. El ARN contiene su número de cuenta y su región.
      + En la `condition` declaración, sustituya el identificador OIDC Región de AWS y el identificador OIDC.
      + Confirme que el nombre y el espacio de nombres de la cuenta de servicio sean correctos.

      Debe asociar el archivo de política de confianza en el siguiente paso al crear el rol de 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
      ```

      Opcional: también puede agregar varias entradas en las condiciones `StringEquals` y `StringLike` para permitir que varias cuentas de servicio o espacios de nombres asuman el rol. Para permitir que su cuenta de servicio asuma un rol de IAM en otra cuenta de AWS diferente, consulte [Permisos de IAM entre cuentas](https://docs.aws.amazon.com/eks/latest/userguide/cross-account-access.html) en la *Guía del usuario de Amazon EKS*.

1. Cree un rol de IAM con el nombre `my-iam-role` para que lo asuma la cuenta de servicio de Amazon EKS. Asocie el archivo de política de confianza creado en el último paso al rol. La política de confianza especifica la cuenta de servicio y el proveedor de OIDC en los que puede confiar el rol de IAM. 

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

1. Asigne al rol de IAM permisos para Amazon Keyspaces mediante la asociación de una política de acceso. 

   1. Asocie una política de acceso para definir las acciones que el rol de IAM puede realizar en recursos específicos de Amazon Keyspaces. Para este tutorial utilizamos la política AWS gestionada`AmazonKeyspacesFullAccess`, ya que nuestra aplicación escribirá datos en tu tabla de Amazon Keyspaces. Sin embargo, como práctica recomendada, se recomienda crear políticas de acceso personalizadas que implementen el principio de privilegios mínimos. Para obtener más información, consulte [Funcionamiento de Amazon Keyspaces con 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
      ```

      Confirme que la política se haya asociado correctamente al rol de IAM con la siguiente instrucción.

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

      La salida debería tener este aspecto.

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

   1. Anote en la cuenta de servicio el nombre de recurso de Amazon (ARN) del rol de IAM que puede asumir. Asegúrese de actualizar el ARN del rol con su ID de cuenta.

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

1. Confirme que el rol de IAM y la cuenta de servicio se hayan configurado correctamente.

   1. Confirme que la política de confianza del rol de IAM se haya configurado correctamente con la siguiente instrucción.

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

      La salida debería ser similar a la siguiente.

      ```
      {
          "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. Confirme que en la cuenta de servicio de Amazon EKS se haya anotado el rol de IAM.

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

      La salida debería ser similar a la siguiente.

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

Tras crear la cuenta de servicio de Amazon EKS y el rol de IAM, y tras configurar las relaciones y los permisos necesarios, continúe con [Paso 2: configuración de la aplicación](EKS-tutorial-step2.md).

# Paso 2: configuración de la aplicación
<a name="EKS-tutorial-step2"></a>

En este paso, creará una aplicación que se conectará a Amazon Keyspaces mediante el complemento SigV4. Puede ver y descargar la aplicación Java de ejemplo desde el repositorio de código de ejemplo de Amazon Keyspaces en [Github](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/eks). O también puede continuar con su propia aplicación, asegurándose de completar todos los pasos de configuración.

**Configuración de su aplicación y adición de las dependencias necesarias.**

1. Puede descargar la aplicación Java de ejemplo clonando el repositorio de Github con el siguiente comando.

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

1. Después de descargar el repositorio de Github, descomprima el archivo descargado y navegue hasta el directorio `resources` del archivo `application.conf`.

   1. **Configuración de aplicaciones**

      En este paso, configurará el complemento de autenticación SigV4. Puede utilizar el siguiente ejemplo en su aplicación. Si aún no lo ha hecho, debe generar sus claves de acceso a IAM (un ID de clave de acceso y una clave de acceso secreta) y guardarlas en su archivo de AWS configuración o como variables de entorno. Para obtener instrucciones detalladas, consulte [Credenciales requeridas por el AWS CLI AWS SDK o el complemento SiGv4 de Amazon Keyspaces para los controladores de cliente de Cassandra](SigV4_credentials.md). Actualice la AWS región y el punto de enlace del servicio para Amazon Keyspaces según sea necesario. Para obtener información acerca de más puntos de conexión del servicio, consulte [Puntos de conexión de servicio para Amazon Keyspaces](programmatic.endpoints.md). Sustituya la ubicación, el nombre y la contraseña del almacén de confianza por los suyos propios.

      ```
      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. **Agregue la dependencia del módulo STS.**

      Esto añade la posibilidad de utilizar una `WebIdentityTokenCredentialsProvider` que devuelva las AWS credenciales que la aplicación debe proporcionar para que la cuenta de servicio pueda asumir la función de IAM. Para hacerlo, siga este ejemplo.

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

   1. **Agregue la dependencia de SigV4.**

       Este paquete implementa el complemento de autenticación SigV4 que se necesita para autenticarse en Amazon Keyspaces.

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

1. **Agregue la dependencia de registro.**

    Sin registros, es imposible solucionar los problemas de conexión. En este tutorial, utilizamos `slf4j` como marco de registro y empleamos `logback.xml` para almacenar la salida del registro. Establecemos el nivel de registro en `debug` para establecer la conexión. Puede utilizar el siguiente ejemplo para agregar la dependencia.

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

   Puede utilizar el siguiente fragmento de código para configurar el registro.

   ```
   <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>
   ```
**nota**  
El nivel de `debug` es necesario para investigar los errores de conexión. Una vez que se haya conectado correctamente a Amazon Keyspaces desde su aplicación, podrá cambiar el nivel de registro a `info` o `warning` según sea necesario. 

# Paso 3: creación de la imagen de la aplicación y subida del archivo de Docker a su repositorio de Amazon ECR
<a name="EKS-tutorial-step3"></a>

En este paso, compilará la aplicación de ejemplo, creará una imagen de Docker y enviará la imagen a su repositorio de Amazon ECR.

**Desarrollo de su aplicación, creación de una imagen de Docker y envío a Amazon Elastic Container Registry**

1. Establezca las variables de entorno para la compilación que se definan en su Región de AWS. En los ejemplos, sustituya las regiones por las suyas propias.

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

1. Compile una aplicación con Apache Maven versión 3.6.3 o superior mediante el siguiente comando.

   ```
   mvn clean install
   ```

   Esto crea un archivo `JAR` con todas las dependencias incluidas en el directorio `target`.

1. Recupere el URI del repositorio de ECR que necesita para el próximo paso con el siguiente comando. Asegúrese de actualizar la región y de poner la que ha estado utilizando.

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

   El resultado debe tener el aspecto del siguiente ejemplo.

   ```
   "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. Desde el directorio raíz de la aplicación, cree la imagen de Docker utilizando el URI del repositorio del último paso. Modifique el archivo de Docker según sea necesario. En el comando build, asegúrese de reemplazar su ID de cuenta y configurarlo en la región en la Región de AWS que se `my-ecr-repository` encuentra el repositorio de Amazon ECR. 

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

1. Recupere un token de autenticación para enviar la imagen de Docker a Amazon ECR. Puede hacerlo con el siguiente comando.

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

1. En primer lugar, compruebe si hay imágenes existentes en su repositorio de Amazon ECR. Puede utilizar el siguiente comando.

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

   Después, envíe la imagen de Docker al repositorio. Puede utilizar el siguiente comando.

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

# Paso 4: implementación de la aplicación en Amazon EKS y escritura de los datos en la tabla
<a name="EKS-tutorial-step4"></a>

En este paso del tutorial, configurará la implementación de Amazon EKS para su aplicación y confirmará que la aplicación se está ejecutando y que puede conectarse a Amazon Keyspaces.

Para implementar una aplicación en Amazon EKS, debe configurar todos los ajustes pertinentes en un archivo llamado `deployment.yaml`. A continuación, Amazon EKS utiliza este archivo para implementar la aplicación. Los metadatos del archivo deben contener la siguiente información:
+ **Nombre de la aplicación**: el nombre de la aplicación. Para este tutorial, utilizaremos `my-keyspaces-app`.
+ **Espacio de nombres de Kubernetes**: el espacio de nombres del clúster de Amazon EKS. Para este tutorial, utilizaremos `my-eks-namespace`.
+ **Nombre de cuenta de servicio de Amazon EKS**: el nombre de la cuenta de servicio de Amazon EKS. Para este tutorial, utilizaremos `my-eks-serviceaccount`.
+ **Nombre de imagen:** el nombre de la imagen de la aplicación. Para este tutorial, utilizaremos `my-keyspaces-app`.
+ **URI de imagen**: el URI de imagen de Docker de Amazon ECR.
+  **AWS ID de cuenta: su ID** AWS de cuenta.
+ **ARN del rol de IAM**: el ARN del rol de IAM creado para que lo asuma la cuenta de servicio. Para este tutorial, utilizaremos `my-iam-role`.
+ **Región de AWS del clúster de Amazon EKS** en el Región de AWS que creó su clúster de Amazon EKS.

En este paso, implementará y ejecutará la aplicación que se conecta a Amazon Keyspaces y que escribe datos en la tabla.

1. Configure el archivo `deployment.yaml`. Debe sustituir los siguientes valores:
   + `name`
   + `namespace`
   + `serviceAccountName`
   + `image`
   + `AWS_ROLE_ARN value`
   + La Región de AWS entrada `CASSANDRA_HOST`
   + `AWS_REGION`

   Puede utilizar el siguiente archivo como ejemplo.

   ```
   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. Implemente `deployment.yaml`.

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

   La salida debería tener este aspecto.

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

1. Compruebe el estado del pod en el espacio de nombres del clúster de Amazon EKS. 

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

   La salida debe ser similar al siguiente ejemplo.

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

   Para obtener más detalles, puede usar el comando siguiente.

   ```
   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. Compruebe los registros del pod para confirmar que la aplicación se esté ejecutando y que se pueda conectar a la tabla de Amazon Keyspaces. Puede hacerlo con el siguiente comando. Asegúrese de reemplazar el nombre de su implementación.

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

   Debería poder ver las entradas del registro de la aplicación que confirman la conexión a Amazon Keyspaces, como en el ejemplo siguiente.

   ```
   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. Ejecute la siguiente consulta de CQL en la tabla de Amazon Keyspaces para confirmar que se ha escrito una fila de datos en la tabla:

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

   Debería ver los siguientes datos de salida:

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

# Paso 5: (opcional) eliminación
<a name="EKS-tutorial-step5"></a>

Siga estos pasos para eliminar todos los recursos que ha creado en este tutorial.

**Eliminación de los recursos creados en este tutorial**

1. Elimine su implementación. Puede utilizar el siguiente comando para hacerlo.

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

1. Elimine el clúster de Amazon EKS y todos los pods que contiene. Esto también elimina los recursos relacionados, como la cuenta de servicio y el proveedor de identidades de OIDC. Puede utilizar el siguiente comando para hacerlo.

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

1. Elimine el rol de IAM utilizado para la cuenta de servicio de Amazon EKS con permisos de acceso a Amazon Keyspaces. En primer lugar, debe eliminar la política administrada asociada al rol.

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

   A continuación, puede eliminar el rol con el siguiente comando.

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

   Para obtener más información, consulte [Eliminación de un rol de IAM (AWS CLI)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli) en la *Guía del usuario de IAM*. 

1. Elimine el repositorio de Amazon ECR, incluidas todas las imágenes almacenadas en él. Puede hacerlo con el siguiente comando.

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

   Tenga en cuenta que la marca `force` es necesaria para eliminar un repositorio que contenga imágenes. Para eliminar su imagen primero, puede utilizar el siguiente comando. 

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

   Para obtener más información, consulte [Eliminación de una imagen](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-delete-image) en la Guía del usuario de Amazon Elastic Container Registry.

1. Elimine el espacio de claves y la tabla de Amazon Keyspaces. Al eliminar el espacio de claves, se eliminan automáticamente todas las tablas de ese espacio de claves. Puede utilizar una de las siguientes opciones para ello.

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

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

   Para confirmar que el espacio de claves se ha eliminado, puede utilizar el siguiente comando.

   ```
   aws keyspaces list-keyspaces
   ```

   Para eliminar primero la tabla, puede utilizar el siguiente comando.

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

   Para confirmar que la tabla se ha eliminado, puede utilizar el siguiente comando.

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

   Para obtener más información, consulte [eliminación de un espacio de claves](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-keyspace.html) y [eliminación de una tabla](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-table.html) en la *Referencia de comandos de la AWS CLI *.

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

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

   Para verificar que sus espacios de claves se hayan eliminado, puede utilizar la siguiente instrucción.

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

   Su espacio de claves no debería aparecer en el resultado de esta instrucción. Tenga en cuenta que puede haber un retraso hasta que se eliminen los espacios de claves. Para obtener más información, consulte [DROP KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.drop).

   Para eliminar primero la tabla, puede utilizar el siguiente comando.

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

   Para confirmar que la tabla se ha eliminado, puede utilizar el siguiente comando.

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

   Su tabla no debería aparecer en el resultado de esta instrucción. Tenga en cuenta que puede haber un retraso hasta que se elimine la tabla. Para obtener más información, consulte [DROP TABLE](cql.ddl.table.md#cql.ddl.table.drop).

------