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

Ինչ է աննկատ սխալ անում Kafka lag մոնիթորինգը

Գիշերվա ժամը 3-ին ձեր ահազանգը միանում է. «Consumer group orders-processor-ը 50,000 հաղորդագրությամբ հետ է մնում»։ Նյարդայնացած՝ վազում եք նոութբուքի մոտ։ Դա 10 վայրկյան է, 10 րոպե, թե 10 ժամ ուշացում։ Ահազանգը չի ասի։ Dashboard-ը դեռ ցույց է տալիս 50,000 հաղորդագրություն։ Ուրեմն ի՞նչ է այդ թիվը իրականում նշանակում ձեր օգտատերերի համար։

9 րոպե
KafkaLag MonitoringOffset LagTime Lag

Գիշերվա ժամը 3-ին ձեր ահազանգը միանում է. «Consumer group orders-processor-ը 50,000 հաղորդագրությամբ հետ է մնում»։ Նյարդայնացած՝ վազում եք նոութբուքի մոտ։ Դա 10 վայրկյան է, 10 րոպե, թե 10 ժամ ուշացում։ Ահազանգը չի ասի։ Բացում եք dashboard-ը – այն դեռ ցույց է տալիս 50,000 հաղորդագրություն։

Ուրեմն ի՞նչ է այդ թիվը իրականում նշանակում ձեր օգտատերերի համար։

Այն մետրիկան, որին բոլորը հետևում են՝ offset lag-ը, համարյա ոչինչ չի ասում այն մասին, թե consumer-ն իրականում որքան առողջ է։ Թոփիքի թողունակությունից կախված՝ 1,000 հաղորդագրության lag-ը կարող է նշանակել 1 վայրկյան ուշացում կամ 1 օր։ Եվ այդուհանդերձ հենց այդ թիվն է, որ ցուցադրվում է ամենուր dashboard-ներում։

Իրականում կարևորը time lag-ն է՝ քանի վայրկյանով է ձեր consumer-ը իրականում հետ մնացել։ Մոնիթորինգի գործիքների մեծ մասը, սակայն, այն կամ անճշտորեն է ցուցադրում, կամ ընդհանրապես չի ցուցադրում։

Ստորև բացատրում եմ՝ ինչու, և ինչ կարելի է անել։

Offset lag-ի միրաժը

Նախ՝ հիմունքները։ Offset lag-ը հաշվարկվում է այսպես.

offset_lag = latest_offset - committed_offset

Այստեղ.

  • latest_offset-ը այն դիրքն է, որտեղ կգրվի հաջորդ հաղորդագրությունը (high watermark)
  • committed_offset-ը ցույց է տալիս, թե ձեր consumer-ը մինչև ուր է մշակել

Հեշտ է, չէ՞։ Վերցնում ես երկու թիվ, մեկը հանում ես մյուսից, և վերջ։

Հենց այդ պարզության պատճառով է, որ մոնիթորինգի յուրաքանչյուր գործիք այն ցուցադրում է։ Kafka Admin API-ը երկու թվերն էլ տալիս է անմիջապես. ոչինչ բերելու կարիք չկա, timestamp-եր վերլուծելու կարիք չկա, միայն մետատվյալներ։

Եվ հենց այստեղ է, որ ամեն ինչ փլուզվում է։

Offset lag-ը ոչ մի կապ չունի ժամանակի հետ։ Նայեք այս երկու սցենարներին.

Նույն տեսակի մետրիկա, բայց խիստ տարբեր լրջություն։ Գիշերվա ժամը 3-ի այդ ահազանգը 50,000 հաղորդագրության մասին։ Բարձր թողունակությամբ թոփիքի վրա ձեր հերթապահ ինժեները կարող է անհիմն կորցնել քունը։ Հանգիստ թոփիքի վրա նույնիսկ 50 հաղորդագրությունը կարող է նշանակել, որ consumer-ը օրերով կանգնած է։

Պարապուրդի մեջ գտնվող producer-ի թակարդը

Ավելի վատ է դառնում։ Ի՞նչ է լինում, երբ producer-ը դադարում է հաղորդագրություններ ուղարկել։

