Comme nous l’avons évoqué dans notre guide ultime sur Docker, la notion de conteneurisation est un concept très important, surtout si l’on travaille en tant qu’ingénieur DevOps/Cloud ou développeur Big Data. Toujours dans cette lignée, nous allons aujourd’hui vous parler d’un outil permettant d’optimiser le traitement des conteneurs à savoir Kubernetes.

En effet, pour travailler efficacement avec les conteneurs et bénéficier pleinement de ses avantages, il faut des outils tels que Kubernetes. Alors, dans cet article, nous allons vous le présenter et vous donner un tutoriel exhaustif afin que vous puissiez effectuer vos premiers pas en Kubernetes.

Kubernetes : qu’est-ce que c’est ?

Avant toute chose, Kubernetes, c’est quoi ? Pour faire simple, il s’agit d’un outil open source d’orchestration de conteneur.

Pour ne pas vous perdre dès le départ, un conteneur est un environnement permettant d’isoler une application et ses dépendances afin qu’ils ne rentrent pas en conflit avec d’autres applications. Il contient seulement les ressources nécessaires afin de faire fonctionner l’application, ce qui nous évite de créer une machine virtuelle pour chaque déploiement.

Revenons maintenant à nos moutons. Si l’on rentre dans les détails, Kubernetes permet d’effectuer de nombreuses tâches relatives à cette première définition. En effet, il nous aide à gérer et à distribuer de nombreuses applications conteneurisées en automatisant certains processus. Il offre également la possibilité de basculer d’un environnement à l’autre sans aucun souci, même s’il s’agit d’un cloud public tel que AWS, Google Cloud ou Microsoft Azure. Cette automatisation se fait de manière agile, ce qui laisse plus de temps aux développeurs et aux administrateurs de se focaliser sur d’autres tâches.

Revenons un peu sur son origine

Kubernetes a été créé par des développeurs de Google en 2014. Son nom vient du mot grec signifiant pilote et on l’appelle également K8s, 8 faisant référence au nombre de mots se trouvant entre K et s.

C’est un projet inspiré de l’outil qu’utilise Google pour effectuer du clustering et gérer les workloads appelé Borg. À partir de cet outil de base, ils ont développé Kubernetes à l’aide du langage Go.

La première version est apparue en 2015 et nous en sommes actuellement à la version 1.23. En même temps que la parution de la première version de Kubernetes, Google a également créé la CNCF ou la Cloud Native Computing Foundation en partenariat avec la Fondation Linux.

Comment fonctionne-t-il ?

Avant de commencer, voici à quoi ressemble l’architecture globale de Kubernetes :

architecture-kubernetes

L’architecture d’un cluster de Kubernetes forme une relation maître/esclave, c’est-à-dire qu’il y a un composant principal qui contient le plan de contrôle et d’autres composants appelés nœuds qui forment les machines de calculs.

Plusieurs composants entrent en jeu dans le plan de contrôle. Nous allons les voir dans la section suivante.

Les nœuds peuvent être répartis sur plusieurs machines physiques ou virtuelles. Les nœuds contiennent les pods qui sont les plus petits composants de Kubernetes et dans lesquels on retrouve les applications conteneurisées.

Tous ces composants communiquent à l’aide de l’API de Kubernetes. C’est avec cette API que l’on peut créer, configurer et gérer un cluster. Elle possède son propre serveur qui va déterminer si la requête demandée par l’utilisateur est valide ou non. Ce serveur va également se charger de transmettre les demandes valides ou d’effectuer une action spécifique si ce n’est pas le cas.

Kubernetes se base sur l’état des clusters pour fonctionner. Pour cela, il vérifie l’état actuel et le compare à l’état souhaité par l’administrateur. Si ces derniers sont différents, Kubernetes va faire en sorte à ce que l’état devienne celui attendu. Ces spécifications sont définies dans un fichier YAML ou JSON que l’utilisateur exécute lors de la création d’un nœud. Ce sera cet état qui déterminera les tâches que devra effectuer le nœud, les ressources allouées à ces tâches ainsi que les images de conteneur à déployer.

Les composants de Kubernetes

Nous allons maintenant voir un à un les principaux composants de Kubernetes.

Kubernetes node

Un node est là où sont placées toutes les charges de travail dans Kubernetes, c’est-à-dire qu’il exécute les tâches que le plan de contrôle lui assigne. Un nœud peut être une machine physique ou virtuelle et les nœuds peuvent se trouver sur un même emplacement ou non. Un cluster est l’appellation que l’on donne à un ensemble de nodes. Cependant, il peut ne contenir qu’un seul node si les ressources sont limitées. C’est à l’intérieur d’un node que l’on retrouve les pods, mais il contient également d’autres composants qui sont le Kubelet, Kubernetes CRI et Kube-proxy. Nous allons voir ces composants un à un dans les sections qui suivent.

