Etcd im Cluster

Ziel

In diesem Projekt geht es um die Einrichtung von etcd als Static Pod im Kubernetes-Cluster. Sie werden:

• Etcd-Zertifikate aus dem vorherigen Lab wiederverwenden und korrekt platzieren
• Ein Static Pod-Manifest für etcd erstellen
• Etcd als Cluster mit drei Instanzen auf den Control Plane-Nodes starten
• Die Funktionalität des etcd-Clusters testen und debuggen

Vorbereitung: Arbeitsverzeichnis

• Wechseln Sie in das workspace-Verzeichnis

  cd ~/workspace
  

Aufgabe 1: Etcd-Zertifikate kopieren und vorbereiten

Zertifikate aus vorherigem Lab kopieren

• Erstellen Sie das etcd-PKI-Verzeichnis und kopieren Sie die Zertifikate aus dem ersten Lab

  mkdir -p pki/etcd
  cp etcd/ca.crt pki/etcd/
  cp etcd/etcd-server.key pki/etcd/server.key
  cp etcd/etcd-server.crt pki/etcd/server.crt
  

Zertifikate auf Control Plane-Nodes verteilen

• Kopieren Sie die etcd-Zertifikate auf alle Control Plane-Nodes

  for instance in controlplane-0 controlplane-1 controlplane-2; do
      echo "## Copying etcd certificates and keys to ${instance}"
      scp -r pki/etcd $instance:/etc/kubernetes/pki/
  done
  

Weitere Zertifikate kopieren

• Kopieren Sie weitere Zertifikate in den pki-Ordner. Diese werden später benötigt, müssen aber nicht auf den Nodes liegen.

  cp etcd/ca.key pki/etcd/
  cp etcd/etcd-client.key pki/etcd/client.key
  cp etcd/etcd-client.crt pki/etcd/client.crt
  

Aufgabe 2: Static Pod-Manifest für etcd erstellen

Arbeitsverzeichnis für etcd-Cluster

• Erstellen Sie ein separates Verzeichnis für die etcd-Cluster-Konfiguration

  mkdir -p ./etcd-cluster
  cd ./etcd-cluster
  

Etcd-Manifest-Template erstellen

• Erstellen Sie eine Template-Datei etcd.yaml.tmpl für das etcd Static Pod-Manifest

  cat > etcd.yaml.tmpl << 'EOF'
  apiVersion: v1
  kind: Pod
  metadata:
    name: etcd
    namespace: kube-system
    labels:
      component: etcd
  spec:
    volumes:
    - hostPath:
        path: /etc/kubernetes/pki/etcd
        type: DirectoryOrCreate
      name: etcd-certs
    - hostPath:
        path: /var/lib/etcd
        type: DirectoryOrCreate
      name: etcd-data
    containers:
    - name: etcd
      image: registry.k8s.io/etcd:3.5.16-0
      volumeMounts:
      - mountPath: /var/lib/etcd
        name: etcd-data
      - mountPath: /etc/kubernetes/pki/etcd
        name: etcd-certs
      command:
      - etcd
      - --name=${NODE_NAME}
      - --data-dir=/var/lib/etcd
      - --advertise-client-urls=https://${NODE_IP}:2379
      - --listen-client-urls=https://127.0.0.1:2379,https://${NODE_IP}:2379
      - --cert-file=/etc/kubernetes/pki/etcd/server.crt
      - --key-file=/etc/kubernetes/pki/etcd/server.key
      - --client-cert-auth=true
      - --trusted-ca-file=/etc/kubernetes/pki/etcd/ca.crt
  
      - --initial-advertise-peer-urls=https://${NODE_IP}:2380
      - --initial-cluster=controlplane-0=https://${IP_CONTROLPLANE_0}:2380,controlplane-1=https://${IP_CONTROLPLANE_1}:2380,controlplane-2=https://${IP_CONTROLPLANE_2}:2380
  
      - --listen-peer-urls=https://${NODE_IP}:2380
  
      - --peer-client-cert-auth=true
      - --peer-trusted-ca-file=/etc/kubernetes/pki/etcd/ca.crt
      - --peer-cert-file=/etc/kubernetes/pki/etcd/server.crt
      - --peer-key-file=/etc/kubernetes/pki/etcd/server.key
      - --snapshot-count=10000
  
      imagePullPolicy: IfNotPresent
      ports:
      - containerPort: 2381
        name: probe-port
        protocol: TCP
      resources:
        requests:
          cpu: 100m
          memory: 100Mi
  
    hostNetwork: true
    priority: 2000001000
    priorityClassName: system-node-critical
    securityContext:
      seccompProfile:
        type: RuntimeDefault
  EOF
  

