JVM-ի ներքին մետրիկաների ուղարկումը GCP Monitoring OpenTelemetry-ով (առանց կոդի)
Քայլ առ քայլ ուղեցույց՝ Java հավելվածի ներքին մետրիկաները GCP Monitoring ծառայություն ուղարկելու համար OpenTelemetry-ով (GKE-ում աշխատող OpenTelemetry operator-ով)։
Այս ձեռնարկում ցույց կտամ, թե ինչպես 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-ը կազմված է՝
- OpenTelemetry controller-ից
- OpenTelemetry collector-ի CRD-ից
- 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-ը ընդունում է հետևյալ արժեքները՝
- “true” – ներարկում է instrumentation-ը լռելյայն անունով՝ ընթացիկ namespace-ից (օրինակ, երբ կա ընդամենը մեկ instrumentation)
- “instrumentation-name” – instrumentation-ի անունը, երբ namespace-ում կան մի քանի instrumentation
- “namespace-name/instrumentation-name” – մեկ այլ namespace-ում գտնվող instrumentation-ի անունը
- “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-ի փաստաթղթերին։