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-ի ավելի դիմացկուն մոնիթորինգի համար։
Ձեր 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-ը.
- Seek անում եք offset 100-ին
- Kafka-ն չի կարող գտնել offset 100-ը (compaction-ը հեռացրել է այն)
- Kafka-ն դրա փոխարեն վերադարձնում է offset 101-ը
- Դուք կարդում եք timestamp 10:00:15-ը
- Ընթացիկ ժամանակը 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-ը նախքան այդ հաղորդագրությունների ջնջվելը.
- Consumer-ի committed offset-ը. 50
- Kafka-ի low watermark-ը. 500 (offset-ներ 0-499-ը այլևս գոյություն չունեն)
- Դուք փորձում եք seek անել offset 50-ին
- Kafka-ն դրա փոխարեն վերադարձնում է offset 500-ը
- Ձեր կարդացած timestamp-ը գալիս է Օր 2-ից, այլ ոչ թե Օր 1-ից
- Հաղորդվող 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-ը ձեր սեփական միջավայրում։