本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 访问 Amazon Keyspaces（Apache Cassandra 兼容）
您可以使用控制台、通过运行`cqlsh`客户端 AWS CloudShell、软件开发工具包或使用 Apache 2.0 许可的 Cassandra 驱动程序以编程方式访问 Amazon AWS Keyspaces。Amazon Keyspaces 支持与 Apache Cassandra 3.11.2 兼容的驱动程序和客户端。在访问亚马逊密钥空间之前，您必须完成设置， AWS Identity and Access Management 然后向亚马逊密钥空间授予 IAM 身份访问权限。
## 设置 AWS Identity and Access Management
### 注册获取 AWS 账户
如果您没有 AWS 账户，请完成以下步骤来创建一个。
**要注册 AWS 账户**
1. 打开[https://portal.aws.amazon.com/billing/注册。](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 Identity Center，启用并创建管理用户，这样您就不会使用 root 用户执行日常任务。
**保护你的 AWS 账户根用户**
1. 选择 **Root 用户**并输入您的 AWS 账户 电子邮件地址，以账户所有者的身份登录。[AWS 管理控制台](https://console.aws.amazon.com/)在下一页上，输入您的密码。
要获取使用根用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)。
1. 为您的根用户启用多重身份验证（MFA）。
有关说明，请参阅 I [A *M* 用户指南中的为 AWS 账户 根用户启用虚拟 MFA 设备（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)。
**创建具有管理访问权限的用户**
1. 启用 IAM Identity Center。
有关说明，请参阅**《AWS IAM Identity Center 用户指南》中的[启用 AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。
1. 在 IAM Identity Center 中，为用户授予管理访问权限。
有关使用 IAM Identity Center 目录 作为身份源的教程，请参阅《[用户*指南》 IAM Identity Center 目录中的使用默认设置配置AWS IAM Identity Center 用户*访问权限](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)。
**以具有管理访问权限的用户身份登录**
+ 要使用您的 IAM Identity Center 用户身份登录，请使用您在创建 IAM Identity Center 用户时发送到您的电子邮件地址的登录 URL。
有关使用 IAM Identity Center 用户[登录的帮助，请参阅*AWS 登录 用户指南*中的登录 AWS 访问门户](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。
**将访问权限分配给其他用户**
1. 在 IAM Identity Center 中，创建一个权限集，该权限集遵循应用最低权限的最佳做法。
有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。
1. 将用户分配到一个组，然后为该组分配单点登录访问权限。
有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。
## 设置 Amazon Keyspaces
使用 [IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) 管理对 Amazon Keyspaces 资源的访问。使用 IAM，您可以将策略附加到 IAM 用户、角色和联合身份，从而授予对 Amazon Keyspaces 中特定资源的读写权限。
要开始向 IAM 身份授予权限，您可以使用其中一个适用于 Amazon Keyspaces 的 AWS 托管式策略：
+ [AmazonKeyspacesFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesFullAccess.html)— 此政策授予访问亚马逊密钥空间中所有资源的权限，并授予对所有功能的完全访问权限。
+ [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)。
要在创建 AWS 账户 并创建授予 IAM 身份访问亚马逊密钥空间的策略之后访问 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 用户指南 AWS 管理控制台中的控制 IAM 用户对的访问权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_controlling-access.html)。
您可以使用控制台在 Amazon Keyspaces 中执行以下操作：
+ 创建、删除以及管理键空间和表。
+ 在表**监控**选项卡监控重要的表指标：
+ 计费表大小(字节)
+ 容量指标
+ 使用 CQL 编辑器或通过[集成 AWS CloudShell 体验](console_cloudshell_integration.md)运行查询，例如插入、更新和删除数据。
+ 通过集成的 CQLSH 支持直接连接到 Amazon Key AWS CloudShell spaces。
+ 更改账户的分区程序配置。
+ 在控制面板上查看账户的性能指标和错误指标。
# 使用控制台连接到 Amazon Keysp AWS CloudShell aces
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 集成提供了对标准 CQLSH 功能的访问，包括对基本 CQL 之外的命令的支持。
+ **描述**-列出并查看密钥空间和表格的详细描述。
+ **复制-将**查询输出导出到文件以供日后处理。
+ **源**-从文件中执行 CQL 语句。
+ **命令历史导航**-使用键盘快捷键滚动浏览以前的命令。
+ **查询执行**-直接从键盘界面运行查询。
+ **输出复制**-将结果复制为简单文本，以便在其他应用程序中使用。
## 功能注意事项
使用 AWS CloudShell 集成时，请考虑以下权衡。
**不支持以下功能：**
+ CQL 语法建议和自动完成功能。
+ 编辑器工具，例如显示自动完成、显示工具提示、查找、查找和替换、重做、切换方块注释、切换代码折叠、切换行注释和撤消。
**修改后的功能：**
+ **CSV 下载**-要以 CSV 格式下载结果，请指定`>`运算符来管道命令输出：
```
SELECT * FROM my_table > file_name.csv
```
+ **JSON 查看**-无需转换数据即可查看 JSON 格式的项目。
+ **终端风格的界面**-该体验作为终端界面运行，而不是功能齐全的代码编辑器。
该 AWS CloudShell 集成简化了连接过程，同时提供了基本的 CQL 功能，便于直接从管理您的 Amazon Keyspaces 数据。 AWS 管理控制台
要了解如何创建 Amazon Keyspaces 键空间和表以及使用示例应用程序数据进行设置，请参阅 [Amazon Keyspaces（Apache Cassandra 兼容）](getting-started.md)。
# AWS CloudShell 用于访问 Amazon Keyspaces
AWS CloudShell 是一个基于浏览器、经过预先验证的 shell，您可以直接从启动。 AWS 管理控制台您可以使用首选外壳（Bash PowerShell 或 Z shell）对 AWS 服务运行 AWS CLI 命令。 AWS CloudShell 已使用您的控制台凭据进行预先身份验证，并包含用于处理 AWS 服务的常用工具，包括 AWS CLI、Python 和 Node.js。
您可以[AWS CloudShell 从启动 AWS 管理控制台，](https://docs.aws.amazon.com/cloudshell/latest/userguide/working-with-cloudshell.html#launch-options)用于登录控制台的 AWS 凭据将在新的 shell 会话中自动可用。这种对 AWS CloudShell 用户的预身份验证允许您在`cqlsh`使用 AWS CLI 或版本 2（预安装在外壳的计算环境中）与 Amazon Keyspaces 等 AWS 服务进行交互时跳过配置凭证。
## AWS CloudShell 集成选项
Amazon Keyspaces 提供两种使用方式： AWS CloudShell
1. **集成 AWS CloudShell 体验**-一种简化的连接方法，可直接从 Amazon Keyspaces 控制台中获得，可自动初始化`cqlsh-expansion`并连接到特定的密钥空间。有关使用此集成体验的完整说明，请参阅[使用控制台连接到 Amazon Keysp AWS CloudShell aces](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创建和管理的独立策略。以下的 AWS 托管策略 CloudShell 可以附加到 IAM 身份：
+ `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 托管策略向您的 Amazon Keyspaces 授予您的 IAM 身份访问权限，也可以从托管策略作为模板开始删除不需要的权限。您还可以限制访问特定键空间和表来创建自定义策略。以下适用于 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，您需要下载所需的亚马逊数字证书。有关下载和配置 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)。
## 将 CQLSH 与 Amazon Keyspaces 配合使用
连接后，您可以使用标准 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) 来了解详细步骤。
**注意**
使用 in 时 AWS CloudShell，您无需`cqlsh-expansion`在调用之前配置凭据，因为您已经在 shell 中进行了身份验证。
**连接到 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 用户指南》中的[结合使用 IAM 与 Amazon Keyspaces（Apache Cassandra 兼容）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_keyspaces.html)。
**警告**
IAM 用户具有长期凭证，这会带来安全风险。为帮助减轻这种风险，我们建议仅向这些用户提供执行任务所需的权限，并在不再需要这些用户时将其移除。
+ 为了增强安全性，我们建议创建用于所有 AWS 服务的 IAM 身份并使用临时证书。借助适用于 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 签名版本 4 流程 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)。
您可以从以下位置下载 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 用户相关联的长期凭证，只能用于所针对的服务。要授予 IAM 角色或联合身份使用临时证书访问您的所有 AWS 资源的权限，您应使用AWS 适用于 A [mazon 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. 在导航窗格中，选择**用户**，然后选择之前创建的具有 Amazon Keyspaces 权限（已附加策略）的用户。
1. 选择 **Security Credentials (安全凭证)**。在 **Amazon Keyspaces 的凭证**下，选择**生成凭证**以生成服务特定凭证。
您的服务特定凭证现在可用。这是您下载或查看密码的唯一机会。以后您无法恢复它。不过，您可以随时重置密码。将用户和密码保存在安全的位置，因为随后您需要使用它们。
------
#### [ 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) 和[配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) 的说明进行操作。
1. 使用运行以下命令为用户`alice`生成特定于服务的证书，以便她可以访问 Amazon Keyspaces。 AWS CLI
```
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、软件开发工具包或 Cassandra 客户端驱动程序和 Sigv4 插件以编程方式访问 Amazon AWS Keyspaces，您需要一个拥有访问密钥的 IAM 用户。当您以编程方式使用 Amazon Keyspaces 时，您需要提供 AWS 访问密钥，以便 AWS 可以在编程调用中验证您的身份。您的访问密钥由访问密钥 ID（ AKIAIOSFODNN7例如，示例）和私有访问密钥（例如wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY）组成。本主题将引导您完成此过程中的必要步骤。
安全最佳实践建议创建权限有限的 IAM 用户，改为将 IAM 角色与执行特定任务所需的权限相关联。然后，IAM 用户可以临时代入 IAM 角色来执行所需任务。例如，您账户中使用 Amazon Keyspaces 控制台的 IAM 用户可切换为某个角色，以临时使用该控制台中的角色的权限。该用户放弃自己的原始权限，采用分配给该角色的权限。用户退出角色时，将恢复其原始权限。用户用于代入该角色的凭证是临时的。相反，IAM 用户拥有长期凭证，如果直接为他们分配权限而非代入角色，这将会带来安全风险。为帮助减轻这种风险，我们建议仅向这些用户提供执行任务所需的权限，并在不再需要这些用户时将其移除。有关角色的更多信息，请参阅《IAM 用户指南》**中的[角色的常见场景：用户、应用程序和服务](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios.html)。
**Topics**
+ [适用于 Cassandra AWS CLI客户端驱动程序的、 AWS 软件开发工具包或 Amazon Keyspaces Sigv4 插件所需的凭证](SigV4_credentials.md)
+ [使用 IAM 角色和 SigV4 插件创建用于连接 Amazon Keyspaces 的临时凭证](temporary.credentials.IAM.md)
+ [创建一个 IAM 用户，以便以编程方式访问您账户中的 Amazon Keyspaces AWS](access.credentials.IAM.md)
+ [为 IAM 用户创建新的访问密钥](create.keypair.md)
+ [存储用于通过编程方式进行访问的访问密钥](aws.credentials.manage.md)
# 适用于 Cassandra AWS CLI客户端驱动程序的、 AWS 软件开发工具包或 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，推荐的做法是通过 SigV4 插件使用[临时凭证](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)进行身份验证。在许多情况下，您并不需要永不过期的长期访问密钥（如 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 管理控制台 并打开 IAM 控制台，网址为[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在导航窗格中，选择**角色**，然后选择**创建角色**。
1. 在**创建角色**页面上的**选择受信实体类型**下，选择 **AWS 服务**。在**使用案例**下，选择 **Amazon EC2**，然后选择**下一步**。
1. 在**添加权限**页面的**权限策略**下，从策略列表中选择 **Amazon Keyspaces 只读访问**，然后选择**下一步**。
1. 在**命名、审核和创建**页面上，为角色输入名称，并查看**选择受信实体**和**添加权限**部分。您还可以在此页面上为角色添加可选标签。完成后，选择**创建角色**。请记住此名称，因为您在启动 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 的 Pyt DataStax hon 驱动程序和 SigV4 身份验证插件连接到亚马逊密钥空间](using_python_driver.md#python_SigV4)。
有关如何调用 `AssumeRole`、`GetFederationToken` 和其他 API 操作的详细信息，请参阅 [AWS Security Token Service API 参考](https://docs.aws.amazon.com/STS/latest/APIReference/)。有关从结果中获取临时安全凭证和会话令牌的信息，请参阅所用开发工具包的文档。你可以在主文档 AWS SDKs [页面的**SDKs 和工具包**部分找到所有文档的AWS 文档](https://aws.amazon.com/documentation)。
# 创建一个 IAM 用户，以便以编程方式访问您账户中的 Amazon Keyspaces AWS
要通过 AWS CLI、软件开发工具包或 Sigv4 插件获取以编程方式访问 Amazon AWS Keyspaces 的证书，您需要先创建 IAM 用户或角色。以下步骤显示了创建 IAM 用户并将该 IAM 用户配置为以编程方式访问 Amazon Keyspaces 的过程：
1. 在 AWS 管理控制台、、Windows 工具中创建用户 PowerShell，或者使用 AWS API 操作创建用户。 AWS CLI如果您在中创建用户 AWS 管理控制台，则会自动创建凭据。
1. 如果以编程方式创建用户，您必须通过额外步骤为该用户创建访问密钥（访问密钥 ID 和秘密访问密钥）。
1. 向用户授予访问 Amazon Keyspaces 的权限。
有关创建 IAM 用户所需的权限的信息，请参阅[访问 IAM 资源所需的权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html)。
------
#### [ Console ]
**创建可通过编程方式进行访问的 IAM 用户（控制台）**
1. 登录 AWS 管理控制台 并打开 IAM 控制台，网址为[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在导航窗格中，选择 **Users**（用户），然后选择 **Add users**（添加用户）。
1. 为新用户键入用户名。这是的登录名。 AWS
**注意**
用户名可以是一个最多由 64 个字母、数字和以下字符构成的组合：加号 (\$1)、等号 (=)、逗号 (,)、句点 (.)、at 符号 (@)、下划线 (\$1) 和连字符 (-)。账户中的姓名必须是唯一的。它们不按大小写区分。例如，您不能创建名为 *TESTUSER* 和 *testuser* 的两个用户。
1. 选择**访问密钥 - 编程访问**，为新用户创建一个访问密钥。您可以在转到**最终**页面后查看或下载访问密钥。
选择**下一步: 权限**。
1. 在**设置权限**页面，选择**直接附加现有策略**，为新用户分配权限。
此选项显示您账户中可用的 AWS 托管和客户托管策略列表。您可以在搜索字段中输入 `keyspaces`，以仅显示与 Amazon Keyspaces 相关的策略。
对于 Amazon Keyspaces，可用的托管策略是 `AmazonKeyspacesFullAccess` 和 `AmazonKeyspacesReadOnlyAccess`。有关每项策略的更多信息，请参阅 [AWS Amazon Keyspaces 的托管策略](security-iam-awsmanpol.md)。
要进行测试和学习连接教程，请为新 IAM 用户选择 `AmazonKeyspacesReadOnlyAccess` 策略。**注意**：作为最佳实践，我们建议您遵循最低权限原则并创建自定义策略，限制对特定资源的访问并仅允许所需操作。有关 IAM policy 的更多信息以及查看 Amazon Keyspaces 的示例策略，请参阅[Amazon Keyspaces 基于身份的策略](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies)。创建自定义权限策略后，请将策略附加到角色，然后使用户临时代入相应角色。
选择**下一步：标签**。
1. 在**添加标签（可选）**页面，您可以为用户添加标签，或选择**下一步：审核**。
1. 在**审核**页面，您可以看到目前所做的所有选择。如果您已准备好继续，请选择**创建用户**。
1. 要查看用户的访问密钥（访问密钥 IDs 和私有访问密钥），请选择密码和访问密钥旁边的**显示**。要保存访问密钥，请选择**下载 .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)
+ 适用于 Windows 的工具 PowerShell：[https://docs.aws.amazon.com/powershell/latest/reference/items/New-IAMAccessKey.html](https://docs.aws.amazon.com/powershell/latest/reference/items/New-IAMAccessKey.html)
+ 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 管理控制台 并打开 IAM 控制台，网址为[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
1. 在导航窗格中，选择 **Users**（用户）。
1. 选择所需用户的名称，以便为其创建访问密钥。
1. 在用户的**摘要**页面身上，选择**安全凭证**选项卡。
1. 在 “**访问密钥****最佳实践和替代方案” 下的 “访问密钥**” 部分，选择 “**其他**” 用例。单击 “**下一步**”，根据需要输入可选信息，然后选择 “**创建访问密钥**”。
要查看新访问密钥对，请选择 **Show (显示)**。您的凭证与下面类似：
+ 访问密钥 ID： AKIAIOSFODNN7示例
+ 秘密访问密钥：wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
**注意**
关闭此对话框后，您将无法再次访问该秘密访问密钥。
对于您创建的密钥 pair，请考虑以下最佳实践。
+ 切勿将访问密钥以纯文本、代码存储库或代码形式存储。
+ 不再需要访问密钥时禁用或删除访问密钥。
+ 启用最低权限权限。
+ 定期轮换访问密钥。
1. 要下载密钥对，请选择 **Download .csv file**（下载 .csv 文件）。将密钥存储在安全位置。
1. 下载 csv 格式文件之后，选择 **Close（关闭）**。
在创建访问密钥时，预设情况下，密钥对处于活动状态，并且您可以立即使用此密钥对。
# 存储用于通过编程方式进行访问的访问密钥
作为最佳实践，我们建议您不要直接将访问密钥嵌入到代码中。 AWS SDKs 和 AWS 命令行工具使您可以将访问密钥放在已知位置，这样您就不必将其保存在代码中。在以下任一位置中放置访问密钥：
+ **环境变量**：在多租户系统上，选择用户环境变量，而不是系统环境变量。
+ **CLI 凭证文件** – 在运行 `credentials` 命令时，将更新 `config` 和 `aws configure` 文件。`credentials` 文件在 Linux、macOS 或 Unix 上位于 `~/.aws/credentials`，在 Windows 上位于 `C:\Users\USERNAME\.aws\credentials`。该文件可以包含 `default` 配置文件和任何命名配置文件的凭证详细信息。
+ **CLI 配置文件** – 在运行 `credentials` 命令时，将更新 `config` 和 `aws configure` 文件。`config` 文件在 Linux、macOS 或 Unix 上位于 `~/.aws/config`，在 Windows 上位于 `C:\Users\USERNAME\.aws\config`。该文件包含原定设置配置文件和任何命名配置文件的配置设置。
将访问密钥存储为环境变量是[Step-by-step 使用适用于 Apache Cassandra 的 4.x DataStax Java 驱动程序和 Sigv4 身份验证插件连接亚马逊密钥空间的教程](using_java_driver.md#java_tutorial.SigV4)的先决条件。请注意，这包括默认值 AWS 区域。客户端使用默认凭证提供程序链来搜索凭证，存储为环境变量的访问密钥优先于所有其他位置，例如配置文件。有关更多信息，请参阅[配置设置和优先顺序](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
```
设置环境变量会更改使用的值，直到 Shell 会话结束或直到您将该变量设置为其他值。通过在 shell 的启动脚本中设置变量，可使变量在未来的会话中继续有效。
------
#### [ 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) 设置环境变量会更改当前命令提示符会话和运行该命令后创建的所有命令提示符会话中使用的值。它***不*** 影响在运行该命令时已经运行的其他命令 shell。
------
#### [ 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 文档](https://docs.microsoft.com/powershell/module/microsoft.powershell.core/about/about_environment_variables)。
------
# Amazon Keyspaces 的服务端点
**Topics**
+ [端口和协议](#ports)
+ [全球终端节点](#global_endpoints)
+ [AWS GovCloud (US) Region FIPS 终端节点](#fips_endpoints)
+ [中国区域端点](#china_endpoints)
+ [直播终端节点](#streams_endpoints)
+ [连接到双堆栈端点](dualstack_endpoints.md)
## 端口和协议
您可以通过运行`cqlsh`客户端、使用 Apache 2.0 许可的 Cassandra 驱动程序或使用和软件开发工具包以编程方式访问 Amazon Keyspaces。 AWS CLI AWS
下表显示了不同访问机制使用的端口和协议。
| 以编程方式访问 | 端口： | 协议 |
| --- | --- | --- |
| CQLSH | 9142 | TLS |
| Cassandra 驱动程序 | 9142 | TLS |
| AWS CLI | 443 | HTTPS |
| AWS SDK | 443 | HTTPS |
对于 TLS 连接，Amazon Keyspaces 使用在亚马逊信任服务（Amazon Root 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 同时支持 IPv6 公共终 IPv4 端节点。您可以在 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/zh_cn/keyspaces/latest/devguide/programmatic.endpoints.html)
## AWS GovCloud (US) Region FIPS 终端节点
AWS GovCloud (US) Region中可用的 FIPS 端点。Amazon Keyspaces 同时支持 IPv6 FIPS 终 IPv4 端节点。您可以在 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/zh_cn/keyspaces/latest/devguide/programmatic.endpoints.html)
## 中国区域端点
Amazon Keyspaces 支持中国区域的 IPv4 终端节点 AWS 。
要访问这些端点，您必须注册一组中国区域独有的单独账户凭证。有关更多信息，请参阅[中国注册、账户和凭证](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/zh_cn/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/zh_cn/keyspaces/latest/devguide/programmatic.endpoints.html)
# 连接到双堆栈端点
Amazon Keyspaces 全局终端节点是接受 IPv4 和请求的双栈终端节点。 IPv6
使用连接到 Amazon Keyspaces 时 IPv6，该服务会自动调整系统表响应以匹配您的连接协议。这样可以确保您的应用程序收到与其连接类型相匹配的一致网络地址信息。这为客户端提供了准确的网络拓扑信息，同时保持了现有 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.
```
例如`cassandra.us-east-1.api.aws`，从 IPv6 网络到双栈端点的连接会返回以下响应。
```
SELECT * FROM system.peers;
-- Returns IPv6 addresses in peer column
-- Example: 2001:db8::1, 2001:db8::2, etc.
```
有关 Amazon Keyspaces IPv6 支持的更多信息，请参阅。[IPv6 Amazon Keyspaces 中的支持](ipv6-support.md)
# IPv6 Amazon Keyspaces 中的支持
IPv6 Amazon Keyspaces 中的支持允许应用程序使用互联网协议版本 6 建立连接，这是下一代互联网协议，与之相比，它提供了大大扩展的地址空间。 IPv4该实现使用同时支持两者的 IPv4双栈端点，确保向后兼容性， IPv6 同时实现面向未来的连接。有关 终端节点的列表，请参阅[全球终端节点](programmatic.endpoints.md#global_endpoints)。
Amazon Keyspaces 通过双栈架构实现 IPv6 支持，该架构在实现连接的同时保持完全的向后兼容性。 IPv6
## Amazon Keyspaces 中的 DNS 解析
当应用程序连接到双栈端点时，DNS 解析过程会返回两种地址类型：
A Records (IPv4)
向后兼容的传统 IPv4 地址
AAAA 唱片 () IPv6
现代连接的新 IPv6 地址
客户端的操作系统和网络堆栈会根据本地配置、网络可用性和系统偏好自动选择最合适的协议。
Cassandra 查询语言 (CQL) 协议无缝支持 IPv6 连接，无需更改应用程序代码。
自动选择协议
+ 应用程序指定双栈端点
+ 网络堆栈 IPv6 根据可用性选择 IPv4 或
+ 现有 CQL 应用程序无需修改代码
驱动程序兼容性
+ 透明地支持 IPv6 所有主要 CQL 驱动程序
+ DataStax 驱动程序以本地 IPv6 方式处理地址
+ 开源驱动程序无需修改即可运行
连接一致性
+ 系统表反映了所使用的连接协议
+ IPv6 连接显示 IPv6 地址在 `system.peers`
+ IPv4 连接继续显示 IPv4 地址
# 使用 `cqlsh` 连接 Amazon Keyspaces
要使用 `cqlsh` 连接 Amazon Keyspaces，您可以使用 `cqlsh-expansion`。该工具包包含常用的 Apache Cassandra 工具（例如 `cqlsh` 和帮助程序），能够对 Amazon Keyspaces 进行预配置，同时保持与 Apache Cassandra 的完全兼容。`cqlsh-expansion` 与 SigV4 身份验证插件集成，让您可以使用 IAM 访问密钥而不是用户名和密码进行连接。您只需安装 `cqlsh` 脚本即可建立连接，无需安装完整的 Apache Cassandra 发行版，因为 Amazon Keyspaces 是无服务器的。这一轻量级安装包包括 `cqlsh-expansion` 和经典 `cqlsh` 脚本，可以在任何支持 Python 的平台上安装。
**注意**
`Murmur3Partitioner` 是 Amazon Keyspaces 和 `cqlsh-expansion` 的推荐分区程序。`cqlsh-expansion` 不支持 Amazon Keyspaces `DefaultPartitioner`。有关更多信息，请参阅 [使用 Amazon Keyspaces 中的分区程序](working-with-partitioners.md)。
有关 `cqlsh` 的一般信息，请参阅 [`cqlsh`：CQL Shell](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 安装*在您的设备上安装 `cqlsh-expansion` 脚本以及一个包含依赖项列表的文件。`--user flag` 会告诉 `pip` 使用 Python 用户为平台安装目录。在基于 Unix 的系统上，应安装 `~/.local/` 目录。
您需要使用 Python 3 来安装 `cqlsh-expansion`，要弄清楚您的 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 使用此证书通过传输层安全性协议 (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. 创建一项 IAM 策略，至少向角色（或 IAM 用户）授予对 Amazon Keyspaces 的只读访问权限。要详细了解 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 创建服务特定凭证，如[创建用于通过编程方式访问 Amazon Keyspaces 的服务特定凭证。](programmatic.credentials.ssc.md)中所述。您还必须向该用户授予访问 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。
```
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 只接受使用传输层安全性协议 (TLS) 的安全连接。您可以使用该`cqlsh-expansion`实用程序自动为您下载证书并安装预配置的`cqlshrc`配置文件。有关更多信息，请参阅本页上的[使用 `cqlsh-expansion` 连接 Amazon Keyspaces](#using_cqlsh)。
如果要下载证书并手动配置连接，则可以使用以下步骤进行操作。
1. 下载以下数字证书并将文件保存在本地或您的主目录中。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root（可选 — 为了向后兼容）
要下载证书，您可以使用以下命令。
```
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 正在将所有证书全部迁移 AWS 区域 到根据亚马逊信任服务（Amazon Root CAs 1—4）颁发的证书。在此过渡期间，将客户端配置为同时信任 Amazon Root CAs 1—4 和 Starfield 根，以确保所有区域之间的兼容性。
1. 将所有下载的证书合并到一个`pem`文件中，其名称与我们的示例*keyspaces-bundle.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，您可以将 AWS CLI 用于数据定义语言 (DDL) 操作，例如创建表。此外，您还可以使用基础设施即代码 (IaC) 服务和工具，例如 AWS CloudFormation 和 Terraform。
在 Amazon Key AWS CLI spaces 中使用之前，您必须先获得访问密钥 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)
+ [AWS CLI 与 Amazon Keyspaces 一起使用](#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) 的说明进行操作
## AWS CLI 与 Amazon Keyspaces 一起使用
命令行格式包含 Amazon Keyspaces 操作名称，后跟该操作的参数。 AWS CLI 支持参数值的速记语法以及 JSON。以下 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\$1awards* 的表。该表的分区键由 `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* 的简单表（带有其他选项）。请注意，为提高可读性，命令被分成了多个独立的行。该命令显示了如何创建表以及如何执行以下操作:
+ 设置表的容量模式
+ 为表启用 Point-in-time恢复
+ 将表的默认生存时间 (TTL) 值设为一年
+ 为表添加两个标签
```
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 软件开发工具包和 AWS Command Line Interface (AWS CLI) 与 Amazon Keyspaces 进行交互式协作。您可以使用 API 进行数据语言定义 (DDL) 操作，如创建密钥空间或表。此外，您还可以使用基础设施即代码 (IaC) 服务和工具，例如 AWS CloudFormation 和 Terraform。
在 Amazon Key AWS CLI spaces 中使用之前，您必须先获得访问密钥 ID 和私有访问密钥。有关更多信息，请参阅 [为 Amazon Keyspaces 创建和配置 AWS 证书](access.credentials.md)。
有关 API 中可用于 Amazon Keyspaces 的所有操作的完整列表，请参阅 [https://docs.aws.amazon.com/keyspaces/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/keyspaces/latest/APIReference/Welcome.html)。
# 使用 Cassandra 客户端驱动程序以编程方式访问 Amazon Keyspaces
您可以使用许多第三方开源 Cassandra 驱动程序连接 Amazon Keyspaces。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 客户端驱动程序](http://cassandra.apache.org/doc/latest/getting_started/drivers.html)。
**注意**
为了帮助您入门，您可以查看和下载使用常用驱动程序与 Amazon Keyspaces 建立连接的 end-to-end代码示例。请参阅[上的 Amazon Keyspaces 示例](https://github.com/aws-samples/amazon-keyspaces-examples)。 GitHub
本章中的教程包括一个简单的 CQL 查询，用于确认已成功建立与 Amazon Keyspaces 的连接。要了解连接到 Amazon Keyspaces 端点后如何使用密钥空间和表，请参阅 [Amazon Keyspaces（Apache Cassandra 兼容）的 CQL 语言参考](cql.md)。有关展示如何从 Amazon VPC 终端节点连接到 Amazon Keyspaces 的 step-by-step教程，请参阅。[教程：使用接口 VPC 终端节点连接到 Amazon Keyspaces](vpc-endpoints-tutorial.md)
**Topics**
+ [使用 Cassandra 客户端驱动程序以编程方式访问 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 客户端驱动程序以编程方式访问 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 身份创建 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)
+ [Step-by-step 使用适用于 Apache Cassandra 的 DataStax Java 驱动程序使用特定于服务的凭证连接亚马逊密钥空间的教程](#java_tutorial)
+ [Step-by-step 使用适用于 Apache Cassandra 的 4.x DataStax Java 驱动程序和 Sigv4 身份验证插件连接亚马逊密钥空间的教程](#java_tutorial.SigV4)
+ [使用适用于 Apache Cassandra 的 3.x DataStax Java 驱动程序和 SigV4 身份验证插件连接亚马逊密钥空间](#java3x_tutorial.SigV4)
## 开始前的准备工作
要连接到 Amazon Keyspaces，您需要先完成以下任务。
1. Amazon Keyspaces 要求使用传输层安全性协议 (TLS) 来帮助保护与客户端的连接。
1. 下载以下数字证书并将文件保存在本地或您的主目录中。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root（可选 — 为了向后兼容）
要下载证书，您可以使用以下命令。
```
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 正在将所有证书全部迁移 AWS 区域 到根据亚马逊信任服务（Amazon Root CAs 1—4）颁发的证书。在此过渡期间，将客户端配置为同时信任 Amazon Root 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. 将 trustStore 文件附加到 JVM 参数中：
```
-Djavax.net.ssl.trustStore=path_to_file/cassandra_truststore.jks
-Djavax.net.ssl.trustStorePassword=my_password
```
## Step-by-step 使用适用于 Apache Cassandra 的 DataStax Java 驱动程序使用特定于服务的凭证连接亚马逊密钥空间的教程
以下 step-by-step教程将引导您使用特定于服务的凭证使用适用于 Cassandra 的 Java 驱动程序连接到 Amazon Keyspaces。具体而言，你将使用适用于 Apache Cassandr DataStax a 的 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 访问密钥进行身份验证，请参阅[Step-by-step 使用适用于 Apache Cassandra 的 4.x DataStax Java 驱动程序和 Sigv4 身份验证插件连接亚马逊密钥空间的教程](#java_tutorial.SigV4)。
+ 将 Apache Cassandra 的 DataStax Java 驱动程序添加到你的 Java 项目中。确保您使用的驱动程序版本支持 Apache Cassandra 3.11.2。有关更多信息，请参阅 A [pache 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 驱动程序的身份验证插件，而不是在驱动程序配置文件中对凭据进行硬编码，从而使用短期证书。要了解更多信息，请按照[Step-by-step 使用适用于 Apache Cassandra 的 4.x DataStax Java 驱动程序和 Sigv4 身份验证插件连接亚马逊密钥空间的教程](#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** — 通过在配置文件中添加一个部分来初始化 SSLEngine工厂，其中有一行用于指定类。`class = DefaultSslEngineFactory`提供 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 的路径，或者在 JVM 参数中添加 trustStore 的路径。
### 步骤 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` 代码块，请记得关闭连接，以免泄漏资源。
## Step-by-step 使用适用于 Apache Cassandra 的 4.x DataStax Java 驱动程序和 Sigv4 身份验证插件连接亚马逊密钥空间的教程
以下部分介绍如何使用适用于 Apache Cassandra 的开源 4.x DataStax Java 驱动程序的 SigV4 身份验证插件访问亚马逊密钥空间（适用于 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。有关更多信息，请参阅 A [pache Cassandra 的 DataStax Java 驱动程序](https://github.com/datastax/java-driver)文档。
+ 将身份验证插件添加到您的应用程序。该身份验证插件支持 Apache Cassandr DataStax a 的 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` 的新实例。Sigv4 AuthProvider 是插件提供的用于执行 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`为始终重试失败的请求。read/write/prepare/execute这是适用于分布式应用程序的最佳实践，可通过重试失败的请求来协助处理暂时性故障。
1. **SSL/TLS** — 通过在配置文件中添加一个部分来初始化 SSLEngine工厂，其中有一行用于指定类。`class = DefaultSslEngineFactory`提供 trustStore 文件的路径和您之前创建的密码。Amazon Keyspaces 不支持对等设备的 `hostname-validation`，因此请将此选项设为 false。
1. **连接** - 通过设置 `local.size = 3` 为每个端点创建至少 3 个本地连接。这是一种最佳实践，方便您的应用程序应对开销和流量暴增。有关如何根据预期流量模式计算应用程序每个端点需要多少本地连接的更多信息，请参阅[如何在 Amazon Keyspaces 中配置连接](connections.md#connections.howtoconfigure)。
1. **重试策略** - 实施 Amazon Keyspaces 重试策略 `AmazonKeyspacesExponentialRetryPolicy`，而非 Cassandra 驱动程序附带的 `DefaultRetryPolicy`。这样您就可以根据自己的需求配置 `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 的路径，或者在 JVM 参数中添加 trustStore 的路径。
### 步骤 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 身份验证插件连接亚马逊密钥空间
以下部分介绍如何使用适用于 Apache Cassandra 的 3.x 开源 DataStax Java 驱动程序的 Sigv4 身份验证插件来访问亚马逊密钥空间。该插件可从[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)。
+ 按照中的步骤下载数字证书，将其转换为 TrustStore 文件，然后将 JVM 参数中的密钥库附加到您的应用程序。[开始前的准备工作](#using_java_driver.BeforeYouBegin)
+ 将 Apache Cassandra 的 DataStax Java 驱动程序添加到你的 Java 项目中。确保您使用的驱动程序版本支持 Apache Cassandra 3.11.2。有关更多信息，请参阅 A [pache Cassandra 的 DataStax Java 驱动程序](https://github.com/datastax/java-driver)文档。
+ 将身份验证插件添加到您的应用程序。该身份验证插件支持 Apache Cassandr DataStax a 的 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 驱动程序策略、示例，以及结合使用 Java 驱动程序和 Amazon Keyspaces 的最佳实践，：[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 的 Pyt DataStax hon 驱动程序和 SigV4 身份验证插件连接到亚马逊密钥空间](#python_SigV4)
## 开始前的准备工作
在开始之前，您需要完成以下任务。
Amazon Keyspaces 要求使用传输层安全性协议 (TLS) 来帮助保护与客户端的连接。要使用 TLS 连接到亚马逊密钥空间，您需要下载亚马逊数字证书并将 Python 驱动程序配置为使用 TLS。
下载以下数字证书并将文件保存在本地或您的主目录中。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root（可选 — 为了向后兼容）
要下载证书，您可以使用以下命令。
```
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 正在将所有证书全部迁移 AWS 区域 到根据亚马逊信任服务（Amazon Root CAs 1—4）颁发的证书。在此过渡期间，将客户端配置为同时信任 Amazon Root CAs 1—4 和 Starfield 根，以确保所有区域之间的兼容性。
将所有下载的证书合并到一个`pem`文件中，其名称与我们的示例*keyspaces-bundle.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. 按照以下步骤操作，确保和与您在生成服务特定凭证时获得的用户名和密码*ServicePassword*相匹配。*ServiceUserName* [创建用于通过编程方式访问 Amazon Keyspaces 的服务特定凭证。](programmatic.credentials.ssc.md)
1. 有关可用端点的列表，请参阅[Amazon Keyspaces 的服务端点](programmatic.endpoints.md)。
## 使用适用于 Apache Cassandra 的 Pyt DataStax hon 驱动程序和 SigV4 身份验证插件连接到亚马逊密钥空间
以下部分介绍如何使用适用于 Apache Cassandra 的开源 Pyth DataStax on 驱动程序的 Sigv4 身份验证插件来访问亚马逊密钥空间（适用于 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 的开源 Python 驱动程序和 SigV4 身份验证插件连接到 Amaz DataStax on Keyspaces。该插件依赖于适用于 Python 的 AWS SDK (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*、与`Session Token`您使用获得的`Access Key``Secret Access Key`、和*aws\$1session\$1token*相匹配`boto3.session`。有关详细信息，请参阅*适用于 Python (Boto3) 的 AWS SDK* 中的[凭证](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 驱动程序和特定于服务的凭证连接到亚马逊密钥空间](#nodejs_ssc)
+ [使用适用于 Apache Cassandra DataStax 的 Node.js 驱动程序和 SigV4 身份验证插件连接到亚马逊密钥空间](#nodejs_SigV4)
## 开始前的准备工作
在开始之前，您需要完成以下任务。
Amazon Keyspaces 要求使用传输层安全性协议 (TLS) 来帮助保护与客户端的连接。要使用 TLS 连接到 Amazon Keyspaces，您需要下载 Amazon 数字证书，并将 Python 驱动程序配置为使用 TLS。
下载以下数字证书并将文件保存在本地或您的主目录中。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root（可选 — 为了向后兼容）
要下载证书，您可以使用以下命令。
```
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 正在将所有证书全部迁移 AWS 区域 到根据亚马逊信任服务（Amazon Root CAs 1—4）颁发的证书。在此过渡期间，将客户端配置为同时信任 Amazon Root CAs 1—4 和 Starfield 根，以确保所有区域之间的兼容性。
将所有下载的证书合并到一个`pem`文件中，其名称与我们的示例*keyspaces-bundle.pem*中的名称相同。您可以使用以下 命令进行这项操作：记下文件的路径，稍后需要这个。
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## 使用适用于 Apache Cassandra 的 Node.js DataStax 驱动程序和特定于服务的凭证连接到亚马逊密钥空间
将您的驱动程序配置为使用 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. 按照以下步骤操作，确保和与您在生成服务特定凭证时获得的用户名和密码*ServicePassword*相匹配。*ServiceUserName* [创建用于通过编程方式访问 Amazon Keyspaces 的服务特定凭证。](programmatic.credentials.ssc.md)
1. 有关可用端点的列表，请参阅[Amazon Keyspaces 的服务端点](programmatic.endpoints.md)。
## 使用适用于 Apache Cassandra DataStax 的 Node.js 驱动程序和 SigV4 身份验证插件连接到亚马逊密钥空间
以下部分介绍如何使用适用于 Apache Cassandra 的开源 DataStax Node.js 驱动程序的 Sigv4 身份验证插件来访问亚马逊密钥空间（适用于 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，并且依赖于 Node.js 的 AWS SDK。它使用 `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`。有关更多信息，请参阅 *Node.js 中的AWS SDK 中在 Node.js JavaScript 中*[设置凭证](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html)。
1. 要在代码之外存储访问密钥，请参阅[存储用于通过编程方式进行访问的访问密钥](aws.credentials.manage.md)中的最佳实践。
1. 有关可用端点的列表，请参阅[Amazon Keyspaces 的服务端点](programmatic.endpoints.md)。
# 使用 Cassandra .NET Core 客户端驱动程序以编程方式访问 Amazon Keyspaces
本部分介绍了如何使用 .NET Core 客户端驱动程序连接 Amazon Keyspaces。设置步骤因环境和操作系统而异，您可能需要相应地进行修改。Amazon Keyspaces 要求使用传输层安全性协议 (TLS) 来帮助保护与客户端的连接。要使用 TLS 连接到 Amazon Keyspaces，请将您的驱动程序配置为使用系统信任存储，其中包括亚马逊根 CAs 1-4。
1. 使用 nuget 控制台，通过 nuget 安装 Cassandra CSharp 驱动程序。
```
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. 按照以下步骤操作，确保和与您在生成服务特定凭证时获得的用户名和密码*ServicePassword*相匹配。*ServiceUserName* [创建用于通过编程方式访问 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 要求使用传输层安全性协议 (TLS) 来帮助保护与客户端的连接。要使用 TLS 连接到 Amazon Keyspaces，您需要下载 Amazon 数字证书，并将 Go 驱动程序配置为使用 TLS。
下载以下数字证书并将文件保存在本地或您的主目录中。
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root（可选 — 为了向后兼容）
要下载证书，您可以使用以下命令。
```
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 正在将所有证书全部迁移 AWS 区域 到根据亚马逊信任服务（Amazon Root CAs 1—4）颁发的证书。在此过渡期间，将客户端配置为同时信任 Amazon Root CAs 1—4 和 Starfield 根，以确保所有区域之间的兼容性。
将所有下载的证书合并到一个`pem`文件中，其名称与我们的示例*keyspaces-bundle.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. 按照以下步骤操作，确保和与您在生成服务特定凭证时获得的用户名和密码*ServicePassword*相匹配。*ServiceUserName* [创建用于通过编程方式访问 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
以下代码示例展示了如何使用开源 Go 驱动程序的 SigV4 身份验证插件访问 Amazon Keyspaces（Apache Cassandra 兼容）。
请按照[为 Amazon Keyspaces 创建和配置 AWS 证书](access.credentials.md)中的步骤为 IAM 主体创建凭证（如果您尚未创建）。如果应用程序在 Lambda 或 Amazon EC2 实例上运行，则您的应用程序将自动使用该实例的凭证。要在本地运行本教程，可以将凭证存储为本地环境变量。
[将 Go Sigv4 身份验证插件从存储库添加到您的应用程序中。GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin)该插件支持适用于 Cassandra 的开源 Go 驱动程序 1.2.x 版本，并且依赖于 Go 的 AWS SDK。
```
$ 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 要求使用传输层安全性协议 (TLS) 来帮助保护与客户端的连接。
**重要**
Amazon KeyspacesCertificents 正在过渡到亚马逊信任服务 (ATS) 层次结构。确保您的环境信任 Amazon 根 CAs 1—4，以避免在此轮换期间出现连接错误。Perl 驱动程序不会验证服务器的 Amazon SSL 证书，这意味着无法确认您是否能连接到 Amazon Keyspaces。第二步，务必要在连接 Amazon Keyspaces 时配置驱动程序以使用 TLS，这可以确保在客户端和服务器之间传输的数据经过加密。
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;
```
**重要**
按照以下步骤操作，确保和与您在生成服务特定凭证时获得的用户名和密码*ServicePassword*相匹配。*ServiceUserName* [创建用于通过编程方式访问 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 端点的更多信息，请参阅[将 Amazon Keyspaces 与接口 VPC 端点结合使用](vpc-endpoints.md)。
**Topics**
+ [使用共享 VPC 配置跨账户访问](access.cross-account.sharedVPC.md)
+ [不使用共享 VPC 配置跨账户访问](access.cross-account.noVPC.setup.md)
# 使用共享 VPC 中的 VPC 端点配置 Amazon Keyspaces 的跨账户访问
您可以创建不同的资源 AWS 账户 以将资源与应用程序分开。例如，您可以为 Amazon Keyspaces 表创建一个账户，为开发环境中的应用程序创建一个不同的账户，为生产环境中的应用程序创建另一个账户。本主题将引导您完成在共享 VPC 中使用接口 VPC 端点为 Amazon Keyspaces 设置跨账户访问所需的配置步骤。
有关如何为 Amazon Keyspaces 配置 VPC 端点的详细步骤，请参阅[步骤 3：为 Amazon Keyspaces 创建 VPC 端点](vpc-endpoints-tutorial.create-endpoint.md)。
在本例中，我们在共享 VPC 中使用了以下三个账户：
+ `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 的不同账户。\]](http://docs.aws.amazon.com/zh_cn/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. 在中创建一个 IAM 角色`Account A:111111111111`，该角色具有对 Amazon Keyspaces 表的完全访问权限、对 Amazon Keyspaces 系统表的读取权限，并且能够描述 Amazon VP EC2 C 资源，如以下策略示例所示。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "CrossAccountAccess",
"Effect": "Allow",
"Action": [
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeVpcEndpoints",
"cassandra:*"
],
"Resource": "*"
}
]
}
```
1. 在中为 IAM 角色配置信任策略`Account B:222222222222`，`Account A:111111111111`以便`Account C:333333333333`可以将该角色代入可信账户。如以下示例所示。
```
{
"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 (AWS STS) 的 `AssumeRole` API 实现的。有关更多信息，请参阅 [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 身份验证插件的应用程序，该插件允许应用程序扮演共享角色，`Account A:111111111111`通过共享 VPC 中的 VPC 终端节点连接到位于中的 Amazon Keyspaces 表。有关 SIGV4 身份验证插件的更多信息，请参阅[创建用于通过编程方式访问 Amazon Keyspaces 的凭证。](programmatic.credentials.md)。有关如何将应用程序配置为在另一个 AWS 账户中扮演角色的更多信息，请参阅[和*工具参考指南中的身份验证AWS SDKs 和*访问权限](https://docs.aws.amazon.com/sdkref/latest/guide/access.html)。
# 不使用共享 VPC 配置 Amazon Keyspaces 的跨账户访问
如果 Amazon Keyspaces 表和私有 VPC 端点由不同的账户拥有但不共享 VPC，则应用程序仍可使用 VPC 端点进行跨账户连接。由于账户不共享 VPC 端点，`Account A:111111111111`、`Account B:222222222222` 和`Account C:333333333333` 需要各自的 VPC 端点。在 Cassandra 客户端驱动程序中，Amazon Keyspaces 显示为单节点集群而不是多节点集群。连接后，客户端驱动程序会到达 DNS 服务器，服务器会返回账户 VPC 中的一个可用终端节点。
您还可以使用公有终端节点或在每个账户中部署私有 VPC 终端节点来跨不同账户访问 Amazon Keyspaces 表，而无需共享 VPC 终端节点。不使用共享 VPC 时，每个账户都需要自己的 VPC 端点。在本示例中，`Account A:111111111111`、`Account B:222222222222` 和`Account C:333333333333` 都需要各自的 VPC 端点才能访问`Account A:111111111111` 中的表。在此配置中使用 VPC 端点时，Amazon Keyspaces 在 Cassandra 客户端驱动程序中显示为单节点集群，而不是多节点集群。连接后，客户端驱动程序会到达 DNS 服务器，服务器会返回账户 VPC 中的一个可用终端节点。但客户端驱动程序无法访问 `system.peers` 表来发现其他端点。由于可用主机较少，驱动程序建立的连接也较少。要对此进行调整，请将驱动程序的连接池设置提高 3 倍。
![\[示意图：显示了同一组织在同一 AWS 区域 拥有的三个没有共享 VPC 的不同账户。\]](http://docs.aws.amazon.com/zh_cn/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. 在中创建一个 IAM 角色`Account A:111111111111`，该角色具有对 Amazon Keyspaces 表的完全访问权限和对 Amazon Keyspaces 系统表的读取权限。
```
{
"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. 为中的 IAM 角色配置信任策略，`Account A:111111111111`以便`Account B:222222222222`和中的委托人`Account C:333333333333`可以作为可信账户代入该角色。如以下示例所示。
```
{
"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`并向该终端节点授予权限，允许来自`Account B:222222222222`和`Account C:333333333333`扮演角色的角色`Account A`使用 VPC 终端节点。这些权限对它们所连接的 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 (AWS STS) 的 `AssumeRole` API 实现的。有关更多信息，请参阅 [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 账户中扮演角色的更多信息，请参阅[和*工具参考指南中的身份验证AWS SDKs 和*访问权限](https://docs.aws.amazon.com/sdkref/latest/guide/access.html)。