שימוש בשדרוג OpenTelemetry ללא קוד לעומסי עבודה של Java ב-GKE

הוספת אינסטרומנטציה ללא קוד ב-OpenTelemetry מאפשרת לאסוף באופן אוטומטי מדדים ומעקבים מאפליקציות Java שפועלות ב-Google Kubernetes Engine‏ (GKE), בלי לשנות את קוד האפליקציה. במדריך הזה תפרסו אפליקציית Java לדוגמה ב-GKE, תגדירו אינסטרומנטציה אוטומטית של OpenTelemetry ותציגו את נתוני הטלמטריה שנוצרו ב-Google Cloud Observability. למרות שהשלבים האלה מתמקדים בעומסי עבודה של Java, אתם יכולים להרחיב את הגישה הזו לשפות נתמכות אחרות.

למה כדאי להשתמש בהטמעה ללא קוד?

הוספה של כלי מדידה ללא קוד (נקראת גם הוספה אוטומטית של כלי מדידה) ב-OpenTelemetry היא כלי יעיל שמאפשר למפתחי אפליקציות להוסיף לקוד שלהם יכולת תצפית ניתנת להגדרה, בלי צורך לכתוב קוד נוסף או לשנות קוד קיים. כדי להשתמש במכשור ללא קוד, מוסיפים באופן אוטומטי מכשור לספריות של אפליקציות שנפרסו באופן פעיל. כך מקבלים תובנות מהימנות לגבי ביצועי האפליקציה על ידי פליטת Golden Signals. לכן, שימוש בכלים ללא קוד הוא נקודת התחלה מצוינת לתהליך התצפיתיות של האפליקציה.

הכלים ללא קוד ב-Java פולטים מדדים וטווחים של מעקב על ידי שימוש בכלים בספריות פופולריות שנמצאות בשימוש נרחב בסביבה של השפה. ב-Java, המדדים כוללים:

• מדדי זמן ריצה של JVM שנוצרו על ידי פלטפורמת Java
• מדדי HttpClient וטווחים של HttpClient שנשלחים מספריות כמו ספריית הלקוח של HTTP ב-Java וספריית הלקוח של HTTP ב-Google.
• מדדים של לקוח מסד נתונים וטווחים של לקוח מסד נתונים שנשלחים מספריות כמו JDBC ו-Lettuce.

קבוצת המדדים שמונפקים תלויה באפליקציה שמוטמעת ובספריות שבהן האפליקציה משתמשת. רשימה מלאה של הספריות והמסגרות שאפשר להשתמש בהן עם סוכן Java zero-code instrumentation מופיעה במאמר ספריות ומסגרות נתמכות.

בעזרת אינסטרומנטציה אוטומטית, אתם יכולים:

• קבלת מעקב אחר אותות הזהב בלי לבצע שינויים בקוד.
• התאמה בין זמן אחזור גבוה של p99.9 לבין מעקבים של משתמשים ספציפיים, שכוללים כל קריאת RPC.
• קבלת נתוני טלמטריה עקביים במדדים, ביומנים ובמעקבים ממגוון רחב של ספריות ו-frameworks פופולריים.

למידע נוסף על שימוש בכלים ללא קוד, ראו ללא קוד ב-OpenTelemetry.

סקירה כללית

כדי להוסיף יכולות ניטור לעומס עבודה ב-Java שפועל ב-GKE, צריך לפרוס את הרכיבים הבאים:

• שדרוג המידע ממעקבים ללא קוד באמצעות OpenTelemetry, שיוצר את הטלמטריה מהאפליקציה.
• ‫OpenTelemetry Collector אוסף את נתוני הטלמטריה שנוצרו על ידי האפליקציה, מעשיר אותם במטא-נתונים ובהקשר חשובים, ומנתב אותם אל Google Cloud לצורך צריכה.

