Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Asynchroner Client und Leistung

Lektion 10 von 14 Aktualisiert am 3. November 2026 Anfänger
Auf dieser Seite
  1. Leistung mit Asynchronie optimieren
  2. Der AsyncOpenAI-Client
  3. Parallele Anfragen mit asyncio.gather
  4. Parallelität steuern
  5. Kompletter asynchroner Pipeline
  6. Synchron vs. Asynchron: Vergleich
  7. Fehlerbehandlung
  8. Kernaussagen

Aktualisiert am 3. November 2026 basierend auf der xAI-Seite zu Rate Limits und der Referenz für die Images API: Die Limits des Imagine-Modells werden pro Sekunde gezählt – 6 beim Einstiegs-Tarif und 100 beim höchsten Tarif – und nicht als „30 pro Minute”. Ein Semaphore begrenzt die gleichzeitigen Anfragen, nicht den Durchsatz. Bilder werden standardmäßig als JPEG ausgegeben. Die spezifischen Zeitangaben der alten Version, die auf keiner veröffentlichten Messung basierten, weichen einer Berechnung. Quellen: Rate Limits · Images API.

Leistung mit Asynchronie optimieren

Wenn Sie viele Bilder generieren oder bearbeiten müssen, werden sequenzielle Aufrufe zum Flaschenhals. Der asynchrone Client der xAI API ermöglicht es Ihnen, mehrere Anfragen parallel auszuführen und die gesamte Verarbeitungszeit erheblich zu verkürzen.

Der AsyncOpenAI-Client

Asynchronie macht eine einzelne Generierung nicht schneller: Eine einzelne Bildanfrage dauert exakt so lange wie zuvor. Was sie eliminiert, ist das unnötige Warten zwischen den Anfragen – während das erste Bild auf dem Server berechnet wird, kann Ihr Programm zehn weitere anfordern, statt blockiert zu bleiben. Deshalb ist der Gewinn bei einem Bild null, aber bei fünfzig Bildern dramatisch.

from openai import AsyncOpenAI
import asyncio
import os

async_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1"
)

async def generate_image(prompt):
    """Generiert ein Bild asynchron."""
    response = await async_client.images.generate(
        model="grok-imagine-image",
        prompt=prompt,
        extra_body={"resolution": "1k"},
    )
    return response.data[0].url

async def main():
    url = await generate_image("A lighthouse on a cliff, watercolor style")
    print(url)

asyncio.run(main())

Parallele Anfragen mit asyncio.gather

asyncio.gather startet alle Anfragen und wartet darauf, dass die Menge abgeschlossen ist. Die Gesamtdauer entspricht der des langsamensten Vorgangs, nicht der Summe aller – das ist der gesamte Unterschied, und Sie sehen ihn bereits mit drei oder vier Bildern.

async def generate_batch(prompts):
    """Generiert Bilder für mehrere Prompts parallel."""
    tasks = [generate_image(prompt) for prompt in prompts]
    results = await asyncio.gather(*tasks)
    return results

async def main():
    prompts = [
        "Portrait of an engineer, corporate style",
        "Panoramic view of a futuristic city",
        "Isometric diagram of a data center",
        "Abstract blue and silver logo",
        "Illustration of a team in a meeting"
    ]

    urls = await generate_batch(prompts)
    for prompt, url in zip(prompts, urls):
        print(f"{prompt[:40]}... → {url}")

asyncio.run(main())

Bei fünf Prompts warten Sie nicht, bis jede Anfrage abgeschlossen ist, bevor Sie die nächste starten. Alle fünf Bilder werden gleichzeitig berechnet: Die Gesamtzeit nähert sich der Dauer des langsamsten Vorgangs.

Parallelität steuern

Ohne Limitierung startet gather alles auf einmal – und fünfzig gleichzeitige Anfragen bei einem Modell, das am Einstiegs-Tarif auf 6 Anfragen pro Sekunde begrenzt ist, produzieren eine Lawine von 429-Fehlern, die Ihnen mehr Zeit kostet als eine sequenzielle Ausführung. Der Semaphore ist daher keine optionale Vorsichtsmaßnahme: Er macht Parallelität erst nutzbar. Kalibrieren Sie ihn an das Modells-Rate Limit, niemals an die Kapazität Ihrer Maschine.

