Page d'accueil>Lié à la programmation>Autre code source
Télécharger

Gestionnaire de contrôleurs Cloud Kubernetes pour Hetzner Cloud

Le gestionnaire de contrôleur cloud Hetzner Cloud intègre votre cluster Kubernetes aux API Hetzner Cloud & Robot.

Caractéristiques

  • Nœud :
    • Met à jour vos objets Node avec des informations sur le serveur provenant de l'API Cloud & Robot.
    • Type d'instance, emplacement, centre de données, ID de serveur, adresses IP.
  • Cycle de vie du nœud :
    • Nettoie les objets Node obsolètes lorsque le serveur est supprimé dans l'API.
  • Itinéraires (si activé) :
    • Achemine le trafic vers les pods via les réseaux cloud Hetzner. Supprime une couche d'indirection dans les CNI qui prennent en charge cela.
  • Équilibreur de charge :
    • Surveille les services de type: LoadBalancer et crée des équilibreurs de charge Hetzner Cloud pour eux, ajoute des nœuds Kubernetes comme cibles pour l'équilibreur de charge.

En savoir plus sur les contrôleurs cloud dans la documentation Kubernetes.

Exemple de métadonnées de nœud 

 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

Déploiement

Cet exemple de déploiement utilise kubeadm pour amorcer un cluster Kubernetes, avec Flannel comme agent réseau superposé. N'hésitez pas à adapter les étapes à votre méthode préférée d'installation de Kubernetes.

Ces instructions de déploiement sont conçues pour guider l'installation de hcloud-cloud-controller-manager et ne constituent en aucun cas un didacticiel approfondi sur la configuration des clusters Kubernetes. Des connaissances préalables sur les composants impliqués sont requises.

Veuillez vous référer au guide de création de cluster kubeadm, que ces instructions sont censées compléter, ainsi qu'à la documentation kubeadm.

  1. Le gestionnaire de contrôleur cloud ajoute les étiquettes lorsqu'un nœud est ajouté au cluster. Pour les versions actuelles de Kubernetes, cela signifie que nous devons ajouter l'indicateur --cloud-provider=external au kubelet . La façon dont vous procédez dépend de votre distribution Kubernetes. Avec kubeadm vous pouvez le définir soit dans la configuration de kubeadm ( nodeRegistration.kubeletExtraArgs ), soit via une unité d'insertion systemd /etc/systemd/system/kubelet.service.d/20-hcloud.conf : 

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

    Remarque : l'indicateur --cloud-provider est obsolète depuis K8S 1.19. Vous verrez un message de journal à ce sujet. Pour l'instant (v1.31), c'est toujours obligatoire.

  2. Le plan de contrôle peut maintenant être initialisé : 

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

  3. Configurez kubectl pour vous connecter au kube-apiserver : 

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

  4. Déployez le plugin flanelle CNI : 

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

  5. Corrigez le déploiement de flanelle pour tolérer la teinte uninitialized : 

    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. Créez un secret contenant votre jeton API Hetzner Cloud. 

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

  7. Déployer hcloud-cloud-controller-manager

    Utilisation de Helm (recommandé) : 

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

    Voir la charte Helm README pour plus d'informations.

    Méthode d'installation héritée : 

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

Prise en charge des réseaux

Lorsque vous utilisez Cloud Controller Manager avec prise en charge des réseaux, le CCM est favorable à l'allocation des adresses IP (et à la configuration du routage) (Docs : https://kubernetes.io/docs/concepts/architecture/cloud-controller/#route- contrôleur). Le plugin CNI que vous utilisez doit prendre en charge cette fonctionnalité native de k8s (Cilium le fait, je ne connais pas Calico et WeaveNet), donc fondamentalement, vous utilisez les réseaux Cloud Hetzner comme pile réseau sous-jacente.

Lorsque vous utilisez le CCM sans prise en charge des réseaux, cela désactive simplement la partie RouteController, toutes les autres parties fonctionnent de la même manière. Ensuite, seul le CNI est en charge de réaliser tous les éléments de la pile réseau. L'utilisation du CCM avec la prise en charge des réseaux présente l'avantage que votre nœud est connecté à un réseau privé, de sorte que le nœud n'a pas besoin de chiffrer les connexions et que vous avez un peu moins de surcharge opérationnelle car vous n'avez pas besoin de gérer le réseau.

