Event streaming nazariyasi: tartib kafolati, retention va qachon Kafka ortiqcha
Qisqacha: Navbat xabarni bajargach o'chiradi, jurnal (log) esa saqlaydi: har o'quvchi o'zi qayerga kelganini — offset'ni — eslab qoladi. Shu farqdan event streaming'ning uchta asosiy savoli chiqadi: xabarlar qaysi tartibda ishlanadi, ular qancha saqlanadi va o'quvchi qulasa nima bo'ladi. Kurs tajribasida consumer ish o'rtasida o'ldirildi: 38 ta xabar "olingan, tasdiqlanmagan" holatda qoldi, oddiy qayta ishga tushish ularni 40 soniyada ham olmadi. Bitta qo'shimcha qadam bilan 636 ms da 500/500 bo'ldi. Dars oxirida Kafka qachon kerakligini raqam bilan hisoblaymiz.
Bu darsda
- Navbat va jurnal (log) farqini tushuntirasiz: o'chirish, ko'p o'quvchi, qayta o'qish.
- Offset, commit va ularning tartibi yetkazish kafolatini qanday belgilashini ko'rasiz.
- Consumer qulaganda tasdiqlanmagan xabarlar nega "osilib" qolishini va ularni qanday tiklashni bilasiz.
- Tartib kafolati qayerda bor, qayerda yo'qolishini modelda ko'rasiz.
- Retention (saqlash muddati) va hajmni hisoblab, Kafka kerakmi yoki yo'qligini aniqlaysiz.
Oldin bilishingiz kerak: Servislararo aloqa: sinxron va asinxron, Pub/Sub va Redis Streams, Boshqa xabar broker'lari, Transactional outbox naqshi.
1. Nega bu kerak?
Oldingi darsda B servisi ish o'rtasida o'ldirildi va qayta ishga tushirildi (Servislararo aloqa). Xabarlar navbatda kutdi — bu asinxron aloqaning va'dasi edi. Lekin va'da to'liq bajarilmadi: 500 xabardan 462 tasi ishlandi, 38 tasi qoldi. Bu Redis'ning xatosi emas. Bu consumer'ning xatosi, aniqrog'i — event streaming qanday ishlashini bilmaslik.
29-qismda broker'lar bilan amaliy ishlagansiz: BullMQ, RabbitMQ, NATS, Kafka modeli (Boshqa xabar broker'lari). 27-qismda Redis Streams buyruqlarini yozgansiz (Pub/Sub va Redis Streams). Bu dars ularning umumiy nazariyasi. Qaysi broker bo'lishidan qat'i nazar, uchta savol bir xil turadi:
- Tartib — xabarlar yozilgan tartibda ishlanadimi?
- Saqlash — xabar qancha vaqt turadi va kim uni qayta o'qiy oladi?
- Qulash — o'quvchi o'lsa, qaysi xabar yo'qoladi, qaysi biri ikki marta ishlanadi?
Har savolga javob — trade-off (murosali tanlov). Kuchli tartib parallellikni kamaytiradi. Uzoq saqlash disk va xotira talab qiladi. "Hech narsa yo'qolmasin" degan talab takrorni majburiy qiladi.
2. Navbat va jurnal
2.1 Ikki model
Navbat (queue) — ishlar ro'yxati. Ishchi ishni oladi, bajaradi, tasdiqlaydi va ish navbatdan o'chadi. Bitta xabarni bitta ishchi bajaradi. BullMQ, RabbitMQ, SQS — shu model.
Jurnal (log) — faqat oxiriga qo'shiladigan (append-only) yozuvlar ketma-ketligi. Har yozuvning tartib raqami bor — offset. O'qish yozuvni o'chirmaydi. Har o'quvchi o'zi qayerga kelganini alohida saqlaydi. Kafka, Redis Streams, NATS JetStream — shu model.
| Navbat | Jurnal | |
|---|---|---|
| O'qilgandan keyin | o'chadi | qoladi (retention tugaguncha) |
| Ko'p mustaqil o'quvchi | har biriga alohida navbat kerak | har biri o'z offset'i bilan |
| Qayta o'qish (replay) | yo'q | offset'ni orqaga surish |
| Kim qayerdaligini biladi | broker (har xabar holati) | o'quvchi (bitta raqam) |
| Tartib | odatda yo'q yoki zaif | jurnal ichida qat'iy |
Jurnal g'oyasi yangi emas. Postgres'ning WAL jurnali (Replikatsiya va read replica'lar) aynan shunday: replika WAL'ni o'z joyidan o'qiydi. Jay Kreps (Kafka mualliflaridan biri) 2013-yildagi mashhur maqolasida jurnalni "real vaqtli ma'lumotlarning birlashtiruvchi abstraksiyasi" deb atagan.
2.2 Bitta jurnal, ikki o'quvchi guruhi
Jurnal modelining kuchi — bitta yozuvni turli maqsadda o'qish:
flowchart LR
P[producer: outbox relay] --> L["jurnal: 0 1 2 3 4 5 6"]
L --> G1["guruh: xatlar<br/>offset 6"]
L --> G2["guruh: analitika<br/>offset 2"]
G1 --> C1[consumer x1]
G1 --> C2[consumer x2]
G2 --> C3[consumer a1]Diagrammada ikkita consumer group (iste'molchilar guruhi). "Xatlar" guruhi deyarli oxirgacha o'qigan — offset 6. "Analitika" guruhi orqada — offset 2. Ular bir-biriga xalal bermaydi. Analitika bir kun to'xtab tursa ham, xatlar ketishda davom etadi. Guruh ichida esa xabarlar consumer'lar orasida bo'linadi: har xabar guruhdagi bitta consumer'ga boradi.
Yangi guruh qo'shilsa, u jurnalni boshidan (yoki istalgan joydan) o'qiy oladi. Navbatda bu imkonsiz: o'qilgan ish allaqachon o'chgan.
3. Offset va commit
3.1 Joyni qachon saqlash kerak
O'quvchi xabarni olib, ishlab, keyin "shu yergacha keldim" deb belgilaydi. Kafka'da bu commit (offset'ni saqlash), Redis Streams'da — XACK. Muhim savol — qachon: ishdan oldinmi yoki keyinmi?
- Avval commit, keyin ish. Jarayon ular orasida o'lsa, xabar "o'qilgan" deb belgilangan, lekin ishlanmagan. U yo'qoladi. Bu at-most-once (ko'pi bilan bir marta).
- Avval ish, keyin commit. Jarayon ular orasida o'lsa, xabar ishlangan, lekin belgilanmagan. Qayta ishga tushgach u yana ishlanadi. Bu at-least-once (kamida bir marta).
Yetkazish kafolatlari jadvalini Transactional outbox naqshi darsida ko'rgansiz. Bu yerda muhimi — kafolatni broker emas, commit tartibi belgilaydi. Bir xil Kafka ikkala kafolatni ham bera oladi, qaysi biri bo'lishini consumer kodi tanlaydi. 2-mashqda ikkalasini modellashtirasiz.
3.2 Exactly-once qayerda bor
Kafka'da "exactly-once" degan rejim bor: idempotent producer va tranzaksiyalar. Hujjat va Kafka mualliflari blogiga ko'ra u haqiqatan ishlaydi, lekin bitta chegara ichida — o'qish, ishlash va natijani Kafka'ning o'ziga yozish bitta tranzaksiyada. Natija tashqariga ketsa (xat, to'lov API, boshqa baza), kafolat tugaydi. U yerda yana "at-least-once + idempotent iste'molchi" qoladi. Tashqi ta'sirni aniq bir marta qilishning yagona amaliy yo'li — idempotentlik kaliti yoki inbox jadvali.
4. Consumer qulaganda
4.1 Kanon tajribasi
Tajriba oldingi darsdagi B servisi bilan. B Redis Streams'dan 50 tadan xabar oladi va ularni bittalab ishlaydi. A 300 ta xabar yozdi, 1 soniyadan keyin B majburan o'ldirildi, keyin A yana 200 ta yozdi. B o'chiq paytdagi holat:
qayta ishlangan: 74 / 500; XPENDING (B olgan, tasdiqlamagan): 38Hisoblab ko'ramiz. Birinchi 300 tadan 74 tasi ishlandi. 38 tasi B ga berilgan, lekin tasdiqlanmagan. Bular B ning COUNT: 50 partiyasidan qolganlar. Qolgan 188 tasi va keyingi 200 tasi hali hech kimga berilmagan. 74 + 38 + 188 = 300.
Tasdiqlanmagan xabarlar ro'yxati — PEL (pending entries list, kutilayotgan yozuvlar ro'yxati). Redis har guruh uchun saqlaydi: qaysi xabar, qaysi consumer'ga, qachon berilgan, necha marta.
4.2 Oddiy qayta ishga tushish
B qayta ishga tushirildi. Kodi o'zgarmadi: XREADGROUP ... > — "menga hali hech kimga berilmagan yangi xabarlarni ber":
kutish: 462/500 yozuv, 40159 ms
qayta ishlangan: 462 / 500; XPENDING: 38 — osilib qolgan40 soniya kutildi. 388 ta yangi xabar ishlandi (74 + 388 = 462), lekin 38 tasi joyida qoldi. > belgisi ularni qaytarmaydi: ular "yangi" emas, allaqachon B ga berilgan. Redis nuqtai nazaridan ular B ning qo'lida. B esa ular haqida hech narsa bilmaydi — eski jarayon bilan birga xotirasi ham o'chdi.
Bu xavfli holat, chunki sokin. Xato xabari yo'q, consumer ishlayapti, yangi xabarlar o'tyapti. Faqat 38 ta buyurtma hech qachon hisoblanmaydi. Buni faqat PEL uzunligi metrikasi yoki "eng eski kutayotgan xabar yoshi" ko'rsatadi.
4.3 Tiklash bilan
B ga bitta qoida qo'shildi: ishga tushganda avval o'zining kutilayotgan xabarlarini o'qisin, keyin yangilarini. Buning uchun > o'rniga 0 beriladi: "menga berilgan, lekin men tasdiqlamagan xabarlarni ber". Kurs tajribasidagi kod (kalit nomlari qisqartirildi):
let pel = process.env.PEL === "1";
for (;;) {
const javob = await r.xReadGroup("hisob", "b1",
[{ key: "buyurtmalar", id: pel ? "0" : ">" }],
{ COUNT: 50, BLOCK: 1000 });
if (pel && (javob?.[0]?.messages.length ?? 0) === 0) {
pel = false; // o'zimnikilar tugadi — endi yangilari
continue;
}
// ... ishlash va XACK — avvalgidek
}Natija:
kutish: 500/500 yozuv, 636 ms
yetkazilgan: 500, noyob id: 500, kutilayotgan (XPENDING): {"pending":0,"firstId":null,"lastId":null,"consumers":null}38 ta xabar 636 ms da ishlandi (38 × 15.67 ms ≈ 595 ms), PEL bo'sh. noyob id: 500 — hech bir xabar ikki marta ishlanmadi.
Natijani halol o'qiymiz. Takror 0 — bu safar omad. B kodida ish va XACK orasida natija yoziladi. Agar B aynan shu ikki qator orasida o'lganda, o'sha xabar natijada ikki marta bo'lardi. Bu at-least-once'ning narxi: tiklash takrorni kafolatlamaydi, lekin uning ehtimolini olib tashlamaydi. Shuning uchun iste'molchi idempotent bo'lishi shart.
Yana bir raqam — yetkazish kechikishining eng kattasi 45 190 ms. Bu B o'chiq turgan va oddiy rejimda 40 soniya kutilgan vaqt. Xabar yo'qolmadi, lekin 45 soniya kechikdi. Asinxron tizimda "yo'qolmadi" va "o'z vaqtida yetdi" — ikki xil va'da.
4.4 Boshqa consumer'ga o'tkazish
0 bilan tiklash faqat o'sha nomdagi consumer qaytsa ishlaydi. Consumer butunlay yo'qolsa (masalan, Kubernetes pod'i boshqa nom bilan qayta yaratildi), uning PEL'i abadiy qoladi. Buning uchun XAUTOCLAIM bor: "berilganiga N millisekunddan ko'p bo'lgan tasdiqlanmagan xabarlarni menga o'tkaz". 27-qismda uni sinab ko'rgansiz (Pub/Sub va Redis Streams). Bu tajribada u ishlatilmadi.
Ikkala usulning ham murosali tanlovi bor. 0 bilan tiklash sodda, lekin consumer nomi barqaror bo'lishini talab qiladi. XAUTOCLAIM nomga bog'liq emas, lekin "N millisekund" ni to'g'ri tanlash kerak. Juda qisqa bo'lsa, hali ishlayotgan consumer'ning xabari boshqasiga o'tib ketadi va takror bo'ladi. Juda uzun bo'lsa, xabar uzoq kutadi. BullMQ bu ishni o'zi qiladi: "stalled" ishlarni qulf muddati o'tgach qayta navbatga qaytaradi (BullMQ ishonchlilik). Bu tayyor broker'ning afzalligi: bunday qoidani har consumer'da qo'lda yozish kerak emas.
Tekshirib ko'ring: Consumer'lar Kubernetes'da ishlaydi va har restart'da yangi tasodifiy nom oladi. Ular
0bilan tiklash qiladi. Nima bo'ladi?
Javob
Tiklash hech narsa topmaydi: yangi nomdagi consumer'ning PEL'i bo'sh. Eski nomdagi consumer'ning xabarlari esa abadiy osilib qoladi. Yechim — barqaror nom (masalan, pod tartib raqami) yoki boshqa consumer'lar XAUTOCLAIM bilan eski xabarlarni o'ziga olishi. Eski nomlarni guruhdan XGROUP DELCONSUMER bilan olib tashlash ham kerak, aks holda ro'yxat o'sib boradi.
5. Tartib kafolati
5.1 Jurnal tartibli, ishlash — yo'q
Jurnalda yozuvlar qat'iy tartibda turadi. Bitta Redis stream'da har yozuv ID'si oldingisidan katta. Lekin "yozildi" tartibi "ishlandi" tartibi bilan bir xil emas. Guruhda ikki consumer bo'lsa, xabarlar ular orasida bo'linadi va har biri o'z tezligida ishlaydi.
Bitta vazifaning uchta hodisasini ikki consumer'ga beramiz. c1 sekin (30 ms), c2 tez (5 ms). Avval xabarlar navbat bilan bo'linadi, keyin — vazifa id si bo'yicha. Chiqishda har hodisa qaysi consumer'da va nechanchi millisekundda tugaganiga qarang:
// Bitta stream, ikki consumer: c1 sekin (30 ms), c2 tez (5 ms).
// Xabarlar navbat bilan bo'linadi (consumer group shunday qiladi).
const oqim = [
{ id: 7, tur: "yaratildi", versiya: 1 },
{ id: 7, tur: "tahrirlandi", versiya: 2 },
{ id: 7, tur: "bajarildi", versiya: 3 },
];
const tezlik = { c1: 30, c2: 5 };
function ishla(taqsim) {
const tugash = [];
const band = { c1: 0, c2: 0 };
oqim.forEach((x, i) => {
const c = taqsim(x, i);
band[c] += tezlik[c];
tugash.push({ ...x, c, t: band[c] });
});
return tugash.toSorted((a, b) => a.t - b.t);
}
const navbatBilan = (x, i) => (i % 2 === 0 ? "c1" : "c2");
const kalitBilan = (x) => (x.id % 2 === 0 ? "c2" : "c1");
for (const [nom, f] of [["navbat bilan", navbatBilan],
["kalit bilan", kalitBilan]]) {
const tartib = ishla(f).map((x) => `${x.tur}(${x.c}, ${x.t} ms)`);
console.log(`${nom}: ${tartib.join(" → ")}`);
}Konsolda:
navbat bilan: tahrirlandi(c2, 5 ms) → yaratildi(c1, 30 ms) → bajarildi(c1, 60 ms)
kalit bilan: yaratildi(c1, 30 ms) → tahrirlandi(c1, 60 ms) → bajarildi(c1, 90 ms)Birinchi qatorda "tahrirlandi" "yaratildi" dan oldin ishlandi. Iste'molchi hali mavjud bo'lmagan vazifani tahrirlamoqchi bo'ladi. Ikkinchi qatorda bitta kalitning hamma hodisasi bitta consumer'ga tushdi va tartib saqlandi.
Narxini ham ko'ring. Kalit bilan bo'lishda oxirgi hodisa 90 ms da tugadi, navbat bilan — 60 ms da. c2 umuman ishlamay turdi: bu kalitning hamma hodisasi c1 ga ketgan. Tartib kafolati parallellikdan olinadi. Kafka bu murosali tanlovni partition orqali hal qiladi: bir kalitli xabarlar doim bitta partition'ga tushadi, partition esa guruhdagi bitta consumer'ga. Tartib — faqat partition ichida, partition'lar orasida — yo'q. Partition kalitlari teng taqsimlanmasa, bitta consumer "issiq" bo'lib qoladi — sharding'dagi issiq nuqta muammosi (Sharding va taqsimlangan SQL).
5.2 Tartib kerak bo'lmasligi uchun
Tartibni broker'dan talab qilish o'rniga, ko'pincha iste'molchini tartibga befarq qilish arzonroq. vazifalar-api ning webhook tanasida buning uchun maydon bor — versiya:
{ type, timestamp, data: { id, matn, bajarildi, versiya } }Iste'molchi har vazifa uchun oxirgi ko'rgan versiyani saqlaydi. Kelgan hodisaning versiyasi kichik yoki teng bo'lsa — uni tashlaydi. Shunda "tahrirlandi (2)" "bajarildi (3)" dan keyin kelsa ham, eski holat yangisini bosib ketmaydi. Bu Kafka'siz, partition'siz ishlaydi. Narxi — har hodisada versiya bo'lishi va iste'molchi holat saqlashi.
jamoa ning asinxron ishlar haqidagi qarori (ADR) aynan shu yo'lni tanlagan. Uning birinchi qoralamasida "tartib kafolati — bitta jamoa ichida, navbat kaliti jamoa_id" deb yozilgan edi. Tekshiruvda bu noto'g'ri chiqdi: BullMQ'ning ochiq versiyasida kalit bo'yicha tartiblangan guruhlar yo'q. Hujjatga ko'ra bu imkoniyat (groups) pullik BullMQ Pro'da (2026-11 holatiga). Qaror tuzatildi: hodisada versiya raqami, iste'molchi esa eskisini tashlab yuboradi. Qaror yozuvlarining o'zi bilan ADR va C4 diagrammalar darsida ishlaymiz.
6. Retention: qancha saqlanadi
6.1 Muddat va hajm
Jurnal cheksiz o'smaydi. Saqlash siyosati (retention policy) — eski yozuvlar qachon o'chirilishini belgilaydi. Ikki asosiy usul bor:
- Vaqt bo'yicha — "7 kundan eski yozuvlar o'chsin". Kafka'da sukut bo'yicha 7 kun (
log.retention.hours=168, hujjat bo'yicha). Redis Streams'daXTRIM ... MINID— ma'lum ID'dan (ya'ni vaqtdan) eskilari. - Hajm bo'yicha — "oxirgi N ta yozuv" yoki "N gigabayt". Redis'da
XADD ... MAXLEN ~ N.
Kafka'da uchinchi usul ham bor — compaction (siqish): har kalit uchun faqat oxirgi yozuv qoladi. Bu "joriy holat"ni saqlash uchun qulay, masalan, har foydalanuvchining oxirgi sozlamasi.
Retention o'quvchi uchun xavf ham. Agar guruh retention muddatidan ko'p orqada qolsa, u o'qimagan yozuvlar o'chib ketadi. Masalan, analitika guruhi 8 kun to'xtab turdi, retention esa 7 kun. Bir kunlik hodisalar uning uchun abadiy yo'qoladi. Shuning uchun orqada qolish (consumer lag) metrikasi retention bilan birga kuzatiladi.
6.2 Loyihadagi retention
vazifalar-api da jurnal bor-yo'qligini bilmasdan ham, retention qarorlari allaqachon qabul qilingan:
| Jadval | Nima | Retention | Qanday |
|---|---|---|---|
outbox |
tarqatiladigan hodisalar | tarqatilgandan keyin 7 kun | kunlik outboxTozala ishi, DELETE |
vazifa_hodisalari |
analitika uchun hodisalar | 13 oy | oylik bo'limlar, eskisi DROP (Partitioning) |
Ikkalasi ham jurnal xususiyatiga ega: faqat qo'shiladi, tartib raqami (id yoki vaqt) bor, eski qismi muddat bilan o'chadi. Farq maqsadda. Outbox — yetkazish uchun, shuning uchun qisqa. Analitika hodisalari — grafik va hisobot uchun, shuning uchun uzun. Kafka'ning "bitta jurnal, ko'p guruh" modeli shu ikki ehtiyojni bitta joyda yopardi. Bizda ular ikki jadvalda va bu hozircha arzonroq.
7. Uch broker, uch model
| Redis Streams | NATS JetStream | Kafka | |
|---|---|---|---|
| Saqlash | xotirada (RDB/AOF bilan diskka) | diskda yoki xotirada | diskda |
| Tartib | bitta stream ichida | bitta stream ichida | partition ichida |
| Guruh ichida bo'linish | xabar bo'yicha | xabar bo'yicha | partition bo'yicha |
| Tasdiqlanmaganlar | PEL, XAUTOCLAIM |
ack muddati, qayta yetkazish | offset commit |
| Retention | MAXLEN, MINID |
vaqt, hajm, "ish navbati" rejimi | vaqt, hajm, compaction |
| Infratuzilma | Redis (loyihada bor) | bitta Go binar | klaster (KRaft) |
| Kursda | sinalgan | 29-qismda sinalgan | sinalmagan |
Redis Streams'ning asosiy cheklovi — xotira. Jurnal operativ xotirada yashaydi. Retention uzun yoki hodisa ko'p bo'lsa, xotira tugaydi. Kafka esa diskka yozadi va oylab saqlashga mo'ljallangan. Kafka'ning narxi — operatsion murakkablik: klaster, replikatsiya sozlamalari, partition sonini oldindan tanlash (keyin oshirish kalit taqsimotini buzadi), monitoring. Kafka kursda o'rnatilmadi va sinalmadi. Uning haqidagi hamma gap rasmiy hujjat bo'yicha.
Jadvalda Redis Pub/Sub yo'q, chunki u jurnal ham, navbat ham emas. Pub/Sub xabarni faqat shu daqiqada ulangan obunachilarga beradi va hech narsani saqlamaydi. Obunachi bir soniya uzilsa, o'sha soniyadagi xabarlar u uchun yo'q. Bu at-most-once'ning eng sof shakli. Shunga qaramay, u o'z joyida juda foydali. Kesh tozalash signali yoki "ekranni yangila" degan bildirishnoma uchun yo'qotish zararsiz: keyingi signal baribir keladi. vazifalar-api da SSE hodisalari ko'p nusxaga shu tamoyil bilan tarqatiladi (Realtime'ni masshtablash). Qoida oddiy: xabar yo'qolsa nima bo'lishini so'rang. "Hech narsa" bo'lsa — Pub/Sub, "foydalanuvchi zarar ko'radi" bo'lsa — jurnal yoki navbat.
Tekshirib ko'ring: Kafka topic'ida 3 ta partition va guruhda 5 ta consumer bor. Nechta consumer ishlaydi?
Javob
Uchtasi. Har partition guruhdagi bitta consumer'ga beriladi, ikkita consumer bo'sh turadi. Kafka'da guruh ichidagi parallellik partition sonidan oshmaydi. Shuning uchun partition soni kelajakdagi yukka qarab oldindan tanlanadi — bu yana bitta "keyin o'zgartirish qimmat" qaror.
8. Qachon Kafka ortiqcha
8.1 Hisob-kitob
jamoa uchun qaror yozuvida Kafka'ga o'tish sharti raqam bilan berilgan: kuniga 10⁷ dan ko'p hodisa yoki tarixni bir nechta mustaqil tizim qayta o'qishi kerak bo'lsa. Bu raqam nimani anglatadi? Taxminiy hisob qilamiz (Taxminiy hisob-kitob va latency raqamlari usuli). Faraz: har so'rov bitta hodisa, hodisa 1 KB, cho'qqi o'rtachadan 10 barobar:
// Taxminiy hisob: kunlik hodisa → soniyaga, cho'qqi va saqlash hajmi
function hisob(nom, kunlik, bayt, kun, koef = 10) {
const ortacha = kunlik / 86_400;
const hajmGb = (kunlik * bayt * kun) / 1e9;
console.log(`${nom}: o'rtacha ${ortacha.toFixed(1)}/s,`,
`cho'qqi ~${Math.round(ortacha * koef)}/s,`,
`${kun} kunlik hajm ${hajmGb.toFixed(2)} GB`);
}
hisob("jamoa (3 so'rov/s)", 3 * 86_400, 1_000, 7);
hisob("ADR chegarasi", 1e7, 1_000, 7);
hisob("katta tizim", 1e9, 1_000, 7);Konsolda:
jamoa (3 so'rov/s): o'rtacha 3.0/s, cho'qqi ~30/s, 7 kunlik hajm 1.81 GB
ADR chegarasi: o'rtacha 115.7/s, cho'qqi ~1157/s, 7 kunlik hajm 70.00 GB
katta tizim: o'rtacha 11574.1/s, cho'qqi ~115741/s, 7 kunlik hajm 7000.00 GBUchta qatorni o'qiymiz:
jamoa— soniyasiga 30 ta hodisa. Kurs tajribasida bitta producer ketma-ketXADDbilan 500 ta xabarni 582 ms da yozdi, ya'ni soniyasiga 800 dan ortiq. Bu ham Redis chegarasi emas, bitta ulanishning kutish vaqti. Bo'sh joy (headroom) yuz barobardan ko'p.- ADR chegarasi — soniyasiga ~1 000 ta cho'qqi va 70 GB. Yozish tezligi Redis'ga ham, Postgres'ga ham sig'adi. Lekin 70 GB jurnal operativ xotiraga sig'maydi — masalan, 16 GB xotirali VPS'da (faraz). Retention'ni qisqartirish yoki diskli jurnalga o'tish kerak. Chegara aynan shu yerdan.
- Katta tizim — soniyasiga 100 mingdan ortiq va terabaytlar. Bu Kafka'ning odatiy hududi.
Raqamlar taxminiy va farazga bog'liq. Hodisa 1 KB emas, 200 bayt bo'lsa, hajm besh barobar kichik. Shuning uchun faraz har doim natija yonida yoziladi.
8.2 Hajmdan tashqari sabablar
Kafka'ni faqat hajm uchun tanlashmaydi. Ikkita boshqa sabab bor:
- Ko'p mustaqil iste'molchi va replay. Bitta hodisalar oqimini analitika, qidiruv indeksi, firibgarlik tizimi va audit alohida o'qiydi. Yangi tizim qo'shilganda u tarixni boshidan o'qiydi. Bunda jurnal — tizimlar orasidagi umumiy "haqiqat manbai".
- Oqimli ishlash (stream processing). Hodisalar ustida doimiy hisoblar: "oxirgi 5 daqiqadagi to'lovlar soni". Kafka Streams, Flink kabi vositalar shu jurnal ustida ishlaydi.
Teskari tomoni — Kafka ortiqcha bo'ladigan belgilar:
- bitta jamoa, bitta ilova, bitta baza;
- hodisalarni bitta yoki ikkita iste'molchi o'qiydi va ularni qayta o'qish kerak emas;
- yuk soniyasiga yuzlab, minglab emas;
- jamoada Kafka'ni ishlatgan va kechasi tuzatgan odam yo'q.
jamoa to'rttala belgiga ham mos. Shuning uchun qaror — outbox va BullMQ, Kafka emas (Transactional outbox naqshi). Bu "Kafka yomon" degani emas. Bu "Kafka'ning narxi bizga hozir to'lanadigan foyda bermaydi" degani. O'tish sharti esa oldindan yozilgan: shart bajarilsa, qaror qayta ko'riladi.
9. Loyiha qadami: tajriba, loyihaga kirmaydi
Bu darsda vazifalar-api ga kod qo'shilmaydi. Loyihada Redis Streams'ni qo'lda o'qiydigan consumer yo'q. Fon ishlari BullMQ orqali, u tasdiqlanmagan ishlarni o'zi qaytaradi. SSE uchun ishlatiladigan stream esa faqat "shu daqiqada ulangan mijozlar"ga xizmat qiladi, unda iste'molchi guruhi yo'q. Tajribadagi tiklash qoidasi faqat namoyish uchun yozildi.
Lekin qoidani eslab qoling. Agar siz qachondir Redis Streams consumer'ini qo'lda yozsangiz, ishga tushishda birinchi qadam — o'z PEL'ini 0 bilan o'qish. Ikkinchisi — boshqalarning eski xabarlarini XAUTOCLAIM bilan olish. Uchinchisi — PEL uzunligini metrika qilish.
10. Ko'p uchraydigan xatolar
10.1 Faqat > bilan o'qish
Consumer qulasa, uning qo'lidagi xabarlar osilib qoladi. Ishga tushishda avval 0 bilan o'zining kutilayotganlarini o'qing.
10.2 Commit'ni ishdan oldin qilish
Tez ko'rinadi, lekin jarayon o'lsa xabar yo'qoladi. Yo'qotish mumkin bo'lmagan joyda commit ishdan keyin, iste'molchi esa idempotent.
10.3 "Jurnal tartibli — demak ishlash ham tartibli"
Guruhda bir nechta consumer bo'lsa, tartib yo'qoladi. Kerak bo'lsa — kalit bo'yicha bo'lish yoki versiya maydoni.
10.4 Retention'ni consumer lag'dan qisqa qilish
Orqada qolgan guruh o'qimagan yozuvlar o'chadi. Lag va retention birga kuzatiladi.
10.5 Kafka'ni "keyin kerak bo'lar" deb qo'yish
Yangi klaster — yangi server, monitoring, bilim va kechasi qo'ng'iroq. O'tish shartini raqam bilan yozing va shu raqamga yetganda o'ting.
11. Mashqlar
Mashqlar kurs/mashqlar/36/19-event-streaming/ da. 2- va 3-mashq yechimlari Node 24.21.0 da tekshirilgan (biz ishga tushirdik).
1-mashq (oson): bo'shliqlarni to'ldiring
- Jurnaldagi yozuvning tartib raqami —
- Redis'da berilgan, lekin tasdiqlanmagan xabarlar ro'yxati —
- Faqat yangi xabarlarni so'raydigan
XREADGROUPID'si — - O'zining tasdiqlanmagan xabarlarini qayta so'raydigan ID —
- Har kalit uchun faqat oxirgi yozuvni qoldiradigan Kafka retention usuli —
Yechim
- offset — o'quvchi o'zi saqlaydi; Kafka'da commit.
- PEL — pending entries list; tajribada 38 ta.
- > — PEL'dagi xabarlarni qaytarmaydi, shuning uchun 40 s da 462/500.
- 0 — tiklash bilan 636 ms da 500/500.
- compaction — joriy holatni saqlash uchun.
2-mashq (o'rta): commit qachon
yurgiz(rejim, qulash) funksiyasini yozing. Consumer 0 dan 9 gacha 10 ta xabarni ishlaydi. rejim — "oldin" (avval commit, keyin ish) yoki "keyin" (avval ish, keyin commit). qulash raqamli xabarda jarayon ish va commit orasida o'ladi. Keyin yangi jarayon saqlangan offset'dan oxirigacha ishlaydi. Natija satri: necha marta ishlandi, nechta takror, nechta yo'qolgan.
Ishora: ishlangan xabarlar raqamini massivga yig'ing, noyoblarini Set bilan sanang (Set).
Yechim
// Consumer 10 ta xabarni ishlaydi. `qulash` raqamli xabarda jarayon
// ish va commit ORASIDA o'ladi, keyin offset'dan davom etiladi.
function yurgiz(rejim, qulash) {
let offset = 0; // saqlangan joy (Kafka'da commit, Streams'da XACK)
const ishlangan = [];
for (let i = offset; i < 10; i++) { // 1-jarayon
if (rejim === "oldin") {
offset = i + 1; // avval commit
if (i === qulash) break; // o'ldi: ish bajarilmadi
ishlangan.push(i);
} else {
ishlangan.push(i); // avval ish
if (i === qulash) break; // o'ldi: commit bo'lmadi
offset = i + 1;
}
}
for (let i = offset; i < 10; i++) ishlangan.push(i); // 2-jarayon
const noyob = new Set(ishlangan).size;
return `${rejim}: ishlandi ${ishlangan.length},`
+ ` takror ${ishlangan.length - noyob}, yo'qolgan ${10 - noyob}`;
}
console.log(yurgiz("oldin", 4));
console.log(yurgiz("keyin", 4));Konsolda:
oldin: ishlandi 9, takror 0, yo'qolgan 1
keyin: ishlandi 11, takror 1, yo'qolgan 0"Oldin" rejimida 4-xabar commit qilindi, lekin ishlanmadi — yo'qoldi. Bu at-most-once. "Keyin" rejimida 4-xabar ishlandi, commit bo'lmadi va yangi jarayon uni yana ishladi — takror. Bu at-least-once. Uchinchi variant yo'q: ish va commit ikki alohida tizimda bo'lsa, ular orasidagi qulash yo yo'qotish, yo takror beradi. Takrorni zararsiz qilish — iste'molchining ishi.
3-mashq (qiyin): Kafka kerakmi
tanla(t) funksiyasini yozing. Kirish: kunlik hodisa, bayt (bitta hodisa), saqlashKun, qaytaOqish (tarixni qayta o'qish kerakmi), oquvchilar (mustaqil iste'molchi tizimlar soni), xotiraGb (Redis serveridagi xotira). Qoidalar tartib bilan:
- kuniga 10⁷ dan ko'p — Kafka (hajm);
- qayta o'qish kerak va o'quvchilar 3 va undan ko'p — Kafka (replay);
- jurnal hajmi xotiraning yarmidan katta — diskli jurnal;
- aks holda — BullMQ yoki Redis Streams.
To'rt holatni sinang: jamoa, analitika, bank, telemetriya.
Ishora: hajm — kunlik × bayt × saqlashKun, GB uchun 10⁹ ga bo'ling. Shartlarni if va erta return bilan yozing.
Yechim
function tanla(t) {
const hajmGb = (t.kunlik * t.bayt * t.saqlashKun) / 1e9;
if (t.kunlik > 1e7) return "Kafka: hajm chegaradan katta";
if (t.qaytaOqish && t.oquvchilar >= 3) {
return "Kafka: tarixni bir nechta tizim qayta o'qiydi";
}
if (hajmGb > t.xotiraGb / 2) {
return `diskli jurnal: ${hajmGb.toFixed(1)} GB sig'maydi`;
}
return `BullMQ yoki Redis Streams (${hajmGb.toFixed(2)} GB)`;
}
const holatlar = [
{ nom: "jamoa", kunlik: 259_200, bayt: 1_000, saqlashKun: 7,
qaytaOqish: false, oquvchilar: 2, xotiraGb: 16 },
{ nom: "analitika", kunlik: 2e6, bayt: 2_000, saqlashKun: 30,
qaytaOqish: true, oquvchilar: 1, xotiraGb: 16 },
{ nom: "bank", kunlik: 5e6, bayt: 1_000, saqlashKun: 365,
qaytaOqish: true, oquvchilar: 4, xotiraGb: 64 },
{ nom: "telemetriya", kunlik: 5e8, bayt: 300, saqlashKun: 3,
qaytaOqish: false, oquvchilar: 1, xotiraGb: 64 },
];
for (const h of holatlar) console.log(`${h.nom}: ${tanla(h)}`);Konsolda:
jamoa: BullMQ yoki Redis Streams (1.81 GB)
analitika: diskli jurnal: 120.0 GB sig'maydi
bank: Kafka: tarixni bir nechta tizim qayta o'qiydi
telemetriya: Kafka: hajm chegaradan kattaAnalitika qatoriga qarang. Yuk kichik — soniyasiga 23 ta hodisa. Lekin 30 kunlik retention bilan 120 GB, xotiraga sig'maydi. Javob Kafka emas, "diskli jurnal": bo'limli Postgres jadvali (vazifa_hodisalari kabi), NATS JetStream fayl rejimi yoki Kafka. Bank qatorida hajm emas, replay va to'rtta mustaqil tizim hal qildi. Qoidalar tartibi ham qaror: birinchi bajarilgan qoida javob beradi. Real qarorda bularga jamoa bilimi va operatsion narx qo'shiladi. Bu funksiya ularni hisobga olmaydi.
12. Real ishda
- Kafka — markaziy jurnal. Katta kompaniyalarda Kafka ko'pincha "hodisalar magistrali": har servis o'z hodisalarini yozadi, boshqalari kerakligini o'qiydi. Bu model jamoalar o'nlab bo'lganda o'zini oqlaydi.
- CDC. Ma'lumotlar bazasining o'z jurnali (Postgres WAL) Debezium kabi vositalar orqali Kafka'ga uzatiladi (CDC va ma'lumot sinxronlash). Outbox jadvali ham shu yo'l bilan tarqatilishi mumkin.
- Boshqariladigan xizmatlar. Kafka'ni o'zingiz ko'tarmasdan bulut xizmatlaridan olish mumkin. Bu operatsion narxni pulga almashtiradi.
- Intervyu. "Kafka va RabbitMQ farqi nima?" Kutilgan javob: jurnal va navbat, offset va ack, partition bo'yicha tartib, retention va replay — har biri qaysi masalaga mos.
Xulosa
- Navbat xabarni bajargach o'chiradi; jurnal saqlaydi, har o'quvchi o'z offset'i bilan o'qiydi.
- Yetkazish kafolatini commit tartibi belgilaydi: avval commit — yo'qotish, avval ish — takror.
- Kurs tajribasi: consumer qulaganda 38 ta xabar PEL'da qoldi. Faqat
>bilan qayta ishga tushish 40 s da 462/500 berdi.0bilan tiklash — 636 ms da 500/500. - Jurnal tartibli, lekin guruhdagi ishlash tartibli emas. Tartib kalit bo'yicha bo'lish yoki versiya maydoni bilan saqlanadi.
- Retention — vaqt, hajm yoki compaction; consumer lag retention'dan oshmasin.
- Kafka hajm, ko'p mustaqil iste'molchi va replay uchun.
jamoauchun ortiqcha: soniyasiga ~30 ta hodisa, o'tish sharti oldindan yozilgan.
Keyingi dars: Event-driven arxitektura — hodisa nimani olib yurishi kerak: faqat "o'zgardi" degan signalmi yoki butun holatmi, va servislar buyruqsiz qanday hamkorlik qiladi.
Manbalar
- Jay Kreps — The Log: What every software engineer should know about real-time data's unifying abstraction (LinkedIn Engineering, 2013-12-16): https://engineering.linkedin.com/distributed-systems/log-what-every-software-engineer-should-know-about-real-time-datas-unifying (2026-11 da 404 qaytardi). Kitob varianti: Jay Kreps — I Heart Logs (O'Reilly, 2014).
- Apache Kafka — Documentation (dizayn, retention, consumer group, exactly-once): https://kafka.apache.org/documentation/ (Kafka kursda o'rnatilmagan;
log.retention.hours= 168 broker sozlamalari jadvalidan tekshirildi, 2026-11) - Apurva Mehta, Jason Gustafson — Transactions in Apache Kafka (Confluent blog, 2017): https://www.confluent.io/blog/transactions-apache-kafka/ (tekshirildi, 2026-11: exactly-once — o'qish, ishlash va Kafka'ga yozish sikli ichida)
- Redis — Streams: XREADGROUP, XPENDING, XAUTOCLAIM: https://redis.io/docs/latest/develop/data-types/streams/ (tekshirildi, 2026-11)
- NATS — JetStream: https://docs.nats.io/nats-concepts/jetstream (tekshirildi, 2026-11: xotira yoki disk, retention)
- BullMQ — Groups (BullMQ Pro): https://docs.bullmq.io/bullmq-pro/groups (tekshirildi, 2026-11)
- Martin Kleppmann — Designing Data-Intensive Applications (O'Reilly, 2017), 11-bob "Stream Processing"
- Kurs tajribasi (IlmHamroh, 2026-11): Redis Streams consumer group, consumer'ni majburan o'ldirish,
>va0bilan qayta ishga tushish (Windows 11, Node 24.21.0, Redis 8). Mashq yechimlari — biz ishga tushirdik (2026-11-09).
Izohlar · 0
Izoh yozish uchun kiring.