Regeln om determinism
På denna sida
Varför determinism är obligatoriskt
Determinism är den viktigaste begränsningen i Mistral-arbetsflöden, och den härrör direkt från den uppspelningsmekanism du lärde dig om tidigare. När en arbetare återupptar ett avbrutet arbetsflöde spelar den upp arbetsflödeskoden från början och jämför, operation för operation, vad koden producerar mot vad historikloggen registrerade. Så länge de två sekvenserna matchar är återupptagandet osynligt. I det ögonblick de skiljer sig åt har plattformen inget sätt att veta var den slutade: den upptäcker inkonsistensen och misslyckas med arbetsflödet med ett fel om icke-determinism.
I praktiken producerar ett deterministiskt arbetsflöde exakt samma sekvens av operationer varje gång det körs med samma indata. Notera nyansen: aktivitetsresultat kan variera mellan körningar eftersom de kommer från journalen. Det är ordningen på anropen som måste förbli identisk.
Hur detta ser ut i kod
Tänk dig ett arbetsflöde som skickar en rapport till en användare baserat på dennes prenumerationsstatus.
@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
@workflows.workflow.entrypoint
async def run(self, user_id: str) -> dict:
# Alltid samma anropssekvens för samma indata
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"}
Detta arbetsflöde är deterministiskt även om det innehåller en förgrening. Anledningen ligger i villkorets källa: profile["premium"] kommer från ett aktivitetsresultat, så det kommer från journalen. Under uppspelning returnerar get_profile exakt samma värde som vid den första körningen, och samma väg tas.
Jämför nu detta med denna version, som ser ofarlig ut men som förstör allt.
import datetime
import random
@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
@workflows.workflow.entrypoint
async def run(self, user_id: str) -> dict:
# FÖRBJUDET: datetime.now() ändras vid varje körning
if datetime.datetime.now().hour < 12:
await send_morning_email(user_id)
else:
await send_afternoon_email(user_id)
# FÖRBJUDET: random.random() ger ett annat resultat varje gång
if random.random() > 0.5:
await send_notification(user_id)
return {"status": "completed"}
Föreställ dig att arbetaren kraschar kl. 11:58 och startar om kl. 12:03. Vid uppspelning returnerar datetime.now() en eftermiddagstid medan historiken innehåller ett anrop till send_morning_email. Arbetsflödet misslyckas. random.random() ger samma effekt, bara svårare att diagnostisera.
SDK-ersättningar
SDK:n förbjuder inte bara dessa anrop; den tillhandahåller deterministiska motsvarigheter för de tre vanligaste operationerna.
from mistralai.workflows import workflow
# Hämta aktuell tid (deterministisk under uppspelning)
current_time = workflow.now() # Istället för datetime.now()
# Generera ett unikt ID (deterministiskt under uppspelning)
request_id = workflow.uuid4() # Istället för uuid.uuid4()
# Hämta ett slumptal (deterministiskt under uppspelning)
rand_value = workflow.random() # Istället för random.random()
Principen är densamma som för aktiviteter: värdet beräknas och registreras i journalen vid den första körningen, för att sedan helt enkelt spelas upp efteråt. Det tidigare exemplet blir då helt säkert.
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() är deterministisk under uppspelning
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() är deterministisk under uppspelning
if workflow.random() > 0.5:
await send_notification(user_id)
# KORREKT: workflow.uuid4() är deterministisk under uppspelning
trace_id = workflow.uuid4()
await log_trace(str(trace_id), user_id)
return {"status": "completed", "trace_id": str(trace_id)}
Gränsen att komma ihåg
Följande är förbjudna i arbetsflödeskod: datetime.now(), datetime.utcnow() och time.time(); uuid.uuid4() och uuid.uuid1(); random.random(), random.randint() och random.choice(); alla direkta nätverksanrop (httpx, aiohttp, requests); alla fil läs- eller skrivoperationer (open(), aiofiles); all databåtkomst; os.environ, eftersom miljövariabler kan ändras mellan uppspelningar; och slutligen threading och multiprocessing, eftersom plattformen hanterar intern parallellism.
Allt som är reproducerbart förblir tillåtet: anropa aktiviteter via await, använda workflow.now(), workflow.uuid4() och workflow.random(), skriva villkorslogik eller loopar vars villkor beror på aktivitetsresultat, manipulera data i minnet (beräkningar, strängar) och loggning – loggning anses vara en acceptabel sidoeffekt.
Diagnostisera ett fel om icke-determinism
När felet inträffar räcker det oftast med fyra kontroller för att lokalisera det.
- Förekomst av icke-deterministiska anrop – Sök efter
datetime.now,uuid.uuid4,random.randomi arbetsflödeskoden - Direkt I/O – Alla nätverks- eller filanrop måste finnas i en aktivitet
- Miljövariabler – Om du använder
os.environför förgrening, flytta läsningen till en aktivitet - Tredjepartsbibliotek – Vissa bibliotek gör nätverksanrop eller använder slumpmässighet internt
Denna sista punkt är den mest lömska: ett serialiseringsbibliotek som sorterar efter ett slumpmässigt genererat ID, eller en HTTP-klient som initieras vid modulbelastning, kan få en uppspelning att misslyckas utan att en enda misstänkt rad syns i ditt arbetsflöde.
Det mest effektiva försvaret är att hålla arbetsflödet så smalt som möjligt och flytta all komplex logik till aktiviteter. Ett arbetsflöde som helt enkelt kedjar tre anrop har mekaniskt sett ingen möjlighet att vara icke-deterministiskt.
# BÄSTA PRAXIS: enkelt arbetsflöde, 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
Viktiga punkter
- Arbetsflödeskod måste vara deterministisk: samma indata = samma sekvens av operationer
- Använd
workflow.now(),workflow.uuid4(),workflow.random()istället för standard-Python-motsvarigheter - Alla I/O-operationer (nätverk, fil, DB) måste finnas i en aktivitet, aldrig i arbetsflödet
- Villkorliga förgreningar är tillåtna om de beror på aktivitetsresultat
- En överträdelse av determinismen får arbetsflödet att misslyckas under uppspelning
- Vid tveksamhet, flytta logiken till en aktivitet