Gérer vos contextes Kubernetes avec Kubie

Kubie est un outil puissant pour simplifier la gestion des contextes et namespaces Kubernetes tout en réduisant les erreurs. Grâce à ses sessions isolées, il permet de travailler en toute sécurité sur plusieurs clusters sans modifier la configuration globale. Son intégration avec les principaux shells, sa personnalisation avancée et sa gestion automatique des kubeconfigs en font un incontournable pour les administrateurs Kubernetes.

Kubie, qu’est-ce que c’est ?

Présentation de Kubie et ses avantages

Kubie est un outil en ligne de commande qui facilite la gestion des contextes Kubernetes et des namespaces. Contrairement à l’approche traditionnelle avec kubectl config use-context et kubens, Kubie offre une gestion plus fluide et sécurisée en permettant d’ouvrir des sessions isolées pour chaque contexte.

Avec Kubie, vous pouvez :

Passer d’un contexte Kubernetes à un autre sans modifier la configuration globale.
Changer de namespace de manière temporaire sans affecter d’autres sessions.
Travailler simultanément sur plusieurs clusters sans risque d’erreur.
Profiter d’une intégration fluide avec kubectl et les principaux shells (bash, zsh, fish).

Kubie est particulièrement utile pour les administrateurs système, les ingénieurs DevOps et toute personne gérant plusieurs clusters au quotidien.

Comparaison avec kubectx et kubens

Les outils kubectx et kubens sont souvent utilisés pour naviguer entre les contextes et namespaces. Cependant, ils modifient directement la configuration Kubernetes, ce qui peut être problématique dans certains cas.

Fonctionnalité	Kubie	kubectx / kubens
Changement de contexte	✔ Sessions temporaires	✘ Modifie `~/.kube/config`
Gestion des namespaces	✔ Sessions isolées	✔ Mais globalement modifié
Sécurité	✔ Moins de risque d’erreur	✘ Risque d’impacter d’autres sessions
Compatibilité	✔ `kubectl`, `zsh`, `bash`, `fish`	✔ `kubectl`, `bash`, `zsh`

En résumé, si vous travaillez avec plusieurs clusters et souhaitez éviter les erreurs de contexte, Kubie est une alternative plus robuste et sécurisée.

Installation de Kubie

Prérequis

Avant d’installer Kubie, assurez-vous d’avoir :

Un système Linux, macOS ou Windows (via WSL)
kubectl installé et configuré
Un accès aux fichiers de configuration Kubernetes (~/.kube/config)

Installation sous Linux

Sur Linux, vous pouvez installer Kubie en téléchargeant le binaire depuis le dépôt GitHub officiel.

Téléchargez la dernière version stable :

curl -Lo kubie https://github.com/sbstp/kubie/releases/latest/download/kubie-linux-amd64

Donnez les permissions d’exécution :
Fenêtre de terminal
```
chmod +x kubie
```
Déplacez-le dans un répertoire accessible (/usr/local/bin par exemple) :
Fenêtre de terminal
```
sudo install kubie /usr/local/bin/
```
Vérifiez l’installation :
Fenêtre de terminal
```
kubie --version
kubie 0.24.1
```

Configuration de Kubie

Kubie propose plusieurs options de configuration permettant de personnaliser son comportement, notamment en ce qui concerne la gestion des contextes, l’affichage du prompt et la prise en charge des fichiers kubeconfig multiples.

Kubie utilise un fichier YAML pour sa configuration, situé par défaut dans :

~/.kube/kubie.yaml

Ce fichier permet de modifier l’affichage du prompt, le comportement des sessions et les chemins des fichiers kubeconfig.

Kubie affiche par défaut le contexte et le namespace actifs dans le prompt du terminal. Il est possible de modifier la couleur et le format via le fichier de configuration.

Exemple de personnalisation :

theme:
  context: cyan      # Couleur du contexte
  namespace: yellow  # Couleur du namespace
  info: green        # Couleur des informations supplémentaires

Avec cette configuration, le prompt ressemblera à :

[prod|monitoring] user@host:~$

Par défaut, Kubie n’impose pas de style mais ajoute simplement des informations au début du prompt existant.

Kubie permet d’utiliser plusieurs fichiers kubeconfig au lieu d’un seul fichier ~/.kube/config. Cela facilite l’organisation des configurations et évite d’avoir un fichier trop volumineux.

Les fichiers kubeconfig pris en charge par défaut sont :