Si vous souhaitez utiliser la fonctionnalité Hetzner Cloud Networks , rendez-vous sur la documentation de support Déploiement avec réseaux.

Si vous gérez le réseau vous-même, il peut être nécessaire d'informer le CCM des réseaux privés. Vous pouvez le faire en ajoutant la variable d'environnement avec le nom/ID du réseau dans le déploiement CCM. 

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

Vous devez également ajouter le nom/ID du réseau au secret : kubectl -n kube-system create secret generic hcloud --from-literal=token=<hcloud API token> --from-literal=network=<hcloud Network_ID_or_Name> .

IPVS en mode proxy Kube et HCloud LoadBalancer

Si kube-proxy est exécuté en mode IPVS, le manifeste Service doit avoir l'annotation load-balancer.hetzner.cloud/hostname où le nom de domaine complet est résolu en adresse IP HCloud LoadBalancer.

Voir #212

Politique de gestion des versions

Notre objectif est de prendre en charge les trois dernières versions de Kubernetes. Lorsqu'une version de Kubernetes est marquée comme End Of Life , nous arrêterons sa prise en charge et supprimerons la version de nos tests CI. Cela ne signifie pas nécessairement que Cloud Controller Manager ne fonctionne toujours pas avec cette version. Nous ne corrigerons pas les bugs liés uniquement à une version non prise en charge.

Versions actuelles de Kubernetes : https://kubernetes.io/releases/

Avec prise en charge des réseaux

Kubernetes Gestionnaire de contrôleur cloud Fichier de déploiement
1.31 dernier https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm-networks.yaml
13h30 dernier https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm-networks.yaml
1,29 dernier https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm-networks.yaml
1,28 dernier 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

Sans support réseaux

Kubernetes Gestionnaire de contrôleur cloud Fichier de déploiement
1.31 dernier https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm.yaml
13h30 dernier https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm.yaml
1,29 dernier https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm.yaml
1,28 dernier 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

Développement

Configurer un environnement de développement

Pour configurer un environnement de développement, assurez-vous d'avoir installé les outils suivants :

  • tofu
  • k3sup
  • docker
  • échafaudage
  1. Configurez un HCLOUD_TOKEN dans votre session shell.

Avertissement

L'environnement de développement fonctionne sur des serveurs Hetzner Cloud, ce qui entraînera des coûts.

  1. Déployez le cluster de développement : 
make -C dev up
  1. Chargez la configuration générée pour accéder au cluster de développement : 
 source dev/files/env.sh
  1. Vérifiez que le cluster de développement est sain : 
kubectl get nodes -o wide
  1. Commencez à développer hcloud-cloud-controller-manager dans le cluster de développement : 
skaffold dev

Lors du changement de code, skaffold reconstruira l'image, la redéployera et imprimera tous les journaux.

️ N'oubliez pas de nettoyer le cluster de développement une fois terminé : 

make -C dev down

Exécutez les tests unitaires

Pour exécuter les tests unitaires, assurez-vous d'avoir installé les outils suivants :

  • Aller
  1. Exécutez la commande suivante pour exécuter les tests unitaires : 
go test ./...

Exécutez les tests Kubernetes e2e

Avant d'exécuter les tests e2e, assurez-vous d'avoir suivi les étapes de configuration d'un environnement de développement.

  1. Exécutez les tests Kubernetes e2e à l'aide de la commande suivante : 
 source dev/files/env.sh
go test ./tests/e2e -tags e2e -v

Développement avec Robot

Si vous souhaitez travailler sur le support Robot, vous devez apporter quelques modifications à la configuration ci-dessus.

Cela nécessite que vous disposiez d'un Robot Server dans le même compte que celui que vous utilisez pour le développement. Le serveur doit être configuré avec Ansible Playbook dev/robot/install.yml et configuré dans dev/robot/install.yml .

  1. Définissez ces variables d'environnement : 
 export ROBOT_ENABLED=true

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

  1. Continuez la configuration de l'environnement jusqu'à ce que vous atteigniez l'étape skaffold . Exécutez plutôt skaffold dev --profile=robot .

  2. Nous avons une autre suite de tests pour Robot. Vous pouvez les exécuter avec : 

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

Licence

Licence Apache, version 2.0

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout