Գնահատել նախագիծը
← Բոլոր հրապարակումները

JVM-ի ներքին մետրիկաների ուղարկումը GCP Monitoring OpenTelemetry-ով (առանց կոդի)

Քայլ առ քայլ ուղեցույց՝ Java հավելվածի ներքին մետրիկաները GCP Monitoring ծառայություն ուղարկելու համար OpenTelemetry-ով (GKE-ում աշխատող OpenTelemetry operator-ով)։

8 րոպե
JavaGCPKubernetesJVMGCP monitoringOpenTelemetry

Այս ձեռնարկում ցույց կտամ, թե ինչպես Java հավելվածի ներքին մետրիկաները ուղարկել GCP Monitoring ծառայություն։

Կօգտագործեմ OpenTelemetry (որն աշխատում է որպես OpenTelemetry operator GKE-ում), և խոստանում եմ՝ Java կոդի ոչ մի տող չեմ գրի ;)։

Ի՞նչ է OpenTelemetry-ը

Հարցը շրջեմ՝ ի՞նչ չէ OpenTelemetry-ը։

Այն ևս մեկ մոնիթորինգի գործիք կամ գրադարան չէ։ Փոխարենը դա ստանդարտացված եղանակ է՝ հավաքելու, մշակելու և արտահանելու հեռաչափական տվյալներ, ինչպիսիք են լոգերը, մետրիկաները և trace-երը։

Պատկերացրեք՝ մեր հավելվածը instrument է արված որևէ գործիքով, ասենք՝ Kamon-ով։ Ի՞նչ կլինի, եթե հետո որոշենք, որ նախընտրում ենք Prometheus-ը։ Մենք ստիպված կլինենք վերագրել հավելվածի կոդի մեծ մասը։

OpenTelemetry-ը փոխում է խաղի կանոնները. նրա ընդհանուր SDK-ն և API-ն թույլ են տալիս մշակողներին ազդանշաններ ուղարկել գործնականում ցանկացած ուղղությամբ։ Միակ պայմանն այն է, որ backend-ը խոսի otlp պրոտոկոլով, կամ որ գոյություն ունենա համատեղելի OpenTelemetry exporter։

OpenTelemetry-ի այլընտրանքները

Երբ գոյություն ունեցող հավելվածներն արդեն instrument արված են և տրամադրում են Prometheus-ի հետ համատեղելի մետրիկաներ, դրանք կարող եք օգտագործել GCP Monitoring-ում Managed Service for Prometheus-ի միջոցով։ Սա Prometheus-ի հետ համատեղելի backend է, որը կարելի է ավտոմատ ավելացնել GKE կլաստերին՝ միացնելով այն GKE-ի կոնֆիգուրացիայում։ Միացնելուց հետո այն տեղակայում է մետրիկաների կոլեկտորներ, Google Managed Prometheus controller-ը (gmp-controller) և մի քանի CRD (օրինակ՝ PodMonitorig)՝ ընտրելու համար, թե որ pod-երը կամ ծառայությունները մոնիթորինգի ենթարկվեն։

Ինչո՞ւ օգտագործել OpenTelemetry։ GCP monitoring-ը բավարար չէ՞

GCP Monitoring-ը շատ լավ է մշակում հենց GKE համակարգի արձակած մետրիկաները, ինչպես նաև կոնտեյներների որոշ մետրիկաներ։ Որոշները, ոչ բոլորը։ Դրանով չի ստացվի հավելվածի ներսից մետրիկաներ ստանալ, ինչպիսիք են JVM-ի ներքին մետրիկաները, գրադարանների հատուկ մետրիկաները և այլն։

Այդ մետրիկաները ստանալու համար անհրաժեշտ է մի բան, որը աշխատում է JVM-ի ներսում և հրապարակում է դրանք կոլեկտորին։

Առկա կարգավորումը

Ենթադրենք՝ մենք արդեն ունենք GKE կլաստեր, որի վրա աշխատում են JVM-ի վրա հիմնված մի քանի միկրոսերվիսներ։ GKE-ի հանգույցներն արդեն ունեն գրելու հասանելիություն monitoring-ին, ուստի մենք բաց թողեցինք workload identity federation-ը, որը GKE workload-ներին GCP-ի հասանելիություն տալու առաջարկվող եղանակն է (ես սա ընտրեցի՝ ամեն ինչ պարզ պահելու համար)։

OpenTelemetry-ի տեղադրումը

Քանի որ աշխատում ենք Kubernetes կլաստերի հետ, OpenTelemetry-ը կտեղադրենք որպես Kubernetes operator։ OpenTelemetry operator-ը կազմված է՝

  1. OpenTelemetry controller-ից
  2. OpenTelemetry collector-ի CRD-ից
  3. OpenTelemetry instrumentation-ի CRD-ից։

Operator-ը կարելի է տեղադրել մի քանի եղանակով՝ operator manifest-ով, Helm chart-ով, կամ Operator Hub-ով։ Ես կընտրեմ Helm chart-ը։ Այն տեղադրելու համար սկզբում պետք է ավելացնել Helm repository-ն՝

$ helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
$ helm repo update

և հետո տեղադրել chart-ը՝

$ helm install --namespace otel-system --create-namespace \
  opentelemetry-operator open-telemetry/opentelemetry-operator

Այստեղ ես օգտագործեցի otel-system namespace, բայց կարող եք ընտրել ցանկացած անուն։

Կարևոր է. OpenTelemetry operator-ը հենվում է admission webhook-ի վրա, որն ըստ լռելյայն օգտագործում է TLS։ Լռելյայն կարգավորումներով Helm-ը ենթադրում է, որ cert-manager-ը արդեն տեղադրված է կլաստերում։ Readme ֆայլում նկարագրված են OpenTelemetry operator chart-ը առանց cert-manager-ի տեղադրելու մի քանի այլընտրանքային եղանակներ։

Ստուգենք, որ chart-ը ճիշտ է տեղադրվել՝

$ kubectl -n otel-system get deployments
NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
opentelemetry-operator          1/1      1           1           4min

$  kubectl get opentelemetrycollectors
No resources found in default namespace.

Collector-ի ստեղծումը

Մինչև հավելվածներից մետրիկաներ հավաքելը մեզ անհրաժեշտ է OpenTelemetry collector։ Այն պատասխանատու է մետրիկաները ստանալու և մշակելու, և ըստ ցանկության՝ արտաքին համակարգ արտահանելու համար. այստեղ՝ GCP Monitoring։

Collector-ը կարելի է աշխատեցնել մի քանի եղանակով՝

Deployment

Այստեղ collector-ը աշխատում է սովորական հավելվածի պես։ Այն մեծացնելը և փոքրացնելը, նախորդ տարբերակ վերադարձնելը և այն ամենը, ինչ սովորաբար անում եք հավելվածի հետ, պարզ է։ Սա հավանաբար collector-ը տեղակայելու ամենաուղիղ եղանակն է։

Daemonset

Երբ ձեզ անհրաժեշտ է, որ collector-ը գործի որպես գործակալ Kubernetes-ի հանգույցներում, կարող եք այն աշխատեցնել որպես daemonset։ Սա օգտակար է Host Metrics Receiver-ով հանգույցներից host-ի մակարդակի մետրիկաներ հավաքելու համար. այդ դեպքում collector-ը պետք է ունենա ուղիղ հասանելիություն հանգույցներին։ Թերությունն այն է, որ այն չի կարող առանձին մասշտաբավորվել։

Statefulset

Սա հարմար է, երբ ձեր pod-երին անհրաժեշտ են ստատիկ host անուններ։

Sidecar

Այստեղ collector-ը ներարկվում է pod-ի մեջ որպես լրացուցիչ կոնտեյներ։ Նպատակն է հեռաչափական տվյալները հնարավորինս արագ փոխանցել collector-ին։ Յուրաքանչյուր pod ստանում է իր սեփական collector-ը։

Մենք ընտրեցինք deployment-ը, քանի որ դա ամենապարզ տարբերակն է։

Ահա մեր collector-ի manifest-ը՝

apiVersion: opentelemetry.io/v1alpha1
kind: OpenTelemetryCollector
metadata:
  name: gcp
  namespace: otel-system
spec:
  mode: "deployment"
  config: |
    receivers:
      otlp:
        protocols:
          grpc:
          http:

    exporters:
      googlecloud:

    processors:

      batch:
        # batch metrics before sending to reduce API usage
        send_batch_max_size: 200
        send_batch_size: 200
        timeout: 5s

      memory_limiter:
        # drop metrics if memory usage gets too high
        check_interval: 1s
        limit_percentage: 65
        spike_limit_percentage: 20

      resourcedetection:
        # detect cluster name and location
        detectors: [gcp]
        timeout: 10s

    service:
      pipelines:
        metrics:
          receivers: [otlp]
          processors: [batch, memory_limiter, resourcedetection]
          exporters: [googlecloud]

Եկեք վերլուծենք այն մաս առ մաս։

Մենք ստեղծում ենք gcp անունով collector otel-system namespace-ում։

Նրա spec-ը պարունակում է 2 դաշտ՝ mode, որը դրված է deployment, ինչպես նկարագրված է վերևում, և config, որը սովորական OpenTelemetry կոնֆիգուրացիոն ֆայլ է։

Կոնֆիգուրացիան սահմանում է receiver-ները, processor-ները և exporter-ները։ Վերջում այս երեք մասերը համակցվում են pipeline-ի մեջ։

Մենք ընդունում ենք միայն otlp պրոտոկոլով ուղարկված տվյալներ՝ grpc-ով կամ http-ով։ Նրանցից յուրաքանչյուրն ունի իր endpoint-ը և պորտը։

Երբ տվյալները հասնում են, մենք դրանք մշակում ենք։ Սկզբում batch processor-ը առանձին ազդանշանները խմբավորում է փաթեթների։ Մենք և՛ փաթեթի չափը, և՛ առավելագույն չափը դրեցինք 200 (մետրիկաների քանակ), իսկ timeout-ը՝ 5s. այդ ժամանակը անցնելուց հետո փաթեթը գնում է pipeline-ի հաջորդ բաղադրիչին՝ անկախ նրանից, թե ներկայում որքան մեծ է։

Pipeline-ում հաջորդը memory_limiter-ն է։ Այն կա, որպեսզի հիշողությունը չվերջանա, երբ պետք է մշակել շատ տվյալներ։ Մենք օգտագործում ենք հարաբերական արժեքներ, ուստի սահմանները դինամիկ կերպով ճշգրտվում են՝ ըստ հասանելի հիշողության։

Վերջին processor-ը resourcedetection-ն է. այն հայտնաբերում է ռեսուրսի տեղեկատվությունը host համակարգից և ավելացնում է այն OpenTelemetry ձևաչափի ազդանշաններին։ Հենց այդպես ենք իմանում աղբյուր pod-ի անունը, նրա namespace-ը և այլն։ Մենք օգտագործում ենք gcp detector-ը՝ google metadata սերվերից և GCP-ին հատուկ միջավայրի փոփոխականներից տեղեկատվություն քաշելու համար։

Մշակվելուց հետո տվյալները արտահանվում են googlecloud, ինչը պարզապես նշանակում է, որ դրանք գրվում են որպես մետրիկա GCP Monitoring համակարգում։

Կիրառենք manifest-ը՝

kubectl apply -f collector.yaml

Manifest-ը կիրառելուց հետո collector-ների ցանկը պետք է որոշ արդյունք վերադարձնի՝

kubectl -n otel-system get opentelemetrycollectors
NAME   MODE         VERSION   READY   AGE     IMAGE                                         MANAGEMENT
gcp    deployment   0.85.0    1/1     3d23h   otel/opentelemetry-collector-contrib:0.85.0   managed

Ուրեմն ի՞նչ է տեղի ունենում collector ստեղծելիս։

OpenTelemetry controller-ը տեղակայում է workload (այստեղ՝ deployment) և մի քանի ծառայություն՝ տվյալներ հավաքելու և collector-ին մոնիթորինգի ենթարկելու համար։

kubectl -n otel-system get services
NAME                             TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)             AGE
gcp-collector                    ClusterIP   10.200.179.87    <none>        4317/TCP,4318/TCP   3d23h
gcp-collector-headless           ClusterIP   None             <none>        4317/TCP,4318/TCP   3d23h
gcp-collector-monitoring         ClusterIP   10.200.47.54     <none>        8888/TCP            3d23h

Հիանալի է, collector-ը բարձրացել և աշխատում է. ժամանակն է նրան տվյալներ ուղարկել։

Instrumentation-ի ստեղծումը

Հաջորդը մենք ստեղծում ենք instrumentation անունով OpenTelemetry օբյեկտ։ Այն նկարագրում է, թե ինչպես պետք է հավելվածում միացվի autoinstrumentation-ը։

JVM հավելվածների համար մենք օգտագործում ենք Java Autoinstrumentation, որն աշխատում է որպես Java agent։

Ահա մեր instrumentation-ը՝

apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata:
  name: java-instrumentation
  namespace: default
spec:
  exporter:
    endpoint: http://gcp-collector.otel-system:4317
  java:
    env:
      - name: OTEL_METRICS_EXPORTER
        value: otlp
      - name: OTEL_TRACES_EXPORTER
        value: none
      - name: OTEL_LOGS_EXPORTER
        value: none

