Съдържание на курса
Урок 29 — Без загуби при консумиране
От Dorian Chávez · съосновател и Chief Executive Officer на Hábil ·
Какво ще постигнеш: събитие, което една интеграция е прочела, но не е довършила (доставила е поръчката, но не е успяла да остави своя резултат), да се прочете отново, вместо да се смята за прочетено. И прочитането му два пъти да не създава поръчката два пъти в API-то.
Преди да започнеш, ти трябват: завършени уроци 18 и 28, включена средата от урок 00 и вдигната Kafka
(docker compose -f infra/compose.yaml --profile kafka up -d --wait).
Новото днес, в едно изречение
В урок 28 всяка група води своя сметка докъде е прочела: offset-а. До днес тази сметка я потвърждава Kafka сама
(autoCommitEnable, което идва включено) — автоматично потвърждаване на офсета (auto-commit) — с това, което консуматорът вече е прочел, независимо дали е приключил, или не. А когато едно събитие
се провали по средата, Camel го записва в лога и продължава със следващото: сметката напредва над това, което се е провалило.
API-то вече има поръчката, но рутерът никога не научава как е минало и никой не чете отново това събитие. Днес
offset-ът се потвърждава на ръка и само когато работата е приключила.
Картината: разделителят в една книга. Ако го местиш всеки път, когато обръщаш страницата, дори да си заспал по средата на главата, утре започваш от следващата глава и това, което не си прочел, вече не го четеш. Ако го местиш само когато си завършил главата, най-лошото, което може да стане, е да препрочетеш няколко страници.
leer el evento → entregarlo al canal → publicar el desenlace → confirmar el offset
↑ si algo falla antes de aquí, se vuelve a leer
1. Подготви папката си
cd lecciones/29-no-perder-al-consumir
cp -R inicio mio
Твоята работа е в трите моста: mio/int-rest/kafka.camel.yaml, mio/int-bd/kafka.camel.yaml и
mio/int-edi/kafka.camel.yaml. И трите се променят еднакво.
Преди това отвори mio/orden-router/desenlaces.camel.yaml: рутерът вече чете топика desenlaces така. Служи ти за
образец.
2. Предвиди
Отговори на лист хартия:
- API-то получи поръчка 2001 и отговори с
201на int-rest, но Kafka не прие резултата, който int-rest се опита да публикува. При автоматичното потвърждаване научава ли рутерът, че 2001 е пристигнала? Чете ли някой отново това събитие? - Ако потвърждаваш offset-а едва накрая и убият int-rest, след като е доставил, но преди да е потвърдил, какво става, когато се върне? Създава ли се 2001 два пъти в API-то? (Подсказка: урок 18.)
- Ако едно събитие не може да бъде довършено никога, какво става с тези, които идват след него в неговия дял?
Виж какво е положението днес:
./verifica inicio
Скриптът verifica залага капан на Kafka: прави така, че топикът desenlaces да не приема нищо. Праща три поръчки, вижда, че
API-то и ERP ги получават и че рутерът не научава за нито една. После маха капана. При автоматичното
потвърждаване рутерът остава, без да знае за нито една от 6-те операции: събитията вече бяха потвърдени.
3. Потвърждавай, когато си приключил
Във всеки мост има три TODO.
TODO 1: трите опции на консуматора
Във from: kafka:ordenes, до groupId:
autoCommitEnable: false # Kafka ya no confirma solo
allowManualCommit: true # el puente confirma cada evento cuando terminó con él
breakOnFirstError: true # si un evento falla, se vuelve a leer ése, no se sigue con el siguiente
Трите вървят заедно:
| Ако липсва… | Какво става |
|---|---|
autoCommitEnable: false |
Kafka потвърждава сама прочетеното и твоето ръчно потвърждаване не променя нищо |
allowManualCommit: true |
Camel не ти дава с какво да потвърдиш (TODO 2 не намира нищо) |
breakOnFirstError: true |
Camel продължава със следващото събитие и като потвърди него, потвърждава и това, което се е провалило |
Точно този последен ред се забравя. Да потвърдиш едно събитие казва на Kafka „дотук прочетох“ в неговия дял: потвърждаването на следващото покрива това, което се е провалило.
TODO 2: запази с какво да потвърдиш
С allowManualCommit Camel оставя в хедъра CamelKafkaManualCommit обекта, който потвърждава това събитие.
Запази го в променлива, като първа стъпка, защото доставката към канала чисти хедърите:
- setVariable:
name: confirmar
expression:
simple:
expression: "${header.CamelKafkaManualCommit}"
TODO 3: потвърди накрая
В края на стъпките, след filter (тоест когато резултатът вече е в Kafka или събитието не е било за
този канал), извикай commit() върху тази променлива. Camel има стъпка, script, която изчислява израз само заради това,
което той прави:
- script:
expression:
simple:
expression: "${variable.confirmar.commit()}"
Преди това — не: потвърденото вече не се чете отново. Повтори трите TODO в другите два моста.
4. Счупи едно нарочно
С твоите три завършени моста премести в този на int-rest script-а от TODO 3 над filter, така че
да потвърждава, преди да достави. Пусни ./verifica.
Преди това предвиди: трите опции още са сложени. Чете ли се отново това, което се е провалило?
Не. Излиза в червено отметката за 6-те операции: рутерът не научава за тези на API-то. Събитието вече беше
потвърдено, когато резултатът му се провали, така че breakOnFirstError се връща към потвърдения offset, който вече е след
него. Опциите казват как се потвърждава; мястото на script казва кога. А важното е именно кога.
Върни го в края.
5. Провери
./verifica
verifica прави три експеримента. В първия залага капана в desenlaces, праща 2001, 2003 и 2004 и
го маха. Във втория спира int-rest, праща 2006, 2008 и 2009, прави API-то бавно (2.5 s на поръчка),
включва int-rest и го убива по средата на една доставка, за да го включи отново. В третия отново залага капана и праща
4002, която е на франчайз и се пада на партньора. Урокът е завършен, когато видиш деветте зелени отметки:
✅ Arrancaron el router, los tres canales con su puente y el sondeo
✅ La 4001 llegó a sus tres canales
✅ Control: la API tiene (…) y el ERP (…) de las 3, y el router no se enteró de ninguna (sus desenlaces no se pudieron escribir)
✅ Kafka volvió a aceptar y el router se enteró de las 6 operaciones: lo que falló se volvió a leer
✅ En la API se creó cada una UNA vez (3 creaciones para 3 órdenes)
✅ Tras matar int-rest, la API tiene las 3 y las 3 operaciones quedaron aceptadas
✅ Cada una se creó UNA vez en la API (…)
✅ Control: el 850 de la 4002 ya está en el socio y el router no se enteró (su desenlace no se pudo escribir)
✅ int-edi releyó la 4002, reconoció su 850 como el mismo y quedó aceptada: un solo 850 en el socio
Третата е контрола: преди да махне капана, verifica проверява, че наистина нещо се е провалило. Ако рутерът вече знаеше за поръчките, четвъртата отметка нямаше да доказва нищо. Осмата е още една контрола — тази на 4002.
Обърни внимание на третата: API-то може да има 1, 2 или 3 от поръчките. С твоята версия събитие, което не може да бъде довършено, спира своя дял: Camel го опитва отново, а това, което идва след него в този дял, чака. Това е цената да не губиш.
Седмата отметка има две форми. Ако прекъсването на int-rest е оставило непотвърдено събитие, int-rest го е прочел отново и
API-то го е разпознало по ключа за идемпотентност (урок 18): отговорило е с 200, не с 201, и не е създало нищо ново. Ако прекъсването е паднало
точно след потвърждаването, не е имало какво да се препрочита. И двете са правилни.
Последните две са на партньора, а тази дестинация няма ключ за идемпотентност: SFTP не презаписва файл, който вече е там
(урок 07), така че второто доставяне на същия 850 се проваля. Този, който го разпознава, е int-edi, който вече идва така в
твоя mio/: ако файлът съществува, го прочита и го сравнява с този, който е щял да остави. Тъй като името и съдържанието
идват от поръчката, включително контролния номер, повторението е идентично: отговаря, че вече е бил там, и операцията
е приета. Ако беше различно, щеше да е конфликт, като в урок 18: отговаря с 409 и не презаписва нищо.
Не тръгва? ./verifica solucion тества нашето решение, а diff -r mio solucion ти казва по какво се различават.
| Какво виждаш | Какво правиш |
|---|---|
Kafka no levantó |
Включи я на ръка с командата от „Преди да започнеш“ |
No arrancaron todas las rutas |
Провери YAML-а на мостовете си: логът, който излиза отдолу, казва кой файл и кой ред |
El router se enteró de … de 6 operaciones: … se perdieron |
Липсва някоя от трите опции от TODO 1 или script не е в края |
Control: esperaba al menos 1 en la API y en el ERP y 0 enteradas en el router |
Ако рутерът все пак е научил, капанът не е бил заложен: пусни verifica отново. Ако API-то има 0, провери дали мостът продължава да доставя |
En la API hubo … creaciones para 3 órdenes |
API-то е създало някоя два пъти: променил ли си ключа, който int-rest му праща? (урок 18) |
La 4002 quedó «…» en el canal del socio |
int-edi не разпознава собствения си 850, когато го препрочита: сравни своя mio/int-edi/int-edi.camel.yaml с този в solucion/ |
Tras matar int-rest, la API tiene … de 3 |
Когато се е върнал, int-rest не е препрочел непотвърденото: провери опциите от TODO 1 в неговия мост |
El puerto 8080 está ocupado |
Услугите от друго пускане са останали вдигнати: DONDE=mio docker compose -f compose.yaml down |
Какво учи това извън курса
„Прочетено“ не е „приключено“. Автоматичното потвърждаване казва първото. Важното е второто, а него го знае само този, който е свършил работата.
Това, което се губи, не винаги е онова, което очакваш. При нашите пускания убиването на консуматора по средата не загуби събития дори с автоматичното потвърждаване: когато се върна, Kafka му даде това, което още не беше потвърдено. Това, което наистина се загуби, беше събитието, чийто резултат не можа да бъде записан. Затова verifica предизвиква и двете.
Да не губиш задължава да търпиш повторения. Ако едно събитие може да бъде прочетено два пъти, получателят трябва да го разпознае. Ключът за идемпотентност от урок 18 е това, което кара този урок да работи. А когато дестинацията не може да разпознае повторение, като папка с файлове, го разпознава каналът: сравнява това, което намира, с това, което е щял да остави.
Да не губиш си има цена. Събитие, което не може да бъде довършено, спира своя дял. Затова мостът оставя
резултат, дори каналът да не отговори (no_se_sabe): доставката я опитва отново рутерът, а не мостът.
Упражнение: разделителят в книгата
- На хартия, за всеки случай кажи дали събитието се губи, повтаря се или минава добре, с автоматично потвърждаване и с твоето: (a) каналът доставя и резултатът се публикува; (b) каналът доставя, а резултатът не може да се публикува; (c) убиват моста, след като е доставил и преди да е публикувал.
- Отвори
mio/orden-router/desenlaces.camel.yaml. Къде потвърждава рутерът? Какво би станало, ако потвърждаваше, преди да запише резултата в базата? - Обясни защо мостът не опитва сам отново доставката, когато каналът не отговаря. (Подсказка: дялът.)
Защо е направено така
Какво решихме в този урок, заедно с това, което отхвърлихме, и какво би ни накарало да си променим мнението:
- Offset-ът се потвърждава на ръка, след като е оставен резултатът, а провалилото се се чете отново
Преговор
- Какво е offset и какво прави автоматичното потвърждаване?
- За какво служи всяка от трите опции от TODO 1?
- Защо
commit()е в края, а не в началото? - Какво пречи на поръчка, прочетена два пъти, да се създаде два пъти в API-то?
- Заключителният въпрос: Kafka не прие резултата на 2001. Обясни какво става с това събитие при автоматично потвърждаване и при твоето и какво струва твоята версия на дяла.
Следва: в урок 30 пролуката е от другата страна: рутерът записва поръчката и после публикува. А ако Kafka е паднала точно в този миг?
Предпочитате имейл? Пишете ни на hola@habil.mx