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

Compaction և Retention. սահմանային դեպքեր, որոնք աղավաղում են ձեր Kafka lag մետրիկաները

Կարո՞ղ եք վստահել ձեր Kafka lag dashboard-ին։ Իմացեք, թե ինչպես log compaction-ը և retention-ը կարող են թաքցնել consumer-ների հսկայական ուշացումները և ինչպես նկատել time lag-ի մոլորեցնող մետրիկաները։ Թիմերը հաճախ հենվում են Kafka lag մետրիկաների վրա՝ համակարգի առողջությունը հետևելու համար, սակայն log compaction-ը և retention քաղաքականությունները կարող են լուռ հեռացնել հաղորդագրությունները նախքան որևէ մեկի դրանք մշակելը։ Այս հոդվածը բացատրում է, թե ինչու է time lag-ի սովորական բանաձևը՝ $current\_time - timestamp\_of\_message\_at\_committed\_offset$, թերագնահատում իրական հապաղումը, երբ պահանջվող offset-ն այլևս չկա։ Մենք նկարագրում ենք, թե ինչպես «klag-exporter»-ը նկատում է այս անճշտությունները՝ համեմատելով պահանջված և փաստացի offset-ները, ինչպես նաև low watermark-երը։ Վերջում առաջարկում ենք գործնական մեղմացման ռազմավարություններ, ինչպիսիք են min.compaction.lag.ms-ի կարգավորումը, consumer-ի ռեսուրսների օպտիմալացումը և dashboard-ներում նախազգուշացնող ցուցիչների ավելացումը՝ Kafka-ի ավելի դիմացկուն մոնիթորինգի համար։

6 րոպե
Apache KafkaObservabilityLag մոնիթորինգTime Lag

Ձեր dashboard-ի համաձայն՝ inventory-updates consumer-ը 5 վայրկյանով հետ է մնացել։ Թվում է՝ ամեն ինչ լավ է։ Բայց օգտատերերը շարունակում են հայտնել հնացած տվյալների մասին. նրանց տեսած գույքագրման քանակները 10 րոպե հին են։

Դուք նորից անցնում եք մետրիկաների միջով։ Դեռ 5 վայրկյան։ Թվերով՝ գրեթե հասել եք։

Թվերը ճշմարտությունը չեն ասում։

Time lag-ը ավելի կարևոր է, քան offset lag-ը, բայց կա վերապահում. նույնիսկ ճիշտ հաշվարկված time lag-ը կարող է խաբել ձեզ։ Kafka-ի երկու հնարավորություն՝ log compaction-ը և retention-ը, կարող են ջնջել հենց այն հաղորդագրությունները, որոնց վրա հենվում են ձեր մետրիկաները, ինչը հաղորդվող lag-ը դարձնում է իրականից շատ ավելի ցածր։

Ծանոթացեք մեր նոր գործիքին՝ Rust-ով գրված բարձր արտադրողականության Apache Kafka consumer group lag exporter-ին։ Այն հաշվարկում է և՛ offset lag-ը, և՛ time lag-ը (հապաղումը վայրկյաններով)՝ օգտագործելով timestamp-ների վրա հիմնված ճշգրիտ չափումներ։

Եկեք միասին անցնենք, թե ինչպես է դա տեղի ունենում և ինչ կարելի է անել դրա դեմ։

Արագ հիշեցում. ինչպես է աշխատում Time Lag-ը

Թղթի վրա time lag-ի հաշվարկը պարզ է.

time_lag = current_time - timestamp_of_message_at_committed_offset

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

Բայց ի՞նչ է լինում, երբ այդ հաղորդագրությունն այլևս չկա։

Kafka-ն սխալ չի բարձրացնում։ Փոխարենը այն լուռ վերադարձնում է հաջորդ հասանելի հաղորդագրությունը։ Այդ հաղորդագրությունը ունի ավելի ուշ timestamp, ուստի մեր հաշվարկած lag-ը թվում է իրականից փոքր։

