Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Verbindung zu einer Redis-Instanz herstellen

Auf dieser Seite wird beschrieben, wie Sie mit Telnet und redis-cli eine Verbindung zu Ihrer Redis-Instanz herstellen. Außerdem finden Sie hier eine Anleitung zum Herstellen einer Verbindung bei Verwendung von Funktionen wie Lesereplikaten, AUTH und Verschlüsselung während der Übertragung. Schließlich wird auf dieser Seite beschrieben, wie Sie eine Verbindung von einer Google Kubernetes Engine-Umgebung aus herstellen.

Eine Liste der Google Cloud Umgebungen, die von Memorystore for Redis unterstützt werden, finden Sie unter Unterstützte Umgebungen. Für einige serverlose Umgebungen, die von Memorystore unterstützt werden, ist ein Connector für Serverloser VPC-Zugriff erforderlich. Weitere Informationen finden Sie unter Anforderungen an den Connector für serverlosen VPC-Zugriff.

Über Telnet eine Verbindung zu einer Redis-Instanz von einer Compute Engine-VM aus herstellen

Sie können eine Verbindung zur Memorystore for Redis-Instanz über eine Compute Engine VM herstellen, die das autorisierte Netzwerk der Instanz mit einer unterstützten IP-Adresse gemäß RFC 1918 verwendet.

Wenn Sie keine Compute Engine-VM haben, die dasselbe autorisierte Netzwerk wie Ihre Instanz verwendet, erstellen Sie eine VM und stellen Sie eine Verbindung zu ihr her: Folgen Sie dazu der Kurzanleitung: Linux-VM verwenden. Führen Sie dazu die Schritte unter Linux-VM-Instanz in Compute Engine erstellen aus.
Installieren Sie telnet mit apt-get:
```
sudo apt-get install telnet
```
Stellen Sie über das Terminal eine Telnet-Verbindung zur IP-Adresse der Instanz her. Ersetzen Sie VARIABLES durch die entsprechenden Werte.
```
telnet INSTANCE_IP_ADDRESS 6379
```
Wenn Sie eine Verbindung zur Instanz herstellen können, gibt der Befehl folgendes Ergebnis zurück:
```
Trying INSTANCE_IP_ADDRESS…
Connected to INSTANCE_IP_ADDRESS
```
Geben Sie in der Telnet-Sitzung einige Redis-Befehle ein:

Geben Sie Folgendes ein:
```
PING
```
Ergebnis:
```
PONG
```
Eingeben
```
SET HELLO WORLD
```
Ergebnis:
```
+OK
```
Geben Sie Folgendes ein:
```
GET HELLO
```
Ergebnis:
```
$5
WORLD
```

Über `redis-cli` eine Verbindung zu einer Redis-Instanz von einer Compute Engine-VM aus herstellen

Sie können eine Verbindung zur Redis-Instanz über eine Compute Engine-VM herstellen, die das autorisierte Netzwerk der Redis-Instanz mit einer unterstützten IP-Adresse gemäß RFC 1918 verwendet.

Wenn Sie noch keine Compute Engine-VM haben, die das autorisierte Netzwerk für Ihre Redis-Instanz verwendet, erstellen Sie eine VM und stellen Sie eine Verbindung zu ihr her: Folgen Sie dazu der Kurzanleitung: VM-Instanz in einem bestimmten Subnetz erstellen.
Installieren Sie redis-cli auf der Compute Engine-VM. Führen Sie dazu den folgenden Befehl im Compute Engine-SSH-Terminal aus:
```
sudo apt-get install redis-tools
```
Führen Sie den folgenden Befehl im Compute Engine-Terminal aus und ersetzen Sie variables durch die entsprechenden Werte.
```
redis-cli -h redis-instance-ip-address
```
Sie sind jetzt über redis-cli mit Ihrer Redis-Instanz verbunden.
Nachdem Sie Ihre Verbindung zur Redis-Instanz getestet haben, sollten Sie die Compute Engine-VM löschen, mit der Sie eine Verbindung zur Redis-Instanz hergestellt haben. Dadurch vermeiden Sie, dass Ihrem Cloud-Rechnungskonto Gebühren berechnet werden.

Verbindung zu einer Redis-Instanz herstellen, die AUTH verwendet

In diesem Abschnitt wird beschrieben, wie Sie eine Verbindung zu einer Redis-Instanz herstellen, für die die AUTH Funktion aktiviert ist.

