Lab 01: Übung: Klassischen AKS Cluster mit Nodepools erstellen¶

In dieser Übung erstellst du einen AKS-Cluster im Standard-Modus und lernst, wie du Nodepools manuell verwalten kannst.

Teil 1: Resource Group erstellen¶

Aufgabe: Erstelle eine neue Resource Group für diese Übung.

# Variablen setzen (passe INITIALEN an)
export INITIALEN="abc"
export RESOURCE_GROUP="rg-aks-classic-${INITIALEN}"
export LOCATION="germanywestcentral"
export CLUSTER_NAME="aks-classic-${INITIALEN}"

# Resource Group erstellen
az group create \
  --name $RESOURCE_GROUP \
  --location $LOCATION

Teil 2: AKS Standard Cluster erstellen¶

Aufgabe: Erstelle einen AKS-Cluster im Standard-Modus mit einem System-Nodepool.

az aks create \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --location $LOCATION \
  --sku Base \
  --tier Free \
  --node-count 1 \
  --node-vm-size Standard_D2s_v3 \
  --enable-aad \
  --network-plugin azure \
  --network-plugin-mode overlay \
  --network-dataplane cilium \
  --enable-azure-rbac \
  --enable-keda \
  --generate-ssh-keys

Die Erstellung dauert ca. 5-10 Minuten.

Teil 3: kubectl konfigurieren¶

Aufgabe: Verbinde dein lokales kubectl mit dem Cluster.

# Credentials holen
az aks get-credentials \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME

# Verbindung testen
kubectl get nodes

Du solltest nun einen Node mit Status Ready sehen.

Teil 4: Den Cluster verstehen¶

Cluster-Informationen abrufen¶

Bevor wir mit dem Cluster arbeiten, verschaffen wir uns einen Überblick:

# Zeigt die kubectl- und Kubernetes-Versionen
kubectl version

# Gibt grundlegende Cluster-Informationen aus
kubectl cluster-info

# Listet alle Nodes (Rechenknoten) im Cluster
kubectl get nodes

Aufgabe: Führt diese Befehle aus und beantwortet:

Welche Kubernetes-Version läuft auf eurem Cluster?
Wie viele Nodes hat euer Cluster?
Ist der Node im Status Ready?

Node-Details untersuchen¶

Mit describe erhalten wir detaillierte Informationen zu einer Ressource. Ersetze <NODENAME> durch einen echten Node-Namen:

kubectl describe node <NODENAME>

Aufgaben:

Findet heraus:
- Wie viele CPUs stehen auf dem Node zur Verfügung?
- Welches Betriebssystem in welcher Version ist installiert? (Stichwort: "OS Image")
- Wie viel RAM ist insgesamt verfügbar? (Stichwort: "Capacity")
- Wie viel Prozent des RAMs ist bereits allokiert? (Stichwort: "Allocated resources")
Scrollt zu "Non-terminated Pods" – welche System-Pods laufen bereits auf dem Node?

Ressourcen im Cluster erkunden¶

Pods sind die kleinste deploybare Einheit in Kubernetes. Schauen wir uns an, was bereits läuft:

# Alle Pods im aktuellen Namespace (default)
kubectl get pods

# Alle Pods über alle Namespaces hinweg
kubectl get pods --all-namespaces

# Kurzform mit -A statt --all-namespaces
kubectl get pods -A

Was fällt auf?

Im default-Namespace läuft vermutlich noch nichts
In kube-system laufen System-Komponenten (CoreDNS, kube-proxy, etc.)
Jeder Pod hat einen Status (Running, Pending, etc.)

Welche Ressourcen gibt es überhaupt?¶

Kubernetes kennt viele verschiedene Ressourcentypen. Lasst euch alle anzeigen:

kubectl api-resources

Aufgaben:

Findet in der Liste den Eintrag für pods – wie lautet die Kurzform (SHORTNAMES)?
Welche Kurzformen haben services, deployments und namespaces?
Probiert aus:

kubectl get po -A        # statt pods
kubectl get svc -A       # statt services
kubectl get deploy -A    # statt deployments
kubectl get ns           # statt namespaces

Tipp: Die Kurzformen sparen Tipparbeit. Es lohnt sich, sie sich einzuprägen.

Namespace-System verstehen¶

Namespaces sind wie Ordner – sie gruppieren Ressourcen logisch:

# Alle Namespaces anzeigen
kubectl get namespaces

# Pods in einem bestimmten Namespace
kubectl get pods -n kube-system
kubectl get pods --namespace kube-system  # Langform

# Pods im default-Namespace (wenn nichts angegeben wird)
kubectl get pods

