Comment nettoyer les anciennes tâches Kubernetes
Agence web » Actualités du digital » Comment démarrer un cluster Kubernetes à partir de zéro avec Kubeadm et Kubectl

Comment démarrer un cluster Kubernetes à partir de zéro avec Kubeadm et Kubectl

Kubernetes est réputé pour sa complexité, mais les versions modernes sont relativement simples à configurer. L’outil d’administration de cluster officiel Kubeadm fournit une expérience automatisée pour démarrer votre plan de contrôle et enregistrer les nœuds de travail.

Cet article vous guidera dans la configuration d’un cluster Kubernetes simple à l’aide de la configuration par défaut. Il s’agit d’un guide « à partir de zéro » qui devrait fonctionner sur un hôte fraîchement provisionné. Un système basé sur Debian est supposé, mais vous pouvez ajuster la plupart des commandes pour qu’elles correspondent au gestionnaire de paquets de votre système d’exploitation. Ces étapes ont été testées avec Ubuntu 22.04 et Kubernetes v1.25.

Installer un runtime de conteneur

Kubernetes a besoin d’un environnement d’exécution de conteneur compatible CRI pour démarrer et exécuter vos conteneurs. La distribution standard de Kubernetes n’est pas fournie avec un environnement d’exécution, vous devez donc en installer un avant de continuer. containerd est le choix le plus populaire. C’est le runtime inclus avec les versions modernes de Docker.

Vous pouvez installer containerd à l’aide du référentiel Apt de Docker. Ajoutez d’abord quelques dépendances qui seront utilisées lors de la procédure d’installation :

$ sudo apt update
$ sudo apt install -y 
   ca-certificates 
   curl 
   gnupg 
   lsb-release

Ajoutez ensuite la clé GPG du référentiel à celle d’Apt keyrings annuaire:

$ sudo mkdir -p /etc/apt/keyrings
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Vous pouvez maintenant ajouter le dépôt correct pour votre système en exécutant cette commande :

$ echo 
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu 
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Mettez à jour votre liste de packages pour inclure le contenu du dépôt Docker :

$ sudo apt update

Enfin, installez containerd :

$ sudo apt install -y containerd.io

Vérifiez que le service containerd a démarré :

$ sudo service containerd status
 containerd.service - containerd container runtime
     Loaded: loaded (/lib/systemd/system/containerd.service; enabled; vendor preset: enabled)
     Active: active (running) since Tue 2022-09-13 16:50:12 BST; 6s ago

Quelques ajustements au fichier de configuration containerd sont nécessaires pour qu’il fonctionne correctement avec Kubernetes. Remplacez d’abord le contenu du fichier par la configuration par défaut de containerd :

$ sudo containerd config default > /etc/containerd/config.toml

Cela remplit tous les champs de configuration disponibles et résout certains problèmes, tels que la prise en charge CRI désactivée sur les nouvelles installations.

Prochaine ouverture /etc/containerd/config.toml et trouvez la ligne suivante :

SystemdCgroup = false

Changez la valeur en true:

SystemdCgroup = true

Cette modification est nécessaire pour activer la prise en charge complète de systemd gestion des groupes de contrôle. Sans cette option, les conteneurs du système Kubernetes redémarreront périodiquement.

Redémarrez containerd pour appliquer vos modifications :

$ sudo service containerd restart

Installation de Kubeadm, Kubectl et Kubelet

La deuxième phase du processus consiste à installer les outils Kubernetes. Ces trois utilitaires offrent les fonctionnalités suivantes :

  • KubeadmComment – Un outil d’administration qui fonctionne au niveau du cluster. Vous l’utiliserez pour créer votre cluster et ajouter des nœuds supplémentaires.
  • Kubect – Kubectl est la CLI que vous utilisez pour interagir avec votre cluster Kubernetes une fois qu’il est en cours d’exécution.
  • Kubelet – Il s’agit du processus Kubernetes qui s’exécute sur les noeuds worker de votre cluster. Il est chargé de maintenir le contact avec le plan de contrôle et de démarrer de nouveaux conteneurs à la demande.

Les trois binaires sont disponibles dans un référentiel Apt hébergé par Google Cloud. Enregistrez d’abord le trousseau de clés GPG du référentiel :

$ sudo curl -fsSLo /etc/apt/keyrings/kubernetes.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg

Ajoutez ensuite le référentiel à vos sources…

$ echo "deb [signed-by=/etc/apt/keyrings/kubernetes.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

…et mettez à jour votre liste de packages :

$ sudo apt update

Installez maintenant les packages :

$ sudo apt install -y kubeadm kubectl kubelet

