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

Εκτέλεση και δοκιμή μιας ροής εργασίας

Μάθημα 7 / 14 Ενημερώθηκε 3 Νοεμβρίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Εκκίνηση μιας ροής εργασίας
  2. Εκκίνηση μέσω του Python SDK
  3. Εκκίνηση μέσω cURL
  4. Παράδειγμα από άκρη σε άκρη
  5. Έλεγχος αποτελεσμάτων
  6. Διαχείριση σφαλμάτων
  7. Τοπικές δοκιμές
  8. Βασικά σημεία

Μάθημα ενημερώθηκε στις 3 Νοεμβρίου 2026 με βάση το SDK mistralai 3.7.0: η παρακολούθηση μιας εκτέλεσης χρησιμοποιεί πλέον τη μέθοδο client.workflows.executions.get_workflow_execution_async, και το αποτέλεσμα διαβάζεται από το πεδίο result. Προσθήκη της ίδιας ημέρας: τα προηγούμενα παραδείγματα αναφέρονταν ακόμη στα execution.id, execution.output και execution.error, τα οποία απουσιάζουν από το SDK, και συνέκριναν την κατάσταση με τις τιμές "completed" ή "failed" σε πεζά γράμματα· πλέον χρησιμοποιούν τα execution_id, result, wait_for_result=True και καταστάσεις με κεφαλαία γράμματα. Πηγή: client-python.

Εκκίνηση μιας ροής εργασίας

Έχετε γράψει τις δραστηριότητές σας, έχετε ορίσει τη ροή εργασίας σας και έχετε ξεκινήσει τον worker σας. Τώρα πρέπει να ξεκινήσετε μια εκτέλεση. Έχετε δύο επιλογές: το Python SDK ή μια κλήση cURL στο REST API. Η πρώτη ταιριάζει στα Python scripts και τις υπηρεσίες σας· η δεύτερη λειτουργεί για γρήγορες δοκιμές από τη γραμμή εντολών ή για ενεργοποιήσεις από συστήματα εκτός Python—ένα webhook, έναν χρονοπρογραμματιστή ή ένα backend γραμμένο σε άλλη γλώσσα.

Τρεις προϋποθέσεις πρέπει να πληρούνται πριν ενεργοποιήσετε οτιδήποτε. Ο worker σας πρέπει να εκτελείται (uv run python worker.py), το κλειδί API σας πρέπει να έχει οριστεί στο MISTRAL_API_KEY, και η ροή εργασίας πρέπει να είναι καταχωρημένη σε αυτόν τον worker, πράγμα που σημαίνει ότι εμφανίζεται στη λίστα που περνάτε στη συνάρτηση run_worker().

Εκκίνηση μέσω του Python SDK

Γράψτε την ενεργοποίηση σε ένα script ξεχωριστό από τον worker, καθώς η διαδικασία του worker δεν επιστρέφει ποτέ τον έλεγχο:

import asyncio
from mistralai.client import Mistral

async def main():
    client = Mistral()

    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="salutation_workflow",
        input={"nom": "Marie"},
        wait_for_result=True,  # αναμονή ολοκλήρωσης και λήψη του αποτελέσματος
    )

    print(f"Execution ID: {execution.execution_id}")
    print(f"Result: {execution.result}")

if __name__ == "__main__":
    asyncio.run(main())

Το workflow_identifier ταιριάζει ακριβώς με το name που δηλώσατε στο @workflows.workflow.define(), και τα κλειδιά στο λεξικό input αντιστοιχούν στις παραμέτρους της μεθόδου run σας. Εκτελέστε αυτό το script σε ένα ξεχωριστό τερματικό, αφήνοντας το πρώτο κατειλημμένο από τον worker:

uv run python trigger.py

Με την παράμετρο wait_for_result=True, το SDK περιμένει να ολοκληρωθεί η εκτέλεση και επιστρέφει απευθείας το αποτέλεσμα, καθιστώντας τις δοκιμές πολύ ευανάγνωστες για σύντομες ροές εργασίας. Χωρίς αυτή την παράμετρο, η κλήση επιστρέφει αμέσως με το αναγνωριστικό εκτέλεσης, το οποίο στη συνέχεια παρακολουθείτε (δείτε παρακάτω).

Εκκίνηση μέσω cURL

