Apstrāde kļūdām un izvietošana ražošanā
Šajā lapā
Atjaunināts 2026. gada 2. novembrī, pamatojoties uz xAI video dokumentāciju un
xai-sdk1.21.0 kodu:client.video.generate(nevisclient.videos), rezultāts laukāurl, kļūdas tiek ziņotas arVideoGenerationErrorun kodu (invalid_argument,service_unavailable…), pieprasījumu limita pārsniegums tiek saņemts kāgrpc.RpcErrorar koduRESOURCE_EXHAUSTED— klaseRateLimitErrorun statussexpirednepastāv. Papildinājums 2026. gada 3. novembrī: pieprasījumu limits skaita pieprasījumus sekundē (10 ievades līmenī), nevis “60 RPM”, un faktiskās izmaksas par ģenerēšanu tiek nolasītas nousage.cost_in_usd_ticks. Avoti: Video ģenerēšana · Pieprasījumu limiti.
Sagatavo savu lietotni ražošanai
Skriptam, kas ģenerē video tavā datorā, un servisam, kas ražo simtiem video dienā reāliem lietotājiem, ir maz kopīga. Pēdējam ir jāapstrādā moderācijas atteikumi, kvotu pārsniegumi, serveru incidenti un URL adreses ar beigu termiņu, nekad neticami zaudējot apmaksātu ģenerēšanu. Šī nodarbība aptver mehānismus, kas rada atšķirību: kļūdu klasifikāciju, atkārtotu mēģinājumu stratēģiju, rindu arhitektūru un novērojamību.
Divas kļūdu saimes, divi brīži
Pirmā saime parādās uzreiz, POST izsaukuma brīdī. Tās ir stingras pieprasījuma kļūdas, un HTTP kods ir pietiekams, lai izlemtu, ko darīt.
| HTTP kods | Cēlonis | Risinājums |
|---|---|---|
| 400 | Nederīgi parametri (piemēram, nezināma balss reference_audios) | Labo pieprasījumu |
| 401 | Nederīga vai beidzies derīguma termiņš API atslēgai | Pārbaudi autentifikāciju |
| 429 | Pārsniegts pieprasījumu limits (pieprasījumi sekundē atkarībā no līmeņa) | Ievies atkāpšanos (backoff) |
| 500 | Servera kļūda | Mēģini vēlreiz ar eksponenciālu atkāpšanos |
Otrā saime izpaužas daudz vēlāk, aptaujas (polling) laikā, pēc tam, kad pieprasījums ir pieņemts un ģenerēšana ir sākusies.
| Statuss | Iespējamais cēlonis | Darbība |
|---|---|---|
failed + invalid_argument vai permission_denied | Pieprasījums vai saturs noraidīts | Maini uzvedni vai avotu |
failed + service_unavailable vai internal_error | Serviss pārslogots, incidents | Mēģini vēlreiz vēlāk |
Šī atšķirība nav akadēmiska: 400 kļūdai ir uzreiz jāatgriežas zvanītājam, jo vainīgs ir kods, savukārt failed statuss rodas pēc vairāku minūšu gaidīšanas un ir jāapstrādā uzdevuma kontekstā, nevis HTTP pieprasījumā, kas to izraisīja.
Atkārtoti mēģini gudri
Kopējais pamats ir eksponenciāla atkāpšanās ar nelielu nejaušību (jitter). Kavējuma dubultošana dod pārejošam incidentam laiku atrisināties, bet nejaušība novērš to, ka visi tavi procesi mēģina vēlreiz vienlaicīgi pēc pieprasījumu pīķa — parādība, kas pārvērš mikro-pārtraukumu ilgstošā kļūmē.
import asyncio
import random
async def call_with_retry(func, max_retries=3, base_delay=2):
"""Izpilda funkciju ar atkārtotu mēģinājumu un eksponenciālu atkāpšanos."""
for attempt in range(max_retries + 1):
try:
return await func()
except Exception as e:
if attempt == max_retries:
raise
# Eksponenciāla atkāpšanās ar nejaušību
delay = base_delay * (2 ** attempt) + random.uniform(0, 1)
print(f"Mēģinājums {attempt + 1} neizdevās: {e}. Atkārtosim pēc {delay:.1f}s")
await asyncio.sleep(delay)
Tomēr šī vispārīgā shēma nav pietiekama, jo ne visas kļūdas ir pelnījušas vienādu pacietību. Kvotas pārsniegums tiek atrisināts, pagaidot veselu minūti; moderācijas atteikums nekad netiks atrisināts, un atkārtots mēģinājums nozīmē maksāt vairākas reizes par vienu un to pašu kļūmi. Tālāk esošā funkcija atdala šos gadījumus.
import asyncio
from datetime import timedelta
import grpc
from xai_sdk.video import VideoGenerationError
# Kļūdu kodi, kurus atkārtots mēģinājums neatrisinās
REQUIRES_FIX = {"invalid_argument", "permission_denied", "failed_precondition"}
async def generate_with_retry(client, params, max_retries=3):
"""Video ģenerēšana ar mērķtiecīgu atkārtotu mēģinājumu (klients: xai_sdk.AsyncClient)."""
for attempt in range(max_retries + 1):
is_last = attempt == max_retries
try:
return await client.video.generate(**params)
except VideoGenerationError as e:
if e.code.lower() in REQUIRES_FIX or is_last:
raise # pieprasījums vai saturs noraidīts: labo pirms atkārtotas palaišanas
await asyncio.sleep(5 * (attempt + 1)) # serviss pārslogots, incidents
except grpc.RpcError as e:
if e.code() != grpc.StatusCode.RESOURCE_EXHAUSTED or is_last:
raise
await asyncio.sleep(2 ** attempt) # pieprasījumu limits: atkāpšanās
except TimeoutError:
if is_last:
raise
# Ļauj vairāk laika nākamajam mēģinājumam
params["timeout"] = params.get("timeout", timedelta(minutes=10)) + timedelta(minutes=2)
Rinda, lai saglabātu tempu
Tiklīdz tavs serviss sāk saņemt pieprasījumus no vairākiem lietotājiem, tev ir jāatdala pieprasījumu saņemšana no to izpildes un, pats galvenais, jāierobežo vienlaicīgums, lai paliktu zem sava līmeņa pieprasījumu limita. Rinda, kas apvienota ar semaforu, apmierina abas vajadzības: uzdevumi brīvi sakrājas, bet vienlaicīgi tiek izpildīti maksimāli desmit.
import asyncio
from collections import deque
class VideoGenerationQueue:
def __init__(self, client, max_concurrent=10):
self.client = client
self.queue = deque()
self.semaphore = asyncio.Semaphore(max_concurrent)
self.results = {}
async def add(self, job_id, params):
"""Pievieno ģenerēšanu rindai."""
self.queue.append((job_id, params))
async def process(self):
"""Apstrādā visas gaidošās ģenerēšanas."""
tasks = []
while self.queue:
job_id, params = self.queue.popleft()
task = asyncio.create_task(
self._execute(job_id, params)
)
tasks.append(task)
await asyncio.gather(*tasks, return_exceptions=True)
async def _execute(self, job_id, params):
"""Izpilda ģenerēšanu ar vienlaicīguma kontroli."""
async with self.semaphore:
try:
result = await generate_with_retry(
self.client, params
)
self.results[job_id] = {
"status": "done",
"url": result.url
}
except Exception as e:
self.results[job_id] = {
"status": "failed",
"error": str(e)
}
Ņem vērā, ka katrs uzdevums saglabā savu iznākumu results, neatkarīgi no tā, vai tas ir veiksmīgs vai ne: ģenerēšana, kas pazūd bez pēdām, ir incidents, ko neviens nevar diagnosticēt.
Otrs arhitektūras reflekss attiecas uz glabāšanu. Tā kā video URL adreses ir pagaidu, lejupielādei ir jābūt automātiskai un tūlītējai, ar laika zīmogu nosaukumiem, kas garantē, ka starp divām vienlaicīgām ģenerēšanām nebūs sadursmju.
import httpx
from pathlib import Path
from datetime import datetime
async def save_video(video_url, output_dir="./videos"):
"""Lejupielādē un saglabā ģenerēto video."""
Path(output_dir).mkdir(parents=True, exist_ok=True)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
file_path = f"{output_dir}/video_{timestamp}.mp4"
async with httpx.AsyncClient() as client:
resp = await client.get(video_url)
resp.raise_for_status()
Path(file_path).write_bytes(resp.content)
return file_path
Pārbaudi savu atslēgu, pirms uz to paļaujies
Galapunkts GET /v1/api-key informē tevi par tavas atslēgas stāvokli. Tās izsaukšana servisa startēšanas brīdī ļauj izvairīties no situācijas, kad bloķētu atslēgu atklāj tikai pēc divdesmit neveiksmīgiem pieprasījumiem, kamēr tavi lietotāji gaida.
resp = httpx.get(
"https://api.x.ai/v1/api-key",
headers={"Authorization": f"Bearer {api_key}"}
).json()
if resp.get("api_key_blocked") or resp.get("api_key_disabled") or resp.get("team_blocked"):
raise RuntimeError("API atslēga vai komanda ir bloķēta, vai arī atslēga ir atspējota")
Redzi, kas notiek ražošanā
Lai vadītu video ģenerēšanas servisu, pietiek ar pieciem rādītājiem. Veiksmes rādītājs, proti, to ģenerēšanu īpatsvars, kas beidzas ar done, mēra vispārējo veselību. Vidējais ģenerēšanas laiks, mērīts no iesniegšanas līdz done statusam, kalpo, lai kalibrētu tavus noilgumus un informētu lietotājus. Kļūdu līmenis, sadalīts pa veidiem — failed pēc kļūdas koda, noilgums, pieprasījumu limits — norāda, kur koncentrēt pūles: piemēram, noilgumu pieaugums bez failed pieauguma signalizē, ka ģenerēšana ir lēnāka par tavu gaidīšanas termiņu, nevis ka tā ir kļūdaina. Kumulatīvās izmaksas, ko iegūst, summējot lauku usage.cost_in_usd_ticks no katra rezultāta (viens dolārs ir vienāds ar 10 miljardiem tikšu), vai alternatīvi, reizinot ģenerētos ilgumus ar modeļa cenu par sekundi, ir jāuzrauga ikdienā. Visbeidzot, kvotu izmantojums, izteikts pieprasījumos sekundē attiecībā pret sava līmeņa limitu (10 ievades līmenī video modeļiem), ļauj paredzēt piesātinājumu, pirms tas pārvēršas 429 kļūdās.
Šie rādītāji dabiski veidojas no strukturēta žurnāla, kur katra ģenerēšana atstāj rindu, ko var izmantot tava analīzes rīks.
import logging
import json
logger = logging.getLogger("video-generation")
def log_generation(request_id, status, duration_s, cost, time_ms):
logger.info(json.dumps({
"event": "video_generation",
"request_id": request_id,
"status": status,
"duration_seconds": duration_s,
"cost_usd": cost,
"processing_time_ms": time_ms
}))
Pirms atver savu servisu publiskai lietošanai, pārskati visu no sākuma. Eksponenciālai atkāpšanās ar nejaušību ir jābūt ieviestai, un vienlaicīgums ir jāierobežo ar semaforu, lai paliktu zem pieprasījumu limita. Video lejupielādēm ir jānotiek automātiski, tiklīdz tās ir gatavas, nepaļaujoties uz cilvēka rīcību. Katrai ģenerēšanai ir jāatstāj žurnāla ieraksts, kas nes tās request_id, statusu un izmaksas, pretējā gadījumā kļūdu līmenis un vidējais ģenerēšanas laiks paliks nepārbaudāmi. Pārbaudi API atslēgas stāvokli startēšanas brīdī, nevis pie pirmās kļūmes. Un noteic budžetu ar pārsnieguma brīdinājumiem: pie 0,05 USD par sekundi, neierobežots atkārtotu mēģinājumu cikls patērē līdzekļus ātrāk, nekā domā.
Cenas pārbaudītas 2026. gada 3. novembrī — cenas regulāri mainās: pirms jebkāda budžeta aprēķina pārbaudi aktuālo cenu lapu oficiālajā xAI modeļu un cenu lapā.
Galvenās atziņas
- Kļūdas dalās sinhronās (pieprasījuma) un asinhronās (ģenerēšanas)
- Ne visas kļūdas ir pelnījušas atkārtotu mēģinājumu: moderācija ir galīga
- Izmanto semaforu, lai ierobežotu vienlaicīgas ģenerēšanas
- Pagaidu URL adreses prasa tūlītēju un sistemātisku lejupielādi
- Uzraugi izmaksu, veiksmes un ģenerēšanas laika rādītājus, lai vadītu savu servisu
Pārbaudi savas zināšanas
Ģeneratīvais video ražošanā: apstiprini pilnu darbplūsmu.
1. Kādas ir video uzvednes īpatnības?
Atbilde: Apraksti darbību un kustību, ne tikai ainu: subjekts, pārvietošanās, noskaņa, kadrs — laika dimensija ir tas, kas atšķir video uzvedni no attēla uzvednes.
2. Ko ļauj attēls-video (image-to-video)?
Atbilde: Animēt esošu attēlu vai ievietot konkrētus cilvēkus un produktus jaunā ainā, izmantojot atsauces attēlus — un, izmantojot grok-imagine-video-1.5, fiksēt pirmo, pēdējo vai galvenos attēlus: tava vizuālā identitāte kļūst par sākumpunktu, nevis par nejaušību.
3. Rediģēšana un pagarināšana: kādi lietojumi?
Atbilde: /videos/edits modificē ģenerētu video, /videos/extensions to pagarina — un abi apvienojumā ļauj veidot garas secības ar iterācijām.
4. Kāpēc darbplūsma ir asinhrona?
Atbilde: Video ģenerēšana prasa laiku: tu iesniedz uzdevumu, aptaujā tā statusu un pēc tam iegūsti rezultātu — xAI SDK automatizē šo aptauju.
5. Kas jāplāno ražošanai?
Atbilde: Kļūdu apstrāde un neveiksmīgi uzdevumi, izejas datu tūlītēja lejupielāde un izmaksu izsekošana (izšķirtspēja, ilgums, iterācijas) — video ir visdārgākais modalitātes veids: tam ir jābūt budžetam.
Laika uzvedne, vizuālā atsauce, apgūta asinhronitāte: ģeneratīvais video kļūst par konveijeru — nevis par loteriju.