Startseite>Programmierbezogen>Anderer Quellcode
Herunterladen

Kubernetes Cloud Controller Manager für Hetzner Cloud

Der Hetzner Cloud Cloud-Controller-Manager integriert Ihren Kubernetes-Cluster mit den Hetzner Cloud & Robot APIs.

Merkmale

  • Knoten :
    • Aktualisiert Ihre Node mit Informationen über den Server aus der Cloud & Robot API.
    • Instanztyp, Standort, Rechenzentrum, Server-ID, IPs.
  • Knotenlebenszyklus :
    • Bereinigt veraltete Node , wenn der Server in der API gelöscht wird.
  • Routen (falls aktiviert):
    • Leitet den Datenverkehr über Hetzner Cloud Networks an die Pods weiter. Entfernt eine Indirektionsebene in CNIs, die dies unterstützen.
  • Load Balancer :
    • Überwacht Dienste mit type: LoadBalancer und erstellt Hetzner Cloud Load Balancer für sie, fügt Kubernetes-Knoten als Ziele für den Load Balancer hinzu.

Weitere Informationen zu Cloud-Controllern finden Sie in der Kubernetes-Dokumentation.

Beispiel für Knotenmetadaten 

 apiVersion : v1
kind : Node
metadata :
  labels :
    node.kubernetes.io/instance-type : cx22
    topology.kubernetes.io/region : fsn1
    topology.kubernetes.io/zone : fsn1-dc8
    instance.hetzner.cloud/provided-by : cloud
  name : node
spec :
  podCIDR : 10.244.0.0/24
  providerID : hcloud://123456 # <-- Hetzner Cloud Server ID
status :
  addresses :
    - address : node
      type : Hostname
    - address : 1.2.3.4 # <-- Hetzner Cloud Server public ipv4
      type : ExternalIP

Einsatz

In diesem Bereitstellungsbeispiel wird kubeadm zum Bootstrap eines Kubernetes-Clusters verwendet, mit Flannel als Overlay-Netzwerkagent. Passen Sie die Schritte gerne an Ihre bevorzugte Methode zur Installation von Kubernetes an.

Diese Bereitstellungsanweisungen dienen als Leitfaden für die Installation des hcloud-cloud-controller-manager und sind keineswegs eine ausführliche Anleitung zum Einrichten von Kubernetes-Clustern. Vorkenntnisse über die beteiligten Komponenten sind erforderlich.

Weitere Informationen finden Sie im Kubeadm-Cluster-Erstellungsleitfaden, den diese Anweisungen ergänzen sollen, sowie in der Kubeadm-Dokumentation.

  1. Der Cloud-Controller-Manager fügt die Beschriftungen hinzu, wenn ein Knoten zum Cluster hinzugefügt wird. Für aktuelle Kubernetes-Versionen bedeutet dies, dass wir das Flag --cloud-provider=external zum kubelet hinzufügen müssen. Wie Sie dies tun, hängt von Ihrer Kubernetes-Distribution ab. Mit kubeadm können Sie es entweder in der kubeadm-Konfiguration ( nodeRegistration.kubeletExtraArgs ) oder über eine systemd-Drop-in-Einheit /etc/systemd/system/kubelet.service.d/20-hcloud.conf festlegen: 

     [Service]
Environment = " KUBELET_EXTRA_ARGS=--cloud-provider=external "

    Hinweis: Das Flag --cloud-provider ist seit K8S 1.19 veraltet. Hierzu wird eine Protokollmeldung angezeigt. Derzeit (v1.31) ist es noch erforderlich.

  2. Jetzt kann die Kontrollebene initialisiert werden: 

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

  3. Konfigurieren Sie kubectl, um eine Verbindung zum kube-apiserver herzustellen: 

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

  4. Stellen Sie das Flannel-CNI-Plugin bereit: 

    kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

  5. Patchen Sie die Flannel-Bereitstellung, um den uninitialized Taint zu tolerieren: 

    kubectl -n kube-system patch ds kube-flannel-ds --type json -p ' [{"op":"add","path":"/spec/template/spec/tolerations/-","value":{"key":"node.cloudprovider.kubernetes.io/uninitialized","value":"true","effect":"NoSchedule"}}] '

  6. Erstellen Sie ein Geheimnis, das Ihr Hetzner Cloud API-Token enthält. 

    kubectl -n kube-system create secret generic hcloud --from-literal=token= < hcloud API token >

  7. Stellen Sie hcloud-cloud-controller-manager bereit

    Verwendung von Helm (empfohlen): 

     helm repo add hcloud https://charts.hetzner.cloud
