Memcache zu Memorystore migrieren

Leistungsfähige, skalierbare Python-Webanwendungen verwenden für einige Aufgaben häufig einen verteilten speicherinternen Daten-Cache anstelle eines robusten, nichtflüchtigen Speichers.

Die App Engine-Lösung hierfür ist Memcache, ein verteilter speicherinterner Datenspeicher, der für bestimmte Aufgaben als Cache verwendet wird.

Bei der Migration von gebündelten Legacy-Diensten wird als Ersatz für App Engine Memcache Memorystore empfohlen, ein vollständig verwalteter cloudbasierter Caching-Dienst, der die Open-Source-Caching-Engines Redis und Memcache unterstützt. In diesem Leitfaden wird die Verwendung von Memorystore for Redis beschrieben, das Anwendungscaches erstellen kann, die Datenzugriffe innerhalb eines Bruchteils von Millisekunden ermöglichen.

Wenn Ihre Python-Anwendung Memcache nur verwendet, um die Latenz für ndb- oder Cloud NDB-Anfragen zu verringern, können Sie anstelle von Memcache oder Memorystore for Redis die integrierte Unterstützung von Cloud NDB für Redis verwenden.

Bevor Sie beginnen, müssen Sie dafür sorgen, dass Ihre Anwendung innerhalb der Kontingente für Memorystore for Redis bleibt.

Gründe für die Verwendung eines Speicher-Caches für Python-Anwendungen

In Ihren Python-Anwendungen sind Sitzungsdaten, Nutzereinstellungen und andere Daten, die von Abfragen für Webseiten zurückgegeben werden, gute Kandidaten für das Caching. Wenn eine häufig ausgeführte Abfrage eine Reihe von Ergebnissen zurückgibt, die nicht sofort in Ihrer Anwendung angezeigt werden müssen, können Sie die Ergebnisse normalerweise im Cache speichern. Nachfolgende Anfragen können den Cache prüfen und die Datenbank nur abfragen, wenn Ergebnisse fehlen oder abgelaufen sind.

Wenn Sie einen Wert nur in Memorystore speichern, ohne ihn im nichtflüchtigen Speicher zu sichern, achten Sie darauf, dass Ihre Anwendung angemessen reagiert, wenn der Wert abläuft und aus dem Cache entfernt wird. Wenn beispielsweise Sitzungsdaten eines Nutzers plötzlich nicht mehr verfügbar sind und dies zu einer fehlerhaften Sitzung führen würde, sollten diese Daten nicht nur in Memorystore, sondern zusätzlich auch in der Datenbank gespeichert werden.

Vorbereitung

Richten Sie die Python-Entwicklungsumgebung ein, falls Sie dies noch nicht getan haben, um eine mit Google Cloud kompatible Python-Version zu verwenden, und installieren Sie Testtools, um isoliertes Python zu erstellen. Umgebungen.

Informationen zu Memorystore-Berechtigungen

Jede Interaktion mit einem Google Cloud-Dienst muss autorisiert werden. Für die Interaktion mit einer von Memorystore gehosteten Redis-Datenbank muss Ihre Anwendung zum Beispiel die Anmeldedaten eines Kontos bereitstellen, das zum Zugriff auf Memorystore berechtigt ist.

Standardmäßig stellt Ihre Anwendung die Anmeldedaten für das Standarddienstkonto von App Engine bereit, das zum Zugriff auf Datenbanken berechtigt ist, die sich in demselben Projekt wie Ihre Anwendung befinden.

Wenn eine der folgenden Bedingungen zutrifft, müssen Sie eine alternative Authentifizierungsmethode verwenden, die Anmeldedaten explizit bereitstellt:

Ihre Anwendung und die Memorystore-Datenbank befinden sich in verschiedenen Google Cloud-Projekten.
Sie haben die Rollen geändert, die dem App Engine-Standarddienstkonto zugewiesen sind.

Informationen zu alternativen Authentifizierungsmethoden finden Sie unter Authentifizierung für Server-zu-Server-Produktionsanwendungen einrichten.

Übersicht über den Migrationsprozess

So verwenden Sie Memorystore anstelle von Memcache in Ihrer Python-Anwendung:

Richten Sie Memorystore for Redis ein. Erstellen Sie dazu eine Redis-Instanz in Memorystore und einen serverlosen VPC-Zugriff, den Ihre Anwendung für die Kommunikation mit der Redis-Instanz verwendet. Die Erstellung dieser beiden unabhängigen Entitäten ist nicht strikt und kann in beliebiger Reihenfolge eingerichtet werden. Die Anleitung in diesem Leitfaden zeigt zuerst, wie Sie den serverlosen VPC-Zugriff einrichten.
Installieren Sie eine Clientbibliothek für Redis und verwenden Sie Redis-Befehle, um Daten im Cache zu speichern.

