Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 1: k0s mit k0sctl aufbauen

Ziel: Ein k0s-Cluster v1.36.6 mit einem Controller und drei Workern läuft, die Worker tragen ihre Zone als Label, und kubectl auf k0s-ctrl spricht mit ihm. · Dauer: ca. 45 min · Voraussetzung: Tag 0

Briefing

  • k0s ist ein einziges Binary mit API-Server, Scheduler, etcd, containerd, kubelet und CNI. Vom Betriebssystem braucht es nur den Kernel.
  • k0sctl verteilt k0s per SSH: Download, Konfiguration, Join-Tokens, später Updates. Es läuft auf dem Arbeitsplatz und braucht dort Zugang zu allen Hosts.
  • Ein reiner Controller ist kein Node: kein kubelet, keine Pods, nicht in kubectl get nodes.
  • Die Cluster-Beschreibung k0sctl.yaml ist die einzige Quelle der Wahrheit. k0sctl apply gleicht den Cluster mit ihr ab, beliebig oft.
  • Du baust bewusst v1.36.6 auf. Das Update auf 1.37 übst du an Tag 15.
 k0s-ctrl: k0sctl ──SSH──> k0s-ctrl  k0scontroller (etcd, API, Scheduler)
                  ──SSH──> k0s-w1/2/3 k0sworker (containerd, kubelet)
           kubectl ──6443──> API      konnectivity: Worker ──8132──> Controller

Drill 1: k0sctl laden

Binaries lädst du in diesem Buch immer passend zur Architektur. dpkg --print-architecture liefert amd64 oder arm64 – genau so heißen die Release-Dateien.

# auf k0s-ctrl
mkdir -p ~/k0s-lab/tag01 && cd ~/k0s-lab/tag01
ARCH=$(dpkg --print-architecture); echo $ARCH
V=v0.33.1
curl -sSfLO https://github.com/k0sproject/k0sctl/releases/download/$V/k0sctl-linux-$ARCH
curl -sSfLO https://github.com/k0sproject/k0sctl/releases/download/$V/checksums.txt
grep "k0sctl-linux-$ARCH\$" checksums.txt | sha256sum -c
sudo install -m 755 k0sctl-linux-$ARCH /usr/local/bin/k0sctl
k0sctl version

Erwartet:

amd64
k0sctl-linux-amd64: OK
version: v0.33.1
commit: c4bfa95

Das \$ im grep verankert den Namen am Zeilenende: sha256sum -c bekommt genau die eine Zeile für deine Datei.

Fortschritt speichern? Kostenlos registrieren

Drill 2: kubectl passend zum Cluster

kubectl darf höchstens eine Minor-Version vom API-Server abweichen. Du nimmst genau die Version des Clusters.

# auf k0s-ctrl
K=v1.36.6
curl -sSfLO https://dl.k8s.io/release/$K/bin/linux/$ARCH/kubectl
curl -sSfLO https://dl.k8s.io/release/$K/bin/linux/$ARCH/kubectl.sha256
echo "$(cat kubectl.sha256)  kubectl" | sha256sum -c
sudo install -m 755 kubectl /usr/local/bin/kubectl
kubectl version --client

Erwartet:

kubectl: OK
Client Version: v1.36.6
Kustomize Version: v5.8.1

Auf dem Controller gäbe es auch sudo k0s kubectl. Das läuft aber als root mit Admin-Rechten und nur dort. Für den Alltag ist ein normales kubectl mit kubeconfig sauberer.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Das Gerüst von k0sctl init

# auf k0s-ctrl
k0sctl init --k0s -C 1 -i ~/.ssh/id_ed25519 [email protected] \
  [email protected] [email protected] [email protected] > init.yaml
wc -l init.yaml
grep role: init.yaml
grep -A1 telemetry init.yaml
grep -c version: init.yaml

Erwartet:

88 init.yaml
    role: controller
    role: worker
    role: worker
    role: worker
        telemetry:
          enabled: true
0

-C 1 macht die erste Adresse zum Controller, alle weiteren zu Workern. Das Gerüst schreibt jeden Standardwert aus – 88 Zeilen, die du nicht pflegen willst. Telemetrie ist an, und zwei Dinge fehlen ganz: eine feste Version (0 Treffer) und die Zonen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Die eigene k0sctl.yaml