helm repo update hcloud
helm install hccm hcloud/hcloud-cloud-controller-manager -n kube-system

    Weitere Informationen finden Sie in der README-Datei zum Helm-Chart.

    Legacy-Installationsmethode : 

    kubectl apply -f https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm.yaml

Netzwerkunterstützung

Wenn Sie den Cloud Controller Manager mit Netzwerkunterstützung verwenden, befürwortet der CCM die Zuweisung der IPs (und die Einrichtung des Routings) (Dokumente: https://kubernetes.io/docs/concepts/architecture/cloud-controller/#route- Regler). Das von Ihnen verwendete CNI-Plugin muss diese native Funktionalität von k8s unterstützen (Cilium macht das, ich weiß nichts über Calico & WeaveNet), also verwenden Sie im Grunde die Hetzner Cloud Networks als zugrunde liegenden Netzwerk-Stack.

Wenn Sie den CCM ohne Netzwerkunterstützung verwenden, wird nur der RouteController-Teil deaktiviert, alle anderen Teile funktionieren völlig gleich. Dann ist allein das CNI für die Herstellung aller Netzwerk-Stack-Dinge verantwortlich. Die Verwendung des CCM mit Netzwerkunterstützung hat den Vorteil, dass Ihr Knoten mit einem privaten Netzwerk verbunden ist, sodass der Knoten die Verbindungen nicht verschlüsseln muss und Sie einen etwas geringeren Betriebsaufwand haben, da Sie das Netzwerk nicht verwalten müssen.

Wenn Sie die Hetzner Cloud Networks Funktion nutzen möchten, lesen Sie die Supportdokumentation „Bereitstellung mit Netzwerken“.

Wenn Sie das Netzwerk selbst verwalten, ist es möglicherweise dennoch erforderlich, den CCM über private Netzwerke zu informieren. Sie können dies tun, indem Sie die Umgebungsvariable mit dem Netzwerknamen/der Netzwerk-ID in der CCM-Bereitstellung hinzufügen. 

          env:
            - name: HCLOUD_NETWORK
              valueFrom:
                secretKeyRef:
                  name: hcloud
                  key: network

Sie müssen dem Geheimnis auch den Netzwerknamen/die Netzwerk-ID hinzufügen: kubectl -n kube-system create secret generic hcloud --from-literal=token=<hcloud API token> --from-literal=network=<hcloud Network_ID_or_Name> .

Kube-Proxy-Modus IPVS und HCloud LoadBalancer

Wenn kube-proxy im IPVS-Modus ausgeführt wird, muss das Service die Annotation load-balancer.hetzner.cloud/hostname haben, wobei der FQDN in die HCloud LoadBalancer-IP aufgelöst wird.

Siehe #212

Versionierungsrichtlinie

Unser Ziel ist es, die neuesten drei Versionen von Kubernetes zu unterstützen. Wenn eine Kubernetes-Version als End Of Life markiert wird, stellen wir den Support dafür ein und entfernen die Version aus unseren CI-Tests. Dies bedeutet nicht zwangsläufig, dass der Cloud Controller Manager mit dieser Version nicht noch funktioniert. Wir werden keine Fehler beheben, die nur mit einer nicht unterstützten Version zusammenhängen.

Aktuelle Kubernetes-Releases: https://kubernetes.io/releases/

Mit Netzwerkunterstützung

Kubernetes Cloud Controller Manager Bereitstellungsdatei
1.31 letzte https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm-networks.yaml
1.30 letzte https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm-networks.yaml
1.29 letzte https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm-networks.yaml
1.28 letzte https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm-networks.yaml
1.27 v1.20.0 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.20.0/ccm-networks.yaml
1.26 v1.19.0 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.19.0/ccm-networks.yaml
1,25 v1.19.0 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.19.0/ccm-networks.yaml
1.24 v1.17.2 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.17.2/ccm-networks.yaml
1.23 v1.13.2 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.13.2/ccm-networks.yaml

Ohne Netzwerkunterstützung

Kubernetes Cloud Controller Manager Bereitstellungsdatei
1.31 letzte https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm.yaml
1.30 letzte https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm.yaml
1.29 letzte https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm.yaml
1.28 letzte https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm.yaml
1.27 v1.20.0 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.20.0/ccm.yaml
1.26 v1.19.0 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.19.0/ccm.yaml
1,25 v1.19.0 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.19.0/ccm.yaml
1.24 v1.17.2 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.17.2/ccm.yaml
1.23 v1.13.2 https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/download/v1.13.2/ccm.yaml

Entwicklung

Richten Sie eine Entwicklungsumgebung ein

Stellen Sie zum Einrichten einer Entwicklungsumgebung sicher, dass Sie die folgenden Tools installiert haben:

  • Tofu
  • k3sup
  • Docker
  • Gerüst
  1. Konfigurieren Sie ein HCLOUD_TOKEN in Ihrer Shell-Sitzung.

Warnung

Die Entwicklungsumgebung läuft auf Hetzner Cloud-Servern, wodurch Kosten entstehen.

  1. Stellen Sie den Entwicklungscluster bereit: 
make -C dev up
  1. Laden Sie die generierte Konfiguration, um auf den Entwicklungscluster zuzugreifen: 
 source dev/files/env.sh
  1. Überprüfen Sie, ob der Entwicklungscluster fehlerfrei ist: 
kubectl get nodes -o wide
  1. Beginnen Sie mit der Entwicklung von hcloud-cloud-controller-manager im Entwicklungscluster: 
skaffold dev

Bei einer Codeänderung erstellt Gerüst das Image neu, stellt es erneut bereit und druckt alle Protokolle.

️ Vergessen Sie nicht, den Entwicklungscluster zu bereinigen, wenn Sie fertig sind: 

make -C dev down

Führen Sie die Unit-Tests durch

Stellen Sie zum Ausführen der Komponententests sicher, dass Sie die folgenden Tools installiert haben:

  • Gehen
  1. Führen Sie den folgenden Befehl aus, um die Komponententests auszuführen: 
go test ./...

Führen Sie die Kubernetes E2E-Tests aus

Bevor Sie die e2e-Tests ausführen, stellen Sie sicher, dass Sie die Schritte zum Einrichten einer Entwicklungsumgebung befolgt haben.

  1. Führen Sie die Kubernetes-E2e-Tests mit dem folgenden Befehl aus: 
 source dev/files/env.sh
go test ./tests/e2e -tags e2e -v

Entwicklung mit Roboter

Wenn Sie an der Roboterunterstützung arbeiten möchten, müssen Sie einige Änderungen an der obigen Einrichtung vornehmen.

Dies erfordert, dass Sie über einen Roboterserver in demselben Konto verfügen, das Sie für die Entwicklung verwenden. Der Server muss mit dem Ansible Playbook dev/robot/install.yml eingerichtet und in dev/robot/install.yml konfiguriert werden.

  1. Legen Sie diese Umgebungsvariablen fest: 
 export ROBOT_ENABLED=true

export ROBOT_USER= < Your Robot User >
export ROBOT_PASSWORD= < Your Robot Password >

  1. Fahren Sie mit der Einrichtung der Umgebung fort, bis Sie die skaffold erreichen. Führen Sie stattdessen skaffold dev --profile=robot aus.

  2. Wir haben eine weitere Reihe von Tests für Robot. Sie können diese ausführen mit: 

go test ./tests/e2e -tags e2e,robot -v

Lizenz

Apache-Lizenz, Version 2.0

Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle