Przejdź do głównej treści
Polski— Wybierz język
Menu

Ograniczenia platformy

Lekcja 10 z 14 Zaktualizowano 29 lipca 2026 Zaawansowany
Na tej stronie
  1. Poznaj ograniczenia
  2. Dwie sekundy między każdą aktywnością
  3. Dwa megabajty na wywołanie
  4. Budżet zdarzeń i wolumenu
  5. Brak operacji I/O w workflow
  6. Kluczowe wnioski

Poznaj ograniczenia

Platforma Mistral Workflows znajduje się w fazie Public Preview (stan na kwiecień 2026 r.). Jak każdy system orkiestracji, nakłada ona ograniczenia techniczne, które musisz zrozumieć, aby projektować odporne workflow. Te limity to nie tylko przypisy w dokumentacji; pojawiają się w środowisku produkcyjnym, często w późnej fazie projektu, jako błędy serializacji lub niespodziewanie zakończone workflow bez żadnego ostrzeżenia w Twoim kodzie. Wiedza o nich z wyprzedzeniem zmienia sposób, w jaki strukturujesz swoją logikę przetwarzania.

Poniższa tabela podsumowuje kluczowe ograniczenia i konkretne konsekwencje ich przekroczenia.

Ograniczenie Wartość Konsekwencja przekroczenia
Opóźnienie między aktywnościami 2 sekundy Nieuniknione opóźnienie przy każdym wywołaniu aktywności
Wejście/wyjście na wywołanie 2 MB Błąd serializacji, niepowodzenie workflow
Zdarzenia na wykonanie 51 200 Wymuszone zakończenie workflow
Łączny rozmiar na wykonanie 50 MB Wymuszone zakończenie workflow
Domyślny limit czasu 1 godzina Anulowanie workflow (konfigurowalne do 7 dni)
Maksymalny limit czasu 7 dni Automatyczne anulowanie workflow
Operacje I/O w workflow Zabronione Błąd niedeterminizmu podczas odtwarzania

Dwie sekundy między każdą aktywnością

Platforma wymusza minimalne 2-sekundowe opóźnienie między wywołaniami aktywności. To opóźnienie nie jest chorobą wieku dziecięcego; jest ono nierozerwalnie związane z architekturą orkiestracji, która utrwalają każde zdarzenie przed przejściem dalej. To cena za trwałość.

Wpływ tego mechanizmu jest łatwy do obliczenia i często zaskakujący. Workflow łączące dziesięć sekwencyjnych aktywności zużywa co najmniej dwadzieścia sekund czasu orkiestracji, niezależnie od tego, jak długo same aktywności trwają. Jeśli każda aktywność działa przez pięćdziesiąt milisekund, zaprojektowałeś zadanie trwające pół sekundy, które zwraca wynik po dwudziestu sekundach.

Rozwiązaniem jest grupowanie operacji, które nie muszą być rozdzielone, w jedną aktywność. Porównaj te dwie wersje tego samego potoku NLP.

# NIEOPTYMALNE: 3 aktywności = 6 sekund opóźnienia orkiestracji
@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

# ZOPTYMALIZOWANE: 1 aktywność = 2 sekundy opóźnienia orkiestracji
@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)

Zasada dotycząca podziału staje się prosta: twórz osobną aktywność tylko wtedy, gdy potrzebujesz gwarancji trwałości między dwiema operacjami. Jeśli dwie operacje mogą zakończyć się niepowodzeniem razem bez powodowania problemów – jak lokalna tokenizacja i obliczanie osadzeń połączone w pamięci – zgrupuj je.

Dwa megabajty na wywołanie

Każde wywołanie aktywności jest ograniczone do 2 MB dla danych wejściowych i 2 MB dla danych wyjściowych, w oparciu o serializowaną reprezentację JSON danych. Raport w formacie PDF, zestaw obrazów lub duży eksport CSV łatwo przekroczą ten limit, powodując niepowodzenie workflow z błędem serializacji.

Rozwiązanie mieści się w jednym zdaniu: przekazuj referencje, nigdy ładunków danych. Aktywność pobiera dane z zewnętrznej pamięci masowej, przetwarza je lokalnie (gdzie ogranicza ją tylko pamięć workera) i zwraca URL wyniku.

@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
    """Pobierz, przetwórz i ponownie prześlij plik.
    Tylko URL-e przechodzą przez workflow."""
    async with httpx.AsyncClient() as client:
        # Pobierz z S3/GCS
        response = await client.get(fichier_url)
        contenu = response.content  # Może to być 100 MB

        # Przetwórz plik
        resultat = traiter(contenu)

        # Prześlij wynik
        await client.put(
            "https://storage.example.com/résultats/output.json",
            content=resultat
        )

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

Budżet zdarzeń i wolumenu

Każde wykonanie jest ograniczone do 51 200 zdarzeń. Platforma generuje zdarzenie dla każdego rozpoczęcia aktywności, każdego zakończenia aktywności, każdego otrzymanego sygnału i każdego uruchomionego timera. W praktyce wywołanie aktywności kosztuje około dwóch do trzech zdarzeń po uwzględnieniu metadanych, co oznacza, że workflow ze stu aktywnościami zużywa około 250 do 300 zdarzeń. Innymi słowy, limit ten pozwala na piętnaście do dwudziestu tysięcy wywołań aktywności na wykonanie: znacznie więcej niż wymaga większość przypadków użycia.

Limit ten osiągniesz tylko przy przetwarzaniu wsadowym – na przykład iterując przez pięćdziesiąt tysięcy dokumentów w ramach jednego wykonania. Wzorzec kontynuacji, szczegółowo opisany w następnej lekcji, rozwiązuje ten problem: workflow przetwarza partię, a następnie uruchamia nowe workflow dla kolejnej partii, resetując licznik zdarzeń.

Drugie ograniczenie dotyczy wolumenu: łączny rozmiar wszystkich zdarzeń w wykonaniu nie może przekroczyć 50 MB. Limit ten wypełnia się szybciej, jeśli Twoje aktywności zwracają bogate obiekty, ponieważ każdy wynik jest zapisywany w logu. Zastosuj ten sam odruch – zwracaj identyfikator zamiast pełnej struktury, przechowuj wyniki pośrednie w usłudze zewnętrznej, dziel przetwarzanie na partie – i wystarczy to w zdecydowanej większości przypadków.

Brak operacji I/O w workflow

Ostatni wiersz tabeli to nie limit rozmiaru, ale zasada projektowa, omówiona już w kontekście determinizmu. Kod workflow nie może zawierać żadnych operacji wejścia/wyjścia: żadnych wywołań sieciowych (httpx, aiohttp, requests), żadnego odczytu ani zapisu plików (open, aiofiles), żadnego dostępu do bazy danych i żadnego odczytu zmiennych środowiskowych w celu sterowania rozgałęzieniami. Wszystkie te operacje muszą znajdować się w aktywnościach, których wyniki są logowane, a zatem identycznie odtwarzalne.

Kluczowe wnioski

  • 2 sekundy minimalnego opóźnienia między każdą aktywnością – grupuj powiązane operacje
  • 2 MB maksymalnie na wejście/wyjście aktywności – używaj zewnętrznej pamięci masowej dla dużych danych
  • 51 200 zdarzeń i 50 MB maksymalnie na wykonanie – używaj wzorca kontynuacji dla bardzo długich workflow
  • Brak operacji I/O w kodzie workflow – wszystko musi trafić do aktywności
  • Ograniczenia te wynikają z podstawowej architektury Temporal i statusu Public Preview