Control Plane Setup

Ziel

In diesem Projekt setzen Sie die Control Plane eines Kubernetes-Clusters manuell auf. Dabei werden Sie: - containerd, runc und die cni-plugins installieren - Zertifikate und Konfigurationsdateien erstellen - etcd, kube-apiserver, kube-controller-manager und kube-scheduler konfigurieren und starten - die Control Plane testen

Aufgabe 1: Installation von containerd

In dieser Aufgabe installieren Sie containerd und runc auf einem Node.

• Erstellen Sie ein Shell-Skript install-containerd.sh, das die Installation von containerd durchführt:

CONTAINERD_VERSION=2.0.2
RUNC_VERSION=1.2.4

# Install Containerd
wget https://github.com/containerd/containerd/releases/download/v${CONTAINERD_VERSION}/containerd-${CONTAINERD_VERSION}-linux-amd64.tar.gz
tar Cxzvf /usr/local containerd-${CONTAINERD_VERSION}-linux-amd64.tar.gz
rm containerd-${CONTAINERD_VERSION}-linux-amd64.tar.gz
mkdir -p /usr/local/lib/systemd/system/
wget https://raw.githubusercontent.com/containerd/containerd/main/containerd.service -O /usr/local/lib/systemd/system/containerd.service
systemctl daemon-reload
systemctl enable --now containerd

# Install runc
wget https://github.com/opencontainers/runc/releases/download/v${RUNC_VERSION}/runc.amd64
install -m 755 runc.amd64 /usr/local/sbin/runc

• Führen Sie das Skript aus:

bash install-containerd.sh

Aufgabe 2: Zertifikate erstellen

In dieser Aufgabe erstellen Sie die benötigten Zertifikate für die Control Plane.

• Erstellen Sie ein Shell-Skript generate-certificates.sh, das die Zertifikate generiert:

#!/bin/bash

# CA Zertifikat
openssl genrsa -out /etc/kubernetes/pki/ca.key 2048
openssl req -x509 -new -nodes -key /etc/kubernetes/pki/ca.key \
  -subj "/CN=kubernetes-ca" \
  -days 10000 -out /etc/kubernetes/pki/ca.crt

# API Server Zertifikat
openssl genrsa -out /etc/kubernetes/pki/apiserver.key 2048
openssl req -new -key /etc/kubernetes/pki/apiserver.key \
  -subj "/CN=kube-apiserver" \
  -out /etc/kubernetes/pki/apiserver.csr
openssl x509 -req -in /etc/kubernetes/pki/apiserver.csr \
  -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial \
  -days 10000 -out /etc/kubernetes/pki/apiserver.crt

# API Server Kubelet Client Zertifikat
openssl genrsa -out /etc/kubernetes/pki/apiserver-kubelet-client.key 2048
openssl req -new -key /etc/kubernetes/pki/apiserver-kubelet-client.key \
  -subj "/CN=kube-apiserver-kubelet-client" \
  -out /etc/kubernetes/pki/apiserver-kubelet-client.csr
openssl x509 -req -in /etc/kubernetes/pki/apiserver-kubelet-client.csr \
  -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial \
  -days 10000 -out /etc/kubernetes/pki/apiserver-kubelet-client.crt

# Service Account Key
openssl genrsa -out /etc/kubernetes/pki/sa.key 2048
openssl rsa -in /etc/kubernetes/pki/sa.key -pubout -out /etc/kubernetes/pki/sa.pub

# Etcd Zertifikat
openssl genrsa -out /etc/kubernetes/pki/etcd.key 2048
openssl req -new -key /etc/kubernetes/pki/etcd.key \
  -subj "/CN=etcd" \
  -out /etc/kubernetes/pki/etcd.csr
openssl x509 -req -in /etc/kubernetes/pki/etcd.csr \
  -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial \
  -days 10000 -out /etc/kubernetes/pki/etcd.crt

# Etcd Peer Zertifikat
openssl genrsa -out /etc/kubernetes/pki/etcd-peer.key 2048
openssl req -new -key /etc/kubernetes/pki/etcd-peer.key \
  -subj "/CN=etcd-peer" \
  -out /etc/kubernetes/pki/etcd-peer.csr
openssl x509 -req -in /etc/kubernetes/pki/etcd-peer.csr \
  -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial \
  -days 10000 -out /etc/kubernetes/pki/etcd-peer.crt

# Controller Manager Zertifikat
openssl genrsa -out /etc/kubernetes/pki/controller-manager.key 2048
openssl req -new -key /etc/kubernetes/pki/controller-manager.key \
  -subj "/CN=system:kube-controller-manager" \
  -out /etc/kubernetes/pki/controller-manager.csr
openssl x509 -req -in /etc/kubernetes/pki/controller-manager.csr \
  -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial \
  -days 10000 -out /etc/kubernetes/pki/controller-manager.crt

# Scheduler Zertifikat
openssl genrsa -out /etc/kubernetes/pki/scheduler.key 2048
openssl req -new -key /etc/kubernetes/pki/scheduler.key \
  -subj "/CN=system:kube-scheduler" \
  -out /etc/kubernetes/pki/scheduler.csr
