© Liashko/Shutterstock.com
Kubernetes anwenderfreundlich machen, aber wie?

Kubernetes hat ein Imageproblem


Kubernetes ist populär wie nie zuvor. Kein Wunder, denn der Containerorchestrator bietet begehrte Features wie Rolling Updates, Zero Downtime, Self-Healing und Auto-Scaling. Zudem verspricht er ein nie zuvor dagewesenes Maß an Portabilität zwischen Plattformen. Doch je größer das Wertversprechen von Kubernetes wird, desto größer wird das Imageproblem, das über die Jahre entstanden ist.

Von vielen Entwicklern wird Kubernetes als zu komplex und kaum beherrschbar wahrgenommen. Kubernetes hat ein Imageproblem. Wenn Anwendungsentwickler aus diesem Grund Kubernetes meiden, dann werden die Vorteile von Kubernetes kaum realisierbar sein, denn es wird schlicht an Anwendungen fehlen, die für den Betrieb mit Kubernetes entwickelt werden.

Die mehr als 2 000 Contributors von Unternehmen wie Google, Microsoft oder Red Hat haben Kubernetes zur mächtigsten Technologie für den Betrieb und die Skalierung von Containern gemacht. Kubernetes löst einige der kompliziertesten Probleme beim Betrieb von Software auf sehr intelligente Weise, aber zur gleichen Zeit macht es sehr simple Aufgaben deutlich komplizierter. In Zeiten von Microservices und DevOps möchten Entwicklerteams kleine Anwendungen schnell aufbauen und in den Betrieb überführen. Nutzt man hierbei Kubernetes, muss der Entwickler plötzlich neben dem Konzept des Containers auch verstehen, was ein Pod ist und wie ein solcher durch ein ReplicaSet gesteuert wird, das wiederum von einem Deployment oder einem StatefulSet erzeugt wurde. Um eine Anwendung dann nach außen verfügbar zu machen, müssen zusätzlich noch Networkingressourcen wie Services, Ingresses oder Load Balancer konfiguriert werden. Die Anforderungen, die die Nutzung von Kubernetes mit sich bringt, sind selbst bei kleinsten Anwendungen so hoch, dass es insbesondere für Anwendungsentwickler zur Herausforderung werden kann, Kubernetes effizient einzusetzen.

Warum Kubernetes so komplex sein muss

Grundsätzlich ist Kubernetes als Containerorchestrator kein klassisches Entwicklertool, sondern überwiegend eine Technologie für Systemadministratoren. Dass Kubernetes entwicklerfreundlicher werden muss, stand bisher kaum im Fokus und daher ist es verständlich, dass Kubernetes als kompliziert und das Ökosystem als kaum zu überblicken gilt. Als Kubernetes 2014 von Google als Open-Source-Software auf GitHub veröffentlicht wurde [1], konnte wohl kaum einer ahnen, dass sich ein riesiges Ökosystem um diesen Containerorchestrator entwickeln würde. Heute zählt die Cloud Native Computing Foundation (CNCF), die im August 2018 die operative Kontrolle über das Kubernetes-Projekt übernommen hat [2], zu den aktivsten Initiativen innerhalb der Linux Foundation. Die CNCF hat mittlerweile knapp 100 Kubernetes-Distributionen, -Plattformen und -Installer zertifiziert [3] und listet mehr als 600 Projekte auf der CNCF Landscape [4], in deren Entwicklung bereits mehr als 40 Milliarden US-Dollar geflossen sind.

Dass das Kubernetes-Ökosystem so vielseitig ist, mag auf den ersten Blick abschrecken, doch es ist notwendig, da die Architektur von Kubernetes ein großes Maß an Flexibilität bietet. Und genau das ist das Erfolgsrezept von Kubernetes: Egal ob in der Public Cloud, im firmeneignen Rechenzentrum oder in hybriden Szenarien, Kubernetes lässt sich dank der Vielzahl an Plug-ins, Operatoren und Controllern auf nahezu jeder Infrastruktur betrieben. Und damit wird die Vision von infrastrukturunabhängiger, leicht portabler Software Realität. Kubernetes ist also unvermeidlich so komplex, doch führt das zwangsläufig dazu, dass Kubernetes auch eine schlechte Developer Experience haben muss?

Wie man Kubernetes anwenderfreundlicher macht

Einer der Gründe, warum Kubernetes zurzeit nicht besonders anwenderfreundlich ist, liegt darin, dass kaum ein Unternehmen Kubernetes so bereitstellt, dass Entwickler es mühelos als Service konsumieren und in ihren bestehenden Workflow integrieren können. Viele Unternehmen experimentieren zurzeit zwar mit Kubernetes, doch das Betreiben von Kubernetes-Clustern allein schafft noch keinen Mehrwert. Wenn wir Kubernetes-Cluster aufbauen und dann an Entwicklerteams übergeben, befruchten wir das Image von Kubernetes als komplexes Monster, das kaum zu managen ist. Übergibt man für Entwicklung nicht-optimierte Cluster an die Anwendungsentwickler, ist es nicht verwunderlich, dass Entwicklerteams sich von der Komplexität des Kubernetes-Ökosystems überwältigt fühlen. Die überwiegende Mehrheit der CNCF-Projekte ist für den Anwendungsentwickler jedoch kaum relevant. Für ein Entwicklerteam ist es unerheblich, welche Kubernetes-Distribution im Unternehmen verwendet wird und welches Storage-/Networking- oder Monitoring-Plug-in dabei genutzt wird.

Daher sollte man beim Betrieb von Kubernetes von Anfang an den Anwendungsentwickler im Blick haben, Cluster gemäß den Bedürfnissen der Entwickler ausstatten und die Developer Experience entsprechend optimieren. Wenn es Unternehmen gelingt, ihre Entwickler in die Lage zu versetzen, schnell und effizient Anwendungen zu entwickeln, die auf Kubernetes betrieben werden können, k...

headline from sands settings