Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Async och bästa praxis

Lektion 13 av 14 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Async I/O: Ett tekniskt krav
  2. Välj bibliotek som är asynkrona från grunden
  3. När ingen async-version finns
  4. Designa rena aktiviteter
  5. Viktiga punkter

Async I/O: Ett tekniskt krav

Alla aktiviteter i Mistral Workflows måste använda asynkrona in-/utmatningsoperationer. Detta är inte en stilrekommendation; det är ett tekniskt krav. Ett blockerande synkront anrop som requests.post() fryser workern och förhindrar att någon annan aktivitet körs.

Detta krav härrör från worker-arkitekturen, som exekverar aktiviteter inom en asyncio-händelseslinga. När en korutin väntar på ett nätverkssvar asynkront lämnar den tillbaka kontrollen till slingan, vilket låter andra aktiviteter fortsätta. Ett synkront anrop lämnar däremot ingenting ifrån sig.

import requests

# FELAKTIGT: Blockerar hela workern
@workflows.activity()
async def blocking_activity(url: str) -> dict:
    # requests.post() är synkront — det blockerar händelseslingan
    response = requests.post(url, json={"query": "test"})
    return response.json()

Symtomen i produktion kan vara förvirrande: du startar tio aktiviteter parallellt med asyncio.gather, men de exekveras faktiskt en efter en. Om var och en väntar två sekunder på ett externt API mäter du tjugo sekunder istället för de förväntade två, utan att några fel lyfts.

Välj bibliotek som är asynkrona från grunden

Lösningen är att ersätta varje blockerande bibliotek med dess asynkrona motsvarighet. För HTTP-anrop är httpx det självklara valet.

import httpx

# KORREKT: Icke-blockerande
@workflows.activity()
async def async_activity(url: str) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.post(url, json={"query": "test"})
    return response.json()

aiohttp fyller samma syfte med ett något annorlunda API baserat på sessioner.

import aiohttp

@workflows.activity()
async def aiohttp_activity(url: str) -> dict:
    async with aiohttp.ClientSession() as session:
        async with session.post(url, json={"query": "test"}) as response:
            return await response.json()

För databaser ersätter asyncpg psycopg2 för PostgreSQL. Notera blocket try/finally: anslutningen måste stängas även om frågan kastar ett undantag. Annars kommer efterföljande försök att tömma anslutningspoolen.

import asyncpg

# KORREKT: Asynkron PostgreSQL-drivrutin
@workflows.activity()
async def async_db_query(user_id: str) -> dict:
    conn = await asyncpg.connect("postgresql://user:pass@localhost/db")
    try:
        row = await conn.fetchrow(
            "SELECT * FROM users WHERE id = $1", user_id
        )
        return dict(row) if row else {"error": "user not found"}
    finally:
        await conn.close()

Filåtkomst följer samma logik med aiofiles, även för små filer där du kanske frestas att fortsätta använda open().

import aiofiles

# KORREKT: Asynkron filläsning
@workflows.activity()
async def read_file_async(path: str) -> dict:
    async with aiofiles.open(path, mode="r") as f:
        content = await f.read()
    return {"content": content, "size": len(content)}

Mistral SDK är inget undantag: varje metod har en variant med suffixet _async, och det är den du måste anropa från en aktivitet.

from mistralai.client import Mistral

@workflows.activity()
async def call_mistral(prompt: str) -> dict:
    client = Mistral()
    # Använd complete_async, INTE complete
    response = await client.chat.complete_async(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}]
    )
    return {"response": response.choices[0].message.content}

Ha denna mapping-tabell till hands under kodgranskningar: varje rad från vänster kolumn som upptäcks i en aktivitet är en potentiell prestandabugg.

OperationFelaktigt (blockerande)Korrekt (async)
HTTPrequests.get()httpx.AsyncClient().get()
HTTPurllib.request.urlopen()aiohttp.ClientSession().get()
PostgreSQLpsycopg2.connect()asyncpg.connect()
MySQLmysql.connector.connect()aiomysql.connect()
Redisredis.Redis()redis.asyncio.Redis()
Fileropen()aiofiles.open()
Sleeptime.sleep()asyncio.sleep()
Mistralclient.chat.complete()client.chat.complete_async()

När ingen async-version finns

Vissa affärsbibliotek, som ett proprietärt SDK eller en äldre klient, erbjuder helt enkelt ingen asynkron variant. I dessa fall låter asyncio.to_thread() dig köra den blockerande koden i en separat tråd utan att frysa händelseslingan.

