Objectifs du chapitre et prérequis

Pour aborder ce chapitre, vous devez maîtriser un minimum de compétences dans l’administration de Linux ainsi que dans l’utilisation de la ligne de commandes.

Ce chapitre a pour but de mettre en place un environnement de test local avec Minikube et kubectl. Si vous avez déjà un cluster fonctionnel, vous pouvez très bien sauter la partie consacrée à Minikube pour passer à la partie concernant kubectl.

Une autre partie du chapitre aura pour but de préparer votre environnement afin qu’il soit le plus efficace possible avec les mécanismes d’autocomplétion (avec bash ou zsh).

Enfin, certaines notions requises seront abordées sur le format YAML.

Alternative à l’installation en local

1. Pourquoi ces alternatives ?

La mise en place de Kubernetes n’est pas une opération simple et réclame de nombreuses connaissances au niveau système. Il est par ailleurs fortement recommandé d’avoir de solides connaissances sur Linux ou au moins Unix en général :

gestion des process d’un système ;
gestion des utilisateurs ;
gestion des espaces disques.

Dans le cas où l’installation des commandes kubectl ou la mise en place de Minikube pourrait constituer un obstacle, il existe des alternatives tout à fait viables pour aborder le fonctionnement de Kubernetes.

2. Utilisation d’un service managé

La plupart des fournisseurs d’informatique dans les nuages (en anglais cloud provider) offrent des clusters Kubernetes sous forme de services managés avec des crédits d’utilisation.

Au moment de la rédaction de ce livre, les principaux fournisseurs proposaient les offres suivantes :

300 $ chez Google à consommer sur un an ;
200 $ chez Azure à consommer sur un an ;
période d’essai gratuite chez Amazon pendant 1 an.

Autre aspect à prendre en compte : Google et Azure proposent une console de lignes de commandes directement depuis l’interface web du navigateur. Il devient ainsi possible de tester complètement le service sans...

Mise en place de la commande kubectl

1. À quoi sert kubectl ?

Kubernetes s’administre à l’aide d’une API. Cette dernière est disponible au travers d’une interface HTTP et peut tout à fait être utilisée à l’aide d’un langage de programmation tel que Python, Java ou via des appels curl en shell Unix.

Toutefois, kubectl reste beaucoup plus simple à utiliser pour les premières interactions avec un cluster Kubernetes. En effet, ce dernier permet de prendre en charge toutes les opérations courantes du type consultation, création ou suppression d’éléments dans un cluster ainsi que les mécanismes d’authentification.

2. Installation de kubectl

Les instructions d’installation sont récupérables sur l’emplacement suivant : https://kubernetes.io/docs/tasks/tools/#install-kubectl

a. Installation sous Debian/Ubuntu

L’installation va passer par l’installation d’un package Debian. Ci-dessous les commandes à passer pour réaliser l’installation de cet outil :

Ajout des clés :

$ curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key |\ 
     sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

Déclaration des sources Kubernetes :

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] 
https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /' | \ 
     sudo tee /etc/apt/sources.list.d/kubernetes.list

Mise à jour des sources de packages :

$ sudo apt update

Installation du package kubectl :

$ sudo apt install kubectl

b. Installation sous CentOS/RHEL ou Fedora

L’installation de kubectl va passer par l’installation d’un package RPM. Ci-dessous les opérations à réaliser :

Déclaration d’un fichier /etc/yum.repos.d/kubernetes.repo pointant sur le dépôt de RPM :

cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo 
[kubernetes] 
name=Kubernetes 
baseurl=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/ 
enabled=1 
gpgcheck=1 
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/repodata/repomd.xml.key 
EOF

Installation du package RPM :

yum install -y kubectl

c. Installation à l’aide d’Arkade

L’administration de Kubernetes réclame...

Mise en place de Minikube

1. Pourquoi faire appel à Minikube ?

Minikube est un projet qui a pour but de fournir un environnement bac à sable à un utilisateur pour expérimenter le fonctionnement de Kubernetes.

Ce mécanisme n’a pas vocation à servir à l’hébergement d’application en production, mais à expérimenter en toute sécurité le fonctionnement de Kubernetes.

À noter qu’il existe des alternatives comme par exemple k3s, kind ou le client Docker.

2. Téléchargement et installation de Minikube

