K9s : Piloter Kubernetes depuis le terminal

Ce guide vous permet de piloter vos clusters Kubernetes depuis le terminal, sans enchaîner des kubectl get, describe, logs à la main. K9s offre une interface TUI (Text User Interface) qui affiche l’état de vos ressources en temps réel, avec navigation par touches, filtres, et actions contextuelles. Vous apprendrez à l’installer, naviguer efficacement, et le personnaliser. Prérequis : kubectl configuré et un cluster accessible.

Le problème : trop de commandes kubectl répétitives

Quand vous déboguez ou surveillez un cluster Kubernetes, vous enchaînez souvent :

kubectl get pods -n monitoring
kubectl describe pod prometheus-0 -n monitoring
kubectl logs prometheus-0 -n monitoring -f
kubectl get events -n monitoring --sort-by='.lastTimestamp'

Problèmes concrets :

Beaucoup de frappe répétitive
Impossible de voir l’état en temps réel sans boucle watch
Changement de namespace/contexte fastidieux
Pas de vue d’ensemble “santé du cluster”

La solution : K9s

K9s est une interface TUI développée en Go qui s’exécute dans votre terminal. Elle offre :

Fonctionnalité	Ce que ça change
Rafraîchissement temps réel	Plus besoin de relancer les commandes
Navigation par vues	`:pods`, `:deploy`, `:svc`, `:nodes`…
Actions contextuelles	Logs, describe, shell, edit, delete en une touche
Filtres puissants	`/` pour chercher, `-l` pour labels
Vues diagnostiques	`:popeye` (problèmes), `:xray` (dépendances), `:pulse` (santé)

Installation

Version actuelle : v0.50.18 (janvier 2026)

mise gère les versions d’outils de développement.

mise install k9s@latest
mise use -g k9s@latest

Vérification :

k9s version

Version:    v0.50.18

brew install derailed/k9s/k9s
k9s version

Téléchargez depuis les releases GitHub :

# Linux AMD64
curl -Lo k9s.tar.gz https://github.com/derailed/k9s/releases/latest/download/k9s_Linux_amd64.tar.gz
tar -xzf k9s.tar.gz
sudo install k9s /usr/local/bin/
k9s version

pacman -S k9s

Scoop :

scoop install k9s

Chocolatey :

choco install k9s

sudo snap install k9s

K9s en 10 minutes

Objectif : être opérationnel immédiatement, sans se noyer dans les options.

Lancer et se repérer

Lancer K9s
Fenêtre de terminal
```
k9s
```
K9s ouvre la vue pods du contexte courant. La barre d’état (en haut) affiche :
- Contexte actif (ex: minikube)
- Namespace courant (ex: default)
- Version K9s et cluster
Repérer les zones de l’écran

Zone Contenu
Haut Contexte, namespace, raccourcis actifs
Centre Liste des ressources (pods par défaut)
Bas Barre de commande (:) et filtres (/)

Zone	Contenu
Haut	Contexte, namespace, raccourcis actifs
Centre	Liste des ressources (pods par défaut)
Bas	Barre de commande (`:`) et filtres (`/`)

Les 5 gestes de base

Geste	Touche	Effet
Ouvrir une vue	`:` + nom	`:pods`, `:deploy`, `:svc`
Filtrer	`/` + texte	Recherche instantanée
Voir détails	`Enter`	Drill-down dans la ressource
Retour	`Esc`	Revenir à la vue précédente
Aide	`?`	Affiche tous les raccourcis

Mini routine de découverte

:pods → sélectionner un pod → l (logs) → Esc
      → d (describe) → Esc
      → y (yaml) → Esc
      → :events (voir les événements)

Quitter

Ctrl+C ou :quit

TP 5 minutes : explorer votre cluster

Lancez k9s
Tapez :ns et changez de namespace
Tapez :pods et filtrez avec / suivi d’un nom de pod
Sur un pod, appuyez sur l pour les logs, puis Esc
Appuyez sur d pour describe, puis Esc
Tapez :events pour voir les événements récents
Quittez avec Ctrl+C