Պատկերացրեք՝ դուք գնահատում եք, թե վազորդը որքան հետ է մնացել՝ նայելով նրա անցած վերջին հսկիչ կետի նշանին։ Եթե որևէ մեկը ջնջել է 1-ից 10 նշանները, և առաջինը, որ տեսնում եք, 11-ն է, դուք վազորդին կգրանցեք 11-րդ հսկիչ կետում՝ թեև նա իրականում դեռ 1-ինում է։

Հենց դա են անում compaction-ը և retention-ը։

Log Compaction-ի խնդիրը

Log compaction-ը Kafka-ի հնարավորություն է, որն օգտագործվում է cleanup.policy=compact կարգավորված topic-ներում։ Յուրաքանչյուր հաղորդագրություն պահելու փոխարեն Kafka-ն պահում է միայն յուրաքանչյուր key-ի ամենավերջին հաղորդագրությունը և հեռացնում է հին տարբերակները։

Այն իդեալական է այնպիսի դեպքերի համար, ինչպիսիք են.

  • Change Data Capture (CDC) հոսքերը
  • KTable-ներին սպասարկող topic-ները
  • Կոնֆիգուրացիայի կամ վիճակի պահոցները

Ահա թե ինչպես է compaction-ը փոխում ձեր partition-ը.

Compaction-ից առաջ.

  offset 100: key=user-1, value={"status":"active"},   ts=10:00:00

  offset 101: key=user-2, value={"status":"pending"},  ts=10:00:15

  offset 102: key=user-1, value={"status":"inactive"}, ts=10:00:30  ← newer user-1

  offset 103: key=user-3, value={"status":"active"},   ts=10:00:45

Compaction-ից հետո.

  offset 101: key=user-2, value={"status":"pending"},  ts=10:00:15

  offset 102: key=user-1, value={"status":"inactive"}, ts=10:00:30

  offset 103: key=user-3, value={"status":"active"},   ts=10:00:45

  (offset 100 is gone - compacted away)

Lag-ի խնդիրը

Ենթադրենք՝ ձեր consumer-ը committed է արել offset 100-ը նախքան compaction-ի սկսվելը։ Դուք ուզում եք հաշվել time lag-ը.

  1. Seek անում եք offset 100-ին
  2. Kafka-ն չի կարող գտնել offset 100-ը (compaction-ը հեռացրել է այն)
  3. Kafka-ն դրա փոխարեն վերադարձնում է offset 101-ը
  4. Դուք կարդում եք timestamp 10:00:15-ը
  5. Ընթացիկ ժամանակը 10:01:00 լինելով՝ դուք հաղորդում եք 45 վայրկյան lag

Սակայն իրականում consumer-ը գտնվում է offset 100-ում, որը արտադրվել է 10:00:00-ին։ Իրական lag-ը 60 վայրկյան է. 25%-ով ավելի, քան հաղորդվածը։

Այս պարզ օրինակում սխալը աննշան է։ Production-ում այն կարող է հսկայական լինել։

Իրական ազդեցությունը

Compacted topic-ների consumer-ները հաճախ դանդաղ են։ Դասագրքային օրինակ. KTable-ի վերակառուցումը զրոյից։ Ձեր consumer-ը կարող է գտնվել offset 0-ում՝ դանդաղ անցնելով միլիոնավոր հաղորդագրությունների միջով, մինչդեռ compaction-ը շարունակում է հեռացնել հին տվյալները վերջին offset-ի հետևում։

Հնարավոր սցենար.

  • Հաղորդվող time lag. 30 վայրկյան
  • Փաստացի time lag. 30 րոպե

Consumer-ը վերակառուցում էր իր վիճակը սկզբից՝ խիստ compacted topic-ի վրա։ Հազարավոր վաղ հաղորդագրություններ արդեն compacted էին արվել, ուստի timestamp-ի յուրաքանչյուր որոնում վերադարձնում էր հաղորդագրություն, որը շատ ավելի նոր էր, քան consumer-ի իրական դիրքը։

Retention-ով ջնջումը. երբ ձեր offset-ները ընկնում են ժայռից

