Spuštění spravovaného pracovního postupu

Verze balíčků

Kód na této stránce byl vyvinut s použitím následujících požadavků. Doporučujeme používat tyto nebo novější verze.

qiskit-serverless~=0.38.0

Úloha spravovaného pracovního postupu funguje jako dávková úloha, kterou odesíláš plánovači HPC. run() úlohu odešle a okamžitě vrátí objekt Job. Objekt Job používej pro úkoly, které v clusteru pokrývají squeue, výstupní soubor úlohy a scancel. Úloha běží dál i po zavření notebooku.

Příklady na této stránce používají malý pracovní postup, který načte jeden úhel theta a selže, pokud je úhel mimo rozsah. Nahraj ho podle popisu v Nasazení prvního spravovaného pracovního postupu.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit_ibm_catalog": "qiskit-ibm-catalog", "qiskit_serverless": "qiskit-serverless"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

# This cell is hidden from users. It creates the working directory.
from pathlib import Path

Path("./source_files").mkdir(exist_ok=True)

%%writefile ./source_files/my_workflow.py
import math

from qiskit_serverless import get_arguments, save_result

arguments = get_arguments()
theta = arguments["theta"]
if not 0 <= theta <= math.pi:
    raise ValueError(f"theta must be between 0 and pi, got {theta}")

print(f"Computing the expectation value for theta={theta}", flush=True)
save_result({"theta": theta, "expectation_value": math.cos(theta)})

Writing ./source_files/my_workflow.py

Spuštění úlohy

Získej pracovní postup podle jeho názvu a zavolej run() s argumenty, které pracovní postup čte:

# This cell is hidden from users. It uploads the workflow under a title that
# other test notebooks do not use, and makes load("my-workflow") return it.
# It also silences the account warning that job.cancel() logs.
import logging

from qiskit_ibm_catalog import ManagedWorkflow, ManagedWorkflowClient

logging.getLogger("qiskit_ibm_runtime").setLevel(logging.ERROR)

_test_title = "docs-run-managed-workflow"
ManagedWorkflowClient().upload(
    ManagedWorkflow(
        title=_test_title,
        entrypoint="my_workflow.py",
        working_dir="./source_files/",
    )
)
_load = ManagedWorkflowClient.load
ManagedWorkflowClient.load = lambda self, title, *a, **k: _load(
    self, _test_title if title == "my-workflow" else title, *a, **k
)

run_workflow_remotely.ipynb

from qiskit_ibm_catalog import ManagedWorkflowClient

client = ManagedWorkflowClient()
my_workflow = client.load("my-workflow")

job = my_workflow.run(theta=0.5)
job_id = job.job_id

run() vrátí řízení poté, co pracovní postup zařadí úlohu do fronty. Ulož si ID úlohy, abys mohl(a) úlohu najít z nové relace.

Informace o tom, jak zvolit argumenty, které pracovní postup přijímá, a ověřit je před spuštěním úlohy, najdeš v Definice vstupů a výstupů.
Chceš-li úlohu spustit s jinou velikostí výpočetních prostředků, předej function_size. Viz Výběr velikosti pro každé spuštění.

Sledování úlohy

Kontrola stavu

Bezprostředně po zavolání run() je stav obvykle QUEUED: run_workflow_remotely.ipynb

job.status()

'QUEUED'

Stav	Význam
`QUEUED`	Úloha čeká na výpočetní slot.
`INITIALIZING`	Pracovní postup spouští prostředí s výpočetním profilem úlohy.
`RUNNING`	Běží vstupní bod pracovního postupu.
`RUNNING: <stage>`	Vstupní bod nahlásil fázi pomocí `update_status()`, například `RUNNING: WAITING_FOR_QPU`.
`CANCELING`	Zrušil(a) jsi úlohu a pracovní postup ji zastavuje.
`DONE`	Vstupní bod skončil úspěšně.
`ERROR`	Vstupní bod vyvolal chybu nebo skončil s nenulovým kódem. Viz Nalezení příčiny chyby.
`CANCELED`	Zrušil(a) jsi úlohu, nebo dosáhla 24hodinového limitu.

DONE, ERROR a CANCELED jsou konečné stavy a job.in_terminal_state() pro ně vrací True. Smyčka kontroly stavu, která čeká na jinou hodnotu, například SUCCEEDED, nikdy neskončí.

Čekání na dokončení úlohy

Chceš-li počkat, dokud úloha neskončí, zavolej wait_for_final_state(). Vrátí konečný stav a s verbose=True vypisuje každou změnu stavu. Pokud nastavíš timeout v sekundách, wait_for_final_state() vyvolá TimeoutError, jestliže čas vyprší dříve, než úloha skončí. Úloha přitom běží dál:

run_workflow_remotely.ipynb

job.wait_for_final_state(timeout=600, verbose=True)

Waiting for job 3f2a1c0e-6b1d-4c0e-9a51-2f0c4d1e7a90
0:00:00  QUEUED
0:02:10  RUNNING
0:03:05  RUNNING: WAITING_FOR_QPU
0:41:44  DONE
'DONE'

