Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Midlertidige URL'er og downloadstrategier

Lektion 13 af 14 Opdateret 3. november 2026 Begynder
På denne side
  1. Håndtering af flygtige genererede billeder
  2. Problemet med midlertidige URL’er
  3. Strategi 1: Øjeblikkeligt download
  4. Strategi 2: Brug af Base64
  5. Strategi 3: Automatisk cloud-lagring
  6. Strategi 4: Lad xAI gemme billedet
  7. Robust pipeline med genforsøg
  8. Bedste praksis
  9. Vigtige pointer

Lektion afsluttet den 3. november 2026 baseret på siderne Image Generation og Imagine outputs fra xAI: parameteren storage_options gemmer billedet i Files API og kan oprette en permanent offentlig URL; dokumentationen specificerer ikke levetiden for flygtige URL’er (de „403- eller 404-fejl” fra den tidligere version forekommer ikke her); billeder outputtes som JPEG som standard. Kilder: Image Generation · Imagine outputs.

Håndtering af flygtige genererede billeder

URL’er returneret af API’et til generering og redigering af billeder er midlertidige: xAIs dokumentation beskriver dem som kortlivede uden at specificere deres levetid, og beder dig om at downloade eller behandle billederne uden forsinkelse. Denne begrænsning påvirker direkte, hvordan du designer dine applikationer.

Temp.
Output URL'er
b64
Permanent alternativ
+33%
Base64 størrelsesoverhead
30 dage
xAI-lagring eller ubegrænset

Problemet med midlertidige URL’er

Når du bruger response_format="url" (standardværdien), returnerer API’et en flygtig URL. Efter en uspecificeret periode holder den op med at levere billedet.

# Flygtig URL: download uden forsinkelse
response = client.images.generate(
    model="grok-imagine-image",
    prompt="A mountain landscape"
)

url = response.data[0].url

Konsekvens: Du kan ikke gemme disse URL’er i en database og genbruge dem senere. Du skal systematisk downloade billederne.

Strategi 1: Øjeblikkeligt download

Den mest pålidelige strategi er at downloade hvert billede, så snart det er genereret:

import urllib.request
import os
from datetime import datetime

def generate_and_save(prompt, output_dir="images"):
    """Genererer et billede og gemmer det med det samme."""
    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")  # JPEG som standard

    urllib.request.urlretrieve(response.data[0].url, filepath)
    print(f"Billede gemt: {filepath}")
    return filepath

Strategi 2: Brug af Base64

Ved at anmode om svaret i Base64 modtager du billedets binære data direkte uden at skulle stole på en midlertidig URL:

import base64

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

# Dataene er direkte i svaret
image_bytes = base64.b64decode(response.data[0].b64_json)

with open("mountain.jpg", "wb") as f:  # JPEG som standard
    f.write(image_bytes)

Fordele ved Base64

Fordelen ved Base64 kan opsummeres i ét ord: autonomi. Billedet ankommer direkte i JSON-svaret uden at være afhængig af en midlertidig URL, der kan udløbe, før din kode behandler det, og uden en ekstra HTTP-anmodning for at downloade det – én netværksrunde mindre betyder ét fejlpunkt mindre i din pipeline.

Ulemper ved Base64

Afvælgningen er mekanisk: Base64-kodning oppuster JSON-svaret med ca. 33 %, hvilket koster dig tre gange over – i overførselstid for API-svar, i hukommelse brugt på klienten til at dekode det, og i kompleksitet, hvis du manipulerer flere højopløselige billeder i samme anmodning. For et enkelt billede er det ubetydeligt; for en batch på ti 2k-billeder bliver forskellen mærkbar.

Strategi 3: Automatisk cloud-lagring

Til produktionsapplikationer bør du kombinere generering med en upload til din egen lagring:

import boto3
import urllib.request
import tempfile

def generate_and_upload_s3(prompt, bucket, key):
    """Genererer et billede og uploader det direkte til S3."""
    response = client.images.generate(
        model="grok-imagine-image",
        prompt=prompt
    )

    # Download til en midlertidig fil
    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
        urllib.request.urlretrieve(response.data[0].url, tmp.name)

        # Upload til S3
        s3 = boto3.client("s3")
        s3.upload_file(tmp.name, bucket, key)

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

Strategi 4: Lad xAI gemme billedet

Hver Imagine-anmodning accepterer en parameter storage_options, der gemmer det producerede billede i dit teams Files API og yderligere kan oprette en permanent offentlig URL til deling eller indlejring. Med 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)  # stabil identifikator i Files API
print(response.public_url)           # permanent offentlig URL

Svaret beholder den sædvanlige flygtige URL og tilføjer for hvert billede en file_output-blok: file_id, filename og, hvis anmodet, public_url. Kun filename er påkrævet: uden andre indstillinger gemmes billedet privat uden udløb eller offentlig URL. expires_after (fra 3.600 sekunder til 30 dage) planlægger sletning af filen, og public_url accepterer også sin egen expires_after, som ikke må overstige filens. Et team kan have op til 1.000 aktive offentlige URL’er; ud over dette, eller i tilfælde af en hændelse, er billedet stadig gemt, og svaret indeholder en public_url_error i stedet for URL’en. Via REST placeres det samme storage_options-objekt i anmodningsbodyen, også ved redigering.

Robust pipeline med genforsøg

Midlertidige URL’er kan nogle gange fejle under download. Implementér en mekanisme til genforsøg:

import time
import urllib.request
import urllib.error

def download_with_retry(url, filepath, max_retries=3):
    """Downloader et billede med genforsøg i tilfælde af fejl."""
    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  # Eksponentiel backoff
                print(f"Forsøg {attempt + 1} mislykkedes, prøver igen om {wait_time}s...")
                time.sleep(wait_time)
            else:
                print(f"Mislykkedes efter {max_retries} forsøg: {e}")
                return False

Bedste praksis

Al disciplin udspringer af én kendsgerning: URL’er er midlertidige. Download skal derfor følge umiddelbart efter generering i den samme kodestrøm – hvert minuts forsinkelse er et vindue, hvor billedet kan blive uopretteligt. Af samme grund må en midlertidig URL aldrig gemmes i en database som en permanent reference: den vil være død ved næste opslag, og dette er den type fejl, der først viser sig i produktion dage senere. I kritiske applikationer, hvor pålidelighed kommer først, skal du omgå problemet med b64_json, der leverer billedet i svaret, eller med storage_options, der beholder det hos xAI med en stabil identifikator.

Selve downloadet fortjener at blive behandlet som en normal netværksoperation: et genforsøg med backoff for at absorbere forbigående fejl, filnavngivning efter tidsstempel eller unik identifikator for at undgå kollisioner, når flere genereringer kører parallelt. Log endelig metadata – prompt, model, parametre – sammen med hvert gemt billede: om seks måneder, når du skal regenerere et visuelt „ligesom det der, men i 2k”, vil denne log være uvurderlig.

Vigtige pointer

  • Output-URL’er er midlertidige: download straks
  • Formatet b64_json undgår problemet med flygtige URL’er
  • Base64 øger svarstørrelsen med ca. 33 %
  • Implementér genforsøg med eksponentiel backoff for robusthed
  • I produktion: upload til permanent lagring (S3, GCS), eller lad xAI gemme billedet med storage_options