Daten zu einer neuen Instanz migrieren

In diesem Tutorial erfahren Sie, wie Sie Ihre Daten von einer bestehenden Redis-Service-Instanz zu einer neu erstellten migrieren.

Anforderungen

• Redis CLI: (CLI-Client für Redis)
• gunzip: (CLI-Programm zum Dekomprimieren von Dateien)
• openssl: (Toolkit für die SSL- und TLS-Protokolle, das sichere Kommunikation über das Netzwerk und Kryptografie bietet)
• cf CLI Version 7: (CLI für Cloud Foundry zur Vereinfachung von Verwaltung von Apps und Spaces)

Vor der Migration

Tools installieren

Um eine reibungslose Migration zu gewährleisten, installieren Sie bitte alle in den Anforderungen aufgeführten Tools.

Für die Installation empfehlen wir, die offizielle Dokumentation des jeweiligen Tools zu Rate zu ziehen, die umfassende Leitfäden und Anweisungen bietet. Je nach Betriebssystem können Sie auch Paketmanager wie apt für Linux, homebrew für macOS oder choco (Chocolatey) für Windows verwenden, um den Installationsprozess zu erleichtern. Diese Tools sind für die Verwaltung von Softwarepaketen unerlässlich und können die Einrichtung vereinfachen.

Nach der Installation ist es wichtig zu prüfen, ob jedes Tool betriebsbereit ist, in der Regel durch Aufruf eines Version-Befehls oder Ausführen einer für das Tool spezifischen Basis-Operation.

Quelldatenbank isolieren

Es wird dringend empfohlen, die Redis-Service-Instanz vor Beginn der Migration zu isolieren. Dies vermeidet potenzielle Dateninkonsistenzen, die entstehen könnten, wenn die Redis-Service-Instanz während des Migrationsprozesses gleichzeitig neue Daten empfängt.

Insgesamt besteht das Ziel darin, Client-Verbindungen zu vermeiden. Auf diese Weise stellen wir sicher, dass während des Migrationsprozesses keine Daten in die Redis-Service-Instanz geschrieben werden. Dies kann durch Trennen (Unbinding/Disconnecting) aller Anwendungen von Ihrer Redis-Service-Instanz erreicht werden.

Sicherung der Quelldatenbank erstellen

Wir empfehlen, die RDB-Datei Ihrer Service-Instanz als Ausfallsicherung für den Fall eines unerwarteten Datenverlusts zu speichern. Diese Datei muss sicher aufbewahrt werden, bis die Konsistenz der Datenbank nach der Migration bestätigt wurde.

1. Öffnen Sie das Service Dashboard, um manuell eine Sicherung Ihrer Quell-Service-Instanz auszulösen. Stellen Sie sicher, dass Sie ein Verschlüsselungspasswort festlegen und dieses sicher aufbewahren.

2. Laden Sie die neueste Sicherung aus dem STACKIT Redis Service Dashboard herunter und speichern Sie diese sicher.

   Weitere Details finden Sie im folgenden Leitfaden: Backup and restore your Redis instances

   Die Erstellung von RDB-Dump-Dateien für Redis v7 Data Services über die Redis CLI wird nicht unterstützt.

Ziel-Redis-Datenbank erstellen

Erstellen Sie eine neue und leere Redis-Service-Instanz, die als Ziel für die Datenmigration von einer bestehenden Redis-Quell-Service-Instanz dienen soll.

Fügen Sie keine Daten in die Maschine ein, bevor die Migration und die Prüfung abgeschlossen sind.

Erstellen Sie eine Service-Instanz mit den gleichen oder höheren Kapazitäten.

Zugangsdaten erstellen

Erstellen Sie Zugangsdaten über das STACKIT Portal oder mit der cf CLI (für Cloud Foundry Runtime Redis Data Services, die im STACKIT Marketplace bestellt wurden) für die Quell- und Ziel-Redis-Datenbanken.

Datenbank-Verbindungszeichenfolgen

STACKIT Portal

1. Öffnen Sie Ihr Projekt im STACKIT Portal.
2. Navigieren Sie zu Datenbanken > Redis.
3. Wählen Sie Ihre Instanz aus und gehen Sie zur Übersicht.
4. Wählen Sie in der Seitenleiste Zugangsdaten.
5. Klicken Sie auf den Service-Key-Eintrag, den Sie anzeigen möchten.