במדריך הזה נסביר איך פורסים אפליקציית Java עם מכשור ב-GKE, שפולטת מדדים ועקבות ל- Google Cloud. אחרי שהנתונים נאספים, אפשר לראות את אותות הטלמטריה האלה באמצעות הכלים של Google Cloudלתצפית, כמו Metrics Explorer,‏ Logs Explorer ו-Trace Explorer. מידע על הצגה ושימוש בטלמטריה שנוצרה זמין במאמר הצגת הטלמטריה.

במדריך הזה נעשה שימוש בשירותים הבאים שניתנים בתשלום כדי לכתוב אותות:

• השירות המנוהל של Cloud Monitoring ל-Prometheus
• Cloud Logging
• Cloud Trace
• Google Kubernetes Engine
• Cloud Build
• Artifact Registry

כדי ליצור הערכת עלויות בהתאם לשימוש החזוי, אתם יכולים להשתמש במחשבון התמחור.

לפני שמתחילים

בקטע הזה מוסבר איך להגדיר את הסביבה לפריסה של האפליקציה, להטמעה שלה ולהרצה שלה.

בחירה או יצירה של פרויקט ב- Google Cloud

בוחרים פרויקט ב- Google Cloud בשביל המדריך הזה. אם עדיין אין לכם פרויקט Google Cloud , אתם יכולים ליצור פרויקט חדש:

נכנסים לחשבון Google Cloud . אנחנו ממליצים למשתמשים חדשים ב- Google Cloud ליצור חשבון כדי שיוכלו להעריך את הביצועים של המוצרים שלנו בתרחישים מהעולם האמיתי. לקוחות חדשים מקבלים בחינם גם קרדיט בשווי 300$ להרצה, לבדיקה ולפריסה של עומסי העבודה.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

התקנת כלי שורת פקודה

במסמך הזה נעשה שימוש בכלי שורת הפקודה הבאים:

• gcloud
• kubectl

הכלים gcloud ו-kubectl הם חלק מ-Google Cloud CLI. במאמר ניהול רכיבי Google Cloud CLI מוסבר איך להתקין אותם. כדי לראות את הרכיבים של ה-CLI של gcloud שהתקנתם, מריצים את הפקודה הבאה:

gcloud components list

הגדרה של משתני סביבה

כדי לצמצם את ההקלדה של ערכים שמופיעים לעיתים קרובות, למנוע שגיאות הקלדה ולאפשר הפעלה של הפקודות במסמך הזה, צריך להגדיר את משתני הסביבה הבאים:

export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME
export CLUSTER_REGION=us-east1
export ARTIFACT_REGISTRY=opentelemetry-autoinstrument-registry
export REGISTRY_LOCATION=us-east4

לפני שמריצים את הפקודות, מחליפים את המשתנים הבאים או משתמשים בערכי ברירת המחדל:

• ‫PROJECT_ID: מזהה הפרויקט.
• ‫CLUSTER_NAME: שם האשכול. יכול להיות שמדובר באשכול חדש או באשכול קיים.
• ‫us-east1: האזור של האשכול. אם אתם משתמשים באשכול קיים, השתמשו באזור של האשכול הזה.
• ‫opentelemetry-autoinstrument-registry: השם של המאגר ב-Artifact Registry. המאגר יכול להיות חדש או קיים.
• ‫us-east4: האזור של המאגר ב-Artifact Registry. אם אתם משתמשים במאגר קיים, צריך להשתמש באזור של המאגר הזה.

אם נתקלתם בשגיאות בהרצת הפקודות במסמך הזה, בדקו שהמשתנים האלה מוגדרים בצורה נכונה בסביבת הטרמינל.

הפעלת ממשקי ה-API

כדי להשתמש בשירותים שמופיעים במסמך הזה, צריך להפעיל את ממשקי ה-API הבאים בפרויקט Google Cloud :