Il est préférable de « conserver » ces packages afin qu’Apt ne les mette pas automatiquement à jour lorsque vous exécutez apt upgrade. Les mises à niveau du cluster Kubernetes doivent être lancées manuellement pour éviter les temps d’arrêt et éviter les modifications avec rupture indésirables.

$ sudo apt-mark hold kubeadm kubectl kubelet

Désactivation de l’échange

Kubernetes ne fonctionne pas lorsque l’échange est activé. Vous devez désactiver la permutation avant de créer votre cluster. Sinon, vous constaterez que le processus de provisionnement se bloque en attendant le démarrage de Kubelet.

Exécutez cette commande pour désactiver l’échange :

$ sudo swapoff -a

Modifiez ensuite votre /etc/fstab fichier et désactivez tous les montages d’échange :

UUID=ec6efe91-5d34-4c80-b59c-cafe89cc6cb2 /               ext4    errors=remount-ro 0       1
/swapfile                                 none            swap    sw              0       0

Ce fichier montre un montage avec le swap tapez comme dernière ligne. Il doit être supprimé ou commenté afin que l’échange reste désactivé après le redémarrage du système.

Chargement du module br_netfilter

La br_netfilter Le module du noyau est requis pour permettre à iptables de voir le trafic ponté. Kubeadm ne vous laissera pas créer votre cluster lorsque ce module est manquant.

Vous pouvez l’activer avec la commande suivante :

$ sudo modprobe br_netfilter

Faites-le persister après un redémarrage en l’incluant dans la liste des modules de votre système :

$ echo br_netfilter | sudo tee /etc/modules-load.d/kubernetes.conf

Création de votre grappe

Vous êtes prêt à créer votre cluster Kubernetes. Courir kubeadm init sur la machine sur laquelle vous souhaitez héberger votre plan de contrôle :

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

La --pod-network-cidr L’indicateur est inclus afin qu’une allocation CIDR correcte soit disponible pour le module complémentaire de mise en réseau du pod qui sera installé ultérieurement. La valeur par défaut de 10.244.0.0/16 fonctionne dans la plupart des cas, mais vous devrez peut-être modifier la plage si vous utilisez un environnement réseau fortement personnalisé.

La création du cluster peut prendre plusieurs minutes. Les informations de progression seront affichées dans votre terminal. Vous devriez voir ce message en cas de succès :

Your Kubernetes control-plane has initialized successfully!

La sortie inclut également des informations sur la façon de commencer à utiliser votre cluster.

Préparation de votre fichier Kubeconfig

Commencez par copier le fichier Kubeconfig généré automatiquement dans votre propre .kube/config annuaire. Ajustez la propriété du fichier pour vous-même afin que Kubectl puisse lire son contenu correctement.

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

Installation d’un module complémentaire de mise en réseau de pod

Kubernetes nécessite qu’un module complémentaire de mise en réseau de pod existe dans votre cluster avant que les nœuds de travail ne commencent à fonctionner normalement. Vous devez installer manuellement un module complémentaire compatible pour terminer votre installation.

Calico et Flannel sont les deux choix les plus populaires. Ce guide utilise Flannel en raison de sa simplicité d’installation.

Utilisez Kubectl pour ajouter Flannel à votre cluster :

$ kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

Attendez quelques instants puis courez kubectl get nodes dans votre borne. Vous devriez voir vos émissions Node comme Ready et vous pouvez commencer à interagir avec votre cluster.

$ kubectl get nodes
NAME       STATUS   ROLES           AGE     VERSION
ubuntu22   Ready    control-plane   7m19s   v1.25.0

Si tu cours kubectl get pods --all-namespacesvous devriez voir que les composants du plan de contrôle, CoreDNS et Flannel sont tous opérationnels :

$ kubectl get pods --all-namespaces
NAMESPACE      NAME                               READY   STATUS    RESTARTS        AGE
kube-flannel   kube-flannel-ds-xlrk6              1/1     Running   5 (16s ago)     11m
kube-system    coredns-565d847f94-bzzkf           1/1     Running   5 (2m9s ago)    14m
kube-system    coredns-565d847f94-njrdc           1/1     Running   4 (30s ago)     14m
kube-system    etcd-ubuntu22                      1/1     Running   6 (113s ago)    13m
kube-system    kube-apiserver-ubuntu22            1/1     Running   5 (30s ago)     16m
kube-system    kube-controller-manager-ubuntu22   1/1     Running   7 (3m59s ago)   13m
kube-system    kube-proxy-r9g9k                   1/1     Running   8 (21s ago)     14m
kube-system    kube-scheduler-ubuntu22            1/1     Running   7 (30s ago)     15m

Interagir avec votre cluster