Kubernetes pod

Le composant où l’on retrouve les conteneurs est appelé Pod. Un pod peut contenir un ou plusieurs conteneurs censés fonctionner ensemble. Le groupe de conteneurs possède ses propres ressources, un système de stockage partagé ainsi que des paramètres d’exécution des conteneurs. Mis à part les conteneurs des applications, il peut également embarquer un conteneur d’initialisation permettant justement de définir les spécifications de démarrage du pod.

Kubelet

Kubelet est un agent qui s’assure que le node fonctionne parfaitement. Pour cela, il vérifie si chaque conteneur s’exécute sans aucun souci et il regarde l’état de santé de chaque conteneur en exécution. Il communique ensuite les informations qu’il obtient au plan de contrôle.

Kubernetes container runtime

Comme son nom laisse entendre, le container runtime est un logiciel se trouvant à l’intérieur de Kubernetes permettant de lancer les conteneurs. Il existe plusieurs types d’exécuteurs de conteneur comme par exemple containerd et toutes les implémentations de Kubernetes Container Runtime Interface (Kubernetes CRI) telles que CRI-O.

Kube-proxy

Kube-proxy est le réseau proxy qui maintient les règles de réseau de chaque node et qui implémente une partie de Kubernetes Services. Ce sont ces règles qui permettent la communication entre les nodes et le reste du cluster, mais également ses relations avec l’extérieur. Il s’appuie sur la couche de filtrage du système d’exploitation s’il existe et dans le cas contraire, il effectue lui-même l’expédition des paquets et gère lui-même le trafic.

Kubernetes Services

Un service, également appelé microservice, est une méthode qui définit un ensemble de nodes et le moyen d’y accéder. Dans Kubernetes, les pods reçoivent chacun dynamiquement une adresse IP et un nom DNS uniques. Cependant, pour maintenir l’état souhaité, un ensemble de pods peut être créé et détruit à tout moment. Cela pose un problème aux autres pods qui consomment ceux qui opèrent des changements et c’est là qu’un service entre en jeu. En effet, c’est lui qui s’occupera de connecter les pods dits frontend aux pods backends.

Un service est un objet REST, c’est-à-dire que l’on utilise des API pour le définir et communiquer avec lui. Le nom d’un service doit correspondre à un label RFC 1035 valide.

Kubectl

Kubectl est une interface de ligne de commande vous permettant d’interagir avec le plan de contrôle d’un cluster Kubernetes. Pour fonctionner, il fait référence à un fichier config fourni par défaut par Kubernetes qui se situe dans le répertoire $HOME/.kube. Cependant, vous pouvez spécifier d’autres fichiers de configuration nommés kubeconfig pour par exemple paramétrer les variables d’environnement.

Voici la structure de base de la syntaxe de kubectl :

kubectl [commande] [ressource] [nom_de_la_ressource] [flags]

où :

  • command est la commande à exécuter c’est-à-dire la requête que vous souhaitez soumettre ;
  • ressource spécifie le type de la ressource que vous sollicitez ; la ressource est insensible à la casse et il existe plusieurs manières de le mentionner : soit en tapant le nom entier de la ressource (en singulier ou au pluriel) ou son abréviation ;
  • nom_de_la_ressource permet de spécifier la ressource avec laquelle vous voulez interagir. Ce paramètre est sensible à la casse donc il faut mentionner le nom exact de la ressource. S’il n’est pas spécifié, la commande affichera toutes les ressources du même type présentes sur votre cluster. On peut mentionner plusieurs noms sur une même commande ou bien plusieurs noms de ressources différentes, mais dans ce cas, il faut également donner le type de ressource ;
  • flags sont des paramètres supplémentaires et optionnels qui vous permettent de préciser un peu plus le résultat que vous souhaitez obtenir.

Si vous souhaitez connaître toutes les commandes kubectl disponibles et les différents types de ressources, vous pouvez vous rendre sur la documentation officielle de Kubernetes. Toutefois, voici quelques commandes qui sont les plus souvent utilisées :

  • kubectl get : vous permet de lister des ressources. Vous pouvez choisir d’obtenir une ressource en spécifiant son nom ;
  • kubectl describe : sert à obtenir les détails d’un ou plusieurs ressources ;
  • kubectl delete : supprime un ou plusieurs ressources. Vous pouvez spécifier le nom de la ressource ou un fichier, une ressource selector ou un label selector qui donne les ressources à supprimer. Vous avez également la possibilité de supprimer toutes les ressources du même type en ajoutant le mot-clé –all après le paramètre [ressource] ;
  • kubectl exec : exécute une commande sur un conteneur dans un pod ;
  • kubectl logs : affiche les logs d’un conteneur dans un pod.

