ב-Memorystore for Redis יש מדדים בזמן אמת בצד השרת למעקב אחרי קצב העברת הנתונים, ניצול המעבד (CPU) והשימוש בזיכרון, אבל יכול להיות שהנתונים האלה לבדם לא יסבירו למה יש זמן אחזור ארוך באפליקציית הלקוח במערכות מבוזרות מורכבות.
מדדים בצד הלקוח פותרים את הבעיה הזו על ידי מתן שקיפות למחזור המלא של הבקשה והתגובה. הם מודדים פקודה מהרגע שהאפליקציה יוזמת אותה ועד שהיא מעבדת את התגובה. בעזרת תיעוד נקודות הנתונים האלה, תוכלו לקבוע במדויק אם מקור זמן האחזור הוא בלוגיקה של האפליקציה, בנתיב הרשת או בשרת Redis.
לפני שמתחילים
מוודאים שאפליקציית הלקוח משתמשת בחשבון שירות, ושהוקצו לה תפקידי ניהול הזהויות והרשאות הגישה (IAM) הבאים:
-
roles/cloudtrace.agent(סוכן Cloud Trace) roles/monitoring.metricWriter(כתיבת מדדי מעקב)
מידע נוסף על הקצאת תפקידים מופיע במדריך למתחילים בנושא הקצאת תפקיד ב-IAM באמצעות מסוף Google Cloud .
הפעלת Cloud Monitoring API
כדי לייצא מדדים בצד הלקוח אל Monitoring, צריך להפעיל את Monitoring API באפליקציה. ייצוא והצגה חזותית של המדדים האלה ב-Monitoring מאפשרים לכם לזהות את שורש הבעיה של צווארי הבקבוק, כדי לקבוע מה המקור של זמן האחזור.
כדי להפעיל את Monitoring API:
במסוף Google Cloud , נכנסים לדף APIs & Services.
בוחרים את הפרויקט שבו יצרתם את המכונה של Memorystore for Redis.
לוחצים על Enable APIs and services.
חיפוש של
monitoring.בתוצאות החיפוש, לוחצים על Cloud Monitoring API.
אם מופיע הכיתוב API enabled, סימן שה-API כבר מופעל. אם לא, לוחצים על Enable.
הפעלת Cloud Trace API
כדי להציג מעקבים מבוזרים ב-Trace, צריך להפעיל את Trace API. לאחר מכן תוכלו להשתמש ב-Trace Explorer כדי להציג את המעקבים האלה, לאבחן צווארי בקבוק ולבודד את מקור זמן האחזור באפליקציה.
כדי להפעיל את Trace API:
במסוף Google Cloud , נכנסים לדף APIs & Services.
בוחרים את הפרויקט שבו יצרתם את המכונה של Memorystore for Redis.
לוחצים על Enable APIs and services.
חיפוש של
trace.בתוצאות החיפוש, לוחצים על Cloud Trace API.
אם מופיע הכיתוב API enabled, סימן שה-API כבר מופעל. אם לא, לוחצים על Enable.
הפעלת Telemetry API
כדי לייצא מדדים בצד הלקוח באמצעות פרוטוקול OpenTelemetry (OTLP), צריך להפעיל את Telemetry API. אחר כך תוכלו להשתמש בייצוא סטנדרטי של OTLP בקוד הלקוח, במקום בייצוא של Google Cloud ספציפי לספק.
מייצאים רגילים של OTLP מונעים אובדן נתונים. הם גם מפשטים את יחסי התלות ומבטיחים שהנתונים יישארו ניידים בין פלטפורמות אחרות של ניראות. אחרי שכותבים את קוד הטלמטריה פעם אחת, אפשר להעביר את הנתונים לכל אחת מהפלטפורמות האלה על ידי עדכון ההגדרות. לא צריך לשכתב את הקוד עם קבוצה חדשה של ספריות קנייניות לכל פלטפורמה.
כדי להפעיל את Telemetry API:
במסוף Google Cloud , נכנסים לדף APIs & Services.
בוחרים את הפרויקט שבו יצרתם את המכונה של Memorystore for Redis.
לוחצים על Enable APIs and services.
חיפוש של
telemetry.בתוצאות החיפוש, לוחצים על Telemetry API.
אם מופיע הכיתוב API enabled, סימן שה-API כבר מופעל. אם לא, לוחצים על Enable.
הפעלת מדדים בצד הלקוח
כדי להפעיל מדדים בצד הלקוח, צריך להוסיף לקוד של האפליקציה את ה-SDK של OpenTelemetry ואת כלי הייצוא של OpenTelemetry OTLP, שמטרגטים את Telemetry API. הכלים של OpenTelemetry, שפועלים ישירות בתוך ספריית הלקוח של Redis באפליקציה, מתעדים את המדדים. כך האפליקציה יכולה לתעד נקודות על הגרף של זמן אחזור ולייצא אותן ל-Monitoring ול-Trace לצורך הצגה חזותית.
כדי להפעיל מדדים בצד הלקוח, אפשר להשתמש ב-Go, ב-Java, ב-Node.js או ב-Python. בכרטיסיות הבאות מופיע מידע על הפעלת המדדים לכל שפה.
המשך
כדי להתקין את יחסי התלות הנדרשים של OpenTelemetry ושל כלי הייצוא של OTLP, מריצים את הפקודות הבאות בטרמינל:
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
כדי להפעיל את המדדים בצד הלקוח, יוצרים קובץ
main.goומוסיפים לו את הקוד הבא:מריצים את האפליקציה למשך דקה לפחות כדי לתת למייצא מספיק זמן לאסוף את המדדים שפורסמו ולשלוח אותם ל-Monitoring.
Java
כדי להתקין את יחסי התלות הנדרשים של OpenTelemetry ושל מייצא OTLP, מוסיפים את הקוד הבא לקובץ
pom.xmlשל האפליקציה:כדי להפעיל את המדדים בצד הלקוח, יוצרים קובץ
RedisTelemetryApp.javaומוסיפים לו את הקוד הבא:מריצים את האפליקציה למשך דקה לפחות כדי לתת למייצא מספיק זמן לאסוף את המדדים שפורסמו ולשלוח אותם ל-Monitoring.
Node.js
כדי להתקין את יחסי התלות הנדרשים של OpenTelemetry ושל כלי הייצוא של OTLP, מריצים את הפקודות הבאות בטרמינל:
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
כדי להפעיל את המדדים בצד הלקוח, יוצרים קובץ
server.jsומוסיפים לו את הקוד הבא:מריצים את האפליקציה למשך דקה לפחות כדי לתת למייצא מספיק זמן לאסוף את המדדים שפורסמו ולשלוח אותם ל-Monitoring.
Python
כדי להתקין את יחסי התלות הנדרשים של OpenTelemetry ושל כלי הייצוא של OTLP, מריצים את הפקודות הבאות בטרמינל:
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
כדי להפעיל את המדדים בצד הלקוח, יוצרים קובץ
main.pyומוסיפים את הקוד הבא לאפליקציה:מריצים את האפליקציה למשך דקה לפחות כדי לתת למייצא מספיק זמן לאסוף את המדדים שפורסמו ולשלוח אותם ל-Monitoring.
הצגת מדדים ב-Monitoring
אחרי שמפעילים את המדדים בצד הלקוח ומריצים את האפליקציה במשך דקה לפחות, כדי לתת למייצא מספיק זמן לאסוף ולשלוח מדדים ל-Monitoring, משתמשים ב-Monitoring כדי להציג את המדדים, לקבץ אותם לפי פעולה או מכונה ולהחיל צבירות כדי לעקוב אחרי ביצועי האפליקציה.
כדי לראות את המדדים ב-Monitoring:
נכנסים לדף Metrics explorer במסוף Google Cloud .
בוחרים את הפרויקט ב- Google Cloud .
לוחצים על בחירת מדד.
חיפוש של
workload.googleapis.com/redis.בוחרים מדד בצד הלקוח. מקבלים את הנתונים לפי
operationו-instanceלפי הצורך, ובוחרים צובר. אפשרויות נוספות מפורטות במאמר איך בוחרים מדדים כשמשתמשים ב-Metrics Explorer.
הצגת מעקבים מבוזרים ב-Trace
אחרי שהאפליקציה מתחילה לייצא נתונים, אפשר להשתמש ב-Trace כדי להציג באופן חזותי את מחזור הבקשה-תגובה המלא של פקודות Redis. הצגת המעקבים המבוזרים ב-Trace מאפשרת לכם לאבחן צווארי בקבוק, כדי שתוכלו לבודד במהירות את המקור המדויק של זמן האחזור באפליקציה.
כדי להציג מעקבים מבוזרים ב-Trace:
נכנסים לדף Trace explorer במסוף Google Cloud .
בוחרים מעקב אחרון שמיוצג על ידי נקודה בתרשים הפיזור.
בודקים את תצוגת ה-Waterfall כדי לבודד את מקור זמן הטעינה על ידי זיהוי צווארי הבקבוק הבאים:
משך הבקשה הכולל: הסרגל ברמה העליונה (הורה) מציג את משך הזמן הכולל שצריך להמתין עד לסיום הפעולה.
זמן האחזור של הרשת והשרת (RTT): הפסים המשניים (כמו אלה שמסומנים ב-
GETאו ב-SET) מציגים את הזמן שנדרש לפקודה לעבור ברשת ולרוץ בשרת Memorystore for Redis.חסימת חיבור לקוח: אם יש פער אופקי גדול וריק לפני שמתחיל ה-span הצאצא של Redis, אז ה-thread של האפליקציה תקוע וממתין לחיבור TCP זמין ממאגר החיבורים.
חסימה של ניתוח האפליקציה: אם יש פער אופקי גדול וריק אחרי שה-span הצאצא של Redis מסתיים, סימן שהאפליקציה מתקשה לנתח או לעבד את המטען הייעודי (payload) שהוחזר. זה קורה לעיתים קרובות עם מחרוזות JSON בגודל של כמה מגה-בייט.
ניסיונות חוזרים: אם אתם רואים כמה טווחי משנה קצרים לאותה פקודה שמתרחשים ברצף באותו מעקב הורה, יכול להיות שהלקוח חווה אובדן מנות ברשת וצריך להפעיל את לולאת הניסיון החוזר של ההשהיה המעריכית לפני ניסיון חוזר (exponential backoff).
פתרון בעיות
בקטע הזה מפורטות בעיות נפוצות בביצועים שאפשר לזהות באמצעות מדדים בצד הלקוח, מוסבר מהן הסיבות העיקריות לבעיות האלה וניתנות הנחיות לפתרון הבעיות.
| שגיאה | מטרה | פתרון בעיות |
|---|---|---|
באפליקציה יש עלייה פתאומית בזמן האחזור, אבל נראה ש-Memorystore for Redis תקין לחלוטין.
|
צוואר הבקבוק נמצא בתוך האפליקציה. השרשורים מנסים להריץ פקודות Redis, אבל מאגר החיבורים מנוצל במלואו. הערך הגבוה של redis_client_blocking_latency מייצג את הזמן שבו הקוד ממתין לשקע TCP זמין לפני שהפקודה נשלחת לרשת. |
כדי לטפל בתנועה הגבוהה יותר בו-זמנית, מגדילים את מגבלות הגודל של מאגר החיבורים בהגדרות של לקוח Redis (לדוגמה, MaxActive ל-Go, MaxTotal ל-Java או max_connections ל-Node.js ול-Python). |
הבקשה הושלמה, אבל נקודת הקצה נמשכת הרבה יותר זמן מהצפוי. אין בעיות שקשורות לתקינות של הרשת או השרת.
|
Memorystore for Redis מריץ את הפקודה והרשת מעבירה את המטען הייעודי (payload) במהירות (זמן הלוך ושוב קצר). עם זאת, המטען הייעודי שמוחזר הוא גדול (לדוגמה, מחרוזת JSON בגודל 15MB). באפליקציה יש redis_application_blocking_latency גבוה כי היא צורכת יותר מדי משאבים בזמן הקצאת הזיכרון וההסרה של המחרוזת הגדולה הזו מהסדרה לאובייקט. |
מבצעים אופטימיזציה של מודל הנתונים. אל תאחסנו אובייקטים גדולים של JSON במפתחות בודדים.
מפרקים את הנתונים באמצעות פונקציות גיבוב (hash) של Redis (HSET) ומשתמשים ב-HGET או ב-HMGET כדי לאחזר רק את השדות הספציפיים שצריך.
|
הזמן שלוקח לאפליקציה להגיב למשתמשים מתארך, אבל במדדים של Redis מדווח על זמן תגובה קצר של השרת ועל מספר רגיל של בקשות למאגר החיבורים.
|
redis_client_rtt מתעד רק את ה-RTT של בקשות שהצליחו, ולכן הוא לא משקף את משך הזמן הקצוב לתפוגה של חבילה שנכשלה. כשהאפליקציה חווה אובדן מנות זמני או איפוסים של TCP, לוגיקת הניסיון החוזר של הלקוח המדווח מגדילה את redis_retry_count ומפעילה את לולאת ההשהיה המעריכית לפני ניסיון חוזר (exponential backoff).
הפעולה הזו גורמת לזמן המתנה בין הניסיונות (לדוגמה, 100ms, 200ms או 400ms). המשתמש חווה זמן אחזור כולל גבוה, אבל שורש הבעיה הוא אובדן מנות ברשת, שגורם לעיכובים בהמתנה בצד הלקוח. |
בודקים ביומני הזרימה של VPC אם יש חבילות שנמחקו, הגבלת רוחב פס או חריגות בניתוב בין אזורים. אם אתם נתקלים בבעיות של זמן קצוב לתפוגה, ודאו שזמן הקצוב לתפוגה של חיבור הלקוח (socket_timeout או connect_timeout) גדול מה-RTT הצפוי, כדי להביא בחשבון את התנודות הזמניות ברשת. |
הכול נעצר וכל השכבות של צינור עיבוד הנתונים של הטלמטריה מדווחות על זמן אחזור ארוך.
|
Redis הוא single-threaded. כשמריצים פקודה עם מורכבות זמן של O(N), כמו KEYS *, SMEMBERS על קבוצה גדולה או HGETALL על גיבוב עם מיליוני שדות, מנוע Redis מושהה כדי למלא את הבקשה. בזמן שהפקודה הזו פועלת, כל בקשה אחרת של האפליקציה נכנסת לתור, וכתוצאה מכך יש עלייה חדה בזמן האחזור בכל המערכת. מכיוון שהערך של redis_client_rtt בהתאמה אישית תואם לזמן האחזור של השרת (commands/usec_per_call), השרת שמריץ את הפקודה הוא צוואר הבקבוק. |
פותחים את Trace ומסתכלים על פקודות Redis בפרקי הזמן האיטיים כדי לזהות איזו שאילתה גורמת לחסימה. החליפו פקודות חסימה בפקודות ללא חסימה בקוד. כדי לעבור על מערכי נתונים גדולים באופן מצטבר בלי לנעול את השרשור של השרת, משתמשים ב- |
באפליקציה מדווח על זמן אחזור בסיסי גבוה ועקבי לכל פקודות Redis, גם כשתעבורת הנתונים נמוכה.
|
שרת Redis מריץ פקודות באופן מיידי, אבל האפליקציה והמכונה פרוסות באזורים שונים (לדוגמה, us-central1 ו-us-east1). כל חבילת נתונים ברשת צריכה לעבור בתשתית הענן הפיזית של Google Cloud בין מרכזי הנתונים הגיאוגרפיים האלה. התוצאה היא זמן אחזור חובה בין אזורים במהירות האור לכל נסיעה הלוך ושוב. |
כדי לצמצם את זמן האחזור, כדאי לפרוס את האפליקציה כך שתהיה באותו אזור ובאותו תחום כמו המכונה. כדי לראות את האזור של האפליקציה והמכונה, משתמשים במסוף Google Cloud . |