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

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

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

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

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

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

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

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

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

סקירה כללית

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

  • ‫OpenTelemetry zero-code instrumentation, שיוצר את הטלמטריה מהאפליקציה.
  • ‫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 , אתם צריכים ליצור פרויקט:

  1. 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.

    Go to project selector

  2. 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:

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

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

הגדרת האשכול

מגדירים אשכול 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

  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. ה-collector מוגדר לייצא נתונים באמצעות המייצאים הבאים:

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

  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./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./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./subject/ns/opentelemetry/sa/opentelemetry-collector \
  --condition=None

  2. כדי לפרוס את המכונה של Google-Built OpenTelemetry Collector באשכול 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

כדי להגדיר אינסטרומנטציה ללא קוד של OpenTelemetry לאפליקציה שנפרסה ב-GKE, מתקינים את OpenTelemetry Operator באשכול GKE. ה-OpenTelemetry Operator מספק גישה ל-Kubernetes Custom Resource Definition (CRD), שהוא משאב למדידת ביצועים שמשמש להוספת מדידת ביצועים אוטומטית למשאבי 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. מוסיפים את ההערה של Auto-instrumentation לאפליקציית 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. אחרי תיקון הפריסה, שגורם להפעלה מחדש של פריסת האפליקציה, אתם יכולים לבדוק את הסטטוס של ה-pods באפליקציה באמצעות הפקודה הבאה:

    kubectl get po -n APPLICATION_NAMESPACE -w

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

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

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

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

  1. יוצרים קובץ תצורה לפריסה של הסימולטור, על ידי העתקת התוכן הבא לקובץ בשם 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: golang:1.24
          command:
            - go
            - run
            - github.com/rakyll/hey@latest
            - -c=2
            - -q=1
            - -z=1h
            - http://quickstart-app:8080/multi

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

    kubectl apply -f quickstart-traffic.yaml -n APPLICATION_NAMESPACE

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

    kubectl get po -n APPLICATION_NAMESPACE -w

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

הצגת נתוני הטלמטריה

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

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

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

הצגת המדדים

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

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

כניסה לדף Metrics Explorer

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

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

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

    • שימוש בזיכרון של 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:

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

  • מדדי 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:

      בתרשים מוצג משך הזמן הממוצע של שרת ה-HTTP, שתועד באמצעות OpenTelemetry ללא קוד.

איך בוחרים מדדים כשמשתמשים ב-Metrics Explorer

הצגת המעקבים

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

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

כניסה לדף Trace Explorer

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

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

ב-Trace Explorer מוצגים מעקבים שנוצרו באמצעות OpenTelemetry ללא קוד.

מידע נוסף על השימוש ב-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