Résultat attendu : vous savez naviguer entre vues, filtrer, et inspecter un pod.

Objectif : naviguer plus vite qu’avec kubectl get … | grep.

Vues principales

Vue	Commande	Alias	Contenu
Pods	`:pods`	`:po`	Tous les pods du namespace
Déploiements	`:deployments`	`:dp`	Déploiements et replicas
Services	`:services`	`:svc`	Services et endpoints
Nodes	`:nodes`	`:no`	État des nœuds
Events	`:events`	`:ev`	Événements cluster
Namespaces	`:namespaces`	`:ns`	Changer de namespace
Contextes	`:contexts`	`:ctx`	Changer de cluster

Astuce : tapez 0 pour voir tous les namespaces d’un coup.

Filtres et recherche

Type de filtre	Syntaxe	Exemple
Texte simple	`/texte`	`/nginx`
Regex	`/regex`	`/nginx-[0-9]+`
Par label	`/-l key=value`	`/-l app=frontend`
Inverser	`/!texte`	`/!kube-system`
Fuzzy	`//texte`	`//ngx`

Actions contextuelles (sur une ressource sélectionnée)

Catégorie	Action	Touche
Observer	Logs	`l`
	Describe	`d`
	YAML	`y`
	Shell	`s`
Agir	Éditer	`e`
	Supprimer	`Ctrl+D`
	Kill (restart)	`Ctrl+K`
Naviguer	Retour	`Esc`
	Aide	`?`

Vues diagnostiques avancées

Vue	Commande	Usage
Popeye	`:popeye`	Scan des problèmes de config (limites, probes, RBAC)
XRay	`:xray TYPE`	Dépendances (ex: `:xray deploy` → rs → pods)
Pulse	`:pulse`	Tableau de bord santé du cluster

TP 5 minutes : maîtriser les filtres

Lancez k9s et tapez :pods
Tapez / puis un nom partiel de pod → filtrage instantané
Tapez Esc pour effacer le filtre
Tapez /-l app= suivi d’un label existant
Tapez 0 pour voir tous les namespaces
Tapez :xray deploy pour voir les dépendances

Résultat attendu : vous filtrez en temps réel sans quitter K9s.

Debug pod comme un runbook

Objectif : transformer K9s en runbook interactif pour diagnostiquer un pod.

Le workflow de debug

Quand un pod ne fonctionne pas, suivez cette séquence :

Events du namespace — :events

Cherchez les erreurs récentes : FailedScheduling, ImagePullBackOff, CrashLoopBackOff, Unhealthy.
État du pod — :pods → sélectionner le pod problématique

Regardez la colonne STATUS et RESTARTS.
Describe — touche d

Sections à vérifier :
- Conditions : Ready, ContainersReady, PodScheduled
- Events (en bas) : erreurs de scheduling, probes, volumes
Logs — touche l
- p pour logs précédents (si le conteneur a crashé)
- w pour activer le wrap (lignes longues)
- t pour afficher les timestamps
- 0-9 pour sélectionner un conteneur (multi-conteneurs)
YAML — touche y

Vérifiez : image, resources, env, volumeMounts, livenessProbe, readinessProbe.
Shell — touche s (si le pod tourne)

Exécutez des commandes de diagnostic dans le conteneur.

Symptômes → causes fréquentes

Symptôme	Cause probable	Où regarder
`Pending`	Pas de node disponible, PVC non lié	`:events`, describe → Conditions
`ImagePullBackOff`	Image introuvable, auth registry	`:events`, describe → Events
`CrashLoopBackOff`	Erreur au démarrage	Logs (`l` puis `p` pour previous)
`OOMKilled`	Mémoire insuffisante	Describe → Last State, ajuster `resources`
`Unhealthy`	Probe échoue	Describe → Events, vérifier `livenessProbe`
`Error`	Erreur applicative	Logs

