Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Regeln om determinism

Lektion 8 av 14 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Varför determinism är obligatoriskt
  2. Hur detta ser ut i kod
  3. SDK-ersättningar
  4. Gränsen att komma ihåg
  5. Diagnostisera ett fel om icke-determinism
  6. Viktiga punkter

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.

  1. Förekomst av icke-deterministiska anrop – Sök efter datetime.now, uuid.uuid4, random.random i arbetsflödeskoden
  2. Direkt I/O – Alla nätverks- eller filanrop måste finnas i en aktivitet
  3. Miljövariabler – Om du använder os.environ för förgrening, flytta läsningen till en aktivitet
  4. 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