Offset lag-ը մնում է հաստատուն։ Committed offset-ը չի փոխվում, քանի որ սպառելու նոր բան չկա։ Latest offset-ն էլ չի փոխվում, քանի որ ոչինչ չի արտադրվում։ Տարբերությո՞ւնը։ Այն ընդհանրապես չի փոխվում։

Մինչդեռ իրական ուշացումը շարունակում է աճել։ Եթե վերջին հաղորդագրությունը արտադրվել է մեկ ժամ առաջ, և ձեր consumer-ը դեռ կանգնած է այդ offset-ի վրա, դուք իրական ժամանակում մեկ ժամ հետ եք՝ չնայած offset lag-ը պնդում է, որ ամեն ինչ լավ է։

Ես տեսել եմ, թե ինչպես են թիմերը հենց այս իրավիճակում ծուղակն ընկնում։ Օրը մեկ անգամ batch աշխատանքներ մշակող ցածր թողունակությամբ թոփիքը մի ամբողջ շաբաթ հաղորդում էր «կայուն lag»։ Պարզվեց, որ consumer-ը կոտրվել էր, բայց քանի որ producer-ը հաղորդագրություններ էր ուղարկում միայն օրը մեկ անգամ, lag թիվը համարյա չէր փոխվել։ Օգտատերերը խնդիրը նկատեցին, երբ իրենց օրական հաշվետվությունները դադարեցին երևալ։

Ինչու է time lag-ը ճիշտ ստանալը դժվար

Եթե time lag-ը այդքան կարևոր է, ինչու՞ բոլոր գործիքները այն չեն ցուցադրում։

Որովհետև այն ճիշտ հաշվարկելը թանկ է և նուրբ։

Time lag-ը սահմանվում է այսպես.

time_lag = current_time - timestamp_of_message_at_committed_offset

Այդ timestamp-ը ստանալու համար պետք է իրականում կարդալ committed offset-ի վրա գտնվող հաղորդագրությունը։ Այլ կերպ ասած.

  1. Կարգավորել consumer
  2. Seek անել committed offset-ին
  3. Բերել հաղորդագրությունը
  4. Վերլուծել դրա timestamp-ը
  5. Կրկնել սա lag ունեցող յուրաքանչյուր պարտիցիայի համար

Հազարավոր պարտիցիաների վրա տարածված հարյուրավոր consumer group-ներով կլաստերում դա արագ վերածվում է մեծ աշխատանքի։ Գործիքների մեծ մասը այն բաց է թողնում։

Ինտերպոլյացիայի դյուրանցումը (և որտեղ է այն կոտրվում)

Որոշ գործիքներ փորձում են ավելի խելացի ճանապարհ։ Լայնորեն օգտագործվող kafka-lag-exporter-ը (գրված է Scala-ով) աստիճանաբար կառուցում է (offset, timestamp) զույգերի որոնման աղյուսակ։ Տվյալ offset-ի timestamp-ը գնահատելու համար այն ինտերպոլյացիա է անում արդեն հայտնի կետերի միջև։

Դա խելամիտ է հնչում։ Ահա թե ինչու է այն ձախողվում.

  1. Սառը մեկնարկի խնդիր. Որոնման աղյուսակը սկսվում է դատարկ։ Մինչև բավարար տվյալների կետեր հավաքվեն, մետրիկան իմաստալից արժեք չունի։
  2. Պարապուրդի մեջ գտնվող producer-ի եզրային դեպք. Երբ արտադրությունը դադարում է, որոնման աղյուսակը կրկնվող offset-ները փլուզում է հարթ հատվածի։ Հարթ հատվածի ներսում ինտերպոլյացիան հանգեցնում է զրոյի վրա բաժանման (dy = 0 կանխատեսման բանաձևում), ուստի time lag-ը ստացվում է NaN։
  3. Փոփոխական թողունակություն. Գծային ինտերպոլյացիան ենթադրում է, որ տվյալների կետերի միջև հաղորդագրությունների արագությունը հաստատուն է։ Մեկ poll միջակայքի ընթացքում (լռելյայն 30s) տեղի ունեցող պոռթկումները տալիս են անճշգրիտ ժամանակային գնահատականներ, քանի որ իրական, ոչ գծային արտադրության օրինաչափությունը չի արտացոլվում։

