Gérer vos ressources Kubernetes avec Ansible

Ansible est un outil d’automatisation IT qui permet de déployer, configurer et orchestrer des infrastructures de manière simple et déclarative. Kubernetes, quant à lui, est la plateforme de référence pour l’orchestration de conteneurs. Associer les deux, c’est tirer parti d’Ansible pour automatiser la gestion des ressources Kubernetes : déploiements, services, secrets, etc.

Grâce au module k8s de la collection kubernetes.core, il devient possible de piloter un cluster Kubernetes directement depuis des playbooks Ansible, en intégrant ces tâches dans un pipeline CI/CD ou une stratégie d’infrastructure as code.

Prérequis pour gérer Kubernetes avec Ansible

Avant de pouvoir automatiser la gestion de Kubernetes avec Ansible, assurez-vous que votre environnement répond aux exigences suivantes.

1. Accès à un cluster Kubernetes : Vous devez disposer d’un cluster Kubernetes fonctionnel, qu’il soit local (par exemple, Minikube, Kind) ou distant. Assurez-vous que le cluster est accessible et opérationnel.

2. Configuration de l’authentification : Le module k8s prend en charge plusieurs méthodes d’authentification pour se connecter à l’API Kubernetes :

   • Fichier ~/.kube/config : Par défaut, Ansible utilise ce fichier pour l’authentification.
   • Variables d’environnement : Vous pouvez définir des variables telles que K8S_AUTH_API_KEY pour spécifier un token d’authentification.
   • Paramètres directs : Des paramètres comme api_key, username, password, ssl_ca_cert, cert_file, et key_file peuvent être utilisés pour une configuration plus fine.

3. Installation de la collection kubernetes.core : La collection kubernetes.core contient les modules nécessaires pour interagir avec Kubernetes. Installez-la avec la commande suivante :

ansible-galaxy collection install kubernetes.core

4. Dépendances Python requises : Le module k8s de la collection kubernetes.core nécessite certaines bibliothèques Python. Installez-les avec la commande suivante :

pip install pyyaml kubernetes

5. Kubectl installé : Sur la machine où Ansible s’exécute, le binaire kubectl doit être installé et accessible dans le PATH.

Avec ces prérequis en place, vous êtes prêt à utiliser Ansible pour automatiser la gestion de vos ressources Kubernetes.

Structure d’un playbook Ansible pour Kubernetes

Si vous avez suivi ma formation sur Ansible, vous savez que la structure d’un playbook est assez simple. Si ce n’est pas le cas, je vous invite à le faire avant de continuer.

Exemple de déploiement complet

Voici un playbook qui crée un namespace, déploie une application Nginx et expose celle-ci via un service :

---
- name: Déployer Nginx sur Kubernetes
  hosts: localhost
  gather_facts: no
  collections:
    - kubernetes.core

  tasks:
    - name: Créer un namespace
      kubernetes.core.k8s:
        state: present
        definition:
          apiVersion: v1
          kind: Namespace
          metadata:
            name: demo-nginx

    - name: Déployer Nginx
      kubernetes.core.k8s:
        state: present
        definition:
          apiVersion: apps/v1
          kind: Deployment
          metadata:
            name: nginx
            namespace: demo-nginx
          spec:
            replicas: 2
            selector:
              matchLabels:
                app: nginx
            template:
              metadata:
                labels:
                  app: nginx
              spec:
                containers:
                  - name: nginx
                    image: nginx:latest
                    ports:
                      - containerPort: 80

    - name: Exposer Nginx via un service
      kubernetes.core.k8s:
        state: present
        definition:
          apiVersion: v1
          kind: Service
          metadata:
            name: nginx-service
            namespace: demo-nginx
          spec:
            selector:
              app: nginx
            ports:
              - protocol: TCP
                port: 80
                targetPort: 80

Ce modèle est facilement réutilisable pour d’autres types de ressources comme les ConfigMap, Secret, Ingress, ou RBAC.

Paramètres essentiels du module k8s

Le module k8s est polyvalent et configurable, ce qui en fait un outil central pour piloter des ressources Kubernetes avec Ansible. Voici les paramètres clés à connaître.

• state : Contrôle l’état désiré de la ressource :

  • present : crée ou met à jour la ressource
  • absent : supprime la ressource
  • patched : applique un patch partiel

  state: present

• definition : Décrit la ressource Kubernetes directement dans le playbook, au format YAML ou JSON.

  definition:
    apiVersion: v1
    kind: Namespace
    metadata:
      name: test-ns

• src : Permet de charger un manifeste à partir d’un fichier YAML ou JSON externe.

  src: ./manifests/myapp.yaml

• namespace : Spécifie le namespace cible. Si absent, celui du manifeste est utilisé.

  namespace: mon-namespace

• kubeconfig : Chemin vers le fichier kubeconfig utilisé pour se connecter au cluster.

  kubeconfig: ~/.kube/config

• context : Permet de choisir un contexte kubeconfig spécifique, utile si vous gérez plusieurs clusters.

  context: my-cluster-admin

• Autres paramètres utiles :

  • wait: permet d’attendre que la ressource soit dans l’état souhaité
  • validate: active la validation du manifeste avant application
  • apply: force une application même si la ressource existe déjà

Une bonne compréhension de ces paramètres est essentielle pour écrire des playbooks robustes, fiables et réutilisables.