TP 5 minutes : simuler un debug

Lancez k9s et tapez :pods
Sélectionnez un pod quelconque
Appuyez sur d (describe) → repérez les Conditions et Events
Appuyez sur Esc, puis l (logs)
Appuyez sur t (timestamps), w (wrap)
Si multi-conteneurs, appuyez sur 0, 1, etc. pour changer
Appuyez sur Esc, puis y (YAML) → repérez resources, image, probes

Résultat attendu : vous savez où chercher selon le symptôme.

Observabilité intégrée : Pulse et XRay

Objectif : passer du symptôme à la zone de panne sans enchaîner les commandes.

Pulse : vue santé du cluster

Tapez :pulse pour afficher un tableau de bord avec :

Nombre de pods par état (Running, Pending, Failed)
Utilisation CPU/Mem agrégée
Tendances et signaux faibles

Usage : repérer rapidement si le cluster est sain avant de creuser.

XRay : drill-down par dépendances

Tapez :xray TYPE pour visualiser la hiérarchie d’une ressource :

:xray deploy    → Deployment → ReplicaSet → Pods
:xray svc       → Service → Endpoints → Pods
:xray sts       → StatefulSet → Pods → PVCs

Usage : identifier quel niveau de la chaîne pose problème (ex: un ReplicaSet qui ne crée pas de pods).

Popeye : audit de configuration

Tapez :popeye pour lancer un scan qui détecte :

Ressources sans limites CPU/Mem
Pods sans probes
Secrets non utilisés
Problèmes RBAC

Options CLI utiles

# Mode lecture seule (sécurité en prod)
k9s --readonly

# Démarrer sur un namespace spécifique
k9s -n monitoring

# Démarrer sur tous les namespaces
k9s -A

# Démarrer sur une vue spécifique
k9s -c deploy          # Déploiements
k9s -c svc             # Services
k9s -c popeye          # Analyse de problèmes

# Modifier le taux de rafraîchissement (en secondes)
k9s --refresh 5

# Utiliser un kubeconfig spécifique
k9s --kubeconfig ~/.kube/prod-config

# Contexte spécifique
k9s --context prod-cluster

Toutes les options CLI

Option	Description
`--readonly`	Mode lecture seule
`-n NAMESPACE`	Namespace de départ
`-A`	Tous les namespaces
`-c VIEW`	Vue de départ (pods, deploy, svc, etc.)
`--refresh N`	Rafraîchissement en secondes
`--kubeconfig PATH`	Fichier kubeconfig
`--context NAME`	Contexte Kubernetes
`--headless`	Sans logo ni bannière
`--logoless`	Sans logo
`--crumbsless`	Sans fil d’Ariane
`--write`	Force le mode écriture même si `readOnly: true`

Pour toutes les options : k9s --help ou la documentation officielle.

Configuration

K9s suit la convention XDG pour ses fichiers de configuration :

Fichier	Emplacement Linux/macOS
Config principale	`~/.config/k9s/config.yaml`
Skins (thèmes)	`~/.config/k9s/skins/`
Plugins	`~/.config/k9s/plugins.yaml`
Hotkeys	`~/.config/k9s/hotkeys.yaml`
Aliases	`~/.config/k9s/aliases.yaml`
Logs	`~/.local/state/k9s/k9s.log`

Exemple de configuration

k9s:
  liveViewAutoRefresh: true
  refreshRate: 2
  maxConnRetry: 5
  readOnly: false
  noExitOnCtrlC: false
  ui:
    enableMouse: false
    headless: false
    logoless: false
    crumbsless: false
    noIcons: false
  skipLatestRevCheck: false
  disablePodCounting: false
  shellPod:
    image: busybox:1.36.1
    namespace: default
    limits:
      cpu: 100m
      memory: 100Mi
  logger:
    tail: 100
    buffer: 5000
    sinceSeconds: -1
    fullScreenLogs: false
    textWrap: false
    showTime: false
  thresholds:
    cpu:
      critical: 90
      warn: 70
    memory:
      critical: 90
      warn: 70

