Skalierung auf Null in Kubernetes: Ein detaillierter Einblick in Elasti

Auf Geschwindigkeit ausgelegt: ~ 10 ms Latenz, auch unter Last
Unglaublich schnelle Methode zum Erstellen, Verfolgen und Bereitstellen Ihrer Modelle!
- Verarbeitet mehr als 350 RPS auf nur 1 vCPU — kein Tuning erforderlich
- Produktionsbereit mit vollem Unternehmenssupport
Elasti ist eine innovative Open-Source-Lösung zur Optimierung der Kubernetes-Ressourcennutzung. Sie ermöglicht es Services, in Inaktivitätszeiten auf Null herunterzuskalieren und bei Bedarf wieder hochzuskalieren. Mit einer Zwei-Komponenten-Architektur – einem Kubernetes-Controller und einem Request Resolver – verwaltet Elasti nahtlos die Service-Verfügbarkeit bei minimalen Kosten. Dieser Beitrag bietet einen technischen Überblick über die Architektur, Installation und Betriebsabläufe, damit Sie Elasti effektiv in Ihre Kubernetes-Umgebungen integrieren und erweitern können.
💡 Diese Funktion ist in der Autoscaling-Suite von TrueFoundry enthalten. Weitere Details finden Sie in der Dokumentation.
Die Scale-to-Zero-Landschaft
Obwohl Kubernetes über HPA und Lösungen wie KEDA robuste Skalierungsfunktionen bietet, bleibt das Skalieren auf Null Replikate eine Herausforderung. Bestehende Ansätze fallen typischerweise in zwei Kategorien:
- Natives KEDA-Skalieren – KEDA kann Deployments mithilfe von Event-Metriken zwar auf Null skalieren, dies erzeugt jedoch ein Zeitfenster, in dem eingehende Anfragen während des Kaltstarts beim Hochskalieren verloren gehen können.
- Vollständige Service Meshes (z. B. Knative) – Bieten umfassendes Scale-to-Zero, erfordern jedoch erhebliche architektonische Änderungen und sind mit hohem betrieblichem Aufwand verbunden.
- HTTP-Proxies (z. B. KEDA HTTP Add-on) – Verwenden dauerhafte Proxy-Schichten, die selbst nach dem Hochskalieren der Services Latenz verursachen.
Warum Elasti?
Elasti wurde entwickelt, um diese Einschränkungen mit drei zentralen Entwurfszielen zu beheben:
- Leichtgewichtige Integration – Funktioniert mit bestehenden Deployments/Services ohne Codeänderungen.
- Kein Proxy-Overhead – Klinkt sich aus dem Request-Pfad aus, sobald die Services hochskaliert sind.
- Kostenoptimierte Skalierung – Echte Null-Skalierung, ohne ständig aktive Komponenten betreiben zu müssen.
Wie es funktioniert
Elasti besteht aus zwei Kernkomponenten, die zusammenarbeiten, um die Service-Skalierung zu verwalten:
Controller (Operator):
- Überwacht ElastiService-Ressourcen in Ihrem Kubernetes-Cluster.
- Skaliert Services dynamisch zwischen 0 und 1 basierend auf Echtzeit-Traffic-Metriken.
Resolver:
- Agiert als Proxy, um eingehende Anfragen abzufangen, wenn der Service herunterskaliert ist.
- Reiht diese Anfragen in eine Warteschlange ein und benachrichtigt den Controller, den Service wieder hochzuskalieren, sodass keine Anfrage verloren geht.

Normalbetrieb (Steady State) des Request-Flusses zu Services
In diesem Modus werden alle Anfragen direkt von den Service-Pods verarbeitet. Der Elasti Resolver schaltet sich nicht in den Request-Pfad ein. Der Elasti Controller fragt Prometheus kontinuierlich mit der konfigurierten Abfrage ab und vergleicht das Ergebnis mit dem Schwellenwert, um zu prüfen, ob der Service herunterskaliert werden kann.

Herunterskalieren auf 0 bei ausbleibenden Anfragen
Wenn die Abfrage von Prometheus einen Wert unterhalb des Schwellenwerts zurückgibt, skaliert Elasti den Service auf 0 herunter. Bevor auf 0 skaliert wird, leitet Elasti die Anfragen an den Elasti Resolver um und passt das Rollout/Deployment so an, dass es 0 Replikate hat. Anschließend pausiert es KEDA (falls KEDA verwendet wird), um zu verhindern, dass KEDA den Service wieder hochskaliert, da KEDA üblicherweise mit minReplicas=1 konfiguriert ist.

