Memorystore for Redis bietet zwar serverseitige Echtzeitmesswerte zur Überwachung von Durchsatz, CPU-Auslastung und Speichernutzung, aber diese Daten allein erklären möglicherweise nicht, warum Ihre Clientanwendung in komplexen verteilten Systemen eine hohe Latenz aufweist.
Clientseitige Messwerte lösen dieses Problem, indem sie Transparenz über den gesamten Anfrage-Antwort-Zyklus bieten. Sie messen einen Befehl ab dem Zeitpunkt, an dem die Anwendung ihn initiiert, bis zu dem Zeitpunkt, an dem die Anwendung die Antwort verarbeitet. Durch das Erfassen dieser Datenpunkte können Sie genau feststellen, ob die Latenz von der Anwendungslogik, dem Netzwerkpfad oder dem Redis-Server verursacht wird.
Hinweis
Achten Sie darauf, dass Ihre Clientanwendung ein Dienstkonto verwendet und ihm die folgenden IAM-Rollen (Identity and Access Management) zugewiesen sind:
roles/cloudtrace.agent(Cloud Trace-Agent)roles/monitoring.metricWriter(Monitoring-Messwert-Autor)
Weitere Informationen zum Zuweisen von Rollen finden Sie in der Kurzanleitung IAM-Rolle über die Google Cloud -Console zuweisen.
Cloud Monitoring API aktivieren
Wenn Sie clientseitige Messwerte in Monitoring exportieren möchten, müssen Sie in Ihrer Anwendung die Monitoring API aktivieren. Wenn Sie diese Messwerte in Monitoring exportieren und visualisieren, können Sie die Ursache von Engpässen ermitteln und feststellen, wo die Latenz entsteht.
So aktivieren Sie die Monitoring API:
Rufen Sie in der Google Cloud Console die Seite APIs und Dienste auf.
Wählen Sie das Projekt aus, in dem Sie die Memorystore for Redis-Instanz erstellt haben.
Klicken Sie auf APIs und Dienste aktivieren.
Suchen Sie nach
monitoring.Klicken Sie in den Suchergebnissen auf Cloud Monitoring API.
Wenn API aktiviert angezeigt wird, ist die API bereits aktiviert. Klicken Sie andernfalls auf Aktivieren.
Cloud Trace API aktivieren
Wenn Sie verteilte Traces in Trace ansehen möchten, müssen Sie die Trace API aktivieren. Anschließend können Sie mit Trace Explorer diese Traces ansehen, Engpässe diagnostizieren und die Latenzquelle in Ihrer Anwendung isolieren.
So aktivieren Sie die Trace API:
Rufen Sie in der Google Cloud Console die Seite APIs und Dienste auf.
Wählen Sie das Projekt aus, in dem Sie die Memorystore for Redis-Instanz erstellt haben.
Klicken Sie auf APIs und Dienste aktivieren.
Suchen Sie nach
trace.Klicken Sie in den Suchergebnissen auf Cloud Trace API.
Wenn API aktiviert angezeigt wird, ist die API bereits aktiviert. Klicken Sie andernfalls auf Aktivieren.
Telemetry API aktivieren
Wenn Sie clientseitige Messwerte mit dem OpenTelemetry Protocol (OTLP) exportieren möchten, müssen Sie die Telemetry API aktivieren. Anschließend können Sie in Ihrem Clientcode Standard-OTLP-Exporter anstelle von anbieterspezifischen Google Cloud -Exportern verwenden.
Standard-OTLP-Exporter verhindern Datenverlust. Außerdem werden Ihre Abhängigkeiten vereinfacht und Ihre Daten bleiben auf anderen Beobachtbarkeitsplattformen übertragbar. Nachdem Sie Ihren Telemetriecode einmal geschrieben haben, können Sie Ihre Daten an jede dieser Plattformen weiterleiten, indem Sie Ihre Konfiguration aktualisieren. Sie müssen Ihren Code nicht für jede Plattform mit einem neuen Satz proprietärer Bibliotheken umschreiben.
So aktivieren Sie die Telemetry API:
Rufen Sie in der Google Cloud Console die Seite APIs und Dienste auf.
Wählen Sie das Projekt aus, in dem Sie die Memorystore for Redis-Instanz erstellt haben.
Klicken Sie auf APIs und Dienste aktivieren.
Suchen Sie nach
telemetry.Klicken Sie in den Suchergebnissen auf Telemetry API.
Wenn API aktiviert angezeigt wird, ist die API bereits aktiviert. Klicken Sie andernfalls auf Aktivieren.
Clientseitige Messwerte aktivieren
Wenn Sie clientseitige Messwerte aktivieren möchten, fügen Sie dem Code Ihrer Anwendung das OpenTelemetry-SDK und die OpenTelemetry-OTLP-Exporter hinzu, die auf die Telemetry API ausgerichtet sind. Die OpenTelemetry-Instrumentierung, die direkt in der Redis-Clientbibliothek Ihrer Anwendung ausgeführt wird, erfasst die Messwerte. Dadurch kann Ihre Anwendung Latenzdatenpunkte aufzeichnen und zur Visualisierung in Monitoring und Trace exportieren.
Zum Aktivieren clientseitiger Messwerte können Sie Go, Java, Node.js oder Python verwenden. Informationen zum Aktivieren der Messwerte für die einzelnen Sprachen finden Sie auf den folgenden Tabs.
Go
Führen Sie die folgenden Befehle in Ihrem Terminal aus, um die erforderlichen OpenTelemetry- und OTLP-Exporter-Abhängigkeiten zu installieren:
go get github.com/gomodule/redigo/redis@latest go get go.opentelemetry.io/otel go get go.opentelemetry.io/otel/sdk go get go.opentelemetry.io/otel/sdk/metric go get go.opentelemetry.io/contrib/detectors/gcp go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc go get go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc go get golang.org/x/oauth2/google go get google.golang.org/grpc
Wenn Sie die clientseitigen Messwerte aktivieren möchten, erstellen Sie eine
main.go-Datei und fügen Sie ihr den folgenden Code hinzu:Führen Sie Ihre Anwendung mindestens eine Minute lang aus, damit der Exporter genügend Zeit hat, die veröffentlichten Messwerte zu bündeln und an Monitoring zu senden.
Java
Wenn Sie die erforderlichen OpenTelemetry- und OTLP-Exporter-Abhängigkeiten installieren möchten, fügen Sie der Datei
pom.xmlIhrer Anwendung den folgenden Code hinzu:Erstellen Sie eine
RedisTelemetryApp.java-Datei und fügen Sie den folgenden Code hinzu, um die clientseitigen Messwerte zu aktivieren:Führen Sie Ihre Anwendung mindestens eine Minute lang aus, damit der Exporter genügend Zeit hat, die veröffentlichten Messwerte zu bündeln und an Monitoring zu senden.
Node.js
Führen Sie die folgenden Befehle in Ihrem Terminal aus, um die erforderlichen OpenTelemetry- und OTLP-Exporter-Abhängigkeiten zu installieren:
npm install redis@^4.6.0 \ @grpc/grpc-js@^1.12.0 \ google-auth-library@^9.15.0 \ @opentelemetry/api@^1.9.0 \ @opentelemetry/sdk-trace-node@^2.1.0 \ @opentelemetry/sdk-trace-base@^2.1.0 \ @opentelemetry/sdk-metrics@^2.1.0 \ @opentelemetry/instrumentation@^0.205.0 \ @opentelemetry/instrumentation-redis@^0.67.0 \ @opentelemetry/exporter-trace-otlp-grpc@^0.205.0 \ @opentelemetry/exporter-metrics-otlp-grpc@^0.205.0 \ @opentelemetry/resources@^2.10.0 \ @opentelemetry/resource-detector-gcp@^0.40.0
Wenn Sie die clientseitigen Messwerte aktivieren möchten, erstellen Sie eine
server.js-Datei und fügen Sie ihr den folgenden Code hinzu:Führen Sie Ihre Anwendung mindestens eine Minute lang aus, damit der Exporter genügend Zeit hat, die veröffentlichten Messwerte zu bündeln und an Monitoring zu senden.
Python
Führen Sie die folgenden Befehle in Ihrem Terminal aus, um die erforderlichen OpenTelemetry- und OTLP-Exporter-Abhängigkeiten zu installieren:
pip install redis>=5.0.0 \ opentelemetry-api==1.39.1 \ opentelemetry-sdk==1.39.1 \ opentelemetry-instrumentation-redis==0.60b1 \ opentelemetry-exporter-otlp-proto-grpc \ opentelemetry-resourcedetector-gcp \ google-auth \ requests \ grpcio
Wenn Sie die clientseitigen Messwerte aktivieren möchten, erstellen Sie eine
main.py-Datei und fügen Sie Ihrer Anwendung den folgenden Code hinzu:Führen Sie Ihre Anwendung mindestens eine Minute lang aus, damit der Exporter genügend Zeit hat, die veröffentlichten Messwerte zu bündeln und an Monitoring zu senden.
Messwerte in Monitoring ansehen
Nachdem Sie clientseitige Messwerte aktiviert und Ihre Anwendung mindestens eine Minute lang ausgeführt haben, damit der Exporter genügend Zeit hat, Messwerte zu bündeln und an Monitoring zu senden, können Sie Monitoring verwenden, um Ihre Messwerte zu visualisieren, sie nach Vorgang oder Instanz zu gruppieren und Aggregatoren anzuwenden, um die Leistung Ihrer Anwendung zu überwachen.
So rufen Sie Messwerte in Monitoring auf:
Wechseln Sie in der Google Cloud Console zur Seite Metrics Explorer.
Wählen Sie Ihr Google Cloud Projekt aus.
Klicken Sie auf Messwert auswählen.
Suchen Sie nach
workload.googleapis.com/redis.Wählen Sie einen clientseitigen Messwert aus. Gruppieren Sie die Daten nach Bedarf nach
operationundinstanceund wählen Sie einen Aggregator aus. Weitere Optionen finden Sie unter Messwerte bei Verwendung von Metrics Explorer auswählen.
Verteilte Traces in Trace ansehen
Nachdem Ihre Anwendung mit dem Exportieren von Daten begonnen hat, können Sie Trace verwenden, um den gesamten Anfrage-Antwort-Zyklus Ihrer Redis-Befehle zu visualisieren. Wenn Sie sich Ihre verteilten Traces in Trace ansehen, können Sie Engpässe diagnostizieren und so die genaue Ursache der Latenz in Ihrer Anwendung schnell isolieren.
So rufen Sie verteilte Traces in Trace auf:
Rufen Sie in der Google Cloud Console die Seite Trace Explorer auf.
Wählen Sie einen aktuellen Trace aus, der durch einen Punkt im Streudiagramm dargestellt wird.
Sehen Sie sich die Wasserfallansicht an, um die Latenzquelle zu isolieren. Identifizieren Sie dazu die folgenden Engpässe:
Gesamte Anfragedauer: Der oberste Balken (übergeordnet) zeigt die Gesamtzeit an, die Sie auf den Abschluss des Vorgangs warten müssen.
Netzwerk- und Serverlatenz (RTT): Die untergeordneten Balken (z. B. mit den Labels
GEToderSET) zeigen die Zeit, die der Befehl für die Übertragung über das Netzwerk und die Ausführung auf dem Memorystore for Redis-Server benötigt hat.Blockierung der Clientverbindung: Wenn es eine große, leere horizontale Lücke vor dem Beginn des untergeordneten Redis-Spans gibt, wartet der Anwendungsthread auf eine verfügbare TCP-Verbindung aus dem Verbindungspool.
Blockierung beim Parsen der Anwendung: Wenn nach dem Ende des untergeordneten Redis-Spans eine große, leere horizontale Lücke vorhanden ist, hat die Anwendung Schwierigkeiten, die zurückgegebene Nutzlast zu parsen oder zu verarbeiten. Dies geschieht häufig bei JSON-Strings mit mehreren Megabyte.
Wiederholungen: Wenn Sie mehrere kurze untergeordnete Spans für denselben Befehl sehen, die nacheinander innerhalb desselben übergeordneten Trace auftreten, kann es sein, dass Ihr Client Netzwerkpaketverluste hat und seine exponentielle Backoff-Wiederholungsschleife auslösen muss.
Fehlerbehebung
In diesem Abschnitt werden häufige Leistungsprobleme aufgeführt, die Sie mithilfe von clientseitigen Messwerten identifizieren können. Außerdem werden die Ursachen erläutert und es wird beschrieben, wie Sie die Probleme beheben können.
| Problem | Ursache | Fehlerbehebung |
|---|---|---|
In Ihrer Anwendung tritt ein plötzlicher Latenzanstieg auf, aber Memorystore for Redis scheint völlig fehlerfrei zu sein.
|
Der Engpass befindet sich ausschließlich in Ihrer Anwendung. Ihre Threads versuchen, Redis-Befehle auszuführen, aber der Verbindungspool ist vollständig erschöpft. Der hohe redis_client_blocking_latency-Wert stellt die Zeit dar, die Ihr Code auf einen verfügbaren TCP-Socket wartet, bevor der Befehl an das Netzwerk gesendet wird. |
Erhöhen Sie die Größenlimits für den Verbindungspool in Ihrer Redis-Clientkonfiguration (z. B. MaxActive für Go, MaxTotal für Java oder max_connections für Node.js und Python), um den höheren gleichzeitigen Traffic zu bewältigen. |
Die Anfrage wird abgeschlossen, aber der Endpunkt benötigt deutlich länger als erwartet. Es gibt keine Probleme mit dem Zustand Ihres Netzwerks oder Servers.
|
Memorystore for Redis führt den Befehl aus und das Netzwerk überträgt die Nutzlast schnell (niedrige RTT). Die zurückgegebene Nutzlast ist jedoch groß (z. B. ein JSON-String mit 15 MB). In Ihrer Anwendung tritt ein hoher redis_application_blocking_latency auf, da die Anwendung beim Zuweisen von Arbeitsspeicher und Deserialisieren dieses großen Strings in ein Objekt übermäßig viele Ressourcen verbraucht. |
Datenmodell optimieren Speichern Sie keine riesigen JSON-Blobs in einzelnen Schlüsseln.
Schlüsseln Sie die Daten mithilfe von Redis-Hashes (HSET) auf und verwenden Sie HGET oder HMGET, um nur die spezifischen Felder abzurufen, die Sie benötigen.
|
Die Latenz Ihrer für Nutzer sichtbaren Anwendung steigt, aber Ihre Redis-Messwerte zeigen eine niedrige Serverlatenz und typische Verbindungspool-Checkouts an.
|
Da redis_client_rtt nur die RTT erfolgreicher Anfragen erfasst, wird die Zeitlimitdauer eines fehlgeschlagenen Pakets nicht berücksichtigt. Wenn in Ihrer Anwendung vorübergehende Paketverluste oder TCP-Zurücksetzungen auftreten, erhöht die Wiederholungslogik des instrumentierten Clients den Wert redis_retry_count und löst die exponentielle Backoff-Schleife aus.
Dadurch wird eine Wartezeit zwischen den Versuchen eingeführt (z. B. 100ms, 200ms oder 400ms). Der Nutzer erlebt eine hohe Gesamtlatenz, aber die zugrunde liegende Ursache ist ein Netzwerk-Paketverlust, der clientseitige Wartezeiten auslöst. |
Prüfen Sie Ihre VPC-Flusslogs auf verworfene Pakete, Bandbreitendrosselung oder Anomalien beim regionsübergreifenden Routing. Wenn Sie aggressive Zeitüberschreitungen feststellen, sollten Sie darauf achten, dass die Zeitüberschreitungen für Clientverbindungen (socket_timeout oder connect_timeout) größer als die erwartete RTT sind, um vorübergehenden Netzwerk-Jitter zu berücksichtigen. |
Alles wird angehalten und alle Ebenen der Telemetriepipeline melden eine hohe Latenz.
|
Redis ist Single-Threaded. Wenn Sie einen Befehl mit der Zeitkomplexität O(N) ausführen, z. B. KEYS *, SMEMBERS für einen riesigen Satz oder HGETALL für einen Hash mit Millionen von Feldern, pausiert die Redis-Engine, um diese Anfrage zu erfüllen. Während dieser Befehl ausgeführt wird, werden alle anderen Anwendungsanfragen in die Warteschlange gestellt, was zu einer systemweiten Latenzspitze führt. Da Ihr benutzerdefinierter redis_client_rtt mit der Latenz des Servers (commands/usec_per_call) übereinstimmt, ist der Server, auf dem der Befehl ausgeführt wird, der Engpass. |
Öffnen Sie Trace und sehen Sie sich die Redis-Befehle in den langsamen Spans an, um herauszufinden, welche Abfrage die Blockierung verursacht. Ersetzen Sie blockierende Befehle in Ihrem Code durch nicht blockierende Befehle. Wenn Sie große Datasets schrittweise durchlaufen möchten, ohne den Serverthread zu sperren, verwenden Sie |
Ihre Anwendung meldet eine konsistente, erhöhte Baseline-Latenz für alle Redis-Befehle, auch bei geringem Traffic.
|
Der Redis-Server führt Befehle sofort aus, aber Ihre Anwendung und Ihre Instanz werden in verschiedenen Regionen bereitgestellt (z. B. us-central1 und us-east1). Jedes Netzwerkpaket muss über die physische Google Cloud-Infrastruktur zwischen diesen geografischen Rechenzentren übertragen werden. Dies führt zu einer obligatorischen, überregionalen Latenzstrafe für jeden Hin- und Rückflug. |
Um die Latenz zu verringern, stellen Sie Ihre Anwendung in derselben Region und Zone wie Ihre Instanz bereit. In der Google Cloud Console können Sie die Region Ihrer Anwendung und Instanz aufrufen. |