Aufgabe 3: Node-spezifische Manifeste generieren

IP-Adressen ermitteln und Manifeste erstellen

• Ermitteln Sie die IP-Adressen aller Control Plane-Nodes und generieren Sie node-spezifische Manifeste

  export IP_CONTROLPLANE_0=$(ssh -G controlplane-0 | awk '/^hostname /{print $2}')
  export IP_CONTROLPLANE_1=$(ssh -G controlplane-1 | awk '/^hostname /{print $2}')
  export IP_CONTROLPLANE_2=$(ssh -G controlplane-2 | awk '/^hostname /{print $2}')
  
  for instance in controlplane-0 controlplane-1 controlplane-2; do
      echo "## Generating etcd manifest for ${instance}"
      export NODE_NAME=${instance}
      export NODE_IP=$(ssh -G ${instance} | awk '/^hostname /{print $2}')
      envsubst < etcd.yaml.tmpl > ${instance}-etcd.yaml
  done
  

• Überprüfen Sie die generierten Manifeste

Manifeste auf Control Plane-Nodes kopieren

• Kopieren Sie die generierten Manifeste in das Static Pod-Verzeichnis aller Control Plane-Nodes

  for instance in controlplane-0 controlplane-1 controlplane-2; do
      echo "## Copying etcd manifest to ${instance}"
      ssh ${instance} "mkdir -p /etc/kubernetes/manifests"
      scp ${instance}-etcd.yaml ${instance}:/etc/kubernetes/manifests/etcd.yaml
  done
  

Aufgabe 4: Etcd-Cluster testen

Cluster-Status überprüfen

• Wechseln Sie zurück ins workspace-Verzeichnis und testen Sie die etcd-Cluster-Funktionalität

  cd ~/workspace
  
  ./etcd/etcdctl \
    --endpoints https://<CONTROLPLANE_IP>:2379 \
    --cacert pki/etcd/ca.crt \
    --key pki/etcd/client.key \
    --cert pki/etcd/client.crt \
    member list
  

Cluster-Health überprüfen

• Testen Sie den Zugriff auf alle etcd-Cluster-Member

  # Health-Check für alle Endpoints
  IP_CONTROLPLANE_0=$(ssh -G controlplane-0 | awk '/^hostname /{print $2}')
  IP_CONTROLPLANE_1=$(ssh -G controlplane-1 | awk '/^hostname /{print $2}')
  IP_CONTROLPLANE_2=$(ssh -G controlplane-2 | awk '/^hostname /{print $2}')
  
  ./etcd/etcdctl \
    --endpoints https://${IP_CONTROLPLANE_0}:2379,https://${IP_CONTROLPLANE_1}:2379,https://${IP_CONTROLPLANE_2}:2379 \
    --cacert pki/etcd/ca.crt \
    --key pki/etcd/client.key \
    --cert pki/etcd/client.crt \
    endpoint health
  

Daten schreiben und lesen

• Testen Sie das Schreiben und Lesen von Daten im etcd-Cluster

  # Daten schreiben
  ./etcd/etcdctl \
    --endpoints https://${IP_CONTROLPLANE_0}:2379 \
    --cacert pki/etcd/ca.crt \
    --key pki/etcd/client.key \
    --cert pki/etcd/client.crt \
    put /test/cluster "etcd cluster is working"
  
  # Daten von einem anderen Node lesen
  ./etcd/etcdctl \
    --endpoints https://${IP_CONTROLPLANE_1}:2379 \
    --cacert pki/etcd/ca.crt \
    --key pki/etcd/client.key \
    --cert pki/etcd/client.crt \
    get /test/cluster
  

