Към съдържанието
Съдържание на курса

Урок 29 — Без загуби при консумиране

От · съосновател и 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. Предвиди

Отговори на лист хартия:

  1. API-то получи поръчка 2001 и отговори с 201 на int-rest, но Kafka не прие резултата, който int-rest се опита да публикува. При автоматичното потвърждаване научава ли рутерът, че 2001 е пристигнала? Чете ли някой отново това събитие?
  2. Ако потвърждаваш offset-а едва накрая и убият int-rest, след като е доставил, но преди да е потвърдил, какво става, когато се върне? Създава ли се 2001 два пъти в API-то? (Подсказка: урок 18.)
  3. Ако едно събитие не може да бъде довършено никога, какво става с тези, които идват след него в неговия дял?

Виж какво е положението днес:

./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): доставката я опитва отново рутерът, а не мостът.

Упражнение: разделителят в книгата

  1. На хартия, за всеки случай кажи дали събитието се губи, повтаря се или минава добре, с автоматично потвърждаване и с твоето: (a) каналът доставя и резултатът се публикува; (b) каналът доставя, а резултатът не може да се публикува; (c) убиват моста, след като е доставил и преди да е публикувал.
  2. Отвори mio/orden-router/desenlaces.camel.yaml. Къде потвърждава рутерът? Какво би станало, ако потвърждаваше, преди да запише резултата в базата?
  3. Обясни защо мостът не опитва сам отново доставката, когато каналът не отговаря. (Подсказка: дялът.)

Защо е направено така

Какво решихме в този урок, заедно с това, което отхвърлихме, и какво би ни накарало да си променим мнението:

  • Offset-ът се потвърждава на ръка, след като е оставен резултатът, а провалилото се се чете отново

Преговор

  1. Какво е offset и какво прави автоматичното потвърждаване?
  2. За какво служи всяка от трите опции от TODO 1?
  3. Защо commit() е в края, а не в началото?
  4. Какво пречи на поръчка, прочетена два пъти, да се създаде два пъти в API-то?
  5. Заключителният въпрос: Kafka не прие резултата на 2001. Обясни какво става с това събитие при автоматично потвърждаване и при твоето и какво струва твоята версия на дяла.

Следва: в урок 30 пролуката е от другата страна: рутерът записва поръчката и после публикува. А ако Kafka е паднала точно в този миг?

Да обсъдим вашия проект

Предпочитате имейл? Пишете ни на hola@habil.mx