• ‫Artifact Registry API: artifactregistry.googleapis.com
• Cloud Build API: cloudbuild.googleapis.com
• ‫Google Kubernetes Engine: ‏ container.googleapis.com
• ‫Identity and Access Management API‏: iam.googleapis.com
• ‫Cloud Logging API: ‏logging.googleapis.com
• ‫Cloud Monitoring API: monitoring.googleapis.com
• ‫Telemetry API: telemetry.googleapis.com

יכול להיות שממשקי ה-API האלה, חוץ מ-Telemetry API, כבר מופעלים בפרויקט ב- Google Cloud . מריצים את הפקודה הבאה כדי להציג את רשימת ממשקי ה-API המופעלים:

gcloud services list

מפעילים את ממשקי ה-API שעדיין לא מופעלים. שימו לב במיוחד ל-Telemetry API, telemetry.googleapis.com; יכול להיות שזו הפעם הראשונה שאתם נתקלים ב-API הזה.

כדי להפעיל ממשקי API שעדיין לא הופעלו, מריצים את הפקודות של ממשקי ה-API המתאימים:

gcloud services enable artifactregistry.googleapis.com
gcloud services enable cloudbuild.googleapis.com
gcloud services enable container.googleapis.com
gcloud services enable iam.googleapis.com
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com
gcloud services enable telemetry.googleapis.com

קבלת הרשאות

1. כדי לקבל את ההרשאות שדרושות להפעלת האפליקציה ולכתיבת נתוני יומנים, מדדים ומעקב, אתם צריכים לבקש מהאדמין לתת לכם את התפקידים הבאים ב-IAM:

   • כתיבה ביומן (roles/logging.logWriter) בפרויקט
   • כתיבת מדדי מעקב (roles/monitoring.metricWriter) בפרויקט
   • ‫Cloud Telemetry Traces Writer (roles/telemetry.tracesWriter) בפרויקט
   • מפתח (roles/container.developer) בפרויקט
   • עריכה ב-Cloud Build (roles/cloudbuild.builds.editor) בפרויקט
   • כתיבה ב-Artifact Registry ‏ (roles/artifactregistry.writer) בפרויקט
   • משתמש בחשבון שירות (roles/iam.serviceAccountUser) בפרויקט
   • Service Usage Consumer (roles/serviceusage.serviceUsageConsumer) בפרויקט המכסה

   ההרשאות האלה מספיקות אם מריצים את הדוגמה ב-Cloud Shell, ב Google Cloud משאבים או בסביבת פיתוח מקומית. איך מגדירים פרויקט לצורכי מכסה

   חשוב: אפליקציות בייצור מסתמכות בדרך כלל על חשבון שירות כדי לספק את פרטי הכניסה שנדרשים לכתיבת נתוני יומן, מדדים ומעקב. בתרחישים האלה, צריך להקצות לחשבון השירות את התפקידים הקודמים.

2. כדי לקבל את ההרשאות שדרושות לצפייה בנתוני היומנים, המדדים והמעקב, בקשו מהאדמין להקצות לכם את תפקידי ה-IAM הבאים בפרויקט:

   • כלי הצפייה ביומנים (roles/logging.viewer)
   • צפייה ב-Monitoring (roles/monitoring.viewer)
   • משתמש Cloud Trace (roles/cloudtrace.user)

הגדרת האשכול

מגדירים אשכול GKE לאפליקציה לדוגמה ולאוסף:

1. נכנסים אל Google Cloud באמצעות הפקודות הבאות:

   gcloud auth login
   gcloud config set project PROJECT_ID
   

2. אם אין לכם אשכול GKE, אתם יכולים ליצור אשכול Autopilot באמצעות הפקודה הבאה:

   gcloud container clusters create-auto --region us-east1 CLUSTER_NAME --project PROJECT_ID
   

3. כדי לבצע פעולות באשכול, מחברים את כלי השירות המקומי kubectl באמצעות הפקודה הבאה:

   gcloud container clusters get-credentials CLUSTER_NAME --region us-east1 --project PROJECT_ID
   

