Izveido darbplūsmu
Šajā lapā
Darbplūsmas loma
Darbplūsma ir tava lietotnes orķestrācijas slānis. Tā definē, kas ir jādara, kādā secībā un ar kādiem nosacījumiem, neveicot pašu darbu. Konkrēti runājot, tā koordinē aktivitātes, gaida ārējus notikumus, pārvalda taimerus un nosacījumu zarus, bet nekad tieši nesazinās ar tīklu vai disku.
To var apkopot vienā frāzē, kas jāpatur prātā, ik reizi pārskatot kodu: aktivitātes veic darbu, darbplūsma to vada. Ja darbplūsmas klasē redzi httpx vai open(), kaut kas ir jāpārvieto.
Darbplūsmas struktūra
Darbplūsma ir Python klase, kas dekorēta ar @workflows.workflow.define(), un tajā ir ievades metode, kas dekorēta ar @workflows.workflow.entrypoint:
import mistralai.workflows as workflows
@workflows.workflow.define(name="mon_premier_workflow")
class MonPremierWorkflow:
@workflows.workflow.entrypoint
async def run(self, nom: str) -> dict:
"""Workflow entry point."""
resultat = await saluer(nom)
return resultat
Dekorators @workflows.workflow.define(name="...") reģistrē klasi kā darbplūsmu. name, ko tā saņem, ir unikālais identifikators, ko izmantosi, lai iedarbinātu izpildi — tieši šī virkne, nevis Python klases nosaukums, ir tas, ko redz izsaucošā puse. Dekorators @workflows.workflow.entrypoint atzīmē metodi, kas tiek izsaukta startēšanas brīdī. Pirmais parametrs self paliek klases instances objekts, tāpat kā jebkurā Python objektā, un katrs aktivitātes izsaukums izmanto await.
Pilns piemērs: apstrādes konveijers
Lūk, reālistiska darbplūsma, kas orķestrē vairākas aktivitātes dokumenta apstrādei. Pievērs uzmanību darba sadalījumam: trīs funkcijas augšdaļā satur visu kodu, kas sazinās ar ārējo pasauli, bet klase apakšdaļā vienkārši savieno await izsaukumus un apkopo rezultātu.
import mistralai.workflows as workflows
from mistralai.client import Mistral
# --- Activities ---
@workflows.activity()
async def extraire_texte(url_document: str) -> dict:
"""Download and extract text from a document."""
async with httpx.AsyncClient() as client:
response = await client.get(url_document)
texte = response.text
return {"texte": texte, "longueur": len(texte)}
@workflows.activity()
async def analyser_avec_mistral(texte: str) -> dict:
"""Analyze text with Mistral to extract key points."""
client = Mistral()
response = await client.chat.complete_async(
model="mistral-large-latest",
messages=[
{"role": "system", "content": "Extract the 5 key points from this text."},
{"role": "user", "content": texte}
]
)
return {"analyse": response.choices[0].message.content}
@workflows.activity()
async def sauvegarder_resultat(analyse: dict) -> dict:
"""Save the analysis result."""
async with httpx.AsyncClient() as client:
response = await client.post(
"https://api.example.com/rapports",
json=analyse
)
return {"id_rapport": response.json()["id"]}
# --- Workflow ---
@workflows.workflow.define(name="pipeline_analyse_document")
class PipelineAnalyseDocument:
@workflows.workflow.entrypoint
async def run(self, url_document: str) -> dict:
"""Orchestrate extraction, analysis, and saving."""
# Step 1: Extract text
extraction = await extraire_texte(url_document)
# Step 2: Analyze with Mistral
analyse = await analyser_avec_mistral(extraction["texte"])
# Step 3: Save
sauvegarde = await sauvegarder_resultat(analyse)
return {
"url_source": url_document,
"longueur_texte": extraction["longueur"],
"id_rapport": sauvegarde["id_rapport"]
}
Katrs await darbplūsmā veido persistences punktu. Ir vērts to garīgi pārbaudīt, izmantojot iepriekš minēto piemēru: ja process neizdodas starp 2. un 3. soli, dokuments netiks lejupielādēts atkārtoti un modelis netiks izsaukts vēlreiz — tātad nav papildu tokenu izmaksu. Darbplūsma atsāksies tieši saglabāšanas solī.
Darbplūsmas izturība
Darbplūsmas izdzīvo pēc restartiem, infrastruktūras kļūmēm un pārejošām kļūdām, jo platforma reģistrē katru notikumu un atjauno darbplūsmas stāvokli atkārtošanas laikā. Šī rekonstrukcija ir uzticama tikai ar vienu nosacījumu, kas minēts iepriekš: darbplūsmas kodam vienmēr ir jārada viena un tā pati operāciju secība vienādām ievadēm. Tas ir determinisma ierobežojums. Mēs aplūkosim detaļas 8. nodarbībā.
Darbplūsma ar nosacījumu zariem
Darbplūsma nav ierobežota tikai ar lineāru secību. Tā var saturēt nosacījuma loģiku, kā šajā pasūtījumu apstrādes piemērā, kur ceļš ir atkarīgs no krājumu statusa:
@workflows.workflow.define(name="traitement_commande")
class OrderProcessing:
@workflows.workflow.entrypoint
async def run(self, order: dict) -> dict:
# Check stock
stock = await check_stock(order["produit_id"])
if stock["disponible"]:
# Standard path
payment = await process_payment(order["montant"])
shipment = await prepare_shipment(order)
await send_confirmation(order["email"], shipment)
return {"status": "confirmée", "tracking": shipment["tracking"]}
else:
# Alternative path
await notify_stockout(order["email"], order["produit_id"])
return {"status": "rupture_stock"}
if/else zari ir pilnībā atbalstīti. Vienīgais ierobežojums attiecas uz materiālu, ko izmanto lēmuma pieņemšanai: zara iznākumam ir jābūt atkarīgam no aktivitātes atgrieztās vērtības — vērtības, kas reģistrēta žurnālā un atkārtošanas laikā identiska, — nevis no tieša ārēja servisa izsaukuma darbplūsmas ietvaros. Šeit verifier_stock vaicā krājumus aktivitātes ietvaros, un if priekšraksts nolas tikai vārdnīcu, kas jau ir saglabāta.
Ievades, izmantojot Pydantic
Darbplūsma, kas pieņem sešus pozicionālos parametrus, ātri kļūst nelasāma. Strukturētām ievadēm izmanto Pydantic modeļus, kas nodrošina arī tipu validāciju izpildes sākumā:
from pydantic import BaseModel
class ReportParams(BaseModel):
report_type: str
include_details: bool = False
start_date: str
end_date: str
@workflows.workflow.define(name="generation_rapport")
class ReportGeneration:
@workflows.workflow.entrypoint
async def run(self, params: ReportParams) -> dict:
data = await collect_data(params.report_type, params.start_date, params.end_date)
if params.include_details:
data = await enrich_data(data)
report = await generate_pdf_report(data)
return {"url_rapport": report["url"]}
Viens piesardzības punkts, iedarbinot šo darbplūsmu: kad izmanto BaseModel, lauki kļūst par augšējā līmeņa atslēgām JSON ievadē, kas tiek nosūtīta darbplūsmai. Tu nosūtīsi {"type_rapport": ..., "date_debut": ...}, nevis objektu, kas ligzdots zem params atslēgas.
Labākā prakse
Četri ieradumi ilgtermiņā rada lielu atšķirību. Pirmkārt, ievēro vienu atbildību vienā darbplūsmā: rēķinu izrakstīšanas un pārdošanas pēcpārbaudes sajaukšana vienā klasē padara neiespējamu vienas procesa daļas atkārtošanu bez otras. Tālāk, pievērs uzmanību nosaukumiem, jo darbplūsmas name ir publisks identifikators, ko izsauc citas sistēmas — "traitement_commande" ir uzturams, "workflow_1" nav. Neievieš nekādas I/O operācijas darbplūsmā: katrs tīkla izsaukums, faila piekļuve vai datubāzes vaicājums pieder aktivitātei. Visbeidzot, uzturi darbplūsmas kodu vienkāršu, nododot sarežģītu loģiku — parsēšanu, transformācijas, smagus aprēķinus — aktivitātēm, kur to var testēt izolēti bez determinisma ierobežojumiem.
Galvenās atziņas
- Darbplūsma ir klase, kas dekorēta ar
@workflows.workflow.define()un orķestrē aktivitātes - Metode
@workflows.workflow.entrypointir ievades punkts, ko izsauc startēšanas brīdī - Katrs aktivitātes
awaitir persistences punkts (automātiska atsākšana kļūdas gadījumā) - Nosacījumu zari un cikli ir atbalstīti
- Strukturētiem ievades parametriem izmanto Pydantic modeļus
- Darbplūsmā nedrīkst būt tiešas I/O operācijas