Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Laikinieji URL ir atsisiuntimo strategijos

Paskaita 13 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Pradedantisiems
Šiame puslapyje
  1. Laikinai sugeneruotų vaizdų tvarkymas
  2. Laikinų URL problema
  3. 1 strategija: Momentinis atsisiuntimas
  4. 2 strategija: Base64 naudojimas
  5. 3 strategija: Automatinis debesijos saugojimas
  6. 4 strategija: Leisti xAI saugoti vaizdą
  7. Patikima sistema su kartojimu
  8. Geriausios praktikos
  9. Svarbiausi punktai

Pamoka užbaigta 2026 m. lapkričio 3 d. remiantis Image Generation ir Imagine outputs puslapiais iš xAI: parametras storage_options leidžia išsaugoti vaizdą Files API ir sukurti nuolatinį viešąjį URL; dokumentacijoje nenurodyta laikinų URL galiojimo trukmė (ankstesnėje versijoje minėtos „403 arba 404 klaidos“ čia nefigūruoja); vaizdai pagal nutylėjimą generuojami JPEG formatu. Šaltiniai: Image Generation · Imagine outputs.

Laikinai sugeneruotų vaizdų tvarkymas

Vaizdų generavimo ir redagavimo API grąžinami URL yra laikini: xAI dokumentacija juos apibūdina kaip trumpalaikius, nenurodydama tikslios galiojimo trukmės, ir ragina vaizdus atsisiųsti arba apdoroti nedelsiant. Šis apribojimas tiesiogiai veikia tavo programų kūrimo būdą.

Laik.
Išvesties URL
b64
Nuolatinė alternatyva
+33%
Base64 dydžio perteklius
30 dienų
xAI saugykla arba neribotai

Laikinų URL problema

Naudojant response_format="url" (numatytoji reikšmė), API grąžina laikiną URL. Po nenustatyto laiko tarpo jis nustoja teikti vaizdą.

# Laikinas URL: atsisiųskite nedelsiant
response = client.images.generate(
    model="grok-imagine-image",
    prompt="A mountain landscape"
)

url = response.data[0].url

Pasekmė: šių URL negalima saugoti duomenų bazėje ir naudoti vėliau. Vaizdus privalai sistemingai atsisiųsti.

1 strategija: Momentinis atsisiuntimas

Patikimiausia strategija – atsisiųsti kiekvieną vaizdą iškart po jo sugeneravimo:

import urllib.request
import os
from datetime import datetime

def generate_and_save(prompt, output_dir="images"):
    """Sugeneruoja vaizdą ir jį iškart išsaugo."""
    os.makedirs(output_dir, exist_ok=True)

    response = client.images.generate(
        model="grok-imagine-image",
        prompt=prompt
    )

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filepath = os.path.join(output_dir, f"gen_{timestamp}.jpg")  # Pagal nutylėjimą JPEG

    urllib.request.urlretrieve(response.data[0].url, filepath)
    print(f"Vaizdas išsaugotas: {filepath}")
    return filepath

2 strategija: Base64 naudojimas

Prašant atsako Base64 formatu, gauni tiesioginius vaizdo binarinius duomenis, nesiremdamas laikinu URL:

import base64

response = client.images.generate(
    model="grok-imagine-image",
    prompt="A mountain landscape",
    response_format="b64_json"
)

# Duomenys yra tiesiogiai atsakyme
image_bytes = base64.b64decode(response.data[0].b64_json)

with open("mountain.jpg", "wb") as f:  # Pagal nutylėjimą JPEG
    f.write(image_bytes)

Base64 privalumai

Base64 privalumas telpa į vieną žodį: autonomija. Vaizdas atkeliauja tiesiogiai JSON atsakyme, nesiremiant laikinu URL, kuris gali nustoti galioti prieš tavo kodui jį panaudojant, ir be papildomo HTTP užklausos atsisiuntimui – vienu tinklo ciklu mažiau reiškia vienu gedimo tašku mažiau tavo sistemoje.

Base64 trūkumai

Kompromisas yra mechaninis: Base64 kodavimas padidina JSON atsako dydį apie 33 %, kas kainuoja trigubai – API atsako perdavimo laiku, kliento pusėje dekodavimui sunaudojama atmintimi ir sudėtingumu, jei viename užklausime apdoroji kelis didelės raiškos vaizdus. Vienam vaizdui tai nereikšminga, tačiau dešimčiai 2k vaizdų partijoje skirtumas tampa apčiuopiamas.

3 strategija: Automatinis debesijos saugojimas

Gamybinėms programoms derink generavimą su įkėlimu į savo saugyklą:

import boto3
import urllib.request
import tempfile

