翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# チュートリアル: Amazon Elastic Kubernetes Service でホストされているコンテナ化されたアプリケーションから接続する
<a name="EKS-tutorial"></a>

このチュートリアルでは、SigV4 認証を使用して Amazon Keyspaces に接続するコンテナ化されたアプリケーションを、Amazon Elastic Kubernetes Service (Amazon EKS) クラスターでホストするために必要な設定手順を学びます。

Amazon EKS はマネージドサービスであるため、Kubernetes コントロールプレーンを自前でインストール、運用、メンテナンスする必要がありません。[Kubernetes](https://kubernetes.io/docs/concepts/overview/) は、コンテナ化されたアプリケーションのデプロイ、スケール、管理を自動化するためのオープンソースシステムです。

このチュートリアルでは、コンテナ化された 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)。これらのステップには、Amazon Keyspaces にアクセスできる AWS Identity and Access Management (IAM) プリンシパルへのサインアップ AWS と作成が含まれます。

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 はサーバーレスのコンピューティングエンジンです。Amazon EC2 インスタンスを管理することなく、Kubernetes ポッドをデプロイすることができます。このチュートリアルに実際に取り組む上で、すべてのコマンド例のクラスター名を変更しなくても済むように、「Amazon EKS ユーザーガイド**」の「[Amazon EKS – `eksctl` の使用を開始する](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)」の手順に従って、`my-eks-cluster` という名前のクラスターを作成しておきましょう。クラスターが作成されたら、ノードと 2 つのデフォルトのポッドが正常に実行されていることを確認します。それには、次のコマンドを使用します。

   ```
   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 はさまざまなオペレーティングシステムで使用できます。Ubuntu のような最新の Linux ディストリビューションや、 macOS や Windows でも使用できます。特定のオペレーティングシステムに Docker をインストールする方法の詳細については、[Docker インストールガイド](https://docs.docker.com/engine/install/#installation) を参照してください。

1. Amazon ECR リポジトリを作成します。Amazon ECR は、任意の CLI で Docker イメージをプッシュ、プル、管理するために使用できる AWS マネージドコンテナイメージレジストリサービスです。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 クラスターの OpenID 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 ID プロバイダーを作成します。この例では、クラスター名を `my-eks-cluster` としています。クラスターの名前が異なる場合は、以降のすべてのコマンドで名前を変更してください。

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

   1. 次のコマンドを使用して、OIDC ID プロバイダーが 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 クラスター用のサービスアカウントを作成します。サービスアカウントで、ポッド**で実行されるプロセス用のアイデンティティを用意できます。ポッドは、最小かつ最もシンプルな Kubernetes オブジェクトであり、コンテナ化されたアプリケーションをデプロイするために使用できます。次に、リソースへのアクセス許可を取得するためにサービスアカウントが引き受けることができる IAM ロールを作成します。その AWS サービスへのアクセス許可を持つ IAM ロールを引き受けることができるサービスアカウントを使用するように設定された Pod から任意のサービスにアクセスできます。

   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. Amazon EKS サービスアカウントが引き受ける IAM ロールを `my-iam-role` という名前で作成します。直前の手順で作成した信頼ポリシーファイルをロールにアタッチします。信頼ポリシーには、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 リソースに対して実行できるアクションを定義します。このチュートリアルでは、アプリケーションが Amazon Keyspaces テーブルにデータを書き込むため`AmazonKeyspacesFullAccess`、 AWS マネージドポリシー を使用します。ただし、ベストプラクティスとしては、最小特権の原則を実装したカスタムのアクセスポリシーを作成することをお勧めします。詳細については、「[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) を注釈として追加します。ロールの ARN にアカウント ID を反映してください。

      ```
      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 リポジトリをダウンロードしたら、ダウンロードしたファイルを解凍し、`resources` ディレクトリの `application.conf` ファイルに移動します。

   1. **アプリケーションの設定**

      この手順では、SigV4 認証プラグインを設定します。以下のサンプルをアプリケーションで使用できます。まだ作成していない場合は、IAM アクセスキー (アクセスキー ID とシークレットアクセスキー) AWS を生成し、設定ファイルまたは環境変数として保存する必要があります。詳細な手順については、「[AWS CLI、 AWS SDK、または Cassandra クライアントドライバー用の 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`が IAM ロールを引き受けることができるように、アプリケーションが提供する必要がある AWS 認証情報を返す を使用する機能が追加されます。この作業は、次の例を参考にして行います。

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

   すべての依存関係を `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 を置き換え、 AWS リージョン を Amazon ECR リポジトリがあるリージョンに設定します`my-ecr-repository`。

   ```
   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 リージョン Amazon EKS クラスターを**  AWS リージョン 作成した 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 クラスターの名前空間におけるポッドのステータスを確認します。

   ```
   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 クエリを実行して、テーブルに 1 行のデータが書き込まれていることを確認します。

   ```
   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 クラスターと、その中に含まれるすべてのポッドを削除します。サービスアカウントや OIDC ID プロバイダーなどの関連リソースも削除されます。それには、次のコマンドを使用します。

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

1. Amazon EKS サービスアカウントで使用される、Amazon Keyspaces へのアクセス許可を持つ 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)」を参照してください。

------