Determinismereglen
På denne side
Hvorfor determinisme er obligatorisk
Determinisme er den vigtigste begrænsning i Mistral-workflows, og det stammer direkte fra replay-mekanismen, du lærte om tidligere. Når en worker genoptager et afbrudt workflow, afspiller den workflow-koden fra begyndelsen og sammenligner operation for operation det, koden producerer, med det, historikloggen har registreret. Så længe de to sekvenser matcher, er genoptagelsen usynlig. I det øjeblik de divergerer, har platformen ingen måde at vide, hvor den slap: den registrerer inkonsistensen og får workflowet til at fejle med en ikke-determinisme-fejl.
I praksis producerer et deterministisk workflow præcis den samme sekvens af operationer hver gang, det kører med de samme input. Bemærk nuancen: aktivitetsresultater kan variere mellem eksekveringer, da de kommer fra journalen. Det er rækkefølgen af kald, der skal forblive identisk.
Hvordan dette ser ud i kode
Overvej et workflow, der sender en rapport til en bruger baseret på deres abonnementsstatus.
@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
@workflows.workflow.entrypoint
async def run(self, user_id: str) -> dict:
# Altid samme kaldsekvens for samme 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"}
Dette workflow er deterministisk, selvom det indeholder en forgrening. Årsagen ligger i kilden til betingelsen: profile["premium"] kommer fra et aktivitetsresultat, så det kommer fra journalen. Under replay returnerer get_profile præcis den samme værdi som den første eksekvering, og den samme sti følges.
Sammenlign nu det med denne version, som ser uskadelig ud, men ødelægger alt.
import datetime
import random
@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
@workflows.workflow.entrypoint
async def run(self, user_id: str) -> dict:
# FORBUDT: datetime.now() ændrer sig ved hver eksekvering
if datetime.datetime.now().hour < 12:
await send_morning_email(user_id)
else:
await send_afternoon_email(user_id)
# FORBUDT: random.random() giver et andet resultat hver gang
if random.random() > 0.5:
await send_notification(user_id)
return {"status": "completed"}
Forestil dig, at workeren crascher kl. 11:58 og genstarter kl. 12:03. Ved replay returnerer datetime.now() et tidspunkt om eftermiddagen, mens historikken indeholder et kald til send_morning_email. Workflowet fejler. random.random() producerer den samme effekt, blot sværere at diagnosticere.
SDK-erstatninger
SDK’et forbyder ikke blot disse kald; det leverer deterministiske alternativer til de tre mest almindelige operationer.
from mistralai.workflows import workflow
# Hent nuværende tid (deterministisk under replay)
current_time = workflow.now() # I stedet for datetime.now()
# Generer et unikt ID (deterministisk under replay)
request_id = workflow.uuid4() # I stedet for uuid.uuid4()
# Hent et tilfældigt tal (deterministisk under replay)
rand_value = workflow.random() # I stedet for random.random()
Princippet er det samme som for aktiviteter: værdien beregnes og registreres i journalen ved den første eksekvering og derefter blot afspillet bagefter. Det tidligere eksempel bliver dermed helt sikkert.
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:
# KORREKT: workflow.now() er deterministisk under replay
current_hour = workflow.now()
if current_hour.hour < 12:
await send_morning_email(user_id)
else:
await send_afternoon_email(user_id)
# KORREKT: workflow.random() er deterministisk under replay
if workflow.random() > 0.5:
await send_notification(user_id)
# KORREKT: workflow.uuid4() er deterministisk under replay
trace_id = workflow.uuid4()
await log_trace(str(trace_id), user_id)
return {"status": "completed", "trace_id": str(trace_id)}
Grænsen du skal huske
Følgende er forbudt i workflow-kode: datetime.now(), datetime.utcnow() og time.time(); uuid.uuid4() og uuid.uuid1(); random.random(), random.randint() og random.choice(); ethvert direkte netværkskald (httpx, aiohttp, requests); enhver fil-læsning eller -skrivning (open(), aiofiles); enhver databaseadgang; os.environ, fordi miljøvariabler kan ændre sig mellem replays; og endelig threading og multiprocessing, da platformen håndterer intern parallelisering.
Alt reproducerbart forbliver tilladt: kald af aktiviteter via await, brug af workflow.now(), workflow.uuid4() og workflow.random(), skrivning af betinget logik eller løkker, hvis betingelser afhænger af aktivitetsresultater, manipulering af data i hukommelsen (beregninger, strenge) og logning – logning betragtes som en acceptabel sideeffekt.
Diagnosticering af en ikke-determinisme-fejl
Når fejlen opstår, er fire tjek normalt nok til at finde den.
- Tilstedeværelse af ikke-deterministiske kald — Søg efter
datetime.now,uuid.uuid4,random.randomi workflow-koden - Direkte I/O — Ethvert netværks- eller filkald skal bo i en aktivitet
- Miljøvariabler — Hvis du bruger
os.environtil forgrening, så flyt læsningen ind i en aktivitet - Tredjepartsbiblioteker — Nogle biblioteker foretager netværkskald eller bruger tilfældighed internt
Dette sidste punkt er det mest snigende: et serialiseringsbibliotek, der sorterer efter et tilfældigt genereret ID, eller en HTTP-klient instantieret ved modulindlæsning, kan få et replay til at fejle uden en eneste mistænkelig linje i dit workflow.
Det mest effektive forsvar er at holde workflowet så slankt som muligt og skubbe al kompleks logik ind i aktiviteter. Et workflow, der blot kæder tre kald sammen, har mekanisk set ingen mulighed for at være ikke-deterministisk.
# BEDSTE PRAKSIS: simpelt workflow, logik i aktiviteter
@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
Vigtige pointer
- Workflow-kode skal være deterministisk: samme input = samme operationsekvens
- Brug
workflow.now(),workflow.uuid4(),workflow.random()i stedet for standard Python-modstykker - Alle I/O-operationer (netværk, fil, DB) skal bo i en aktivitet, aldrig i workflowet
- Betingede forgreninger er tilladt, hvis de afhænger af aktivitetsresultater
- En overtrædelse af determinismen får workflowet til at fejle under replay
- Hvis du er i tvivl, så flyt logikken ind i en aktivitet