Երբ ինտերպոլյացիան ձախողվում է (սառը մեկնարկ, չափազանց քիչ տվյալներ), համակարգը time lag-ը հաղորդում է որպես NaN։ Dashboard-ները դա ցույց են տալիս որպես բացեր տվյալներում, ոչ թե որպես զրո։ Offset lag մետրիկան (որը կախված չէ ինտերպոլյացիայից) մնում է ճշգրիտ նույնիսկ երբ time lag-ը հնարավոր չէ հաշվարկել։

Ճիշտ անելը. timestamp-երի ուղղակի նմուշառում

Ճշգրտությունը դյուրանցում չունի։ Իրական time lag ստանալու համար պետք է կարդալ հաղորդագրությունների իրական timestamp-երը։

Ահա թե ինչպես է դա անում klag-exporter-ը.

Յուրաքանչյուր պարտիցիայի համար, որտեղ lag > 0.

  1. Կարգավորել consumer և seek անել committed offset-ին
  2. Բերել մեկ հաղորդագրություն
  3. Կարդալ դրա timestamp-ը
  4. Հաշվարկել՝ time_lag = now - message_timestamp
  5. Քեշավորել արդյունքը, որպեսզի Kafka-ն չծանրաբեռնվի

Առանցքային դիտարկումն այն է, որ timestamp-եր անհրաժեշտ են միայն իրականում հետ մնացող պարտիցիաների համար։ Հասնող (lag = 0) consumer-ը timestamp չի պահանջում. մենք արդեն գիտենք, որ այն արդի է։

Հետ մնացող պարտիցիաների համար բերված timestamp-ը քեշավորվում է TTL-ով։ Քանի դեռ consumer-ը չի շարժվել (committed offset-ը անփոփոխ է), քեշավորված timestamp-ը մնում է վավեր։ Նորը բերվում է միայն այն բանից հետո, երբ consumer-ը commit է անում նոր offset։

Այս մոտեցմամբ դուք ստանում եք.

  • Ճշգրիտ time lag՝ անկախ թոփիքի թողունակությունից
  • Պարապուրդի մեջ գտնվող producer-ների ճիշտ մշակում (time lag-ը շարունակում է աճել, ինչպես պետք է)
  • Kafka-ի սահմանափակ ծանրաբեռնվածություն՝ քեշավորման շնորհիվ

Իսկ եզրային դեպքե՞րը

Երկու իրավիճակ կարող են խեղաթյուրել timestamp-ի ճշգրտությունը.

Log compaction. Երբ թոփիքը օգտագործում է cleanup.policy=compact, ձեր committed offset-ի հաղորդագրությունը կարող է հեռացվել compaction-ով։ Այդ դեպքում Kafka-ն վերադարձնում է հաջորդ հասանելի հաղորդագրությունը, որն ունի ավելի ուշ timestamp, ուստի հաղորդված lag-ը ստացվում է իրականից մի փոքր ցածր։

Retention deletion. Երբ ձեր committed offset-ը մատնանշում է մի հաղորդագրություն, որն արդեն ջնջվել է retention քաղաքականության կողմից, հանդիպում եք նույն խնդրին. Kafka-ն վերադարձնում է ավելի նոր հաղորդագրություն։

Երկու դեպքում էլ lag-ը թերագնահատվում է (ցուցադրված ուշացումը իրականից փոքր է)։ Լավ իրականացումը ճանաչում է այս պայմանները և նշում դրանք, որպեսզի իմանաք, որ թիվը կարող է անճշգրիտ լինել։

TL;DR. Time lag-ը կարելի է ստանալ միայն իրական հաղորդագրություններ կարդալով։ Ինտերպոլյացիան գրավիչ է թվում, բայց փլուզվում է պարապուրդի/ցածր թողունակությամբ թոփիքների վրա։ Ուղղակի նմուշառումը՝ քեշավորման հետ զուգակցված, տալիս է ճշգրիտ թվեր՝ առանց ձեր broker-ները ծանրաբեռնելու։