Minikube se présente sous la forme d’un binaire à télécharger. Il faut le placer dans les chemins de l’utilisateur (variable d’environnement PATH) afin de pouvoir s’en servir.

Dans le cas où Arkade serait déjà présent, utilisez l’instruction suivante :

$ arkade get minikube

À défaut, utilisez les instructions suivantes afin de réaliser l’installation :

Téléchargement de Minikube :

$ MINIKUBE_URL=https://storage.googleapis.com/minikube/releases 
$ curl -Lo minikube \ 
          $MINIKUBE_URL/latest/minikube-linux-amd64

Déplacement du fichier Minikube dans /usr/local/bin :

sudo mv minikube /usr/local/bin

Positionnement des droits d’exécution :

sudo chmod...

Installation du cluster Kubernetes avec Minikube

1. Options de lancement

L’installation du cluster Kubernetes par Minikube se fait soit à l’aide d’un conteneur Docker ou d’une machine virtuelle (pilotée par un hyperviseur). Par défaut, Minikube va chercher à détecter automatiquement la meilleure solution. Par la suite, un exemple sera donné en s’appuyant sur Docker ou à l’aide d’un hyperviseur.

À noter qu’il existe de nombreux choix d’hyperviseurs. Ce livre abordera uniquement le cas de VirtualBox et KVM sous Linux.

Les deux hyperviseurs sont relativement similaires. Par conséquent, il n’est pas nécessaire d’installer les deux. Choisissez la solution qui vous conviendra le mieux. Dans le cas où vous n’auriez aucun des deux, privilégiez la solution s’appuyant sur Docker.

2. Installation de Docker

a. Installation de Docker Community Edition sur Ubuntu

Docker propose ses propres binaires sous forme de paquets. Dans le cas des distributions compatibles Ubuntu, cette installation se fait à l’aide des instructions suivantes :

Ajout de paquets prérequis :

sudo apt-get install \  
    apt-transport-https \  
    ca-certificates \  
    curl \  
    gnupg-agent \  
    software-properties-common

Récupération de la clé du dépôt de paquets Docker :

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | 
sudo apt-key add -

Ajout de la source de paquets Docker :

$ sudo add-apt-repository \  
  "deb [arch=amd64] https://download.docker.com/linux/ubuntu \  
  $(lsb_release -cs) \  
  stable"

Mise à jour de la liste des paquets :

$ sudo apt update

Enfin, installation de Docker :

$ sudo apt-get install docker-ce docker-ce-cli containerd.io

Pour plus de détails, n’hésitez pas à consulter l’adresse suivante : https://docs.docker.com/engine/install/ubuntu/

b. Installation alternative

Dans le cas de l’utilisation d’une autre distribution Linux ou de l’utilisation d’un autre type de système d’exploitation (Windows ou macOS), n’hésitez pas à visiter la documentation officielle à l’adresse suivante : https://docs.docker.com/...

Quelques notions sur le format YAML

La commande kubectl permet d’interagir avec Kubernetes afin de créer certains objets (déploiement, adresse de services, proxy inverse, etc.). En revanche, dès qu’il s’agit de pousser la gestion un peu plus loin (automatisation, mise à jour d’éléments), il devient nécessaire de le faire avec des fichiers YAML.

Pour l’essentiel, le YAML permet d’écrire des structures de données. Ces données peuvent être sous la forme de listes ou de dictionnaires. Ce langage permet d’écrire les mêmes structures de plusieurs façons en fonction de l’approche désirée : lisibilité ou compacité (même si, généralement, la lisibilité est à privilégier).

Le format JSON peut être utilisé en l’état dans du YAML, la principale différence entre le JSON et la notation YAML étant surtout au niveau de la lisibilité.

1. Déclaration de couples clés/valeurs

Le langage YAML sert à déclarer des couples clés/valeurs. La clé se présente sous la forme d’une suite de caractères suivie de deux points (:) suivis eux-mêmes d’un caractère espace.

Le nom de ces clés n’a pas de limitation. En revanche, il est préférable de privilégier des noms simples faisant appel à des lettres, des chiffres et les caractères tirets bas (_).

Exemples de noms de clés : kind, apiVersion, spec, data...

Le contenu est ensuite stocké à la suite de la clé....

Installation de l’environnement Kubernetes