Մինչդեռ compaction-ը հեռացնում է կոնկրետ հաղորդագրություններ (նույն key-ի հին արժեքները), retention-ը ջնջում է հաղորդագրություններ լոգի սկզբից՝ ըստ ժամանակի կամ չափի սահմանաչափերի։

Լռելյայն քաղաքականությունը (cleanup.policy=delete) ջնջում է հաղորդագրությունները, երբ retention.ms-ն անցել է կամ երբ retention.bytes-ը գերազանցվել է։ Ամենահին հաղորդագրությունները միշտ ջնջվում են առաջինը։

Օր 1 (7-օրյա retention-ով).

  low_watermark = 0

  offset 0: ts=Day1 09:00

  offset 1: ts=Day1 09:01

  offset 2: ts=Day2 10:00

  ...

  high_watermark = 1000

Օր 8.

  low_watermark = 500  ← moved forward!

  offset 500: ts=Day2 12:00  ← now the earliest message

  ...

  high_watermark = 5000

  (offsets 0-499 deleted by retention)

Lag-ի խնդիրը

Ենթադրենք՝ ձեր consumer-ը committed է արել offset 50-ը նախքան այդ հաղորդագրությունների ջնջվելը.

  1. Consumer-ի committed offset-ը. 50
  2. Kafka-ի low watermark-ը. 500 (offset-ներ 0-499-ը այլևս գոյություն չունեն)
  3. Դուք փորձում եք seek անել offset 50-ին
  4. Kafka-ն դրա փոխարեն վերադարձնում է offset 500-ը
  5. Ձեր կարդացած timestamp-ը գալիս է Օր 2-ից, այլ ոչ թե Օր 1-ից
  6. Հաղորդվող lag-ը սխալ է մեկ օրով կամ ավելիով

Ինչու է սա պատահում

Բնորոշ իրավիճակներ, որոնք առաջացնում են retention-ի պատճառով անճշտություն.

  • Consumer-ը կանգնեցված է օրերով կամ շաբաթներով – Ինչ-որ մեկը անջատել է այն միգրացիայի ժամանակ և երբեք նորից չի միացրել։
  • Դանդաղ consumer՝ մեծ ծավալով topic-ի վրա – Մշակումը հետ է մնում, և հին հաղորդագրությունները ժամկետանց են դառնում մինչև սպառվելը։
  • Consumer-ի offset-ը վերակայված է 0-ի – Դիտավորյալ replay, բայց ավելի հին հաղորդագրություններն արդեն ջնջված են։

Այս բոլոր դեպքերում ձեր time lag մետրիկան խիստ կթերագնահատի, թե consumer-ը իրականում որքան է հետ մնացել։

Հայտնաբերում. ինչպես է klag-exporter-ը բռնում այս սուտերը

Բարեբախտաբար, երկու իրավիճակներն էլ կարելի է հայտնաբերել։ Պետք է միայն համեմատել այն, ինչ խնդրել եք, այն բանի հետ, ինչ Kafka-ն իրականում վերադարձրել է։

Compaction-ի հայտնաբերում

requested_offset = committed_offset

actual_offset = offset_of_returned_message

if actual_offset > requested_offset:

    # Gap detected - compaction removed messages

    compaction_likely = true

Եթե մենք seek ենք անում offset 100-ին, բայց ստանում ենք offset 101, կարող ենք ասել, որ ինչ-որ բան compacted է արվել։

Retention-ի հայտնաբերում

Այս դեպքը դեռ ավելի պարզ է. low watermark-ը (ամենավաղ հասանելի offset-ը) արդեն վերցվում է սովորական աշխատանքի ընթացքում.

if committed_offset < low_watermark:

    # Consumer's position is before the earliest message

    retention_affected = true

Երբ ձեր committed offset-ը 50 է, իսկ low watermark-ը՝ 500, այդ հաղորդագրությունները պարզապես այլևս գոյություն չունեն։

Ինչ է հրապարակում klag-exporter-ը

