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

Retry Policy

Lektion 12 av 14 Uppdaterad 29 juli 2026 Avancerad
På denna sida
  1. Varför återförsök är avgörande
  2. Konfigurera en återförsökspolicy
  3. Uteslut aldrig start_to_close_timeout
  4. Idempotens: ett icke-förhandlingsbart villkor
  5. Tre konfigurationsprofiler
  6. Viktiga punkter

Varför återförsök är avgörande

I ett distribuerat system är övergående fel oundvikliga: nätverkstidsgränser överskrids, hastighetsbegränsningar nås, tjänster är tillfälligt otillgängliga. Inget av dessa fel indikerar en bugg i din kod, men vart och ett av dem kan få en process att misslyckas om inget dämpar stöten. En återförsökspolicy låter dina aktiviteter överleva dessa fel utan manuellt ingripande, där plattformen automatiskt startar om dem enligt den konfiguration du definierar för varje aktivitet.

Konfigurera en återförsökspolicy

Dekoreraren @workflows.activity() accepterar parametrar som styr detta beteende. Här är en aktivitet för anrop till ett externt API, ordentligt rustad för motståndskraft.

from datetime import timedelta
import mistralai.workflows as workflows

@workflows.activity(
    start_to_close_timeout=timedelta(minutes=5),
    retry_policy_max_attempts=3,
    retry_policy_backoff_coefficient=2.0,
)
async def call_external_api(url: str, data: dict) -> dict:
    """Calls an external API with automatic retry."""
    async with httpx.AsyncClient(timeout=60) as client:
        response = await client.post(url, json=data)
        response.raise_for_status()
        return response.json()

Tre parametrar, tre kompletterande roller.

  • start_to_close_timeout — Maximal varaktighet för ett enskilt körningsförsök. Om aktiviteten inte slutförs inom denna tidsram anses den ha misslyckats och ett nytt försök startas.

  • retry_policy_max_attempts — Maximalt antal försök. Standardvärdet beror på plattformen. Efter detta antal försök misslyckas aktiviteten definitivt och arbetsflödet tar emot ett fel.

  • retry_policy_backoff_coefficient — Multiplikator för fördröjningen mellan försöken. Med en koefficient på 2,0 fördubblas fördröjningarna vid varje försök (1 s, 2 s, 4 s, 8 s…). Detta kallas exponentiell backoff.

Denna backoff-mekanism förtjänar uppmärksamhet eftersom syftet inte bara är att vänta: den ger den kämpande tjänsten tid att återhämta sig istället för att hamra på den. Förloppet för ett anrop som så småningom lyckas illustrerar detta tydligt.

Attempt 1: immediate execution
  → Failure (network timeout)
  → Wait 1 second

Attempt 2: execution
  → Failure (service unavailable)
  → Wait 2 seconds (1 × 2.0)

Attempt 3: execution
  → Failure (rate limit)
  → Wait 4 seconds (2 × 2.0)

Attempt 4: execution
  → Success!

Vid ett svar med felkoden »429 Too Many Requests« är denna mekanism särskilt effektiv: en policy som försökte igen omedelbart skulle bara upprätthålla överbelastningen, medan ökade mellanrum så småningom hamnar under leverantörens tröskelvärde.

Uteslut aldrig start_to_close_timeout

Denna tidsgräns är kritisk och måste finnas med i varje aktivitet, utan undantag. Utan den väntar en aktivitet som fastnar – deadlocks, hängande anslutningar, tjänster som accepterar begäran men aldrig svarar – på obestämd tid och fryser hela arbetsflödet. Värre än så: den utlöser inget återförsök, eftersom den ur dess perspektiv ännu inte har misslyckats.

# BAD PRACTICE: no timeout
@workflows.activity()
async def dangerous_activity(params: dict) -> dict:
    # If the service never responds, the activity waits indefinitely
    async with httpx.AsyncClient() as client:
        response = await client.get("https://api.lente.example.com/data")
    return response.json()

# GOOD PRACTICE: explicit timeout
@workflows.activity(
    start_to_close_timeout=timedelta(minutes=2)
)
async def safe_activity(params: dict) -> dict:
    async with httpx.AsyncClient(timeout=90) as client:
        response = await client.get("https://api.lente.example.com/data")
    return response.json()