wait_for_final_state() kontroluje stav po 1, 2, 4, 8, 16 a 32 sekundách a poté každých 60 sekund, takže konec krátké úlohy zjistí během několika sekund a u dlouhé úlohy posílá málo požadavků. Chceš-li místo toho kontrolovat v pevném intervalu, předej poll_interval v sekundách.

Čtení logů

Vše, co pracovní postup zapíše na standardní výstup nebo standardní chybový výstup, jde do logů úlohy. Můžeš je číst pomocí job.logs() za běhu úlohy, ještě než má výsledek:

# This cell is hidden from users. It waits for the job to end, so that the
# logs are complete.
job.wait_for_final_state()

run_workflow_remotely.ipynb

print(job.logs())

Computing the expectation value for theta=0.5

# This cell is hidden from users. It checks the logs.
assert "Computing the expectation value for theta=0.5" in job.logs()

Pracovní postup nahrává nové řádky logu přibližně každých 15 sekund a ještě jednou, když úloha skončí nebo je zrušena. Bezprostředně po spuštění úlohy vrací job.logs() text No logs yet.
Pracovní postup uchovává pro každou úlohu nejnovějších 50 MB logů a na začátek přidá řádek, který říká, že logy byly zkráceny.

O tom, co váš pracovní postup loguje, rozhoduješ podle Zápis logů. Chceš-li zobrazit jen řádky odpovídající regulárnímu výrazu, předej include do job.filtered_logs(). Chceš-li řádky skrýt, předej exclude.

Získání výsledku

job.result() počká, dokud úloha neskončí, a poté vrátí hodnotu, kterou pracovní postup předal funkci save_result(): run_workflow_remotely.ipynb

job.result()

{'theta': 0.5, 'expectation_value': 0.8775825618903728}

# This cell is hidden from users. It checks the result.
assert _ == {"theta": 0.5, "expectation_value": 0.8775825618903728}, _  # noqa: F821

Ve výchozím nastavení job.result() kontroluje stav každých 30 sekund a čeká bez časového limitu. Předej maxwait, abys omezil(a) počet kontrol. Například job.result(maxwait=40) čeká přibližně 20 minut. Chceš-li zkontrolovat jednou bez čekání, předej wait=False. Pokud job.result() přestane čekat dříve, než úloha skončí, vrátí {}.

Zjištění, jak dlouho trvala každá fáze

job.events() vypíše každou změnu stavu a fáze úlohy s časem, takže uvidíš, jak dlouho úloha čekala na výpočetní prostředky a jak dlouho trvala každá fáze: run_workflow_remotely.ipynb

for event in reversed(job.events()):
    print(
        event.created,
        event.data.get("status") or event.data.get("sub_status"),
    )

2026-11-02T14:43:07.134377Z QUEUED
2026-11-02T14:43:24.474199Z PENDING
2026-11-02T14:46:07.309519Z RUNNING
2026-11-02T14:46:21.115038Z SUCCEEDED

# This cell is hidden from users. It checks the events.
_statuses = [e.data.get("status") for e in job.events()]
assert "QUEUED" in _statuses and "SUCCEEDED" in _statuses, _statuses

Události používají uložené názvy stavů. PENDING je INITIALIZING a SUCCEEDED je DONE. Informace o využití QPU při spuštění najdeš v Nalezení úloh QPU pro spuštění.

Nalezení příčiny chyby

Když pracovní postup vyvolá výjimku, úloha skončí se stavem ERROR. Například spusť pracovní postup s úhlem, který odmítne: run_workflow_remotely.ipynb

failed_job = my_workflow.run(theta=-1.0)

# This cell is hidden from users. It waits for the job to end.
failed_job.wait_for_final_state()

run_workflow_remotely.ipynb

failed_job.status()

'ERROR'

Logy zobrazují traceback: run_workflow_remotely.ipynb

print(failed_job.logs())

Traceback (most recent call last):
  File "/function_user_data/my_workflow.py", line 8, in <module>
    raise ValueError(f"theta must be between 0 and pi, got {theta}")
ValueError: theta must be between 0 and pi, got -1.0

job.result() raises a QiskitServerlessException: run_workflow_remotely.ipynb

from qiskit_serverless.exception import QiskitServerlessException

try:
    failed_job.result()
except QiskitServerlessException as error:
    print(error)

raise ValueError(f"theta must be between 0 and pi, got {theta}")
ValueError: theta must be between 0 and pi, got -1.0

# This cell is hidden from users. It checks the error.
assert failed_job.status() == "ERROR", failed_job.status()
assert (
    "ValueError: theta must be between 0 and pi, got -1.0"
    in failed_job.logs()
)
assert failed_job.events(type="ERROR") == []

Pokud pracovní postup hlásí chyby pomocí send_error(), přečti je pomocí job.events(type="ERROR") a jejich zprávy pomocí job.error_message(). U úlohy bez nahlášených chyb vrací job.events(type="ERROR") prázdný seznam a job.error_message() vrací {}.

run_workflow_remotely.ipynb

