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

Créer un worker

Lecția 6 din 14 Actualizată 29 iulie 2026 Avansat
Pe această pagină
  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. Worker en production
  8. Puncte cheie

Le rôle du worker

Le worker est le processus Python qui exécute réellement vos workflows et activités. Il se connecte à la plateforme Mistral, écoute les tâches en attente et les exécute localement sur votre machine ou votre serveur. Ce détail architectural surprend souvent les nouveaux venus : votre code ne quitte jamais votre 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, vos workflows ne peuvent pas s’exécuter. Vous pouvez déclencher une exécution, mais elle restera simplement en attente jusqu’à l’apparition d’un worker capable de la traiter. Le worker constitue le lien entre la plateforme d’orchestration Mistral et votre 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 afin que vous puissiez 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, il n’est donc pas nécessaire de lister les activités séparément.

Ce que fait run_worker()

Lorsque vous appelez workflows.run_worker([MyWorkflow]), cinq choses se produisent séquentiellement. Premièrement, le worker s’authentifie auprès de la plateforme Mistral en utilisant votre 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 intentionnellement inactif jusqu’au déclenchement d’une exécution. 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 à votre terminal. Utilisez 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 lorsqu’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 fichier unique convient pour l’apprentissage, mais pas pour un projet en production. Pour la production, séparez votre 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. Vous devriez voir quelque chose comme :

Worker connected. Listening for tasks...

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

Worker en production

Un worker lancé manuellement dans un terminal disparaît après la première déconnexion SSH. Confiez-le à un gestionnaire de processus — systemd, supervisor ou pm2 — qui le redémarrera automatiquement après un plantage 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 reprennent d’eux-mêmes dès que le nouveau processus se connecte. Concernant les secrets, ne codez jamais la clé API en dur dans le fichier du worker, sinon elle finira dans votre 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, pensez à la journalisation (logging). Le worker émet des messages via le module standard logging de Python. Une configuration simple au démarrage vous offre 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)

Puncte cheie

  • Le worker est le processus qui exécute vos workflows et 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, utilisez un gestionnaire de processus pour maintenir le worker en marche
  • La clé API est lue automatiquement depuis MISTRAL_API_KEY