openssl x509 -req -in /etc/kubernetes/pki/scheduler.csr \
  -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial \
  -days 10000 -out /etc/kubernetes/pki/scheduler.crt

# Admin Zertifikat
openssl genrsa -out /etc/kubernetes/pki/admin.key 2048
openssl req -new -key /etc/kubernetes/pki/admin.key \
  -subj "/CN=kubernetes-admin/O=system:masters" \
  -out /etc/kubernetes/pki/admin.csr
openssl x509 -req -in /etc/kubernetes/pki/admin.csr \
  -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial \
  -days 10000 -out /etc/kubernetes/pki/admin.crt

• Führen Sie das Skript aus:

bash generate-certificates.sh

• Überprüfen Sie die generierten Zertifikate:

ls -l /etc/kubernetes/pki/

Die folgenden Zertifikate sollten vorhanden sein: - ca.crt, ca.key - apiserver.crt, apiserver.key - apiserver-kubelet-client.crt, apiserver-kubelet-client.key - sa.key, sa.pub - etcd.crt, etcd.key, etcd-peer.crt, etcd-peer.key - controller-manager.crt, controller-manager.key - scheduler.crt, scheduler.key - admin.crt, admin.key

---

Aufgabe 3: etcd konfigurieren und starten

In dieser Aufgabe konfigurieren und starten Sie etcd.

• Erstellen Sie eine Datei etcd.yaml mit folgendem Inhalt:

apiVersion: v1
kind: Pod
metadata:
  name: etcd
  namespace: kube-system
spec:
  containers:
    - name: etcd
      image: quay.io/coreos/etcd:v3.4.13
      command:
        - "/usr/local/bin/etcd"
        - "--name=etcd-0"
        - "--data-dir=/var/lib/etcd"
        - "--listen-peer-urls=http://0.0.0.0:2380"
        - "--listen-client-urls=http://0.0.0.0:2379"
        - "--advertise-client-urls=http://<CONTROL_PLANE_IP>:2379"
        - "--initial-cluster=etcd-0=http://<CONTROL_PLANE_IP>:2380"
        - "--initial-cluster-token=etcd-cluster"
        - "--initial-cluster-state=new"
        - "--cert-file=/etc/kubernetes/pki/etcd.crt"
        - "--key-file=/etc/kubernetes/pki/etcd.key"
        - "--trusted-ca-file=/etc/kubernetes/pki/ca.crt"
      volumeMounts:
        - name: etcd-data
          mountPath: /var/lib/etcd
        - name: etcd-certs
          mountPath: /etc/kubernetes/pki
  volumes:
    - name: etcd-data
      emptyDir: {}
    - name: etcd-certs
      hostPath:
        path: /etc/kubernetes/pki

• Wenden Sie die Konfiguration an:

kubectl apply -f etcd.yaml

---

Aufgabe 4: API Server konfigurieren und starten

In dieser Aufgabe konfigurieren und starten Sie den API Server.

• Erstellen Sie eine Datei kube-apiserver.yaml mit folgendem Inhalt:

apiVersion: v1
kind: Pod
metadata:
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
    - name: kube-apiserver
      image: k8s.gcr.io/kube-apiserver:v1.24.0
      command:
        - "/kube-apiserver"
        - "--advertise-address=<CONTROL_PLANE_IP>"
        - "--allow-privileged=true"
        - "--etcd-servers=http://<CONTROL_PLANE_IP>:2379"
        - "--service-cluster-ip-range=10.96.0.0/12"
        - "--tls-cert-file=/etc/kubernetes/pki/apiserver.crt"
        - "--tls-private-key-file=/etc/kubernetes/pki/apiserver.key"
        - "--client-ca-file=/etc/kubernetes/pki/ca.crt"
      volumeMounts:
        - name: apiserver-certs
          mountPath: /etc/kubernetes/pki
  volumes:
    - name: apiserver-certs
      hostPath:
        path: /etc/kubernetes/pki

• Wenden Sie die Konfiguration an:

kubectl apply -f kube-apiserver.yaml

---

Aufgabe 5: Controller Manager und Scheduler konfigurieren

In dieser Aufgabe konfigurieren und starten Sie den Controller Manager und den Scheduler.

• Erstellen Sie eine Datei kube-controller-manager.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: kube-controller-manager
  namespace: kube-system
spec:
  containers:
    - name: kube-controller-manager
      image: k8s.gcr.io/kube-controller-manager:v1.24.0
      command:
        - "/kube-controller-manager"
        - "--leader-elect=true"
        - "--kubeconfig=/etc/kubernetes/controller-manager.conf"
      volumeMounts:
        - name: controller-manager-config
          mountPath: /etc/kubernetes
  volumes:
    - name: controller-manager-config
      hostPath:
        path: /etc/kubernetes

• Erstellen Sie eine Datei kube-scheduler.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: kube-scheduler
  namespace: kube-system
