Was ist Helm und wie verwendet man es?

/ / Tutorials
Helm - Titelbild

Helm ist ein leistungsstarkes Werkzeug, das den Einsatz und das Management von Anwendungen auf Kubernetes vereinfacht. Es fungiert als Paketmanager für Kubernetes, ähnlich wie apt oder yum für Linux, und ermöglicht es dir, selbst die komplexesten Kubernetes-Anwendungen zu definieren, zu installieren und zu aktualisieren. Mit Helm kannst du als Systemadministrator oder Entwickler deine Workflows optimieren, die Komplexität reduzieren und Konsistenz bei den Bereitstellungen sicherstellen.

Das Verwalten von Anwendungen im großen Maßstab ist eine erhebliche Herausforderung. Kubernetes hat sich als De-facto-Standard für die Container-Orchestrierung etabliert, bringt aber auch seine eigenen Komplexitäten mit sich. Helm löst diese Probleme, indem es eine Möglichkeit bietet, Kubernetes-Ressourcen in einem einzigen Paket zu bündeln, was das Teilen und Bereitstellen von Anwendungen erleichtert. Dieser Guide soll dir Helm vorstellen und dabei die Installation, wichtige Konzepte und praktische Anwendung abdecken, damit du seine Fähigkeiten in deiner Kubernetes-Umgebung nutzen kannst.

Was ist Helm?

Helm ist ein Open-Source-Tool, das entwickelt wurde, um die Bereitstellung und Verwaltung von Anwendungen in einem Kubernetes-Cluster zu vereinfachen. Es fungiert als Paketmanager für Kubernetes und bietet eine standardisierte Möglichkeit, komplexe Anwendungen und Dienste zu verwalten.

Helm Definition und Zweck

Helm vereinfacht die Bereitstellung von Kubernetes-Anwendungen durch die Verwendung von „Charts“, die vorkonfigurierte Pakete von Kubernetes-Ressourcen sind. Diese Charts ermöglichen es dir, Anwendungen mit einem einzigen Befehl bereitzustellen, was Konsistenz gewährleistet und das Risiko von Fehlern verringert.

Hauptfunktionen von Helm

  • Paketverwaltung: Kubernetes-Anwendungen mithilfe von Charts definieren, installieren und aktualisieren, die in Repositories gespeichert und geteilt werden können.
  • Templating: Nutze Templates, um Kubernetes-Manifeste zu definieren, was es dir erleichtert, Deployments individuell anzupassen.
  • Versionierung: Charts unterstützen die Versionierung, wodurch du Änderungen nachverfolgen und bei Bedarf auf frühere Versionen zurückrollen kannst.
  • Abhängigkeitsmanagement: Charts können Abhängigkeiten deklarieren, um sicherzustellen, dass alle erforderlichen Dienste korrekt installiert und konfiguriert sind.

Wie installiert man Helm?

Die Installation von Helm ist ein einfacher Prozess und kann auf verschiedenen Plattformen, einschließlich Linux, macOS und Windows, durchgeführt werden.
Los gehts mit den Schritten für die Installation auf verschiedenen Betriebssystemen:

Systemanforderungen

Vor der Installation solltest du sicher stellen, dass du die folgenden Voraussetzungen erfüllst:

– Ein Kubernetes Cluster (ab Version 1.16 empfohlen)

– kubectl installiert und konfiguriert, um mit deinem Kubernetes Cluster zu kommunizieren

– Curl oder wget zum Herunterladen des Installationsskripts

Installationsschritte für unterschiedliche Plattformen

Alle nachfolgenden Schritte, egal für welche Operation, müssen in einem Terminal ausgeführt werden.

Für Linux und macOS ist es das Terminal, für Windows ist es PowerShell.

Linux

  1. Installationsskript herunterladen:

Führe diesen Befehl in deinem Terminal aus, um das Installationsskript von deren offizieller GitHub-Repository herunterzuladen:

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
  1. Installationsskript ausführen:
chmod 700 get_helm.sh
./get_helm.sh

macOS

  1. Homebrew verwenden:

Öffne das Terminal und führe diesen Befehl aus, um Helm mit Homebrew zu installieren:

brew install helm
  1. Alternativ kannst du die Binary herunterladen:
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 
chmod 700 get_helm.sh
./get_helm.sh

Windows

  1. Chocolatey verwenden:
choco install kubernetes-helm
  1. Scoop verwenden:
scoop install helm

Installation überprüfen

Nach der Installation kannst du die Installation überprüfen, indem du diesen Befehl in einem Terminal ausführst:

helm version

Du solltest eine Ausgabe ähnlich der folgenden sehen:

version.BuildInfo{Version:"v3.x.x", GitCommit:"xxxxx", GitTreeState:"clean", GoVersion:"go1.xx.x"} 

Helm-Charts verstehen

Helm-Charts sind wohl die wichtigste Funktionalität von Helm. Diese Charts sind Sammlungen von Dateien, die eine zusammengehörige Gruppe von Kubernetes-Ressourcen beschreiben. Das Verständnis der Struktur und der wesentlichen Komponenten eines Charts ist wichtig, um Helm effektiv zur Verwaltung deiner Anwendungen zu nutzen.

Struktur eines Charts

Ein solcher Charts folgt typischerweise einer Standard-Verzeichnisstruktur, die mehrere Schlüsseldateien und Verzeichnisse enthält:

mychart/
  Chart.yaml
  values.yaml
  charts/
  templates/

Hauptkomponenten

  • Chart.yaml: Dies ist die Hauptdatei eines Charts. Es enthält Metadaten über das Chart, wie Name, Version und Beschreibung.
apiVersion: v2
name: mychart
description: A Helm chart for Kubernetes
version: 0.1.0
  • values.yaml: Diese Datei enthält die Standardkonfigurationswerte für das Chart. Benutzer können diese Werte beim Bereitstellen des Charts überschreiben.
replicaCount: 1
image:
  repository: myimage
  tag: latest
  • charts/: Dieses Verzeichnis enthält alle Abhängigkeiten für das Chart. Abhängigkeiten sind selbst Charts, auf die dieses Chart angewiesen ist.
  • templates/: Dieses Verzeichnis enthält die Kubernetes-Manifest-Templates. Diese Vorlagen werden in Kubernetes-Manifeste gerendert, basierend auf den in values.yaml angegebenen Werten und anderen vom Benutzer festgelegten Werten.

Beispiel einer Bereitstellungsvorlage (`deployment.yaml`):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-myapp
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}-myapp
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}-myapp
    spec:
      containers:
        - name: myapp
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"

Das Verständnis dieser Komponenten ermöglicht es dir, Charts effektiv zu erstellen und anzupassen. Charts bieten ein wiederverwendbares, konfigurierbares und teilbares Paketformat zum Bereitstellen von Anwendungen auf Kubernetes. Durch die Verwendung von Templates und Werten können Charts an verschiedene Umgebungen und Anforderungen angepasst werden, wodurch sie ein leistungsstarkes Werkzeug in deinem Kubernetes-Management-Toolkit darstellen.

So erstellst Du deinen ersten Helm-Chart

Das Erstellen deines ersten Charts ist ein spannender Schritt, um zu lernen, wie man Kubernetes-Anwendungen effizient verwaltet. In diesem Abschnitt wirst du durch den Prozess geführt, wie du ein einfaches Chart erstellst und eine grundlegende Anwendung bereitstellst.

Schritt-für-Schritt Anleitung

  1. Neues Diagramm erstellen

Benutze den Befehl `helm create` um ein neues Diagramm zu erstellen:

helm create mychart

Dieser Befehl erzeugt eine Verzeichnisstruktur mit Standarddateien und Verzeichnissen, einschließlich `Chart.yaml`, `values.yaml` und dem `templates` Verzeichnis.

  1. Chart.yaml anpassen

Öffne die `Chart.yaml` Datei und aktualisiere sie mit den entsprechenden Metadaten für dein Diagramm:

apiVersion: v2
name: mychart
description: A Helm chart for a simple Kubernetes application
version: 0.1.0
  1. Werte.yaml bearbeiten

Ändere die `values.yaml` Datei, um Standardwerte für dein Diagramm festzulegen. Zum Beispiel:

replicaCount: 2
image:
  repository: nginx
  tag: stable
  1. Kubernetes Manifests in „templates/“ erstellen

Erstelle im `templates` Verzeichnis eine Bereitstellungsvorlage (`deployment.yaml`):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-nginx
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}-nginx
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}-nginx
    spec:
      containers:
        - name: nginx
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
  1. Chart packen

Sobald dein Diagramm fertig ist, packe es mit dem Befehl `helm package`:

helm package mychart

Dieser Befehl erzeugt eine `.tgz`-Datei, bei welcher es sich un die paketierte Version deines Diagramms handelt.

Beispiel-Projekt

Um das eben gezeigte zu demonstireren, erstellen wir ein Diagramm für einen Nginx-Webserver:

  1. Diagramm erstellen:
helm create nginx-chart
  1. Chart.yaml aktualisieren:
apiVersion: v2
name: nginx-chart
description: A Helm chart for Nginx
version: 0.1.0
  1. Werte.yaml bearbeiten:
replicaCount: 2
image:
  repository: nginx
  tag: stable
  1. Erstelle deployment.yaml in „templates/“:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-nginx
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}-nginx
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}-nginx
    spec:
      containers:
        - name: nginx
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
  1. Chart starten
helm install my-nginx nginx-chart

Verwendung von Helm zur Verwaltung von Anwendungen

Helm vereinfacht nicht nur die Bereitstellung von Anwendungen auf Kubernetes, sondern erleichtert auch deren Verwaltung. Dieses Kapitel behandelt, wie man Anwendungen installiert, aktualisiert, zurücksetzt und verwaltet.

Installieren von Anwendungen mit Helm

Um eine Anwendung mit einem Chart zu installieren, benutze den Befehl `helm install`, gefolgt vom Release-Namen und dem Pfad oder Namen des Charts:

helm install my-release mychart/

– `my-release` ist der Name, den du dieser Installationsinstanz angibt.

– `mychart/` ist der Pfad zu dem Chart, das du installieren möchtest.

Zum Beispiel, um das `nginx-chart` zu installieren, das im vorherigen Kapitel erstellt wurde:

helm install my-nginx nginx-chart/

Anwendungen mit Helm aktualisieren

Um ein existierendes Release auf eine neue Version eines Diagramms zu aktualisieren oder um Konfigurationswerte zu aktualisieren, benutze den `helm upgrade` Befehl:

helm upgrade my-release mychart/

Du kannst auch eine neue `values.yaml` Datei angeben oder neue Werte direkt im Befehl angeben:

helm upgrade my-release mychart/ --values new_values.yaml

oder

helm upgrade my-release mychart/ --set replicaCount=3

Rolling Back Anwendungen

Wenn ein Upgrade Probleme verursacht, kannst du einfach auf eine vorherige Version zurückrollen, indem du den Befehl `helm rollback` verwendest:

helm rollback my-release 1

In diesem Befehl bezieht sich `1` auf die Revisionsnummer, auf die du zurückrollen möchtest. Es wird automatische eine Historie der Releases, sodass du zu jedem vorherigen Zustand zurückkehren kannst.

Verwalten von Anwendungs-Releases mit Helm

Es werden mehrere Befehle zur Verfügung, um Informationen über deine Releases zu verwalten und einzusehen:

  • Alle Releases auflisten:
  helm list
  • Erhalte detaillierte Informationen zu einer bestimmten Version:
  helm status my-release
  • Eine Version deinstallieren:
  helm uninstall my-release

Mit diesen Befehlen kannst du die Kontrolle über den Lebenszyklus deiner Anwendung behalten und sicherstellen, dass die Bereitstellungen reibungslos und verwaltbar sind. Helms leistungsstarke Funktionen vereinfachen den Prozess der Wartung von Anwendungen und erleichtern die Verwaltung komplexer Kubernetes-Umgebungen.

Helm Repositories

Helm-Repositories sind wichtig zum Teilen und Verteilen von Charts. Ein Repository ist ein einfacher HTTP-Server, der gepackte Charts und eine Indexdatei enthält. Mit diesen Repositorys kannst du Charts finden und verwenden, die von anderen erstellt wurden, und deine eigenen Charts mit der Community teilen.

Hinzufügen und Benutzen von Helm-Repositories

Helm wird mit einem Standard-Repository namens Helm Hub geliefert, das Charts aus verschiedenen Quellen aggregiert. Du kannst jedoch auch andere Repositories hinzufügen, um auf eine größere Auswahl an Charts zuzugreifen.

  1. Repository hinzufügen:

Benutze den Befehl `helm repo add` um ein neues Repository hinzuzufügen:

helm repo add stable https://charts.helm.sh/stable

In diesem Beispiel fügen wir das Stable-Repository hinzu, das viele beliebte Charts enthält.

  1. Repositories aktualisieren:

Nachdem du Repositories hinzugefügt hast, aktualisiere sie, um die neueste Liste der Charts zu erhalten:

helm repo update
  1. Nach Charts suchen:

Benutze den Befehl `helm search repo` um Charts in den hinzugefügten Repositories zu finden:

helm search repo nginx

Dieser Befehl sucht in den hinzugefügten Repositories nach allen Charts, die mit Nginx in Verbindung stehen.

Charts aus Repositories verwenden

Sobald du ein Repository hinzugefügt und ein Chart gefunden hast, das du verwenden möchtest, ist die Installation einfach. Zum Beispiel, um das Nginx-Chart aus dem Stable-Repository zu installieren:

helm install my-nginx stable/nginx

Dieser Befehl installiert das Nginx-Chart unter Verwendung von Standardwerten. Du kannst die Installation anpassen, indem du eine eigene Werte-Datei bereitstellst oder die `–set`-Option verwendest, um bestimmte Werte zu überschreiben.

Fazit

Helm ist ein leistungsstarkes Werkzeug, das die Verwaltung von Kubernetes-Anwendungen vereinfacht, indem es das Konzept von Charts verwendet, die mehrere Kubernetes-Ressourcen in einem einzigen Paket bündeln. Durch die Verwendun können Entwickler und Systemadministratoren Anwendungen effizienter und konsistenter bereitstellen, aktualisieren und verwalten.

In diesem Leitfaden haben wir die wesentlichen Aspekte von Helm behandelt: von der Grundverständnis und Installation bis hin zur Erstellung eigener Charts und deren Verwendung zur Verwaltung von Anwendungen. Wir haben auch untersucht, wie man Repositorys nutzen kann, um eine Vielzahl von vorkonfigurierten Charts zu finden und bereitzustellen, was die Verwaltung von Kubernetes-Umgebungen weiter vereinfacht.

Zusammenfassung der wichtigsten Punkte

  • Überblick: Helm ist ein Paketmanager für Kubernetes, der eine standardisierte Methode zur Bereitstellung und Verwaltung von Anwendungen bietet.
  • Installation: Die Installation von Helm ist einfach, mit Unterstützung für verschiedene Betriebssysteme.
  • Helm-Charts: Charts sind die zentralen Einheiten in Helm und enthalten alle notwendigen Informationen zur Bereitstellung von Anwendungen.
  • Erstellen von Diagrammen: Du kannst deine eigenen Helm-Charts erstellen, um deine Anwendungen zu verpacken, sodass sie wiederverwendbar und teilbar sind.
  • Anwendungsverwaltung: Helm vereinfacht die Verwaltung des Anwendungslebenszyklus, einschließlich Installation, Upgrades und Rollbacks.
  • Repositories: Helm-Repositorys ermöglichen es dir, Charts zu teilen und zu finden, was die Zusammenarbeit in der Community und die Wiederverwendbarkeit fördert.

Helm optimiert nicht nur den Bereitstellungsprozess, sondern verbessert auch die Skalierbarkeit, Zuverlässigkeit und Wartbarkeit deiner Anwendungen. Durch die Nutzung von Helm kannst du dich mehr auf die Entwicklung und Verbesserung deiner Anwendungen konzentrieren, anstatt dich mit den Komplexitäten der Bereitstellung auseinanderzusetzen.

Nach oben scrollen