Wenn Sie noch keine Compute Engine-VM haben, die dasselbe autorisierte Netzwerk wie Ihre Redis-Instanz verwendet, erstellen Sie eine VM und stellen eine Verbindung zu ihr her: Folgen Sie dazu der Kurzanleitung: Linux-VM verwenden.
Installieren Sie redis-cli auf der Compute Engine-VM. Führen Sie dazu den folgenden Befehl im Compute Engine-SSH-Terminal aus:
```
sudo apt-get install redis-tools
```
AUTH-String Ihrer Instanz abrufen
Führen Sie den folgenden Befehl aus, um redis-cli zur Authentifizierung und Verbindung mit Ihrer Instanz zu verwenden. Ersetzen Sie dabei variables durch die entsprechenden Werte:
```
redis-cli -h instance-ip-address -a auth-string
```
oder:
```
redis-cli -h instance-ip-address
AUTH auth-string
```
Führen Sie einen Redis-Befehl SET und GET aus, um zu prüfen, ob eine authentifizierte Verbindung zu Ihrer Instanz hergestellt wurde.
Nachdem Sie Ihre Verbindung zur Redis-Instanz getestet haben, sollten Sie die Compute Engine-VM löschen, mit der Sie eine Verbindung zur Redis-Instanz hergestellt haben. Dadurch vermeiden Sie, dass Ihrem Cloud-Rechnungskonto Gebühren berechnet werden.

Über den Lese-Endpunkt eine Verbindung zu einer Redis-Instanz herstellen

Wenn für die Instanz Lesereplikate aktiviert sind, können Sie so eine Verbindung zum Lese-Endpunkt herstellen:

Wenn Sie noch keine Compute Engine-VM haben, die dasselbe autorisierte Netzwerk wie Ihre Redis-Instanz verwendet, erstellen Sie eine VM und stellen Sie eine Verbindung zu ihr her: Folgen Sie dazu der Kurzanleitung: Linux-VM verwenden.
Installieren Sie telnet mit apt-get:
```
sudo apt-get install telnet
```
Die IP-Adresse des Lese-Endpunkts Ihrer Instanz finden Sie, indem Sie die Informationen zum Lesereplikat für Ihre Instanz anzeigen.
Stellen Sie vom Terminal aus eine Telnet-Verbindung zur IP-Adresse der Redis-Instanz her und ersetzen Sie dabei variables durch die entsprechenden Werte.
```
telnet read-endpoint-ip 6379
```
Bei Erfolg gibt der Befehl folgendes Ergebnis zurück:
```
Trying read-endpoint-ip…
Connected to read-endpoint-ip
```
Geben Sie in der Telnet-Sitzung einige Redis-Befehle ein:

Geben Sie Folgendes ein:
```
PING
```
Ergebnis:
```
PONG
```

Über Stunnel und Telnet eine sichere Verbindung zu einer Redis-Instanz herstellen

In diesem Abschnitt wird anhand eines Beispiels gezeigt, wie Sie mit Stunnel eine Verbindung zu einer Redis-Instanz herstellen, für die die Verschlüsselung während der Übertragung aktiviert ist. Stunnel ist ein Proxy, der Clients und Servern die Verschlüsselungsfunktionen von Transport Layer Security (TLS) hinzufügt, ohne dass ihr Code geändert werden muss. Weitere Informationen finden Sie in der Dokumentation zu Stunnel.

Wenn Sie keine Redis-Instanz haben, für die die Verschlüsselung während der Übertragung aktiviert ist, erstellen Sie eine. Weitere Informationen finden Sie unter Redis-Instanz mit Verschlüsselung während der Übertragung erstellen.
Wenn Sie keine Compute Engine-VM haben, die dasselbe autorisierte Netzwerk wie die Redis-Instanz aus dem vorherigen Schritt verwendet, erstellen Sie eine VM und stellen Sie eine Verbindung zu ihr her. Weitere Informationen finden Sie unter Linux-VM-Instanz in Compute Engine erstellen.
Installieren Sie die für diese Prozedur erforderlichen Tools, indem Sie die folgenden Befehle ausführen:
```
sudo apt-get install stunnel4
```
```
sudo apt-get install telnet
```
Die restlichen Schritte in dieser Prozedur werden im SSH-Terminal der Compute Engine-VM ausgeführt, die Sie erstellt und mit der Sie eine Verbindung hergestellt haben, sofern nicht anders angegeben.
Konfigurieren Sie Ihre Compute Engine-VM für die Verwendung mit Stunnel:
1. Erstellen Sie eine Datei für Ihre Zertifizierungsstelle (Certificate Authority, CA), indem Sie den folgenden Befehl ausführen:
```
sudo vim /tmp/server_ca.pem
```
2. Rufen Sie die CAs Ihrer Redis-Instanz auf, indem Sie den folgenden Befehl im Standardterminal ausführen, das Sie zum Verwalten Ihrer Google Cloud Ressourcen (nicht im Compute Engine-Terminal) verwenden:
```
gcloud redis instances describe INSTANCE_ID --region=REGION
```
  Ersetzen Sie die folgenden Werte:
  - INSTANCE_ID: die ID Ihrer Redis-Instanz
  - REGION: die Region, in der sich die Instanz befindet
  Es können bis zu drei CAs vorhanden sein.
