Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation d'un pilote client Cassandra pour accéder à Amazon Keyspaces par programmation
Vous pouvez utiliser de nombreux pilotes Cassandra open source tiers pour vous connecter à Amazon Keyspaces. Amazon Keyspaces est compatible avec les pilotes Cassandra compatibles avec la version 3.11.2 d'Apache Cassandra. Voici les pilotes et les dernières versions que nous avons testés et que nous recommandons d'utiliser avec 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`
Pour de plus amples informations sur les pilotes Cassandra, veuillez consulter [Pilotes client Apache Cassandra](http://cassandra.apache.org/doc/latest/getting_started/drivers.html).
**Note**
Pour vous aider à démarrer, vous pouvez consulter et télécharger des exemples de end-to-end code permettant d'établir des connexions avec Amazon Keyspaces à l'aide de pilotes populaires. Consultez les [exemples d'Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-examples) sur. GitHub
Les didacticiels de ce chapitre incluent une simple requête CQL pour confirmer que la connexion à Amazon Keyspaces a été correctement établie. Pour savoir comment utiliser les espaces de touches et les tables après vous être connecté à un point de terminaison Amazon Keyspaces, consultez. [Référence du langage CQL pour Amazon Keyspaces (pour Apache Cassandra)](cql.md) Pour un step-by-step didacticiel expliquant comment se connecter à Amazon Keyspaces depuis un point de terminaison Amazon VPC, consultez. [Tutoriel : Connectez-vous à Amazon Keyspaces à l'aide d'un point de terminaison VPC d'interface](vpc-endpoints-tutorial.md)
**Topics**
+ [Utilisation d'un pilote client Cassandra Java pour accéder à Amazon Keyspaces par programmation](using_java_driver.md)
+ [Utilisation d'un pilote client Cassandra Python pour accéder à Amazon Keyspaces par programmation](using_python_driver.md)
+ [Utilisation d'un pilote client Cassandra Node.js pour accéder à Amazon Keyspaces par programmation](using_nodejs_driver.md)
+ [Utilisation d'un pilote client Cassandra .NET Core pour accéder à Amazon Keyspaces par programmation](using_dotnetcore_driver.md)
+ [Utilisation d'un pilote client Cassandra Go pour accéder à Amazon Keyspaces par programmation](using_go_driver.md)
+ [Utilisation d'un pilote client Cassandra Perl pour accéder à Amazon Keyspaces par programmation](using_perl_driver.md)
# Utilisation d'un pilote client Cassandra Java pour accéder à Amazon Keyspaces par programmation
Cette section explique comment vous connecter à Amazon Keyspaces à l'aide d'un pilote client Java.
**Note**
Java 17 et le pilote DataStax Java 4.17 ne sont actuellement pris en charge que par la version bêta. Pour de plus amples informations, veuillez consulter [https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/](https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/).
Pour fournir aux utilisateurs et aux applications des informations d'identification leur permettant d'accéder par programmation aux ressources Amazon Keyspaces, vous pouvez effectuer l'une des opérations suivantes :
+ Créez des informations d'identification spécifiques au service associées à un utilisateur Gestion des identités et des accès AWS (IAM) spécifique.
+ Pour renforcer la sécurité, nous recommandons de créer des clés d'accès IAM pour les identités IAM qui sont utilisées dans tous les AWS services. Le plugin d'authentification Amazon Keyspaces SigV4 pour les pilotes clients Cassandra vous permet d'authentifier les appels vers Amazon Keyspaces à l'aide de clés d'accès IAM plutôt que de votre nom d'utilisateur et de votre mot de passe. Pour de plus amples informations, veuillez consulter [Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).
**Note**
Pour un exemple d'utilisation d'Amazon Keyspaces avec Spring Boot, consultez. [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**
+ [Avant de commencer](#using_java_driver.BeforeYouBegin)
+ [Step-by-step tutoriel pour se connecter à Amazon Keyspaces à l'aide du pilote DataStax Java pour Apache Cassandra à l'aide d'informations d'identification spécifiques au service](#java_tutorial)
+ [Step-by-step tutoriel pour se connecter à Amazon Keyspaces à l'aide du pilote DataStax Java 4.x pour Apache Cassandra et du plugin d'authentification SigV4](#java_tutorial.SigV4)
+ [Connectez-vous à Amazon Keyspaces à l'aide du pilote DataStax Java 3.x pour Apache Cassandra et du plugin d'authentification SigV4](#java3x_tutorial.SigV4)
## Avant de commencer
Pour vous connecter à Amazon Keyspaces, vous devez effectuer les tâches suivantes avant de pouvoir commencer.
1. Amazon Keyspaces nécessite l'utilisation du protocole TLS (Transport Layer Security) pour sécuriser les connexions avec les clients.
1. Téléchargez les certificats numériques suivants et enregistrez les fichiers localement ou dans votre répertoire personnel.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (en option, pour une rétrocompatibilité)
Pour télécharger les certificats, vous pouvez utiliser les commandes suivantes.
```
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
```
**Note**
Amazon Keyspaces utilisait auparavant des certificats TLS ancrés à l'autorité de certification Starfield Class 2. AWS migre le tout Régions AWS vers des certificats émis dans le cadre d'Amazon Trust Services (Amazon Root CAs 1—4). Au cours de cette transition, configurez les clients pour qu'ils fassent confiance à la fois à Amazon Root CAs 1-4 et à la racine Starfield afin de garantir la compatibilité entre toutes les régions.
1. Convertissez les certificats numériques en fichiers TrustStore et ajoutez-les au 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
```
Dans la dernière étape, vous devez créer un mot de passe pour le keystore et faire confiance à chaque certificat. La commande interactive ressemble à ceci.
```
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. Joignez le fichier trustStore dans les arguments de la JVM :
```
-Djavax.net.ssl.trustStore=path_to_file/cassandra_truststore.jks
-Djavax.net.ssl.trustStorePassword=my_password
```
## Step-by-step tutoriel pour se connecter à Amazon Keyspaces à l'aide du pilote DataStax Java pour Apache Cassandra à l'aide d'informations d'identification spécifiques au service
Le step-by-step didacticiel suivant vous explique comment vous connecter à Amazon Keyspaces à l'aide d'un pilote Java pour Cassandra à l'aide d'informations d'identification spécifiques au service. Plus précisément, vous utiliserez la version 4.0 du pilote DataStax Java pour Apache Cassandra.
**Topics**
+ [Étape 1 : Prérequis](#java_tutorial.prereq)
+ [Étape 2 : Configuration du pilote](#java_tutorial.driverconfiguration)
+ [Étape 3 : Exécuter l'exemple d'application](#java_tutorial.application)
### Étape 1 : Prérequis
Pour suivre ce didacticiel, vous devez générer des informations d'identification spécifiques au service et ajouter le pilote DataStax Java pour Apache Cassandra à votre projet Java.
+ Générez des informations d'identification spécifiques au service pour votre utilisateur Amazon Keyspaces IAM en suivant les étapes décrites dans. [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md) Si vous préférez utiliser les clés d'accès IAM pour l'authentification, consultez[Step-by-step tutoriel pour se connecter à Amazon Keyspaces à l'aide du pilote DataStax Java 4.x pour Apache Cassandra et du plugin d'authentification SigV4](#java_tutorial.SigV4).
+ Ajoutez le pilote DataStax Java pour Apache Cassandra à votre projet Java. Assurez-vous que vous utilisez une version du pilote compatible avec Apache Cassandra 3.11.2. Pour plus d'informations, consultez la [documentation du pilote DataStax Java pour Apache Cassandra](https://github.com/datastax/java-driver).
### Étape 2 : Configuration du pilote
Vous pouvez définir les paramètres du pilote DataStax Java Cassandra en créant un fichier de configuration pour votre application. Ce fichier de configuration remplace les paramètres par défaut et indique au pilote de se connecter au point de terminaison du service Amazon Keyspaces via le port 9142. Pour obtenir la liste des points de terminaison de service disponibles, consultez[Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
Créez un fichier de configuration et enregistrez-le dans le dossier des ressources de l'application, par exemple,. `src/main/resources/application.conf` Ouvrez `application.conf` et ajoutez les paramètres de configuration suivants.
1. **Fournisseur d'authentification** : créez le fournisseur d'authentification avec la `PlainTextAuthProvider` classe. *ServiceUserName*et *ServicePassword* doivent correspondre au nom d'utilisateur et au mot de passe que vous avez obtenus lorsque vous avez généré les informations d'identification spécifiques au service en suivant les étapes décrites dans. [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md)
**Note**
Vous pouvez utiliser des informations d'identification à court terme en utilisant le plug-in d'authentification du pilote DataStax Java pour Apache Cassandra au lieu de les coder en dur dans le fichier de configuration du pilote. Pour en savoir plus, suivez les instructions du[Step-by-step tutoriel pour se connecter à Amazon Keyspaces à l'aide du pilote DataStax Java 4.x pour Apache Cassandra et du plugin d'authentification SigV4](#java_tutorial.SigV4).
1. **Centre de données local** : définissez la valeur `local-datacenter` pour la région à laquelle vous vous connectez. Par exemple, si l'application se connecte à`cassandra.us-east-2.amazonaws.com`, définissez le centre de données local sur`us-east-2`. Pour toutes les options disponibles Régions AWS, voir[Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md). Paramétré `slow-replica-avoidance = false` pour équilibrer la charge en fonction d'un nombre réduit de nœuds.
1. **SSL/TLS** — Initialisez la SSLEngine fabrique en ajoutant une section dans le fichier de configuration avec une seule ligne qui spécifie la classe avec. `class = DefaultSslEngineFactory` Indiquez le chemin d'accès au fichier TrustStore et le mot de passe que vous avez créés précédemment. Amazon Keyspaces ne prend pas en charge `hostname-validation` les pairs, alors définissez cette option sur 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
}
}
```
**Note**
Au lieu d'ajouter le chemin du TrustStore dans le fichier de configuration, vous pouvez également ajouter le chemin du TrustStore directement dans le code de l'application ou vous pouvez ajouter le chemin du TrustStore à vos arguments JVM.
### Étape 3 : Exécuter l'exemple d'application
Cet exemple de code montre une application de ligne de commande simple qui crée un pool de connexions vers Amazon Keyspaces à l'aide du fichier de configuration que nous avons créé précédemment. Il confirme que la connexion est établie en exécutant une simple requête.
```
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"));
}
}
}
```
**Note**
Utilisez un `try` bloc pour établir la connexion afin de garantir qu'elle est toujours fermée. Si vous n'utilisez pas de `try` blocage, pensez à fermer votre connexion pour éviter toute fuite de ressources.
## Step-by-step tutoriel pour se connecter à Amazon Keyspaces à l'aide du pilote DataStax Java 4.x pour Apache Cassandra et du plugin d'authentification SigV4
La section suivante décrit comment utiliser le plug-in d'authentification SigV4 pour le pilote DataStax Java 4.x open source pour Apache Cassandra afin d'accéder à Amazon Keyspaces (pour Apache Cassandra). Le plugin est disponible dans le [GitHubréférentiel](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin).
Le plugin d'authentification SigV4 vous permet d'utiliser les informations d'identification IAM pour les utilisateurs ou les rôles lorsque vous vous connectez à Amazon Keyspaces. Au lieu de demander un nom d'utilisateur et un mot de passe, ce plugin signe les demandes d'API à l'aide de clés d'accès. Pour de plus amples informations, veuillez consulter [Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).
### Étape 1 : Prérequis
Pour suivre ce didacticiel, vous devez effectuer les tâches suivantes.
+ Si ce n'est pas déjà fait, créez des informations d'identification pour votre utilisateur ou rôle IAM en suivant les étapes décrites dans[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md). Ce didacticiel part du principe que les clés d'accès sont stockées sous forme de variables d'environnement. Pour de plus amples informations, veuillez consulter [Stocker les clés d'accès pour un accès programmatique](aws.credentials.manage.md).
+ Ajoutez le pilote DataStax Java pour Apache Cassandra à votre projet Java. Assurez-vous que vous utilisez une version du pilote compatible avec Apache Cassandra 3.11.2. Pour plus d'informations, consultez la [documentation du pilote DataStax Java pour Apache Cassandra](https://github.com/datastax/java-driver).
+ Ajoutez le plugin d'authentification à votre application. Le plugin d'authentification prend en charge la version 4.x du pilote DataStax Java pour Apache Cassandra. Si vous utilisez Apache Maven, ou un système de génération qui peut utiliser les dépendances Maven, ajoutez les dépendances suivantes à votre fichier `pom.xml`.
**Important**
Remplacez la version du plugin par la dernière version, comme indiqué dans le [GitHub référentiel](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
```
### Étape 2 : Configuration du pilote
Vous pouvez définir les paramètres du pilote DataStax Java Cassandra en créant un fichier de configuration pour votre application. Ce fichier de configuration remplace les paramètres par défaut et indique au pilote de se connecter au point de terminaison du service Amazon Keyspaces via le port 9142. Pour obtenir la liste des points de terminaison de service disponibles, consultez[Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
Créez un fichier de configuration et enregistrez-le dans le dossier des ressources de l'application, par exemple,. `src/main/resources/application.conf` Ouvrez `application.conf` et ajoutez les paramètres de configuration suivants.
1. **Fournisseur d'authentification** : définissez une nouvelle instance de`software.aws.mcs.auth.SigV4AuthProvider`. `advanced.auth-provider.class` Le SigV4 AuthProvider est le gestionnaire d'authentification fourni par le plugin pour effectuer l'authentification Sigv4.
1. **Centre de données local** : définissez la valeur `local-datacenter` pour la région à laquelle vous vous connectez. Par exemple, si l'application se connecte à`cassandra.us-east-2.amazonaws.com`, définissez le centre de données local sur`us-east-2`. Pour toutes les options disponibles Régions AWS, voir[Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md). Réglé `slow-replica-avoidance = false` pour équilibrer la charge par rapport à tous les nœuds disponibles.
1. **Idempotentie** — Définissez la valeur par défaut `idempotence` pour que l'application configure le pilote `true` afin qu'il réessaie toujours les demandes ayant échoué. read/write/prepare/execute Il s'agit d'une bonne pratique pour les applications distribuées qui permet de gérer les défaillances transitoires en réessayant les demandes ayant échoué.
1. **SSL/TLS** — Initialisez la SSLEngine fabrique en ajoutant une section dans le fichier de configuration avec une seule ligne qui spécifie la classe avec. `class = DefaultSslEngineFactory` Indiquez le chemin d'accès au fichier TrustStore et le mot de passe que vous avez créés précédemment. Amazon Keyspaces ne prend pas en charge `hostname-validation` les pairs, alors définissez cette option sur false.
1. **Connexions** — Créez au moins 3 connexions locales par point de terminaison en définissant`local.size = 3`. Il s'agit d'une bonne pratique qui aide votre application à gérer les surcharges et les pics de trafic. Pour plus d'informations sur la façon de calculer le nombre de connexions locales par point de terminaison dont votre application a besoin en fonction des modèles de trafic attendus, voir[Comment configurer les connexions dans Amazon Keyspaces](connections.md#connections.howtoconfigure).
1. **Politique de nouvelle tentative** : implémentez la `AmazonKeyspacesExponentialRetryPolicy` politique de nouvelle tentative d'Amazon Keyspaces au lieu de celle fournie avec `DefaultRetryPolicy` le pilote Cassandra. Cela vous permet de configurer le nombre de tentatives de tentative `AmazonKeyspacesExponentialRetryPolicy` correspondant à vos besoins. Par défaut, le nombre de nouvelles tentatives pour le `AmazonKeyspacesExponentialRetryPolicy` est défini sur 3. Pour de plus amples informations, veuillez consulter [Comment configurer la politique de nouvelles tentatives pour les connexions dans Amazon Keyspaces](connections.md#connections.retry-policies).
1. **Instructions préparées :** définissez la valeur `prepare-on-all-nodes` sur false pour optimiser l'utilisation du réseau.
```
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
}
}
}
```
**Note**
Au lieu d'ajouter le chemin du TrustStore dans le fichier de configuration, vous pouvez également ajouter le chemin du TrustStore directement dans le code de l'application ou vous pouvez ajouter le chemin du TrustStore à vos arguments JVM.
### Étape 3 : Exécuter l'application
Cet exemple de code montre une application de ligne de commande simple qui crée un pool de connexions vers Amazon Keyspaces à l'aide du fichier de configuration que nous avons créé précédemment. Il confirme que la connexion est établie en exécutant une simple requête.
```
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"));
}
}
}
```
**Note**
Utilisez un `try` bloc pour établir la connexion afin de garantir qu'elle est toujours fermée. Si vous n'utilisez pas de `try` blocage, pensez à fermer votre connexion pour éviter toute fuite de ressources.
## Connectez-vous à Amazon Keyspaces à l'aide du pilote DataStax Java 3.x pour Apache Cassandra et du plugin d'authentification SigV4
La section suivante décrit comment utiliser le plug-in d'authentification SigV4 pour le pilote DataStax Java open source 3.x pour Apache Cassandra afin d'accéder à Amazon Keyspaces. Le plugin est disponible dans le [GitHub référentiel](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible).
Le plugin d'authentification SigV4 vous permet d'utiliser les informations d'identification IAM pour les utilisateurs et les rôles lorsque vous vous connectez à Amazon Keyspaces. Au lieu de demander un nom d'utilisateur et un mot de passe, ce plugin signe les demandes d'API à l'aide de clés d'accès. Pour de plus amples informations, veuillez consulter [Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).
### Étape 1 : Prérequis
Pour exécuter cet exemple de code, vous devez d'abord effectuer les tâches suivantes.
+ Créez des informations d'identification pour votre utilisateur ou votre rôle IAM en suivant les étapes décrites dans[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md). Ce didacticiel part du principe que les clés d'accès sont stockées sous forme de variables d'environnement. Pour de plus amples informations, veuillez consulter [Stocker les clés d'accès pour un accès programmatique](aws.credentials.manage.md).
+ Suivez les étapes décrites [Avant de commencer](#using_java_driver.BeforeYouBegin) pour télécharger les certificats numériques, les convertir en fichiers TrustStore et joindre le keystore dans les arguments de la JVM à votre application.
+ Ajoutez le pilote DataStax Java pour Apache Cassandra à votre projet Java. Assurez-vous que vous utilisez une version du pilote compatible avec Apache Cassandra 3.11.2. Pour plus d'informations, consultez la [documentation du pilote DataStax Java pour Apache Cassandra](https://github.com/datastax/java-driver).
+ Ajoutez le plugin d'authentification à votre application. Le plugin d'authentification prend en charge la version 3.x du pilote DataStax Java pour Apache Cassandra. Si vous utilisez Apache Maven, ou un système de génération qui peut utiliser les dépendances Maven, ajoutez les dépendances suivantes à votre fichier `pom.xml`. Remplacez la version du plugin par la dernière version, comme indiqué dans le [GitHub référentiel](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
```
### Étape 2 : Exécuter l'application
Cet exemple de code montre une application de ligne de commande simple qui crée un pool de connexions vers Amazon Keyspaces. Il confirme que la connexion est établie en exécutant une simple requête.
```
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"));
}
}
```
Remarques d'utilisation :
Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
Consultez le référentiel suivant pour obtenir des politiques, des exemples et des meilleures pratiques utiles en matière de pilote Java lors de l'utilisation du pilote Java avec Amazon Keyspaces :. [https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers)
# Utilisation d'un pilote client Cassandra Python pour accéder à Amazon Keyspaces par programmation
Dans cette section, nous vous expliquons comment vous connecter à Amazon Keyspaces à l'aide d'un pilote client Python. Pour fournir aux utilisateurs et aux applications des informations d'identification leur permettant d'accéder par programmation aux ressources Amazon Keyspaces, vous pouvez effectuer l'une des opérations suivantes :
+ Créez des informations d'identification spécifiques au service associées à un utilisateur Gestion des identités et des accès AWS (IAM) spécifique.
+ Pour renforcer la sécurité, nous recommandons de créer des clés d'accès IAM pour les utilisateurs ou les rôles IAM qui sont utilisées dans tous les AWS services. Le plugin d'authentification Amazon Keyspaces SigV4 pour les pilotes clients Cassandra vous permet d'authentifier les appels vers Amazon Keyspaces à l'aide de clés d'accès IAM plutôt que de votre nom d'utilisateur et de votre mot de passe. Pour de plus amples informations, veuillez consulter [Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).
**Topics**
+ [Avant de commencer](#using_python_driver.BeforeYouBegin)
+ [Connectez-vous à Amazon Keyspaces à l'aide du pilote Python pour Apache Cassandra et des informations d'identification spécifiques au service](#python_ssc)
+ [Connectez-vous à Amazon Keyspaces à l'aide du pilote DataStax Python pour Apache Cassandra et du plugin d'authentification SigV4](#python_SigV4)
## Avant de commencer
Vous devez effectuer la tâche suivante avant de pouvoir commencer.
Amazon Keyspaces nécessite l'utilisation du protocole TLS (Transport Layer Security) pour sécuriser les connexions avec les clients. Pour vous connecter à Amazon Keyspaces via le protocole TLS, vous devez télécharger les certificats numériques Amazon et configurer le pilote Python pour qu'il utilise le protocole TLS.
Téléchargez les certificats numériques suivants et enregistrez les fichiers localement ou dans votre répertoire personnel.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (en option, pour une rétrocompatibilité)
Pour télécharger les certificats, vous pouvez utiliser les commandes suivantes.
```
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
```
**Note**
Amazon Keyspaces utilisait auparavant des certificats TLS ancrés à l'autorité de certification Starfield Class 2. AWS migre le tout Régions AWS vers des certificats émis dans le cadre d'Amazon Trust Services (Amazon Root CAs 1—4). Au cours de cette transition, configurez les clients pour qu'ils fassent confiance à la fois à Amazon Root CAs 1-4 et à la racine Starfield afin de garantir la compatibilité entre toutes les régions.
Combinez tous les certificats téléchargés dans un seul `pem` fichier portant le nom *keyspaces-bundle.pem* indiqué dans nos exemples. Pour ce faire, exécutez la commande suivante : Notez le chemin du fichier, vous en aurez besoin plus tard.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Connectez-vous à Amazon Keyspaces à l'aide du pilote Python pour Apache Cassandra et des informations d'identification spécifiques au service
L'exemple de code suivant vous montre comment vous connecter à Amazon Keyspaces à l'aide d'un pilote client Python et d'informations d'identification spécifiques au service.
```
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)
```
Remarques d'utilisation :
1. Remplacez `"path_to_file/keyspaces-bundle.pem"` par le chemin d'accès au fichier de certificat combiné enregistré lors de la première étape.
1. Assurez-vous que *ServiceUserName* et *ServicePassword* correspondent au nom d'utilisateur et au mot de passe que vous avez obtenus lorsque vous avez généré les informations d'identification spécifiques au service en suivant les étapes de. [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
## Connectez-vous à Amazon Keyspaces à l'aide du pilote DataStax Python pour Apache Cassandra et du plugin d'authentification SigV4
La section suivante explique comment utiliser le plugin d'authentification SigV4 pour le pilote DataStax Python open source pour Apache Cassandra afin d'accéder à Amazon Keyspaces (pour Apache Cassandra).
Si ce n'est pas déjà fait, commencez par créer des informations d'identification pour votre rôle IAM en suivant les étapes décrites dans[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md). Ce didacticiel utilise des informations d'identification temporaires, qui nécessitent un rôle IAM. Pour plus d'informations sur les informations d'identification temporaires, consultez[Créez des informations d'identification temporaires pour vous connecter à Amazon Keyspaces à l'aide d'un rôle IAM et du plugin SigV4](temporary.credentials.IAM.md).
Ajoutez ensuite le plugin d'authentification Python SigV4 à votre environnement depuis le [GitHub référentiel](https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin).
```
pip install cassandra-sigv4
```
L'exemple de code suivant montre comment se connecter à Amazon Keyspaces à l'aide du pilote DataStax Python open source pour Cassandra et du plugin d'authentification SigV4. Le plugin dépend du AWS SDK pour Python (Boto3). Il est utilisé `boto3.session` pour obtenir des informations d'identification temporaires.
```
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)
```
Remarques d'utilisation :
1. `"path_to_file/keyspaces-bundle.pem"`Remplacez-le par le chemin d'accès au certificat enregistré lors de la première étape.
1. Assurez-vous que le *aws\$1access\$1key\$1id**aws\$1secret\$1access\$1key*, et le *aws\$1session\$1token* correspondent au`Access Key`,`Secret Access Key`, et `Session Token` que vous avez obtenu en utilisant`boto3.session`. Pour de plus amples informations, veuillez consulter [Informations d'identification](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) dans le *AWS SDK pour Python (Boto3)*.
1. Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
# Utilisation d'un pilote client Cassandra Node.js pour accéder à Amazon Keyspaces par programmation
Cette section explique comment vous connecter à Amazon Keyspaces à l'aide d'un pilote client Node.js. Pour fournir aux utilisateurs et aux applications des informations d'identification leur permettant d'accéder par programmation aux ressources Amazon Keyspaces, vous pouvez effectuer l'une des opérations suivantes :
+ Créez des informations d'identification spécifiques au service associées à un utilisateur Gestion des identités et des accès AWS (IAM) spécifique.
+ Pour renforcer la sécurité, nous recommandons de créer des clés d'accès IAM pour les utilisateurs ou les rôles IAM qui sont utilisées dans tous les AWS services. Le plugin d'authentification Amazon Keyspaces SigV4 pour les pilotes clients Cassandra vous permet d'authentifier les appels vers Amazon Keyspaces à l'aide de clés d'accès IAM plutôt que de votre nom d'utilisateur et de votre mot de passe. Pour de plus amples informations, veuillez consulter [Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).
**Topics**
+ [Avant de commencer](#using_nodejs_driver.BeforeYouBegin)
+ [Connectez-vous à Amazon Keyspaces à l'aide du DataStax pilote Node.js pour Apache Cassandra et des informations d'identification spécifiques au service](#nodejs_ssc)
+ [Connectez-vous à Amazon Keyspaces à l'aide du pilote DataStax Node.js pour Apache Cassandra et du plugin d'authentification SigV4](#nodejs_SigV4)
## Avant de commencer
Vous devez effectuer la tâche suivante avant de pouvoir commencer.
Amazon Keyspaces nécessite l'utilisation du protocole TLS (Transport Layer Security) pour sécuriser les connexions avec les clients. Pour vous connecter à Amazon Keyspaces via le protocole TLS, vous devez télécharger un certificat numérique Amazon et configurer le pilote Python pour qu'il utilise le protocole TLS.
Téléchargez les certificats numériques suivants et enregistrez les fichiers localement ou dans votre répertoire personnel.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (en option, pour une rétrocompatibilité)
Pour télécharger les certificats, vous pouvez utiliser les commandes suivantes.
```
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
```
**Note**
Amazon Keyspaces utilisait auparavant des certificats TLS ancrés à l'autorité de certification Starfield Class 2. AWS migre le tout Régions AWS vers des certificats émis dans le cadre d'Amazon Trust Services (Amazon Root CAs 1—4). Au cours de cette transition, configurez les clients pour qu'ils fassent confiance à la fois à Amazon Root CAs 1-4 et à la racine Starfield afin de garantir la compatibilité entre toutes les régions.
Combinez tous les certificats téléchargés dans un seul `pem` fichier portant le nom *keyspaces-bundle.pem* indiqué dans nos exemples. Pour ce faire, exécutez la commande suivante : Notez le chemin du fichier, vous en aurez besoin plus tard.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Connectez-vous à Amazon Keyspaces à l'aide du DataStax pilote Node.js pour Apache Cassandra et des informations d'identification spécifiques au service
Configurez votre pilote pour qu'il utilise le fichier de certificat combiné `keyspaces-bundle.pem` pour TLS et qu'il s'authentifie à l'aide d'informations d'identification spécifiques au service. Par exemple :
```
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}`));
```
Remarques d'utilisation :
1. Remplacez `"path_to_file/keyspaces-bundle.pem"` par le chemin d'accès au fichier de certificat combiné enregistré lors de la première étape.
1. Assurez-vous que *ServiceUserName* et *ServicePassword* correspondent au nom d'utilisateur et au mot de passe que vous avez obtenus lorsque vous avez généré les informations d'identification spécifiques au service en suivant les étapes de. [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
## Connectez-vous à Amazon Keyspaces à l'aide du pilote DataStax Node.js pour Apache Cassandra et du plugin d'authentification SigV4
La section suivante explique comment utiliser le plugin d'authentification SigV4 pour le pilote open source DataStax Node.js pour Apache Cassandra afin d'accéder à Amazon Keyspaces (pour Apache Cassandra).
Si ce n'est pas déjà fait, créez des informations d'identification pour votre utilisateur ou rôle IAM en suivant les étapes décrites dans[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).
Ajoutez le plugin d'authentification SigV4 Node.js à votre application depuis le [GitHub référentiel](https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin). Le plugin prend en charge la version 4.x du pilote DataStax Node.js pour Cassandra et dépend du AWS SDK pour Node.js. Il est utilisé `AWSCredentialsProvider` pour obtenir des informations d'identification.
```
$ npm install aws-sigv4-auth-cassandra-plugin --save
```
Cet exemple de code montre comment définir une instance spécifique à une région `SigV4AuthProvider` comme fournisseur d'authentification.
```
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}`));
```
Remarques d'utilisation :
1. `"path_to_file/keyspaces-bundle.pem"`Remplacez-le par le chemin d'accès au certificat enregistré lors de la première étape.
1. Assurez-vous que *accessKeyId* et *secretAccessKey* correspondent à la clé d'accès et à la clé d'accès secrète que vous avez obtenues à l'aide`AWSCredentialsProvider`. Pour plus d'informations, consultez la section [Configuration des informations d'identification dans Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html) dans le *AWS SDK pour JavaScript Node.js*.
1. Pour stocker les clés d'accès en dehors du code, consultez les meilleures pratiques sur[Stocker les clés d'accès pour un accès programmatique](aws.credentials.manage.md).
1. Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
# Utilisation d'un pilote client Cassandra .NET Core pour accéder à Amazon Keyspaces par programmation
Cette section explique comment vous connecter à Amazon Keyspaces à l'aide d'un pilote client .NET Core. Les étapes de configuration varient en fonction de votre environnement et de votre système d'exploitation, vous devrez peut-être les modifier en conséquence. Amazon Keyspaces nécessite l'utilisation du protocole TLS (Transport Layer Security) pour sécuriser les connexions avec les clients. Pour vous connecter à Amazon Keyspaces via le protocole TLS, configurez votre pilote pour qu'il utilise le System Trust Store, qui inclut l'Amazon Root 1-4. CAs
1. Installez le CSharp pilote Cassandra via Nuget, à l'aide de la console Nuget.
```
PM> Install-Package CassandraCSharpDriver
```
1. L'exemple suivant utilise un projet de console .NET Core C\$1 pour se connecter à Amazon Keyspaces et exécuter une requête.
```
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);
}
}
}
}
```
Remarques d'utilisation :
1. Assurez-vous d'utiliser le System Trust Store par défaut, qui inclut Amazon Root CAs 1-4.
1. Assurez-vous que *ServiceUserName* et *ServicePassword* correspondent au nom d'utilisateur et au mot de passe que vous avez obtenus lorsque vous avez généré les informations d'identification spécifiques au service en suivant les étapes de. [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
# Utilisation d'un pilote client Cassandra Go pour accéder à Amazon Keyspaces par programmation
Cette section explique comment vous connecter à Amazon Keyspaces à l'aide d'un pilote client Go Cassandra. Pour fournir aux utilisateurs et aux applications des informations d'identification leur permettant d'accéder par programmation aux ressources Amazon Keyspaces, vous pouvez effectuer l'une des opérations suivantes :
+ Créez des informations d'identification spécifiques au service associées à un utilisateur Gestion des identités et des accès AWS (IAM) spécifique.
+ Pour renforcer la sécurité, nous recommandons de créer des clés d'accès IAM pour les principaux IAM, qui sont utilisées dans tous les services. AWS Le plugin d'authentification Amazon Keyspaces SigV4 pour les pilotes clients Cassandra vous permet d'authentifier les appels vers Amazon Keyspaces à l'aide de clés d'accès IAM plutôt que de votre nom d'utilisateur et de votre mot de passe. Pour de plus amples informations, veuillez consulter [Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md).
**Topics**
+ [Avant de commencer](#using_go_driver.BeforeYouBegin)
+ [Connectez-vous à Amazon Keyspaces à l'aide du pilote Gocql pour Apache Cassandra et des informations d'identification spécifiques au service](#go_ssc)
+ [Connectez-vous à Amazon Keyspaces à l'aide du pilote Go pour Apache Cassandra et du plugin d'authentification SigV4](#go_SigV4)
## Avant de commencer
Vous devez effectuer la tâche suivante avant de pouvoir commencer.
Amazon Keyspaces nécessite l'utilisation du protocole TLS (Transport Layer Security) pour sécuriser les connexions avec les clients. Pour vous connecter à Amazon Keyspaces via le protocole TLS, vous devez télécharger un certificat numérique Amazon et configurer le pilote Go pour qu'il utilise le protocole TLS.
Téléchargez les certificats numériques suivants et enregistrez les fichiers localement ou dans votre répertoire personnel.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (en option, pour une rétrocompatibilité)
Pour télécharger les certificats, vous pouvez utiliser les commandes suivantes.
```
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
```
**Note**
Amazon Keyspaces utilisait auparavant des certificats TLS ancrés à l'autorité de certification Starfield Class 2. AWS migre le tout Régions AWS vers des certificats émis dans le cadre d'Amazon Trust Services (Amazon Root CAs 1—4). Au cours de cette transition, configurez les clients pour qu'ils fassent confiance à la fois à Amazon Root CAs 1-4 et à la racine Starfield afin de garantir la compatibilité entre toutes les régions.
Combinez tous les certificats téléchargés dans un seul `pem` fichier portant le nom *keyspaces-bundle.pem* indiqué dans nos exemples. Pour ce faire, exécutez la commande suivante : Notez le chemin du fichier, vous en aurez besoin plus tard.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Connectez-vous à Amazon Keyspaces à l'aide du pilote Gocql pour Apache Cassandra et des informations d'identification spécifiques au service
1. Créez un nouveau répertoire pour votre application.
```
mkdir ./gocqlexample
```
1. Accédez au nouveau répertoire.
```
cd gocqlexample
```
1. Créez un fichier pour votre candidature.
```
touch cqlapp.go
```
1. Téléchargez le pilote Go.
```
go get github.com/gocql/gocql
```
1. Ajoutez l'exemple de code suivant au fichier 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()
}
```
Remarques d'utilisation :
1. Remplacez `"path_to_file/keyspaces-bundle.pem"` par le chemin d'accès au fichier de certificat combiné enregistré lors de la première étape.
1. Assurez-vous que *ServiceUserName* et *ServicePassword* correspondent au nom d'utilisateur et au mot de passe que vous avez obtenus lorsque vous avez généré les informations d'identification spécifiques au service en suivant les étapes de. [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md)
1. Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
1. Créez le programme.
```
go build cqlapp.go
```
1. Exécutez le programme.
```
./cqlapp
```
## Connectez-vous à Amazon Keyspaces à l'aide du pilote Go pour Apache Cassandra et du plugin d'authentification SigV4
L'exemple de code suivant montre comment utiliser le plugin d'authentification SigV4 pour le pilote Go open source afin d'accéder à Amazon Keyspaces (pour Apache Cassandra).
Si ce n'est pas déjà fait, créez des informations d'identification pour votre principal IAM en suivant les étapes décrites dans[Création et configuration des AWS informations d'identification pour Amazon Keyspaces](access.credentials.md). Si une application s'exécute sur Lambda ou sur une instance Amazon EC2, elle utilise automatiquement les informations d'identification de l'instance. Pour exécuter ce didacticiel localement, vous pouvez enregistrer les informations d'identification sous forme de variables d'environnement locales.
Ajoutez le plugin d'authentification Go SigV4 à votre application depuis le [GitHubréférentiel](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin). Le plugin prend en charge la version 1.2.x du pilote open source Go pour Cassandra et dépend du SDK pour AWS Go.
```
$ go mod init
$ go get github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin
```
Dans cet exemple de code, le point de terminaison Amazon Keyspaces est représenté par la `Cluster` classe. Il utilise la propriété `AwsAuthenticator` for the authenticator du cluster pour obtenir des informations d'identification.
```
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)
}
}
```
Remarques d'utilisation :
1. `"path_to_file/keyspaces-bundle.pem"`Remplacez-le par le chemin d'accès au fichier de certificat enregistré lors de la première étape.
1. Pour que cet exemple s'exécute localement, vous devez définir les variables suivantes en tant que variables d'environnement :
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_DEFAULT_REGION`
1. Pour stocker les clés d'accès en dehors du code, consultez les meilleures pratiques sur[Stocker les clés d'accès pour un accès programmatique](aws.credentials.manage.md).
1. Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
# Utilisation d'un pilote client Cassandra Perl pour accéder à Amazon Keyspaces par programmation
Cette section explique comment vous connecter à Amazon Keyspaces à l'aide d'un pilote client Perl. Pour cet exemple de code, nous avons utilisé Perl 5. Amazon Keyspaces nécessite l'utilisation du protocole TLS (Transport Layer Security) pour sécuriser les connexions avec les clients.
**Important**
Les certificats Amazon Keyspaces sont en train de passer à la hiérarchie Amazon Trust Services (ATS). Assurez-vous que votre environnement fait confiance à Amazon Root CAs 1—4 pour éviter les erreurs de connexion lors de cette rotation. Le pilote Perl ne valide pas le certificat SSL Amazon du serveur, ce qui signifie que vous ne pouvez pas confirmer que vous êtes connecté à Amazon Keyspaces. La deuxième étape, qui consiste à configurer le pilote pour utiliser le protocole TLS lors de la connexion à Amazon Keyspaces, est toujours requise et garantit que les données transférées entre le client et le serveur sont cryptées.
1. Téléchargez le pilote Cassandra DBI depuis [https://metacpan.org/pod/DBD::Cassandra](https://metacpan.org/pod/DBD::Cassandra) et installez-le dans votre environnement Perl. Les étapes exactes dépendent de l'environnement. Voici un exemple courant.
```
cpanm DBD::Cassandra
```
1. Créez un fichier pour votre candidature.
```
touch cqlapp.pl
```
1. Ajoutez l'exemple de code suivant au fichier 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;
```
**Important**
Assurez-vous que *ServiceUserName* et *ServicePassword* correspondent au nom d'utilisateur et au mot de passe que vous avez obtenus lorsque vous avez généré les informations d'identification spécifiques au service en suivant les étapes de. [Créez des informations d'identification spécifiques au service pour un accès programmatique à Amazon Keyspaces](programmatic.credentials.ssc.md)
**Note**
Pour obtenir la liste des points de terminaison disponibles, reportez-vous à la section [Points de terminaison de service pour Amazon Keyspaces](programmatic.endpoints.md).
1. Exécutez l'application.
```
perl cqlapp.pl
```