async def generate_with_limit(prompts, max_concurrent=5):
    """Generiert Bilder mit einer maximalen Anzahl paralleler Anfragen."""
    semaphore = asyncio.Semaphore(max_concurrent)

    async def limited_generate(prompt):
        async with semaphore:
            return await generate_image(prompt)

    tasks = [limited_generate(prompt) for prompt in prompts]
    return await asyncio.gather(*tasks)

Die offiziellen Tabellen für grok-imagine-image und grok-imagine-image-2.0 geben 6 Anfragen pro Sekunde am Einstiegs-Tarif an, ein Limit, das mit dem Tarif Ihres Teams bis zu 100 wächst. Hinweis: Ein Semaphore begrenzt gleichzeitige Anfragen, nicht den Durchsatz. Bei max_concurrent=5 bleiben Sie unter 6 Anfragen pro Sekunde, solange jede Generierung länger als eine Sekunde dauert; wenn Ihre Antworten schneller eintreffen, verteilen Sie die Einreichungen ebenfalls. Prüfen Sie die Limits Ihres Teams in der xAI-Konsole, bevor Sie diese erhöhen.

Kompletter asynchroner Pipeline

Diese Pipeline verknüpft die drei Operationen, die zusammengehören: Generieren, sofortiges Herunterladen – URLs verfallen – und Isolierung von Fehlern. Bei einem großen Batch macht dieser dritte Punkt den Unterschied zwischen einem Vorfall und einem Totalverlust.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Lädt ein Bild asynchron herunter."""
    async with session.get(url) as resp:
        if resp.status == 200:
            async with aiofiles.open(filepath, "wb") as f:
                await f.write(await resp.read())
            return filepath
    return None

async def pipeline(prompts, output_dir="output"):
    """Komplette Pipeline: Generierung + Download."""
    os.makedirs(output_dir, exist_ok=True)

    # Schritt 1: Alle Bilder parallel generieren
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # Schritt 2: Alle Bilder parallel herunterladen
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # Standardmäßig JPEG (image/jpeg), es sei denn, die Qualitätseinstellung erzeugt ein PNG
                filepath = os.path.join(output_dir, f"image_{i:03d}.jpg")
                download_tasks.append(download_image(session, url, filepath))

        saved_files = await asyncio.gather(*download_tasks)

    count = sum(1 for f in saved_files if f)
    print(f"{count}/{len(prompts)} Bilder generiert und gespeichert")

Synchron vs. Asynchron: Vergleich

Der Gewinn berechnet sich auf dem Papier. Wenn eine Generierung T Sekunden dauert, benötigen 20 nacheinander angeforderte Bilder etwa 20 × T. Mit fünf gleichzeitigen Anfragen gehen sie in Wellen von fünf: etwa 4 × T, ein Gewinn, der der Anzahl der gleichzeitigen Anfragen nahe kommt – sofern Sie unter dem Durchsatzlimit bleiben. Messen Sie T auf Ihrem eigenen Konto, bevor Sie eine Frist zusichern: Die Bildseiten von xAI geben keine Generierungszeit an, und diese variiert je nach Modell, Auflösung und Last.

Fehlerbehandlung

Das Standardverhalten von gather ist brutal: Eine Ausnahme in einer Aufgabe lässt den Fehler aufsteigen und Sie verlieren die Ergebnisse der anderen, einschließlich der bereits bezahlten. return_exceptions=True ändert dies – jede Aufgabe gibt entweder ihr Ergebnis oder ihre Ausnahme zurück, und Sie entscheiden, was Sie mit den Fehlern tun, ohne die Erfolge zu opfern.

async def safe_generate(prompt):
    """Generiert ein Bild mit Fehlerbehandlung."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Error for '{prompt[:30]}...' : {e}")
        return None

Kernaussagen

  • Der AsyncOpenAI-Client ermöglicht parallele Anfragen über asyncio.
  • Verwenden Sie asyncio.gather, um mehrere Generierungen gleichzeitig zu starten.
  • Begrenzen Sie die Parallelität mit einem Semaphore, um Rate Limits zu respektieren.
  • Der Gewinn nähert sich der Anzahl der gleichzeitigen Anfragen, innerhalb des autorisierten Durchsatzlimits (6 Anfragen pro Sekunde am Einstiegs-Tarif).
  • Behandeln Sie Fehler einzeln, um den gesamten Batch nicht zu verlieren.