Մետրիկաները, որ ձեզ իրականում պետք են

Ահա թե ինչ պետք է ընդգրկի ձեր Kafka մոնիթորինգը.

Յուրաքանչյուր պարտիցիայի համար – կոնկրետ խնդիրները հետևելու համար

kafka_consumergroup_group_lag{group="orders", topic="orders", partition="0"} 1523

kafka_consumergroup_group_lag_seconds{group="orders", topic="orders", partition="0"} 12.5

Յուրաքանչյուր group-ի համար – ահազանգերի համար

kafka_consumergroup_group_max_lag{group="orders"} 2847

kafka_consumergroup_group_max_lag_seconds{group="orders"} 45.2

Offset lag-ը (group_lag) դեռ արժե ունենալ – այն ցույց է տալիս, թե քանի հաղորդագրություն է սպասում մշակման։ Բայց այն պետք է համադրել time lag-ի (group_lag_seconds) հետ՝ իրավիճակի լրջությունը գնահատելու համար։

Ահազանգերի համար հենվեք բոլոր պարտիցիաների max_lag_seconds-ի վրա, որը տալիս է group-ի ամենավատ դեպքի ուշացումը.

Ահազանգ միացնել, երբ որևէ պարտիցիա 60 վայրկյանից ավելի է հետ մնում

kafka_consumergroup_group_max_lag_seconds{group="orders-processor"} > 60

Այս ահազանգը գործարկվում է իրական ուշացումից, այլ ոչ թե կամայական հաղորդագրությունների քանակից։ «Պատվերները մշակել 30 վայրկյանի ընթացքում» նման SLA-ն վերջապես կարելի է մոնիթորինգի ենթարկել ճիշտ ձևով։

Ծանոթացեք klag-exporter-ին

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

Ինչով է այն տարբերվում առկա գործիքներից.

Exporter-ը ճանաչում է նաև compaction-ի և retention-ի եզրային դեպքերը և նշում է տուժած պարտիցիաները, որպեսզի իմանաք, թե երբ time lag-ին պետք է վերաբերվել զգուշությամբ։

Արագ մեկնարկ Docker-ով

Կսկսենք հնարավոր ամենապարզ կարգավորումից և այն քայլ առ քայլ կընդլայնենք։

Նվազագույն կարգավորում

  1. Գրել հիմնական կոնֆիգուրացիա

  2. Գործարկել exporter-ը

your-kafka-network-ը փոխեք այն Docker ցանցով, որի վրա աշխատում է ձեր Kafka-ն, իսկ bootstrap_servers-ը սահմանեք ձեր broker(ներ)ի վրա։

  1. Ստուգել, որ աշխատում է

Դուք պետք է ստանաք այսպիսի մետրիկաներ.

kafka_consumergroup_group_lag{cluster_name="my-cluster",group="my-group",topic="my-topic",partition="0"} 1523

kafka_consumergroup_group_lag_seconds{cluster_name="my-cluster",consumer_group="my-group",topic="my-topic",partition="0"} 12.5

Լրիվ դեմո stack

Կցանկանայի՞ք տեսնել ամբողջը միասին աշխատելիս՝ Kafka, producer-ներ, consumer-ներ, Prometheus և Grafana՝ պատրաստի dashboard-ներով։ Repo-ն գալիս է դեմոյով, որը կարող եք անմիջապես գործարկել.

Դեմոն ներառում է producer-ներ և consumer-ներ, որոնք ստեղծում են իրատեսական lag օրինաչափություններ, այնպես որ կարող եք անմիջապես տեսնել time lag և offset lag մետրիկաների աշխատանքը։

Կոնֆիգուրացիայի ավելի մանրամասն դիտարկում

  1. Exporter-ի կարգավորումներ

Granularity փոխզիջումներ.

Շատ կարգավորումներում սկսեք partition-ից։ Անհրաժեշտության դեպքում միշտ կարող եք համախմբել Prometheus-ում։

  1. Կլաստերի կոնֆիգուրացիա

Whitelist/blacklist օրինաչափությունները կանոնավոր արտահայտություններ են և կիրառվում են հաջորդաբար. նախ whitelist-ը, որից հետո blacklist-ը հեռացնում է այն ամենը, ինչ համընկնում է։

