Zum Inhalt springen

Wie wir unsere Kubernetes-Deployments mit einer Alternative zu Helm vereinfacht haben

Vier Personen sitzen in einem Konferenzraum mit Glaswänden um einen Konferenztisch herum. Im Hintergrund zeigt ein grosser Bildschirm Informationen an.

Dieser Artikel setzt voraus, dass du weisst, was Kubernetes ist und wie Deployments auf Kubernetes funktionieren. Falls nicht, empfehle ich dir die beiden verlinkten Posts von Daniel Sanche.

Am Anfang

«Am Anfang war das W̶o̶r̶t̶ YAML – und zwar jede Menge davon!»

Wenn du eine Applikation auf Kubernetes deployen willst, musst du Manifeste in Form von YAML-Dateien liefern. Sie sagen Kubernetes, wie das Deployment aussehen soll. Je mehr Applikationen du hast und je komplexer deine Infrastruktur wird, desto mehr Zeilen YAML sammeln sich an. Das muss nichts Schlechtes sein, aber für die meisten Applikationen sehen die Dateien ziemlich ähnlich aus (selbst bei unterschiedlichen Technologien).

Wenn du schon eine Weile in der Informatik unterwegs bist, wird dir bei so viel repetitivem «Code» sofort unwohl. Wiederholungen willst du lieber vermeiden. Stell dir vor, du willst etwas Simples wie den Namen deines Deployments ändern. Dann passt du wahrscheinlich dasselbe Feld metadata.name in deinen Dateien deployment.yml, service.yml, ingress.yml, certificate.yml, configmap.yml und secret.yml an. Und dabei sind spec.selector.matchLabels.name und spec.template.metadata.labels.name, die du vielleicht auch anpassen willst, noch nicht einmal mitgezählt.

Ein dunkler Code-Editor zeigt YAML-Dateien für die Bereitstellung von Kubernetes-Anwendungen an und hebt Dienste, Bilder, Konfigurationen und Ingress-Einstellungen hervor.

Unser Weg

Wir brauchten also einen Weg, unsere YAML-Dateien schlanker zu machen. Weil wir unseren Source Code auf GitLab hosten und unsere Applikationen dort auch bauen und deployen, haben wir angefangen, Platzhalter in unsere Kubernetes-Manifeste einzubauen. Mit dem GitLab Variables Feature haben wir dann Werte wie metadata.namespace oder metadata.name ersetzt. Für die Ersetzung der Variablen haben wir ein paar Bash-Skripte geschrieben, die wir in der GitLab-Pipeline laufen lassen konnten. Das sah ungefähr so aus:

stages:
  - deploy
