Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Beperkingen van het platform

Les 10 van 14 Bijgewerkt op 29 juli 2026 Gevorderd
Op deze pagina
  1. Ken de beperkingen
  2. Twee seconden tussen elke activiteit
  3. Twee megabyte per aanroep
  4. Het budget voor gebeurtenissen en volume
  5. Geen I/O in de workflow
  6. Belangrijkste punten

Ken de beperkingen

Het Mistral Workflows-platform bevindt zich in Public Preview (vanaf april 2026). Zoals elk orchestratiesysteem legt het technische beperkingen op die u moet begrijpen om robuuste workflows te ontwerpen. Deze limieten zijn niet slechts voetnoten in de documentatie; ze manifesteren zich in productie, vaak laat in het proces, als serialisatiefouten of als workflows onverwacht worden beëindigd zonder waarschuwing in uw code. Als u ze vooraf kent, verandert dit de manier waarop u uw verwerkingslogica structureert.

De onderstaande tabel vat de belangrijkste beperkingen samen en het concrete gevolg van het overschrijden ervan.

Beperking Waarde Gevolg bij overschrijding
Vertraging tussen activiteiten 2 seconden Onvermijdelijke latentie tussen elke activiteitsaanroep
Invoer/uitvoer per aanroep 2 MB Serialisatiefout, workflow faalt
Gebeurtenissen per uitvoering 51.200 Workflow gedwongen beëindigd
Totale grootte per uitvoering 50 MB Workflow gedwongen beëindigd
Standaard time-out 1 uur Workflow geannuleerd (configureerbaar tot 7 dagen)
Maximale time-out 7 dagen Workflow automatisch geannuleerd
I/O in workflows Verboden Fout door non-determinisme tijdens replay

Twee seconden tussen elke activiteit

Het platform handhaaft een minimale vertraging van 2 seconden tussen activiteitsaanroepen. Deze latentie is geen kinderziekte; het is inherent aan de orchestratie-architectuur, die elke gebeurtenis persisteert voordat deze doorgaat. Het is de prijs voor duurzaamheid.

De impact is eenvoudig te berekenen en vaak verrassend. Een workflow die tien opeenvolgende activiteiten koppelt, verbruikt minimaal twintig seconden orchestratietijd, ongeacht hoe lang de activiteiten zelf duren. Als elke activiteit vijftig milliseconden duurt, heeft u een taak van een halve seconde ontworpen die twintig seconden nodig heeft om een resultaat terug te geven.

De oplossing is om bewerkingen die niet gescheiden hoeven te zijn, te bundelen in één enkele activiteit. Vergelijk deze twee versies van dezelfde NLP-pipeline.

# SUBOPTIMAAL: 3 activiteiten = 6 seconden orchestratie-latentie
@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

# GEOPTIMALISEERD: 1 activiteit = 2 seconden orchestratie-latentie
@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)

De regel voor het splitsen wordt eenvoudig: maak alleen een aparte activiteit als u de persistentiegarantie tussen twee bewerkingen nodig heeft. Als twee bewerkingen samen kunnen falen zonder problemen te veroorzaken—zoals lokale tokenisatie en embedding-berekening die in het geheugen zijn gekoppeld—bundel ze dan.

Twee megabyte per aanroep

Elke activiteitsaanroep is beperkt tot 2 MB voor invoer en 2 MB voor uitvoer, gebaseerd op de geserialiseerde JSON-weergave van de gegevens. Een PDF-rapport, een set afbeeldingen of een grote CSV-export zal dit gemakkelijk overschrijden, waardoor de workflow faalt met een serialisatiefout.

De oplossing is één zin: geef referenties door, nooit payloads. De activiteit downloadt de gegevens van externe opslag, verwerkt ze lokaal (waar ze alleen beperkt zijn door het geheugen van de worker) en retourneert de resultaat-URL.

@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
    """Download, verwerk en upload het bestand opnieuw.
    Alleen URL's passeren de workflow."""
    async with httpx.AsyncClient() as client:
        # Downloaden van S3/GCS
        response = await client.get(fichier_url)
        contenu = response.content  # Kan 100 MB zijn

        # Verwerk het bestand
        resultat = traiter(contenu)

        # Upload het resultaat
        await client.put(
            "https://storage.example.com/résultats/output.json",
            content=resultat
        )

    return {"url_resultat": "https://storage.example.com/résultats/output.json"}

Het budget voor gebeurtenissen en volume

Elke uitvoering is beperkt tot 51.200 gebeurtenissen. Het platform genereert een gebeurtenis voor elke start van een activiteit, elke voltooiing van een activiteit, elk ontvangen signaal en elke geactiveerde timer. In de praktijk kost een activiteitsaanroep ongeveer twee tot drie gebeurtenissen zodra metadata is meegeteld, wat een workflow met honderd activiteiten op ongeveer 250 tot 300 gebeurtenissen brengt. Met andere woorden, de limiet staat vijftien- tot twintigduizend activiteitsaanroepen per uitvoering toe: ver beyond wat de meeste use cases vereisen.

U loopt alleen tegen deze limiet aan bij bulkverwerking—bijvoorbeeld het itereren door vijftigduizend documenten in één enkele uitvoering. Het voortzettingspatroon, dat in de volgende les wordt behandeld, lost dit op: de workflow verwerkt een batch en start vervolgens een nieuwe workflow voor de volgende batch, waardoor de gebeurtenistenteller wordt gereset.

De tweede grens betreft volume: de cumulatieve grootte van alle gebeurtenissen in een uitvoering mag niet meer dan 50 MB bedragen. Dit raakt sneller vol als uw activiteiten rijke objecten retourneren, aangezien elk resultaat naar het logboek wordt geschreven. Dezelfde reflex is van toepassing: retourneer een identificatie in plaats van een volledige structuur, sla tussenresultaten op in een externe service, verwerk paginagewijs in batches, en dat volstaat in de overgrote meerderheid van de gevallen.

Geen I/O in de workflow

De laatste regel van de tabel is geen groottebeperking, maar een ontwerpregel, die al aan bod is gekomen onder determinisme. Workflow-code mag geen invoer/uitvoer-bewerkingen bevatten: geen netwerkaanroepen (httpx, aiohttp, requests), geen bestanden lezen of schrijven (open, aiofiles), geen databanktoegang en geen lezen van omgevingsvariabelen om vertakkingen te sturen. Al deze bewerkingen horen thuis in activiteiten, waarvan de resultaten worden gelogd en daarom identiek opnieuw kunnen worden afgespeeld.

Belangrijkste punten

  • 2 seconden minimale latentie tussen elke activiteit—bundel gerelateerde bewerkingen
  • 2 MB maximum per activiteit invoer/uitvoer—gebruik externe opslag voor grote gegevens
  • 51.200 gebeurtenissen en 50 MB maximum per uitvoering—gebruik het voortzettingspatroon voor zeer lange workflows
  • Geen I/O in workflow-code—alles gaat naar activiteiten
  • Deze beperkingen vloeien voort uit de onderliggende Temporal-architectuur en de status Public Preview