Comment utiliser Kubernetes gratuitement sur WSL | DevOps

Voyons comment installer Docker, kubectl et Minikube sur WSL

Keywords: k8s, DevOps, VM, Virtual Machines, AWS, GCP, DIY, tutoriel

By Carmen Cincotti

March 06, 2023

C’est quoi Kubernetes ?
- Pourquoi utiliser Kubernetes ?
- Fonctionnalités de Kubernetes
C’est quoi le Minikube ?
- Comment fonctionne Minikube ?
C’est quoi WSL ?
Pourquoi utiliser WSL ?
Comment fonctionne WSL ?
Comment utiliser minikube sur WSL
Des ressources (en français et anglais)

Cette semaine, j’ai commencé à suivre un cours pour devenir certifié avec l’utilisation de Kubernetes en utilisant un cours fourni par The Linux Foundation.

Avoir une certification Certified Kubernetes Administrator (CKA) serait bon pour ma carrière d’ingénieur DevOps.

Cependant, j’ai essayé de suivre les exercices de laboratoire sans utiliser de fournisseurs de cloud comme Amazon Web Services (AWS) ou Google Cloud Platform (GCP).

Pourquoi? Ces plateformes sont chères et elles nécessitent ma carte de crédit. Je ne suis pas chaud à l’idée de payer pour apprendre à utiliser un logiciel comme Kubernetes.

Heureusement, il existe une application que nous pouvons utiliser pour exécuter un cluster Kubernetes localement sur nos ordinateurs gratuitement.

Ce logiciel s’appelle minikube.

Au cours de cet article, nous verrons ensemble comment installer minikube sur WSL pour faire fonctionner un environnement Kubernetes sur votre ordinateur.

Après avoir lu cet article, vous pourrez développer et tester gratuitement Kubernetes en utilisant WSL (Ubuntu).

C’est quoi Kubernetes ?

Kubernetes est un système d’orchestration de conteneurs open source qui automatise le déploiement, la mise à l’échelle et la gestion des applications conteneurisées. Il a été initialement développé par Google et est maintenant géré par la Cloud Native Computing Foundation (CNCF).

Kubernetes est devenu la norme de facto pour l’orchestration de conteneurs et est largement utilisé par des organisations de toutes tailles pour déployer et gérer leurs applications conteneurisées dans des environnements de production.

Pourquoi utiliser Kubernetes ?

Avec Kubernetes, les développeurs peuvent facilement déployer et gérer des applications conteneurisées sur un cluster de serveurs ou de machines virtuelles.

Kubernetes fait abstraction de l’infrastructure sous-jacente et fournit une API unifiée pour le déploiement et la gestion des applications, permettant aux développeurs de se concentrer sur l’écriture de code plutôt que de se soucier de l’infrastructure.

Fonctionnalités de Kubernetes

Kubernetes fournit un certain nombre de fonctionnalités puissantes, notamment :

Mise à l’échelle automatique
Mises à jour continues
Autoguérison
Découverte des services

Ces fonctionnalités permettent de garantir que les applications sont toujours disponibles et fonctionnent correctement, même en cas de pannes matérielles ou logicielles.

C’est quoi le Minikube ?

Minikube est un outil open source qui permet aux développeurs d’exécuter et de tester des clusters Kubernetes localement sur leurs propres machines.

Il offre un moyen simple et facile d’expérimenter et de tester Kubernetes sans nécessiter un environnement de production à grande échelle.

Comment fonctionne Minikube ?

Minikube permet aux développeurs de créer un cluster Kubernetes avec un node unique (… ou plusieurs nodes) sur leur machine locale à l’aide d’une machine virtuelle ou d’un runtime de conteneur, tel que Docker.

Minikube fournit une API et une interface de ligne de commande qui permettent aux développeurs d’interagir avec le cluster Kubernetes exécuté sur leur ordinateur local, comme ils le feraient avec un environnement Kubernetes de production.

Cela facilite le test et le débogage des applications avant de les déployer dans un environnement de production sans avoir besoin d’une infrastructure ou de services cloud coûteux.

Dans l’ensemble, Minikube est un outil précieux pour les développeurs qui souhaitent :

Apprendre Kubernetes
Expérimenter de nouvelles fonctionnalités
Tester leurs applications dans un environnement local

C’est quoi WSL ?

Windows Subsystem for Linux (WSL) est une fonctionnalité de Windows 10 et des versions ultérieures qui permet aux utilisateurs d’exécuter des applications Linux (telles qu’Ubuntu) en mode natif sur Windows.

Plus précisément, il fournit une interface de kernel compatible Linux qui permet aux binaires Linux de s’exécuter sur Windows.

Pourquoi utiliser WSL ?

WSL permet aux développeurs et aux administrateurs système d’utiliser des outils et utilitaires Linux, tels que bash, grep, sed et awk, directement sur Windows, sans avoir besoin d’une machine virtuelle distincte ou d’une configuration à dual-boot.

Cela facilite le développement, le test et le déploiement d’applications conçues pour fonctionner sous Linux.

WSL comprend également une interface de ligne de commande (CLI) pour gérer et configurer l’environnement Linux sous Windows. Les utilisateurs peuvent :

Installer et gérer des distributions Linux, telles qu’Ubuntu, Arch, Debian, etc.
Créer et gérer des comptes utilisateurs Linux
Configurer les paramètres réseau et les préférences système

Personnellement, c’est une fonctionnalité tellement géniale, car je peux exécuter mes applications natives Windows comme Photoshop, Steam, etc. parallèlement à mon environnement de développement dans Ubuntu.

… Sans oublier que cela me permet d’utiliser mon GPU à pleine puissance, car les driveurs GPU pour Linux sont généralement… mauvais.