Նույնականացման մեթոդներ

consumer_properties-ի միջոցով klag-exporter-ը աջակցում է Kafka-ի յուրաքանչյուր ստանդարտ նույնականացման մեխանիզմ։

SASL/PLAIN (օգտանուն/գաղտնաբառ).

SASL/SCRAM (TLS-ով).

mTLS (փոխադարձ TLS, առանց օգտանվան).

AWS MSK IAM-ով.

Միջավայրի փոփոխականների փոխարինում

Կոնֆիգուրացիայի յուրաքանչյուր արժեք ընդունում է ${VAR_NAME} շարահյուսությունը – այդպես գաղտնիքները երբեք կոշտ կոդավորված չեն լինի կոնֆիգուրացիայի ֆայլում.

Տեղակայում Kubernetes-ում

Արտադրական միջավայրում klag-exporter-ը սովորաբար կաշխատի Kubernetes-ում։ Մեր GitHub repo-ն պարունակում է պատրաստի helm chart-եր, որոնք հեշտացնում են klag-exporter-ի տեղակայումը ձեր կլաստերում։

Grafana dashboard

Dashboard-ի ներմուծում

Տարբերակ A. Պատճենել JSON ֆայլը

Repository-ից

Տարբերակ B. Ներմուծել Grafana UI-ի միջոցով

  1. Բացել Dashboards → Import
  2. Վերբեռնել kafka-lag.json-ը կամ տեղադրել դրա պարունակությունը
  3. Ընտրել ձեր Prometheus datasource-ը
  4. Սեղմել Import

Հիմնական վահանակները

Ներառված dashboard-ը բաժանված է մի քանի բաժնի.

Overview վիճակագրություն.

  • Total Consumer Lag (գումարված բոլոր group-երի վրա)
  • Max Time Lag (ամենավատ դեպքի ուշացում)
  • Exporter Status (UP/DOWN)
  • Scrape Duration (որքան արագ է աշխատում հավաքագրումը)
  • Consumer Groups (մոնիթորինգի ենթակա group-երի քանակ)

Ժամանակային շարքեր.

  • Consumer Group Total Lag – ինչպես է այն փոխվում ժամանակի ընթացքում
  • Time Lag in Seconds – այն մետրիկան, որ կարևոր է
  • Per-Partition Lag – կոնկրետ խնդիրները հետևելու համար

Throughput և բաշխում.

  • Partition Latest Offsets – ինչպես են դրանք բաշխված պարտիցիաների միջև
  • Topic Message Rate – արտադրության թողունակությունը ժամանակի ընթացքում

Dashboard-ի փոփոխականներ

Dashboard-ը գալիս է ֆիլտրման փոփոխականներով.

Օգտագործեք դրանք՝ խնդիրներ հետաքննելիս պատկերը նեղացնելու համար։

Մի քանի կլաստերի մոնիթորինգ

klag-exporter-ի մեկ instance-ը կարող է հսկել մի քանի Kafka կլաստեր։ Պարզապես ավելացրեք լրացուցիչ [[clusters]] բլոկներ.

Մետրիկաներում յուրաքանչյուր կլաստեր կրում է իր սեփական cluster_name պիտակը, ինչը թույլ է տալիս ֆիլտրել ըստ կլաստերի Grafana-ում և ահազանգերում։

Մեկ exporter թե մի քանիսը – երբ ինչն ընտրել.

OpenTelemetry ինտեգրացիա

Prometheus endpoint-ից բացի (կամ դրա փոխարեն) klag-exporter-ը կարող է նաև մետրիկաներ ուղարկել OTEL-ով։

Սա օգտակար է, եթե օգտագործում եք Datadog, New Relic, Honeycomb կամ OTEL ներմուծում ընդունող այլ backend։

Թեստային stack-ը պարունակում է OpenTelemetry Collector, որը ստանում է այս մետրիկաները և արտահանում դրանք և՛ debug ելքին (լոգեր), և՛ Prometheus endpoint։

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