Memorystore for Redis ist mit allen Clientbibliotheken für Redis kompatibel.

In diesem Leitfaden wird beschrieben, wie Sie mit der Clientbibliothek redis-py Redis-Befehle aus Ihrer Anwendung senden.
Testen Sie Ihre Aktualisierungen.
Stellen Sie die Anwendung in App Engine bereit.

Memorystore for Redis einrichten

So richten Sie Memorystore for Redis ein:

Verbinden Sie Ihre App Engine-Anwendung mit einem VPC-Netzwerk. Ihre Anwendung kann nur über einen VPC-Connector mit Memorystore kommunizieren.

Fügen Sie die Informationen zur VPC-Verbindung in die Datei app.yaml ein, wie unter Anwendung mit Connector konfigurieren beschrieben.
Notieren Sie sich die IP-Adresse und die Portnummer der von Ihnen erstellten Redis-Instanz. Sie benötigen diese Informationen, wenn Sie in Ihrem Code einen Redis-Client erstellen.
Erstellen Sie eine Redis-Instanz in Memorystore.

Wenn Sie aufgefordert werden, eine Region für Ihre Redis-Instanz auszuwählen, wählen Sie dieselbe Region aus, in der sich Ihre App Engine-Anwendung befindet.

Abhängigkeiten installieren

So verwenden Sie die Clientbibliothek redis-py:

Aktualisieren Sie die Datei app.yaml. Folgen Sie der Anleitung für Ihre Python-Version:
Python 2
Fügen Sie für Python 2-Anwendungen die neuesten Versionen der Bibliotheken grpcio und setuptools hinzu.

Hier sehen Sie eine app.yaml-Beispieldatei:
```
runtime: python27
threadsafe: yes
api_version: 1

libraries:
- name: grpcio
  version: latest
- name: setuptools
  version: latest
```
Python 3
Geben Sie für Python 3-Anwendungen das runtime-Element in Ihrer app.yaml-Datei mit einer unterstützten Python 3-Version an. Beispiel:
```
runtime: python310 # or another support version
```
Die Python 3-Laufzeit installiert Bibliotheken automatisch. Sie müssen also keine integrierten Bibliotheken aus der vorherigen Python 2-Laufzeit angeben. Wenn Ihre Python 3-Anwendung bei der Migration andere gebündelte Legacy-Dienste verwendet, können Sie weiter die erforderlichen integrierten Bibliotheken angeben. Andernfalls können Sie die unnötigen Zeilen in Ihrer app.yaml-Datei löschen.
Aktualisieren Sie die Datei requirements.txt. Folgen Sie der Anleitung für Ihre Python-Version:
Python 2
Fügen Sie die Cloud-Clientbibliotheken für Memorystore for Redis der Liste der Abhängigkeiten in der requirements.txt-Datei hinzu.
```
redis
```
Führen Sie dann pip install -t lib -r requirements.txt aus, um die Liste der verfügbaren Bibliotheken für Ihre Anwendung zu aktualisieren.
Python 3
Fügen Sie die Cloud-Clientbibliotheken für Memorystore for Redis der Liste der Abhängigkeiten in der requirements.txt-Datei hinzu.
```
redis
```
App Engine installiert diese Abhängigkeiten während der Anwendungsbereitstellung in der Python 3-Laufzeit automatisch. Löschen Sie daher den Ordner lib, falls vorhanden.

Wenn Ihre Anwendung für Python 2-Anwendungen integrierte oder kopierte Bibliotheken verwendet, die im lib-Verzeichnis angegeben sind, müssen Sie diese Pfade in der appengine_config.py-Datei angeben, die sich im selben Ordner befindet wie Ihre app.yaml-Datei:

import pkg_resources
from google.appengine.ext import vendor

# Set PATH to your libraries folder.
PATH = 'lib'
# Add libraries installed in the PATH folder.
vendor.add(PATH)
# Add libraries to pkg_resources working set to find the distribution.
pkg_resources.working_set.add_entry(PATH)

Redis-Client erstellen

Für die Interaktion mit einer Redis-Datenbank muss Ihr Code einen Redis-Client erstellen, um die Verbindung zu Ihrer Redis-Datenbank zu verwalten. In den folgenden Abschnitten wird beschrieben, wie Sie einen Redis-Client mit der redis-py-Clientbibliothek erstellen.

Umgebungsvariablen angeben

Die redis-py-Clientbibliothek verwendet zwei Umgebungsvariablen, um die URL für Ihre Redis-Datenbank zusammenzustellen:

Eine Variable zur Identifizierung der IP-Adresse der Redis-Datenbank, die Sie in Memorystore erstellt haben.
Eine Variable zur Identifizierung der Portnummer der Redis-Datenbank, die Sie in Memorystore erstellt haben.

Wir empfehlen, diese Variablen in der Datei app.yaml Ihrer Anwendung zu definieren, anstatt sie direkt im Code zu definieren. Dies erleichtert die Ausführung der Anwendung in verschiedenen Umgebungen, z. B. in einer lokalen Umgebung und in App Engine.

Fügen Sie Ihrer app.yaml-Datei beispielsweise die folgenden Zeilen hinzu:

 env_variables:
      REDISHOST: '10.112.12.112'
      REDISPORT: '6379'

redis-py importieren und Client erstellen

Nach dem Definieren der Umgebungsvariablen REDISHOST und REDISPORT verwenden Sie die folgenden Zeilen, um die redis-py-Bibliothek zu importieren und einen Client zu erstellen:

  import redis

  redis_host = os.environ.get('REDISHOST', 'localhost')
  redis_port = int(os.environ.get('REDISPORT', 6379))
  redis_client = redis.Redis(host=redis_host, port=redis_port)

Wenn Sie eine ältere Version von redis-py für andere Anwendungen verwendet haben, haben Sie möglicherweise statt StrictClient die Klasse Client verwendet. redis-py empfiehlt jedoch aktuell Client anstelle von StrictClient.

Daten im Cache mit Redis-Befehlen speichern und abrufen

Die Redis-Datenbank in Memorystore unterstützt die meisten Redis-Befehle, daher benötigen Sie zum Speichern und Abrufen von Daten aus dem Cache nur wenige Befehle. In der folgenden Tabelle werden Redis-Befehle vorgeschlagen, mit denen Sie Daten im Cache speichern können. Informationen zum Aufrufen dieser Befehle aus Ihrer Anwendung finden Sie in der Dokumentation der Clientbibliothek.

Beachten Sie, dass Memcache bei Python 2-Anwendungen für viele seiner Befehle asynchrone Alternativen bereitstellt. Die redis-py-Clientbibliothek stellt jedoch nicht immer äquivalente asynchrone Methoden bereit. Wenn alle Interaktionen mit dem Cache asynchron sein müssen, stehen andere Redis-Clientbibliotheken für Python zur Verfügung.

Aufgabe	Redis-Befehl
Eintrag im Datencache erstellen und eine Ablaufzeit für den Eintrag festlegen	SETNX MSETNX
Daten aus dem Cache abrufen	GET MGET
Vorhandene Cachewerte ersetzen	SET MSET
Erhöht oder verringert numerische Cache-Werte	INCR INCRBY DECR DECRBY
Einträge aus dem Cache löschen	DEL UNLINK
Gleichzeitige Interaktionen mit dem Cache unterstützen (vergleichen und festlegen)	Weitere Informationen zu Redis-Transaktionen Beachten Sie, dass die redis-py-Clientbibliothek erfordert, dass alle Transaktionen in einer Pipeline ausgeführt werden.

Aktualisierungen testen

Wenn Sie Ihre Anwendung lokal testen, sollten Sie eine lokale Instanz von Redis ausführen, um die Interaktion mit Produktionsdaten zu vermeiden (Memorystore stellt keinen Emulator bereit). Folgen Sie der Anleitung in der Redis-Dokumentation, um Redis lokal zu installieren und auszuführen. Redis kann derzeit nicht lokal unter Windows ausgeführt werden.

Weitere Informationen zum Testen von Python-Anwendungen finden Sie unter Lokalen Entwicklungsserver verwenden.

Anwendung bereitstellen

Sobald Ihre Anwendung auf dem lokalen Entwicklungsserver fehlerfrei ausgeführt wird:

Testen Sie die Anwendung in App Engine.
Wenn die Anwendung fehlerfrei ausgeführt wird, verwenden Sie die Trafficaufteilung, um den Traffic für die aktualisierte Anwendung langsam hochzufahren. Prüfen Sie die Anwendung genau auf mögliche Datenbankprobleme, bevor Sie mehr Traffic zur aktualisierten Anwendung leiten.

Nächste Schritte

Eine praxisorientierte Anleitung finden Sie im Codelab zur Migration von App Engine Memcache zu Memorystore for Redis.
Weitere Informationen finden Sie in der Memorystore for Redis-Dokumentation.