Gérer GKE efficacement avec Terraform et Kustomize (avec code)

La mise en place d'un cluster GKE / K8S est un processus complexe. Une bonne approche consiste à automatiser sa création sous forme d'artefact IAC. Nous utiliserons Terraform comme outil IAC dans cet article.

Mise en place de l'IAC

Créer des modules avec paramètres et attributs pour chaque ressource est la clé pour maintenir la cohérence (parité) entre environnements. Notre dépôt comportera 3 modules : 1. un module GKE Cluster avec deux node pools ; 2. un module nginx ingress controller s'appuyant sur le provisioner helm chart ; 3. un module kcert pour les certificats SSL Letsencrypt destinés à vos endpoints publics.

Le code de l'ensemble des modules ci-dessous est disponible dans notre dépôt à : https://github.com/agileguru/gke_nginx_kcert_quick_start

• Provisionner un cluster GKE avec plusieurs node-pools

Ce module contient main.tf, variables.tf et outputs.tf, respectivement pour le provisionnement, le paramétrage et les métadonnées réutilisables d'un cluster GKE.

Capture d'écran du module IAC Terraform GKE

• Installation du nginx ingress controller Ce module contient main.tf, variables.tf et un outputs.tf optionnel (vide), respectivement pour le provisionnement et le paramétrage du contrôleur nginx.

Capture d'écran du main.tf du provisioner IAC Terraform NGINX

• Installation du gestionnaire SSL kcert Letsencrypt Ce module contient main.tf, variables.tf et un outputs.tf optionnel (vide), respectivement pour le provisionnement et le paramétrage du contrôleur SSL kcert.

Capture d'écran du main.tf du provisioner IAC Terraform Kcert

• Tout orchestrer ensemble

Une fois les 3 modules terminés, nous créons un environnement k8s devops via le module devops, appelé depuis le main / root pour tout regrouper.

Capture d'écran du module d'environnement k8s Devops

Capture d'écran de l'orchestration root qui crée le module Devops

• Provisionner le cluster et les contrôleurs avec Terraform\* Modifiez le nom du projet, de la région et de la zone dans variables.tf

\* Modifiez le nom du bucket dans backend.tf après l'avoir créé dans la console GCP

\* Exécutez les commandes suivantes

terraform init

terraform plan -var-file=sample.tfvars (modifiez sample.tfvars si besoin)

terraform apply -var-file=sample.tfvars (modifiez sample.tfvars si besoin)

1. Une fois les commandes Terraform exécutées, vous récupérez l'adresse IP du LoadBalancer pour l'enregistrement du domaine.
2. Vous pouvez obtenir la configuration kubectl avec la commande…

gcloud container clusters get-credentials <nom du cluster> — zone <zone du cluster> — project <id du projet contenant le cluster>

Le cluster est désormais prêt à accueillir des workloads. Nous utiliserons le plugin Kustomize pour en simplifier la gestion. Prenons un cas d'usage simple pour cet article.

• Nous avons 2 applications, api-1 et api-2, basées sur l'image tutum/hello-world.
• Nous avons aussi 2 namespaces k8s correspondant aux environnements DEV et SIT.
• Nous devons déployer le service et l'exposer en https (ssl) avec les configurations, déploiements, services et mappings d'ingress correspondants.
• Tout cela doit être stocké dans un dépôt. Pour la démo, c'est dans notre dépôt à https://github.com/agileguru/kustomize_quickstart_demo

Étape 1 : créer la structure de dossiers

Dossiers de base des composants et des configurations

Étape 2 : personnaliser chaque environnement avec des overlays

Dossiers d'overlays pour les environnements via patch / merge avec kustomize.yaml

Étape 3 : modifier le mapping du nom d'hôte de l'Ingress

Modifiez le nom d'hôte dans dev-ingress-patch.json et sit-ingress-patch.json en y indiquant un hôte ou un domaine valide. Le résultat ressemble au code ci-dessous…

[\
    {\
        "op": "replace",\
        "path": "/spec/rules/0/host",\
        "value": "dev.agileguru.org"\
    },\
    {\
        "op": "replace",\
        "path": "/spec/tls/0/hosts/0",\
        "value": "dev.agileguru.org"\
    }\
]

[\
    {\
        "op": "replace",\
        "path": "/spec/rules/0/host",\
        "value": "sit.agileguru.org"\
    },\
    {\
        "op": "replace",\
        "path": "/spec/tls/0/hosts/0",\
        "value": "sit.agileguru.org"\
    }\
]

Étape 4 : déployer vos applications

$ kubectl apply -k overlays/dev
namespace/dev created
configmap/config-map-api-1 created
configmap/config-map-api-2 created
service/api-1-service created
service/api-2-service created
deployment.apps/api-1-deployment created
deployment.apps/api-2-deployment created

Étape 5 : désinstaller vos applications

$ kubectl delete -k overlays/dev
namespace "dev" deleted
configmap "config-map-api-1" deleted
configmap "config-map-api-2" deleted
service "api-1-service" deleted
service "api-2-service" deleted
deployment.apps "api-1-deployment" deleted
deployment.apps "api-2-deployment" deleted
ingress.networking.k8s.io "app-ingress" deleted

1. Ce qu'il faut faire

   — Laisser le nombre de réplicas à 0 dans la configuration de base

— Toujours préciser le namespace dans le kustomization.yaml de l'overlay

— Toujours faire un Dry Run avec sortie yaml pour valider le résultat

— Adopter de bonnes conventions de nommage pour les dossiers et les fichiers de manifest

— Isoler le mapping Ingress dans son propre dossier

— Toujours prévoir un override.yaml pour chaque composant. 2. Ce qu'il ne faut pas faire

— _Coder en dur le namespace dans les configurations de base_

— Mélanger les configurations et le code applicatif dans le même dossier

— Utiliser des branches Git pour la configuration des environnements (ce qu'on appelle la dérive de parité)

1. Dépôt de démarrage GKE Nginx Kcert : https://github.com/agileguru/gke_nginx_kcert_quick_start
2. Dépôt de démarrage rapide Kustomize : https://github.com/agileguru/kustomize_quickstart_demo
3. Documentation Kustomize : https://kustomize.io/
4. GitHub Kcert : https://github.com/nabsul/kcert
5. Nginx Controller : https://kubernetes.github.io/ingress-nginx/
6. LetsEncrypt : https://letsencrypt.org/