import asyncio
from some_library import blocking_function

@workflows.activity()
async def compatibility_activity(params: dict) -> dict:
    """Omsluter ett blockerande anrop i en tråd."""
    result = await asyncio.to_thread(
        blocking_function,
        params["arg1"],
        params["arg2"]
    )
    return {"result": result}

Detta är en kompromiss, inte en likvärdig lösning: varje anrop konsumerar en tråd från poolen, vilken har en begränsad storlek. För en aktivitet som anropas massivt parallellt flyttar du bara flaskhalsen snarare än att ta bort den. Föredrag alltid ett inbyggt asynkront bibliotek när ett sådant finns.

Designa rena aktiviteter

Utöver asynkronitet finns det fyra vanor som skiljer en robust aktivitet från en som kommer att kosta dig timmar av felsökning.

Den första är omfattning. En aktivitet bör ha ett och endast ett ansvar, eftersom den också är enheten för återförsök och persistens: en catch-all-aktivitet som misslyckas medan den skickar ett e-postmeddelande kommer att spela om extrahering och analys från början.

# BRA: Varje aktivitet har ett tydligt ansvar
@workflows.activity()
async def extract_text(url: str) -> dict:
    # ...
    pass

@workflows.activity()
async def analyze_sentiment(text: str) -> dict:
    # ...
    pass

# DÅLIGT: Catch-all-aktivitet
@workflows.activity()
async def do_everything(url: str) -> dict:
    text = ...  # extrahering
    sentiment = ...  # analys
    # skicka e-post
    # spara till DB
    pass

Den andra gäller resurser. Kontexthanteraren async with garanterar att klienten stängs även om ett undantag inträffar, något manuella anrop oundvikligen glömmer förr eller senare.

@workflows.activity()
async def clean_request(params: dict) -> dict:
    # Använd async with för att garantera stängning
    async with httpx.AsyncClient() as client:
        response = await client.get(params["url"])
    # Klienten stängs automatiskt här
    return response.json()

Den tredje är mer subtil: inte alla fel förtjänar ett återförsök. En timeout, en 429 eller en 500 är övergående och bör bubbla upp för att utlösa ett återförsök. Ett 4xx-fel indikerar dock en ogiltig begäran som tre återförsök inte kommer att åtgärda. Returnera istället ett explicit resultat och låt arbetsflödet besluta.

@workflows.activity(
    start_to_close_timeout=timedelta(minutes=2),
    retry_policy_max_attempts=3,
)
async def robust_activity(params: dict) -> dict:
    async with httpx.AsyncClient(timeout=60) as client:
        try:
            response = await client.post(params["url"], json=params["data"])
            response.raise_for_status()
            return {"status": "success", "data": response.json()}
        except httpx.TimeoutException:
            raise  # Kommer att försökas igen av plattformen
        except httpx.HTTPStatusError as e:
            if e.response.status_code == 429:
                raise  # Hastighetsbegränsad — kommer att försökas igen
            elif e.response.status_code >= 500:
                raise  # Serverfel — kommer att försökas igen
            else:
                # Klientfel (4xx) — försök inte igen
                return {"status": "error", "code": e.response.status_code}

Slutligen härrör den fjärde vanan från gränsen på 2 MB per anrop: returnera endast det arbetsflödet faktiskt behöver för att besluta om nästa steg. Ett antal, ett urval och URL:en till det fullständiga resultatet är nästan alltid tillräckligt.

@workflows.activity()
async def extract_data(source: str) -> dict:
    data = await retrieve_large_data(source)

    # Returnera endast det arbetsflödet behöver
    return {
        "item_count": len(data),
        "summary": data[:10],  # Endast de första 10
        "full_url": await upload_results(data)
    }

Viktiga punkter

  • Async I/O är obligatoriskt: använd httpx, asyncpg, aiofiles istället för deras synkrona motsvarigheter
  • Blockerande anrop (requests, psycopg2, open) fryser hela workern
  • Använd asyncio.to_thread() som en sista utväg för bibliotek utan en async-version
  • Varje aktivitet måste ha ett tydligt ansvar
  • Stäng alltid anslutningar med async with
  • Hantera fel explicit: vissa bör försökas igen, andra bör inte göra det
  • Begränsa returstorlekar för att hålla sig under gränsen på 2 MB