Utiliser le module k8s_info pour interroger Kubernetes

Le module k8s_info de la collection kubernetes.core permet d’interroger des ressources Kubernetes et de récupérer des informations détaillées. Ce module est essentiel pour construire des playbooks dynamiques et conditionnels.

k8s_info retourne une liste de ressources correspondant aux critères spécifiés (type, namespace, nom, etc.). Ces informations peuvent ensuite être utilisées pour contrôler le déroulement d’un playbook.

Récupérer toutes les ressources d’un type

- name: Lister tous les pods
  kubernetes.core.k8s_info:
    kind: Pod
    namespace: default
  register: pod_list

- name: Afficher les noms de pods
  debug:
    msg: "{{ item.metadata.name }}"
  loop: "{{ pod_list.resources }}"

Vérifier l’existence d’une ressource

- name: Vérifier si un service existe
  kubernetes.core.k8s_info:
    kind: Service
    name: myapp-service
    namespace: mon-namespace
  register: svc_info

- name: Déployer le service s’il n’existe pas
  when: svc_info.resources | length == 0
  kubernetes.core.k8s:
    state: present
    src: ./manifests/service.yaml

Lire des attributs spécifiques

Vous pouvez extraire des valeurs précises à partir des objets retournés. Exemple avec un Deployment :

- name: Obtenir les infos du déploiement
  kubernetes.core.k8s_info:
    kind: Deployment
    name: myapp
    namespace: mon-namespace
  register: deployment_data

- name: Afficher le nombre de replicas actifs
  debug:
    msg: "{{ deployment_data.resources[0].status.readyReplicas }}"

Utiliser des filtres Jinja

Exploitez la puissance de Jinja pour filtrer ou transformer les données extraites :

- name: Compter les pods en erreur
  debug:
    msg: >-
      {{ pod_list.resources | selectattr('status.phase', 'equalto', 'Failed') | list | length }}

Cas d’usage typiques

• Conditionner des déploiements en fonction de l’état d’une ressource
• Contrôler l’environnement avant d’appliquer un changement
• Générer des rapports d’état du cluster

Le module k8s_info est un outil indispensable pour rendre vos playbooks intelligents, réactifs et sûrs dans un contexte de production.

Bonnes pratiques pour gérer Kubernetes avec Ansible

L’automatisation avec Ansible doit rester simple, lisible et maintenable. Évitez les usines à gaz : privilégiez une approche claire et progressive.

1. Centraliser les manifestes Kubernetes

Regroupez tous vos fichiers YAML dans un répertoire bien identifié :

project/
└── manifests/
    ├── namespace.yaml
    ├── deployment.yaml
    ├── service.yaml

Utilisez le paramètre src pour les appliquer dans vos playbooks :

- name: Appliquer le déploiement
  kubernetes.core.k8s:
    state: present
    src: ./manifests/deployment.yaml

2. Utiliser des variables

Injectez dynamiquement les valeurs comme l’image, le namespace ou le nombre de réplicas :

vars:
  image: nginx:1.25
  replicas: 2

tasks:
  - name: Appliquer un modèle
    template:
      src: deployment.j2
      dest: /tmp/deployment.yaml

  - name: Appliquer la ressource
    kubernetes.core.k8s:
      state: present
      src: /tmp/deployment.yaml

3. Garder des rôles simples

Si vous utilisez des rôles Ansible, structurez-les de façon minimale. Un rôle doit faire une seule chose et la faire bien : déployer une app, créer des secrets, gérer un ingress…

4. Tester localement avec localhost

Développez et testez vos playbooks sur localhost, sans inventaire complexe :

- name: Test local
  hosts: localhost
  connection: local

5. Éviter les dépendances complexes

Installez uniquement les collections nécessaires. Pas besoin d’un écosystème complet pour manipuler des fichiers YAML et appeler l’API Kubernetes.

6. Documenter le playbook

Ajoutez des commentaires, des noms explicites, et regroupez les tâches logiquement. Un bon playbook se lit comme une histoire.

- name: Déployer nginx avec Ansible
  hosts: localhost
  tasks:
    - name: Créer le namespace nginx
      # Création du namespace de l'application
      ...

7. Séparer logique et contenu

Laissez Ansible gérer la logique d’exécution, et les fichiers YAML décrire les ressources Kubernetes. Ne surchargez pas vos playbooks avec trop de logique conditionnelle ou de boucles.

L’objectif : un système simple, prévisible et reproductible. Chaque modification doit être lisible et testable sans effort.

Conclusion

Avec la collection kubernetes.core, Ansible devient un outil puissant pour piloter Kubernetes de manière déclarative, reproductible et intégrée dans vos workflows DevOps. En combinant la simplicité des playbooks avec la flexibilité du module k8s, vous pouvez :

• déployer vos applications automatiquement,
• gérer les ressources critiques comme les services, secrets ou ingress,
• interroger l’état du cluster à tout moment,
• et intégrer facilement ces actions dans vos pipelines CI/CD.

Mais n’oubliez pas : la clarté prime sur la complexité. Gardez vos fichiers lisibles, vos structures simples, et vos automatisations maîtrisables. Ansible pour Kubernetes, ce n’est pas une usine à gaz — c’est une boîte à outils élégante pour administrateurs pragmatiques.