deploy:
  variables:
    K8S_NAMESPACE: staging
  script:
    - chmod +x ./*
    - mkdir -p k8s/deploy
    - /bin/bash deploy.sh $CI_PROJECT_NAME $K8S_NAMESPACE
    - kubectl apply -f ${CI_PROJECT_DIR}/k8s/deploy
#!/usr/bin/env bash
export CI_PROJECT_NAMESPACE=${1}
export CI_PROJECT_NAME=${2}
export K8S_NAMESPACE=${3}
for f in k8s/*.yml
do
  envsubst < $filename > "k8s/deploy/$(basename $filename)"
done

Das war eine grosse Verbesserung: Wir konnten die Werte der GitLab Variables ändern, und die Änderungen landeten direkt in unserem laufenden System.

Wir setzten immer mehr auf Platzhalter und Shell-Skripte (und auf die teils hässlichen Dinge, die sich damit anstellen lassen). Irgendwann fiel uns auf, dass in unserem Repository plötzlich mehrere voodoo-magic.sh-Dateien lagen, die:

  • sich nicht wirklich mit Unit Tests testen liessen
  • schwer zu verstehen waren
  • in all unseren Projekten sehr ähnlich aussahen

Ähnliche Dateien … da klingelt doch was. Wir wollten diese Skripte sofort an einen Ort auslagern, wo wir sie verwalten und zwischen unseren Repositories teilen konnten (und wo keine Entwickler*innen sie je anschauen müssten).

Die (offizielle?) Lösung

Wir waren natürlich nicht die Ersten, deren Kubernetes-YAML-Dateien zu einem Chaos anwuchsen. Tatsächlich gibt es ein Produkt, das dir hilft, es in den Griff zu bekommen. Die klugen Köpfe von Deis (inzwischen von Microsoft übernommen) und Google arbeiteten schon länger an diesem Problem. Irgendwann beschlossen sie, sich zusammenzutun. Das Resultat ist der heute sehr beliebte Helm Package Manager. Er vereint die Features des Kubernetes-Ports des «Google Cloud Deployment Manager» mit denen von «Helm Classic», wie es heute heisst.

«Helm hilft dir, Kubernetes-Applikationen zu verwalten. Mit Helm Charts kannst du selbst die komplexesten Kubernetes-Applikationen definieren, installieren und upgraden. - Website helm.sh»

Neben anderen Features kann Helm im Kern Templates von YAML-Dateien (sogenannte Charts) verwalten und die Platzhalter darin durch die Werte ersetzen, die du in einer values.yaml-Datei angibst. Das zweite Argument für Helm: Viele Tools wie der bekannte cert-manager haben bereits eigene Charts. Die Installation wird so zum Einzeiler:

helm install --name my-release stable/cert-manager
«Hey, das klingt doch genau nach dem, was ihr braucht. Warum nicht einfach Helm verwenden?»

Ja, das haben wir uns auch gefragt, und zwar sehr oft!! Warum haben wir es also nicht gemacht? Warum der Aufwand für eine eigene Lösung?

Ein Problem von Helm ist eine mögliche Sicherheitslücke: Tiller (die Server-Komponente von Helm) muss in deinem Cluster laufen und braucht privilegierte Zugriffsrechte, um Deployments anzuwenden und zu löschen. Wenn sich also Angreifer*innen Zugriff auf Tiller (in deinem Cluster) verschaffen, können sie Deployments anwenden und löschen. Im schlimmsten Fall läuft Tiller mit cluster-admin-Rechten, damit es Namespaces, Service Accounts oder Cluster Role Bindings erstellen und löschen kann (was du wahrscheinlich sowieso irgendwann brauchst und viele auch so machen). Dann können Angreifer*innen mit Zugriff auf diese Tiller-Instanz deine Deployments löschen und sogar deinen ganzen Cluster lahmlegen.

Viele von euch wissen wahrscheinlich, dass es Wege gibt, dieses Risiko zu minimieren, und manche werden einwenden, dass das Szenario sowieso ziemlich unwahrscheinlich ist. Für uns kam es (damals) aber einfach nicht in Frage. Zu der Zeit war das Helm-Projekt noch nicht einmal Teil der CNCF. Jetzt, wo das Team hinter Helm an Version 3 ohne Tiller arbeitet und wir gelernt haben, dass sich der Helm Client auch ohne Tiller nutzen lässt, stellt sich die Frage «Warum nicht einfach Helm verwenden?» erneut.

Aber es gibt noch ein weiteres Argument.

Damit wir unsere Kund*innen bei der Wahl von Tools und Technologien gut beraten können, wollen wir genau wissen, wie die Dinge funktionieren. Ein gutes Beispiel dafür ist mein erster Kontakt mit dem Monitoring-Toolset Prometheus und Grafana. Hätten wir Helm verwendet, hätte ich wahrscheinlich einfach eines der vielen verfügbaren Helm Charts installiert, um unseren Cluster zu überwachen. Weil ich Helm nicht verwenden konnte und deshalb alle nötigen Manifeste selbst zusammengestellt habe, verstehe ich die verschiedenen Komponenten auf unserem Cluster heute viel besser. Das hilft mir, Probleme in unserem Cluster zu erkennen und unsere Kund*innen fundiert zu beraten, wenn sie nach einer bestimmten Software fragen.

Unsere Lösung

Wie gesagt, mit unseren Templates mit Platzhaltern waren wir ziemlich zufrieden. Wir suchten aber noch nach einem besseren Weg, die Variablen zu ersetzen, um die hässliche Sammlung eigener Skripte loszuwerden. Gleichzeitig merkten wir, dass wir in unserer gitlab-ci.yml-Datei rund um den Befehl kubectl apply -f ... immer wieder ähnliche Skript-Schnipsel verwendeten. So kam uns die Idee, ein eigenes Command Line Tool zu bauen, das uns einfache Befehle für unsere Deployments liefert.

Ich habe das Glück, in einer Firma zu arbeiten, die solche Ideen unterstützt. Und noch besser: Mein Kollege Christoph Bühler setzt sie blitzschnell um. Kurz darauf war unser neues interaktives CLI-Deployment-Tool «kuby» geboren. Es ist Open Source und du findest es hier auf GitHub. Kuby ist ein Wrapper um kubectl und bietet Befehle wie kuby prepare, um Variablen in YAML zu ersetzen, oder kuby deploy, um Deployments vorzubereiten und auf Kubernetes anzuwenden. Es ist in Node.js geschrieben und verwendet yargs, um CLI-Befehle und -Optionen zu parsen und zu verarbeiten. Dank TypeScript können wir unsere Deployment-«Skripte» endlich mit Unit Tests prüfen und sicherstellen, dass nach Anpassungen alles noch funktioniert.

Wir haben kuby in ein Docker Image gepackt und stellen mehrere Images für die verschiedenen kubectl-Versionen bereit. Mit diesem Image sieht das Skript, um eine Applikation mit YAML-Templates auf Kubernetes zu deployen, jetzt so einfach aus:

stages:
  - deploy
deploy:
  image: smartive/kuby
  script:
    - kuby --ci deploy
view raw

Der Befehl kuby —- ci deploy sucht in einem bestimmten Ordner (standardmässig ./k8s) nach allen *.yml-Dateien, ersetzt jedes ${MY_VARIABLE} oder $MY_VARIABLE durch Werte aus Umgebungsvariablen (mit envsubst) und führt in diesem Ordner ein kubectl apply -f . aus. Ausserdem bringt das CLI Tool ein paar praktische Features mit, etwa Namespaces erstellen, Kontexte wechseln oder Secrets anlegen. Das vereinfacht einige alltägliche Aufgaben mit Kubernetes und beschleunigt unseren Workflow.

Wir sind ziemlich zufrieden mit dieser Lösung, weil sie im Vergleich zu Helm ziemlich leichtgewichtig ist. Trotzdem arbeiten wir weiter an anderen Teilen unserer CI/CD-Pipeline. Auf unserer Liste stehen zum Beispiel der bessere Umgang mit .gitlab-ci.yml-Dateien, eine einfachere Google-Cloud-Build-Konfiguration und das Golden Image Pattern für unsere Docker Images. Vielleicht gibt es also bald einen Blogpost zu einem dieser Themen :-)

Probier es selbst aus

Schau dir kuby an und finde heraus, ob es deine eigenen Deployments verbessern kann. Für den Einstieg wirf einen Blick ins Readme in unserem Repository, und hinterlass einen Kommentar, wenn du Fragen hast.

Ein Mann mit Brille, kurzen dunklen Haaren und Bart steht mit den Händen in den Taschen da. Er trägt ein marineblaues T-Shirt und Jeans in Orange.

Geschrieben von
Josh Wirth

DevOps|November 2019

Ähnliche Challenge auf dem Tisch? Lass uns drüber reden.

Weitere Artikel

© 2026 smartive AG