Nous allons voir en détail l’utilisation de ces commandes, d’autres commandes, mais également l’installation de kubectl dans la partie tutoriel.

Kube-controller-manager

Il s’agit d’un daemon, c’est-à-dire un programme tournant en arrière-plan, qui lance des boucles de contrôle dans Kubernetes. Kube-controller-manager sert entre autres à surveiller l’état partagé d’un cluster et d’adapter ce dernier à l’état souhaité. Il existe plusieurs Kube-controller-manager tel que le contrôleur de namespace, le contrôleur de réplication ou encore le contrôleur de points de terminaison.

Cloud-controller-manager

Ce composant est celui qui vous permet de lier votre cluster à un service cloud, qu’il soit public, privé ou hybride. Cette liaison se fera par le biais de l’API du fournisseur cloud, ce qui vous permet de séparer les composants utilisés par celui-ci à ceux utilisés uniquement sur le cluster Kubernetes. Le but est de laisser les deux plateformes évoluer selon leurs propres rythmes sans que l’une n’altère les fonctionnalités de l’autre.

Cloud-controller-manager peut être inclus à toutes les plateformes de cloud qui satisfont le cloudprovider.Interface. Pour cela, ils utilisent un mécanisme de plug-in facilitant l’intégration de leurs environnements à celui de Kubernetes.

Tout comme kube-controller-manager, cloud-controller-manager constitue un ensemble de boucles de contrôle tel que le node controller, le services controller et le route controller. On peut même comparer les deux, car la différence est que l’un opère sur un environnement local et l’autre sur le cloud.

Kube-scheduler

Kube-scheduler est le plan de contrôle qui attribue les pods à un node. Pour ce faire, il identifie les nodes disposant de ressources et assigne un pod de la file d’attente en fonction de cette dernière et d’autres contraintes. Il s’assure que chaque pod soit mis dans le bon node afin que kubelet puisse l’exécuter.

Kube-apiserver

Kube-apiserver est le composant permettant d’exposer les API Kubernetes. Il fournit la partie frontend du plan de contrôle ainsi que les opérations REST. C’est également à lui de valider et de configurer les données pour les objets tels que les pods, les contrôleurs ou encore les services.

Kubernetes Ingress

Ingress permet de donner l’accès d’un service au sein d’un cluster de l’extérieur. Pour cela, il expose les routes HTTP et HTTPS dont le contrôle est soumis à des règles spécifiées par une ressource. Il permet également de créer des URLs avec le certificat SSL/TLS et le système de load balancing nécessaires pour que des services soient accessibles de l’extérieur. Pour qu’il effectue ces tâches, Ingress a besoin d’un composant appelé Ingress-controller qu’il faut lancer manuellement, car il n’est pas compris dans l’installation de base.

kubernetes-ingress

L’image ci-dessus montre une manière simple d’envoyer un trafic vers un service via Ingress.

Autres composants et outils utiles

Kubernetes etcd

Etcd est un magasin de stockage de données hautement disponible orienté clé/valeur pour stocker les données de sauvegarde des clusters Kubernetes. Si l’on souhaite opter pour cet outil pour sauvegarder ces données, il faut disposer d’un plan de sauvegarde. Il existe deux solutions pour l’installer. Vous pouvez passer par la pré-build en ajoutant le fichier bin présent dans la version que vous aurez téléchargée à l’emplacement où vous souhaitez utiliser etcd. Vous pouvez également l’installer directement à partir de la source principale en utilisant quelques instructions en ligne de commande.

Si vous souhaitez en savoir plus sur Kubernetes etcd, vous pouvez voir la documentation officielle d’etcd.

Helm

Helm est l’outil recommandé par Kubernetes pour vous aider à gérer vos applications. Il s’agit d’un package manager qui permet non seulement de gérer les applications dans un cluster, mais également de les déployer. Il effectue cette gestion via ce que l’on appelle un chart. Helm gère également le système de versionning de votre application en facilitant la mise à niveau et le roll-back de cette dernière.

Avant la version 3, Helm était composé de deux parties : la partie serveur appelée Tiller et une partie cliente. Mais, dès que cette version est apparue, Helm ne contient plus que le côté client qui gère directement vos applications Kubernetes.

Helm fournit une interface de ligne de commande et voici quelques commandes de base que l’on utilise pour cela :

helm install my-chart

Permet de créer un chart appelé my-chart ;

helm delete version1 

Supprime la version appelé version1 de Kubernetes ;

helm ls

Affiche la liste des charts présents sur un cluster.

Operators

