Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di un driver client Cassandra per accedere ad Amazon Keyspaces a livello di codice
Puoi utilizzare molti driver Cassandra open source di terze parti per connetterti ad Amazon Keyspaces. Amazon Keyspaces è compatibile con i driver Cassandra che supportano la versione 3.11.2 di Apache Cassandra. Questi sono i driver e le versioni più recenti che abbiamo testato e che consigliamo di utilizzare con 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`
Per ulteriori informazioni sui driver Cassandra, consulta Driver del client [Apache Cassandra](http://cassandra.apache.org/doc/latest/getting_started/drivers.html).
**Nota**
Per aiutarti a iniziare, puoi visualizzare e scaricare esempi di end-to-end codice che stabiliscono connessioni ad Amazon Keyspaces con i driver più diffusi. Guarda gli [esempi di Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-examples) su. GitHub
I tutorial in questo capitolo includono una semplice query CQL per confermare che la connessione ad Amazon Keyspaces è stata stabilita correttamente. Per informazioni su come utilizzare keyspace e tabelle dopo la connessione a un endpoint Amazon Keyspaces, consulta. [Riferimento al linguaggio CQL per Amazon Keyspaces (per Apache Cassandra)](cql.md) Per un step-by-step tutorial che mostra come connettersi ad Amazon Keyspaces da un endpoint Amazon VPC, consulta. [Tutorial: Connettiti ad Amazon Keyspaces utilizzando un endpoint VPC di interfaccia](vpc-endpoints-tutorial.md)
**Topics**
+ [
# Utilizzo di un driver client Java Cassandra per accedere ad Amazon Keyspaces a livello di programmazione
](using_java_driver.md)
+ [
# Utilizzo di un driver client Cassandra Python per accedere ad Amazon Keyspaces a livello di codice
](using_python_driver.md)
+ [
# Utilizzo di un driver client Cassandra Node.js per accedere ad Amazon Keyspaces a livello di codice
](using_nodejs_driver.md)
+ [
# Utilizzo di un driver client Cassandra.NET Core per accedere ad Amazon Keyspaces a livello di codice
](using_dotnetcore_driver.md)
+ [
# Utilizzo di un driver client Cassandra Go per accedere ad Amazon Keyspaces a livello di codice
](using_go_driver.md)
+ [
# Utilizzo di un driver client Cassandra Perl per accedere ad Amazon Keyspaces a livello di codice
](using_perl_driver.md)
# Utilizzo di un driver client Java Cassandra per accedere ad Amazon Keyspaces a livello di programmazione
Questa sezione mostra come connettersi ad Amazon Keyspaces utilizzando un driver client Java.
**Nota**
Java 17 e DataStax Java Driver 4.17 sono attualmente supportati solo in versione beta. Per ulteriori informazioni, consulta [https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/](https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/).
Per fornire agli utenti e alle applicazioni le credenziali per l'accesso programmatico alle risorse di Amazon Keyspaces, puoi effettuare una delle seguenti operazioni:
+ Crea credenziali specifiche del servizio associate a un utente specifico (IAM). AWS Identity and Access Management
+ Per una maggiore sicurezza, consigliamo di creare chiavi di accesso IAM per le identità IAM utilizzate in tutti i servizi. AWS Il plug-in di autenticazione Amazon Keyspaces SigV4 per i driver client Cassandra consente di autenticare le chiamate ad Amazon Keyspaces utilizzando chiavi di accesso IAM anziché nome utente e password. Per ulteriori informazioni, consulta [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md).
**Nota**
Per un esempio di come usare Amazon Keyspaces con Spring Boot, vedi. [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**
+ [
## Prima di iniziare
](#using_java_driver.BeforeYouBegin)
+ [
## Step-by-step tutorial per connettersi ad Amazon Keyspaces utilizzando il driver DataStax Java per Apache Cassandra utilizzando credenziali specifiche del servizio
](#java_tutorial)
+ [
## Step-by-step tutorial per connettersi ad Amazon Keyspaces utilizzando il driver DataStax Java 4.x per Apache Cassandra e il plug-in di autenticazione SigV4
](#java_tutorial.SigV4)
+ [
## Connect ad Amazon Keyspaces utilizzando il driver DataStax Java 3.x per Apache Cassandra e il plug-in di autenticazione SigV4
](#java3x_tutorial.SigV4)
## Prima di iniziare
Per connetterti ad Amazon Keyspaces, devi completare le seguenti attività prima di iniziare.
1. Amazon Keyspaces richiede l'uso di Transport Layer Security (TLS) per proteggere le connessioni con i client.
1. Scarica i seguenti certificati digitali e salva i file localmente o nella tua home directory.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opzionale, per compatibilità con le versioni precedenti)
Per scaricare i certificati, puoi usare i seguenti comandi.
```
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**
Amazon Keyspaces utilizzava in precedenza certificati TLS ancorati alla CA Starfield Class 2. AWS sta migrando tutto Regioni AWS verso certificati emessi nell'ambito di Amazon Trust Services (Amazon Root CAs 1—4). Durante questa transizione, configura i client in modo che si fidino sia di Amazon Root CAs 1-4 che di Starfield root per garantire la compatibilità in tutte le regioni.
1. Converti i certificati digitali in file TrustStore e aggiungili al 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
```
Nell'ultimo passaggio, è necessario creare una password per il keystore e considerare attendibile ogni certificato. Il comando interattivo ha questo aspetto.
```
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. Allega il file TrustStore negli argomenti JVM:
```
-Djavax.net.ssl.trustStore=path_to_file/cassandra_truststore.jks
-Djavax.net.ssl.trustStorePassword=my_password
```
## Step-by-step tutorial per connettersi ad Amazon Keyspaces utilizzando il driver DataStax Java per Apache Cassandra utilizzando credenziali specifiche del servizio
Il seguente step-by-step tutorial illustra come connettersi ad Amazon Keyspaces utilizzando un driver Java per Cassandra utilizzando credenziali specifiche del servizio. In particolare, utilizzerai la versione 4.0 del driver DataStax Java per Apache Cassandra.
**Topics**
+ [
### Fase 1: prerequisiti
](#java_tutorial.prereq)
+ [
### Fase 2: Configurare il driver
](#java_tutorial.driverconfiguration)
+ [
### Fase 3: Esegui l'applicazione di esempio
](#java_tutorial.application)
### Fase 1: prerequisiti
Per seguire questo tutorial, è necessario generare credenziali specifiche del servizio e aggiungere il driver DataStax Java per Apache Cassandra al progetto Java.
+ Genera credenziali specifiche del servizio per il tuo utente IAM di Amazon Keyspaces completando i passaggi indicati in. [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md) Se preferisci utilizzare le chiavi di accesso IAM per l'autenticazione, consulta. [Step-by-step tutorial per connettersi ad Amazon Keyspaces utilizzando il driver DataStax Java 4.x per Apache Cassandra e il plug-in di autenticazione SigV4](#java_tutorial.SigV4)
+ Aggiungi il driver DataStax Java per Apache Cassandra al tuo progetto Java. Assicurati di utilizzare una versione del driver che supporti Apache Cassandra 3.11.2. Per ulteriori informazioni, consulta la documentazione del [driver DataStax Java per](https://github.com/datastax/java-driver) Apache Cassandra.
### Fase 2: Configurare il driver
È possibile specificare le impostazioni per il driver DataStax Java Cassandra creando un file di configurazione per l'applicazione. Questo file di configurazione sostituisce le impostazioni predefinite e indica al driver di connettersi all'endpoint del servizio Amazon Keyspaces utilizzando la porta 9142. Per un elenco degli endpoint di servizio disponibili, consulta. [Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md)
Create un file di configurazione e salvatelo nella cartella delle risorse dell'applicazione, ad esempio. `src/main/resources/application.conf` Apri `application.conf` e aggiungi le seguenti impostazioni di configurazione.
1. **Provider di autenticazione**: crea il provider di autenticazione con la `PlainTextAuthProvider` classe. *ServiceUserName*e *ServicePassword* deve corrispondere al nome utente e alla password ottenuti quando sono state generate le credenziali specifiche del servizio seguendo la procedura riportata di seguito. [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md)
**Nota**
È possibile utilizzare credenziali a breve termine utilizzando il plug-in di autenticazione per il driver DataStax Java per Apache Cassandra anziché codificare le credenziali nel file di configurazione del driver. Per ulteriori informazioni, segui le istruzioni per. [Step-by-step tutorial per connettersi ad Amazon Keyspaces utilizzando il driver DataStax Java 4.x per Apache Cassandra e il plug-in di autenticazione SigV4](#java_tutorial.SigV4)
1. **Data center locale**: imposta il valore per la regione `local-datacenter` a cui ti stai connettendo. Ad esempio, se l'applicazione si connette a`cassandra.us-east-2.amazonaws.com`, imposta il data center locale su`us-east-2`. Per tutte le opzioni disponibili Regioni AWS, vedi[Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md). Impostato `slow-replica-avoidance = false` per bilanciare il carico su un minor numero di nodi.
1. **SSL/TLS**: inizializza SSLEngine Factory aggiungendo una sezione nel file di configurazione con una singola riga che specifica la classe con. `class = DefaultSslEngineFactory` Fornisci il percorso del file TrustStore e la password che hai creato in precedenza. Amazon Keyspaces non supporta `hostname-validation` i peer, quindi imposta questa opzione su 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**
Invece di aggiungere il percorso al TrustStore nel file di configurazione, puoi anche aggiungere il percorso TrustStore direttamente nel codice dell'applicazione oppure puoi aggiungere il percorso al TrustStore agli argomenti JVM.
### Fase 3: Esegui l'applicazione di esempio
Questo esempio di codice mostra una semplice applicazione a riga di comando che crea un pool di connessioni ad Amazon Keyspaces utilizzando il file di configurazione creato in precedenza. Conferma che la connessione è stata stabilita eseguendo una semplice query.
```
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**
Usa un `try` blocco per stabilire la connessione per assicurarti che sia sempre chiusa. Se non usi un `try` blocco, ricordati di chiudere la connessione per evitare perdite di risorse.
## Step-by-step tutorial per connettersi ad Amazon Keyspaces utilizzando il driver DataStax Java 4.x per Apache Cassandra e il plug-in di autenticazione SigV4
La sezione seguente descrive come utilizzare il plug-in di autenticazione SigV4 per il driver DataStax Java 4.x open source per Apache Cassandra per accedere ad Amazon Keyspaces (per Apache Cassandra). [Il plugin è disponibile nel repository. GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin)
Il plug-in di autenticazione SigV4 consente di utilizzare le credenziali IAM per utenti o ruoli durante la connessione ad Amazon Keyspaces. Invece di richiedere un nome utente e una password, questo plugin firma le richieste API utilizzando le chiavi di accesso. Per ulteriori informazioni, consulta [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md).
### Fase 1: prerequisiti
Per seguire questo tutorial, devi completare le seguenti attività.
+ Se non l'hai già fatto, crea le credenziali per il tuo utente o ruolo IAM seguendo la procedura riportata qui. [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md) Questo tutorial presuppone che le chiavi di accesso siano memorizzate come variabili di ambiente. Per ulteriori informazioni, consulta [Memorizza le chiavi di accesso per l'accesso programmatico](aws.credentials.manage.md).
+ Aggiungi il driver DataStax Java per Apache Cassandra al tuo progetto Java. Assicurati di utilizzare una versione del driver che supporti Apache Cassandra 3.11.2. Per ulteriori informazioni, consulta la documentazione del [driver DataStax Java per](https://github.com/datastax/java-driver) Apache Cassandra.
+ Aggiungi il plugin di autenticazione alla tua applicazione. Il plugin di autenticazione supporta la versione 4.x del driver DataStax Java per Apache Cassandra. Se utilizzi Apache Maven o un sistema di compilazione in grado di utilizzare le dipendenze Maven, aggiungi le seguenti dipendenze al tuo file. `pom.xml`
**Importante**
[Sostituisci la versione del plugin con l'ultima versione mostrata nel repository. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin#add-the-authentication-plugin-to-the-application)
```
software.aws.mcs
aws-sigv4-auth-cassandra-java-driver-plugin
4.0.9
```
### Fase 2: Configurare il driver
È possibile specificare le impostazioni per il driver DataStax Java Cassandra creando un file di configurazione per l'applicazione. Questo file di configurazione sostituisce le impostazioni predefinite e indica al driver di connettersi all'endpoint del servizio Amazon Keyspaces utilizzando la porta 9142. Per un elenco degli endpoint di servizio disponibili, consulta. [Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md)
Create un file di configurazione e salvatelo nella cartella delle risorse dell'applicazione, ad esempio. `src/main/resources/application.conf` Apri `application.conf` e aggiungi le seguenti impostazioni di configurazione.
1. **Provider di autenticazione**: imposta una nuova istanza di`software.aws.mcs.auth.SigV4AuthProvider`. `advanced.auth-provider.class` SigV4 AuthProvider è il gestore di autenticazione fornito dal plugin per eseguire l'autenticazione SigV4.
1. **Data center locale**: imposta il valore per la regione `local-datacenter` a cui ti stai connettendo. Ad esempio, se l'applicazione si connette a`cassandra.us-east-2.amazonaws.com`, imposta il data center locale su`us-east-2`. Per tutte le opzioni disponibili Regioni AWS, vedi[Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md). Impostato `slow-replica-avoidance = false` per bilanciare il carico rispetto a tutti i nodi disponibili.
1. **Idempotenza**: imposta l'impostazione predefinita `idempotence` per l'applicazione in modo da configurare il driver in modo `true` che riprovi sempre le richieste non riuscite. read/write/prepare/execute Si tratta di una procedura ottimale per le applicazioni distribuite che consente di gestire gli errori temporanei riprovando le richieste non riuscite.
1. **SSL/TLS**: inizializza la SSLEngine fabbrica aggiungendo una sezione nel file di configurazione con una sola riga che specifica la classe con. `class = DefaultSslEngineFactory` Fornisci il percorso del file TrustStore e la password che hai creato in precedenza. Amazon Keyspaces non supporta `hostname-validation` i peer, quindi imposta questa opzione su false.
1. **Connessioni**: crea almeno 3 connessioni locali per endpoint impostando. `local.size = 3` Si tratta di una best practice che aiuta l'applicazione a gestire i sovraccarichi e i picchi di traffico. Per ulteriori informazioni su come calcolare il numero di connessioni locali per endpoint necessarie all'applicazione in base ai modelli di traffico previsti, consulta. [Come configurare le connessioni in Amazon Keyspaces](connections.md#connections.howtoconfigure)
1. **Politica di riprova**: implementa la `AmazonKeyspacesExponentialRetryPolicy` politica di riprova di Amazon Keyspaces anziché quella fornita con `DefaultRetryPolicy` il driver Cassandra. Ciò ti consente di configurare il numero di tentativi di riprova per quello che soddisfa le `AmazonKeyspacesExponentialRetryPolicy` tue esigenze. Per impostazione predefinita, il numero di tentativi di nuovo tentativo `AmazonKeyspacesExponentialRetryPolicy` è impostato su 3. Per ulteriori informazioni, consulta [Come configurare la politica di riprova per le connessioni in Amazon Keyspaces](connections.md#connections.retry-policies).
1. **Dichiarazioni preparate**: imposta su false `prepare-on-all-nodes` per ottimizzare l'utilizzo della rete.
```
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**
Invece di aggiungere il percorso al TrustStore nel file di configurazione, puoi anche aggiungere il percorso TrustStore direttamente nel codice dell'applicazione oppure puoi aggiungere il percorso al TrustStore agli argomenti JVM.
### Passaggio 3: Esegui l'applicazione
Questo esempio di codice mostra una semplice applicazione a riga di comando che crea un pool di connessioni ad Amazon Keyspaces utilizzando il file di configurazione creato in precedenza. Conferma che la connessione è stata stabilita eseguendo una semplice query.
```
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**
Usa un `try` blocco per stabilire la connessione per assicurarti che sia sempre chiusa. Se non usi un `try` blocco, ricordati di chiudere la connessione per evitare perdite di risorse.
## Connect ad Amazon Keyspaces utilizzando il driver DataStax Java 3.x per Apache Cassandra e il plug-in di autenticazione SigV4
La sezione seguente descrive come utilizzare il plug-in di autenticazione SigV4 per il driver DataStax Java open source 3.x per Apache Cassandra per accedere ad Amazon Keyspaces. [Il plugin è disponibile nel repository. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible)
Il plug-in di autenticazione SigV4 consente di utilizzare le credenziali IAM per utenti e ruoli durante la connessione ad Amazon Keyspaces. Invece di richiedere un nome utente e una password, questo plugin firma le richieste API utilizzando le chiavi di accesso. Per ulteriori informazioni, consulta [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md).
### Fase 1: prerequisiti
Per eseguire questo esempio di codice, è necessario innanzitutto completare le seguenti attività.
+ Crea le credenziali per il tuo utente o ruolo IAM seguendo la procedura descritta in[Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md). Questo tutorial presuppone che le chiavi di accesso siano memorizzate come variabili di ambiente. Per ulteriori informazioni, consulta [Memorizza le chiavi di accesso per l'accesso programmatico](aws.credentials.manage.md).
+ Segui i passaggi indicati [Prima di iniziare](#using_java_driver.BeforeYouBegin) per scaricare i certificati digitali, convertirli in file TrustStore e allegare il keystore negli argomenti JVM all'applicazione.
+ Aggiungi il driver DataStax Java per Apache Cassandra al tuo progetto Java. Assicurati di utilizzare una versione del driver che supporti Apache Cassandra 3.11.2. Per ulteriori informazioni, consulta la documentazione del [driver DataStax Java per](https://github.com/datastax/java-driver) Apache Cassandra.
+ Aggiungi il plugin di autenticazione alla tua applicazione. Il plugin di autenticazione supporta la versione 3.x del driver DataStax Java per Apache Cassandra. Se utilizzi Apache Maven o un sistema di compilazione in grado di utilizzare le dipendenze Maven, aggiungi le seguenti dipendenze al tuo file. `pom.xml` [Sostituisci la versione del plugin con l'ultima versione mostrata nel repository. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible)
```
software.aws.mcs
aws-sigv4-auth-cassandra-java-driver-plugin_3
3.0.3
```
### Fase 2: Esegui l'applicazione
Questo esempio di codice mostra una semplice applicazione a riga di comando che crea un pool di connessioni ad Amazon Keyspaces. Conferma che la connessione è stata stabilita eseguendo una semplice query.
```
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"));
}
}
```
Note d'uso:
Per un elenco degli endpoint disponibili, vedere[Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md).
Consulta il seguente repository per utili politiche, esempi e best practice dei driver Java per l'utilizzo del driver Java con Amazon [https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers) Keyspaces:.
# Utilizzo di un driver client Cassandra Python per accedere ad Amazon Keyspaces a livello di codice
In questa sezione, ti mostriamo come connetterti ad Amazon Keyspaces usando un driver client Python. Per fornire agli utenti e alle applicazioni le credenziali per l'accesso programmatico alle risorse di Amazon Keyspaces, puoi effettuare una delle seguenti operazioni:
+ Crea credenziali specifiche del servizio associate a un utente specifico (IAM). AWS Identity and Access Management
+ Per una maggiore sicurezza, consigliamo di creare chiavi di accesso IAM per utenti o ruoli IAM utilizzati in tutti i servizi. AWS Il plug-in di autenticazione Amazon Keyspaces SigV4 per i driver client Cassandra consente di autenticare le chiamate ad Amazon Keyspaces utilizzando chiavi di accesso IAM anziché nome utente e password. Per ulteriori informazioni, consulta [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Prima di iniziare
](#using_python_driver.BeforeYouBegin)
+ [
## Connect ad Amazon Keyspaces utilizzando il driver Python per Apache Cassandra e le credenziali specifiche del servizio
](#python_ssc)
+ [
## Connect ad Amazon Keyspaces utilizzando il driver DataStax Python per Apache Cassandra e il plug-in di autenticazione SigV4
](#python_SigV4)
## Prima di iniziare
È necessario completare la seguente attività prima di iniziare.
Amazon Keyspaces richiede l'uso di Transport Layer Security (TLS) per proteggere le connessioni con i client. Per connetterti ad Amazon Keyspaces tramite TLS, devi scaricare i certificati digitali Amazon e configurare il driver Python per utilizzare TLS.
Scarica i seguenti certificati digitali e salva i file localmente o nella tua home directory.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opzionale, per compatibilità con le versioni precedenti)
Per scaricare i certificati, puoi usare i seguenti comandi.
```
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**
Amazon Keyspaces utilizzava in precedenza certificati TLS ancorati alla CA Starfield Class 2. AWS sta migrando tutto Regioni AWS verso certificati emessi nell'ambito di Amazon Trust Services (Amazon Root CAs 1—4). Durante questa transizione, configura i client in modo che si fidino sia di Amazon Root CAs 1-4 che di Starfield root per garantire la compatibilità in tutte le regioni.
Combina tutti i certificati scaricati in un unico `pem` file con il nome indicato *keyspaces-bundle.pem* nei nostri esempi. Per aggiungerlo, eseguire il comando seguente: Prendi nota del percorso del file, ne avrai bisogno in seguito.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Connect ad Amazon Keyspaces utilizzando il driver Python per Apache Cassandra e le credenziali specifiche del servizio
Il seguente esempio di codice mostra come connettersi ad Amazon Keyspaces con un driver client Python e credenziali specifiche del servizio.
```
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)
```
Note sull'utilizzo:
1. Sostituisci `"path_to_file/keyspaces-bundle.pem"` con il percorso del file di certificato combinato salvato nel primo passaggio.
1. Assicurati che *ServiceUserName* e *ServicePassword* corrispondano al nome utente e alla password che hai ottenuto quando hai generato le credenziali specifiche del servizio seguendo i passaggi per. [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Per un elenco degli endpoint disponibili, consulta. [Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md)
## Connect ad Amazon Keyspaces utilizzando il driver DataStax Python per Apache Cassandra e il plug-in di autenticazione SigV4
La sezione seguente mostra come utilizzare il plug-in di autenticazione SigV4 per il driver DataStax Python open source per Apache Cassandra per accedere ad Amazon Keyspaces (per Apache Cassandra).
Se non l'hai già fatto, inizia a creare le credenziali per il tuo ruolo IAM seguendo i passaggi riportati di seguito. [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md) Questo tutorial utilizza credenziali temporanee, che richiedono un ruolo IAM. Per ulteriori informazioni sulle credenziali temporanee, consulta. [Crea credenziali temporanee per connetterti ad Amazon Keyspaces utilizzando un ruolo IAM e il plug-in SigV4](temporary.credentials.IAM.md)
[Quindi, aggiungi il plug-in di autenticazione Python SigV4 al tuo ambiente dal repository. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin)
```
pip install cassandra-sigv4
```
Il seguente esempio di codice mostra come connettersi ad Amazon Keyspaces utilizzando il driver DataStax Python open source per Cassandra e il plug-in di autenticazione SigV4. Il plugin dipende dall' AWS SDK per Python (Boto3). Viene utilizzato per `boto3.session` ottenere credenziali temporanee.
```
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)
```
Note d'uso:
1. Sostituisci `"path_to_file/keyspaces-bundle.pem"` con il percorso del certificato salvato nel primo passaggio.
1. Assicurati che il *aws\$1access\$1key\$1id**aws\$1secret\$1access\$1key*, e il *aws\$1session\$1token* corrispondano a `Access Key``Secret Access Key`, e `Session Token` che hai ottenuto utilizzando`boto3.session`. Per ulteriori informazioni, consulta [Credentials](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) nella *AWS SDK per Python (Boto3)*.
1. Per un elenco degli endpoint disponibili, consulta[Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md).
# Utilizzo di un driver client Cassandra Node.js per accedere ad Amazon Keyspaces a livello di codice
Questa sezione mostra come connettersi ad Amazon Keyspaces utilizzando un driver client Node.js. Per fornire agli utenti e alle applicazioni le credenziali per l'accesso programmatico alle risorse di Amazon Keyspaces, puoi effettuare una delle seguenti operazioni:
+ Crea credenziali specifiche del servizio associate a un utente specifico (IAM). AWS Identity and Access Management
+ Per una maggiore sicurezza, consigliamo di creare chiavi di accesso IAM per utenti o ruoli IAM utilizzati in tutti i servizi. AWS Il plug-in di autenticazione Amazon Keyspaces SigV4 per i driver client Cassandra consente di autenticare le chiamate ad Amazon Keyspaces utilizzando chiavi di accesso IAM anziché nome utente e password. Per ulteriori informazioni, consulta [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Prima di iniziare
](#using_nodejs_driver.BeforeYouBegin)
+ [
## Connect ad Amazon Keyspaces utilizzando il DataStax driver Node.js per Apache Cassandra e le credenziali specifiche del servizio
](#nodejs_ssc)
+ [
## Connect ad Amazon Keyspaces utilizzando il driver DataStax Node.js per Apache Cassandra e il plug-in di autenticazione SigV4
](#nodejs_SigV4)
## Prima di iniziare
È necessario completare la seguente attività prima di iniziare.
Amazon Keyspaces richiede l'uso di Transport Layer Security (TLS) per proteggere le connessioni con i client. Per connetterti ad Amazon Keyspaces tramite TLS, devi scaricare un certificato digitale Amazon e configurare il driver Python per utilizzare TLS.
Scarica i seguenti certificati digitali e salva i file localmente o nella tua home directory.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opzionale, per compatibilità con le versioni precedenti)
Per scaricare i certificati, puoi usare i seguenti comandi.
```
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**
Amazon Keyspaces utilizzava in precedenza certificati TLS ancorati alla CA Starfield Class 2. AWS sta migrando tutto Regioni AWS verso certificati emessi nell'ambito di Amazon Trust Services (Amazon Root CAs 1—4). Durante questa transizione, configura i client in modo che si fidino sia di Amazon Root CAs 1-4 che di Starfield root per garantire la compatibilità in tutte le regioni.
Combina tutti i certificati scaricati in un unico `pem` file con il nome indicato *keyspaces-bundle.pem* nei nostri esempi. Per aggiungerlo, eseguire il comando seguente: Prendi nota del percorso del file, ne avrai bisogno in seguito.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Connect ad Amazon Keyspaces utilizzando il DataStax driver Node.js per Apache Cassandra e le credenziali specifiche del servizio
Configura il driver per utilizzare il file di certificato combinato `keyspaces-bundle.pem` per TLS e autenticarsi utilizzando credenziali specifiche del servizio. Esempio:
```
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}`));
```
Note sull'utilizzo:
1. Sostituisci `"path_to_file/keyspaces-bundle.pem"` con il percorso del file di certificato combinato salvato nel primo passaggio.
1. Assicurati che *ServiceUserName* e *ServicePassword* corrispondano al nome utente e alla password che hai ottenuto quando hai generato le credenziali specifiche del servizio seguendo i passaggi per. [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Per un elenco degli endpoint disponibili, consulta. [Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md)
## Connect ad Amazon Keyspaces utilizzando il driver DataStax Node.js per Apache Cassandra e il plug-in di autenticazione SigV4
La sezione seguente mostra come utilizzare il plug-in di autenticazione SigV4 per il driver open source DataStax Node.js per Apache Cassandra per accedere ad Amazon Keyspaces (per Apache Cassandra).
Se non l'hai già fatto, crea le credenziali per il tuo utente o ruolo IAM seguendo la procedura descritta qui. [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md)
[Aggiungi il plug-in di autenticazione SigV4 Node.js all'applicazione dal repository. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin) Il plugin supporta la versione 4.x del driver DataStax Node.js per Cassandra e dipende dall'SDK per Node.js. AWS Viene utilizzato per `AWSCredentialsProvider` ottenere le credenziali.
```
$ npm install aws-sigv4-auth-cassandra-plugin --save
```
Questo esempio di codice mostra come impostare un'istanza specifica della regione `SigV4AuthProvider` come provider di autenticazione.
```
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}`));
```
Note sull'utilizzo:
1. Sostituisci `"path_to_file/keyspaces-bundle.pem"` con il percorso del certificato salvato nel primo passaggio.
1. Assicurati che *accessKeyId* e *secretAccessKey* corrispondano alla chiave di accesso e alla chiave di accesso segreta che hai ottenuto utilizzando`AWSCredentialsProvider`. Per ulteriori informazioni, consulta [Impostazione delle credenziali in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html) nell'*AWS SDK per JavaScript in Node.js*.
1. Per archiviare le chiavi di accesso al di fuori del codice, consulta le best practice all'indirizzo. [Memorizza le chiavi di accesso per l'accesso programmatico](aws.credentials.manage.md)
1. Per un elenco degli endpoint disponibili, consulta[Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md).
# Utilizzo di un driver client Cassandra.NET Core per accedere ad Amazon Keyspaces a livello di codice
Questa sezione mostra come connettersi ad Amazon Keyspaces utilizzando un driver client.NET Core. I passaggi di configurazione variano a seconda dell'ambiente e del sistema operativo, potrebbe essere necessario modificarli di conseguenza. Amazon Keyspaces richiede l'uso di Transport Layer Security (TLS) per proteggere le connessioni con i client. Per connetterti ad Amazon Keyspaces tramite TLS, configura il driver per utilizzare il trust store di sistema, che include Amazon Root 1-4. CAs
1. Installa il CSharp driver Cassandra tramite nuget, utilizzando la console nuget.
```
PM> Install-Package CassandraCSharpDriver
```
1. L'esempio seguente utilizza un progetto console.NET Core C\$1 per connettersi ad Amazon Keyspaces ed eseguire una query.
```
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);
}
}
}
}
```
Note sull'utilizzo:
1. Assicurati di utilizzare l'archivio di fiducia di sistema predefinito, che include Amazon Root CAs 1-4.
1. Assicurati che *ServiceUserName* e *ServicePassword* corrispondano al nome utente e alla password che hai ottenuto quando hai generato le credenziali specifiche del servizio seguendo i passaggi per. [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Per un elenco degli endpoint disponibili, consulta. [Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md)
# Utilizzo di un driver client Cassandra Go per accedere ad Amazon Keyspaces a livello di codice
Questa sezione mostra come connettersi ad Amazon Keyspaces utilizzando un driver client Go Cassandra. Per fornire agli utenti e alle applicazioni le credenziali per l'accesso programmatico alle risorse di Amazon Keyspaces, puoi effettuare una delle seguenti operazioni:
+ Crea credenziali specifiche del servizio associate a un utente specifico (IAM). AWS Identity and Access Management
+ Per una maggiore sicurezza, consigliamo di creare chiavi di accesso IAM per i principali IAM che vengono utilizzate in tutti i servizi. AWS Il plug-in di autenticazione Amazon Keyspaces SigV4 per i driver client Cassandra consente di autenticare le chiamate ad Amazon Keyspaces utilizzando chiavi di accesso IAM anziché nome utente e password. Per ulteriori informazioni, consulta [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md).
**Topics**
+ [
## Prima di iniziare
](#using_go_driver.BeforeYouBegin)
+ [
## Connect ad Amazon Keyspaces utilizzando il driver Gocql per Apache Cassandra e le credenziali specifiche del servizio
](#go_ssc)
+ [
## Connect ad Amazon Keyspaces utilizzando il driver Go per Apache Cassandra e il plug-in di autenticazione SigV4
](#go_SigV4)
## Prima di iniziare
È necessario completare la seguente attività prima di iniziare.
Amazon Keyspaces richiede l'uso di Transport Layer Security (TLS) per proteggere le connessioni con i client. Per connetterti ad Amazon Keyspaces tramite TLS, devi scaricare un certificato digitale Amazon e configurare il driver Go per utilizzare TLS.
Scarica i seguenti certificati digitali e salva i file localmente o nella tua home directory.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (opzionale, per compatibilità con le versioni precedenti)
Per scaricare i certificati, puoi usare i seguenti comandi.
```
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**
Amazon Keyspaces utilizzava in precedenza certificati TLS ancorati alla CA Starfield Class 2. AWS sta migrando tutto Regioni AWS verso certificati emessi nell'ambito di Amazon Trust Services (Amazon Root CAs 1—4). Durante questa transizione, configura i client in modo che si fidino sia di Amazon Root CAs 1-4 che di Starfield root per garantire la compatibilità in tutte le regioni.
Combina tutti i certificati scaricati in un unico `pem` file con il nome indicato *keyspaces-bundle.pem* nei nostri esempi. Per aggiungerlo, eseguire il comando seguente: Prendi nota del percorso del file, ne avrai bisogno in seguito.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Connect ad Amazon Keyspaces utilizzando il driver Gocql per Apache Cassandra e le credenziali specifiche del servizio
1. Crea una directory per l'applicazione.
```
mkdir ./gocqlexample
```
1. Accedere alla nuova directory.
```
cd gocqlexample
```
1. Crea un file per la tua applicazione.
```
touch cqlapp.go
```
1. Scarica il driver Go.
```
go get github.com/gocql/gocql
```
1. Aggiungi il seguente codice di esempio al file 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()
}
```
Note sull'utilizzo:
1. Sostituisci `"path_to_file/keyspaces-bundle.pem"` con il percorso del file di certificato combinato salvato nel primo passaggio.
1. Assicurati che *ServiceUserName* e *ServicePassword* corrispondano al nome utente e alla password che hai ottenuto quando hai generato le credenziali specifiche del servizio seguendo i passaggi per. [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Per un elenco degli endpoint disponibili, consulta. [Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md)
1. Costruisci il programma.
```
go build cqlapp.go
```
1. Esegui il programma.
```
./cqlapp
```
## Connect ad Amazon Keyspaces utilizzando il driver Go per Apache Cassandra e il plug-in di autenticazione SigV4
Il seguente esempio di codice mostra come utilizzare il plug-in di autenticazione SigV4 per il driver open source Go per accedere ad Amazon Keyspaces (per Apache Cassandra).
Se non l'hai già fatto, crea le credenziali per il tuo principale IAM seguendo la procedura riportata qui. [Crea e configura AWS credenziali per Amazon Keyspaces](access.credentials.md) Se un'applicazione è in esecuzione su Lambda o un'istanza Amazon EC2, l'applicazione utilizza automaticamente le credenziali dell'istanza. Per eseguire questo tutorial localmente, puoi memorizzare le credenziali come variabili di ambiente locali.
[Aggiungi il plug-in di autenticazione Go SigV4 all'applicazione dal repository. GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin) Il plugin supporta la versione 1.2.x del driver open source Go per Cassandra e dipende dall'SDK for AWS Go.
```
$ go mod init
$ go get github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin
```
In questo esempio di codice, l'endpoint Amazon Keyspaces è rappresentato dalla classe. `Cluster` Utilizza la proprietà `AwsAuthenticator` for the authenticator del cluster per ottenere le credenziali.
```
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)
}
}
```
Note sull'utilizzo:
1. Sostituisci `"path_to_file/keyspaces-bundle.pem"` con il percorso del file di certificato salvato nel primo passaggio.
1. Affinché questo esempio venga eseguito localmente, è necessario definire le seguenti variabili come variabili di ambiente:
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_DEFAULT_REGION`
1. Per memorizzare le chiavi di accesso al di fuori del codice, consulta le best practice all'indirizzo[Memorizza le chiavi di accesso per l'accesso programmatico](aws.credentials.manage.md).
1. Per un elenco degli endpoint disponibili, consulta[Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md).
# Utilizzo di un driver client Cassandra Perl per accedere ad Amazon Keyspaces a livello di codice
Questa sezione mostra come connettersi ad Amazon Keyspaces utilizzando un driver client Perl. Per questo esempio di codice, abbiamo usato Perl 5. Amazon Keyspaces richiede l'uso di Transport Layer Security (TLS) per proteggere le connessioni con i client.
**Importante**
I certificati Amazon Keyspaces stanno passando alla gerarchia di Amazon Trust Services (ATS). Assicurati che il tuo ambiente si fidi di Amazon Root CAs 1-4 per evitare errori di connessione durante questa rotazione. Il driver Perl non convalida il certificato Amazon SSL del server, il che significa che non puoi confermare che ti stai connettendo ad Amazon Keyspaces. Il secondo passaggio, configurare il driver per utilizzare TLS durante la connessione ad Amazon Keyspaces, è ancora necessario e garantisce che i dati trasferiti tra il client e il server siano crittografati.
1. Scarica il driver Cassandra DBI da [https://metacpan.org/pod/DBD::Cassandra](https://metacpan.org/pod/DBD::Cassandra) e installalo nel tuo ambiente Perl. I passaggi esatti dipendono dall'ambiente. Di seguito è riportato un esempio comune.
```
cpanm DBD::Cassandra
```
1. Crea un file per la tua applicazione.
```
touch cqlapp.pl
```
1. Aggiungi il seguente codice di esempio al file 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**
Assicurati che *ServiceUserName* e *ServicePassword* corrispondano al nome utente e alla password che hai ottenuto quando hai generato le credenziali specifiche del servizio seguendo i passaggi da. [Crea credenziali specifiche del servizio per l'accesso programmatico ad Amazon Keyspaces](programmatic.credentials.ssc.md)
**Nota**
Per un elenco degli endpoint disponibili, consulta. [Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md)
1. Esegui l'applicazione.
```
perl cqlapp.pl
```