Cloud Foundry CLI

1. Listen Sie Ihre Organisationen auf.

   cf orgs

2. Setzen Sie das Ziel auf die gewünschte Organisation.

   cf target -o [Name-Ihrer-Organisation] -s [Name-Ihres-Spaces]

3. Listen Sie die Services der Zielorganisation auf.

   cf services

4. Erstellen Sie einen Service-Key für Ihren Data Service und lassen Sie ihn anzeigen.

   cf create-service-key [Name-Ihrer-Service-Instanz] [Ihr-Key-Name]
   cf service-key [Name-Ihrer-Service-Instanz] [Ihr-Key-Name]

5. Listen Sie alle verfügbaren Service-Keys für eine bestimmte Instanz auf.

   cf service-keys <NAME_IHRER_SERVICE_INSTANZ>

Formatieren Sie die erhaltenen Service-Keys als Datenbank-Verbindungszeichenfolgen um:

• Redis v6 DB-Verbindungszeichenfolge: rediss://[Passwort]@[Hosts-FQDN]:[Port]
• Redis v7 DB-Verbindungszeichenfolge: rediss://[Benutzernamen][Passwort]@[Hosts-FQDN]:[Port]

Verwenden Sie für die Quell- und Zieldatenbanken immer den Wert von \host!

Backend-Host für die Migration abrufen

Dieser Schritt ist nur erforderlich, wenn Sie zu einem exponierten STACKIT Redis Data Service migrieren (nicht für Cloud Foundry Runtime Redis Data Services).

Um die Migration durchzuführen, müssen Sie den Backend-Hostnamen für die Ziel-Redis-Instanz abrufen. Der Befehl MIGRATE erfordert eine direkte TCP-Verbindung von der Quell- zur Zieldatenbank. Daher führt die Verwendung von exponierten Frontend-Hosts wie red297348-master-3.data.eu01.onstackit.cloud als Ziel dazu, dass die Migration fehlschlägt. Verwenden Sie stattdessen den Backend-Host für die Zieldatenbank.

Es ist nicht erforderlich, einen Cloud Foundry Runtime Service zu bestellen, um diesen Schritt auszuführen!

1. Melden Sie sich mit der cf CLI an.

   Detaillierte Anweisungen finden Sie unter Interact with Cloud Foundry.

2. Wählen Sie Ihre Cloud Foundry Organisation aus.

   Verwenden Sie entweder das bereitgestellte Menü oder die folgenden Befehle.

   Listen Sie alle verfügbaren Organisationen aller STACKIT Projekte auf, auf die Sie Zugriff haben:

   cf orgs

   Wechseln Sie zu Ihrer Organisation:

   cf target -o [Organisationsname]

   Eine typische Organisation hat das folgende Namensschema: stackit_portal_prod_[Portal_Projektname]_id.

   Beispiel

   Wenn Ihr STACKIT Projekt My Cloud heißt, würde der Organisationsname etwa so lauten: stackit_portal_prod_my_cloud_4eFgBq5P.

3. Listen Sie Ihre Data-Service-Instanzen auf

   Verwenden Sie cf services, um Ihre Redis-Zieldatenbank anhand des Namens zu identifizieren (erste Spalte der Ausgabe). Die korrekte Backend-Instanz enthält das Suffix -internal.

4. Erstellen Sie einen Service-Key.

   Verwenden Sie diesen Befehl, um einen Service-Key zu erstellen:

   cf create-service-key <NAME_DER_ZIELINSTANZ> <IHR_KEY_NAME>

   Beispiel

   cf create-service-key my-redis-target-db-internal mykey

5. Zeigen Sie den Service-Key an.

   cf service-key <Name-der-Zielinstanz> [Ihr-Key-Name]

   Speichern Sie die gesamte JSON-Ausgabe. Diese wird in einem späteren Schritt benötigt.

CA-Zertifikate abrufen

Abhängig von Ihrem STACKIT Projekttyp (öffentlich oder intern) und der Konfiguration des Redis Data Service (exponiert oder innerhalb der Cloud Foundry Runtime) benötigen Sie möglicherweise unterschiedliche CA-Zertifikate, um eine verschlüsselte Datenbankverbindung herzustellen.

