Tutoriel : Comment installer Kubernetes avec rke ?

Publié le

Dans un précédant article, nous avions vu que Kubernetes était très facile à installer en utilisant l'outil rke de chez Rancher.

Nous allons maintenant installer Kubernetes dans un labo en local.

Création du labo

Nous allons utiliser Vagrant pour créer notre environnement de test local.

Article connexe : Comment créer un labo d’admin DevOps en local avec Vagrant ?

On commence par créer un fichier Vagrantfile avec le contenu suivant :

NODE_COUNT = 2
IMAGE = "ubuntu/focal64"

Vagrant.configure("2") do |config|
  config.vm.define "control-plane" do |server|
    server.vm.box = IMAGE
    server.vm.hostname = "control-plane"
    server.vm.network :private_network, ip: "10.0.0.10"
  end

  (1..NODE_COUNT).each do |server_index|
    config.vm.define "worker-#{server_index}" do |node|
      node.vm.box = IMAGE
      node.vm.hostname = "worker-#{server_index}"
      node.vm.network :private_network, ip: "10.0.0.#{server_index + 10}"
    end
  end
end

Grâce à ce fichier, nous définissons 3 machines virtuelles qui vont être déployées dans VirtualBox (le provider par défaut de Vagrant) :

  • 1 machine de control-plane (qui va héberger etcd, et l'api-server de Kubernetes). Cette machine s'appelle « control-plane » et a l'adresse IP 10.0.0.10.
  • 2 machines destinées à exécuter les tâches via Docker, elles s'appellent « worker-1 » et « worker-2 » et ont respectivement les adresse IP 10.0.0.11 et 10.0.0.12. On peut changer le nombre de workers en modifiant la variable NODE_COUNT à la première ligne.

Toutes ces machines virtuelles fonctionnent sous ubuntu focal (20.04).

Une fois le Vagrantfile créé, il ne reste plus qu'à créer les machines virtuelles en lançant la commande vagrant up. Cette commande va d'abord télécharger la box ubuntu 20.04, donc sera plus ou moins longue en fonction de la vitesse de votre connexion Internet.

Au bout de quelques minutes, on arrive à quelque chose comme ça :

2021-01-15-rke-vagrant-up.png

On peut récupérer les chemins d'accès aux clés privées SSH de vagrant via la commande vagrant ssh-key:

philippe@philBook ~/labo-rke> vagrant ssh-config
Host control-plane
  HostName 127.0.0.1
  User vagrant
  Port 2222
  UserKnownHostsFile /dev/null
  StrictHostKeyChecking no
  PasswordAuthentication no
  IdentityFile /Users/philippe/labo-rke/.vagrant/machines/control-plane/virtualbox/private_key
  IdentitiesOnly yes
  LogLevel FATAL

Host worker-1
  HostName 127.0.0.1
  User vagrant
  Port 2200
  UserKnownHostsFile /dev/null
  StrictHostKeyChecking no
  PasswordAuthentication no
  IdentityFile /Users/philippe/labo-rke/.vagrant/machines/worker-1/virtualbox/private_key
  IdentitiesOnly yes
  LogLevel FATAL

Host worker-2
  HostName 127.0.0.1
  User vagrant
  Port 2201
  UserKnownHostsFile /dev/null
  StrictHostKeyChecking no
  PasswordAuthentication no
  IdentityFile /Users/philippe/labo-rke/.vagrant/machines/worker-2/virtualbox/private_key
  IdentitiesOnly yes
  LogLevel FATAL

La section IdentityFile de chaque Host doit être mise de côté. On en aura besoin pour faire la mise en place de rke. Dans mon cas, ces clés sont aux emplacements suivants :

  • /Users/philippe/labo-rke/.vagrant/machines/control-plane/virtualbox/private_key
  • /Users/philippe/labo-rke/.vagrant/machines/worker-1/virtualbox/private_key
  • /Users/philippe/labo-rke/.vagrant/machines/worker-2/virtualbox/private_key

Installation de Docker

rke a besoin d'avoir Docker préinstallé pour faire fonctionne le cluster. On applique la procédure disponible dans la documentation de Docker.

On se connecte au serveur de control-plane vagrant ssh control-plane:

sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common
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 update
sudo apt-get install docker-ce docker-ce-cli containerd.io

# On autorise l'utilisateur vagrant à executer docker (en l'ajoutant au groupe docker)
sudo usermod -aG docker vagrant

# On a terminé avec l'installation de Docker
exit

On répète l'opération sur les workers avec vagrant ssh worker-1 et vagrant ssh worker-2.

Installation de Kubernetes via rke

Nous avons besoin de télécharger le binaire de rke. On se rend sur la page du projet sur Github :
On va dans la section Releases pour télécharger la version adaptée à notre plateforme.

2021-01-15_rke-github.png

Ici on peut voir les différentes options. rke_darwin-amd64 concerne macOS sur processeur Intel. Les autres archives ont un nom assez parlant.

2021-01-15-rke-releases.png

Une fois l'archive téléchargée (pour ma part c'est rke_darwin-amd64), on le déplace dans le dossier de notre labo en le renommant en rke et on lui donne les droits d'exécution.

mv ~/Downloads/rke_darwin-amd64 rke
chmod +x rke

Sous macOS, il est nécessaire d'autoriser l'exécution de rke dans Gatekeeper. Cet article explique comment faire.

Nous préparons ensuite un fichier cluster.yml qui va être utilisé par rke. Attention, l'extension du fichier est bien yml et non yaml. Le contenu de ce fichier est le suivant :

