本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 教程：从托管在亚马逊 Elastic Kubernetes Service 上的容器化应用程序进行连接
<a name="EKS-tutorial"></a>

本教程将引导您完成设置 Amazon Elastic Kubernetes Service（Amazon EKS）集群所需的步骤，以便托管使用 SigV4 身份验证连接到 Amazon Keyspaces 的容器化应用程序。

Amazon EKS 是一项托管服务，无需安装、操作和维护自己的 Kubernetes 控制面板。[Kubernetes](https://kubernetes.io/docs/concepts/overview/) 是一个开源系统，可以实现容器化应用程序的管理、扩缩和部署自动化。

本教程提供了 step-by-step有关配置、构建容器化 Java 应用程序并将其部署到 Amazon EKS 的指导。在最后一步中，运行应用程序将数据写入 Amazon Keyspaces 表。

**Topics**
+ [从 Amazon EKS 连接到 Amazon Keyspaces 的先决条件](EKS-tutorial-prerequisites.md)
+ [第 1 步：配置 Amazon EKS 集群并设置 IAM 权限](EKS-tutorial-step1.md)
+ [第 2 步：配置应用程序](EKS-tutorial-step2.md)
+ [第 3 步：创建应用程序映像并将 Docker 文件上传到 Amazon ECR 存储库](EKS-tutorial-step3.md)
+ [第 4 步：将应用程序部署到 Amazon EKS 并将数据写入表中](EKS-tutorial-step4.md)
+ [第 5 步：（可选）清理](EKS-tutorial-step5.md)

# 从 Amazon EKS 连接到 Amazon Keyspaces 的先决条件
<a name="EKS-tutorial-prerequisites"></a>

**在开始学习本教程之前，请先创建以下 AWS 资源**

1. 在开始本教程之前，请按照中的 AWS 设置说明进行操作[访问 Amazon Keyspaces（Apache Cassandra 兼容）](accessing.md)。这些步骤包括注册 AWS 和创建有权访问 Amazon Keyspaces 的 AWS Identity and Access Management (IAM) 委托人。

1. 在本教程的后面部分中，创建一个名为 `aws` 的 Amazon Keyspaces 键空间以及一个名为 `user` 的表，您可以从在 Amazon EKS 中运行的容器化应用程序中写入该键空间和表。您可以使用 AWS CLI 或来执行此操作`cqlsh`。

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

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

   要确认键空间已创建，您可以使用以下命令。

   ```
   aws keyspaces list-keyspaces
   ```

   要创建表，您可以使用以下命令。

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

   要确认表已创建，您可以使用以下命令。

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

   有关更多信息，请参阅《AWS CLI 命令参考》**中的 [create-keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-keyspace.html) 和 [create-table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-table.html)。

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

   要确认表已创建，您可以使用以下语句。

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

   表应在此语句的输出中列出。请注意，表创建过程中可能会有延迟。有关更多信息，请参阅 [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create)。

------

1. 创建一个节点类型为 **Fargate - Linux ** 的 Amazon EKS 集群。Fargate 是一种无服务器计算引擎，让您可以部署 Kubernetes 容器组（pod）而不用管理 Amazon EC2 实例。要遵循本教程，而不必更新所有示例命令中的集群名称，请按照《Amazon EKS 用户指南》**中[开始使用 Amazon EKS – `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) 里面的说明创建一个名为 `my-eks-cluster` 的集群。创建集群后，请验证您的节点和两个默认容器组（pod）是否正常运行。可使用以下命令执行此操作。

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

   您会可以看到类似于如下输出的内容。

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

1. 安装 Docker。有关如何在 Amazon EC2 实例上安装 Docker 的说明，请参阅《Amazon Elastic Container Registry 用户指南》中的[安装 Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#getting-started-cli-prereqs)。

   Docker 适用于许多不同的操作系统，包括大多数现代 Linux 分发版 (如 Ubuntu) 甚至 MacOS 和 Windows。有关如何在特定的操作系统上安装 Docker 的更多信息，请转到 [Docker 安装指南](https://docs.docker.com/engine/install/#installation)。

1. 创建 Amazon ECR 存储库。Amazon ECR 是一项 AWS 托管容器镜像注册服务，您可以将其与首选 CLI 配合使用，以推送、拉取和管理 Docker 镜像。有关 Amazon ECR 存储库的更多信息，请参阅 [Amazon Elastic Container Registry 用户指南](https://docs.aws.amazon.com/AmazonECR/latest/userguide/)。您可以使用以下命令创建名为 `my-ecr-repository` 的存储库。

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

完成先决条件步骤后，继续执行[第 1 步：配置 Amazon EKS 集群并设置 IAM 权限](EKS-tutorial-step1.md)。

# 第 1 步：配置 Amazon EKS 集群并设置 IAM 权限
<a name="EKS-tutorial-step1"></a>

**配置 Amazon EKS 集群并创建允许 Amazon EKS 服务账户连接到 Amazon Keyspaces 表所需的 IAM 资源**

1. 为 Amazon EKS 集群创建 Open ID Connect（OIDC）身份提供者。需要执行此操作才能将 IAM 角色用于服务账户。有关 OIDC 身份提供者以及如何创建它们的更多信息，请参阅《Amazon EKS 用户指南》中的[为集群创建 IAM OIDC 提供商](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html)。

   1. 使用以下命令为您的集群创建 IAM OIDC 身份提供商。此示例假定集群名称为 `my-eks-cluster`。如果集群名称不同，请务必在所有未来的命令中更新名称。

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

   1. 使用以下命令，确认 OIDC 身份提供者已在 IAM 中注册。

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

      输出应如下所示：记下 OIDC 的 Amazon 资源名称（ARN），下一步为服务账户创建信任策略时需要该名称。

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

1. 为 Amazon EKS 集群创建服务账户。服务账户为在*容器组（pod）*中运行的进程提供身份。容器组是最小、最简单的 Kubernetes 对象，可以用来部署容器化应用程序。接下来，创建一个 IAM 角色，服务账户可代入该角色来获取资源权限。您可以从 Pod 访问任何 AWS 服务，该服务账号已配置为使用服务账号，该账号可以代入具有该服务访问权限的 IAM 角色。

   1. 为服务账户创建新的命名空间。命名空间有助于隔离为本教程创建的集群资源。您可以使用以下命令创建新的命名空间。

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

   1. 要使用自定义命名空间，必须将其与 Fargate 配置文件关联。下面是一个代码示例。

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

   1. 使用以下命令在 Amazon EKS 集群的命名空间 `my-eks-namespace` 中创建一个名为 `my-eks-serviceaccount` 的服务账户。

      ```
      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. 运行以下命令来创建信任策略文件，指示 IAM 角色信任您的服务账户。主体必须先建立这种信任关系，然后才能代入角色。需要对文件进行以下编辑：
      + 对于 `Principal`，输入 IAM 返回给 `list-open-id-connect-providers` 命令的 ARN。ARN 包含您的账号和区域。
      + 在`condition`语句中，替换 AWS 区域 和 OIDC ID。
      + 确认服务账户名称和命名空间正确无误。

      在下一步中创建 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
      ```

      可选：您还可以在 `StringEquals` 和 `StringLike` 条件中添加多个条目，以允许多个服务账户或命名空间代入角色。要允许您的服务账户在其他 AWS 账户中代入 IAM 角色，请参阅《Amazon EKS 用户指南》**中的[跨账户 IAM 权限](https://docs.aws.amazon.com/eks/latest/userguide/cross-account-access.html)。

1. 创建一个名为 `my-iam-role` 的 IAM 角色，供 Amazon EKS 服务账户代入。将上一步中创建的信任策略文件附加到该角色。信任策略指定了 IAM 角色可以信任的服务账户和 OIDC 身份提供者。

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

1. 通过附加访问策略向 IAM 角色分配 Amazon Keyspaces 权限。

   1. 附加访问策略以定义 IAM 角色可以对特定 Amazon Keyspaces 资源执行的操作。在本教程中，我们使用 AWS 托管策略`AmazonKeyspacesFullAccess`，因为我们的应用程序将向您的 Amazon Keyspaces 表中写入数据。但是，作为最佳实践，建议创建实现最低权限原则的自定义访问策略。有关更多信息，请参阅 [Amazon Keyspaces 如何与 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
      ```

      使用以下语句确认策略已成功附加到 IAM 角色。

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

      输出应如下所示：

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

   1. 使用服务账户可以代入的 IAM 角色的 Amazon 资源名称（ARN）为服务账户添加注释。确保使用您的账户 ID 更新角色 ARN。

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

1. 确认 IAM 角色和服务账户均已正确配置。

   1. 使用以下语句确认 IAM 角色的信任策略已正确配置。

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

      输出应如下所示：

      ```
      {
          "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. 确认已使用 IAM 角色为 Amazon EKS 服务账户添加注释。

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

      输出应如下所示：

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

创建 Amazon EKS 服务账户、IAM 角色并配置所需的关系和权限后，请继续[第 2 步：配置应用程序](EKS-tutorial-step2.md)。

# 第 2 步：配置应用程序
<a name="EKS-tutorial-step2"></a>

在此步骤中，您将构建使用 SigV4 插件连接到 Amazon Keyspaces 的应用程序。您可以从 [Github](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/eks) 上的 Amazon Keyspaces 示例代码存储库中查看和下载示例 Java 应用程序。或者，您可以使用自己的应用程序继续操作，确保完成所有配置步骤。

**配置您的应用程序并添加所需的依赖关系。**

1. 您可以使用以下命令克隆 Github 存储库，从而下载示例 Java 应用程序。

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

1. 下载 Github 存储库后，解压缩下载的文件并导航到 `application.conf` 文件的 `resources` 目录。

   1. **应用程序配置**

      在此步骤中，您将配置 SigV4 身份验证插件。您可以在应用程序中使用以下示例。如果您尚未这样做，则需要生成 IAM 访问密钥（访问密钥 ID 和私有访问密钥），并将其保存在 AWS 配置文件中或作为环境变量保存。有关详细说明，请参阅[适用于 Cassandra AWS CLI客户端驱动程序的、 AWS 软件开发工具包或 Amazon Keyspaces Sigv4 插件所需的凭证](SigV4_credentials.md)。根据需要更新 Amazon Keyspaces 的 AWS 区域和服务终端节点。如需了解更多服务端点，请参阅[Amazon Keyspaces 的服务端点](programmatic.endpoints.md)。将信任库位置、信任库名称和信任库密码替换为您自己的对应项。

      ```
      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. **添加 STS 模块依赖关系。**

      这增加了使用返回应用程序需要提供的 AWS 证书的功能，以便服务账户可以担任 IAM 角色。`WebIdentityTokenCredentialsProvider`您可以根据以下示例执行这项操作。

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

   1. **添加 SigV4 依赖关系。**

       此软件包实现了向 Amazon Keyspaces 进行身份验证所需的 SigV4 身份验证插件

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

1. **添加日志记录依赖项。**

    没有日志，就无法对连接问题进行排查。在本教程中，我们使用 `slf4j` 作为日志记录框架，并使用 `logback.xml` 存储日志输出。我们将日志记录级别设置为 `debug` 以建立连接。您可以使用以下示例来添加依赖关系。

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

   您可以使用以下代码段来配置日志记录。

   ```
   <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>
   ```
**注意**  
`debug` 级别是调查连接失败所必需的。通过应用程序成功连接到 Amazon Keyspaces 后，您可以根据需要将日志记录级别更改为 `info` 或 `warning`。

# 第 3 步：创建应用程序映像并将 Docker 文件上传到 Amazon ECR 存储库
<a name="EKS-tutorial-step3"></a>

在此步骤中，需要编译示例应用程序，构建 Docker 映像，然后将该映像推送到 Amazon ECR 存储库。

**构建应用程序，构建 Docker 映像，然后将其提交到 Amazon Elastic Container Registry**

1. 为用于定义您 AWS 区域的内部版本设置环境变量。请将示例中的区域替换为您自己的区域。

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

1. 使用以下命令，通过 Apache Maven 3.6.3 或更高版本编译应用程序。

   ```
   mvn clean install
   ```

   这将创建 `JAR` 文件，其所有依赖项都包含在 `target` 目录中。

1. 使用以下命令检索下一步所需的 ECR 存储库 URI。请务必将区域更新为您一直在使用的区域。

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

   输出应与以下示例类似。

   ```
   "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. 使用上一步中的存储库 URI 从应用程序的根目录构建 Docker 映像。根据需要修改 Docker 文件。在构建命令中，请务必替换您的账户 ID，并将设置为 Amazon ECR 存储库`my-ecr-repository`所在的区域。 AWS 区域 

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

1. 检索身份验证令牌，将 Docker 映像推送到 Amazon ECR。可使用以下命令执行此操作。

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

1. 首先，检查 Amazon ECR 存储库中的现有映像。您可使用以下命令。

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

   然后，将 Docker 映像推送到存储库。您可使用以下命令。

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

# 第 4 步：将应用程序部署到 Amazon EKS 并将数据写入表中
<a name="EKS-tutorial-step4"></a>

在本教程的这一步中，需要为应用程序配置 Amazon EKS 部署，并确认应用程序正在运行且可以连接到 Amazon Keyspaces。

要将应用程序部署到 Amazon EKS，您需要在名为 `deployment.yaml` 的文件中配置所有相关设置。然后，Amazon EKS 将使用此文件来部署应用程序。该文件中的元数据应包含以下信息：
+ **应用程序名称**：应用程序的名称。在本教程中，我们使用 `my-keyspaces-app`。
+ **Kubernetes 命名空间**：Amazon EKS 集群的命名空间。在本教程中，我们使用 `my-eks-namespace`。
+ **Amazon EKS 服务账户名称**：Amazon EKS 服务账户的名称。在本教程中，我们使用 `my-eks-serviceaccount`。
+ **映像名称**：应用程序映像的名称。在本教程中，我们使用 `my-keyspaces-app`。
+ **映像 URI**：Amazon ECR 中的 Docker 映像 URI。
+  **AWS 账户 ID** 您的 AWS 账户 ID。
+ **IAM 角色 ARN**：创建供服务账户代入的 IAM 角色的 ARN。在本教程中，我们使用 `my-iam-role`。
+ **AWS 区域 在 AWS 区域 你创建 Amazon EKS 集群**的 Amazon EKS 集群中。

在此步骤中，您将部署并运行连接到 Amazon Keyspaces 的应用程序，并将数据写入表中。

1. 配置 `deployment.yaml` 文件。您需要替换以下值：
   + `name`
   + `namespace`
   + `serviceAccountName`
   + `image`
   + `AWS_ROLE_ARN value`
   + The AWS 区域 in `CASSANDRA_HOST`
   + `AWS_REGION`

   您可以使用以下文件作为示例。

   ```
   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. 部署 `deployment.yaml`。

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

   输出应如下所示：

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

1. 检查 Amazon EKS 集群命名空间中容器组（pod）的状态。

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

   输出应类似于以下示例：

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

   有关更多详细信息，您可使用以下命令。

   ```
   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. 查看容器组日志，确认您的应用程序正在运行且可以连接到 Amazon Keyspaces 表。可使用以下命令执行此操作。务必替换您的部署的名称。

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

   您应该能够看到确认连接到 Amazon Keyspaces 的应用程序日志条目，如下例所示。

   ```
   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. 对 Amazon Keyspaces 表运行以下 CQL 查询，确认表中已写入一行数据：

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

   您应看到以下输出：

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

# 第 5 步：（可选）清理
<a name="EKS-tutorial-step5"></a>

按照以下步骤删除本教程中创建的所有资源。

**删除本教程中创建的资源。**

1. 测试部署。您可以使用以下命令执行该操作。

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

1. 删除 Amazon EKS 集群以及其中包含的所有容器组（pod）。此操作还会删除相关资源，例如服务账户和 OIDC 身份提供者。您可以使用以下命令执行该操作。

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

1. 删除用于具有 Amazon Keyspaces 访问权限的 Amazon EKS 服务账户的 IAM 角色。首先，必须删除附加到该角色的托管式策略。

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

   然后您可以使用以下命令删除该角色。

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

   有关更多信息，请参阅《IAM 用户指南》**中的[删除 IAM 角色（AWS CLI）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli)。

1. 删除 Amazon ECR 存储库，包括存储在其中的所有映像。您可以使用以下命令执行这项操作。

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

   请注意，需要 `force` 标志才能删除包含映像的存储库。要先删除映像，您可以使用以下命令执行此项操作。

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

   有关更多信息，请参阅《Amazon Elastic Container Registry 用户指南》中的[删除映像](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-delete-image)。

1. 删除 Amazon Keyspaces 键空间和表。删除键空间会自动删除该键空间中的所有表。您可以使用以下任一选项来执行此操作。

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

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

   要确认键空间已删除，您可以使用以下命令。

   ```
   aws keyspaces list-keyspaces
   ```

   要先删除表，您可以使用以下命令。

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

   要确认表已删除，您可以使用以下命令。

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

   有关更多信息，请参阅《AWS CLI 命令参考》**中的 [delete-keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-keyspace.html) 和 [delete-table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-table.html)。

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

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

   要验证键空间是否已删除，您可以使用以下语句。

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

   键空间不应在此语句的输出中列出。请注意，在删除键空间的过程中，可能会有延迟。有关更多信息，请参阅 [DROP KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.drop)。

   要先删除表，您可以使用以下命令。

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

   要确认表已删除，您可以使用以下命令。

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

   表不应在此语句的输出中列出。请注意，删除表的过程中可能会有延迟。有关更多信息，请参阅 [DROP TABLE](cql.ddl.table.md#cql.ddl.table.drop)。

------