Gérer namespaces et contextes Kubernetes facilement

Dans Kubernetes, la gestion des namespaces est essentielle pour organiser et isoler les ressources au sein d’un cluster. Que vous administriez plusieurs projets, environnements (développement, test, production) ou équipes, il est important de naviguer en toute sécurité entre ces espaces, pour éviter les erreurs.

Pourquoi utiliser kubens et kubectx ?

Lorsque l’on travaille avec Kubernetes, il est courant de devoir jongler entre plusieurs clusters et namespaces. La commande native kubectl permet bien sûr de changer de contexte, mais elle devient vite fastidieuse, surtout lorsqu’on le fait plusieurs fois par jour. C’est ici que kubectx et kubens interviennent pour simplifier et accélérer ces manipulations.

Limites des commandes kubectl classiques

Voici comment créer un contexte propre à un Namespace :

kubectl config set-context --current --namespace=mon-namespace

Et pour changer de contexte :

kubectl config use-context mon-contexte

Ces commandes sont longues et sujettes aux erreurs de frappe, notamment lorsque les noms des contextes ou des namespaces sont complexes. De plus, il n’y a pas de moyen simple de revenir rapidement au contexte précédent.

Avantages de kubens

Même problème avec kubectl pour les namespaces : changer de namespace est une tâche fréquente, mais mal optimisée avec les commandes classiques. kubens apporte une vraie simplicité :

Lister les namespaces disponibles :
Fenêtre de terminal
```
kubens
```
Changer de namespace instantanément :
Fenêtre de terminal
```
kubens mon-namespace
```
Revenir au namespace précédent en un seul caractère :
Fenêtre de terminal
```
kubens -
```

Cela évite d’avoir à spécifier systématiquement le namespace dans chaque commande kubectl et rend l’expérience bien plus fluide.

Avantages de kubectx

Avec kubectx, la gestion des contextes Kubernetes devient beaucoup plus fluide :

Lister tous les contextes disponibles :
Fenêtre de terminal
```
kubectx
```
Changer de contexte en une commande courte :
Fenêtre de terminal
```
kubectx mon-contexte
```
Basculer vers le contexte précédent sans avoir à s’en souvenir :
Fenêtre de terminal
```
kubectx -
```
Renommer un contexte pour un usage plus simple :
Fenêtre de terminal
```
kubectx prod=gke_projet-region-cluster
```

Avec ces commandes, plus besoin de se souvenir des noms longs et compliqués des clusters. On peut les renommer avec des alias courts et explicites, comme prod, dev, ou staging.

Un gain de productivité important

L’utilisation combinée de kubectx et kubens permet de :

✔ Réduire les erreurs de frappe sur des commandes longues et fastidieuses. ✔ Basculer entre plusieurs environnements (clusters/namespaces) sans friction. ✔ Faciliter le travail en équipe en permettant à chacun d’utiliser des alias clairs et mémorisables. ✔ Améliorer la rapidité d’exécution en réduisant le nombre de commandes nécessaires.

Installation de kubectx et kubens

L’installation de kubectx et kubens est simple et peut se faire de plusieurs manières selon votre système d’exploitation et vos préférences. Ces outils étant des scripts Bash, ils sont compatibles avec Linux et macOS. Sous Windows, il faudra utiliser WSL ou un environnement compatible.

Installation via Krew (recommandé)

Krew est un gestionnaire de plugins pour kubectl. Il permet d’installer facilement kubectx et kubens en tant que plugins officiels.

Installer Krew si ce n’est pas déjà fait :

(
  set -x; cd "$(mktemp -d)" &&
  OS="$(uname | tr '[:upper:]' '[:lower:]')" &&
  ARCH="$(uname -m | sed 's/x86_64/amd64/' | sed 's/arm.*$/arm/')" &&
  KREW="krew-${OS}_${ARCH}" &&
  curl -fsSLO "https://github.com/kubernetes-sigs/krew/releases/latest/download/${KREW}.tar.gz" &&
  tar zxvf "${KREW}.tar.gz" &&
  ./"${KREW}" install krew
)

Ajouter Krew au PATH :

export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH"

Installer kubectx et kubens via Krew :
Fenêtre de terminal
```
kubectl krew install ctx
kubectl krew install ns
```
Vérifier l’installation :
Fenêtre de terminal
```
kubectl ctx --help
kubectl ns --help
```

Ces commandes seront accessibles sous kubectl ctx et kubectl ns.

Installation via Homebrew (macOS & Linux)

Si vous utilisez Homebrew, l’installation est encore plus rapide :

brew install kubectx

Cette commande installe automatiquement kubectx et kubens.

Installation manuelle (Linux/macOS)

Si vous ne souhaitez pas utiliser Krew ou Homebrew, vous pouvez installer kubectx et kubens manuellement depuis leur dépôt GitHub.

Télécharger les scripts et les copier dans un dossier du PATH :

sudo git clone https://github.com/ahmetb/kubectx /opt/kubectx
sudo ln -s /opt/kubectx/kubectx /usr/local/bin/kubectx
sudo ln -s /opt/kubectx/kubens /usr/local/bin/kubens

Rendre les scripts exécutables :

chmod +x /usr/local/bin/kubectx
chmod +x /usr/local/bin/kubens

