翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# Amazon Keyspaces (Apache Cassandra 向け) へのアクセス
Amazon Keyspaces にアクセスするには、 コンソールを使用する AWS CloudShellか、`cqlsh`クライアント、 AWS SDK を実行するか、Apache 2.0 ライセンスの Cassandra ドライバーを使用します。Amazon Keyspaces では、Apache Cassandra 3.11.2 と互換性のあるドライバーとクライアントがサポートされています。Amazon Keyspaces にアクセスする前に、セットアップを完了し AWS Identity and Access Management 、IAM ID に Amazon Keyspaces へのアクセス許可を付与する必要があります。
## セットアップ AWS Identity and Access Management
### にサインアップする AWS アカウント
がない場合は AWS アカウント、次の手順を実行して作成します。
**にサインアップするには AWS アカウント**
1. [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup) を開きます。
1. オンラインの手順に従います。
サインアップ手順の一環として、電話またはテキストメッセージを受け取り、電話キーパッドで検証コードを入力します。
にサインアップすると AWS アカウント、 *AWS アカウントのルートユーザー* が作成されます。ルートユーザーには、アカウントのすべての AWS のサービス とリソースへのアクセス権があります。セキュリティベストプラクティスとして、ユーザーに管理アクセス権を割り当て、[ルートユーザーアクセスが必要なタスク](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)の実行にはルートユーザーのみを使用するようにしてください。
AWS サインアッププロセスが完了すると、 から確認メールが送信されます。[https://aws.amazon.com/](https://aws.amazon.com/) の **[マイアカウント]** をクリックして、いつでもアカウントの現在のアクティビティを表示し、アカウントを管理することができます。
### 管理アクセスを持つユーザーを作成する
にサインアップしたら AWS アカウント、日常的なタスクにルートユーザーを使用しないように AWS アカウントのルートユーザー、 を保護し AWS IAM アイデンティティセンター、 を有効にして管理ユーザーを作成します。
**を保護する AWS アカウントのルートユーザー**
1. **ルートユーザー**を選択し、 AWS アカウント E メールアドレスを入力して、アカウント所有者[AWS マネジメントコンソール](https://console.aws.amazon.com/)として にサインインします。次のページでパスワードを入力します。
ルートユーザーを使用してサインインする方法については、「*AWS サインイン ユーザーガイド*」の「[ルートユーザーとしてサインインする](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)」を参照してください。
1. ルートユーザーの多要素認証 (MFA) を有効にします。
手順については、*IAM* [ユーザーガイドの AWS アカウント 「ルートユーザー (コンソール) の仮想 MFA デバイス](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)を有効にする」を参照してください。
**管理アクセスを持つユーザーを作成する**
1. IAM アイデンティティセンターを有効にします。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[AWS IAM アイデンティティセンターの有効化](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)」を参照してください。
1. IAM アイデンティティセンターで、ユーザーに管理アクセスを付与します。
を ID ソース IAM アイデンティティセンターディレクトリ として使用する方法のチュートリアルについては、「 *AWS IAM アイデンティティセンター ユーザーガイド*」の[「デフォルトを使用してユーザーアクセスを設定する IAM アイデンティティセンターディレクトリ](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)」を参照してください。
**管理アクセス権を持つユーザーとしてサインインする**
+ IAM アイデンティティセンターのユーザーとしてサインインするには、IAM アイデンティティセンターのユーザーの作成時に E メールアドレスに送信されたサインイン URL を使用します。
IAM Identity Center ユーザーを使用してサインインする方法については、*AWS サインイン 「 ユーザーガイド*[」の AWS 「 アクセスポータルにサインイン](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)する」を参照してください。
**追加のユーザーにアクセス権を割り当てる**
1. IAM アイデンティティセンターで、最小特権のアクセス許可を適用するというベストプラクティスに従ったアクセス許可セットを作成します。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[アクセス許可セットを作成する](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)」を参照してください。
1. グループにユーザーを割り当て、そのグループにシングルサインオンアクセス権を割り当てます。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[グループを追加する](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)」を参照してください。
## Amazon Keyspaces を設定する
Amazon Keyspaces リソースへのアクセスは、[IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) を使用して管理します。IAM を使用すれば、IAM ユーザー、ロール、フェデレーティッドアイデンティティに、Amazon Keyspaces の特定のリソースへの読み書きアクセス許可を付与するポリシーをアタッチできます。
IAM アイデンティへのアクセス許可の付与を開始するには、Amazon Keyspaces 用の AWS マネージドポリシーのいずれかを使用できます。
+ [AmazonKeyspacesFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesFullAccess.html) – Amazon Keyspaces 内のすべてのリソースへのアクセス許可を付与し、すべての機能へのフルアクセスを認めるポリシー。
+ [AmazonKeyspacesReadOnlyAccess\$1v2](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesReadOnlyAccess_v2.html) – Amazon Keyspaces への読み取り専用のアクセス許可を付与するポリシー。
マネージドポリシーで定義されているアクションの詳細については、「[AWS Amazon Keyspaces の マネージドポリシー](security-iam-awsmanpol.md)」を参照してください。
IAM アイデンティティが実行可能なアクションの範囲や、アイデンティティがアクセス可能なリソースを制限するには、`AmazonKeyspacesFullAccess` マネージドポリシーをテンプレートとして使用してカスタムポリシーを作成し、不要なアクセス許可をすべて削除できます。また、特定のキースペースやテーブルにアクセスを限定することもできます。Amazon Keyspaces でアクションを制限する方法や、特定のリソースにアクセスを限定する方法については、「[Amazon Keyspaces で IAM が機能する仕組み](security_iam_service-with-iam.md)」を参照してください。
を作成し、IAM ID に Amazon Keyspaces へのアクセスを許可するポリシー AWS アカウント を作成した後で Amazon Keyspaces にアクセスするには、次のいずれかのセクションに進みます。
+ [コンソールの使用](console_keyspaces.md)
+ [の使用 AWS CloudShell](using-aws-with-cloudshell.md)
# コンソールを使用した Amazon Keyspaces へのアクセス
Amazon Keyspaces コンソールには [https://console.aws.amazon.com/keyspaces/home](https://console.aws.amazon.com/keyspaces/home) からアクセスできます。 AWS マネジメントコンソール アクセスの詳細については、[「IAM ユーザーガイド」の「IAM ユーザーの へのアクセスの制御 AWS マネジメントコンソール](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_controlling-access.html)」を参照してください。
コンソールを使用して、Amazon Keyspaces で以下のことを行うことができます。
+ キースペースとテーブルを作成、削除、管理する。
+ テーブルの **[モニタリング]** タブで、テーブルの重要なメトリクスを監視する。
+ 請求可能なテーブルサイズ (バイト数）
+ キャパシティメトリクス
+ CQL エディタを使用するか、データの挿入、更新、削除など、[統合された AWS CloudShell エクスペリエンス](console_cloudshell_integration.md)を使用してクエリを実行します。
+ 統合された CQLSH サポート AWS CloudShell を使用して、 を介して Amazon Keyspaces に直接接続します。
+ アカウントのパーティショナー設定を変更する。
+ ダッシュボードでアカウントのパフォーマンスとエラーのメトリクスを表示する。
# コンソール AWS CloudShell から を使用して Amazon Keyspaces に接続する
AWS CloudShell は、コンソールから直接 Amazon Keyspaces に接続する効率的な方法を提供します。 AWS CloudShell 統合によって が自動的に初期化され、特定のキースペースへの接続が確立され`cqlsh-expansion`ます。
## AWS CloudShell 統合の開始方法
1. ** AWS CloudShell 統合へのアクセス** – Amazon Keyspaces コンソールから、接続するキースペースに移動し、**キースペースへの接続** AWS CloudShell ボタンを選択します。
1. **事前入力済みセットアップコマンド** – AWS CloudShell ボタンを選択すると、システムは必要な初期化パラメータと接続パラメータを含む事前入力済みコマンドを提供します。
```
cqlsh-expansion.init ; cqlsh-expansion cassandra.region.amazonaws.com 9142 --ssl -my_keyspace
```
1. ****実行** をクリックします。**
1. **Amazon Keyspaces が接続を確立するのを待つ** – セットアッププロセスが完了し、選択したキースペースへの接続が確立されるまで待ちます。
1. **コマンドの実行** – 接続すると、選択したキースペースに対して CQL コマンドを直接書き込み、実行できます。
## 使用可能な CQLSH コマンド
AWS CloudShell 統合により、基本的な CQL 以外のコマンドのサポートなど、標準の CQLSH 機能にアクセスできます。
+ **Describe** – キースペースとテーブルの詳細な説明を一覧表示して表示します。
+ **コピー** – クエリ出力をファイルにエクスポートして後で処理します。
+ **ソース** – ファイルから CQL ステートメントを実行します。
+ **コマンド履歴ナビゲーション** – キーボードショートカットを使用して以前のコマンドをスクロールします。
+ **クエリ実行** – キーボードインターフェイスから直接クエリを実行します。
+ **出力コピー** – 結果をシンプルなテキストとしてコピーし、他のアプリケーションで使用します。
## 機能に関する考慮事項
AWS CloudShell 統合を使用する場合は、次のトレードオフを考慮してください。
**以下の機能はサポートされていません。**
+ CQL 構文の提案と自動補完機能。
+ オートコンプリートの表示、ツールヒントの表示、検索、検索、置換、やり直し、ブロックコメントの切り替え、コードの折りたたみの切り替え、行コメントの切り替え、元に戻すなどのエディタツール。
**変更された機能:**
+ **CSV ダウンロード** – 結果を CSV 形式でダウンロードするには、コマンド出力をパイプする`>`演算子を指定します。
```
SELECT * FROM my_table > file_name.csv
```
+ **JSON 表示** - データ変換を必要とせずに、JSON 形式で項目を表示できます。
+ **ターミナルスタイルのインターフェイス** - エクスペリエンスは、フル機能のコードエディタではなくターミナルインターフェイスとして動作します。
この AWS CloudShell 統合により、Amazon Keyspaces データを から直接管理するための重要な CQL 機能を提供しながら、接続プロセスが簡素化されます AWS マネジメントコンソール。
Amazon Keyspaces のキースペースとテーブルを作成してサンプルアプリケーションデータで設定する方法については、「[Amazon Keyspaces (Apache Cassandra 向け) の使用開始](getting-started.md)」を参照してください。
# AWS CloudShell を使用して Amazon Keyspaces にアクセスする
AWS CloudShell はブラウザベースの事前認証済みシェルで、 から直接起動できます AWS マネジメントコンソール。任意のシェル (Bash、PowerShell、または Z シェル) を使用して、 AWS サービスに対して AWS CLI コマンドを実行できます。 AWS CloudShell はコンソール認証情報で事前認証され AWS CLI、、、Python、Node.js などの AWS サービスを操作するための一般的なツールが含まれています。
[AWS CloudShell から を起動 AWS マネジメントコンソール](https://docs.aws.amazon.com/cloudshell/latest/userguide/working-with-cloudshell.html#launch-options)すると、コンソールへのサインインに使用した AWS 認証情報が新しいシェルセッションで自動的に利用可能になります。 AWS CloudShell ユーザーのこの事前認証により、 `cqlsh`または AWS CLI バージョン 2 (シェルのコンピューティング環境にプリインストールされている) を使用して Amazon Keyspaces などの AWS サービスとやり取りするときに、認証情報の設定をスキップできます。
## AWS CloudShell 統合オプション
Amazon Keyspaces には、次の 2 つの使用方法があります AWS CloudShell。
1. **統合 AWS CloudShell エクスペリエンス** - Amazon Keyspaces コンソールから直接利用できる効率的な接続方法で、 を自動的に初期化`cqlsh-expansion`し、特定のキースペースに接続します。この統合エクスペリエンスの使用方法の詳細については、「」を参照してください[コンソール AWS CloudShell から を使用して Amazon Keyspaces に接続する](console_cloudshell_integration.md)。
1. **手動 AWS CloudShell セットアップ** - で手動でインストールおよび設定`cqlsh`します AWS CloudShell。ステップについては、以下のセクションで説明し、セットアッププロセスをより詳細に制御し、カスタム設定を有効にします。
## 前提条件
で Amazon Keyspaces を使用する前に AWS CloudShell、以下があることを確認してください。
+ Amazon Keyspaces および にアクセスできる AWS アカウント AWS CloudShell
+ 両方のサービスを使用するための適切な IAM アクセス許可
+ Cassandra クエリ言語 (CQL) に関する基本的な知識
## の開始方法 AWS CloudShell
アクセスするには AWS CloudShell:
1. にサインインする AWS マネジメントコンソール
1. コンソールの上部にあるナビゲーションバー AWS CloudShell のアイコン AWS CloudShell を選択するか、[https://console.aws.amazon.com/cloudshell/](https://console.aws.amazon.com/cloudshell/) に移動して起動します。
1. AWS CloudShell 環境が初期化されるまで待機する
## の IAM アクセス許可の取得 AWS CloudShell
が提供するアクセス管理リソースを使用して AWS Identity and Access Management、管理者は IAM ユーザーにアクセス許可を付与し、環境の機能にアクセスして AWS CloudShell 使用できます。
管理者がユーザーにアクセス権を付与する最も簡単な方法は、 AWS マネージドポリシーを使用することです。[AWS マネージドポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies)は、 AWSが作成および管理するスタンドアロンポリシーです。CloudShell の次の AWS 管理ポリシーを IAM ID にアタッチできます。
+ `AWSCloudShellFullAccess`: すべての機能へのフルアクセス AWS CloudShell で を使用するアクセス許可を付与します。
IAM ユーザーが実行できるアクションの範囲を制限する場合は AWS CloudShell、`AWSCloudShellFullAccess`管理ポリシーをテンプレートとして使用するカスタムポリシーを作成できます。CloudShell でユーザーが使用できるアクションの制限の詳細については、*AWS CloudShell 「 ユーザーガイド*」の[「IAM ポリシーによる AWS CloudShell アクセスと使用状況の管理](https://docs.aws.amazon.com/cloudshell/latest/userguide/sec-auth-with-identities.html)」を参照してください。
**注記**
IAM アイデンティティには、Amazon Keyspaces への呼び出しを行うアクセス許可を付与するポリシーも必要です。
AWS 管理ポリシーを使用して IAM ID に Amazon Keyspaces へのアクセスを許可するか、管理ポリシーをテンプレートとして開始し、不要なアクセス許可を削除できます。また、特定のキースペースやテーブルにアクセスを限定して、カスタムのポリシーを作成することもできます。Amazon Keyspaces 用の次のマネージドポリシーを IAM アイデンティティにアタッチできます。
+ [AmazonKeyspacesFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesFullAccess.html) – Amazon Keyspaces の使用を許可し、すべての機能へのフルアクセスを認めるポリシー。
マネージドポリシーで定義されているアクションの詳細については、「[AWS Amazon Keyspaces の マネージドポリシー](security-iam-awsmanpol.md)」を参照してください。
Amazon Keyspaces でアクションを制限する方法や、特定のリソースにアクセスを限定する方法については、「[Amazon Keyspaces で IAM が機能する仕組み](security_iam_service-with-iam.md)」を参照してください。
## cqlsh クライアントのインストール
AWS CloudShell には、 が`cqlsh`プリインストールされていません。Amazon Keyspaces を操作するには、インストールする必要があります。Amazon Keyspaces 固有のバージョンの をインストールできます`cqlsh`。`cqlsh-expansion` のインストール手順については、「[`cqlsh-expansion` による Amazon Keyspaces までの接続](programmatic.cqlsh.md#using_cqlsh)」を参照してください。
## TLS 証明書の設定
TLS 接続を使用して Amazon Keyspaces に接続するには、必要な Amazon デジタル証明書をダウンロードする必要があります。SSL 証明書のダウンロードと設定の詳細な手順については、「」を参照してください[TLS の `cqlsh` 接続を手動で設定する方法](programmatic.cqlsh.md#encrypt_using_tls)。
## Amazon Keyspaces への接続
IAM 認証情報 (推奨) またはサービス固有の認証情報を使用して Amazon Keyspaces に接続できます。
### IAM 認証情報を使用した接続 (推奨)
AWS CloudShell は既に IAM 認証情報で認証されています。これらの認証情報を使用して接続するには、SigV4 認証プラグインを使用できます。で IAM 認証情報を使用する詳細な手順については`cqlsh`、「」を参照してください[`cqlsh-expansion` による Amazon Keyspaces までの接続](programmatic.cqlsh.md#using_cqlsh)。
### サービス固有の認証情報による接続
Amazon Keyspaces のサービス固有の認証情報を作成している場合は、それらを使用して接続できます。サービス固有の認証情報の作成と使用については、「」を参照してください[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md)。
## Amazon Keyspaces での CQLSH の使用
接続すると、標準の CQL コマンドを使用してキースペースとテーブルを操作できます。サポートされている CQL コマンドとオペレーションの詳細については、「」を参照してください[`cqlsh-expansion` による Amazon Keyspaces までの接続](programmatic.cqlsh.md#using_cqlsh)。
## でのデータの永続化 AWS CloudShell
AWS CloudShell は、ホームディレクトリに 1 GB の永続的ストレージを提供します。つまり、作成したスクリプト、証明書、および設定ファイルは、セッション間で引き続き使用できます。の設定ファイルを作成して`cqlsh`、接続を簡素化できます。
設定ファイルを使用すると、追加のパラメータを指定`cqlsh`せずに を実行できます。`cqlsh` 設定ファイルの作成と使用の詳細については、「」を参照してください[`cqlsh-expansion` による Amazon Keyspaces までの接続](programmatic.cqlsh.md#using_cqlsh)。
## ベストプラクティス
で Amazon Keyspaces を使用する場合は AWS CloudShell、次のベストプラクティスをお勧めします。
+ 反復タスク用のスクリプトを作成し、永続的なホームディレクトリに保存します。
+ 機密情報をハードコーディングするのではなく、環境変数を使用します。
+ 非アクティブになると AWS CloudShell セッションがタイムアウトする場合があることに注意してください。
+ AWS CloudShell サービスクォータと制限に注意してください。
+ Amazon Keyspaces の自動オペレーション AWS CLI に を使用することを検討してください。
## トラブルシューティング
から Amazon Keyspaces に接続するときに問題が発生した場合 AWS CloudShell:
+ IAM アクセス許可に必要な Amazon Keyspaces アクションが含まれていることを確認します。
+ リージョンに正しいエンドポイントを使用していることを確認します。
+ SSL 証明書が正しくダウンロードされ、参照されていることを確認します。
+ サービス固有の認証情報が正しく、有効期限が切れていないことを確認します。
+ cqlshrc ファイルを使用する場合は、その形式とアクセス許可を確認してください。
## 例: を使用して Amazon Keyspaces を操作する方法 AWS CloudShell
AWS CloudShell から起動すると AWS マネジメントコンソール、 `cqlsh`またはコマンドラインインターフェイスを使用して Amazon Keyspaces の操作をすぐに開始できます。`cqlsh-expansion` をまだインストールしていない場合は、「[`cqlsh-expansion` による Amazon Keyspaces までの接続](programmatic.cqlsh.md#using_cqlsh)」で詳しい手順を確認してください。
**注記**
`cqlsh-expansion` で を使用する場合 AWS CloudShell、シェル内で既に認証されているため、呼び出しを行う前に認証情報を設定する必要はありません。
**Amazon Keyspaces に接続して新しいキースペースを作成した後、次に、システムテーブルから読み取って、 を使用してキースペースが作成されたことを確認します。 AWS CloudShell**
1. から AWS マネジメントコンソール、ナビゲーションバーで使用できる以下のオプションを選択して CloudShell を起動できます。
+ CloudShell アイコンを選択します。
+ `cloudshell` 検索ボックスに入力を開始し、CloudShell オプションを選択します。
1. 次のコマンドを使用して、Amazon Keyspaces への接続を確立できます。をリージョンに適したエンドポイント`cassandra.us-east-1.amazonaws.com`に置き換えてください。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
正常に接続されると次の例のような出力が表示されます。
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
cqlsh>
```
1. `mykeyspace` という名前の新しいキースペースを作成します。そのためには、次のコマンドを使用できます。
```
CREATE KEYSPACE mykeyspace WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. キースペースが作成されたことを確認するには、次のコマンドを使用してシステムテーブルから読み取ります。
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
コールが成功すると、コマンドラインに次の出力に似たサービスからのレスポンスが表示されます。
```
keyspace_name | durable_writes | replication
----------------+----------------+-------------------------------------------------------------------------------------
mykeyspace | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(1 rows)
```
# Amazon Keyspaces にプログラムによってアクセスするための認証情報を作成する
Amazon Keyspaces リソースへのプログラムアクセスに必要な認証情報を、ユーザーとアプリケーションに提供するには、次のいずれかを実行します。
+ Cassandra が認証とアクセス管理に使用する従来のユーザー名とパスワードに似たサービス固有の認証情報を作成します。 AWS サービス固有の認証情報は、特定の AWS Identity and Access Management (IAM) ユーザーに関連付けられ、作成されたサービスにのみ使用できます。詳細については、「IAM ユーザーガイド」の[「Using IAM with Amazon Keyspaces (for Apache Cassandra)」](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_keyspaces.html)(IAM と Amazon Keyspaces (Apache Cassandra 向け) の併用) を参照してください。
**警告**
IAM ユーザーは長期認証情報を保有するため、セキュリティ上のリスクが生じます。このリスクを軽減するために、これらのユーザーにはタスクの実行に必要な権限のみを付与し、不要になったユーザーは削除することをお勧めします。
+ セキュリティを強化するために、すべての AWS サービスで使用される IAM ID を作成し、一時的な認証情報を使用することをお勧めします。Cassandra クライアントドライバー用の Amazon Keyspaces SigV4 認証プラグインを使用すると、ユーザー名とパスワードではなく IAM アクセスキーを使用して Amazon Keyspaces のコールの認証を行うことができます。Amazon Keyspaces SigV4 プラグインにより、[IAM ユーザー、ロール、およびフェデレーティッドアイデンティティ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)の認証を Amazon Keyspaces API リクエストで行えるようにするには、[「AWS Signature Version 4 process (SigV4)」](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)( 署名バージョン 4 プロセス (SigV4)) を参照してください。
SigV4 プラグインは次の場所からダウンロードできます。
+ Java: [https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin)。
+ Node.js: [https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin](https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin)。
+ Python: [https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin](https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin)。
+ Go: [https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin)。
SigV4 認証プラグインを使用して接続を確立する方法のサンプルコードについては、「[Cassandra クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス](programmatic.drivers.md)」を参照してください。
**Topics**
+ [サービス固有の認証情報の作成](programmatic.credentials.ssc.md)
+ [AWS 認証用の IAM 認証情報を作成する](access.credentials.md)
# Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する
サービス固有の認証情報は、Cassandra が認証とアクセス管理に使用するような従来方式のユーザー名とパスワードに似ています。サービス固有の認証情報があれば、IAM ユーザーは特定の AWS サービスにアクセスできるようになります。これらの長期的な認証情報は、他の AWS サービスへのアクセスには使用できません。これらは特定の IAM ユーザーに関連付けられているため、他の IAM ユーザーが使用することはできません。
**重要**
サービス固有の認証情報は、特定の IAM ユーザーに関連付けられた長期の資格情報で、認証情報の作成時に対象としていたサービスにしか使用できません。一時的な認証情報を使用してすべての AWS リソースにアクセスするためのアクセス許可を IAM ロールまたはフェデレーティッド ID に付与するには、[AWS Amazon Keyspaces の SigV4 認証プラグインで認証](access.credentials.md)を使用する必要があります。
次のいずれかの手順でサービス固有の認証情報を生成してください。
------
#### [ Console ]
**コンソールを使用してサービス固有の認証情報を作成する**
1. にサインイン AWS マネジメントコンソール し、 で AWS Identity and Access Management コンソールを開きます[https://console.aws.amazon.com/iam/home](https://console.aws.amazon.com/iam/home)。
1. ナビゲーションペインで、**[Users]** (ユーザー) を選択し、次に、事前に作成した、Amazon Keyspaces のアクセス許可 (ポリシーがアタッチされている) を持っているユーザーを選択します。
1. **[Security Credentials]** (セキュリティ認証情報) を選択します。**[Credentials for Amazon Keyspaces]** (Amazon Keyspaces の認証情報) で、**[Generate credentials]** (認証情報を生成) を使用してサービス固有の認証情報を生成します。
これで、サービス固有の認証情報が利用可能になりました。パスワードを表示またはダウンロードできるのはこの時点だけです。後で回復することはできません。ただし、パスワードはいつでもリセットできます。ユーザーおよびパスワードは後で必要になるため、安全な場所に保存します。
------
#### [ CLI ]
**を使用してサービス固有の認証情報を作成する AWS CLI**
サービス固有の認証情報を生成する前に、 AWS Command Line Interface () をダウンロード、インストール、設定する必要がありますAWS CLI。
1. AWS CLI で をダウンロードします[http://aws.amazon.com/cli](https://aws.amazon.com/cli)。
**注記**
は Windows、macOS、または Linux で AWS CLI 実行されます。
1. 「 *AWS Command Line Interface ユーザーガイド*[」の AWS 「 CLI のインストール](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)」および[「 CLI AWS の設定](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)」の手順に従います。
1. を使用して AWS CLI、次のコマンドを実行してユーザー のサービス固有の認証情報を生成し`alice`、Amazon Keyspaces にアクセスできるようにします。
```
aws iam create-service-specific-credential \
--user-name alice \
--service-name cassandra.amazonaws.com
```
出力は次のようになります。
```
{
"ServiceSpecificCredential": {
"CreateDate": "2019-10-09T16:12:04Z",
"ServiceName": "cassandra.amazonaws.com",
"ServiceUserName": "alice-at-111122223333",
"ServicePassword": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"ServiceSpecificCredentialId": "ACCAYFI33SINPGJEBYESF",
"UserName": "alice",
"Status": "Active"
}
}
```
出力の `ServiceUserName` と `ServicePassword` の値を書き留めておきます。これらの値は後で必要になるため、安全な場所に保存しておいてください。
**重要**
`ServicePassword` を利用できるのはこの時点だけです。
------
# Amazon Keyspaces の AWS 認証情報の作成と設定
AWS CLI、 AWS SDK、または Cassandra クライアントドライバーと SigV4 プラグインを使用してプログラムで Amazon Keyspaces にアクセスするには、アクセスキーを持つ IAM ユーザーが必要です。Amazon Keyspaces をプログラムで使用する場合、 AWS がプログラムによる呼び出しで ID を検証できるように AWS アクセスキーを指定します。アクセスキーは、アクセスキー ID (例: AKIAIOSFODNN7EXAMPLE) とシークレットアクセスキー (例: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY) で構成されます。このトピックでは、このプロセスで必要になる手順を説明します。
セキュリティのベストプラクティスとして、アクセス許可が制限された IAM ユーザーを作成し、代わりに、特定のタスクの実行に必要なアクセス許可を IAM ロールに関連付けておくことをお勧めします。そうしておけば、IAM ユーザーが一時的に IAM ロールを引き受けて、必要なタスクを実行できます。例えば、アカウントの IAM ユーザーが Amazon Keyspaces コンソールを使用する場合、別のロールに切り替えて、コンソールでそのロールのアクセス許可を一時的に使用できます。ユーザーは、元のアクセス権限を返却し、そのロールに割り当てられたアクセス権限を取得します。ユーザーがそのロールを終了すると、元のアクセス権限に戻ります。ユーザーがロールを引き受ける際に使用する認証情報は一時的なものです。一方で、IAM ユーザーには長期的な認証情報が割り当てられるため、ロールを引き受ける代わりにアクセス許可を直接割り当てた場合、セキュリティリスクを伴います。このリスクを軽減するために、これらのユーザーにはタスクの実行に必要な権限のみを付与し、不要になったユーザーは削除することをお勧めします。ロールの詳細については、「IAM ユーザーガイド**」の「[ロールの一般的なシナリオ: ユーザー、アプリケーション、およびサービス](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios.html)」を参照してください。
**Topics**
+ [AWS CLI、 AWS SDK、または Cassandra クライアントドライバー用の Amazon Keyspaces SigV4 プラグインに必要な認証情報](SigV4_credentials.md)
+ [IAM ロールと SigV4 プラグインで Amazon Keyspaces に接続するための一時的な認証情報を作成する](temporary.credentials.IAM.md)
+ [AWS アカウントの Amazon Keyspaces にプログラムでアクセスするための IAM ユーザーを作成する](access.credentials.IAM.md)
+ [IAM ユーザーの新しいアクセスキーを作成する](create.keypair.md)
+ [プログラムによるアクセス用のアクセスキーを保存する](aws.credentials.manage.md)
# AWS CLI、 AWS SDK、または Cassandra クライアントドライバー用の Amazon Keyspaces SigV4 プラグインに必要な認証情報
IAM ユーザーまたはロールの認証には、次の認証情報が必要です。
`AWS_ACCESS_KEY_ID`
IAM ユーザーまたはロールに関連付けられた AWS アクセスキーを指定します。
プログラムによる Amazon Keyspaces への接続には、アクセスキー `aws_access_key_id` が必要です。
`AWS_SECRET_ACCESS_KEY`
アクセスキーに関連付けられるシークレットキーを指定します。これは、基本的にアクセスキーの「パスワード」です。
プログラムによる Amazon Keyspaces への接続には、`aws_secret_access_key` が必要です。
`AWS_SESSION_TOKEN` – オプション
AWS Security Token Service オペレーションから直接取得した一時的なセキュリティ認証情報を使用している場合に必要なセッショントークン値を指定します。詳細については、「[IAM ロールと SigV4 プラグインで Amazon Keyspaces に接続するための一時的な認証情報を作成する](temporary.credentials.IAM.md)」を参照してください。
IAM ユーザーに接続する場合、`aws_session_token` は不要です。
# IAM ロールと SigV4 プラグインで Amazon Keyspaces に接続するための一時的な認証情報を作成する
Amazon Keyspaces にプログラムによってアクセスする場合に推奨される方法は、[一時的な認証情報](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)を使用して SigV4 プラグインで認証することです。多くの場合、期限のない長期のアクセスキー (IAM ユーザーのアクセスキーなど) は必要ありません。その代わり、IAM ロールを作成して一時的なセキュリティ認証情報を生成することができます。一時的なセキュリティ認証情報は、アクセスキー ID とシークレットアクセスキーで構成されていますが、認証情報がいつ無効になるかを示すセキュリティトークンも含んでいます。長期アクセスキーの代わりに IAM ロールを使用する方法の詳細については、[「IAM ロールへの切り替え (AWS API)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-api.html)」を参照してください。
一時認証情報を使用するには、まず IAM ロールを作成しておく必要があります。
**Amazon Keyspaces に読み取り専用アクセスを付与する IAM ロールを作成します。**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソールを開きます。
1. ナビゲーションペインで [**Roles (ロール)**]、[**Create role (ロールを作成)**] の順に選択します。
1. [**ロールを作成**] ページの [**信頼されたエンティティのタイプを選択**] で、[**AWS サービス)**] を選択します。[**Choose a use case (ユースケースを選択)**] で [**Amazon EC2**] を選択し、[**Next (次へ)**] を選択します。
1. 「**アクセス権限を追加**」ページの「**アクセス権限ポリシー」で、ポリシーリストから**「**Amazon Keyspaces 読み取り専用アクセス**」を選択し、「**次へ**」を選択します。
1. 「**名前、レビュー、作成**」ページで、ロールの名前を入力し、「**信頼できるエンティティを選択**」 と「**権限を追加**」セクションを確認します。このページでは、ロールにオプションでタグを追加することもできます。終了したら、[**Create role (ロールを作成)**] を選択します。この名前は Amazon EC2 インスタンスを起動するときに必要になるため、覚えておいてください。
コードで一時的なセキュリティ認証情報を使用するには、 などの AWS Security Token Service API をプログラムで呼び出し`AssumeRole`、前のステップで作成した IAM ロールから生成された認証情報とセッショントークンを抽出します。次に、これらの値を後続の 呼び出しの認証情報として使用します AWS。以下の例で、一時的なセキュリティ認証情報を使用する方法に関する疑似コードを示します。
```
assumeRoleResult = AssumeRole(role-arn);
tempCredentials = new SessionAWSCredentials(
assumeRoleResult.AccessKeyId,
assumeRoleResult.SecretAccessKey,
assumeRoleResult.SessionToken);
cassandraRequest = CreateAmazoncassandraClient(tempCredentials);
```
Python ドライバを使用して Amazon Keyspaces にアクセスするために一時的な認証情報を実装する例については、「[Apache Cassandra 用 DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する](using_python_driver.md#python_SigV4)」を参照してください。
`AssumeRole`、`GetFederationToken`、およびその他の API オペレーションを呼び出す方法の詳細については、「[AWS Security Token Service API リファリファレンス](https://docs.aws.amazon.com/STS/latest/APIReference/)」を参照してください。結果から一時的なセキュリティ認証情報とセッショントークンを取得する方法の詳細については、お使いの SDK のドキュメントを参照してください。すべての AWS SDKs のドキュメントは、**SDKs とツールキット**セクションのメイン[AWS ドキュメントページ](https://aws.amazon.com/documentation)にあります。
# AWS アカウントの Amazon Keyspaces にプログラムでアクセスするための IAM ユーザーを作成する
、 AWS SDK AWS CLI、または SigV4 プラグインを使用して Amazon Keyspaces にプログラムでアクセスするための認証情報を取得するには、まず IAM ユーザーまたはロールを作成する必要があります。IAM ユーザーを作成して、IAM ユーザーによる Amazon Keyspaces へのプログラムアクセスを設定する手順を以下に示します。
1. 、 AWS マネジメントコンソール、 AWS CLI Tools for Windows PowerShell、または AWS API オペレーションを使用してユーザーを作成します。でユーザーを作成すると AWS マネジメントコンソール、認証情報が自動的に作成されます。
1. プログラムによりユーザーを作成する場合は、追加のステップでそのユーザーのアクセスキー (アクセスキー ID とシークレットアクセスキー) を作成する必要があります。
1. Amazon Keyspaces へのアクセス許可をユーザーに付与します。
IAM ユーザーの作成に必要なアクセス許可の詳細については、「[他の IAM リソースへのにアクセスするのに必要なアクセス許可](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html)」を参照してください。
------
#### [ Console ]
**プログラムによってアクセスするための IAM ユーザーを作成する (コンソール)**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソールを開きます。
1. ナビゲーションペインで **[Users]** (ユーザー)、**[Add user]** (ユーザーを追加する) の順に選択します。
1. 新しいユーザーのユーザー名を入力します。これは のサインイン名です AWS。
**注記**
ユーザー名は、最大 64 文字の英数字、プラス記号 (\$1)、等号 (=)、カンマ (,)、ピリオド (.)、アットマーク (@)、アンダースコア (\$1)、ハイフン (-) を組み合わせて指定します。名前はアカウント内で一意である必要があります。これらは大文字と小文字で区別されません。例えば、*TESTUSER* というユーザーと *testuser* というユーザーを作成することはできません。
1. 新しいユーザーのアクセスキーを作成するには、[**アクセスキー - プログラムによるアクセス**] を選択します。[**Final (最終**)] ページに到達すると、アクセスキーの表示やダウンロードができます。
[**Next: Permissions (次へ: 許可)**] を選択します。
1. [**アクセス許可を設定**] ページで、[**既存のポリシーを直接添付**] を選択して、新しいユーザーにアクセス許可を割り当てます。
このオプションは、アカウントで利用可能な AWS 管理ポリシーとカスタマー管理ポリシーのリストを表示します。検索フィールドに `keyspaces` を入力して、Amazon Keyspaces に関連するポリシーのみを表示できます。
Amazon Keyspaces の場合、利用可能なマネージドポリシーは `AmazonKeyspacesFullAccess` と `AmazonKeyspacesReadOnlyAccess` です。各ポリシーの詳細については、「[AWS Amazon Keyspaces の マネージドポリシー](security-iam-awsmanpol.md)」を参照してください。
テストが目的の場合や、接続のチュートリアルに従う場合は、新しい IAM ユーザー用に `AmazonKeyspacesReadOnlyAccess` ポリシーを選択してください。**注意:**ベストプラクティスとして、最小権限の原則に従い、特定のリソースへのアクセスを制限し、必要なアクションのみを許可するカスタムポリシーを作成することをお勧めします。IAM ポリシーと Amazon Keyspaces サンプルポリシーの詳細については、「[Amazon Keyspaces のアイデンティティベースポリシー](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies)」を参照してください。カスタムのアクセス許可ポリシーを作成したら、ポリシーをロールにアタッチし、ユーザーが適切なロールを一時的に引き受けられるようにします。
**[Next: Tags]** (次へ: タグ) を選択します。
1. [**タグを追加 (オプション)**] ページでは、ユーザーのタグを追加するか、[**次へ:確認**] を選択できます。
1. [**レビュー**] ページで、この時点までに行ったすべての選択を確認できます。続行する準備ができたら、[**Create user (ユーザーの作成)**] を選択します。
1. ユーザーのアクセスキー (アクセスキー ID とシークレットアクセスキー) を表示するには、パスワードとアクセスキーの横にある [**Show (表示)**] を選択します。アクセスキーを保存するには、[**Download .csv (.csv のダウンロード)**] を選択し、安全な場所にファイルを保存します。
**重要**
シークレットアクセスキーの表示またはダウンロードを実行できるのはこの時点だけです。ユーザーが SigV4 プラグインを使用できるようにするには、あらかじめこの情報を提供しておく必要があります。ユーザーの新しいアクセスキー ID とシークレットアクセスキーは、安全な場所に保存してください。このステップを行った後に、シークレットキーに再度アクセスすることはできません。
------
#### [ CLI ]
**プログラムによってアクセスするための IAM ユーザーを作成する (AWS CLI)**
1. 次の AWS CLI コードを使用してユーザーを作成します。
+ [https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html)
1. ユーザーにプログラムアクセス権を付与します。これにはアクセスキーが必要です。アクセスキーは、次の方法で生成できます。
+ AWS CLI: [https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html)
+ [https://docs.aws.amazon.com/powershell/latest/reference/items/New-IAMAccessKey.html](https://docs.aws.amazon.com/powershell/latest/reference/items/New-IAMAccessKey.html) Tools for Windows PowerShell
+ IAM API: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html)
**重要**
シークレットアクセスキーの表示またはダウンロードを実行できるのはこの時点だけです。ユーザーが SigV4 プラグインを使用できるようにするには、あらかじめこの情報を提供しておく必要があります。ユーザーの新しいアクセスキー ID とシークレットアクセスキーは、安全な場所に保存してください。このステップを行った後に、シークレットキーに再度アクセスすることはできません。
1. ユーザーのアクセス許可を定義する `AmazonKeyspacesReadOnlyAccess` ポリシーをユーザーにアタッチします。**注意:** ベストプラクティスとして、ユーザーのアクセス許可の管理は、ユーザーをグループに追加してグループにポリシーをアタッチすることで (ユーザーに直接アタッチするのではなく) 行うことをお勧めします。
+ AWS CLI: [https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html)
------
# IAM ユーザーの新しいアクセスキーを作成する
IAM ユーザーをすでに作成している場合は、いつでも新しいアクセスキーを作成できます。アクセスキーの更新方法など、キー管理の詳細については、「[IAM ユーザーのアクセスキーの管理](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)」を参照してください。
**IAM ユーザーのアクセスキーを作成するには (コンソール)**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソールを開きます。
1. ナビゲーションペインで [**Users (ユーザー)**] を選択します。
1. アクセスキーを作成するユーザーの名前を選択します。
1. ユーザーの [**Summary (概要)**] ページで、[**Security credentials (セキュリティ認証情報)**] タブをクリックします。
1. **「アクセスキー**」セクションの**「アクセスキーのベストプラクティスと代替方法」で、ユースケース「その他**」を選択します。 ******次へ**をクリックし、必要に応じてオプション情報を入力し、**アクセスキーの作成**を選択します。
新しいアクセスキーのペアを表示するには、[**Show (表示)**] を選択します。認証情報は以下のようになります:
+ アクセスキーID: AKIAIOSFODNN7EXAMPLE
+ シークレットアクセスキー: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
**注記**
このダイアログボックスを閉じた後で、シークレットアクセスキーに再度アクセスすることはできません。
作成したキーペアについては、次のベストプラクティスを考慮してください。
+ アクセスキーをプレーンテキスト、コードリポジトリ、またはコードに保存しないでください。
+ 不要になったアクセスキーを無効化または削除します。
+ 最小特権のアクセス許可を有効にします。
+ アクセスキーを定期的にローテーションします。
1. キーペアをダウンロードするには、[**Download .csv file.csv (.csv ファイルのダウンロード)**] を選択します。このキーは安全な場所に保存してください。
1. .csv ファイルをダウンロードしたら、[**Close (閉じる)**] を選択します。
アクセスキーを作成すると、キーペアはデフォルトで有効になり、すぐにキーペアを使用できるようになります。
# プログラムによるアクセス用のアクセスキーを保存する
ベストプラクティスとして、アクセスキーをコードに直接埋め込まないことをお勧めします。 AWS SDKs と AWS コマンドラインツールを使用すると、既知の場所にアクセスキーを配置できるため、コード内に保持する必要はありません。次のいずれかの場所にアクセスキーを置きます。
+ **環境変数** – マルチテナントシステムでは、システム環境変数ではなくユーザー環境変数を選択します。
+ **CLI 認証情報ファイル** – コマンド `aws configure` を実行すると、`credentials` ファイルと `config` ファイルが更新されます。`credentials` ファイルは、Linux、macOS、Unix では `~/.aws/credentials` に、Windows では `C:\Users\USERNAME\.aws\credentials` にあります。このファイルには、`default` プロファイルと任意の名前付きプロファイルの認証情報の詳細が含まれています。
+ **CLI 設定ファイル** - コマンド `aws configure` を実行すると、`credentials` ファイルと `config` ファイルが更新されます。`config` ファイルは、Linux、macOS、Unix では `~/.aws/config` に、Windows では `C:\Users\USERNAME\.aws\config` にあります。このファイルには、 デフォルトプロファイルとあらゆる名前付きプロファイルの設定が含まれています。
アクセスキーを環境変数として保存することは、「[Apache Cassandra 用の 4.x DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続するためのステップバイステップのチュートリアル](using_java_driver.md#java_tutorial.SigV4)」の前提条件です。これにはデフォルトが含まれることに注意してください AWS リージョン。クライアントでは、デフォルトの認証情報プロバイダーチェーンを使用して認証情報が検索されます。環境変数として保存されたアクセスキーは、設定ファイルなどの他のすべての場所よりも優先されます。詳細については、「[Configuration settings and precedence (設定と優先順位)](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-precedence)」を参照してください。
次の例では、デフォルトのユーザーの環境変数を設定する方法を示します。
------
#### [ Linux, macOS, or Unix ]
```
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
$ export AWS_SESSION_TOKEN=AQoDYXdzEJr...
$ export AWS_DEFAULT_REGION=us-east-1
```
環境変数を設定すると、シェルセッションの終了時まで、または変数に別の値を設定するまで、使用する値が変更されます。変数をシェルのスタートアップスクリプトで設定することで、変数をこれからのセッションで永続的にすることができます。
------
#### [ Windows Command Prompt ]
```
C:\> setx AWS_ACCESS_KEY_ID AKIAIOSFODNN7EXAMPLE
C:\> setx AWS_SECRET_ACCESS_KEY wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
C:\> setx AWS_SESSION_TOKEN AQoDYXdzEJr...
C:\> setx AWS_DEFAULT_REGION us-east-1
```
`[set](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/set_1)` を使用して環境変数を設定すると、現在のコマンドプロンプトセッションの終了時まで、または変数を別の値に設定するまで、使用する値が変更されます。[https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx) を使用して環境変数を設定すると、現在のコマンドプロンプトセッションおよびコマンド実行後に作成するすべてのコマンドプロンプトセッションで使用する値が変更されます。これは、コマンド実行時にすでに実行されている他のコマンドシェルには影響を及ぼし***ません***。
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
PS C:\> $Env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
PS C:\> $Env:AWS_SESSION_TOKEN="AQoDYXdzEJr..."
PS C:\> $Env:AWS_DEFAULT_REGION="us-east-1"
```
前の例に示すように PowerShell プロンプトで環境変数を設定した場合は、現在のセッションの期間だけ値が保存されます。PowerShell およびコマンドプロンプトセッション間で環境変数を永続的に設定するには、[**コントロールパネル**] の [**システム**] アプリケーションを使用して変数を保存します。または、変数を PowerShell プロファイルに追加すると、その変数を今後のすべての PowerShell セッションに設定できます。環境変数の保存やそれをセッション間で永続的に維持する詳細については、[「PowerShell documentation」](https://docs.microsoft.com/powershell/module/microsoft.powershell.core/about/about_environment_variables)(PowerShell ドキュメント) を参照してください。
------
# Amazon Keyspaces のサービスエンドポイント
**Topics**
+ [ポートとプロトコル](#ports)
+ [グローバルエンドポイント](#global_endpoints)
+ [AWS GovCloud (US) Region FIPS エンドポイント](#fips_endpoints)
+ [中国リージョンのエンドポイント](#china_endpoints)
+ [ストリームエンドポイント](#streams_endpoints)
+ [デュアルスタックエンドポイントへの接続](dualstack_endpoints.md)
## ポートとプロトコル
Amazon Keyspaces にプログラムでアクセスするには、`cqlsh`クライアントを実行するか、Apache 2.0 ライセンスの Cassandra ドライバーを使用するか、 AWS CLI と AWS SDK を使用します。
次の表は、さまざまなアクセスメカニズムのポートとプロトコルをまとめたものです。
| プログラムによるアクセス | ポート | プロトコル |
| --- | --- | --- |
| CQLSH | 9142 | TLS |
| Cassandra ドライバー | 9142 | TLS |
| AWS CLI | 443 | HTTPS |
| AWS SDK | 443 | HTTPS |
TLS 接続の場合、Amazon Keyspaces は Amazon Trust Services (Amazon ルート CAs 1～4) で発行された証明書を使用してサーバーに対して認証します。詳細については、「[TLS の `cqlsh` 接続を手動で設定する方法](programmatic.cqlsh.md#encrypt_using_tls)」または [Cassandra クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス](programmatic.drivers.md) 章のドライバーの「[始める前に](using_java_driver.md#using_java_driver.BeforeYouBegin)」セクションを参照してください。
## グローバルエンドポイント
Amazon Keyspaces は、IPv4 と IPv6 の両方のパブリックエンドポイントをサポートしています。IPv4 エンドポイントとデュアルスタックエンドポイントのいずれかを選択できます。エンドポイントは、次の命名規則を使用します。この命名規則では、*us-east-1* をテーブル AWS リージョン から利用可能な別の命名規則に置き換えることができます。
+ **IPv4 エンドポイント** – `cassandra.us-east-1.amazonaws.com`
+ **デュアルスタックエンドポイント –** `cassandra.us-east-1.api.aws`
デュアルスタックエンドポイントと接続の設定方法の詳細については、「」を参照してください[デュアルスタックエンドポイントへの接続](dualstack_endpoints.md)。
Amazon Keyspaces は、次のリージョンで使用できます。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/keyspaces/latest/devguide/programmatic.endpoints.html)
## AWS GovCloud (US) Region FIPS エンドポイント
AWS GovCloud (US) Regionで使用可能な FIPS エンドポイント。Amazon Keyspaces は、IPv4 と IPv6 の両方の FIPS エンドポイントをサポートしています。IPv4 エンドポイントとデュアルスタックエンドポイントのいずれかを選択できます。詳細については、『*AWS GovCloud (US) ユーザーガイド*』の「[Amazon Keyspaces」を参照してください](https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/govcloud-keyspaces.html)。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/keyspaces/latest/devguide/programmatic.endpoints.html)
## 中国リージョンのエンドポイント
Amazon Keyspaces は、 AWS 中国リージョンで IPv4 エンドポイントをサポートしています。
これらのエンドポイントにアクセスするには、中国リージョン固有のアカウント認証情報を別途取得する必要があります。詳細については、「[中国でのサインアップ、アカウント、認証情報](https://docs.amazonaws.cn/en_us/aws/latest/userguide/accounts-and-credentials.html)」を参照してください。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/keyspaces/latest/devguide/programmatic.endpoints.html)
## ストリームエンドポイント
Amazon Keyspaces CDC streams は以下の で利用できます AWS リージョン。この表は、各リージョンで使用可能なデュアルスタックサービスエンドポイントを示しています。詳細については Amazon Keyspaces CDC streams、「」を参照してください[Amazon Keyspaces で CDC ストリームエンドポイントにアクセスする方法](CDC_access-endpoints.md)。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/keyspaces/latest/devguide/programmatic.endpoints.html)
# デュアルスタックエンドポイントへの接続
Amazon Keyspaces グローバルエンドポイントは、IPv4 および IPv6 リクエストを受け入れるデュアルスタックエンドポイントです。
IPv6 を使用して Amazon Keyspaces に接続すると、サービスは自動的にシステムテーブルレスポンスを接続プロトコルに合わせて調整します。これにより、アプリケーションは接続タイプに一致する一貫したネットワークアドレス情報を受信できます。これにより、既存の CQL アプリケーションの下位互換性を維持しながら、クライアントに正確なネットワークトポロジ情報が提供されます。
Amazon Keyspaces は、クライアント接続で使用されるネットワークプロトコル (IPv4 または IPv6) を自動的に検出し、それに応じてシステムテーブルのレスポンスを調整します。この検出は、最初の接続ハンドシェイク中に透過的に行われるため、クライアントアプリケーションからの追加の設定は必要ありません。
Amazon Keyspaces は、接続プロトコルに基づいて IP アドレスを返します。例えば、IPv4 ネットワークからのリクエストは次のレスポンスを返します。
```
SELECT * FROM system.peers;
-- Returns IPv4 addresses in peer column
-- Example: 172.31.1.1, 172.31.1.2, etc.
```
IPv6 ネットワークから などのデュアルスタックエンドポイントへの接続は`cassandra.us-east-1.api.aws`、次のレスポンスを返します。
```
SELECT * FROM system.peers;
-- Returns IPv6 addresses in peer column
-- Example: 2001:db8::1, 2001:db8::2, etc.
```
Amazon Keyspaces での IPv6 サポートの詳細については、「」を参照してください[Amazon Keyspaces での IPv6 サポート](ipv6-support.md)。
# Amazon Keyspaces での IPv6 サポート
Amazon Keyspaces での IPv6 サポートにより、アプリケーションはIPv4 と比較して大幅に拡張されたアドレススペースを提供する次世代インターネットプロトコルであるインターネットプロトコルバージョン 6 を使用して接続を確立できます。この実装では、IPv4 と IPv6 の両方を同時にサポートするデュアルスタックエンドポイントが使用され、将来の対応が可能な接続を可能にしながら下位互換性を確保します。; エンドポイントのリストについては、「[グローバルエンドポイント](programmatic.endpoints.md#global_endpoints)」を参照してください。
Amazon Keyspaces は、IPv6 接続を有効にしながら完全な下位互換性を維持するデュアルスタックアーキテクチャを通じて IPv6 サポートを実装します。
## Amazon Keyspaces での DNS 解決
アプリケーションがデュアルスタックエンドポイントに接続すると、DNS 解決プロセスは両方のアドレスタイプを返します。
レコード (IPv4)
下位互換性のための従来の IPv4 アドレス
AAAA レコード (IPv6)
最新の接続用の新しい IPv6 アドレス
クライアントのオペレーティングシステムとネットワークスタックは、ローカル設定、ネットワークの可用性、システム設定に基づいて、最適なプロトコルを自動的に選択します。
Cassandra クエリ言語 (CQL) プロトコルは、アプリケーションコードの変更を必要とせずに IPv6 接続をシームレスにサポートします。
自動プロトコル選択
+ アプリケーションがデュアルスタックエンドポイントを指定する
+ ネットワークスタックが可用性に基づいて IPv4 または IPv6 を選択する
+ 既存の CQL アプリケーションにコードの変更は必要ありません
ドライバーの互換性
+ すべての主要な CQL ドライバーが IPv6 を透過的にサポート
+ DataStax ドライバーは IPv6 アドレスをネイティブに処理します
+ オープンソースドライバーは変更なしで動作する
接続の一貫性
+ システムテーブルには、使用される接続プロトコルが反映されます。
+ IPv6 接続は で IPv6 アドレスを表示します `system.peers`
+ IPv4 接続に IPv4 アドレスが表示され続ける
# `cqlsh` を使用した Amazon Keyspaces への接続
`cqlsh` で Amazon Keyspaces に接続するには、`cqlsh-expansion` を使用します。このツールキットには、`cqlsh` や Apache Cassandra との完全な互換性を維持して、Amazon Keyspaces 用に事前設定した一般的な Apache Cassandra ツールなどのヘルパーが含まれています。`cqlsh-expansion` は、SigV4 認証プラグインを統合しているため、ユーザー名とパスワードを使用する代わりに、IAM アクセスキーで接続できます。Amazon Keyspaces はサーバーレスなので、`cqlsh` スクリプトをインストールするだけで接続でき、Apache Cassandraディストリビューション一式をインストールする必要はありません。この軽量インストールパッケージには、`cqlsh-expansion` と、Python をサポートするプラットフォームであればどのプラットフォームにもインストールできるクラシック `cqlsh` スクリプトが含まれています。
**注記**
`Murmur3Partitioner` は、Amazon Keyspaces と `cqlsh-expansion` に推奨されるパーティショナーです。`cqlsh-expansion` は Amazon Keyspaces `DefaultPartitioner` に対応していません。詳細については、「[Amazon Keyspaces でのパーティショナーの操作](working-with-partitioners.md)」を参照してください。
「`cqlsh`」の詳細については、[「`cqlsh`: CQL シェル」](https://cassandra.apache.org/doc/latest/cassandra/managing/tools/cqlsh.html) を参照してください。
**Topics**
+ [`cqlsh-expansion` による Amazon Keyspaces までの接続](#using_cqlsh)
+ [TLS の `cqlsh` 接続を手動で設定する方法](#encrypt_using_tls)
## `cqlsh-expansion` による Amazon Keyspaces までの接続
**`cqlsh-expansion` のインストールと設定**
1. `cqlsh-expansion` Python パッケージをインストールするには、`pip` コマンドを実行します。これにより、*pip install* と依存関係のリストを保存したファイルとともに、`cqlsh-expansion` スクリプトがマシンにインストールされます。`--user flag` は、プラットフォームの Python ユーザーインストールディレクトリを使用するように `pip` に指示します。Unix ベースのシステムでは、それが `~/.local/` ディレクトリになるはずです。
`cqlsh-expansion` をインストールするには Python 3 が必要です。使用している Python のバージョンを確認するには、`Python --version` を使用してください。インストールするには、次のコマンドを実行します。
```
python3 -m pip install --user cqlsh-expansion
```
出力は次のようになります。
```
Collecting cqlsh-expansion
Downloading cqlsh_expansion-0.9.6-py3-none-any.whl (153 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 153.7/153.7 KB 3.3 MB/s eta 0:00:00
Collecting cassandra-driver
Downloading cassandra_driver-3.28.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (19.1 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 19.1/19.1 MB 44.5 MB/s eta 0:00:00
Requirement already satisfied: six>=1.12.0 in /usr/lib/python3/dist-packages (from cqlsh-expansion) (1.16.0)
Collecting boto3
Downloading boto3-1.29.2-py3-none-any.whl (135 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 135.8/135.8 KB 17.2 MB/s eta 0:00:00
Collecting cassandra-sigv4>=4.0.2
Downloading cassandra_sigv4-4.0.2-py2.py3-none-any.whl (9.8 kB)
Collecting botocore<1.33.0,>=1.32.2
Downloading botocore-1.32.2-py3-none-any.whl (11.4 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 11.4/11.4 MB 60.9 MB/s eta 0:00:00
Collecting s3transfer<0.8.0,>=0.7.0
Downloading s3transfer-0.7.0-py3-none-any.whl (79 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 79.8/79.8 KB 13.1 MB/s eta 0:00:00
Collecting jmespath<2.0.0,>=0.7.1
Downloading jmespath-1.0.1-py3-none-any.whl (20 kB)
Collecting geomet<0.3,>=0.1
Downloading geomet-0.2.1.post1-py3-none-any.whl (18 kB)
Collecting python-dateutil<3.0.0,>=2.1
Downloading python_dateutil-2.8.2-py2.py3-none-any.whl (247 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 247.7/247.7 KB 33.1 MB/s eta 0:00:00
Requirement already satisfied: urllib3<2.1,>=1.25.4 in /usr/lib/python3/dist-packages (from botocore<1.33.0,>=1.32.2->boto3->cqlsh-expansion) (1.26.5)
Requirement already satisfied: click in /usr/lib/python3/dist-packages (from geomet<0.3,>=0.1->cassandra-driver->cqlsh-expansion) (8.0.3)
Installing collected packages: python-dateutil, jmespath, geomet, cassandra-driver, botocore, s3transfer, boto3, cassandra-sigv4, cqlsh-expansion
WARNING: The script geomet is installed in '/home/ubuntu/.local/bin' which is not on PATH.
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
WARNING: The scripts cqlsh, cqlsh-expansion and cqlsh-expansion.init are installed in '/home/ubuntu/.local/bin' which is not on PATH.
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed boto3-1.29.2 botocore-1.32.2 cassandra-driver-3.28.0 cassandra-sigv4-4.0.2 cqlsh-expansion-0.9.6 geomet-0.2.1.post1 jmespath-1.0.1 python-dateutil-2.8.2 s3transfer-0.7.0
```
インストールディレクトリが `PATH` にない場合は、オペレーティングシステムの指示に従って追加する必要があります。以下は、Ubuntu Linux の場合の一例です。
```
export PATH="$PATH:/home/ubuntu/.local/bin"
```
パッケージがインストールされたことを確認するためには、次のコマンドを実行します。
```
cqlsh-expansion --version
```
出力は次のようになります。
```
cqlsh 6.1.0
```
1. `cqlsh-expansion` を設定するには、インストール後のスクリプトを実行して次の手順を自動的に完了させることができます。
1. `.cassandra` ディレクトリがなければ、ユーザーのホームディレクトリに作成します。
1. 事前設定済みの `cqlshrc` 設定ファイルを `.cassandra` ディレクトリにコピーします。
1. 結合された証明書ファイルを `.cassandra` ディレクトリにコピーします。Amazon Keyspaces では、この証明書で、Transport Layer Security (TLS) との安全な接続を設定します。転送時の暗号化では、Amazon Keyspaces との間で送受信するときにデータを暗号化することによって、データ保護のレイヤーを追加します。証明書の詳細については、「」を参照してください[TLS の `cqlsh` 接続を手動で設定する方法](#encrypt_using_tls)。
このスクリプトを最初に確認するため、[https://github.com/aws-samples/amazon-keyspaces-toolkit/blob/master/cqlsh-expansion/cqlsh_expansion/post_install.py](https://github.com/aws-samples/amazon-keyspaces-toolkit/blob/master/cqlsh-expansion/cqlsh_expansion/post_install.py) にある Github リポジトリからスクリプトにアクセスします。
スクリプトを使用するには、次のコマンドを実行します。
```
cqlsh-expansion.init
```
**注記**
ポストインストールスクリプトによって作成されるディレクトリとファイルは、`pip uninstall` で `cqlsh-expansion` をアンインストールしても削除されないため、手動で削除する必要があります。
**`cqlsh-expansion` を使用した Amazon Keyspaces への接続**
1. を設定し AWS リージョン 、ユーザー環境変数として追加します。
デフォルトリージョンを Unix ベースシステムの環境変数として追加するには、次のコマンドを実行します。この例では、 を使用します`us-east-1`。
```
export AWS_DEFAULT_REGION=us-east-1
```
他のプラットフォーム用など、環境変数の設定方法の詳細については、「[環境変数を設定する方法](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html#envvars-set)」を参照してください。
1. サービスエンドポイントを検索します。
リージョンに適したサービスエンドポイントを選択します。Amazon Keyspaces で使用可能なエンドポイントを確認するには、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。この例では、`cassandra.us-east-1.amazonaws.com` エンドポイントを使用します。
1. 認証方法を設定します。
IAM アクセスキー (IAM ユーザー、ロール、フェデレーテッドアイデンティティ) を使用した接続が、セキュリティ強化のための推奨方法です。
IAM アクセスキーで続する前に、以下の手順を完了してください。
1. IAM ユーザーを作成するか、ベストプラクティスに従って IAM ユーザーが引き受けることができる IAM ロールを作成します。IAM アクセスキーの作成方法の詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
1. Amazon Keyspaces に少なくとも読み取り専用アクセス権限を与えるロール（または IAM ユーザー）を作成します。IAM ユーザーまたはロールが Amazon Keyspaces に接続するために必要な権限の詳細については、「[Amazon Keyspaces テーブルへのアクセス](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-one-table)」を参照してください。
1. 次の例のように、IAM ユーザーのアクセスキーをユーザーの環境変数に追加します。
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
他のプラットフォームなど、環境変数の設定方法の詳細については、「[環境変数を設定する方法](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html#envvars-set)」を参照してください。
**注記**
Amazon EC2 インスタンスから接続する場合は、そのインスタンスから Amazon Keyspaces へのトラフィックを許可するアウトバウンドルールをセキュリティグループで設定する必要もあります。EC2 アウトバウンドルールの表示方法と編集方法の詳細については、「Amazon EC2 ユーザーガイド」の「[セキュリティグループへのルールの追加](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule)」を参照してください。
1. `cqlsh-expansion` と SigV4 認証で Amazon Keyspaces に接続
`cqlsh-expansion` を使用して Amazon Keyspaces に接続するには、次のコマンドを使用します。必ずサービスエンドポイントを、リージョンに適したエンドポイントに置き換えてください。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
正常に接続されると次の例のような出力が表示されます。
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
cqlsh>
```
接続エラーが発生した場合は、「[cqlsh を使用して Amazon Keyspaces に接続できない](troubleshooting.connecting.md#troubleshooting.connection.cqlsh)」でトラブルシューティング情報をご確認ください。
+ サービス固有の認証情報で Amazon Keyspaces に接続します。
Cassandra が認証に使用する従来のユーザー名とパスワードの組み合わせで接続するには、[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md) にあるように、まず Amazon Keyspaces 用のサービス固有の認証情報を作成する必要があります。また、Amazon Keyspaces にアクセスするための権限をそのユーザーに与える必要があります。詳細については、「[Amazon Keyspaces テーブルへのアクセス](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-one-table)」を参照してください。
ユーザー用にサービス固有の認証情報と権限を作成したら、`cqlshrc` ファイルを更新します。通常、このファイルはユーザーディレクトリパス `~/.cassandra/` にあります。`cqlshrc` ファイル内の Cassandra `[authentication]` セクションに移動し、以下の例のように「;」文字を使用して `[auth_provider]` の下にある SigV4 モジュールとクラスをコメントアウトします。
```
[auth_provider]
; module = cassandra_sigv4.auth
; classname = SigV4AuthProvider
```
`cqlshrc` ファイルを更新すると、次のコマンドで Amazon Keyspaces に接続できます。サービス固有の認証情報で Amazon Keyspaces に接続できます。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 -u myUserName -p myPassword --ssl
```
**クリーンアップ**
+ `cqlsh-expansion` パッケージを削除するには、`pip uninstall` コマンドを使用します。
```
pip3 uninstall cqlsh-expansion
```
`pip3 uninstall` コマンドでは、インストール後のスクリプトによって作成されたディレクトリと関連ファイルは削除されません。ポストインストールスクリプトによって作成されたフォルダとファイルを削除するには、`.cassandra` ディレクトリを削除します。
## TLS の `cqlsh` 接続を手動で設定する方法
Amazon Keyspaces では、Transport Layer Security (TLS) を使用した安全な接続しか許容されません。証明書を自動的にダウンロードし、事前設定された`cqlshrc`設定ファイルをインストールする `cqlsh-expansion`ユーティリティを使用できます。詳細については、このページの「[`cqlsh-expansion` による Amazon Keyspaces までの接続](#using_cqlsh)」を参照してください。
証明書をダウンロードして接続を手動で設定する場合は、次の手順を実行します。
1. 次のデジタル証明書をダウンロードし、ローカルまたはホームディレクトリにファイルを保存します。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield クラス 2 ルート (オプション – 下位互換性用)
証明書をダウンロードするには、次のコマンドを使用できます。
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**注記**
Amazon Keyspaces は以前、Starfield Class 2 CA に固定された TLS 証明書を使用していました。 AWS は、Amazon Trust Services (Amazon ルート CAs で発行された証明書 AWS リージョン にすべて移行しています。この移行中に、Amazon ルート CAs 1～4 と Starfield ルートの両方を信頼するようにクライアントを設定し、すべてのリージョンで互換性を確保します。
1. ダウンロードしたすべての証明書を、この例の *keyspaces-bundle.pem* という名前の 1 つの`pem`ファイルに結合します。そのためには、以下の コマンドを実行します。ファイルへのパスを書き留めます。これは後で必要になります。
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
1. Cassandra ホームディレクトリにある `cqlshrc` 設定ファイル（`${HOME}/.cassandra/cqlshrc` など）を開いて、次の行を追加します。
```
[connection]
port = 9142
factory = cqlshlib.ssl.ssl_transport_factory
[ssl]
validate = true
certfile = path_to_file/keyspaces-bundle.pem
```
# AWS CLI を使用して Amazon Keyspaces に接続する
AWS Command Line Interface (AWS CLI) を使用して、コマンドラインから複数の AWS サービスを制御し、スクリプトを使用して自動化できます。Amazon Keyspaces では、テーブルの作成などのデータ定義言語 (DDL) オペレーション AWS CLI に を使用できます。さらに、Infrastructure as Code (IaC) サービスと、 AWS CloudFormation や Terraform などのツールを使用できます。
Amazon Keyspaces AWS CLI で を使用する前に、アクセスキー ID とシークレットアクセスキーを取得する必要があります。詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
で Amazon Keyspaces で使用できるすべてのコマンドの完全なリストについては AWS CLI、[https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/index.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/index.html)」を参照してください。
**Topics**
+ [のダウンロードと設定 AWS CLI](#access.cli.installcli)
+ [Amazon Keyspaces AWS CLI での の使用](#access.cli.usingcli)
## のダウンロードと設定 AWS CLI
AWS CLI は で入手できます[https://aws.amazon.com/cli](https://aws.amazon.com/cli)。Windows、macOS、または Linux 上で実行できます。をダウンロードしたら AWS CLI、以下の手順に従ってインストールして設定します。
1. [AWS Command Line Interface ユーザーガイド](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)に移動します。
1. 「[AWS CLIのインストール](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)と[AWS CLIの設定](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)」の手順に従ってください。
## Amazon Keyspaces AWS CLI での の使用
このコマンドラインは、Amazon Keyspaces オペレーション名の後にそのオペレーション用のパラメータが続く形式になっています。は、パラメータ値と JSON の短縮構文 AWS CLI をサポートしています。次の Amazon Keyspaces の例では、 AWS CLI 短縮構文を使用しています。詳細については、「 [CLI での短縮構文の使用 AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-shorthand.html)」を参照してください。
以下のコマンドは、*catalog* という名前のキースペースを作成します。
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
このコマンドは、リソースの Amazon リソースネーム (ARN) を出力に返します。
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/"
}
```
キースペース*カタログ*が存在することは、以下のコマンドで確認できます。
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
このコマンドの出力で、以下の値が返ります。
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/"
}
```
以下のコマンドで *book\$1wards* という名前のテーブルが作成されます。テーブルのパーティションキーは `year` 列と `award` 列で構成され、クラスタリングキーは `category` 列と `rank` 列で構成され、どちらのクラスタリング列も昇順でソートされます。(読みやすくするために、このセクションの長いコマンドは、複数の行に分かれています)。
```
aws keyspaces create-table --keyspace-name 'catalog' --table-name 'book_awards'
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},
{name=category,type=text}, {name=author,type=text},{name=book_title,type=text},{name=publisher,type=text}],
partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]'
```
このコマンドで、次の出力が返ります。
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
テーブルのメタデータとプロパティは、以下のコマンドで確認します。
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
このコマンドで、以下の出力が返ります。
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards",
"creationTimestamp": 1645564368.628,
"status": "ACTIVE",
"schemaDefinition": {
"allColumns": [
{
"name": "year",
"type": "int"
},
{
"name": "award",
"type": "text"
},
{
"name": "category",
"type": "text"
},
{
"name": "rank",
"type": "int"
},
{
"name": "author",
"type": "text"
},
{
"name": "book_title",
"type": "text"
},
{
"name": "publisher",
"type": "text"
}
],
"partitionKeys": [
{
"name": "year"
},
{
"name": "award"
}
],
"clusteringKeys": [
{
"name": "category",
"orderBy": "ASC"
},
{
"name": "rank",
"orderBy": "ASC"
}
],
"staticColumns": []
},
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": 1645564368.628
},
"encryptionSpecification": {
"type": "AWS_OWNED_KMS_KEY"
},
"pointInTimeRecovery": {
"status": "DISABLED"
},
"ttl": {
"status": "ENABLED"
},
"defaultTimeToLive": 0,
"comment": {
"message": ""
}
}
```
複雑なスキーマがあるテーブルを作成する場合、JSON ファイルからテーブルのスキーマ定義を読み込むと便利です。次に例を示します。[schema\$1definition.zip](samples/schema_definition.zip) からスキーマ定義のサンプル JSON ファイルをダウンロードし、ファイルへのパスを書き留めて `schema_definition.json` を抽出します。この例では、スキーマ定義 JSON ファイルは現在のディレクトリにあります。さまざまなファイルパスオプションについては、「[ファイルからパラメーターを読み込む方法](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how)」を参照してください。
```
aws keyspaces create-table --keyspace-name 'catalog'
--table-name 'book_awards' --schema-definition 'file://schema_definition.json'
```
次の例は、*myTable* という名前でオプションを追加した単純なテーブルを作成する方法です。読みやすくするために、コマンドは別々の行に分かれているので注意してください。このコマンドでは、テーブルの作成方法と次の操作を示します。
+ テーブルのキャパシティモードを設定する
+ テーブルでポイントインタイムリカバリを有効にする
+ テーブルのデフォルト有効期限 (TTL) 値を 1 年に設定する
+ テーブルに 2 つのタグを追加する
```
aws keyspaces create-table --keyspace-name 'catalog' --table-name 'myTable'
--schema-definition 'allColumns=[{name=id,type=int},{name=name,type=text},{name=date,type=timestamp}],partitionKeys=[{name=id}]'
--capacity-specification 'throughputMode=PROVISIONED,readCapacityUnits=5,writeCapacityUnits=5'
--point-in-time-recovery 'status=ENABLED'
--default-time-to-live '31536000'
--tags 'key=env,value=test' 'key=dpt,value=sec'
```
この例では、暗号化にカスタマーマネージドキーを使用し、列と行の有効期限を設定できるように TTL を有効にした新しいテーブルを作成する方法を説明します。このサンプルを実行するには、カスタマーマネージド AWS KMS キーのリソース ARN を独自のキーに置き換え、Amazon Keyspaces がそのキーにアクセスできることを確認する必要があります。
```
aws keyspaces create-table --keyspace-name 'catalog' --table-name 'myTable'
--schema-definition 'allColumns=[{name=id,type=int},{name=name,type=text},{name=date,type=timestamp}],partitionKeys=[{name=id}]'
--encryption-specification 'type=CUSTOMER_MANAGED_KMS_KEY,kmsKeyIdentifier=arn:aws:kms:us-east-1:111122223333:key/11111111-2222-3333-4444-555555555555'
--ttl 'status=ENABLED'
```
# API を使用して Amazon Keyspaces に接続する
AWS SDK と AWS Command Line Interface （AWS CLI) を使用して、Amazon Keyspaces とインタラクティブに連携できます。API で、キースペースやテーブルの作成など、データ言語定義 (DDL) の操作を同期なしで実行します。さらに、Infrastructure as Code (IaC) サービスと、 AWS CloudFormation や Terraform などのツールを使用できます。
Amazon Keyspaces AWS CLI で を使用する前に、アクセスキー ID とシークレットアクセスキーを取得する必要があります。詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
API の Amazon キースペースで使用できるすべてのオペレーションの完全なリストについては、「[https://docs.aws.amazon.com/keyspaces/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/keyspaces/latest/APIReference/Welcome.html)」を参照してください。
# Cassandra クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス
Amazon Keyspaces への接続には、サードパーティー製の多数のオープンソース Cassandra ドライバーを使用できます。Amazon Keyspaces は、Apache Cassandra バージョン 3.11.2 に対応している Cassandra ドライバーと互換性があります。以下に、Amazon Keyspaces での使用が推奨されるテスト済みのドライバーと最新バージョンを紹介します。
+ `Java v3.3`
+ `Java v4.17`
+ `Python Cassandra-driver 3.29.1`
+ `Node.js cassandra driver -v 4.7.2`
+ `GO using GOCQL v1.6`
+ `.NET CassandraCSharpDriver -v 3.20.1`
Cassandra ドライバーの詳細については、「[Apache Cassandra Client drivers(Apache Cassandra クライアントドライバー)](http://cassandra.apache.org/doc/latest/getting_started/drivers.html)」を参照してください。
**注記**
円滑に使用を開始するために、一般的なドライバーを使用して Amazon Keyspaces への接続を確立するエンドツーエンドのコード例を確認してダウンロードすることができます。GitHub で「[Amazon Keyspaces examplesmazon Keyspaces の例](https://github.com/aws-samples/amazon-keyspaces-examples)」を参照してください。
この章のチュートリアルには、Amazon Keyspaces への接続が正常に確立されたことを確認するための簡易 CQL クエリが含まれています。Amazon Keyspaces エンドポイントへの接続後にキースペースとテーブルを操作する方法については、「[Amazon Keyspaces (Apache Cassandra 向け) の CQL 言語リファレンス](cql.md)」を参照してください。Amazon VPC エンドポイントから Amazon Keyspaces に接続する方法を示すステップバイステップチュートリアルについては、「[チュートリアル: インターフェイス VPC エンドポイントを使用して Amazon Keyspaces に接続する](vpc-endpoints-tutorial.md)」を参照してください。
**Topics**
+ [Cassandra Java クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス](using_java_driver.md)
+ [Cassandra Python クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス](using_python_driver.md)
+ [Cassandra Node.js クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス](using_nodejs_driver.md)
+ [Cassandra .NET Core クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス](using_dotnetcore_driver.md)
+ [Cassandra Go クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス](using_go_driver.md)
+ [Cassandra Perl クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス](using_perl_driver.md)
# Cassandra Java クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス
このセクションでは、Java クライアントドライバーを使用して Amazon Keyspaces に接続する方法について説明します。
**注記**
Java 17 と DataStax Java ドライバー 4.17 は、現時点ではベータサポートのみです。詳細については、「[https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/](https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/)」を参照してください。
Amazon Keyspaces リソースへのプログラムアクセスに必要な認証情報を、ユーザーとアプリケーションに提供するには、次のいずれかを実行します。
+ 特定の AWS Identity and Access Management (IAM) ユーザーに関連付けられたサービス固有の認証情報を作成します。
+ セキュリティを強化するために、すべての AWS サービスで使用される IAM ID の IAM アクセスキーを作成することをお勧めします。Cassandra クライアントドライバー用の Amazon Keyspaces SigV4 認証プラグインを使用すると、ユーザー名とパスワードではなく IAM アクセスキーを使用して Amazon Keyspaces のコールの認証を行うことができます。詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
**注記**
Spring Boot で Amazon Keyspaces を使用する方法の例については、「[https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/spring](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/spring)」を参照してください。
**Topics**
+ [[開始する前に]](#using_java_driver.BeforeYouBegin)
+ [サービス固有の認証情報を使用して、Apache Cassandra 用の DataStax Java ドライバーで Amazon Keyspaces に接続するためのステップバイステップチュートリアル](#java_tutorial)
+ [Apache Cassandra 用の 4.x DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続するためのステップバイステップのチュートリアル](#java_tutorial.SigV4)
+ [Apache Cassandra 用 3.x DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する](#java3x_tutorial.SigV4)
## [開始する前に]
Amazon Keyspaces への接続を開始する前に、以下のタスクを行う必要があります。
1. Amazon Keyspaces では、クライアントとの安全な接続を確保するために Transport Layer Security (TLS) を使用する必要があります。
1. 次のデジタル証明書をダウンロードし、ローカルまたはホームディレクトリにファイルを保存します。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield クラス 2 ルート (オプション – 下位互換性用)
証明書をダウンロードするには、次のコマンドを使用できます。
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**注記**
Amazon Keyspaces は以前、Starfield クラス 2 CA に固定された TLS 証明書を使用していました。 AWS は、Amazon Trust Services (Amazon ルート CAs で発行された証明書 AWS リージョン にすべて移行しています。この移行中に、Amazon ルート CAs 1～4 と Starfield ルートの両方を信頼するようにクライアントを設定し、すべてのリージョンで互換性を確保します。
1. デジタル証明書を trustStore ファイルに変換し、キーストアに追加します。
```
openssl x509 -outform der -in AmazonRootCA1.pem -out temp_file.der
keytool -import -alias amazon-root-ca-1 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA2.pem -out temp_file.der
keytool -import -alias amazon-root-ca-2 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA3.pem -out temp_file.der
keytool -import -alias amazon-root-ca-3 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in AmazonRootCA4.pem -out temp_file.der
keytool -import -alias amazon-root-ca-4 -keystore cassandra_truststore.jks -file temp_file.der
openssl x509 -outform der -in sf-class2-root.crt -out temp_file.der
keytool -import -alias cassandra -keystore cassandra_truststore.jks -file temp_file.der
```
最後のステップでは、キーストアのパスワードを作成し、各証明書を信頼する必要があります。対話型コマンドは次のようになります。
```
Enter keystore password:
Re-enter new password:
Owner: CN=Amazon Root CA 1, O=Amazon, C=US
Issuer: CN=Amazon Root CA 1, O=Amazon, C=US
Serial number: 66c9fcf99bf8c0a39e2f0788a43e696365bca
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sun Jan 17 00:00:00 UTC 2038
Certificate fingerprints:
SHA1: 8D:A7:F9:65:EC:5E:FC:37:91:0F:1C:6E:59:FD:C1:CC:6A:6E:DE:16
SHA256: 8E:CD:E6:88:4F:3D:87:B1:12:5B:A3:1A:C3:FC:B1:3D:70:16:DE:7F:57:CC:90:4F:E1:CB:97:C6:AE:98:19:6E
Signature algorithm name: SHA256withRSA
Subject Public Key Algorithm: 2048-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: 84 18 CC 85 34 EC BC 0C 94 94 2E 08 59 9C C7 B2 ....4.......Y...
0010: 10 4E 0A 08 .N..
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 2, O=Amazon, C=US
Issuer: CN=Amazon Root CA 2, O=Amazon, C=US
Serial number: 66c9fd29635869f0a0fe58678f85b26bb8a37
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: 5A:8C:EF:45:D7:A6:98:59:76:7A:8C:8B:44:96:B5:78:CF:47:4B:1A
SHA256: 1B:A5:B2:AA:8C:65:40:1A:82:96:01:18:F8:0B:EC:4F:62:30:4D:83:CE:C4:71:3A:19:C3:9C:01:1E:A4:6D:B4
Signature algorithm name: SHA384withRSA
Subject Public Key Algorithm: 4096-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: B0 0C F0 4C 30 F4 05 58 02 48 FD 33 E5 52 AF 4B ...L0..X.H.3.R.K
0010: 84 E3 66 52 ..fR
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 3, O=Amazon, C=US
Issuer: CN=Amazon Root CA 3, O=Amazon, C=US
Serial number: 66c9fd5749736663f3b0b9ad9e89e7603f24a
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: 0D:44:DD:8C:3C:8C:1A:1A:58:75:64:81:E9:0F:2E:2A:FF:B3:D2:6E
SHA256: 18:CE:6C:FE:7B:F1:4E:60:B2:E3:47:B8:DF:E8:68:CB:31:D0:2E:BB:3A:DA:27:15:69:F5:03:43:B4:6D:B3:A4
Signature algorithm name: SHA256withECDSA
Subject Public Key Algorithm: 256-bit EC (secp256r1) key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: AB B6 DB D7 06 9E 37 AC 30 86 07 91 70 C7 9C C4 ......7.0...p...
0010: 19 B1 78 C0 ..x.
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: CN=Amazon Root CA 4, O=Amazon, C=US
Issuer: CN=Amazon Root CA 4, O=Amazon, C=US
Serial number: 66c9fd7c1bb104c2943e5717b7b2cc81ac10e
Valid from: Tue May 26 00:00:00 UTC 2015 until: Sat May 26 00:00:00 UTC 2040
Certificate fingerprints:
SHA1: F6:10:84:07:D6:F8:BB:67:98:0C:C2:E2:44:C2:EB:AE:1C:EF:63:BE
SHA256: E3:5D:28:41:9E:D0:20:25:CF:A6:90:38:CD:62:39:62:45:8D:A5:C6:95:FB:DE:A3:C2:2B:0B:FB:25:89:70:92
Signature algorithm name: SHA384withECDSA
Subject Public Key Algorithm: 384-bit EC (secp384r1) key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.19 Criticality=true
BasicConstraints:[
CA:true
PathLen:2147483647
]
#2: ObjectId: 2.5.29.15 Criticality=true
KeyUsage [
DigitalSignature
Key_CertSign
Crl_Sign
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: D3 EC C7 3A 65 6E CC E1 DA 76 9A 56 FB 9C F3 86 ...:en...v.V....
0010: 6D 57 E5 81 mW..
]
]
Trust this certificate? [no]: yes
Certificate was added to keystore
Enter keystore password:
Owner: OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US
Issuer: OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US
Serial number: 0
Valid from: Tue Jun 29 17:39:16 UTC 2004 until: Thu Jun 29 17:39:16 UTC 2034
Certificate fingerprints:
SHA1: AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A
SHA256: 14:65:FA:20:53:97:B8:76:FA:A6:F0:A9:95:8E:55:90:E4:0F:CC:7F:AA:4F:B7:C2:C8:67:75:21:FB:5F:B6:58
Signature algorithm name: SHA1withRSA (weak)
Subject Public Key Algorithm: 2048-bit RSA key
Version: 3
Extensions:
#1: ObjectId: 2.5.29.35 Criticality=false
AuthorityKeyIdentifier [
KeyIdentifier [
0000: BF 5F B7 D1 CE DD 1F 86 F4 5B 55 AC DC D7 10 C2 ._.......[U.....
0010: 0E A9 88 E7 ....
]
[OU=Starfield Class 2 Certification Authority, O="Starfield Technologies, Inc.", C=US]
SerialNumber: [ 00]
]
#2: ObjectId: 2.5.29.19 Criticality=false
BasicConstraints:[
CA:true
PathLen:2147483647
]
#3: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: BF 5F B7 D1 CE DD 1F 86 F4 5B 55 AC DC D7 10 C2 ._.......[U.....
0010: 0E A9 88 E7 ....
]
]
Warning:
The input uses the SHA1withRSA signature algorithm which is considered a security risk. This algorithm will be disabled in a future update.
Trust this certificate? [no]: yes
Certificate was added to keystore
```
1. JVM 引数に TrustStore ファイルをアタッチします。
```
-Djavax.net.ssl.trustStore=path_to_file/cassandra_truststore.jks
-Djavax.net.ssl.trustStorePassword=my_password
```
## サービス固有の認証情報を使用して、Apache Cassandra 用の DataStax Java ドライバーで Amazon Keyspaces に接続するためのステップバイステップチュートリアル
以下のステップバイステップチュートリアルでは、サービス固有の認証情報を使用して Cassandra 用 Java ドライバーで Amazon Keyspaces に接続する手順を説明します。具体的には、Apache Cassandra 用の DataStax Java ドライバーのバージョン 4.0 を使用します。
**Topics**
+ [ステップ 1: 前提条件](#java_tutorial.prereq)
+ [ステップ 2: ドライバーを設定する](#java_tutorial.driverconfiguration)
+ [ステップ 3: サンプルアプリケーションを実行する](#java_tutorial.application)
### ステップ 1: 前提条件
このチュートリアルに従って作業を行うには、サービス固有の認証情報を生成し、Apache Cassandra 用の DataStax Java ドライバーを Java プロジェクトに追加しておく必要があります。
+ 「[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md)」の手順を完了することで、Amazon Keyspaces IAM ユーザー向けにサービス固有の認証情報を生成します。認証に IAM アクセスキーを使用する場合は、「[Apache Cassandra 用の 4.x DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続するためのステップバイステップのチュートリアル](#java_tutorial.SigV4)」を参照してください。
+ Apache Cassandra 用の DataStax Java ドライバーを Java プロジェクトに追加します。Apache Cassandra 3.11.2 に対応しているドライバーバージョンを使用していることを確認します。詳細については、「[DataStax Java driver for Apache Cassandra documentation(Apache Cassandra 用 DataStax Java ドライバーのドキュメント)](https://github.com/datastax/java-driver)」を参照してください。
### ステップ 2: ドライバーを設定する
アプリケーション用の設定ファイルを作成すれば、DataStax Java Cassandra ドライバーの設定を指定できます。この設定ファイルは、デフォルト設定をオーバーライドし、ポート 9142 を使用して Amazon Keyspaces サービスエンドポイントに接続するようにドライバーに指示を与えます。利用可能なサービスエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
設定ファイルを作成し、アプリケーションのリソースフォルダ (例: `src/main/resources/application.conf`) に保存します。`application.conf` を開き、次の設定を追加します。
1. **認証プロバイダ** — `PlainTextAuthProvider` クラスを使用して認証プロバイダを作成します。*ServiceUserName* と *ServicePassword* は、[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md) の手順に従ってサービス固有の認証情報を生成したときに取得したユーザー名とパスワードと一致します。
**注記**
短期の認証情報を使用するには、ドライバー設定ファイルの認証情報をハードコードする代わりに、Apache Cassandra 用 DataStax Java ドライバーの認証プラグインを使用します。詳細を把握するには、「[Apache Cassandra 用の 4.x DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続するためのステップバイステップのチュートリアル](#java_tutorial.SigV4)」の指示に従ってください。
1. **ローカルデータセンター** — `local-datacenter` の値を、接続先のリージョンに設定します。例えば、アプリケーションを `cassandra.us-east-2.amazonaws.com` に接続する場合は、ローカルデータセンターを `us-east-2` に設定します。すべての利用可能な AWS リージョンについては「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。。負荷分散の対象となるノードの数を減らすように `slow-replica-avoidance = false` を設定します。
1. **SSL/TLS** — `class = DefaultSslEngineFactory` があるクラスを指定する 1 行を含む設定ファイルにセクションを追加することで、SSlengineFactory を初期化します。trustStore ファイルへのパスと、以前に作成したパスワードを提供します。Amazon Keyspaces はピアの `hostname-validation` をサポートしていないため、このオプションを false に設定してください。
```
datastax-java-driver {
basic.contact-points = [ "cassandra.us-east-2.amazonaws.com:9142"]
advanced.auth-provider{
class = PlainTextAuthProvider
username = "ServiceUserName"
password = "ServicePassword"
}
basic.load-balancing-policy {
local-datacenter = "us-east-2"
slow-replica-avoidance = false
}
advanced.ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "./src/main/resources/cassandra_truststore.jks"
truststore-password = "my_password"
hostname-validation = false
}
}
```
**注記**
trustStore へのパスを設定ファイル追加する代わりに、trustStore パスをアプリケーションコード直接追加することも、trustStore へのパスを JVM 引数に追加することもできます。
### ステップ 3: サンプルアプリケーションを実行する
このコード例は、先ほど作成した設定ファイルを使用して Amazon Keyspaces への接続プールを作成する単純なコマンドラインアプリケーションを示しています。これは、単純なクエリを実行することで、接続が確立されたことを確認するものです。
```
package ;
// add the following imports to your project
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
public class App
{
public static void main( String[] args )
{
//Use DriverConfigLoader to load your configuration file
DriverConfigLoader loader = DriverConfigLoader.fromClasspath("application.conf");
try (CqlSession session = CqlSession.builder()
.withConfigLoader(loader)
.build()) {
ResultSet rs = session.execute("select * from system_schema.keyspaces");
Row row = rs.one();
System.out.println(row.getString("keyspace_name"));
}
}
}
```
**注記**
`try` ブロックを使用して接続を確立し、その接続が常に閉じていることを確認します。`try` ブロックを使用しない場合は、リソースの漏洩を防ぐために必ず接続を閉じてください。
## Apache Cassandra 用の 4.x DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続するためのステップバイステップのチュートリアル
次のセクションでは、Apache Cassandra 用のオープンソース 4.x DataStax Java ドライバーに SigV4 認証プラグインを使用して、Amazon Keyspaces (Apache Cassandra 向け) にアクセスする方法について説明します。このプラグインは [GitHub リポジトリ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin)から入手できます。
この SigV4 認証プラグインを使用すると、Amazon Keyspaces に接続するときに、ユーザーまたはロールの IAM 認証情報を使用できます。このプラグインは、ユーザー名とパスワードを要求する代わりに、アクセスキーを使用して API リクエストに署名します。詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
### ステップ 1: 前提条件
このチュートリアルを実行するには、次のタスクを完了する必要があります。
+ まだ完了していない場合は、[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md) のステップに従って IAM ユーザーまたはロールの認証情報を作成します。このチュートリアルでは、アクセスキーが環境変数として保存されることを前提としています。詳細については、「[プログラムによるアクセス用のアクセスキーを保存する](aws.credentials.manage.md)」を参照してください。
+ Apache Cassandra 用の DataStax Java ドライバーを Java プロジェクトに追加します。Apache Cassandra 3.11.2 に対応しているドライバーバージョンを使用していることを確認します。詳細については、「[DataStax Java Driver for Apache Cassandra documentation (Apache Cassandra 用 DataStax Java ドライバーのドキュメント)](https://github.com/datastax/java-driver)」を参照してください。
+ 認証プラグインをアプリケーションに追加します。認証プラグインは、Apache Cassandra 用 DataStax Java ドライバーのバージョン 4.x に対応しています。Apache Maven を使用している場合、または Maven の依存関係を使用できるビルドシステムを使用している場合は、次の依存関係を `pom.xml` ファイルに追加します。
**重要**
[GitHub リポジトリ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin#add-the-authentication-plugin-to-the-application)に示されているように、プラグインのバージョンを最新バージョンに置き換えます。
```
software.aws.mcs
aws-sigv4-auth-cassandra-java-driver-plugin
4.0.9
```
### ステップ 2: ドライバーを設定する
アプリケーション用の設定ファイルを作成すれば、DataStax Java Cassandra ドライバーの設定を指定できます。この設定ファイルは、デフォルト設定をオーバーライドし、ポート 9142 を使用して Amazon Keyspaces サービスエンドポイントに接続するようにドライバーに指示を与えます。利用可能なサービスエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
設定ファイルを作成し、アプリケーションのリソースフォルダ (例: `src/main/resources/application.conf`) に保存します。`application.conf` を開き、次の設定を追加します。
1. **認証プロバイダ** — `advanced.auth-provider.class` を `software.aws.mcs.auth.SigV4AuthProvider` の新しいインスタンスに設定します。SigV4AuthProvider は、SigV4 認証を実行するためのプラグインによって提供される認証ハンドラです。
1. **ローカルデータセンター** — `local-datacenter` の値を、接続先のリージョンに設定します。例えば、アプリケーションを `cassandra.us-east-2.amazonaws.com` に接続する場合は、ローカルデータセンターを `us-east-2` に設定します。使用可能なすべての については AWS リージョン、「」を参照してください[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)。利用可能なすべてのノードで負荷を分散させるには、`slow-replica-avoidance = false` を設定します。
1. **Idempotence** – アプリケーションのデフォルトの `idempotence` を `true` に設定して、読み取り/書き込み/準備/実行のリクエストが失敗した場合に常に再試行するようにドライバーを設定します。これは、分散型アプリケーションではベストプラクティスであり、失敗したリクエストを再試行することで一時的な障害に対処できます。
1. **SSL/TLS** — `class = DefaultSslEngineFactory` があるクラスを指定する 1 行を含む設定ファイルにセクションを追加することで、SSlengineFactory を初期化します。trustStore ファイルへのパスと、以前に作成したパスワードを提供します。Amazon Keyspaces はピアの `hostname-validation` をサポートしていないため、このオプションを false に設定してください。
1. **接続数** – `local.size = 3` を設定して、エンドポイントごとに 3 つ以上のローカル接続を作成します。これは、アプリケーションがオーバーヘッドやトラフィックのバーストに対処するうえで役立つベストプラクティスです。予想されるトラフィックパターンに基づいて、アプリケーションが必要とするローカル接続の数をエンドポイントごとに計算する方法については、「[Amazon Keyspaces で接続を設定する方法](connections.md#connections.howtoconfigure)」を参照してください。
1. **再試行ポリシー** – Cassandra ドライバーに付属の `DefaultRetryPolicy` ではなく、Amazon Keyspaces の再試行ポリシー `AmazonKeyspacesExponentialRetryPolicy` を実装します。これにより、`AmazonKeyspacesExponentialRetryPolicy` の再試行回数をニーズに応じて設定できます。デフォルトでは、`AmazonKeyspacesExponentialRetryPolicy` の再試行回数は 3 に設定されています。詳細については、「[Amazon Keyspaces で接続の再試行ポリシーを設定する方法](connections.md#connections.retry-policies)」を参照してください。
1. **プリペアドステートメント** – ネットワーク使用量を最適化するため、`prepare-on-all-nodes` を false に設定します。
```
datastax-java-driver {
basic {
contact-points = [ "cassandra.us-east-2.amazonaws.com:9142"]
request {
timeout = 2 seconds
consistency = LOCAL_QUORUM
page-size = 1024
default-idempotence = true
}
load-balancing-policy {
local-datacenter = "us-east-2"
class = DefaultLoadBalancingPolicy
slow-replica-avoidance = false
}
}
advanced {
auth-provider {
class = software.aws.mcs.auth.SigV4AuthProvider
aws-region = us-east-2
}
ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "./src/main/resources/cassandra_truststore.jks"
truststore-password = "my_password"
hostname-validation = false
}
connection {
connect-timeout = 5 seconds
max-requests-per-connection = 512
pool {
local.size = 3
}
}
retry-policy {
class = com.aws.ssa.keyspaces.retry.AmazonKeyspacesExponentialRetryPolicy
max-attempts = 3
min-wait = 10 mills
max-wait = 100 mills
}
prepared-statements {
prepare-on-all-nodes = false
}
}
}
```
**注記**
trustStore へのパスを設定ファイル追加する代わりに、trustStore パスをアプリケーションコード直接追加することも、trustStore へのパスを JVM 引数に追加することもできます。
### ステップ 3: アプリケーションを実行する
このコード例は、先ほど作成した設定ファイルを使用して Amazon Keyspaces への接続プールを作成する単純なコマンドラインアプリケーションを示しています。これは、単純なクエリを実行することで、接続が確立されたことを確認するものです。
```
package ;
// add the following imports to your project
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import com.datastax.oss.driver.api.core.cql.Row;
public class App
{
public static void main( String[] args )
{
//Use DriverConfigLoader to load your configuration file
DriverConfigLoader loader = DriverConfigLoader.fromClasspath("application.conf");
try (CqlSession session = CqlSession.builder()
.withConfigLoader(loader)
.build()) {
ResultSet rs = session.execute("select * from system_schema.keyspaces");
Row row = rs.one();
System.out.println(row.getString("keyspace_name"));
}
}
}
```
**注記**
`try` ブロックを使用して接続を確立し、その接続が常に閉じていることを確認します。`try` ブロックを使用しない場合は、リソースの漏洩を防ぐために必ず接続を閉じてください。
## Apache Cassandra 用 3.x DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する
次のセクションでは、Apache Cassandra 用 3.x オープンソース DataStax Java ドライバーの SigV4 認証プラグインを使用して Amazon Keyspaces にアクセスする方法について説明します。このプラグインは [GitHub リポジトリ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible)から入手できます。
SigV4 認証プラグインを使用すると、Amazon Keyspaces に接続するときに、ユーザーとロールの IAM 認証情報を使用できます。このプラグインは、ユーザー名とパスワードを要求する代わりに、アクセスキーを使用して API リクエストに署名します。詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
### ステップ 1: 前提条件
このコードサンプルを実行するには、まず以下のタスクを完了する必要があります。
+ 「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」の手順に従って、IAM ユーザーまたはロールの認証情報を作成します。このチュートリアルでは、アクセスキーが環境変数として保存されることを前提としています。詳細については、「[プログラムによるアクセス用のアクセスキーを保存する](aws.credentials.manage.md)」を参照してください。
+ の手順に従って、デジタル証明書[[開始する前に]](#using_java_driver.BeforeYouBegin)をダウンロードして trustStore ファイルに変換し、JVM 引数のキーストアをアプリケーションにアタッチします。
+ Apache Cassandra 用の DataStax Java ドライバーを Java プロジェクトに追加します。Apache Cassandra 3.11.2 に対応しているドライバーバージョンを使用していることを確認します。詳細については、「[DataStax Java Driver for Apache Cassandra documentation (Apache Cassandra 用 DataStax Java ドライバーのドキュメント)](https://github.com/datastax/java-driver)」を参照してください。
+ 認証プラグインをアプリケーションに追加します。認証プラグインは、Apache Cassandra 用 DataStax Java ドライバーのバージョン 3.x に対応しています。Apache Maven を使用している場合、または Maven の依存関係を使用できるビルドシステムを使用している場合は、次の依存関係を `pom.xml` ファイルに追加します。[GitHub リポジトリ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible)に示されているように、プラグインのバージョンを最新バージョンに置き換えます。
```
software.aws.mcs
aws-sigv4-auth-cassandra-java-driver-plugin_3
3.0.3
```
### ステップ 2: アプリケーションを実行する
このコード例は、Amazon Keyspaces への接続プールを作成する単純なコマンドラインアプリケーションを示しています。これは、単純なクエリを実行することで、接続が確立されたことを確認するものです。
```
package ;
// add the following imports to your project
import software.aws.mcs.auth.SigV4AuthProvider;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Row;
import com.datastax.driver.core.Session;
public class App
{
public static void main( String[] args )
{
String endPoint = "cassandra.us-east-2.amazonaws.com";
int portNumber = 9142;
Session session = Cluster.builder()
.addContactPoint(endPoint)
.withPort(portNumber)
.withAuthProvider(new SigV4AuthProvider("us-east-2"))
.withSSL()
.build()
.connect();
ResultSet rs = session.execute("select * from system_schema.keyspaces");
Row row = rs.one();
System.out.println(row.getString("keyspace_name"));
}
}
```
使用に関する注意事項:
利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
Java ドライバーを Amazon Keyspaces で使用する場合に役立つ Java ドライバーポリシー ([https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers)) およびベストプラクティスについては、次のリポジトリを参照してください。
# Cassandra Python クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス
このセクションでは、Python クライアントドライバーを使用して Amazon Keyspaces に接続する方法について説明します。Amazon Keyspaces リソースへのプログラムアクセスに必要な認証情報を、ユーザーとアプリケーションに提供するには、次のいずれかを実行します。
+ 特定の AWS Identity and Access Management (IAM) ユーザーに関連付けられたサービス固有の認証情報を作成します。
+ セキュリティを強化するために、すべての AWS サービスで使用される IAM ユーザーまたはロールの IAM アクセスキーを作成することをお勧めします。Cassandra クライアントドライバー用の Amazon Keyspaces SigV4 認証プラグインを使用すると、ユーザー名とパスワードではなく IAM アクセスキーを使用して Amazon Keyspaces のコールの認証を行うことができます。詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
**Topics**
+ [[開始する前に]](#using_python_driver.BeforeYouBegin)
+ [Apache Cassandra 用の Python ドライバーとサービス固有の認証情報を使用して Amazon Keyspaces に接続する](#python_ssc)
+ [Apache Cassandra 用 DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する](#python_SigV4)
## [開始する前に]
開始する前に、次のタスクを完了する必要があります。
Amazon Keyspaces では、クライアントとの安全な接続を確保するために Transport Layer Security (TLS) を使用する必要があります。TLS を使用して Amazon Keyspaces に接続するには、Amazon デジタル証明書をダウンロードし、TLS を使用するように Python ドライバーを設定する必要があります。
次のデジタル証明書をダウンロードし、ローカルまたはホームディレクトリにファイルを保存します。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield クラス 2 ルート (オプション – 下位互換性用)
証明書をダウンロードするには、次のコマンドを使用できます。
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**注記**
Amazon Keyspaces は以前、Starfield クラス 2 CA に固定された TLS 証明書を使用していました。 AWS は、Amazon Trust Services (Amazon ルート CAs で発行された証明書 AWS リージョン にすべて移行しています。この移行中に、Amazon ルート CAs 1～4 と Starfield ルートの両方を信頼するようにクライアントを設定し、すべてのリージョンで互換性を確保します。
ダウンロードしたすべての証明書を、この例の *keyspaces-bundle.pem* という名前の 1 つの`pem`ファイルに結合します。そのためには、以下の コマンドを実行します。ファイルへのパスを書き留めます。これは後で必要になります。
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Apache Cassandra 用の Python ドライバーとサービス固有の認証情報を使用して Amazon Keyspaces に接続する
次のコード例では、Python クライアントドライバーとサービス固有の認証情報を使用して Amazon Keyspaces に接続する方法を示します。
```
from cassandra.cluster import Cluster
from ssl import SSLContext, PROTOCOL_TLSv1_2 , CERT_REQUIRED
from cassandra.auth import PlainTextAuthProvider
ssl_context = SSLContext(PROTOCOL_TLSv1_2 )
ssl_context.load_verify_locations('path_to_file/keyspaces-bundle.pem')
ssl_context.verify_mode = CERT_REQUIRED
auth_provider = PlainTextAuthProvider(username='ServiceUserName', password='ServicePassword')
cluster = Cluster(['cassandra.us-east-2.amazonaws.com'], ssl_context=ssl_context, auth_provider=auth_provider, port=9142)
session = cluster.connect()
r = session.execute('select * from system_schema.keyspaces')
print(r.current_rows)
```
使用に関する注意事項:
1. を、最初のステップで保存した結合証明書ファイルへのパス`"path_to_file/keyspaces-bundle.pem"`に置き換えます。
1. *ServiceUserName* と *ServicePassword* が、[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md) の手順に従ってサービス固有の認証情報を生成したときに取得したユーザー名とパスワードと一致していることを確認してください。
1. 利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
## Apache Cassandra 用 DataStax Java ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する
次のセクションでは、Apache Cassandra 用オープンソース DataStax Python ドライバーの SigV4 認証プラグインを使用して、Amazon Keyspaces (Apache Cassandra 向け) にアクセスする方法を示します。
まだ完了していない場合は、[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md) のステップに従って IAM ロールの認証情報の作成を開始します。このチュートリアルでは、IAM ロールを必要とする一時認証情報を使用します。一時認証情報の詳細については、「[IAM ロールと SigV4 プラグインで Amazon Keyspaces に接続するための一時的な認証情報を作成する](temporary.credentials.IAM.md)」を参照してください。
次に、Python SigV4 認証プラグインを [GitHub リポジトリ](https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin)から環境に追加します。
```
pip install cassandra-sigv4
```
次のコード例では、Cassandra 用のオープンソース DataStax Python ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する方法を示します。プラグインは AWS SDK for Python (Boto3) によって異なります。`boto3.session` を使用して一時認証情報を取得します。
```
from cassandra.cluster import Cluster
from ssl import SSLContext, PROTOCOL_TLSv1_2 , CERT_REQUIRED
from cassandra.auth import PlainTextAuthProvider
import boto3
from cassandra_sigv4.auth import SigV4AuthProvider
ssl_context = SSLContext(PROTOCOL_TLSv1_2)
ssl_context.load_verify_locations('path_to_file/keyspaces-bundle.pem')
ssl_context.verify_mode = CERT_REQUIRED
# use this if you want to use Boto to set the session parameters.
boto_session = boto3.Session(aws_access_key_id="AKIAIOSFODNN7EXAMPLE",
aws_secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
aws_session_token="AQoDYXdzEJr...",
region_name="us-east-2")
auth_provider = SigV4AuthProvider(boto_session)
# Use this instead of the above line if you want to use the Default Credentials and not bother with a session.
# auth_provider = SigV4AuthProvider()
cluster = Cluster(['cassandra.us-east-2.amazonaws.com'], ssl_context=ssl_context, auth_provider=auth_provider,
port=9142)
session = cluster.connect()
r = session.execute('select * from system_schema.keyspaces')
print(r.current_rows)
```
使用に関する注意事項:
1. `"path_to_file/keyspaces-bundle.pem"` を、最初のステップで保存した証明書へのパスに置き換えてください。
1. *aws\$1access\$1key\$1id*、*aws\$1secret\$1access\$1key*、*aws\$1session\$1token* が、`boto3.session` を使用して入手した `Access Key`、`Secret Access Key`、`Session Token` に一致していることを確認します。詳細については、*AWS SDK for Python (Boto3)* の[「Credentials」](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html)(認証情報) を参照してください。
1. 利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
# Cassandra Node.js クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス
このセクションでは、Node.js クライアントドライバーを使用して Amazon Keyspaces に接続する方法を説明します。Amazon Keyspaces リソースへのプログラムアクセスに必要な認証情報を、ユーザーとアプリケーションに提供するには、次のいずれかを実行します。
+ 特定の AWS Identity and Access Management (IAM) ユーザーに関連付けられたサービス固有の認証情報を作成します。
+ セキュリティを強化するために、すべての AWS サービスで使用される IAM ユーザーまたはロールの IAM アクセスキーを作成することをお勧めします。Cassandra クライアントドライバー用の Amazon Keyspaces SigV4 認証プラグインを使用すると、ユーザー名とパスワードではなく IAM アクセスキーを使用して Amazon Keyspaces のコールの認証を行うことができます。詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
**Topics**
+ [[開始する前に]](#using_nodejs_driver.BeforeYouBegin)
+ [Apache Cassandra 用の Node.js DataStax ドライバーとサービス固有の認証情報を使用して Amazon Keyspaces に接続する](#nodejs_ssc)
+ [Apache Cassandra 用 DataStax Node.js ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する](#nodejs_SigV4)
## [開始する前に]
開始する前に、次のタスクを完了する必要があります。
Amazon Keyspaces では、クライアントとの安全な接続を確保するために Transport Layer Security (TLS) を使用する必要があります。TLS を使用して Amazon Keyspaces に接続するには、Amazon デジタル証明書をダウンロードし、TLS を使用するように Python ドライバーを設定する必要があります。
次のデジタル証明書をダウンロードし、ローカルまたはホームディレクトリにファイルを保存します。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield クラス 2 ルート (オプション – 下位互換性用)
証明書をダウンロードするには、次のコマンドを使用できます。
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**注記**
Amazon Keyspaces は以前、Starfield クラス 2 CA に固定された TLS 証明書を使用していました。 AWS は、Amazon Trust Services (Amazon ルート CAs で発行された証明書 AWS リージョン にすべて移行しています。この移行中に、Amazon ルート CAs 1～4 と Starfield ルートの両方を信頼するようにクライアントを設定し、すべてのリージョンで互換性を確保します。
ダウンロードしたすべての証明書を、この例の *keyspaces-bundle.pem* という名前の 1 つの`pem`ファイルに結合します。そのためには、以下の コマンドを実行します。ファイルへのパスを書き留めます。これは後で必要になります。
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Apache Cassandra 用の Node.js DataStax ドライバーとサービス固有の認証情報を使用して Amazon Keyspaces に接続する
TLS `keyspaces-bundle.pem`の結合証明書ファイルを使用し、サービス固有の認証情報を使用して認証するようにドライバーを設定します。例えば、次のようになります。
```
const cassandra = require('cassandra-driver');
const fs = require('fs');
const auth = new cassandra.auth.PlainTextAuthProvider('ServiceUserName', 'ServicePassword');
const sslOptions1 = {
ca: [
fs.readFileSync('path_to_file/keyspaces-bundle.pem', 'utf-8')],
host: 'cassandra.us-west-2.amazonaws.com',
rejectUnauthorized: true
};
const client = new cassandra.Client({
contactPoints: ['cassandra.us-west-2.amazonaws.com'],
localDataCenter: 'us-west-2',
authProvider: auth,
sslOptions: sslOptions1,
protocolOptions: { port: 9142 }
});
const query = 'SELECT * FROM system_schema.keyspaces';
client.execute(query)
.then( result => console.log('Row from Keyspaces %s', result.rows[0]))
.catch( e=> console.log(`${e}`));
```
使用に関する注意事項:
1. を、最初のステップで保存した結合証明書ファイルへのパス`"path_to_file/keyspaces-bundle.pem"`に置き換えます。
1. *ServiceUserName* と *ServicePassword* が、[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md) の手順に従ってサービス固有の認証情報を生成したときに取得したユーザー名とパスワードと一致していることを確認してください。
1. 利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
## Apache Cassandra 用 DataStax Node.js ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する
次のセクションでは、Apache Cassandra 用オープンソース DataStax Node.js ドライバーの SigV4 認証プラグインを使用して、Amazon Keyspaces (Apache Cassandra 向け) にアクセスする方法を示します。
まだ完了していない場合は、[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md) のステップに従って IAM ユーザーまたはロールの認証情報を作成します。
Node.js SigV4 認証プラグインを [GitHub リポジトリ](https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin)からアプリケーションに追加します。プラグインは、Cassandra 用の DataStax Node.js ドライバーのバージョン 4.x をサポートし、 AWS SDK for Node.js に依存します。認証情報の取得には `AWSCredentialsProvider` が使用されます。
```
$ npm install aws-sigv4-auth-cassandra-plugin --save
```
次のコード例で、`SigV4AuthProvider` のリージョン固有のインスタンスを認証プロバイダーとして設定する方法について説明します。
```
const cassandra = require('cassandra-driver');
const fs = require('fs');
const sigV4 = require('aws-sigv4-auth-cassandra-plugin');
const auth = new sigV4.SigV4AuthProvider({
region: 'us-west-2',
accessKeyId:'AKIAIOSFODNN7EXAMPLE',
secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'});
const sslOptions1 = {
ca: [
fs.readFileSync('path_to_file/keyspaces-bundle.pem', 'utf-8')],
host: 'cassandra.us-west-2.amazonaws.com',
rejectUnauthorized: true
};
const client = new cassandra.Client({
contactPoints: ['cassandra.us-west-2.amazonaws.com'],
localDataCenter: 'us-west-2',
authProvider: auth,
sslOptions: sslOptions1,
protocolOptions: { port: 9142 }
});
const query = 'SELECT * FROM system_schema.keyspaces';
client.execute(query).then(
result => console.log('Row from Keyspaces %s', result.rows[0]))
.catch( e=> console.log(`${e}`));
```
使用に関する注意事項:
1. `"path_to_file/keyspaces-bundle.pem"` を、最初のステップで保存した証明書へのパスに置き換えてください。
1. *accessKeyId* と *secretAccessKey* が、`AWSCredentialsProvider` を使用して取得したアクセスキーとシークレットアクセスキーに一致していることを確認してください。詳細については、*「AWS SDK for JavaScript in Node.js」*(Node.js での JavaScript の SDK) の[「Setting Credentials in Node.js」](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html)(Node.js での認証情報の設定) を参照してください。
1. アクセスキーをコード外に保存するには、[プログラムによるアクセス用のアクセスキーを保存する](aws.credentials.manage.md) のベストプラクティスを参照してください。
1. 利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
# Cassandra .NET Core クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス
このセクションでは、.NET Core クライアントドライバーを使用して Amazon Keyspaces に接続する方法について説明します。セットアップ手順が環境やオペレーティングシステムによって異なるため、状況によっては手順の変更が必要になることがあります。Amazon Keyspaces では、クライアントとの安全な接続を確保するために Transport Layer Security (TLS) を使用する必要があります。TLS を使用して Amazon Keyspaces に接続するには、Amazon ルート CAs 1～4 を含むシステムトラストストアを使用するようにドライバーを設定します。
1. NuGet コンソールを使用して、NuGet から CassandraCSharpDriver をインストールします。
```
PM> Install-Package CassandraCSharpDriver
```
1. 次の例では、.NET Core C\$1 コンソールプロジェクトを使用して Amazon Keyspaces に接続し、クエリを実行します。
```
using Cassandra;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Security;
using System.Runtime.ConstrainedExecution;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
namespace CSharpKeyspacesExample
{
class Program
{
public Program(){}
static void Main(string[] args)
{
var userName = "ServiceUserName";
var pwd = "ServicePassword";
certCollection.Add(amazoncert);
var awsEndpoint = "cassandra.us-east-2.amazonaws.com" ;
var cluster = Cluster.Builder()
.AddContactPoints(awsEndpoint)
.WithPort(9142)
.WithAuthProvider(new PlainTextAuthProvider(userName, pwd))
.WithSSL(new SSLOptions().SetCertificateCollection(certCollection))
.Build();
var session = cluster.Connect();
var rs = session.Execute("SELECT * FROM system_schema.tables;");
foreach (var row in rs)
{
var name = row.GetValue("keyspace_name");
Console.WriteLine(name);
}
}
}
}
```
使用に関する注意事項:
1. Amazon ルート CAs 1～4 を含むデフォルトのシステムトラストストアを使用していることを確認してください。
1. *ServiceUserName* と *ServicePassword* が、[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md) の手順に従ってサービス固有の認証情報を生成したときに取得したユーザー名とパスワードと一致していることを確認してください。
1. 利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
# Cassandra Go クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス
このセクションでは、Go Cassandra クライアントドライバーを使用して Amazon Keyspaces に接続する方法を説明します。Amazon Keyspaces リソースへのプログラムアクセスに必要な認証情報を、ユーザーとアプリケーションに提供するには、次のいずれかを実行します。
+ 特定の AWS Identity and Access Management (IAM) ユーザーに関連付けられたサービス固有の認証情報を作成します。
+ セキュリティを強化するために、すべての AWS サービスで使用される IAM プリンシパルの IAM アクセスキーを作成することをお勧めします。Cassandra クライアントドライバー用の Amazon Keyspaces SigV4 認証プラグインを使用すると、ユーザー名とパスワードではなく IAM アクセスキーを使用して Amazon Keyspaces のコールの認証を行うことができます。詳細については、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」を参照してください。
**Topics**
+ [[開始する前に]](#using_go_driver.BeforeYouBegin)
+ [Apache Cassandra 用の Gocql ドライバーとサービス固有の認証情報を使用して Amazon Keyspaces に接続する](#go_ssc)
+ [Apache Cassandra 用の Go ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する](#go_SigV4)
## [開始する前に]
開始する前に、次のタスクを完了する必要があります。
Amazon Keyspaces では、クライアントとの安全な接続を確保するために Transport Layer Security (TLS) を使用する必要があります。TLS を使用して Amazon Keyspaces に接続するには、Amazon デジタル証明書をダウンロードし、TLS を使用するように Go ドライバーを設定する必要があります。
次のデジタル証明書をダウンロードし、ローカルまたはホームディレクトリにファイルを保存します。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield クラス 2 ルート (オプション – 下位互換性用)
証明書をダウンロードするには、次のコマンドを使用できます。
```
curl -O https://www.amazontrust.com/repository/AmazonRootCA1.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA2.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA3.pem
curl -O https://www.amazontrust.com/repository/AmazonRootCA4.pem
curl -O https://certs.secureserver.net/repository/sf-class2-root.crt
```
**注記**
Amazon Keyspaces は以前、Starfield クラス 2 CA に固定された TLS 証明書を使用していました。 AWS は、Amazon Trust Services (Amazon ルート CAs で発行された証明書 AWS リージョン にすべて移行しています。この移行中に、Amazon ルート CAs 1～4 と Starfield ルートの両方を信頼するようにクライアントを設定し、すべてのリージョンで互換性を確保します。
ダウンロードしたすべての証明書を、この例の *keyspaces-bundle.pem* という名前の 1 つの`pem`ファイルに結合します。そのためには、以下の コマンドを実行します。ファイルへのパスを書き留めます。これは後で必要になります。
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Apache Cassandra 用の Gocql ドライバーとサービス固有の認証情報を使用して Amazon Keyspaces に接続する
1. アプリケーション用の新しいディレクトリを作成します。
```
mkdir ./gocqlexample
```
1. 新しいディレクトリに移動します。
```
cd gocqlexample
```
1. アプリケーション用のファイルを作成します。
```
touch cqlapp.go
```
1. Go ドライバーをダウンロードします。
```
go get github.com/gocql/gocql
```
1. 次のサンプルコードを cqlapp.go ファイルに追加します。
```
package main
import (
"fmt"
"github.com/gocql/gocql"
"log"
)
func main() {
// add the Amazon Keyspaces service endpoint
cluster := gocql.NewCluster("cassandra.us-east-2.amazonaws.com")
cluster.Port=9142
// add your service specific credentials
cluster.Authenticator = gocql.PasswordAuthenticator{
Username: "ServiceUserName",
Password: "ServicePassword"}
// provide the path to the keyspaces-bundle.pem
cluster.SslOpts = &gocql.SslOptions{
CaPath: "path_to_file/keyspaces-bundle.pem",
EnableHostVerification: false,
}
// Override default Consistency to LocalQuorum
cluster.Consistency = gocql.LocalQuorum
cluster.DisableInitialHostLookup = false
session, err := cluster.CreateSession()
if err != nil {
fmt.Println("err>", err)
}
defer session.Close()
// run a sample query from the system keyspace
var text string
iter := session.Query("SELECT keyspace_name FROM system_schema.tables;").Iter()
for iter.Scan(&text) {
fmt.Println("keyspace_name:", text)
}
if err := iter.Close(); err != nil {
log.Fatal(err)
}
session.Close()
}
```
使用に関する注意事項:
1. を、最初のステップで保存した結合証明書ファイルへのパス`"path_to_file/keyspaces-bundle.pem"`に置き換えます。
1. *ServiceUserName* と *ServicePassword* が、[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md) の手順に従ってサービス固有の認証情報を生成したときに取得したユーザー名とパスワードと一致していることを確認してください。
1. 利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
1. プログラムを構築します。
```
go build cqlapp.go
```
1. プログラムを実行します。
```
./cqlapp
```
## Apache Cassandra 用の Go ドライバーと SigV4 認証プラグインを使用して Amazon Keyspaces に接続する
次のコードサンプルで、Apache Cassandra 用オープンソース Go ドライバーの SigV4 認証プラグインを使用して、Amazon Keyspaces (Apache Cassandra 向け) にアクセスする方法を示します。
IAM プリンシパル用の認証情報をまだ作成していない場合は、「[Amazon Keyspaces の AWS 認証情報の作成と設定](access.credentials.md)」の手順に従って作成します。Lambda または Amazon EC2 インスタンスで実行されているアプリケーションは、そのインスタンスの認証情報を自動的に使用します。このチュートリアルをローカルで実行するには、認証情報をローカル環境変数として保存します。
Go SigV4 認証プラグインを [GitHub リポジトリ](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin)からアプリケーションに追加します。プラグインは、Cassandra 用のオープンソース Go ドライバーのバージョン 1.2.x をサポートし、 AWS SDK for Go に依存します。
```
$ go mod init
$ go get github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin
```
このコードサンプルでは、Amazon Keyspaces エンドポイントは、`Cluster` クラスで表されています。クラスターの認証システムプロパティに対して `AwsAuthenticator` を使用して、認証情報を取得します。
```
package main
import (
"fmt"
"github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin/sigv4"
"github.com/gocql/gocql"
"log"
)
func main() {
// configuring the cluster options
cluster := gocql.NewCluster("cassandra.us-west-2.amazonaws.com")
cluster.Port=9142
// the authenticator uses the default credential chain to find AWS credentials
cluster.Authenticator = sigv4.NewAwsAuthenticator()
cluster.SslOpts = &gocql.SslOptions{
CaPath: "path_to_file/keyspaces-bundle.pem",
EnableHostVerification: false,
}
cluster.Consistency = gocql.LocalQuorum
cluster.DisableInitialHostLookup = false
session, err := cluster.CreateSession()
if err != nil {
fmt.Println("err>", err)
return
}
defer session.Close()
// doing the query
var text string
iter := session.Query("SELECT keyspace_name FROM system_schema.tables;").Iter()
for iter.Scan(&text) {
fmt.Println("keyspace_name:", text)
}
if err := iter.Close(); err != nil {
log.Fatal(err)
}
}
```
使用に関する注意事項:
1. を、最初のステップで保存した証明書ファイルへのパス`"path_to_file/keyspaces-bundle.pem"`に置き換えます。
1. このサンプルをローカルで実行するには、次の変数を環境変数として定義する必要があります。
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_DEFAULT_REGION`
1. アクセスキーをコード外に保存するには、[プログラムによるアクセス用のアクセスキーを保存する](aws.credentials.manage.md) のベストプラクティスを参照してください。
1. 利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
# Cassandra Perl クライアントドライバーを使用した Amazon Keyspaces へのプログラムアクセス
このセクションでは、Perl クライアントドライバーを使用して Amazon Keyspaces に接続する方法について説明します。このコードサンプルでは、Perl 5 を使用しました。Amazon Keyspaces では、クライアントとの安全な接続を確保するために Transport Layer Security (TLS) を使用する必要があります。
**重要**
Amazon Keyspacescertificates は Amazon Trust Services (ATS) 階層に移行しています。このローテーション中に接続エラーが発生しないように、環境が Amazon ルート CAs 1～4 を信頼していることを確認します。Perl ドライバーではサーバーの Amazon SSL 証明書が検証されないため、Amazon Keyspaces に接続していることを確認できません。Amazon Keyspaces への接続時にドライバーにより TLS が使用されるように設定するという 2 番目のステップは引き続き必要で、このステップにより、クライアントとサーバーの間で転送されるデータが確実に暗号化されます。
1. [https://metacpan.org/pod/DBD::Cassandra](https://metacpan.org/pod/DBD::Cassandra) から Cassandra DBI ドライバーをダウンロードして Perl 環境にインストールします。厳密には、環境によって手順が多少異なります。一般的な例を以下に示します。
```
cpanm DBD::Cassandra
```
1. アプリケーション用のファイルを作成します。
```
touch cqlapp.pl
```
1. 次のサンプルコードを cqlapp.pl ファイルに追加します。
```
use DBI;
my $user = "ServiceUserName";
my $password = "ServicePassword";
my $db = DBI->connect("dbi:Cassandra:host=cassandra.us-east-2.amazonaws.com;port=9142;tls=1;",
$user, $password);
my $rows = $db->selectall_arrayref("select * from system_schema.keyspaces");
print "Found the following Keyspaces...\n";
for my $row (@$rows) {
print join(" ",@$row['keyspace_name']),"\n";
}
$db->disconnect;
```
**重要**
*ServiceUserName* と *ServicePassword* が、[Amazon Keyspaces にプログラムによってアクセスするためのサービス固有の認証情報を作成する](programmatic.credentials.ssc.md) の手順に従ってサービス固有の認証情報を生成したときに取得したユーザー名とパスワードと一致していることを確認してください。
**注記**
利用可能なエンドポイントのリストについては、「[Amazon Keyspaces のサービスエンドポイント](programmatic.endpoints.md)」を参照してください。
1. アプリケーションを実行します。
```
perl cqlapp.pl
```
# VPC エンドポイントを使用して Amazon Keyspaces へのクロスアカウントアクセスを設定する
個別の を作成して使用 AWS アカウント することで、リソースを分離し、開発や本番稼働などのさまざまな環境で使用できます。このトピックでは、 Amazon Virtual Private Cloudのインターフェイス VPC エンドポイントによる Amazon Keyspaces へのクロスアカウントアクセスについて説明します。IAM のクロスアカウントアクセスの設定の詳細については、『IAM ユーザーガイド』の「[開発アカウントとプロダクションアカウントを分けるシナリオの例](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html#id_roles_common-scenarios_aws-accounts-example)」を参照してください。
Amazon Keyspaces と VPC エンドポイントの詳細については、「[インターフェイス VPC エンドポイントと Amazon Keyspaces の使用](vpc-endpoints.md)」を参照してください。
**Topics**
+ [共有 VPC のクロスアカウントアクセスの設定](access.cross-account.sharedVPC.md)
+ [共有 VPC を利用しないクロスアカウントアクセスの設定](access.cross-account.noVPC.setup.md)
# 共有 VPC の VPC エンドポイントを使用して Amazon Keyspaces へのクロスアカウントアクセスを設定する
異なる を作成して AWS アカウント 、アプリケーションからリソースを分離できます。たとえば、Amazon Keyspaces テーブル用に 1 つのアカウントを作成し、開発環境のアプリケーション用に別のアカウントを作成し、本番環境のアプリケーション用に別のアカウントを作成するといったことができます。このトピックでは、共有 VPC のインターフェイス VPC エンドポイントを使用した Amazon Keyspaces のクロスアカウントアクセスを設定するために必要な設定手順を順を追って説明します。
Amazon Keyspaces の VPC エンドポイントを設定する方法の詳細な手順については、「[ステップ 3: Amazon Keyspaces 用の VPC エンドポイントを作成する](vpc-endpoints-tutorial.create-endpoint.md)」を参照してください。
この例では、共有 VPC で次の 3 つのアカウントを使用します。
+ `Account A:111111111111` — このアカウントには、VPC エンドポイント、VPC サブネット、Amazon Keyspaces テーブルなどのインフラストラクチャが含まれています。
+ `Account B:222222222222` — このアカウントには、`Account A:111111111111` の Amazon Keyspaces テーブルに接続する必要がある開発環境のアプリケーションが含まれています。
+ `Account C:333333333333` — このアカウントには、`Account A:111111111111` の Amazon Keyspaces テーブルに接続する必要がある本番環境のアプリケーションが含まれています。
![\[同じ AWS リージョン 内の同じ組織が所有し、共有 VPC を使用する 3 つの異なるアカウントを示す図。\]](http://docs.aws.amazon.com/ja_jp/keyspaces/latest/devguide/images/keyspaces_cross-account_sharedVPC.png)
`Account A:111111111111` は、 `Account B:222222222222`がアクセス`Account C:333333333333`する必要があるリソース (Amazon Keyspaces テーブル) を含むアカウントであり、 `Account A:111111111111` は*信頼する*アカウントです。 `Account B:222222222222`と `Account C:333333333333`は、 のリソース (Amazon Keyspaces テーブル) にアクセスする必要があるプリンシパルを持つアカウントであり`Account A:111111111111`、 `Account B:222222222222` と `Account C:333333333333`は*信頼*されたアカウントです。信頼するアカウントは IAM ロールを共有して、信頼されたアカウントに権限を与えます。次の手順では、`Account A:111111111111` に必要な設定ステップを簡単に説明します。
**`Account A:111111111111` の設定**
1. AWS Resource Access Manager を使用してサブネットのリソース共有を作成し、プライベートサブネットを `Account B:222222222222`および と共有します`Account C:333333333333`。
`Account B:222222222222` と `Account C:333333333333` は、共有されているサブネット内のリソースを表示し、作成できます。
1. を使用した Amazon Keyspaces プライベート VPC エンドポイントを作成します AWS PrivateLink。これにより、Amazon Keyspaces サービスエンドポイントの共有サブネットと DNS エントリに複数のエンドポイントが作成されます。
1. Amazon Keyspaces キースペースとテーブルを作成します。
1. 次のポリシー例に示すように、Amazon Keyspaces テーブルへの`Account A:111111111111`フルアクセス、Amazon Keyspaces システムテーブルへの読み取りアクセス、Amazon EC2 VPC リソースを記述できる IAM ロールを に作成します。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "CrossAccountAccess",
"Effect": "Allow",
"Action": [
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeVpcEndpoints",
"cassandra:*"
],
"Resource": "*"
}
]
}
```
1. `Account B:222222222222` と が信頼されたアカウントとしてロールを引き`Account C:333333333333`受ける`Account A:111111111111`ことができるように、 で IAM ロールの信頼ポリシーを設定します。以下の例ではこれを示しています。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::222222222222:role/Cross-Account-Role-B",
"arn:aws:iam::333333333333:role/Cross-Account-Role-C"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
クロスアカウント IAM ポリシーの詳細については、『IAM ユーザーガイド』の「[クロスアカウントポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html)」を参照してください。
**`Account B:222222222222` と `Account C:333333333333` における設定**
1. `Account B:222222222222` と `Account C:333333333333` で新しいロールを作成し、`Account A:111111111111` で作成した共有ロールをプリンシパルが引き受けることを許可する以下のポリシーをアタッチします。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
プリンシパルが共有ロールを引き受けることを許可するには、 AWS Security Token Service () の `AssumeRole` API を使用しますAWS STS。詳細については、[「IAM ユーザーガイド」の「自分が所有 AWS アカウント している別の の IAM ユーザーへのアクセスを提供する](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html)」を参照してください。
1. `Account B:222222222222` と `Account C:333333333333` では、SIGV4 認証プラグインを利用するアプリケーションを作成できます。これにより、アプリケーションは共有ロールを引き受け、共有 VPC の VPC エンドポイントを介して `Account A:111111111111` にある Amazon Keyspaces テーブルに接続できます。SIGV4 認証プラグインの詳細については、「[Amazon Keyspaces にプログラムによってアクセスするための認証情報を作成する](programmatic.credentials.md)」を参照してください。別の AWS アカウントでロールを引き受けるようにアプリケーションを設定する方法の詳細については、 SDK およびツールリファレンスガイドの[「認証とアクセス](https://docs.aws.amazon.com/sdkref/latest/guide/access.html)」を参照してください。 *AWS SDKs *
# 共有 VPC を利用せずに Amazon Keyspaces へのクロスアカウントアクセスを設定する
Amazon Keyspaces テーブルとプライベート VPC エンドポイントを別のアカウントが所有していて、VPC を共有していない場合でも、アプリケーションは VPC エンドポイントを使用してクロスアカウントに接続できます。アカウントは VPC エンドポイントを共有していないため、`Account A:111111111111`、`Account B:222222222222` 、`Account C:333333333333` には独自の VPC エンドポイントが必要です。Cassandra クライアントドライバーは、Amazon Keyspaces はマルチノードクラスターではなく単一ノードとして認識します。接続すると、クライアントドライバーは DNS サーバーにアクセスし、DNS サーバーはアカウントの VPC で使用可能なエンドポイントの 1 つを返します。
パブリックエンドポイントを使用するか、各アカウントにプライベート VPC エンドポイントをデプロイすることで、共有 VPC エンドポイントなしで異なるアカウントの Amazon Keyspaces テーブルにアクセスすることもできます。共有 VPC を使用しない場合、各アカウントには独自の VPC エンドポイントが必要です。この例では、`Account A:111111111111`、`Account B:222222222222`、`Account C:333333333333` が `Account A:111111111111` のテーブルにアクセスするには独自の VPC エンドポイントが必要です。この設定で VPC エンドポイントを使用する場合、Cassandra クライアントドライバーに、Amazon Keyspaces は、マルチノードクラスターではなく単一ノードクラスターとして認識されます。接続すると、クライアントドライバーは DNS サーバーにアクセスし、DNS サーバーはアカウントの VPC で使用可能なエンドポイントの 1 つを返します。ただし、クライアントドライバーは `system.peers` テーブルにアクセスして追加のエンドポイントを検出することはできません。利用できるホストの数が少ないため、ドライバーによる接続数は少なくなります。これを調整するには、ドライバーの接続プール設定を 3 倍に増やします。
![\[共有 VPC がない同じ AWS リージョン 内の同じ組織に属する 3 つの異なるアカウントを示す図\]](http://docs.aws.amazon.com/ja_jp/keyspaces/latest/devguide/images/keyspaces_cross-account_noVPC.png)
`Account A:111111111111` は、 `Account B:222222222222`がアクセス`Account C:333333333333`する必要があるリソース (Amazon Keyspaces テーブル) を含むアカウントであり、 `Account A:111111111111` は*信頼する*アカウントです。 `Account B:222222222222`と `Account C:333333333333`は、 のリソース (Amazon Keyspaces テーブル) にアクセスする必要があるプリンシパルを持つアカウントであり`Account A:111111111111`、 `Account B:222222222222` と `Account C:333333333333`は*信頼*されたアカウントです。信頼するアカウントは IAM ロールを共有して、信頼されたアカウントに権限を与えます。次の手順では、`Account A:111111111111` に必要な設定ステップを簡単に説明します。
**`Account A:111111111111` の設定**
1. で Amazon Keyspaces キースペースとテーブルを作成します`Account A:111111111111`。
1. Amazon Keyspaces テーブルへのフルアクセスと Amazon Keyspaces システムテーブルへの読み取りアクセス権`Account A:111111111111`を持つ IAM ロールを に作成します。
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:Select",
"cassandra:Modify"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111111111111:/keyspace/mykeyspace/table/mytable",
"arn:aws:cassandra:us-east-1:111111111111:/keyspace/system*"
]
}
]
}
```
1. と のプリンシパルが信頼`Account B:222222222222``Account C:333333333333`されたアカウントとしてロールを引き受け`Account A:111111111111`られるように、 で IAM ロールの信頼ポリシーを設定します。以下の例ではこれを示しています。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::222222222222:role/Cross-Account-Role-B",
"arn:aws:iam::333333333333:role/Cross-Account-Role-C"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
クロスアカウント IAM ポリシーの詳細については、『IAM ユーザーガイド』の「[クロスアカウントポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html)」を参照してください。
1. で VPC エンドポイントを設定し`Account A:111111111111`、VPC エンドポイント`Account A`を使用して `Account B:222222222222`と のロールが でロールを引き受けることを許可するアクセス許可をエンドポイント`Account C:333333333333`にアタッチします。これらのアクセス許可は、アタッチされている VPC エンドポイントに対して有効です。VPC エンドポイントポリシーの詳細については、「[Amazon Keyspaces のインターフェイス VPC エンドポイントへのアクセスの制御](vpc-endpoints.md#interface-vpc-endpoints-policies)」を参照してください。
```
{{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccessfromSpecificIAMroles",
"Effect": "Allow",
"Action": "cassandra:*",
"Resource": "*",
"Principal": "*",
"Condition": {
"ArnEquals": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:role/Cross-Account-Role-B",
"arn:aws:iam::333333333333:role/Cross-Account-Role-C"
]
}
}
}
]
}
```
**`Account B:222222222222` と `Account C:333333333333` における設定**
1. `Account B:222222222222` と `Account C:333333333333` で新しいロールを作成し、`Account A:111111111111` で作成した共有ロールをプリンシパルが引き受けることを許可する以下のポリシーをアタッチします。
```
{
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111111111111:role/keyspaces_access"
}
}
```
プリンシパルが共有ロールを引き受けることを許可するには、 AWS Security Token Service () の `AssumeRole` API を使用しますAWS STS。詳細については、[「IAM ユーザーガイド」の「所有 AWS アカウント している別の の IAM ユーザーへのアクセスを提供する](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html)」を参照してください。
1. `Account B:222222222222` および では`Account C:333333333333`、SIGV4 認証プラグインを使用するアプリケーションを作成できます。これにより、アプリケーションは共有ロールを引き受けて、 にある Amazon Keyspaces テーブルに接続できます`Account A:111111111111`。SIGV4 認証プラグインの詳細については、「[Amazon Keyspaces にプログラムによってアクセスするための認証情報を作成する](programmatic.credentials.md)」を参照してください。別の AWS アカウントでロールを引き受けるようにアプリケーションを設定する方法の詳細については、 SDK およびツールリファレンスガイドの[「認証とアクセス](https://docs.aws.amazon.com/sdkref/latest/guide/access.html)」を参照してください。 *AWS SDKs *