Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Πολιτική Επαναλήψεων

Μάθημα 12 / 14 Ενημερώθηκε 29 Ιουλίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Γιατί οι επαναλήψεις είναι απαραίτητες
  2. Διαμόρφωση μιας πολιτικής επαναλήψεων
  3. Μην παραλείπετε ποτέ το start_to_close_timeout
  4. Ιδιοδυναμία: μια μη διαπραγματεύσιμη προϋπόθεση
  5. Τρία προφίλ διαμόρφωσης
  6. Βασικά σημεία

Γιατί οι επαναλήψεις είναι απαραίτητες

Σε ένα κατανεμημένο σύστημα, τα παροδικά σφάλματα είναι αναπόφευκτα: χρονικά όρια δικτύου (timeouts), υπέρβαση ορίων ρυθμού (rate limits), υπηρεσίες προσωρινά μη διαθέσιμες. Καμία από αυτές τις αστοχίες δεν υποδηλώνει bug στον κώδικά σας, ωστόσο οποιαδήποτε από αυτές μπορεί να προκαλέσει αποτυχία μιας διαδικασίας εάν τίποτα δεν απορροφήσει τον κραδασμό. Μια πολιτική επαναλήψεων επιτρέπει στις δραστηριότητές σας να επιβιώνουν από αυτά τα σφάλματα χωρίς χειροκίνητη παρέμβαση, με την πλατφόρμα να τις επανεκκινεί αυτόματα σύμφωνα με τη διαμόρφωση που ορίζετε για κάθε δραστηριότητα.

Διαμόρφωση μιας πολιτικής επαναλήψεων

Ο διακοσμητής @workflows.activity() δέχεται παραμέτρους που διέπουν αυτή τη συμπεριφορά. Ακολουθεί μια δραστηριότητα κλήσης εξωτερικού API, σωστά εξοπλισμένη για ανθεκτικότητα.

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

Τρεις παράμετροι, τρεις συμπληρωματικοί ρόλοι.

  • start_to_close_timeout — Μέγιστη διάρκεια για μία μόνο προσπάθεια εκτέλεσης. Εάν η δραστηριότητα δεν ολοκληρωθεί εντός αυτού του χρονικού πλαισίου, θεωρείται αποτυχημένη και ξεκινά μια νέα προσπάθεια.

  • retry_policy_max_attempts — Μέγιστος αριθμός προσπαθειών. Η προεπιλεγμένη τιμή εξαρτάται από την πλατφόρμα. Μετά από αυτόν τον αριθμό προσπαθειών, η δραστηριότητα αποτυγχάνει οριστικά και το workflow λαμβάνει ένα σφάλμα.

  • retry_policy_backoff_coefficient — Πολλαπλασιαστής για την καθυστέρηση μεταξύ των προσπαθειών. Με συντελεστή 2.0, οι καθυστερήσεις διπλασιάζονται με κάθε προσπάθεια (1δ, 2δ, 4δ, 8δ…). Αυτό είναι η εκθετική καθυστέρηση (exponential backoff).

Αυτός ο μηχανισμός backoff αξίζει προσοχής, καθώς ο σκοπός του δεν είναι απλώς η αναμονή: δίνει χρόνο στην υπηρεσία που δυσκολεύεται να ανακάμψει, αντί να την βομβαρδίζετε. Η εξέλιξη μιας κλήσης που τελικά succeeds το illustrates αυτό ξεκάθαρα.

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!

Αντιμέτωποι με μια απόκριση “429 Too Many Requests”, αυτός ο μηχανισμός είναι ιδιαίτερα αποτελεσματικός: μια πολιτική που θα επαναλάμβανε αμέσως θα διατηρούσε απλώς τον κορεσμό, whereas η αύξηση των διαστημάτων τελικά πέφτει κάτω από το όριο του παρόχου.

Μην παραλείπετε ποτέ το start_to_close_timeout

Αυτό το χρονικό όριο είναι κρίσιμο και πρέπει να εμφανίζεται σε κάθε δραστηριότητα, χωρίς εξαίρεση. Χωρίς αυτό, μια δραστηριότητα που κολλάει—deadlock, κρεμασμένη σύνδεση, υπηρεσία που δέχεται το αίτημα αλλά δεν απαντά ποτέ—περιμένει επ’ αόριστον και παγώνει ολόκληρο το workflow. Χειρότερα: δεν ενεργοποιεί καμία επανάληψη, καθώς από την οπτική της γωνία δεν έχει αποτύχει ακόμα.

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