Les operators sont des contrôleurs personnalisés qui vous permettent d’empaqueter, de déployer et de gérer des applications Kubernetes. Ils étendent les fonctionnalités que proposent les API Kubernetes et les outils Kubectl qui sont fournis de base. En utilisant des operators, on a la possibilité d’automatiser complètement les tâches relatives aux applications Kubernetes. Pour cela, ils ajoutent leurs propres instructions aux contrôleurs et aux services déjà présents dans Kubernetes.

Kubernetes Dashboard

Il s’agit d’une interface graphique sous forme d’application web vous permettant de gérer Kubernetes de manière plus interactive. Elle fournit des outils qui vous aident à déployer vos applications conteneurisées, de gérer vos clusters ainsi que leurs ressources. Le dashboard vous donne également une vue d’ensemble sur les applications en cours d’exécution sur vos clusters ainsi que sur l’état des ressources de ces derniers.

kubernetes-dashboard

Kubernetes Dashboard n’est pas installé par défaut sur Kubernetes. Pour ce faire, il faut lancer la commande Kubectl suivante :

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/master/aio/deploy/recommended.yaml

Kubernetes crictl

C’est un outil qui vous permet d’inspecter et de débugger une application ou un code Kubernetes. Il s’agit d’une interface de ligne de commande et sa source est stockée dans le répertoire cri-tools.

Kubernetes crictl ne marche cependant que sur Linux disposant d’un CRI Runtime. Pour y avoir accès, il vous suffit de télécharger la version compatible à celle du Kubernetes installé sur votre environnement de travail.

Minikube

Minikube est l’outil que vous allez utiliser si vous souhaitez lancer Kubernetes en local pour votre apprentissage. C’est d’ailleurs celui que nous allons utiliser dans le tutoriel qui va suivre. Il s’agit d’un outil simple et léger qui vous permet de simuler le fonctionnement d’un cluster Kubernetes dans une seule machine. Vous pouvez donc l’utiliser pour déployer vos applications conteneurisées à base d’images Docker par exemple.

Il fonctionne sur MacOS, Linux et Windows et tout ce dont vous avez besoin est de l’installer, d’installer un hyperviseur et de disposer d’une application conteneurisée pour vos tests.

Nous allons voir comment l’installer et l’utiliser dans la partie tutoriel que nous allons voir un peu plus bas.

Kubeadm

Kubeadm est le composant qui vous permet de créer et de gérer un cluster Kubernetes simple, mais déjà fonctionnel et ressemblant à un environnement de production. Il vous donne la possibilité de tester pour la première fois Kubernetes en production et de créer vos premiers clusters. Il offre également d’autres fonctionnalités comme la gestion des bootstrap tokens, les mises à niveau ou les rétrogradations.

Pour pouvoir l’installer et l’utiliser, il vous faut une ou plusieurs machines physiques ou virtuelles ainsi que quelques spécificités de ces machines.

Pourquoi utiliser Kubernetes ?

Conteneur vs Machine virtuelle

Avant de comprendre l’utilité de Kubernetes, il faut d’abord comprendre l’importance des conteneurs dans le déploiement de nos applications actuelles.

docker-vs-container

Avant, pour déployer une application, nous avons eu tendance à mettre en place une machine virtuelle afin de l’isoler. Mais comme vous pouvez le constater sur l’image ci-dessus, monter l’architecture d’une VM comporte plusieurs composants, ce qui veut dire que les ressources dont elle a besoin sont importantes.

Par contre, depuis l’adoption des systèmes de conteneurisation, la consommation de ressource a diminué considérablement sans altérer la performance des applications.

La question de la pertinence des conteneurs étant réglée, voyons l’importance de l’utilisation de Kubernetes au sein de ces systèmes.

Maintenant, si vous ne disposez que d’une seule application conteneurisée, vous ne rencontrerez aucun souci, ni au niveau de la performance, ni pour la gestion des ressources ou du conteneur lui-même. Mais à partir du moment où le nombre de conteneurs que vous devez déployer augmente, le nombre de points à prendre en compte augmente également. C’est là que Kubernetes entre en jeu, puisque c’est, comme nous l’avons vu dans la définition, un outil d’orchestration des applications conteneurisées.

Alors, pourquoi Kubernetes ?

Tout d’abord, la première raison d’utiliser Kubernetes est l’automatisation de nombreuses tâches qu’il offre. C’est lui qui gère les ressources allouées à chaque nœud et pod. Il vérifie l’état de ces derniers et fait en sorte à ce qu’ils soient toujours fonctionnels. Les données sont persistées pendant tout le cycle de vie du conteneur et les pods peuvent être répliqués autant de fois que l’on souhaite afin d’offrir une haute disponibilité à l’application. Kubernetes gère également les mises à jour des applications et permet de revenir à une ancienne version en cas de problèmes.

Tout cela offre un gain de temps considérable, car il permet aux développeurs de se concentrer sur d’autres tâches autres que de penser à l’architecture qui va héberger leurs applications. En plus, cela réduit le coût de la mise en production, mais également permet d’obtenir un environnement très flexible.