Expand

STACKIT Projekttyp	Exponierte Redis Data Services (Frontend-Hosts)	Cloud Foundry Runtime Redis Data Services (Backend-Hosts)
öffentlich (Web)	CA-Zertifikate (Root-CA und Intermediate-CAs) sind optional und nur erforderlich, wenn Ihre Umgebung der öffentlichen SwissSign-Autorität nicht standardmäßig vertraut.	Das CA-Zertifikat ist obligatorisch und kann aus dem Service-Key abgerufen werden.
intern (Schwarz)	CA-Zertifikate (Root-CA und Intermediate-CAs) sind nicht erforderlich und werden standardmäßig vertraut.	Das CA-Zertifikat ist obligatorisch und kann aus dem Service-Key abgerufen werden.

Exponierte STACKIT Redis Data Services in öffentlichen Projekten

Besuchen Sie die SwissSign-Supportseite für eine Übersicht aller Zertifikate: Download SwissSign Certificates. Erforderliche Zertifikate zum Aufbau der Kette sind:

SwissSign RSA TLS OV ICA 2022 - 1

• Key-ID: 7C:6F:0A:6F:13:0F:D9:8C:24:6F:26:34:F3:5C:6B:43:6D:B7:23:B6
• Serial: 6A:EC:7C:44:41:7B:9B:44:1F:B9:76:34:CB:C6:A7:80:B0:04:1E:01
• Fingerprint (SHA2): 33:2F:9E:AE:36:50:C7:74:54:AF:14:FE:1A:62:1A:24:98:FD:12:87:73:66:28:90:A0:D1:28:35:B3:43:6E:23
• Zertifikat herunterladen: PEM

SwissSign RSA TLS Root CA 2022 - 1 (Cross-Signed By Gold 2)

• Key-ID: 6F:8E:62:8B:93:43:B0:E1:40:F6:A7:C3:FD:F1:0F:B8:0F:15:38:A5
• Serial: 68:6f:43:b4:dc:40:4c:06:7e:23:0e:3f:af:c3:2b
• Fingerprint (SHA2): 28:8B:4A:9F:60:5B:09:B9:99:B2:15:85:08:25:C8:1F:9B:53:7D:BA:F2:36:64:AC:A9:8B:F6:BA:98:ED:C3:79
• Zertifikat herunterladen: PEM

Gold G2

• Key-ID: 5B:25:7B:96:A4:65:51:7E:B8:39:F3:C0:78:66:5E:E8:3A:E7:F0:EE
• Serial: BB:40:1C:43:F5:5E:4F:B0
• Fingerprint (SHA2): 62:DD:0B:E9:B9:F5:0A:16:3E:A0:F8:E7:5C:05:3B:1E:CA:57:EA:55:C8:68:8F:64:7C:68:81:F2:C8:35:7B:95
• Zertifikat herunterladen: PEM

Migrationsprozess

Bevorzugte Strategie: Migration per Redis MIGRATE-Befehl

Die bevorzugte Strategie zur Migration des gesamten Datensatzes von einer Redis-Service-Instanz zu einer anderen basiert auf der Redis MIGRATE-Funktion.

Diese Funktion erfolgt in Form eines einfachen Befehls, der über die Redis CLI ausgeführt werden kann. Über die CLI verbinden wir uns mit der bestehenden Instanz und führen den Befehl MIGRATE aus. Der Befehl akzeptiert den Hostnamen und die Zugangsdaten für die neue Instanz, was impliziert, dass während der Migration eine direkte Verbindung zwischen den beiden Instanzen besteht.

Basierend auf internen und isolierten Tests dauert die Migration von 1GB durchschnittlich etwa 50 Sekunden. Dies hängt jedoch von der jeweiligen Umgebung und ihren Besonderheiten ab. Beachten Sie, dass dies einige Zeit in Anspruch nehmen kann, daher ist eine sorgfältige Planung erforderlich.

Verwenden Sie die Redis CLI, um die Datenbank-Keys abzurufen und zwischen den Redis-Service-Instanzen zu migrieren. Ersetzen Sie alle Platzhalterwerte im untenstehenden Befehl und führen Sie ihn anschließend aus. Diese Befehle können sich je nach Redis-Version ändern; stellen Sie sicher, dass Sie den für Ihren Fall geeigneten Befehl ausführen.

