Премини към основното съдържание
Български— Изберете език
Меню

Издръжливост и надеждност на работните потоци

Урок 2 от 14 Обновен 29 юли 2026 г. Напреднало
На тази страница
  1. Защо издръжливостта променя всичко
  2. Извличане на събития: Основният принцип
  3. Автоматично възпроизвеждане: Възстановяване от срив
  4. Отказоустойчивост: Покрити сценарии
  5. Ограничението за детерминизъм
  6. Сравнение с традиционните подходи
  7. Точно веднъж: Логическа гаранция
  8. Ключови изводи

Защо издръжливостта променя всичко

Представете си десетстъпков конвейер за обработка на партида фактури: извличане, валидиране, извикване на модел, запис в база данни, известяване. В стандартен Python скрипт срив на стъпка 7 Ви връща обратно на стъпка 1. Първите шест стъпки се изпълняват отново, което създава сериозни проблеми, ако някоя от тях вече е записала данни в база или е изпратила съобщение. При издръжлив работен поток системата възобновява работа точно от стъпка 7. Тя пропуска първите шест стъпки, избягва дублиране на действия и не губи никакви данни.

Тази възможност разчита на специфичен механизъм, наречен извличане на събития (event sourcing). Разбирането на тази концепция е от съществено значение, тъй като тя обяснява ограниченията, с които ще се сблъскате по-късно.

Извличане на събития: Основният принцип

Извличането на събития записва всяко действие на работния поток като неизменяемо събитие в дневник. Разликата спрямо традиционния подход се свежда до едно изречение: вместо да се съхранява само текущото състояние (напр. „в процес на изпълнение, стъпка 7“), платформата пази пълна история на операциите и техните резултати. Изпълнението на работен поток с две дейности оставя следната следа:

  1. Работният поток стартира и получава входни параметри → събитието е записано
  2. Работният поток извиква Дейност А → събитието е записано
  3. Дейност А завършва с резултат → събитието е записано
  4. Работният поток извиква Дейност Б → събитието е записано
  5. Дейност Б завършва → събитието е записано
  6. Работният поток връща крайния си резултат → събитието е записано

Системата запазва всяка стъпка преди да премине към следващата. Няма прозорец от време, в който дадено действие да се случи, без дневникът да знае за него. Този дневник се превръща в единствения източник на истина; състоянието на работния поток не съществува никъде другаде.

Автоматично възпроизвеждане: Възстановяване от срив

Когато даден работник (worker) се срине, нов работник поема задачата, извлича дневника със събития и възпроизвежда кода на работния поток от самото начало. Думата „възпроизвеждане“ често изненадва хората: кодът наистина рестартира от първия ред, но за всяка дейност, която вече е приключила, движъкът не извиква Вашата функция отново. Вместо това той замества изпълнението с записания резултат от дневника. Работният поток напредва със скоростта на четене, докато не достигне първата незавършена дейност. Едва тогава реалната работа се възобновява.

Дейностите, които вече са успешни, никога не се изпълняват повторно по време на възпроизвеждане. Примерът по-долу прави тази гаранция осезаема за най-чувствителния случай: изпращане на имейл.

import mistralai.workflows as workflows

@workflows.activity()
async def send_email(recipient: str, content: str) -> dict:
    """Тази дейност се изпълнява само веднъж,
    дори ако работният поток се възпроизведе многократно."""
    response = await email_service.send(recipient, content)
    return {"status": "sent", "id": response.id}

@workflows.workflow.define(name="notification_workflow")
class NotificationWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, recipient: str) -> dict:
        # Ако работният поток се срине СЛЕД изпращането на имейла,
        # имейлът НЯМА да бъде изпратен отново по време на възпроизвеждането.
        email_result = await send_email(recipient, "Вашият доклад е готов")

        # Работният поток възобновява работа тук
        log_result = await log_notification(recipient, email_result)
        return log_result

Отказоустойчивост: Покрити сценарии

Платформата обработва четири типа инциденти, без да изисква нито един ред код от Ваша страна. Първо, срив на работник: Python процесът спира внезапно поради грешка в паметта, сигнал kill или рестарт на сървъра. Друг работник поема работния поток точно от мястото, където е спрял. Второ, преходна мрежова грешка: API извикване се проваля поради изтичане на времето за изчакване (timeout). Политиката за повторни опити автоматично рестартира дейността с експоненциално забавяне, използвайки нарастващи интервали, за да избегне претоварване на затруднена услуга.

Трето, грешки във Вашия собствен код: изключение, възникнало в дадена дейност, се опитва отново определен брой пъти въз основа на конфигурираната политика, преди да се провали окончателно. Четвърто, временна недостъпност на услуга на трета страна. Ефектът тук е драматичен: ако партньорски API спре за десет минути, Вашият нощен конвейер вече не се проваля. Изчакващите дейности се рестартират, когато услугата се върне, и обработката завършва само с десет минути закъснение.

Ограничението за детерминизъм

Възпроизвеждането има своята цена. За да може възпроизвеждането на дневника вярно да възпроизведе оригиналното изпълнение, кодът на работния поток (не на дейностите) трябва да бъде детерминиран. При едни и същи входни данни той трябва да произведе една и съща последователност от операции. Ако Вашият работен поток се разклонява въз основа на if datetime.now().hour < 12, едно възпроизвеждане тази вечер може да поеме другия клон, което напълно да десинхронизира дневника.

Следователно, никога не трябва да правите следното в кода на работния поток:

  • Използване на datetime.now() → използвайте workflow.now()
  • Използване на uuid.uuid4() → използвайте workflow.uuid4()
  • Използване на random.random() → използвайте workflow.random()
  • Директно извършване на мрежови или I/O извиквания → преместете ги в дейност

Тези три замествания връщат стойности, записани по време на първото преминаване, и ги възпроизвеждат идентично впоследствие. Ще разгледаме подробно това ограничение в Урок 8, който е фокусиран върху детерминизма.

Сравнение с традиционните подходи

ПодходВъзстановяване при сривГаранция за изпълнениеСложност
Обикновен Python скриптНеНикакваНиска
Опашка за съобщения (Celery, RQ)ЧастичноПоне веднъж (At-least-once)Средна
Cron + База данниРъчноЗависи от имплементациятаВисока
Mistral Workflows (Temporal)АвтоматичноТочно веднъж (логическо)Ниска (SDK)

Обърнете специално внимание на колоната за сложност. Опашката за съобщения изглежда проста за стартиране, но нейното частично възстановяване Ви принуждава да пишете логика за управление на състоянието, която SDK предоставя „от кутията“.

Точно веднъж: Логическа гаранция

Платформата гарантира, че логиката на Вашия работен поток се изпълнява точно веднъж. Ако дадена дейност е успешна, системата записва резултата и никога не я изпълнява отново. Ако се провали, системата я опитва отново според конфигурираната политика.

Думата „логическо“ не е просто украса. На мрежово ниво дадено извикване може всъщност да бъде изпратено два пъти: Вашата заявка за създаване на клиент достига до CRM системата, но потвърждението се губи по пътя. От Ваша гледна точка дейността се е провалила и ще бъде опитана отново, въпреки че клиентът вече съществува. Това създава необходимост от идемпотентни дейности, които произвеждат един и същ резултат, дори ако бъдат извикани многократно с едни и същи параметри. На практика това означава да предпочитате PUT върху стабилен идентификатор пред POST, който създава нов ред при всяко извикване.

Ключови изводи

  • Извличането на събития записва всяка стъпка като неизменяемо събитие в дневник
  • Автоматичното възпроизвеждане Ви позволява да възобновите прекъснат работен поток, без да изпълнявате отново завършените дейности
  • Платформата автоматично обработва сривове, мрежови грешки и прекъсвания на услуги
  • Кодът на работния поток трябва да бъде детерминиран, за да работи възпроизвеждането
  • Дейностите трябва да бъдат идемпотентни, за да се осигури съгласуваност при повторни опити
  • Гаранцията за изпълнение е логическо „точно веднъж“