Ensuite, Kubernetes est multiplateforme, il fonctionne sur de nombreux types de systèmes, que ce soit en local ou sur le cloud. Plusieurs fournisseurs cloud et systèmes d’exploitation sont déjà compatibles avec lui et sa mise en place sur ces plateformes est assez facile. L’avantage d’utiliser ce genre d’outil est que l’on peut basculer d’un environnement à l’autre sans avoir à refaire tout le travail.

Avec Kubernetes, la sécurité de vos applications est garantie, d’une part grâce au réplicat des conteneurs et d’autre part grâce à la limitation des interventions humaines au sein de l’architecture réduisant donc les fausses manipulations.

Et enfin, il s’agit d’un outil open source maintenu par Google et doté d’une communauté très active. En cas de soucis, vous aurez l’assurance de trouver la solution adéquate, soit dans la documentation, soit à travers les forums de discussion.

Kubernetes vs Docker Swarm

Si vous utilisez Docker comme plateforme de conteneurisation d’application, vous savez qu’il possède son outil d’orchestration qui est Docker Swarm. Docker Swarm est préinstallé avec Docker et il permet de gérer les applications conteneurisées présentes dans chaque nœud de cluster. Il gère également les ressources attribuées à ce dernier et agit en tant qu’équilibreur de charges auprès des requêtes qui y circulent.

L’avantage de Docker Swarm est qu’il est facile à appréhender si l’on débute dans l’orchestration de conteneurs, car il ne nécessite aucune autre configuration et est accessible via le CLI de Docker. Cependant, il est assez limité au niveau des fonctionnalités qu’il prend en charge et de sa capacité d’automatisation, contrairement à Kubernetes.

Nous avons déjà vu les raisons qui peuvent pousser à utiliser Kubernetes dans la section précédente. Il est donc évident qu’il est la solution la plus adéquate si l’on souhaite mettre en place un système d’orchestration d’applications conteneurisées complet et complètement autonome. Par contre, comme toute technologie, il possède également quelques points faibles, notamment au niveau de son appréhension. En effet, cet outil nécessite l’apprentissage de la technologie même, car il dispose de ses propres composants, utilise ses propres syntaxes de code et suit sa propre logique. Si l’on ne sait pas le manipuler, il peut s’avérer assez complexe et peut entraîner quelques problèmes de performance et de productivité.

Avant de choisir entre ces deux plateformes, vous devez tout d’abord prendre en compte vos besoins et le projet que vous souhaitez entreprendre. Si l’architecture de votre cluster est simple et peu évolutive, vous pouvez choisir Docker Swarm. Mais si vous envisagez d’élaborer une architecture plus complexe et que vous souhaitez obtenir une solution performante qui vous permet d’automatiser le plus de tâches possible, foncez vers Kubernetes.

Tutoriel : premier pas avec Kubernetes

Pour un premier test, nous n’allons pas utiliser plusieurs clusters, mais seulement un à l’aide de notre propre machine physique. Pour cela, il faut suivre les étapes décrites dans les sections qui suivent. Alors, commençons !

Installer Kubectl

Le premier outil que vous devez installer est Kubectl, car ce sera à partir de cet outil que l’on pourra saisir les commandes que nous allons utiliser. Ici, nous allons décrire la manière de l’installer pour Linux, MacOS et Windows.

Pour Linux

Il existe plusieurs façons d’installer Kubectl sur Linux, mais la plus simple est de l’effectuer avec curl. D’abord, il faut le télécharger à l’aide de la commande suivante :

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

Ensuite, il faut l’installer en tapant la commande :

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

Et voilà, Kubectl est disponible sur votre machine !

Pour MacOS

Si vous utilisez MacOS, vous avez également la possibilité de choisir entre plusieurs options d’installation de Kubectl.

La première option est d’utiliser Curl, comme c’est le cas avec Linux. Dans ce cas, la commande à exécuter dépend de la puce embarquée dans votre machine (Intel ou M1).

Cependant, les deux options suivantes sont les plus simples : soit vous effectuer l’installation avec Homebrew en tapant l’une des commandes suivantes :

brew install kubectl

ou

brew install kubernetes-cli

Soit vous lancer l’installation avec Macport en utilisant les commandes suivantes :

sudo port selfupdate
sudo port install kubectl

Pour Windows

Pour Windows, nous allons commencer par télécharger le fichier exécutable à partir du lien mentionné ici.

installer-kubernetes-windows

Une fois le téléchargement terminé, copiez le fichier obtenu dans un nouveau dossier que nous allons par exemple appeler Kubernetes.

Placez ensuite le chemin du dossier dans le Path de la variable d’environnement de votre système.