Comment fonctionne WSL ?

WSL utilise une machine virtuelle Hyper-V légère pour exécuter un kernel Linux complet, offrant de meilleures performances et une meilleure compatibilité avec une plus large gamme d’applications Linux.

Pour conclure, WSL est un outil puissant pour les développeurs et les administrateurs système qui ont besoin de travailler avec des outils basés sur Linux sur une plate-forme Windows.

Comment utiliser minikube sur WSL

Je suppose que WSL est déjà installé sur votre ordinateur. J’utilise Ubuntu v20.04 LTS comme version Linux.

Étape 1 : Installez Docker sous Windows

La première étape consiste à installer Docker sur Windows en suivant ce lien.

Ouvrez Docker Desktop sur Windows.

Activez les paramètres d’intégration WSL de Docker

Après l’installation, accédez à Settings (icône d’engrenage) -> Resources -> WSL Integration.

Cochez ensuite la case Enable integration with my default WSL distro.

Activer WSL sur Docker

Accédez ensuite à General, puis cochez la case Use the WSL2 based engine.

Activer le backend WSL Hyper V sur Docker

Étape 2: Installez minikube sur Windows

Ensuite, il faut juste installer minikube sur Windows.

Rien de plus simple ! Suivez ce lien pour l’installer sur votre ordinateur.

Configurez WSL pour accéder à minikube

Pour accéder facilement à minikube côté Windows, nous pouvons créer un petit script à l’emplacement /usr/local/bin/minikube avec le contenu suivant :

#!/bin/sh
/mnt/c/Program\ Files/Kubernetes/Minikube/minikube.exe $@

Étape 3 : Installez kubectl sur WSL (Ubuntu)

Pour accéder à notre cluster Kubernetes et pour exécuter des commandes sur notre cluster Kubernetes créé par minikube, nous avons besoin d’un outil CLI pour le faire.

L’outil que nous allons utiliser s’appelle kubectl. C’est la norme de l’industrie !

Pour installer kubectl suivez ce lien.

Veuillez noter que cette installation aura lieu sur WSL avec Ubuntu et non du côté Windows.

Étape 4 : Configurer kubectl pour utiliser minikube

Nous devons d’abord créer la configuration pour accéder à minikube sur Windows avec kubectl. Nous pouvons le faire en démarrant minikube comme ceci :

minikube start

Cette étape est cruciale. Vous devriez voir minikube démarrer avec succès.

😄  minikube v1.29.0 on Microsoft Windows 11 Pro 10.0.22000.1574 Build 22000.1574
✨  Using the docker driver based on existing profile
👍  Starting control plane node minikube in cluster minikube
🚜  Pulling base image ...
🔄  Restarting existing docker container for "minikube" ...
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23 ...
🔗  Configuring bridge CNI (Container Networking Interface) ...
🔎  Verifying Kubernetes components...
    ▪ Using image gcr.io/k8s-minikube/storage-provisioner:v5
🌟  Enabled addons: default-storageclass, storage-provisioner
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Après, vous devriez voir la configuration de minikube dans le fichier %UserProfile%\.kube\config sur Windows.

Copiez le kubeconfig de Windows

Ne sautez pas cette étape !

Copiez le contenu de .kube/config à partir de Windows vers WSL (Ubuntu) avec la commande suivante :

cp /mnt/c/Users/{USER_ACCOUNT}/.kube/config ~/.kube

Vous devriez voir le contenu de .kube/config comme suit :

apiVersion: v1
clusters:
- cluster:
    certificate-authority: C:\Users\{...}.crt
    extensions:
    - extension:
        last-update: {}
        provider: minikube.sigs.k8s.io
        version: v1.29.0
      name: cluster_info
    server: https://{...}
  name: minikube
contexts:
- context:
    cluster: minikube
    extensions:
    - extension:
        last-update: {...}
        provider: minikube.sigs.k8s.io
        version: v1.29.0
      name: context_info
    namespace: default
    user: minikube
  name: minikube
current-context: minikube
kind: Config
preferences: {}
users:
- name: minikube
  user:
    client-certificate: C:\Users\{...}.crt
    client-key: C:\Users\{...}.key

Vous devrez convertir les chemins de fichiers Windows en chemins de fichiers WSL.

Par exemple, convertissez C:\Users\carmencincotti\ en /mnt/c/Users/carmencincotti. Notez la différence dans le sens des barres obliques (\ versus /).

Si vous ne savez pas comment procéder, vous pouvez utiliser la commande wslpath comme suit :

wslpath -u "C:\Users\carmencincotti\.minikube\profiles\minikube\client.key"
>> /mnt/c/Users/carmencincotti/.minikube/profiles/minikube/client.key

Étape 5 : Copiez l’environnement Docker

Enfin, il suffit d’injecter les variables d’environnement Docker dans l’environnement de WSL (Ubuntu).

Pour ce faire, utilisez simplement ces deux commandes :

eval $(sh /usr/local/bin/minikube docker-env --shell=bash)
export DOCKER_CERT_PATH=$(wslpath -u "${DOCKER_CERT_PATH}")

Pour vérifier que ces deux commandes ont fonctionné, vous pouvez utiliser la commande env dans le terminal pour voir si la configuration a été ajoutée à env.

Accéder à minikube sur WSL avec kubectl

Après, il est désormais possible d’utiliser kubectl pour envoyer des commandes à minikube à partir de WSL !

kubectl config use-context minikube
>> Switched to context "minikube".
kubectl get nodes
>> NAME       STATUS   ROLES           AGE     VERSION
>> minikube   Ready    control-plane   6d22h   v1.26.1

Carmen's Graphics Blog