AI Engineering Academy · Les

Load balancing en strategieën met meerdere sleutels

Implementeer round-robin- en gewogen load balancing over meerdere API-sleutels en accounts om uw speelruimte binnen snelheidslimieten te vergroten en pieken in p99-latentie te beperken.

Les 2 van 413 stappen

Load balancing en strategieën met meerdere sleutels is een gratis AI Engineering Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI Engineering Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI Engineering Academy bevat in totaal 4 lessen.

Waarom één API-sleutel niet genoeg is

Voor één OpenAI API-sleutel geldt een vaste snelheidslimiet, gemeten in verzoeken per minuut (RPM) en tokens per minuut (TPM). In Tier 1 staat GPT-4o 500 RPM en 30.000 TPM toe. Voor een productietoepassing met honderden gelijktijdige gebruikers bereikt één sleutel deze limieten voortdurend. Meerdere API-sleutels vergroten je beschikbare marge evenredig.

Meerdere API-sleutels maken

Je kunt meerdere API-sleutels binnen één OpenAI-organisatie maken, of meerdere OpenAI-accounts maken die elk afzonderlijk worden gefactureerd. Sla elke sleutel op in je omgevingsconfiguratie en behandel ze als een pool. Bewaar sleutels in een geheimenbeheerder zoals AWS Secrets Manager of HashiCorp Vault, en niet in je broncode of in .env-bestanden die je aan versiebeheer hebt toegevoegd.

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 TPM

Taakverdeling volgens round-robin

Round-robin verdeelt verzoeken gelijkmatig over alle sleutels door ze steeds in dezelfde volgorde te doorlopen. Dit is eenvoudig te implementeren en zorgt ervoor dat elke sleutel na verloop van tijd ongeveer dezelfde belasting verwerkt. Gebruik een threadveilige teller of een atomair geheel getal om te voorkomen dat twee gelijktijdige verzoeken tegelijkertijd dezelfde sleutel kiezen. Round-robin werkt goed wanneer alle sleutels identieke snelheidslimieten hebben.

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()

Gewogen taakverdeling

Bij gewogen taakverdeling krijgen sleutels met een hogere tier en hogere snelheidslimieten een groter deel van het verkeer, evenredig aan hun capaciteit. Als sleutel A Tier 3 (10.000 RPM) heeft en sleutel B Tier 1 (500 RPM), moet sleutel A ongeveer 95% van de verzoeken ontvangen. Gewogen taakverdeling voorkomt dat sleutels van een lagere tier knelpunten worden wanneer ze samen met sleutels van een hogere tier worden gebruikt.

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},
])

De status van snelheidslimieten per sleutel bijhouden

De OpenAI API retourneert bij elk antwoord kopteksten met snelheidslimieten: x-ratelimit-remaining-requests en x-ratelimit-remaining-tokens. Houd deze kopteksten per sleutel bij om te weten welke sleutels bijna uitgeput zijn. Wanneer een sleutel minder dan 10 resterende verzoeken in de huidige minuut rapporteert, leid je het verkeer tijdelijk om, zodat je 429-fouten voorkomt voordat ze optreden.

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] = remaining

429-fouten door snelheidslimieten afhandelen

Wanneer een sleutel een 429-fout retourneert, haal je die sleutel onmiddellijk gedurende de periode uit de pool die in de koptekst Retry-After staat (doorgaans 60 seconden). Markeer de sleutel als afkoelend en leid al het verkeer naar de overige sleutels. Voeg de sleutel na afloop van de afkoelperiode weer aan de pool toe. Zo voorkom je kettingfouten waarbij nieuwe pogingen met dezelfde sleutel de situatie verergeren.

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 gebruiken

OpenRouter is een proxyservice die honderden modellen via één OpenAI-compatibel API-eindpunt beschikbaar maakt. Door verkeer via OpenRouter te leiden, krijg je automatisch taakverdeling over meerdere onderliggende provideraccounts, een terugvalmogelijkheid naar alternatieve providers en toegang tot opensourcemodellen als reserve. De opslag op de kosten is klein in verhouding tot de operationele eenvoud die dit biedt.

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 down