def generate_and_upload_s3(prompt, bucket, key):
    """Sugeneruoja vaizdą ir jį iškart įkelia į S3."""
    response = client.images.generate(
        model="grok-imagine-image",
        prompt=prompt
    )

    # Atsisiuntimas į laikiną failą
    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
        urllib.request.urlretrieve(response.data[0].url, tmp.name)

        # Įkėlimas į S3
        s3 = boto3.client("s3")
        s3.upload_file(tmp.name, bucket, key)

    permanent_url = f"https://{bucket}.s3.amazonaws.com/{key}"
    return permanent_url

4 strategija: Leisti xAI saugoti vaizdą

Kiekvienas Imagine užklausimas priima storage_options parametrą, kuris išsaugo sukurtą vaizdą tavo komandos Files API ir papildomai gali sukurti nuolatinį viešąjį URL bendrinimui arba įterpimui. Naudojant xAI SDK:

import os
import xai_sdk

client_xai = xai_sdk.Client(api_key=os.getenv("XAI_API_KEY"))

response = client_xai.image.sample(
    prompt="A mountain landscape at sunrise",
    model="grok-imagine-image-2.0",
    storage_options={"filename": "mountain.jpg", "public_url": True},
)

print(response.file_output.file_id)  # stabilus identifikatorius Files API
print(response.public_url)           # nuolatinis viešasis URL

Atsakyme lieka įprastas laikinas URL ir kiekvienam vaizdui pridėtas file_output blokas: file_id, filename ir, jei prašyta, public_url. Privalomas tik filename: be kitų parinkčių vaizdas saugomas privačiai, be galiojimo pabaigos ar viešojo URL. expires_after (nuo 3 600 sekundžių iki 30 dienų) planuoja failo ištrynimą, o public_url taip pat priima savo expires_after, kuris negali viršyti paties failo galiojimo. Komanda gali turėti iki 1 000 aktyvių viešųjų URL; viršijus šį limitą arba įvykus incidentui, vaizdas vis tiek išsaugomas, o atsakyme vietoj URL pateikiama public_url_error. Naudojant REST, tas pats storage_options objektas dedamas į užklausos kūną, taip pat ir redaguojant.

Patikima sistema su kartojimu

Laikini URL kartais gali nepavykti atsisiųsti. Įdiek kartojimo mechanizmą:

import time
import urllib.request
import urllib.error

def download_with_retry(url, filepath, max_retries=3):
    """Atsisiunčia vaizdą, kartodamas bandymus klaidos atveju."""
    for attempt in range(max_retries):
        try:
            urllib.request.urlretrieve(url, filepath)
            return True
        except urllib.error.URLError as e:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Eksponentinis delsos didinimas
                print(f"{attempt + 1} bandymas nepavyko, kartojama po {wait_time}s...")
                time.sleep(wait_time)
            else:
                print(f"Nepavyko po {max_retries} bandymų: {e}")
                return False

Geriausios praktikos

Visa disciplina kyla iš vieno fakto: URL yra laikini. Todėl atsisiuntimas turi vykti iškart po generavimo, tame pačiame kodo sraute – kiekviena minutės tarpas yra langas, kuriame vaizdas gali tapti neatkuriamas. Dėl tos pačios priežasties laikino URL niekada negalima saugoti duomenų bazėje kaip nuolatinės nuorodos: kitą kartą jį tikrinant jis jau bus neveikiantis, o tai yra klaida, kuri pasireiškia tik gamyboje, po kelių dienų. Kritinėse programose, kur patikimumas yra pirmoje vietoje, apeik šią problemą naudodamas b64_json, kuris pateikia vaizdą atsakyme, arba storage_options, kuris išlaiko jį xAI su stabiliu identifikatoriumi.

Pats atsisiuntimas заслужуя tokio paties dėmesio kaip ir bet kuri kita tinklo operacija: kartojimas su eksponentine delsa trumpalaikiams gedimams sugerti, failų pavadinimų generavimas pagal laiko žymą arba unikalų identifikatorių, kad būtų išvengta kolizijų vykdant lygiagrečius generavimus. Galiausiai, registruok metaduomenis – raginimą, modelį, parametrus – kartu su kiekvienu išsaugotu vaizdu: po šešių mėnesių, kai reikės regeneruoti vizualą „kaip tas, bet 2k“, šis žurnalas bus neįkainojamas.

Svarbiausi punktai

  • Išvesties URL yra laikini: atsisiųskite nedelsiant
  • b64_json formatas išvengia laikinų URL problemos
  • Base64 padidina atsako dydį ~33 %
  • Patikimumui įdiek kartojimą su eksponentine delsa
  • Gamyboje įkelkite į nuolatinę saugyklą (S3, GCS) arba leiskite xAI saugoti vaizdą naudojant storage_options