Note : Si vous avez Docker Desktop installé sur votre machine, assurez-vous que le lien de Kubernetes passe avant celui de Docker, car ce dernier intègre également une version de Kubectl.

path-kubernetes

Maintenant, vous pouvez tester si Kubectl est bel et bien présent sur votre machine en tapant cette commande (valable sur tous les systèmes) :

kubectl version --client
kubectl-version

Installer Minikube

Puisque nous sommes sur un environnement de test, nous allons utiliser Minikube. Voici les étapes à suivre pour l’installer suivant le système d’exploitation que vous utilisez.

Pour Linux

Il existe plusieurs manières d’installer Minikube sur un système d’exploitation Linux, mais ici, nous allons nous servir de curl.

Pour ce faire, il faut exécuter les commandes suivantes :

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

Et voilà, le tour est joué, vous avez maintenant Minikube installé sur votre machine.

Pour MacOS

Pour MacOS, vous pouvez effectuer cette installation à l’aide de curl ou de Homebrew. Nous allons, comme pour Linux, utiliser curl dans ce tutoriel. La commande à exécuter dans ce cas est la suivante :

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64
sudo install minikube-darwin-amd64 /usr/local/bin/minikube

Pour Windows

Avant d’installer Minikube sur Windows, vous avez besoin d’un hyperviseur. Si vous utilisez Windows 10 Professionnel, Windows 10 Enterprise ou Windows 10 Education ou Window 11, il existe déjà un hyperviseur par défaut nommé Hyper-V. Pour l’activer, il faut aller dans les fonctionnalités de Windows et cocher la case correspondant à cela.

activer-hyperv

Si vous ne souhaitez pas utiliser Hyper-V, vous pouvez également opter pour d’autres hyperviseurs tel que Virtual Box.

Une fois l’un de ces outils est prêt à l’emploi, vous pouvez procéder à l’installation de Minikube.

La manière la plus simple de procéder est d’utiliser Chocolatey. Pour ce faire, lancez la commande suivante sur votre invite de commande (il faut que cmd soit ouvert en tant qu’administrateur) :

choco install minikube
installer-minikube

Pour vérifier que Minikube est bien installé, tapez la commande suivante :

minikube start --vm-driver=

où <nom_du_driver> est le nom en minuscule de l’hyperviseur que vous avez utilisé.

minikube-start

Cette commande sert à démarrer un cluster Kubernetes local. Pour vérifier si votre cluster marche parfaitement, vous pouvez vérifier son statut en utilisant la commande suivante :

minikube status

Si tout s’est bien passé, le résultat devrait ressembler à ceci :

minikube-status

Maintenant que tout est en place, passons maintenant à l’application.

Note : Dans le reste de ce tutoriel, nous allons utiliser Kubernetes sur le système d’exploitation Windows.

Créer une image Docker

Avant tout, il faut que l’on ait à notre disposition une application conteneurisée à démarrer. Ici, nous allons utiliser Docker pour l’obtenir. Pour cela, il faut créer une image Docker à l’aide d’un dockerfile. Reprenons l’image que nous avons utilisée dans notre article sur Docker. La base de l’application que nous allons utiliser se trouve ici.

Nous allons reproduire les étapes réalisées dans cet article à savoir copier le dossier app de ce projet, ouvrir ce dossier dans un éditeur de texte et créer notre Dockerfile en y ajoutant les instructions ci-dessous :

FROM node:12-alpine
RUN apk add --no-cache python2 g++ make
WORKDIR /app
COPY . .
RUN yarn install --production
CMD ["node", "src/index.js"]
EXPOSE 3000
dockerfile

Il faut également créer un fichier .dockerignore comme ceci :

dockerignore

L’image est maintenant prête à être construite, mais avant de le faire, il faut régler un dernier détail que nous allons voir dans la prochaine section.

Créer un déploiement d’un pod

Configurer les variables d’environnement Docker

Avant de créer le déploiement, nous devons nous assurer que l’environnement local Docker est bien configuré dans Minikube. Pour cela, en utilisant Git Bash, nous allons nous positionner au niveau de notre projet Docker (le dossier app où se trouve le dockerfile) et lancer la commande suivante :

echo $(minikube docker-env)
echo-minikube-docker-env

Pour activer ces variables d’environnement, nous allons exécuter la commande suivante :

eval $(minikube docker-env)
eval-minikube-docker-env

Note : Si vous êtes sur Linux, vous n’aurez pas besoin d’utiliser Git Bash pour cette étape.

Construire l’image Docker

Une fois que vos variables d’environnement sont configurées, il faut maintenant créer l’image Docker à l’intérieur de Minikube lui-même. Pour cela, exécutez la commande suivante :

docker build . -t mon-image
docker-build-image

