Lastbalansering og strategier med flere nøkler
Implementer round-robin- og vektet lastbalansering på tvers av flere API-nøkler og kontoer for å øke kapasiteten innenfor hastighetsgrensene og redusere topper i p99-ventetid.
Lastbalansering og strategier med flere nøkler er en gratis leksjon i AI Engineering Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI Engineering Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.
Hvorfor én API-nøkkel ikke er nok
Én OpenAI API-nøkkel har en fast hastighetsbegrensning målt i forespørsler per minutt (RPM) og token per minutt (TPM). På nivå 1 tillater GPT-4o 500 RPM og 30 000 TPM. For en produksjonsapplikasjon med hundrevis av samtidige brukere vil én enkelt nøkkel stadig treffe disse grensene. Flere API-nøkler øker den tilgjengelige kapasiteten proporsjonalt.
Opprette flere API-nøkler
De kan opprette flere API-nøkler i én OpenAI-organisasjon eller opprette flere OpenAI-kontoer (som faktureres separat). Lagre hver nøkkel i miljøkonfigurasjonen, og behandle dem som en pool. Oppbevar nøkler i en hemmelighetshåndteringstjeneste som AWS Secrets Manager eller HashiCorp Vault, ikke i kildekoden eller i .env-filer som er lagt inn i versjonskontrollen.
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 TPMLastbalansering med round-robin
Round-robin fordeler forespørsler jevnt på alle nøkler ved å gå gjennom dem i rekkefølge. Det er enkelt å implementere og sørger for at hver nøkkel håndterer omtrent samme belastning over tid. Bruk en trådsikker teller eller et atomisk heltall for å unngå at to samtidige forespørsler velger samme nøkkel samtidig. Round-robin fungerer godt når alle nøklene har identiske hastighetsgrenser.
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()Vektet lastbalansering
Vektet lastbalansering gir nøkler på høyere nivå (med høyere hastighetsgrenser) en større andel av trafikken, proporsjonalt med kapasiteten deres. Hvis nøkkel A er på nivå 3 (10 000 RPM) og nøkkel B er på nivå 1 (500 RPM), bør nøkkel A motta omtrent 95 % av forespørslene. Vektet balansering hindrer nøkler på lavere nivå i å bli flaskehalser når de brukes sammen med nøkler på høyere nivå.
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},
])Sporing av tilstanden for hver nøkkels hastighetsgrense
OpenAI API-et returnerer headere for hastighetsgrenser med hvert svar: x-ratelimit-remaining-requests og x-ratelimit-remaining-tokens. Spor disse headerne per nøkkel for å vite hvilke nøkler som nærmer seg oppbrukt kapasitet. Når en nøkkel rapporterer færre enn 10 gjenværende forespørsler i det aktuelle minuttet, bør De midlertidig lede trafikken bort fra den for å hindre 429-feil før de oppstår.
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] = remainingHåndtering av 429-feil for hastighetsgrenser
Når en nøkkel returnerer en 429-feil, tar De den umiddelbart ut av poolen i tidsrommet som er angitt i Retry-After-headeren (vanligvis 60 sekunder). Merk den som under nedkjøling, og led all trafikk til de gjenværende nøklene. Når nedkjølingsperioden er over, legger De nøkkelen tilbake i poolen. Dette hindrer kaskadefeil der nye forsøk på samme nøkkel gjør situasjonen verre.
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')Bruke OpenRouter som multiplekser
OpenRouter er en proxy-tjeneste som eksponerer hundrevis av modeller gjennom ett enkelt OpenAI-kompatibelt API-endepunkt. Ved å rute gjennom OpenRouter får De automatisk lastbalansering på tvers av flere underliggende leverandørkontoer, reserveleverandører og tilgang til åpen kildekode-modeller som sikkerhetskopier. Påslaget er lite sammenlignet med den driftsmessige enkelheten tjenesten gir.
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 downOvervåke nøkkelhelse med målinger
Spor målinger per nøkkel, blant annet antall sendte forespørsler, mottatte 429-feil og nedkjølingstid den siste timen. En nøkkel med høy 429-rate trenger enten redusert trafikk eller en oppgradering til et høyere nivå. Eksponer disse målingene på et /metrics-endepunkt i Prometheus-format, slik at overvåkingssystemet kan varsle når en nøkkel stadig treffer grensene.
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')Geografisk fordeling av nøkler
Hvis brukerne Deres er spredt over hele verden, bør De vurdere å ha separate API-nøkler per geografisk region og rute forespørsler til nøkkelen som er nærmest brukeren. Kortere nettverksrundtur forbedrer TTFT. Distribuer en lettvektslastbalanserer i hver region (AWS Lambda@Edge eller Cloudflare Worker) som velger riktig nøkkel og videresender forespørselen, slik at nøklene ikke eksponeres for klientene.
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'])Teste lastbalansereren
Skriv en lasttest som sender 100 samtidige forespørsler gjennom balanseringspoolen og måler fordeling, feilrater og latensprosentiler. Kontroller at ingen enkelt nøkkel håndterer mer enn sin proporsjonale andel, og at 429-feilene er under 0,1 %. Bruk asyncio.gather eller et verktøy som Locust for å simulere den samtidige belastningen produksjonssystemet faktisk vil oppleve.
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 resultsVelge riktig balanseringsstrategi
Tilpass balanseringsstrategien til strukturen for hastighetsgrensene. Bruk round-robin når alle nøklene har identiske nivågrenser og trafikken er jevnt fordelt. Bruk vektet balansering når nøklene har ulike nivågrenser. Bruk helsebevisst ruting (der nøkler som nærmer seg oppbrukt kapasitet, hoppes over) når De vil minimere 429-feil ved trafikkøkninger. For de fleste produksjonssystemer gir helsebevisst ruting med eksponentiell tilbakeventing den beste balansen mellom enkelhet og robusthet.
# 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 locationRask sjekk
Test forståelsen Deres av lastbalanseringsstrategier for LLM-API-er.
Oppsummering av leksjonen
I denne leksjonen lærte De at round-robin og vektet balansering fordeler trafikken på flere API-nøkler og dermed øker den tilgjengelige kapasiteten innenfor hastighetsgrensene, at sporing av nedkjøling hindrer kaskadefeil med 429-feil ved midlertidig å fjerne strupede nøkler, og at OpenRouter tilbyr et administrert multipleksingsalternativ med automatisk reserveleverandør. Neste steg er å implementere reserveleverandører og kretsbrytere.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Lastbalansering og strategier med flere nøkler» gratis?
Ja – hele teksten i «Lastbalansering og strategier med flere nøkler» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI Engineering Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Lastbalansering og strategier med flere nøkler»?
Implementer round-robin- og vektet lastbalansering på tvers av flere API-nøkler og kontoer for å øke kapasiteten innenfor hastighetsgrensene og redusere topper i p99-ventetid. Du øver på AI Engineering Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med AI Engineering Academy?
Ingen tidligere erfaring er nødvendig. AI Engineering Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «Lastbalansering og strategier med flere nøkler»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne AI Engineering Academy-leksjonen?
Ja. Alle AI Engineering Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Måle LLM-ventetid: TTFT og TPOT
- Lastbalansering og strategier med flere nøkler
- Reserveleverandører og kretsbrytere
- Tidsavbruddsbudsjetter og kontrollert degradering