for event in job.events(type="ERROR"):
    print(event.created, event.data.get("code"), event.data.get("message"))

Správa úloh

Zrušení úlohy

Úlohu zrušíš pomocí job.cancel(). Stav se změní na CANCELING, zatímco pracovní postup úlohu zastavuje, a poté na CANCELED: run_workflow_remotely.ipynb

job_to_cancel = my_workflow.run(theta=1.0)
job_to_cancel.cancel()

'Job has been stopped. No active runtime job ID associated with this serverless job ID.'

# This cell is hidden from users. It checks the cancellation.
assert (
    job_to_cancel.wait_for_final_state() == "CANCELED"
), job_to_cancel.status()

job.cancel() vrací zprávu o úloze a o jejích propojených úlohách QPU, které se také pokusí zrušit. U běžící úlohy pracovní postup pošle SIGTERM tvému vstupnímu bodu. Jak uložit částečné výsledky, viz Úklid při zrušení úlohy. Pokud úloha již skončila, job.cancel() vrátí Job already in terminal state. a nic nezmění.

Nalezení úlohy z nové relace

Objekt Job a pracovní postup existují pouze v tvé aktuální relaci Pythonu. Po restartu jádra notebooku předej uložené ID úlohy do client.job() nebo si vypiš své poslední úlohy pomocí client.jobs(): run_workflow_remotely.ipynb

from qiskit_ibm_catalog import ManagedWorkflowClient

client = ManagedWorkflowClient()
job = client.job(job_id)
my_workflow = client.load("my-workflow")

client.jobs(function=my_workflow, status="ERROR", limit=5)

[<Job | e6b1ffa1-cd26-437d-bd53-b265dd4ba952>,
 <Job | 11308f2a-8d7a-40a0-a970-7fdeca2b171b>,
 <Job | af597785-3470-469a-9051-607e0185892e>,
 <Job | a9051931-3bc2-4b80-9ce6-c39d28ce260c>,
 <Job | e329e8e3-e955-4188-9bfd-8f3050ee2d39>]

# This cell is hidden from users. It checks the job lookups.
assert job.result()["theta"] == 0.5
assert failed_job.job_id in [j.job_id for j in _]  # noqa: F821

client.jobs() vrací tvých 10 nejnovějších úloh, nejnovější první. Filtruj je pomocí function, status (z tabulky stavů) nebo created_after (časové razítko ISO 8601) a procházej je pomocí limit a offset. Chceš-li vypsat pracovní postupy, které jsi nahrál(a), zavolej client.list().

Tabulka Workloads na IBM Quantum Platform také uvádí tvé úlohy s jejich stavem, výpočetním profilem a dobami běhu.

Časový limit

Spravovaný pracovní postup zruší úlohu, která běží déle než 24 hodin, a úloha skončí se stavem CANCELED. Při dlouhých během ukládej kontrolní body do souborového úložiště, abys o práci nepřišel(la).

Řešení problémů s úlohami

Problém	Příčina
`run()` selže s `Code: 429` a `Active job limit reached.`	Dosáhl(a) jsi limitu aktivních úloh. Počkej, až některé úlohy skončí, nebo zruš úlohy, které už nepotřebuješ.
Úloha zůstává ve stavu `QUEUED` a `run()` upozornilo, že `your account, plan or subscription is blocked`.	Úloha se nespustí, dokud nebude blokace tvého účtu, plánu nebo předplatného zrušena. Obrať se na svého správce.
`job.logs()` vrací `No logs yet.`	Úloha je ve frontě nebo se právě spustila. Počkej přibližně 15 sekund.
`job.result()` vrací `{}`	Úloha neskončila, byla zrušena nebo neuložila žádný výsledek. Viz Ukládání výsledků.
`job.error_message()` vrací `{}`	Pracovní postup vyvolal výjimku, aniž by nahlásil chybu. Přečti si traceback pomocí `job.logs()`.
Úloha je `CANCELED`, ale ty jsi ji nezrušil(a)	Úloha dosáhla 24hodinového limitu.

Další kroky

Doporučení

Zápis logů a zpracování chyb, kde nastavíš logy a chyby, které úloha hlásí.
Spuštění parametrického průchodu, kde spustíš pracovní postup jednou pro každou sadu vstupů.

Spuštění úlohy​

Sledování úlohy​

Kontrola stavu​

Čekání na dokončení úlohy​

Čtení logů​

Získání výsledku​

Zjištění, jak dlouho trvala každá fáze​

Nalezení příčiny chyby​

Správa úloh​

Zrušení úlohy​

Nalezení úlohy z nové relace​

Časový limit​

Řešení problémů s úlohami​

Další kroky​

Spuštění úlohy

Sledování úlohy

Kontrola stavu

Čekání na dokončení úlohy

Čtení logů

Získání výsledku

Zjištění, jak dlouho trvala každá fáze

Nalezení příčiny chyby

Správa úloh

Zrušení úlohy

Nalezení úlohy z nové relace

Časový limit

Řešení problémů s úlohami

Další kroky