kubeconfig_paths:
  - ~/.kube/config
  - ~/.kube/*.yml
  - ~/.kube/*.yaml
  - ~/.kube/configs/*.yml
  - ~/.kube/configs/*.yaml
  - ~/.kube/kubie/*.yml
  - ~/.kube/kubie/*.yaml

Si vous souhaitez définir vos propres chemins, modifiez la section kubeconfig_paths dans ~/.config/kubie.yaml :

kubeconfig_paths:
  - ~/k8s-configs/production.yaml
  - ~/k8s-configs/staging.yaml
  - ~/k8s-configs/dev.yaml

Avec cette configuration, Kubie utilisera uniquement les fichiers listés.

Kubie peut être configuré pour modifier son comportement à l’entrée et à la sortie d’une session.

Exemple :

on_enter:
  exec: echo "Bienvenue dans une session Kubie !"

on_exit:
  clear: true  # Efface l'écran en quittant la session

Avec cette configuration :

Un message est affiché lorsqu’une session Kubie démarre.
L’écran est nettoyé (clear) à la fermeture de la session.

Par défaut, Kubie utilise le shell défini par l’utilisateur, mais il est possible d’imposer un shell particulier (bash, zsh, fish, etc.) :

shell: /bin/zsh

Cela garantit que Kubie utilise Zsh même si le shell par défaut du système est Bash.

Il est possible d’ajouter un timeout pour fermer automatiquement une session Kubie après un certain temps d’inactivité :

session_timeout: 30m  # Ferme la session après 30 minutes

Cela permet d’éviter d’oublier une session ouverte trop longtemps.

Une fois les modifications apportées à ~/.config/kubie.yaml, vous pouvez tester la configuration en exécutant :

kubie edit-config  # Ouvre le fichier de configuration dans l’éditeur par défaut
kubie lint         # Vérifie si la configuration est valide

Ces commandes permettent de corriger rapidement les erreurs éventuelles et de s’assurer que la configuration est bien prise en compte.

Installation sous macOS

Sous macOS, l’installation est simplifiée grâce à Homebrew :

brew install kubie

Vérifiez ensuite la version installée :

kubie --version

Fonctionnalités de Kubie

Isolation des contextes et des namespaces :

L’une des principales différences entre Kubie et kubectx/kubens est que Kubie n’altère pas le fichier kubeconfig global. Chaque session ouverte avec Kubie est totalement indépendante, ce qui évite les interférences entre terminaux.

Lorsqu’un utilisateur bascule vers un contexte Kubernetes, Kubie :

Crée un fichier kubeconfig temporaire contenant uniquement le contexte sélectionné.
Lance une nouvelle session shell où la variable KUBECONFIG est redirigée vers ce fichier temporaire.
Ne modifie pas ~/.kube/config, garantissant que les autres terminaux ne sont pas affectés.

Commandes associées :

kubie ctx <context>   # Ouvre un shell dans le contexte donné
kubie ctx -           # Revient au contexte précédent
kubie ns <namespace>  # Change temporairement de namespace
kubie ns -            # Revient au namespace précédent

Modification du prompt pour plus de visibilité :

Kubie améliore la lisibilité en modifiant dynamiquement le prompt du terminal pour inclure le contexte et le namespace actifs.

Exemple :

Avant Kubie :
Fenêtre de terminal
```
user@host:~$
```
Avec Kubie dans le contexte prod et le namespace monitoring :
Fenêtre de terminal
```
[prod|monitoring] user@host:~$
```

Cette fonctionnalité évite les erreurs en affichant en permanence le bon environnement de travail.

Support des fichiers kubeconfig séparés :

Gérer plusieurs clusters Kubernetes dans un unique fichier kubeconfig (~/.kube/config) peut vite devenir ingérable. Kubie permet d’utiliser plusieurs fichiers de configuration, ce qui facilite l’organisation.

Par défaut, Kubie cherche les fichiers kubeconfig dans ces emplacements :

~/.kube/config
~/.kube/*.yml
~/.kube/*.yaml
~/.kube/configs/*.yml
~/.kube/configs/*.yaml
~/.kube/kubie/*.yml
~/.kube/kubie/*.yaml

Kubie permet aussi la désambiguïsation des noms : chaque fichier kubeconfig peut contenir un cluster et un utilisateur portant le même nom, sans provoquer de conflits.

Exemple d’un fichier kubeconfig séparé :

clusters:
  - name: my-cluster
    cluster:
      server: https://my-cluster.example.com
users:
  - name: my-user
    user:
      token: my-token
contexts:
  - name: my-context
    context:
      cluster: my-cluster
      user: my-user
      namespace: default

Exécution directe de commandes avec kubie exec

Kubie permet d’exécuter des commandes Kubernetes dans un contexte et un namespace spécifiques sans changer la session en cours.

Exemples :

Exécuter une commande dans un contexte et un namespace donnés :
Fenêtre de terminal
```
kubie exec my-cluster monitoring kubectl get pods
```
Exécuter une commande sur plusieurs contextes grâce aux wildcards :
Fenêtre de terminal
```
kubie exec dev-* default kubectl get nodes
```

Arrêter l’exécution en cas d’échec (-e) :

kubie exec prod-* monitoring -e kubectl apply -f deployment.yaml

Cette fonctionnalité est particulièrement utile dans les scripts d’automatisation.

Gestion avancée des fichiers de configuration :

Kubie permet également :

D’éditer un fichier kubeconfig spécifique sans chercher manuellement où il est stocké :
Fenêtre de terminal
```
kubie edit <context>
```
De générer un fichier kubeconfig isolé pour un contexte donné :
Fenêtre de terminal
```
kubie export my-context my-namespace
```

Ces options facilitent la gestion et la personnalisation des configurations Kubernetes.

Mise à jour et vérification de Kubie :

Pour vérifier et mettre à jour Kubie vers la dernière version disponible :

kubie update

Cela permet de s’assurer que l’outil est toujours à jour avec les dernières fonctionnalités et corrections.

Vérification et correction des fichiers kubeconfig avec kubie lint :

Kubie inclut un outil de validation des fichiers kubeconfig :

kubie lint

Cette commande permet de détecter les erreurs de configuration avant qu’elles ne posent problème lors de l’exécution des commandes Kubernetes.

Conclusion

Grâce à ses sessions isolées, son affichage clair du contexte, son support natif des fichiers kubeconfig multiples et ses commandes avancées (kubie exec, kubie edit, kubie lint), Kubie est un compagnon indispensable pour tout utilisateur de Kubernetes. Il permet de travailler en toute sécurité sur plusieurs clusters sans risque d’erreur, tout en restant simple et intuitif à utiliser.

Grâce aussi à son fichier de configuration flexible, Kubie permet d’adapter son comportement à vos besoins. Que ce soit pour personnaliser l’affichage, gérer plusieurs fichiers kubeconfig, ou automatiser certaines actions, la configuration de Kubie offre une grande souplesse pour optimiser votre workflow Kubernetes.