Personnalisation

Raccourcis clavier (hotkeys)

Créez ~/.config/k9s/hotkeys.yaml :

hotKeys:
  shift-1:
    shortCut: Shift-1
    description: View deployments
    command: dp
  shift-2:
    shortCut: Shift-2
    description: View services
    command: svc
  shift-3:
    shortCut: Shift-3
    description: XRay deployments
    command: xray deploy

Thèmes (skins)

K9s supporte les thèmes personnalisés. Placez vos fichiers dans ~/.config/k9s/skins/.

Exemple minimaliste :

k9s:
  body:
    fgColor: white
    bgColor: black
    logoColor: blue
  info:
    fgColor: lightgray
    sectionColor: steelblue

Puis dans config.yaml :

k9s:
  ui:
    skin:
      name: dark

Des thèmes prédéfinis sont disponibles dans le dépôt officiel.

Plugins

Les plugins permettent d’étendre K9s avec des commandes personnalisées.

Exemple : intégrer Dive pour analyser les images :

plugins:
  dive:
    shortcut: Shift-D
    confirm: false
    description: Dive into container image
    scopes:
      - containers
    command: dive
    background: false
    args:
      - $COL-IMAGE

Variables disponibles dans les plugins

Variable	Description
`$NAMESPACE`	Namespace de la ressource
`$NAME`	Nom de la ressource
`$CONTAINER`	Conteneur actuel
`$POD`	Nom du pod
`$CONTEXT`	Contexte Kubernetes actif
`$KUBECONFIG`	Chemin du kubeconfig
`$COL-<COLUMN>`	Valeur d’une colonne (ex: `$COL-IMAGE`)

Bonnes pratiques

En production : mode lecture seule

Pour explorer un cluster de production sans risque de modification accidentelle :

k9s --readonly

Ou dans config.yaml :

k9s:
  readOnly: true

Coupler avec kubectx/kubens ou Kubie

K9s gère les contextes, mais pour une navigation encore plus rapide :

kubectx/kubens pour le switch global
Kubie pour l’isolation par terminal

Versionner la configuration

Si vous travaillez en équipe, versionnez vos fichiers de configuration :

~/.config/k9s/
├── config.yaml
├── plugins.yaml
├── hotkeys.yaml
└── skins/
    └── team-dark.yaml

Partagez via un dépôt dotfiles ou un outil de configuration management.

Dépannage

Symptôme	Cause probable	Solution
`no such file or directory` au lancement	Config absente	Normal au premier lancement, K9s la crée
`forbidden` sur les ressources	Droits RBAC insuffisants	Vérifier vos permissions Kubernetes
Affichage décalé/cassé	Terminal trop petit ou incompatible	Agrandir la fenêtre, vérifier `$TERM`
Version Snap en retard	Package non mis à jour	Passer à Homebrew ou binaire GitHub
Logs introuvables	Emplacement par défaut	`k9s info` pour voir le chemin des logs

À retenir

K9s = TUI Kubernetes pour observer et agir vite, sans quitter le terminal
Version actuelle : v0.50.18 — vérifiez avec k9s version
Configuration via XDG (~/.config/k9s/), retrouvez les chemins avec k9s info
Installation recommandée : mise, Homebrew, binaires GitHub (Snap peut être en retard)
En production : utilisez --readonly pour éviter les accidents
Plugins et hotkeys font gagner du temps, mais restent à maîtriser (sécurité + cohérence équipe)

Prochaines étapes

kubectl : les bases Maîtrisez les commandes kubectl essentielles

kubectx et kubens Basculer rapidement entre contextes et namespaces

Kubie : isolation par shell Alternative plus sûre pour le travail multi-terminal

Dive : analyser les images Explorer les couches de vos images Docker