Lastverteilung und Strategien mit mehreren Schlüsseln
Implementieren Sie Round-Robin- und gewichtete Lastverteilung über mehrere API-Schlüssel und Konten, um Ihren Spielraum bei Rate-Limits zu vergrößern und p99-Latenzspitzen zu reduzieren.
Lastverteilung und Strategien mit mehreren Schlüsseln ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum ein API-Schlüssel nicht ausreicht
Ein einzelner OpenAI-API-Schlüssel hat ein festgelegtes Ratenlimit, gemessen in Anfragen pro Minute (RPM) und Tokens pro Minute (TPM). In Tier 1 erlaubt GPT-4o 500 RPM und 30.000 TPM. Bei einer Produktionsanwendung mit Hunderten gleichzeitig aktiven Benutzern stößt ein einzelner Schlüssel ständig an diese Grenzen. Mehrere API-Schlüssel vergrößern Ihren verfügbaren Spielraum proportional.
Mehrere API-Schlüssel erstellen
Sie können mehrere API-Schlüssel innerhalb einer einzelnen OpenAI-Organisation erstellen oder mehrere OpenAI-Konten anlegen (jedes wird separat abgerechnet). Speichern Sie jeden Schlüssel in Ihrer Umgebungskonfiguration und behandeln Sie sie als einen Pool. Bewahren Sie die Schlüssel in einem Secrets-Manager wie AWS Secrets Manager oder HashiCorp Vault auf und nicht in Ihrem Quellcode oder in .env-Dateien, die in der Versionsverwaltung gespeichert sind.
import os
API_KEYS = [
os.environ['OPENAI_KEY_1'],
os.environ['OPENAI_KEY_2'],
os.environ['OPENAI_KEY_3'],
os.environ['OPENAI_KEY_4'],
]
# Total effective RPM = 500 * 4 = 2000 RPM
# Total effective TPM = 30000 * 4 = 120000 TPMRound-Robin-Load-Balancing
Round-Robin verteilt Anfragen gleichmäßig auf alle Schlüssel, indem die Schlüssel der Reihe nach durchlaufen werden. Die Methode ist einfach zu implementieren und stellt sicher, dass jeder Schlüssel langfristig ungefähr dieselbe Last verarbeitet. Verwenden Sie einen threadsicheren Zähler oder eine atomare Ganzzahl, damit nicht zwei gleichzeitige Anfragen denselben Schlüssel auswählen. Round-Robin eignet sich gut, wenn alle Schlüssel identische Ratenlimits haben.
import itertools
import threading
from openai import OpenAI
class RoundRobinPool:
def __init__(self, keys: list):
self._clients = [OpenAI(api_key=k) for k in keys]
self._cycle = itertools.cycle(range(len(self._clients)))
self._lock = threading.Lock()
def get_client(self) -> OpenAI:
with self._lock:
idx = next(self._cycle)
return self._clients[idx]
pool = RoundRobinPool(API_KEYS)
client = pool.get_client()Gewichtetes Load-Balancing
Gewichtetes Load-Balancing weist Schlüsseln höherer Tiers (mit höheren Ratenlimits) entsprechend ihrer Kapazität einen größeren Anteil des Datenverkehrs zu. Wenn Schlüssel A Tier 3 (10.000 RPM) und Schlüssel B Tier 1 (500 RPM) hat, sollte Schlüssel A etwa 95 % der Anfragen erhalten. Gewichtetes Balancing verhindert, dass Schlüssel niedrigerer Tiers zu Engpässen werden, wenn sie mit Schlüsseln höherer Tiers kombiniert werden.
import random
class WeightedPool:
def __init__(self, key_configs: list):
# key_configs = [{'key': '...', 'weight': 10}, ...]
self._clients = [OpenAI(api_key=c['key']) for c in key_configs]
self._weights = [c['weight'] for c in key_configs]
def get_client(self) -> OpenAI:
return random.choices(self._clients, weights=self._weights, k=1)[0]
pool = WeightedPool([
{'key': os.environ['OPENAI_KEY_TIER3'], 'weight': 20},
{'key': os.environ['OPENAI_KEY_TIER1'], 'weight': 1},
])Ratenlimitstatus pro Schlüssel verfolgen
Die OpenAI API gibt mit jeder Antwort Ratenlimit-Header zurück: x-ratelimit-remaining-requests und x-ratelimit-remaining-tokens. Verfolgen Sie diese Header für jeden Schlüssel, um zu erkennen, welche Schlüssel kurz vor der Ausschöpfung stehen. Wenn ein Schlüssel für die aktuelle Minute weniger als 10 verbleibende Anfragen meldet, leiten Sie den Datenverkehr vorübergehend von ihm weg, um 429-Fehler zu verhindern, bevor sie auftreten.
class SmartPool:
def __init__(self, keys: list):
self._clients = [OpenAI(api_key=k) for k in keys]
self._remaining = {i: 500 for i in range(len(keys))} # initial RPM
def get_best_client(self):
# Pick key with most remaining capacity
best_idx = max(self._remaining, key=lambda i: self._remaining[i])
return self._clients[best_idx], best_idx
def update_remaining(self, idx: int, response_headers: dict):
remaining = int(response_headers.get('x-ratelimit-remaining-requests', 0))
self._remaining[idx] = remaining429-Ratenlimitfehler behandeln
Wenn ein Schlüssel einen 429-Fehler zurückgibt, nehmen Sie ihn sofort für die im Retry-After-Header angegebene Dauer aus dem Pool (typischerweise 60 Sekunden). Markieren Sie ihn als in Abkühlphase und leiten Sie den gesamten Datenverkehr an die verbleibenden Schlüssel weiter. Stellen Sie den Schlüssel nach Ablauf des Abkühlungszeitraums wieder in den Pool zurück. Dadurch verhindern Sie kaskadierende Ausfälle, bei denen Wiederholungsversuche mit demselben Schlüssel die Situation verschlimmern.
import time
from openai import RateLimitError
class CooldownPool:
def __init__(self, keys: list):
self._clients = [(OpenAI(api_key=k), None) for k in keys] # (client, cooldown_until)
def get_available_clients(self):
now = time.time()
return [
(i, c) for i, (c, until) in enumerate(self._clients)
if until is None or until <= now
]
def mark_cooling(self, idx: int, retry_after: int = 60):
client, _ = self._clients[idx]
self._clients[idx] = (client, time.time() + retry_after)
print(f'Key {idx} cooling down for {retry_after}s')OpenRouter als Multiplexer verwenden
OpenRouter ist ein Proxy-Dienst, der Hunderte von Modellen über einen einzigen OpenAI-kompatiblen API-Endpunkt bereitstellt. Wenn Sie den Datenverkehr über OpenRouter leiten, erhalten Sie automatisch Load-Balancing über mehrere zugrunde liegende Anbieter-Konten, einen Fallback auf alternative Anbieter und Zugriff auf Open-Source-Modelle als Ersatz. Der Kostenaufschlag ist angesichts der gebotenen betrieblichen Einfachheit gering.
from openai import OpenAI
# OpenRouter uses the same OpenAI SDK interface
client = OpenAI(
api_key=os.environ['OPENROUTER_API_KEY'],
base_url='https://openrouter.ai/api/v1'
)
response = client.chat.completions.create(
model='openai/gpt-4o', # OpenRouter model name format
messages=[{'role': 'user', 'content': prompt}]
)
# Automatic failover if OpenAI is downSchlüsselstatus mit Metriken überwachen
Verfolgen Sie Metriken pro Schlüssel, darunter gesendete Anfragen, empfangene 429-Fehler und die Abkühlungszeit in der letzten Stunde. Ein Schlüssel mit einer hohen 429-Rate benötigt entweder weniger Datenverkehr oder ein Upgrade des Tiers. Stellen Sie diese Metriken an einem /metrics-Endpunkt im Prometheus-Format bereit, damit Ihr Überwachungssystem alarmieren kann, wenn ein Schlüssel dauerhaft an seine Grenzen stößt.
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class KeyMetrics:
requests_sent: int = 0
rate_limit_errors: int = 0
total_tokens_used: int = 0
cooldown_count: int = 0
class MetricPool:
def __init__(self, keys: list):
self._clients = [OpenAI(api_key=k) for k in keys]
self._metrics = [KeyMetrics() for _ in keys]
def report(self):
for i, m in enumerate(self._metrics):
error_rate = m.rate_limit_errors / max(m.requests_sent, 1)
print(f'Key {i}: {m.requests_sent} req, {error_rate:.1%} 429 rate')Geografische Verteilung der Schlüssel
Wenn Ihre Benutzer weltweit verteilt sind, sollten Sie separate API-Schlüssel pro geografischer Region verwalten und Anfragen an den Schlüssel weiterleiten, der dem Benutzer am nächsten liegt. Eine kürzere Round-Trip-Zeit im Netzwerk verbessert TTFT. Stellen Sie in jeder Region einen schlanken Load-Balancer bereit (AWS Lambda@Edge oder Cloudflare Worker), der den passenden Schlüssel auswählt und die Anfrage als Proxy weiterleitet, sodass Ihre Schlüssel nicht gegenüber den Clients offengelegt werden.
REGIONAL_KEYS = {
'us-east': os.environ['OPENAI_KEY_US_EAST'],
'eu-west': os.environ['OPENAI_KEY_EU_WEST'],
'ap-southeast': os.environ['OPENAI_KEY_AP'],
}
def get_key_for_region(user_region: str) -> str:
# Default to us-east if region unknown
return REGIONAL_KEYS.get(user_region, REGIONAL_KEYS['us-east'])Ihren Load-Balancer testen
Schreiben Sie einen Lasttest, der 100 gleichzeitige Anfragen über Ihren Balancing-Pool sendet und Verteilung, Fehlerraten sowie Latenzperzentile misst. Stellen Sie sicher, dass kein einzelner Schlüssel mehr als seinen proportionalen Anteil verarbeitet und dass 429-Fehler unter 0,1 % liegen. Verwenden Sie asyncio.gather oder ein Tool wie Locust, um die gleichzeitige Last zu simulieren, die Ihr Produktionssystem tatsächlich bewältigen muss.
import asyncio
import time
async def load_test(pool, concurrency=100, total=1000):
sem = asyncio.Semaphore(concurrency)
results = []
async def one_request():
async with sem:
client = pool.get_client()
start = time.perf_counter()
try:
await client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': 'Ping'}],
max_tokens=5
)
results.append(('ok', time.perf_counter() - start))
except Exception as e:
results.append(('error', str(e)))
await asyncio.gather(*[one_request() for _ in range(total)])
ok = [r for r in results if r[0] == 'ok']
print(f'Success rate: {len(ok)/total:.1%}')
return resultsDie richtige Balancing-Strategie wählen
Passen Sie Ihre Balancing-Strategie an die Struktur Ihrer Ratenlimits an. Verwenden Sie Round-Robin, wenn alle Schlüssel identische Tier-Limits haben und der Datenverkehr gleichmäßig verteilt ist. Verwenden Sie gewichtetes Balancing, wenn die Schlüssel unterschiedliche Tier-Limits haben. Verwenden Sie gesundheitsbewusstes Routing (wobei Schlüssel kurz vor der Ausschöpfung übersprungen werden), wenn Sie 429-Fehler bei stoßartigem Datenverkehr minimieren müssen. Für die meisten Produktionssysteme bietet gesundheitsbewusstes Routing mit exponentiellem Backoff das beste Verhältnis aus Einfachheit und Ausfallsicherheit.
# Strategy selection guide:
# Scenario A: 4 keys all Tier 2 (same limits)
# -> Round-robin: simple, even distribution
#
# Scenario B: 1 Tier 3 key + 3 Tier 1 keys
# -> Weighted: Tier 3 gets 10x weight
#
# Scenario C: Variable traffic with burst periods
# -> Health-aware: track remaining headers, skip near-limit keys
#
# Scenario D: Multi-region, latency-sensitive
# -> Geographic: regional keys, route by user locationKurzer Check
Testen Sie Ihr Verständnis von Load-Balancing-Strategien für LLM-APIs.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Round-Robin und gewichtetes Balancing verteilen den Datenverkehr auf mehrere API-Schlüssel und vergrößern dadurch den Spielraum bei den Ratenlimits, die Nachverfolgung von Abkühlungsphasen verhindert kaskadierende 429-Fehler, indem gedrosselte Schlüssel vorübergehend entfernt werden, und OpenRouter bietet eine verwaltete Multiplexing-Option mit automatischem Fallback. Als Nächstes implementieren wir Fallback-Anbieter und Circuit Breaker.
Häufig gestellte Fragen
Ist die Lektion „Lastverteilung und Strategien mit mehreren Schlüsseln“ kostenlos?
Ja — der vollständige Text von „Lastverteilung und Strategien mit mehreren Schlüsseln“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Lastverteilung und Strategien mit mehreren Schlüsseln“?
Implementieren Sie Round-Robin- und gewichtete Lastverteilung über mehrere API-Schlüssel und Konten, um Ihren Spielraum bei Rate-Limits zu vergrößern und p99-Latenzspitzen zu reduzieren. Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Engineering Academy zu starten?
Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Lastverteilung und Strategien mit mehreren Schlüsseln“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?
Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- LLM-Latenz messen: TTFT und TPOT
- Lastverteilung und Strategien mit mehreren Schlüsseln
- Fallback-Anbieter und Circuit Breaker
- Timeout-Budgets und sanfte Verschlechterung