Asincronacht agus Dea-Chleachtais
Ar an leathanach seo
I/A Asincronach: Riachtanas Teicniúil
Caithfidh gach gníomhaíocht i Mistral Workflows oibríochtaí ionchuir/aschuir asincronacha a úsáid. Ní moladh stíle é seo; srian teicniúil atá ann. Reáchtáil chomhthreomhar a chuireann glaonna blocála cosúil le requests.post() ar an obairí ar fad ar ceal agus coscaíonn sé aon ghníomhaíocht eile ó rith.
Eascraíonn an riachtanas seo ó ailtireacht an oibreora, a fheidhmíonn gníomhaíochtaí laistigh de lúba imeachta asyncio. Nuair a fhanann coraitín le freagra líonra go hasincronach, tugann sé smacht ar ais don lúb, rud a ligeann do ghníomhaíochtaí eile dul ar aghaidh. I gcodarsnacht leis sin, ní thugann glaonna comhthreomhara aon smacht ar ais.
import requests
# MÍCHEART: Blocálann sé an t-oibreoir ar fad
@workflows.activity()
async def blocking_activity(url: str) -> dict:
# Is comhthreomhar é requests.post() — blocálann sé an lúb imeachta
response = requests.post(url, json={"query": "test"})
return response.json()
Is féidir leis an siomptóm sa táirgeadh a bheith mearbhallach: seolann tú deich ngníomhaíocht i gcomhthráth le asyncio.gather, ach feidhmíonn siad ceann i ndiaidh a chéile i ndáiríre. Má fhanann gach ceann dhá shoicind le haghaidh API i gcéin, tomhaiseann tú fiche soicind in ionad an dá shoicind a bhí súil leo, gan aon earráidí a thógáil.
Roghnaigh Leabharlanna atá Asincronach go Dúchasach
Is é an réiteach gach leabharlann bhlocála a chur in ionad a leagan comhionann asincronach. I gcás glaonna HTTP, is é httpx an rogha réamhshocraithe.
import httpx
# CEART: Gan blocáil
@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()
Freastalaíonn aiohttp ar an gcuspóir céanna le API beagán difriúil bunaithe ar sheisiúin.
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()
I gcás bunachair shonraí, téann asyncpg in ionad psycopg2 do PostgreSQL. Tabhair faoi deara an bloc try/finally: caithfear an nasc a dhúnadh fiú má ardaíonn an cheist earráid. Murach sin, ídeoidh iarrachtaí athfhillteacha an linn naisc.
import asyncpg
# CEART: Tiománaí Asincronach 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()
Leanann rochtain ar chomhaid an loighic chéanna le aiofiles, fiú do chomhaid bheaga ina mbeifeá buartha faoi open() a úsáid fós.
import aiofiles
# CEART: Léamh comhad asincronach
@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)}
Níl SDK Mistral féin eisceachtúil: tá leagan ag gach modh atá iarmhírthe ag _async, agus is é sin an ceann ba chóir duit a ghlaowh ó ghníomhaíocht.
from mistralai.client import Mistral
@workflows.activity()
async def call_mistral(prompt: str) -> dict:
client = Mistral()
# Úsáid complete_async, NÍ complete
response = await client.chat.complete_async(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}]
)
return {"response": response.choices[0].message.content}
Coinnigh an tábla mapála seo ar láimh le linn athbhreithnithe cód: is fabht feidhmíochta féideartha é aon líne ón gcolún clé a fheictear i ngníomhaíocht.
| Oibríocht | Mícheart (blocála) | Ceart (asincronach) |
|---|---|---|
| HTTP | requests.get() | httpx.AsyncClient().get() |
| HTTP | urllib.request.urlopen() | aiohttp.ClientSession().get() |
| PostgreSQL | psycopg2.connect() | asyncpg.connect() |
| MySQL | mysql.connector.connect() | aiomysql.connect() |
| Redis | redis.Redis() | redis.asyncio.Redis() |
| Comhaid | open() | aiofiles.open() |
| Codladh | time.sleep() | asyncio.sleep() |
| Mistral | client.chat.complete() | client.chat.complete_async() |
Nuair nach bhfuil Leagan Asincronach ann
Ní thugann roinnt leabharlann gnó, cosúil le SDK dílseánaigh nó cliant seanbhunaithe, leagan asincronach ar bídís. Sa chás seo, ligeann asyncio.to_thread() duit an cód blocála a rith i snáithe ar leith gan an lúb imeachta a reo.
import asyncio
from some_library import blocking_function
@workflows.activity()
async def compatibility_activity(params: dict) -> dict:
"""Clúdaíonn sé glaonna blocála i snáithe."""
result = await asyncio.to_thread(
blocking_function,
params["arg1"],
params["arg2"]
)
return {"result": result}
Is comhréiteach é seo, ní réiteach comhionann: ídíonn gach glaó snáithe ón linn, atá teoranta ó thaobh méide de. I gcás gníomhaíochta a ghlaotar go maiveach i gcomhthráth, ní dhéanann tú ach an bac a aistriú seachas é a bhaint. Is fearr i gcónaí leabharlann atá asincronach go dúchasach a úsáid nuair atá ceann ar fáil.
Gníomhaíochtaí Glana a Dearadh
Thar asincronacht, is iad ceithre nós a dhéanann idirdhealú idir gníomhaíocht láidir agus ceann a chuirfidh uaireanta de bhriseadh ceann ort.
Is é an chéad cheann ná raon feidhme. Ba chóir freagracht amháin agus gan ach ceann amháin a bheith ag gníomhaíocht, toisc gurb é an t-aonad athfhillte agus marthanachta é freisin: déanfaidh gníomhaíocht uileghabhálach a theipeann agus é ag seoladh ríomhphoist an t-asbhaint agus an anailís a athsheinm ón tús.
# MAITH: Tá freagracht shoiléir ag gach gníomhaíocht
@workflows.activity()
async def extract_text(url: str) -> dict:
# ...
pass
@workflows.activity()
async def analyze_sentiment(text: str) -> dict:
# ...
pass
# OLc: Gníomhaíocht uileghabhálach
@workflows.activity()
async def do_everything(url: str) -> dict:
text = ... # asbhaint
sentiment = ... # anailís
# seol ríomhphost
# sábháil chuig DB
pass
Baineann an dara ceann le hacmhainní. Ráthaíonn bainisteoir comhthéacs async with go ndúntar an cliant fiú má tharlaíonn earráid, rud a dhéanann glaonna láimhe dearmad go minic sooner nó later.
@workflows.activity()
async def clean_request(params: dict) -> dict:
# Úsáid async with chun dúnadh a ráthú
async with httpx.AsyncClient() as client:
response = await client.get(params["url"])
# Dúntar an cliant go huathoibríoch anseo
return response.json()
Tá an tríú ceann níos fíneálta: ní tuilleann gach earráid iarracht athfhillte. Is sealadach iad teorainn ama, 429, nó 500 agus ba chóir dóibh teacht chun cinn chun athfhillte a spreagadh. Léiríonn earráid 4xx, áfach, iarratas neamhbhailí nach réiteoidh trí iarracht athfhillte é. Ina ionad sin, fill toradh sainráite agus lig don sreabhadh oibre cinneadh a dhéanamh.
@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 # Déanfar athfhillte air ag an ardán
except httpx.HTTPStatusError as e:
if e.response.status_code == 429:
raise # Ráta teoranta — déanfar athfhillte air
elif e.response.status_code >= 500:
raise # Earráid freastalaí — déanfar athfhillte air
else:
# Earráid cliant (4xx) — ná déan athfhillte
return {"status": "error", "code": e.response.status_code}
Ar deireadh, eascraíonn an ceathrú nós as an teorainn 2 MB in aghaidh na nglaonna: ná fill ach an méid atá ag teastáil ón sreabhadh oibre chun an chéad chéim eile a chinneadh. Is leor beagnach i gcónaí comhaireamh, sampla, agus an URL chuig an toradh iomlán.
@workflows.activity()
async def extract_data(source: str) -> dict:
data = await retrieve_large_data(source)
# Fill ach an méid atá ag teastáil ón sreabhadh oibre
return {
"item_count": len(data),
"summary": data[:10], # Ní ach an chéad 10
"full_url": await upload_results(data)
}
Príomhphointí
- Tá I/A Asincronach éigeantach: úsáid
httpx,asyncpg,aiofilesin ionad a gcomhpháirtithe comhthreomhara - Reoíonn glaonna blocála (
requests,psycopg2,open) an t-oibreoir ar fad - Úsáid
asyncio.to_thread()mar rogha dheireanach do leabharlanna gan leagan asincronach - Caithfidh freagracht shoiléir amháin a bheith ag gach gníomhaíocht
- Dún naisc i gcónaí le
async with - Láimhseáil earráidí go sainráite: ba chóir athfhillte a dhéanamh ar chuid acu, ach ní ar chuid eile
- Teorainn a chur le méideanna fillte chun fanacht faoin teorainn 2 MB