Sleutelgezondheid bewaken met metingen

Houd per sleutel metingen bij, waaronder verzonden verzoeken, ontvangen 429-fouten en de afkoeltijd in het afgelopen uur. Een sleutel met een hoog aantal 429-fouten heeft minder verkeer of een upgrade van de tier nodig. Stel deze metingen beschikbaar via een /metrics-eindpunt in Prometheus-indeling, zodat je bewakingssysteem een waarschuwing kan geven wanneer een sleutel voortdurend de limieten bereikt.

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 verdeling van sleutels

Als je gebruikers wereldwijd verspreid zijn, kun je overwegen afzonderlijke API-sleutels per geografische regio te beheren en verzoeken naar de sleutel te leiden die zich het dichtst bij de gebruiker bevindt. Een kortere retourtijd over het netwerk verbetert TTFT. Implementeer in elke regio een lichtgewicht taakverdeler (AWS Lambda@Edge of Cloudflare Worker) die de juiste sleutel selecteert en het verzoek doorstuurt, zodat je sleutels niet aan clients worden blootgesteld.

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'])

Je taakverdeler testen

Schrijf een belastingstest die 100 gelijktijdige verzoeken via je taakverdelingspool verstuurt en de verdeling, foutpercentages en latentiepercentielen meet. Controleer of geen enkele sleutel meer dan zijn evenredige aandeel verwerkt en of het aantal 429-fouten lager is dan 0,1%. Gebruik asyncio.gather of een hulpprogramma zoals Locust om de gelijktijdige belasting te simuleren die je productiesysteem daadwerkelijk zal ervaren.

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 results

De juiste taakverdelingsstrategie kiezen

Stem je taakverdelingsstrategie af op je structuur voor snelheidslimieten. Gebruik round-robin wanneer alle sleutels identieke tierlimieten hebben en het verkeer gelijkmatig wordt verdeeld. Gebruik gewogen taakverdeling wanneer sleutels verschillende tierlimieten hebben. Gebruik routering op basis van gezondheid (waarbij sleutels die bijna uitgeput zijn worden overgeslagen) wanneer je 429-fouten bij piekverkeer wilt minimaliseren. Voor de meeste productiesystemen biedt routering op basis van gezondheid met exponentiële wachttijden de beste balans tussen eenvoud en veerkracht.

# 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 location

Korte controle

Test je begrip van strategieën voor taakverdeling van LLM-API's.

Beantwoord dit in de interactieve les

Samenvatting van de les

In deze les heb je geleerd dat round-robin en gewogen taakverdeling verkeer over meerdere API-sleutels verdelen en zo de marge tot de snelheidslimieten vergroten, dat het bijhouden van afkoelperioden kettingfouten met 429-fouten voorkomt door tijdelijk afgeremde sleutels te verwijderen, en dat OpenRouter een beheerde optie voor multiplexing biedt met automatische terugval. Hierna implementeren we terugvalproviders en stroomonderbrekers.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 30
Lessen: 120

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Load balancing en strategieën met meerdere sleutels” gratis?

Ja — de volledige tekst van “Load balancing en strategieën met meerdere sleutels” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus AI Engineering Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus AI Engineering Academy bevat in totaal 4 lessen.

Wat leer ik in “Load balancing en strategieën met meerdere sleutels”?

Implementeer round-robin- en gewogen load balancing over meerdere API-sleutels en accounts om uw speelruimte binnen snelheidslimieten te vergroten en pieken in p99-latentie te beperken. Je oefent met AI Engineering Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met AI Engineering Academy te beginnen?

Ervaring vooraf is niet nodig. AI Engineering Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Load balancing en strategieën met meerdere sleutels”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over AI Engineering Academy?

Ja. Elke les over AI Engineering Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

LLM-latentie meten: TTFT en TPOT
Load balancing en strategieën met meerdere sleutels
Fallbackproviders en circuit breakers
Time-outbudgetten en geleidelijke degradatie

← Terug naar AI Engineering Academy