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

Ασύγχρονες Λειτουργίες και Βέλτιστες Πρακτικές

Μάθημα 13 / 14 Ενημερώθηκε 2 Νοεμβρίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Ασύγχρονη Είσοδος/Έξοδος: Μια Τεχνική Απαίτηση
  2. Επιλέξτε Εγγενώς Ασύγχρονες Βιβλιοθήκες
  3. Όταν Δεν Υπάρχει Ασύγχρονη Έκδοση
  4. Σχεδιασμός Καθαρών Δραστηριοτήτων
  5. Βασικά σημεία

Ασύγχρονη Είσοδος/Έξοδος: Μια Τεχνική Απαίτηση

Όλες οι δραστηριότητες στα Mistral Workflows πρέπει να χρησιμοποιούν ασύγχρονες λειτουργίες εισόδου/εξόδου. Αυτό δεν είναι μια σύσταση ύφους, αλλά ένας τεχνικός περιορισμός. Μια μπλοκαρισμένη συγχρονισμένη κλήση, όπως η requests.post(), παγώνει τον worker και εμποδίζει την εκτέλεση οποιασδήποτε άλλης δραστηριότητας.

Αυτή η απαίτηση πηγάζει από την αρχιτεκτονική του worker, ο οποίος εκτελεί δραστηριότητες εντός ενός βρόχου γεγονότων asyncio. Όταν μια συνρουτίνα (coroutine) περιμένει ασύγχρονα μια απόκριση δικτύου, επιστρέφει τον έλεγχο στον βρόχο, επιτρέποντας σε άλλες δραστηριότητες να προχωρήσουν. Αντίθετα, μια συγχρονισμένη κλήση δεν επιστρέφει τίποτα.

import requests

# ΛΑΝΘΑΣΜΕΝΟ: Μπλοκάρει ολόκληρο τον worker
@workflows.activity()
async def blocking_activity(url: str) -> dict:
    # Η requests.post() είναι συγχρονισμένη — μπλοκάρει τον βρόχο γεγονότων
    response = requests.post(url, json={"query": "test"})
    return response.json()

Το σύμπτωμα στην παραγωγή μπορεί να είναι μπερδευτικό: εκκινείτε δέκα δραστηριότητες παράλληλα με το asyncio.gather, αλλά στην πραγματικότητα εκτελούνται η μία μετά την άλλη. Αν κάθε μία περιμένει δύο δευτερόλεπτα για ένα απομακρυσμένο API, μετράτε είκοσι δευτερόλεπτα αντί για τα αναμενόμενα δύο, χωρίς να εμφανίζονται σφάλματα.

Επιλέξτε Εγγενώς Ασύγχρονες Βιβλιοθήκες

Η λύση είναι να αντικαταστήσετε κάθε μπλοκαρισμένη βιβλιοθήκη με την ασύγχρονη ισοδύναμή της. Για κλήσεις HTTP, το httpx είναι η προεπιλεγμένη επιλογή.

import httpx

# ΣΩΣΤΟ: Μη μπλοκαριστικό
@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 εξυπηρετεί τον ίδιο σκοπό με ένα ελαφρώς διαφορετικό API βασισμένο σε συνεδρίες.

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

Για βάσεις δεδομένων, το asyncpg αντικαθιστά το psycopg2 για την PostgreSQL. Σημειώστε το μπλοκ try/finally: η σύνδεση πρέπει να κλείνει ακόμα και αν το ερώτημα προκαλέσει εξαίρεση. Διαφορετικά, οι διαδοχικές επαναλήψεις θα εξαντλήσουν την ομάδα συνδέσεων (connection pool).

import asyncpg

# ΣΩΣΤΟ: Ασύγχρονος οδηγός PostgreSQL
@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()

Η πρόσβαση σε αρχεία ακολουθεί την ίδια λογική με το aiofiles, ακόμα και για μικρά αρχεία όπου θα μπορούσατε να πειραστείτε νασυνεχίσετε να χρησιμοποιείτε το open().

import aiofiles

# ΣΩΣΤΟ: Ασύγχρονη ανάγνωση αρχείου
@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 δεν αποτελεί εξαίρεση: κάθε μέθοδος έχει μια παραλλαγή με την κατάληξη _async, και αυτή είναι που πρέπει να καλείτε από μια δραστηριότητα.

from mistralai.client import Mistral

@workflows.activity()
async def call_mistral(prompt: str) -> dict:
    client = Mistral()
    # Χρησιμοποιήστε το complete_async, ΟΧΙ το complete
    response = await client.chat.complete_async(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}]
    )
    return {"response": response.choices[0].message.content}

Κρατήστε αυτόν τον πίνακα αντιστοιχίας πρόχειρο κατά τις αναθεωρήσεις κώδικα: οποιαδήποτε γραμμή από την αριστερή στήλη εντοπιστεί σε μια δραστηριότητα αποτελεί πιθανό σφάλμα απόδοσης.

ΛειτουργίαΛανθασμένο (μπλοκαριστικό)Σωστό (ασύγχρονο)
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()
Αρχείαopen()aiofiles.open()
Αναμονήtime.sleep()asyncio.sleep()
Mistralclient.chat.complete()client.chat.complete_async()

