本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 教學課程：從託管在 Amazon 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. 在本教學課程稍後從在 Amazon EKS 中執行的容器化應用程式建立名稱為 的 Amazon Keyspaces 金鑰空間`aws`和名稱`user`為 的資料表。您可以使用 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 命令參考*》中的[建立金鑰空間](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-keyspace.html)和[建立資料表](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 執行個體。若要遵循本教學課程，而無需更新所有範例命令中的叢集名稱，`my-eks-cluster`請依照《[Amazon EKS 使用者指南》中的 Amazon EKS `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) 入門中的指示，使用名稱建立叢集。 **建立叢集時，請確認您的節點和兩個預設 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 Resource Name (ARN)，當您為服務帳戶建立信任政策時，需要在下一個步驟中使用它。

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

1. 為 Amazon EKS 叢集建立服務帳戶。服務帳戶為在 *Pod* 中執行的程序提供身分。Pod 是最小且最簡單的 Kubernetes 物件，可用來部署容器化應用程式。接著，建立服務帳戶可擔任的 IAM 角色，以取得 資源的許可。您可以從已設定為使用服務帳戶的 AWS Pod 存取任何服務，該帳戶可擔任具有該服務存取許可的 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 傳回命令的 ARN`list-open-id-connect-providers`。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`的 Amazon EKS 服務帳戶的名稱建立 IAM 角色。將最後一個步驟中建立的信任政策檔案連接到角色。信任政策會指定 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 Resource Name (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. 確認 Amazon EKS 服務帳戶已標註 IAM 角色。

      ```
      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 模組相依性。**

      這會新增使用 的功能`WebIdentityTokenCredentialsProvider`，以傳回應用程式需要提供的 AWS 登入資料，以便服務帳戶可以擔任 IAM 角色。您可以根據下列範例執行此操作。

      ```
              <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 後，您可以`warning`視需要將記錄層級變更為 `info`或 。

# 步驟 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
   ```

   這會建立包含 `target`目錄中所有相依性`JAR`的檔案。

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，並將 設定為 `my-ecr-repository` Amazon ECR 儲存庫所在的 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`
   +  AWS 區域 中的 `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. 檢查 Pod 的日誌，以確認您的應用程式正在執行，並可以連線至您的 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 命令參考*》中的[刪除金鑰空間](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-keyspace.html)和[刪除資料表](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)。

------