Exporter-ը մետրիկաներ չի ցուցադրում

  1. Ստուգեք, որ Kafka-ն հասանելի է.

  2. Նայեք exporter-ի լոգերին.

  3. Հաստատեք նույնականացումը.

Լոգերում փնտրեք SASL կամ SSL սխալներ։ Նորից ստուգեք ձեր հավատարմագրերը և վկայագրերը։

Մետրիկաներ կան, բայց consumer group-եր չկան

  1. Վերանայեք ձեր whitelist/blacklist օրինաչափությունները. չափազանց խիստ օրինաչափությունները կարող են group-երը զտել։
  2. Համոզվեք, որ consumer group-երը գոյություն ունեն. kafka-consumer-groups –bootstrap-server kafka:9092 –list
  3. Պարզեք՝ արդյոք consumer-ները commit են արել offset-եր. klag-exporter-ը թվարկում է միայն committed offset-ներ ունեցող group-երը։

Time lag-ը մնացել է 0-ի վրա

  1. Համոզվեք, որ timestamp նմուշառումը միացված է.

  2. Պարզեք՝ արդյոք consumer-ները իրականում հետ են մնում. երբ group_lag-ը 0 է, group_lag_seconds-ը նույնպես 0 է (հասել է = time lag չկա)։

Grafana-ն ցուցադրում է «No data»

  1. Նայեք Prometheus targets-ը. http://localhost:9090/targets – klag-exporter-ը UP է՞։
  2. Փորձարկեք datasource-ը. Grafana → Configuration → Data Sources → Test
  3. Ստուգեք մետրիկաների անունները. dashboard-ը հենվում է որոշակի մետրիկաների անունների վրա։ Եթե դրանք փոխել եք, հարմարեցրեք հարցումները։

Որտեղ պետք է լինեք հիմա

Եթե անցել եք այս ուղեցույցը, այժմ ունեք.

  • klag-exporter, որը հավաքում է և՛ offset lag, և՛ time lag մետրիկաներ
  • Prometheus, որը scrape է անում և պահում այս մետրիկաները
  • Grafana dashboard-ներ, որոնք վիզուալիզացնում են lag-ի միտումներն ու բաշխումները
  • Ձեր SLA-ների համար կարգավորված ահազանգեր
  • Եզրային դեպքերի իմացություն (compaction/retention հայտնաբերում)

«Consumer X-ը 50,000 հաղորդագրության lag ունի» փոխարեն ձեր հերթապահ ինժեներները այժմ կարող են արձագանքել «Consumer X-ը 45 վայրկյանով հետ է» – ահազանգի, որի վրա գործել շատ ավելի հեշտ է։

Հիմնական եզրակացությունները

  1. Offset lag-ը ցույց է տալիս, թե քանի հաղորդագրությամբ եք հետ, time lag-ը՝ իրական ժամանակում որքան հետ եք։ Երկուսն էլ կարևոր են, բայց ձեր SLA-ները արտահայտվում են time lag-ով։
  2. Ինտերպոլյացիայի վրա հիմնված գործիքները փլուզվում են պարապուրդի կամ ցածր թողունակությամբ թոփիքների վրա։ Դրանք զրո lag են հաղորդում, մինչդեռ դուք կարող եք ժամերով հետ լինել։
  3. Timestamp-երի ուղղակի նմուշառումն ավելի ճշգրիտ է, բայց պահանջում է քեշավորում։ Բերեք միայն հետ մնացող պարտիցիաների համար և քեշավորեք արդյունքները TTL-ով։
  4. Ահազանգերը հիմնեք time lag-ի, ոչ թե offset lag-ի վրա։ Ձեր հերթապահ ինժեներները երախտապարտ կլինեն լրջությունը մի հայացքով հասկանալու համար։

Եթե այսօր մոնիթորինգի եք ենթարկում միայն offset lag-ը, դուք մասամբ կույր եք թռչում։ Time lag-ը ձեր dashboard-ներում դնելը ամենաարժեքավոր բարելավումն է, որ կարող եք անել ձեր Kafka մոնիթորինգին։

Հաղորդագրությունները կմնան իրենց տեղում։ Ձեր օգտատերերը, սակայն, սպասում են – և զգում են ուշացումը։