As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Tutorial: Conecte-se a partir de um aplicativo em contêiner hospedado no Amazon Elastic Kubernetes Service Amazon Elastic Kubernetes Service
<a name="EKS-tutorial"></a>

Esse tutorial esclarece as etapas necessárias para configurar um cluster do Amazon Elastic Kubernetes Service (Amazon EKS) para receber um aplicativo em contêiner que se conecta ao Amazon Keyspaces usando autenticação SigV4.

O Amazon EKS é um serviço gerenciado que elimina a necessidade de instalar, operar e manter um ambiente de gerenciamento do Kubernetes próprio. O [Kubernetes](https://kubernetes.io/docs/concepts/overview/) é um sistema de código aberto que automatiza o gerenciamento, a ajuste de escala e a implantação de aplicações em contêineres.

O tutorial fornece step-by-step orientação para configurar, criar e implantar um aplicativo Java em contêiner no Amazon EKS. Na última etapa, você executa o aplicativo para gravar dados em uma tabela do Amazon Keyspaces.

**Topics**
+ [Pré-requisitos para conexão do Amazon EKS com o Amazon Keyspaces](EKS-tutorial-prerequisites.md)
+ [Etapa 1: configurar o cluster do Amazon EKS e configurar permissões do IAM](EKS-tutorial-step1.md)
+ [Etapa 2: configurar o aplicativo](EKS-tutorial-step2.md)
+ [Etapa 3: Crie a imagem do aplicativo e faça o upload do arquivo Docker no seu repositório Amazon ECR](EKS-tutorial-step3.md)
+ [Etapa 4: implantar o aplicativo no Amazon EKS e gravar dados na sua tabela](EKS-tutorial-step4.md)
+ [Etapa 5 (opcional): limpeza](EKS-tutorial-step5.md)

# Pré-requisitos para conexão do Amazon EKS com o Amazon Keyspaces
<a name="EKS-tutorial-prerequisites"></a>

**Crie os seguintes AWS recursos antes de começar com o tutorial**

1. Antes de começar este tutorial, siga as instruções AWS de configuração em[Como acessar o Amazon Keyspaces (para Apache Cassandra)](accessing.md). Essas etapas incluem a inscrição AWS e a criação de um diretor AWS Identity and Access Management (IAM) com acesso ao Amazon Keyspaces. 

1. Crie um keyspace do Amazon Keyspaces com o nome `aws` e uma tabela com o nome `user` no qual você pode gravar a partir do aplicativo em contêiner executado no Amazon EKS posteriormente neste tutorial. Você pode fazer isso com o AWS CLI ou usando`cqlsh`.

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

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

   Para confirmar que o espaço de chave foi criado, você pode usar o seguinte comando.

   ```
   aws keyspaces list-keyspaces
   ```

   Use o comando a seguir para criar a tabela:

   ```
   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 a tabela deve estar listada, você pode usar o seguinte comando:

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

   Para obter mais informações, consulte [criar espaço de chaves](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-keyspace.html) e [criar tabela](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-table.html) na *Referência de comandos 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 confirmar que a tabela deve estar listada, você pode usar a instrução a seguir.

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

   A tabela deve estar listada na saída desta instrução. Lembre-se que pode haver um atraso até que a tabela seja criada. Para obter mais informações, consulte [CRIAR TABELA](cql.ddl.table.md#cql.ddl.table.create).

------

1. Crie um cluster Amazon EKS com um tipo de nó **Fargate - Linux**. O Fargate é um mecanismo de computação sem servidor que permite a implantação de pods do Kubernetes sem gerenciar instâncias do Amazon EC2. Para seguir este tutorial sem precisar atualizar o nome do cluster em todos os comandos de exemplo, crie um cluster com o nome `my-eks-cluster` seguindo as instruções em [Introdução ao Amazon EKS, `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) no *Guia do usuário do Amazon EKS*. Quando seu cluster for criado, verifique se seus nós e os dois pods padrão estão funcionando e saudáveis. Você pode fazer isso com o comando a seguir:

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

   Você deverá ver algo semelhante ao resultado a seguir.

   ```
   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. Instalar o Docker. Para instruções sobre a instalação do Docker em uma instância do Amazon EC2, consulte [Instalação do Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#getting-started-cli-prereqs) no Guia do usuário do Amazon Elastic Container Registry. 

   O Docker está disponível em muitos sistemas operacionais diferentes, incluindo a maioria das distribuições modernas do Linux, como o Ubuntu e até no MacOS e no Windows. Para obter mais informações sobre como instalar o Docker no seu sistema operacional, consulte o [Guia de instalação do Docker](https://docs.docker.com/engine/install/#installation). 

1. Crie um repositório do Amazon ECR. O Amazon ECR é um serviço AWS gerenciado de registro de imagens de contêineres que você pode usar com sua CLI preferida para enviar, extrair e gerenciar imagens do Docker. Para obter mais informações sobre os repositórios do Amazon ECR, consulte o [Guia do usuário do Amazon Elastic Container Registry](https://docs.aws.amazon.com/AmazonECR/latest/userguide/). É possível usar o seguinte comando para criar um repositório com o nome `my-ecr-repository`.

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

Depois de concluir as etapas de pré-requisito, vá para [Etapa 1: configurar o cluster do Amazon EKS e configurar permissões do IAM](EKS-tutorial-step1.md).

# Etapa 1: configurar o cluster do Amazon EKS e configurar permissões do IAM
<a name="EKS-tutorial-step1"></a>

**Configure o cluster do Amazon EKS e crie os recursos do IAM necessários para permitir que uma conta de serviço do Amazon EKS se conecte à sua tabela do Amazon Keyspaces**

1. Crie um provedor Open ID Connect (OIDC) para o cluster do Amazon EKS. Isso é necessário para usar perfis do IAM em contas de serviço. Para obter mais informações sobre provedores OIDC e como criá-los, consulte [Criação de um provedor IAM OIDC para seu cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) no *Guia do usuário do Amazon EKS*.

   1. Crie o provedor de identidade OIDC do IAM para o cluster com o comando a seguir. Este exemplo pressupõe que o nome do cluster `my-eks-cluster`. Se você tiver um cluster com um nome diferente, lembre-se de atualizar o nome em todos os comandos futuros.

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

   1. Confirme se o provedor de identidade OIDC foi registrado com IAM com o comando a seguir.

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

      A saída deve ser semelhante a esta. Anote o nome do recurso da Amazon (ARN) no OIDC, será necessário na próxima etapa ao criar uma política de confiança para a conta de serviço.

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

1. Crie uma conta de serviço para o cluster do Amazon EKS. Contas de serviço fornecem uma identidade para processos executados em um *Pod*. Um pod é o menor e mais simples objeto Kubernetes que você pode usar para implantar um aplicativo em contêiner. Em seguida, crie um perfil do IAM que a conta de serviço possa assumir para obter permissões para recursos. Você pode acessar qualquer AWS serviço de um pod que tenha sido configurado para usar uma conta de serviço que possa assumir uma função do IAM com permissões de acesso a esse serviço.

   1. Crie um novo namespace para a conta de serviço. Um namespace ajuda a isolar os recursos de cluster criados para este tutorial. Você pode criar um namespace usando o seguinte comando:

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

   1. Para usar um namespace personalizado, você precisa associá-lo a um perfil do Fargate. O código a seguir é um exemplo disso.

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

   1. Crie uma conta de serviço com o nome `my-eks-serviceaccount` no namespace `my-eks-namespace` do seu cluster Amazon EKS usando o comando a seguir.

      ```
      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. Execute o comando a seguir para criar um arquivo de política de confiança que instrua o perfil do IAM a confiar em sua conta de serviço. Essa relação de confiança é necessária antes que uma entidade principal possa assumir uma função. Você precisa realizar as seguintes edições no arquivo:
      + Para o `Principal`, insira o ARN que o IAM retornou ao comando `list-open-id-connect-providers`. O ARN contém o número da sua conta e a região.
      + Na `condition` declaração, substitua o Região da AWS e o ID do OIDC.
      + Confirme se o nome e o namespace da conta de serviço estão corretos.

      É necessário anexar o arquivo de política de confiança na etapa a seguir ao criar o perfil do 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: É possível também adicionar várias entradas nas condições `StringEquals` ou `StringLike` abaixo para permitir que várias contas de serviço ou namespaces assumam o perfil. Para permitir que sua conta de serviço assuma um perfil do IAM em uma conta AWS diferente, consulte [Permissões do IAM entre contas](https://docs.aws.amazon.com/eks/latest/userguide/cross-account-access.html) no *Guia do usuário do Amazon EKS*.

1. Crie um perfil do IAM com o nome `my-iam-role` a ser assumido pela conta de serviço do Amazon EKS. Anexe o arquivo de política de confiança criado na etapa anterior ao perfil. A política de confiança especifica a conta de serviço e o provedor do OIDC em que o perfil do IAM pode confiar. 

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

1. Atribua as permissões da perfil do IAM ao Amazon Keyspaces anexando uma política de acesso. 

   1. Anexe uma política de acesso para definir as ações que o perfil do IAM pode realizar em recursos específicos do Amazon Keyspaces. Para este tutorial, usamos a política AWS gerenciada`AmazonKeyspacesFullAccess`, porque nosso aplicativo gravará dados na sua tabela do Amazon Keyspaces. No entanto, como prática recomendada, é recomendável criar políticas de acesso personalizadas que implementem o princípio de privilégios mínimos. Para obter mais informações, consulte [Como o Amazon Keyspaces funciona com o 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 se a política foi anexada com sucesso ao perfil do IAM com a seguinte declaração.

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

      A saída deve ser algo parecido com isso.

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

   1. Sinalize a conta de serviço com o nome do recurso da Amazon (ARN) do perfil do IAM que pode ser assumido. Certifique-se de atualizar o perfil ARN com seu ID da conta.

      ```
      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 se o perfil do IAM e a conta de serviço estão configurados corretamente.

   1. Confirme se a política de confiança do perfil do IAM está configurada corretamente com a seguinte instrução.

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

      A saída deve ser semelhante a esta.

      ```
      {
          "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 a conta do serviço do Amazon EKS esteja anotada com o perfil do IAM.

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

      A saída deve ser semelhante a esta.

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

Depois de criar a conta de serviço do Amazon EKS, o perfil do IAM e configurar os relacionamentos e permissões necessários, prossiga para[Etapa 2: configurar o aplicativo](EKS-tutorial-step2.md).

# Etapa 2: configurar o aplicativo
<a name="EKS-tutorial-step2"></a>

Nesta etapa, você cria seu aplicativo para se conectar ao Amazon Keyspaces usando o plugin SigV4. Você pode visualizar e baixar o exemplo de aplicativo Java no repositório de código de exemplo do Amazon Keyspaces no [Github](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/eks). Ou você pode acompanhar usando seu próprio aplicativo, certificando-se de concluir todas as etapas de configuração.

**Configure seu aplicativo e adicione as dependências necessárias.**

1. Você pode baixar o aplicativo Java de exemplo clonando o repositório Github usando o comando a seguir.

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

1. Depois de baixar o repositório do Github, descompacte o arquivo baixado e navegue até o diretório `resources` do arquivo `application.conf`.

   1. **Configuração do aplicativo**

      Nesta etapa, você configura o plug-in de autenticação SigV4. Você poderá usar o seguinte exemplo em seu aplicativo. Se ainda não tiver feito isso, você precisa gerar suas chaves de acesso do IAM (um ID de chave de acesso e uma chave de acesso secreta) e salvá-las em seu arquivo de AWS configuração ou como variáveis de ambiente. Para obter instruções detalhadas, consulte [Credenciais exigidas pelo AWS CLI AWS SDK ou pelo plug-in SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra](SigV4_credentials.md). Atualize a AWS região e o endpoint de serviço do Amazon Keyspaces conforme necessário. Para mais endpoints de serviço, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md). Substitua a localização da loja confiável, o nome da loja confiável e a senha da loja confiável pelos seus.

      ```
      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. **Adicione a dependência do módulo STS.**

      Isso adiciona a capacidade de usar um `WebIdentityTokenCredentialsProvider` que retorna AWS as credenciais que o aplicativo precisa fornecer para que a conta de serviço possa assumir a função do IAM. É possível fazer isso com base no exemplo a seguir.

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

   1. **Adicione a dependência SigV4.**

       Este pacote implementa o plug-in de autenticação SigV4 que é necessário para se autenticar no Amazon Keyspaces

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

1. **Adicionar dependência de registro.**

    Sem registros, é impossível solucionar problemas de conexão. Neste tutorial, usamos `slf4j` como estrutura de registro e `logback.xml` para armazenar a saída do registro. Definimos o nível de registro em `debug` para estabelecer a conexão. É possível usar o seguinte comando para adicionar a dependência.

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

   É possível usar o seguinte snippet de código para configurar o 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**  
O nível `debug` é necessário para investigar falhas de conexão. Depois de se conectar com sucesso ao Amazon Keyspaces a partir do seu aplicativo, você pode alterar o nível de registro para `info` ou `warning` conforme necessário. 

# Etapa 3: Crie a imagem do aplicativo e faça o upload do arquivo Docker no seu repositório Amazon ECR
<a name="EKS-tutorial-step3"></a>

Nesta etapa, você compila o aplicativo de exemplo, cria uma imagem do Docker e envia a imagem para o seu repositório Amazon ECR.

**Crie seu aplicativo, crie uma imagem do Docker e envie-a para o Amazon Elastic Container Registry**

1. Defina variáveis de ambiente para a compilação que definem sua Região da AWS. Nos exemplos, substitua as Regiões com suas próprias informações.

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

1. Compile seu aplicativo com o Apache Maven versão 3.6.3 ou superior usando o comando a seguir.

   ```
   mvn clean install
   ```

   Isso cria um arquivo `JAR` com todas as dependências incluídas no diretório `target`.

1. Recupere o URI do repositório ECR necessário para a próxima etapa com o comando a seguir. Certifique-se de atualizar a região para a que você está usando.

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

   A saída deve ser como o exemplo a seguir:

   ```
   "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. No diretório raiz do aplicativo, crie a imagem do Docker usando o URI do repositório da última etapa. Modifique o arquivo Docker conforme necessário. No comando build, certifique-se de substituir o ID da sua conta e configurá-lo Região da AWS para a região em que o repositório do Amazon ECR `my-ecr-repository` está localizado. 

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

1. Recupere um token de autenticação para inserir a imagem do Docker no Amazon ECR. Você pode fazer isso com o comando a seguir:

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

1. Primeiro, verifique se há imagens existentes em seu repositório Amazon ECR. É possível usar o seguinte comando.

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

   Então, insira a imagem do Docker no repositório. É possível usar o seguinte comando.

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

# Etapa 4: implantar o aplicativo no Amazon EKS e gravar dados na sua tabela
<a name="EKS-tutorial-step4"></a>

Nesta etapa do tutorial, você configura a implantação do Amazon EKS para seu aplicativo e confirma se o aplicativo está em execução e pode se conectar ao Amazon Keyspaces.

Para implantar um aplicativo no Amazon EKS, você precisa definir todas as configurações relevantes em um arquivo chamado `deployment.yaml`. Esse arquivo é então usado pelo Amazon EKS para implantar o aplicativo. Os metadados no arquivo devem conter as informações a seguir:
+ **Nome do aplicativo**: o nome do aplicativo. Para este tutorial, usamos `my-keyspaces-app`.
+ **Namespace do Kubernetes** O namespace do cluster do Amazon EKS. Para este tutorial, usamos `my-eks-namespace`.
+ **Nome da conta de serviço Amazon EKS** o nome da conta de serviço do Amazon EKS. Para este tutorial, usamos `my-eks-serviceaccount`.
+ **nome da imagem** o nome da imagem do aplicativo. Para este tutorial, usamos `my-keyspaces-app`.
+ URI da imagem o URI da imagem do Docker do Amazon ECR.
+  **AWS ID da conta** sua ID AWS da conta.
+ **ARN do perfil do IAM** o ARN do perfil do IAM criado para ser assumido pela conta de serviço. Para este tutorial, usamos `my-iam-role`.
+ **Região da AWS do cluster Amazon EKS** em Região da AWS que você criou seu cluster Amazon EKS.

Nesta etapa, você implanta executa o aplicativo que se conecta ao Amazon Keyspaces e grava dados em uma tabela.

1. Configure o arquivo `deployment.yaml`. Será necessário substituir os valores a seguir:
   + `name`
   + `namespace`
   + `serviceAccountName`
   + `image`
   + `AWS_ROLE_ARN value`
   + A Região da AWS entrada `CASSANDRA_HOST`
   + `AWS_REGION`

   Você pode usar o seguinte arquivo como exemplo.

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

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

   A saída deve ser algo parecido com isso.

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

1. Verifique o status do pod no seu namespace do cluster Amazon EKS. 

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

   A saída deve ser semelhante a este exemplo:

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

   Para mais detalhes, é possível usar o seguinte comando:

   ```
   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. Verifique os registros do pod para confirmar se seu aplicativo está em execução e pode se conectar à sua tabela do Amazon Keyspaces. Você pode fazer isso com o comando a seguir: Certifique-se de substituir pelo nome da sua implantação.

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

   Você deve conseguir ver as entradas de registro do aplicativo confirmando a conexão com o Amazon Keyspaces, como no exemplo abaixo.

   ```
   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. Execute a seguinte consulta CQL em sua tabela do Amazon Keyspaces para confirmar que uma linha de dados foi gravada em sua tabela:

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

   A seguinte saída deverá ser mostrada:

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

# Etapa 5 (opcional): limpeza
<a name="EKS-tutorial-step5"></a>

Siga essas etapas para remover os recursos criados neste tutorial.

**Remova recursos criados neste tutorial**

1. Exclua sua implantação. É possível usar o seguinte comando para fazer isso:

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

1. Exclua o cluster Amazon EKS e todos os pods contidos nele. Isso também exclui recursos relacionados, como a conta de serviço e o provedor de identidade OIDC. É possível usar o seguinte comando para fazer isso:

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

1. Exclua o perfil do IAM usado para a conta de serviço Amazon EKS com permissões de acesso ao Amazon Keyspaces. Primeiro, você precisa remover a política gerenciada anexada ao perfil.

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

   Em seguida, você pode usar o seguinte comando para excluir o perfil.

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

   Para obter mais informações, consulte [Exclusão de um perfil do IAM (AWS CLI)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli) no *Guia do usuário do IAM*. 

1. Exclua o repositório Amazon ECR, incluindo todas as imagens armazenadas nele. É possível fazer isso usando o comando a seguir.

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

   Note que a bandeira `force` é necessária para excluir um repositório que contém imagens. Para excluir sua imagem antes, você pode fazer isso executando o seguinte comando. 

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

   Para obter mais informações, consulte [Excluir uma imagem](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-delete-image) no Guia do usuário do Amazon Elastic Container Registry.

1. Exclua o espaço de chaves e a tabela do Amazon Keyspaces. A exclusão do espaço de chave exclui automaticamente todas as tabelas desse espaço de chave. Você pode usar uma das opções a seguir para fazê-lo:

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

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

   Para confirmar que o catálogo do espaço de chave foi excluído, você pode usar o seguinte comando.

   ```
   aws keyspaces list-keyspaces
   ```

   Para excluir sua tabela antes, é possível usar o seguinte comando.

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

   Para confirmar que a tabela foi excluída, você pode usar o seguinte comando.

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

   Para obter mais informações, consulte [excluir espaço de chave](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-keyspace.html) e [excluir tabela](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-table.html) na *Referência de comandos AWS CLI *.

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

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

   Para confirmar que o espaço de chave existe, você pode usar a instrução a seguir.

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

   Seu espaço de chave não deve ser listado na saída desta instrução. Note que pode haver um atraso até a chave de espaço ser excluída. Para obter mais informações, consulte [DESCARTAR ESPAÇO DE CHAVES](cql.ddl.keyspace.md#cql.ddl.keyspace.drop).

   Para excluir sua tabela antes, é possível usar o seguinte comando.

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

   Para confirmar que a tabela foi excluída, você pode usar o seguinte comando.

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

   Sua tabela não deve estar listada na saída desta instrução. Note que pode haver um atraso até a tabela ser excluída. Para obter mais informações, consulte [DESCARTAR TABELA](cql.ddl.table.md#cql.ddl.table.drop).

------