פריסת האפליקציה ב-Java

בשלבים שבקטע הזה נפרס באשכול אפליקציית Java לדוגמה ללא אינסטרומנטציה, OpenTelemetry Spring Boot instrumentation example. בקטע הזה נשתמש ב-Cloud Build וב-Artifact Registry כדי ליצור ולאחסן את קובץ האימג' של האפליקציה.

1. אם עדיין אין לכם מאגר ב-Artifact Registry, יוצרים מאגר על ידי הרצת הפקודה הבאה:

   gcloud artifacts repositories create opentelemetry-autoinstrument-registry --repository-format=docker --location=us-east4 --description="GKE Autoinstrumentation sample app"
   

2. משכפלים את האפליקציה לדוגמה באמצעות הפקודה הבאה:

   git clone https://github.com/GoogleCloudPlatform/opentelemetry-samples.git
   

3. מגדירים את משתני הסביבה הבאים:

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID
   export ARTIFACT_REGISTRY=opentelemetry-autoinstrument-registry
   export REGISTRY_LOCATION=us-east4
   

4. מריצים את הפקודות הבאות כדי ליצור את קובץ האימג' של האפליקציה ולהעביר אותו למאגר ב-Artifact Registry:

   pushd opentelemetry-samples/java/instrumentation-quickstart && \
   gcloud builds submit --config <(envsubst < cloudbuild-uninstrumented-app.yaml) . && \
   popd
   

   הערה: אם אתם משתמשים במחשב Mac, יכול להיות שתצטרכו קודם להתקין את חבילת gettext מ-Homebrew כדי להריץ את הפקודות הקודמות. מידע נוסף זמין במאמר הזה ב-Stack Overflow. אחרי התקנת החבילה, יכול להיות שתצטרכו להגדיר מחדש את משתני הסביבה.

5. יוצרים קובץ תצורה לפריסה של Kubernetes בשביל האפליקציה. מעתיקים את ההגדרות הבאות ושומרים אותן בקובץ בשם deployment.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     name: quickstart-app
     labels:
       app: quickstart-app
       app.kubernetes.io/part-of: gke-autoinstrument-guide
   spec:
     ports:
       - port: 8080
         targetPort: 8080
         name: quickstart-app
     selector:
       app: quickstart-app
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: quickstart-app
     labels:
       app: quickstart-app
       app.kubernetes.io/part-of: gke-autoinstrument-guide
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: quickstart-app
     template:
       metadata:
         labels:
           app: quickstart-app
       spec:
         containers:
           - name: quickstart-app
             image: us-east4-docker.pkg.dev/PROJECT_ID/opentelemetry-autoinstrument-registry/java-quickstart:latest
             ports:
               - containerPort: 8080
                 name: quickstart-app
   

6. כדי ליצור מרחב שמות לאפליקציה, מריצים את הפקודה הבאה:

   kubectl create namespace APPLICATION_NAMESPACE
   

7. מריצים את הפקודה הבאה כדי להחיל את הגדרות הפריסה על האשכול:

   kubectl apply -f deployment.yaml -n APPLICATION_NAMESPACE
   

8. אחרי שיוצרים את הפריסה, יכול להיות שיעבור זמן מה עד שה-pods ייווצרו ויתחילו לפעול. כדי לבדוק את הסטטוס של הפודים, מריצים את הפקודה הבאה:

   kubectl get po -n APPLICATION_NAMESPACE -w
   

   כדי להפסיק את המעקב אחרי סטטוס ה-Pod, מקישים על Ctrl-C כדי לעצור את הפקודה.

הגדרת מכונה של OpenTelemetry Collector

בקטע הזה יוצרים פריסה נוספת שמריצה מכונה של Google-Built OpenTelemetry Collector באשכול GKE. המאסף מוגדר לייצא נתונים באמצעות רכיבי הייצוא הבאים:

• מדדים באמצעות OTLP HTTP exporter
• מעקבים באמצעות מייצא OTLP HTTP
• יומנים באמצעות Google Cloud Exporter

במקום לבצע את השלבים הידניים שבמסמך הזה כדי לפרוס את OpenTelemetry Collector, אתם יכולים לפעול לפי ההוראות במאמר Managed OpenTelemetry for GKE, שבו משתמשים ב-Google-Built OpenTelemetry Collector בסביבה מנוהלת.

הערה: במסמך הזה מוגדר ה-collector עם ההגדרות המומלצות של Google, שמתאימות לרוב המשתמשים ותרחישי השימוש. אפשר לפרוס כלי איסוף מותאם אישית כדי לתמוך בתרחישי שימוש מתקדמים, אבל צריך לשמור על אפשרויות הגדרה מסוימות כדי לשמור על תאימות ל- Google Cloud. למידע נוסף על הגדרת אוסף בהתאמה אישית, ראו פריסת Google-Built OpenTelemetry Collector ב-Google Kubernetes Engine.

1. כדי לתת הרשאה לחשבון השירות של Kubernetes לפריסת OpenTelemetry Collector, מריצים את הפקודות הבאות:

   export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
   
   gcloud projects add-iam-policy-binding projects/PROJECT_ID \
     --role=roles/logging.logWriter \
     --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector \
     --condition=None
   
   gcloud projects add-iam-policy-binding projects/PROJECT_ID \
     --role=roles/monitoring.metricWriter \
     --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector \
     --condition=None
   
   gcloud projects add-iam-policy-binding projects/PROJECT_ID \
     --role=roles/telemetry.tracesWriter \
     --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/opentelemetry/sa/opentelemetry-collector \
     --condition=None
   

2. כדי לפרוס את מופע OpenTelemetry Collector מבית Google באשכול GKE עם הגדרת ברירת המחדל המומלצת, מריצים את הפקודה הבאה:

   kubectl kustomize https://github.com/GoogleCloudPlatform/otlp-k8s-ingest//k8s/base?ref=otlpmetric | envsubst | kubectl apply -f -
   

   ההגדרה הזו פורסת את ה-collector במרחב השמות opentelemetry.

3. אחרי שיוצרים את הפריסה, יכול להיות שיעבור זמן מה עד שה-pods ייווצרו ויתחילו לפעול. כדי לבדוק את הסטטוס של הפודים, מריצים את הפקודה הבאה:

   kubectl get po -n opentelemetry -w
   

   כדי להפסיק את הצפייה בסטטוס של ה-Pod, מקישים על Ctrl+C כדי להפסיק את הפקודה.

הגדרת שדרוג מידע ממעקבים ללא קוד באמצעות OpenTelemetry

כדי להגדיר באפליקציה שפרוסה ב-GKE אינסטרומנטציה ללא קוד של OpenTelemetry, צריך להתקין את OpenTelemetry Operator באשכול GKE. ה-OpenTelemetry Operator מספק גישה ל-Kubernetes Custom Resource Definition ‏ (CRD), שהוא משאב ה-Instrumentation, שמשמש להחדרת Instrumentation אוטומטית למשאבים ב-Kubernetes שפועלים באשכול.

משאב המדידה "מוזרק" או "מוחל" על עומסי עבודה ספציפיים באמצעות הערות מיוחדות. ה-OpenTelemetry Operator עוקב אחרי ההערות האלה במשאבים שפועלים באשכול, ומזריק את האינסטרומנטציה המתאימה לאפליקציות שמנוהלות על ידי המשאבים האלה.

1. אם ה-CLI של Helm לא מותקן, מתקינים אותו באמצעות הפקודות הבאות:

   curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
   
   chmod 700 get_helm.sh
   
   ./get_helm.sh                         
   