# auf k0s-ctrl
cat > k0sctl.yaml <<'EOF'
apiVersion: k0sctl.k0sproject.io/v1beta1
kind: Cluster
metadata:
  name: k0s-lab
spec:
  hosts:
  - role: controller
    ssh: {address: 172.16.0.176, user: ubuntu, keyPath: ~/.ssh/id_ed25519}
  - role: worker
    ssh: {address: 172.16.0.186, user: ubuntu, keyPath: ~/.ssh/id_ed25519}
    installFlags: [--labels=topology.kubernetes.io/zone=a]
  - role: worker
    ssh: {address: 172.16.0.36, user: ubuntu, keyPath: ~/.ssh/id_ed25519}
    installFlags: [--labels=topology.kubernetes.io/zone=b]
  - role: worker
    ssh: {address: 172.16.0.72, user: ubuntu, keyPath: ~/.ssh/id_ed25519}
    installFlags: [--labels=topology.kubernetes.io/zone=a]
  k0s:
    version: v1.36.6+k0s.0
    config:
      apiVersion: k0s.k0sproject.io/v1beta1
      kind: ClusterConfig
      metadata:
        name: k0s-lab
      spec:
        api:
          address: 172.16.0.176
          sans: [172.16.0.176]
        network:
          provider: kuberouter
          podCIDR: 10.244.0.0/16
          serviceCIDR: 10.96.0.0/12
        telemetry:
          enabled: false
EOF
  • role: controller heißt Control Plane ohne Workloads. controller+worker lässt den Controller zusätzlich Pods tragen – für kleine Cluster gedacht, hier nicht gewollt.
  • version pinnt k0s. Ohne die Zeile nimmt k0sctl die neueste, und ein späteres apply aktualisiert den Cluster ungefragt. Das Suffix +k0s.0 gehört dazu.
  • installFlags landen in der systemd-Unit des Workers. Das Zonen-Label steht so nach jedem Start und jeder Neuregistrierung wieder am Node. Ein kubectl label hält das nicht (Tag 2).
  • topology.kubernetes.io/zone ist das Standard-Label, das Scheduler und CSI-Treiber kennen. In LINSTOR setzt du die Zone an Tag 4 zusätzlich als Aux/zone.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Der Cluster entsteht

# auf k0s-ctrl
k0sctl apply --config k0sctl.yaml

Erwartet (gekürzt):

level=info msg="==> Running phase: Gather host facts"
level=info msg="172.16.0.72:22: detected amd64 architecture"
...
level=info msg="==> Running phase: Validate hosts"
level=info msg="validating clock skew"
...
level=info msg="172.16.0.72:22: downloading k0s v1.36.6+k0s.0"
...
level=info msg="==> Running phase: Initialize the k0s cluster"
level=info msg="172.16.0.176:22: installing k0s controller"
level=info msg="172.16.0.176:22: wait for kubernetes to reach ready state"
level=info msg="==> Running phase: Install workers"
level=info msg="172.16.0.176:22: generating a join token for worker 1"
...
level=info msg="172.16.0.186:22: waiting for node to become ready"
level=info msg="==> Finished in 2m38s"
level=info msg="k0s cluster version v1.36.6+k0s.0 is now installed"

k0sctl erkennt die Architektur jedes Hosts und lädt das passende k0s-Binary direkt dort herunter. Vorher prüft es die Uhrzeit aller Hosts – deshalb war NTP an Tag 0 wichtig.

Fortschritt speichern? Kostenlos registrieren

Drill 6: kubectl verbinden

# auf k0s-ctrl
mkdir -p ~/.kube
k0sctl kubeconfig --config k0sctl.yaml > ~/.kube/config
chmod 600 ~/.kube/config
grep server ~/.kube/config
kubectl get nodes -o wide

Erwartet (gekürzt):

    server: https://172.16.0.176:6443
NAME     STATUS   ROLES    AGE   VERSION       INTERNAL-IP    ... CONTAINER-RUNTIME
k0s-w1   Ready    <none>   50s   v1.36.6+k0s   172.16.0.186   ... containerd://2.3.6
k0s-w2   Ready    <none>   50s   v1.36.6+k0s   172.16.0.36    ... containerd://2.3.6
k0s-w3   Ready    <none>   50s   v1.36.6+k0s   172.16.0.72    ... containerd://2.3.6

