Salt la conținutul principal
Română— Alege o limbă
Meniu

Limitările platformei

Lecția 10 din 14 Actualizată 29 iulie 2026 Avansat
Pe această pagină
  1. Cunoașteți limitările
  2. Două secunde între fiecare activitate
  3. Doi megabytes per invocare
  4. Bugetul de evenimente și volum
  5. Fără I/O în fluxul de lucru
  6. Puncte cheie

Cunoașteți limitările

Platforma Mistral Workflows se află în etapă de Previzualizare Publică (din aprilie 2026). Ca orice sistem de orchestrare, impune constrângeri tehnice pe care trebuie să le înțelegeți pentru a proiecta fluxuri de lucru robuste. Aceste limite nu sunt simple note de subsol în documentație; ele apar în producție, adesea târziu în proces, sub formă de erori de serializare sau fluxuri de lucru terminate neașteptat, fără niciun avertisment în codul dumneavoastră. Cunoașterea lor anticipată modifică modul în care structurați logica de procesare.

Tabelul de mai jos rezumă constrângerile principale și consecința concretă a depășirii fiecăreia.

Limitare Valoare Consecință la depășire
Întârziere între activități 2 secunde Latentă inevitabilă între fiecare apel de activitate
Intrare/ieșire per invocare 2 MB Eroare de serializare, eșec al fluxului de lucru
Evenimente per execuție 51.200 Flux de lucru terminat forțat
Dimensiune totală per execuție 50 MB Flux de lucru terminat forțat
Timeout implicit 1 oră Flux de lucru anulat (configurabil până la 7 zile)
Timeout maxim 7 zile Flux de lucru anulat automat
I/O în fluxurile de lucru Interzis Eroare de nedeterminism în timpul redării (replay)

Două secunde între fiecare activitate

Platforma impune o întârziere minimă de 2 secunde între apelurile de activități. Această latență nu este o problemă de început; este inerentă arhitecturii de orchestrare, care persistă fiecare eveniment înainte de a continua. Este prețul durabilității.

Impactul este ușor de calculat și adesea surprinzător. Un flux de lucru care înlănțuie zece activități secvențiale consumă cel puțin douăzeci de secunde de timp de orchestrare, indiferent de durata efectivă a activităților în sine. Dacă fiecare activitate rulează în cincizeci de milisecunde, ați proiectat o sarcină de jumătate de secundă care necesită douăzeci de secunde pentru a returna un rezultat.

Soluția constă în gruparea operațiunilor care nu trebuie să fie separate într-o singură activitate. Comparați aceste două versiuni ale aceluiași pipeline NLP.

# SUBOPTIMAL: 3 activități = 6 secunde de latență de orchestrare
@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

# OPTIMIZAT: 1 activitate = 2 secunde de latență de orchestrare
@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)

Regula pentru divizare devine simplă: creați o activitate separată doar dacă aveți nevoie de garanția de persistență între două operațiuni. Dacă două operațiuni pot eșua împreună fără a cauza probleme — cum ar fi tokenizarea locală și calculul embedding-urilor înlănțuite în memorie — grupați-le.

Doi megabytes per invocare

Fiecare apel de activitate este limitat la 2 MB pentru intrare și 2 MB pentru ieșire, bazat pe reprezentarea JSON serializată a datelor. Un raport PDF, un set de imagini sau un export CSV voluminos vor depăși cu ușurință această limită, determinând eșecul fluxului de lucru cu o eroare de serializare.

Soluția se rezumă la o propoziție: transmiteți referințe, niciodată payload-uri. Activitatea descarcă datele din stocarea externă, le procesează local (unde este limitată doar de memoria worker-ului) și returnează URL-ul rezultatului.

@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
    """Descarcă, procesează și reîncarcă fișierul.
    Doar URL-urile trec prin fluxul de lucru."""
    async with httpx.AsyncClient() as client:
        # Descarcă din S3/GCS
        response = await client.get(fichier_url)
        contenu = response.content  # Poate fi 100 MB

        # Procesează fișierul
        resultat = traiter(contenu)

        # Încarcă rezultatul
        await client.put(
            "https://storage.example.com/résultats/output.json",
            content=resultat
        )

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

Bugetul de evenimente și volum

Fiecare execuție este limitată la 51.200 de evenimente. Platforma generează un eveniment pentru fiecare start de activitate, fiecare finalizare de activitate, fiecare semnal recepționat și fiecare timer declanșat. În practică, un apel de activitate costă aproximativ două până la trei evenimente odată ce metadata este contorizată, plasând un flux de lucru de o sută de activități în jurul a 250 până la 300 de evenimente. Cu alte cuvinte, limita permite între cincisprezece și douăzeci de mii de apeluri de activitate per execuție: mult peste ceea ce necesită majoritatea cazurilor de utilizare.

Veți atinge această limită doar în cazul procesării în masă — de exemplu, iterarea prin cincizeci de mii de documente într-o singură execuție. Modelul de continuare, detaliat în lecția următoare, rezolvă această problemă: fluxul de lucru procesează un lot, apoi lansează un nou flux de lucru pentru lotul următor, resetând contorul de evenimente.

A doua limită privește volumul: dimensiunea cumulativă a tuturor evenimentelor dintr-o execuție nu trebuie să depășească 50 MB. Aceasta se umple mai rapid dacă activitățile dumneavoastră returnează obiecte bogate, deoarece fiecare rezultat este scris în jurnal. Același reflex se aplică — returnați un identificator în loc de o structură completă, stocați rezultatele intermediare într-un serviciu extern, paginați procesarea în loturi — și este suficient în marea majoritate a cazurilor.

Fără I/O în fluxul de lucru

Ultima linie a tabelului nu este o limită de dimensiune, ci o regulă de proiectare, deja abordată sub aspectul determinismului. Codul fluxului de lucru nu trebuie să conțină operațiuni de intrare/ieșire: nici apeluri de rețea (httpx, aiohttp, requests), nici citire sau scriere de fișiere (open, aiofiles), nici acces la baza de date și nici citirea variabilelor de mediu pentru a direcționa ramificările. Toate aceste operațiuni trăiesc în activități, ale căror rezultate sunt jurnalizate și, prin urmare, reproductibile identic.

Puncte cheie

  • 2 secunde latență minimă între fiecare activitate — grupați operațiunile conexe
  • 2 MB maxim per intrare/ieșire de activitate — utilizați stocarea externă pentru date voluminoase
  • 51.200 de evenimente și 50 MB maxim per execuție — utilizați modelul de continuare pentru fluxurile de lucru foarte lungi
  • Fără I/O în codul fluxului de lucru — totul merge în activități
  • Aceste limitări derivă din arhitectura Temporal subiacentă și din statutul de Previzualizare Publică