Όταν Δεν Υπάρχει Ασύγχρονη Έκδοση

Ορισμένες επιχειρηματικές βιβλιοθήκες, όπως ένα ιδιόκτητο SDK ή ένας πελάτης παλαιάς τεχνολογίας, απλά δεν προσφέρουν ασύγχρονη παραλλαγή. Σε αυτές τις περιπτώσεις, το asyncio.to_thread() σας επιτρέπει να εκτελέσετε τον μπλοκαρισμένο κώδικα σε ένα ξεχωριστό νήμα χωρίς να παγώσετε τον βρόχο γεγονότων.

import asyncio
from some_library import blocking_function

@workflows.activity()
async def compatibility_activity(params: dict) -> dict:
    """Τυλίγει μια μπλοκαρισμένη κλήση σε ένα νήμα."""
    result = await asyncio.to_thread(
        blocking_function,
        params["arg1"],
        params["arg2"]
    )
    return {"result": result}

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

Σχεδιασμός Καθαρών Δραστηριοτήτων

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

Η πρώτη είναι το πεδίο εφαρμογής. Μια δραστηριότητα πρέπει να έχει μία και μοναδική ευθύνη, καθώς αποτελεί επίσης τη μονάδα επανάληψης και επιμονής: μια δραστηριότητα «όλα σε ένα» που αποτυγχάνει κατά την αποστολή email, θα επαναλάβει από την αρχή την εξαγωγή και την ανάλυση.

# ΚΑΛΟ: Κάθε δραστηριότητα έχει σαφή ευθύνη
@workflows.activity()
async def extract_text(url: str) -> dict:
    # ...
    pass

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

# ΚΑΚΟ: Δραστηριότητα «όλα σε ένα»
@workflows.activity()
async def do_everything(url: str) -> dict:
    text = ...  # εξαγωγή
    sentiment = ...  # ανάλυση
    # αποστολή email
    # αποθήκευση στη ΒΔ
    pass

Η δεύτερη αφορά τους πόρους. Ο διαχειριστής πλαισίου async with εγγυάται ότι ο πελάτης θα κλείσει ακόμα και αν συμβεί εξαίρεση, κάτι που οι χειροκίνητες κλήσεις ξεχνούν αναπόφευκτα αργά ή γρήγορα.

@workflows.activity()
async def clean_request(params: dict) -> dict:
    # Χρησιμοποιήστε async with για να εγγυηθείτε το κλείσιμο
    async with httpx.AsyncClient() as client:
        response = await client.get(params["url"])
    # Ο πελάτης κλείνει αυτόματα εδώ
    return response.json()

Η τρίτη είναι πιο λεπτή: δεν αξίζουν όλα τα σφάλματα επανάληψη. Ένα χρονικό όριο (timeout), ένα 429 ή ένα 500 είναι παροδικά και πρέπει να προωθούνται για να ενεργοποιήσουν μια επανάληψη. Ένα σφάλμα 4xx, ωστόσο, υποδηλώνει ένα μη έγκυρο αίτημα που η τριπλή επανάληψη δεν θα διορθώσει. Αντ’ αυτού, επιστρέψτε ένα ρητό αποτέλεσμα και αφήστε τη ροή εργασίας να αποφασίσει.

@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  # Θα επαναληφθεί από την πλατφόρμα
        except httpx.HTTPStatusError as e:
            if e.response.status_code == 429:
                raise  # Περιορισμός ρυθμού — θα επαναληφθεί
            elif e.response.status_code >= 500:
                raise  # Σφάλμα διακομιστή — θα επαναληφθεί
            else:
                # Σφάλμα πελάτη (4xx) — μην επαναλάβετε
                return {"status": "error", "code": e.response.status_code}

Τέλος, η τέταρτη συνήθεια πηγάζει από το όριο των 2 MB ανά κλήση: επιστρέψτε μόνο ό,τι χρειάζεται πραγματικά η ροή εργασίας για να αποφασίσει το επόμενο βήμα. Ένας μετρητής, ένα δείγμα και το URL προς το πλήρες αποτέλεσμα είναι σχεδόν πάντα επαρκή.

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

    # Επιστρέψτε μόνο ό,τι χρειάζεται η ροή εργασίας
    return {
        "item_count": len(data),
        "summary": data[:10],  # Μόνο τα πρώτα 10
        "full_url": await upload_results(data)
    }

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

  • Η ασύγχρονη Ε/Ε είναι υποχρεωτική: χρησιμοποιήστε httpx, asyncpg, aiofiles αντί για τις συγχρονισμένες ισοδύναμές τους
  • Οι μπλοκαρισμένες κλήσεις (requests, psycopg2, open) παγώνουν ολόκληρο τον worker
  • Χρησιμοποιήστε το asyncio.to_thread() ως έσχατη λύση για βιβλιοθήκες χωρίς ασύγχρονη έκδοση
  • Κάθε δραστηριότητα πρέπει να έχει μία σαφή ευθύνη
  • Κλείνετε πάντα τις συνδέσεις με async with
  • Διαχειριστείτε τα σφάλματα ρητά: κάποια πρέπει να επαναληφθούν, άλλα όχι
  • Περιορίστε τα μεγέθη επιστροφής για να παραμείνετε κάτω από το όριο των 2 MB