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