Utiliser Kubernetes en local avec Minikube sous Windows 10

Introduction

Utiliser Kubernetes en local avec Minikube sur Windows, c’est maintenant possible (et facile) grâce à la mise à jour 2004 (Avril 2020) pour Windows 10.

Windows & le WSL2

Microsoft a sorti la mise à jour 2004 pour Winsows 10 début juin. Cette update comprend une tonne de fonctionnalités, corrections de bug, etc… et notamment la généralisation du WSL2.
Vous n’êtes plus obligé de vous cacher dans le cercle des “Insiders developers” de Microsoft pour bénéficier de cette fonctionnalité (majeure).

En quelques mots, avec le WSL2 nous pouvons générer un système Linux au sein même de Windows, en se basant sur un noyau Linux (point important et central comparé aux anciennes versions). Ainsi que l’implémentation de la conteneurisation dans le système Linux, fonctionnalité inaccessible en WSL (version 1).

Un article dédié au WSL2 est accessible ici.

WSL2 et les services Linux

Si vous êtes développeur, le système Linux vous paraîtra parfaitement limpide.
Si vous êtes Ops, vous verrez que quelques différences apparaissent, notamment l’intégration du module des services.

Cette information conditionne certaines manipulations au sein de l’article, d’où ces quelques explications.

Le service systemd n’est pas accessible, tout doit passer par le systemv classique.

Dites adieu aux commandes systemctl et utilisez les commandes service sshd start. (ou /etc/init.d/sshd start)

WSL2 et Docker

La grande nouveauté du WSL2 est la pleine intégration de docker dans l’environnement Linux, ce qui n’était pas le cas dans sa 1ère version.

Vous pouvez installer docker comme en suivant la documentation officielle. Pas besoin de tricks particuliers pour le faire fonctionner.

Avec le WSL2, vous pouvez dire adieu à Docker for Windows. Terminé les tirages de cheveux pour monter des volumes ou configurer la stack docker.
Maintenant que qu’un système Linux prend entièrement le relais, c’est comme utiliser docker sur un serveur (à quelques différences prêt).

Minikube

Version 1.11.0

Documentation officielle : https://minikube.sigs.k8s.io/docs/

Explications

Les drivers

Minikube peut être exécuté de plusieurs manière :

• Nativement sur le système (--driver=none) : Minikube installe un Master ainsi qu’un Node directement sur le serveur,
• A partir d’un VM (--driver=vm) : Minikube monte une machine virtuelle qui lui permettr ade créer le Master/Node Kubernetes,
• Dans un conteneur (--driver=docker) : Minikube génère un conteneur qui lui servira à créer le cluster (mono-noeud) Kubernetes,

L’option VM permet de créer une machine virtuelle dans laquelle Minikube montera un OS et s’installera comme un grand. On se rapproche beaucoup du mode opératoire des Ops quand ils provisionnent un cluster Kubernetes.
Cette option ne sera pas traitée ici.

L’option native est très intéressante car elle installe tout le nécessaire à même la machine rendant l’environnement très proche des éco-système Kubernetes classiques.
Malheureusement, cette option n’est pas possible dans le mde WSL2, car Minikube se base sur systemd pour démarrer les services Kubernetes. Etant donné que Systemd est dédié au système lui-même et que nous sommes obligés d’utiliser SystemV, cette solutoin n’est pas possible en l’état.
Il existe des “hacks” pour intégrer les namespaces SystemD, mais ils ne sont pas très stables.

L’option docker est très intéressante, car elle permet de s’affranchir des bug liés aux OS et aux librairies installées.
En s’appuyant uniquement sur Docker, on créé une couche d’abstration entre le système et ce dont Minikube nécessite pour démarrer. L’orchestrateur local se basera sur une image Docker de référence valide, testée et robuste pour tout démarrer.

Dans cet article, nous utiliserons l’option Docker (la plus facile à mettre en place) pour créer notre cluster Minikube.

Installation

Se prémunir des erreurs

Bien que le WSL2 soit maintenant disponible comme mise à jour régulière sous Windows 10, des bugs sont toujours ouverts à l’heure actuelle concernant l’interaction entre Docker et WSL2 :

• https://github.com/docker/for-linux/issues/219 (opened)
• https://github.com/kubernetes/minikube/issues/459 (closed)
• https://github.com/kubernetes/minikube/issues/5392 (closed)

Ces bugs introduisent quelques comportement non attendus.
Pour se prémunir de ces futures potentielles erreurs, réalisez les actions qui suivent.

Activer et monter le sysfs

sudo mkdir /sys/fs/cgroup/systemd
sudo mount -t cgroup -o none,name=systemd cgroup /sys/fs/cgroup/systemd

Nettoyer le répertoire minikube

rm -rf ~/.minikube

Installer Docker

Installons Docker en suivant la documentation officielle : https://docs.docker.com/engine/install/ubuntu/

# Prérequis
sudo apt-get update
sudo apt-get remove -t docker docker-engine docker.io containerd runc
sudo apt-get install -y apt-transport-https ca-certificates curl gnupg-agent software-properties-common

# Installation
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt-get install -y docker-ce docker-ce-cli containerd.io

Lançons docker à l’aide de son service :

sudo service docker start

Ajoutons les droits d’exécuter les commandes docker à notre utilisateur :

sudo groupadd docker
sudo usermod -aG docker $USER

Vous devez vous déconnecter/reconnecter pour prendre en compte la modification des groupes et droits utilisateur.

Installer Minikube

Installons Minikube à l’aide de la documentation officielle :

curl -sLo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube
sudo mkdir -p /usr/local/bin/
sudo install minikube /usr/local/bin/

A présent, nous pouvons démarrer le cluster local Kubernetes grâce à Minikube :

minikube start --driver=docker --kubernetes-version=v1.16.10

😄 minikube v1.11.0 on Ubuntu 18.04
✨ Using the docker driver based on user configuration
🆕 Kubernetes 1.18.3 is now available. If you would like to upgrade, specify: --kubernetes-version=v1.18.3
👍 Starting control plane node minikube in cluster minikube
🚜 Pulling base image …
💾 Downloading Kubernetes v1.16.10 preload …
> preloaded-images-k8s-v3-v1.16.10-docker-overlay2-amd64.tar.lz4: 502.49 Mi
🔥 Creating docker container (CPUs=2, Memory=3100MB) …
🐳 Preparing Kubernetes v1.16.10 on Docker 19.03.2 …
▪ kubeadm.pod-network-cidr=10.244.0.0/16
🔎 Verifying Kubernetes components…
🌟 Enabled addons: default-storageclass, storage-provisioner
🏄 Done! kubectl is now configured to use "minikube"
💡 For best results, install kubectl: https://kubernetes.io/docs/tasks/tools/install-kubectl/

Installer Kubectl

Kubernetes est joignable uniquement à l’aide d’un client sur le modèle du client/server : kubectl.

Habituellement vous iriez sur la page officielle pour télécharger la version du binaire.
Mais pour cette fois, nous allons utiliser les compétences de minikube pour télécharger la bonne version du client.

minikube kubectl

Si le client est présent, il l’utilisera. Si ce n’est pas le cas, il le téléchargera tout seul pour en faire bénéficier.

minikube kubectl version

Client Version: version.Info{Major:"1", Minor:"16", GitVersion:"v1.16.10", GitCommit:"f3add640dbcd4f3c33a7749f38baaac0b3fe810d", GitTreeState:"clean", BuildDate:"2020-05-20T14:00:52Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"16", GitVersion:"v1.16.10", GitCommit:"f3add640dbcd4f3c33a7749f38baaac0b3fe810d", GitTreeState:"clean", BuildDate:"2020-05-20T13:51:56Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}

Utilisation

Manipulons un peu notre cluster Kubernetes tout neuf. Pour réaliser des actions, nous avons besoin d’un client qui ira solliciter l’API du serveur Kubernetes : kubectl.

Kubectl

