Wachsen Ihren Sysadmins die Docker-Container über den Kopf?
Ihr Software-System setzt sich aus einer Vielzahl von Anwendungen zusammen, die alle in Docker-Containern laufen. Für die Docker-Umgebungen benötigen Sie mehrere physische oder virtuelle Server. Bei steigender Last müssen Sie manuell nachziehen. Fällt eine Instanz aus, bemerkt das oft niemand rechtzeitig. Ihr Team führt Buch darüber, wo welche Anwendungen mit welchen Parametern laufen.
Ihr Team muss ständig hinterherrennen, um die Server und die Docker-Umgebungen aktuell zu halten. Die Sysadmin-Dokumentation zu pflegen, ist eine Sisyphusarbeit. Entwickler wälzen DevOps-Aufgaben gerne auf die Sysadmins ab: Den Entwicklern fehlt das Verständnis für die Ausführungs-Umgebung. Der Kommunikationsaufwand zwischen Entwicklung und Operations ist dauerhaft hoch.
Kubernetes einfach nutzen mit
Virtual Developer ist eine Plattform zur Modellierung, Generierung (ohne KI) und Dokumentation von Software-Systemen.
Der Kubernetes-Cluster und die Deployments der Anwendungen werden modelliert. Umgebungsvariablen sind First-Class Citizens im Modell und dokumentierbar. Ein Entwickler wird durch die Modellierung ermächtigt, seine Anwendung selbstständig in den Betrieb zu überführen. Die Rolle des Sysadmins verlagert sich hin zu Kontroll-Aufgaben und den Blick auf das Gesamtsystem.
Der Kubernetes-Generator erzeugt die passenden yaml-Dateien. Es spielt dabei keine Rolle, ob die Anwendungen generiert oder von Hand entwickelt werden. Die Generierung der Kubernetes-Konfiguration ist auch unabhängig von den für die Anwendungen genutzten Programmiersprachen und Frameworks. Sysadmins haben dadurch den freien Blick auf die für sie wichtigen Dinge: CPU- und RAM-Bedarf, Last-Anforderungen, Monitoring-Setup.
Bringen Sie Ihre Anwendungen mit Leichtigkeit auf Kubernetes
Entwicklern mehr Verantwortung geben, Sysadmins entlasten
Entwicklern DevOps zugänglich machen
Anstatt über Meetings oder E-Mails mit Ihren Sysadmins Informationen über eine zu deployende Anwendung auszutauschen, tragen Ihre Entwickler die Informationen direkt ins Modell ein. Ein Sysadmin meldet sich nur bei eventuellen Unklarheiten beim Entwickler.
Koordinierte Deployments mit mehreren Anwendungen können dann von Ihren Sysadmins durchgeführt werden. Die Sysadmins finden die notwendigen Informationen für alle Anwendungen im Modell, inklusive der Abhängigkeiten zwischen den Anwendungen.
Saubere yaml-Dateien nutzen
Die von Ihrem Team generierten yaml-Dateien haben eine geordnete Struktur. Generierte Werte sollten nur an bestimmten, dokumentierten Stellen manuell überschrieben werden. Das schützt vor Syntax-Fehlern und semantisch fehlerhaften Konfigurationen. Fehler, die Ihr Team erst später, vielleicht sogar erst im Produktivbetrieb merkt, werden vermieden.
Kubernetes-Lernkurve flach halten
Die Generierung der Kubernetes-Konfiguration durch Ihr Team führt dazu, dass viele Personen Kubernetes indirekt nutzen können, ohne gleich einen mehrtägigen Kurs absolviert zu haben oder monatelang Erfahrungen sammeln zu müssen. Kubernetes wird schonend eingeführt und trotzdem von Anfang an nutzbar.
Anwendungs-Konfiguration in den Griff bekommen
Umgebungsvariablen, oder allgemeiner ausgedrückt „Konfigurationselemente“, werden von Ihrem Team im Modell benannt, dokumentiert und mit Standardwerten versehen. In den generierten yaml-Dateien sind Links enthalten, mit denen man direkt zum Konfigurationselement im Modell springen kann.
Einer Ihrer Sysadmins muss keinen Entwickler mehr nach der Bedeutung von Umgebungsvariablen fragen, die von einer Anwendung ausgewertet werden. Und Ihr Entwickler muss dann nicht mehr im Programmcode suchen, um selbst die Bedeutung zu verstehen.
Nichtfunktionale Anforderungen spezifizieren
Ihre Entwickler und Ihre Sysadmins können im Modell Informationen über den Ressourcen-Bedarf einer Anwendung hinterlegen. Auch die Themen der Lastverteilung und Ausfallsicherheit sind im Modell über Optionen spezifizierbar. Da Ihr Team solche Werte schon sehr früh angeben kann, dient das Modell in dieser Hinsicht auch als Planungswerkzeug.
Sysadmins entlasten
Die Aufgaben Ihrer Sysadmins werden nach einer Umstellung auf Kubernetes mit Virtual Developer weniger umfangreich sein:
- Server- und Docker-Aktualisierungen fallen bei Kubernetes von vorneherein nicht an.
- Der zugrundeliegende Kubernetes-Cluster wird von Ihrem gewählten Dienstleister gepflegt.
- Die Modellierung und Generierung halten die Komplexität der Kubernetes-Konfiguration in Schach.
- Die System- und Deployment-Dokumentation entsteht prinzipbedingt von selbst, im Modell.
Ihre Sysadmins gewinnen dadurch Zeit, sich um andere technische Herausforderungen zu kümmern.
In 3 Schritten zu Ihrem Kubernetes-Cluster
Sie behalten die volle Kontrolle über die Laufzeitumgebung und die Deployments.
Kubernetes-Cluster und Deployments modellieren
Der Cluster, samt Namespaces und Anwendungs-Deployments, wird von Ihrem Team im Modell spezifiziert. Das funktioniert sowohl für generierte als auch für nur spezifizierte Anwendungen.
Kubernetes-Konfiguration generieren
Ihr Team erzeugt mit dem Kubernetes-Generator die yaml-Dateien für das Deployment der modellierten Anwendungen.
Kubernetes-Konfiguration anwenden
Ihr Team stellt die generierten yaml-Dateien in einem Git-Repository bereit. Von dort holt sich der Kubernetes-Cluster die Konfiguration, anhand derer die Pods und Container im Cluster eingerichtet und gesteuert werden.
Wir sprechen gerne mit Ihnen darüber, wie Sie Ihre Anwendungen auf einem Kubernetes-Cluster betreiben können.
Ich bin Marcus, ein echter Mensch – schreiben Sie mir direkt, wenn Sie das Thema beschäftigt.