Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Apstrāde kļūdām un izvietošana ražošanā

Nodarbība 12 no 12 Atjaunota 2026. gada 3. novembris Vidējs
Šajā lapā
  1. Sagatavo savu lietotni ražošanai
  2. Divas kļūdu saimes, divi brīži
  3. Atkārtoti mēģini gudri
  4. Rinda, lai saglabātu tempu
  5. Pārbaudi savu atslēgu, pirms uz to paļaujies
  6. Redzi, kas notiek ražošanā
  7. Galvenās atziņas
  8. Pārbaudi savas zināšanas

Atjaunināts 2026. gada 2. novembrī, pamatojoties uz xAI video dokumentāciju un xai-sdk 1.21.0 kodu: client.video.generate (nevis client.videos), rezultāts laukā url, kļūdas tiek ziņotas ar VideoGenerationError un kodu (invalid_argument, service_unavailable…), pieprasījumu limita pārsniegums tiek saņemts kā grpc.RpcError ar kodu RESOURCE_EXHAUSTED — klase RateLimitError un statuss expired nepastā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 no usage.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 kodsCēlonisRisinājums
400Nederīgi parametri (piemēram, nezināma balss reference_audios)Labo pieprasījumu
401Nederīga vai beidzies derīguma termiņš API atslēgaiPārbaudi autentifikāciju
429Pārsniegts pieprasījumu limits (pieprasījumi sekundē atkarībā no līmeņa)Ievies atkāpšanos (backoff)
500Servera kļūdaMēģ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.

StatussIespējamais cēlonisDarbība
failed + invalid_argument vai permission_deniedPieprasījums vai saturs noraidītsMaini uzvedni vai avotu
failed + service_unavailable vai internal_errorServiss pārslogots, incidentsMēģ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.