De regel van determinisme
Op deze pagina
Waarom determinisme verplicht is
Determinisme is de belangrijkste beperking in Mistral-workflows. Dit volgt rechtstreeks uit het replay-mechanisme dat u eerder hebt geleerd. Wanneer een worker een onderbroken workflow hervat, speelt deze de workflow-code vanaf het begin opnieuw af en vergelijkt deze, operatie voor operatie, wat de code produceert met wat het geschiedenislogboek heeft vastgelegd. Zolang de twee reeksen overeenkomen, is de hervatting onzichtbaar. Zodra ze divergeren, heeft het platform geen manier meer om te weten waar het was gebleven: het detecteert de inconsistentie en laat de workflow falen met een non-determinisme-fout.
In de praktijk produceert een deterministische workflow bij elke uitvoering met dezelfde inputs exact dezelfde reeks operaties. Let op de nuance: activiteitsresultaten kunnen variëren tussen uitvoeringen omdat ze uit het logboek komen. Het is de volgorde van aanroepen die identiek moet blijven.
Hoe dit eruitziet in code
Neem een workflow die een rapport naar een gebruiker stuurt op basis van hun abonnementsstatus.
@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
@workflows.workflow.entrypoint
async def run(self, user_id: str) -> dict:
# Altijd dezelfde volgorde van aanroepen voor dezelfde input
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"}
Deze workflow is deterministisch, ook al bevat deze een vertakking. De reden ligt in de bron van de voorwaarde: profile["premium"] komt uit een activiteitsresultaat en dus uit het logboek. Tijdens replay geeft get_profile exact dezelfde waarde terug als bij de eerste uitvoering, waardoor hetzelfde pad wordt gevolgd.
Vergelijk dit nu met deze versie, die onschuldig lijkt maar alles laat mislukken.
import datetime
import random
@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
@workflows.workflow.entrypoint
async def run(self, user_id: str) -> dict:
# VERBODEN: datetime.now() verandert bij elke uitvoering
if datetime.datetime.now().hour < 12:
await send_morning_email(user_id)
else:
await send_afternoon_email(user_id)
# VERBODEN: random.random() levert elke keer een ander resultaat op
if random.random() > 0.5:
await send_notification(user_id)
return {"status": "completed"}
Stel dat de worker crasht om 11:58 uur en herstart om 12:03 uur. Bij replay geeft datetime.now() een middagtijd terug, terwijl de geschiedenis een aanroep naar send_morning_email bevat. De workflow faalt. random.random() heeft hetzelfde effect, alleen is dit moeilijker te diagnosticeren.
Vervangingen in de SDK
De SDK verbiedt deze aanroepen niet alleen; deze biedt deterministische equivalenten voor de drie meest voorkomende bewerkingen.
from mistralai.workflows import workflow
# Huidige tijd ophalen (deterministisch tijdens replay)
current_time = workflow.now() # In plaats van datetime.now()
# Een unieke ID genereren (deterministisch tijdens replay)
request_id = workflow.uuid4() # In plaats van uuid.uuid4()
# Een willekeurig getal ophalen (deterministisch tijdens replay)
rand_value = workflow.random() # In plaats van random.random()
Het principe is hetzelfde als bij activiteiten: de waarde wordt berekend en vastgelegd in het logboek bij de eerste uitvoering, en daarna eenvoudigweg afgespeeld. Het vorige voorbeeld wordt dan volkomen veilig.
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:
# CORRECT: workflow.now() is deterministisch tijdens replay
current_hour = workflow.now()
if current_hour.hour < 12:
await send_morning_email(user_id)
else:
await send_afternoon_email(user_id)
# CORRECT: workflow.random() is deterministisch tijdens replay
if workflow.random() > 0.5:
await send_notification(user_id)
# CORRECT: workflow.uuid4() is deterministisch tijdens replay
trace_id = workflow.uuid4()
await log_trace(str(trace_id), user_id)
return {"status": "completed", "trace_id": str(trace_id)}
De grens om te onthouden
Het volgende is verboden in workflow-code: datetime.now(), datetime.utcnow() en time.time(); uuid.uuid4() en uuid.uuid1(); random.random(), random.randint() en random.choice(); elke directe netwerkaanroep (httpx, aiohttp, requests); elk bestand lezen of schrijven (open(), aiofiles); elke database-toegang; os.environ, omdat omgevingsvariabelen kunnen veranderen tussen replays; en tot slot threading en multiprocessing, aangezien het platform interne parallelle verwerking afhandelt.
Alles wat reproduceerbaar is, blijft toegestaan: activiteiten aanroepen via await, gebruikmaken van workflow.now(), workflow.uuid4() en workflow.random(), conditionele logica of lussen schrijven waarvan de voorwaarden afhangen van activiteitsresultaten, gegevens in het geheugen manipuleren (berekeningen, strings) en loggen—loggen wordt beschouwd als een acceptabel neveneffect.
Een non-determinisme-fout diagnosticeren
Wanneer de fout optreedt, volstaan vier controles meestal om de oorzaak te lokaliseren.
- Aanwezigheid van non-deterministische aanroepen — Zoek naar
datetime.now,uuid.uuid4,random.randomin de workflow-code - Directe I/O — Elke netwerk- of bestandsaanroep moet in een activiteit zitten
- Omgevingsvariabelen — Als u
os.environgebruikt voor vertakkingen, verplaats het lezen dan naar een activiteit - Bibliotheken van derden — Sommige bibliotheken doen netwerkaanroepen of gebruiken intern willekeurigheid
Dit laatste punt is het meest verraderlijk: een serialisatiebibliotheek die sorteert op een willekeurig gegenereerde ID, of een HTTP-client die bij het laden van de module wordt geïnstantieerd, kan een replay laten mislukken zonder dat er een enkele verdachte regel in uw workflow verschijnt.
De meest effectieve verdediging is de workflow zo sober mogelijk houden en alle complexe logica naar activiteiten verplaatsen. Een workflow die simpelweg drie aanroepen ketent, heeft mechanisch gezien geen enkele kans om non-deterministisch te zijn.
# BESTE PRAKTIJK: eenvoudige workflow, logica in activiteiten
@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
Belangrijkste punten
- Workflow-code moet deterministisch zijn: dezelfde inputs = dezelfde reeks operaties
- Gebruik
workflow.now(),workflow.uuid4(),workflow.random()in plaats van standaard Python-equivalenten - Alle I/O-bewerkingen (netwerk, bestand, DB) moeten in een activiteit zitten, nooit in de workflow
- Conditionele vertakkingen zijn toegestaan als ze afhangen van activiteitsresultaten
- Een schending van het determinisme zorgt ervoor dat de workflow faalt tijdens replay
- Bij twijfel: verplaats de logica naar een activiteit