3. Kopieren Sie alle CAs, einschließlich der -----BEGIN CERTIFICATE----- Zeile und der
  -----END CERTIFICATE----- Zeile, und fügen Sie den Inhalt in die server_ca.pem Datei ein und speichern Sie ihn.
  
  Achten Sie darauf, dass der Text der CA vollständig linksbündig ist und keine Leerzeichen am Anfang einer Zeile der CA vorhanden sind.
4. Erstellen Sie eine Datei für Ihre Stunnel-Konfigurationsinformationen, indem Sie den folgenden Befehl ausführen:
```
sudo vim /etc/stunnel/redis-client.conf
```
5. Fügen Sie den folgenden Text in die Datei ein und ersetzen Sie REDIS_INSTANCE_IP durch die IP-Adresse der Instanz:
```
output=/tmp/stunnel.log
CAfile=/tmp/server_ca.pem
client=yes
pid=/var/run/stunnel.pid
verifyChain=yes
sslVersion=TLSv1.2
[redis]
accept=127.0.0.1:6378
connect=REDIS_INSTANCE_IP:6378
```
6. Starten Sie Stunnel mit dem folgenden Befehl:
```
sudo stunnel /etc/stunnel/redis-client.conf
```
7. Prüfen Sie, ob Stunnel ausgeführt wird:
```
ps aux | grep stunnel
```
8. Starten Sie Stunnel mit dem folgenden Befehl neu:
```
sudo systemctl restart stunnel4
```
  Sie können den Befehl ps aux | grep stunnel vor und nach dem Neustart von Stunnel verwenden, um zu bestätigen, dass der Neustart erfolgreich war. Wenn sich die Stunnel-Prozess-ID, die vom Befehl ps aux | grep stunnel angezeigt wird, unterscheidet, wurde Stunnel erfolgreich neu gestartet.
Führen Sie den folgenden Befehl aus, um über Telnet eine Verbindung zu Ihrer Redis-Instanz herzustellen:
```
telnet localhost 6378
```
Testen Sie in der Telnet-Sitzung die Verbindung.
1. Optional: Wenn für Ihre Instanz Redis AUTH aktiviert ist, müssen Sie sich authentifizieren, bevor Sie die Verbindung testen.
  
  Führen Sie dazu diesen Befehl aus:
```
AUTH AUTH_STRING
```
  Ersetzen Sie AUTH_STRING durch den Authentifizierungsstring der Instanz.
  
  Ergebnis:
```
OK
```
Führen Sie dazu diesen Befehl aus:
```
PING
```
Ergebnis:
```
PONG
```
Optional: Alternativ zu Telnet können Sie über den lokalen Stunnel-Port eine Verbindung mit redis-cli herstellen und den AUTH-String übergeben.

Führen Sie dazu diesen Befehl aus:
```
redis-cli -h 127.0.0.1 -p 6378 -a AUTH_STRING
```

Über Portweiterleitung eine Verbindung von einem lokalen Computer aus herstellen

Es kann hilfreich sein, eine Verbindung zu Ihrer Redis-Instanz während der Entwicklung von Ihrem lokalen Computer herzustellen. Dazu müssen Sie eine Compute Engine-Instanz erstellen, die für die Portweiterleitung zur Redis-Instanz verwendet wird.

