As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Como acessar o Amazon Keyspaces (para Apache Cassandra)
Você pode acessar o Amazon Keyspaces usando o console, AWS CloudShell, programaticamente executando um `cqlsh` cliente, o AWS SDK ou usando um driver Cassandra licenciado pelo Apache 2.0. O Amazon Keyspaces tem suporte para os drivers e os clientes que são compatíveis com o Apache Cassandra versão 3.11.2. Antes de acessar o Amazon Keyspaces, você deve concluir a configuração AWS Identity and Access Management e, em seguida, conceder a uma identidade do IAM permissões de acesso ao Amazon Keyspaces.
## Conf AWS Identity and Access Management iguração
### Inscreva-se para um Conta da AWS
Se você não tiver um Conta da AWS, conclua as etapas a seguir para criar um.
**Para se inscrever em um Conta da AWS**
1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup)
1. Siga as instruções online.
Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.
Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS envia um e-mail de confirmação após a conclusão do processo de inscrição. A qualquer momento, você pode visualizar a atividade atual da sua conta e gerenciar sua conta acessando [https://aws.amazon.com/e](https://aws.amazon.com/) escolhendo **Minha conta**.
### Criar um usuário com acesso administrativo
Depois de se inscrever em um Conta da AWS, proteja seu Usuário raiz da conta da AWS Centro de Identidade do AWS IAM, habilite e crie um usuário administrativo para que você não use o usuário root nas tarefas diárias.
**Proteja seu Usuário raiz da conta da AWS**
1. Faça login [Console de gerenciamento da AWS](https://console.aws.amazon.com/)como proprietário da conta escolhendo **Usuário raiz** e inserindo seu endereço de Conta da AWS e-mail. Na próxima página, insira a senha.
Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS *.
1. Habilite a autenticação multifator (MFA) para o usuário-raiz.
Para obter instruções, consulte [Habilitar um dispositivo de MFA virtual para seu usuário Conta da AWS raiz (console) no Guia](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) do *usuário do IAM*.
**Criar um usuário com acesso administrativo**
1. Habilita o Centro de Identidade do IAM.
Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário.
Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte [Configurar o acesso do usuário com o padrão Diretório do Centro de Identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia Centro de Identidade do AWS IAM do usuário*.
**Iniciar sessão como o usuário com acesso administrativo**
+ Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado.
Para obter ajuda para fazer login usando um usuário do IAM Identity Center, consulte Como [fazer login no portal de AWS acesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) no *Guia Início de Sessão da AWS do usuário*.
**Atribuir acesso a usuários adicionais**
1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.
Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
1. Atribua usuários a um grupo e, em seguida, atribua o acesso de logon único ao grupo.
Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
## Configurando o Amazon Keyspaces
O acesso aos recursos do Amazon Keyspaces é gerenciado usando [ IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html). Usando o IAM, você pode anexar políticas a usuários do IAM, funções e identidades federadas do IAM que concedem permissões de leitura e gravação a recursos específicos no Amazon Keyspaces.
Para começar a conceder permissões a uma identidade do IAM, você pode usar uma das políticas gerenciadas pela AWS para Amazon Keyspaces:
+ [AmazonKeyspacesFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesFullAccess.html)— esta política concede permissões para acessar todos os recursos no Amazon Keyspaces com acesso total a todos os recursos.
+ [AmazonKeyspacesReadOnlyAccess\$1v2](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesReadOnlyAccess_v2.html) — essa política concede permissões somente de leitura ao Amazon Keyspaces.
Para obter uma explicação detalhada das ações definidas nas políticas gerenciadas, consulte [AWS políticas gerenciadas para Amazon Keyspaces](security-iam-awsmanpol.md).
Para limitar o escopo das ações que uma identidade do IAM pode realizar ou limitar os recursos que a identidade pode acessar, crie uma política personalizada que use a política gerenciada de `AmazonKeyspacesFullAccess` como modelo e remova todas as permissões que você não precisa. Você também pode limitar o acesso a tabelas ou espaços de chaves específicos. Para obter mais informações sobre como restringir ações ou limitar o acesso a recursos específicos no Amazon Keyspaces, consulte [Como o Amazon Keyspaces funciona com o IAM](security_iam_service-with-iam.md).
Para acessar o Amazon Keyspaces depois de criar Conta da AWS e criar uma política que conceda a uma identidade do IAM acesso ao Amazon Keyspaces, continue em uma das seguintes seções:
+ [Como usar o console](console_keyspaces.md)
+ [Usando AWS CloudShell](using-aws-with-cloudshell.md)
# Como acessar o Amazon Keyspaces usando o console
Você pode acessar o console do Amazon Keyspaces em [https://console.aws.amazon.com/keyspaces/home](https://console.aws.amazon.com/keyspaces/home). Para obter mais informações sobre Console de gerenciamento da AWS acesso, consulte Como [controlar o acesso dos usuários do IAM ao Console de gerenciamento da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_controlling-access.html) no Guia do usuário do IAM.
É possível usar o console para fazer o seguinte no Amazon Keyspaces:
+ Criar, excluir e gerenciar tabelas e keyspaces.
+ Monitore métricas importantes da tabela na guia **Monitor** de uma tabela:
+ Tamanho da tabela faturável (bytes)
+ Métricas de capacidade
+ Execute consultas usando o editor CQL ou por meio da [AWS CloudShell experiência integrada](console_cloudshell_integration.md), por exemplo, insira, atualize e exclua dados.
+ Conecte-se diretamente ao Amazon Keyspaces por meio do suporte AWS CloudShell integrado ao CQLSH.
+ Altere a configuração do particionador da conta.
+ Veja as métricas de desempenho e erro da conta no painel.
# Conecte-se ao Amazon Keyspaces usando o AWS CloudShell console
AWS CloudShell fornece uma forma simplificada de se conectar ao Amazon Keyspaces diretamente do console. A AWS CloudShell integração inicializa automaticamente o `cqlsh-expansion` para você e estabelece uma conexão com um espaço de teclas específico.
## Começando com a AWS CloudShell integração
1. **Acesse a AWS CloudShell integração** — No console do Amazon Keyspaces, navegue até o keyspace ao qual você deseja se conectar e escolha o botão Connect **to Keyspaces**. AWS CloudShell
1. **Comando de configuração pré-preenchido** — Quando você escolhe o AWS CloudShell botão, o sistema fornece um comando pré-preenchido que inclui os parâmetros de inicialização e conexão necessários:
```
cqlsh-expansion.init ; cqlsh-expansion cassandra.region.amazonaws.com 9142 --ssl -my_keyspace
```
1. **Clique em **Executar****
1. **Aguarde até que o Amazon Keyspaces estabeleça a conexão** — Reserve um tempo para que o processo de configuração seja concluído e a conexão com o keyspace selecionado seja estabelecida.
1. **Executar comandos** — Quando conectado, você pode escrever e executar comandos CQL diretamente no espaço de teclas selecionado.
## Comandos CQLSH disponíveis
A AWS CloudShell integração fornece acesso à funcionalidade padrão do CQLSH, incluindo suporte para comandos além do CQL básico.
+ **Descrever** — Liste e visualize descrições detalhadas de espaços-chave e tabelas.
+ **Copiar** — Exporte a saída da consulta para um arquivo para processamento posterior.
+ **Fonte** — Execute instruções CQL a partir de um arquivo.
+ **Navegação pelo histórico de comandos** — Percorra os comandos anteriores usando atalhos do teclado.
+ **Execução de consultas** — Execute consultas diretamente da interface do teclado.
+ **Cópia de saída** — Copie os resultados como texto simples para uso em outros aplicativos.
## Considerações sobre recursos
Ao usar a AWS CloudShell integração, considere as seguintes vantagens e desvantagens.
**Os seguintes recursos não são suportados:**
+ Sugestões de sintaxe CQL e funcionalidade de preenchimento automático.
+ Ferramentas de edição, como mostrar preenchimento automático, mostrar dica de ferramenta, localizar, localizar e substituir, refazer, alternar comentários em bloco, alternar dobra de código, alternar comentário em linha e desfazer.
**Funcionalidade modificada:**
+ **Downloads de CSV** — Para baixar os resultados no formato CSV, especifique o `>` operador para canalizar a saída do comando:
```
SELECT * FROM my_table > file_name.csv
```
+ **Visualização JSON** - Você pode visualizar itens no formato JSON sem precisar de conversão de dados.
+ **Interface em estilo terminal** - A experiência funciona como uma interface de terminal em vez de um editor de código completo.
A AWS CloudShell integração simplifica o processo de conexão e, ao mesmo tempo, fornece a funcionalidade essencial do CQL para gerenciar seus dados do Amazon Keyspaces diretamente do. Console de gerenciamento da AWS
Para saber como criar um keyspace e uma tabela do Amazon Keyspaces e configurá-los com exemplos de dados do aplicativo, consulte [Conceitos básicos do Amazon Keyspaces (para Apache Cassandra)](getting-started.md).
# Usando AWS CloudShell para acessar o Amazon Keyspaces
AWS CloudShell é um shell pré-autenticado baseado em navegador que você pode iniciar diretamente do. Console de gerenciamento da AWS Você pode executar AWS CLI comandos em AWS serviços usando seu shell preferido (Bash PowerShell ou Z shell). AWS CloudShell vem pré-autenticado com suas credenciais do console e inclui ferramentas comuns para trabalhar com AWS serviços, incluindo o AWS CLI Python e o Node.js.
Você [inicia a AWS CloudShell partir do Console de gerenciamento da AWS](https://docs.aws.amazon.com/cloudshell/latest/userguide/working-with-cloudshell.html#launch-options), e AWS as credenciais que você usou para entrar no console estão automaticamente disponíveis em uma nova sessão de shell. Essa pré-autenticação de AWS CloudShell usuários permite que você ignore a configuração de credenciais ao interagir com serviços AWS como o Amazon Keyspaces usando `cqlsh` ou a AWS CLI versão 2 (pré-instalada no ambiente computacional do shell).
## AWS CloudShell opções de integração
O Amazon Keyspaces oferece duas formas de uso: AWS CloudShell
1. ** AWS CloudShell Experiência integrada** — Um método de conexão simplificado disponível diretamente no console do Amazon Keyspaces que inicializa e se conecta automaticamente `cqlsh-expansion` a um keyspace específico. Para obter instruções completas sobre como usar essa experiência integrada, consulte[Conecte-se ao Amazon Keyspaces usando o AWS CloudShell console](console_cloudshell_integration.md).
1. ** AWS CloudShell Configuração manual** - Instale e configure manualmente `cqlsh` em AWS CloudShell. As etapas são descritas nas seções a seguir e fornecem mais controle sobre o processo de instalação e permitem configurações personalizadas.
## Pré-requisitos
Antes de usar o Amazon Keyspaces com AWS CloudShell, certifique-se de ter:
+ Uma AWS conta com acesso ao Amazon Keyspaces e AWS CloudShell
+ Permissões apropriadas do IAM para usar os dois serviços
+ Familiaridade básica com a Cassandra Query Language (CQL)
## Começando com AWS CloudShell
Para acessar AWS CloudShell:
1. Faça login no Console de gerenciamento da AWS
1. Inicie AWS CloudShell escolhendo o AWS CloudShell ícone na barra de navegação na parte superior do console ou navegando até [https://console.aws.amazon.com/cloudshell/](https://console.aws.amazon.com/cloudshell/)
1. Aguarde até que o AWS CloudShell ambiente seja inicializado
## Obtendo permissões do IAM para AWS CloudShell
Usando os recursos de gerenciamento de acesso fornecidos por AWS Identity and Access Management, os administradores podem conceder permissões aos usuários do IAM para que eles possam acessar AWS CloudShell e usar os recursos do ambiente.
A maneira mais rápida de um administrador conceder acesso aos usuários é por meio de uma política AWS gerenciada. Uma [política gerenciada pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) é uma política independente que é criada e administrada pela AWS. A seguinte política AWS gerenciada para CloudShell pode ser anexada às identidades do IAM:
+ `AWSCloudShellFullAccess`: concede permissão para uso AWS CloudShell com acesso total a todos os recursos.
Se você quiser limitar o escopo das ações que um usuário do IAM pode realizar AWS CloudShell, crie uma política personalizada que use a política `AWSCloudShellFullAccess` gerenciada como modelo. Para obter mais informações sobre como limitar as ações que estão disponíveis para os usuários em CloudShell, consulte [Gerenciamento de AWS CloudShell acesso e uso com políticas do IAM](https://docs.aws.amazon.com/cloudshell/latest/userguide/sec-auth-with-identities.html) no *Guia do AWS CloudShell usuário*.
**nota**
Sua identidade do IAM também exige uma política que conceda permissão para fazer chamadas para o Amazon Keyspaces.
Você pode usar uma política AWS gerenciada para dar à sua identidade do IAM acesso ao Amazon Keyspaces ou começar com a política gerenciada como modelo e remover as permissões que você não precisa. Você também pode limitar o acesso a tabelas e espaços de teclas específicos para criar uma política personalizada. A seguinte política gerenciada para o Amazon Keyspaces pode ser anexada às identidades do IAM:
+ [AmazonKeyspacesFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesFullAccess.html)— Essa política concede permissão para usar o Amazon Keyspaces com acesso total a todos os recursos.
Para obter uma explicação detalhada das ações definidas na política gerenciada, consulte [AWS políticas gerenciadas para Amazon Keyspaces](security-iam-awsmanpol.md).
Para obter mais informações sobre como restringir ações ou limitar o acesso a recursos específicos no Amazon Keyspaces, consulte [Como o Amazon Keyspaces funciona com o IAM](security_iam_service-with-iam.md).
## Instalando o cliente cqlsh
AWS CloudShell não vem com `cqlsh` pré-instalado. Você precisa instalá-lo para interagir com o Amazon Keyspaces. Você pode instalar a versão específica do Amazon KeySpaces do. `cqlsh` Para obter instruções de instalação de `cqlsh-expansion`, consulte [Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh).
## Configurando certificados TLS
Para se conectar ao Amazon Keyspaces usando uma conexão TLS, você precisa baixar os certificados digitais da Amazon necessários. Para obter instruções detalhadas sobre como baixar e configurar o certificado SSL, consulte. [Como configurar manualmente as conexões `cqlsh` para o TLS](programmatic.cqlsh.md#encrypt_using_tls)
## Conectando-se ao Amazon Keyspaces
Você pode se conectar ao Amazon Keyspaces usando credenciais do IAM (recomendado) ou credenciais específicas do serviço.
### Conexão com as credenciais do IAM (recomendado)
AWS CloudShell já está autenticado com suas credenciais do IAM. Para se conectar usando essas credenciais, você pode usar o plug-in de autenticação SigV4. Para obter instruções detalhadas sobre como usar as credenciais do IAM com`cqlsh`, consulte[Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh).
### Como conectar-se com credenciais específicas do serviço
Se você criou credenciais específicas de serviço para o Amazon Keyspaces, você pode usá-las para se conectar. Para obter informações sobre como criar e usar credenciais específicas do serviço, consulte. [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md)
## Usando o CQLSH com o Amazon Keyspaces
Quando conectado, você pode usar comandos CQL padrão para interagir com seus espaços de teclas e tabelas. Para obter informações detalhadas sobre comandos e operações CQL compatíveis, consulte[Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh).
## Dados persistentes em AWS CloudShell
AWS CloudShell fornece 1 GB de armazenamento persistente em seu diretório inicial. Isso significa que os scripts, certificados e arquivos de configuração que você cria permanecem disponíveis em todas as sessões. Você pode criar um arquivo de configuração para `cqlsh` simplificar as conexões.
Com um arquivo de configuração, você pode executar `cqlsh` sem especificar parâmetros adicionais. Para obter mais informações sobre como criar e usar arquivos de `cqlsh` configuração, consulte[Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh).
## Práticas recomendadas
Ao usar o Amazon Keyspaces com AWS CloudShell, recomendamos as seguintes melhores práticas:
+ Crie scripts para tarefas repetitivas e armazene-os em seu diretório inicial persistente.
+ Use variáveis de ambiente para informações confidenciais em vez de codificá-las.
+ Lembre-se de que AWS CloudShell as sessões podem expirar após a inatividade.
+ Esteja atento às cotas e limitações do AWS CloudShell serviço.
+ Considere usar o AWS CLI para operações automatizadas com o Amazon Keyspaces.
## Solução de problemas
Se você encontrar problemas ao se conectar ao Amazon Keyspaces a partir de: AWS CloudShell
+ Verifique se suas permissões do IAM incluem as ações necessárias do Amazon Keyspaces.
+ Verifique se você está usando o endpoint correto para sua região.
+ Verifique se os certificados SSL foram baixados e referenciados corretamente.
+ Verifique se suas credenciais específicas do serviço estão corretas e não expiraram.
+ Se estiver usando um arquivo cqlshrc, verifique sua formatação e permissões.
## Exemplo: Como interagir com o Amazon Keyspaces usando AWS CloudShell
Depois AWS CloudShell de iniciar a partir do Console de gerenciamento da AWS, você pode começar imediatamente a interagir com o Amazon Keyspaces usando nossa interface `cqlsh` de linha de comando. Se você ainda não instalou o `cqlsh-expansion`, consulte [Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh) para as etapas detalhadas.
**nota**
Ao usar o `cqlsh-expansion` in AWS CloudShell, você não precisa configurar as credenciais antes de fazer chamadas, porque você já está autenticado no shell.
**Conecte-se ao Amazon Keyspaces e crie um novo espaço de chaves. Em seguida, leia uma tabela do sistema para confirmar se o keyspace foi criado usando AWS CloudShell**
1. A partir do Console de gerenciamento da AWS, você pode iniciar CloudShell escolhendo as seguintes opções disponíveis na barra de navegação:
+ Escolha o CloudShell ícone.
+ Comece a digitar `cloudshell` na caixa de pesquisa e escolha a CloudShell opção.
1. Você pode estabelecer uma conexão com o Amazon Keyspaces usando o comando a seguir. Certifique-se de `cassandra.us-east-1.amazonaws.com` substituir pelo endpoint correto para sua região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Se a conexão for bem-sucedida, você verá um resultado semelhante a este:
```
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. Crie um novo espaço de chave com o nome `mykeyspace`. É possível usar o seguinte comando para fazer isso:
```
CREATE KEYSPACE mykeyspace WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Para confirmar que o espaço de chave foi criado, você pode ler a partir de uma tabela do sistema usando o comando a seguir.
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
Se a chamada tiver êxito, a linha de comando exibirá uma resposta do serviço semelhante à seguinte saída:
```
keyspace_name | durable_writes | replication
----------------+----------------+-------------------------------------------------------------------------------------
mykeyspace | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(1 rows)
```
# Crie credenciais para acesso programático ao Amazon Keyspaces
Para fornecer aos usuários e aplicativos credenciais para acesso programático aos recursos do Amazon Keyspaces, você pode executar uma das seguintes ações:
+ Crie credenciais específicas do serviço que sejam semelhantes ao nome de usuário e senha tradicionais que o Cassandra usa para autenticação e gerenciamento de acesso. AWS as credenciais específicas do serviço estão associadas a um usuário específico AWS Identity and Access Management (IAM) e só podem ser usadas para o serviço para o qual foram criadas. Para obter mais informações, consulte [Como usar o IAM com o Amazon Keyspaces (para Apache Cassandra)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_keyspaces.html) no Guia do usuário do IAM.
**Atenção**
Os usuários do IAM têm credenciais de longo prazo, o que representa um risco de segurança. Para ajudar a reduzir esse risco, recomendamos que você forneça a esses usuários somente as permissões necessárias para realizar a tarefa e que você os remova quando não forem mais necessários.
+ Para aumentar a segurança, recomendamos criar identidades do IAM que sejam usadas em todos os AWS serviços e usar credenciais temporárias. O plug-in de autenticação SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra permite que você autentique chamadas para o Amazon Keyspaces usando chaves de acesso do IAM em vez de nome de usuário e senha. Para saber mais sobre como o plug-in SigV4 do Amazon Keyspaces permite que [usuários do IAM, perfis e identidades federadas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) se autentiquem nas solicitações da API do Amazon Keyspaces, consulte o [processo AWS Signature Version 4 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
É possível fazer download dos plugins SigV4 nos seguintes locais.
+ 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).
Para exemplos de código que mostram como estabelecer conexões usando o plug-in de autenticação SigV4, consulte [Como usar um driver de cliente Cassandra para acessar o Amazon Keyspaces programaticamente](programmatic.drivers.md).
**Topics**
+ [Crie credenciais específicas do serviço](programmatic.credentials.ssc.md)
+ [Crie credenciais do IAM para autenticação AWS](access.credentials.md)
# Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces
As credenciais específicas de serviço são semelhantes ao nome de usuário e à senha que o Cassandra usa para autenticação e gerenciamento de acesso. As credenciais específicas do serviço permitem que os usuários do IAM acessem um serviço AWS específico. Essas credenciais de longo prazo não podem ser usadas para acessar outros AWS serviços. Elas estão associados a um usuário específico do IAM e não podem ser usadas por outros usuários do IAM.
**Importante**
Credenciais específicas do serviço são credenciais de longo prazo associadas a um usuário do IAM específico e só podem ser usadas para o serviço para o qual foram criadas. Para conceder permissões às funções do IAM ou identidades federadas para acessar todos os seus AWS recursos usando credenciais temporárias, você deve usar a [AWS autenticação com o plug-in de autenticação SigV4 para Amazon Keyspaces](access.credentials.md).
Use um dos procedimentos a seguir para gerar uma credencial específica do serviço.
------
#### [ Console ]
**Crie credenciais específicas do serviço usando o console**
1. Faça login no Console de gerenciamento da AWS e abra o AWS Identity and Access Management console em[https://console.aws.amazon.com/iam/home](https://console.aws.amazon.com/iam/home).
1. No painel de navegação, escolha **Usuários** e, em seguida, escolha o usuário que você criou anteriormente e que tem permissões do Amazon Keyspaces (política anexada).
1. Selecione **Credenciais de segurança**. Em **Credenciais para Amazon Keyspaces**, escolha **Gerar credenciais** para gerar as credenciais específicas do serviço.
As credenciais específicas do seu serviço agora estão disponíveis. Esta é a única vez que a senha pode ser visualizada ou baixada. Não será possível recuperá-la posteriormente. No entanto, é possível redefinir a senha a qualquer momento. Salve o usuário e a senha em um local seguro, pois você precisará deles mais tarde.
------
#### [ CLI ]
**Crie credenciais específicas do serviço usando o AWS CLI**
Antes de gerar credenciais específicas do serviço, você precisa baixar, instalar e configurar o AWS Command Line Interface ():AWS CLI
1. Faça o download AWS CLI em [http://aws.amazon.com/cli](https://aws.amazon.com/cli).
**nota**
AWS CLI É executado em Windows, macOS ou Linux.
1. *Siga as instruções para [instalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) e [configurar a AWS CLI no Guia do](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) usuário.AWS Command Line Interface *
1. Usando o AWS CLI, execute o comando a seguir para gerar credenciais específicas do serviço para a usuária`alice`, para que ela possa acessar o Amazon Keyspaces.
```
aws iam create-service-specific-credential \
--user-name alice \
--service-name cassandra.amazonaws.com
```
A saída é semelhante à seguinte.
```
{
"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"
}
}
```
Na saída, observe os valores de `ServiceUserName` e `ServicePassword`. Salve os valores em um local seguro, pois você precisará deles mais tarde.
**Importante**
Este é o único momento em que o `ServicePassword` estará disponível para você.
------
# Crie e configure AWS credenciais para o Amazon Keyspaces
Para acessar o Amazon Keyspaces programaticamente com o AWS SDK ou com os AWS CLI drivers do cliente Cassandra e o plug-in SigV4, você precisa de um usuário do IAM com chaves de acesso. Ao usar o Amazon Keyspaces programaticamente, você fornece suas chaves de AWS acesso para que você AWS possa verificar sua identidade em chamadas programáticas. Suas chaves de acesso consistem em um ID de chave de acesso (por exemplo, AKIAIOSFODNN7 EXEMPLO) e uma chave de acesso secreta (por exemplo,wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY). Este tópico o guia pelas etapas necessárias nesse processo.
As melhores práticas de segurança recomendam que você crie usuários do IAM com permissões limitadas e, em vez disso, associe perfis do IAM às permissões necessárias para realizar tarefas específicas. Os usuários do IAM podem então assumir temporariamente os perfis do IAM para realizar as tarefas necessárias. Por exemplo, os usuários do IAM na sua conta que estiverem usando o console do Amazon Keyspaces podem mudar para uma função para usarem, temporariamente, as permissões da função no console. Os usuários cedem suas permissões originais e assumem as permissões atribuídas à função. Quando os usuários saem da função, suas permissões originais são restauradas. As credenciais que os usuários usam para assumir a função são temporárias. Ao contrário, os usuários do IAM têm credenciais de longo prazo, o que representa um risco de segurança se, em vez de assumir funções, tiverem permissões atribuídas diretamente a eles. Para ajudar a reduzir esse risco, recomendamos que você forneça a esses usuários somente as permissões necessárias para realizar a tarefa e que você os remova quando não forem mais necessários. Para obter mais informações sobre funções, consulte [ Common Scenarios for Roles: Users, Applications, and Services](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios.html) no *Guia do usuário do IAM*.
**Topics**
+ [
# Credenciais exigidas pelo AWS CLI AWS SDK ou pelo plug-in SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra
](SigV4_credentials.md)
+ [
# Crie credenciais temporárias para se conectar ao Amazon Keyspaces usando um perfil do IAM e o plug-in SigV4
](temporary.credentials.IAM.md)
+ [
# Crie um usuário do IAM para acesso programático ao Amazon Keyspaces em sua conta AWS
](access.credentials.IAM.md)
+ [
# Crie novas chaves de acesso para um usuário do IAM
](create.keypair.md)
+ [
# Armazene chaves de acesso para acesso programático
](aws.credentials.manage.md)
# Credenciais exigidas pelo AWS CLI AWS SDK ou pelo plug-in SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra
As seguintes credenciais são necessárias para autenticar o usuário do IAM ou o perfil do IAM:
`AWS_ACCESS_KEY_ID`
Especifica uma chave de AWS acesso associada a um usuário ou função do IAM.
A chave de acesso `aws_access_key_id` é necessária para se conectar programaticamente ao Amazon Keyspaces.
`AWS_SECRET_ACCESS_KEY`
Especifica a chave secreta associada à chave de acesso. Essencialmente, essa é a “senha” para a chave de acesso.
A `aws_secret_access_key` é necessária para se conectar programaticamente ao Amazon Keyspaces.
`AWS_SESSION_TOKEN`— Opcional
Especifica o valor de token de sessão que é necessário se você estiver usando credenciais de segurança temporárias recuperadas diretamente das operações do AWS Security Token Service . Para obter mais informações, consulte [Crie credenciais temporárias para se conectar ao Amazon Keyspaces usando um perfil do IAM e o plug-in SigV4](temporary.credentials.IAM.md).
Se você estiver se conectando com um usuário do IAM, o `aws_session_token` não é obrigatório.
# Crie credenciais temporárias para se conectar ao Amazon Keyspaces usando um perfil do IAM e o plug-in SigV4
A forma recomendada de acessar o Amazon Keyspaces programaticamente é usando [credenciais temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) para se autenticar com o plug-in SigV4. Em muitos casos, você não precisa de chaves de acesso de longo prazo que nunca expiram (como há no caso de um usuário do IAM). Em vez disso, você pode criar perfis do IAM e gerar credenciais de segurança temporárias. As credenciais de segurança temporárias consistem em um ID da chave de acesso e uma chave de acesso secreta, mas elas também incluem um token de segurança que indica quando as credenciais expiram. Para saber mais sobre como usar funções do IAM em vez de chaves de acesso de longo prazo, consulte Como [mudar para uma função do IAM (AWS API)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-api.html).
Para começar com credenciais temporárias, primeiro você precisa criar um perfil do IAM.
**Crie um perfil do IAM que conceda acesso somente leitura ao Amazon Keyspaces**
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, selecione **Perfis** e depois **Criar perfil**.
1. Na página **Criar perfil**, em **Selecionar tipo de entidade confiável**, selecione **AWS serviço**. Em **Escolher um caso de uso**, escolha **Amazon EC2** e escolha **Próximo**.
1. Na página **Adicionar permissões**, em **Políticas de permissões**, escolha **Amazon Keyspaces Read Only Access** na lista de políticas e escolha **Próximo**.
1. Na página **Nome, revisão e criação**, insira um nome para o perfil e revise as seções **Selecionar entidades confiáveis** e **Adicionar permissões**. Você também pode adicionar tags opcionais para o perfil nesta página. Quando concluir, selecione **Criar perfil**. Lembre-se desse nome, pois você precisará dele quando executar sua instância do Amazon EC2.
Para usar credenciais de segurança temporárias no código, você chama programaticamente uma AWS Security Token Service API como `AssumeRole` e extrai as credenciais e o token de sessão resultantes da sua função do IAM que você criou na etapa anterior. Em seguida, você usa esses valores como credenciais para chamadas subsequentes para AWS. O exemplo a seguir mostra o pseudocódigo de como usar credenciais de segurança temporárias:
```
assumeRoleResult = AssumeRole(role-arn);
tempCredentials = new SessionAWSCredentials(
assumeRoleResult.AccessKeyId,
assumeRoleResult.SecretAccessKey,
assumeRoleResult.SessionToken);
cassandraRequest = CreateAmazoncassandraClient(tempCredentials);
```
Para obter um exemplo que implementa credenciais temporárias usando o driver Python para acessar o Amazon Keyspaces, consulte [Conecte-se ao Amazon Keyspaces usando o driver DataStax Python para Apache Cassandra e o plug-in de autenticação SigV4](using_python_driver.md#python_SigV4).
Para obter detalhes sobre como chamar `AssumeRole`, `GetFederationToken` e outras operações de API, consulte a [Referência da API do AWS Security Token Service](https://docs.aws.amazon.com/STS/latest/APIReference/). Para obter informações sobre como obter as credenciais de segurança temporárias e o token de sessão provenientes do resultado, consulte a documentação do SDK com o qual você está trabalhando. Você pode encontrar a documentação de todos AWS SDKs na [página principal da AWS documentação](https://aws.amazon.com/documentation), na seção **SDKs e kits de ferramentas**.
# Crie um usuário do IAM para acesso programático ao Amazon Keyspaces em sua conta AWS
Para obter credenciais para acesso programático ao Amazon Keyspaces com o plug-in AWS CLI, AWS SDK ou SigV4, você precisa primeiro criar um usuário ou uma função do IAM. O processo de criar um usuário do IAM e configurar esse usuário do IAM para ter acesso programático ao Amazon Keyspaces é mostrado nas seguintes etapas:
1. Crie o usuário no Console de gerenciamento da AWS Tools for Windows PowerShell ou usando uma operação de AWS API. AWS CLI Se você criar o usuário no Console de gerenciamento da AWS, as credenciais serão criadas automaticamente.
1. Caso crie o usuário programaticamente, você deverá criar uma chave de acesso (uma ID de chave de acesso e uma chave de acesso secreta) para esse usuário em uma etapa adicional.
1. Conceda ao usuário permissões para acessar o Amazon Keyspaces.
Para obter informações sobre as permissões de que você precisa para criar um usuário do IAM, consulte [Permissões necessárias para acessar recursos do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html).
------
#### [ Console ]
**Crie um usuário do IAM com acesso programático (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Users** (Usuários) e **Add users** (Adicionar usuários).
1. Digite o nome para o novo usuário. Esse é o nome de login do. AWS
**nota**
Os nomes de usuário podem ser uma combinação de até 64 letras, dígitos e estes caracteres: adição (\$1), igual (=), vírgula (,), ponto (.), arroba (@), sublinhado (\$1) e hífen (-). Os nomes devem ser exclusivos em uma conta. Eles não são diferenciados por maiúsculas e minúsculas. Por exemplo, você não pode criar dois usuários denominados *TESTUSER* e *testuser*.
1. Selecione **Chave de acesso - Acesso programático** para criar uma chave de acesso para o novo usuário. Você pode visualizar ou fazer download das chaves de acesso ao acessar a página **Final**.
Escolha **Próximo: Permissões**.
1. Na página **Set permissions (Definir permissões)**, selecione **Attach existing policies to user directly (Anexar políticas existentes diretamente ao usuário)**.
Essa opção exibe a lista de políticas AWS gerenciadas e gerenciadas pelo cliente disponíveis em sua conta. Você pode inserir `keyspaces` no campo de pesquisa para exibir apenas políticas relacionadas ao Amazon Keyspaces.
Para o Amazon Keyspaces, as políticas gerenciadas disponíveis são `AmazonKeyspacesFullAccess` e `AmazonKeyspacesReadOnlyAccess`. Para obter mais informações sobre cada política, consulte [AWS políticas gerenciadas para Amazon Keyspaces](security-iam-awsmanpol.md).
Para fins de teste e para seguir os tutoriais de conexão, selecione a `AmazonKeyspacesReadOnlyAccess` política para o novo usuário do IAM. **Observação:** como uma prática recomendada, sugerimos que você siga o princípio do privilégio mínimo e crie políticas personalizadas que limitem o acesso a recursos específicos e permitam apenas as ações necessárias. Para obter mais informações sobre políticas do IAM e para ver políticas de exemplo para Amazon Keyspaces, consulte [Políticas baseadas em identidade do Amazon Keyspaces](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies). Depois de criar políticas de permissão personalizadas, anexe suas políticas às funções e deixe os usuários assumirem temporariamente as funções apropriadas.
Escolha **Próximo: tags**.
1. Na página **Adicionar tags (opcional)**, você pode adicionar tags para o usuário ou escolher **Avançar: Revisão**.
1. Na página **Revisão**, você poder ver todas as escolhas feitas até esse ponto. Quando estiver pronto para continuar, escolha **Criar usuário**.
1. Para visualizar as chaves de acesso do usuário (chave de acesso IDs e chaves de acesso secretas), escolha **Mostrar** ao lado da senha e da chave de acesso. Para salvar as chaves de acesso, escolha **Fazer download de .csv** e, em seguida, salve o arquivo em um local seguro.
**Importante**
Esta é a única oportunidade de visualizar ou fazer download das chaves de acesso secretas, e você precisa desta informação antes de poder usar o plug-in SigV4. Salve a nova ID da chave de acesso do usuário e a chave de acesso secreta em um local seguro e protegido. Você não terá acesso às chaves secretas novamente depois dessa etapa.
------
#### [ CLI ]
**Crie um usuário do IAM com acesso programático (AWS CLI)**
1. Crie um usuário com o AWS CLI código a seguir.
+ [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. Forneça ao usuário acesso programático. Isso requer chaves de acesso, que podem ser geradas como se segue.
+ 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)
+ Ferramentas para 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)
+ API do IAM: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html)
**Importante**
Esta é a única oportunidade de visualizar ou fazer download das chaves de acesso secretas, e você precisa desta informação antes de poder usar o plug-in SigV4. Salve a nova ID da chave de acesso do usuário e a chave de acesso secreta em um local seguro e protegido. Você não terá acesso às chaves secretas novamente depois dessa etapa.
1. Anexe uma política `AmazonKeyspacesReadOnlyAccess` ao usuário que defina as permissões do usuário. **Observação:** como prática recomendada, recomendamos que você gerencie as permissões de usuário adicionando o usuário a um grupo e anexando uma política ao grupo, em vez de anexá-la diretamente a um usuário.
+ 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)
------
# Crie novas chaves de acesso para um usuário do IAM
Caso já tenha um usuário do IAM, você poderá criar novas chaves de acesso a qualquer momento. Para obter informações sobre como gerenciar chaves, por exemplo, como atualizar as chaves de acesso, consulte [Gerenciar chaves de acesso para usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**Para criar chaves de acesso para um usuário do IAM (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Users**.
1. Escolha o nome do usuário para o qual você deseja criar uma chave de acesso.
1. Na página **Resumo**, clique na guia **Credenciais de segurança**.
1. Na seção **Chaves de acesso**, em **Melhores práticas e alternativas das chaves de acesso**, escolha o caso de uso **Outro**. Clique em **Avançar**, insira as informações opcionais conforme necessário e escolha **Criar chave de acesso**.
Para ver o novo par de chaves de acesso, escolha **Show** (Mostrar). Suas credenciais terão a seguinte aparência:
+ ID da chave de acesso: AKIAIOSFODNN7 EXEMPLO
+ Chave de acesso secreta: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
**nota**
Você não terá mais acesso à chave de acesso secreta depois que essa caixa de diálogo for fechada.
Considere as seguintes práticas recomendadas para o key pair que você criou.
+ Nunca armazene sua chave de acesso em texto simples, em um repositório de código ou em código.
+ Desative ou exclua as chaves de acesso quando não forem mais necessárias.
+ Ative as permissões com privilégios mínimos.
+ Gire as teclas de acesso regularmente.
1. Para baixar o par de chaves, escolha **Baixar arquivo .csv**. Armazene as chaves em um lugar seguro.
1. Depois de baixar o arquivo .csv, escolha **Close** (Fechar).
Quando você cria uma chave de acesso, o par de chaves é ativo por padrão, e você pode usar o par imediatamente.
# Armazene chaves de acesso para acesso programático
Como uma prática recomendada, sugerimos que você não incorpore chaves de acesso diretamente no código. As ferramentas de linha de AWS comando AWS SDKs e as ferramentas de linha de comando permitem que você coloque as chaves de acesso em locais conhecidos para que você não precise mantê-las em código. Coloque chaves de acesso em um dos seguintes locais:
+ **Variáveis de ambiente**: em um sistema multicliente, escolha as variáveis de ambiente do usuário, não as variáveis de ambiente do sistema.
+ **Arquivo de credenciais da CLI**: os arquivos `credentials` e `config` são atualizados quando você executa o comando `aws configure`. O arquivo `credentials` está localizado em `~/.aws/credentials` no Linux, no macOS ou no Unix, ou ainda em `C:\Users\USERNAME\.aws\credentials` no Windows. Esse arquivo pode conter os detalhes da credencial para o perfil `default` e quaisquer perfis nomeados.
+ **Arquivo de configuração da CLI**: os arquivos `credentials` e `config` são atualizados quando você executa o comando `aws configure`. O arquivo `config` está localizado em `~/.aws/config` no Linux, no macOS ou no Unix, ou ainda em `C:\Users\USERNAME\.aws\config` no Windows. Esse arquivo contém as definições de configuração para o perfil padrão e quaisquer perfis nomeados.
Armazenar chaves de acesso como variáveis de ambiente é um pré-requisito para o [Step-by-step tutorial para se conectar ao Amazon Keyspaces usando o driver DataStax Java 4.x para Apache Cassandra e o plug-in de autenticação SigV4](using_java_driver.md#java_tutorial.SigV4). Observe que isso inclui o padrão Região da AWS. O cliente pesquisa credenciais usando a cadeia de fornecedores de credenciais padrão, e as chaves de acesso armazenadas como variáveis de ambiente têm precedência sobre todos os outros locais, por exemplo, arquivos de configuração. Para obter mais informações, consulte [Definições e precedência de configuração](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-precedence).
Os exemplos a seguir mostram como configurar variáveis de ambiente para o usuário padrão.
------
#### [ 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
```
Configurar a variável de ambiente altera o valor usado até o final da sua sessão de shell ou até que você defina a variável como um valor diferente. Você pode tornar as variáveis persistentes em sessões futuras definindo-as no script de inicialização do 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
```
O uso de `[set](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/set_1)` para definir uma variável de ambiente altera o valor usado até o final da sessão de prompt de comando atual ou até que você defina a variável como um valor diferente. O uso de [https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx) para definir uma variável de ambiente altera o valor usado na sessão de prompt de comando atual e todas as sessões de prompt de comando que você criar após a execução do comando. ***Não*** afeta outros shells de comando que já estejam em execução no momento em que você executar o comando.
------
#### [ 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"
```
Se você definir uma variável de ambiente no PowerShell prompt, conforme mostrado nos exemplos anteriores, ela salvará o valor somente durante a sessão atual. Para tornar a configuração da variável de ambiente persistente em todas as sessões PowerShell e nas sessões do Prompt de Comando, armazene-a usando o aplicativo **Sistema** no **Painel de Controle**. Como alternativa, você pode definir a variável para todas as PowerShell sessões futuras adicionando-a ao seu PowerShell perfil. Consulte a [PowerShell documentação](https://docs.microsoft.com/powershell/module/microsoft.powershell.core/about/about_environment_variables) para obter mais informações sobre como armazenar variáveis de ambiente ou persisti-las nas sessões.
------
# Endpoints de serviço para Amazon Keyspaces
**Topics**
+ [
## Portas e protocolos
](#ports)
+ [
## Endpoints globais
](#global_endpoints)
+ [
## AWS GovCloud (US) Region Endpoints FIPS
](#fips_endpoints)
+ [
## Endpoints da região da China
](#china_endpoints)
+ [
## Endpoints de streaming
](#streams_endpoints)
+ [
# Conexão a endpoints de pilha dupla
](dualstack_endpoints.md)
## Portas e protocolos
Você pode acessar o Amazon Keyspaces programaticamente executando um `cqlsh` cliente, com um driver Cassandra licenciado pelo Apache 2.0 ou usando o e o SDK. AWS CLI AWS
A tabela a seguir mostra as portas e os protocolos dos diferentes mecanismos de acesso.
| Acesso programático | Porta | Protocolo |
| --- | --- | --- |
| CQLSH | 9142 | TLS |
| Driver Cassandra | 9142 | TLS |
| AWS CLI | 443 | HTTPS |
| AWS SDK | 443 | HTTPS |
Para conexões TLS, o Amazon Keyspaces usa certificados emitidos pelo Amazon Trust Services (Amazon CAs Root 1—4) para se autenticar no servidor. Para obter mais informações, consulte [Como configurar manualmente as conexões `cqlsh` para o TLS](programmatic.cqlsh.md#encrypt_using_tls) ou a seção [Antes de começar](using_java_driver.md#using_java_driver.BeforeYouBegin) do seu driver no capítulo [Como usar um driver de cliente Cassandra para acessar o Amazon Keyspaces programaticamente](programmatic.drivers.md).
## Endpoints globais
O Amazon Keyspaces oferece suporte a ambos IPv4 e a endpoints IPv6 públicos. Você pode escolher entre IPv4 endpoints e endpoints de pilha dupla. Os endpoints usam a seguinte convenção de nomenclatura, na qual você pode *us-east-1* substituir por outra disponível na Região da AWS tabela.
+ **IPv4 pontos finais** — `cassandra.us-east-1.amazonaws.com`
+ **Endpoints de pilha dupla** — `cassandra.us-east-1.api.aws`
Para obter mais informações sobre endpoints de pilha dupla e como configurar conexões, consulte. [Conexão a endpoints de pilha dupla](dualstack_endpoints.md)
O Amazon Keyspaces está disponível nas seguintes regiões.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/keyspaces/latest/devguide/programmatic.endpoints.html)
## AWS GovCloud (US) Region Endpoints FIPS
Endpoints FIPS disponíveis no AWS GovCloud (US) Region. O Amazon Keyspaces oferece suporte a ambos IPv4 e aos endpoints IPv6 FIPS. Você pode escolher entre IPv4 endpoints e endpoints de pilha dupla. Para obter mais informações, consulte [Amazon Keyspaces no *AWS GovCloud (US) Guia do Usuário*](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/pt_br/keyspaces/latest/devguide/programmatic.endpoints.html)
## Endpoints da região da China
O Amazon Keyspaces oferece suporte a IPv4 endpoints nas regiões da China AWS .
Para acessar esses endpoints, você precisa se inscrever em um conjunto separado de credenciais de conta exclusivas para as regiões da China. Para obter mais informações, consulte [Inscrição, contas e credenciais na China](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/pt_br/keyspaces/latest/devguide/programmatic.endpoints.html)
## Endpoints de streaming
Amazon Keyspaces CDC streams está disponível a seguir Regiões da AWS. Esta tabela mostra o endpoint de serviço de pilha dupla disponível para cada região. Para obter mais informações sobre Amazon Keyspaces CDC streams, consulte[Como acessar endpoints de stream do CDC no Amazon Keyspaces](CDC_access-endpoints.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/keyspaces/latest/devguide/programmatic.endpoints.html)
# Conexão a endpoints de pilha dupla
Os endpoints globais do Amazon Keyspaces são endpoints de pilha dupla que aceitam e solicitam. IPv4 IPv6
Ao se conectar ao Amazon Keyspaces usando IPv6, o serviço adapta automaticamente as respostas da tabela do sistema para corresponder ao seu protocolo de conexão. Isso garante que seus aplicativos recebam informações de endereço de rede consistentes que correspondam ao tipo de conexão. Isso fornece informações precisas da topologia de rede ao cliente, mantendo a compatibilidade com versões anteriores dos aplicativos CQL existentes.
O Amazon Keyspaces detecta automaticamente o protocolo de rede (IPv4 ou IPv6) usado pela conexão do seu cliente e ajusta as respostas da tabela do sistema adequadamente. Essa detecção ocorre de forma transparente durante o handshake de conexão inicial, não exigindo nenhuma configuração adicional do aplicativo cliente.
O Amazon Keyspaces retorna endereços IP com base no seu protocolo de conexão. Por exemplo, uma solicitação de uma IPv4 rede retorna a seguinte resposta.
```
SELECT * FROM system.peers;
-- Returns IPv4 addresses in peer column
-- Example: 172.31.1.1, 172.31.1.2, etc.
```
Uma conexão de uma IPv6 rede com um endpoint de pilha dupla, por exemplo`cassandra.us-east-1.api.aws`, retorna a seguinte resposta.
```
SELECT * FROM system.peers;
-- Returns IPv6 addresses in peer column
-- Example: 2001:db8::1, 2001:db8::2, etc.
```
Para obter mais informações sobre o IPv6 suporte no Amazon Keyspaces, consulte. [IPv6 suporte no Amazon Keyspaces](ipv6-support.md)
# IPv6 suporte no Amazon Keyspaces
IPv6 o suporte no Amazon Keyspaces permite que os aplicativos estabeleçam conexões usando o Internet Protocol versão 6, o protocolo de internet de próxima geração que fornece um espaço de endereço amplamente expandido em comparação com o. IPv4 A implementação usa endpoints de pilha dupla que oferecem suporte a ambos IPv4 e IPv6 simultaneamente, garantindo compatibilidade com versões anteriores e permitindo conectividade pronta para o futuro. Para uma lista de endpoints , consulte [Endpoints globais](programmatic.endpoints.md#global_endpoints).
O Amazon Keyspaces implementa o IPv6 suporte por meio de uma arquitetura de pilha dupla que mantém total compatibilidade com versões anteriores e permite a conectividade. IPv6
## Resolução de DNS no Amazon Keyspaces
Quando os aplicativos se conectam a endpoints de pilha dupla, o processo de resolução de DNS retorna os dois tipos de endereço:
Registros A (IPv4)
IPv4 Endereços tradicionais para compatibilidade com versões anteriores
Registros AAAA () IPv6
Novos IPv6 endereços para conectividade moderna
O sistema operacional e a pilha de rede do cliente selecionam automaticamente o protocolo mais adequado com base na configuração local, na disponibilidade da rede e nas preferências do sistema.
O protocolo Cassandra Query Language (CQL) oferece suporte contínuo à IPv6 conectividade sem exigir alterações no código do aplicativo.
Seleção automática de protocolos
+ Os aplicativos especificam o endpoint de pilha dupla
+ A pilha de rede escolhe IPv4 ou IPv6 com base na disponibilidade
+ Nenhuma modificação de código é necessária para aplicativos CQL existentes
Compatibilidade de drivers
+ Todos os principais drivers CQL oferecem suporte transparente IPv6
+ DataStax os motoristas lidam com IPv6 endereços de forma nativa
+ Os drivers de código aberto funcionam sem modificações
Consistência da conexão
+ As tabelas do sistema refletem o protocolo de conexão usado
+ IPv6 conexões mostram IPv6 endereços em `system.peers`
+ IPv4 as conexões continuam mostrando IPv4 endereços
# Usar `cqlsh` para se conectar ao Amazon Keyspaces
Para se conectar ao Amazon Keyspaces usando `cqlsh`, você pode usar o `cqlsh-expansion`. Este é um kit de ferramentas que contém ferramentas comuns do Apache Cassandra, como `cqlsh`, e auxiliares pré-configurados para o Amazon Keyspaces, mantendo total compatibilidade com o Apache Cassandra. O `cqlsh-expansion` integra o plug-in de autenticação SigV4 e permite que você se conecte usando chaves de acesso do IAM em vez de nome de usuário e senha. Você só precisa instalar os scripts `cqlsh` para fazer uma conexão e não a distribuição completa do Apache Cassandra, porque o Amazon Keyspaces é uma tecnologia sem servidor. Esse pacote de instalação leve inclui os `cqlsh-expansion` e os scripts clássicos `cqlsh` que você pode instalar em qualquer plataforma compatível com Python.
**nota**
`Murmur3Partitioner` é o particionador recomendado para o Amazon Keyspaces e o `cqlsh-expansion`. O `cqlsh-expansion` não é compatível com o Amazon Keyspaces `DefaultPartitioner`. Para obter mais informações, consulte [Como trabalhar com particionadores no Amazon Keyspaces](working-with-partitioners.md).
Para obter informações gerais sobre o `cqlsh`, consulte [`cqlsh`: shell do CQL](https://cassandra.apache.org/doc/latest/cassandra/managing/tools/cqlsh.html).
**Topics**
+ [
## Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces
](#using_cqlsh)
+ [
## Como configurar manualmente as conexões `cqlsh` para o TLS
](#encrypt_using_tls)
## Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces
**Instalar e configurar a `cqlsh-expansion`**
1. Para instalar o pacote `cqlsh-expansion` Python, você pode executar um comando `pip`. Isso instala os scripts `cqlsh-expansion` em sua máquina usando uma *instalação pip* e um arquivo contendo uma lista de dependências. O `--user flag` instrui `pip` a usar o diretório de instalação do usuário do Python para sua plataforma. Em um sistema baseado em Unix, esse deve ser o diretório `~/.local/`.
Você precisa do Python 3 para instalar o `cqlsh-expansion`. Para descobrir sua versão do Python, use `Python --version`. Para instalar, é possível executar o comando a seguir.
```
python3 -m pip install --user cqlsh-expansion
```
A saída deve ser semelhante a esta.
```
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
```
Se o diretório de instalação não estiver no`PATH`, você precisará adicioná-lo seguindo as instruções do seu sistema operacional. Abaixo está um exemplo para o Ubuntu Linux.
```
export PATH="$PATH:/home/ubuntu/.local/bin"
```
Para confirmar se o pacote foi instalado, você pode executar o comando a seguir.
```
cqlsh-expansion --version
```
A saída deve ser algo parecido com isso.
```
cqlsh 6.1.0
```
1. Para configurar o `cqlsh-expansion`, você pode executar um script de pós-instalação para concluir automaticamente as seguintes etapas:
1. Crie o diretório `.cassandra` no diretório inicial do usuário se ele ainda não existir.
1. Copie um arquivo `cqlshrc` de configuração pré-configurado no diretório `.cassandra`.
1. Copie o arquivo de certificado combinado no `.cassandra` diretório. O Amazon Keyspaces usa esse certificado para configurar a conexão segura com o Transport Layer Security (TLS). A criptografia em trânsito fornece uma camada adicional de proteção de dados ao criptografar seus dados à medida que eles viajam de e para o Amazon Keyspaces. Para obter mais informações sobre certificados, consulte[Como configurar manualmente as conexões `cqlsh` para o TLS](#encrypt_using_tls).
Para revisar o script primeiro, você pode acessá-lo no repositório do Github em [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).
Para usar o script, você pode executar o seguinte comando.
```
cqlsh-expansion.init
```
**nota**
O diretório e o arquivo criados pelo script de pós-instalação não são removidos quando você desinstala o `cqlsh-expansion` usando `pip uninstall`, e precisam ser excluídos manualmente.
**Conectar-se ao Amazon Keyspaces usando `cqlsh-expansion`**
1. Configure seu Região da AWS e adicione-o como uma variável de ambiente do usuário.
Para adicionar sua região padrão como uma variável de ambiente em um sistema baseado em Unix, você pode executar o comando a seguir. Para este exemplo, usamos`us-east-1`.
```
export AWS_DEFAULT_REGION=us-east-1
```
Para obter mais informações sobre como definir variáveis de ambiente, inclusive para outras plataformas, consulte [Como definir variáveis de ambiente](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html#envvars-set).
1. Encontre seu endpoint.
Escolha o endpoint de serviço apropriado para sua região. Para analisar os endpoints disponíveis para o Amazon Keyspaces, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md). Para este exemplo, usamos o endpoint `cassandra.us-east-1.amazonaws.com`.
1. Configurar o modo de autenticação.
A conexão com as chaves de acesso do IAM (usuários, perfis e identidades federadas do IAM) é o método recomendado para aumentar a segurança.
Antes de se conectar com as chaves de acesso do IAM, você precisa concluir as seguintes etapas:
1. Crie um usuário do IAM ou siga as melhores práticas e crie um perfil do IAM que os usuários do IAM possam assumir. Para obter mais informações sobre como criar uma chave de acesso do IAM, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
1. Crie uma política do IAM que conceda ao perfil (ou ao usuário do IAM) no mínimo o acesso somente leitura ao Amazon Keyspaces. Para obter mais informações sobre as permissões necessárias para que o usuário ou o perfil do IAM se conecte ao Amazon Keyspaces, consulte [Como acessar as tabelas do Amazon Keyspaces](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-one-table).
1. Adicione as chaves de acesso do usuário do IAM às variáveis de ambiente do usuário, conforme mostrado no exemplo a seguir.
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
Para obter mais informações sobre como definir variáveis de ambiente, inclusive para outras plataformas, consulte [Como definir variáveis de ambiente](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html#envvars-set).
**nota**
Se você estiver se conectando a partir de uma instância do Amazon EC2, também precisará configurar uma regra de saída no grupo de segurança que permita o tráfego da instância para o Amazon Keyspaces. Para obter mais informações sobre como exibir e editar regras de saída do EC2, consulte [Adicionar regras a um grupo de segurança no Guia do usuário do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule).
1. Conectar-se ao Amazon Keyspaces usando a `cqlsh-expansion` e a autenticação SigV4.
Para se conectar ao Amazon Keyspaces com a `cqlsh-expansion`, você pode usar o comando a seguir. Certifique-se de substituir o endpoint de serviço pelo endpoint correto para sua região.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Se a conexão for bem-sucedida, você verá um resultado semelhante a este:
```
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>
```
Se você encontrar um erro de conexão, consulte [Não consigo me conectar ao Amazon Keyspaces com o cqlsh](troubleshooting.connecting.md#troubleshooting.connection.cqlsh) para obter informações sobre solução de problemas.
+ Conectar-se ao Amazon Keyspaces com credenciais específicas do serviço.
Para se conectar à combinação tradicional de nome de usuário e senha que o Cassandra usa para autenticação, você deve primeiro criar credenciais específicas do serviço para o Amazon Keyspaces, conforme descrito em [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md). Você também precisa conceder a esse usuário permissões para acessar o Amazon Keyspaces. Para obter mais informações, consulte [Como acessar as tabelas do Amazon Keyspaces](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-one-table).
Depois de criar credenciais e permissões específicas do serviço para o usuário, você deve atualizar o arquivo `cqlshrc`, normalmente encontrado no caminho do diretório do usuário `~/.cassandra/`. No arquivo `cqlshrc`, vá para a seção `[authentication]` do Cassandra e comente o módulo e a classe SigV4 em `[auth_provider]` usando o caractere “;”, conforme mostrado no exemplo a seguir.
```
[auth_provider]
; module = cassandra_sigv4.auth
; classname = SigV4AuthProvider
```
Depois de atualizar o arquivo `cqlshrc`, você pode se conectar ao Amazon Keyspaces com credenciais específicas do serviço usando o comando a seguir.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 -u myUserName -p myPassword --ssl
```
**Limpeza**
+ Para remover o pacote `cqlsh-expansion`, é possível usar o comando `pip uninstall`.
```
pip3 uninstall cqlsh-expansion
```
O comando `pip3 uninstall` não remove o diretório e os arquivos relacionados criados pelo script de pós-instalação. Para remover a pasta e os arquivos criados pelo script de pós-instalação, você pode excluir o diretório `.cassandra`.
## Como configurar manualmente as conexões `cqlsh` para o TLS
O Amazon Keyspaces só aceita conexões seguras usando Transport Layer Security (TLS). Você pode usar o `cqlsh-expansion` utilitário que baixa automaticamente os certificados para você e instala um arquivo de `cqlshrc` configuração pré-configurado. Para obter mais informações sobre isso, consulte [Usar a `cqlsh-expansion` para se conectar ao Amazon Keyspaces](#using_cqlsh) nesta página.
Se quiser baixar os certificados e configurar a conexão manualmente, você pode fazer isso usando as etapas a seguir.
1. Baixe os seguintes certificados digitais e salve os arquivos localmente ou em seu diretório pessoal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional — para compatibilidade com versões anteriores)
Para baixar os certificados, você pode usar os seguintes comandos.
```
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
```
**nota**
O Amazon Keyspaces usava anteriormente certificados TLS ancorados na CA Starfield Class 2. AWS está migrando tudo Regiões da AWS para certificados emitidos pelo Amazon Trust Services (Amazon Root CAs 1—4). Durante essa transição, configure os clientes para que confiem tanto na Amazon Root CAs 1—4 quanto na raiz Starfield para garantir a compatibilidade em todas as regiões.
1. Combine todos os certificados baixados em um único `pem` arquivo com o nome *keyspaces-bundle.pem* em nossos exemplos. Você pode fazer isso executando o seguinte comando : Anote o caminho para o arquivo, você precisará disso mais tarde.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
1. Abra o arquivo `cqlshrc` de configuração no diretório inicial do Cassandra, por exemplo, `${HOME}/.cassandra/cqlshrc`, e adicione as linhas a seguir.
```
[connection]
port = 9142
factory = cqlshlib.ssl.ssl_transport_factory
[ssl]
validate = true
certfile = path_to_file/keyspaces-bundle.pem
```
# Usando o AWS CLI para se conectar ao Amazon Keyspaces
Você pode usar o AWS Command Line Interface (AWS CLI) para controlar vários AWS serviços na linha de comando e automatizá-los por meio de scripts. Com o Amazon Keyspaces, você pode usar o AWS CLI para operações de linguagem de definição de dados (DDL), como criar uma tabela. Além disso, você pode usar serviços e ferramentas de infraestrutura como código (IaC), como AWS CloudFormation o Terraform.
Antes de usar o AWS CLI com o Amazon Keyspaces, você deve obter um ID de chave de acesso e uma chave de acesso secreta. Para obter mais informações, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
Para obter uma lista completa de todos os comandos disponíveis para o Amazon Keyspaces no AWS CLI, consulte a Referência de [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**
+ [
## Baixando e configurando o AWS CLI
](#access.cli.installcli)
+ [
## Usando o AWS CLI com o Amazon Keyspaces
](#access.cli.usingcli)
## Baixando e configurando o AWS CLI
O AWS CLI está disponível em[https://aws.amazon.com/cli](https://aws.amazon.com/cli). Ela é executada no Windows, macOS ou Linux. Depois de baixar o AWS CLI, siga estas etapas para instalá-lo e configurá-lo:
1. Acesse o [Guia do usuário do AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).
1. Siga as instruções de [Instalação da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) e [Configuração da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
## Usando o AWS CLI com o Amazon Keyspaces
O formato de linha de comando consiste em um nome de operação do Amazon Keyspaces, seguido pelos parâmetros dessa operação. O AWS CLI suporta uma sintaxe abreviada para os valores dos parâmetros, bem como para JSON. Os seguintes exemplos do Amazon Keyspaces usam sintaxe AWS CLI abreviada. Para obter mais informações, consulte [Usando a sintaxe abreviada com a CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-shorthand.html). AWS
O comando a seguir cria um espaço de chaves com o *catálogo* de nomes.
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
O comando retorna o recurso nome do recurso da Amazon (ARN) na saída.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/"
}
```
Para confirmar que o *catálogo* do espaço de chave existe, você pode usar o seguinte comando.
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
A saída do comando retorna os seguintes valores.
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/"
}
```
O comando a seguir cria uma tabela com o nome *book\$1awards*. A chave de partição da tabela consiste nas colunas `year` e `award` e a chave de agrupamento consiste nas colunas `category` de `rank`. As duas colunas de agrupamento usam a ordem de classificação crescente. (Para facilitar a leitura, comandos longos nesta seção são divididos em linhas separadas.)
```
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}]'
```
Este comando resulta na seguinte saída.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
Para confirmar os metadados e as propriedades da tabela, você pode usar o seguinte comando:
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
Este comando retorna a seguinte saída.
```
{
"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": ""
}
}
```
Ao criar tabelas com esquemas complexos, pode ser útil carregar a definição do esquema da tabela a partir de um arquivo JSON. A seguir, temos um exemplo. Faça o download do arquivo JSON de exemplo de definição de esquema em [schema\$1definition.zip](samples/schema_definition.zip) e extraia `schema_definition.json`, anotando o caminho para o arquivo. Neste exemplo, o arquivo JSON de definição do esquema está localizado no diretório atual. Para diferentes opções de caminho de arquivo, consulte [ Como carregar parâmetros de um arquivo](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'
```
Os exemplos a seguir mostram como criar uma tabela simples com o nome *myTable* com opções adicionais. Observe que os comandos estão divididos em linhas separadas para melhorar a legibilidade. Esse comando mostra como criar uma tabela e:
+ definir o modo de capacidade da tabela
+ ativar Point-in-time a recuperação da tabela
+ definir a vida útil (TTL) padrão para a tabela como um ano
+ adicionar duas tags para a tabela
```
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'
```
Este exemplo mostra como criar uma nova tabela que usa uma chave gerenciada pelo cliente para criptografia e tem o TTL ativado para permitir que você defina datas de expiração para colunas e linhas. Para executar essa amostra, você deve substituir o ARN do recurso da AWS KMS chave gerenciada pelo cliente pela sua própria chave e garantir que o Amazon Keyspaces tenha acesso a ela.
```
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'
```
# Usar a API para se conectar ao Amazon Keyspaces
Você pode usar o AWS SDK e o AWS Command Line Interface (AWS CLI) para trabalhar interativamente com o Amazon Keyspaces. Você pode usar a API para operações de definição de linguagem de dados (DDL), como criar um espaço de chave ou uma tabela. Além disso, você pode usar serviços e ferramentas de infraestrutura como código (IaC), como AWS CloudFormation o Terraform.
Antes de usar o AWS CLI com o Amazon Keyspaces, você deve obter um ID de chave de acesso e uma chave de acesso secreta. Para obter mais informações, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
Para obter uma lista completa de todas as operações disponíveis para Amazon Keyspaces na API, consulte [https://docs.aws.amazon.com/keyspaces/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/keyspaces/latest/APIReference/Welcome.html).
# Como usar um driver de cliente Cassandra para acessar o Amazon Keyspaces programaticamente
Você pode usar vários drivers Cassandra de código aberto de terceiros para se conectar ao Amazon Keyspaces. O Amazon Keyspaces é compatível com os drivers do Cassandra que suportam o Apache Cassandra versão 3.11.2. Estes são os drivers e as versões mais recentes que testamos e recomendamos usar com o 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`
Para obter mais informações sobre os drivers do Cassandra, consulte [Drivers do Apache Cassandra Client](http://cassandra.apache.org/doc/latest/getting_started/drivers.html).
**nota**
Para ajudar você a começar, você pode visualizar e baixar exemplos de end-to-end códigos que estabelecem conexões com o Amazon Keyspaces com drivers populares. Veja [exemplos do Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-examples) em. GitHub
Os tutoriais deste capítulo incluem uma consulta CQL simples para confirmar que a conexão com o Amazon Keyspaces foi estabelecida com sucesso. Para saber como trabalhar com espaços de chaves e tabelas depois de se conectar a um endpoint do Amazon Keyspaces, consulte [Referência de idiomas CQL para Amazon Keyspaces (para Apache Cassandra)](cql.md). Para ver um step-by-step tutorial que mostra como se conectar ao Amazon Keyspaces a partir de um endpoint da Amazon VPC, consulte. [Tutorial: Conecte-se ao Amazon Keyspaces usando uma interface VPC endpoint](vpc-endpoints-tutorial.md)
**Topics**
+ [
# Como usar um driver de cliente Java Cassandra para acessar o Amazon Keyspaces programaticamente
](using_java_driver.md)
+ [
# Como usar um driver de cliente Cassandra Python para acessar o Amazon Keyspaces programaticamente
](using_python_driver.md)
+ [
# Como usar um driver de cliente Cassandra Node.js para acessar o Amazon Keyspaces programaticamente
](using_nodejs_driver.md)
+ [
# Como usar um driver de cliente Cassandra .NET Core para acessar o Amazon Keyspaces programaticamente
](using_dotnetcore_driver.md)
+ [
# Como usar um driver de cliente Cassandra Go para acessar o Amazon Keyspaces programaticamente
](using_go_driver.md)
+ [
# Como usar um driver de cliente Cassandra Perl para acessar o Amazon Keyspaces programaticamente
](using_perl_driver.md)
# Como usar um driver de cliente Java Cassandra para acessar o Amazon Keyspaces programaticamente
Esta seção mostra como se conectar ao Amazon Keyspaces usando um driver de cliente Java.
**nota**
Atualmente, o Java 17 e o DataStax Java Driver 4.17 estão apenas em suporte Beta. Para obter mais informações, consulte [https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/](https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/).
Para fornecer aos usuários e aplicativos credenciais para acesso programático aos recursos do Amazon Keyspaces, você pode executar uma das seguintes ações:
+ Criar credenciais específicas do serviço associadas a um usuário específico AWS Identity and Access Management (IAM).
+ Para aumentar a segurança, recomendamos criar chaves de acesso do IAM para identidades do IAM que são usadas em todos os AWS serviços. O plug-in de autenticação SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra permite que você autentique chamadas para o Amazon Keyspaces usando chaves de acesso do IAM em vez de nome de usuário e senha. Para obter mais informações, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
**nota**
Para obter um exemplo de como usar o Amazon Keyspaces com o Spring Boot, consulte [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**
+ [
## Antes de começar
](#using_java_driver.BeforeYouBegin)
+ [
## Step-by-step tutorial para se conectar ao Amazon Keyspaces usando o driver DataStax Java para Apache Cassandra usando credenciais específicas do serviço
](#java_tutorial)
+ [
## Step-by-step tutorial para se conectar ao Amazon Keyspaces usando o driver DataStax Java 4.x para Apache Cassandra e o plug-in de autenticação SigV4
](#java_tutorial.SigV4)
+ [
## Conecte-se ao Amazon Keyspaces usando o driver DataStax Java 3.x para Apache Cassandra e o plug-in de autenticação SigV4
](#java3x_tutorial.SigV4)
## Antes de começar
Para se conectar ao Amazon Keyspaces, você precisa concluir as seguintes tarefas antes de começar.
1. O Amazon Keyspaces requer o uso do Transport Layer Security (TLS) para ajudar a proteger as conexões com os clientes.
1. Faça o download dos seguintes certificados digitais e salve os arquivos localmente ou em seu diretório pessoal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional — para compatibilidade com versões anteriores)
Para baixar os certificados, você pode usar os seguintes comandos.
```
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
```
**nota**
O Amazon Keyspaces usava anteriormente certificados TLS ancorados na CA Starfield Class 2. AWS está migrando tudo Regiões da AWS para certificados emitidos pelo Amazon Trust Services (Amazon Root CAs 1—4). Durante essa transição, configure os clientes para que confiem tanto na Amazon Root CAs 1—4 quanto na raiz Starfield para garantir a compatibilidade em todas as regiões.
1. Converta os certificados digitais em arquivos TrustStore e adicione-os ao keystore.
```
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
```
Na última etapa, você precisa criar uma senha para o armazenamento de chaves e confiar em cada certificado. O comando interativo tem a aparência a seguir.
```
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. Anexe o arquivo trustStore nos argumentos da JVM:
```
-Djavax.net.ssl.trustStore=path_to_file/cassandra_truststore.jks
-Djavax.net.ssl.trustStorePassword=my_password
```
## Step-by-step tutorial para se conectar ao Amazon Keyspaces usando o driver DataStax Java para Apache Cassandra usando credenciais específicas do serviço
O step-by-step tutorial a seguir mostra como se conectar ao Amazon Keyspaces usando um driver Java para Cassandra usando credenciais específicas do serviço. Especificamente, você usará a versão 4.0 do driver DataStax Java para o Apache Cassandra.
**Topics**
+ [
### Etapa 1: pré-requisitos
](#java_tutorial.prereq)
+ [
### Etapa 2: configurar o driver
](#java_tutorial.driverconfiguration)
+ [
### Etapa 3: executar o aplicativo de exemplo
](#java_tutorial.application)
### Etapa 1: pré-requisitos
Para seguir este tutorial, você precisa gerar credenciais específicas do serviço e adicionar o driver DataStax Java para Apache Cassandra ao seu projeto Java.
+ Gere credenciais específicas do serviço para seu usuário do IAM do Amazon Keyspaces concluindo as etapas em [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md). Se preferir usar as chaves de acesso do IAM para autenticação, consulte [Step-by-step tutorial para se conectar ao Amazon Keyspaces usando o driver DataStax Java 4.x para Apache Cassandra e o plug-in de autenticação SigV4](#java_tutorial.SigV4).
+ Adicione o driver DataStax Java para Apache Cassandra ao seu projeto Java. Verifique se está usando uma versão do driver compatível com o Apache Cassandra 3.11.2. Para obter mais informações, consulte a documentação do [driver DataStax Java para Apache Cassandra](https://github.com/datastax/java-driver).
### Etapa 2: configurar o driver
Você pode especificar as configurações do driver DataStax Java Cassandra criando um arquivo de configuração para seu aplicativo. Esse arquivo de configuração substitui as configurações padrão e instrui o driver a se conectar ao endpoint do serviço Amazon Keyspaces usando a porta 9142. Para obter uma lista de endpoints de serviço, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
Crie um arquivo de configuração e salve-o na pasta de recursos do aplicativo — por exemplo, `src/main/resources/application.conf`. Abra `application.conf` e adicione as seguintes configurações.
1. **Provedor de autenticação** — Crie o provedor de autenticação com a `PlainTextAuthProvider` classe. *ServiceUserName*e *ServicePassword* deve corresponder ao nome de usuário e à senha que você obteve ao gerar as credenciais específicas do serviço seguindo as etapas em. [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md)
**nota**
Você pode usar credenciais de curto prazo usando o plug-in de autenticação do driver DataStax Java para Apache Cassandra em vez de credenciais codificadas no arquivo de configuração do driver. Para saber mais, siga as instruções do [Step-by-step tutorial para se conectar ao Amazon Keyspaces usando o driver DataStax Java 4.x para Apache Cassandra e o plug-in de autenticação SigV4](#java_tutorial.SigV4).
1. **Datacenter local**: defina o valor `local-datacenter` para a região à qual você está se conectando. Por exemplo, se o aplicativo estiver se conectando a `cassandra.us-east-2.amazonaws.com`, defina o datacenter local como `us-east-2`. Para saber todas as Regiões da AWS disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md). Defina `slow-replica-avoidance = false` para balancear a carga em relação a menos nós.
1. **SSL/TLS** — Inicialize a SSLEngine fábrica adicionando uma seção no arquivo de configuração com uma única linha que especifica a classe com. `class = DefaultSslEngineFactory` Forneça o caminho para o arquivo trustStore e a senha que você criou anteriormente. O Amazon Keyspaces não oferece suporte `hostname-validation` a pares, então defina essa opção como 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
}
}
```
**nota**
Em vez de adicionar o caminho para o trustStore no arquivo de configuração, você também pode adicioná-lo diretamente no código do aplicativo ou aos seus argumentos da JVM.
### Etapa 3: executar o aplicativo de exemplo
Este exemplo de código mostra um aplicativo de linha de comando simples que cria um pool de conexões com o Amazon Keyspaces usando o arquivo de configuração que criamos anteriormente. Ele confirma que a conexão foi estabelecida executando uma consulta simples.
```
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"));
}
}
}
```
**nota**
Use um `try` bloco para estabelecer a conexão e garantir que ela esteja sempre fechada. Se você não usa um `try` bloco, lembre-se de fechar sua conexão para evitar o vazamento de recursos.
## Step-by-step tutorial para se conectar ao Amazon Keyspaces usando o driver DataStax Java 4.x para Apache Cassandra e o plug-in de autenticação SigV4
A seção a seguir descreve como usar o plug-in de autenticação SigV4 para o driver DataStax Java 4.x de código aberto do Apache Cassandra para acessar o Amazon Keyspaces (para o Apache Cassandra). O plug-in está disponível no [GitHubrepositório.](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin)
O plug-in de autenticação SigV4 permite que você use credenciais do IAM para usuários ou perfis ao se conectar ao Amazon Keyspaces. Em vez de exigir um nome de usuário e senha, esse plug-in assina solicitações de API usando chaves de acesso. Para obter mais informações, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
### Etapa 1: pré-requisitos
Para seguir este tutorial, você precisa concluir as tarefas a seguir.
+ Se ainda não tiver feito isso, crie credenciais para o usuário do IAM ou o perfil do IAM seguindo as etapas em [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md). Este tutorial pressupõe que as chaves de acesso sejam armazenadas como variáveis de ambiente. Para obter mais informações, consulte [Armazene chaves de acesso para acesso programático](aws.credentials.manage.md).
+ Adicione o driver DataStax Java para Apache Cassandra ao seu projeto Java. Verifique se está usando uma versão do driver compatível com o Apache Cassandra 3.11.2. Para obter mais informações, consulte a documentação do [driver DataStax Java para Apache Cassandra](https://github.com/datastax/java-driver).
+ Adicione o plug-in de autenticação ao seu aplicativo. O plug-in de autenticação suporta a versão 4.x do driver DataStax Java para Apache Cassandra. Se estiver usando o Apache Maven ou um sistema de compilação que pode usar dependências do Maven, adicione as seguintes dependências ao seu arquivo `pom.xml`.
**Importante**
Substitua a versão do plug-in pela versão mais recente, conforme mostrado no [GitHub repositório](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
```
### Etapa 2: configurar o driver
Você pode especificar as configurações do driver DataStax Java Cassandra criando um arquivo de configuração para seu aplicativo. Esse arquivo de configuração substitui as configurações padrão e instrui o driver a se conectar ao endpoint do serviço Amazon Keyspaces usando a porta 9142. Para obter uma lista de endpoints de serviço, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
Crie um arquivo de configuração e salve-o na pasta de recursos do aplicativo — por exemplo, `src/main/resources/application.conf`. Abra `application.conf` e adicione as seguintes configurações.
1. **Provedor de autenticação**: defina o `advanced.auth-provider.class` para uma nova instância de `software.aws.mcs.auth.SigV4AuthProvider`. O SigV4 AuthProvider é o manipulador de autenticação fornecido pelo plug-in para realizar a autenticação SigV4.
1. **Datacenter local**: defina o valor `local-datacenter` para a região à qual você está se conectando. Por exemplo, se o aplicativo estiver se conectando a `cassandra.us-east-2.amazonaws.com`, defina o datacenter local como `us-east-2`. Para todos os disponíveis Regiões da AWS, consulte[Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md). Defina `slow-replica-avoidance = false` para balancear a carga em relação a todos os nós disponíveis.
1. **Idempotência** — Defina o padrão `idempotence` para que o aplicativo configure o driver `true` para sempre repetir as solicitações com falha. read/write/prepare/execute Essa é uma prática recomendada para aplicativos distribuídos que ajuda a lidar com falhas transitórias ao tentar novamente solicitações com falha.
1. **SSL/TLS** — Inicialize a SSLEngine fábrica adicionando uma seção no arquivo de configuração com uma única linha que especifica a classe com. `class = DefaultSslEngineFactory` Forneça o caminho para o arquivo trustStore e a senha que você criou anteriormente. O Amazon Keyspaces não oferece suporte `hostname-validation` a pares, então defina essa opção como false.
1. **Conexões**: crie pelo menos 3 conexões locais por endpoint configurando `local.size = 3`. Essa é uma prática recomendada que ajuda seu aplicativo a lidar com sobrecarga e picos de tráfego. Para obter mais informações sobre como calcular quantas conexões locais por endpoint seu aplicativo precisa com base nos padrões de tráfego esperados, consulte [Como configurar conexões no Amazon Keyspaces](connections.md#connections.howtoconfigure).
1. **Política de repetição**: implemente a política de repetição do Amazon Keyspaces `AmazonKeyspacesExponentialRetryPolicy` em vez da `DefaultRetryPolicy` que vem com o driver Cassandra. Isso permite que você configure o número de tentativas de repetição para `AmazonKeyspacesExponentialRetryPolicy` que atenda às suas necessidades. Por padrão, o número de tentativas de repetição do `AmazonKeyspacesExponentialRetryPolicy` é definido como 3. Para obter mais informações, consulte [Como configurar a política de nova tentativa para conexões no Amazon Keyspaces](connections.md#connections.retry-policies).
1. **Declarações preparadas**: defina `prepare-on-all-nodes`como falso para otimizar o uso da rede.
```
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
}
}
}
```
**nota**
Em vez de adicionar o caminho para o trustStore no arquivo de configuração, você também pode adicioná-lo diretamente no código do aplicativo ou aos seus argumentos da JVM.
### Etapa 3: executar o aplicativo
Este exemplo de código mostra um aplicativo de linha de comando simples que cria um pool de conexões com o Amazon Keyspaces usando o arquivo de configuração que criamos anteriormente. Ele confirma que a conexão foi estabelecida executando uma consulta simples.
```
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"));
}
}
}
```
**nota**
Use um `try` bloco para estabelecer a conexão e garantir que ela esteja sempre fechada. Se você não usa um `try` bloco, lembre-se de fechar sua conexão para evitar o vazamento de recursos.
## Conecte-se ao Amazon Keyspaces usando o driver DataStax Java 3.x para Apache Cassandra e o plug-in de autenticação SigV4
A seção a seguir descreve como usar o plug-in de autenticação SigV4 para o driver DataStax Java de código aberto 3.x para o Apache Cassandra acessar o Amazon Keyspaces. O plug-in está disponível no [GitHub repositório.](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible)
O plug-in de autenticação SigV4 permite que você use credenciais do IAM para usuários e perfis ao se conectar ao Amazon Keyspaces. Em vez de exigir um nome de usuário e senha, esse plug-in assina solicitações de API usando chaves de acesso. Para obter mais informações, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
### Etapa 1: pré-requisitos
Para executar esse exemplo de código, primeiro você precisa concluir as tarefas a seguir.
+ Crie credenciais para seu usuário do IAM ou perfil do IAM seguindo as etapas em [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md). Este tutorial pressupõe que as chaves de acesso sejam armazenadas como variáveis de ambiente. Para obter mais informações, consulte [Armazene chaves de acesso para acesso programático](aws.credentials.manage.md).
+ Siga as etapas em [Antes de começar](#using_java_driver.BeforeYouBegin) para baixar os certificados digitais, convertê-los em arquivos TrustStore e anexar o keystore nos argumentos da JVM ao seu aplicativo.
+ Adicione o driver DataStax Java para Apache Cassandra ao seu projeto Java. Verifique se está usando uma versão do driver compatível com o Apache Cassandra 3.11.2. Para obter mais informações, consulte a documentação do [driver DataStax Java para Apache Cassandra](https://github.com/datastax/java-driver).
+ Adicione o plug-in de autenticação ao seu aplicativo. O plug-in de autenticação suporta a versão 3.x do driver DataStax Java para Apache Cassandra. Se estiver usando o Apache Maven ou um sistema de compilação que pode usar dependências do Maven, adicione as seguintes dependências ao seu arquivo `pom.xml`. Substitua a versão do plug-in pela versão mais recente, conforme mostrado no [GitHub repositório](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
```
### Etapa 2: executar o aplicativo
Este exemplo de código mostra um aplicativo de linha de comando simples que cria um pool de conexões com o Amazon Keyspaces. Ele confirma que a conexão foi estabelecida executando uma consulta simples.
```
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"));
}
}
```
Observações de uso:
Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
Consulte o seguinte repositório para políticas úteis de drivers Java, exemplos, e melhores práticas ao usar o driver Java com o Amazon Keyspaces: [https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers).
# Como usar um driver de cliente Cassandra Python para acessar o Amazon Keyspaces programaticamente
Esta seção mostra como se conectar ao Amazon Keyspaces usando um driver de cliente Python. Para fornecer aos usuários e aplicativos credenciais para acesso programático aos recursos do Amazon Keyspaces, você pode executar uma das seguintes ações:
+ Criar credenciais específicas do serviço associadas a um usuário específico AWS Identity and Access Management (IAM).
+ Para aumentar a segurança, recomendamos criar chaves de acesso do IAM para usuários ou funções do IAM que são usadas em todos os AWS serviços. O plug-in de autenticação SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra permite que você autentique chamadas para o Amazon Keyspaces usando chaves de acesso do IAM em vez de nome de usuário e senha. Para obter mais informações, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Antes de começar
](#using_python_driver.BeforeYouBegin)
+ [
## Conecte-se ao Amazon Keyspaces usando o driver Python para Apache Cassandra e credenciais específicas do serviço
](#python_ssc)
+ [
## Conecte-se ao Amazon Keyspaces usando o driver DataStax Python para Apache Cassandra e o plug-in de autenticação SigV4
](#python_SigV4)
## Antes de começar
Você precisa concluir a tarefa seguinte antes de iniciar.
O Amazon Keyspaces requer o uso do Transport Layer Security (TLS) para ajudar a proteger as conexões com os clientes. Para se conectar ao Amazon Keyspaces usando o TLS, você precisa baixar os certificados digitais da Amazon e configurar o driver do Python para usar o TLS.
Faça o download dos seguintes certificados digitais e salve os arquivos localmente ou em seu diretório pessoal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional — para compatibilidade com versões anteriores)
Para baixar os certificados, você pode usar os seguintes comandos.
```
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
```
**nota**
O Amazon Keyspaces usava anteriormente certificados TLS ancorados na CA Starfield Class 2. AWS está migrando tudo Regiões da AWS para certificados emitidos pelo Amazon Trust Services (Amazon Root CAs 1—4). Durante essa transição, configure os clientes para que confiem tanto na Amazon Root CAs 1—4 quanto na raiz Starfield para garantir a compatibilidade em todas as regiões.
Combine todos os certificados baixados em um único `pem` arquivo com o nome *keyspaces-bundle.pem* em nossos exemplos. Você pode fazer isso executando o seguinte comando : Anote o caminho para o arquivo, você precisará disso mais tarde.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Conecte-se ao Amazon Keyspaces usando o driver Python para Apache Cassandra e credenciais específicas do serviço
O exemplo de código a seguir mostra como se conectar ao Amazon Keyspaces com um driver de cliente Python e credenciais específicas do serviço.
```
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)
```
Observações de uso:
1. `"path_to_file/keyspaces-bundle.pem"`Substitua pelo caminho para o arquivo de certificado combinado salvo na primeira etapa.
1. Certifique-se de que *ServiceUserName* e *ServicePassword* corresponda ao nome de usuário e à senha que você obteve ao gerar as credenciais específicas do serviço seguindo as etapas para. [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
## Conecte-se ao Amazon Keyspaces usando o driver DataStax Python para Apache Cassandra e o plug-in de autenticação SigV4
A seção a seguir mostra como usar o plug-in de autenticação SigV4 para o driver DataStax Python de código aberto do Apache Cassandra para acessar o Amazon Keyspaces (para o Apache Cassandra).
Se ainda não tiver feito isso, comece criando credenciais para o usuário ou o perfil do IAM seguindo as etapas em [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md). Este tutorial usa credenciais temporárias, o que requer um perfil do IAM. Para obter mais informações sobre credenciais temporárias, consulte [Crie credenciais temporárias para se conectar ao Amazon Keyspaces usando um perfil do IAM e o plug-in SigV4](temporary.credentials.IAM.md).
[Em seguida, adicione o plug-in de autenticação Python SigV4 ao seu ambiente a partir do repositório. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin)
```
pip install cassandra-sigv4
```
O exemplo de código a seguir mostra como se conectar ao Amazon Keyspaces usando o driver DataStax Python de código aberto para Cassandra e o plug-in de autenticação SigV4. O plug-in depende do AWS SDK para Python (Boto3). Ele usa `boto3.session` para obter credenciais temporárias.
```
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)
```
Observações de uso:
1. Substitua `"path_to_file/keyspaces-bundle.pem"` pelo caminho para o certificado salvo na primeira etapa.
1. Certifique-se de que o *aws\$1access\$1key\$1id**aws\$1secret\$1access\$1key*, e o *aws\$1session\$1token* correspondam ao `Access Key``Secret Access Key`, e `Session Token` que você obteve usando`boto3.session`. Para obter mais informações, consulte [Credenciais](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) no *AWS SDK para Python (Boto3)*.
1. Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
# Como usar um driver de cliente Cassandra Node.js para acessar o Amazon Keyspaces programaticamente
Esta seção mostra como se conectar ao Amazon Keyspaces usando um driver de cliente Node.js. Para fornecer aos usuários e aplicativos credenciais para acesso programático aos recursos do Amazon Keyspaces, você pode executar uma das seguintes ações:
+ Criar credenciais específicas do serviço associadas a um usuário específico AWS Identity and Access Management (IAM).
+ Para aumentar a segurança, recomendamos criar chaves de acesso do IAM para usuários ou funções do IAM que são usadas em todos os AWS serviços. O plug-in de autenticação SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra permite que você autentique chamadas para o Amazon Keyspaces usando chaves de acesso do IAM em vez de nome de usuário e senha. Para obter mais informações, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Antes de começar
](#using_nodejs_driver.BeforeYouBegin)
+ [
## Conecte-se ao Amazon Keyspaces usando o DataStax driver Node.js para Apache Cassandra e credenciais específicas do serviço
](#nodejs_ssc)
+ [
## Conecte-se ao Amazon Keyspaces usando o driver DataStax Node.js para Apache Cassandra e o plug-in de autenticação SigV4
](#nodejs_SigV4)
## Antes de começar
Você precisa concluir a tarefa seguinte antes de iniciar.
O Amazon Keyspaces requer o uso do Transport Layer Security (TLS) para ajudar a proteger as conexões com os clientes. Para se conectar ao Amazon Keyspaces usando o TLS, você precisa baixar um certificado digital da Amazon e configurar o driver do Python para usar o TLS.
Faça o download dos seguintes certificados digitais e salve os arquivos localmente ou em seu diretório pessoal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional — para compatibilidade com versões anteriores)
Para baixar os certificados, você pode usar os seguintes comandos.
```
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
```
**nota**
O Amazon Keyspaces usava anteriormente certificados TLS ancorados na CA Starfield Class 2. AWS está migrando tudo Regiões da AWS para certificados emitidos pelo Amazon Trust Services (Amazon Root CAs 1—4). Durante essa transição, configure os clientes para que confiem tanto na Amazon Root CAs 1—4 quanto na raiz Starfield para garantir a compatibilidade em todas as regiões.
Combine todos os certificados baixados em um único `pem` arquivo com o nome *keyspaces-bundle.pem* em nossos exemplos. Você pode fazer isso executando o seguinte comando : Anote o caminho para o arquivo, você precisará disso mais tarde.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Conecte-se ao Amazon Keyspaces usando o DataStax driver Node.js para Apache Cassandra e credenciais específicas do serviço
Configure seu driver para usar o arquivo de certificado combinado `keyspaces-bundle.pem` para TLS e autenticar usando credenciais específicas do serviço. Por exemplo:
```
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}`));
```
Observações de uso:
1. `"path_to_file/keyspaces-bundle.pem"`Substitua pelo caminho para o arquivo de certificado combinado salvo na primeira etapa.
1. Certifique-se de que *ServiceUserName* e *ServicePassword* corresponda ao nome de usuário e à senha que você obteve ao gerar as credenciais específicas do serviço seguindo as etapas para. [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
## Conecte-se ao Amazon Keyspaces usando o driver DataStax Node.js para Apache Cassandra e o plug-in de autenticação SigV4
A seção a seguir mostra como usar o plug-in de autenticação SigV4 para o driver DataStax Node.js de código aberto do Apache Cassandra para acessar o Amazon Keyspaces (para o Apache Cassandra).
Se ainda não tiver feito isso, crie credenciais para o usuário do IAM ou o perfil do IAM seguindo as etapas em [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
[Adicione o plug-in de autenticação Node.js SigV4 ao seu aplicativo a partir do GitHub repositório.](https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin) O plug-in é compatível com a versão 4.x do driver DataStax Node.js para Cassandra e depende do AWS SDK para Node.js. Ele usa `AWSCredentialsProvider` para obter credenciais.
```
$ npm install aws-sigv4-auth-cassandra-plugin --save
```
Este exemplo de código mostra como definir uma instância específica da região `SigV4AuthProvider` como provedor de autenticação.
```
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}`));
```
Observações de uso:
1. Substitua `"path_to_file/keyspaces-bundle.pem"` pelo caminho para o certificado salvo na primeira etapa.
1. Certifique-se de que *accessKeyId* e *secretAccessKey* corresponda à chave de acesso e à chave de acesso secreta que você obteve usando`AWSCredentialsProvider`. Para obter mais informações, consulte [Configuração de credenciais em Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html) no *AWS SDK para JavaScript em Node.js*.
1. Para armazenar chaves de acesso fora do código, consulte as melhores práticas em [Armazene chaves de acesso para acesso programático](aws.credentials.manage.md).
1. Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
# Como usar um driver de cliente Cassandra .NET Core para acessar o Amazon Keyspaces programaticamente
Esta seção mostra como se conectar ao Amazon Keyspaces usando um driver de cliente .NET Core. As etapas de configuração variam de acordo com o ambiente e o sistema operacional. Talvez seja necessário modificá-las adequadamente. O Amazon Keyspaces requer o uso do Transport Layer Security (TLS) para ajudar a proteger as conexões com os clientes. Para se conectar ao Amazon Keyspaces usando TLS, configure seu driver para usar o armazenamento confiável do sistema, que inclui o Amazon Root 1-4. CAs
1. Instale o CSharp driver Cassandra por meio do nuget, usando o console do nuget.
```
PM> Install-Package CassandraCSharpDriver
```
1. O exemplo a seguir usa um projeto de console do .NET Core C\$1 para se conectar ao Amazon Keyspaces e executar uma consulta.
```
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);
}
}
}
}
```
Observações de uso:
1. Certifique-se de usar o armazenamento confiável padrão do sistema, que inclui o Amazon Root CAs 1-4.
1. Certifique-se de que *ServiceUserName* e *ServicePassword* corresponda ao nome de usuário e à senha que você obteve ao gerar as credenciais específicas do serviço seguindo as etapas para. [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
# Como usar um driver de cliente Cassandra Go para acessar o Amazon Keyspaces programaticamente
Esta seção mostra como se conectar ao Amazon Keyspaces usando um driver de cliente Go Cassandra. Para fornecer aos usuários e aplicativos credenciais para acesso programático aos recursos do Amazon Keyspaces, você pode executar uma das seguintes ações:
+ Criar credenciais específicas do serviço associadas a um usuário específico AWS Identity and Access Management (IAM).
+ Para aumentar a segurança, recomendamos criar chaves de acesso do IAM para entidades principais do IAM que sejam usadas em todos os AWS serviços. O plug-in de autenticação SigV4 do Amazon Keyspaces para drivers de clientes do Cassandra permite que você autentique chamadas para o Amazon Keyspaces usando chaves de acesso do IAM em vez de nome de usuário e senha. Para obter mais informações, consulte [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Antes de começar
](#using_go_driver.BeforeYouBegin)
+ [
## Conecte-se ao Amazon Keyspaces usando o driver Gocql para Apache Cassandra e credenciais específicas do serviço
](#go_ssc)
+ [
## Conecte-se ao Amazon Keyspaces usando o driver Go para Apache Cassandra e o plug-in de autenticação SigV4
](#go_SigV4)
## Antes de começar
Você precisa concluir a tarefa seguinte antes de iniciar.
O Amazon Keyspaces requer o uso do Transport Layer Security (TLS) para ajudar a proteger as conexões com os clientes. Para se conectar ao Amazon Keyspaces usando o TLS, você precisa baixar um certificado digital da Amazon e configurar o driver do Go para usar o TLS.
Faça o download dos seguintes certificados digitais e salve os arquivos localmente ou em seu diretório pessoal.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opcional — para compatibilidade com versões anteriores)
Para baixar os certificados, você pode usar os seguintes comandos.
```
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
```
**nota**
O Amazon Keyspaces usava anteriormente certificados TLS ancorados na CA Starfield Class 2. AWS está migrando tudo Regiões da AWS para certificados emitidos pelo Amazon Trust Services (Amazon Root CAs 1—4). Durante essa transição, configure os clientes para que confiem tanto na Amazon Root CAs 1—4 quanto na raiz Starfield para garantir a compatibilidade em todas as regiões.
Combine todos os certificados baixados em um único `pem` arquivo com o nome *keyspaces-bundle.pem* em nossos exemplos. Você pode fazer isso executando o seguinte comando : Anote o caminho para o arquivo, você precisará disso mais tarde.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Conecte-se ao Amazon Keyspaces usando o driver Gocql para Apache Cassandra e credenciais específicas do serviço
1. Crie um diretório para seu aplicativo.
```
mkdir ./gocqlexample
```
1. Navegue até o novo diretório.
```
cd gocqlexample
```
1. Crie um arquivo para o aplicativo.
```
touch cqlapp.go
```
1. Baixe o driver Go.
```
go get github.com/gocql/gocql
```
1. Adicione o código de exemplo a seguir ao arquivo 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()
}
```
Observações de uso:
1. `"path_to_file/keyspaces-bundle.pem"`Substitua pelo caminho para o arquivo de certificado combinado salvo na primeira etapa.
1. Certifique-se de que *ServiceUserName* e *ServicePassword* corresponda ao nome de usuário e à senha que você obteve ao gerar as credenciais específicas do serviço seguindo as etapas para. [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
1. Crie o programa.
```
go build cqlapp.go
```
1. Execute o programa.
```
./cqlapp
```
## Conecte-se ao Amazon Keyspaces usando o driver Go para Apache Cassandra e o plug-in de autenticação SigV4
A seção a seguir descreve como usar o plug-in de autenticação SigV4 do driver Go de código aberto para acessar o Amazon Keyspaces (para Apache Cassandra).
Se ainda não tiver feito isso, crie credenciais para a entidade principal do IAM seguindo as etapas em [Crie e configure AWS credenciais para o Amazon Keyspaces](access.credentials.md). Se um aplicativo estiver sendo executado no Lambda ou em uma instância do Amazon EC2, seu aplicativo estará automaticamente usando as credenciais da instância. Para executar este tutorial localmente, você pode armazenar as credenciais como variáveis de ambiente local.
[Adicione o plug-in de autenticação Go SigV4 ao seu aplicativo a partir do GitHub repositório.](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin) O plug-in é compatível com a versão 1.2.x do driver Go de código aberto para Cassandra e depende do SDK for Go. AWS
```
$ go mod init
$ go get github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin
```
Neste exemplo de código, o endpoint do Amazon Keyspaces é representado pela classe `Cluster`. Ele usa a propriedade `AwsAuthenticator` para o autenticador do cluster para obter credenciais.
```
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)
}
}
```
Observações de uso:
1. `"path_to_file/keyspaces-bundle.pem"`Substitua pelo caminho para o arquivo de certificado salvo na primeira etapa.
1. Para que este exemplo seja executado localmente, você precisa definir as seguintes variáveis como variáveis de ambiente:
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_DEFAULT_REGION`
1. Para armazenar chaves de acesso fora do código, consulte as melhores práticas em [Armazene chaves de acesso para acesso programático](aws.credentials.manage.md).
1. Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
# Como usar um driver de cliente Cassandra Perl para acessar o Amazon Keyspaces programaticamente
Esta seção mostra como se conectar ao Amazon Keyspaces usando um driver de cliente Perl. Para esse exemplo de código, usamos o Perl 5. O Amazon Keyspaces requer o uso do Transport Layer Security (TLS) para ajudar a proteger as conexões com os clientes.
**Importante**
Os certificados Amazon Keyspaces estão migrando para a hierarquia do Amazon Trust Services (ATS). Certifique-se de que seu ambiente confie no Amazon Root CAs 1—4 para evitar erros de conexão durante essa rotação. O driver Perl não valida o certificado Amazon SSL do servidor, o que significa que você não pode confirmar que está se conectando ao Amazon Keyspaces. A segunda etapa, configurar o driver para usar o TLS ao se conectar ao Amazon Keyspaces, ainda é necessária e garante que os dados transferidos entre o cliente e o servidor sejam criptografados.
1. Baixe o driver Cassandra DBI em [https://metacpan.org/pod/DBD::Cassandra](https://metacpan.org/pod/DBD::Cassandra) e instale o driver em seu ambiente Perl. As etapas exatas dependem do ambiente. A seguir, um exemplo comum.
```
cpanm DBD::Cassandra
```
1. Crie um arquivo para o aplicativo.
```
touch cqlapp.pl
```
1. Adicione o código de exemplo a seguir ao arquivo 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;
```
**Importante**
Certifique-se de que *ServiceUserName* e *ServicePassword* corresponda ao nome de usuário e à senha que você obteve ao gerar as credenciais específicas do serviço seguindo as etapas para. [Crie credenciais específicas do serviço para acesso programático ao Amazon Keyspaces](programmatic.credentials.ssc.md)
**nota**
Para obter uma lista de endpoints disponíveis, consulte [Endpoints de serviço para Amazon Keyspaces](programmatic.endpoints.md).
1. Execute a aplicação .
```
perl cqlapp.pl
```
# Configure o acesso entre contas para Amazon Keyspaces e endpoints da VPC
Você pode criar e usar separadamente Contas da AWS para isolar recursos e para uso em ambientes diferentes, por exemplo, desenvolvimento e produção. Este tópico explica o acesso entre contas ao Amazon Keyspaces usando endpoints da VPC de interface em um Amazon Virtual Private Cloud. Para obter mais informações sobre a configuração de acesso entre contas do IAM, consulte [Exemplo de cenário usando contas de desenvolvimento e produção separadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html#id_roles_common-scenarios_aws-accounts-example) no Guia do usuário do IAM.
Para obter mais informações sobre Amazon Keyspaces e endpoints da VPC privados, consulte [Como usar o Amazon Keyspaces com endpoint da VPC de interface](vpc-endpoints.md).
**Topics**
+ [Configure o acesso entre contas em uma VPC compartilhada](access.cross-account.sharedVPC.md)
+ [Configure o acesso entre contas sem uma VPC compartilhada](access.cross-account.noVPC.setup.md)
# Configure o acesso entre contas para o Amazon Keyspaces usando endpoints da VPC em uma VPC compartilhada
Você pode criar recursos diferentes Contas da AWS ou separados dos aplicativos. Por exemplo, você pode criar uma conta para suas tabelas do Amazon Keyspaces, uma conta diferente para aplicativos em um ambiente de desenvolvimento e outra conta para aplicativos em um ambiente de produção. Este tópico mostra as etapas de configuração necessárias para configurar o acesso entre contas para o Amazon Keyspaces usando endpoints de VPC de interface em uma VPC compartilhada.
Para obter etapas detalhadas sobre como configurar um endpoint da VPC para o Amazon Keyspaces, consulte [Etapa 3: criar um endpoint da VPC para o Amazon Keyspaces](vpc-endpoints-tutorial.create-endpoint.md).
Neste exemplo, usamos as três contas a seguir em uma VPC compartilhada:
+ `Account A:111111111111`: essa conta contém infraestrutura, incluindo os endpoints da VPC, as sub-redes da VPC e as tabelas do Amazon Keyspaces.
+ `Account B:222222222222`: essa conta contém um aplicativo em um ambiente de desenvolvimento que precisa se conectar à tabela do Amazon Keyspaces em `Account A:111111111111`.
+ `Account C:333333333333`: essa conta contém um aplicativo em um ambiente de produção que precisa se conectar à tabela do Amazon Keyspaces em `Account A:111111111111`.
![\[Diagrama mostrando três contas diferentes pertencentes à mesma organização, na mesma Região da AWS , que usam uma VPC compartilhada.\]](http://docs.aws.amazon.com/pt_br/keyspaces/latest/devguide/images/keyspaces_cross-account_sharedVPC.png)
`Account A:111111111111`é a conta que contém os recursos (uma tabela do Amazon Keyspaces) que `Account B:222222222222` `Account C:333333333333` você precisa acessar, assim *como `Account A:111111111111` a conta confiável*. `Account B:222222222222`e `Account C:333333333333` são as contas com os diretores que precisam acessar os recursos (uma tabela do Amazon Keyspaces)`Account A:111111111111`, ou `Account B:222222222222` seja, `Account C:333333333333` *as* contas confiáveis. A conta confiável concede as permissões às contas confiáveis compartilhando um perfil do IAM. O procedimento a seguir descreve as etapas de configuração necessárias em `Account A:111111111111`.
**Configuração para a `Account A:111111111111`**
1. Use AWS Resource Access Manager para criar um compartilhamento de recursos para a sub-rede e compartilhar a sub-rede privada com e. `Account B:222222222222` `Account C:333333333333`
`Account B:222222222222` e `Account C:333333333333` agora podem ver e criar recursos na sub-rede que foi compartilhada com eles.
1. Crie um endpoint VPC privado do Amazon Keyspaces desenvolvido por. AWS PrivateLink Isso cria vários endpoints em sub-redes compartilhadas e entradas de DNS para o endpoint do serviço do Amazon Keyspaces.
1. Crie um espaço de chaves e uma tabela do Amazon Keyspaces.
1. Crie uma função do IAM `Account A:111111111111` que tenha acesso total à tabela Amazon Keyspaces, leia as tabelas do sistema Amazon Keyspaces e seja capaz de descrever os recursos da Amazon EC2 VPC conforme mostrado no exemplo de política a seguir.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "CrossAccountAccess",
"Effect": "Allow",
"Action": [
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeVpcEndpoints",
"cassandra:*"
],
"Resource": "*"
}
]
}
```
1. Configure uma política de confiança para a função do IAM `Account A:111111111111` para que ela `Account B:222222222222` `Account C:333333333333` possa assumir a função como contas confiáveis. Isso é mostrado no exemplo a seguir.
```
{
"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": {}
}
]
}
```
Para ver mais informações sobre as políticas do IAM entre contas, consulte [Políticas entre contas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) no Guia do usuário do IAM.
**Configuração em `Account B:222222222222` e `Account C:333333333333`**
1. Em `Account B:222222222222` e `Account C:333333333333`, crie novos perfis e anexe a seguinte política que permite que a entidade principal assuma o perfil compartilhado criado em `Account A:111111111111`.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
Permitir que o diretor assuma a função compartilhada é implementado usando a `AssumeRole` API do AWS Security Token Service (AWS STS). Para obter mais informações, consulte [Fornecer acesso a um usuário do IAM em outro Conta da AWS de sua propriedade](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) no Guia do usuário do IAM.
1. Em `Account B:222222222222` e`Account C:333333333333`, você pode criar aplicativos que utilizam o plug-in de SIGV4 autenticação, que permite que um aplicativo assuma a função compartilhada para se conectar à tabela do Amazon Keyspaces localizada `Account A:111111111111` por meio do endpoint da VPC na VPC compartilhada. Para obter mais informações sobre o plug-in de SIGV4 autenticação, consulte[Crie credenciais para acesso programático ao Amazon Keyspaces](programmatic.credentials.md). Para obter mais informações sobre como configurar um aplicativo para assumir uma função em outra AWS conta, consulte [Autenticação e acesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) no *AWS SDKs Guia de referência de ferramentas*.
# Como configurar o acesso entre contas para o Amazon Keyspaces sem uma VPC compartilhada
Se a tabela do Amazon Keyspaces e o endpoint privado da VPC pertencerem a contas diferentes, mas não estiverem compartilhando uma VPC, os aplicativos ainda poderão se conectar entre contas usando endpoints da VPC. Como as contas não estão compartilhando os endpoints da VPC, `Account A:111111111111`, `Account B:222222222222` e `Account C:333333333333` exigem seus próprios endpoints da VPC. Para o driver do cliente Cassandra, o Amazon Keyspaces aparece como um único nó em vez de um cluster de vários nós. Após a conexão, o driver do cliente chega ao servidor DNS, que retorna um dos endpoints disponíveis na VPC da conta.
Você também pode acessar tabelas do Amazon Keyspaces em contas diferentes sem um VPC endpoint compartilhado usando os endpoints públicos ou implantando um endpoint VPC privado em cada conta. Quando não está usando uma VPC compartilhada, cada conta exige seu próprio endpoint da VPC. Neste exemplo, `Account A:111111111111`, `Account B:222222222222` e `Account C:333333333333` exigem seus próprios endpoints da VPC para acessar a tabela em `Account A:111111111111`. Ao usar endpoints da VPC nessa configuração, o Amazon Keyspaces aparece como um cluster de nó único para o driver do cliente Cassandra em vez de um cluster de vários nós. Após a conexão, o driver do cliente chega ao servidor DNS, que retorna um dos endpoints disponíveis na VPC da conta. Mas o driver do cliente não consegue acessar a tabela `system.peers` para descobrir endpoints adicionais. Como há menos hosts disponíveis, o driver faz menos conexões. Para ajustar isso, aumente a configuração do pool de conexões do driver em um fator de três.
![\[Diagrama mostrando três contas diferentes pertencentes à mesma organização, na mesma Região da AWS sem uma VPC compartilhada.\]](http://docs.aws.amazon.com/pt_br/keyspaces/latest/devguide/images/keyspaces_cross-account_noVPC.png)
`Account A:111111111111`é a conta que contém os recursos (uma tabela do Amazon Keyspaces) que `Account B:222222222222` `Account C:333333333333` você precisa acessar, assim *como `Account A:111111111111` a conta confiável*. `Account B:222222222222`e `Account C:333333333333` são as contas com os diretores que precisam acessar os recursos (uma tabela do Amazon Keyspaces)`Account A:111111111111`, ou `Account B:222222222222` seja, `Account C:333333333333` *as* contas confiáveis. A conta confiável concede as permissões às contas confiáveis compartilhando um perfil do IAM. O procedimento a seguir descreve as etapas de configuração necessárias em `Account A:111111111111`.
**Configuração para a `Account A:111111111111`**
1. Crie um keyspace do Amazon Keyspaces e insira uma tabela. `Account A:111111111111`
1. Crie uma função do IAM `Account A:111111111111` que tenha acesso total à tabela Amazon Keyspaces e acesso de leitura às tabelas do sistema 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. Configure uma política de confiança para a função do IAM em `Account A:111111111111` para que os diretores `Account C:333333333333` possam assumir a função como contas confiáveis. `Account B:222222222222` Isso é mostrado no exemplo a seguir.
```
{
"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": {}
}
]
}
```
Para ver mais informações sobre as políticas do IAM entre contas, consulte [Políticas entre contas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) no Guia do usuário do IAM.
1. Configure o VPC endpoint `Account A:111111111111` e anexe permissões ao endpoint que permitem que as funções de `Account B:222222222222` e assumam `Account C:333333333333` a função no uso `Account A` do VPC endpoint. Essas permissões são válidas para o VPC endpoint ao qual elas estão conectadas. Para obter mais informações sobre as políticas de endpoint da VPC, consulte [Como controlar o acesso aos endpoints da VPC de interface para o Amazon Keyspaces](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"
]
}
}
}
]
}
```
**Configuração em `Account B:222222222222` e `Account C:333333333333`**
1. Em `Account B:222222222222` e `Account C:333333333333`, crie novos perfis e anexe a seguinte política que permite que a entidade principal assuma o perfil compartilhado criado em `Account A:111111111111`.
```
{
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111111111111:role/keyspaces_access"
}
}
```
Permitir que o diretor assuma a função compartilhada é implementado usando a `AssumeRole` API do AWS Security Token Service (AWS STS). Para obter mais informações, consulte [Fornecer acesso a um usuário do IAM em outro Conta da AWS de sua propriedade](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) no Guia do usuário do IAM.
1. Em `Account B:222222222222` e`Account C:333333333333`, você pode criar aplicativos que utilizam o plug-in de SIGV4 autenticação, que permite que um aplicativo assuma a função compartilhada para se conectar à tabela Amazon Keyspaces localizada em. `Account A:111111111111` Para obter mais informações sobre o plug-in de SIGV4 autenticação, consulte[Crie credenciais para acesso programático ao Amazon Keyspaces](programmatic.credentials.md). Para obter mais informações sobre como configurar um aplicativo para assumir uma função em outra AWS conta, consulte [Autenticação e acesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) no *AWS SDKs Guia de referência de ferramentas*.