In Kubernetes auf Null skalieren: Ein tiefer Einblick in Elasti

Elastisch ist eine innovative Open-Source-Lösung zur Optimierung der Kubernetes-Ressourcennutzung, indem Dienste während Leerlaufzeiten auf Null herunterskaliert und bei Bedarf wieder hochskaliert werden können. Elasti basiert auf einer Zweikomponenten-Architektur — einem Kubernetes-Controller und einem Request-Resolver — und verwaltet die Serviceverfügbarkeit nahtlos und minimiert gleichzeitig die Kosten. Dieser Beitrag soll einen technischen Überblick über die Architektur, Installation und Betriebsabläufe geben und sicherstellen, dass Sie Elasti effektiv in Ihre Kubernetes-Umgebungen integrieren und erweitern können.

💡 Diese Funktion ist in der Autoscaling-Suite von Truefoundry enthalten. Weitere Informationen finden Sie auf der Dokumentation.

Die Scale-to-Zero-Landschaft

Kubernetes bietet zwar robuste Skalierungsfunktionen durch HPA und Lösungen wie KEDA, aber die Skalierung auf null Replikate bleibt eine Herausforderung. Bestehende Ansätze lassen sich in der Regel in zwei Kategorien einteilen:

1. Native KEDA-Skalierung - KEDA kann zwar Bereitstellungen mithilfe von Ereignismetriken auf Null skalieren, aber dadurch entsteht ein Zeitfenster, in dem eingehende Anfragen während der Scale-Up-Kaltstartphase verloren gehen können.
2. Netze mit umfassendem Service (z. B. Knative) — Bietet eine umfassende Skalierung auf Null, erfordert jedoch erhebliche architektonische Änderungen und ist mit einem hohen Betriebsaufwand verbunden.
3. HTTP-Proxys (z. B. KEDA HTTP Add-on) — Pflegen Sie persistente Proxyschichten, die auch nach der Skalierung von Diensten zu Latenz führen.

Warum Elasti?

Elasti wurde entwickelt, um diese Einschränkungen mit drei zentralen Designzielen zu umgehen:

1. Leichte Integration - Arbeiten Sie mit vorhandenen Bereitstellungen/Diensten ohne Codeänderungen.
2. Kein Proxy-Overhead - Verlassen Sie den Anforderungspfad, sobald die Dienste skaliert sind.
3. Kostenoptimierte Skalierung - Echte Nullskalierung ohne Wartung der ständig aktiven Komponenten.

So funktioniert's

Elasti besteht aus zwei Kernkomponenten, die zusammenarbeiten, um die Serviceskalierung zu verwalten:

Controller (Betreiber):‍

• Überwacht ElastiService-Ressourcen in Ihrem Kubernetes-Cluster.
• Skaliert Services dynamisch zwischen 0 und 1 auf der Grundlage von Verkehrsmetriken in Echtzeit.

Resolver:

• Fungiert als Proxy, um eingehende Anfragen abzufangen, wenn der Dienst herunterskaliert wird.
• Stellt diese Anfragen in die Warteschlange und benachrichtigt den Controller, um den Service wieder zu skalieren, um sicherzustellen, dass keine Anfrage verloren geht.

Stetiger Fluss von Anfragen an Dienste

In diesem Modus werden alle Anfragen direkt von den Service-Pods bearbeitet. Der Elasti-Resolver wird nicht in den Anforderungspfad aufgenommen. Der Elasti-Controller fragt Prometheus weiterhin mit der konfigurierten Abfrage ab und überprüft das Ergebnis mit dem Schwellenwert, um festzustellen, ob der Dienst herunterskaliert werden kann.

Auf 0 herunterskalieren, wenn keine Anfragen vorliegen

Wenn die Abfrage von Prometheus einen Wert zurückgibt, der unter dem Schwellenwert liegt, skaliert Elasti den Dienst auf 0 herunter. Bevor er auf 0 skaliert wird, leitet er die Anfragen um, die an den Elasti-Resolver weitergeleitet werden, um dann das Rollout/die Bereitstellung so zu ändern, dass es 0 Replikate hat. Außerdem wird Keda dann angehalten (falls Keda verwendet wird), um zu verhindern, dass der Dienst hochskaliert wird, da Keda mit minReplicas als 1 konfiguriert ist.

Skalieren Sie von 0 aus, wenn die erste Anfrage eintrifft.

