Kubernetes installieren: Komplette Anleitung für Ubuntu und Debian

Kubernetes installieren: Komplette Anleitung für Ubuntu und Debian 2026

Kubernetes (K8s) ist die führende Container-Orchestrierungs-Plattform für moderne Microservices-Architekturen. In dieser Anleitung zeigen wir Ihnen Schritt für Schritt, wie Sie einen produktionsreifen Kubernetes Cluster installieren auf Ubuntu und Debian. Sie lernen die Installation von kubeadm, die Einrichtung eines Control Plane Nodes und das Hinzufügen von Worker Nodes.

Was ist Kubernetes?

Kubernetes ist ein Open-Source-System zur Automatisierung von Deployment, Skalierung und Verwaltung containerisierter Anwendungen. Ursprünglich von Google entwickelt, orchestriert Kubernetes heute Millionen von Containern weltweit.

Kubernetes bietet:

  • Automatisches Deployment und Skalierung von Containern
  • Self-Healing: Automatischer Neustart ausgefallener Container
  • Load Balancing und Service Discovery
  • Rolling Updates ohne Downtime
  • Secrets- und Konfigurationsmanagement
  • Storage-Orchestrierung über Persistent Volumes

Voraussetzungen

Bevor Sie Kubernetes installieren, benötigen Sie:

Systemanforderungen

  • Betriebssystem: Ubuntu 20.04/22.04/24.04 LTS oder Debian 11/12
  • Architektur: 64-Bit (x86_64/amd64 oder ARM64)
  • RAM: Mindestens 2 GB pro Node (4 GB+ empfohlen)
  • CPU: Mindestens 2 CPU-Cores pro Node
  • Netzwerk: Volle Konnektivität zwischen allen Nodes
  • Swap: Muss deaktiviert sein

Cluster-Aufbau

Für diese Anleitung richten wir ein:

  • 1x Control Plane Node (Master)
  • 2x Worker Nodes (optional, für Produktion empfohlen)

Wichtig: Sie können auch mit einem Single-Node-Cluster starten (Control Plane = Worker).

Container-Runtime

Kubernetes benötigt eine Container-Runtime. Wir verwenden containerd (empfohlen seit K8s 1.24).

Schritt 1: System vorbereiten (auf allen Nodes)

Führen Sie diese Schritte auf allen Nodes (Control Plane + Worker) aus:

1.1 System aktualisieren



1
2
sudo apt update

sudo apt upgrade -y

1.2 Hostname setzen

Geben Sie jedem Node einen eindeutigen Hostname:



1
2
3
4
5
6
7
8
# Control Plane Node

sudo hostnamectl set-hostname k8s-control



# Worker Node 1

sudo hostnamectl set-hostname k8s-worker-1



# Worker Node 2

sudo hostnamectl set-hostname k8s-worker-2

1.3 Hosts-Datei anpassen

Fügen Sie alle Nodes in

1
/etc/hosts

ein:



1
2
3
4
5
6
sudo nano /etc/hosts



# Fügen Sie hinzu:

192.168.1.10  k8s-control

192.168.1.11  k8s-worker-1

192.168.1.12  k8s-worker-2

Hinweis: Ersetzen Sie die IP-Adressen durch Ihre tatsächlichen IPs.

1.4 Swap deaktivieren

Kubernetes benötigt deaktivierten Swap:



1
2
sudo swapoff -a

sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

1.5 Kernel-Module laden



1
2
3
4
5
6
7
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf

overlay

br_netfilter

EOF



sudo modprobe overlay

sudo modprobe br_netfilter

1.6 Netzwerk-Parameter setzen



1
2
3
4
5
6
7
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf

net.bridge.bridge-nf-call-iptables  = 1

net.bridge.bridge-nf-call-ip6tables = 1

net.ipv4.ip_forward                 = 1

EOF



sudo sysctl --system

Schritt 2: containerd installieren (auf allen Nodes)

