Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden eines Cassandra-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
Sie können viele Open-Source-Cassandra-Treiber von Drittanbietern verwenden, um eine Verbindung zu Amazon Keyspaces herzustellen. Amazon Keyspaces ist mit Cassandra-Treibern kompatibel, die Apache Cassandra Version 3.11.2 unterstützen. Dies sind die Treiber und neuesten Versionen, die wir getestet haben und die wir zur Verwendung mit Amazon Keyspaces empfehlen:
+ `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`
Weitere Informationen zu Cassandra-Treibern finden Sie unter [Apache Cassandra Client-Treiber](http://cassandra.apache.org/doc/latest/getting_started/drivers.html).
**Anmerkung**
Um Ihnen den Einstieg zu erleichtern, können Sie end-to-end Codebeispiele ansehen und herunterladen, die Verbindungen zu Amazon Keyspaces mit gängigen Treibern herstellen. [Beispiele für Amazon Keyspaces](https://github.com/aws-samples/amazon-keyspaces-examples) finden Sie unter GitHub.
Die Tutorials in diesem Kapitel enthalten eine einfache CQL-Abfrage, um zu bestätigen, dass die Verbindung zu Amazon Keyspaces erfolgreich hergestellt wurde. Informationen zum Arbeiten mit Keyspaces und Tabellen, nachdem Sie eine Verbindung zu einem Amazon Keyspaces-Endpunkt hergestellt haben, finden Sie unter. [CQL-Sprachreferenz für Amazon Keyspaces (für Apache Cassandra)](cql.md) Ein step-by-step Tutorial, das zeigt, wie Sie von einem Amazon VPC-Endpunkt aus eine Verbindung zu Amazon Keyspaces herstellen, finden Sie unter. [Tutorial: Stellen Sie über einen VPC-Endpunkt mit einer Schnittstelle eine Verbindung zu Amazon Keyspaces her](vpc-endpoints-tutorial.md)
**Topics**
+ [
# Verwenden eines Cassandra-Java-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
](using_java_driver.md)
+ [
# Verwenden eines Cassandra-Python-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
](using_python_driver.md)
+ [
# Verwenden eines Cassandra Node.js Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
](using_nodejs_driver.md)
+ [
# Verwenden eines Cassandra.NET-Core-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
](using_dotnetcore_driver.md)
+ [
# Verwenden eines Cassandra Go-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
](using_go_driver.md)
+ [
# Verwenden eines Cassandra Perl-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
](using_perl_driver.md)
# Verwenden eines Cassandra-Java-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
In diesem Abschnitt erfahren Sie, wie Sie mithilfe eines Java-Client-Treibers eine Verbindung zu Amazon Keyspaces herstellen.
**Anmerkung**
Java 17 und der DataStax Java-Treiber 4.17 werden derzeit nur in der Betaversion unterstützt. Weitere Informationen finden Sie unter [https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/](https://docs.datastax.com/en/developer/java-driver/4.17/upgrade_guide/).
Um Benutzern und Anwendungen Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces-Ressourcen zur Verfügung zu stellen, können Sie einen der folgenden Schritte ausführen:
+ Erstellen Sie dienstspezifische Anmeldeinformationen, die einem bestimmten AWS Identity and Access Management (IAM-) Benutzer zugeordnet sind.
+ Aus Sicherheitsgründen empfehlen wir, IAM-Zugriffsschlüssel für IAM-Identitäten zu erstellen, die für alle Dienste verwendet werden. AWS Das Amazon Keyspaces SigV4-Authentifizierungs-Plugin für Cassandra-Client-Treiber ermöglicht es Ihnen, Anrufe an Amazon Keyspaces mithilfe von IAM-Zugriffsschlüsseln anstelle von Benutzername und Passwort zu authentifizieren. Weitere Informationen finden Sie unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
**Anmerkung**
Ein Beispiel für die Verwendung von Amazon Keyspaces mit Spring Boot finden Sie unter[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**
+ [
## Bevor Sie beginnen
](#using_java_driver.BeforeYouBegin)
+ [
## Step-by-step Tutorial zum Herstellen einer Verbindung zu Amazon Keyspaces mithilfe des DataStax Java-Treibers für Apache Cassandra mit dienstspezifischen Anmeldeinformationen
](#java_tutorial)
+ [
## Step-by-step Tutorial zum Herstellen einer Verbindung zu Amazon Keyspaces mithilfe des DataStax 4.x-Java-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins
](#java_tutorial.SigV4)
+ [
## Stellen Sie mithilfe des DataStax 3.x-Java-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her
](#java3x_tutorial.SigV4)
## Bevor Sie beginnen
Um eine Verbindung zu Amazon Keyspaces herzustellen, müssen Sie die folgenden Aufgaben ausführen, bevor Sie beginnen können.
1. Amazon Keyspaces erfordert die Verwendung von Transport Layer Security (TLS), um Verbindungen mit Clients zu sichern.
1. Laden Sie die folgenden digitalen Zertifikate herunter und speichern Sie die Dateien lokal oder in Ihrem Home-Verzeichnis.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (optional — aus Gründen der Abwärtskompatibilität)
Um die Zertifikate herunterzuladen, können Sie die folgenden Befehle verwenden.
```
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
```
**Anmerkung**
Amazon Keyspaces verwendete zuvor TLS-Zertifikate, die in der Starfield Class 2 CA verankert waren. AWS migriert alle AWS-Regionen auf Zertifikate, die unter Amazon Trust Services (Amazon Root CAs 1—4) ausgestellt wurden. Während dieser Umstellung sollten Sie die Clients so konfigurieren, dass sie sowohl Amazon Root CAs 1—4 als auch Starfield Root vertrauen, um die Kompatibilität in allen Regionen sicherzustellen.
1. Konvertieren Sie die digitalen Zertifikate in TrustStore-Dateien und fügen Sie sie dem Keystore hinzu.
```
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
```
Im letzten Schritt müssen Sie ein Passwort für den Keystore erstellen und jedem Zertifikat vertrauen. Der interaktive Befehl sieht so aus.
```
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. Hängen Sie die TrustStore-Datei an die JVM-Argumente an:
```
-Djavax.net.ssl.trustStore=path_to_file/cassandra_truststore.jks
-Djavax.net.ssl.trustStorePassword=my_password
```
## Step-by-step Tutorial zum Herstellen einer Verbindung zu Amazon Keyspaces mithilfe des DataStax Java-Treibers für Apache Cassandra mit dienstspezifischen Anmeldeinformationen
Das folgende step-by-step Tutorial führt Sie durch die Herstellung einer Verbindung zu Amazon Keyspaces mithilfe eines Java-Treibers für Cassandra mit dienstspezifischen Anmeldeinformationen. Insbesondere verwenden Sie die 4.0-Version des DataStax Java-Treibers für Apache Cassandra.
**Topics**
+ [
### Schritt 1: Voraussetzungen
](#java_tutorial.prereq)
+ [
### Schritt 2: Konfigurieren Sie den Treiber
](#java_tutorial.driverconfiguration)
+ [
### Schritt 3: Führen Sie die Beispielanwendung aus
](#java_tutorial.application)
### Schritt 1: Voraussetzungen
Um diesem Tutorial zu folgen, müssen Sie dienstspezifische Anmeldeinformationen generieren und den DataStax Java-Treiber für Apache Cassandra zu Ihrem Java-Projekt hinzufügen.
+ Generieren Sie dienstspezifische Anmeldeinformationen für Ihren Amazon Keyspaces IAM-Benutzer, indem Sie die unter aufgeführten Schritte ausführen. [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md) Wenn Sie lieber IAM-Zugriffsschlüssel für die Authentifizierung verwenden möchten, finden Sie weitere Informationen unter. [Step-by-step Tutorial zum Herstellen einer Verbindung zu Amazon Keyspaces mithilfe des DataStax 4.x-Java-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins](#java_tutorial.SigV4)
+ Fügen Sie den DataStax Java-Treiber für Apache Cassandra zu Ihrem Java-Projekt hinzu. Stellen Sie sicher, dass Sie eine Version des Treibers verwenden, die Apache Cassandra 3.11.2 unterstützt. Weitere Informationen finden Sie in der Dokumentation zum [DataStax Java-Treiber für Apache Cassandra](https://github.com/datastax/java-driver).
### Schritt 2: Konfigurieren Sie den Treiber
Sie können Einstellungen für den DataStax Java-Cassandra-Treiber angeben, indem Sie eine Konfigurationsdatei für Ihre Anwendung erstellen. Diese Konfigurationsdatei überschreibt die Standardeinstellungen und weist den Treiber an, über Port 9142 eine Verbindung zum Amazon Keyspaces-Serviceendpunkt herzustellen. Eine Liste der verfügbaren Service-Endpunkte finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md)
Erstellen Sie eine Konfigurationsdatei und speichern Sie die Datei im Ressourcenordner der Anwendung, z. B. `src/main/resources/application.conf` Öffnen Sie die folgenden `application.conf` Konfigurationseinstellungen und fügen Sie sie hinzu.
1. **Authentifizierungsanbieter** — Erstellen Sie den Authentifizierungsanbieter mit der `PlainTextAuthProvider` Klasse. *ServiceUserName*und *ServicePassword* sollte mit dem Benutzernamen und dem Passwort übereinstimmen, die Sie bei der Generierung der dienstspezifischen Anmeldeinformationen erhalten haben, indem Sie die Schritte unter befolgen. [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md)
**Anmerkung**
Sie können kurzfristige Anmeldeinformationen verwenden, indem Sie das Authentifizierungs-Plug-In für den DataStax Java-Treiber für Apache Cassandra verwenden, anstatt die Anmeldeinformationen in Ihrer Treiberkonfigurationsdatei fest zu codieren. Um mehr zu erfahren, folgen Sie den Anweisungen für. [Step-by-step Tutorial zum Herstellen einer Verbindung zu Amazon Keyspaces mithilfe des DataStax 4.x-Java-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins](#java_tutorial.SigV4)
1. **Lokales Rechenzentrum** — Stellen Sie den Wert für `local-datacenter` die Region ein, mit der Sie eine Verbindung herstellen. Wenn die Anwendung beispielsweise eine Verbindung herstellt`cassandra.us-east-2.amazonaws.com`, legen Sie das lokale Rechenzentrum auf fest`us-east-2`. Alle verfügbaren AWS-Regionen Informationen finden Sie unter[Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md). Auf `slow-replica-avoidance = false` Lastenausgleich für weniger Knoten eingestellt.
1. **SSL/TLS** — Initialisieren Sie die SSLEngine Factory, indem Sie der Konfigurationsdatei einen Abschnitt mit einer einzigen Zeile hinzufügen, in der die Klasse mit angegeben wird. `class = DefaultSslEngineFactory` Geben Sie den Pfad zur TrustStore-Datei und das Passwort an, das Sie zuvor erstellt haben. Amazon Keyspaces unterstützt keine `hostname-validation` Peers, setzen Sie diese Option daher auf 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
}
}
```
**Anmerkung**
Anstatt den Pfad zum TrustStore in der Konfigurationsdatei hinzuzufügen, können Sie den TrustStore-Pfad auch direkt im Anwendungscode hinzufügen oder Sie können den Pfad zum TrustStore zu Ihren JVM-Argumenten hinzufügen.
### Schritt 3: Führen Sie die Beispielanwendung aus
Dieses Codebeispiel zeigt eine einfache Befehlszeilenanwendung, die mithilfe der zuvor erstellten Konfigurationsdatei einen Verbindungspool zu Amazon Keyspaces erstellt. Es bestätigt, dass die Verbindung hergestellt wurde, indem eine einfache Abfrage ausgeführt wird.
```
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"));
}
}
}
```
**Anmerkung**
Verwenden Sie einen `try` Block, um die Verbindung herzustellen, um sicherzustellen, dass sie immer geschlossen ist. Wenn Sie keinen `try` Block verwenden, denken Sie daran, Ihre Verbindung zu schließen, um zu vermeiden, dass Ressourcen verloren gehen.
## Step-by-step Tutorial zum Herstellen einer Verbindung zu Amazon Keyspaces mithilfe des DataStax 4.x-Java-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins
Im folgenden Abschnitt wird beschrieben, wie Sie das SigV4-Authentifizierungs-Plugin für den DataStax Open-Source-4.x-Java-Treiber für Apache Cassandra verwenden, um auf Amazon Keyspaces (für Apache Cassandra) zuzugreifen. [Das Plugin ist im Repository verfügbar. GitHub](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin)
Das SigV4-Authentifizierungs-Plugin ermöglicht es Ihnen, IAM-Anmeldeinformationen für Benutzer oder Rollen zu verwenden, wenn Sie eine Verbindung zu Amazon Keyspaces herstellen. Anstatt einen Benutzernamen und ein Passwort zu benötigen, signiert dieses Plugin API-Anfragen mit Zugriffsschlüsseln. Weitere Informationen finden Sie unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
### Schritt 1: Voraussetzungen
Um diesem Tutorial zu folgen, müssen Sie die folgenden Aufgaben ausführen.
+ Falls Sie dies noch nicht getan haben, erstellen Sie Anmeldeinformationen für Ihren IAM-Benutzer oder Ihre IAM-Rolle gemäß den Schritten unter[AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md). In dieser Anleitung wird davon ausgegangen, dass die Zugriffsschlüssel als Umgebungsvariablen gespeichert sind. Weitere Informationen finden Sie unter [Speichern Sie die Zugriffstasten für den programmatischen Zugriff](aws.credentials.manage.md).
+ Fügen Sie den DataStax Java-Treiber für Apache Cassandra zu Ihrem Java-Projekt hinzu. Stellen Sie sicher, dass Sie eine Version des Treibers verwenden, die Apache Cassandra 3.11.2 unterstützt. Weitere Informationen finden Sie in der Dokumentation zum [DataStax Java-Treiber für Apache Cassandra](https://github.com/datastax/java-driver).
+ Fügen Sie das Authentifizierungs-Plugin zu Ihrer Anwendung hinzu. Das Authentifizierungs-Plugin unterstützt Version 4.x des DataStax Java-Treibers für Apache Cassandra. Wenn Sie Apache Maven oder ein Build-System verwenden, das Maven-Abhängigkeiten verwenden kann, fügen Sie Ihrer Datei die folgenden Abhängigkeiten hinzu. `pom.xml`
**Wichtig**
[Ersetzen Sie die Version des Plugins durch die neueste Version, wie im GitHub Repository gezeigt.](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
```
### Schritt 2: Konfigurieren Sie den Treiber
Sie können Einstellungen für den DataStax Java-Cassandra-Treiber angeben, indem Sie eine Konfigurationsdatei für Ihre Anwendung erstellen. Diese Konfigurationsdatei überschreibt die Standardeinstellungen und weist den Treiber an, über Port 9142 eine Verbindung zum Amazon Keyspaces-Serviceendpunkt herzustellen. Eine Liste der verfügbaren Service-Endpunkte finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md)
Erstellen Sie eine Konfigurationsdatei und speichern Sie die Datei im Ressourcenordner der Anwendung, z. B. `src/main/resources/application.conf` Öffnen Sie die folgenden `application.conf` Konfigurationseinstellungen und fügen Sie sie hinzu.
1. **Authentifizierungsanbieter** — Legen Sie `advanced.auth-provider.class` für eine neue Instanz von fest`software.aws.mcs.auth.SigV4AuthProvider`. Der SigV4 AuthProvider ist der Authentifizierungshandler, der vom Plugin für die Durchführung der SigV4-Authentifizierung bereitgestellt wird.
1. **Lokales Rechenzentrum** — Stellen Sie den Wert für die Region ein`local-datacenter`, zu der Sie eine Verbindung herstellen. Wenn die Anwendung beispielsweise eine Verbindung herstellt`cassandra.us-east-2.amazonaws.com`, legen Sie das lokale Rechenzentrum auf fest`us-east-2`. Alle verfügbaren AWS-Regionen Informationen finden Sie unter[Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md). Auf `slow-replica-avoidance = false` Lastenausgleich für alle verfügbaren Knoten eingestellt.
1. **Idempotenz** — Legen Sie als Standardeinstellung `idempotence` für die Anwendung fest, dass der Treiber so konfiguriert wird`true`, dass fehlgeschlagene Anfragen immer wiederholt werden. read/write/prepare/execute Dies ist eine bewährte Methode für verteilte Anwendungen, mit der vorübergehende Fehler behoben werden können, indem fehlgeschlagene Anfragen wiederholt werden.
1. **SSL/TLS** — Initialisieren Sie die SSLEngine Factory, indem Sie der Konfigurationsdatei einen Abschnitt mit einer einzigen Zeile hinzufügen, in der die Klasse mit angegeben wird. `class = DefaultSslEngineFactory` Geben Sie den Pfad zur TrustStore-Datei und das Passwort an, das Sie zuvor erstellt haben. Amazon Keyspaces unterstützt keine `hostname-validation` Peers, setzen Sie diese Option daher auf False.
1. **Verbindungen** — Erstellen Sie mindestens 3 lokale Verbindungen pro Endpunkt, indem Sie diese Einstellung `local.size = 3` vornehmen. Dies ist eine bewährte Methode, die Ihrer Anwendung hilft, Overhead und Datenverkehrsspitzen zu bewältigen. Weitere Informationen darüber, wie Sie anhand der erwarteten Datenverkehrsmuster berechnen können, wie viele lokale Verbindungen pro Endpunkt Ihre Anwendung benötigt, finden Sie unter[So konfigurieren Sie Verbindungen in Amazon Keyspaces](connections.md#connections.howtoconfigure).
1. **Wiederholungsrichtlinie** — Implementieren Sie die Amazon Keyspaces-Wiederholungsrichtlinie `AmazonKeyspacesExponentialRetryPolicy` anstelle der im `DefaultRetryPolicy` Cassandra-Treiber enthaltenen Richtlinie. Auf diese Weise können Sie die Anzahl der Wiederholungsversuche so konfigurieren, wie es Ihren Anforderungen entspricht. `AmazonKeyspacesExponentialRetryPolicy` Standardmäßig ist die Anzahl der Wiederholungsversuche für auf `AmazonKeyspacesExponentialRetryPolicy` 3 festgelegt. Weitere Informationen finden Sie unter [So konfigurieren Sie die Wiederholungsrichtlinie für Verbindungen in Amazon Keyspaces](connections.md#connections.retry-policies).
1. **Vorbereitete Anweisungen** — Auf „False“ setzen`prepare-on-all-nodes`, um die Netzwerknutzung zu optimieren.
```
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
}
}
}
```
**Anmerkung**
Anstatt den Pfad zum TrustStore in der Konfigurationsdatei hinzuzufügen, können Sie den TrustStore-Pfad auch direkt im Anwendungscode hinzufügen oder Sie können den Pfad zum TrustStore zu Ihren JVM-Argumenten hinzufügen.
### Schritt 3: Führen Sie die Anwendung aus
Dieses Codebeispiel zeigt eine einfache Befehlszeilenanwendung, die mithilfe der zuvor erstellten Konfigurationsdatei einen Verbindungspool zu Amazon Keyspaces erstellt. Es bestätigt, dass die Verbindung hergestellt wurde, indem eine einfache Abfrage ausgeführt wird.
```
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"));
}
}
}
```
**Anmerkung**
Verwenden Sie einen `try` Block, um die Verbindung herzustellen, um sicherzustellen, dass sie immer geschlossen ist. Wenn Sie keinen `try` Block verwenden, denken Sie daran, Ihre Verbindung zu schließen, um zu vermeiden, dass Ressourcen verloren gehen.
## Stellen Sie mithilfe des DataStax 3.x-Java-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her
Im folgenden Abschnitt wird beschrieben, wie Sie das SigV4-Authentifizierungs-Plugin für den DataStax 3.x-Open-Source-Java-Treiber für Apache Cassandra für den Zugriff auf Amazon Keyspaces verwenden. [Das Plugin ist im Repository verfügbar. GitHub ](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin/tree/3.x-Driver-Compatible)
Das SigV4-Authentifizierungs-Plugin ermöglicht es Ihnen, IAM-Anmeldeinformationen für Benutzer und Rollen zu verwenden, wenn Sie eine Verbindung zu Amazon Keyspaces herstellen. Anstatt einen Benutzernamen und ein Passwort zu benötigen, signiert dieses Plugin API-Anfragen mit Zugriffsschlüsseln. Weitere Informationen finden Sie unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
### Schritt 1: Voraussetzungen
Um dieses Codebeispiel auszuführen, müssen Sie zunächst die folgenden Aufgaben ausführen.
+ Erstellen Sie Anmeldeinformationen für Ihren IAM-Benutzer oder Ihre IAM-Rolle, indem Sie die Schritte unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md) befolgen. In dieser Anleitung wird davon ausgegangen, dass die Zugriffsschlüssel als Umgebungsvariablen gespeichert sind. Weitere Informationen finden Sie unter [Speichern Sie die Zugriffstasten für den programmatischen Zugriff](aws.credentials.manage.md).
+ Folgen Sie den Schritten unter, [Bevor Sie beginnen](#using_java_driver.BeforeYouBegin) um die digitalen Zertifikate herunterzuladen, sie in TrustStore-Dateien zu konvertieren und den Keystore in den JVM-Argumenten an Ihre Anwendung anzuhängen.
+ Fügen Sie den DataStax Java-Treiber für Apache Cassandra zu Ihrem Java-Projekt hinzu. Stellen Sie sicher, dass Sie eine Version des Treibers verwenden, die Apache Cassandra 3.11.2 unterstützt. Weitere Informationen finden Sie in der Dokumentation zum [DataStax Java-Treiber für Apache Cassandra](https://github.com/datastax/java-driver).
+ Fügen Sie das Authentifizierungs-Plugin zu Ihrer Anwendung hinzu. Das Authentifizierungs-Plugin unterstützt Version 3.x des DataStax Java-Treibers für Apache Cassandra. Wenn Sie Apache Maven oder ein Build-System verwenden, das Maven-Abhängigkeiten verwenden kann, fügen Sie Ihrer Datei die folgenden Abhängigkeiten hinzu. `pom.xml` [Ersetzen Sie die Version des Plugins durch die neueste Version, wie im GitHub Repository gezeigt.](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
```
### Schritt 2: Führen Sie die Anwendung aus
Dieses Codebeispiel zeigt eine einfache Befehlszeilenanwendung, die einen Verbindungspool zu Amazon Keyspaces erstellt. Es bestätigt, dass die Verbindung hergestellt wurde, indem eine einfache Abfrage ausgeführt wird.
```
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"));
}
}
```
Hinweise zur Verwendung:
Eine Liste der verfügbaren Endpunkte finden Sie unter[Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md).
Im folgenden Repository finden Sie hilfreiche Java-Treiberrichtlinien, Beispiele und bewährte Methoden für die Verwendung des Java-Treibers mit Amazon Keyspaces:[https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers).
# Verwenden eines Cassandra-Python-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
In diesem Abschnitt zeigen wir Ihnen, wie Sie mithilfe eines Python-Client-Treibers eine Verbindung zu Amazon Keyspaces herstellen. Um Benutzern und Anwendungen Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces-Ressourcen zur Verfügung zu stellen, können Sie einen der folgenden Schritte ausführen:
+ Erstellen Sie dienstspezifische Anmeldeinformationen, die einem bestimmten AWS Identity and Access Management (IAM-) Benutzer zugeordnet sind.
+ Aus Sicherheitsgründen empfehlen wir, IAM-Zugriffsschlüssel für IAM-Benutzer oder -Rollen zu erstellen, die für alle Dienste verwendet werden. AWS Das Amazon Keyspaces SigV4-Authentifizierungs-Plugin für Cassandra-Client-Treiber ermöglicht es Ihnen, Anrufe an Amazon Keyspaces mithilfe von IAM-Zugriffsschlüsseln anstelle von Benutzername und Passwort zu authentifizieren. Weitere Informationen finden Sie unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
**Topics**
+ [
## Bevor Sie beginnen
](#using_python_driver.BeforeYouBegin)
+ [
## Stellen Sie mithilfe des Python-Treibers für Apache Cassandra und dienstspezifische Anmeldeinformationen eine Connect zu Amazon Keyspaces her
](#python_ssc)
+ [
## Stellen Sie mithilfe des DataStax Python-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her
](#python_SigV4)
## Bevor Sie beginnen
Sie müssen die folgende Aufgabe abschließen, bevor Sie beginnen können.
Amazon Keyspaces erfordert die Verwendung von Transport Layer Security (TLS), um Verbindungen mit Clients zu sichern. Um über TLS eine Verbindung zu Amazon Keyspaces herzustellen, müssen Sie digitale Amazon-Zertifikate herunterladen und den Python-Treiber für die Verwendung von TLS konfigurieren.
Laden Sie die folgenden digitalen Zertifikate herunter und speichern Sie die Dateien lokal oder in Ihrem Home-Verzeichnis.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (optional — aus Gründen der Abwärtskompatibilität)
Um die Zertifikate herunterzuladen, können Sie die folgenden Befehle verwenden.
```
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
```
**Anmerkung**
Amazon Keyspaces verwendete zuvor TLS-Zertifikate, die in der Starfield Class 2 CA verankert waren. AWS migriert alle AWS-Regionen auf Zertifikate, die unter Amazon Trust Services (Amazon Root CAs 1—4) ausgestellt wurden. Während dieser Umstellung sollten Sie die Clients so konfigurieren, dass sie sowohl Amazon Root CAs 1—4 als auch Starfield Root vertrauen, um die Kompatibilität in allen Regionen sicherzustellen.
Kombinieren Sie alle heruntergeladenen Zertifikate in einer einzigen `pem` Datei mit dem Namen *keyspaces-bundle.pem* in unseren Beispielen. Sie erreichen dies mit dem -Befehl- Notieren Sie sich den Pfad zur Datei, den Sie später benötigen.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Stellen Sie mithilfe des Python-Treibers für Apache Cassandra und dienstspezifische Anmeldeinformationen eine Connect zu Amazon Keyspaces her
Das folgende Codebeispiel zeigt Ihnen, wie Sie mit einem Python-Client-Treiber und dienstspezifischen Anmeldeinformationen eine Verbindung zu Amazon Keyspaces herstellen.
```
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)
```
Hinweise zur Verwendung:
1. `"path_to_file/keyspaces-bundle.pem"`Ersetzen Sie durch den Pfad zur kombinierten Zertifikatsdatei, die im ersten Schritt gespeichert wurde.
1. Stellen Sie sicher, dass der Benutzername *ServiceUserName* und das Kennwort, die Sie bei der Generierung der dienstspezifischen Anmeldeinformationen erhalten haben, *ServicePassword* übereinstimmen, indem Sie die Schritte bis [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md) ausführen.
1. Eine Liste der verfügbaren Endpunkte finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md)
## Stellen Sie mithilfe des DataStax Python-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her
Der folgende Abschnitt zeigt, wie Sie das SigV4-Authentifizierungs-Plugin für den DataStax Open-Source-Python-Treiber für Apache Cassandra verwenden, um auf Amazon Keyspaces (für Apache Cassandra) zuzugreifen.
Falls Sie dies noch nicht getan haben, beginnen Sie mit der Erstellung von Anmeldeinformationen für Ihre IAM-Rolle. Folgen Sie dabei den Schritten unter. [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md) In diesem Tutorial werden temporäre Anmeldeinformationen verwendet, für die eine IAM-Rolle erforderlich ist. Weitere Informationen zu temporären Anmeldeinformationen finden Sie unter[Erstellen Sie temporäre Anmeldeinformationen, um mithilfe einer IAM-Rolle und des SigV4-Plug-ins eine Verbindung zu Amazon Keyspaces herzustellen](temporary.credentials.IAM.md).
Fügen Sie dann das Python-SigV4-Authentifizierungs-Plugin aus dem [GitHub Repository](https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin) zu Ihrer Umgebung hinzu.
```
pip install cassandra-sigv4
```
Das folgende Codebeispiel zeigt, wie Sie mithilfe des DataStax Open-Source-Python-Treibers für Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Verbindung zu Amazon Keyspaces herstellen. Das Plugin hängt vom AWS SDK for Python (Boto3) ab. Es dient `boto3.session` zum Abrufen temporärer Anmeldeinformationen.
```
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)
```
Hinweise zur Verwendung:
1. `"path_to_file/keyspaces-bundle.pem"`Ersetzen Sie es durch den Pfad zu dem Zertifikat, das im ersten Schritt gespeichert wurde.
1. Stellen Sie sicher*aws\$1access\$1key\$1id*, dass das*aws\$1secret\$1access\$1key*, und das *aws\$1session\$1token* mit dem`Access Key`, und, übereinstimmen`Secret Access Key`, das `Session Token` Sie mit erhalten haben`boto3.session`. Weitere Informationen finden Sie unter [Anmeldeinformationen](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) im *AWS SDK für Python (Boto3)*.
1. Eine Liste der verfügbaren Endpunkte finden Sie unter[Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md).
# Verwenden eines Cassandra Node.js Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
In diesem Abschnitt erfahren Sie, wie Sie mithilfe eines Node.js Client-Treibers eine Verbindung zu Amazon Keyspaces herstellen. Um Benutzern und Anwendungen Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces-Ressourcen zur Verfügung zu stellen, können Sie einen der folgenden Schritte ausführen:
+ Erstellen Sie dienstspezifische Anmeldeinformationen, die einem bestimmten AWS Identity and Access Management (IAM-) Benutzer zugeordnet sind.
+ Aus Sicherheitsgründen empfehlen wir, IAM-Zugriffsschlüssel für IAM-Benutzer oder -Rollen zu erstellen, die für alle Dienste verwendet werden. AWS Das Amazon Keyspaces SigV4-Authentifizierungs-Plugin für Cassandra-Client-Treiber ermöglicht es Ihnen, Anrufe an Amazon Keyspaces mithilfe von IAM-Zugriffsschlüsseln anstelle von Benutzername und Passwort zu authentifizieren. Weitere Informationen finden Sie unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
**Topics**
+ [
## Bevor Sie beginnen
](#using_nodejs_driver.BeforeYouBegin)
+ [
## Stellen Sie mithilfe des DataStax Treibers Node.js für Apache Cassandra und dienstspezifische Anmeldeinformationen eine Connect zu Amazon Keyspaces her
](#nodejs_ssc)
+ [
## Stellen Sie mithilfe des Treibers DataStax Node.js für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her
](#nodejs_SigV4)
## Bevor Sie beginnen
Sie müssen die folgende Aufgabe abschließen, bevor Sie beginnen können.
Amazon Keyspaces erfordert die Verwendung von Transport Layer Security (TLS), um Verbindungen mit Clients zu sichern. Um über TLS eine Verbindung zu Amazon Keyspaces herzustellen, müssen Sie ein digitales Amazon-Zertifikat herunterladen und den Python-Treiber für die Verwendung von TLS konfigurieren.
Laden Sie die folgenden digitalen Zertifikate herunter und speichern Sie die Dateien lokal oder in Ihrem Home-Verzeichnis.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (optional — aus Gründen der Abwärtskompatibilität)
Um die Zertifikate herunterzuladen, können Sie die folgenden Befehle verwenden.
```
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
```
**Anmerkung**
Amazon Keyspaces verwendete zuvor TLS-Zertifikate, die in der Starfield Class 2 CA verankert waren. AWS migriert alle AWS-Regionen auf Zertifikate, die unter Amazon Trust Services (Amazon Root CAs 1—4) ausgestellt wurden. Während dieser Umstellung sollten Sie die Clients so konfigurieren, dass sie sowohl Amazon Root CAs 1—4 als auch Starfield Root vertrauen, um die Kompatibilität in allen Regionen sicherzustellen.
Kombinieren Sie alle heruntergeladenen Zertifikate in einer einzigen `pem` Datei mit dem Namen *keyspaces-bundle.pem* in unseren Beispielen. Sie erreichen dies mit dem -Befehl- Notieren Sie sich den Pfad zur Datei, den Sie später benötigen.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Stellen Sie mithilfe des DataStax Treibers Node.js für Apache Cassandra und dienstspezifische Anmeldeinformationen eine Connect zu Amazon Keyspaces her
Konfigurieren Sie Ihren Treiber so, dass er die kombinierte Zertifikatsdatei `keyspaces-bundle.pem` für TLS verwendet und sich mit dienstspezifischen Anmeldeinformationen authentifiziert. Beispiel:
```
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}`));
```
Hinweise zur Verwendung:
1. `"path_to_file/keyspaces-bundle.pem"`Ersetzen Sie durch den Pfad zur kombinierten Zertifikatsdatei, die im ersten Schritt gespeichert wurde.
1. Stellen Sie sicher, dass der Benutzername *ServiceUserName* und das Kennwort, die Sie bei der Generierung der dienstspezifischen Anmeldeinformationen erhalten haben, *ServicePassword* übereinstimmen, indem Sie die Schritte bis [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md) ausführen.
1. Eine Liste der verfügbaren Endpunkte finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md)
## Stellen Sie mithilfe des Treibers DataStax Node.js für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her
Der folgende Abschnitt zeigt, wie Sie das SigV4-Authentifizierungs-Plugin für den Open-Source-Treiber DataStax Node.js für Apache Cassandra verwenden, um auf Amazon Keyspaces (für Apache Cassandra) zuzugreifen.
Falls Sie dies noch nicht getan haben, erstellen Sie Anmeldeinformationen für Ihren IAM-Benutzer oder Ihre IAM-Rolle, indem Sie die Schritte unter befolgen. [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md)
[Fügen Sie Ihrer Anwendung das SigV4-Authentifizierungs-Plug-In Node.js aus dem GitHub Repository hinzu.](https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin) Das Plugin unterstützt Version 4.x des DataStax Node.js -Treibers für Cassandra und ist vom AWS SDK für Node.js abhängig. Es dient `AWSCredentialsProvider` zum Abrufen von Anmeldeinformationen.
```
$ npm install aws-sigv4-auth-cassandra-plugin --save
```
Dieses Codebeispiel zeigt, wie eine regionsspezifische Instanz von `SigV4AuthProvider` als Authentifizierungsanbieter eingerichtet wird.
```
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}`));
```
Hinweise zur Verwendung:
1. `"path_to_file/keyspaces-bundle.pem"`Ersetzen Sie es durch den Pfad zu dem Zertifikat, das im ersten Schritt gespeichert wurde.
1. Stellen Sie sicher, dass der *accessKeyId* Zugriffsschlüssel und der geheime Zugriffsschlüssel, die Sie verwendet haben, *secretAccessKey* übereinstimmen`AWSCredentialsProvider`. Weitere Informationen finden Sie unter [Setting Credentials in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-node.html) im *AWS SDK oder JavaScript in Node.js*.
1. Informationen zum Speichern von Zugriffsschlüsseln außerhalb des Codes finden Sie unter Best Practices[Speichern Sie die Zugriffstasten für den programmatischen Zugriff](aws.credentials.manage.md).
1. Eine Liste der verfügbaren Endpunkte finden Sie unter[Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md).
# Verwenden eines Cassandra.NET-Core-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
In diesem Abschnitt erfahren Sie, wie Sie mithilfe eines .NET Core-Client-Treibers eine Verbindung zu Amazon Keyspaces herstellen. Die Einrichtungsschritte variieren je nach Umgebung und Betriebssystem. Möglicherweise müssen Sie sie entsprechend ändern. Amazon Keyspaces erfordert die Verwendung von Transport Layer Security (TLS), um Verbindungen mit Clients zu sichern. Um über TLS eine Verbindung zu Amazon Keyspaces herzustellen, konfigurieren Sie Ihren Treiber so, dass er den System Trust Store verwendet, der Amazon Root CAs 1-4 enthält.
1. Installieren Sie den CSharp Cassandra-Treiber mithilfe der Nuget-Konsole über Nuget.
```
PM> Install-Package CassandraCSharpDriver
```
1. Im folgenden Beispiel wird ein .NET Core C\$1-Konsolenprojekt verwendet, um eine Verbindung zu Amazon Keyspaces herzustellen und eine Abfrage auszuführen.
```
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);
}
}
}
}
```
Hinweise zur Verwendung:
1. Stellen Sie sicher, dass Sie den standardmäßigen System Trust Store verwenden, der Amazon Root CAs 1-4 enthält.
1. Stellen Sie sicher, dass der Benutzername *ServiceUserName* und das Passwort, die Sie bei der Generierung der dienstspezifischen Anmeldeinformationen erhalten haben, *ServicePassword* übereinstimmen, indem Sie die Schritte unter befolgen. [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md)
1. Eine Liste der verfügbaren Endpunkte finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md)
# Verwenden eines Cassandra Go-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
In diesem Abschnitt erfahren Sie, wie Sie mithilfe eines Go Cassandra-Client-Treibers eine Verbindung zu Amazon Keyspaces herstellen. Um Benutzern und Anwendungen Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces-Ressourcen zur Verfügung zu stellen, können Sie einen der folgenden Schritte ausführen:
+ Erstellen Sie dienstspezifische Anmeldeinformationen, die einem bestimmten AWS Identity and Access Management (IAM-) Benutzer zugeordnet sind.
+ Aus Sicherheitsgründen empfehlen wir, IAM-Zugriffsschlüssel für IAM-Prinzipale zu erstellen, die für alle Dienste verwendet werden. AWS Das Amazon Keyspaces SigV4-Authentifizierungs-Plugin für Cassandra-Client-Treiber ermöglicht es Ihnen, Anrufe an Amazon Keyspaces mithilfe von IAM-Zugriffsschlüsseln anstelle von Benutzername und Passwort zu authentifizieren. Weitere Informationen finden Sie unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
**Topics**
+ [
## Bevor Sie beginnen
](#using_go_driver.BeforeYouBegin)
+ [
## Stellen Sie mithilfe des Gocql-Treibers für Apache Cassandra und dienstspezifische Anmeldeinformationen eine Connect zu Amazon Keyspaces her
](#go_ssc)
+ [
## Stellen Sie mithilfe des Go-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her
](#go_SigV4)
## Bevor Sie beginnen
Sie müssen die folgende Aufgabe abschließen, bevor Sie beginnen können.
Amazon Keyspaces erfordert die Verwendung von Transport Layer Security (TLS), um Verbindungen mit Clients zu sichern. Um über TLS eine Verbindung zu Amazon Keyspaces herzustellen, müssen Sie ein digitales Amazon-Zertifikat herunterladen und den Go-Treiber für die Verwendung von TLS konfigurieren.
Laden Sie die folgenden digitalen Zertifikate herunter und speichern Sie die Dateien lokal oder in Ihrem Home-Verzeichnis.
1. AmazonRootCA1
1. AmazonRootCA2
1. AmazonRootCA3
1. AmazonRootCA4
1. Starfield Class 2 Root (optional — aus Gründen der Abwärtskompatibilität)
Um die Zertifikate herunterzuladen, können Sie die folgenden Befehle verwenden.
```
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
```
**Anmerkung**
Amazon Keyspaces verwendete zuvor TLS-Zertifikate, die in der Starfield Class 2 CA verankert waren. AWS migriert alle AWS-Regionen auf Zertifikate, die unter Amazon Trust Services (Amazon Root CAs 1—4) ausgestellt wurden. Während dieser Umstellung sollten Sie die Clients so konfigurieren, dass sie sowohl Amazon Root CAs 1—4 als auch Starfield Root vertrauen, um die Kompatibilität in allen Regionen sicherzustellen.
Kombinieren Sie alle heruntergeladenen Zertifikate in einer einzigen `pem` Datei mit dem Namen *keyspaces-bundle.pem* in unseren Beispielen. Sie erreichen dies mit dem -Befehl- Notieren Sie sich den Pfad zur Datei, den Sie später benötigen.
```
cat AmazonRootCA1.pem \
AmazonRootCA2.pem \
AmazonRootCA3.pem \
AmazonRootCA4.pem \
sf-class2-root.crt \
> keyspaces-bundle.pem
```
## Stellen Sie mithilfe des Gocql-Treibers für Apache Cassandra und dienstspezifische Anmeldeinformationen eine Connect zu Amazon Keyspaces her
1. Erstellen Sie ein Verzeichnis für die Anwendung.
```
mkdir ./gocqlexample
```
1. Navigieren Sie zum neuen Verzeichnis.
```
cd gocqlexample
```
1. Erstellen Sie eine Datei für Ihre Anwendung.
```
touch cqlapp.go
```
1. Laden Sie den Go-Treiber herunter.
```
go get github.com/gocql/gocql
```
1. Fügen Sie der Datei cqlapp.go den folgenden Beispielcode hinzu.
```
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()
}
```
Hinweise zur Verwendung:
1. `"path_to_file/keyspaces-bundle.pem"`Ersetzen Sie durch den Pfad zur kombinierten Zertifikatsdatei, die im ersten Schritt gespeichert wurde.
1. Stellen Sie sicher, dass der Benutzername *ServiceUserName* und das Kennwort, die Sie bei der Generierung der dienstspezifischen Anmeldeinformationen erhalten haben, *ServicePassword* übereinstimmen, indem Sie die Schritte bis [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md) ausführen.
1. Eine Liste der verfügbaren Endpunkte finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md)
1. Erstellen Sie das Programm.
```
go build cqlapp.go
```
1. Führen Sie das Programm aus.
```
./cqlapp
```
## Stellen Sie mithilfe des Go-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her
Das folgende Codebeispiel zeigt, wie Sie das SigV4-Authentifizierungs-Plugin für den Open-Source-Go-Treiber verwenden, um auf Amazon Keyspaces (für Apache Cassandra) zuzugreifen.
Falls Sie dies noch nicht getan haben, erstellen Sie Anmeldeinformationen für Ihren IAM-Principal, indem Sie die Schritte unter befolgen. [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md) Wenn eine Anwendung auf Lambda oder einer Amazon EC2 EC2-Instance ausgeführt wird, verwendet Ihre Anwendung automatisch die Anmeldeinformationen der Instance. Um dieses Tutorial lokal auszuführen, können Sie die Anmeldeinformationen als lokale Umgebungsvariablen speichern.
Fügen Sie das Go SigV4-Authentifizierungs-Plugin aus dem [GitHubRepository](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin) zu Ihrer Anwendung hinzu. Das Plugin unterstützt Version 1.2.x des Open-Source-Go-Treibers für Cassandra und hängt vom SDK for Go ab. AWS
```
$ go mod init
$ go get github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin
```
In diesem Codebeispiel wird der Amazon Keyspaces-Endpunkt durch die `Cluster` Klasse repräsentiert. Es verwendet die Eigenschaft `AwsAuthenticator` for the authenticator des Clusters, um Anmeldeinformationen abzurufen.
```
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)
}
}
```
Hinweise zur Verwendung:
1. `"path_to_file/keyspaces-bundle.pem"`Ersetzen Sie durch den Pfad zur Zertifikatsdatei, die im ersten Schritt gespeichert wurde.
1. Damit dieses Beispiel lokal ausgeführt werden kann, müssen Sie die folgenden Variablen als Umgebungsvariablen definieren:
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_DEFAULT_REGION`
1. Informationen zum Speichern von Zugriffsschlüsseln außerhalb des Codes finden Sie unter Best Practices[Speichern Sie die Zugriffstasten für den programmatischen Zugriff](aws.credentials.manage.md).
1. Eine Liste der verfügbaren Endpunkte finden Sie unter[Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md).
# Verwenden eines Cassandra Perl-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces
In diesem Abschnitt erfahren Sie, wie Sie mithilfe eines Perl-Client-Treibers eine Verbindung zu Amazon Keyspaces herstellen. Für dieses Codebeispiel haben wir Perl 5 verwendet. Amazon Keyspaces erfordert die Verwendung von Transport Layer Security (TLS), um Verbindungen mit Clients zu sichern.
**Wichtig**
Amazon Keyspaces-Zertifikate werden in die Amazon Trust Services (ATS) -Hierarchie umgewandelt. Stellen Sie sicher, dass Ihre Umgebung Amazon Root CAs 1—4 vertraut, um Verbindungsfehler während dieser Rotation zu vermeiden. Der Perl-Treiber validiert das Amazon SSL-Zertifikat des Servers nicht, was bedeutet, dass Sie nicht bestätigen können, dass Sie eine Verbindung zu Amazon Keyspaces herstellen. Der zweite Schritt, die Konfiguration des Treibers für die Verwendung von TLS bei der Verbindung zu Amazon Keyspaces, ist weiterhin erforderlich und stellt sicher, dass die zwischen dem Client und dem Server übertragenen Daten verschlüsselt werden.
1. Laden Sie den Cassandra DBI-Treiber von herunter [https://metacpan.org/pod/DBD::Cassandra](https://metacpan.org/pod/DBD::Cassandra) und installieren Sie ihn in Ihrer Perl-Umgebung. Die genauen Schritte hängen von der Umgebung ab. Das Folgende ist ein gängiges Beispiel.
```
cpanm DBD::Cassandra
```
1. Erstellen Sie eine Datei für Ihre Anwendung.
```
touch cqlapp.pl
```
1. Fügen Sie der Datei cqlapp.pl den folgenden Beispielcode hinzu.
```
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;
```
**Wichtig**
Stellen Sie sicher, dass die *ServiceUserName* und *ServicePassword* mit dem Benutzernamen und dem Passwort übereinstimmen, die Sie bei der Generierung der dienstspezifischen Anmeldeinformationen erhalten haben, indem Sie die Schritte bis ausführen. [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md)
**Anmerkung**
Eine Liste der verfügbaren Endpunkte finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md)
1. Führen Sie die Anwendung aus.
```
perl cqlapp.pl
```