49 Cluster Installation using kubeadm

49.1 Einführung

kubeadm ist ein Tool, das die Einrichtung und Konfiguration eines Kubernetes-Clusters erleichtert. Es automatisiert viele der komplexen Prozesse, die für die Installation und Verwaltung eines Clusters erforderlich sind. In diesem Kapitel wird beschrieben, wie man einen Kubernetes-Cluster mit kubeadm installiert und konfiguriert.

49.2 Voraussetzungen

Bevor Sie mit der Installation beginnen, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

Mindestens zwei Maschinen (eine Master-Node und eine oder mehrere Worker-Nodes).
Jede Maschine hat mindestens 2 CPU, 2 GB RAM und 10 GB freier Festplattenspeicher.
Ubuntu 18.04+ oder CentOS 7+ als Betriebssystem.
Root- oder sudo-Zugriff auf alle Maschinen.
Alle Maschinen sind in der Lage, über das Netzwerk miteinander zu kommunizieren.
Swap-Speicher ist deaktiviert.

49.3 Schritte zur Installation

49.3.1 1. Systemvorbereitung

Führen Sie die folgenden Schritte auf allen Maschinen (Master und Worker) aus:

Swap-Speicher deaktivieren:

sudo swapoff -a

Docker installieren:

sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt-get update
sudo apt-get install -y docker-ce
sudo systemctl enable docker
sudo systemctl start docker

kubeadm, kubelet und kubectl installieren:

sudo apt-get update && sudo apt-get install -y apt-transport-https curl
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
deb https://apt.kubernetes.io/ kubernetes-xenial main
EOF
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

Kernel-Module laden:

sudo modprobe overlay
sudo modprobe br_netfilter

cat <<EOF | sudo tee /etc/sysctl.d/kubernetes.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

sudo sysctl --system

49.3.2 2. Master-Node initialisieren

Führen Sie den folgenden Befehl auf der Master-Node aus, um den Cluster zu initialisieren:

sudo kubeadm init --pod-network-cidr=192.168.0.0/16

Nach erfolgreicher Initialisierung:

Kopieren Sie den angezeigten Befehl zur Konfiguration von kubectl.
Fügen Sie die Worker-Nodes mit dem angegebenen kubeadm join-Befehl hinzu.

Konfigurieren Sie kubectl:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

49.3.3 3. Netzwerk-Plugin installieren

Installieren Sie ein Netzwerk-Plugin, z. B. Calico, auf der Master-Node:

kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

49.3.4 4. Worker-Nodes dem Cluster hinzufügen

Führen Sie den folgenden Befehl auf jeder Worker-Node aus (verwenden Sie den kubeadm join-Befehl, der bei der Initialisierung der Master-Node angezeigt wurde):

sudo kubeadm join <master-ip>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>

49.4 Überprüfung der Cluster-Installation

Überprüfen Sie den Status der Nodes:

kubectl get nodes

Die Ausgabe sollte die Master- und Worker-Nodes mit dem Status Ready anzeigen.

Überprüfen Sie die Pods im kube-system Namespace:

kubectl get pods -n kube-system

Alle Pods sollten im Status Running sein.

49.5 Beispiel eines einfachen Deployments

Um sicherzustellen, dass der Cluster ordnungsgemäß funktioniert, erstellen Sie ein einfaches Nginx-Deployment:

Erstellen Sie eine Deployment-Datei nginx-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Wenden Sie die Deployment-Datei an:

kubectl apply -f nginx-deployment.yaml

Überprüfen Sie den Status des Deployments:

kubectl get deployments
kubectl get pods
kubectl get services

Die Installation eines Kubernetes-Clusters mit kubeadm ist eine bewährte Methode, um schnell und effizient einen produktionsreifen Cluster aufzusetzen. kubeadm automatisiert viele komplexe Prozesse und bietet eine solide Grundlage für die weitere Konfiguration und Verwaltung des Clusters. Durch die Befolgung dieser Schritte können Sie sicherstellen, dass Ihr Cluster stabil und betriebsbereit ist.

49.5.1 Schritt 1: Vorbereitung der Umgebung

System aktualisieren und notwendige Pakete installieren

sudo apt update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg

Kubernetes-APT-Repository hinzufügen

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/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.30/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt update

Kubernetes-Komponenten und Containerd installieren

sudo apt-get install -y kubelet kubeadm kubectl containerd
sudo apt-mark hold kubelet kubeadm kubectl containerd

CNI-Plugins installieren

sudo apt-get install -y containernetworking-plugins

Kubelet aktivieren
```
sudo systemctl enable --now kubelet
```

49.5.2 Schritt 2: Netzwerk- und Systemkonfiguration

IP-Weiterleitung aktivieren

sudo sysctl -w net.ipv4.ip_forward=1
sudo sh -c "echo 'net.ipv4.ip_forward=1' >> /etc/sysctl.conf"
sudo sysctl -p

Swap deaktivieren

sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

Containerd konfigurieren

sudo mkdir -p /etc/containerd
sudo containerd config default | sudo tee /etc/containerd/config.toml
sudo systemctl restart containerd