Hochskalieren von 0, wenn die erste Anfrage eintrifft
Da der Service auf 0 herunterskaliert ist, treffen alle Anfragen beim Elasti Resolver ein. Wenn die erste Anfrage eingeht, skaliert Elasti den Service auf die konfigurierten minTargetReplicas hoch. Anschließend setzt es KEDA wieder fort, damit das automatische Skalieren im Falle eines plötzlichen Traffic-Anstiegs weiterläuft. Sobald der Pod bereit ist, passt Elasti den Service so an, dass er wieder auf die tatsächlichen Service-Pods zeigt. Anfragen, die beim ElastiResolver eingegangen sind, werden bis zu 6 Minuten lang erneut versucht, bis die Antwort an den Client zurückgesendet wird. Benötigt der Pod länger als 6 Minuten für den Start, wird die Anfrage verworfen.


Erste Schritte
Bereitstellen einer einfachen Anwendung mit Elasti
- Erstellen eines lokalen Clusters
minikube start
oder
kind create cluster --name elasti-demo
oder
Erstellen Sie einen lokalen Cluster mit Docker Desktop
- Einrichten von Prometheus
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
--namespace monitoring \
--create-namespace \
--set alertmanager.enabled=false \
--set grafana.enabled=false \
--set prometheus.prometheusSpec.serviceMonitorSelectorNilUsesHelmValues=false
Installieren und konfigurieren Sie Prometheus im Namespace monitoring
Prometheus wird verwendet, um Metriken von Ingress NGINX zu lesen, die anschließend von Elasti abgefragt werden, um zu entscheiden, wann ein Service auf und von Null skaliert werden soll.
- Einrichten von Ingress NGINX
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install ingress-nginx ingress-nginx/ingress-nginx \
--namespace ingress-nginx \
--set controller.metrics.enabled=true \
--set controller.metrics.serviceMonitor.enabled=true \
--create-namespace
Bereitstellung eines NGINX-Controllers im Namespace ingress-nginx
Der Controller wird verwendet, um Traffic zu unserem Demo-httpbin-Service zu routen.
4. Einrichten von Elasti:
helm repo add elasti https://charts.truefoundry.com/elasti
helm repo update
helm install elasti oci://tfy.jfrog.io/tfy-helm/elasti \
--namespace elasti --create-namespace
Installation von Elasti mit Helm im Namespace elasti
Sobald Elasti installiert ist, sollten die zwei Kernkomponenten ausgeführt werden:
- Controller/Operator: Steuert die Traffic-Umschaltung und das Skalieren durch Überwachung von Metriken.
- Resolver: Fängt eingehende Anfragen ab, reiht sie in eine Warteschlange ein und leitet sie weiter.
Für erweiterte Konfigurationen werfen Sie einen Blick in die values.yaml, um alle Konfigurationsoptionen der Helm-Values-Datei zu sehen.
- Bereitstellen einer Demo-Anwendung
kubectl create namespace elasti-demo
kubectl apply -n elasti-demo -f \
https://raw.githubusercontent.com/truefoundry/elasti/refs/heads/main/playground/config/demo-application.yaml
Bereitstellung eines httpbin-Service im Namespace elasti-demo
Dieser httpbin-Service dient dazu, zu demonstrieren, wie ein Service für die Abwicklung von Traffic über Elasti konfiguriert wird.
- Erstellen einer ElastiService-Ressource:
Erstellen Sie eine YAML-Datei mit der folgenden Konfiguration für einen ElastiService.
apiVersion: elasti.truefoundry.com/v1alpha1
kind: ElastiService
metadata:
name: httpbin-elasti
namespace: elasti-demo
spec:
minTargetReplicas: 1
service: httpbin
cooldownPeriod: 5
scaleTargetRef:
apiVersion: apps/v1
kind: deployments
name: httpbin
triggers:
- type: prometheus
metadata:
query: sum(rate(nginx_ingress_controller_nginx_process_requests_total[1m])) or vector(0)
serverAddress: http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090
threshold: "0.5"
demo-elasti-service.yaml
Sobald die Datei erstellt ist, wenden Sie den ElastiService an:
kubectl apply -f https://raw.githubusercontent.com/truefoundry/elasti/refs/heads/main/playground/config/demo-elastiService.yaml
Wichtige Felder in der CRD-Spezifikation sind:
minTargetReplicas: Mindestanzahl an Replikaten, die beim Eintreffen der ersten Anfrage gestartet werden sollen.cooldownPeriod: Mindestzeit (in Sekunden), die nach dem Hochskalieren gewartet wird, bevor ein Herunterskalieren in Betracht gezogen wird.triggers: Liste von Bedingungen, die bestimmen, wann herunterdeskaliert werden soll (derzeit werden nur Prometheus-Metriken unterstützt).scaleTargetRef: Referenz auf das Skalierungsziel, ähnlich der Verwendung im HorizontalPodAutoscaler.
Weitere Details und Anleitungen zur Konfiguration eines ElastiService für Ihren Anwendungsfall finden Sie in dieser Dokumentation.
Testen des Setups
Mit diesen Schritten verfügen Sie nun über:
- Ingress NGINX als Ihren Ingress-Controller.
- Prometheus zur Erfassung von Metriken (einschließlich derer von Ingress NGINX).
- httpbin bereitgestellt und erreichbar über eine Ingress-Route.
Diese Konfiguration hilft Ihnen, reale Routing-Szenarien zu testen und die Leistung sowie Metriken Ihres Ingress-Traffics zu überwachen.
Um dieses Setup zu testen, können Sie Anfragen an den NGINX-Load-Balancer senden und die Pods unseres Demo-Service beobachten.
kubectl port-forward svc/nginx-ingress-nginx-controller \
-n ingress-nginx 8080:80
Port-Forwarding zum NGINX-Controller
kubectl get pods -n elasti-demo -w
Starten Sie ein Watch auf den httpbin-Service
Nun können Sie eine Anfrage an http://localhost:8080/httpbin senden und beobachten, wie der Service von Elasti auf 1 Replikat hochskaliert wird.
curl -v http://localhost:8080/httpbin
Senden Sie eine Anfrage an den httpbin-Service
Der Service wird nach Ablauf der im ElastiService angegebenen Inaktivitätszeit von cooldownPeriod Sekunden (in diesem Fall 5 Sekunden) wieder auf 0 herunterskaliert.
Deinstallieren von Elasti
Um Elasti zu deinstallieren, müssen Sie zuerst alle installierten ElastiServices entfernen. Löschen Sie danach einfach die Installationsdatei.
kubectl delete elastiservices --all
helm uninstall elasti -n elasti
kubectl delete namespace elasti
Vergleiche
Funktionsvergleichstabelle:
Wann Sie Elasti wählen sollten
Elasti ist die beste Wahl, wenn Sie:
- Bestehenden HTTP-Services Scale-to-Zero-Funktionen hinzufügen müssen
- Sicherstellen möchten, dass während Skalierungsvorgängen keine Anfragen verloren gehen
- Eine leichtgewichtige Lösung mit minimalem Konfigurationsaufwand bevorzugen
- Eine Integration mit bestehenden Autoscalern (HPA/KEDA) benötigen
Fazit
Elasti wurde aus der Notwendigkeit heraus entwickelt, eine spezifische Herausforderung in Kubernetes zu lösen: ein echtes Scale-to-Zero zu implementieren, ohne die Anfrageintegrität zu gefährden oder übermäßigen Overhead zu erzeugen. Die Lösung unterstützt natives Autoscaling mit HPA und KEDA und stellt sicher, dass bestehende Service-Konfigurationen unverändert bleiben, während eine effiziente Ressourcenauslastung erreicht wird.
Mit der Open-Source-Bereitstellung dieses Tools möchten wir eine robuste Lösung für Umgebungen bieten, die echtes Scale-to-Zero, null Anfrageverlust und einen minimalen betrieblichen Aufwand erfordern.
Wir freuen uns über Beiträge und Feedback aus der Community – weitere Details finden Sie in der Entwicklerdokumentation.
TrueFoundry AI Gateway bietet eine Latenz von ~3—4 ms, verarbeitet mehr als 350 RPS auf einer vCPU, skaliert problemlos horizontal und ist produktionsbereit, während LiteLM unter einer hohen Latenz leidet, mit moderaten RPS zu kämpfen hat, keine integrierte Skalierung hat und sich am besten für leichte Workloads oder Prototyp-Workloads eignet.


















%20(28).webp)



.webp)
.webp)
.png)

.png)
.png)
.png)
.png)
.png)
.webp)
.webp)






