Un Cluster Kubernetes custom sur GCP en 7 minutes avec Terraform et Ansible

L’application que je développe chez mon client est déployée sur Kubernetes. Ce n’est pas la dernière version et curieux de nature, j’ai voulu me tenir à jour, c’est pourquoi je me suis intéressé à Kubernetes The Hard Way. Je vous encourage à regarder ce projet si vous souhaitez comprendre le fonctionnement interne et les différents composants de Kubernetes. Vous saurez comment réaliser l’installation d’un cluster Kubernetes et même d’en automatiser toutes les étapes.

Kubernetes The Hard Way

En résumé, ce projet vous permet de monter un cluster Kubernetes sur Google Compute Engine en déroulant chaque étape du déploiement :

• Provisioning des VMs
• Création des certificats
• Configuration du réseau
• Déploiement et configuration des composants sur les controllers
  • etcd – le store clé-valeur utilisé pour stocker les données du cluster
  • kube-apiserver – l’interface entre le store et les composants
  • kube-controller-manager – la boucle de contrôle de l’état du cluster
  • kube-scheduler – le gestionnaire pour le positionnement des ressources sur les nœuds du cluster

• Déploiement et configuration des composants sur les workers
  • kubelet – l’agent du nœud, il y gère les conteneurs
  • kube-proxy – l’interface entre les services du nœud et
  • cri-containerd – le runtime de conteneur

Une fois ce tutoriel déroulé, j’ai souhaité l’automatiser. C’était également pour moi l’occasion d’utiliser Terraform et Ansible.

Les Outils

Terraform est un projet d’HashiCorp. Il vous permettra d’automatiser la création de ressources sur le Cloud en utilisant des descripteurs façon Infra as Code. Dans notre cas, on l’utilisera pour créer les machines virtuelles et configurer le réseau sur Google Cloud Engine.
Ansible lui, nous servira à déployer les composants nécessaires sur chaque serveur en fonction de leur rôle (controller ou worker).
Au passage, j’ai également découvert l’utilitaire cfssl qui simplifie grandement la gestion de certificats à partir de fichiers de configuration json. Par exemple pour générer le certificat de notre autorité et sa clé privée, on utilisera le fichier de configuration suivant :

{
  "CN": "Kubernetes",
  "key": {
    "algo": "rsa",
    "size": 2048
  },
  "names": [
    {
      "C": "FR",
      "L": "Nantes",
      "O": "system:masters",
      "O": "Kubernetes",
      "ST": "Loire-Atlantique"
    }
  ]
}

Et la commande suivante :

cfssl gencert -initca ca-csr.json | cfssljson -bare ca

C’est cet utilitaire qu’on utilisera pour mettre en place la PKI utilisée dans ce projet.
Pour simplifier l’utilisation du projet, l’ensemble de ces outils seront directement intégrés dans une image docker.
 

Utilisation

L’ensemble du projet est disponible sur Github, nous allons voir brièvement comment l’utiliser. N’hésitez pas à l’essayer !
Commençons par clone le dépôt :

git clone https://github.com/Zenika/k8s-on-gce.git
cd k8s-on-gce

Ensuite, configurons nos identifiants Google Cloud. Allons sur cette page et suivons les instructions de création de compte de service et la clé associée.
Téléchargeons le fichier adc.json et copions-le dans le répertoire app.
Modifions le fichier profile pour définir le projet, la région et la zone Google Cloud à utiliser :

export GCLOUD_PROJECT=<VOTRE_PROJET>
export GCLOUD_REGION= # Exemple europe-west1
export GCLOUD_ZONE= # Exemple europe-west1-b

Lançons alors la commande ./in.sh qui va lancer un conteneur docker avec les outils nécessaires.
Dans ce conteneur, nous pouvons obtenir la liste des régions et des zones disponibles avec les commandes :

gcloud compute zones list
gcloud compute regions list

Nous pouvons ensuite lancer la commande ./create.sh
Cette commande va dérouler les étapes nécessaires à la création du cluster. La numérotation des étapes correspond à celle du projet d’origine. Les étapes 1 et 2 concernant les prérequis et l’installation des outils ne sont pas détaillées ici, car elles sont prises en compte dans l’image Docker que nous utilisons.
En premier lieu, nous créons une paire de clé ssh pour accéder à nos VMs (⚠️ attention, la clé privée est créée sans passphrase).
Ensuite, nous allons utiliser Terraform pour créer l’ensemble des ressources nécessaires :

• Machines virtuelles
• Configuration réseau
• Règles de firewall
• Load balancer pour accéder au cluster

La description de ces ressources est présente dans le fichier 03-provisioning/kube.tf
La commande terraform init  initialise l’environnement Terraform et va télécharger les plugins liés au provider (Google Cloud Platform dans notre cas)
La commande suivante lance la création des ressources avec nos paramètres :

terraform apply -auto-approve -var "gce_zone=${GCLOUD_ZONE}" 03-provisioning

S’en suivent, trois étapes de préparation :

• 04-certs : La création des certificats utilisés pour sécuriser et authentifier les accès entre les différents composants et depuis l’extérieur du cluster
• 05-kubeconfig : La génération de la configuration utilisée par kubelet et kube-proxy sur chacun des workers
• 06-encryption : La génération d’une clé utilisée pour chiffrer les Secrets Kubernetes du cluster.

Et une étape ajoutée pour la configuration d’Ansible 00-ansible pour générer l’inventaire des machines sur lesquelles sera déroulé le déploiement.
Nous pouvons alors passer à l’étape 07-etcd et le lancement de notre premier playbook Ansible qui va déployer etcd sur chaque nœud controller du cluster.
Lors de l’étape 08-kube-controller nous finissons le déploiement des composants du controller (kube-apiserver, kube-controller-manager, kube-scheduler), toujours via un playbook Ansible.
C’est maintenant au tour du playbook de déploiement des workers (kubelet, kube-proxy, cri-containerd) : 09-kubelet.
Il nous faut ensuite configurer notre propre client 10-kubectl, afin qu’il pointe vers notre cluster et qu’il utilise les bons certificats.
Les pods déployés sur les différents nœuds recevront une adresse IP dans un réseau lié au nœud sur lequel ils seront créés. L’étape 11-network-conf nous permet de configurer les routes utilisées par les pods pour communiquer.
Enfin, nous déployons 12-kube-dns qui permettra d’accéder aux services directement par leur nom depuis l’intérieur du cluster.
Notre cluster est maintenant accessible via le client kubectl !
Par exemple, si nous souhaitons consulter l’état des nœuds worker du cluster, il suffit de lancer la commande :

kubectl get nodes

 
Le répertoire 13-addons contient le nécessaire pour déployer des compléments sur notre cluster :

• Un dashboard qui permet de visualiser l’état du cluster et des ressources qu’il héberge
• L’Ingress Traefik qui permet d’exposer les services à l’extérieur du cluster.

Conclusion

Certes, il existe une manière beaucoup plus simple d’utiliser Kubernetes sur GCP, mais le fait de décrire l’ensemble des étapes nécessaires à la création d’un cluster Kubernetes permet de mieux comprendre le rôle de chaque composant et comment la magie opère 😉
Cela vous permet également d’utiliser vos propres versions ou variantes des outils sans être contraint par celles proposées sur GCP ou un autre Cloud Provider.