För att ställa in värdet mäter du först den normala körtiden för aktiviteten och lägger sedan till en marginal på två till tre gånger denna tid för att täcka långsamma fall. Se slutligen till att den interna HTTP-klientens tidsgräns är lägre än start_to_close_timeout – i exemplet ovan 90 sekunder mot 2 minuter – så att felet propagerar rent från din kod istället för att kapras av plattformen.

Idempotens: ett icke-förhandlingsbart villkor

Eftersom en aktivitet kan spelas upp flera gånger med samma parametrar måste den producera samma effekt oavsett antal körningar. Denna egenskap kallas idempotens, och dess frånvaro förvandlar en återförsökspolicy till en generator av incidenter.

@workflows.activity(retry_policy_max_attempts=3)
async def add_credit(user_id: str, amount: float) -> dict:
    """DANGEROUS: if retried, credit is added multiple times!"""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"https://api.billing.com/credits/add",
            json={"user_id": user_id, "amount": amount}
        )
    return response.json()

Det fruktade scenariot är vanligt: fakturerings-API:t bearbetar begäran korrekt, men svaret går förlorat i nätverket. Aktiviteten konstaterar ett misslyckande, plattformen försöker igen och kunden får kredit två gånger. En idempotensnyckel eliminerar problemet genom att ge den externa tjänsten ett sätt att känna igen en redan bearbetad begäran.

@workflows.activity(retry_policy_max_attempts=3)
async def add_credit(user_id: str, amount: float, idempotency_key: str) -> dict:
    """CORRECT: idempotency key prevents duplication."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"https://api.billing.com/credits/add",
            json={
                "user_id": user_id,
                "amount": amount,
                "idempotency_key": idempotency_key
            }
        )
    return response.json()

Generera nyckeln i arbetsflödet med workflow.uuid4(), vilket garanterar att den förblir identisk från en uppspelning till en annan – en klassisk uuid.uuid4() skulle producera ett nytt värde vid varje försök och upphäva allt skydd. När den externa tjänsten inte erbjuder denna mekanism finns två andra vägar: upsert i databasen, där du använder INSERT ... ON CONFLICT UPDATE istället för enbart INSERT, eller förkontroll genom att fråga tillståndet innan du agerar.

Tre konfigurationsprofiler

Värdena kalibreras efter operationens natur. En betalning eller avisering måste lyckas snabbt eller misslyckas snabbt: kort tidsgräns, tre försök, måttlig backoff.

@workflows.activity(
    start_to_close_timeout=timedelta(seconds=30),
    retry_policy_max_attempts=3,
    retry_policy_backoff_coefficient=2.0,
)
async def process_payment(params: dict) -> dict:
    # ...
    pass

Långvarig bearbetning, såsom rapportgenerering eller tung inferens, vänder på logiken: varje försök kostar betydande beräkningstid, så du tillåter färre försök med större mellanrum.

@workflows.activity(
    start_to_close_timeout=timedelta(minutes=15),
    retry_policy_max_attempts=2,
    retry_policy_backoff_coefficient=3.0,
)
async def generate_ml_report(params: dict) -> dict:
    # ...
    pass

När du står inför ett instabilt tredjeparts-API som utsätts för hastighetsbegränsningar antar du slutligen uthållighet: fem försök, även om det sträcker sig över flera minuter.

@workflows.activity(
    start_to_close_timeout=timedelta(minutes=2),
    retry_policy_max_attempts=5,
    retry_policy_backoff_coefficient=2.0,
)
async def call_third_party_api(params: dict) -> dict:
    # ...
    pass

Viktiga punkter

  • Konfigurera alltid start_to_close_timeout för att undvika blockerade aktiviteter
  • Exponentiell backoff (retry_policy_backoff_coefficient) ökar fördröjningen mellan försöken
  • retry_policy_max_attempts definierar det maximala antalet försök innan definitivt misslyckande
  • Aktiviteter med återförsök måste vara idempotenta – samma resultat vid flera körningar
  • Använd idempotensnycklar eller upserts för att garantera idempotens
  • Anpassa tidsgränser och antal återförsök efter operationstyp (snabb kontra lång, stabil kontra instabil)