Si vous avez l’habitude du client kubectl natif de Kubernetes, celui de minikube est légèrement différent au niveau syntaxe. Il faut penser à échapper les paramètres (--) de la commandes minikube kubectl :

minikube kubectl -- get pods

Si vous ne souhaitez pas vous embarasser avec cette subtilité qui est propre à minikube, ajouter un alias à votre profile :

cat << EOF >> ~/.profile
alias kubectl='minikube kubectl --'
EOF
. ~/.profile

On pourra maintenant faire appel à la commande k pour lancer le client Kubernetes : rapide et efficace ! Et ainsi retrouver un comportement identique au client natif.

kubectl get  pods

Toutes les commandes qui suivent utilisent l’alias kubectl (qui correspond à minikube kubectl --).

Nodes

Les Nodes sont les serveurs sur lesquels les conteneurs vont vivre.

kubectl get nodes

NAME STATUS ROLES AGE VERSION
minikube Ready master 21m v1.16.10

Pods

Les Pods sont les conteneurs qui sont exécutés sur les Nodes. En réalité, un Pod est composé d’un ou plusieurs conteneurs.

kubectl get pods

No resources found in default namespace.

Redémarrage de Minikube

Vous serez certainement amenés à redémarrer la machine WSL, que ce soit en arrêtant le système avec wsl --terminate Ubuntu ou en redémarrant le service Windows LxssManager.

Quoiqu’il en soit, vous serez amenés à devoir (re-)démarrer minikube mais ne le faites pas n’importe comment.

Vérifiez que docker soit bien démarré, sinon démarrez le service : service docker start.

Etant donné que minikube tourne lui-même dans un conteneur, ne démarrez pas le conteneur minikube vous-même, utilisez la commande start de minikube : minikube start --driver=docker --kubernetes-version=v1.16.10

Configuration

Minikube vient avec un helper facilitant l’installation de composants (addons) utiles ou tout simplement indispensables.

Addons

Faisons un tour des addons que nous propose Minikube et initialons les plus courants et importants.

minikube addons list

Nous allons faire un focus sur les addons suivants :

• Kubernetes Dashoard : Tableau de bord Kubernetes
• Helm : Package manager
• EFK : Collecte de logs
• Registry : Registry Docker
• Ingress Controller : Passerelle de publication des apps
• Metrics : Collecte interne de métriques

Kubernetes Dashboards

Kubernetes Dashboards est un projet mené par les équipes de développement du produit pour visualiser les objets créés au sein du cluster Kubernetes (cluster de un noeud dans notre cas).

minikube addons enable dashboard

Les objets sont créés dans le namespace kubernetes-dashboard :

kubectl get -n kubernetes-dashboard pod,deployment,service

NAME                                             READY   STATUS    RESTARTS   AGE
pod/dashboard-metrics-scraper-7b64584c5c-nz682   1/1     Running   0          18m
pod/kubernetes-dashboard-5b48b67b68-f4w9s        1/1     Running   0          18m

NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/dashboard-metrics-scraper   1/1     1            1           18m
deployment.apps/kubernetes-dashboard        1/1     1            1           18m

NAME                                TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
service/dashboard-metrics-scraper   ClusterIP   10.110.233.80   <none>        8000/TCP   18m
service/kubernetes-dashboard        ClusterIP   10.96.57.22     <none>        80/TCP     18m

Connectons-nous à l’interface visualle du dashboard :

kubectl port-forward -n kubernetes-dashboard svc/kubernetes-dashboard 8080:80

Forwarding from 127.0.0.1:8080 -> 9090
Forwarding from [::1]:8080 -> 9090
Handling connection for 8080
...

Rendez-vous à l’adresse http://localhost:8080/

Site officiel Kubernetes Dashboard : https://kubernetes.io/fr/docs/tasks/access-application-cluster/web-ui-dashboard/

Helm

Helm, accompagné de son fidèle destrier Tiller, est un outil de déploiement pour Kubernetes.

minikube addons enable helm-tiller

Le pod destiné à l’utilisation de Helm est un peu vicieux car il se cache dans le namespace système de Kubernetes appelé kube-system. Allons le récupérer à l’aide des filtres et des labels et visualiser la version déployée :

