Introduction à Kubernetes

Dans la grande guerre des orchestrateurs de containers, Kubernetes, solution créée par Google, propose des fonctionnalités très intéressantes. Ça fait un moment que je voulais tester, mais je n’en avais pas encore eu l’occasion. J’ai donc profité de l’offre de Google Cloud Engine pour sauter le pas (deux mois gratuits).

Kubernetes est un orchestrateur d’hôtes Docker. Il permet donc de manager des containers entre vos différentes hôtes et de gérer plusieurs types de services tel que du load-balancing ou de la haute disponibilité. Il utilise le système de clées-valeurs distribué Etcd (de CoreOS) qui permet de garder un oeil sur tous les services du cluster.

Voici un schéma qui résume bien l’architecture de Kubernetes :

Un océan de containers managés et distribués dynamiquement sur vos hôtes

Dans ce tutoriel, nous créerons notre premier cluster Docker dans G.C.E (Google Container Engine), puis nous déploierons une application en load-balancing à l’intérieur de notre cluster (un site statique Nginx). Nous utiliserons donc deux outils en ligne de commande, gcloud qui permet de manager votre cloud Google et kubectl qui vous donne la main sur votre cluster Kubernetes. Pour gérer votre cluster, il n’est pas nécessaire de se connecter en SSH sur vos serveurs, kubectl se connecte à l’API Server de Kubernetes vous pourrez donc effectuez toutes les commandes directement dans votre shell.

Pour commencer, il faut se rendre sur G.C.E avec votre compte Google et créer notre premier cluster. Vous pouvez faire cela gratuitement, car Google offre un essai de 300$ sur 2 mois d’utilisation, parfait pour tester correctement leurs services. On va tout d’abord créer un projet et ensuite se rendre dans Google Container Engine pour créer un cluster. Pour ma part, j’ai pris 4 VM au total, le master Kubernetes et 3 hôtes Docker.

Maintenant que tout est prêt, on va installer les deux outils en ligne de commande sur notre système afin de manager notre cluster. On commence par gcloud :

curl https://sdk.cloud.google.com | bash

Une fois installé, on va l’initialiser, c’est-à-dire le relier à notre compte Google puis installer l’outil kubectl pour administrer Kubernetes :

gcloud init gcloud components install kubectl gcloud container clusters get-credentials lab1-ouvrard

Avec cette dernière commande, on relie notre cluster à kubectl afin de pouvoir l’administrer.

Pour vérifier les caractéristiques de votre cluster (et qu’il tourne correctement), on lance :

kubectl cluster-info

Comme expliqué au début, ce tutoriel est une introduction donc je ne détaillerai pas un déploiement compliqué avec des réplications automatiques et tout. Cela viendra dans un autre tutoriel. Pour commencer nous allons essayer de déployer deux containers Nginx puis de faire du load-balancing entre ces deux containers depuis une IP publique (fournit par Google).

Avant de commencer, il y a pas mal de notions à connaître dans Kubernetes, je les détaillerai au besoin. Dans ce tutoriel, nous utiliserons un Pod, qui correspond globalement à une application donc à un ou plusieurs containers et un Service qui permet d’exposer à l’extérieur du cluster un service interne (notre pod).

Vous pouvez voir la liste des pods et des services comme ceci :

kubectl get pod kubectl get service

Maintenant, on va arrêter de tourner autour du pot, on va donc lancer notre premier Pod de l’image Docker Nginx (vous pouvez changer) avec deux Replicas, ce qui signifie que le Pod sera répliqué deux fois (peut importe où dans notre cluster) et finalement on veut que nos Pods soient servis par un Service de type Load-Balancer. Grâce à la magie de Kubernetes, cela se fais en une commande !

kubectl run my-nginx --image=nginx --replicas=2 --port=80 --expose --service-overrides='{ "spec": { "type": "LoadBalancer" } }'

Dans cette commande kubectl run, qui utilise la même syntaxe qu’un docker run, on peut facilement la modifier pour ajouter des infos comme les volumes, les ports, les variables d’environnements…

Vous pouvez maintenant interroger vos Pods, vous devriez en avoir deux :

On va maintenant vérifier les services, Google devrait vous attribuer une IP publique au bout d’une trentaine de secondes :

On constate donc que notre Pod Nginx est correctement déployé et joignable sur Internet.

L’intérêt d’avoir des Pods répliqués, c’est que si on en supprime un (ou qu’il se casse la guele), vu qu’on à précisé qu’on en voulait deux, il se recréer automatiquement :

Kubernetes surveille donc qu’il y ait toujours deux containers Nginx lancés dans notre cluster, peu importe l’hôte. On va maintenant pouvoir vérifier que le load-balancing fonctionne correctement, j’ai donc pour cela modifié un petit peu la page d’accueil Nginx afin de savoir sur quel pod on est :

On constate bien qu’une fois sur deux (environ) c’est des pods différents qui répondent à la requête. On aurait pu préciser 100 Replicas, cela aurait eu le même effet.

Voilà donc comment on peut faire un simple déploiement dans un cluster Kubernetes. Cependant, pour des applications plus complexes qu’un simple site statique sur Nginx, cela peut s’avérer plus compliqué, car il faut prendre en compte les données montées dans des volumes, le nombre de réplicas souhaités, comment load-balancer le tout et exposer les bons services… Bref tout cela viendra dans un second tutoriel. Si vous avez la moindre question, n’hésitez pas !

Pour nettoyer les instances créer (pour pas être facturé dans le vide), on lance ces commandes puis on supprime le cluster et le projet dans la console Google Cloud.

kubectl delete deployment my-nginx kubectl delete svc my-nginx