2. אם cert-manager לא מותקן באשכול, מתקינים אותו באמצעות הפקודות הבאות:

   helm repo add jetstack https://charts.jetstack.io
   
   helm repo update
   
   helm install \
   --create-namespace \
   --namespace cert-manager \
   --set installCRDs=true \
   --set global.leaderElection.namespace=cert-manager \
   --set extraArgs={--issuer-ambient-credentials=true} \
   cert-manager jetstack/cert-manager
   

3. מריצים את הפקודה הבאה כדי להתקין את OpenTelemetry Operator בגרסה 0.140.0 ואילך:

   kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/download/v0.140.0/opentelemetry-operator.yaml
   

4. יוצרים קובץ תצורה למשאב בהתאמה אישית של אינסטרומנטציה, על ידי יצירת קובץ בשם instrumentation.yaml עם התוכן הבא:

   apiVersion: opentelemetry.io/v1alpha1
   kind: Instrumentation
   metadata:
     name: sample-java-auto-instrumentation
   spec:
     exporter:
       endpoint: http://opentelemetry-collector.opentelemetry.svc.cluster.local:4317
     sampler:
       type: parentbased_traceidratio
       # Adjust the sampling rate to control cost
       argument: "0.01"
   
     java:
       env:
         - name: OTEL_EXPORTER_OTLP_PROTOCOL
           value: grpc
         - name: OTEL_LOGS_EXPORTER
           value: none
   

5. יוצרים מרחב שמות ל-Operator. אפשר להשתמש באותו ערך שבו השתמשתם למרחב השמות של האפליקציה, APPLICATION_NAMESPACE.

   kubectl create namespace INSTRUMENTATION_NAMESPACE
   

6. יוצרים את המשאב המותאם אישית של הכלים באשכול ומחילים את הקובץ instrumentation.yaml באמצעות הפקודה הבאה:

   kubectl apply -f instrumentation.yaml -n INSTRUMENTATION_NAMESPACE
   

7. החלת ההערה של הוספת מכשור אוטומטית על אפליקציית Java לדוגמה שנפרסה קודם. מריצים את הפקודה הבאה כדי להוסיף את ההערה לפריסה המקורית:

   kubectl patch deployment.apps/quickstart-app -n APPLICATION_NAMESPACE -p '{"spec":{"template":{"metadata":{"annotations":{"instrumentation.opentelemetry.io/inject-java": "'"INSTRUMENTATION_NAMESPACE"'/sample-java-auto-instrumentation"}}}}}'
   

8. אחרי שמתקנים את הפריסה, מה שגורם להפעלה מחדש של פריסת האפליקציה, אפשר לבדוק את הסטטוס של הפודים באפליקציה באמצעות הפקודה הבאה:

   kubectl get po -n APPLICATION_NAMESPACE -w
   

   כדי להפסיק את הצפייה בסטטוס של ה-Pod, מקישים על Ctrl-C כדי לעצור את הפקודה.

אפליקציית Java שנפרסה באשכול GKE מוגדרת עכשיו באופן אוטומטי.

יצירת נתוני טלמטריה מהאפליקציה שנפרסה

כדי ליצור נתוני טלמטריה מהאפליקציה עם האינסטרומנטציה האוטומטית, צריך לשלוח בקשות לאפליקציה כדי לדמות פעילות משתמש. כדי ליצור תנועה קבועה, אפשר להריץ סימולטור תנועה. בקטע הזה מוסבר איך להוריד את הסימולטור, ליצור אותו באמצעות Cloud Build, לאחסן את קובץ האימג' ב-Artifact Registry ולפרוס את הסימולטור:

1. מריצים את הפקודות הבאות כדי להוריד את אפליקציית סימולטור התנועה:

   mkdir traffic-simulator && pushd traffic-simulator && \
   curl -O https://raw.githubusercontent.com/GoogleCloudPlatform/opentelemetry-operator-sample/refs/heads/main/recipes/self-managed-otlp-ingest/traffic/hey.Dockerfile  && \
   curl -O https://raw.githubusercontent.com/GoogleCloudPlatform/opentelemetry-operator-sample/refs/heads/main/recipes/self-managed-otlp-ingest/traffic/cloudbuild-hey.yaml && \
   popd
   

   הפקודות הקודמות מבצעות את הפעולות הבאות:

   1. יוצרים ספרייה נפרדת לבניית אפליקציה לסימולציה של תנועת גולשים.
   2. מורידים את קובץ Dockerfile של האפליקציה.
   3. מורידים את תצורת ה-build של Cloud Build כדי ליצור את קובץ האימג' של האפליקציה.

2. כדי ליצור את קובץ האימג' של האפליקציה באמצעות Cloud Build ולהעביר אותו בדחיפה ל-Artifact Registry, מריצים את הפקודות הבאות:

   pushd traffic-simulator && \
   gcloud builds submit --config <(envsubst < cloudbuild-hey.yaml) . && \
   popd
   

3. יוצרים קובץ תצורה לפריסה של הסימולטור, על ידי העתקת התוכן הבא לקובץ בספרייה traffic-simulator בשם quickstart-traffic.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: traffic-simulator
     labels:
       app.kubernetes.io/part-of: gke-autoinstrument-guide
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: traffic-simulator
     template:
       metadata:
         labels:
           app: traffic-simulator
       spec:
         containers:
           - name: traffic-simulator
             image: us-east4-docker.pkg.dev/PROJECT_ID/opentelemetry-autoinstrument-registry/hey:latest
             args:
             - -c=2
             - -q=1
             - -z=1h
             - http://quickstart-app:8080/multi
   

4. מריצים את הפקודות הבאות כדי לפרוס את סימולטור התנועה:

   pushd traffic-simulator && \
   kubectl apply -f quickstart-traffic.yaml -n APPLICATION_NAMESPACE && \
   popd
   

5. אחרי שיוצרים את הפריסה, יכול להיות שיעבור זמן מה עד שה-pods ייווצרו ויתחילו לפעול. כדי לבדוק את הסטטוס של הפודים, מריצים את הפקודה הבאה:

   kubectl get po -n APPLICATION_NAMESPACE -w
   

   כדי להפסיק את הצפייה בסטטוס של ה-Pod, מקישים על Ctrl+C כדי להפסיק את הפקודה.

צפייה בנתוני הטלמטריה

אחרי שהסימולטור של התנועה מתחיל לשלוח בקשות לאפליקציה, אפליקציית Java שנפרסה יוצרת טלמטריה. יכול להיות שיעברו כמה דקות עד שהמדדים והעקבות יתחילו להופיע ב- Google Cloud.

• הכלים שנוספו על ידי OpenTelemetry Operator מסתמכים על OpenTelemetry Java Agent. ‫OpenTelemetry Java Agent מכיל מכשור מובנה עבור הרבה ספריות ומסגרות עבודה פופולריות של Java שפולטות מדדים.

• הכלים שהוחדרו גם מתעדים באופן אוטומטי את המעקב אחרי כל הקריאות שבוצעו לכל נקודת קצה (endpoint) שנחשפה על ידי האפליקציה לדוגמה. סימולטור התנועה שולח בקשות לנקודת הקצה /multi שנחשפת על ידי אפליקציית Java בקצב קבוע. נקודת הקצה (endpoint) של /multi שולחת בקשות לנקודת הקצה (endpoint) של /single כדי ליצור את התשובה הסופית. האינטראקציות האלה מסתיימות כמעקבים שאפשר לראות באמצעות Trace Explorer.

הצגת המדדים

אפשר לראות את המדדים שנוספו אוטומטית בכלי Metrics Explorer של Cloud Monitoring. הקטע הזה כולל שאילתות לדוגמה שכתובות ב-PromQL.

