Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Opret en worker

Lektion 6 af 14 Opdateret 29. juli 2026 Avanceret
På denne side
  1. Workerens rolle
  2. Opret en minimal worker
  3. Hvad run_worker() gør
  4. Worker med flere workflows
  5. Anbefalet filstruktur
  6. Start workeren
  7. Worker i produktion
  8. Vigtige pointer

Workerens rolle

Workeren er den Python-proces, der faktisk udfører dine workflows og aktiviteter. Den forbinder sig til Mistral-platformen, lytter efter ventende opgaver og kører dem lokalt på din maskine eller server. Denne arkitektoniske detalje overrasker ofte nybegyndere: din kode forlader aldrig dit miljø; kun orchestration-tilstanden opbevares hos Mistral.

Konsekvensen er direkte og forklarer de fleste „intet sker”-problemer, man støder på tidligt i et projekt: uden en kørende worker kan dine workflows ikke udføres. Du kan udløse en eksekvering, men den vil blot vente, indtil en egnet worker dukker op. Workeren er bindeleddet mellem Mistral-orchestrationsplatformen og din lokale kode.

Opret en minimal worker

En funktionel worker fylder kun få linjer. Eksemplet nedenfor kombinerer bevidst aktivitet, workflow og opstartslogik i én fil, så du kan køre det med det samme:

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())

Nøglefunktionen er workflows.run_worker(). Den tager en liste med workflow-klasser, som denne worker kan udføre – og kun workflows. Aktiviteter opdages gennem dem, så du behøver ikke liste aktiviteter separat.

Hvad run_worker() gør

Når du kalder workflows.run_worker([MyWorkflow]), sker fem ting i rækkefølge. Først autentificerer workeren sig hos Mistral-platformen ved hjælp af din API-nøgle. Derefter registrerer den de erklærede workflows og aktiviteter. Denne registrering fortæller platformen, at der findes en executor for identifikatoren salutation_workflow. Dernæst åbner den en vedvarende forbindelse og venter på opgaver, hvor den bevidst holder sig inaktiv, indtil en eksekvering udløses. Når en eksekvering ankommer, kører workeren koden lokalt, og resultaterne sendes tilbage til platformen til lagring.

Workeren forbliver aktiv, så længe Python-processen kører, hvilket er grunden til, at den aldrig returnerer kontrollen til din terminal. Brug Ctrl+C til at stoppe den korrekt.

Worker med flere workflows

Intet kræver én worker pr. workflow. En enkelt proces kan hoste flere workflows, selv når de deler aktiviteter. Her betjener extraire_texte og analyser_sentiment begge:

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())

Anbefalet filstruktur

Én fil fungerer til læring, men ikke til et live-projekt. Til produktion skal du opdele din kode i moduler efter 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

Filen worker.py indeholder derefter kun imports og opstartslogik, hvilket gør den til en læsbar oversigt over, hvad denne proces kan udføre:

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())

Start workeren

uv run python worker.py

Workeren viser en forbindelsesmeddelelse og forbliver aktiv i venteposition på opgaver. Du bør se noget i stil med:

Worker connected. Listening for tasks...

Indtil denne linje vises, må du ikke udløse noget. Tjek først din API-nøgle og netværksforbindelse.

Worker i produktion

En worker, der startes manuelt i en terminal, forsvinder efter den første SSH-afbrydelse. Overlad den til en proceshåndtering – systemd, supervisor eller pm2 – som automatisk genstarter den efter et nedbrud eller genstart:

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

# With systemd (create a .service file)

Denne automatiske genstart passer godt sammen med holdbarhed: kørende workflows genoptages af sig selv, så snart den nye proces forbinder sig. Hvad angår hemmeligheder, må du aldrig hardcode API-nøglen i worker-filen, ellers havner den i dit Git-repository. SDK’en læser miljøvariablen automatisk:

import os

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

Overvej endelig logging. Workeren udsender meddelelser via Pythons standard logging-modul. En simpel konfiguration ved opstart giver dig et spor over udførte aktiviteter, hvilket er værdifuldt for at forstå, hvad der kørte under en hændelse:

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

Vigtige pointer

  • Workeren er den proces, der udfører dine workflows og aktiviteter lokalt
  • workflows.run_worker([...]) tager en liste med workflow-klasser, der skal udføres
  • En enkelt worker kan udføre flere forskellige workflows
  • Workeren forbliver aktiv og lytter efter opgaver, så længe processen kører
  • Brug en proceshåndtering i produktion for at holde workeren kørende
  • API-nøglen læses automatisk fra MISTRAL_API_KEY