nodes:
  - address: 10.0.0.10
    user: vagrant
    ssh_key_path: /Users/philippe/labo-rke/.vagrant/machines/control-plane/virtualbox/private_key
    role:
      - controlplane
      - etcd
  - address: 10.0.0.11
    user: vagrant
    ssh_key_path: /Users/philippe/labo-rke/.vagrant/machines/worker-1/virtualbox/private_key
    role:
      - worker
  - address: 10.0.0.12
    user: vagrant
    ssh_key_path: /Users/philippe/labo-rke/.vagrant/machines/worker-2/virtualbox/private_key
    role:
      - worker

ignore_docker_version: true

Il faut penser à adapter les valeurs de ssh_key_path avec celles qui ont été trouvées via vagrant ssh-config.

On définit la machine 10.0.0.10 comme hébergeant le controlplane et etcd. Cette machine va être le cerveau du cluster Kubernetes. C'est dans etcd qu'est stocké l'état du cluster, et c'est le controlplane (qui comprend entre autre l'api server de Kubernetes) qui va recevoir les commandes de déploiement.

On définit les deux workers 10.0.0.11 et 10.0.0.12. Ce sont ces machines qui vont exécuter les containers.

On déclare que rke ne doit pas vérifier quelle version de Docker est installée. Pour chaque version de rke, seulement certaines version de Docker sont supportées officiellement. En production, l'idéal est d'utiliser une version de Docker supportée.

Dans notre dossier on arrive à ce résultat si on fait un ls -lah:

philippe@philBook ~/labo-rke> ls -lah
total 94288
drwxr-xr-x   6 philippe  staff   192B Jan  6 23:37 ./
drwxr-xr-x+ 62 philippe  staff   1.9K Jan  6 22:27 ../
drwxr-xr-x   4 philippe  staff   128B Jan  6 22:28 .vagrant/
-rw-r--r--   1 philippe  staff   519B Jan  6 23:37 Vagrantfile
-rw-r--r--   1 philippe  staff   221B Jan  6 23:37 cluster.yml
-rwxr-xr-x@  1 philippe  staff    45M Jan  6 22:29 rke*

Il ne reste plus qu'à lancer rke : ./rke up.

Au bout de quelques minutes, on arrive à ce résultat :

2021-01-15-rke-installation-complete.png

On a des warnings liés au déploiement des add-ons. Ceux-ci sont dus au fait que les déploiements sont assez lents dans les machines virtuelles. Normalement, les déploiements se font correctement (il faut juste attendre un peu plus). Vous pouvez noter que sur les machines virtuelles d'un cloud provider, ces warnings n'apparaissent pas.

Vérification de l'installation

Si on liste le contenu de notre labo, on remarque que rke a créé un fichier kube_config_cluster.yml :

philippe@philBook ~/labo-rke> ls -lah
total 94504
drwxr-xr-x   8 philippe  staff   256B Jan  7 13:22 ./
drwxr-xr-x+ 62 philippe  staff   1.9K Jan  6 22:27 ../
drwxr-xr-x   4 philippe  staff   128B Jan  6 22:28 .vagrant/
-rw-r--r--   1 philippe  staff   518B Jan  7 12:34 Vagrantfile
-rw-r-----   1 philippe  staff    99K Jan  7 13:25 cluster.rkestate
-rw-r--r--   1 philippe  staff   537B Jan  7 13:10 cluster.yml
-rw-r-----   1 philippe  staff   5.3K Jan  7 13:22 kube_config_cluster.yml
-rwxr-xr-x@  1 philippe  staff    45M Jan  6 22:29 rke*

Ce fichier permet l'accès au cluster Kubernetes par kubectl. On installe kubectl sur notre machine. La procédure à suivre se trouve ici.

Une fois installé, on peut vérifier que tous les services de base de Kubernetes sont fonctionnels :

philippe@philBook ~/labo-rke> kubectl --kubeconfig ./kube_config_cluster.yml get pods --all-namespaces
NAMESPACE       NAME                                      READY   STATUS      RESTARTS   AGE
ingress-nginx   default-http-backend-67cf578fc4-xpgx9     1/1     Running     0          9m8s
ingress-nginx   nginx-ingress-controller-d488l            1/1     Running     0          10m
ingress-nginx   nginx-ingress-controller-nk2lg            1/1     Running     0          9m8s
kube-system     canal-l582m                               2/2     Running     0          13m
kube-system     canal-ncpwj                               2/2     Running     0          13m
kube-system     canal-tgrtq                               2/2     Running     0          13m
kube-system     coredns-7c5566588d-hh6x5                  1/1     Running     0          11m
kube-system     coredns-7c5566588d-t296w                  1/1     Running     0          13m
kube-system     coredns-autoscaler-65bfc8d47d-5r46h       1/1     Running     0          13m
kube-system     metrics-server-6b55c64f86-tnqtn           1/1     Running     0          11m
kube-system     rke-coredns-addon-deploy-job-zg5vd        0/1     Completed   0          13m
kube-system     rke-ingress-controller-deploy-job-xqwhp   0/1     Completed   0          11m
kube-system     rke-metrics-addon-deploy-job-7h2pq        0/1     Completed   0          12m
kube-system     rke-network-plugin-deploy-job-mkc8s       0/1     Completed   0          13m

Tout les Pods sont en statut Running. Notre cluster est prêt.

Destruction du labo

On peut détruire complètement le labo avec la commande vagrant destroy.

Conclusion

Installer Kubernetes via rke de Rancher est une opération rapide. Toute la complexité de l'installation est cachée par l'outil.

La prochaine étape dans notre process d'installation de Kubernetes serait d'automatiser le processus en utilisant un outil d'IaC (Infrastructure as Code).

Dans un prochain article, on verra comment faire avec Terraform d'Hashicorp.

PHILIPPE CHEPY

Administrateur Système et Développeur