Aufgabe 5: Debugging und Troubleshooting

Container-Status überprüfen

• Verbinden Sie sich zu einem Control Plane-Node und überprüfen Sie den etcd-Container-Status

  ssh controlplane-0
  
  # Prüfen Sie, ob der etcd-Container läuft
  crictl ps
  
  # Falls der Container nicht läuft, schauen Sie sich alle Container an
  crictl ps -a
  

Logs analysieren

• Analysieren Sie die etcd-Container-Logs bei Problemen

  # Finden Sie die Container-ID
  ETCD_CONTAINER_ID=$(crictl ps | grep etcd | awk '{print $1}')
  
  # Schauen Sie sich die Logs an
  crictl logs $ETCD_CONTAINER_ID
  
  # Oder direkt:
  crictl logs $(crictl ps | grep etcd | awk '{print $1}')
  

Kubelet-Service bei Problemen neustarten

• Falls das Static Pod-Manifest nicht erkannt wird, starten Sie den Kubelet-Service neu

  # Auf dem problematischen Node
  systemctl restart kubelet
  
  # Status überprüfen
  systemctl status kubelet
  
  # Kubelet-Logs verfolgen
  journalctl -u kubelet -f
  

Manifest-Verzeichnis überprüfen

• Stellen Sie sicher, dass das Static Pod-Manifest korrekt platziert wurde

  # Manifest-Verzeichnis überprüfen
  ls -la /etc/kubernetes/manifests/
  
  # Manifest-Inhalt überprüfen
  cat /etc/kubernetes/manifests/etcd.yaml | head -20
  

Aufgabe 6: Erweiterte Tests (Optional)

Konsistenz zwischen Nodes testen

• Testen Sie die Datenkonsistenz zwischen verschiedenen etcd-Nodes

  # Schreiben Sie Daten über Node 0
  ./etcd/etcdctl \
    --endpoints https://${IP_CONTROLPLANE_0}:2379 \
    --cacert pki/etcd/ca.crt \
    --key pki/etcd/client.key \
    --cert pki/etcd/client.crt \
    put /test/consistency "written-via-node-0"
  
  # Lesen Sie von Node 1
  ./etcd/etcdctl \
    --endpoints https://${IP_CONTROLPLANE_1}:2379 \
    --cacert pki/etcd/ca.crt \
    --key pki/etcd/client.key \
    --cert pki/etcd/client.crt \
    get /test/consistency
  
  # Lesen Sie von Node 2
  ./etcd/etcdctl \
    --endpoints https://${IP_CONTROLPLANE_2}:2379 \
    --cacert pki/etcd/ca.crt \
    --key pki/etcd/client.key \
    --cert pki/etcd/client.crt \
    get /test/consistency
  

Performance-Test

• Führen Sie einen einfachen Performance-Test durch

  # Benchmark schreiben
  ./etcd/etcdctl \
    --endpoints https://${IP_CONTROLPLANE_0}:2379 \
    --cacert pki/etcd/ca.crt \
    --key pki/etcd/client.key \
    --cert pki/etcd/client.crt \
    check perf
  

Ausblick

Nach Abschluss dieser Aufgabe läuft ein funktionsfähiger etcd-Cluster als Static Pods auf Ihren Control Plane-Nodes. Dies ist die Basis für die Kubernetes Control Plane-Komponenten (API-Server, Controller Manager, Scheduler), die im nächsten Schritt konfiguriert werden.

Wichtiger Hinweis

In einem produktiven Umgebung sollten etcd-Cluster regelmäßig gesichert werden. Die hier eingerichtete Konfiguration dient Lernzwecken und sollte für Produktionsumgebungen entsprechend gehärtet und überwacht werden.

Troubleshooting-Tipps

• Falls etcd nicht startet, überprüfen Sie die Zertifikatspfade und -berechtigungen
• Kontrollieren Sie, ob alle IP-Adressen im --initial-cluster Parameter korrekt sind
• Stellen Sie sicher, dass die Ports 2379 und 2380 zwischen den Nodes erreichbar sind