Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Begrænsninger i platformen

Lektion 10 af 14 Opdateret 29. juli 2026 Avanceret
På denne side
  1. Kend begrænsningerne
  2. To sekunder mellem hver aktivitet
  3. To megabyte pr. kald
  4. Budgettet for hændelser og volumen
  5. Ingen I/O i workflowet
  6. Vigtige pointer

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