Przejdź do głównej treści
Polski— Wybierz język
Menu

Zasada determinizmu

Lekcja 8 z 14 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Dlaczego determinizm jest obowiązkowy
  2. Jak wygląda to w kodzie
  3. Zamienniki w SDK
  4. Granica, o której musisz pamiętać
  5. Diagnozowanie błędu niedeterminizmu
  6. Kluczowe wnioski

Dlaczego determinizm jest obowiązkowy

Determinizm to najważniejsze ograniczenie w przepływach pracy Mistral, wynikające bezpośrednio z mechanizmu odtwarzania (replay), o którym dowiedziałeś się wcześniej. Gdy worker wznawia przerwany przepływ pracy, wykonuje jego kod od samego początku i porównuje, operacja po operacji, to, co generuje kod, z tym, co zostało zapisane w dzienniku historii. Dopóki obie sekwencje są identyczne, wznowienie jest niewidoczne. W momencie ich rozbieżności platforma nie ma sposobu, by ustalić, na czym stanęła: wykrywa niespójność i kończy przepływ pracy błędem niedeterminizmu.

W praktyce deterministyczny przepływ pracy generuje dokładnie tę samą sekwencję operacji za każdym razem, gdy jest uruchamiany z tymi samymi danymi wejściowymi. Zwróć uwagę na niuans: wyniki aktywności mogą się różnić między wykonaniami, ponieważ pochodzą z dziennika. To kolejność wywołań musi pozostać identyczna.

Jak wygląda to w kodzie

Rozważmy przepływ pracy, który wysyła raport do użytkownika w zależności od statusu jego subskrypcji.

@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # Zawsze ta sama sekwencja wywołań dla tych samych danych wejściowych
        profile = await get_profile(user_id)
        
        if profile["premium"]:
            report = await generate_full_report(user_id)
        else:
            report = await generate_basic_report(user_id)
        
        await send_email(profile["email"], report)
        return {"status": "completed"}

Ten przepływ pracy jest deterministyczny, mimo że zawiera rozgałęzienie. Powód leży w źródle warunku: profile["premium"] pochodzi z wyniku aktywności, a więc z dziennika. Podczas odtwarzania get_profile zwraca dokładnie tę samą wartość co przy pierwszym wykonaniu, dzięki czemu wybierana jest ta sama ścieżka.

Porównaj to teraz z tą wersją, która wygląda nieszkodliwie, ale psuje wszystko.

import datetime
import random

@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # ZABRONIONE: datetime.now() zmienia się przy każdym wykonaniu
        if datetime.datetime.now().hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # ZABRONIONE: random.random() zwraca inny wynik za każdym razem
        if random.random() > 0.5:
            await send_notification(user_id)
        
        return {"status": "completed"}

Wyobraź sobie, że worker awaryjnie kończy pracę o 11:58 i restartuje się o 12:03. Przy odtwarzaniu datetime.now() zwraca czas popołudniowy, podczas gdy historia zawiera wywołanie send_morning_email. Przepływ pracy kończy się niepowodzeniem. random.random() wywołuje ten sam efekt, tylko trudniejszy do zdiagnozowania.

Zamienniki w SDK

SDK nie tylko zabrania tych wywołań, ale dostarcza deterministycznych odpowiedników dla trzech najczęstszych operacji.

from mistralai.workflows import workflow

# Pobranie bieżącego czasu (deterministyczne podczas odtwarzania)
current_time = workflow.now()          # Zamiast datetime.now()

# Generowanie unikalnego ID (deterministyczne podczas odtwarzania)
request_id = workflow.uuid4()          # Zamiast uuid.uuid4()

# Pobranie liczby losowej (deterministyczne podczas odtwarzania)
rand_value = workflow.random()         # Zamiast random.random()

Zasada jest taka sama jak w przypadku aktywności: wartość jest obliczana i zapisywana w dzienniku przy pierwszym wykonaniu, a następnie po prostu odtwarzana później. Poprzedni przykład staje się wtedy całkowicie bezpieczny.

import mistralai.workflows as workflows
from mistralai.workflows import workflow

@workflows.workflow.define(name="fixed_workflow")
class FixedWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # POPRAWNIE: workflow.now() jest deterministyczne podczas odtwarzania
        current_hour = workflow.now()
        if current_hour.hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # POPRAWNIE: workflow.random() jest deterministyczne podczas odtwarzania
        if workflow.random() > 0.5:
            await send_notification(user_id)
        
        # POPRAWNIE: workflow.uuid4() jest deterministyczne podczas odtwarzania
        trace_id = workflow.uuid4()
        await log_trace(str(trace_id), user_id)
        
        return {"status": "completed", "trace_id": str(trace_id)}

Granica, o której musisz pamiętać

W kodzie przepływu pracy zabronione są następujące elementy: datetime.now(), datetime.utcnow() i time.time(); uuid.uuid4() i uuid.uuid1(); random.random(), random.randint() i random.choice(); wszelkie bezpośrednie wywołania sieciowe (httpx, aiohttp, requests); wszelkie operacje odczytu lub zapisu plików (open(), aiofiles); wszelki dostęp do bazy danych; os.environ, ponieważ zmienne środowiskowe mogą zmieniać się między odtworzeniami; oraz wreszcie threading i multiprocessing, ponieważ platforma obsługuje wewnętrzny paralelizm.

Wszystko, co jest odtwarzalne, pozostaje dozwolone: wywoływanie aktywności przez await, używanie workflow.now(), workflow.uuid4() i workflow.random(), stosowanie logiki warunkowej lub pętli, których warunki zależą od wyników aktywności, manipulowanie danymi w pamięci (obliczenia, ciągi znaków) oraz logowanie – logowanie jest uznawane za akceptowalny efekt uboczny.

Diagnozowanie błędu niedeterminizmu

Gdy wystąpi błąd, zazwyczaj wystarczą cztery kroki, aby go zlokalizować.

  1. Obecność wywołań niedeterministycznych — Wyszukaj w kodzie przepływu pracy fragmentów datetime.now, uuid.uuid4, random.random.
  2. Bezpośrednie operacje I/O — Każde wywołanie sieciowe lub plikowe musi znajdować się w aktywności.
  3. Zmienne środowiskowe — Jeśli używasz os.environ do tworzenia rozgałęzień, przenieś odczyt do aktywności.
  4. Biblioteki zewnętrzne — Niektóre biblioteki wykonują wewnętrznie wywołania sieciowe lub używają losowości.

Ten ostatni punkt jest najbardziej podstępny: biblioteka serializująca, która sortuje dane według losowo generowanego ID, lub klient HTTP instancjonowany podczas ładowania modułu, mogą spowodować niepowodzenie odtwarzania, nawet jeśli w Twoim przepływie pracy nie ani jednej podejrzanej linii.

Najskuteczniejszą obroną jest utrzymanie przepływu pracy w jak najprostszej formie i przenoszenie całej złożonej logiki do aktywności. Przepływ pracy, który po prostu łączy trzy wywołania, mechanicznie nie ma możliwości bycia niedeterministycznym.

# DOBRA PRAKTYKA: prosty przepływ pracy, logika w aktywnościach
@workflows.workflow.define(name="simple_pipeline")
class SimplePipeline:
    @workflows.workflow.entrypoint
    async def run(self, params: dict) -> dict:
        step1 = await prepare_data(params)
        step2 = await process_data(step1)
        step3 = await finalize(step2)
        return step3

Kluczowe wnioski

  • Kod przepływu pracy musi być deterministyczny: te same dane wejściowe = ta sama sekwencja operacji.
  • Używaj workflow.now(), workflow.uuid4(), workflow.random() zamiast standardowych odpowiedników w Pythonie.
  • Wszystkie operacje I/O (sieć, pliki, baza danych) muszą znajdować się w aktywności, nigdy w przepływie pracy.
  • Rozgałęzienia warunkowe są dozwolone, jeśli zależą od wyników aktywności.
  • Naruszenie determinizmu powoduje niepowodzenie przepływu pracy podczas odtwarzania.
  • W razie wątpliwości przenieś logikę do aktywności.