Begrænsninger i platformen
På denne side
Kend begrænsningerne
Mistral Workflows-platformen befinder sig i Public Preview (pr. april 2026). Som ethvert orkestreringssystem indebærer den tekniske begrænsninger, som du skal forstå for at designe robuste workflows. Disse grænser er ikke blot fodnoter i dokumentationen; de viser sig i produktionen, ofte sent i forløbet, som serialiseringsfejl eller workflows, der afbrydes uventet uden advarsel i din kode. At kende dem på forhånd ændrer måden, du strukturerer din behandlingslogik på.
Tabellen nedenfor opsummerer de vigtigste begrænsninger og den konkrete konsekvens af at overskride hver enkelt.
| Begrænsning | Værdi | Konsekvens ved overskridelse |
|---|---|---|
| Forsinkelse mellem aktiviteter | 2 sekunder | Undgåelig ventetid mellem hvert aktivitetskald |
| Input/output pr. kald | 2 MB | Serialiseringsfejl, workflow fejler |
| Hændelser pr. kørsel | 51.200 | Workflow tvangsafbrydes |
| Samlet størrelse pr. kørsel | 50 MB | Workflow tvangsafbrydes |
| Standard timeout | 1 time | Workflow annulleres (kan konfigureres op til 7 dage) |
| Maksimal timeout | 7 dage | Workflow annulleres automatisk |
| I/O i workflows | Forbudt | Fejl vedrørende ikke-determinisme under replay |
To sekunder mellem hver aktivitet
Platformen håndhæver en minimumsforsinkelse på 2 sekunder mellem aktivitetskald. Denne ventetid er ikke et børnesygdomsproblem; den er iboende i orkestreringsarkitekturen, som persisterer hver hændelse, før den fortsætter. Det er prisen for holdbarhed.
Påvirkningen er let at beregne og ofte overraskende. Et workflow, der kæder ti sekventielle aktiviteter sammen, bruger mindst tyve sekunder på orkestreringstid, uanset hvor længe aktiviteterne selv tager. Hvis hver aktivitet kører på halvtreds millisekunder, har du designet et halvsekunds-job, der tager tyve sekunder om at returnere et resultat.
Løsningen er at bundte operationer, der ikke behøver være separate, ind i en enkelt aktivitet. Sammenlign disse to versioner af samme NLP-pipeline.
# SUBOPTIMAL: 3 aktiviteter = 6 sekunders orkestreringsventetid
@workflows.workflow.define(name="pipeline_lent")
class SlowPipeline:
@workflows.workflow.entrypoint
async def run(self, text: str) -> dict:
tokens = await tokenize(text)
embeddings = await calculate_embeddings(tokens)
clusters = await cluster(embeddings)
return clusters
# OPTIMERET: 1 aktivitet = 2 sekunders orkestreringsventetid
@workflows.activity()
async def complete_nlp_processing(text: str) -> dict:
tokens = tokenize_local(text)
embeddings = calculate_embeddings_local(tokens)
clusters = cluster_local(embeddings)
return {"clusters": clusters}
@workflows.workflow.define(name="pipeline_rapide")
class FastPipeline:
@workflows.workflow.entrypoint
async def run(self, text: str) -> dict:
return await complete_nlp_processing(text)
Reglen for opdeling bliver simpel: Opret kun en separat aktivitet, hvis du har brug for garantien for persistens mellem to operationer. Hvis to operationer kan fejle sammen uden at skabe problemer – som lokal tokenisering og beregning af embeddings kædet sammen i hukommelsen – så bundt dem.
To megabyte pr. kald
Hvert aktivitetskald er begrænset til 2 MB for input og 2 MB for output, baseret på den serialiserede JSON-repræsentation af dataene. En PDF-rapport, et sæt billeder eller en stor CSV-eksport vil nemt overskride dette, hvilket får workflowet til at fejle med en serialiseringsfejl.
Løsningen kan siges i én sætning: Send referencer, aldrig payloads. Aktiviteten downloader dataene fra ekstern lagring, behandler dem lokalt (hvor den kun er begrænset af workerens hukommelse) og returnerer resultat-URL’en.
@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
"""Download, behandl og genupload filen.
Kun URLs sendes gennem workflowet."""
async with httpx.AsyncClient() as client:
# Download fra S3/GCS
response = await client.get(fichier_url)
contenu = response.content # Kan være 100 MB
# Behandl filen
resultat = traiter(contenu)
# Upload resultatet
await client.put(
"https://storage.example.com/résultats/output.json",
content=resultat
)
return {"url_resultat": "https://storage.example.com/résultats/output.json"}
Budgettet for hændelser og volumen
Hver kørsel er begrænset til 51.200 hændelser. Platformen genererer en hændelse for hver aktivitetsstart, hver aktivitetsafslutning, hvert modtaget signal og hver udløst timer. I praksis koster et aktivitetskald omkring to til tre hændelser, når metadata er talt med, hvilket placerer et workflow med hundrede aktiviteter på omkring 250 til 300 hændelser. Med andre ord tillader loftet femten til tyve tusind aktivitetskald pr. kørsel: langt ud over, hvad de fleste brugstilfælde kræver.
Du rammer kun denne grænse ved bulkbehandling – for eksempel ved at iterere gennem halvtreds tusind dokumenter i en enkelt kørsel. Fortsættelsesmønsteret, som beskrives i næste lektion, løser dette: workflowet behandler en batch og lancerer derefter et nyt workflow til næste batch, hvilket nulstiller hændelsestælleren.
Den anden grænse vedrører volumen: Den samlede størrelse af alle hændelser i en kørsel må ikke overstige 50 MB. Dette fyldes hurtigere op, hvis dine aktiviteter returnerer rige objekter, da hvert resultat skrives til loggen. Den samme refleks gælder: Returner en identifikator frem for en fuld struktur, gem mellemresultater i en ekstern tjeneste, og paginer behandlingen i batches – det er tilstrækkeligt i langt de fleste tilfælde.
Ingen I/O i workflowet
Den sidste linje i tabellen er ikke en størrelsesbegrænsning, men en designregel, som allerede er dækket under determinisme. Workflow-kode må ikke indeholde input/output-operationer: ingen netværkskald (httpx, aiohttp, requests), ingen fil-læsning eller -skrivning (open, aiofiles), ingen databaseadgang og ingen læsning af miljøvariabler for at styre forgreninger. Alle disse operationer hører hjemme i aktiviteter, hvis resultater logges og derfor kan afspilles identisk.
Vigtige pointer
- 2 sekunder minimum ventetid mellem hver aktivitet – bundt relaterede operationer
- 2 MB maksimum pr. aktivitets input/output – brug ekstern lagring til store data
- 51.200 hændelser og 50 MB maksimum pr. kørsel – brug fortsættelsesmønsteret til meget lange workflows
- Ingen I/O i workflow-kode – alt skal foregå i aktiviteter
- Disse begrænsninger stammer fra den underliggende Temporal-arkitektur og statussen som Public Preview