Kuormantasaus ja usean avaimen strategiat
Toteuta round-robin- ja painotettu kuormantasaus useiden API-avainten ja tilien välillä kasvattaaksesi nopeusrajoitusten pelivaraa ja vähentääksesi p99-viivepiikkejä.
Kuormantasaus ja usean avaimen strategiat on ilmainen AI Engineering Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu AI Engineering Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. AI Engineering Academy-kurssilla on yhteensä 4 oppituntia.
Miksi yksi API-avain ei riitä
Yhdellä OpenAI API-avaimella on kiinteä nopeusrajoitus, joka ilmoitetaan pyyntöinä minuutissa (RPM) ja tokeneina minuutissa (TPM). Tasolla 1 GPT-4o sallii 500 RPM ja 30 000 TPM. Tuotantosovelluksessa, jolla on satoja samanaikaisia käyttäjiä, yksi avain saavuttaa nämä rajat jatkuvasti. Useat API-avaimet kasvattavat käytettävissä olevaa kapasiteettivaraa vastaavasti.
Useiden API-avainten luominen
Voit luoda useita API-avaimia yhden OpenAI-organisaation sisällä tai luoda useita OpenAI-tilejä (joista jokainen laskutetaan erikseen). Tallenna jokainen avain ympäristömäärityksiin ja käsittele niitä poolina. Säilytä avaimet salaisuuksien hallintapalvelussa, kuten AWS Secrets Managerissa tai HashiCorp Vaultissa, älä lähdekoodissa tai versionhallintaan viedyissä .env-tiedostoissa.
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-kuormantasaus
Round-robin jakaa pyynnöt tasaisesti kaikille avaimille kierrättämällä niitä järjestyksessä. Se on helppo toteuttaa ja varmistaa, että jokainen avain käsittelee ajan mittaan suunnilleen saman kuorman. Käytä säieturvallista laskuria tai atomista kokonaislukua, jotta kaksi samanaikaista pyyntöä ei valitse samaa avainta yhtä aikaa. Round-robin toimii hyvin, kun kaikilla avaimilla on samat nopeusrajoitukset.
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()Painotettu kuormantasaus
Painotettu kuormantasaus antaa korkeamman tason avaimille (joilla on suuremmat nopeusrajoitukset) suuremman osuuden liikenteestä suhteessa niiden kapasiteettiin. Jos avain A on tasolla 3 (10 000 RPM) ja avain B tasolla 1 (500 RPM), avaimen A pitäisi saada noin 95 % pyynnöistä. Painotettu tasaus estää alemman tason avaimia muodostumasta pullonkauloiksi, kun niitä käytetään yhdessä korkeamman tason avainten kanssa.
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},
])Avainkohtaisen nopeusrajoitustilan seuranta
OpenAI API palauttaa jokaisen vastauksen yhteydessä nopeusrajoitusten otsakkeet: x-ratelimit-remaining-requests ja x-ratelimit-remaining-tokens. Seuraa näitä otsakkeita avainkohtaisesti, jotta tiedät, mitkä avaimet ovat lähellä kapasiteettinsa loppumista. Kun avain ilmoittaa, että kuluvalla minuutilla on jäljellä alle 10 pyyntöä, ohjaa liikenne väliaikaisesti sen ohi estääksesi 429-virheet ennen niiden syntymistä.
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-nopeusrajoitusvirheiden käsittely
Kun avain palauttaa 429-virheen, poista se välittömästi poolista Retry-After-otsakkeessa ilmoitetuksi ajaksi (yleensä 60 sekunniksi). Merkitse se jäähdytystilaan ja ohjaa kaikki liikenne jäljellä oleville avaimille. Kun jäähdytysjakso päättyy, palauta avain pooliin. Näin estetään ketjuuntuvat virheet, joissa saman avaimen uudelleenyritykset pahentavat tilannetta.
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')OpenRouterin käyttö multiplekserinä
OpenRouter on välityspalvelu, joka tarjoaa satoja malleja yhden OpenAI-yhteensopivan API-päätepisteen kautta. Kun liikenne reititetään OpenRouterin kautta, saat automaattisesti kuormantasauksen useiden taustalla olevien palveluntarjoajatilien välillä, varapalveluntarjoajat sekä pääsyn avoimen lähdekoodin malleihin varamalleina. Kustannuslisä on pieni sen tarjoamaan toiminnalliseen yksinkertaisuuteen nähden.
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 downAvainten tilan seuranta mittareilla
Seuraa avainkohtaisia mittareita, kuten lähetettyjen pyyntöjen määrää, vastaanotettuja 429-virheitä ja viimeisen tunnin jäähdytysaikaa. Avain, jolla on paljon 429-virheitä, tarvitsee joko vähemmän liikennettä tai tason korotuksen. Julkaise nämä mittarit /metrics-päätepisteessä Prometheus-muodossa, jotta valvontajärjestelmäsi voi ilmoittaa, kun jokin avain osuu jatkuvasti rajoihin.
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')Avainten maantieteellinen jakaminen
Jos käyttäjäsi ovat jakautuneet eri puolille maailmaa, harkitse erillisten API-avainten ylläpitämistä maantieteellisiä alueita varten ja pyyntöjen reitittämistä käyttäjää lähimpänä olevalle avaimelle. Verkon edestakaisen siirtoajan lyhentäminen parantaa TTFT:tä. Ota joka alueella käyttöön kevyt kuormantasaaja (AWS Lambda@Edge tai Cloudflare Worker), joka valitsee sopivan avaimen ja välittää pyynnön eteenpäin, jolloin avaimesi eivät paljastu asiakkaille.
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'])Kuormantasaajan testaaminen
Kirjoita kuormitustesti, joka lähettää kuormantasauspoolin kautta 100 samanaikaista pyyntöä ja mittaa jakauman, virhesuhteet sekä viiveen prosenttipisteet. Varmista, ettei yksikään avain käsittele sille suhteellisesti kuuluvaa osuutta enempää ja että 429-virheiden osuus on alle 0,1 %. Käytä asyncio.gather-funktiota tai Locustin kaltaista työkalua simuloidaksesi tuotantojärjestelmässäsi tosiasiallisesti esiintyvää samanaikaista kuormaa.
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 resultsSopivan tasausstrategian valitseminen
Sovita tasausstrategia nopeusrajoitustesi rakenteeseen. Käytä round-robinia, kun kaikilla avaimilla on saman tason rajat ja liikenne jakautuu tasaisesti. Käytä painotettua tasausta, kun avainten tasorajat poikkeavat toisistaan. Käytä tilatietoista reititystä (lähes kapasiteettinsa saavuttaneiden avainten ohittamista), kun haluat minimoida 429-virheet purskekuormituksessa. Useimmissa tuotantojärjestelmissä tilatietoinen reititys yhdistettynä eksponentiaaliseen uudelleenyritysten viivytykseen tarjoaa parhaan tasapainon yksinkertaisuuden ja vikasietoisuuden välillä.
# 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 locationPikatarkistus
Testaa, miten hyvin ymmärrät LLM-rajapintojen kuormantasausstrategiat.
Oppitunnin kertaus
Tässä oppitunnissa opit, että round-robin- ja painotettu tasaus jakavat liikenteen useiden API-avainten välillä ja kasvattavat näin nopeusrajoitusten kapasiteettivaraa, jäähdytyksen seuranta estää ketjuuntuvat 429-virheet poistamalla rajoitetut avaimet väliaikaisesti käytöstä, ja OpenRouter tarjoaa hallitun multipleksointivaihtoehdon automaattisella varapalveluntarjoajalla. Seuraavaksi toteutamme varapalveluntarjoajat ja piirikytkimet.
Opi Python tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 30
- Oppitunnit
- 120
Usein kysytyt kysymykset
Onko oppitunti ”Kuormantasaus ja usean avaimen strategiat” ilmainen?
Kyllä – oppitunnin ”Kuormantasaus ja usean avaimen strategiat” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko AI Engineering Academy-kurssin, päivitä CoddyKit PROhon. AI Engineering Academy-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Kuormantasaus ja usean avaimen strategiat”?
Toteuta round-robin- ja painotettu kuormantasaus useiden API-avainten ja tilien välillä kasvattaaksesi nopeusrajoitusten pelivaraa ja vähentääksesi p99-viivepiikkejä. Harjoittelet AI Engineering Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni AI Engineering Academy-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin AI Engineering Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.
Kuinka kauan ”Kuormantasaus ja usean avaimen strategiat”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä AI Engineering Academy-oppitunnilla?
Kyllä. Jokainen AI Engineering Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- LLM:n viiveen mittaaminen: TTFT ja TPOT
- Kuormantasaus ja usean avaimen strategiat
- Varapalveluntarjoajat ja sulakekatkaisijat
- Aikakatkaisubudjetit ja hallittu heikentyminen