2.1 Voraussetzungen installieren



1
2
3
4
5
6
sudo apt install -y \

    apt-transport-https \

    ca-certificates \

    curl \

    gnupg \

    lsb-release

2.2 Docker Repository hinzufügen



1
2
3
4
5
6
7
8
9
10
sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \

  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg



echo \

  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \

  https://download.docker.com/linux/ubuntu \

  $(lsb_release -cs) stable" | \

  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Für Debian: Ersetzen Sie

1
/linux/ubuntu

mit

1
/linux/debian

.

2.3 containerd installieren



1
2
sudo apt update

sudo apt install -y containerd.io

2.4 containerd konfigurieren



1
2
3
4
5
6
7
8
sudo mkdir -p /etc/containerd

containerd config default | sudo tee /etc/containerd/config.toml



# SystemdCgroup aktivieren (wichtig für Kubernetes)

sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml



sudo systemctl restart containerd

sudo systemctl enable containerd

2.5 Verifizieren



1
sudo systemctl status containerd

Schritt 3: Kubernetes-Tools installieren (auf allen Nodes)

3.1 Kubernetes Repository hinzufügen



1
2
3
4
5
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key | \

  sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg



echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /' | \

  sudo tee /etc/apt/sources.list.d/kubernetes.list

Hinweis: Wir installieren Kubernetes 1.29 (stabile Version 2026). Für neuere Versionen passen Sie

1
v1.29

an.

3.2 kubeadm, kubelet und kubectl installieren



1
2
3
sudo apt update

sudo apt install -y kubelet kubeadm kubectl

sudo apt-mark hold kubelet kubeadm kubectl

Erklärung:

  • 1
    kubelet

    : Node-Agent, der Container startet

  • 1
    kubeadm

    : Tool für Cluster-Einrichtung

  • 1
    kubectl

    : CLI für Cluster-Verwaltung

  • 1
    apt-mark hold

    : Verhindert automatische Updates (wichtig für Cluster-Stabilität)

3.3 Version prüfen



1
2
kubeadm version

kubectl version --client

Schritt 4: Control Plane initialisieren (nur auf Master-Node)

4.1 Cluster initialisieren

Führen Sie dies nur auf dem Control Plane Node aus:



1
2
3
sudo kubeadm init \

  --pod-network-cidr=10.244.0.0/16 \

  --apiserver-advertise-address=192.168.1.10

Parameter-Erklärung:

  • 1
    --pod-network-cidr

    : Netzwerkbereich für Pods (Flannel verwendet 10.244.0.0/16)

  • 1
    --apiserver-advertise-address

    : IP-Adresse des Control Plane (ersetzen Sie 192.168.1.10 mit Ihrer IP)

Wichtig: Speichern Sie den

1
kubeadm join

-Befehl aus der Ausgabe – Sie brauchen ihn für Worker Nodes!

4.2 kubeconfig für aktuellen Benutzer einrichten



1
2
3
mkdir -p $HOME/.kube

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

sudo chown $(id -u):$(id -g) $HOME/.kube/config

4.3 Cluster-Status prüfen



1
kubectl get nodes

Sie sollten den Control Plane Node sehen, Status:

1
NotReady

(weil das Pod-Netzwerk noch fehlt).

Schritt 5: Pod-Netzwerk installieren (nur auf Master-Node)

Kubernetes benötigt ein CNI-Plugin (Container Network Interface) für Pod-Kommunikation. Wir verwenden Flannel:

5.1 Flannel installieren



1
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

5.2 Warten Sie, bis alle Pods laufen



1
2
kubectl get pods -n kube-flannel

kubectl get pods -n kube-system

Nach 1-2 Minuten sollten alle Pods im Status

1
Running

sein.

5.3 Node-Status erneut prüfen



1
kubectl get nodes

Jetzt sollte der Status

1
Ready

sein! 🎉

