Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Noteikums par determinismu

Nodarbība 8 no 14 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. Kāpēc determinisms ir obligāts
  2. Kā tas izskatās kodā
  3. SDK aizstājējfunkcijas
  4. Robeža, kas jāatceras
  5. Nedeterminisma kļūdas diagnosticēšana
  6. Galvenās atziņas

Kāpēc determinisms ir obligāts

Determinisms ir vissvarīgākais ierobežojums Mistral darbplūsmās, un tas tieši izriet no atkārtošanas mehānisma, ko iepriekš apguvi. Kad strādnieks atsāk pārtrauktu darbplūsmu, tas no jauna izpilda darbplūsmas kodu no paša sākuma un salīdzina operāciju pēc operācijas to, ko rada kods, ar to, kas ierakstīts žurnāla vēsturē. Kamēr abas secības sakrīt, atsākšana paliek nemanāma. Tiklīdz tās atšķiras, platformai nav iespējas noteikt, kur tā apstājās: tā konstatē neatbilstību un pārtrauc darbplūsmu ar nedeterminisma kļūdu.

Praksē deterministiska darbplūsma katru reizi, kad tā tiek palaista ar vienādām ievades vērtībām, ģenerē pilnīgi identisku operāciju secību. Pievērs uzmanību niansei: aktivitāšu rezultāti var atšķirties starp izpildēm, jo tie nāk no žurnāla. Tieši izsaukumu secībai ir jāpaliek nemainīgai.

Kā tas izskatās kodā

Apskatīsim darbplūsmu, kas nosūta lietotājam ziņojumu, pamatojoties uz viņa abonementa statusu.

@workflows.workflow.define(name="deterministic_workflow")
class DeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # Vienmēr viena un tā pati izsaukumu secība vienādai ievadei
        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"}

Šī darbplūsma ir deterministiska, lai gan tajā ir zarojums. Iemesls slēpjas nosacījuma avotā: profile["premium"] nāk no aktivitātes rezultāta, tātad no žurnāla. Atkārtošanas laikā get_profile atgriež tieši tādu pašu vērtību kā pirmās izpildes reizē, un tiek izvēlēts tas pats ceļš.

Tagad salīdzini to ar šo versiju, kas izskatās nekaitīga, bet sabojā visu.

import datetime
import random

@workflows.workflow.define(name="non_deterministic_workflow")
class NonDeterministicWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, user_id: str) -> dict:
        # AIZLIEGTS: datetime.now() mainās katrā izpildē
        if datetime.datetime.now().hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # AIZLIEGTS: random.random() katru reizi dod citu rezultātu
        if random.random() > 0.5:
            await send_notification(user_id)
        
        return {"status": "completed"}

Iedomājies, ka strādnieks sabojājas plkst. 11:58 un restartējas plkst. 12:03. Atkārtošanas laikā datetime.now() atgriež pēcpusdienas laiku, savukārt vēsturē ir ieraksts par izsaukumu send_morning_email. Darbplūsma neizdodas. random.random() rada tādu pašu efektu, tikai to ir grūtāk diagnosticēt.

SDK aizstājējfunkcijas

SDK ne tikai aizliedz šos izsaukumus, bet arī nodrošina deterministiskus ekvivalentus trim visbiežāk sastopamajām operācijām.

from mistralai.workflows import workflow

# Iegūt pašreizējo laiku (deterministisks atkārtošanas laikā)
current_time = workflow.now()          # Vietā datetime.now()

# Ģenerēt unikālu ID (deterministisks atkārtošanas laikā)
request_id = workflow.uuid4()          # Vietā uuid.uuid4()

# Iegūt nejaušu skaitli (deterministisks atkārtošanas laikā)
rand_value = workflow.random()         # Vietā random.random()

Princips ir tāds pats kā aktivitātēm: vērtība tiek aprēķināta un ierakstīta žurnālā pirmās izpildes reizē, bet pēc tam vienkārši atkārtota. Iepriekšējais piemērs tad kļūst pilnīgi drošs.

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:
        # PAREIZI: workflow.now() ir deterministisks atkārtošanas laikā
        current_hour = workflow.now()
        if current_hour.hour < 12:
            await send_morning_email(user_id)
        else:
            await send_afternoon_email(user_id)
        
        # PAREIZI: workflow.random() ir deterministisks atkārtošanas laikā
        if workflow.random() > 0.5:
            await send_notification(user_id)
        
        # PAREIZI: workflow.uuid4() ir deterministisks atkārtošanas laikā
        trace_id = workflow.uuid4()
        await log_trace(str(trace_id), user_id)
        
        return {"status": "completed", "trace_id": str(trace_id)}

Robeža, kas jāatceras

Darbplūsmas kodā ir aizliegti šādi elementi: datetime.now(), datetime.utcnow() un time.time(); uuid.uuid4() un uuid.uuid1(); random.random(), random.randint() un random.choice(); jebkurš tiešs tīkla izsaukums (httpx, aiohttp, requests); jebkura faila lasīšana vai rakstīšana (open(), aiofiles); jebkura datubāzes piekļuve; os.environ, jo vides mainīgie var mainīties starp atkārtošanām; un visbeidzot threading un multiprocessing, jo platforma pati nodrošina iekšējo paralēlismu.

Viss, ko var reproducēt, paliek atļauts: aktivitāšu izsaukšana, izmantojot await, workflow.now(), workflow.uuid4() un workflow.random() lietošana, nosacījumu loģikas vai ciklu rakstīšana, kuru nosacījumi ir atkarīgi no aktivitāšu rezultātiem, datu apstrāde atmiņā (aprēķini, virknes) un žurnālu rakstīšana — žurnālu veidošana tiek uzskatīta par pieņemamu blakusefektu.

Nedeterminisma kļūdas diagnosticēšana

Kad rodas šī kļūda, parasti pietiek ar četrām pārbaudēm, lai to lokalizētu.

  1. Nedeterministisku izsaukumu klātbūtne — Meklē kodā datetime.now, uuid.uuid4, random.random
  2. Tieša I/O — Jebkuram tīkla vai faila izsaukumam ir jāatrodas aktivitātē
  3. Vides mainīgie — Ja zarošanai izmanto os.environ, pārvieto lasīšanu uz aktivitāti
  4. Trešo pušu bibliotēkas — Dažas bibliotēkas veic tīkla izsaukumus vai iekšēji izmanto nejaušību

Šis pēdējais punkts ir visviltīgākais: serializācijas bibliotēka, kas kārto datus pēc nejauši ģenerēta ID, vai HTTP klients, kas tiek inicializēts moduļa ielādes brīdī, var izraisīt atkārtošanas kļūdu, lai gan tavā darbplūsmā nav nevienas aizdomīgas rindiņas.

Visefektīvākā aizsardzība ir uzturēt darbplūsmu pēc iespējas vienkāršāku un visu sarežģīto loģiku pārvietot uz aktivitātēm. Darbplūsmai, kas vienkārši savieno trīs izsaukumus, mehāniski nav iespējas kļūt nedeterministiskai.

# LABĀKĀ PRAKSE: vienkārša darbplūsma, loģika aktivitātēs
@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

Galvenās atziņas

  • Darbplūsmas kodam ir jābūt deterministiskam: vienāda ievade = vienāda operāciju secība
  • Standarta Python ekvivalentu vietā izmanto workflow.now(), workflow.uuid4(), workflow.random()
  • Visām I/O operācijām (tīkls, fails, DB) ir jāatrodas aktivitātē, nekad darbplūsmā
  • Nosacījumu zarojumi ir atļauti, ja tie ir atkarīgi no aktivitāšu rezultātiem
  • Determinisma pārkāpums izraisa darbplūsmas kļūmi atkārtošanas laikā
  • Ja rodas šaubas, pārvieto loģiku uz aktivitāti