Ensuite, puisque l’environnement est prêt, nous allons procéder au déploiement d’un pod Kubernetes. Il y a deux façons d’effectuer cela : soit en créant un fichier YAML ou JSON, soit en lançant directement une commande kubectl qui va créer le déploiement à partir de l’image que l’on vient de créer.

Créer un déploiement d’un pod à partir d’un fichier

Pour la première option, la meilleure manière de procéder est de passer par le tableau de bord Kubernetes. La commande suivante va ouvrir ce dashboard :

minikube dashboard
minikube-dashboard

Le résultat de cette commande est comme ceci :

minikube-dashboard-int

Comme vous pouvez le constater, il n’y a aucun pod en cours d’exécution pour le moment. Pour notre test, nous allons créer un déploiement à partir d’un podTemplate. Il s’agit d’un ensemble de spécifications de base présent dans les charges de travail tels que Deployement, Jobs ou encore DaemonSets.

Pour ce faire, cliquez sur le bouton “+” en haut à gauche du dashboard de Minikube. Ensuite, copiez les instructions suivantes sur l’éditeur de texte :

apiVersion: batch/v1
kind: Job
metadata:
  name: hello
spec:
  template:
    spec:
      containers:
      - name: hello
        image: busybox:1.28
        command: ['sh', '-c', 'echo "Hello, Kubernetes!" && sleep 3600']
      restartPolicy: OnFailure
minikube-yaml

Cliquez ensuite sur le bouton “Télécharger”. Vous verrez sur votre dashboard que votre premier pod vient d’être créé automatiquement par Minikube.

premier-pod-minikube

Créer un déploiement d’un pod à partir d’une commande

Dans ce cas-ci, nous allons utiliser l’image Docker que nous avons créé un peu plus haut. Pour créer le déploiement de notre pod, nous allons lancer la commande suivante :

kubectl create deployment mon-deploiement --image=mon-image
kubectl-create-deployment

Ici, la commande de base est kubectl create deployment. mon-deploiment est le nom que l’on a donné au déploiement. La dernière instruction à savoir –image=mon-image sert à spécifier l’image Docker que l’on souhaite déployer. Souvenez-vous, nous avons renommé notre image de cette manière.

Afficher les déploiements et les pods

Maintenant que vous savez créer un déploiement d’un pod, il faut tout de même vérifier s’il a vraiment été créé. Pour cela vous pouvez lancer la commande suivante pour afficher les déploiements :

kubectl get deployments
kubectl-get-deployment

Ou exécuter la commande suivante pour afficher la liste des pods :

kubectl get pods
kubectl-get-pods

Comme vous pouvez le constater, la première commande que nous avons exécutée affiche un seul résultat. La raison est que nous n’avons lancé qu’une seule commande de création de déploiement. Souvenez-vous, nous avons créé un pod à partir du dashboard. Le déploiement de celui-ci a été généré automatiquement par Minikube, d’où le résultat que nous obtenons dans la deuxième commande.

Exécuter le pod

Si vous regardez bien le résultat qui est affiché lorsque nous avons exécuté la commande kubectl get pods, vous remarquez que le pod mon-deploiement n’est pas en cours d’exécution, car il y a une erreur. Pour remédier à cela, lancez minikube dashboard, cliquez sur le bouton à droite du pod puis cliquez sur Éditer. Un éditeur contenant le fichier YAML de votre déploiement va s’afficher. Modifiez la section ImagePullPolicy en écrivant ImagePullPolicy: IfNotPresent

imagepullpolicy

Cliquez ensuite sur Mettre à jour et vous verrez que votre pod s’activera.

pods-dashboard

Vous pouvez également exécuter la commande kubectl get pods pour vérifier cela.

kubectl-get-pods-2

Permettre les accès externes

Pour que notre pod soit accessible de l’extérieur, il faut l’exposer à un port. Pour cela, on va utiliser un service appelé NodePort en lançant la commande suivante :

kubectl expose deployment mon-deploiement –-type=NodePort --port=3000
kubectl-expose-deployment

mon-deploiement est le nom que nous avons donné à notre déploiement. La valeur du paramètre –port spécifie le port que nous voulons mapper à savoir celui de notre application. Nous avons spécifié ce port lors de la création de notre Dockerfile.

Pour afficher notre service, il faut lancer la commande :

kubectl get service mon-deploiement
kubectl-get-service

Et pour obtenir plus de détails, exécutez celle-ci :

kubectl describe service mon-deploiement
kubectl-describe-service

Maintenant, pour accéder à notre application via ce service, il faut que nous exécutions la commande suivante :

minikube service mon-deploiement

Votre navigateur s’ouvrira automatiquement et lancera votre application.

Si ce n’est pas le cas, vous pouvez également lancer la commande :

minikube service mon-deploiement --url
minikube-service