נכנסים לדף  Metrics explorer במסוף Google Cloud :

כניסה לדף Metrics Explorer

אם אתם משתמשים בשורת החיפוש כדי למצוא את הדף הזה, בחרו בתוצאה שכותרת המשנה שלה היא Monitoring.

אלה חלק מהמדדים שאפשר לראות באפליקציה לדוגמה:

• מדדי זמן ריצה של JVM: OpenTelemetry Java Agent פולט מדדים לגבי ה-JVM הבסיסי. המדדים האלה חושפים מידע על זיכרון JVM, מנגנון איסוף, מחלקות, שרשורים ומושגים קשורים אחרים. רשימה מלאה של מדדי JVM נתמכים זמינה בדף מוסכמות סמנטיות של מדדי זמן ריצה של JVM.

  • שימוש בזיכרון של JVM: מדביקים את שאילתת PromQL הבאה ב-Metrics Explorer:

    sum(avg_over_time({"process.runtime.jvm.memory.usage"}[${__interval}]))
    

  • ניצול CPU של JVM: מדביקים את שאילתת PromQL הבאה ב-Metrics Explorer:

    sum(avg_over_time({"process.runtime.jvm.cpu.utilization"}[${__interval}]))
    

    בתרשים הבא מוצג מדד ניצול המעבד (CPU) של JVM:

    

• מדדי Spring Boot: האפליקציה לדוגמה משתמשת במסגרת Spring Boot, שנתמכת גם על ידי OpenTelemetry zero-code instrumentation ל-Java.

  • משך הזמן הממוצע של צד הלקוח ב-HTTP: מדביקים את השאילתה הבאה ב-PromQL ב-Metrics Explorer:

    sum(rate({"http.client.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.client.duration_count"}[${__interval}])) by (cluster, job)
    

  • משך הזמן הממוצע של שרת HTTP: מדביקים את שאילתת ה-PromQL הבאה ב-Metrics Explorer:

    sum(rate({"http.server.duration_sum"}[${__interval}])) by (cluster, job) / sum(rate({"http.server.duration_count"}[${__interval}])) by (cluster, job)
    

    בתרשים הבא מוצג מדד משך הזמן הממוצע של שרת ה-HTTP ב-Spring Boot:

    

מידע נוסף על השימוש ב-Metrics Explorer מופיע במאמר איך בוחרים מדדים כשמשתמשים ב-Metrics Explorer.

הצגת המעקבים

אתם יכולים לראות את המעקבים שנוצרו באופן אוטומטי ב-Trace Explorer של Cloud Trace. אפשר לסנן את העקבות האלה בכלי Trace Explorer על ידי סינון לפי Service Name (שם השירות) והגדרת שם השירות ל-quickstart-app.

במסוף Google Cloud , נכנסים לדף Trace explorer:

כניסה אל Trace explorer

אפשר גם להשתמש בסרגל החיפוש כדי למצוא את הדף הזה.

בצילום המסך הבא מוצגים המעקבים שנוצרו על ידי פריסת OpenTelemetry quickstart-app:

מידע נוסף על השימוש ב-Trace Explorer מופיע במאמר חיפוש ועיון במעקבים.

הסרת המשאבים

אם יצרתם פרויקט חדש Google Cloud ואין לכם בו יותר צורך, אתם יכולים למחוק אותו באמצעות הפקודה הבאה:

gcloud projects delete PROJECT_ID

אם השתמשתם בפרויקט קיים, אתם יכולים למחוק את המשאבים שיצרתם במהלך המדריך כדי לחסוך בעלויות:

• מריצים את הפקודה הבאה כדי למחוק את אשכול GKE:

  gcloud container clusters delete CLUSTER_NAME --location=us-east1
  

• כדי למחוק את המאגר ב-Artifact Registry, מריצים את הפקודה הבאה:

  gcloud artifacts repositories delete opentelemetry-autoinstrument-registry --location=us-east4