# Kubernetes: Installations-Tutorial

Kubernetes (auch K8s genannt) ermöglicht eine effiziente Verwaltung großer Containermengen und automatisiert viele Prozesse in der Softwareentwicklung. Mit nur wenigen Schritten lässt sich ein leistungsfähiger Kubernetes-Cluster installieren und direkt produktiv nutzen.

## Schritt 1: System vorbereiten

Wir zeigen in diesem Tutorial exemplarisch die Kubernetes-Installation unter [Ubuntu](https://www.ionos.at/digitalguide/server/knowhow/ubuntu-das-linux-system-fuer-jedermann/).

Im ersten Schritt müssen wir das System vorbereiten, indem wir es auf den neuesten Stand bringen und alle notwendigen Abhängigkeiten installieren. Öffnen Sie hierzu das Terminal und führen Sie zunächst ein System-Update durch, um sicherzustellen, dass alle Pakete aktuell sind:

```bash
sudo apt update && sudo apt upgrade -y
```

Anschließend installieren Sie die wichtigsten Hilfsprogramme, die für die Installation von Kubernetes und Minikube benötigt werden. Hierzu können Sie folgenden Befehl nutzen:

```bash
sudo apt install -y curl wget apt-transport-https ca-certificates gnupg lsb-release
```

Diese Tools sorgen dafür, dass Sie externe Quellen sicher nutzen und weitere Softwarepakete problemlos herunterladen und installieren können.

## Schritt 2: kubectl installieren

[Kubernetes](https://www.ionos.at/digitalguide/server/knowhow/was-ist-kubernetes/) arbeitet mit verschiedenen Servern: dem Master und verschiedenen Nodes. Diese müssen nicht zwingend auf unterschiedlichen physischen Servern liegen. [Virtuelle Maschinen](https://www.ionos.at/digitalguide/server/knowhow/virtuelle-maschinen/) lassen es zu, dass Sie auch auf einem einzelnen Computer mehrere Kubernetes-Knotenpunkte aktivieren können. Gerade für Testzwecke hat sich das kostenlose Programm [Minikube](https://www.ionos.at/digitalguide/server/tools/minikube-vorgestellt/) bewährt. Es ermöglicht, auch lokal mit Kubernetes zu arbeiten. Da Minikube eine virtuelle Maschine oder [Docker](https://www.ionos.at/digitalguide/server/knowhow/was-ist-docker/) benötigt, ist das Programm auf einen [Hypervisor](https://www.ionos.at/digitalguide/server/knowhow/was-ist-ein-hypervisor/) oder die Container-Software angewiesen. Außerdem ist das Tool kubectl notwendig.

Hinweis In diesem Tutorial zeigen wir Ihnen den Kubernetes-Einstieg mithilfe von Docker. Sie können dasselbe aber auch mit einer Virtualisierungssoftware wie VirtualBox durchführen.

Zunächst installieren Sie daher kubectl (Kube Control) auf Ihrem System. Dieses Programm benötigen Sie, **um Cluster zu verwalten**.

```bash
curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
```

Hinweis Die Installationsbefehle hängen von Ihrer Systemarchitektur ab.

## Schritt 3: Docker installieren

Bevor Sie Minikube verwenden können, müssen Sie sicherstellen, dass Docker auf Ihrem System installiert ist. Docker dient dabei als Container-Runtime und ermöglicht es Minikube, [Kubernetes-Cluster](https://www.ionos.at/digitalguide/server/knowhow/kubernetes-cluster/) ohne Virtualisierungssoftware zu betreiben. Installieren Sie Docker mit folgendem Befehl:

```bash
sudo apt install -y docker.io
```

Um Docker ohne Root-Rechte nutzen zu können, fügen Sie Ihr Benutzerkonto der Docker-Gruppe hinzu:

```bash
sudo usermod -aG docker $USER
newgrp docker
```

Eventuell müssen Sie sich ab- und wieder anmelden, damit die Gruppenzugehörigkeit aktiv wird. Testen Sie die Installation abschließend mit:

```bash
docker run hello-world
```

Wenn eine kurze Erfolgsmeldung erscheint, ist Docker korrekt installiert und einsatzbereit für Minikube.

## Schritt 4: Minikube installieren und starten

In einem nächsten Schritt installieren Sie Minikube direkt in einer kompatiblen Version und nutzen Docker dabei als Treiber. Laden Sie zunächst die passende Version von Minikube herunter, machen Sie die Datei ausführbar und verschieben Sie sie in ein Systemverzeichnis, sodass der Befehl global verfügbar ist:

```bash
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-arm64
chmod +x minikube-linux-arm64
sudo mv minikube-linux-arm64 /usr/local/bin/minikube
```

Nach der Installation können Sie mit dem folgenden Befehl überprüfen, ob Minikube korrekt eingerichtet wurde:

```bash
minikube version
```

Anschließend starten Sie Minikube mit dem folgenden Kommando:

```bash
minikube start --driver=docker
```

Minikube nutzt in diesem Szenario Docker als Container-Runtime und erstellt den Kubernetes-Cluster direkt innerhalb der Docker-Umgebung. Beim Starten von Minikube sollte kubectl automatisch korrekt konfiguriert werden. Um von der Kommandozeile in ein [GUI](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-ein-gui/) zu wechseln, geben Sie einen weiteren Befehl ein. Dieser öffnet das **Dashboard** im Standardbrowser.

```bash
minikube dashboard
```

[![Bild: Kubernetes-Dashboard](https://www.ionos.at/digitalguide/fileadmin/_processed_/6/c/csm_ansicht-kubernetes-dashboard_879e52d53b.webp "Kubernetes-Dashboard")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/ansicht-kubernetes-dashboard.jpg) Leeres Kubernetes-Dashboard ## Schritt 5: Kubernetes nutzen

Wenn Sie Minikube gestartet haben, hat das Programm automatisch einen **Cluster** mit einem einzelnen Node erstellt. Dies können Sie mit einer Anfrage an kubectl überprüfen:

```bash
kubectl get nodes
```

Über das Dashboard können Sie nun **Deployments erstellen**. Klicken Sie auf den Create-Knopf (das Plus oben rechts), gelangen Sie zu einem webbasierten Editor. Im [JSON](https://www.ionos.at/digitalguide/server/knowhow/was-ist-json/)- oder [YAML](https://www.ionos.at/digitalguide/websites/web-entwicklung/yaml-das-schlanke-css-framework-fuer-experten/)-Format können Sie dort ein Deployment erstellen. Haben Sie dies erledigt, generiert Kubernetes automatisch mehrere Pods. Anpassen können Sie die gewünschte Anzahl, indem Sie das **Deployment skalieren**. Die entsprechende Funktion finden Sie nach einem Klick auf den Button mit drei Punkten neben dem Deployment.

[![Bild: Kubernetes-Dashboard mit einem Deployment und drei Pods](https://www.ionos.at/digitalguide/fileadmin/_processed_/6/4/csm_kubernetes-dashboard-ressourcen-pods-uebersicht_844c525814.webp "Kubernetes-Dashboard mit einem Deployment und drei Pods")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-dashboard-ressourcen-pods-uebersicht.jpg) Kubernetes: Deployment und Pods im Dashboard [![Bild: Skalierung eines Deployments in Kubernetes](https://www.ionos.at/digitalguide/fileadmin/_processed_/d/6/csm_ressourcen-skalieren-kubernetes-dashboard_3ba9b33fcb.webp "Skalierung eines Deployments in Kubernetes")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/ressourcen-skalieren-kubernetes-dashboard.jpg) Kubernetes: Skalieren Ihres Deployments Alternativ können Sie Deployments auch über das Terminal erzeugen. Hierfür müssen die Inhalte allerdings bereits in einem [Docker-Image](https://www.ionos.at/digitalguide/server/knowhow/docker-image/) integriert sein, das man in einem Repository abgelegt hat.

```bash
kubectl create deployment --image=[Pfad zum Image]
```

Über Kommandozeilenbefehle lassen sich zahlreiche Informationen beziehen.

**Welche Deployments gibt es?**

```bash
kubectl get deployments
```

**Wie viele Pods gibt es?**

```bash
kubectl get pods
```

**Welche Services gibt es?**

```bash
kubectl get services
```

**Welche Nodes sind aktiv?**

```bash
kubectl get nodes
```

[![Bild: Terminal mit verschiedenen Kubernetes-Befehlen und -Outputs](https://www.ionos.at/digitalguide/fileadmin/_processed_/f/5/csm_screenshot-kubernetes-ubuntu-terminal_4c2f4d2127.webp "Terminal mit verschiedenen Kubernetes-Befehlen und -Outputs")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/screenshot-kubernetes-ubuntu-terminal.jpg) Kubernetes-Befehle im Terminal ## Schritt 6: Deployment veröffentlichen

Bisher haben Sie Ihr Deployment zwar gestartet, aber noch nicht veröffentlicht. Eine Veröffentlichung veranlasst man, indem man einen **Service** erstellt:

```bash
kubectl expose deploy test-deployment
```

Auf diese Weise hat man den Service aber nur innerhalb des Clusters veröffentlicht. Um auch von **außerhalb des Clusters** auf das Deployment zugreifen zu können, fügt man zusätzliche Flags ein:

```bash
kubectl expose deploy test-deployment --type=LoadBalancer --port=8080
```

Mit Minikube kann man den **Service dann starten**:

```bash
minikube service test-deployment
```

Wer den Service wieder **löschen** möchte, findet auch dafür den richtigen Befehl:

```bash
kubectl delete service test-deployment
```

Auch das Deployment kann wieder gelöscht werden:

```bash
kubectl delete deployment test-deployment
```

Um Minikube schließlich zu beenden, stoppt man den Prozess:

```bash
minikube stop
```

Wer gar nicht mehr mit der VM oder der Container-Runtime arbeiten möchte, der kann diese auch löschen.

```bash
minikube delete
```

Im Anschluss sind auch die vorgenommenen Einstellungen und erstellten Deployments und Pods entfernt. Startet man Minikube erneut, arbeitet man wieder mit einem leeren Cluster.


This is a markdown version of: [https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-tutorial/](https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-tutorial/) for AI/LLM consumption.