Για γρήγορες δοκιμές ή ενσωμάτωση με άλλα συστήματα, το REST API εκθέτει την ίδια ενεργοποίηση:

curl -X POST https://api.mistral.ai/v1/workflows/salutation_workflow/execute \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": {"nom": "Marie"}, "wait_for_result": true}'

Με το wait_for_result, η απόκριση περιέχει το όνομα της ροής εργασίας, το αναγνωριστικό εκτέλεσης και το αποτέλεσμά της· αυτά είναι τα πεδία του μοντέλου WorkflowExecutionSyncResponse του SDK:

{
  "workflow_name": "salutation_workflow",
  "execution_id": "…",
  "result": {
    "message": "Bonjour, Marie !"
  }
}

Κρατήστε αυτό το execution_id: είναι το κλειδί που θα χρησιμοποιήσετε αργότερα για να κάνετε ερώτημα στην εκτέλεση ή να ανακτήσετε τα ίχνη της. Χωρίς το wait_for_result, η απόκριση περιγράφει την εκτέλεση που τρέχει, συμπεριλαμβανομένης της κατάστασής της (status) (RUNNING αρχικά).

Παράδειγμα από άκρη σε άκρη

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

Αρχείο workflow.py (worker + ορισμοί)

import asyncio
import httpx
import mistralai.workflows as workflows
from mistralai.client import Mistral

@workflows.activity()
async def extraire_texte(url: str) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
    return {"texte": response.text[:5000]}  # Περιορισμός στους 5000 χαρακτήρες

@workflows.activity()
async def resumer_texte(texte: str) -> dict:
    client = Mistral()
    response = await client.chat.complete_async(
        model="mistral-large-latest",
        messages=[
            {"role": "system", "content": "Summarize in 3 sentences."},
            {"role": "user", "content": texte}
        ]
    )
    return {"resume": response.choices[0].message.content}

@workflows.workflow.define(name="resume_page_web")
class ResumePageWeb:
    @workflows.workflow.entrypoint
    async def run(self, url: str) -> dict:
        extraction = await extraire_texte(url)
        resume = await resumer_texte(extraction["texte"])
        return {
            "url_source": url,
            "resume": resume["resume"]
        }

async def main() -> None:
    await workflows.run_worker([ResumePageWeb])

if __name__ == "__main__":
    asyncio.run(main())

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

Αρχείο trigger.py (ενεργοποίηση)

import asyncio
from mistralai.client import Mistral

async def main():
    client = Mistral()

    print("Launching workflow...")
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="resume_page_web",
        input={"url": "https://example.com/article"},
    )
    print(f"Execution launched: {execution.execution_id}")

    # Παρακολούθηση εκτέλεσης μέχρι την ολοκλήρωση
    while True:
        suivi = await client.workflows.executions.get_workflow_execution_async(
            execution_id=execution.execution_id
        )
        if suivi.status not in ("RUNNING", "RETRYING_AFTER_ERROR"):
            break
        await asyncio.sleep(2)

    if suivi.status == "COMPLETED":
        print(f"Summary: {suivi.result['resume']}")
    else:
        print(f"Execution finished with status {suivi.status}")

if __name__ == "__main__":
    asyncio.run(main())

Εκτέλεση

Τερματικό 1 — Εκκίνηση του worker:

uv run python workflow.py

Τερματικό 2 — Ενεργοποίηση της εκτέλεσης:

uv run python trigger.py

Έλεγχος αποτελεσμάτων

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

[INFO] Executing activity: extraire_texte
[INFO] Activity completed: extraire_texte (1.2s)
[INFO] Executing activity: resumer_texte
[INFO] Activity completed: resumer_texte (3.4s)
[INFO] Workflow completed: resume_page_web

Για μεγάλες ροές εργασίας, προφανώς δεν θα μείνετε καρφωμένοι στο τερματικό. Μόλις αποκτήσετε το ID εκτέλεσης, μπορείτε να κάνετε ερώτημα στην κατάστασή της ανά πάσα στιγμή από μια άλλη διαδικασία:

execution = await client.workflows.executions.get_workflow_execution_async(
    execution_id="exec_abc123"
)
print(f"Status: {execution.status}")
print(f"Result: {execution.result}")

Η ίδια λειτουργία είναι διαθέσιμη μέσω cURL, χρήσιμη σε ένα script παρακολούθησης:

