Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Limitazioni della Piattaforma

Lezione 10 di 14 Aggiornata il 29 luglio 2026 Avanzato
In questa pagina
  1. Conosci i Limiti
  2. Due Secondi tra Ogni Attività
  3. Due Megabyte per Invocazione
  4. Il Budget di Eventi e Volume
  5. Nessun I/O nel Flusso di Lavoro
  6. Punti chiave

Conosci i Limiti

La piattaforma Mistral Workflows è in Public Preview (ad aprile 2026). Come qualsiasi sistema di orchestrazione, impone vincoli tecnici che devi comprendere per progettare flussi di lavoro robusti. Questi limiti non sono semplici note a piè di pagina nella documentazione; si manifestano in produzione, spesso nelle fasi finali, sotto forma di errori di serializzazione o flussi di lavoro terminati inaspettatamente senza alcun avviso nel tuo codice. Conoscerli in anticipo cambia il modo in cui strutturi la tua logica di elaborazione.

La tabella seguente riassume i vincoli principali e la conseguenza concreta del superamento di ciascuno di essi.

Limitazione Valore Conseguenza se superato
Ritardo tra le attività 2 secondi Latenza inevitabile tra ogni chiamata di attività
Input/output per invocazione 2 MB Errore di serializzazione, il flusso di lavoro fallisce
Eventi per esecuzione 51.200 Flusso di lavoro terminato forzatamente
Dimensione totale per esecuzione 50 MB Flusso di lavoro terminato forzatamente
Timeout predefinito 1 ora Flusso di lavoro annullato (configurabile fino a 7 giorni)
Timeout massimo 7 giorni Flusso di lavoro annullato automaticamente
I/O nei flussi di lavoro Vietato Errore di non determinismo durante il replay

Due Secondi tra Ogni Attività

La piattaforma impone un ritardo minimo di 2 secondi tra le chiamate alle attività. Questa latenza non è un problema di gioventù; è intrinseca all’architettura di orchestrazione, che persiste ogni evento prima di procedere. È il prezzo della durabilità.

L’impatto è facile da calcolare e spesso sorprendente. Un flusso di lavoro che concatena dieci attività sequenziali consuma almeno venti secondi di tempo di orchestrazione, indipendentemente dalla durata delle attività stesse. Se ogni attività viene eseguita in cinquanta millisecondi, hai progettato un lavoro da mezzo secondo che impiega venti secondi per restituire un risultato.

La soluzione consiste nel raggruppare le operazioni che non devono essere separate in un’unica attività. Confronta queste due versioni della stessa pipeline NLP.

# SUBOTTIMALE: 3 attività = 6 secondi di latenza di orchestrazione
@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

# OTTIMIZZATO: 1 attività = 2 secondi di latenza di orchestrazione
@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)

La regola per la suddivisione diventa semplice: crea un’attività separata solo se hai bisogno della garanzia di persistenza tra due operazioni. Se due operazioni possono fallire insieme senza causare problemi—come la tokenizzazione locale e il calcolo degli embedding concatenati in memoria—raggruppale.

Due Megabyte per Invocazione

Ogni chiamata di attività è limitata a 2 MB per l’input e 2 MB per l’output, basandosi sulla rappresentazione JSON serializzata dei dati. Un report PDF, un insieme di immagini o un’esportazione CSV di grandi dimensioni supereranno facilmente questo limite, causando il fallimento del flusso di lavoro con un errore di serializzazione.

La soluzione si riassume in una frase: passa riferimenti, mai payload. L’attività scarica i dati dallo storage esterno, li elabora localmente (dove è limitata solo dalla memoria del worker) e restituisce l’URL del risultato.

@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
    """Scarica, elabora e ricarica il file.
    Solo gli URL passano attraverso il flusso di lavoro."""
    async with httpx.AsyncClient() as client:
        # Scarica da S3/GCS
        response = await client.get(fichier_url)
        contenu = response.content  # Potrebbe essere 100 MB

        # Elabora il file
        resultat = traiter(contenu)

        # Carica il risultato
        await client.put(
            "https://storage.example.com/résultats/output.json",
            content=resultat
        )

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

Il Budget di Eventi e Volume

Ogni esecuzione è limitata a 51.200 eventi. La piattaforma genera un evento per ogni avvio di attività, ogni completamento di attività, ogni segnale ricevuto e ogni timer attivato. In pratica, una chiamata di attività costa circa due o tre eventi una volta contati i metadati, portando un flusso di lavoro di cento attività intorno ai 250-300 eventi. In altre parole, il limite consente dalle quindici alle ventimila chiamate di attività per esecuzione: molto oltre ciò che la maggior parte dei casi d’uso richiede.

Raggiungerai questo limite solo con l’elaborazione in blocco—ad esempio, iterando su cinquantamila documenti in un’unica esecuzione. Il pattern di continuazione, dettagliato nella prossima lezione, risolve il problema: il flusso di lavoro elabora un batch, quindi avvia un nuovo flusso di lavoro per il batch successivo, azzerando il contatore degli eventi.

Il secondo limite riguarda il volume: la dimensione cumulativa di tutti gli eventi in un’esecuzione non deve superare i 50 MB. Questo limite si riempie più velocemente se le tue attività restituiscono oggetti ricchi, poiché ogni risultato viene scritto nel log. Si applica lo stesso riflesso: restituisci un identificatore piuttosto che una struttura completa, archivia i risultati intermedi in un servizio esterno, pagina l’elaborazione in batch; nella stragrande maggioranza dei casi, questo è sufficiente.

Nessun I/O nel Flusso di Lavoro

L’ultima riga della tabella non è un limite dimensionale, ma una regola di progettazione, già trattata sotto il determinismo. Il codice del flusso di lavoro non deve contenere operazioni di input/output: nessuna chiamata di rete (httpx, aiohttp, requests), nessuna lettura o scrittura di file (open, aiofiles), nessun accesso al database e nessuna lettura di variabili d’ambiente per guidare la ramificazione. Tutte queste operazioni risiedono nelle attività, i cui risultati vengono registrati e quindi riproducibili in modo identico.

Punti chiave

  • 2 secondi di latenza minima tra ogni attività: raggruppa le operazioni correlate
  • 2 MB massimi per input/output di ogni attività: usa lo storage esterno per i dati di grandi dimensioni
  • 51.200 eventi e 50 MB massimi per esecuzione: usa il pattern di continuazione per flussi di lavoro molto lunghi
  • Nessun I/O nel codice del flusso di lavoro: tutto va nelle attività
  • Queste limitazioni derivano dall’architettura Temporal sottostante e dallo stato di Public Preview