Aufgabe: Wie viele Pods laufen im Namespace kube-system?

Ausgabeformat wide¶

Standardmäßig zeigt kubectl get nur die wichtigsten Spalten. Mit -o wide bekommt ihr mehr Details:

kubectl get pods -A -o wide

Was seht ihr jetzt zusätzlich?

IP-Adressen der Pods
Auf welchem Node der Pod läuft
Nominated Node, Readiness Gates (falls vorhanden)

Aufgabe: Notiert euch die IP-Adresse eines Pods aus dem kube-system Namespace.

YAML und JSON ausgeben¶

Jede Ressource in Kubernetes wird intern als JSON/YAML gespeichert. Ihr könnt euch die vollständige Definition anschauen:

# YAML-Format (lesbar)
kubectl get pod <POD-NAME> -n kube-system -o yaml

# JSON-Format (maschinenlesbar)
kubectl get pod <POD-NAME> -n kube-system -o json

Ersetzt <POD-NAME> durch einen echten Pod-Namen

Aufgaben:

Schaut euch die YAML-Ausgabe an – findet ihr Abschnitte wie metadata, spec und status?
Mit jsonpath könnt ihr gezielt Felder extrahieren:

# Nur die IP des Pods ausgeben
kubectl get pod <POD-NAME> -n kube-system -o jsonpath='{.status.podIP}'

Custom Columns¶

Ihr könnt euch auch eigene Tabellen zusammenstellen:

kubectl get pods -A -o custom-columns=NAME:.metadata.name,STATUS:.status.phase,IP:.status.podIP

Erklärt in Worten: Was zeigt dieser Befehl an?

Kubectl-Hilfe¶

kubectl explain ist eure eingebaute API-Dokumentation:

# Was ist ein Pod?
kubectl explain pod

# Was gehört in pod.spec?
kubectl explain pod.spec

# Welche Container-Felder gibt es?
kubectl explain pod.spec.containers

Aufgabe: Findet mit explain heraus, welche Felder pod.spec.containers.resources hat.

Teil 5: User Nodepool hinzufügen¶

Aufgabe: Erstelle einen separaten User-Nodepool für Workloads.

Hintergrund: Best Practice ist es, System-Workloads (CoreDNS, etc.) von Anwendungs-Workloads zu trennen. Dafür nutzt man separate Nodepools mit unterschiedlichen mode-Einstellungen.

az aks nodepool add \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name workloads \
  --mode User \
  --node-count 2 \
  --node-vm-size Standard_D2s_v3 \
  --labels workload-type=applications

Erklärung:

--mode User: Dieser Pool ist für Anwendungs-Workloads gedacht
--labels: Fügt Labels hinzu, die für Node-Selektoren genutzt werden können

Prüfe die Nodepools:

az aks nodepool list \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --output table

Teil 6: Nodepool skalieren¶

Aufgabe: Skaliere den User-Nodepool auf 3 Nodes.

az aks nodepool scale \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name workloads \
  --node-count 3

Verifiziere die Änderung:

kubectl get nodes -l workload-type=applications

Teil 7: Autoscaling aktivieren¶

Aufgabe: Aktiviere Cluster Autoscaler für den User-Nodepool.

az aks nodepool update \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name workloads \
  --enable-cluster-autoscaler \
  --min-count 1 \
  --max-count 5

Der Cluster Autoscaler skaliert automatisch basierend auf Pod-Ressourcenanfragen.

Teil 8: Testanwendung deployen¶

Aufgabe: Deploye eine Anwendung, die auf dem User-Nodepool läuft.

Erstelle eine Datei test-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-kubernetes
  template:
    metadata:
      labels:
        app: hello-kubernetes
    spec:
      nodeSelector:
        workload-type: applications
      containers:
      - name: hello-kubernetes
        image: paulbouwer/hello-kubernetes:1.10
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 200m
            memory: 256Mi

Deploye die Anwendung:

kubectl apply -f test-deployment.yaml

# Prüfe, auf welchen Nodes die Pods laufen
kubectl get pods -o wide

Die Pods sollten nur auf Nodes mit dem Label workload-type=applications laufen.

Teil 9: Nodepool-Informationen anzeigen¶

Aufgabe: Untersuche die Konfiguration deiner Nodepools.

# Detaillierte Nodepool-Infos
az aks nodepool show \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name workloads \
  --output yaml

# Node-Labels und Taints in Kubernetes anzeigen
kubectl describe nodes | grep -A5 "Labels:"

# Ressourcenverbrauch der Nodes
kubectl top nodes