Erstellen Sie eine Compute Engine-Instanz, indem Sie den folgenden Befehl ausführen:
```
gcloud compute instances create COMPUTE_VM_NAME --machine-type=f1-micro --zone=ZONE
```
Wobei:
- COMPUTE_VM_NAME der Name ist, den Sie für die Compute Engine-VM festlegen.
- ZONE die Zone ist, in der Sie die VM bereitstellen möchten.
Dieser Befehl erstellt eine kostengünstige Compute Engine-VM mit dem f1-micro Maschinentyp. Sie können auch andere Maschinentypen auswählen.
Öffnen Sie ein neues Terminal auf Ihrem lokalen Computer.
Führen Sie den folgenden Befehl aus, um einen SSH-Tunnel zu erstellen, der Traffic über die Compute Engine-VM per Portweiterleitung weiterleitet:
```
gcloud compute ssh COMPUTE_VM_NAME --zone=ZONE -- -N -L 6379:REDIS_INSTANCE_IP_ADDRESS:6379
```
Wobei:
- COMPUTE_VM_NAME der Name der Compute Engine-VM ist.
- ZONE die Zone ist, in der sich die Compute Engine-VM befindet.
- REDIS_INSTANCE_IP_ADDRESS die IP-Adresse Ihrer Redis-Instanz ist.
Öffnen Sie zum Testen der Verbindung ein neues Terminalfenster und führen Sie den folgenden Befehl aus:
```
redis-cli ping
```
Bei korrekter Funktionsweise sollte das Ergebnis Folgendes zurückgeben:
```
PONG
```
Sie sind jetzt mit der Redis-Instanz verbunden und können mit diesem offenen SSH-Tunnel Befehle an die Redis-Instanz senden. Installieren Sie redis-cli, damit Sie diesen Befehl ausführen können, falls noch nicht geschehen.
Der SSH-Tunnel bleibt geöffnet, solange das Terminalfenster mit der SSH-Tunnelverbindung aufrechterhalten wird.

Über einen Google Kubernetes Engine-Cluster eine Verbindung zu einer Redis-Instanz herstellen

Verwenden Sie gcloud container clusters describe, um zu prüfen, ob Ihr Cluster IP-Aliasing verwendet.

Sie können eine Verbindung zur Redis-Instanz über einen Google Kubernetes Engine-Cluster herstellen, der dasselbe autorisierte Netzwerk wie Ihre Redis-Instanz verwendet.

Verbindung von einem Pod aus herstellen, der eine Bash-Shell ausführt