Για να ορίσετε την τιμή, πρώτα μετρήστε τον κανονικό χρόνο εκτέλεσης της δραστηριότητας και στη συνέχεια προσθέστε ένα περιθώριο δύο έως τριών φορές για να καλύψετε τις αργές περιπτώσεις. Τέλος, βεβαιωθείτε ότι το εσωτερικό χρονικό όριο του HTTP client παραμένει χαμηλότερο από το start_to_close_timeout—στο παραπάνω παράδειγμα, 90 δευτερόλεπτα έναντι 2 λεπτών—ώστε το σφάλμα να διαδίδεται καθαρά από τον κώδικά σας αντί να διακόπτεται από την πλατφόρμα.

Ιδιοδυναμία: μια μη διαπραγματεύσιμη προϋπόθεση

Δεδομένου ότι μια δραστηριότητα μπορεί να επαναληφθεί πολλές φορές με τις ίδιες παραμέτρους, πρέπει να παράγει το ίδιο αποτέλεσμα ανεξάρτητα από τον αριθμό των εκτελέσεων. Αυτή η ιδιότητα ονομάζεται ιδιοδυναμία (idempotence) και η απουσία της μετατρέπει μια πολιτική επαναλήψεων σε γεννήτρια incident.

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

Το τρομακτικό σενάριο είναι κοινό: το billing API επεξεργάζεται σωστά το αίτημα, αλλά η απόκριση χάνεται στο δίκτυο. Η δραστηριότητα καταλήγει σε αποτυχία, η πλατφόρμα κάνει επανάληψη και ο πελάτης πιστώνεται δύο φορές. Ένα κλειδί ιδιοδυναμίας (idempotency key) εξαλείφει το πρόβλημα, δίνοντας στην απομακρυσμένη υπηρεσία έναν τρόπο να αναγνωρίσει ένα αίτημα που έχει ήδη επεξεργαστεί.

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

Δημιουργήστε το κλειδί στο workflow χρησιμοποιώντας το workflow.uuid4(), το οποίο εγγυάται ότι παραμένει ίδιο από μία επανάληψη στην άλλη—ένα κλασικό uuid.uuid4() θα παρήγαγε μια νέα τιμή σε κάθε προσπάθεια και θα ακύρωνε όλη την προστασία. Όταν η απομακρυσμένη υπηρεσία δεν προσφέρει αυτόν τον μηχανισμό, υπάρχουν δύο άλλοι δρόμοι: upsert στη βάση δεδομένων, χρησιμοποιώντας INSERT ... ON CONFLICT UPDATE αντί για απλό INSERT, ή επαλήθευση προ-ελέγχου, η οποία περιλαμβάνει την ερώτηση της κατάστασης πριν από την ενέργεια.

Τρία προφίλ διαμόρφωσης

Οι τιμές βαθμονομούνται ανάλογα με τη φύση της λειτουργίας. Μια πληρωμή ή μια ειδοποίηση πρέπει να succeed γρήγορα ή να αποτύχει γρήγορα: σύντομο timeout, τρεις προσπάθειες, μέτριο 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

Επεξεργασία μεγάλης διάρκειας, όπως η δημιουργία αναφορών ή η βαριά inference, αντιστρέφει τη λογική: κάθε προσπάθεια κοστίζει σημαντικό χρόνο υπολογισμού, επομένως επιτρέπετε λιγότερες προσπάθειες με μεγαλύτερα διαστήματα.

@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

Αντιμέτωποι με ένα ασταθές API τρίτου μέρους που υπόκειται σε περιορισμούς ρυθμού, τελικά υιοθετείτε την επιμονή: πέντε προσπάθειες, ακόμα κι αν αυτό εκτείνεται σε αρκετά λεπτά.

@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

Βασικά σημεία

  • Πάντα να διαμορφώνετε το start_to_close_timeout για να αποφύγετε το μπλοκάρισμα των δραστηριοτήτων
  • Η εκθετική καθυστέρηση (retry_policy_backoff_coefficient) αυξάνει την καθυστέρηση μεταξύ των προσπαθειών
  • Το retry_policy_max_attempts ορίζει τον μέγιστο αριθμό προσπαθειών πριν την οριστική αποτυχία
  • Οι δραστηριότητες με επανάληψη πρέπει να είναι ιδιοδύναμες—ίδιο αποτέλεσμα αν εκτελεστούν πολλές φορές
  • Χρησιμοποιήστε κλειδιά ιδιοδυναμίας ή upserts για να εγγυηθείτε την ιδιοδυναμία
  • Προσαρμόστε τα χρονικά όρια και τον αριθμό των επαναλήψεων στον τύπο της λειτουργίας (γρήγορη vs μακρά, σταθερή vs ασταθής)