Mise en place d'un cluster Kubernetes en local avec Vagrant et Virtual Box

Lorsqu'il s'agit de travailler avec Kubernetes, il est souvent difficile de trouver un environnement de développement personnalisable et fiable. C'est là que Vagrant entre en jeu. Vagrant, qui est une plateforme open-source, va nous permettre de créer et de configurer des environnements de développement reproductibles, portables et isolés. Avec Vagrant, nous pouvons créer des environnements virtuels personnalisés et configurables, sans nous soucier des dépendances système ou des configurations matérielles.

Dans cet article, nous allons explorer comment utiliser Vagrant et Virtual Box en tant que provider, pour mettre en place un cluster Kubernetes local :

• Nous verrons comment créer et configurer le cluster K8s à l'aide de Vagrant et comment le déployer sur plusieurs machines virtuelles qui seront sur Virtual Box.
• Nous verrons également comment garantir une haute disponibilité en utilisant des mécanismes de tolérance aux pannes pour les workers nodes de Kubernetes.

Cet article offrira une introduction pratique pour nous, ops et dev, qui souhaitent se familiariser avec la mise en place de clusters K8s avec kubeadm.

• Tous les fichiers sont disponibles directement ici sur notre GitHub.

Préparation de notre “Tools Kit” ⚙️

Versions des outils

Ci-dessous les versions des différentes applications que nous utiliserons pour notre machine hôte dans ce tutoriel:

• Vagrant, version 2.3.4
• Virtual Box, version 7.0.4

Ci-dessous les versions des différentes applications que nous utiliserons pour nos machines virtuelles dans ce tutoriel:

• Ubuntu, version 20.04
• Kubernetes, version 1.26.3

Ressources nécessaires

Afin de déployer et d'exécuter notre projet Kubernetes en toute efficacité, il est impératif que notre machine hôte dispose d'une configuration minimale comprenant au moins:

• 4 CPU
• 8 Go de RAM
• 50 Go d'espace disque disponible.

De plus, chaque machine virtuelle dans notre cluster, pour garantir un service optimal, doit avoir au moins:

• 2 vCPU
• 2 Go de RAM

⭐️ Pour ajuster les paramètres de notre cluster, nous pouvons modifier les valeurs de configuration pour chaque machine virtuelle dans le fichier Vagrantfile. Cela nous permettra de personnaliser notre infrastructure pour répondre aux besoins spécifiques de notre projet:

Préparation de notre machine hôte

• Installation de Vagrant : ici le lien vers la page de téléchargement de Vagrant.
• Installation de Virtual Box: ici le lien vers la page de téléchargement de Virtual Box.

⭐️ Avant de déployer le cluster nous devons générer une paire de clés SSH, pour permettre aux machines virtuelle de communiquer avec le control plane. Cette clé sera utilisée uniquement une seule fois pour permettre aux workers nodes d'automatiquement rejoindre le control-plane, puis elle sera supprimée de la machine virtuelle.

• Création de la paire de clé:

  Copiercd k8s && mkdir -p .ssh
  ssh-keygen -t rsa -b 4096 -f .ssh/id_rsa -q -N ""
  

Configuration de notre cluster K8s

Avec notre infrastructure Kubernetes basée sur Vagrant et VirtualBox, nous offrons une grande flexibilité en termes de configuration. Les paramètres peuvent être facilement ajustés en fonction des besoins spécifiques de chaque projet.

Tous les fichiers de configuration sont stockés dans le répertoire scripts, offrant une approche simplifiée pour la personnalisation. Nous pouvons facilement augmenter ou diminuer le nombre de workers nodes pour adapter fonction des besoins de notre projet.

De plus, il est possible de modifier la version de Kubernetes pour garantir une compatibilité optimale avec nos applications et services:

• La version de Kubernetes utilisée ici est la version 1.26.3. Cette version peut être modifié grâce à la variable KUBE_VERSION dans le fichier ./scripts/init_k8s.sh:

• Modifier les variables NMB_CONTROL_PLANE et NMB_WORKER pour définir le nombre de nodes du cluster. Nous utiliserons une Vagrant boxes contenant l'image Ubuntu 20.04, définit par la variable IMAGE:

Déploiement de notre “Kit” 🚀

Déploiement du cluster K8s

Pour déployer le cluster, il faudra se rendre à la racine du répertoire k8s et exécuter la commande:

Copiervagrant up

Vagrant va automatiquement télécharger les paquets nécessaires et créer nos machines. Les scripts vont installer les binaires nécessaires pour Kubernetes et automatiquement ajouter les workers nodes à notre cluster:

⏳ Il faudra attendre quelques minutes le temps que les VMs soit créer et provisionner, cela dépendra du débit de votre connexion à Internet ainsi que les performances de votre machine.

• ⭐️ Contactez un de nos experts DevOps pour vous conseillez et mettre en place vos clusters Kubernetes optimisés et hautement disponible !

Accès au cluster

On peut communiquer avec notre cluster de deux manières. Soit en se connectant sur le serveur control-plane, soit en utilisant le client kubectl:

• En utilisant la machine virtuelle control-plane1:

  • Une fois le cluster disponible, accéder en ssh grâce à la commande vagrant ssh control-plane1.

• En utilisant notre machine hôte grâce au client kubectl:

  • Choisir selon votre système d'exploitation:

  Copier# Linux
  OS="linux/amd64"
  # MacOS
  OS="darwin/amd64"
  

  Pour Windows, vous pouvez directement télécharger l'exécutable ici pour la version 1.26.3.

  • Télécharger le binaire kubectl, depuis le dépôt de Google:

  CopierKUBE_VERSION="v1.26.3"
  curl \
  -L https://storage.googleapis.com/kubernetes-release/release/$KUBE_VERSION/bin/$OS/kubectl \
  -o ./kubectl.d/kubectl
  chmod +x ./kubectl.d/kubectl
  

  • Une fois le cluster disponible, récupérer le fichier kubeconfig:

  Copiervagrant ssh control-plane1 -c "cat /home/vagrant/.kube/config" > ./kubectl.d/kubeconfig.yml
  

  • Créer un alias sur la machine hôte, permettant d'utiliser le kubectl télécharger précédemment. On utilisera également le fichier kubeconfig.yml, cela nous permettra d'avoir les accès nécessaires pour communiquer avec le cluster:

  Copieralias kubectl="$(pwd)/kubectl.d/kubectl --kubeconfig $(pwd)/kubectl.d/kubeconfig.yml"
  

  💡 Idéalement, il faudrait renseigner le chemin absolu vers le répertoire k8s.

  • Une fois l'accés au cluster effectif, il faudra installer un plugin pour la gestion réseau de Kubernetes. Ici, nous utiliserons Calico:

Copierkubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.0/manifests/calico.yaml

Nous pouvons par la suite commencer à intéragir avec notre cluster:

Conclusion

En conclusion, la mise en place d'un environnement de développement local pour Kubernetes peut sembler difficile et fastidieuse, mais grâce à Vagrant et Virtual Box, cela devient facile et efficace. La combinaison de Kubernetes, Vagrant et Virtual Box offre une plateforme puissante pour les dev et les ops pour travailler sur des applications basées sur Kubernetes.

La mise en place d'un cluster Kubernetes local avec Vagrant est un moyen idéal pour les développeurs et les administrateurs de travailler sur des applications Kubernetes et de se familiariser avec la plateforme. En utilisant des outils comme Vagrant, les développeurs peuvent consacrer plus de temps à la création et au développement d'applications plutôt qu'à la gestion de l'infrastructure. En somme, la mise en place d'un cluster Kubernetes local avec Vagrant est un outil essentiel pour tout développeur souhaitant travailler sur des applications basées sur Kubernetes de manière efficace et productive.

• ⭐️ Contactez un de nos experts DevOps pour tous besoins concernant votre infrastructure !