Schritt 6: Worker Nodes hinzufügen (optional)

6.1 Join-Token abrufen (auf Control Plane)

Falls Sie den

1
kubeadm join

-Befehl verloren haben:



1
kubeadm token create --print-join-command

6.2 Worker Node joinen (auf jedem Worker)

Führen Sie den Join-Befehl auf Worker Nodes aus:



1
2
3
sudo kubeadm join 192.168.1.10:6443 \

  --token <token> \

  --discovery-token-ca-cert-hash sha256:<hash>

6.3 Worker Nodes verifizieren (auf Control Plane)



1
kubectl get nodes

Alle Nodes sollten nach 1-2 Minuten

1
Ready

sein.

Schritt 7: Erste Anwendung deployen

7.1 NGINX-Deployment erstellen



1
2
kubectl create deployment nginx --image=nginx

kubectl expose deployment nginx --port=80 --type=NodePort

7.2 Deployment prüfen



1
2
3
kubectl get deployments

kubectl get pods

kubectl get services

7.3 NGINX aufrufen



1
2
3
4
5
# NodePort herausfinden

kubectl get svc nginx



# Im Browser aufrufen (Node-IP + NodePort):

# http://192.168.1.10:<NodePort>

Schritt 8: kubectl Autovervollständigung einrichten

Für effizienteres Arbeiten:

Bash



1
2
3
4
echo 'source <(kubectl completion bash)' >>~/.bashrc

echo 'alias k=kubectl' >>~/.bashrc

echo 'complete -F __start_kubectl k' >>~/.bashrc

source ~/.bashrc

Zsh



1
2
3
echo 'source <(kubectl completion zsh)' >>~/.zshrc

echo 'alias k=kubectl' >>~/.zshrc

source ~/.zshrc

Wichtige kubectl-Befehle

Cluster-Informationen



1
2
3
4
5
6
7
8
9
10
11
# Alle Nodes anzeigen

kubectl get nodes



# Cluster-Info

kubectl cluster-info



# Alle Namespaces

kubectl get namespaces



# Alle Pods in allen Namespaces

kubectl get pods -A

Deployments verwalten



1
2
3
4
5
6
7
8
9
10
11
# Deployment erstellen

kubectl create deployment myapp --image=nginx



# Deployment skalieren

kubectl scale deployment myapp --replicas=3



# Deployment aktualisieren

kubectl set image deployment/myapp nginx=nginx:1.25



# Rollout-Status

kubectl rollout status deployment/myapp

Pods verwalten



1
2
3
4
5
6
7
8
9
10
11
# Pods anzeigen

kubectl get pods



# Pod-Details

kubectl describe pod <pod-name>



# Logs anzeigen

kubectl logs <pod-name>



# In Pod ausführen

kubectl exec -it <pod-name> -- /bin/bash

Services



1
2
3
4
5
# Services anzeigen

kubectl get svc



# Service erstellen

kubectl expose deployment myapp --port=80 --type=LoadBalancer

Häufige Probleme und Lösungen

Problem: Node bleibt NotReady

Lösung:



1
2
3
4
5
6
7
# Pod-Netzwerk-Logs prüfen

kubectl logs -n kube-flannel -l app=flannel



# containerd-Status prüfen

sudo systemctl status containerd



# Firewall-Regeln prüfen (Ports 6443, 10250, 10251, 10252 müssen offen sein)

Problem: Pods starten nicht

Lösung:



1
2
3
4
5
6
7
8
9
# Pod-Events prüfen

kubectl describe pod <pod-name>



# Image-Pull-Probleme?

sudo crictl images



# Ressourcen prüfen

kubectl top nodes

kubectl top pods

Problem: Join-Token abgelaufen

Lösung:



1
2
# Neuen Token generieren

kubeadm token create --print-join-command

Problem: DNS funktioniert nicht

Lösung:



1
2
3
4
5
# CoreDNS-Pods prüfen