Cette commande va afficher l’url à partir duquel vous pouvez accéder à l’application. Il vous suffit de copier cette url sur un navigateur et vous verrez que l’application s’ouvrira.

app-test

Note : Assurez-vous que votre port soit exposé à l’extérieur avant de lancer l’application. Pour ce faire, ajoutez une règle au niveau de votre pare-feu Windows.

Consulter les logs

Lors de votre apprentissage, il se peut que vous rencontriez quelques erreurs. Pour connaître leurs origines, vous avez la possibilité de consulter les logs qui vous détaillent l’exécution de votre pod. Pour illustrer cela, regardons par exemple les logs du pod contenant l’application que nous venons d’exécuter. Tout d’abord, récupérons le nom du pod en lançant la commande :

kubectl get pods

Ensuite, il faut exécuter la commande suivante une fois que vous avez identifié le nom du pod :

kubectl logs 
kubectl-logs

Comme vous pouvez le constater, il n’y a pas d’erreur détectée au niveau de notre pods. Mais dans le cas contraire, il affichera des informations concernant les erreurs rencontrées ainsi que leurs potentielles origines.

Supprimer un service et un déploiement d’un pod

Nous arrivons presque à la fin de ce premier pas avec Kubernetes. Donc pour bien terminer notre apprentissage, nous allons apprendre à supprimer un service, puis un déploiement d’un pod.

Pour supprimer un service, il vous suffit de lancer la commande :

kubectl delete service 

Et pour supprimer un déploiement, il faut lancer la commande :

kubectl delete deployment 

Arrêter Minikube

Si vous avez terminé vos tâches sur Minikube et que vous souhaitez l’arrêter, vous n’avez qu’à lancer la commande suivante :

minikube stop

Vous pouvez le relancer à tout moment en lançant la commande que nous avons vue au tout début de ce tutoriel.

Supprimer Minikube

Il existe également une commande pour supprimer Minikube de votre machine et c’est la suivante :

minikube delete  [flag]

Les valeurs que peuvent prendre [flag] sont les suivantes :

  • –all pour supprimer Minikube ainsi que tous les profils ;
  • -o pour afficher stdout ;
  • –purge pour également effacer le dossier d’installation.

Kubernetes en production

Ce que nous venons de voir est ce qui se passe lors d’un test d’utilisation de Kubernetes. Cependant, pour un environnement de production, il y a d’autres paramètres à prendre en compte.

En effet, cette fois-ci, puisque l’objectif est d’obtenir un environnement sécurisé, hautement disponible et possédant une capacité importante en termes de ressource, il faut bien étudier les besoins et agir en conséquence.

Tout d’abord, il faut que vous voyiez le nombre de clusters et de nœuds dont vous aurez besoin. Vous devez gérer l’accès à votre plateforme ainsi que la disponibilité des ressources adéquates. Ce sera également à vous de voir l’emplacement où vous souhaitez déployer vos applications conteneurisées, qu’il s’agisse d’un environnement local ou le cloud.

Une fois que vous avez identifié vos besoins, vous devez maintenant établir un plan de contrôle conforme à ces demandes. Ce plan de contrôle doit prendre en compte les informations concernant :

  • Le choix de l’outil de déploiement, que ce soit kubeadm, kubespray ou kops ;
  • Les certificats nécessaires pour la sécurité des communications entre les services ;
  • Les équilibreurs de charges à mettre en œuvre, notamment pour l’apiserver ;
  • La sécurité des données en mettant en place des services etcd séparés et de secours ;
  • La sécurité du plan de contrôle en le dupliquant ;
  • La vérification de chaque fonctionnalité afin de maintenir l’état souhaité de chaque cluster.

Et voilà, nous arrivons à la fin de cet article sur Kubernetes. Comme nous l’avons vu dans cet article, Kubernetes est un outil vraiment important si l’on souhaite déployer des applications conteneurisées. En effet, si le nombre de ces dernières est important et que l’architecture est évolutive, utiliser Kubernetes devient nécessaire. Maintenant, vous savez comment créer un cluster avec ses composants et vous en servir pour vos projets.

Si vous souhaitez apprendre davantage sur le Big Data et la programmation informatique, nous vous invitons à télécharger cette formation sur le langage Scala.


Juvénal JVC

Juvénal est spécialisé depuis 2011 dans la valorisation à large échelle des données. Son but est d'aider les professionnels de la data à développer les compétences indispensables pour réussir dans le Big Data. Il travaille actuellement comme Lead Data Engineer auprès des grands comptes. Lorsqu'il n'est pas en voyage, Juvénal rédige des livres ou est en train de préparer la sortie d'un de  ses livres. Vous pouvez télécharger un extrait de son dernier livre en date ici : https://www.data-transitionnumerique.com/extrait-ecosystme-hadoop/

>