Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Créer un worker

Lekcija 6 od 14 Ažurirano 29. srpnja 2026. Napredno
Na ovoj stranici
  1. Le rôle du worker
  2. Créer un worker minimal
  3. Ce que fait run_worker()
  4. Worker avec plusieurs workflows
  5. Structure de fichiers recommandée
  6. Démarrer le worker
  7. Le worker en production
  8. Ključne točke

Le rôle du worker

Le worker est le processus Python qui exécute réellement tes workflows et tes activités. Il se connecte à la plateforme Mistral, écoute les tâches en attente et les exécute localement sur ta machine ou ton serveur. Ce détail architectural surprend souvent les nouveaux venus : ton code ne quitte jamais ton environnement ; seul l’état d’orchestration réside chez Mistral.

La conséquence est directe et explique la plupart des problèmes de type « rien ne se passe » rencontrés au début d’un projet : sans worker en cours d’exécution, tes workflows ne peuvent pas s’exécuter. Tu peux déclencher une exécution, mais elle attendra simplement qu’un worker capable apparaisse. Le worker est le lien entre la plateforme d’orchestration Mistral et ton code local.

Créer un worker minimal

Un worker fonctionnel tient en quelques lignes. L’exemple ci-dessous combine volontairement l’activité, le workflow et la logique de démarrage dans un seul fichier pour que tu puisses l’exécuter immédiatement :

import asyncio
import mistralai.workflows as workflows

# Import your workflows and activities
@workflows.activity()
async def dire_bonjour(nom: str) -> dict:
    return {"message": f"Bonjour, {nom} !"}

@workflows.workflow.define(name="salutation_workflow")
class SalutationWorkflow:
    @workflows.workflow.entrypoint
    async def run(self, nom: str) -> dict:
        resultat = await dire_bonjour(nom)
        return resultat

# Start the worker
async def main() -> None:
    await workflows.run_worker([SalutationWorkflow])

if __name__ == "__main__":
    asyncio.run(main())

La fonction clé est workflows.run_worker(). Elle prend une liste de classes de workflow que ce worker peut exécuter — et uniquement des workflows. Les activités sont découvertes à travers eux, tu n’as donc pas besoin de lister les activités séparément.

Ce que fait run_worker()

Lorsque tu appelles workflows.run_worker([MonWorkflow]), cinq choses se produisent séquentiellement. D’abord, le worker s’authentifie auprès de la plateforme Mistral en utilisant ta clé API. Ensuite, il enregistre les workflows et activités déclarés. Cet enregistrement informe la plateforme qu’un exécuteur existe pour l’identifiant salutation_workflow. Puis, il ouvre une connexion persistante et attend les tâches, restant volontairement inactif jusqu’à ce qu’une exécution soit déclenchée. Lorsqu’une exécution arrive, le worker exécute le code localement et les résultats sont renvoyés à la plateforme pour persistance.

Le worker reste actif tant que le processus Python tourne, c’est pourquoi il ne rend jamais la main à ton terminal. Utilise Ctrl+C pour l’arrêter proprement.

Worker avec plusieurs workflows

Rien n’impose un worker par workflow. Un seul processus peut héberger plusieurs workflows, même s’ils partagent des activités. Ici, extraire_texte et analyser_sentiment servent aux deux :

import asyncio
import mistralai.workflows as workflows

# --- Activities ---

@workflows.activity()
async def extraire_texte(url: str) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
    return {"texte": response.text}

@workflows.activity()
async def analyser_sentiment(texte: str) -> dict:
    client = Mistral()
    response = await client.chat.complete_async(
        model="mistral-large-latest",
        messages=[
            {"role": "system", "content": "Analysez le sentiment : positif, négatif ou neutre."},
            {"role": "user", "content": texte}
        ]
    )
    return {"sentiment": response.choices[0].message.content}

@workflows.activity()
async def envoyer_alerte(message: str) -> dict:
    # Envoi vers Slack, email, etc.
    return {"status": "envoyé"}

# --- Workflows ---

@workflows.workflow.define(name="analyse_document")
class DocumentAnalysis:
    @workflows.workflow.entrypoint
    async def run(self, url: str) -> dict:
        extraction = await extraire_texte(url)
        sentiment = await analyser_sentiment(extraction["texte"])
        return sentiment

@workflows.workflow.define(name="surveillance_mentions")
class MentionMonitoring:
    @workflows.workflow.entrypoint
    async def run(self, url: str, seuil: str) -> dict:
        extraction = await extraire_texte(url)
        sentiment = await analyser_sentiment(extraction["texte"])
        if sentiment["sentiment"] == "négatif":
            await envoyer_alerte(f"Mention négative détectée : {url}")
        return sentiment

# --- Worker ---

async def main() -> None:
    await workflows.run_worker([
        DocumentAnalysis,
        MentionMonitoring,
    ])

if __name__ == "__main__":
    asyncio.run(main())

Structure de fichiers recommandée

Un seul fichier fonctionne pour l’apprentissage, mais pas pour un projet en production. Pour la production, sépare ton code en modules par type :

mon-projet/
├── activities/
│   ├── __init__.py
│   ├── extraction.py      # extraire_texte()
│   ├── analyse.py          # analyser_sentiment()
│   └── notifications.py    # envoyer_alerte()
├── workflows/
│   ├── __init__.py
│   ├── analyse_document.py
│   └── surveillance.py
└── worker.py               # Single entry point

Le fichier worker.py ne contient alors que les imports et la logique de démarrage, ce qui en fait un inventaire lisible de ce que ce processus peut exécuter :

import asyncio
import mistralai.workflows as workflows

from workflows.document_analysis import DocumentAnalysis
from workflows.monitoring import MentionMonitoring

async def main() -> None:
    await workflows.run_worker([
        DocumentAnalysis,
        MentionMonitoring,
    ])

if __name__ == "__main__":
    asyncio.run(main())

Démarrer le worker

uv run python worker.py

Le worker affiche un message de connexion et reste actif, en attente de tâches. Tu devrais voir quelque chose comme :

Worker connected. Listening for tasks...

Tant que cette ligne n’apparaît pas, ne déclenche rien. Vérifie d’abord ta clé API et ta connexion réseau.

Le worker en production

Un worker lancé manuellement dans un terminal disparaît après la première déconnexion SSH. Confie-le à un gestionnaire de processus — systemd, supervisor ou pm2 — qui le redémarrera automatiquement après un crash ou un redémarrage :

# With pm2 (if Node.js is available)
pm2 start "uv run python worker.py" --name workflow-worker

# With systemd (create a .service file)

Ce redémarrage automatique s’accorde bien avec la durabilité : les workflows en cours d’exécution reprennent d’eux-mêmes dès que le nouveau processus se connecte. Concernant les secrets, ne code jamais la clé API en dur dans le fichier du worker, sinon elle finira dans ton dépôt Git. Le SDK lit automatiquement la variable d’environnement :

import os

# The SDK automatically reads MISTRAL_API_KEY
# No need to pass it explicitly

Enfin, pense à la journalisation (logging). Le worker émet des messages via le module standard logging de Python. Une configuration simple au démarrage te donne une trace des activités exécutées, ce qui est précieux pour comprendre ce qui tournait lors d’un incident :

import logging
logging.basicConfig(level=logging.INFO)

Ključne točke

  • Le worker est le processus qui exécute tes workflows et tes activités localement
  • workflows.run_worker([...]) prend une liste de classes de workflow à exécuter
  • Un seul worker peut exécuter plusieurs workflows différents
  • Le worker reste actif et écoute les tâches tant que le processus tourne
  • En production, utilise un gestionnaire de processus pour maintenir le worker en marche
  • La clé API est lue automatiquement depuis MISTRAL_API_KEY