kubectl get pods -n kube-system -l k8s-app=kube-dns



# CoreDNS-Logs

kubectl logs -n kube-system -l k8s-app=kube-dns

Kubernetes Dashboard installieren (optional)

Dashboard deployen



1
kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml

Admin-User erstellen



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
cat <<EOF | kubectl apply -f -

apiVersion: v1

kind: ServiceAccount

metadata:

  name: admin-user

  namespace: kubernetes-dashboard

---

apiVersion: rbac.authorization.k8s.io/v1

kind: ClusterRoleBinding

metadata:

  name: admin-user

roleRef:

  apiGroup: rbac.authorization.k8s.io

  kind: ClusterRole

  name: cluster-admin

subjects:

- kind: ServiceAccount

  name: admin-user

  namespace: kubernetes-dashboard

EOF

Token abrufen



1
kubectl -n kubernetes-dashboard create token admin-user

Dashboard öffnen



1
kubectl proxy

Dashboard-URL:

1
http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/

Best Practices für Produktion

  • Multi-Master Setup: 3 Control Plane Nodes für High Availability
  • etcd-Backups: Regelmäßige Backups der etcd-Datenbank
  • RBAC: Zugriffskontrollen für Benutzer und Service Accounts
  • Network Policies: Pod-zu-Pod-Kommunikation einschränken
  • Resource Limits: CPU/RAM-Limits für alle Pods setzen
  • Monitoring: Prometheus + Grafana für Cluster-Überwachung
  • Logging: ELK-Stack oder Loki für zentrales Logging
  • Secrets Management: Externe Tools wie Vault für Secrets
  • Updates: Regelmäßige Kubernetes-Updates (alle 3-4 Monate)

Kubernetes Cluster zurücksetzen

Falls Sie neu starten möchten:

Auf Worker Nodes



1
2
3
sudo kubeadm reset

sudo rm -rf /etc/cni/net.d

sudo rm -rf $HOME/.kube/config

Auf Control Plane



1
2
3
4
sudo kubeadm reset

sudo rm -rf /etc/cni/net.d

sudo rm -rf /etc/kubernetes/

sudo rm -rf $HOME/.kube/config

Nächste Schritte

Nach der erfolgreichen Installation können Sie:

  • Helm installieren für Package Management
  • Ingress Controller deployen (NGINX, Traefik)
  • Cert-Manager für automatische SSL-Zertifikate
  • Persistent Storage mit NFS oder Longhorn einrichten
  • GitOps mit ArgoCD/Flux implementieren
  • Service Mesh (Istio/Linkerd) evaluieren

Fazit

Die Kubernetes Installation auf Ubuntu und Debian ist mit kubeadm gut dokumentiert und reproduzierbar. Mit dieser Anleitung haben Sie einen funktionsfähigen Kubernetes Cluster aufgesetzt, der als Basis für Microservices-Architekturen dient. Für Produktionsumgebungen empfehlen wir zusätzlich High Availability, Monitoring und automatisierte Backups.

Kubernetes hat eine steile Lernkurve, aber die Investition lohnt sich: Sie erhalten eine hochmoderne Container-Orchestrierung, die mit Ihrem Unternehmen wachsen kann – von wenigen Containern bis zu Tausenden Services über mehrere Rechenzentren.

Sie benötigen Unterstützung bei der Einführung von Kubernetes in Ihrem Unternehmen?

Als erfahrener IT-Dienstleister für den Mittelstand unterstützt die Biteno GmbH Sie bei allen Fragen rund um Kubernetes – von der Cluster-Planung über die Installation und Konfiguration bis hin zum produktiven Betrieb, Monitoring und automatisierten Deployments. Profitieren Sie von unserer langjährigen Erfahrung im Bereich Container-Orchestrierung und moderner Cloud-Native-Architekturen.

→ Jetzt unverbindlich Kontakt aufnehmen

 

 

/von