Vous pouvez maintenant commencer à utiliser Kubectl pour interagir avec votre cluster. Avant de continuer, supprimez la teinte par défaut sur votre nœud de plan de contrôle pour permettre aux pods de planifier dessus. Kubernetes empêche les pods de s’exécuter sur le nœud du plan de contrôle pour éviter les conflits de ressources, mais cette restriction n’est pas nécessaire pour une utilisation locale.

$ kubectl taint node ubuntu22 node-role.kubernetes.io/control-plane:NoSchedule-
node/ubuntu22 untainted

Remplacer ubuntu22 dans la commande ci-dessus avec le nom attribué à votre propre nœud.

Essayez maintenant de démarrer un pod NGINX simple :

$ kubectl run nginx --image nginx:latest
pod/nginx created

Exposez-le avec un service NodePort :

$ kubectl expose pod/nginx --port 80 --type NodePort
service/nginx exposed

Recherchez le port hôte qui a été alloué au service :

$ kubectl get services
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        18m
nginx        NodePort    10.106.44.155   <none>        80:30647/TCP   27s

Le port est 30647. Les requêtes HTTP adressées à ce point de terminaison doivent désormais émettre la page de destination NGINX par défaut en réponse :

$ curl http://localhost:30647
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>

Votre cluster Kubernetes fonctionne !

Ajouter un autre nœud

Pour configurer des nœuds de travail supplémentaires, répétez d’abord toutes les étapes des sections jusqu’à « Création de votre cluster » sur chaque machine que vous souhaitez utiliser. Chaque nœud aura besoin de containerd, Kubeadm et Kubelet installés. Vous devez également vérifier que votre nœud dispose d’une connectivité réseau complète à la machine qui exécute votre plan de contrôle.

Exécutez ensuite la commande suivante sur votre nouveau noeud worker :

kubeadm join 192.168.122.229:6443 
    --node-name node-b 
    --token <token> 
    --discovery-token-ca-cert-hash sha256:<token-ca-cert-hash>

Remplacez l’adresse IP par celle de votre nœud de plan de contrôle. Les valeurs de <token> et <token-ca-cert-hash> aura été affiché lorsque vous avez couru kubeadm init pour créer votre plan de contrôle. Vous pouvez les récupérer en suivant les étapes suivantes.

Jeton

Courir kubeadm token list sur le nœud du plan de contrôle. La valeur du jeton sera affichée dans le TOKEN colonne.

$ kubeadm token list
TOKEN                     TTL         EXPIRES                USAGES                   DESCRIPTION                                                EXTRA GROUPS
lkoz6v.cw1e01ckz2yqvw4u   23h         2022-09-14T19:35:03Z   authentication,signing

Token CA Cert Hachage

Exécutez cette commande et utilisez sa sortie comme valeur :

$ openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | 
   openssl dgst -sha256 -hex | sed 's/^.* //'

Rejoindre le cluster

La kubeadm join La commande doit produire cette sortie en cas de succès :

$ kubeadm join 192.168.122.229:6443 
    --node-name node-b 
    --token <token> 
    --discovery-token-ca-cert-hash sha256:<token-ca-cert-hash>
[kubelet-start] Starting the kubelet[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

Vérifiez que le nœud a rejoint le cluster et est prêt à recevoir des pods en exécutant le kubectl get nodes commande:

$ kubectl get nodes
NAME       STATUS   ROLES           AGE    VERSION
node-b     Ready    <none>          91s    v1.25.0
ubuntu22   Ready    control-plane   100m   v1.25.0

Le nœud apparaît dans la liste et a Ready comme son statut. Cela signifie qu’il est opérationnel et que Kubernetes peut y programmer des pods.

Sommaire

La configuration de Kubernetes peut sembler décourageante, mais Kubeadm automatise la plupart des parties difficiles pour vous. Bien qu’il reste encore plusieurs étapes à franchir, vous ne devriez pas rencontrer de problèmes si vous vous assurez que les conditions préalables sont remplies avant de commencer.

La plupart des problèmes surviennent parce qu’il n’y a pas d’environnement d’exécution de conteneur disponible, le br_netfilter le module de noyau est manquant, l’échange est activé ou la nécessité de fournir un module complémentaire de mise en réseau du pod a été négligée. Le dépannage doit commencer par vérifier ces erreurs courantes.

Kubeadm vous offre la dernière version de Kubernetes directement depuis le projet lui-même. Des distributions alternatives sont disponibles qui vous permettent de démarrer un cluster à nœud unique avec une seule commande. Minikube, MicroK8 et K3 sont trois options populaires. Bien qu’ils soient généralement plus faciles à configurer et à mettre à niveau, ils présentent tous de légères différences par rapport à Kubernetes en amont. L’utilisation de Kubeadm vous rapproche du fonctionnement interne de Kubernetes et s’applique à de nombreux environnements différents.

★★★★★