Wenn Sie eine logische Datenbank verwenden und mehr als eine haben, muss dieser Befehl so oft ausgeführt werden, wie logische Datenbanken vorhanden sind. Es ist erforderlich, den Wert -n <DB_NUM> entsprechend anzupassen.

Wenn die ursprüngliche Redis Data Service Instanz Keys mit Namen enthält, die Sonderzeichen aufweisen, wird dieser Migrationsprozess nicht funktionieren. Wenn beispielsweise ein Key ein Zeilenumbruchzeichen enthält, kann dies ein Problem darstellen.

Alternative Strategie: Migration per Skript

Falls die MIGRATE-Funktion nicht funktioniert oder fehlschlägt, können Sie ein Python-Skript namens copy_redis.py verwenden, um alle Keys von der Quell- zur Zieldatenbank zu kopieren und zu verifizieren: copy_redis.zip. Befolgen Sie die Anweisungen in der README-Datei zur Verwendung des Skripts copy_redis.py.

Migration

Wählen Sie die Anweisung abhängig von der Version der Zielinstanz.

Redis v6

redis-cli -u "[Quell-DB-Verbindungszeichenfolge]" -n [DB-Nummer] \
--tls --sni [Quell-Frontend-Hosts-FQDN] \
--cacert [/Pfad/zu/ca-cert.pem] --raw KEYS '*' | \
xargs redis-cli -u "[Quell-DB-Verbindungszeichenfolge]" -n [DB-Nummer] \
--tls --sni [Quell-Frontend-Hosts-FQDN] --cacert [/Pfad/zu/ca-cert.pem] \
MIGRATE [Ziel-Backend-Hosts-FQDN] [Ziel-Backend-Port] "" [DB-Nummer] [Timeout] \
COPY AUTH [Backend-Ziel-Passwort] KEYS > migration-output-checker.txt

Redis v7

redis-cli -u “[Quell-DB-Verbindungszeichenfolge]” -n [DB-Nummer]
—tls —sni [Quell-Frontend-Hosts-FQDN]
—cacert [/Pfad/zu/ca-cert.pem] —raw KEYS ’*’ |
xargs redis-cli -u “[Quell-DB-Verbindungszeichenfolge]” -n [DB-Nummer]
—tls —sni [Quell-Frontend-Hosts-FQDN] —cacert [/Pfad/zu/ca-cert.pem]
MIGRATE [Ziel-Backend-Hosts-FQDN] [Ziel-Backend-Port] "" [DB-Nummer] [Timeout]
COPY AUTH2 [Backend-Ziel-Benutzername] [Backend-Ziel-Passwort] KEYS > migration-output-checker.txt

Erklärung

Quell-Redis CLI-Befehl

redis-cli -u "[Quell-DB-Verbindungszeichenfolge]" -n [DB-Nummer] \
--tls --sni [Quell-Frontend-Hosts-FQDN] \
--cacert [/Pfad/zu/ca-cert.pem] --raw KEYS '*'

• -u "[Quell-DB-Verbindungszeichenfolge]": Die Verbindungszeichenfolge für die Quell-Redis-Datenbank
• -n [DB-Nummer]: Nummer der zu verwendenden logischen Datenbank.
• --tls: TLS-Verschlüsselung aktivieren.
• --sni [Quell-Frontend-Hosts-FQDN]: Der FQDN des Quell-Frontend-Hosts.
• --cacert [/Pfad/zu/ca-cert.pem]: Pfad zum CA-Zertifikat
• --raw KEYS '*': Alle Keys aus der Quelldatenbank abrufen.

Keys an xargs weiterleiten

xargs

• xargs: Übergibt die aus der Quelldatenbank abgerufenen Keys an den nächsten Befehl.

Ziel-Redis CLI-Befehl

redis-cli -u "[Quell-DB-Verbindungszeichenfolge]" -n [DB-Nummer] \
--tls --sni [Quell-Frontend-Hosts-FQDN] --cacert [/Pfad/zu/ca-cert.pem] \
MIGRATE [Ziel-Backend-Hosts-FQDN] [Ziel-Backend-Port] "" [DB-Nummer] [Timeout] \
COPY AUTH2 [Backend-Ziel-Benutzername] [Backend-Ziel-Passwort] KEYS > migration-output-checker.txt

• MIGRATE [Ziel-Backend-Hosts-FQDN] [Ziel-Backend-Port] "" [DB-Nummer] [Timeout]: Migriert Keys zur Ziel-Redis-Datenbank.
• [Ziel-Backend-Hosts-FQDN]: Der FQDN des Ziel-Backend-Hosts.
• [Ziel-Backend-Port]: Der Port des Ziel-Backends.
• "": Der zu migrierende Key (bereitgestellt durch xargs).
• [DB-Nummer]: Die zu verwendende Datenbanknummer.
• [Timeout]: Das Timeout für die Migration.
• COPY: Kopiert den Key, anstatt ihn zu verschieben.
• AUTH [Backend-Ziel-Passwort]: Das Passwort für das Redis v6 Ziel-Backend
• AUTH2 [Backend-Ziel-Benutzername] [Backend-Ziel-Passwort]: Benutzername und Passwort für das Redis v7 Ziel-Backend.
• KEYS > migration-output-checker.txt: Gibt das Ergebnis zur Überprüfung in eine Datei aus.

Beispiel

Redis v6

redis-cli -u "rediss://a9******@red140220-master-1.data.eu01.onstackit.cloud:49620" -n 0 \
--tls --sni red140220-master-1.data.eu01.onstackit.cloud --cacert ca_certs.pem --raw KEYS '*' | \
xargs redis-cli -u "rediss://a9******@red140220-master-1.data.eu01.onstackit.cloud:49620" -n 0 \
--tls --sni red140220-master-1.data.eu01.onstackit.cloud --cacert ca_certs.pem \
MIGRATE red297348-master.service.dc1.a9ssvc 6379 "" 0 30 \
COPY AUTH a9****** KEYS > migration-output-checker.txt

Redis v7

redis-cli -u "rediss://a9******@red140220-master-1.data.eu01.onstackit.cloud:49620" -n 0 \
--tls --sni red140220-master-1.data.eu01.onstackit.cloud --cacert ca_certs.pem --raw KEYS '*' | \
xargs redis-cli -u "rediss://a9******@red140220-master-1.data.eu01.onstackit.cloud:49620" -n 0 \
--tls --sni red140220-master-1.data.eu01.onstackit.cloud --cacert ca_certs.pem \
MIGRATE red297348-master.service.dc1.a9ssvc 6379 "" 0 30 \
COPY AUTH2 a9****** k85***** KEYS > migration-output-checker.txt

Wichtige Überlegungen für die Redis-Migration

Bei der Migration von Daten mit dem Befehl MIGRATE ist es entscheidend, den Unterschied zwischen Frontend- (exponierten) Hosts und Backend-Hosts (Cloud Foundry Runtime Data Services) zu verstehen.

Frontend- (exponierte) Hosts versus Backend-Hosts

• Frontend- (exponierte) Hosts: Dies sind die öffentlich zugänglichen Endpunkte, die für den externen Zugriff auf den Redis Data Service bereitgestellt werden. Sie werden typischerweise für Verbindungen zum Redis Data Service von außerhalb der Cloud Foundry Umgebung verwendet. Beispiele sind:
  • .data.eu01.onstackit.cloud
  • .data.eu01.onstackit.schwarz
• Backend-Hosts: Dies sind die internen Endpunkte, die innerhalb der Cloud Foundry Umgebung verwendet werden. Sie sind nicht öffentlich exponiert und dienen der internen Kommunikation zwischen Services. Beispiele sind:
  • .service.dc1.a9ssvc

Den Redis-Befehl MIGRATE verstehen

Der Befehl MIGRATE erfordert eine direkte Verbindung zwischen der Quell- und der Zieldatenbank. Das bedeutet, dass die Zieldatenbank aus dem Netzwerk der Quelldatenbank erreichbar sein muss.

• Exponierte Redis Data Services: Wenn Sie Daten zu einem exponierten Redis-Service migrieren, führt die Verwendung des Frontend-Hosts als Ziel dazu, dass die Migration fehlschlägt. Dies liegt daran, dass der Befehl MIGRATE keine direkte Verbindung zum Frontend-Host herstellen kann. Bitte verwenden Sie stattdessen den Backend-Host.
• Cloud Foundry Runtime Redis Data Services: Verwenden Sie die Backend-Hosts, die durch die Service-Keys bereitgestellt werden. Diese Hosts sind innerhalb der Cloud Foundry Umgebung erreichbar, sodass der Befehl MIGRATE eine direkte Verbindung zwischen den Datenbanken herstellen kann.

Schritte für eine erfolgreiche Migration

1. Identifizieren Sie die korrekten Hosts

   Stellen Sie bei exponierten Redis Data Services als Ziel sicher, dass Sie über die Backend-Host-Informationen verfügen. Verwenden Sie für Cloud Foundry Runtime Redis Services die vom Service bereitgestellten Backend-Hosts.

2. Verwenden Sie den Backend-Host für die Migration

   Geben Sie bei der Durchführung der Migration den Backend-Host als Ziel im Befehl MIGRATE an.

3. Beispielbefehl

   redis-cli -u "[Quell-Verbindungszeichenfolge-mit-FQDN-Frontend-Host]" -n [DB-Nummer] \
   --tls --sni [Quell-Frontend-Hosts-FQDN] \
   --cacert [/Pfad/zu/ca-cert.pem]--raw KEYS '*' | \
   xargs redis-cli -u "[Quell-Verbindungszeichenfolge-mit-FQDN-Frontend-Host]" -n [DB-Nummer] \
   --tls --sni [Quell-Frontend-Hosts-FQDN] --cacert [/Pfad/zu/ca-cert.pem] \
   MIGRATE [Ziel-Backend-Hosts-FQDN] [Ziel-Backend-Port] "" [DB-Nummer] [Timeout] \
   COPY AUTH [Passwort] KEYS > migration-output-checker.txt

Authentifizierungsänderungen in Redis v7

Beachten Sie bei der Migration von Daten zu Redis 7 mit dem Befehl MIGRATE, dass Redis v7 für die Authentifizierung zusätzlich zum Passwort einen Benutzernamen erfordert. Dies ist eine Änderung gegenüber Redis v6, das nur ein Passwort benötigte.

Zusätzlich wurde der Befehl AUTH durch AUTH2 ersetzt, um den neuen Authentifizierungsanforderungen gerecht zu werden. Stellen Sie sicher, dass Sie AUTH2 mit Benutzernamen und Passwort verwenden, wenn Sie Migrationen zu Redis 7 durchführen.

Passen Sie Ihren Befehl zur Migration entsprechend an:

Redis v6

.. COPY AUTH <PASSWORT> KEYS > migration-output-checker.txt

Redis v7

.. COPY AUTH2 <BENUTZERNAME> <PASSWORT> KEYS > migration-output-checker.txt

Migration von Cloud Foundry Runtime Redis Data Services

Um eine Verbindung zu einer Cloud Foundry Runtime Redis Data Service Datenbank herzustellen, ist ein SSH-Forward-Tunnel erforderlich. Local Port Forwarding ermöglicht es Ihnen, einen Port von Ihrem lokalen Rechner an einen entfernten Server weiterzuleiten. Dies ist nützlich, wenn Sie von Ihrem lokalen Rechner aus auf einen Service zugreifen möchten, der auf einem entfernten Server läuft.

Um eine Verbindung zur Redis Data Service Datenbank in der Cloud Foundry Runtime herzustellen (bestellt über den Cloud Foundry Marketplace oder die API), ist ein SSH-Forward-Tunnel erforderlich. Diese Technik, bekannt als Local Port Forwarding, ermöglicht es Ihnen, einen Port von Ihrem lokalen Rechner sicher an einen entfernten Server weiterzuleiten. Dies ist besonders nützlich, wenn Sie von Ihrer lokalen Umgebung aus auf einen Dienst zugreifen müssen, der auf einem entfernten Server läuft.

Was ist Local Port Forwarding?

Local Port Forwarding ist eine Methode, um Netzwerkverkehr von einem lokalen Port auf Ihrem Rechner an einen bestimmten Port auf einem entfernten Server umzuleiten. Dies geschieht über einen SSH-Tunnel, der die übertragenen Daten verschlüsselt und so eine sichere Kommunikation zwischen Ihrem lokalen Rechner und dem entfernten Dienst gewährleistet.

Warum Local Port Forwarding verwenden?

Local Port Forwarding ist in Szenarien von Vorteil, in denen der direkte Zugriff auf einen Remote-Dienst aufgrund von Netzwerksicherheitsrichtlinien, Firewalls oder NAT (Network Address Translation) eingeschränkt ist. Durch das Erstellen eines SSH-Tunnels können Sie diese Einschränkungen umgehen und sicher auf den Remote-Dienst zugreifen, als ob dieser lokal auf Ihrem Rechner liefe.

Schritte zum Aufbau eines SSH-Tunnels

1. Voraussetzungen

   • Stellen Sie sicher, dass Sie SSH-Zugriff auf die Cloud Foundry Anwendungsinstanz haben.
   • Überprüfen Sie, ob die SSH-Funktion für Ihre Cloud Foundry Anwendung aktiviert ist.
   • Stellen Sie sicher, dass Ihre Anwendung an die Redis Data Service Instanz gebunden ist.

2. Anwendung an den Redis Data Service binden

   Verwenden Sie den folgenden Befehl, um Ihre Cloud Foundry Anwendung an die Redis Data Service Instanz zu binden:

   cf bind-service [Ihr-CF-App-Name] [Ihre-Redis-Service-Instanz]

   Ersetzen Sie die Platzhalter durch die entsprechenden Werte:

   • [Ihr-CF-App-Name]: Der Name Ihrer Cloud Foundry Anwendung.
   • [Ihre-Redis-Service-Instanz]: Der Name Ihrer Redis Data Service Instanz.

3. Anwendung neu stagen

   Nachdem Sie den Service gebunden haben, stagen Sie Ihre Anwendung neu, um die Änderungen zu übernehmen:

   cf restage Ihr-CF-App-Name

4. SSH-Tunnel erstellen

   cf ssh [Ihr-CF-App-Name] -L [Lokaler-Port]:[Redis-Service-Host]:[Redis-Service-Port]

   Ersetzen Sie die Platzhalter durch die entsprechenden Werte:

   • [Ihr-CF-App-Name]: Der Name Ihrer Cloud Foundry Anwendung.
   • [Lokaler-Port]: Der lokale Port auf Ihrem Rechner (z. B. 6379)
   • [Redis-Service-Host]: Der Hostname der Redis Data Service Instanz.
   • [Redis-Service-Port]: Der Port, auf dem der Redis Data Service läuft (typischerweise 6379).

   Beispiel:

   cf ssh my-redis-app -L 6379:red198b63-master.service.dc1.a9ssvc:6379

5. Auf den Redis Data Service zugreifen

   Sobald der SSH-Tunnel aufgebaut ist, können Sie sich mit einem Redis-Client auf Ihrem lokalen Rechner mit dem Redis-Service verbinden. Sie können beispielsweise das Befehlszeilen-Tool Redis CLI verwenden:

   redis-cli -u "rediss://a9********:********@localhost:6379" --tls --cacert /Pfad/zu/ca_cert.pem

   Dieser Befehl verbindet sich über den SSH-Tunnel mit dem auf red198b63-master.service.dc1.a9ssvc laufenden Redis-Service unter Verwendung des lokalen Ports 6379.

Auf Fehler bei der Migration prüfen

Die Datei migration-output-checker.txt enthält die Ausgabe des Befehls MIGRATE und wird in einem weiteren Schritt verwendet, um sicherzustellen, dass die Migration erfolgreich durchgeführt wurde.

Prüfen Sie den Inhalt:

cat migration-output-checker.txt | grep --invert-match "OK"

Die Ausgabe dieses Befehls muss leer sein, andernfalls wird eine Fehlermeldung mit Details darüber ausgegeben, was bei der Migration nicht funktioniert hat. Im Folgenden listen wir einige der potenziellen Fehlermeldungen auf:

Expand