Drei Nodes, nicht vier: k0s-ctrl fehlt, und das ist richtig so. Warte eine Minute, dann sind die Systempods bereit:

# auf k0s-ctrl
kubectl get pods -A

Erwartet:

NAMESPACE     NAME                              READY   STATUS    RESTARTS   AGE
kube-system   coredns-7c5b856895-4dxld          1/1     Running   0          3m51s
kube-system   coredns-7c5b856895-l4zk8          1/1     Running   0          3m51s
kube-system   konnectivity-agent-4249z          1/1     Running   0          3m57s
kube-system   konnectivity-agent-9rhdh          1/1     Running   0          3m57s
kube-system   konnectivity-agent-hnlbn          1/1     Running   0          3m56s
kube-system   kube-proxy-5brnr                  1/1     Running   0          3m57s
kube-system   kube-proxy-kl9cr                  1/1     Running   0          3m57s
kube-system   kube-proxy-vz59j                  1/1     Running   0          3m57s
kube-system   kube-router-b9zjl                 1/1     Running   0          3m57s
kube-system   kube-router-t9dhd                 1/1     Running   0          3m57s
kube-system   kube-router-zh4sq                 1/1     Running   0          3m57s
kube-system   metrics-server-5749cd655b-dpx5r   1/1     Running   0          4m1s

API-Server, Scheduler und etcd fehlen in der Liste. Sie laufen auf k0s-ctrl als normale Prozesse unter systemd, nicht als Pods. Direkt nach dem Aufbau siehst du kurz drei coredns-Pods: k0s skaliert coredns um, sobald mehr als ein Node da ist.

Tipp: kubectl -n kube-system wait --for=condition=Ready pod --all hängt hier bis zum Timeout, weil es auch auf den gerade gelöschten coredns-Pod wartet. Nimm kubectl get pods -A oder rollout status für einzelne Deployments.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Auf den Hosts nachsehen

# auf k0s-ctrl
kubectl get nodes -L topology.kubernetes.io/zone
sudo k0s status
sudo k0s etcd member-list
ssh k0s-w1 sudo k0s status

Erwartet (gekürzt):

NAME     STATUS   ROLES    AGE     VERSION       ZONE
k0s-w1   Ready    <none>   4m46s   v1.36.6+k0s   a
k0s-w2   Ready    <none>   4m46s   v1.36.6+k0s   b
k0s-w3   Ready    <none>   4m46s   v1.36.6+k0s   a
Version: v1.36.6+k0s.0
Process ID: 2604
Role: controller
Workloads: false
SingleNode: false
{"members":{"k0s-ctrl":"https://172.16.0.176:2380"}}
Version: v1.36.6+k0s.0
Process ID: 2551
Role: worker
Workloads: true
SingleNode: false
Kube-api probing successful: true

Workloads: false bestätigt: Auf dem Controller laufen nie Pods. Ein einziges etcd-Mitglied heißt aber auch: Fällt k0s-ctrl aus, laufen die Pods weiter, nur ändern kann niemand mehr etwas. Wie drei Controller das lösen, steht an Tag 19.

Und noch einmal apply, ohne etwas zu ändern:

# auf k0s-ctrl
k0sctl apply --config k0sctl.yaml 2>&1 | grep -E 'phase|running k0s|Finished'

Erwartet (gekürzt):

level=info msg="==> Running phase: Gather k0s facts"
level=info msg="172.16.0.176:22: is running k0s controller version v1.36.6+k0s.0"
level=info msg="172.16.0.186:22: is running k0s worker version v1.36.6+k0s.0"
...
level=info msg="==> Running phase: Run After Apply Hooks"
level=info msg="==> Running phase: Disconnect from hosts"
level=info msg="==> Finished in 9s"

Keine Install-Phase, nach neun Sekunden fertig. apply ist idempotent: Du kannst es jederzeit gefahrlos laufen lassen.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig die Nodes mit ihrer Zone als eigene Spalte. Zeitziel: 15 s
  2. Zeig die k0s-Version auf k0s-w2. Zeitziel: 15 s
  3. Zeig alle Pods, die auf k0s-w2 laufen. Zeitziel: 30 s
  4. Zeig, mit welcher API-Adresse kubectl spricht. Zeitziel: 20 s