Քանի որ մենք հավաքում ենք միայն մետրիկաներ, մի քանի միջավայրի փոփոխական ենք դրել, որոնք անջատում են trace-երն ու լոգերը։

Մենք նաև այն ուղղում ենք նախորդ քայլում ստեղծված collector-ի հասցեին։

Այս պահին մենք ունենք collector և auto instrumentation-ի կոնֆիգուրացիա, բայց տվյալներ դեռ չկան։ Միացնենք instrumentation-ը որոշ ծառայությունների համար։

Auto instrumentation-ի միացումը

Auto instrumentation-ը միացնելու համար պարզապես պետք է pod-ին annotation ավելացնել։

Զգույշ եղեք. այստեղ հեշտ է սխալվել և annotation-ը ավելացնել deployment-ին։ Մեզ անհրաժեշտ է annotation դնել pod-ին, ուստի փոփոխում ենք pod template-ը՝

spec:
  replicas: 2
  template:
    metadata:
      annotations:
        instrumentation.opentelemetry.io/inject-java: “true”

instrumentation.opentelemetry.io/inject-java annotation-ը ընդունում է հետևյալ արժեքները՝

  1. “true” – ներարկում է instrumentation-ը լռելյայն անունով՝ ընթացիկ namespace-ից (օրինակ, երբ կա ընդամենը մեկ instrumentation)
  2. “instrumentation-name” – instrumentation-ի անունը, երբ namespace-ում կան մի քանի instrumentation
  3. “namespace-name/instrumentation-name” – մեկ այլ namespace-ում գտնվող instrumentation-ի անունը
  4. “false” – այս workload-ը հանում է instrumentation-ից։

Կարող եք նաև annotation դնել namespace-ին, որի դեպքում instrumentation-ը կներարկվի դրա յուրաքանչյուր pod-ի մեջ։

Ինչպե՞ս է ներարկվում instrumentation-ը։ Ստեղծվում է init կոնտեյներ, որը ներբեռնում է java agent-ը, ներարկվում են մի քանի միջավայրի փոփոխականներ, և mount է արվում agent-ը պարունակող volume։ JAVA_TOOL_OPTIONS env փոփոխականը նույնպես ներարկվում կամ փոփոխվում է՝ ներառելու համար -javaagent:/otel-auto-instrumentation/javaagent.jar, ինչը փաստացի Java agent-ը կցում է JVM-ին։

Կարևոր է. սա վերաբերում է միայն նոր ստեղծված pod-երին։ Եթե սկզբում փոփոխենք deployment-ը, իսկ instrumentation-ը ստեղծենք հետո, չի աշխատի, և pod-երը ստիպված կլինենք վերագործարկել ձեռքով։

Մետրիկաների ստուգումը GCP-ում

Հիմա փնտրենք մեր մետրիկաները GCP-ում։

gcp resourcedetector-ի շնորհիվ monitoring համակարգը «գիտի», որ մեր JVM մետրիկաները գալիս են Kubernetes pod-երից, ուստի Metrics explorer-ում դրանք կգտնենք Kubernetes container-ի ներքո։

Մետրիկաները կրում են օգտակար պիտակներ, ինչպիսիք են ծառայության անունը, pod-ի անունը, namespace-ը, ինչպես նաև pod-ի յուրաքանչյուր Kubernetes պիտակ, ինչը metric explorer-ում տվյալների ֆիլտրումը դարձնում է բավական պարզ։

Խնդիրների լուծում

Եթե ինչ-որ բան չի աշխատում ակնկալվածի պես, սկսեք GCP Monitoring ծառայության Metric management-ը դիտելուց։ Այնտեղ կարող եք տեսնել սխալների մակարդակը և դիտել լոգերը (audit logs-ը պետք է միացված լինեն)։

Collector-ի և operator controller-ի լոգերը դիտելը նույնպես կարող է օգնել։

Ամփոփում

OpenTelemetry auto instrumentation-ը թույլ է տալիս հավաքել բազմաթիվ օգտակար մետրիկաներ՝ առանց հավելվածին ավելացնելու կոդի մեկ տող։

Auto instrumentation-ը միայն մեկնարկային կետ է. հավելվածը սեփական և/կամ բիզնես մետրիկաներով instrument անելը հավանաբար նույնպես արժե անել։

Այս հոդվածը ընդամենը GCP-ի վրա կենտրոնացած ձեռնարկ է. խորհուրդ եմ տալիս ծանոթանալ OpenTelemetry-ի փաստաթղթերին։