<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Regis Sochard on Medium]]></title>
        <description><![CDATA[Stories by Regis Sochard on Medium]]></description>
        <link>https://medium.com/@regis.sochard?source=rss-216b6e0f84a1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*TH7pxdwU6nPzklsnlOzsfg.jpeg</url>
            <title>Stories by Regis Sochard on Medium</title>
            <link>https://medium.com/@regis.sochard?source=rss-216b6e0f84a1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 12:42:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@regis.sochard/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[KubeVirt, un outil de transformation et de transition d’applications « legacy » sur VM vers du…]]></title>
            <link>https://medium.com/@regis.sochard/kubevirt-un-outil-de-transformation-et-de-transition-dapplications-legacy-sur-vm-vers-du-1f2d30684667?source=rss-216b6e0f84a1------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f2d30684667</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[kubevirt]]></category>
            <dc:creator><![CDATA[Regis Sochard]]></dc:creator>
            <pubDate>Fri, 12 May 2023 14:26:47 GMT</pubDate>
            <atom:updated>2023-06-30T12:29:33.016Z</atom:updated>
            <content:encoded><![CDATA[<h3>KubeVirt, un outil de transformation et de transition d’applications « legacy » sur VM vers du Cloud Native sur Kubernetes ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-XpJyWdN9xYS7QJus0lvBg.png" /></figure><h3>La problématique</h3><p>Vous souhaitez adopter Kubernetes et migrer votre application « legacy » qui fonctionne sur des VMs vers des technologies de conteneurisation mais vous ne savez pas encore comment ni quelles peuvent être les étapes d’une telle transformation, tout en continuant de maintenir et de faire évoluer votre application actuelle ?</p><p>Au-delà du défi technique, toute transformation apporte son lot de difficultés liées à l’organisation et au changement, avec des questionnements tels que :</p><ul><li>Comment assurer la transition sans re-développer entièrement l’application ?</li><li>Comment assurer une cohabitation des deux applications durant cette transition ?</li><li>Comment faire monter en compétences l’ensemble des équipes sur ces nouvelles technologies sans mettre en danger l’application actuelle ?</li><li>Faut-il immédiatement mettre en place une équipe DevOps, si ce n’est pas encore le cas ?</li><li>La taille des équipes de développement et opérationnelle devra-elle doubler durant cette transition ?</li><li>…</li></ul><blockquote>Transformer, oui mais à quel prix ? Pourquoi ne pas tout re-développer et repenser l’architecture directement en une solution Cloud Native qui sera certainement plus ‘efficace’ et ‘maintenable’ (afin d’effacer directement cette « fameuse » dette technique qui existe depuis trop longtemps) ?</blockquote><blockquote>Généralement, il y a beaucoup de freins à faire cela, même si cette approche est souvent mise en avant par les personnes ‘techniques’. En effet, mes précédentes expériences en tant qu’architecte m’ont appris quelques leçons importantes sur ce sujet :</blockquote><blockquote>1. Pour des questions budgétaires, l’effort et les ressources pour refaire une application de zéro sont difficilement défendables auprès de la direction d’une entreprise.</blockquote><blockquote>2. Voir apparaître une seconde équipe de développement dédiée à de nouvelles technologies plus intéressantes risque fortement de créer des dissensions au sein même des développeurs, avec souvent un phénomène de rejet mutuel.</blockquote><blockquote>3. Et enfin, comment rattraper et gérer la mise à niveau de la nouvelle application, alors que l’ancienne continue de grandir en fonctionnalités ?</blockquote><blockquote>Tout ceci pour dire qu’il y a plus de chances que l’on vous demande de réaliser une transition/transformation, avec un véritable plan et une minimisation des risques et des efforts, que de tout refaire de zéro !</blockquote><p>Aussi, au travers de la présentation et de l’utilisation de <strong>Kubevirt</strong>, cet article essayera de répondre en partie à cette problématique. Le but ici, n’étant pas d’expliquer comment transformer une application « legacy » en une application plus moderne comme des microservices, mais de montrer que <strong>Kubevirt</strong> peut être un très bon outil pour faciliter la mise en œuvre de cette transformation.</p><h3>C’est quoi Kubevirt ?</h3><p>Créé en 2016 par RedHat, <strong>Kubevirt </strong>est un projet Open Source géré par la CNCF (Cloud Native Computing Foundation) depuis le 9 septembre 2019. À date, le numéro de version est le « 0.59.0 », ce qui est encore loin de la première version finale ‘stable’.</p><p>Au sein de la CNCF, le projet est au niveau de maturité « incubating », depuis avril 2022. Il s’agit de l’avant dernier niveau avant « graduated », mais il faut tout de même savoir que tous les projets, dès le niveau « incubating », sont considérés par la CNCF comme stables et peuvent être utilisés avec succès en production.</p><p>En effet, on verra plus tard que le nombre de fonctionnalités de <strong>Kubevirt</strong> est assez conséquent et permet une très bonne utilisation dès à présent.</p><p>Sur le site officiel de <a href="https://kubevirt.io/"><strong>Kubevirt</strong></a>, on y trouve la définition suivante :</p><blockquote>La technologie <strong>KubeVirt </strong>répond aux besoins des équipes de développement qui ont adopté ou souhaitent adopter Kubernetes mais qui possèdent des charges de travail existantes basées sur des machines virtuelles qui ne peuvent pas être facilement conteneurisées. Plus précisément, la technologie fournit une plate-forme de développement unifiée où les développeurs peuvent créer, modifier et déployer des applications résidant à la fois dans des conteneurs d’applications et des machines virtuelles dans un environnement commun et partagé.</blockquote><p>En résumé, <strong>Kubevirt</strong> permet à des machines virtuelles d’être déployées, consommées et gérées par Kubernetes comme des conteneurs. Le fait de disposer d’un plan de déploiement et de gestion unique pour les conteneurs et les machines virtuelles permet d’obtenir une plate-forme unifiée pour des applications Cloud Native, quelles que soient les exigences.</p><blockquote>« Pour couper court à toute idée un peu farfelue qui viendrait émerger dans votre cerveau, à la lecture de ces premières lignes, <strong>Kubevirt </strong>n’est pas un hyperviseur, même s’il utilise la technologie KVM dans ses conteneurs »</blockquote><p>Toujours d’après le site officiel de <strong>Kubevirt</strong>, les trois principaux avantages mis en avant, sont :</p><blockquote>1. Tirer parti de KubeVirt et Kubernetes pour gérer les machines virtuelles pour les applications difficiles à conteneuriser.</blockquote><blockquote>2. Combiner les charges de travail virtualisées existantes avec de nouvelles charges de travail de conteneur sur une seule plateforme.</blockquote><blockquote>3. Soutenir le développement de nouvelles applications de microservices dans des conteneurs qui interagissent avec les applications virtualisées existantes.</blockquote><p>C’est bien à partir de ces trois avantages que l’on va voir comment <strong>Kubevirt</strong> peut nous aider dans la mise en œuvre de la transformation d’une application « legacy » (basé sur des VMs) vers du Cloud Native.</p><p>Mais tout d’abord une présentation ‘rapide’ de l’architecture de <strong>Kubevirt</strong> pour comprendre un peu son fonctionnement.</p><h3>A quoi ressemble l’architecture de Kubevirt ?</h3><p>Je ne vais pas faire une description complète de l’architecture de <strong>Kubevirt</strong>, car celle-ci est très bien documentée sur le site officiel : <a href="https://kubevirt.io/user-guide/architecture/">https://kubevirt.io/user-guide/architecture/</a>.</p><p>Pour résumer, on peut représenter l’architecture de <strong>Kubevirt</strong> par le diagramme logique suivant :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_mffRDFrAzGICpon3im_xA.png" /></figure><p>Les utilisateurs nécessitant des services de virtualisation s’adressent à l’API de virtualisation (voir ci-dessous) qui, à son tour, s’adresse au cluster Kubernetes pour planifier les instances de machine virtuelle (VMI) demandées. La planification, la mise en réseau et le stockage sont tous délégués à Kubernetes, tandis que <strong>KubeVirt</strong> fournit uniquement la fonctionnalité de virtualisation (création et gestion des VMs).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/495/1*7xtUrG6JBFx7zA6N35Jjpg.png" /></figure><p><strong>Kubevirt</strong> utilise d’ailleurs la technologie d’hyperviseur KVM et inclut QEMU pour l’émulation de matériel, le tout aidé par Libvirt.</p><p>Pour définir son API de virtualisation, <strong>Kubevirt</strong> utilise des CRD (Custom Resource Definition) qui est une fonctionnalité d’extension de l’API Kubernetes.</p><blockquote>Mais c’est quoi des « CRDs » ? Une ressource est un point de terminaison dans l’API Kubernetes qui stocke une collection d’objets API d’un certain type ; par exemple, la ressource pods intégrée contient une collection d’objets Pod. Une ressource personnalisée est une extension de l’API Kubernetes qui n’est pas nécessairement disponible dans une installation Kubernetes par défaut. Il représente une personnalisation d’une installation Kubernetes particulière. Cependant, de nombreuses fonctions principales de Kubernetes sont désormais construites à l’aide de ressources personnalisées, ce qui rend Kubernetes plus modulaire. Les ressources personnalisées peuvent apparaître et disparaître dans un cluster en cours d’exécution via l’enregistrement dynamique, et les administrateurs de cluster peuvent mettre à jour les ressources personnalisées indépendamment du cluster lui-même. Une fois qu’une ressource personnalisée est installée, les utilisateurs peuvent créer et accéder à ses objets à l’aide de ‘kubectl’ ou au travers de l’API nouvellement défini, tout comme ils le font pour les ressources intégrées telles que les pods.</blockquote><p>Ainsi, au mettre titre que pour la gestion ‘native’ d’un POD/Conteneur au sein d’un cluster Kubernetes, <strong>Kubevirt</strong> définit, entre autres, les notions de VM, VMI et VMIRS:</p><ul><li>VM (Virtual Machine) est l’équivalent du Conteneur, soit un ‘packaging’ avec le programme à exécuter et toutes ses dépendances, telles que le code, le runtime, les bibliothèques système, etc…, liés ensemble. La VM peut être arrêtée et démarrée tout en conservant ses données et son état.</li><li>VMI (Virtual Machine Instance) est l’équivalent du POD, soit l’entité logique pour qu’une VM s’exécute en fonction de ses contraintes (CPU, RAM, affinité HW, …) via le scheduling et l’orchestration de Kubernetes.</li><li>VMIRS (Virtual Machine Instance Replica Set) est similaire aux ReplicaSet des PODs. Il s’agit d’un groupe de VMI éphémères avec une configuration similaire définie au travers d’un seul modèle.</li></ul><p>Bien sûr, il y a aussi les notions de ressources (“requests” et “limits”) pour le placement des VMs, tout comme la notion de HPA (Horizontal Pod Autoscaling) qui permet le scaling automatique des VMs selon certains critères (metrics) et d’autres fonctionnalités similaires à la gestion des Pods.</p><h4>Heu, ça commence à être trop technique, non ? Recentrons-nous sur notre sujet…</h4><h3>Alors comment utiliser Kubevirt pour aider à la transformation ?</h3><p>Pour réaliser cette transformation et la réussir avec toutes les contraintes d’une application qui est déjà à disposition des utilisateurs, il est inutile de vous dire qu’il va falloir le faire en plusieurs étapes.</p><h3>1. La création d’une nouvelle plateforme, basée sur un cluster Kubernetes</h3><p>La première étape consiste bien évidemment à mettre en place une nouvelle plateforme de déploiement et à <strong>créer votre cluster Kubernetes</strong>. Peu importe si celui-ci est hébergé On’Premise ou bien chez votre Cloud Provider préféré (AWS/EKS, GCP/GKE ou Azure/AKS), cela fonctionnera sans problème.</p><p>Pour ceux qui débutent avec ce nouveau type de plateforme il y aura forcément une phase d’apprentissage, essentiellement de l’équipe DevOps, pour permettre sa compréhension et sa maintenance opérationnelle. Il sera donc nécessaire <strong>d’allouer une partie de l’équipe à la formation et la mise en œuvre de Kubernetes</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MsreKRNy56WhJ0qXjV-_Ag.png" /></figure><p>Une fois que la maîtrise de l’environnement Cloud, de Kubernetes, de <strong>Kubevirt</strong> et des outils de CI/CD est acquise, l’équipe DevOps sera en mesure de migrer l’intégralité de l’application vers ce nouvel environnement, avec comme point de départ un cluster vide de tout conteneur, mais avec uniquement des VMs (gérés comme des conteneurs).</p><p>Il n’y a aucun besoin d’apporter des modifications logicielles (ou très peu, si l’infrastructure mise en œuvre avec le cluster Kubernetes est similaire à celle d’origine). Pendant tout ce temps, l’équipe de développement peut continuer de travailler pour maintenir et faire évoluer l’application « legacy » sans être perturbée par ce changement de technologie.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5irZkW0fivXv69uU5gOzkQ.png" /></figure><p>Dès cette première étape, il est à noter que notre application « legacy » bénéfice déjà de quelques avantages comme :</p><ul><li>Portabilité : KubeVirt permet d’exécuter des machines virtuelles sur des clusters Kubernetes, offrant ainsi la possibilité de déplacer facilement les VM vers d’autres clusters ou environnements Cloud.</li><li>Scalabilité : KubeVirt est conçu pour s’intégrer facilement aux clusters Kubernetes existants, permettant ainsi une évolutivité rapide et fluide. Les administrateurs peuvent ainsi ajouter ou supprimer des nœuds du cluster, et les machines virtuelles peuvent alors être facilement déployées ou retirées en fonction des besoins.</li><li>Sécurité : Les politiques de sécurité basées sur des étiquettes de KubeVirt permettent de renforcer la sécurité de l’infrastructure.</li><li>Surveillance et monitoring : Des outils de surveillance et de monitoring peuvent être intégrés pour garantir la disponibilité de l’application au travers d’outils éprouvés et facilement déployables sur le cluster Kubernetes, comme Prometheus/Grafana ou encore Elastic.</li></ul><p>Pendant ce temps et afin de préparer l’étape suivante, l’architecte et une partie de l’équipe de développement pourront commencer une analyse approfondie de l’architecture logicielle de l’application, dans le but d’identifier les fonctionnalités qui peuvent être extraites et conteneurisées.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Atl0HH0mB_Ix8s1UAUDAoQ.png" /></figure><h3>Organisation de l’étape 1 :</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*lIwNHBcmi5M-7IlVfCXCWg.png" /></figure><h3>2. Le début de la transformation : passage par la conteneurisation</h3><p>La deuxième étape marque la « véritable » transformation de l’application « legacy » en identifiant les parties de l’application (à l’intérieur des VMs) qui peuvent être conteneurisées.</p><p>Pour cela, on pourra par exemple utiliser une méthode de « pelage » (comme un oignon) des fonctions de l’application, afin d’en extraire petit à petit les différents services à conteneuriser, tout impactant au minimum le reste de l’application sur VMs.</p><p>Cette méthode permet d’extraire une partie des fonctionnalités en ajoutant uniquement un contrat d’interface entre la partie extraite (dans un conteneur) et le reste de l’application (sur la VM).</p><p>Ainsi, la fonctionnalité nouvellement extraite pourra être conteneurisée et donc faire partie intégrante du cluster Kubernetes de façon ‘native’.</p><blockquote>Ce n’est pas un peu simpliste ? Oui, la description de la phase de transformation est volontairement simplifiée car cet article ne traite pas directement de ce sujet, mais il est important de noter qu’une telle transition doit faire préalablement l’objet d’une étude approfondie de l’architecture de l’application « legacy ». Il est même tout à fait possible que des applications fonctionnant sur VMs, ne puissent pas faire l’objet d’une transformation d’architecture vers des microservices. Dans ce cas précis, la première étape est suffisante et apporte tout de même son lot d’améliorations.</blockquote><p>Cette deuxième étape ne s’applique pas uniquement à la transformation de l’existant mais peut aussi prendre en compte le développement des nouvelles fonctionnalités directement sous forme de conteneurs.</p><p>Avant toute modification d’architecture, l’équipe de développement, tout comme l’a fait l’équipe DevOps durant la première étape, devra aussi monter en compétences sur les technologies de conteneurisation et de cluster Kubernetes, afin de comprendre les impacts liés à leurs utilisations.</p><p>Enfin, l’ensemble des équipes (Développement, DevOps et Q&amp;A) devront travailler de concert, afin de définir les étapes de transformation avec les différents déploiements et tests supplémentaires qui devront forcément être réalisés, du fait du changement d’architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dOUmBwEPSHGUtvTpX-hR5g.png" /></figure><p>Une fois de plus, l’utilisation de <strong>Kubevirt</strong> apporte son lot d’avantages supplémentaires :</p><ul><li>Optimisation des ressources : En combinant des machines virtuelles et des conteneurs sur une même infrastructure, KubeVirt permet une utilisation plus efficace des ressources et une réduction des coûts.</li><li>Gestion centralisée et automatisation : Avec KubeVirt, les machines virtuelles peuvent être gérées et orchestrées de la même manière que les conteneurs Kubernetes, grâce à des fichiers de configuration déclarative. Cela permet une gestion centralisée et automatique de toutes les ressources de l’infrastructure, simplifiant ainsi les opérations de déploiement et de maintenance.</li></ul><p>Cette deuxième étape apporte surtout un avantage majeur : celui de maintenir et faire évoluer l’architecture de l’application « legacy » en douceur, sans avoir à mobiliser de nouvelles équipes dédiées à un développement ‘from scratch’. Les équipes déjà en place restent mobilisées et actrices du changement !</p><blockquote>Et la taille des équipes dans tout ça ? En fonction des demandes d’évolution de l’application « legacy », on augmentera de façon temporaire la capacité des équipes afin d’absorber cette charge, ainsi que celle liée à la transformation.</blockquote><blockquote>Une autre façon de faire, en accord avec le « Product Owner », est de ralentir le rythme des évolutions pour y inclure des releases de transformation (transparente pour le client).</blockquote><h3>Organisation de l’étape 2 :</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/955/1*DwA06dhjy-llA4yxdpxSqQ.png" /></figure><h3>Itinéraire bis !</h3><p>Une étape intermédiaire (ou étape bis) peut être envisagée, afin de minimiser encore un peu plus les risques liés à la transformation d’architecture. Au lieu de déployer les nouveaux services conteneurisés directement sur le cluster Kubernetes en tant que POD, il s’agira de les laisser au sein des VMs.</p><p>Cela permet temporairement d’enlever un niveau de complexité lié au déploiement des PODs/Conteneurs et à leur communication avec les VMs.</p><p>Il faudra tout de même faire attention aux performances de l’application qui pourraient être légèrement dégradées. Des mesures de performance seront nécessaires.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QTOIlhffV6z0OESxStnt6Q.png" /></figure><h3>3. Une application « full » Cloud Native</h3><p>Après plusieurs itérations de la deuxième étape et dans la mesure ou une transformation complète en conteneurisation a été effectuée (si l’architecture le permet), alors l’utilisation de <strong>Kubevirt</strong> devient inutile et peut être facilement enlever du cluster Kubernetes.</p><p>Et oui, rappelez-vous, <strong>Kubevirt</strong> s’installe au travers de CRD et peut donc se désinstaller de façon dynamique et ne plus enrichir l’API de Kubernetes !</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F7Hnij7GmRQ1xSoPboYdcg.png" /></figure><p>Les différentes équipes sont devenues autonomes et maîtrisent complètement la conteneurisation et la technologie Kubernetes.</p><p>Le passage à une application complètement Cloud Native apporte son dernier lot d’avantages :</p><ul><li>L’application se compose de services plus petits, indépendants et faiblement couplés. Elle est conçue de façon à apporter une valeur métier incontestée, comme la capacité à prendre en compte rapidement l’avis des utilisateurs dans un effort d’amélioration continue.</li><li>L’application a été transformée pour offrir une expérience cohérente de développement et de gestion automatisée dans les clouds privés, publics et hybrides. Cela permet d’améliorer l’évolutivité et la disponibilité de l’application, grâce à l’approvisionnement en libre-service et à la demande des ressources ainsi qu’à l’automatisation du cycle de vie des applications (de la phase de développement jusqu’à la production).</li></ul><h3>Organisation de l’étape 3 :</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F7Hnij7GmRQ1xSoPboYdcg.png" /></figure><h3>4. (ou 3 bis) Une application mixte « conteneurs + VMs »</h3><p>Dans certains cas (contraintes techniques, difficultés de compréhension de certaines fonctions que l’on ne désire pas retoucher, etc.), il n’est pas possible ou souhaitable de vouloir tout conteneuriser. Il n’y a aucun souci avec cela ! Aussi, <strong>Kubevirt</strong> apporte tout son sens, et le maintien d’un cluster Kubernetes+Kubevirt doit juste être pensé sur le long terme, avec un suivi supplémentaire du projet Kubevirt et des mises à jour associées.</p><blockquote>Quid des efforts de maintenance de Kubevirt ? Oui, cela peut demander des efforts supplémentaires au niveau de l’équipe DevOps. Par contre, si on ne désire pas gérer par soi-même l’installation et les évolutions de Kubevirt, il existe des solutions de plateforme tout intégrée qui embarque directement Kubernetes, Kubevirt et d’autres composants de la CNCF afin de simplifier l’utilisation de tout cet écosystème.Pour certaines de ces plateformes on parle même d’infrastructure hyperconvergée (HCI) pour solution Cloud Native. Attention, tout de même, ces plateformes sont souvent payantes et peuvent avoir un coût d’utilisation non négligeable. Les plus connues sont ‘<a href="https://docs.openshift.com/"><strong>OpenShift</strong></a>’, ‘<a href="https://harvesterhci.io/"><strong>Rancher Harvester</strong></a>’ ou encore ‘<a href="https://platform9.com/managed-kubevirt/"><strong>Plateform9</strong></a>’.</blockquote><h3>Un peu de technique quand même !</h3><h3>1. Installation de Kubernetes (et des pré-requis)</h3><p>Pour cet « atelier », j’ai utilisé une VM linux (Ubuntu 22.04) sur laquelle j’ai d’abord installé k3s (un ‘packaging’ de Kubernetes hyper léger proposé par Rancher).</p><p>- Installation de ‘docker’ :</p><pre>sudo apt-get update<br>sudo apt-get install -y docker-ce</pre><p>- Installation du binaire ‘kubectl’ (en tant que ‘root’) :</p><pre>curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl<br><br>chmod +x ./kubectl<br>mv ./kubectl /usr/local/bin/kubectl</pre><p>- Installation de k3s :</p><pre>curl -sfL https://get.k3s.io | sh –<br><br># Attendre 30s à 1 minutes pour que le cluster soit « up and running » <br>sudo k3s kubectl get node</pre><p>Pour être certain de la bonne installation, on pourra vérifier que tous les éléments de base du cluster fonctionnent bien via la commande supplémentaire suivante :</p><pre>kubectl -n kube-system get all</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/974/1*KIvNR9rSVBjmbqwvxa8xvg.png" /></figure><p>- On fait pointer le fichier de configuration de k3s pour être utilisé par ‘kubectl’ (afin d’éviter de taper la commande k3s à chaque fois !). Pour cela, on ajoute dans le fichier ‘.bashrc’ les lignes suivantes (toujours en tant que ‘root’) :</p><pre>export KUBECONFIG=/etc/rancher/k3s/k3s.yaml<br>source &lt;(kubectl completion bash)</pre><p>- Comme par la suite on va manipuler des images virtuelles, on installe aussi quelques utilitaires supplémentaires via les commandes suivantes :</p><pre>sudo apt-get update<br>sudo apt-get install -y qemu-utils libguestfs-tools qemu-kvm virt-manager libvirt-daemon-system virtinst libvirt-clients bridge-utils</pre><h3>2. Installation de Kubevirt</h3><p><strong>Kubevirt</strong> s’installe via le déploiement d’un « operator » en utilisant les commandes suivantes :</p><pre>export VERSION=v0.59.0<br>kubectl create -f https://github.com/kubevirt/kubevirt/releases/download/${VERSION}/kubevirt-operator.yaml</pre><p>On modifie le champ version en fonction de la dernière version stable que l’on souhaite utiliser.</p><p>Les <a href="https://github.com/kubevirt/kubevirt/releases">versions</a> disponibles sont directement visibles sur le GitHub de <strong>Kubevirt.</strong></p><p>Puis on ajoute les « CRD » de <strong>Kubevirt</strong> au cluster Kubernetes en utilisant la commande suivante :</p><pre>kubectl create -f https://github.com/kubevirt/kubevirt/releases/download/${VERSION}/kubevirt-cr.yaml</pre><p>Pour vérifier que <strong>Kubevirt</strong> est correctement installé, il faut contrôler que les différents éléments suivants sont ‘running’ et sans erreur dans le « namespace » ‘kubevirt’ du cluster Kubernetes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/652/1*hE6vHu8l4AvWPXxObX9MwQ.png" /></figure><p>Cela peut se faire via la commande suivante :</p><pre>kubectl -n kubevirt get all</pre><p>On vérifiera aussi que les « CRD » ont bien été appliqués, via la commande ci-dessous :</p><pre>kubectl get crd</pre><p>Le résultat est une liste, correspondant à toutes les fonctionnalités de <strong>Kubevirt </strong>accessible par l’API de Kubernetes :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/652/1*_GC_LSVv-k4y_b0llLippg.png" /></figure><blockquote><strong>Kubevirt et la virtualisation imbriquée</strong> :<br>Si le cluster Kubernetes s’exécute déjà sur des machines virtuelles, il est préférable d’activer la virtualisation imbriquée (“nested virtualization”) au niveau de l’hyperviseur pour bénéficier au maximum des capacités matérielles de votre hardware. Si, pour une raison quelconque, la virtualisation imbriquée ne peut pas être activée, alors il faudra activez l’émulation <strong>KubeVirt</strong> comme suit :</blockquote><blockquote>……………………………………………………………………………………………………..<em>kubectl -n kubevirt patch kubevirt kubevirt --type=merge --patch ‘{“spec”:{“configuration”:{“developerConfiguration”:{“useEmulation”:true}}}}’</em></blockquote><blockquote>……………………………………………………………………………………………………..</blockquote><blockquote>Vous l’aurez compris, <strong>Kubevirt</strong> ajoute de la virtualisation au sein d’une plateforme potentiellement déjà virtualisée !</blockquote><p>Pour permettre une meilleure gestion des VMs, il est aussi conseillé d’installer un binaire supplémentaire appelé <em>virtctl </em>en utilisant les commandes suivantes :</p><pre>VERSION=$(kubectl get kubevirt.kubevirt.io/kubevirt -n kubevirt -o=jsonpath=&quot;{.status.observedKubeVirtVersion}&quot;)<br><br>ARCH=$(uname -s | tr A-Z a-z)-$(uname -m | sed &#39;s/x86_64/amd64/&#39;) || windows-amd64.exe<br><br>curl -L -o virtctl https://github.com/kubevirt/kubevirt/releases/download/${VERSION}/virtctl-${VERSION}-${ARCH}<br><br>chmod +x virtctl<br>sudo install virtctl /usr/local/bin</pre><p><em>Virtctl</em> permettra d’effectuer un grand nombre d’opérations au niveau des VMs, comme :</p><ul><li>Démarrer, redémarrer, arrêter, mettre en pause ou réactiver une machine virtuelle</li><li>Redémarrer progressivement une instance de machine virtuelle</li><li>Migrer une machine virtuelle</li><li>Ouvrir une connexion SSH ou VNC à une instance de machine virtuelle</li><li>Se connecter à la console d’une instance de machine virtuelle</li><li>Faire la copie de fichiers via SCP depuis/vers une instance de machine virtuelle</li><li>Ajouter un volume à une machine virtuelle en cours d’exécution</li><li>Supprimer un volume d’une machine virtuelle en cours d’exécution</li><li>Exposer une instance de machine virtuelle, une machine virtuelle ou un jeu de réplicas d’instance de machine virtuelle en tant que nouveau service</li><li>Charger une image de machine virtuelle dans un DataVolume/PersistentVolumeClaim</li><li>Exporter un volume de machine virtuelle</li><li>Vider la mémoire d’une machine virtuelle en cours d’exécution sur un PersistentVolumeClaim</li><li>Annuler la migration d’une machine virtuelle</li><li>Renvoyer la liste complète des utilisateurs connectés sur la machine invitée</li><li>etc…</li></ul><p>Bref, on peut voir que les mêmes opérations, généralement réalisées sur un hyperviseur (qui contrôle des VMs), sont également présentes avec <strong>kubevirt </strong>au niveau du cluster Kubernetes.</p><p>Cela rend la tâche des DevOps beaucoup plus facile pour le déploiement et la maintenance opérationnelle car la gestion simultanée des conteneurs et des VMs se retrouve centralisée sur une plateforme unique et ‘moderne’ qu’est Kubernetes !</p><h3>3. Un exemple concret d’utilisation de Kubevirt ?</h3><p>La VM que l’on va déployer va se baser sur une image Cloud Ubuntu 22.04 (et oui j’aime bien cette distribution 😊).</p><p>- Récupération de l’image :</p><pre>curl -o /var/lib/libvirt/images/jammy-server-cloudimg-amd64.img https://cloud-images.ubuntu.com/jammy/current/jammy-server-cloudimg-amd64.img</pre><p>PS : pour avoir les droits de manipulation, l’image est placée dans le répertoire ‘/var/lib/libvirt/images/’</p><p>- Vérification des informations de l’image :</p><pre>qemu-img info /var/lib/libvirt/images/jammy-server-cloudimg-amd64.img</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*kWTQkgg2EGYEBnki4DbtRQ.png" /></figure><p>Il s’agit bien d’une image au format QCOW2 et la taille est suffisamment grande (10G) pour venir y ajouter des informations sur l’image.</p><p>- En cas de problèmes de manipulation de l’image, on fait une copie de celle-ci avant de la personnaliser :</p><pre>cp /var/lib/libvirt/images/jammy-server-cloudimg-amd64.img /var/lib/libvirt/images/my-ubuntu-image.img<br><br>virt-customize --format qcow2 -a /var/lib/libvirt/images/my-ubuntu-image.img \<br>--install cloud-init,openssl,openssh-server \<br>--memsize 2048 --hostname my-ubuntu --timezone Europe/Paris \<br>--root-password password:toor \<br>--run-command &#39;sudo useradd -s /bin/bash -d /home/rso/ -m -G sudo rso&#39; \<br>--run-command &#39;sudo ufw allow ssh&#39; \<br>--run-command &#39;ssh-keygen -A&#39; \<br>--password rso:password:test</pre><p>Dans mon exemple, la personnalisation consiste à :</p><ol><li><em>Installer « cloud-init », « openssl » et « openssh » afin de gérer plus tard la connexion SSH vers la VM</em></li><li><em>Définir le nom de la machine (my-ubuntu), la taille mémoire nécessaire et la time-zone</em></li><li><em>Modifier le mot de passe ‘root’</em></li><li><em>Ajouter un utilisateur ‘rso’</em></li><li><em>Ouvrir le port SSH</em></li><li><em>Générer la clé SSH de la machine pour le bon démarrage du service SSH</em></li><li><em>Modifier le mot de passe de l’utilisateur ‘rso’</em></li></ol><p>- Maintenant, on peut créer le conteneur correspondant à l’image de la futur VM :</p><pre>cp /var/lib/libvirt/images/my-ubuntu-image.img .<br><br>cat &lt;&lt; END &gt; Dockerfile<br>FROM scratch<br>ADD --chown=107:107 my-ubuntu-image.img /disk/<br>END<br><br>docker build -t ubuntu:22.04 .</pre><p>- Comme on utilise ‘k3s’, il faut transférer l’image que l’on vient de créer dans le ‘registry’ interne de ‘k3s’ (qui lui utilise ‘containerd’) :</p><pre>docker save --output ubuntu-22.04.tar ubuntu:22.04<br>k3s ctr images import ubuntu-22.04.tar</pre><p>- On peut enfin créer un fichier ‘template’ (vm.yaml) de notre machine virtuelle (qui s’appelle ‘my-ubuntu’) avec les ressources nécessaires à son utilisation (comme on n’a pas spécifié de “namespace”, tout va se passer dans celui par défaut) :</p><pre>cat &lt;&lt;EOF &gt; vm.yaml<br>apiVersion: kubevirt.io/v1<br>kind: VirtualMachine<br>metadata:<br>  name: my-ubuntu<br>spec:<br>  running: false<br>  template:<br>    metadata:<br>      labels:<br>        kubevirt.io/size: small<br>        kubevirt.io/domain: my-ubuntu<br>    spec:<br>      domain:<br>        resources:<br>          requests:<br>            cpu: 2<br>            memory: 2048M<br>        devices:<br>          disks:<br>            - name: containervolume<br>              disk:<br>                bus: virtio<br>          interfaces:<br>          - name: default<br>            masquerade: {}<br>      networks:<br>      - name: default<br>        pod: {}<br>      volumes:<br>        - name: containervolume<br>          containerDisk:<br>            image: ubuntu:22.04<br>EOF</pre><p>- On déploie le ‘template’ :</p><pre>kubectl create -f vm.yaml</pre><p>- On vérifie le bon déploiement de notre machine virtuelle (my-ubuntu) qui, par défaut, est arrêtée :</p><pre>virtctl get all</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lnGVBWi9BGTpnIy_qtAAUw.png" /></figure><p>Ou par la commande suivante :</p><pre>kubectl get vm</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/481/1*8u9FvnOfoYZQ6-bnYOAwuw.png" /></figure><p>- On peut maintenant démarrer notre machine virtuelle (my-ubuntu), ce qui va créer une <strong>instance de machine virtuelle</strong> :</p><pre>virtctl start my-ubuntu</pre><p>- Et on vérifie qu’elle est correctement démarrée via la commande suivante :</p><pre>virtctl get all</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*iac8i_Ey_zbkbfCvcwmdaQ.png" /></figure><p>Ou par la commande suivante :</p><pre>kubectl get vmi</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/966/1*u8hQ-hNcXxpNQB4pNtLxpA.png" /></figure><p>- Enfin, on se connecte à la console de notre machine virtuelle pour valider son fonctionnement complet (login = rso et password = test) :</p><pre>virtctl console my-ubuntu</pre><p>Ou en SSH via la commande suivante :</p><pre>virtctl ssh rso@my-ubunu</pre><p>Comme toute machine virtuelle, celle-ci met beaucoup plus de temps à démarrer qu’un ‘simple’ conteneur. L’utilisation de <strong>Kubevirt </strong>ne change rien à cet état de fait.</p><p><strong>Voilà ! On a pu vérifier le déploiement complet d’une VM Ubuntu sur un cluster Kubernetes.</strong></p><p>- Pour détruire/désinstaller la VM :</p><pre>kubectl stop my-ubuntu<br>kubectl delete -f vm.yaml</pre><p>Plutôt que de démarrer manuellement notre machine virtuelle, on peut aussi directement créer un fichier ‘template’ (vmi.yaml) correspondant à <strong>l’instance </strong>de notre machine virtuelle, ce qui la démarrera automatiquement :</p><pre>cat &lt;&lt;EOF &gt; vmi.yaml<br>apiVersion: kubevirt.io/v1<br>kind: VirtualMachineInstance<br>metadata:<br>  name: my-ubuntu<br>spec:<br>  terminationGracePeriodSeconds: 30<br>  domain:<br>    resources:<br>      requests:<br>        cpu: 2<br>        memory: 2048M<br>    devices:<br>      disks:<br>      - name: containerdisk<br>        disk:<br>          bus: virtio<br>  volumes:<br>  - name: containerdisk<br>    containerDisk:<br>      image: ubuntu:22.04<br>EOF</pre><p>On déploiera le ‘template’ de la même façon que le précédent.</p><p>Dans tous ces exemples, toute modification de la machine virtuelle après son démarrage est perdue une fois que celle-ci est détruite, car le montage du disque est de type ‘containerdisk’.</p><p>Pour pallier ce problème, il faut créer un volume persistant (au sens Kubernetes) et lier l’image de la machine virtuelle à ce volume.</p><p>Il existe beaucoup de tutoriels dans la documentation de Kubevirt permettant cela, ainsi que bien d’autres choses, comme la prise en charge de ‘cloud-init’ au niveau de la définition des ‘templates’ de VM/VMI.</p><p>Alors à vous de jouer…</p><h3>Existe-t-il des alternatives à Kubevirt ?</h3><p><strong>Kubevirt</strong> n’est pas la seule solution pour exécuter des machines virtuelles sur des clusters Kubernetes. Les alternatives les plus connues sont “Kata containers” et “Virtlet”.</p><h3>Kata containers</h3><p>Il est utilisé pour exécuter des machines virtuelles légères qui hébergent des images de conteneurs, plutôt que des images de machines virtuelles génériques. Bien qu’il soit également basé sur une implémentation CRI (comme Virtlet), Kata Containers ne rentre pas directement en concurrence avec Kubevirt ou même Virtlet (cf ci-dessous) car dans ce cas, les besoins et les utilisations de VM ne sont pas les mêmes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/728/1*RzwERQRfJVDqqCqbFl236w.png" /></figure><h3>Virtlet</h3><p>Il s’agit d’un serveur d’exécution Kubernetes qui permet d’exécuter des machines virtuelles basées sur des images QCOW2. Virtlet a été lancé par Mirantis, avec une première implémentation basée sur Flannel. En d’autres termes, Virtlet est une implémentation Kubernetes CRI (Container Runtime Interface) pour l’exécution de PODs basés sur des machines virtuelles sur des clusters Kubernetes (CRI est ce qui permet à Kubernetes d’exécuter des versions de conteneurs non Docker, telles que Rkt ou containerd). Par souci de simplicité de déploiement, Virtlet fonctionne comme un DaemonSet, agissant essentiellement comme un hyperviseur et rendant le proxy CRI disponible pour exécuter des machines virtuelles. De cette façon, il est possible d’exécuter des PODs Docker et non Docker (des VMs dans le cas de Virtlet) sur le cluster Kubernetes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/421/1*NfQ-z-V-_rhQth8SaAYcbQ.png" /></figure><h3>Comparaison des fonctionnalités de Kubevirt et Virtlet</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*TP3hyQVkq4sP5i7eOrzNcg.png" /></figure><p>Même si ce comparatif semble un peu en faveur de Virtlet, le projet <strong>Kubevirt</strong> est plus mature et surtout porté par la CNCF qui lui garantit une pérennité dans le temps avec des évolutions planifiées.</p><h3>Conclusion</h3><p><strong>Kubvirt</strong> présente beaucoup d’atouts avec une documentation en ligne très complète et un nombre de fonctionnalités assez conséquent qui faciliteront la migration des VMs « legacy » sur un cluster Kubernetes.</p><p>Le simple fait que <strong>Kubevirt </strong>fasse partie de l’écosystème de Kubernetes et de la CNCF, permet de tirer un très grand nombre de projets et de solutions supplémentaires “Open Source” pour enrichir la solution.</p><p>Cependant, <strong>Kubevirt</strong> est un outil qui présente quelques inconvénients dont il faudra prendre compte :</p><ul><li><strong>Complexité</strong> : KubeVirt est une solution assez complexe à déployer et à gérer, en particulier pour les utilisateurs qui n’ont pas beaucoup d’expérience avec Kubernetes. Cela peut nécessiter des compétences et des ressources supplémentaires pour l’administration et le dépannage. L’utilisation d’une solution clé en main tel que “OpenShift” ou “Rancher Harvester” est à mettre dans la balance.</li><li><strong>Performances et limitations de la virtualisation</strong> : La virtualisation elle-même peut comporter des limites qui peuvent affecter les performances et la flexibilité de KubeVirt. Par exemple, certaines fonctionnalités telles que l’utilisation spécifique de ressources matérielles peuvent ne pas être disponibles ou peuvent être plus complexes à implémenter.</li></ul><p>Malgré tout, et comme on a pu le voir dans cet article, l’utilisation d’un outil comme <strong>Kubevirt</strong> permet véritablement une transformation en ‘douceur’ et totalement ‘contrôlée’ d’application legacy sur VMs vers du Cloud Native.</p><h3>Références</h3><p><a href="https://kubevirt.io/user-guide/">KubeVirt user guide</a></p><p><a href="https://kubevirt.io/quickstart_minikube/">KubeVirt quickstart with Minikube</a></p><p><a href="https://kubevirt.io/labs/kubernetes/lab1.html">Use KubeVirt</a></p><p><a href="https://kubevirt.io/blogs/news.html">Kubevirt blogs</a></p><p><a href="https://www.kube-ovn.io/">Kube-OVN</a></p><p><a href="https://www.kube-ovn.io/news/kubevirt-kube-ovn-networking-for-cloud-native-virtualization">KubeVirt + Kube-OVN = Networking for Cloud Native Virtualization</a></p><p><a href="https://github.com/k8snetworkplumbingwg/multus-cni">Mutlus</a></p><p><a href="https://kubeovn.github.io/docs/v1.11.x/en/advance/multi-nic/">Manage Multiple Interface with Kube-OVN + Multus</a></p><p><a href="https://www.redhat.com/fr/topics/devops">Understand DevOps</a></p><p><a href="https://www.redhat.com/fr/topics/containers">Understand Linux containers</a></p><p><a href="https://www.redhat.com/fr/topics/cloud-native-apps">Understand Cloud Native application</a></p><p><a href="https://www.redhat.com/fr/topics/microservices">Understand microservices</a></p><h3>Pour aller plus loin !</h3><p><a href="https://www.kube-ovn.io/"><strong>Kube-OVN</strong></a> est une intégration de la mise en réseau basée sur OVN/OVS avec Kubernetes. Étant donné qu’OVN et OVS ont été largement utilisés dans les scénarios de virtualisation traditionnels, Kube-OVN a beaucoup attiré l’attention de la communauté KubeVirt depuis qu’il est devenu Open Source.</p><p>Certains premiers utilisateurs de KubeVirt ont encore amélioré les capacités de mise en réseau de Kube-OVN pour leurs cas d’utilisation. Cela a abouti à un grand nombre de nouvelles fonctionnalités optimisées spécifiquement pour Kubevirt et destinées à résoudre certains des défis de mise en réseau rencontrés par KubeVirt.</p><p>Même si Kube-OVN est encore au niveau « sandbox » de la CNCF, il possède déjà de nombreuses fonctionnalités comme : <strong>Namespaced Subnets, Subnet Isolation, Dual Stack, Multi-Cluster Networking, Traffic Mirror, VPC Support, Static IP Addresses, Network Policy, Pod NAT and EIP, Dynamic QoS, Underlay Support et Cilium Integration</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ph7KfJsQiQvQzibtdkjfew.png" /></figure><p><a href="https://github.com/k8snetworkplumbingwg/multus-cni"><strong>Multus</strong></a> est un plug-in d’interface réseau de conteneurs (CNI) pour Kubernetes qui permet d’attacher plusieurs interfaces réseau aux PODs. En règle générale, dans Kubernetes, chaque POD n’a qu’une seule interface réseau (à l’exception de la ‘loopback’). Avec Multus, vous pouvez créer un POD doté de plusieurs interfaces. Ceci est réalisé par Multus car il agit comme un “méta-plugin” : un plugin CNI qui peut appeler plusieurs autres plugins CNI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/474/1*pgixaDTRQ-KFF1MP9-660g.png" /></figure><p>Multus CNI suit la norme des CRD pour la partie réseau de Kubernetes afin de fournir une méthode standardisée permettant de spécifier les configurations des interfaces réseau supplémentaires.</p><p><a href="https://www.konveyor.io/tools/forklift/"><strong>Forklift</strong></a>: Avec cet outil open source, vous pourrez migrer des machines virtuelles vers Kubernetes à grande échelle. Que vous réhébergiez quelques ou des centaines de machines virtuelles sur KubeVirt, Forklift vous aide à minimiser les temps d’arrêt lorsque vous déplacez ces applications.</p><p>Forklift est un projet de la CNCF du niveau « sandbox ».</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/1*SHWUaJ_S15Ag6o_bDvMvug.png" /></figure><p><em>La combinaison de ces différents projets, associés à Kubernetes permet véritablement d’enrichir les fonctionnalités de </em><strong><em>Kubevirt</em></strong><em> et ainsi de créer une infrastructure identique à celle que vous auriez pu faire, à partir d’une solution VMWare ou Cloud publique, basée sur des VMs.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f2d30684667" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>