spec:
  containers:
    - name: kube-scheduler
      image: k8s.gcr.io/kube-scheduler:v1.24.0
      command:
        - "/kube-scheduler"
        - "--leader-elect=true"
        - "--kubeconfig=/etc/kubernetes/scheduler.conf"
      volumeMounts:
        - name: scheduler-config
          mountPath: /etc/kubernetes
  volumes:
    - name: scheduler-config
      hostPath:
        path: /etc/kubernetes

• Wenden Sie beide Konfigurationen an:

kubectl apply -f kube-controller-manager.yaml
kubectl apply -f kube-scheduler.yaml

---

Aufgabe 6: Überprüfung

• Überprüfen Sie, ob alle Pods in der Control Plane laufen:

kubectl get pods -n kube-system

• Überprüfen Sie, ob der API Server erreichbar ist:

kubectl cluster-info

---

Aufgabe 7: Weitere Control Plane Nodes hinzufügen

In dieser Aufgabe verteilen Sie die Control Plane auf zwei weitere Nodes, um Hochverfügbarkeit zu gewährleisten.

Schritt 1: Zertifikate und Konfigurationsdateien kopieren

• Kopieren Sie die Zertifikate und Konfigurationsdateien von der ersten Control Plane Node auf die anderen beiden Nodes:

scp -r /etc/kubernetes/pki <control-plane-node-2>:/etc/kubernetes/
scp -r /etc/kubernetes/pki <control-plane-node-3>:/etc/kubernetes/
scp /etc/kubernetes/admin.conf <control-plane-node-2>:/etc/kubernetes/admin.conf
scp /etc/kubernetes/admin.conf <control-plane-node-3>:/etc/kubernetes/admin.conf

Schritt 2: etcd, kubeapiserver, controller manager und scheduler kopieren und anpassen

scp /etc/kubernetes/manifests/etcd.yaml <control-plane-node-2>:/etc/kubernetes/manifests/
scp /etc/kubernetes/manifests/etcd.yaml <control-plane-node-3>:/etc/kubernetes/manifests/
scp /etc/kubernetes/manifests/kube-apiserver.yaml <control-plane-node-2>:/etc/kubernetes/manifests/
scp /etc/kubernetes/manifests/kube-apiserver.yaml <control-plane-node-3>:/etc/kubernetes/manifests/
scp /etc/kubernetes/manifests/kube-controller-manager.yaml <control-plane-node-2>:/etc/kubernetes/manifests/
scp /etc/kubernetes/manifests/kube-controller-manager.yaml <control-plane-node-3>:/etc/kubernetes/manifests/
scp /etc/kubernetes/manifests/kube-scheduler.yaml <control-plane-node-2>:/etc/kubernetes/manifests/
scp /etc/kubernetes/manifests/kube-scheduler.yaml <control-plane-node-3>:/etc/kubernetes/manifests/

• Ändern Sie in den etcd.yaml-Dateien die spezifischen Werte wie --advertise-address und --name um die jeweilige Node zu identifizieren.

Aufgabe 8: HAProxy konfigurieren

In dieser Aufgabe konfigurieren Sie HAProxy, um den Traffic auf die Control Plane Nodes zu verteilen.

Schritt 1: HAProxy installieren

• Installieren Sie HAProxy auf einer oder mehreren Control Plane Nodes oder auf einer separaten Load Balancer Node:

sudo apt update
sudo apt install -y haproxy

Schritt 2: HAProxy konfigurieren

• Bearbeiten Sie die Datei /etc/haproxy/haproxy.cfg und fügen Sie die folgende Konfiguration hinzu:

frontend kubernetes
    bind *:6443
    mode tcp
    option tcplog
    default_backend kubernetes-backend

backend kubernetes-backend
    mode tcp
    balance roundrobin
    server control-plane-1 <IP1>:6443 check
    server control-plane-2 <IP2>:6443 check
    server control-plane-3 <IP3>:6443 check

• Ersetzen Sie <IP1>, <IP2> und <IP3> durch die IP-Adressen Ihrer Control Plane Nodes.

Schritt 3: HAProxy starten

• Starten und aktivieren Sie den HAProxy-Dienst:

sudo systemctl restart haproxy
sudo systemctl enable haproxy

Schritt 4: HAProxy-Konfiguration überprüfen

• Überprüfen Sie die HAProxy-Konfiguration:

haproxy -c -f /etc/haproxy/haproxy.cfg

• Stellen Sie sicher, dass keine Fehler angezeigt werden.

Schritt 5: HAProxy testen

• Testen Sie, ob der HAProxy den Traffic korrekt auf die Control Plane Nodes verteilt:

curl -k https://<HAPROXY_IP>:6443/version

• Ersetzen Sie <HAPROXY_IP> durch die IP-Adresse der Node, auf der HAProxy läuft. Der Befehl sollte die Kubernetes-Version zurückgeben.

---

Überprüfung

• Stellen Sie sicher, dass der HAProxy den Traffic korrekt verteilt und alle Control Plane Nodes erreichbar sind:

kubectl get nodes

• Überprüfen Sie, ob alle Control Plane Nodes im Cluster als Ready angezeigt werden.