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.
# Zugreifen auf Amazon Keyspaces (für Apache Cassandra)
Sie können über die Konsole auf Amazon Keyspaces zugreifen, programmgesteuert AWS CloudShell, indem Sie einen `cqlsh` Client, das AWS SDK ausführen oder einen für Apache 2.0 lizenzierten Cassandra-Treiber verwenden. Amazon Keyspaces unterstützt Treiber und Clients, die mit Apache Cassandra 3.11.2 kompatibel sind. Bevor Sie auf Amazon Keyspaces zugreifen können, müssen Sie die Einrichtung abschließen AWS Identity and Access Management und dann Amazon Keyspaces eine IAM-Identität gewähren.
## Einrichten AWS Identity and Access Management
### Melden Sie sich an für ein AWS-Konto
Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.
**Um sich für eine anzumelden AWS-Konto**
1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)
1. Folgen Sie den Online-Anweisungen.
Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Sie können Ihre aktuellen Kontoaktivitäten jederzeit einsehen und Ihr Konto verwalten, indem Sie zu [https://aws.amazon.com/](https://aws.amazon.com/)gehen und **Mein Konto** auswählen.
### Erstellen eines Benutzers mit Administratorzugriff
Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.
**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**
1. Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.
Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.
1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.
Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.
**Erstellen eines Benutzers mit Administratorzugriff**
1. Aktivieren Sie das IAM Identity Center.
Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.
*Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *
**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.
Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).
**Weiteren Benutzern Zugriff zuweisen**
1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.
Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.
Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
## Amazon Keyspaces einrichten
Der Zugriff auf Amazon Keyspaces-Ressourcen wird mithilfe von [IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) verwaltet. Mit IAM können Sie Richtlinien an IAM-Benutzer, -Rollen und föderierte Identitäten anhängen, die Lese- und Schreibberechtigungen für bestimmte Ressourcen in Amazon Keyspaces gewähren.
Um mit der Erteilung von Berechtigungen für eine IAM-Identität zu beginnen, können Sie eine der AWS verwalteten Richtlinien für Amazon Keyspaces verwenden:
+ [AmazonKeyspacesFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesFullAccess.html)— Diese Richtlinie gewährt Berechtigungen für den Zugriff auf alle Ressourcen in Amazon Keyspaces mit vollem Zugriff auf alle Funktionen.
+ [AmazonKeyspacesReadOnlyAccess\$1v2](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesReadOnlyAccess_v2.html) — Diese Richtlinie gewährt Amazon Keyspaces nur Leseberechtigungen.
Eine ausführliche Erläuterung der in den verwalteten Richtlinien definierten Aktionen finden Sie unter. [AWS verwaltete Richtlinien für Amazon Keyspaces](security-iam-awsmanpol.md)
Um den Umfang der Aktionen, die eine IAM-Identität ausführen kann, oder die Ressourcen einzuschränken, auf die die Identität zugreifen kann, können Sie eine benutzerdefinierte Richtlinie erstellen, die die `AmazonKeyspacesFullAccess` verwaltete Richtlinie als Vorlage verwendet, und alle nicht benötigten Berechtigungen entfernen. Sie können den Zugriff auch auf bestimmte Schlüsselbereiche oder Tabellen einschränken. Weitere Informationen darüber, wie Sie Aktionen einschränken oder den Zugriff auf bestimmte Ressourcen in Amazon Keyspaces einschränken können, finden Sie unter[So funktioniert Amazon Keyspaces mit IAM](security_iam_service-with-iam.md).
Um auf Amazon Keyspaces zuzugreifen, nachdem Sie die Richtlinie erstellt AWS-Konto und erstellt haben, die einer IAM-Identität Zugriff auf Amazon Keyspaces gewährt, fahren Sie mit einem der folgenden Abschnitte fort:
+ [Verwenden der Konsole](console_keyspaces.md)
+ [Verwenden AWS CloudShell](using-aws-with-cloudshell.md)
# Zugreifen auf Amazon Keyspaces über die Konsole
Sie können auf die Konsole für Amazon Keyspaces unter [https://console.aws.amazon.com/keyspaces/home](https://console.aws.amazon.com/keyspaces/home) zugreifen. Weitere Informationen zum AWS-Managementkonsole Zugriff finden Sie unter [Steuern des Zugriffs von IAM-Benutzern auf das AWS-Managementkonsole](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_controlling-access.html) im IAM-Benutzerhandbuch.
Sie können die Konsole verwenden, um in Amazon Keyspaces Folgendes zu tun:
+ Schlüsselräume und Tabellen erstellen, löschen und verwalten.
+ Überwachen Sie wichtige Tabellenmetriken auf der Registerkarte **Überwachen** einer Tabelle:
+ Größe der fakturierbaren Tabelle (Byte)
+ Kapazitätskennzahlen
+ Führen Sie Abfragen mit dem CQL-Editor oder über die [integrierte AWS CloudShell Benutzeroberfläche](console_cloudshell_integration.md) aus, z. B. Daten einfügen, aktualisieren und löschen.
+ Stellen Sie über die integrierte CQLSH-Unterstützung eine direkte Connect AWS CloudShell zu Amazon Keyspaces her.
+ Ändern Sie die Partitionierungskonfiguration des Kontos.
+ Sehen Sie sich die Leistungs- und Fehlermetriken für das Konto im Dashboard an.
# Stellen Sie über die Konsole eine Connect zu Amazon Keyspaces AWS CloudShell her
AWS CloudShell bietet eine optimierte Möglichkeit, direkt von der Konsole aus eine Verbindung zu Amazon Keyspaces herzustellen. Die AWS CloudShell Integration initialisiert das automatisch `cqlsh-expansion` für Sie und stellt eine Verbindung zu einem bestimmten Schlüsselraum her.
## Erste Schritte mit der Integration AWS CloudShell
1. **Auf die AWS CloudShell Integration zugreifen** — Navigieren Sie in der Amazon Keyspaces-Konsole zu dem Keyspace, zu dem Sie Connect möchten, und wählen Sie die Schaltfläche Mit ** AWS CloudShell Keyspaces verbinden**.
1. **Vorausgefüllter Setup-Befehl** — Wenn Sie AWS CloudShell auf die Schaltfläche klicken, stellt das System einen vorausgefüllten Befehl bereit, der die erforderlichen Initialisierungs- und Verbindungsparameter enthält:
```
cqlsh-expansion.init ; cqlsh-expansion cassandra.region.amazonaws.com 9142 --ssl -my_keyspace
```
1. ****Klicken Sie auf Ausführen****
1. **Warten Sie, bis Amazon Keyspaces die Verbindung hergestellt** hat — Warten Sie, bis der Einrichtungsvorgang abgeschlossen und die Verbindung zu Ihrem ausgewählten Keyspace hergestellt ist.
1. **Befehle ausführen** — Wenn eine Verbindung hergestellt ist, können Sie CQL-Befehle direkt für den ausgewählten Schlüsselraum schreiben und ausführen.
## Verfügbare CQLSH-Befehle
Die AWS CloudShell Integration bietet Zugriff auf die Standard-CQLSH-Funktionalität, einschließlich der Unterstützung von Befehlen, die über die grundlegende CQL-Funktionalität hinausgehen.
+ **Beschreiben** — Listet detaillierte Beschreibungen von Schlüsselräumen und Tabellen auf und zeigt sie an.
+ **Kopieren** — Exportiert die Abfrageausgabe zur späteren Verarbeitung in eine Datei.
+ **Quelle** — Führt CQL-Anweisungen aus einer Datei aus.
+ **Navigation im Befehlsverlauf** — Scrollen Sie mithilfe von Tastenkombinationen durch vorherige Befehle.
+ **Ausführung von Abfragen** — Führen Sie Abfragen direkt über die Tastaturschnittstelle aus.
+ **Kopieren von Ausgaben — Kopiert** die Ergebnisse als einfachen Text zur Verwendung in anderen Anwendungen.
## Überlegungen zu Funktionen
Beachten Sie bei der Verwendung der AWS CloudShell Integration die folgenden Kompromisse.
**Die folgenden Funktionen werden nicht unterstützt:**
+ Vorschläge zur CQL-Syntax und Funktionen zur automatischen Vervollständigung.
+ Editor-Tools wie Autovervollständigung anzeigen, QuickInfo anzeigen, Suchen, Suchen und Ersetzen, Wiederherstellen, Umschalten von Blockkommentaren, Umschalten des Codes, Umschalten von Zeilenkommentaren und Rückgängig machen.
**Geänderte Funktionalität:**
+ **CSV-Downloads** — Um Ergebnisse im CSV-Format herunterzuladen, geben Sie den `>` Operator an, der die Befehlsausgabe weiterleitet:
```
SELECT * FROM my_table > file_name.csv
```
+ **JSON-Anzeige** — Sie können Elemente im JSON-Format anzeigen, ohne dass eine Datenkonvertierung erforderlich ist.
+ **Schnittstelle im Terminal-Stil** — Das Erlebnis funktioniert eher als Terminalschnittstelle als als Code-Editor mit vollem Funktionsumfang.
Die AWS CloudShell Integration vereinfacht den Verbindungsprozess und bietet gleichzeitig wichtige CQL-Funktionen für die Verwaltung Ihrer Amazon Keyspaces-Daten direkt vom. AWS-Managementkonsole
Informationen dazu, wie Sie einen Amazon Keyspaces-Schlüsselraum und eine Tabelle erstellen und mit Beispielanwendungsdaten einrichten, finden Sie unter. [Erste Schritte mit Amazon Keyspaces (für Apache Cassandra)](getting-started.md)
# Für AWS CloudShell den Zugriff auf Amazon Keyspaces verwenden
AWS CloudShell ist eine browserbasierte, vorauthentifizierte Shell, die Sie direkt von der aus starten können. AWS-Managementkonsole Sie können AWS CLI Befehle für AWS Dienste mit Ihrer bevorzugten Shell (Bash PowerShell oder Z-Shell) ausführen. AWS CloudShell wird mit Ihren Konsolenanmeldedaten vorauthentifiziert geliefert und enthält allgemeine Tools für die Arbeit mit AWS Diensten AWS CLI, darunter Python und Node.js.
Sie [starten AWS CloudShell von der aus AWS-Managementkonsole](https://docs.aws.amazon.com/cloudshell/latest/userguide/working-with-cloudshell.html#launch-options), und die AWS Anmeldeinformationen, mit denen Sie sich an der Konsole angemeldet haben, sind automatisch in einer neuen Shell-Sitzung verfügbar. Diese Vorauthentifizierung von AWS CloudShell Benutzern ermöglicht es Ihnen, die Konfiguration von Anmeldeinformationen zu überspringen, wenn Sie mit AWS Diensten wie Amazon Keyspaces interagieren, die `cqlsh` oder AWS CLI Version 2 (in der Computerumgebung der Shell vorinstalliert) verwenden.
## AWS CloudShell Integrationsoptionen
Amazon Keyspaces bietet zwei AWS CloudShell Nutzungsmöglichkeiten:
1. **Integriertes AWS CloudShell Erlebnis** — Eine optimierte Verbindungsmethode, die direkt in der Amazon Keyspaces-Konsole verfügbar ist und die automatisch initialisiert `cqlsh-expansion` und eine Verbindung zu einem bestimmten Schlüsselraum herstellt. Vollständige Anweisungen zur Nutzung dieses integrierten Erlebnisses finden Sie unter. [Stellen Sie über die Konsole eine Connect zu Amazon Keyspaces AWS CloudShell her](console_cloudshell_integration.md)
1. **Manuelles AWS CloudShell Setup** — Manuelles Installieren und Konfigurieren `cqlsh` in AWS CloudShell. Die Schritte werden in den folgenden Abschnitten beschrieben und bieten mehr Kontrolle über den Einrichtungsprozess und ermöglichen benutzerdefinierte Konfigurationen.
## Voraussetzungen
Bevor Sie Amazon Keyspaces mit verwenden AWS CloudShell, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Ein AWS Konto mit Zugriff auf Amazon Keyspaces und AWS CloudShell
+ Entsprechende IAM-Berechtigungen zur Nutzung beider Dienste
+ Grundkenntnisse in Cassandra Query Language (CQL)
## Erste Schritte mit AWS CloudShell
Um darauf zuzugreifen AWS CloudShell:
1. Melden Sie sich an bei AWS-Managementkonsole
1. Wählen Sie zum Starten AWS CloudShell das AWS CloudShell Symbol in der Navigationsleiste oben in der Konsole oder navigieren Sie zu [https://console.aws.amazon.com/cloudshell/](https://console.aws.amazon.com/cloudshell/)
1. Warten Sie, bis die AWS CloudShell Umgebung initialisiert ist
## Einholen von IAM-Berechtigungen für AWS CloudShell
Mithilfe der von bereitgestellten Ressourcen zur Zugriffsverwaltung können Administratoren IAM-Benutzern Berechtigungen erteilen AWS Identity and Access Management, sodass sie auf die Funktionen der Umgebung zugreifen AWS CloudShell und diese nutzen können.
Am schnellsten kann ein Administrator Benutzern Zugriff gewähren, indem er eine AWS verwaltete Richtlinie verwendet. Bei einer [von AWS verwalteten Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) handelt es sich um eine eigenständige Richtlinie, die von AWS erstellt und verwaltet wird. Die folgende AWS verwaltete Richtlinie für CloudShell kann an IAM-Identitäten angehängt werden:
+ `AWSCloudShellFullAccess`: Erteilt die Erlaubnis zur Nutzung AWS CloudShell mit vollem Zugriff auf alle Funktionen.
Wenn Sie den Umfang der Aktionen einschränken möchten, die ein IAM-Benutzer ausführen kann AWS CloudShell, können Sie eine benutzerdefinierte Richtlinie erstellen, die die `AWSCloudShellFullAccess` verwaltete Richtlinie als Vorlage verwendet. Weitere Informationen zur Einschränkung der Aktionen, die Benutzern zur Verfügung stehen CloudShell, finden Sie im *AWS CloudShell Benutzerhandbuch* unter [Verwaltung von AWS CloudShell Zugriff und Nutzung mit IAM-Richtlinien](https://docs.aws.amazon.com/cloudshell/latest/userguide/sec-auth-with-identities.html).
**Anmerkung**
Für Ihre IAM-Identität ist auch eine Richtlinie erforderlich, die die Erlaubnis erteilt, Amazon Keyspaces aufzurufen.
Sie können eine AWS verwaltete Richtlinie verwenden, um Ihrer IAM-Identität Zugriff auf Amazon Keyspaces zu gewähren, oder Sie können mit der verwalteten Richtlinie als Vorlage beginnen und die Berechtigungen entfernen, die Sie nicht benötigen. Sie können den Zugriff auch auf bestimmte Schlüsselbereiche und Tabellen einschränken, um eine benutzerdefinierte Richtlinie zu erstellen. Die folgende verwaltete Richtlinie für Amazon Keyspaces kann an IAM-Identitäten angehängt werden:
+ [AmazonKeyspacesFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonKeyspacesFullAccess.html)— Diese Richtlinie gewährt die Erlaubnis zur Nutzung von Amazon Keyspaces mit vollem Zugriff auf alle Funktionen.
Eine ausführliche Erläuterung der in der verwalteten Richtlinie definierten Aktionen finden Sie unter[AWS verwaltete Richtlinien für Amazon Keyspaces](security-iam-awsmanpol.md).
Weitere Informationen darüber, wie Sie Aktionen einschränken oder den Zugriff auf bestimmte Ressourcen in Amazon Keyspaces einschränken können, finden Sie unter[So funktioniert Amazon Keyspaces mit IAM](security_iam_service-with-iam.md).
## Den Cqlsh-Client installieren
AWS CloudShell wird nicht vorinstalliert geliefert`cqlsh`. Sie müssen es installieren, um mit Amazon Keyspaces zu interagieren. Sie können die Amazon KeySpaces-spezifische Version von installieren. `cqlsh` `cqlsh-expansion`Installationsanweisungen finden Sie unter. [Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md#using_cqlsh)
## Konfiguration von TLS-Zertifikaten
Um über eine TLS-Verbindung eine Verbindung zu Amazon Keyspaces herzustellen, müssen Sie die erforderlichen digitalen Amazon-Zertifikate herunterladen. Detaillierte Anweisungen zum Herunterladen und Konfigurieren des SSL-Zertifikats finden Sie unter[Wie konfiguriert man `cqlsh` Verbindungen für TLS manuell](programmatic.cqlsh.md#encrypt_using_tls).
## Verbindung zu Amazon Keyspaces herstellen
Sie können entweder mit IAM-Anmeldeinformationen (empfohlen) oder dienstspezifischen Anmeldeinformationen eine Verbindung zu Amazon Keyspaces herstellen.
### Verbindung mit IAM-Anmeldeinformationen herstellen (empfohlen)
AWS CloudShell ist bereits mit Ihren IAM-Anmeldeinformationen authentifiziert. Um mit diesen Anmeldeinformationen eine Verbindung herzustellen, können Sie das SigV4-Authentifizierungs-Plugin verwenden. Ausführliche Anweisungen zur Verwendung von IAM-Anmeldeinformationen mit finden Sie `cqlsh` unter. [Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md#using_cqlsh)
### Verbindung mit dienstspezifischen Anmeldeinformationen herstellen
Wenn Sie dienstspezifische Anmeldeinformationen für Amazon Keyspaces erstellt haben, können Sie diese für die Verbindung verwenden. Informationen zum Erstellen und Verwenden von dienstspezifischen Anmeldeinformationen finden Sie unter. [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md)
## Verwenden von CQLSH mit Amazon Keyspaces
Wenn eine Verbindung hergestellt ist, können Sie standardmäßige CQL-Befehle verwenden, um mit Ihren Keyspaces und Tabellen zu interagieren. Ausführliche Informationen zu unterstützten CQL-Befehlen und -Vorgängen finden Sie unter. [Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md#using_cqlsh)
## Dauerhafte Daten in AWS CloudShell
AWS CloudShell stellt 1 GB persistenten Speicher in Ihrem Home-Verzeichnis bereit. Das bedeutet, dass Skripts, Zertifikate und Konfigurationsdateien, die Sie erstellen, sitzungsübergreifend verfügbar bleiben. Sie können eine Konfigurationsdatei erstellen`cqlsh`, um Verbindungen zu vereinfachen.
Mit einer Konfigurationsdatei können Sie ausführen, `cqlsh` ohne zusätzliche Parameter angeben zu müssen. Weitere Hinweise zum Erstellen und Verwenden von `cqlsh` Konfigurationsdateien finden Sie unter[Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md#using_cqlsh).
## Best Practices
Bei der Verwendung von Amazon Keyspaces mit AWS CloudShell empfehlen wir die folgenden bewährten Methoden:
+ Erstellen Sie Skripts für sich wiederholende Aufgaben und speichern Sie sie in Ihrem persistenten Home-Verzeichnis.
+ Verwenden Sie Umgebungsvariablen für vertrauliche Informationen, anstatt sie fest zu codieren.
+ Denken Sie daran, dass AWS CloudShell Sitzungen nach Inaktivität zu einem Timeout führen können.
+ Beachten Sie die AWS CloudShell Servicequotas und -beschränkungen.
+ Erwägen Sie die Verwendung von AWS CLI für automatisierte Operationen mit Amazon Keyspaces.
## Fehlerbehebung
Wenn Sie Probleme haben, eine Verbindung zu Amazon Keyspaces herzustellen von AWS CloudShell:
+ Stellen Sie sicher, dass Ihre IAM-Berechtigungen die erforderlichen Amazon Keyspaces-Aktionen beinhalten.
+ Stellen Sie sicher, dass Sie den richtigen Endpunkt für Ihre Region verwenden.
+ Vergewissern Sie sich, dass die SSL-Zertifikate korrekt heruntergeladen und referenziert wurden.
+ Stellen Sie sicher, dass Ihre dienstspezifischen Anmeldeinformationen korrekt und nicht abgelaufen sind.
+ Wenn Sie eine cqlshrc-Datei verwenden, überprüfen Sie deren Formatierung und Berechtigungen.
## Beispiel: So interagieren Sie mit Amazon Keyspaces mithilfe von AWS CloudShell
Nachdem Sie AWS CloudShell von der aus gestartet haben AWS-Managementkonsole, können Sie sofort mit der Interaktion mit Amazon Keyspaces beginnen, indem Sie `cqlsh` oder die Befehlszeilenschnittstelle verwenden. Falls Sie das noch nicht installiert haben`cqlsh-expansion`, finden Sie detaillierte [Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md#using_cqlsh) Anweisungen unter.
**Anmerkung**
Wenn Sie den `cqlsh-expansion` in verwenden AWS CloudShell, müssen Sie keine Anmeldeinformationen konfigurieren, bevor Sie Anrufe tätigen, da Sie bereits in der Shell authentifiziert sind.
**Connect zu Amazon Keyspaces her und erstellen Sie einen neuen Keyspace. Lesen Sie dann aus einer Systemtabelle, um zu bestätigen, dass der Schlüsselraum erstellt wurde mit AWS CloudShell**
1. Von der aus können Sie starten AWS-Managementkonsole, CloudShell indem Sie die folgenden Optionen auswählen, die in der Navigationsleiste verfügbar sind:
+ Wählen Sie das CloudShell Symbol.
+ Beginnen Sie mit der Eingabe `cloudshell` in das Suchfeld und wählen Sie dann die CloudShell Option.
1. Mit dem folgenden Befehl können Sie eine Verbindung zu Amazon Keyspaces herstellen. Stellen Sie sicher, dass Sie `cassandra.us-east-1.amazonaws.com` durch den richtigen Endpunkt für Ihre Region ersetzen.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Wenn die Verbindung erfolgreich ist, sollten Sie eine Ausgabe sehen, die dem folgenden Beispiel ähnelt.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
cqlsh>
```
1. Erstellen Sie einen neuen Schlüsselraum mit dem Namen`mykeyspace`. Sie können dazu den folgenden Befehl verwenden.
```
CREATE KEYSPACE mykeyspace WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
1. Um zu bestätigen, dass der Schlüsselraum erstellt wurde, können Sie mit dem folgenden Befehl aus einer Systemtabelle lesen.
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
Wenn der Aufruf erfolgreich ist, zeigt die Befehlszeile eine Antwort des Services an, die der folgenden Ausgabe ähnelt:
```
keyspace_name | durable_writes | replication
----------------+----------------+-------------------------------------------------------------------------------------
mykeyspace | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(1 rows)
```
# Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen
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 dem herkömmlichen Benutzernamen und Passwort ähneln, die Cassandra für die Authentifizierung und Zugriffsverwaltung verwendet. AWS dienstspezifische Anmeldeinformationen sind einem bestimmten AWS Identity and Access Management (IAM-) Benutzer zugeordnet und können nur für den Dienst verwendet werden, für den sie erstellt wurden. Weitere Informationen finden Sie unter [Using IAM with Amazon Keyspaces (für Apache Cassandra)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_keyspaces.html) im IAM-Benutzerhandbuch.
**Warnung**
IAM-Benutzer verfügen über langfristige Anmeldeinformationen, was ein Sicherheitsrisiko darstellt. Um dieses Risiko zu minimieren, empfehlen wir, diesen Benutzern nur die Berechtigungen zu gewähren, die sie für die Ausführung der Aufgabe benötigen, und diese Benutzer zu entfernen, wenn sie nicht mehr benötigt werden.
+ Aus Sicherheitsgründen empfehlen wir, IAM-Identitäten zu erstellen, die für alle AWS Dienste verwendet werden, und temporäre Anmeldeinformationen zu verwenden. 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 darüber, wie das Amazon Keyspaces SigV4-Plugin es [IAM-Benutzern, -Rollen und föderierten Identitäten ermöglicht,](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) sich in Amazon Keyspaces-API-Anfragen zu authentifizieren, finden Sie unter [AWS Signature](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) Version 4-Prozess (Sigv4).
Sie können die SigV4-Plugins von den folgenden Orten herunterladen.
+ Java:[https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin](https://github.com/aws/aws-sigv4-auth-cassandra-java-driver-plugin).
+ Node.js:[https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin](https://github.com/aws/aws-sigv4-auth-cassandra-nodejs-driver-plugin).
+ Python: [https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin](https://github.com/aws/aws-sigv4-auth-cassandra-python-driver-plugin).
+ Geh:[https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin](https://github.com/aws/aws-sigv4-auth-cassandra-gocql-driver-plugin).
Codebeispiele, die zeigen, wie Verbindungen mithilfe des SigV4-Authentifizierungs-Plug-ins hergestellt werden, finden Sie unter[Verwenden eines Cassandra-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces](programmatic.drivers.md).
**Topics**
+ [Erstellen Sie dienstspezifische Anmeldeinformationen](programmatic.credentials.ssc.md)
+ [Erstellen Sie IAM-Anmeldeinformationen für die Authentifizierung AWS](access.credentials.md)
# Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen
Dienstspezifische Anmeldeinformationen ähneln dem herkömmlichen Benutzernamen und Passwort, die Cassandra für die Authentifizierung und Zugriffsverwaltung verwendet. Dienstspezifische Anmeldeinformationen ermöglichen IAM-Benutzern den Zugriff auf einen bestimmten Dienst. AWS Diese langfristigen Anmeldeinformationen können nicht für den Zugriff auf andere AWS Dienste verwendet werden. Sie sind einem bestimmten IAM-Benutzer zugeordnet und können nicht von anderen IAM-Benutzern verwendet werden.
**Wichtig**
Servicespezifische Anmeldeinformationen sind langfristige Anmeldeinformationen, die einem bestimmten IAM-Benutzer zugeordnet sind und nur für den Service verwendet werden können, für den sie erstellt wurden. Um IAM-Rollen oder föderierten Identitäten Berechtigungen für den Zugriff auf all Ihre AWS Ressourcen mit temporären Anmeldeinformationen zu erteilen, sollten Sie die [AWS Authentifizierung mit dem SigV4-Authentifizierungs-Plugin](access.credentials.md) für Amazon Keyspaces verwenden.
Verwenden Sie eines der folgenden Verfahren, um dienstspezifische Anmeldeinformationen zu generieren.
------
#### [ Console ]
**Erstellen Sie dienstspezifische Anmeldeinformationen mithilfe der Konsole**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Identity and Access Management Konsole unter[https://console.aws.amazon.com/iam/home](https://console.aws.amazon.com/iam/home).
1. Wählen Sie im Navigationsbereich Benutzer und dann den **Benutzer** aus, den Sie zuvor erstellt haben und der über Amazon Keyspaces-Berechtigungen verfügt (Richtlinie beigefügt).
1. Wählen Sie **Security Credentials (Sicherheitsanmeldeinformationen)** aus. Wählen Sie unter **Anmeldeinformationen für Amazon Keyspaces** die Option **Anmeldeinformationen generieren aus, um die dienstspezifischen Anmeldeinformationen** zu generieren.
Ihre servicespezifischen Anmeldeinformationen sind nun verfügbar. Dies ist das einzige Mal, dass Sie das Passwort herunterladen oder anzeigen können. Später kann er nicht mehr wiederhergestellt werden. Sie können Ihr Passwort jedoch jederzeit zurücksetzen. Speichern Sie den Benutzer und das Passwort an einem sicheren Ort, da Sie sie später benötigen.
------
#### [ CLI ]
**Erstellen Sie dienstspezifische Anmeldeinformationen mit dem AWS CLI**
Bevor Sie dienstspezifische Anmeldeinformationen generieren, müssen Sie Folgendes herunterladen, installieren und konfigurieren AWS Command Line Interface :AWS CLI
1. Laden Sie das AWS CLI unter [http://aws.amazon.com/cli](https://aws.amazon.com/cli) herunter.
**Anmerkung**
Das AWS CLI läuft unter Windows, MacOS oder Linux.
1. Folgen Sie den Anweisungen zur [Installation der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) und [zur Konfiguration der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) im *AWS Command Line Interface Benutzerhandbuch*.
1. Führen Sie mit dem folgenden Befehl den folgenden Befehl aus AWS CLI, um dienstspezifische Anmeldeinformationen für die Benutzerin zu generieren`alice`, damit sie auf Amazon Keyspaces zugreifen kann.
```
aws iam create-service-specific-credential \
--user-name alice \
--service-name cassandra.amazonaws.com
```
Die Ausgabe sieht wie folgt aus.
```
{
"ServiceSpecificCredential": {
"CreateDate": "2019-10-09T16:12:04Z",
"ServiceName": "cassandra.amazonaws.com",
"ServiceUserName": "alice-at-111122223333",
"ServicePassword": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"ServiceSpecificCredentialId": "ACCAYFI33SINPGJEBYESF",
"UserName": "alice",
"Status": "Active"
}
}
```
Notieren Sie sich in der Ausgabe die Werte für `ServiceUserName` und. `ServicePassword` Speichern Sie diese Werte an einem sicheren Ort, da Sie sie später benötigen werden.
**Wichtig**
Dies ist das einzige Mal, dass `ServicePassword` Ihnen das zur Verfügung steht.
------
# AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren
Um programmgesteuert mit dem AWS SDK oder mit Cassandra-Client-Treibern und dem SigV4-Plugin auf Amazon Keyspaces zuzugreifen, benötigen Sie einen IAM-Benutzer mit Zugriffsschlüsseln. AWS CLI Wenn Sie Amazon Keyspaces programmgesteuert verwenden, geben Sie Ihre AWS Zugriffsschlüssel an, damit Sie Ihre Identität bei programmatischen Aufrufen überprüfen AWS können. Ihre Zugangsschlüssel bestehen aus einer Zugriffsschlüssel-ID (zum AKIAIOSFODNN7 Beispiel) und einem geheimen Zugriffsschlüssel (zum Beispiel). wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY In diesem Thema werden Sie durch die erforderlichen Schritte in diesem Prozess geführt.
Bewährte Sicherheitsmethoden empfehlen, dass Sie IAM-Benutzer mit eingeschränkten Berechtigungen erstellen und stattdessen IAM-Rollen den Berechtigungen zuordnen, die für die Ausführung bestimmter Aufgaben erforderlich sind. IAM-Benutzer können dann vorübergehend IAM-Rollen übernehmen, um die erforderlichen Aufgaben auszuführen. Beispielsweise können IAM-Benutzer in Ihrem Konto, die die Amazon Keyspaces-Konsole verwenden, zu einer Rolle wechseln, um vorübergehend die Berechtigungen der Rolle in der Konsole zu nutzen. Die Benutzer verlieren ihre ursprünglichen Berechtigungen und übernehmen die Berechtigungen der zugewiesenen Rolle. Wenn der Benutzer die Rolle verlässt, werden die ursprünglichen Berechtigungen wiederhergestellt. Die Anmeldeinformationen, die die Benutzer verwenden, um die Rolle anzunehmen, sind temporär. Im Gegenteil, IAM-Benutzer verfügen über langfristige Anmeldeinformationen, was ein Sicherheitsrisiko darstellt, wenn ihnen Rechte direkt zugewiesen werden, anstatt Rollen anzunehmen. Um dieses Risiko zu minimieren, empfehlen wir, diesen Benutzern nur die Berechtigungen zu gewähren, die sie für die Ausführung der Aufgabe benötigen, und diese Benutzer zu entfernen, wenn sie nicht mehr benötigt werden. Weitere Informationen zu Rollen finden Sie unter [Allgemeine Szenarien für Rollen: Benutzer, Anwendungen und Dienste](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios.html) im *IAM-Benutzerhandbuch*.
**Topics**
+ [Anmeldeinformationen AWS CLI, die für das AWS SDK oder das Amazon Keyspaces SigV4-Plugin für Cassandra-Client-Treiber erforderlich sind](SigV4_credentials.md)
+ [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)
+ [Erstellen Sie einen IAM-Benutzer für den programmatischen Zugriff auf Amazon Keyspaces in Ihrem Konto AWS](access.credentials.IAM.md)
+ [Erstellen Sie neue Zugriffsschlüssel für einen IAM-Benutzer](create.keypair.md)
+ [Speichern Sie die Zugriffstasten für den programmatischen Zugriff](aws.credentials.manage.md)
# Anmeldeinformationen AWS CLI, die für das AWS SDK oder das Amazon Keyspaces SigV4-Plugin für Cassandra-Client-Treiber erforderlich sind
Die folgenden Anmeldeinformationen sind erforderlich, um den IAM-Benutzer oder die IAM-Rolle zu authentifizieren:
`AWS_ACCESS_KEY_ID`
Gibt einen AWS Zugriffsschlüssel an, der einem IAM-Benutzer oder einer IAM-Rolle zugeordnet ist.
Der Zugriffsschlüssel `aws_access_key_id` ist erforderlich, um programmgesteuert eine Verbindung zu Amazon Keyspaces herzustellen.
`AWS_SECRET_ACCESS_KEY`
Gibt den geheimen Schlüssel an, der mit dem Zugriffsschlüssel verknüpft ist. Dies ist im Wesentlichen das "Passwort" für den Zugriffsschlüssel.
Das `aws_secret_access_key` ist erforderlich, um programmgesteuert eine Verbindung zu Amazon Keyspaces herzustellen.
`AWS_SESSION_TOKEN`— Fakultativ
Gibt den Sitzungstokenwert an, der erforderlich ist, wenn Sie temporäre Sicherheitsanmeldeinformationen verwenden, die Sie direkt aus AWS -Security-Token-Service -Operationen abgerufen haben. Weitere Informationen 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).
Wenn Sie eine Verbindung mit einem IAM-Benutzer herstellen, `aws_session_token` ist das nicht erforderlich.
# Erstellen Sie temporäre Anmeldeinformationen, um mithilfe einer IAM-Rolle und des SigV4-Plug-ins eine Verbindung zu Amazon Keyspaces herzustellen
Die empfohlene Methode für den programmgesteuerten Zugriff auf Amazon Keyspaces ist die Verwendung [temporärer Anmeldeinformationen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) zur Authentifizierung mit dem SigV4-Plugin. In vielen Fällen benötigen Sie keine langfristigen Zugriffsschlüssel, die nie ablaufen (wie es bei IAM-Benutzern der Fall ist). Stattdessen können Sie eine IAM-Rolle erstellen und temporäre Sicherheitsanmeldedaten generieren. Temporäre Sicherheitsanmeldeinformationen bestehen aus einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel, enthalten aber auch ein Sicherheits-Token, das angibt, wann die Anmeldeinformationen ablaufen. Weitere Informationen zur Verwendung von IAM-Rollen anstelle von langfristigen Zugriffsschlüsseln finden Sie unter [Zu einer IAM-Rolle (AWS API) wechseln](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-api.html).
Um mit temporären Anmeldeinformationen zu beginnen, müssen Sie zunächst eine IAM-Rolle erstellen.
**Erstellen Sie eine IAM-Rolle, die nur Lesezugriff auf Amazon Keyspaces gewährt**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Wählen Sie im Navigationsbereich **Rollen** und anschließend **Rolle erstellen** aus.
1. **Wählen Sie auf der Seite **Rolle erstellen** unter Typ der vertrauenswürdigen Entität** auswählen die Option **AWS Dienst** aus. **Wählen Sie unter Anwendungsfall** auswählen die Option **Amazon EC2** und dann **Weiter** aus.
1. Wählen Sie auf der Seite **Berechtigungen hinzufügen** unter **Berechtigungsrichtlinien die** Option **Amazon Keyspaces Read Only Access** aus der Richtlinienliste aus und klicken Sie dann auf **Weiter**.
1. Geben Sie auf der Seite **Name, Überprüfung und Erstellung** einen Namen für die Rolle ein und überprüfen Sie die Abschnitte **Vertrauenswürdige Entitäten auswählen** und **Berechtigungen hinzufügen**. Sie können auf dieser Seite auch optionale Tags für die Rolle hinzufügen. Wenn Sie fertig sind, wählen Sie **Rolle erstellen** aus. Merken Sie sich diesen Namen, da Sie ihn benötigen, wenn Sie Ihre Amazon EC2 EC2-Instance starten.
Um temporäre Sicherheitsanmeldedaten im Code zu verwenden, rufen Sie programmgesteuert eine AWS -Security-Token-Service API auf `AssumeRole` und extrahieren die resultierenden Anmeldeinformationen und das Sitzungstoken aus Ihrer IAM-Rolle, die Sie im vorherigen Schritt erstellt haben. Anschließend verwenden Sie diese Werte als Anmeldeinformationen für nachfolgende Aufrufe von. AWS Das folgende Beispiel zeigt Pseudocode für die Verwendung temporärer Sicherheitsanmeldeinformationen:
```
assumeRoleResult = AssumeRole(role-arn);
tempCredentials = new SessionAWSCredentials(
assumeRoleResult.AccessKeyId,
assumeRoleResult.SecretAccessKey,
assumeRoleResult.SessionToken);
cassandraRequest = CreateAmazoncassandraClient(tempCredentials);
```
Ein Beispiel, das temporäre Anmeldeinformationen mithilfe des Python-Treibers für den Zugriff auf Amazon Keyspaces implementiert, finden Sie unter[Stellen Sie mithilfe des DataStax Python-Treibers für Apache Cassandra und des SigV4-Authentifizierungs-Plug-ins eine Connect zu Amazon Keyspaces her](using_python_driver.md#python_SigV4).
Einzelheiten über den Aufruf von `AssumeRole`, `GetFederationToken` und anderen API-Vorgängen finden Sie in der [AWS -Security-Token-Service -API-Referenz](https://docs.aws.amazon.com/STS/latest/APIReference/). Informationen dazu, wie die temporären Sicherheitsanmeldeinformationen und das Sitzungstoken aus dem Ergebnis abgerufen werden, finden Sie in der Dokumentation für das SDK, mit dem Sie arbeiten. Die Dokumentation für alle finden Sie AWS SDKs auf der [AWS Hauptdokumentationsseite](https://aws.amazon.com/documentation) im Abschnitt **SDKs und Toolkits**.
# Erstellen Sie einen IAM-Benutzer für den programmatischen Zugriff auf Amazon Keyspaces in Ihrem Konto AWS
Um Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces mit dem AWS CLI, dem AWS SDK oder dem SigV4-Plugin zu erhalten, müssen Sie zunächst einen IAM-Benutzer oder eine IAM-Rolle erstellen. Der Prozess der Erstellung eines IAM-Benutzers und der Konfiguration dieses IAM-Benutzers für den programmatischen Zugriff auf Amazon Keyspaces wird in den folgenden Schritten gezeigt:
1. Erstellen Sie den Benutzer in den AWS-Managementkonsole Tools für Windows oder mithilfe einer PowerShell API-Operation. AWS CLI AWS Wenn Sie den Benutzer in der erstellen AWS-Managementkonsole, werden die Anmeldeinformationen automatisch erstellt.
1. Wenn Sie den Benutzer programmgesteuert erstellen, müssen Sie in einem zusätzlichen Schritt einen Zugriffsschlüssel (Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel) für diesen Benutzer erstellen.
1. Erteilen Sie dem Benutzer Berechtigungen für den Zugriff auf Amazon Keyspaces.
Informationen zu den Berechtigungen, die Sie benötigen, um einen IAM-Benutzer zu erstellen, finden Sie unter [Erforderliche Berechtigungen für den Zugriff auf IAM-Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html).
------
#### [ Console ]
**Erstellen Sie einen IAM-Benutzer mit programmatischem Zugriff (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Wählen Sie im Navigationsbereich **Users** und dann **Add User**.
1. Geben Sie den Benutzernamen für den neuen Benutzer an. Dies ist der Anmeldename für. AWS
**Anmerkung**
Benutzernamen können eine Kombination aus bis zu 64 Buchstaben, Ziffern und den folgenden Zeichen enthalten: Plus (\$1), Gleichheitszeichen (=), Komma (,), Punkt (.), at-Zeichen (@), Unterstrich (\$1) und Bindestrich (-). Namen müssen innerhalb eines Kontos eindeutig sein. Sie werden nicht nach Groß- und Kleinschreibung unterschieden. So können Sie beispielsweise keine zwei Gruppen mit Namen *TESTBENUTZER* und *testbenutzer* erstellen.
1. Wählen Sie **Zugriffsschlüssel — Programmgesteuerter Zugriff**, um einen Zugriffsschlüssel für den neuen Benutzer zu erstellen. Sie können den Zugriffsschlüssel ansehen oder herunterladen, wenn Sie zur **letzten** Seite gelangen.
Wählen Sie **Weiter: Berechtigungen** aus.
1. Wählen Sie auf der Seite **Berechtigungen festlegen** die Option **Bestehende Richtlinien direkt anhängen** aus, um dem neuen Benutzer Berechtigungen zuzuweisen.
Diese Option zeigt die Liste der AWS verwalteten und vom Kunden verwalteten Richtlinien an, die in Ihrem Konto verfügbar sind. Sie können `keyspaces` in das Suchfeld eingeben, um nur die Richtlinien anzuzeigen, die sich auf Amazon Keyspaces beziehen.
Für Amazon Keyspaces sind die verfügbaren verwalteten Richtlinien `AmazonKeyspacesFullAccess` und`AmazonKeyspacesReadOnlyAccess`. Weitere Informationen zu den einzelnen Richtlinien finden Sie unter[AWS verwaltete Richtlinien für Amazon Keyspaces](security-iam-awsmanpol.md).
Wählen Sie zu Testzwecken und um den Verbindungs-Tutorials zu folgen, die `AmazonKeyspacesReadOnlyAccess` Richtlinie für den neuen IAM-Benutzer aus. **Hinweis:** Als bewährte Methode empfehlen wir, das Prinzip der geringsten Rechte zu befolgen und benutzerdefinierte Richtlinien zu erstellen, die den Zugriff auf bestimmte Ressourcen einschränken und nur die erforderlichen Aktionen zulassen. Weitere Informationen zu IAM-Richtlinien und Beispielrichtlinien für Amazon Keyspaces finden Sie unter. [Identitätsbasierte Richtlinien von Amazon Keyspaces](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies) Nachdem Sie benutzerdefinierte Berechtigungsrichtlinien erstellt haben, fügen Sie Ihre Richtlinien den Rollen hinzu und lassen Sie die Benutzer dann vorübergehend die entsprechenden Rollen übernehmen.
Wählen Sie **Weiter: Tags** aus.
1. Auf der Seite **Stichwörter hinzufügen (optional)** können Sie Stichwörter für den Benutzer hinzufügen oder **Weiter: Überprüfen** wählen.
1. Auf der Seite **„Überprüfen**“ können Sie alle Entscheidungen sehen, die Sie bis zu diesem Zeitpunkt getroffen haben. Wenn Sie bereit sind, fortzufahren, wählen Sie **Benutzer erstellen**.
1. Um die Zugriffsschlüssel des Benutzers (Zugriffsschlüssel IDs und geheime Zugriffsschlüssel) **anzuzeigen**, wählen Sie neben dem Passwort und dem Zugriffsschlüssel die Option Anzeigen aus. Zum Speichern der Zugriffsschlüssel wählen Sie **Download .csv**. Speichern Sie die Datei an einem sicheren Speicherort.
**Wichtig**
Dies ist Ihre einzige Möglichkeit, die geheimen Zugangsschlüssel anzusehen oder herunterzuladen, und Sie benötigen diese Informationen, bevor sie das SigV4-Plugin verwenden können. Speichern Sie die neue Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel des Benutzers an einem sicheren Speicherort. Sie haben nach diesem Schritt keinen Zugriff mehr auf die geheimen Zugriffsschlüssel.
------
#### [ CLI ]
**Erstellen Sie einen IAM-Benutzer mit programmatischem Zugriff ()AWS CLI**
1. Erstellen Sie einen Benutzer mit dem folgenden AWS CLI Code.
+ [https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html)
1. Erteilen Sie dem Benutzer programmatischen Zugriff. Dazu sind Zugriffsschlüssel erforderlich, die auf folgende Weise generiert werden können.
+ AWS CLI: [https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html)
+ Tools für Windows PowerShell: [https://docs.aws.amazon.com/powershell/latest/reference/items/New-IAMAccessKey.html](https://docs.aws.amazon.com/powershell/latest/reference/items/New-IAMAccessKey.html)
+ IAM-API: [https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateAccessKey.html)
**Wichtig**
Dies ist Ihre einzige Möglichkeit, die geheimen Zugriffsschlüssel anzusehen oder herunterzuladen, und Sie benötigen diese Informationen, bevor sie das SigV4-Plugin verwenden können. Speichern Sie die neue Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel des Benutzers an einem sicheren Speicherort. Sie haben nach diesem Schritt keinen Zugriff mehr auf die geheimen Zugriffsschlüssel.
1. Hängen Sie die `AmazonKeyspacesReadOnlyAccess` Richtlinie, die die Benutzerberechtigungen definiert, an den Benutzer an. **Hinweis:** Als bewährte Methode empfehlen wir, Benutzerberechtigungen zu verwalten, indem Sie den Benutzer zu einer Gruppe hinzufügen und der Gruppe eine Richtlinie anhängen, anstatt sie direkt an einen Benutzer anzuhängen.
+ AWS CLI: [https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html)
------
# Erstellen Sie neue Zugriffsschlüssel für einen IAM-Benutzer
Wenn Sie bereits einen IAM-Benutzer haben, können Sie jederzeit neue Zugriffsschlüssel erstellen. Weitere Informationen zur Schlüsselverwaltung, z. B. zur Aktualisierung von Zugriffsschlüsseln, finden Sie unter [Zugriffsschlüssel für IAM-Benutzer verwalten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**So erstellen Sie Zugriffsschlüssel für einen IAM-Benutzer (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Klicken Sie im Navigationsbereich auf **Users (Benutzer)**.
1. Wählen Sie den Namen des Benutzers, dessen Zugriffsschlüssel Sie erstellen möchten.
1. Wählen Sie auf der **Übersichtsseite** des Benutzers die Registerkarte **Sicherheitsanmeldeinformationen** aus.
1. Wählen **Sie im Abschnitt Zugriffstasten** unter **Bewährte Methoden und Alternativen für Zugriffsschlüssel** den Anwendungsfall **Andere** aus. Klicken Sie auf **Weiter**, geben Sie nach Bedarf optionale Informationen ein und wählen Sie **Zugriffsschlüssel erstellen** aus.
Wählen Sie zum Anzeigen des neuen Zugriffsschlüsselpaars **Show (Anzeigen)** aus. Ihre Anmeldeinformationen sehen etwa folgendermaßen aus:
+ Zugriffsschlüssel-ID: AKIAIOSFODNN7 BEISPIEL
+ Geheimer Zugriffsschlüssel: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
**Anmerkung**
Sie haben keinen Zugriff auf den geheimen Zugriffsschlüssel mehr, nachdem das Dialogfeld geschlossen wird.
Beachten Sie die folgenden bewährten Methoden für das von Ihnen erstellte key pair.
+ Speichern Sie Ihren Zugriffsschlüssel niemals im Klartext, in einem Code-Repository oder in Code.
+ Deaktivieren oder löschen Sie Zugriffsschlüssel, wenn sie nicht mehr benötigt werden.
+ Aktivieren Sie Berechtigungen mit den geringsten Rechten.
+ Wechseln Sie die Zugriffsschlüssel regelmäßig.
1. Wählen Sie zum Herunterladen des Schlüsselpaares **Download .csv file** aus. Speichern Sie die Schlüssel an einem sicheren Ort.
1. Nachdem Sie die CSV-Datei heruntergeladen haben, klicken Sie auf **Close (Schließen)**.
Wenn Sie einen Zugriffsschlüssel erstellen, ist das Schlüsselpaar standardmäßig aktiv, und Sie können es sofort verwenden.
# Speichern Sie die Zugriffstasten für den programmatischen Zugriff
Als bewährte Methode empfehlen wir, Zugriffsschlüssel nicht direkt in Code einzubetten. AWS Mit den Befehlszeilentools AWS SDKs und den Befehlszeilentools können Sie Zugriffstasten an bekannten Stellen platzieren, sodass Sie sie nicht im Code speichern müssen. Legen Sie Zugriffsschlüssel an einem der folgenden Orte ab:
+ **Umgebungsvariablen** — Wählen Sie auf einem Mehrmandantensystem Benutzerumgebungsvariablen, keine Systemumgebungsvariablen.
+ **CLI-Anmeldeinformationsdatei** – Die `credentials`- und `config`-Dateien werden aktualisiert, wenn Sie den Befehl `aws configure` ausführen. Die `credentials` Datei befindet sich `~/.aws/credentials` unter Linux, macOS oder Unix oder unter Windows `C:\Users\USERNAME\.aws\credentials` unter. Diese Datei kann die Anmeldeinformationsdetails für das `default`-Profil und alle benannten Profile enthalten.
+ **CLI-Konfigurationsdatei** – Die `credentials`- und `config`-Dateien werden aktualisiert, wenn Sie den Befehl `aws configure` ausführen. Die `config` Datei befindet sich `~/.aws/config` unter Linux, macOS oder Unix oder unter Windows `C:\Users\USERNAME\.aws\config` unter. Diese Datei enthält die Konfigurationseinstellungen für das Standardprofil sowie alle benannten Profile.
Das Speichern von Zugriffsschlüsseln als Umgebungsvariablen ist eine Voraussetzung für die[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](using_java_driver.md#java_tutorial.SigV4). Beachten Sie, dass dies die Standardeinstellung beinhaltet AWS-Region. Der Client sucht mithilfe der standardmäßigen Anbieterkette für Anmeldeinformationen nach Anmeldeinformationen, und Zugriffsschlüssel, die als Umgebungsvariablen gespeichert sind, haben Vorrang vor allen anderen Speicherorten, z. B. Konfigurationsdateien. Weitere Informationen finden Sie unter [Konfigurationseinstellungen und Rangfolge](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-precedence).
Die folgenden Beispiele zeigen, wie Sie Umgebungsvariablen für den Standardbenutzer konfigurieren können.
------
#### [ Linux, macOS, or Unix ]
```
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
$ export AWS_SESSION_TOKEN=AQoDYXdzEJr...
$ export AWS_DEFAULT_REGION=us-east-1
```
Durch die Festlegung der Umgebungsvariablen wird der verwendete Wert bis zum Ende der Shell-Sitzung oder bis zur Festlegung eines anderen Wertes für die Variable geändert. Sie können Variablen für zukünftige Sitzungen persistent machen, indem Sie sie im Startup-Skript Ihrer Shell festlegen.
------
#### [ Windows Command Prompt ]
```
C:\> setx AWS_ACCESS_KEY_ID AKIAIOSFODNN7EXAMPLE
C:\> setx AWS_SECRET_ACCESS_KEY wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
C:\> setx AWS_SESSION_TOKEN AQoDYXdzEJr...
C:\> setx AWS_DEFAULT_REGION us-east-1
```
Bei Verwendung von `[set](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/set_1)` zur Festlegung einer Umgebungsvariablen wird der verwendete Wert bis zum Ende der aktuellen Eingabeaufforderungssitzung oder bis zur Festlegung eines anderen Wertes für die Variable geändert. Bei Verwendung von [https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/setx) zur Festlegung einer Umgebungsvariablen wird der verwendete Wert in der aktuellen Eingabeaufforderungssitzung und allen nach Ausführung des Befehls erstellten Eingabeaufforderungssitzungen geändert. Andere Befehls-Shells, die zum Zeitpunkt der Befehlsausführung bereits ausgeführt werden, sind hiervon ***nicht*** betroffen.
------
#### [ PowerShell ]
```
PS C:\> $Env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
PS C:\> $Env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
PS C:\> $Env:AWS_SESSION_TOKEN="AQoDYXdzEJr..."
PS C:\> $Env:AWS_DEFAULT_REGION="us-east-1"
```
Wenn Sie an der PowerShell Eingabeaufforderung eine Umgebungsvariable festlegen, wie in den vorherigen Beispielen gezeigt, wird der Wert nur für die Dauer der aktuellen Sitzung gespeichert. Um die Einstellung der Umgebungsvariablen für alle Sitzungen PowerShell und Befehlszeilensitzungen beizubehalten, speichern Sie sie mithilfe der **Systemanwendung** in der **Systemsteuerung**. Alternativ können Sie die Variable für alle future PowerShell Sitzungen festlegen, indem Sie sie zu Ihrem PowerShell Profil hinzufügen. Weitere Informationen zum Speichern von Umgebungsvariablen oder deren Beibehaltung über mehrere Sitzungen hinweg finden Sie in der [PowerShell Dokumentation](https://docs.microsoft.com/powershell/module/microsoft.powershell.core/about/about_environment_variables).
------
# Service-Endpunkte für Amazon Keyspaces
**Topics**
+ [Ports und Protokolle](#ports)
+ [Globale Endpunkte](#global_endpoints)
+ [AWS GovCloud (US) Region FIPS-Endpunkte](#fips_endpoints)
+ [Endpunkte der China Regionen](#china_endpoints)
+ [Streaming-Endpunkte](#streams_endpoints)
+ [Verbindung zu Dual-Stack-Endpunkten herstellen](dualstack_endpoints.md)
## Ports und Protokolle
Sie können programmgesteuert auf Amazon Keyspaces zugreifen, indem Sie einen `cqlsh` Client ausführen, einen für Apache 2.0 lizenzierten Cassandra-Treiber verwenden oder das SDK und das AWS CLI SDK verwenden. AWS
Die folgende Tabelle zeigt die Ports und Protokolle für die verschiedenen Zugriffsmechanismen.
| Programmatischer Zugriff | Port | Protocol (Protokoll) |
| --- | --- | --- |
| CQLSH | 9142 | TLS |
| Cassandra-Treiber | 9142 | TLS |
| AWS CLI | 443 | HTTPS |
| AWS SDK | 443 | HTTPS |
Für TLS-Verbindungen verwendet Amazon Keyspaces Zertifikate, die unter Amazon Trust Services (Amazon Root CAs 1—4) ausgestellt wurden, um sich gegenüber dem Server zu authentifizieren. Weitere Informationen finden Sie unter [Wie konfiguriert man `cqlsh` Verbindungen für TLS manuell](programmatic.cqlsh.md#encrypt_using_tls) oder im Abschnitt [Bevor Sie beginnen zu](using_java_driver.md#using_java_driver.BeforeYouBegin) Ihrem Treiber im Kapitel. [Verwenden eines Cassandra-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces](programmatic.drivers.md)
## Globale Endpunkte
Amazon Keyspaces unterstützt sowohl öffentliche Endgeräte als IPv4 auch IPv6 öffentliche Endgeräte. Sie können zwischen IPv4 Endpunkten und Dual-Stack-Endpunkten wählen. Die Endpunkte verwenden die folgende Benennungskonvention, bei der Sie sie durch eine andere aus der Tabelle verfügbare *us-east-1* AWS-Region ersetzen können.
+ **IPv4 Endpunkte** — `cassandra.us-east-1.amazonaws.com`
+ **Dual-Stack-Endpunkte** — `cassandra.us-east-1.api.aws`
Weitere Informationen zu Dual-Stack-Endpunkten und zur Konfiguration von Verbindungen finden Sie unter. [Verbindung zu Dual-Stack-Endpunkten herstellen](dualstack_endpoints.md)
Amazon Keyspaces ist in den folgenden Regionen verfügbar.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/keyspaces/latest/devguide/programmatic.endpoints.html)
## AWS GovCloud (US) Region FIPS-Endpunkte
Verfügbare FIPS-Endpunkte in der. AWS GovCloud (US) Region Amazon Keyspaces unterstützt sowohl FIPS-Endgeräte als IPv4 auch IPv6 FIPS-Endpunkte. Sie können zwischen IPv4 Endpunkten und Dual-Stack-Endpunkten wählen. Weitere Informationen finden Sie unter [Amazon Keyspaces im *AWS GovCloud (US) Benutzerhandbuch*](https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/govcloud-keyspaces.html).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/keyspaces/latest/devguide/programmatic.endpoints.html)
## Endpunkte der China Regionen
Amazon Keyspaces unterstützt IPv4 Endgeräte in den Regionen AWS China.
Um auf diese Endpunkte zugreifen zu können, müssen Sie sich für einen separaten Satz von Kontoanmeldeinformationen anmelden, die nur für die Regionen China gelten. Weitere Informationen finden Sie unter [Registrierung, Konten und Anmeldeinformationen in China](https://docs.amazonaws.cn/en_us/aws/latest/userguide/accounts-and-credentials.html).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/keyspaces/latest/devguide/programmatic.endpoints.html)
## Streaming-Endpunkte
Amazon Keyspaces CDC streams ist im Folgenden AWS-Regionen verfügbar. Diese Tabelle zeigt den verfügbaren Dual-Stack-Serviceendpunkt für jede Region. Weitere Informationen zu finden Sie Amazon Keyspaces CDC streams unter[So greifen Sie in Amazon Keyspaces auf CDC-Stream-Endpunkte zu](CDC_access-endpoints.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/keyspaces/latest/devguide/programmatic.endpoints.html)
# Verbindung zu Dual-Stack-Endpunkten herstellen
Die globalen Endpunkte von Amazon Keyspaces sind Dual-Stack-Endpunkte, die Anfragen annehmen und Anfragen annehmen. IPv4 IPv6
Wenn Sie eine Verbindung zu Amazon Keyspaces herstellen IPv6, passt der Service die Antworten der Systemtabelle automatisch an Ihr Verbindungsprotokoll an. Dadurch wird sichergestellt, dass Ihre Anwendungen konsistente Netzwerkadressinformationen erhalten, die ihrem Verbindungstyp entsprechen. Dadurch erhält der Client genaue Informationen zur Netzwerktopologie und gewährleistet gleichzeitig die Abwärtskompatibilität vorhandener CQL-Anwendungen.
Amazon Keyspaces erkennt das Netzwerkprotokoll (IPv4 oder IPv6), das von Ihrer Client-Verbindung verwendet wird, automatisch und passt die Antworten der Systemtabelle entsprechend an. Diese Erkennung erfolgt transparent während des ersten Verbindungs-Handshakes, sodass keine zusätzliche Konfiguration durch die Client-Anwendung erforderlich ist.
Amazon Keyspaces gibt IP-Adressen auf der Grundlage Ihres Verbindungsprotokolls zurück. Beispielsweise gibt eine Anfrage von einem IPv4 Netzwerk die folgende Antwort zurück.
```
SELECT * FROM system.peers;
-- Returns IPv4 addresses in peer column
-- Example: 172.31.1.1, 172.31.1.2, etc.
```
Eine Verbindung von einem IPv6 Netzwerk zu einem Dual-Stack-Endpunkt gibt `cassandra.us-east-1.api.aws` beispielsweise die folgende Antwort zurück.
```
SELECT * FROM system.peers;
-- Returns IPv6 addresses in peer column
-- Example: 2001:db8::1, 2001:db8::2, etc.
```
Weitere Informationen zur IPv6 Unterstützung in Amazon Keyspaces finden Sie unter[IPv6 Unterstützung in Amazon Keyspaces](ipv6-support.md).
# IPv6 Unterstützung in Amazon Keyspaces
IPv6 Die Unterstützung in Amazon Keyspaces ermöglicht es Anwendungen, Verbindungen mithilfe von Internet Protocol Version 6 herzustellen, dem Internetprotokoll der nächsten Generation, das im Vergleich zu einen erheblich erweiterten Adressraum bietet. IPv4 Die Implementierung verwendet Dual-Stack-Endpunkte, die beide gleichzeitig unterstützen, wodurch die Abwärtskompatibilität gewährleistet IPv4 und IPv6 gleichzeitig eine zukunftsfähige Konnektivität ermöglicht wird. Eine Liste der Endpunkte finden Sie unter [Globale Endpunkte](programmatic.endpoints.md#global_endpoints).
Amazon Keyspaces implementiert IPv6 Unterstützung über eine Dual-Stack-Architektur, die vollständige Abwärtskompatibilität gewährleistet und gleichzeitig Konnektivität ermöglicht. IPv6
## DNS-Auflösung in Amazon Keyspaces
Wenn Anwendungen eine Verbindung zu Dual-Stack-Endpunkten herstellen, gibt der DNS-Auflösungsprozess beide Adresstypen zurück:
A-Aufzeichnungen () IPv4
Herkömmliche IPv4 Adressen aus Gründen der Abwärtskompatibilität
AAAA-Aufzeichnungen () IPv6
Neue IPv6 Adressen für moderne Konnektivität
Das Betriebssystem und der Netzwerk-Stack des Kunden wählen auf der Grundlage der lokalen Konfiguration, der Netzwerkverfügbarkeit und der Systemeinstellungen automatisch das am besten geeignete Protokoll aus.
Das Cassandra Query Language (CQL) -Protokoll unterstützt nahtlos IPv6 Konnektivität, ohne dass Änderungen am Anwendungscode erforderlich sind.
Automatische Protokollauswahl
+ Anwendungen spezifizieren den Dual-Stack-Endpunkt
+ Der Netzwerk-Stack wählt IPv4 oder IPv6 basiert auf der Verfügbarkeit
+ Für bestehende CQL-Anwendungen sind keine Codeänderungen erforderlich
Treiberkompatibilität
+ Alle wichtigen CQL-Treiber unterstützen transparent IPv6
+ DataStax Treiber verarbeiten Adressen nativ IPv6
+ Open-Source-Treiber funktionieren ohne Änderung
Konsistenz der Verbindung
+ Die Systemtabellen geben das verwendete Verbindungsprotokoll wieder
+ IPv6 Verbindungen zeigen IPv6 Adressen in `system.peers`
+ IPv4 Verbindungen zeigen weiterhin IPv4 Adressen an
# Verwenden`cqlsh`, um eine Verbindung zu Amazon Keyspaces herzustellen
Um eine Verbindung zu Amazon Keyspaces herzustellen`cqlsh`, können Sie den `cqlsh-expansion` verwenden. Dies ist ein Toolkit, das gängige Apache Cassandra-Tools wie `cqlsh` und Hilfsprogramme enthält, die für Amazon Keyspaces vorkonfiguriert sind und gleichzeitig die volle Kompatibilität mit Apache Cassandra gewährleisten. Es `cqlsh-expansion` integriert das SigV4-Authentifizierungs-Plugin und ermöglicht es Ihnen, eine Verbindung mithilfe von IAM-Zugriffsschlüsseln anstelle von Benutzername und Passwort herzustellen. Sie müssen nur die `cqlsh` Skripts installieren, um eine Verbindung herzustellen, und nicht die vollständige Apache Cassandra-Distribution, da Amazon Keyspaces serverlos ist. Dieses einfache Installationspaket enthält die `cqlsh-expansion` und die klassischen `cqlsh` Skripte, die Sie auf jeder Plattform installieren können, die Python unterstützt.
**Anmerkung**
`Murmur3Partitioner`ist der empfohlene Partitionierer für Amazon Keyspaces und die. `cqlsh-expansion` Das unterstützt die Amazon Keyspaces `cqlsh-expansion` `DefaultPartitioner` nicht. Weitere Informationen finden Sie unter [Arbeiten mit Partitionierern in Amazon Keyspaces](working-with-partitioners.md).
Allgemeine Informationen zu `cqlsh` finden Sie unter [`cqlsh`: Die CQL-Shell](https://cassandra.apache.org/doc/latest/cassandra/managing/tools/cqlsh.html).
**Topics**
+ [Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](#using_cqlsh)
+ [Wie konfiguriert man `cqlsh` Verbindungen für TLS manuell](#encrypt_using_tls)
## Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen
**Installation und Konfiguration des `cqlsh-expansion`**
1. Um das `cqlsh-expansion` Python-Paket zu installieren, können Sie einen `pip` Befehl ausführen. Dadurch werden die `cqlsh-expansion` Skripts mithilfe einer *Pip-Installation* zusammen mit einer Datei, die eine Liste von Abhängigkeiten enthält, auf Ihrem Computer installiert. Das `--user flag` weist `pip` an, das Python-Benutzerinstallationsverzeichnis für Ihre Plattform zu verwenden. Auf einem Unix-basierten System sollte das das `~/.local/` Verzeichnis sein.
Sie benötigen Python 3, um das zu installieren`cqlsh-expansion`, um Ihre Python-Version herauszufinden, verwenden`Python --version`. Zur Installation können Sie den folgenden Befehl ausführen.
```
python3 -m pip install --user cqlsh-expansion
```
Die Ausgabe sollte in etwa so aussehen.
```
Collecting cqlsh-expansion
Downloading cqlsh_expansion-0.9.6-py3-none-any.whl (153 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 153.7/153.7 KB 3.3 MB/s eta 0:00:00
Collecting cassandra-driver
Downloading cassandra_driver-3.28.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (19.1 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 19.1/19.1 MB 44.5 MB/s eta 0:00:00
Requirement already satisfied: six>=1.12.0 in /usr/lib/python3/dist-packages (from cqlsh-expansion) (1.16.0)
Collecting boto3
Downloading boto3-1.29.2-py3-none-any.whl (135 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 135.8/135.8 KB 17.2 MB/s eta 0:00:00
Collecting cassandra-sigv4>=4.0.2
Downloading cassandra_sigv4-4.0.2-py2.py3-none-any.whl (9.8 kB)
Collecting botocore<1.33.0,>=1.32.2
Downloading botocore-1.32.2-py3-none-any.whl (11.4 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 11.4/11.4 MB 60.9 MB/s eta 0:00:00
Collecting s3transfer<0.8.0,>=0.7.0
Downloading s3transfer-0.7.0-py3-none-any.whl (79 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 79.8/79.8 KB 13.1 MB/s eta 0:00:00
Collecting jmespath<2.0.0,>=0.7.1
Downloading jmespath-1.0.1-py3-none-any.whl (20 kB)
Collecting geomet<0.3,>=0.1
Downloading geomet-0.2.1.post1-py3-none-any.whl (18 kB)
Collecting python-dateutil<3.0.0,>=2.1
Downloading python_dateutil-2.8.2-py2.py3-none-any.whl (247 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 247.7/247.7 KB 33.1 MB/s eta 0:00:00
Requirement already satisfied: urllib3<2.1,>=1.25.4 in /usr/lib/python3/dist-packages (from botocore<1.33.0,>=1.32.2->boto3->cqlsh-expansion) (1.26.5)
Requirement already satisfied: click in /usr/lib/python3/dist-packages (from geomet<0.3,>=0.1->cassandra-driver->cqlsh-expansion) (8.0.3)
Installing collected packages: python-dateutil, jmespath, geomet, cassandra-driver, botocore, s3transfer, boto3, cassandra-sigv4, cqlsh-expansion
WARNING: The script geomet is installed in '/home/ubuntu/.local/bin' which is not on PATH.
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
WARNING: The scripts cqlsh, cqlsh-expansion and cqlsh-expansion.init are installed in '/home/ubuntu/.local/bin' which is not on PATH.
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed boto3-1.29.2 botocore-1.32.2 cassandra-driver-3.28.0 cassandra-sigv4-4.0.2 cqlsh-expansion-0.9.6 geomet-0.2.1.post1 jmespath-1.0.1 python-dateutil-2.8.2 s3transfer-0.7.0
```
Wenn sich das Installationsverzeichnis nicht im befindet`PATH`, müssen Sie es gemäß den Anweisungen Ihres Betriebssystems hinzufügen. Im Folgenden finden Sie ein Beispiel für Ubuntu Linux.
```
export PATH="$PATH:/home/ubuntu/.local/bin"
```
Um zu bestätigen, dass das Paket installiert ist, können Sie den folgenden Befehl ausführen.
```
cqlsh-expansion --version
```
Die Ausgabe sollte so aussehen.
```
cqlsh 6.1.0
```
1. Um das zu konfigurieren`cqlsh-expansion`, können Sie nach der Installation ein Skript ausführen, um die folgenden Schritte automatisch auszuführen:
1. Erstellen Sie das `.cassandra` Verzeichnis im Home-Verzeichnis des Benutzers, falls es noch nicht vorhanden ist.
1. Kopieren Sie eine vorkonfigurierte `cqlshrc` Konfigurationsdatei in das `.cassandra` Verzeichnis.
1. Kopieren Sie die kombinierte Zertifikatsdatei in das `.cassandra` Verzeichnis. Amazon Keyspaces verwendet dieses Zertifikat, um die sichere Verbindung mit Transport Layer Security (TLS) zu konfigurieren. Die Verschlüsselung bei der Übertragung bietet eine zusätzliche Datenschutzebene, indem Ihre Daten auf dem Weg zu und von Amazon Keyspaces verschlüsselt werden. Weitere Informationen zu Zertifikaten finden Sie unter. [Wie konfiguriert man `cqlsh` Verbindungen für TLS manuell](#encrypt_using_tls)
Um das Skript zunächst zu überprüfen, können Sie es im Github-Repo unter [https://github.com/aws-samples/amazon-keyspaces-toolkit/blob/master/cqlsh-expansion/cqlsh_expansion/post_install.py](https://github.com/aws-samples/amazon-keyspaces-toolkit/blob/master/cqlsh-expansion/cqlsh_expansion/post_install.py)aufrufen.
Um das Skript zu verwenden, können Sie den folgenden Befehl ausführen.
```
cqlsh-expansion.init
```
**Anmerkung**
Das Verzeichnis und die Datei, die durch das Post-Installationsskript erstellt wurden`pip uninstall`, werden bei der Deinstallation `cqlsh-expansion` von using nicht entfernt und müssen manuell gelöscht werden.
**Herstellen einer Verbindung zu Amazon Keyspaces mithilfe der `cqlsh-expansion`**
1. Konfigurieren Sie Ihre AWS-Region und fügen Sie sie als Benutzerumgebungsvariable hinzu.
Um Ihre Standardregion als Umgebungsvariable auf einem Unix-basierten System hinzuzufügen, können Sie den folgenden Befehl ausführen. Für dieses Beispiel verwenden wir`us-east-1`.
```
export AWS_DEFAULT_REGION=us-east-1
```
Weitere Informationen zum Festlegen von Umgebungsvariablen, auch für andere Plattformen, finden Sie unter [So legen Sie Umgebungsvariablen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html#envvars-set) fest.
1. Finden Sie Ihren Service-Endpunkt.
Wählen Sie den entsprechenden Service-Endpunkt für Ihre Region aus. Informationen zu den verfügbaren Endpunkten für Amazon Keyspaces finden Sie unter. [Service-Endpunkte für Amazon Keyspaces](programmatic.endpoints.md) In diesem Beispiel verwenden wir den Endpunkt. `cassandra.us-east-1.amazonaws.com`
1. Konfigurieren Sie die Authentifizierungsmethode.
Die empfohlene Methode zur Erhöhung der Sicherheit ist die Verbindung mit IAM-Zugriffsschlüsseln (IAM-Benutzer, Rollen und föderierte Identitäten).
Bevor Sie eine Verbindung mit IAM-Zugriffsschlüsseln herstellen können, müssen Sie die folgenden Schritte ausführen:
1. Erstellen Sie einen IAM-Benutzer oder folgen Sie den bewährten Methoden und erstellen Sie eine IAM-Rolle, die IAM-Benutzer übernehmen können. Weitere Informationen zum Erstellen von IAM-Zugriffsschlüsseln finden Sie unter. [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md)
1. Erstellen Sie eine IAM-Richtlinie, die der Rolle (oder dem IAM-Benutzer) mindestens schreibgeschützten Zugriff auf Amazon Keyspaces gewährt. Weitere Informationen zu den Berechtigungen, die der IAM-Benutzer oder die IAM-Rolle benötigt, um eine Verbindung zu Amazon Keyspaces herzustellen, finden Sie unter. [Zugreifen auf Amazon Keyspaces-Tabellen](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-one-table)
1. Fügen Sie die Zugriffsschlüssel des IAM-Benutzers zu den Umgebungsvariablen des Benutzers hinzu, wie im folgenden Beispiel gezeigt.
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
Weitere Informationen zum Festlegen von Umgebungsvariablen, auch für andere Plattformen, finden Sie unter [So legen Sie Umgebungsvariablen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html#envvars-set) fest.
**Anmerkung**
Wenn Sie von einer Amazon EC2 EC2-Instance aus eine Verbindung herstellen, müssen Sie auch eine ausgehende Regel in der Sicherheitsgruppe konfigurieren, die den Datenverkehr von der Instance zu Amazon Keyspaces zulässt. Weitere Informationen zum Anzeigen und Bearbeiten von EC2-Regeln für ausgehenden Datenverkehr finden [Sie unter Regeln zu einer Sicherheitsgruppe hinzufügen im Amazon EC2 EC2-Benutzerhandbuch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#adding-security-group-rule).
1. Stellen Sie mithilfe der `cqlsh-expansion` und SigV4-Authentifizierung eine Connect zu Amazon Keyspaces her.
Um mit dem eine Verbindung zu Amazon Keyspaces herzustellen`cqlsh-expansion`, können Sie den folgenden Befehl verwenden. Stellen Sie sicher, dass Sie den Service-Endpunkt durch den richtigen Endpunkt für Ihre Region ersetzen.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Wenn die Verbindung erfolgreich ist, sollten Sie eine Ausgabe sehen, die dem folgenden Beispiel ähnelt.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
cqlsh>
```
Wenn Sie auf einen Verbindungsfehler stoßen, finden Sie Informationen [Ich kann mit cqlsh keine Verbindung zu Amazon Keyspaces herstellen](troubleshooting.connecting.md#troubleshooting.connection.cqlsh) zur Problembehandlung unter.
+ Stellen Sie mit dienstspezifischen Anmeldeinformationen eine Connect zu Amazon Keyspaces her.
Um eine Verbindung mit der herkömmlichen Kombination aus Benutzername und Passwort herzustellen, die Cassandra für die Authentifizierung verwendet, müssen Sie zunächst dienstspezifische Anmeldeinformationen für Amazon Keyspaces erstellen, wie unter beschrieben. [Dienstspezifische Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.ssc.md) Sie müssen diesem Benutzer auch Berechtigungen für den Zugriff auf Amazon Keyspaces erteilen. Weitere Informationen finden Sie unter[Zugreifen auf Amazon Keyspaces-Tabellen](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-one-table).
Nachdem Sie dienstspezifische Anmeldeinformationen und Berechtigungen für den Benutzer erstellt haben, müssen Sie die `cqlshrc` Datei aktualisieren, die sich normalerweise im Benutzerverzeichnispfad befindet. `~/.cassandra/` Gehen Sie in der `cqlshrc` Datei zum `[authentication]` Abschnitt Cassandra und kommentieren Sie das SigV4-Modul und die Klasse unter, `[auth_provider]` indem Sie das Zeichen „;“ verwenden, wie im folgenden Beispiel gezeigt.
```
[auth_provider]
; module = cassandra_sigv4.auth
; classname = SigV4AuthProvider
```
Nachdem Sie die `cqlshrc` Datei aktualisiert haben, können Sie mit dem folgenden Befehl eine Verbindung zu Amazon Keyspaces mit dienstspezifischen Anmeldeinformationen herstellen.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 -u myUserName -p myPassword --ssl
```
**Bereinigen**
+ Um das `cqlsh-expansion` Paket zu entfernen, können Sie den `pip uninstall` Befehl verwenden.
```
pip3 uninstall cqlsh-expansion
```
Der `pip3 uninstall` Befehl entfernt nicht das Verzeichnis und die zugehörigen Dateien, die durch das Post-Installationsskript erstellt wurden. Um den Ordner und die Dateien zu entfernen, die durch das Post-Installationsskript erstellt wurden, können Sie das `.cassandra` Verzeichnis löschen.
## Wie konfiguriert man `cqlsh` Verbindungen für TLS manuell
Amazon Keyspaces akzeptiert nur sichere Verbindungen mit Transport Layer Security (TLS). Sie können das `cqlsh-expansion` Hilfsprogramm verwenden, das die Zertifikate automatisch für Sie herunterlädt und eine vorkonfigurierte `cqlshrc` Konfigurationsdatei installiert. Weitere Informationen finden Sie [Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](#using_cqlsh) auf dieser Seite.
Wenn Sie die Zertifikate herunterladen und die Verbindung manuell konfigurieren möchten, können Sie dies mit den folgenden Schritten tun.
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. 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
```
1. Öffnen Sie beispielsweise die `cqlshrc` Konfigurationsdatei im Cassandra-Home-Verzeichnis `${HOME}/.cassandra/cqlshrc` und fügen Sie die folgenden Zeilen hinzu.
```
[connection]
port = 9142
factory = cqlshlib.ssl.ssl_transport_factory
[ssl]
validate = true
certfile = path_to_file/keyspaces-bundle.pem
```
# Verwenden von AWS CLI , um eine Verbindung zu Amazon Keyspaces herzustellen
Sie können die AWS Command Line Interface (AWS CLI) verwenden, um mehrere AWS Dienste von der Befehlszeile aus zu steuern und sie mithilfe von Skripten zu automatisieren. Mit Amazon Keyspaces können Sie DDL-Operationen (Data Definition Language) verwenden, z. B. das Erstellen einer Tabelle. AWS CLI Darüber hinaus können Sie Dienste und Tools wie Terraform (Infrastructure as Code, IaC) verwenden. AWS CloudFormation
Bevor Sie das AWS CLI mit Amazon Keyspaces verwenden können, benötigen Sie eine Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel. Weitere Informationen finden Sie unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
Eine vollständige Liste aller Befehle, die für Amazon Keyspaces in verfügbar sind AWS CLI, finden Sie in der [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/index.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/index.html)
**Topics**
+ [Herunterladen und Konfigurieren des AWS CLI](#access.cli.installcli)
+ [Verwenden von AWS CLI mit Amazon Keyspaces](#access.cli.usingcli)
## Herunterladen und Konfigurieren des AWS CLI
Das AWS CLI ist verfügbar unter[https://aws.amazon.com/cli](https://aws.amazon.com/cli). Sie kann auf Windows, macOS oder Linux ausgeführt werden. Gehen Sie nach dem Herunterladen wie folgt vor AWS CLI, um es zu installieren und zu konfigurieren:
1. Gehen Sie [AWS Command Line Interface zum Benutzerhandbuch](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)
1. Folgen Sie den Anweisungen [zur Installation AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) und [Konfiguration von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
## Verwenden von AWS CLI mit Amazon Keyspaces
Das Befehlszeilenformat besteht aus einem Amazon Keyspaces-Operationsnamen, gefolgt von den Parametern für diesen Vorgang. Das AWS CLI unterstützt eine Kurzsyntax für die Parameterwerte sowie JSON. Die folgenden Amazon Keyspaces-Beispiele verwenden AWS CLI Kurzsyntax. Weitere Informationen finden Sie unter [Verwenden der Kurzsyntax mit der AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-shorthand.html) CLI.
*Der folgende Befehl erstellt einen Schlüsselraum mit dem Namen catalog.*
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
Der Befehl gibt die Ressource Amazon Resource Name (ARN) in der Ausgabe zurück.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/"
}
```
Um zu bestätigen, dass der *Keyspace-Katalog* existiert, können Sie den folgenden Befehl verwenden.
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
Die Ausgabe des Befehls gibt die folgenden Werte zurück.
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/"
}
```
Der folgende Befehl erstellt eine Tabelle mit dem Namen *book\$1awards*. Der Partitionsschlüssel der Tabelle besteht aus den Spalten `year` `award` und der Gruppierungsschlüssel besteht aus den Spalten`rank`, `category` und beide Clusterspalten verwenden die aufsteigende Sortierreihenfolge. (Für eine bessere Lesbarkeit werden lange Befehle in diesem Abschnitt über mehrere Zeilen verteilt.)
```
aws keyspaces create-table --keyspace-name 'catalog' --table-name 'book_awards'
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},
{name=category,type=text}, {name=author,type=text},{name=book_title,type=text},{name=publisher,type=text}],
partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]'
```
Dieser Befehl führt zu der folgenden Ausgabe.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
Um die Metadaten und Eigenschaften der Tabelle zu bestätigen, können Sie den folgenden Befehl verwenden.
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
Dieser Befehl gibt die folgende Ausgabe zurück.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards",
"creationTimestamp": 1645564368.628,
"status": "ACTIVE",
"schemaDefinition": {
"allColumns": [
{
"name": "year",
"type": "int"
},
{
"name": "award",
"type": "text"
},
{
"name": "category",
"type": "text"
},
{
"name": "rank",
"type": "int"
},
{
"name": "author",
"type": "text"
},
{
"name": "book_title",
"type": "text"
},
{
"name": "publisher",
"type": "text"
}
],
"partitionKeys": [
{
"name": "year"
},
{
"name": "award"
}
],
"clusteringKeys": [
{
"name": "category",
"orderBy": "ASC"
},
{
"name": "rank",
"orderBy": "ASC"
}
],
"staticColumns": []
},
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": 1645564368.628
},
"encryptionSpecification": {
"type": "AWS_OWNED_KMS_KEY"
},
"pointInTimeRecovery": {
"status": "DISABLED"
},
"ttl": {
"status": "ENABLED"
},
"defaultTimeToLive": 0,
"comment": {
"message": ""
}
}
```
Beim Erstellen von Tabellen mit komplexen Schemas kann es hilfreich sein, die Schemadefinition der Tabelle aus einer JSON-Datei zu laden. Das Folgende ist ein Beispiel dafür. Laden Sie die JSON-Beispieldatei für die Schemadefinition von [schema\$1definition.zip](samples/schema_definition.zip) herunter und extrahieren Sie sie`schema_definition.json`, wobei Sie sich den Pfad zur Datei notieren. In diesem Beispiel befindet sich die JSON-Datei mit der Schemadefinition im aktuellen Verzeichnis. Informationen zu verschiedenen Dateipfadoptionen finden Sie unter [So laden Sie Parameter aus einer Datei](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html#cli-usage-parameters-file-how).
```
aws keyspaces create-table --keyspace-name 'catalog'
--table-name 'book_awards' --schema-definition 'file://schema_definition.json'
```
Die folgenden Beispiele zeigen, wie Sie eine einfache Tabelle mit dem Namen *MyTable* mit zusätzlichen Optionen erstellen. Beachten Sie, dass die Befehle zur besseren Lesbarkeit in separate Zeilen aufgeteilt sind. Dieser Befehl zeigt, wie eine Tabelle erstellt wird und:
+ stellt den Kapazitätsmodus der Tabelle ein
+ aktivieren Sie die Point-in-time Wiederherstellung für die Tabelle
+ setzen Sie den Standardwert Time to Live (TTL) für die Tabelle auf ein Jahr
+ fügen Sie zwei Tags für die Tabelle hinzu
```
aws keyspaces create-table --keyspace-name 'catalog' --table-name 'myTable'
--schema-definition 'allColumns=[{name=id,type=int},{name=name,type=text},{name=date,type=timestamp}],partitionKeys=[{name=id}]'
--capacity-specification 'throughputMode=PROVISIONED,readCapacityUnits=5,writeCapacityUnits=5'
--point-in-time-recovery 'status=ENABLED'
--default-time-to-live '31536000'
--tags 'key=env,value=test' 'key=dpt,value=sec'
```
Dieses Beispiel zeigt, wie Sie eine neue Tabelle erstellen, die einen vom Kunden verwalteten Schlüssel für die Verschlüsselung verwendet und TTL aktiviert hat, sodass Sie Ablaufdaten für Spalten und Zeilen festlegen können. Um dieses Beispiel auszuführen, müssen Sie den Ressourcen-ARN für den vom Kunden verwalteten AWS KMS Schlüssel durch Ihren eigenen Schlüssel ersetzen und sicherstellen, dass Amazon Keyspaces Zugriff darauf hat.
```
aws keyspaces create-table --keyspace-name 'catalog' --table-name 'myTable'
--schema-definition 'allColumns=[{name=id,type=int},{name=name,type=text},{name=date,type=timestamp}],partitionKeys=[{name=id}]'
--encryption-specification 'type=CUSTOMER_MANAGED_KMS_KEY,kmsKeyIdentifier=arn:aws:kms:us-east-1:111122223333:key/11111111-2222-3333-4444-555555555555'
--ttl 'status=ENABLED'
```
# Mithilfe der API eine Verbindung zu Amazon Keyspaces herstellen
Sie können das AWS SDK und das AWS Command Line Interface (AWS CLI) verwenden, um interaktiv mit Amazon Keyspaces zu arbeiten. Sie können die API für DDL-Operationen (Data Language Definition) verwenden, z. B. für die Erstellung eines Schlüsselraums oder einer Tabelle. Darüber hinaus können Sie Dienste und Tools wie Terraform (Infrastructure as Code, IaC) verwenden. AWS CloudFormation
Bevor Sie das AWS CLI mit Amazon Keyspaces verwenden können, benötigen Sie eine Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel. Weitere Informationen finden Sie unter [AWS Anmeldeinformationen für Amazon Keyspaces erstellen und konfigurieren](access.credentials.md).
Eine vollständige Liste aller Operationen, die für Amazon Keyspaces in der API verfügbar sind, finden Sie unter [https://docs.aws.amazon.com/keyspaces/latest/APIReference/Welcome.html](https://docs.aws.amazon.com/keyspaces/latest/APIReference/Welcome.html).
# 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
```
# Kontenübergreifenden Zugriff auf Amazon Keyspaces mit VPC-Endpunkten konfigurieren
Sie können separate Ressourcen erstellen und verwenden, um Ressourcen AWS-Konten zu isolieren und sie in verschiedenen Umgebungen zu verwenden, beispielsweise in der Entwicklungs- und Produktionsumgebung. Dieses Thema führt Sie durch den kontoübergreifenden Zugriff auf Amazon Keyspaces mithilfe von Schnittstellen-VPC-Endpunkten in einem. Amazon Virtual Private Cloud Weitere Informationen zur Konfiguration des kontoübergreifenden IAM-Zugriffs finden Sie im IAM-Benutzerhandbuch unter [Beispielszenario mit separaten Entwicklungs- und Produktionskonten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html#id_roles_common-scenarios_aws-accounts-example).
Weitere Informationen zu Amazon Keyspaces und privaten VPC-Endpunkten finden Sie unter. [Verwenden von Amazon Keyspaces mit Schnittstellen-VPC-Endpunkten](vpc-endpoints.md)
**Topics**
+ [Kontenübergreifenden Zugriff in einer gemeinsam genutzten VPC konfigurieren](access.cross-account.sharedVPC.md)
+ [Kontenübergreifenden Zugriff ohne gemeinsam genutzte VPC konfigurieren](access.cross-account.noVPC.setup.md)
# Konfigurieren Sie den kontoübergreifenden Zugriff auf Amazon Keyspaces mithilfe von VPC-Endpunkten in einer gemeinsam genutzten VPC
Sie können verschiedene Ressourcen erstellen AWS-Konten , um sie von Anwendungen zu trennen. Sie können beispielsweise ein Konto für Ihre Amazon Keyspaces-Tabellen, ein anderes Konto für Anwendungen in einer Entwicklungsumgebung und ein weiteres Konto für Anwendungen in einer Produktionsumgebung erstellen. Dieses Thema führt Sie durch die Konfigurationsschritte, die erforderlich sind, um den kontoübergreifenden Zugriff für Amazon Keyspaces mithilfe von VPC-Schnittstellen-Endpunkten in einer gemeinsam genutzten VPC einzurichten.
Ausführliche Schritte zur Konfiguration eines VPC-Endpunkts für Amazon Keyspaces finden Sie unter. [Schritt 3: Erstellen Sie einen VPC-Endpunkt für Amazon Keyspaces](vpc-endpoints-tutorial.create-endpoint.md)
In diesem Beispiel verwenden wir die folgenden drei Konten in einer gemeinsam genutzten VPC:
+ `Account A:111111111111`— Dieses Konto enthält die Infrastruktur, einschließlich der VPC-Endpunkte, der VPC-Subnetze und der Amazon Keyspaces-Tabellen.
+ `Account B:222222222222`— Dieses Konto enthält eine Anwendung in einer Entwicklungsumgebung, die eine Verbindung zur Amazon Keyspaces-Tabelle in `Account A:111111111111` herstellen muss.
+ `Account C:333333333333`— Dieses Konto enthält eine Anwendung in einer Produktionsumgebung, die eine Verbindung zur Amazon Keyspaces-Tabelle in `Account A:111111111111` herstellen muss.
![\[Diagramm, das drei verschiedene Konten zeigt, die derselben Organisation in derselben AWS-Region gehören und eine gemeinsam genutzte VPC verwenden.\]](http://docs.aws.amazon.com/de_de/keyspaces/latest/devguide/images/keyspaces_cross-account_sharedVPC.png)
`Account A:111111111111`ist das Konto, das die Ressourcen (eine Amazon Keyspaces-Tabelle) enthält, auf die zugegriffen werden `Account C:333333333333` muss `Account B:222222222222` und auf die zugegriffen werden muss, `Account A:111111111111` ebenso das *vertrauenswürdige* Konto. `Account B:222222222222`und `Account C:333333333333` sind die Konten bei den Principals, die Zugriff auf die Ressourcen (eine Amazon Keyspaces-Tabelle) benötigen`Account A:111111111111`, also `Account B:222222222222` `Account C:333333333333` die *vertrauenswürdigen* Konten. Das vertrauenswürdige Konto erteilt die Berechtigungen für die vertrauenswürdigen Konten, indem es sich eine IAM-Rolle teilt. Das folgende Verfahren beschreibt die Konfigurationsschritte, die in erforderlich sind. `Account A:111111111111`
**Konfiguration für `Account A:111111111111`**
1. Wird verwendet AWS Resource Access Manager , um eine Ressourcenfreigabe für das Subnetz zu erstellen und das private Subnetz mit `Account B:222222222222` und zu teilen. `Account C:333333333333`
`Account B:222222222222`und `Account C:333333333333` kann jetzt Ressourcen in dem Subnetz sehen und erstellen, das mit ihnen geteilt wurde.
1. Erstellen Sie einen privaten VPC-Endpunkt von Amazon Keyspaces, der von betrieben wird. AWS PrivateLink Dadurch werden mehrere Endpunkte in gemeinsam genutzten Subnetzen und DNS-Einträgen für den Amazon Keyspaces-Serviceendpunkt erstellt.
1. Erstellen Sie einen Amazon Keyspaces-Schlüsselraum und eine Tabelle.
1. Erstellen Sie eine IAM-Rolle in`Account A:111111111111`, die vollen Zugriff auf die Amazon Keyspaces-Tabelle und Lesezugriff auf die Amazon Keyspaces-Systemtabellen hat und die Amazon EC2 VPC-Ressourcen beschreiben kann, wie im folgenden Richtlinienbeispiel gezeigt.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "CrossAccountAccess",
"Effect": "Allow",
"Action": [
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeVpcEndpoints",
"cassandra:*"
],
"Resource": "*"
}
]
}
```
1. Konfigurieren Sie eine Vertrauensrichtlinie für die IAM-Rolle, `Account A:111111111111` sodass Sie die Rolle als `Account B:222222222222` vertrauenswürdige `Account C:333333333333` Konten übernehmen können. Dies wird im folgenden Beispiel veranschaulicht.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::222222222222:role/Cross-Account-Role-B",
"arn:aws:iam::333333333333:role/Cross-Account-Role-C"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
Weitere Informationen zu kontoübergreifenden IAM-Richtlinien finden Sie unter [Kontoübergreifende Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) im IAM-Benutzerhandbuch.
**`Account B:222222222222`Konfiguration in und `Account C:333333333333`**
1. Erstellen Sie in `Account B:222222222222` und `Account C:333333333333` neue Rollen und fügen Sie die folgende Richtlinie hinzu, die es dem Prinzipal ermöglicht, die in erstellte gemeinsame Rolle zu übernehmen`Account A:111111111111`.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
Dem Prinzipal die Übernahme der gemeinsamen Rolle zu ermöglichen, wird mithilfe der `AssumeRole` API von AWS -Security-Token-Service (AWS STS) implementiert. Weitere Informationen finden Sie im [IAM-Benutzerhandbuch unter Gewähren des Zugriffs für einen IAM-Benutzer in einem anderen AWS-Konto , den Sie besitzen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
1. In `Account B:222222222222` und können Sie Anwendungen erstellen`Account C:333333333333`, die das SIGV4 Authentifizierungs-Plugin verwenden, das es einer Anwendung ermöglicht, die gemeinsame Rolle zu übernehmen, um eine Verbindung zur Amazon Keyspaces-Tabelle herzustellen, die sich `Account A:111111111111` über den VPC-Endpunkt in der gemeinsam genutzten VPC befindet. Weitere Informationen zum SIGV4 Authentifizierungs-Plugin finden Sie unter. [Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.md) Weitere Informationen darüber, wie Sie eine Anwendung so konfigurieren, dass sie eine Rolle in einem anderen AWS Konto übernimmt, finden Sie unter [Authentifizierung und Zugriff](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) im *AWS SDKs Referenzhandbuch zu Tools*.
# Konfiguration des kontoübergreifenden Zugriffs auf Amazon Keyspaces ohne gemeinsame VPC
Wenn die Amazon Keyspaces-Tabelle und der private VPC-Endpunkt unterschiedlichen Konten gehören, sich aber keine VPC teilen, können Anwendungen trotzdem kontoübergreifende Verbindungen über VPC-Endpunkte herstellen. Weil die Konten die VPC-Endpunkte,, `Account A:111111111111``Account B:222222222222`, nicht gemeinsam nutzen und ihre eigenen VPC-Endpunkte `Account C:333333333333` benötigen. Für den Cassandra-Client-Treiber erscheint Amazon Keyspaces wie ein einzelner Knoten statt wie ein Cluster mit mehreren Knoten. Nach der Verbindung erreicht der Client-Treiber den DNS-Server, der einen der verfügbaren Endpunkte in der VPC des Kontos zurückgibt.
Sie können auch über verschiedene Konten hinweg auf Amazon Keyspaces-Tabellen zugreifen, ohne einen gemeinsamen VPC-Endpunkt zu haben, indem Sie die öffentlichen Endpunkte verwenden oder in jedem Konto einen privaten VPC-Endpunkt bereitstellen. Wenn Sie keine gemeinsam genutzte VPC verwenden, benötigt jedes Konto einen eigenen VPC-Endpunkt. In diesem `Account A:111111111111` Beispiel `Account C:333333333333` benötigen sie ihre eigenen VPC-Endpunkte`Account B:222222222222`, um auf die Tabelle in zuzugreifen. `Account A:111111111111` Bei Verwendung von VPC-Endpunkten in dieser Konfiguration erscheint Amazon Keyspaces für den Cassandra-Client-Treiber als Einzelknoten-Cluster und nicht als Cluster mit mehreren Knoten. Nach der Verbindung erreicht der Client-Treiber den DNS-Server, der einen der verfügbaren Endpunkte in der VPC des Kontos zurückgibt. Der Client-Treiber kann jedoch nicht auf die `system.peers` Tabelle zugreifen, um weitere Endpunkte zu ermitteln. Da weniger Hosts verfügbar sind, stellt der Treiber weniger Verbindungen her. Um dies anzupassen, erhöhen Sie die Verbindungspool-Einstellung des Treibers um den Faktor drei.
![\[Diagramm, das drei verschiedene Konten zeigt, die derselben Organisation in derselben Organisation AWS-Region ohne gemeinsame VPC gehören.\]](http://docs.aws.amazon.com/de_de/keyspaces/latest/devguide/images/keyspaces_cross-account_noVPC.png)
`Account A:111111111111`ist das Konto, das die Ressourcen (eine Amazon Keyspaces-Tabelle) enthält, auf die zugegriffen werden `Account C:333333333333` muss `Account B:222222222222` und auf die zugegriffen werden muss, `Account A:111111111111` ebenso das *vertrauenswürdige* Konto. `Account B:222222222222`und `Account C:333333333333` sind die Konten bei den Principals, die Zugriff auf die Ressourcen (eine Amazon Keyspaces-Tabelle) benötigen`Account A:111111111111`, also `Account B:222222222222` `Account C:333333333333` die *vertrauenswürdigen* Konten. Das vertrauenswürdige Konto erteilt die Berechtigungen für die vertrauenswürdigen Konten, indem es sich eine IAM-Rolle teilt. Das folgende Verfahren beschreibt die Konfigurationsschritte, die in erforderlich sind. `Account A:111111111111`
**Konfiguration für `Account A:111111111111`**
1. Erstellen Sie einen Amazon Keyspaces-Schlüsselraum und eine Tabelle darin. `Account A:111111111111`
1. Erstellen Sie eine IAM-Rolle in`Account A:111111111111`, die vollen Zugriff auf die Amazon Keyspaces-Tabelle und Lesezugriff auf die Amazon Keyspaces-Systemtabellen hat.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:Select",
"cassandra:Modify"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111111111111:/keyspace/mykeyspace/table/mytable",
"arn:aws:cassandra:us-east-1:111111111111:/keyspace/system*"
]
}
]
}
```
1. Konfigurieren Sie eine Vertrauensrichtlinie für die IAM-Rolle in, `Account A:111111111111` sodass Prinzipale die Rolle als `Account B:222222222222` vertrauenswürdige `Account C:333333333333` Konten übernehmen können. Dies wird im folgenden Beispiel veranschaulicht.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::222222222222:role/Cross-Account-Role-B",
"arn:aws:iam::333333333333:role/Cross-Account-Role-C"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
Weitere Informationen zu kontoübergreifenden IAM-Richtlinien finden Sie unter [Kontoübergreifende Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) im IAM-Benutzerhandbuch.
1. Konfigurieren Sie den VPC-Endpunkt in `Account A:111111111111` und fügen Sie dem Endpunkt Berechtigungen hinzu, die es den Rollen von `Account B:222222222222` und `Account C:333333333333` die Übernahme der Rolle bei der `Account A` Verwendung des VPC-Endpunkts ermöglichen. Diese Berechtigungen gelten für den VPC-Endpunkt, an den sie angehängt sind. Weitere Informationen zu VPC-Endpunktrichtlinien finden Sie unter[Steuerung des Zugriffs auf VPC-Schnittstellen-Endpunkte für Amazon Keyspaces](vpc-endpoints.md#interface-vpc-endpoints-policies).
```
{{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccessfromSpecificIAMroles",
"Effect": "Allow",
"Action": "cassandra:*",
"Resource": "*",
"Principal": "*",
"Condition": {
"ArnEquals": {
"aws:PrincipalArn": [
"arn:aws:iam::222222222222:role/Cross-Account-Role-B",
"arn:aws:iam::333333333333:role/Cross-Account-Role-C"
]
}
}
}
]
}
```
**Konfiguration in und `Account B:222222222222` `Account C:333333333333`**
1. Erstellen Sie in `Account B:222222222222` und `Account C:333333333333` neue Rollen und fügen Sie die folgende Richtlinie hinzu, die es dem Prinzipal ermöglicht, die in erstellte gemeinsame Rolle zu übernehmen`Account A:111111111111`.
```
{
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111111111111:role/keyspaces_access"
}
}
```
Dem Prinzipal die Übernahme der gemeinsamen Rolle zu ermöglichen, wird mithilfe der `AssumeRole` API von AWS -Security-Token-Service (AWS STS) implementiert. Weitere Informationen finden Sie im [IAM-Benutzerhandbuch unter Gewähren des Zugriffs für einen IAM-Benutzer in einem anderen AWS-Konto , den Sie besitzen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
1. In `Account B:222222222222` und können Sie Anwendungen erstellen`Account C:333333333333`, die das SIGV4 Authentifizierungs-Plugin verwenden, das es einer Anwendung ermöglicht, die gemeinsame Rolle zu übernehmen, um eine Verbindung mit der Amazon Keyspaces-Tabelle herzustellen, die sich in `Account A:111111111111` befindet. Weitere Informationen zum SIGV4 Authentifizierungs-Plugin finden Sie unter[Anmeldeinformationen für den programmatischen Zugriff auf Amazon Keyspaces erstellen](programmatic.credentials.md). Weitere Informationen darüber, wie Sie eine Anwendung so konfigurieren, dass sie eine Rolle in einem anderen AWS Konto übernimmt, finden Sie unter [Authentifizierung und Zugriff](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) im *AWS SDKs Referenzhandbuch zu Tools*.