Lösung

# auf k0s-ctrl
kubectl get nodes -L topology.kubernetes.io/zone
ssh k0s-w2 sudo k0s version
kubectl get pods -A -o wide --field-selector spec.nodeName=k0s-w2
kubectl config view -o jsonpath='{.clusters[0].cluster.server}{"\n"}'

Erwartet (gekürzt):

...
v1.36.6+k0s.0
NAMESPACE     NAME                              READY   STATUS    RESTARTS   AGE ...
kube-system   konnectivity-agent-9rhdh          1/1     Running   0          4m49s
kube-system   kube-proxy-vz59j                  1/1     Running   0          4m49s
kube-system   kube-router-zh4sq                 1/1     Running   0          4m49s
kube-system   metrics-server-5749cd655b-dpx5r   1/1     Running   0          4m53s
https://172.16.0.176:6443

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf k0s-ctrl
kubectl get nodes -L topology.kubernetes.io/zone

Erwartet: drei Nodes Ready, v1.36.6+k0s, Zonen a, b, a.

# auf k0s-ctrl
kubectl get pods -A --no-headers | grep -vc Running

Erwartet: 0

# auf k0s-ctrl
sudo k0s status | grep -E 'Version|Workloads'

Erwartet:

Version: v1.36.6+k0s.0
Workloads: false

Challenge

Starte ein Deployment spread mit vier Pause-Pods, die sich gleichmäßig auf die beiden Zonen verteilen, und lösche es danach wieder.

Hinweis: topologySpreadConstraints mit dem Zonen-Label als topologyKey.

Lösung

# auf k0s-ctrl
cat > spread.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: spread, namespace: default}
spec:
  replicas: 4
  selector: {matchLabels: {app: spread}}
  template:
    metadata: {labels: {app: spread}}
    spec:
      topologySpreadConstraints:
      - maxSkew: 1
        topologyKey: topology.kubernetes.io/zone
        whenUnsatisfiable: DoNotSchedule
        labelSelector: {matchLabels: {app: spread}}
      containers:
      - name: pause
        image: registry.k8s.io/pause:3.10
EOF
kubectl apply -f spread.yaml
kubectl rollout status deploy/spread --timeout=120s
kubectl get pods -l app=spread -o custom-columns=NODE:.spec.nodeName --no-headers \
  | sort | uniq -c

Erwartet:

deployment.apps/spread created
...
deployment "spread" successfully rolled out
      1 k0s-w1
      2 k0s-w2
      1 k0s-w3

Zwei Pods in Zone a (verteilt auf k0s-w1 und k0s-w3), zwei in Zone b – dort gibt es nur k0s-w2. Dieselbe Schieflage begegnet dir an Tag 12 wieder: Zone b muss von jedem Volume eine Kopie tragen.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf k0s-ctrl
kubectl delete deploy spread

Interview-Notiz

  • Was unterscheidet k0s von kubeadm? Ein Binary ohne Abhängigkeiten, Control Plane als Prozesse unter systemd statt Static Pods, Controller standardmäßig ohne kubelet.
  • Wie verteilst du k0s auf mehrere Hosts? Mit k0sctl und einer deklarativen k0sctl.yaml. apply ist idempotent und dient auch für Erweiterung und Update.
  • Warum die Version pinnen? Ohne Pin zieht jedes apply die neueste Version – ein ungeplantes Update mitten im Betrieb.

Enterprise-Notiz

  • Drei Controller (etcd-Quorum) hinter einem Load Balancer oder mit k0s Node-local Load Balancing. Mit externem Load Balancer zeigt api.externalAddress auf dessen Adresse.
  • k0sctl.yaml gehört ins Git, Änderungen per Review. Der SSH-Schlüssel des Automationshosts ist ein kritisches Geheimnis.
  • Air-Gap: k0sctl kann Binaries und Images vom Arbeitsplatz hochladen (uploadBinary, Airgap-Bundle) statt sie auf jedem Host herunterzuladen.
  • kubeconfig des Admins nicht verteilen. Für Menschen OIDC, für Automation eigene ServiceAccounts mit RBAC.