kubectl get pod -n kube-system -l name=tiller

NAME                             READY   STATUS    RESTARTS   AGE
tiller-deploy-6cdf7f9d6f-rcfjt   1/1     Running   0          2m4s

kubectl describe pod/tiller-deploy-6cdf7f9d6f-rcfjt -n kube-system

Name: tiller-deploy-6cdf7f9d6f-rcfjt
Namespace: kube-system
[...]
Containers:
  tiller:
    Container ID: docker://fd82cec2f1875cd0f2feb1cdc7eb9aa0f042b8343f01594b06a1961f5c127d43
    Image: gcr.io/kubernetes-helm/tiller:v2.16.7
[...]

Trouvé : Helm version v2.16.7

Pour utiliser Helm, il faut également un client. Si l’activation de l’addon helm-tiller n’a pas installé le client (testez avec helm version), il faut le télécharger par nous-même à l’adresse suivante : curl -sO https://get.helm.sh/helm-v2.16.7-linux-amd64.tar.gz tar -zxvf helm-v2.16.7-linux-amd64.tar.gz chmod u+x,g+x linux-amd64/tiller linux-amd64/helm sudo mv linux-amd64/tiller linux-amd64/helm /usr/local/bin

helm version

Client: &version.Version{SemVer:"v2.16.7", GitCommit:"5f2584fd3d35552c4af26036f0c464191287986b", GitTreeState:"clean"}
Server: &version.Version{SemVer:"v2.16.7", GitCommit:"5f2584fd3d35552c4af26036f0c464191287986b", GitTreeState:"clean"}

Site officiel Helm : https://helm.sh/docs/intro/quickstart/

Extracteur de logs EFK

minikube addons enable efk

kubectl get pod -n kube-system | grep -e kibana -e fluentd -e elastic<br>kubectl get svc -n kube-system

NAME                          READY   STATUS              RESTARTS   AGE
elasticsearch-logging-rxrtx   0/1     PodInitializing     0          29s
fluentd-es-rb5cp              1/1     Running             0          29s
kibana-logging-6cmfh          0/1     ContainerCreating   0          29s

NAME                    TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
elasticsearch-logging   ClusterIP   10.98.109.245   <none>        9200/TCP         8m3s
kibana-logging          NodePort    10.97.18.201    <none>        5601:30003/TCP   8m3s

kubectl port-forward -n kube-system svc/kibana-logging 8080:5601

Rendez-vous à l’adresse : http://localhost:8080, vous accédez à l’interface de Kibana.

Kibana remonte bien les logs. Votre EFK est prêt !

Registry Docker

minikube addons enable registry

La registry docker s’installe dans le namespace kube-system.

kubectl get pod,svc -n kube-system -l kubernetes.io/minikube-addons

NAME                   READY   STATUS              RESTARTS   AGE
registry-kcwtb         0/1     ImagePullBackOff    0          44s
registry-proxy-nmxp5   0/1     ContainerCreating   0          44s

NAME       TYPE        CLUSTER-IP    EXTERNAL-IP      PORT(S)          AGE
registry   ClusterIP   10.98.59.63   <none>           80/TCP,443/TCP   44s

Maintenant que nous avons le nom du service, nous pouvons l’exposer pour pouvoir lister des images docker.

kubectl port-forward -n kube-system svc/registry 5000:80

Ajouter l’url de la registry dans la configuration de docker : /etc/docker/daemon.json :

{
    "registry-mirrors": ["https://localhost:5000"]
}

Attention : La registry nécessite d’être accédée en HTTPS. La configuration précédente expose le port uniquement le port HTTP.

L’utilisation de la registry au sein même de minikube doit être exclusivement réservé au développement local !

Ingres Controller

minikube addons enable ingress

kubectl get pods -n kube-system -l app.kubernetes.io/name=ingress-nginx

NAME                                        READY   STATUS      RESTARTS   AGE
ingress-nginx-admission-create-h4thc        0/1     Completed   0          95s
ingress-nginx-admission-patch-9ddx5         0/1     Completed   0          95s
ingress-nginx-controller-58488fd49c-8lv2f   1/1     Running     0          95s

A présent, vous pouvez utiliser les objets ingress pour exposer vos services à l’extérieur de minikube.

Listez les ingresses du cluster entier (tous namespaces confondus) :

kubectl get ingress -A

Lien vers la documentation Kubernetes – Ingress Controller Nginx : https://kubernetes.github.io/ingress-nginx/
Lien vers la documentation Nginx – Ingress Controller : https://www.nginx.com/products/nginx/kubernetes-ingress-controller/

Supervision des métriques Kubernetes

L’outil de métriques Kubernetes sert ici à collecter les métriques en interne du cluster. Elle vous serviront à visualiser les pods et nodes qui consomment des ressources système.

La commande de visualisation des ressource ne fonctionne pas de base, il faut activer le module . Tester cette commande tout de suite :

kubectl top nodes

Error from server (NotFound): the server could not find the requested resource (get services http:heapster:)

Activons le module.

minikube addons enable metrics-server

Par curiosité, nous pouvons aller voir où le pod s’est lancé :

kubectl get pod,deploy,svc -n kube-system -l k8s-app=metrics-server

Maintenant nous pouvons visualiser les ressources système consommées.

kubectl top nodes

NAME       CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
minikube   215m         2%     6Mi             0%

kubectl top pods -A

NAMESPACE     NAME                               CPU(cores)   MEMORY(bytes)
kube-system   coredns-5644d7b6d9-tmskc           4m           14Mi
kube-system   coredns-5644d7b6d9-x5vjn           4m           12Mi
kube-system   etcd-minikube                      27m          34Mi
kube-system   kube-apiserver-minikube            70m          283Mi
kube-system   kube-controller-manager-minikube   32m          44Mi
kube-system   kube-proxy-qhdts                   2m           16Mi
kube-system   kube-scheduler-minikube            2m           15Mi
kube-system   metrics-server-6754dbc9df-rtsqx    0m           10Mi
kube-system   storage-provisioner                1m           19Mi

Voici un élément indispensable pour mesurer la consommation des pods du cluster prêt à l’emploi.

L’ambassador des API Gateway

Ambassador

minikube addons enable ambassador

minikube service list

Pour apprendre, tester ou savoir utiliser l’APi Gateway d’Ambassador, tournez-vous vers leur demo tutoriel qui nous en dit long sur la création d’un service Ambassador : https://www.getambassador.io/docs/latest/tutorials/quickstart-demo/

Vous pourrez ainsi contacter le service sur le endpoint généré et récupérable à partir de la commande précédente : http://172.17.0.3:32228/backend/

Conclusion

Minikube ne devrait plus avoir de secrets pour vous pour commencer à développer vos projets et manipuler dans un environnement Kubernetes.

Si les choses tournent mal dans Minikube, n’hésitez pas à supprimer l’instance WSL2 et de la reconstruire. Avec la philosophie qu’apporte Kubernetes et le stockage des configurations sous forme de fichiers, reconstruire une application complète ne devrait pas vous prendre longtemps.

Dans la continuité de cet article, vous pouvez poursuivre votre lecture avec la présentation globale de Kubernetes pour mieux comprendre les objets de base : https://blog.ineat-group.com/2019/10/presentation-de-kubernetes/

Découvrez dans un prochain article comment utiliser les ingresses au travers d’un Ingress Controller.

Bibliographie

• Kubernetes : https://kubernetes.io/
• Minikube : https://minikube.sigs.k8s.io/
• Windows WSL : https://docs.microsoft.com/fr-fr/windows/wsl/install-win10
• Kubernetes Dashboard : https://kubernetes.io/fr/docs/tasks/access-application-cluster/web-ui-dashboard/
• Helm : https://helm.sh/docs/intro/quickstart/
• Kubernetes – Ingress Controller Nginx : https://kubernetes.github.io/ingress-nginx/
• Nginx – Ingress Controller : https://www.nginx.com/products/nginx/kubernetes-ingress-controller/