Da der Dienst auf 0 herunterskaliert ist, treffen alle Anfragen den Elasti-Resolver. Wenn die erste Anfrage eintrifft, skaliert Elasti den Dienst auf die konfigurierten MinTargetReplicas. Anschließend setzt es Keda fort, um die automatische Skalierung fortzusetzen, falls es zu einem plötzlichen Anstieg von Anfragen kommt. Außerdem wird der Dienst so geändert, dass er auf die tatsächlichen Service-Pods verweist, sobald der Pod hochgefahren ist. Die Anfragen, die an ElastiResolver eingegangen sind, werden bis zu 6 Minuten wiederholt und die Antwort wird an den Client zurückgesendet. Wenn der Pod länger als 6 Minuten braucht, um hochzufahren, wird die Anfrage verworfen.

Erste Schritte

Bereitstellung einer einfachen Anwendung mit Elasti

1. Einen lokalen Cluster erstellen

Minikube starten


oder

Art Cluster erstellen --name elasti-demo

oder

‍
Erstellen Sie einen lokalen Cluster mit Docker Desktop

2. Prometheus einrichten

Helm-Repo füge die Prometheus-Community hinzu https://prometheus-community.github.io/helm-charts
Helm-Repo-Aktualisierung
helm installiere kube-prometheus-stack prometheus-community/kube-prometheus-stack\
--Namespace-Überwachung\
--namespace erstellen\
--set alertmanager.enabled=falsch\
--set grafana.enabled=falsch\
--set prometheus.prometheusspec.serviceMonitorSelectorniluseHelmValues=Falsch

Installieren und konfigurieren Sie Prometheus im Überwachung Namensraum

Prometheus wird verwendet, um Metriken von Nginx-Ingress zu lesen, die dann von Elasti verwendet werden, um Metriken abzufragen, auf deren Grundlage es entscheidet, wann ein Service auf Null und von Null skaliert werden soll.

3. Nginx Ingress einrichten

Helm-Repo füge Ingress-Nginx hinzu https://kubernetes.github.io/ingress-nginx
Helm-Repo-Aktualisierung
Helm installiere Ingress-Nginx Ingress-Nginx/Ingress-Nginx\
--namespace ingress-nginx\
--set controller.metrics.enabled=wahr\
--set controller.metrics.serviceMonitor.enabled=Wahr\
--namespace erstellen

Stellt einen Nginx-Controller in der Ingress-Nginx Namensraum

Der Controller wird verwendet, um den Verkehr an unseren Httpbin-Demo-Dienst weiterzuleiten.

4. Elasti einrichten:

Helm-Repo füge Elastic hinzu https://charts.truefoundry.com/elasti
Helm-Repo-Aktualisierung
Helm installiert Elastic oci: //tfy.jfrog.io/tfy-helm/elasti\
--namespace elasti --namespace erstellen


Elasti mit Helm im Namespace Elasti installieren

Sobald Elasti installiert ist, sollten Sie sehen, dass zwei Hauptkomponenten ausgeführt werden:

• Controller/Betreiber: Verwaltet das Switching und die Skalierung des Datenverkehrs, indem es Metriken überwacht.
• Resolver: Fängt eingehende Anfragen ab, stellt sie in Warteschlangen und leitet sie als Proxy weiter

Weitere Konfigurationen finden Sie unter Werte.yaml um alle Konfigurationsoptionen in der Helm-Wertedatei zu sehen.

5. Stellen Sie eine Demoanwendung bereit

kubectl erstellt den Namespace Elasti-Demo
kubectl apply -n elasti-Demo -f\
https://raw.githubusercontent.com/truefoundry/elasti/refs/heads/main/playground/config/demo-application.yaml

Bereitstellen eines httpbin-Dienstes in der Elasti-Demo Namensraum

Dieser httpbin-Dienst wird verwendet, um zu demonstrieren, wie ein Dienst für die Verarbeitung des Datenverkehrs über Elasti konfiguriert wird.

6. Erstellen einer ElastiService-Ressource:

Erstellen Sie eine Yaml-Datei mit der folgenden Konfiguration für einen ElastiService.