curl https://api.mistral.ai/v1/workflows/executions/exec_abc123 \
  -H "Authorization: Bearer $MISTRAL_API_KEY"

Διαχείριση σφαλμάτων

Μια αποτυχία δεν συμβαίνει στην πρώτη εξαίρεση: η πλατφόρμα πρώτα επαναλαμβάνει τη δραστηριότητα σύμφωνα με την πολιτική επανάληψής της. Μόνο αφού εξαντληθούν οι επαναλήψεις, η εκτέλεση μεταβαίνει στην κατάσταση FAILED (οι καταστάσεις του SDK είναι με κεφαλαία: RUNNING, COMPLETED, FAILED, CANCELED, TERMINATED, TIMED_OUT κ.λπ.), και ο κώδικας κλήσης σας πρέπει να διαχειριστεί αυτή την περίπτωση αντί να υποθέτει ότι ένα result υπάρχει πάντα:

execution = await client.workflows.executions.get_workflow_execution_async(
    execution_id="exec_abc123"
)

if execution.status == "FAILED":
    print(f"Execution {execution.execution_id} failed")

Η απόκριση δεν περιέχει μήνυμα σφάλματος: η αιτία εμφανίζεται στο ιστορικό εκτέλεσης και στα αρχεία καταγραφής (get_workflow_execution_history_async, get_workflow_execution_logs_async). Για να εντοπίσετε τη faulty δραστηριότητα και την ακολουθία που οδήγησε σε αυτήν, θα αναλύσετε τα ίχνη OpenTelemetry, τα οποία καλύπτονται στο Μάθημα 14.

Τοπικές δοκιμές

Η εναλλαγή μεταξύ δύο τερματικών γίνεται γρήγορα κουραστική κατά την ανάπτυξη. Για την ανάπτυξη, ένα ενιαίο script μπορεί να ξεκινήσει τον worker στο παρασκήνιο, να ενεργοποιήσει τη ροή εργασίας και στη συνέχεια να σταματήσει τα πάντα:

import asyncio
import mistralai.workflows as workflows

# ... ορισμοί δραστηριοτήτων και ροής εργασίας ...

async def main():
    # Εκκίνηση worker στο παρασκήνιο
    worker_task = asyncio.create_task(
        workflows.run_worker([MonWorkflow])
    )

    # Αναμονή έως ότου ο worker είναι έτοιμος
    await asyncio.sleep(2)

    # Ενεργοποίηση ροής εργασίας
    from mistralai.client import Mistral
    client = Mistral()
    execution = await client.workflows.execute_workflow_async(
        workflow_identifier="mon_workflow",
        input={"test": True},
        wait_for_result=True,
    )
    print(f"Result: {execution.result}")

    # Διακοπή worker
    worker_task.cancel()

if __name__ == "__main__":
    asyncio.run(main())

Το asyncio.sleep(2) δίνει χρόνο στον worker να establish τη σύνδεσή του πριν την ενεργοποίηση, και το τελικό worker_task.cancel() εμποδίζει το script να μείνει σε αναμονή επ’ αόριστον. Κρατήστε αυτή τη ρύθμιση για την ανάπτυξη: στην παραγωγή, ο worker και οι ενεργοποιήσεις παραμένουν ξεχωριστές διαδικασίες με ανεξάρτητους κύκλους ζωής.

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

  • Δύο μέθοδοι ενεργοποίησης: Python SDK (execute_workflow_async) και REST API (cURL)
  • Ο worker πρέπει να εκτελείται για να τρέξει η ροή εργασίας
  • Με wait_for_result=True, το SDK περιμένει την ολοκλήρωση και επιστρέφει το αποτέλεσμα (result)· διαφορετικά επιστρέφει το execution_id για παρακολούθηση
  • Χρησιμοποιήστε το client.workflows.executions.get_workflow_execution_async() για να ελέγξετε την κατάσταση μιας εκτέλεσης
  • Οι καταστάσεις είναι με κεφαλαία (RUNNING, COMPLETED, FAILED κ.λπ.)· οι αιτίες αποτυχίας εμφανίζονται στο ιστορικό εκτέλεσης, στα logs και στα traces
  • Για την ανάπτυξη, συνδυάστε τον worker και την ενεργοποίηση σε ένα ενιαίο script χρησιμοποιώντας asyncio