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.
# Tutorial: Stellen Sie über einen VPC-Endpunkt mit einer Schnittstelle eine Verbindung zu Amazon Keyspaces her
Dieses Tutorial führt Sie durch die Einrichtung und Verwendung eines Schnittstellen-VPC-Endpunkts für Amazon Keyspaces.
*Schnittstellen-VPC-Endpunkte* ermöglichen die private Kommunikation zwischen Ihrer Virtual Private Cloud (VPC), die in Amazon VPC ausgeführt wird, und Amazon Keyspaces. Schnittstelle AWS PrivateLink, über die VPC-Endpunkte betrieben werden. Dabei handelt es sich um einen AWS Dienst, der die private Kommunikation zwischen VPCs Diensten ermöglicht. AWS Weitere Informationen finden Sie unter [Verwenden von Amazon Keyspaces mit Schnittstellen-VPC-Endpunkten](vpc-endpoints.md).
**Topics**
+ [
# Voraussetzungen und Überlegungen zum Tutorial
](vpc-endpoints-tutorial.before-you-begin.md)
+ [
# Schritt 1: Starten einer Amazon-EC2-Instance
](vpc-endpoints-tutorial.launch-ec2-instance.md)
+ [
# Schritt 2: Konfigurieren Ihrer Amazon-EC2-Instance
](vpc-endpoints-tutorial.configure-ec2-instance.md)
+ [
# Schritt 3: Erstellen Sie einen VPC-Endpunkt für Amazon Keyspaces
](vpc-endpoints-tutorial.create-endpoint.md)
+ [
# Schritt 4: Berechtigungen für die VPC-Endpunktverbindung konfigurieren
](vpc-endpoints-tutorial.permissions.md)
+ [
# Schritt 5: Konfigurieren Sie die Überwachung mit CloudWatch
](vpc-endpoints-tutorial.monitoring.md)
+ [
# Schritt 6: (Optional) Bewährte Methoden zur Konfiguration der Größe des Verbindungspools für Ihre Anwendung
](vpc-endpoints-tutorial.connections.md)
+ [
# Schritt 7: (Optional) Aufräumen
](vpc-endpoints-tutorial.clean-up.md)
# Voraussetzungen und Überlegungen zum Tutorial
Bevor Sie mit diesem Tutorial beginnen, folgen Sie den Anweisungen zur AWS Einrichtung unter. [Zugreifen auf Amazon Keyspaces (für Apache Cassandra)](accessing.md) Zu diesen Schritten gehören die Registrierung AWS und Erstellung eines AWS Identity and Access Management (IAM-) Principals mit Zugriff auf Amazon Keyspaces. Notieren Sie sich den Namen des IAM-Benutzers und die Zugriffsschlüssel, da Sie sie später in diesem Tutorial benötigen.
Erstellen Sie einen Schlüsselraum mit dem Namen `myKeyspace` und mindestens einer Tabelle, um die Verbindung mit dem VPC-Endpunkt weiter unten in diesem Tutorial zu testen. Eine ausführliche Anleitung finden Sie unter. [Erste Schritte mit Amazon Keyspaces (für Apache Cassandra)](getting-started.md)
Nachdem Sie die erforderlichen Schritte abgeschlossen haben, fahren Sie mit fort[Schritt 1: Starten einer Amazon-EC2-Instance](vpc-endpoints-tutorial.launch-ec2-instance.md).
# Schritt 1: Starten einer Amazon-EC2-Instance
In diesem Schritt starten Sie eine Amazon-EC2-Instance in Ihrer Standard-Amazon-VPC. Anschließend können Sie einen VPC-Endpunkt für Amazon Keyspaces erstellen und verwenden.
**So starten Sie eine Amazon EC2 Instance**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie **Launch Instance** aus und gehen Sie folgendermaßen vor:
Wählen Sie im Dashboard der EC2-Konsole im Feld **Launch Instance** die Option **Launch Instance** und dann aus den angezeigten Optionen **Launch Instance** aus.
Geben Sie unter **Name und Tags** für **Name** einen aussagekräftigen Namen für Ihre Instance ein.
Unter **Anwendungs- und Betriebssystem-Images (Amazon Machine Image)**:
+ Wählen Sie „**Schnellstart**“ und anschließend „Ubuntu“. Dies ist das Betriebssystem für Ihre Instance.
+ Unter **Amazon Machine Image (AMI)** können Sie das Standard-Image verwenden, für das das **kostenlose Kontingent gilt**. Ein *Amazon Machine Image (AMI)* dient als grundlegende Konfigurationsvorlage für Ihre Instance.
Unter **Instanztyp**:
+ Wählen Sie aus der Liste **Instance-Typ** den Instance-Typ **t2.micro** aus, der standardmäßig ausgewählt ist.
Wählen Sie unter **Schlüsselpaar (Anmeldung)** für **Name des Schlüsselpaars** eine der folgenden Optionen für dieses Tutorial aus:
+ Wenn Sie nicht über ein Amazon-EC2-Schlüsselpaar verfügen, wählen Sie **Neues Schlüsselpaar erstellen** aus und befolgen Sie die Anweisungen. Sie werden aufgefordert, eine private Schlüsseldatei (*.pem-Datei*) herunterzuladen. Sie benötigen diese Datei später, wenn Sie sich bei Ihrer Amazon EC2 EC2-Instance anmelden. Notieren Sie sich also den Dateipfad.
+ Wenn Sie bereits über ein bestehendes Amazon-EC2-Schlüsselpaar verfügen, navigieren Sie zu ** Schlüsselpaar wählen** und wählen Sie Ihr Schlüsselpaar aus der Liste aus. Beachten Sie, dass Sie bereits über die private Schlüsseldatei (*.pem*-Datei) verfügen müssen, um sich bei Ihrer Amazon-EC2-Instance anmelden zu können.
Unter **Netzwerkeinstellungen**:
+ Wählen Sie **Bearbeiten** aus.
+ Wählen Sie **Bestehende Sicherheitsgruppe auswählen** aus.
+ Wählen Sie in der Liste der Sicherheitsgruppen **default** aus. Dies ist die Standard-Sicherheitsgruppe für Ihre VPC.
Fahren Sie mit der **Zusammenfassung** fort.
+ Sehen Sie sich im Bereich Zusammenfassung eine **Zusammenfassung** Ihrer Instanzkonfiguration an. Sobald Sie bereit sind, wählen Sie **Instance starten** aus.
1. Wählen Sie auf dem Abschlussbildschirm für die neue Amazon EC2 EC2-Instance die Kachel **Connect to Instance** aus. Der nächste Bildschirm zeigt die erforderlichen Informationen und die erforderlichen Schritte, um eine Verbindung zu Ihrer neuen Instance herzustellen. Notieren Sie sich die folgenden Informationen:
+ Der Beispielbefehl zum Schutz der Schlüsseldatei
+ Die Verbindungszeichenfolge
+ Der **öffentliche IPv4 DNS-Name**
Nachdem Sie die Informationen auf dieser Seite zur Kenntnis genommen haben, können Sie mit dem nächsten Schritt in diesem Tutorial fortfahren ([Schritt 2: Konfigurieren Ihrer Amazon-EC2-Instance](vpc-endpoints-tutorial.configure-ec2-instance.md)).
**Anmerkung**
Es dauert einige Minuten, bis Ihre Amazon-EC2-Instance verfügbar ist. Überprüfen Sie, ob **Instance-Zustand** `running` wird und alle **Status-Kontrollen** bestanden hat, bevor Sie mit dem nächsten Schritt fortfahren.
# Schritt 2: Konfigurieren Ihrer Amazon-EC2-Instance
Wenn Ihre Amazon EC2 EC2-Instance verfügbar ist, können Sie sich bei ihr anmelden und sie für die erste Verwendung vorbereiten.
**Anmerkung**
Bei den folgenden Schritten wird davon ausgegangen, dass Sie von einem Computer aus, auf dem Linux ausgeführt wird, eine Verbindung zu Ihrer Amazon EC2 EC2-Instance herstellen. Weitere Verbindungsmöglichkeiten finden Sie unter [Connect to your Linux Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
**So konfigurieren Sie Ihre Amazon EC2 EC2-Instance**
1. Sie müssen eingehenden SSH-Verkehr zu Ihrer Amazon EC2 EC2-Instance autorisieren. Erstellen Sie dazu eine neue EC2-Sicherheitsgruppe und weisen Sie die Sicherheitsgruppe dann Ihrer EC2-Instance zu.
1. Wählen Sie im Navigationsbereich **Sicherheitsgruppen** aus.
1. Wählen Sie **Sicherheitsgruppen erstellen** aus. Führen Sie im Fenster **Sicherheitsgruppen erstellen** Folgendes aus:
+ **Name der Sicherheitsgruppe** — Geben Sie einen Namen für Ihre Sicherheitsgruppe ein. Beispiel: `my-ssh-access`
+ **Beschreibung** — Geben Sie eine kurze Beschreibung für die Sicherheitsgruppe ein.
+ **VPC** — Wählen Sie Ihre Standard-VPC.
+ Wählen Sie im Abschnitt **Eingehende Regeln** die Option **Regel hinzufügen** aus und gehen Sie wie folgt vor:
+ **Typ** — Wählen Sie **SSH**.
+ **Quelle** — Wähle **meine IP**.
+ Wählen Sie **Regel hinzufügen** aus.
Bestätigen Sie unten auf der Seite die Konfigurationseinstellungen und wählen Sie **Create Security Group** aus.
1. Wählen Sie im Navigationsbereich **Instances** aus.
1. Wählen Sie die Amazon-EC2-Instance aus, die Sie in [Schritt 1: Starten einer Amazon-EC2-Instance](vpc-endpoints-tutorial.launch-ec2-instance.md) gestartet haben.
1. Wählen Sie **Aktionen**, **Sicherheit** und dann **Sicherheitsgruppen ändern** aus.
1. Gehen Sie **unter Sicherheitsgruppen ändern** zu **Zugeordnete Sicherheitsgruppen** und geben Sie die Sicherheitsgruppe ein, die Sie zuvor in diesem Verfahren erstellt haben (z. B.`my-ssh-access`). Die vorhandene `default`-Sicherheitsgruppe sollte ebenfalls ausgewählt werden. Bestätigen Sie die Konfigurationseinstellungen und wählen Sie **Speichern**.
1. Verwenden Sie den folgenden Befehl, um Ihre private Schlüsseldatei vor Zugriff zu schützen. Wenn Sie diesen Schritt überspringen, schlägt die Verbindung fehl.
```
chmod 400 path_to_file/my-keypair.pem
```
1. Verwenden Sie den Befehl `ssh`, wie im folgenden Beispiel gezeigt, um sich bei der Amazon-EC2-Instance anzumelden.
```
ssh -i path_to_file/my-keypair.pem ubuntu@public-dns-name
```
Sie müssen Ihre private Schlüsseldatei (*.pem-Datei*) und den öffentlichen DNS-Namen Ihrer Instance angeben. (Siehe [Schritt 1: Starten einer Amazon-EC2-Instance](vpc-endpoints-tutorial.launch-ec2-instance.md)).
Die Anmelde-ID lautet `ubuntu`. Es ist kein Passwort erforderlich.
Weitere Informationen zum Zulassen von Verbindungen zu Ihrer Amazon EC2 EC2-Instance und AWS CLI Anweisungen finden Sie unter [Autorisieren von eingehendem Datenverkehr für Ihre Linux-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) im *Amazon EC2 EC2-Benutzerhandbuch*.
1. Laden Sie die neueste Version von herunter und installieren Sie sie. AWS Command Line Interface
1. Installieren `unzip`.
```
sudo apt install unzip
```
1. Laden Sie die `zip` Datei mit dem herunter AWS CLI.
```
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
```
1. Entpacken Sie die Datei.
```
unzip awscliv2.zip
```
1. Installiere das AWS CLI.
```
sudo ./aws/install
```
1. Bestätigen Sie die Version der AWS CLI Installation.
```
aws --version
```
Die Ausgabe sollte in etwa wie folgt aussehen:
```
aws-cli/2.9.19 Python/3.9.11 Linux/5.15.0-1028-aws exe/x86_64.ubuntu.22 prompt/off
```
1. Konfigurieren Sie Ihre AWS Anmeldeinformationen, wie im folgenden Beispiel gezeigt. Geben Sie Ihre AWS Zugriffsschlüssel-ID, Ihren geheimen Schlüssel und den Namen der Standardregion ein, wenn Sie dazu aufgefordert werden.
```
aws configure
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-east-1
Default output format [None]:
```
1. Fügen Sie Ihrer VPCs Sicherheitsgruppe Regeln hinzu, die eingehenden HTTP-, HTTPS- und SSH-Zugriff von Adressen aus IPv6 zulassen.
1. Um zu bestätigen, dass Ihr VPC-Endpunkt korrekt konfiguriert wurde, müssen Sie eine `cqlsh` Verbindung zu Amazon Keyspaces verwenden. Wenn Sie Ihre lokale Umgebung oder den Amazon Keyspaces CQL-Editor in der verwenden AWS-Managementkonsole, erfolgt die Verbindung automatisch über den öffentlichen Endpunkt statt über Ihren VPC-Endpunkt. Um Ihre VPC-Endpunktverbindung in diesem Tutorial `cqlsh` zu testen, folgen Sie den Anweisungen zur Einrichtung unter. [Verwenden`cqlsh`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md)
Sie sind jetzt bereit, einen Dual-Stack-VPC-Endpunkt für Amazon Keyspaces zu erstellen.
# Schritt 3: Erstellen Sie einen VPC-Endpunkt für Amazon Keyspaces
In diesem Schritt erstellen Sie einen Dual-Stack-VPC-Endpunkt für Amazon Keyspaces mithilfe von. AWS CLI*Um den VPC-Endpunkt mithilfe der VPC-Konsole zu erstellen, können Sie den Anweisungen zum [Erstellen eines VPC-Endpunkts](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint) im Handbuch folgen.AWS PrivateLink * Geben Sie ein, wenn Sie nach dem **Dienstnamen** filtern. **Cassandra**
**So erstellen Sie einen VPC-Endpunkt mit dem AWS CLI**
1. Bevor Sie beginnen, stellen Sie sicher, dass Sie über den öffentlichen Endpunkt mit Amazon Keyspaces kommunizieren können.
```
aws keyspaces list-tables --keyspace-name 'myKeyspace'
```
Die Ausgabe zeigt eine Liste von Amazon Keyspaces-Tabellen, die im angegebenen Schlüsselraum enthalten sind. Wenn Sie keine Tabellen haben, ist die Liste leer.
```
{
"tables": [
{
"keyspaceName": "myKeyspace",
"tableName": "myTable1",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/myTable1"
},
{
"keyspaceName": "myKeyspace",
"tableName": "myTable2",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/myTable2"
}
]
}
```
1. Stellen Sie sicher, dass Amazon Keyspaces ein verfügbarer Service für die Erstellung von VPC-Endpunkten in der aktuellen Region ist. AWS (Der Befehl wird in Fettschrift angezeigt, gefolgt von einer Beispielausgabe.)
```
aws ec2 describe-vpc-endpoint-services
{
"ServiceNames": [
"com.amazonaws.us-east-1.cassandra",
"com.amazonaws.us-east-1.cassandra-fips"
"api.aws.us-east-1.cassandra-streams"
]
}
```
Wenn Amazon Keyspaces einer der verfügbaren Dienste in der Ausgabe des Befehls ist, können Sie mit der Erstellung eines VPC-Endpunkts fortfahren.
1. Um über IPv6 aktivierte Dual-Stack-Endpunkte eine Verbindung zu Amazon Keyspaces herzustellen, stellen Sie sicher, dass Ihre VPC Subnetze unterstützt, IPv6 und konfigurieren Sie sie mit Support. IPv6 Informationen zum Hinzufügen von IPv6 Unterstützung zu einer bestehenden VPC, die derzeit nur unterstützt IPv4, finden Sie unter [ IPv6 Support für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/) im *Amazon VPC-Benutzerhandbuch;*.
1. Ermitteln Sie den VPC-Bezeichner.
```
aws ec2 describe-vpcs
{
"Vpcs": [
{
"OwnerId": "111122223333",
"InstanceTenancy": "default",
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-0000aaa0a00a00aa0",
"Ipv6CidrBlock": "2600:1f18:e19:7d00::/56",
"Ipv6CidrBlockState": {
"State": "associated"
},
"NetworkBorderGroup": "us-east-1",
"Ipv6Pool": "Amazon",
"Ipv6AddressAttribute": "public",
"IpSource": "amazon"
}
],
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-00a0000a",
"CidrBlock": "111.11.0.0/16",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": true,
"BlockPublicAccessStates": {
"InternetGatewayBlockMode": "off"
},
"VpcId": "vpc-a1234bcd",
"State": "available",
"CidrBlock": "111.11.0.0/16",
"DhcpOptionsId": "dopt-a00aaaaa"
}
]
}
```
In der Beispielausgabe ist die VPC-ID `vpc-a1234bcd`.
1. Verwenden Sie einen Filter, um Details zu den Subnetzen der VPC zu sammeln.
```
aws ec2 describe-subnets --filters "Name=vpc-id,Values=vpc-a1234bcd"
{
"Subnets": [
{
"AvailabilityZoneId": "use1-az1",
"MapCustomerOwnedIpOnLaunch": false,
"OwnerId": "111122223333",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "subnet-cidr-assoc-05d75732736740283",
"Ipv6CidrBlock": "***********************",
"Ipv6CidrBlockState": {
"State": "associated"
},
"Ipv6AddressAttribute": "public",
"IpSource": "amazon"
}
],
"SubnetArn": "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-70b24b16",
"EnableDns64": false,
"Ipv6Native": false,
"PrivateDnsNameOptionsOnLaunch": {
"HostnameType": "ip-name",
"EnableResourceNameDnsARecord": false,
"EnableResourceNameDnsAAAARecord": false
},
"BlockPublicAccessStates": {
"InternetGatewayBlockMode": "off"
},
"SubnetId": "subnet-70b24b16",
"State": "available",
"VpcId": "vpc-a1234bcd",
"CidrBlock": "**********/20",
"AvailableIpAddressCount": 4089,
"AvailabilityZone": "us-east-1a",
"DefaultForAz": true,
"MapPublicIpOnLaunch": true
},
{
"AvailabilityZoneId": "use1-az2",
"MapCustomerOwnedIpOnLaunch": false,
"OwnerId": "111122223333",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "subnet-cidr-assoc-0ec6fb253e05b17eb",
"Ipv6CidrBlock": "***********************",
"Ipv6CidrBlockState": {
"State": "associated"
},
"Ipv6AddressAttribute": "public",
"IpSource": "amazon"
}
],
"SubnetArn": "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-c63ffbe7",
"EnableDns64": false,
"Ipv6Native": false,
"PrivateDnsNameOptionsOnLaunch": {
"HostnameType": "ip-name",
"EnableResourceNameDnsARecord": false,
"EnableResourceNameDnsAAAARecord": false
},
"BlockPublicAccessStates": {
"InternetGatewayBlockMode": "off"
},
"SubnetId": "subnet-c63ffbe7",
"State": "available",
"VpcId": "vpc-a1234bcd",
"CidrBlock": "***********/20",
"AvailableIpAddressCount": 4087,
"AvailabilityZone": "us-east-1b",
"DefaultForAz": true,
"MapPublicIpOnLaunch": true
}
]
}
```
In der Beispielausgabe sind zwei Subnetze IDs verfügbar: und. `subnet-70b24b16` `subnet-c63ffbe7`
1. Erstellen des VPC-Endpunkts Geben Sie für den Parameter `--vpc-id` die VPC-ID aus dem vorherigen Schritt an. Geben Sie für den `--subnet-ids` Parameter das Subnetz IDs aus dem vorherigen Schritt an. Verwenden Sie den `--vpc-endpoint-type` Parameter, um den Endpunkt als Schnittstelle zu definieren. Um einen Dual-Stack-Endpunkt zu erstellen, verwenden Sie`--ip-address-type dualstack`. Weitere Informationen zu dem Befehl finden Sie [https://docs.aws.amazon.com/cli/latest/reference/ec2/create-vpc-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-vpc-endpoint.html)in der *AWS CLI Befehlsreferenz.*
```
aws ec2 create-vpc-endpoint \
--vpc-endpoint-type Interface \
--vpc-id vpc-a1234bcd \
--ip-address-type dualstack \
--service-name com.amazonaws.us-east-1.cassandra \
--subnet-ids subnet-70b24b16 subnet-c63ffbe7
{
"VpcEndpoint": {
"VpcEndpointId": "vpce-000000abc111d2ef3",
"VpcEndpointType": "Interface",
"VpcId": "vpc-a1234bcd",
"ServiceName": "com.amazonaws.us-east-1.cassandra",
"State": "pending",
"RouteTableIds": [],
"SubnetIds": [
"subnet-70b24b16",
"subnet-c63ffbe7"
],
"Groups": [
{
"GroupId": "sg-0123456789",
"GroupName": "default"
}
],
"IpAddressType": "dualstack",
"DnsOptions": {
"DnsRecordIpType": "dualstack"
},
"PrivateDnsEnabled": true,
"RequesterManaged": false,
"NetworkInterfaceIds": [
"eni-08cd525f72ea6f1fa",
"eni-07b1f6c895169d8fb"
],
"DnsEntries": [
{
"DnsName": "vpce-0000000000-1234567.cassandra.us-east-1.vpce.amazonaws.com",
"HostedZoneId": "Z7HUB22UULQXV"
},
{
"DnsName": "vpce-0000000000-1234567-us-east-1a.cassandra.us-east-1.vpce.amazonaws.com",
"HostedZoneId": "Z7HUB22UULQXV"
},
{
"DnsName": "cassandra.us-east-1.amazonaws.com",
"HostedZoneId": "ZONEIDPENDING"
},
{
"DnsName": "cassandra.us-east-1.api.aws",
"HostedZoneId": "ZONEIDPENDING"
}
],
"CreationTimestamp": "2025-09-19T15:19:19.266000+00:00",
"OwnerId": "111122223333",
"ServiceRegion": "us-east-1"
}
}
```
# Schritt 4: Berechtigungen für die VPC-Endpunktverbindung konfigurieren
Die Verfahren in diesem Schritt zeigen, wie Regeln und Berechtigungen für die Verwendung des VPC-Endpunkts mit Amazon Keyspaces konfiguriert werden.
**Um eine eingehende Regel für den neuen Endpunkt zu konfigurieren, um eingehenden TCP-Verkehr zuzulassen**
1. Wählen Sie in der Amazon VPC-Konsole im linken Bereich **Endpoints und dann den Endpoint** aus, den Sie im vorherigen Schritt erstellt haben.
1. Wählen Sie **Sicherheitsgruppen verwalten** und wählen Sie dann die Sicherheitsgruppe aus, die diesem Endpunkt zugeordnet ist.
1. Wählen Sie **Eingehende Regeln** und dann Regeln für **eingehenden Datenverkehr bearbeiten** aus.
1. Fügen Sie eine Regel für eingehenden Datenverkehr mit dem **Typ** **CQLSH**/CASSANDRA hinzu. **Dadurch wird der **Portbereich** automatisch auf 9142 festgelegt.**
1. Um die neue Regel für eingehenden Datenverkehr zu speichern, wählen Sie Regeln **speichern**.
**Um IAM-Benutzerberechtigungen zu konfigurieren**
1. Vergewissern Sie sich, dass der IAM-Benutzer, der für die Verbindung zu Amazon Keyspaces verwendet wurde, über die entsprechenden Berechtigungen verfügt. In AWS Identity and Access Management (IAM) können Sie die AWS verwaltete Richtlinie verwenden, `AmazonKeyspacesReadOnlyAccess` um dem IAM-Benutzer Lesezugriff auf Amazon Keyspaces zu gewähren.
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 auf dem IAM-Konsolen-Dashboard **Users** (Benutzer) und anschließend Ihren IAM-Benutzer aus der Liste aus.
1. Wählen Sie auf der Seite **Summary** (Übersicht) die Option **Add permissions** (Berechtigungen hinzufügen) aus.
1. Wählen Sie **Attach existing policies directly** (Vorhandene Richtlinien direkt zuordnen).
1. Wählen Sie **AmazonKeyspacesReadOnlyAccess**in der Liste der Richtlinien die Option und anschließend **Weiter: Überprüfen** aus.
1. Wählen Sie **Add permissions** (Berechtigungen hinzufügen) aus.
1. Stellen Sie sicher, dass Sie über den VPC-Endpunkt auf Amazon Keyspaces zugreifen können.
```
aws keyspaces list-tables --keyspace-name 'my_Keyspace'
```
Wenn Sie möchten, können Sie einige andere AWS CLI Befehle für Amazon Keyspaces ausprobieren. Weitere Informationen finden Sie in der [AWS CLI -Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/).
**Anmerkung**
Die Mindestberechtigungen, die ein IAM-Benutzer oder eine IAM-Rolle für den Zugriff auf Amazon Keyspaces benötigt, sind Leseberechtigungen für die Systemtabelle, wie in der folgenden Richtlinie dargestellt. Weitere Informationen zu richtlinienbasierten Berechtigungen finden Sie unter. [Beispiele für identitätsbasierte Richtlinien von Amazon Keyspaces](security_iam_id-based-policy-examples.md)
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:Select"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
]
}
]
}
```
1. Gewähren Sie dem IAM-Benutzer Lesezugriff auf die Amazon EC2 EC2-Instance mit der VPC.
Wenn Sie Amazon Keyspaces mit VPC-Endpunkten verwenden, müssen Sie dem IAM-Benutzer oder der IAM-Rolle, der auf Amazon Keyspaces zugreift, *nur Leseberechtigungen für Ihre Amazon EC2 EC2-Instance und die VPC gewähren, um Endpunkt- und* Netzwerkschnittstellendaten zu sammeln. Amazon Keyspaces speichert diese Informationen in der `system.peers` Tabelle und verwendet sie zur Verwaltung von Verbindungen.
**Anmerkung**
Die verwalteten Richtlinien `AmazonKeyspacesReadOnlyAccess_v2` `AmazonKeyspacesFullAccess` enthalten die erforderlichen Berechtigungen, damit Amazon Keyspaces auf die Amazon EC2 EC2-Instance zugreifen kann, um Informationen über verfügbare Schnittstellen-VPC-Endpunkte zu lesen.
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 Dashboard der IAM-Konsole die Option Richtlinien aus.**
1. Wählen Sie **Richtlinie erstellen** und dann die Registerkarte **JSON** aus.
1. Kopieren Sie die folgende Richtlinie und wählen Sie **Weiter: Tags**.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"ListVPCEndpoints",
"Effect":"Allow",
"Action":[
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeVpcEndpoints"
],
"Resource": "*"
}
]
}
```
1. Wählen Sie **Weiter: Überprüfen**, geben Sie den Namen `keyspacesVPCendpoint` für die Richtlinie ein und wählen Sie **Richtlinie erstellen** aus.
1. Wählen Sie auf dem IAM-Konsolen-Dashboard **Users** (Benutzer) und anschließend Ihren IAM-Benutzer aus der Liste aus.
1. Wählen Sie auf der Seite **Summary** (Übersicht) die Option **Add permissions** (Berechtigungen hinzufügen) aus.
1. Wählen Sie **Attach existing policies directly** (Vorhandene Richtlinien direkt zuordnen).
1. Wählen Sie in der Liste der Richtlinien **Keyspaces VPCendpoint** und dann **Weiter: Überprüfen** aus.
1. Wählen Sie **Add permissions** (Berechtigungen hinzufügen) aus.
1. Um zu überprüfen, ob die Amazon `system.peers` Keyspaces-Tabelle mit VPC-Informationen aktualisiert wird, führen Sie die folgende Abfrage von Ihrer Amazon EC2 EC2-Instance aus mit. `cqlsh` Wenn Sie in Schritt 2 noch nicht `cqlsh` auf Ihrer Amazon EC2 EC2-Instance installiert haben, folgen Sie den Anweisungen unter[Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md#using_cqlsh).
```
SELECT * FROM system.peers;
```
Die Ausgabe gibt Knoten mit privaten IPv6 IP-Adressen zurück, abhängig von Ihrer VPC- und Subnetzkonfiguration in Ihrer AWS Region.
```
peer | data_center | host_id | preferred_ip | rack | release_version | rpc_address | schema_version | tokens
-----------------------------------------+-------------+--------------------------------------+-----------------------------------------+-----------+-----------------+-----------------------------------------+--------------------------------------+---------------------------------------------
2600:1111:2222:3333:283b:8e6:d04f | us-east-1 | dddddddd-7a22-3582-a73d-49338a686a53 | 2600:1111:2222:3333:283b:8e6:d04f | us-east-1 | 3.11.2 | 2600:1111:2222:3333:283b:8e6:d04f | 05deae2d-6405-494d-a965-c0e5836bcb3c | {'85070591730234615865843651857942052863'}
2600:1111:2222:4444:7d26:5a09:1b44 | us-east-1 | 66666666-035d-37ef-a247-19a6a867ab09 | 2600:1111:2222:4444:7d26:5a09:1b44 | us-east-1 | 3.11.2 | 2600:1111:2222:4444:7d26:5a09:1b44 | 05deae2d-6405-494d-a965-c0e5836bcb3c | {'170141183460469231731687303715884105726'}
```
**Anmerkung**
Sie müssen eine `cqlsh` Verbindung zu Amazon Keyspaces verwenden, um zu bestätigen, dass Ihr VPC-Endpunkt korrekt konfiguriert wurde. Wenn Sie Ihre lokale Umgebung oder den Amazon Keyspaces CQL-Editor in der verwenden AWS-Managementkonsole, erfolgt die Verbindung automatisch über den öffentlichen Endpunkt statt über Ihren VPC-Endpunkt. Wenn Sie neun IP-Adressen sehen, sind dies die Einträge, die Amazon Keyspaces automatisch in die `system.peers` Tabelle für öffentliche Endpunktverbindungen schreibt.
# Schritt 5: Konfigurieren Sie die Überwachung mit CloudWatch
In diesem Schritt erfahren Sie, wie Sie Amazon verwenden CloudWatch , um die VPC-Endpunktverbindung zu Amazon Keyspaces zu überwachen.
AWS PrivateLink veröffentlicht Datenpunkte zu CloudWatch etwa Ihren Schnittstellen-Endpunkten. Mit den Metriken können Sie überprüfen, ob Ihr System die erwartete Leistung zeigt. Der `AWS/PrivateLinkEndpoints` Namespace in CloudWatch enthält die Metriken für Schnittstellenendpunkte. *Weitere Informationen finden Sie im Handbuch unter [CloudWatch AWS PrivateLink Metriken für](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-cloudwatch-metrics.html).AWS PrivateLink *
**So erstellen Sie ein CloudWatch Dashboard mit VPC-Endpunktmetriken**
1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie im Navigationsbereich **Dashboards** aus. Wählen Sie dann **Dashboard erstellen**. Geben Sie einen Namen für das Dashboard ein und wählen Sie **Erstellen**.
1. Wählen **Sie unter Widget hinzufügen** die Option **Zahl** aus.
1. Wählen Sie unter **Metrics** die Option **AWS/ PrivateLinkEndpoints** aus.
1. Wählen Sie **Endpunkttyp, Dienstname, VPC-Endpunkt-ID, VPC-ID** aus.
1. Wählen Sie die Metriken `ActiveConnections` und `NewConnections` dann Widget **erstellen** aus.
1. Speichern Sie das Dashboard.
Die `ActiveConnections` Metrik ist definiert als die Anzahl der gleichzeitigen aktiven Verbindungen, die der Endpunkt in der letzten Minute empfangen hat. Die `NewConnections` Metrik ist definiert als die Anzahl der neuen Verbindungen, die in der letzten Minute über den Endpunkt hergestellt wurden.
Weitere Informationen zum Erstellen von Dashboards finden Sie unter [Dashboard erstellen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create_dashboard.html) im *CloudWatch Benutzerhandbuch*.
# Schritt 6: (Optional) Bewährte Methoden zur Konfiguration der Größe des Verbindungspools für Ihre Anwendung
In diesem Abschnitt wird beschrieben, wie Sie die ideale Größe des Verbindungspools auf der Grundlage der Anforderungen an den Abfragedurchsatz Ihrer Anwendung ermitteln können.
Amazon Keyspaces erlaubt maximal 3.000 CQL-Abfragen pro Sekunde pro TCP-Verbindung. Die Anzahl der Verbindungen, die ein Treiber mit Amazon Keyspaces herstellen kann, ist also praktisch unbegrenzt. Wir empfehlen Ihnen jedoch, die Größe des Verbindungspools an die Anforderungen Ihrer Anwendung anzupassen und die verfügbaren Endpunkte zu berücksichtigen, wenn Sie Amazon Keyspaces mit VPC-Endpunktverbindungen verwenden.
Sie konfigurieren die Größe des Verbindungspools im Client-Treiber. Basierend auf einer lokalen Poolgröße von **2** und einem VPC-Schnittstellenendpunkt, der über **3** Availability Zones erstellt wurde, richtet der Treiber beispielsweise **6** Verbindungen für Abfragen ein (insgesamt 7, einschließlich einer Kontrollverbindung). Mit diesen 6 Verbindungen können Sie maximal 18.000 CQL-Abfragen pro Sekunde unterstützen.
Wenn Ihre Anwendung 40.000 CQL-Abfragen pro Sekunde unterstützen muss, gehen Sie von der Anzahl der Abfragen aus, die erforderlich sind, um die erforderliche Größe des Verbindungspools zu ermitteln. Um 40.000 CQL-Abfragen pro Sekunde zu unterstützen, müssen Sie die Größe des lokalen Pools auf mindestens 5 konfigurieren, was mindestens 45.000 CQL-Abfragen pro Sekunde unterstützt.
Mithilfe der `PerConnectionRequestRateExceeded` CloudWatch Metrik im Namespace können Sie überwachen, ob Sie das Kontingent für die maximale Anzahl von Vorgängen pro Sekunde und Verbindung überschreiten. `AWS/Cassandra` Die `PerConnectionRequestRateExceeded` Metrik zeigt die Anzahl der Anfragen an Amazon Keyspaces, die das Kontingent für die Anforderungsrate pro Verbindung überschreiten.
Die Codebeispiele in diesem Schritt zeigen, wie Sie das Verbindungspooling schätzen und konfigurieren, wenn Sie VPC-Endpunkte mit Schnittstellen verwenden.
------
#### [ Java ]
Sie können die Anzahl der Verbindungen pro Pool im Java-Treiber konfigurieren. Ein vollständiges Beispiel für eine Verbindung mit einem Java-Clienttreiber finden Sie unter[Verwenden eines Cassandra-Java-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces](using_java_driver.md).
Wenn der Client-Treiber gestartet wird, wird zunächst die Steuerverbindung für Verwaltungsaufgaben hergestellt, z. B. für Schema- und Topologieänderungen. Dann werden die zusätzlichen Verbindungen erstellt.
Im folgenden Beispiel ist die Treiberkonfiguration für die Größe des lokalen Pools mit 2 angegeben. Wenn der VPC-Endpunkt über 3 Subnetze innerhalb der VPC erstellt wird, ergibt dies 7 `NewConnections` in CloudWatch für den Schnittstellenendpunkt, wie in der folgenden Formel dargestellt.
```
NewConnections = 3 (VPC subnet endpoints created across) * 2 (pool size) + 1 ( control connection)
```
```
datastax-java-driver {
basic.contact-points = [ "cassandra.us-east-1.amazonaws.com:9142"]
advanced.auth-provider{
class = PlainTextAuthProvider
username = "ServiceUserName"
password = "ServicePassword"
}
basic.load-balancing-policy {
local-datacenter = "us-east-1"
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
}
advanced.connection {
pool.local.size = 2
}
}
```
Wenn die Anzahl der aktiven Verbindungen nicht Ihrer konfigurierten Poolgröße (Aggregation über Subnetze) \$11 Kontrollverbindung entspricht, verhindert etwas, dass die Verbindungen erstellt werden.
------
#### [ Node.js ]
Sie können die Anzahl der Verbindungen pro Pool im Treiber Node.js konfigurieren. Ein vollständiges Beispiel für eine Clienttreiberverbindung vom Typ Node.js finden Sie unter[Verwenden eines Cassandra Node.js Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces](using_nodejs_driver.md).
Im folgenden Codebeispiel wird die *keyspaces-bundle.pem* Datei für das digitale Zertifikat verwendet. Weitere Informationen finden Sie unter [Bevor Sie beginnen](using_nodejs_driver.md#using_nodejs_driver.BeforeYouBegin).
Für das folgende Codebeispiel ist die Treiberkonfiguration für die Größe des lokalen Pools als 1 angegeben. Wenn der VPC-Endpunkt über 4 Subnetze innerhalb der VPC erstellt wird, ergibt dies 5 `NewConnections` in CloudWatch für den Schnittstellenendpunkt, wie in der folgenden Formel dargestellt.
```
NewConnections = 4 (VPC subnet endpoints created across) * 1 (pool size) + 1 ( control connection)
```
```
const cassandra = require('cassandra-driver');
const fs = require('fs');
const types = cassandra.types;
const auth = new cassandra.auth.PlainTextAuthProvider('ServiceUserName', 'ServicePassword');
const sslOptions1 = {
ca: [
fs.readFileSync('/home/ec2-user/keyspaces-bundle.pem', 'utf-8')],
host: 'cassandra.us-east-1.amazonaws.com',
rejectUnauthorized: true
};
const client = new cassandra.Client({
contactPoints: ['cassandra.us-east-1.amazonaws.com'],
localDataCenter: 'us-east-1',
pooling: { coreConnectionsPerHost: { [types.distance.local]: 1 } },
consistency: types.consistencies.localQuorum,
queryOptions: { isIdempotent: true },
authProvider: auth,
sslOptions: sslOptions1,
protocolOptions: { port: 9142 }
});
```
------
# Schritt 7: (Optional) Aufräumen
Gehen Sie wie folgt vor, wenn Sie die Ressourcen löschen möchten, die Sie in diesem Tutorial erstellt haben.
**So entfernen Sie Ihren VPC-Endpunkt für Amazon Keyspaces**
1. Melden Sie sich bei Ihrer Amazon-EC2-Instance an.
1. Ermitteln Sie die VPC-Endpunkt-ID, die für Amazon Keyspaces verwendet wird. Wenn Sie die `grep` Parameter weglassen, werden VPC-Endpunktinformationen für alle Dienste angezeigt.
```
aws ec2 describe-vpc-endpoint-services | grep ServiceName | grep cassandra
{
"VpcEndpoint": {
"PolicyDocument": "{\"Version\":\"2000-00-00",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":\"*\",\"Resource\":\"*\"}]}",
"VpcId": "vpc-a1234bcd",
"State": "available",
"ServiceName": "com.amazonaws.us-east-1.cassandra",
"RouteTableIds": [],
"VpcEndpointId": "vpce-1a23b4c5",
"CreationTimestamp": "2025-07-26T22:00:14Z"
}
}
```
In der Beispielausgabe ist die ID des VPC-Endpunkts *vpce-1a23b4c5*. Achten Sie darauf, diesen Wert durch Ihren eigenen zu ersetzen.
1. Löschen Sie den VPC-Endpunkt.
```
aws ec2 delete-vpc-endpoints --vpc-endpoint-ids vpce-1a23b4c5
{
"Unsuccessful": []
}
```
Das leere Array `[]` zeigt den Erfolg an (keine fehlgeschlagenen Anforderungen).
**So beenden Sie Ihre Amazon-EC2-Instance**
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Instances** aus.
1. Wählen Sie Ihre Amazon EC2-Instance aus.
1. Wählen Sie „**Aktionen**“, „**Instanzstatus**“ und anschließend „**Beenden**“.
1. Wählen Sie im Bestätigungsfenster **Yes, Terminate** aus.