49.5.3 Schritt 3: Kubernetes-Cluster initialisieren

Kubernetes-Cluster initialisieren

sudo kubeadm init --pod-network-cidr=10.244.0.0/16 --cri-socket=unix:///run/containerd/containerd.sock

Kubeconfig-Datei für den Benutzer einrichten

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

kubectl Autovervollständigung laden

echo "source <(kubectl completion bash)" >> ~/.bashrc
source ~/.bashrc

49.5.4 Schritt 4: Netzwerk-Plugin installieren

Flannel-Netzwerk-Plugin installieren

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

49.5.5 Schritt 5: Überprüfen

Knotenstatus überprüfen
```
kubectl get nodes
```
Pod-Status überprüfen
```
kubectl get pods -n kube-system
```

49.6 Cluster Upgrades

49.6.1 Einführung

Das regelmäßige Aktualisieren eines Kubernetes-Clusters ist entscheidend, um von neuen Funktionen, Sicherheitsupdates und Leistungsverbesserungen zu profitieren. Ein Cluster-Upgrade umfasst das Aktualisieren der Control Plane-Komponenten (API-Server, Controller-Manager, Scheduler) sowie der Worker-Nodes. In diesem Kapitel werden die Schritte beschrieben, die erforderlich sind, um einen Kubernetes-Cluster sicher und effektiv zu aktualisieren.

49.6.2 Voraussetzungen

Bevor Sie mit dem Upgrade beginnen, stellen Sie sicher, dass folgende Voraussetzungen erfüllt sind:

Erstellen Sie ein Backup der etcd-Datenbank.
Überprüfen Sie die Kompatibilität der neuen Kubernetes-Version mit Ihren aktuellen Deployments und Plugins.
Stellen Sie sicher, dass alle Nodes im Cluster im Status Ready sind.
Planen Sie ein Wartungsfenster ein, da das Upgrade zu kurzen Ausfallzeiten führen kann.

49.6.3 Schritte zum Upgrade

49.6.3.1 1. Backup der etcd-Datenbank erstellen

Erstellen Sie ein Backup der etcd-Datenbank auf der Master-Node:

ETCDCTL_API=3 etcdctl snapshot save snapshot.db --endpoints=<etcd-endpoint> --cacert=<path-to-cafile> --cert=<path-to-certfile> --key=<path-to-keyfile>

49.6.3.2 2. Master-Node upgraden

a. Aktualisieren der Paketlisten und Installation der neuen Versionen von kubeadm, kubelet und kubectl:

sudo apt-get update
sudo apt-get install -y kubeadm=<version>

b. Upgrade des Control Plane:

sudo kubeadm upgrade plan
sudo kubeadm upgrade apply <version>

c. Aktualisieren von kubelet und kubectl:

sudo apt-get install -y kubelet=<version> kubectl=<version>
sudo systemctl daemon-reload
sudo systemctl restart kubelet

49.6.3.3 3. Worker-Nodes upgraden

a. Aktualisieren von kubeadm auf jedem Worker-Node:

sudo apt-get update
sudo apt-get install -y kubeadm=<version>

b. Upgrade von kubelet und kubectl auf jedem Worker-Node:

sudo kubeadm upgrade node
sudo apt-get install -y kubelet=<version> kubectl=<version>
sudo systemctl daemon-reload
sudo systemctl restart kubelet

49.6.3.4 4. Überprüfung des Cluster-Status

Überprüfen Sie den Status der Nodes:

kubectl get nodes

Alle Nodes sollten im Status Ready und auf der neuen Version sein.

49.6.4 Beispiel eines Upgrade-Prozesses

Hier ist ein Beispiel für das Upgrade eines Clusters von Version 1.20.x auf 1.21.x:

Backup der etcd-Datenbank:

ETCDCTL_API=3 etcdctl snapshot save snapshot.db --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key

Master-Node upgraden:

sudo apt-get update
sudo apt-get install -y kubeadm=1.21.0-00
sudo kubeadm upgrade plan
sudo kubeadm upgrade apply v1.21.0
sudo apt-get install -y kubelet=1.21.0-00 kubectl=1.21.0-00
sudo systemctl daemon-reload
sudo systemctl restart kubelet

Worker-Nodes upgraden:

for node in worker1 worker2 worker3; do
  ssh $node "sudo apt-get update && sudo apt-get install -y kubeadm=1.21.0-00 && sudo kubeadm upgrade node && sudo apt-get install -y kubelet=1.21.0-00 kubectl=1.21.0-00 && sudo systemctl daemon-reload && sudo systemctl restart kubelet"
done

Cluster-Status überprüfen:

kubectl get nodes

Das Upgrade eines Kubernetes-Clusters erfordert sorgfältige Planung und Ausführung, um Ausfallzeiten zu minimieren und die Integrität des Clusters zu gewährleisten. Durch das Befolgen der beschriebenen Schritte und die regelmäßige Überprüfung des Cluster-Status können Administratoren sicherstellen, dass ihre Kubernetes-Umgebung auf dem neuesten Stand bleibt und von den neuesten Verbesserungen und Sicherheitsupdates profitiert.