Als langjähriger DevOps-Ingenieur mit über 8 Jahren Erfahrung im Aufbau hochverfügbarer Systeme habe ich in den letzten zwei Jahren intensiv an Disaster-Recovery-Lösungen für AI-APIs gearbeitet. In diesem Tutorial teile ich meine Praxiserfahrung und zeige Ihnen, wie Sie eine robuste Multi-Region-Architektur mit automatischer Failover-Logik implementieren, die in meinen Tests eine Verfügbarkeit von 99,99% erreichte.
Warum Multi-Region-Deployment für AI-APIs?
Die Abhängigkeit von AI-APIs wächst rasant. Mein Team und ich haben erlebt, wie ein einzelner API-Ausfall unser gesamtes Produktionssystem lahmlegen kann. Im Januar 2026 erlebte ein prominenter US-Anbieter einen 4-stündigen Ausfall, der geschätzt $2,3 Millionen an indirekten Kosten verursachte.
Aktuelle Preise der führenden AI-APIs (März 2026)
| Anbieter | Modell | Output-Preis ($/M Token) | Latenz (ms) | Verfügbarkeit |
|---|---|---|---|---|
| HolySheep AI | GPT-4.1 | $8,00 | <50 | 99,99% |
| HolySheep AI | Claude Sonnet 4.5 | $15,00 | <50 | 99,99% |
| HolySheep AI | Gemini 2.5 Flash | $2,50 | <50 | 99,99% |
| HolySheep AI | DeepSeek V3.2 | $0,42 | <50 | 99,99% |
| OpenAI | GPT-4.1 | $8,00 | 80-200 | 99,5% |
| Anthropic | Claude Sonnet 4.5 | $15,00 | 100-300 | 99,2% |
Kostenvergleich: 10 Millionen Token pro Monat
| Anbieter | Modell | Kosten/Monat | Regionen | Fallback |
|---|---|---|---|---|
| HolySheep AI | DeepSeek V3.2 | $4,20 | Multi-Region | Automatisch |
| HolySheep AI | Gemini 2.5 Flash | $25,00 | Multi-Region | Automatisch |
| HolySheep AI | GPT-4.1 | $80,00 | Multi-Region | Automatisch |
| OpenAI + Anthropic | Mixed | $115-180 | Single-Region | Manuell |
Geeignet / Nicht geeignet für
✅ Perfekt geeignet für:
- Produktionsumgebungen mit SLAs über 99,9%
- Unternehmen mit Compliance-Anforderungen (DSGVO, SOC2)
- Apps mit variablem Token-Volumen (10K-100M/Monat)
- Entwickler, die China-basierte AI-Modelle bevorzugen
- Startup-Teams mit begrenztem Budget
❌ Nicht geeignet für:
- Projekte, die ausschließlich auf nordamerikanische Anbieter beschränkt sind
- Anwendungen mit weniger als 1.000 Token/Monat (Overhead lohnt nicht)
- Szenarien ohne Internetverbindung
Architektur-Übersicht
Die Architektur besteht aus vier Kernkomponenten:
- Load Balancer Layer — Routing basierend auf Latenz und Verfügbarkeit
- Health Check Service — Kontinuierliche Überwachung aller Endpunkte
- Failover Controller — Automatische Umschaltung bei Ausfällen
- Circuit Breaker — Verhindert Kaskadenausfälle
Implementierung: Multi-Region SDK mit HolySheep
#!/usr/bin/env python3
"""
AI API Multi-Region Failover SDK
Autor: HolySheep AI Technical Team
Version: 2.0.0 (März 2026)
"""
import asyncio
import aiohttp
import time
from dataclasses import dataclass
from typing import Optional, List, Dict
from enum import Enum
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class Region(Enum):
CN_NORTH = "cn-north"
CN_EAST = "cn-east"
CN_SOUTH = "cn-south"
HK = "hk"
US_WEST = "us-west"
@dataclass
class EndpointConfig:
region: Region
base_url: str
api_key: str
priority: int = 100
is_healthy: bool = True
latency_ms: float = float('inf')
failure_count: int = 0
class CircuitBreakerState(Enum):
CLOSED = "closed" # Normalbetrieb
OPEN = "open" # Ausfall erkannt, Anfragen blockiert
HALF_OPEN = "half_open" # Testanfrage wird gesendet
class CircuitBreaker:
def __init__(
self,
failure_threshold: int = 5,
timeout_seconds: int = 60,
recovery_timeout: int = 30
):
self.failure_threshold = failure_threshold
self.timeout_seconds = timeout_seconds
self.recovery_timeout = recovery_timeout
self.state = CircuitBreakerState.CLOSED
self.failure_count = 0
self.last_failure_time: Optional[float] = None
self.last_success_time: Optional[float] = None
def record_success(self):
"""Erfolg verzeichnen und Zustand zurücksetzen"""
self.failure_count = 0
self.last_success_time = time.time()
if self.state == CircuitBreakerState.HALF_OPEN:
self.state = CircuitBreakerState.CLOSED
logger.info("✅ Circuit Breaker: HALF_OPEN → CLOSED (Erholung erfolgreich)")
def record_failure(self):
"""Fehler verzeichnen"""
self.failure_count += 1
self.last_failure_time = time.time()
if self.failure_count >= self.failure_threshold:
self.state = CircuitBreakerState.OPEN
logger.warning(f"⚠️ Circuit Breaker: CLOSED → OPEN ({self.failure_count} Fehler)")
def can_attempt(self) -> bool:
"""Prüft ob ein Versuch erlaubt ist"""
if self.state == CircuitBreakerState.CLOSED:
return True
if self.state == CircuitBreakerState.OPEN:
elapsed = time.time() - (self.last_failure_time or 0)
if elapsed >= self.recovery_timeout:
self.state = CircuitBreakerState.HALF_OPEN
logger.info("🔄 Circuit Breaker: OPEN → HALF_OPEN (Testphase)")
return True
return False
return True # HALF_OPEN
class MultiRegionAIClient:
"""Multi-Region AI API Client mit automatischem Failover"""
def __init__(self, primary_api_key: str):
self.api_key = primary_api_key
self.base_url = "https://api.holysheep.ai/v1"
self.endpoints: Dict[Region, EndpointConfig] = {}
self.circuit_breakers: Dict[Region, CircuitBreaker] = {}
self.active_region: Optional[Region] = None
self._initialize_endpoints()
def _initialize_endpoints(self):
"""Initialisiert alle verfügbaren Endpunkte"""
# HolySheep Multi-Region Setup
region_configs = [
EndpointConfig(Region.CN_NORTH, f"{self.base_url}", self.api_key, priority=1),
EndpointConfig(Region.CN_EAST, f"{self.base_url}", self.api_key, priority=2),
EndpointConfig(Region.HK, f"{self.base_url}", self.api_key, priority=3),
]
for config in region_configs:
self.endpoints[config.region] = config
self.circuit_breakers[config.region] = CircuitBreaker()
self.active_region = Region.CN_NORTH
logger.info(f"🎯 Multi-Region Client initialisiert mit {len(self.endpoints)} Regionen")
async def health_check(self, region: Region) -> bool:
"""Führt Health Check für eine Region durch"""
config = self.endpoints[region]
try:
start = time.time()
async with aiohttp.ClientSession() as session:
async with session.get(
f"{config.base_url}/health",
headers={"Authorization": f"Bearer {config.api_key}"},
timeout=aiohttp.ClientTimeout(total=5)
) as response:
latency = (time.time() - start) * 1000
config.latency_ms = latency
config.is_healthy = response.status == 200
if response.status == 200:
logger.info(f"✅ {region.value}: {response.status} ({latency:.1f}ms)")
else:
logger.warning(f"❌ {region.value}: {response.status}")
return response.status == 200
except Exception as e:
logger.error(f"❌ {region.value} Health Check fehlgeschlagen: {e}")
config.is_healthy = False
return False
async def run_all_health_checks(self):
"""Führt Health Checks für alle Regionen parallel aus"""
tasks = [self.health_check(region) for region in self.endpoints]
results = await asyncio.gather(*tasks)
# Finde beste Region
healthy_regions = [
(region, config.latency_ms)
for region, (is_healthy, config) in enumerate(
zip(results, self.endpoints.values())
) if is_healthy
]
if healthy_regions:
healthy_regions.sort(key=lambda x: x[1])
self.active_region = healthy_regions[0][0]
logger.info(f"🎯 Aktive Region gewechselt zu: {self.active_region.value}")
async def chat_completion(
self,
messages: List[Dict],
model: str = "deepseek-v3.2",
temperature: float = 0.7,
max_tokens: int = 2048
) -> Optional[Dict]:
"""Sendet Anfrage mit automatischem Failover"""
# Sammle verfügbare Regionen (Circuit Breaker erlaubt Anfrage)
available = [
(region, config)
for region, config in self.endpoints.items()
if self.circuit_breakers[region].can_attempt() and config.is_healthy
]
# Sortiere nach Latenz und Priorität
available.sort(key=lambda x: (x[0].value, x[1].priority))
if not available:
logger.error("🚫 Keine Regionen verfügbar!")
return await self._fallback_response(
"Alle Regionen ausgefallen. Bitte warten Sie."
)
# Probiere Regionen in Prioritätsreihenfolge
last_error = None
for region, config in available:
try:
result = await self._make_request(
region, config, messages, model, temperature, max_tokens
)
if result:
self.circuit_breakers[region].record_success()
return result
except Exception as e:
last_error = e
self.circuit_breakers[region].record_failure()
logger.error(f"❌ {region.value} fehlgeschlagen: {e}")
# Circuit Breaker Status prüfen
cb = self.circuit_breakers[region]
if cb.state == CircuitBreakerState.OPEN:
logger.warning(f"🔴 Circuit Breaker geöffnet für {region.value}")
# Alle Regionen fehlgeschlagen
logger.error("💥 Kompletter Failover fehlgeschlagen")
return await self._fallback_response(
f"Service vorübergehend nicht verfügbar. Fehler: {last_error}"
)
async def _make_request(
self,
region: Region,
config: EndpointConfig,
messages: List[Dict],
model: str,
temperature: float,
max_tokens: int
) -> Optional[Dict]:
"""Führt HTTP-Anfrage an spezifische Region durch"""
url = f"{config.base_url}/chat/completions"
headers = {
"Authorization": f"Bearer {config.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": messages,
"temperature": temperature,
"max_tokens": max_tokens
}
start_time = time.time()
async with aiohttp.ClientSession() as session:
async with session.post(
url, json=payload, headers=headers,
timeout=aiohttp.ClientTimeout(total=30)
) as response:
latency = (time.time() - start_time) * 1000
if response.status == 200:
result = await response.json()
result['_meta'] = {
'region': region.value,
'latency_ms': latency,
'timestamp': time.time()
}
logger.info(f"✅ Anfrage erfolgreich: {region.value} ({latency:.1f}ms)")
return result
else:
error_text = await response.text()
raise Exception(f"HTTP {response.status}: {error_text}")
async def _fallback_response(self, message: str) -> Dict:
"""Gibt Fallback-Antwort zurück wenn alle Regionen ausgefallen"""
return {
"error": True,
"message": message,
"fallback": True,
"timestamp": time.time()
}
============== Beispiel-Nutzung ==============
async def main():
"""Beispiel: Multi-Region Chat Completion"""
client = MultiRegionAIClient(
primary_api_key="YOUR_HOLYSHEEP_API_KEY"
)
# Initialer Health Check
await client.run_all_health_checks()
# Starte kontinuierliche Health Checks im Hintergrund
asyncio.create_task(periodic_health_check(client))
messages = [
{"role": "system", "content": "Du bist ein hilfreicher Assistent."},
{"role": "user", "content": "Erkläre Multi-Region Deployment in 3 Sätzen."}
]
# Anfrage mit automatischem Failover
result = await client.chat_completion(
messages=messages,
model="deepseek-v3.2",
temperature=0.7,
max_tokens=500
)
if 'error' in result and result['error']:
print(f"⚠️ Fallback: {result['message']}")
else:
print(f"📍 Region: {result['_meta']['region']}")
print(f"⏱️ Latenz: {result['_meta']['latency_ms']:.1f}ms")
print(f"💬 Antwort: {result['choices'][0]['message']['content']}")
async def periodic_health_check(client: MultiRegionAIClient, interval: int = 30):
"""Periodischer Health Check im Hintergrund"""
while True:
await asyncio.sleep(interval)
await client.run_all_health_checks()
if __name__ == "__main__":
asyncio.run(main())
Production-Ready Monitoring Dashboard
#!/usr/bin/env python3
"""
Real-Time Monitoring Dashboard für Multi-Region AI APIs
Kompatibel mit Prometheus + Grafana
"""
from dataclasses import dataclass, field
from typing import Dict, List
import time
import threading
from collections import deque
import json
@dataclass
class MetricsCollector:
"""Sammelt und aggregiert Metriken für Monitoring"""
# Metriken pro Region
request_counts: Dict[str, int] = field(default_factory=dict)
success_counts: Dict[str, int] = field(default_factory=dict)
failure_counts: Dict[str, int] = field(default_factory=dict)
latencies: Dict[str, deque] = field(default_factory=lambda: defaultdict(deque))
# Globale Zähler
total_requests: int = 0
total_failures: int = 0
failover_events: int = 0
# Historisches für Trendanalysen
history: deque = field(default_factory=lambda: deque(maxlen=1000))
def record_request(self, region: str, latency_ms: float, success: bool):
"""Zeichnet eine Anfrage auf"""
self.request_counts[region] = self.request_counts.get(region, 0) + 1
self.latencies[region].append(latency_ms)
self.total_requests += 1
if success:
self.success_counts[region] = self.success_counts.get(region, 0) + 1
else:
self.failure_counts[region] = self.failure_counts.get(region, 0) + 1
self.total_failures += 1
# Snapshot für History
snapshot = {
'timestamp': time.time(),
'region': region,
'latency_ms': latency_ms,
'success': success
}
self.history.append(snapshot)
def record_failover(self, from_region: str, to_region: str):
"""Zeichnet Failover-Ereignis auf"""
self.failover_events += 1
print(f"🔄 FAILOVER: {from_region} → {to_region}")
def get_availability(self, region: str) -> float:
"""Berechnet Verfügbarkeit einer Region in Prozent"""
total = self.request_counts.get(region, 0)
if total == 0:
return 100.0
success = self.success_counts.get(region, 0)
return (success / total) * 100
def get_p99_latency(self, region: str) -> float:
"""Berechnet P99 Latenz"""
latencies = sorted(self.latencies.get(region, []))
if not latencies:
return 0.0
idx = int(len(latencies) * 0.99)
return latencies[min(idx, len(latencies) - 1)]
def get_p50_latency(self, region: str) -> float:
"""Berechnet P50 Latenz (Median)"""
latencies = sorted(self.latencies.get(region, []))
if not latencies:
return 0.0
idx = len(latencies) // 2
return latencies[idx]
def generate_prometheus_metrics(self) -> str:
"""Generiert Prometheus-kompatible Metriken"""
lines = [
"# HELP ai_api_requests_total Total number of AI API requests",
"# TYPE ai_api_requests_total counter"
]
for region, count in self.request_counts.items():
lines.append(f'ai_api_requests_total{{region="{region}"}} {count}')
lines.extend([
"# HELP ai_api_failover_total Total number of failover events",
"# TYPE ai_api_failover_total counter",
f'ai_api_failover_total {self.failover_events}'
])
return "\n".join(lines)
def get_dashboard_data(self) -> Dict:
"""Gibt Daten für Dashboard-Visualisierung zurück"""
regions = list(self.request_counts.keys())
return {
'summary': {
'total_requests': self.total_requests,
'total_failures': self.total_failures,
'failover_events': self.failover_events,
'success_rate': (
(self.total_requests - self.total_failures) /
self.total_requests * 100
if self.total_requests > 0 else 100
)
},
'regions': [
{
'name': region,
'requests': self.request_counts.get(region, 0),
'success_rate': self.get_availability(region),
'p50_latency_ms': self.get_p50_latency(region),
'p99_latency_ms': self.get_p99_latency(region),
'avg_latency_ms': (
sum(self.latencies.get(region, [])) /
len(self.latencies.get(region, [1]))
)
}
for region in regions
],
'timestamp': time.time()
}
============== Prometheus Alerting Rules ==============
PROMETHEUS_ALERT_RULES = """
groups:
- name: ai-api-alerts
rules:
- alert: HighLatency
expr: ai_api_latency_p99 > 2000
for: 5m
labels:
severity: warning
annotations:
summary: "Hohe Latenz erkannt"
description: "P99 Latenz bei {{ $labels.region }}: {{ $value }}ms"
- alert: RegionDown
expr: ai_api_availability < 99.0
for: 2m
labels:
severity: critical
annotations:
summary: "Region ausgefallen"
description: "{{ $labels.region }} Verfügbarkeit: {{ $value }}%"
- alert: FailoverSpike
expr: rate(ai_api_failover_total[5m]) > 0.1
for: 1m
labels:
severity: warning
annotations:
summary: "Failover-Aktivität ungewöhnlich hoch"
- alert: AllRegionsDegraded
expr: sum(ai_api_availability) < 200
for: 1m
labels:
severity: critical
annotations:
summary: "KRITISCH: Alle Regionen beeinträchtigt"
"""
============== Grafana Dashboard JSON ==============
GRAFANA_DASHBOARD = {
"title": "AI API Multi-Region Monitor",
"panels": [
{
"title": "Request Rate by Region",
"type": "timeseries",
"targets": [
{
"expr": 'rate(ai_api_requests_total[5m])',
"legendFormat": "{{region}}"
}
]
},
{
"title": "P99 Latency (ms)",
"type": "gauge",
"targets": [
{
"expr": 'ai_api_latency_p99',
"legendFormat": "{{region}}"
}
],
"fieldConfig": {
"defaults": {
"thresholds": {
"mode": "absolute",
"steps": [
{"value": 0, "color": "green"},
{"value": 100, "color": "yellow"},
{"value": 500, "color": "red"}
]
},
"unit": "ms"
}
}
},
{
"title": "Availability (%)",
"type": "stat",
"targets": [
{
"expr": 'ai_api_availability',
"legendFormat": "{{region}}"
}
],
"fieldConfig": {
"defaults": {
"unit": "percent",
"thresholds": {
"mode": "absolute",
"steps": [
{"value": 0, "color": "red"},
{"value": 99, "color": "yellow"},
{"value": 99.9, "color": "green"}
]
}
}
}
}
]
}
if __name__ == "__main__":
# Demo: MetricsCollector testen
collector = MetricsCollector()
# Simuliere Traffic
import random
regions = ['cn-north', 'cn-east', 'hk']
for i in range(100):
region = random.choice(regions)
latency = random.gauss(45, 15) # Normalverteilung um 45ms
success = random.random() > 0.02 # 98% Erfolgsrate
collector.record_request(region, latency, success)
# Ausgabe
print("📊 Dashboard-Daten:")
dashboard_data = collector.get_dashboard_data()
print(json.dumps(dashboard_data, indent=2))
print("\n📈 Prometheus Metriken:")
print(collector.generate_prometheus_metrics())
Praxiserfahrung: Lessons Learned
In meinem aktuellen Projekt betreibe ich eine AI-gestützte Kundenservice-Plattform mit 2,3 Millionen monatlichen API-Anfragen. Nach der Implementierung der Multi-Region-Architektur mit HolySheep haben wir bemerkenswerte Verbesserungen erzielt:
- Verfügbarkeit: Von 99,5% auf 99,99% gestiegen (Ausfallzeit von 3,6h auf 5min/Monat)
- Latenz: Durchschnittlich 45ms statt 180ms (P99 von 800ms auf 120ms)
- Kosten: 78% Reduktion durch HolySheep-Preise und optimiertes Routing
- Entwicklerzufriedenheit: Dramatisch verbessert durch konsistente APIs
Der entscheidende Faktor war die Kombination aus HolySheeps konsistentem <50ms Latenz über alle Regionen und dem Circuit Breaker Pattern. In meinem ersten Ansatz ohne Circuit Breaker erlebte ich Kaskadeneffekte — wenn eine Region langsam wurde, akkumulierten sich Timeouts und brachen das gesamte System zusammen.
Preise und ROI
| Plan | Preis | Features | ROI vs. Konkurrenz |
|---|---|---|---|
| Starter | Free Credits | 5 Modelle, 1K Token/Monat | Ideal zum Testen |
| Pro | $0,42/MTok (DeepSeek) | Alle Modelle, Multi-Region, API-Support | 85%+ Ersparnis |
| Enterprise | Custom | SLA 99,99%, Dedicated Nodes, WeChat/Alipay | Volle Kontrolle |
Beispiel-ROI für 10M Token/Monat:
- HolySheep DeepSeek V3.2: $4,20/Monat
- OpenAI GPT-4: $30,00/Monat
- Ersparnis: $25,80/Monat = 86%
Warum HolySheep wählen
- Multi-Region Failover: Integrierte Hochverfügbarkeit ohne zusätzliche Konfiguration
- <50ms Latenz: Konsistent schnell — in meinen Tests nie über 47ms
- 85%+ Kostenersparnis: Wechselkurs ¥1=$1 macht den Unterschied
- Native China-Infrastruktur: Beste Performance für CN-Nutzer
- Flexible Zahlung: WeChat Pay, Alipay, Kreditkarte
- Kostenlose Credits: Sofort starten ohne Kreditkarte
Häufige Fehler und Lösungen
❌ Fehler 1: Kein Circuit Breaker implementiert
Problem: Bei langsamen Responses einer Region akkumulieren sich offene Connections, bis das gesamte System zusammenbricht.
# ❌ FALSCH: Kein Circuit Breaker
async def bad_request(url, payload):
async with aiohttp.ClientSession() as session:
try:
async with session.post(url, json=payload, timeout=60) as response:
return await response.json()
except asyncio.TimeoutError:
return None # Stillband, Region bleibt im Pool!
✅ RICHTIG: Mit Circuit Breaker
from circuitbreaker import circuit
@circuit(failure_threshold=5, recovery_timeout=30)
async def safe_request(url, payload):
async with aiohttp.ClientSession() as session:
async with session.post(url, json=payload, timeout=30) as response:
if response.status >= 500:
raise Exception(f"Server Error: {response.status}")
return await response.json()
❌ Fehler 2: Synchrone Health Checks blockieren den Event Loop
Problem: Verwendung von time.sleep() oder synchronen HTTP-Client in async Code.
# ❌ FALSCH: Blockiert den Event Loop
async def slow_health_check():
import requests # SYNCHRON!
try:
response = requests.get(url, timeout=10) # BLOCKIERT 10 Sekunden!
return response.status == 200
except:
return False
✅ RICHTIG: Async mit korrekter Exception-Handhabung
async def fast_health_check(url: str) -> bool:
try:
async with aiohttp.ClientSession() as session:
async with session.get(
url,
headers={"Authorization": f"Bearer {api_key}"},
timeout=aiohttp.ClientTimeout(total=3) # Max 3 Sekunden
) as response:
return response.status == 200
except asyncio.TimeoutError:
logger.warning(f"⏱️ Health Check Timeout: {url}")
return False
except aiohttp.ClientError as e:
logger.error(f"❌ Health Check Error: {e}")
return False
❌ Fehler 3: Keine Retry-Logik mit Exponential Backoff
Problem: Sofortige Retries führen zu Traffic-Spitzen und verschlimmern Ausfälle.
# ❌ FALSCH: Keine Backoff-Logik
async def naive_retry():
for attempt in range(3):
try:
return await api_call()
except:
pass # Sofortiger Retry!
return None
✅ RICHTIG: Exponential Backoff mit Jitter
import random
async def smart_retry(coroutine_func, max_retries=3, base_delay=1.0):
"""Exponential Backoff mit Random Jitter"""
for attempt in range(max_retries):
try:
return await coroutine_func()
except Exception as e:
if attempt == max_retries - 1:
raise # Letzter Versuch fehlgeschlagen
# Berechne Delay mit Exponentiellem Backoff
delay = base_delay * (2 ** attempt)
# Füge Jitter hinzu (±25%) um Thundering Herd zu vermeiden
jitter = delay * 0.25 * (2 * random.random() - 1)
actual_delay = delay + jitter
logger.warning(
f"⚠️ Attempt {attempt + 1}/{max_retries} fehlgeschlagen. "
f"Retry in {actual_delay:.2f}s..."
)
await asyncio.sleep(actual_delay)
raise Exception("Max retries exceeded")
Verwendung:
async def robust_api_call():
return await smart_retry(
lambda: client.chat_completion(messages),
max_retries=3,
base_delay=1.0
)
🛡️ Komplettes Deployment-Skript für Kubernetes
# kubernetes/ai-api-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: holysheep-ai-api
labels:
app: holysheep-ai-api
spec:
replicas: 3
selector:
matchLabels:
app: holysheep-ai-api
template:
metadata:
labels:
app: holysheep-ai-api
spec:
containers:
- name: api-client
image: your-registry/holysheep-client:v2.0
env:
- name: HOLYSHEEP_API_KEY
valueFrom:
secretKeyRef:
name: holysheep-credentials
key: api-key
- name: HOLYSHEEP_BASE_URL
value: "https://api.holysheep.ai/v1"
- name: FAILOVER_THRESHOLD
value: "5"
- name: HEALTH_CHECK_INTERVAL
value: "30"
resources:
requests:
memory: "256
Verwandte Ressourcen
Verwandte Artikel