Vérifier que les commandes fonctionnent :
Fenêtre de terminal
```
kubectx --help
kubens --help
```

Installation via un package manager Linux

Ubuntu/Debian :

Avec apt, il est possible d’installer kubectx et kubens depuis un package externe :

sudo apt update
sudo apt install kubectx

Si vous ne maitrisez pas le gestionnaire de paquets apt, je vous recommande de lire mon guide sur apt pour mieux comprendre son fonctionnement.

Arch Linux :

Sur Arch, ils sont disponibles dans l’AUR :

yay -S kubectx

Utilisation de kubens pour gérer les namespaces

L’outil kubens simplifie cette gestion en permettant de naviguer rapidement entre les namespaces.

1. Lister les namespaces disponibles

Pour afficher tous les namespaces disponibles dans le cluster actuel :

kubens # ou kubectl ns si vous avez installé via Krew

Exemple de sortie :

default
dev
staging
* prod
kube-system
monitoring

Le * indique le namespace actuellement actif.

2. Changer de namespace

Pour basculer vers un autre namespace :

kubens nom_du_namespace

Par exemple, pour passer au namespace staging :

kubens staging

Dès lors, toutes les commandes kubectl seront exécutées par défaut dans ce namespace, sans qu’il soit nécessaire de le préciser à chaque commande.

3. Revenir au namespace précédent

Si vous travaillez sur plusieurs namespaces et souhaitez revenir rapidement au dernier utilisé :

kubens -

Cela permet d’alterner entre deux namespaces sans effort.

5. Vérifier le namespace actif

À tout moment, vous pouvez voir le namespace actuellement utilisé avec :

kubectl config view --minify | grep namespace

Ou plus simplement avec kubens :

kubens

Le namespace actif est toujours marqué d’un *.

Création et gestion des contextes avec kubectx

Dans Kubernetes, un contexte permet de définir quel cluster, quel utilisateur et quel namespace sont utilisés par défaut lors de l’exécution des commandes kubectl. La gestion des contextes est essentielle pour naviguer efficacement entre différents environnements (développement, test, production) ou clusters Kubernetes.

L’outil kubectx simplifie la gestion des contextes en offrant des commandes plus rapides et intuitives.

1. Lister les contextes disponibles

Avant de basculer entre les contextes, il est utile de voir ceux qui sont disponibles dans votre kubeconfig.

kubectx # ou kubectl ctx si vous avez installé via Krew

Cette commande affiche une liste des contextes configurés sur votre machine :

gke_projet1-europe-west1-prod
gke_projet1-europe-west1-staging
eks-cluster-dev
eks-cluster-prod
* minikube

Le * indique le contexte actuellement actif.

2. Changer de contexte

Pour changer de contexte, il suffit d’exécuter :

kubectx nom_du_contexte

Par exemple, pour passer sur le contexte gke_projet1-europe-west1-prod :

kubectx gke_projet1-europe-west1-prod

Dès lors, toutes les commandes kubectl seront exécutées sur ce cluster.

3. Revenir au contexte précédent

Si vous devez alterner entre deux contextes, kubectx offre une commande rapide :

kubectx -

Cela permet de revenir instantanément au dernier contexte utilisé sans avoir à retaper son nom.

4. Créer un nouveau contexte

Les contextes sont définis dans le fichier ~/.kube/config. Pour créer un nouveau contexte, utilisez kubectl config set-context :

kubectl config set-context mon-nouveau-contexte \
  --cluster=mon-cluster \
  --namespace=mon-namespace \
  --user=mon-utilisateur

Si vous utilisez kubectx, la liste des contextes sera mise à jour automatiquement.

5. Renommer un contexte pour simplifier son utilisation

Les noms de contexte générés par les fournisseurs cloud (GKE, EKS, AKS, etc.) sont souvent longs et peu pratiques. kubectx permet de les renommer avec des alias plus lisibles :

kubectx prod=gke_projet1-europe-west1-prod

Ainsi, au lieu de taper :

kubectx gke_projet1-europe-west1-prod

Vous pouvez simplement écrire :

kubectx prod

6. Supprimer un contexte

Si vous avez des contextes obsolètes dans votre configuration, vous pouvez les supprimer avec :

kubectl config delete-context nom_du_contexte

Attention : cela ne supprime pas le cluster lui-même, mais uniquement la référence dans le fichier kubeconfig.

7. Vérifier le contexte actif

À tout moment, vous pouvez voir quel est votre contexte actuel avec :

kubectl config current-context

Conclusion

L’utilisation de kubectx et kubens est un véritable atout pour tout administrateur Kubernetes cherchant à gagner du temps et à réduire les erreurs lors de la gestion des contextes et namespaces. Ces outils simplifient considérablement la navigation entre les environnements et permettent d’adopter de meilleures pratiques sans complexifier l’expérience utilisateur.

En quelques commandes, on peut alterner rapidement entre les clusters, changer de namespace en un instant et renommer les contextes pour les rendre plus lisibles. Combinés à un bon usage de kubectl, ces outils deviennent indispensables pour une gestion fluide et efficace des clusters Kubernetes.

Si ce n’est pas encore fait, installe-les dès maintenant, teste-les dans ton environnement et adopte une gestion plus simple et plus rapide de tes configurations Kubernetes !