klag-exporter-ը ավտոմատ կերպով հետևում է երկու իրավիճակներին.

Lag մետրիկաների label-ները, ըստ partition-ի.

kafka_consumergroup_group_lag_seconds{..., compaction_detected="true"} 45.2

kafka_consumergroup_group_lag_seconds{..., retention_detected="true"} 120.5

Հայտնաբերման հաշվիչներ.

kafka_lag_exporter_compaction_detected_total 12

kafka_lag_exporter_retention_detected_total 3

Ամեն անգամ, երբ scrape-ի ընթացքում այս իրավիճակներից մեկը հայտնաբերվում է, համապատասխան հաշվիչը մեծանում է։ Եթե դրանք զրոյից բարձր են, դուք գիտեք, որ ձեր time lag-ի որոշ թվերի չի կարելի վստահել։

Ինչ անել դրա դեմ

Եկեք դիտարկենք մեզ հասանելի լուծումները։

Մեղմացում compacted topic-ների համար

Ամենապարզ և ուղղակի տարբերակը min.compaction.lag.ms-ը բարձրացնելն է, ինչը բնականաբար հետաձգում է compaction-ը և consumer-ներին ավելի շատ ժամանակ է տալիս հասնելու, նախքան հաղորդագրությունների անհետանալը։ Լռելյայն արժեքը 0 է (իրավասու է անմիջապես)։

Մեկ այլ տարբերակ է ապահովել, որ consumer-ները համընթաց մնան. եթե ձեր consumer-ը սովորաբար հետ է մնում compaction-ից, շտկեք consumer-ը (մասշտաբավորեք, օպտիմալացրեք կամ ավելի շատ ռեսուրսներ հատկացրեք դրան)։

Վերջապես, կարող եք պարզապես հաշտվել սահմանափակման հետ. compacted topic-ների համար time lag-ը կարդացեք որպես «առնվազն այսքան», այլ ոչ թե որպես ճշգրիտ չափում։

Մեղմացում retention-ից տուժած consumer-ների համար

Երբ consumer-ի offset-ը low watermark-ից հետ է, անճշտ մետրիկաները ձեր ամենափոքր հոգսն են։

Ամենամեծ խնդիրն այն է, որ consumer-ը կորցրել է տվյալներ, և այդ հաղորդագրությունները կորել են ընդմիշտ։ Դուք պետք է որոշեք՝ արդյոք դա ընդունելի է, թե՞ պետք է replay անեք այլ աղբյուրից։ Իհարկե, կարող եք շարունակել այն ամենից, ինչ դեռ հասանելի է, բայց ավելի կարևոր է խորանալ հիմնական պատճառի մեջ. ինչու consumer-ը այդքան հետ մնաց (օրինակ՝ կանգնեցված էր կամ չափազանց դանդաղ էր), և ապա շտկել այդ հիմքում ընկած խնդիրը։

Մոնիթորինգի dashboard-ների համար

Ամեն անգամ, երբ հայտնաբերման դրոշները դրված են.

  • Offset lag-ը ներկայացրեք որպես հիմնական մետրիկա (այն մնում է ճշգրիտ)
  • Time lag-ը ցուցադրեք նախազգուշացնող ցուցիչի հետ միասին
  • Հստակ նշեք, որ արժեքը ստորին սահման է

Log compaction-ը և retention-ը կարող են հեռացնել հաղորդագրություններ, որոնք ձեր consumer-ը դեռ չի մշակել։ Երբ դա պատահում է, time lag մետրիկաները թերագնահատում են խնդիրը՝ երբեմն կտրուկ։ klag-exporter-ը հայտնաբերում է երկու իրավիճակներն էլ և նշում դրանք, այնպես որ գիտեք, երբ պետք է ավելի խորանալ՝ թվերին կուրորեն հենվելու փոխարեն։

Հիմա, երբ գիտեք և՛ այն, ինչ տալիս է time lag-ը, և՛ այն, որտեղ այն թերանում է, պատրաստ եք տեղակայել klag-exporter-ը ձեր սեփական միջավայրում։