Fehlermeldung	Mögliche Ursache	Fehlerbehebung
NOKEY	Der Key existiert nicht in der Quell-Redis-Service-Instanz.	Überprüfen Sie erneut, ob der erste Teil des Befehls (redis-cli --raw KEYS '*') korrekt ist. Die Ausgabe dieses Befehls muss alle in der Redis-Instanz vorhandenen Keys enthalten.
IOERR error or timeout connecting to the client	Wahrscheinlich ein Kommunikationsproblem zwischen den beiden Redis-Instanzen.	Überprüfen Sie erneut, ob die Quell-Redis-Service-Instanz Zugriff auf die Ziel-Redis-Service-Instanz hat. Prüfen Sie bitte auch auf den korrekten Ziel-Backend-Host für die Migration exponierter Redis Data Services.
ERR Target instance replied with error: ERR invalid password	Authentifizierung funktioniert nicht.	Überprüfen Sie erneut, ob das Passwort korrekt ist.

Datenbank-Konsistenz prüfen

Prüfen Sie die Datenbank-Konsistenz zwischen der ursprünglichen Redis-Service-Instanz und der neuen Redis-Service-Instanz.

Falls die Quell-Redis-Service-Instanz nicht isoliert wurde und während der Migration weiterhin neue Daten empfangen hat, wird die folgende Prüfung nicht funktionieren.

Daten zwischen den Redis-Service-Instanzen vergleichen

Führen Sie den Redis CLI-Befehl info keyspace für jeden Host aus. Die Werte für Keys und Expires müssen gleich sein.

Auf der Quell-Redis-DB

redis-cli -u "[Quell-DB-Verbindungszeichenfolge]" \
--tls --sni [Quell-Frontend-Hosts-FQDN] \
--cacert [/Pfad/zu/ca_cert.pem] INFO KEYSPACE

Auf der Ziel-Redis-DB

redis-cli -u "<SOURCE_DB_CONNECTION_STRING>" \
--tls --sni [Ziel-Frontend-Hosts-FQDN] \
--cacert [/Pfad/zu/ca_cert.pem] INFO KEYSPACE

Führen Sie den Redis CLI-Befehl info memory für jeden Host aus. Die Werte müssen ähnlich sein und dürfen, wenn überhaupt, nur wenige Kilobyte Differenz aufweisen.

Auf der Quell-Redis-DB

redis-cli -u "[Quell-DB-Verbindungszeichenfolge]" \
--tls --sni [Quell-Frontend-Hosts-FQDN] \
--cacert [/Pfad/zu/ca_cert.pem] INFO MEMORY | grep "used_memory:\|used_memory_human"

Auf der Ziel-Redis-DB

redis-cli -u "[Quell-DB-Verbindungszeichenfolge]" \
--tls --sni [Ziel-Frontend-Hosts-FQDN] \
--cacert [/Pfad/zu/ca_cert.pem] INFO MEMORY | grep "used_memory:\|used_memory_human"

Keys zwischen den Redis-Service-Instanzen vergleichen

Dieser Schritt vergleicht alle Keys zwischen beiden Redis-Instanzen.

Rufen Sie alle Keys der Quell-Redis-Service-Instanz ab und sortieren Sie diese:

redis-cli -u "[Quell-DB-Verbindungszeichenfolge]" -n [DB-Nummer] \
--tls --sni [Quell-Frontend-Hosts-FQDN] \
--cacert [/Pfad/zu/ca_cert.pem] --raw KEYS '*' > redis-source.txt && \
sort --parallel=2 -uo redis-source-sorted.txt redis-source.txt

Rufen Sie alle Keys der Ziel-Redis-Service-Instanz ab und sortieren Sie diese:

redis-cli -u "<SOURCE_DB_CONNECTION_STRING>" -n [DB-Nummer] \
--tls --sni [Quell-Frontend-Hosts-FQDN] \
--cacert [/Pfad/zu/ca_cert.pem] --raw KEYS '*' > redis-target.txt && \
sort --parallel=2 -uo redis-target-sorted.txt redis-target.txt

Vergleichen Sie die Keys beider Redis-Service-Instanzen. Stellen Sie sicher, dass beide Dateien nicht leer sind und Keys enthalten, bevor Sie den Vergleich durchführen:

diff redis-source-sorted.txt redis-target-sorted.txt

Die Ausgabe darf keine Unterschiede aufweisen.

Anlagen

Link zum Python-Migrations-Skript: copy_redis.zip.

Weitere Informationen

• Redis-Client herunterladen
• Architektur von Redis
• a9s - Redis migration