API-Version: elasti.truefoundry.com/v1alpha1
Art: ElastiService
Metadaten:
Name: http://bin-elasti
Namensraum: Elasti-Demo
spezifikation:
MinTarget-Replikate: 1
Dienst: httpbin
Abklingzeit: 5
Zielreferenz skalieren:
API-Version: Apps/v1
Art: Einsätze
Name: httpbin
löst aus:
- Typ: Prometheus
Metadaten:
Abfrage: sum (rate (nginx_ingress_controller_nginx_process_requests_total [1m])) oder vector (0)
Serveradresse: http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090
Schwellenwert: „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

Einige wichtige Felder in der CRD-Spezifikation sind:

• MinTarget-Repliken: Mindestanzahl der Replikate, die beim Eintreffen der ersten Anfrage angezeigt werden.
• Abklingzeit: Mindestzeit (in Sekunden), die nach einer Hochskalierung abgewartet werden muss, bevor eine Verkleinerung in Betracht gezogen wird
• löst aus: Liste der Bedingungen, die bestimmen, wann herunterskaliert werden muss (unterstützt derzeit nur Prometheus-Metriken)
• Zielreferenz skalieren: Referenz auf das Skalierungsziel, das dem in HorizontalPodAutoscaler verwendeten ähnelt.

Weitere Informationen und die Konfiguration eines ElastiService für Ihren Anwendungsfall finden Sie in diesem Dokument.

Das Setup testen

Mit diesen Schritten haben Sie jetzt:

• Zugang zu Nginx läuft als dein Ingress-Controller.
• Prometheus eingerichtet, um Metriken zu scrapen (einschließlich derer von Ingress NGINX).
• httpbin bereitgestellt und über eine Ingress-Route zugänglich.

Mit dieser Konfiguration können Sie reale Routing-Szenarien testen und die Leistung und Metriken Ihres eingehenden Datenverkehrs überwachen.

Um dieses Setup zu testen, können Sie Anfragen an den Nginx-Load Balancer senden und die Pods unseres Demodienstes überwachen.

kubectl portforward svc/nginx-ingress-nginx-controller\
-n Eingangs-nginx 8080:80


Portweiterleitung zum Nginx-Controller

kubectl get pods -n elasti-Demo -w


Starte eine Uhr auf dem httpbin-Dienst

Jetzt können Sie eine Anfrage senden an http://localhost:8080/httpbin und Sie können sehen, wie der Service von Elasti auf 1 Replikat skaliert wird.

curl -v http://localhost:8080/httpbin

Senden Sie eine Anfrage an den httpbin-Dienst

Der Dienst wird dann wieder heruntergefahren, wenn keine Aktivität für Abklingzeit Sekunden, die im ElastiService angegeben sind (in diesem Fall 5 Sekunden).

Deinstallation von Elasti

Um Elasti zu deinstallieren, Sie müssen zuerst alle installierten ElastiServices entfernen. Löschen Sie dann einfach die Installationsdatei.

kubectl delete elastiservices --all
Helm deinstalliere elasti -n elasti
kubectl lösche den Namespace elasti

^Vergleiche

Vergleichstabelle der Funktionen:

Wann sollte man Elasti wählen

Elasti ist die beste Wahl, wenn Sie:

• Sie müssen vorhandenen HTTP-Diensten die Fähigkeit zur Skalierung auf Null hinzufügen
• Sie möchten sicherstellen, dass bei Skalierungsvorgängen kein Anforderungsverlust auftritt
• Bevorzugen Sie eine leichte Lösung mit minimaler Konfiguration
• Benötigen Sie eine Integration mit vorhandenen Autoscalern (HPA/KEDA)

Letzte Worte

Elasti wurde aus der Notwendigkeit heraus entwickelt, eine spezifische Herausforderung in Kubernetes anzugehen: die Implementierung einer echten Skalierung bis auf Null, ohne die Integrität der Anfragen zu beeinträchtigen oder übermäßigen Overhead zu verursachen. Diese Lösung unterstützt systemeigenes Autoscaling mit HPA und KEDA und stellt so sicher, dass bestehende Servicekonfigurationen unverändert bleiben und gleichzeitig eine effiziente Ressourcennutzung erreicht wird.

Durch die Bereitstellung dieses Tools als Open-Source-Lösung möchten wir eine robuste Lösung für Umgebungen bereitstellen, die eine echte Skalierung bis auf Null, ohne Anforderungsverluste und einen minimalen betrieblichen Fußabdruck erfordern.

Wir freuen uns über Beiträge und Feedback aus der Community — erkunde die Entwicklungsdokument für weitere Informationen.

‍