Rufen Sie in der Google Cloud Console die GKE-Seite auf.
GKE
Klicken Sie auf den GKE-Cluster, von dem aus Sie eine Verbindung herstellen möchten. Wenn Sie noch keinen Cluster haben, erstellen Sie einen Cluster mit aktivierten IP-Aliassen. Eine Anleitung zum Erstellen eines Clusters mit aktivierten IP-Aliassen finden Sie unter VPC-native Cluster erstellen.
Klicken Sie rechts neben dem Namen des Clusters auf den Button Verbinden und dann auf In Cloud Shell ausführen.
Konfigurieren Sie den Zugriff auf die kubectl-Befehlszeile mit dem folgenden Befehl:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone=CLUSTER_ZONE --project=PROJECT_ID
```
- CLUSTER_NAME ist der Name des Clusters.
- CLUSTER_ZONE ist die Zone, in der sich der Cluster befindet. Muss auch die Zone sein, in der sich die Redis-Instanz befindet.
- PROJECT_ID ist das Projekt, in dem sich der Cluster und die Redis-Instanzen befinden.
Sie sollten die Erfolgsmeldung erhalten: kubeconfig generated for CLUSTER_NAME
Wenn die Cluster-Version 1.8 oder höher ist und IP-Aliasse aktiviert sind, überspringen Sie diesen Schritt. Wenn Sie einen Cluster der Version 1.7 oder niedriger haben oder für Ihren Cluster der Version 1.8 oder höher keine IP-Aliasse aktiviert sind, führen Sie die folgenden Umgehungsschritte aus. Daraufhin können Sie versuchen, eine Verbindung zu Ihrer Instanz herzustellen:
Problemumgehung

Führen Sie die folgenden Befehle aus und ersetzen Sie RESERVED_IP_RANGE durch den reservierten IP-Bereich Ihrer Instanz:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Wenn Sie den reservierten IP-Bereich Ihrer Instanz nicht kennen, können Sie dies mit dem folgenden Befehl herausfinden: gcloud redis instances describe INSTANCE_ID --region=REGION
Weitere Informationen zu IP-Aliassen und zum Erstellen eines Clusters, für den diese Einstellung aktiviert ist, finden Sie unter VPC-nativen Cluster erstellen.
Verwenden Sie den folgenden Befehl, um eine Verbindung zu einer Bash-Shell herzustellen:
```
kubectl run -i --tty busybox --image=busybox -- sh
```
Stellen Sie eine Telnet-Verbindung zu Ihrer Redis-Instanz mit der Hostadresse und Portnummer her:
```
telnet HOST-IP PORT
```
Geben Sie einen einfachen Redis-Befehl ein, um die Verbindung zu überprüfen:
```
PING
+PONG
```
Zum Trennen der Telnet-Verbindung drücken Sie Strg + C oder die Befehlstaste + C (Mac-Tastatur). Zum Beenden der Bash-Shell in Ihrem Pod geben Sie "return" ein. Wenn Sie fertig sind und keine Verbindung mehr zu Redis benötigen, führen Sie den folgenden Befehl im /k8s-custom-iptables/ Verzeichnis aus:
```
./uninstall.sh
```

Über einen Google Kubernetes Engine-Pod eine Verbindung zu einer Redis-Instanz herstellen

Für diesen Vorgang benötigen Sie einen GKE-Cluster. Wenn Sie noch keinen Cluster haben, erstellen Sie einen Cluster mit aktivierten IP-Aliassen. Eine Anleitung zum Erstellen eines Clusters mit aktivierten IP-Aliassen finden Sie unter VPC-native Cluster erstellen.

Klicken Sie in der rechten oberen Ecke der Konsole auf den Button Cloud Shell aktivieren .
Konfigurieren Sie den Zugriff auf die kubectl-Befehlszeile mit dem folgenden Befehl:
```
gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_ZONE --project PROJECT_ID
```
- CLUSTER_NAME ist der Name des Clusters.
- CLUSTER_ZONE ist die Zone, in der sich der Cluster befindet. Muss auch die Zone sein, in der sich die Redis-Instanz befindet.
- PROJECT_ID ist das Projekt, in dem sich der Cluster und die Redis-Instanzen befinden.
Sie sollten die Erfolgsmeldung erhalten: kubeconfig generated for CLUSTER_NAME
Wenn die Cluster-Version 1.8 oder höher ist und IP-Aliasse aktiviert sind, überspringen Sie diesen Schritt. Wenn Sie einen Cluster der Version 1.7 oder niedriger haben oder für Ihren Cluster der Version 1.8 oder höher keine IP-Aliasse aktiviert sind, führen Sie die folgenden Umgehungsschritte aus. Daraufhin können Sie versuchen, eine Verbindung zu Ihrer Instanz herzustellen:
Problemumgehung

Führen Sie die folgenden Befehle aus und ersetzen Sie RESERVED_IP_RANGE durch den reservierten IP-Bereich Ihrer Instanz:
```
git clone https://github.com/bowei/k8s-custom-iptables.git
```
```
cd k8s-custom-iptables/
```
```
TARGETS="RESERVED_IP_RANGE" ./install.sh
```
Wenn Sie den reservierten IP-Bereich Ihrer Instanz nicht kennen, können Sie dies mit dem folgenden Befehl herausfinden: gcloud redis instances describe INSTANCE_ID --region [REGION]
Weitere Informationen zu IP-Aliassen und zum Erstellen eines Clusters, für den diese Einstellung aktiviert ist, finden Sie unter VPC-nativen Cluster erstellen.
Verwenden Sie den folgenden Befehl, um einen Redis-Pod zu starten, der redis-cli ausführt:
```
kubectl run -i --tty redisbox --image=redis:7.2 -- sh
```
Führen Sie einen redis-cli-Befehl aus und ersetzen Sie HOST-IP durch die Host-IP-Adresse Ihrer Redis-Instanz:
```
redis-cli -h HOST-IP info
```
Optional können Sie einen Redis-Benchmark-Befehl ausführen und dabei wieder HOST-IP durch die Host-IP-Adresse Ihrer Redis-Instanz ersetzen:
```
redis-benchmark -c 100 -n 100000 -d 1024 -r 100000 -t PING,SET,GET,INCR,LPUSH,RPUSH,LPOP,RPOP,SADD,SPOP,MSET -h HOST-IP -q
```
Zum Beenden des Redis-Pods geben Sie return ein. Wenn Sie fertig sind und keine Verbindung mehr zu Redis benötigen, führen Sie den folgenden Befehl im Verzeichnis /k8s-custom-iptables/ aus:
```
./uninstall.sh
```

Nächste Schritte

Stellen Sie eine Verbindung zu Ihrer Redis-Instanz mithilfe einer Beispielanwendung her, die in einer der folgenden Umgebungen ausgeführt wird: