← Back

2026

K9s: A Terminal-Based UI for Kubernetes

How K9s turns painful kubectl commands into a fast, interactive terminal dashboard and why it belongs in every Kubernetes workflow.

I'll be honest: for the longest time I was the person typing out full kubectl commands from memory, tab-completing my way through namespace flags, and opening three terminal tabs just to keep an eye on what was happening in a cluster. It worked. It was slow and a bit tedious, but it worked.

Then in one of my projects someone said “just use k9s” during a debugging session and I've barely typed a raw kubectl command since.

What even is K9s?

K9s is a terminal-based UI for Kubernetes. Not a web dashboard, not a GUI; it lives right in your terminal. You launch it, it reads your kubeconfig, connects to your cluster and gives you a live, interactive view of everything running inside it.

Think of it less like a dashboard and more like a control panel.

Navigate between resources without typing
Tail logs live from any pod
Exec into containers with one keypress
Describe and edit resource YAML in-place
Scale deployments interactively
Auto-refreshes from the Kubernetes API

Under the hood it's just talking to the Kubernetes API server using whatever context you have active in ~/.kube/config. No magic, no extra setup.

Getting it running

Platform
Command
macOS (Homebrew)
brew install derailed/k9s/k9s
Linux (Homebrew)
brew install derailed/k9s/k9s
Windows (Chocolatey)
choco install k9s
Windows (Scoop)
scoop install k9s
Go
go install github.com/derailed/k9s@latest

Once installed, just run k9s. It picks up your current kubeconfig context and drops you straight into the pod view, no config file to edit, no setup wizard.

How you actually navigate it

The whole interface is driven by two things: colon commands to jump between resource types and single-key shortcuts to act on whatever you've selected.

Type : then a resource shortname to switch views

:podPods
:svcServices
:deployDeployments
:nsNamespaces
:noNodes
:secSecrets
:cmConfigMaps
:cjCronJobs
:pvPersistentVolumes
:ingIngresses

Once you've selected a resource, use these keys

l

Tail logs, live

d

Describe the resource (same as kubectl describe)

e

Open the resource YAML in your editor

s

Shell into the container

k

Kill a pod

ctrl-d

Delete a resource

/

Filter the current list by name

?

Show all available shortcuts for the current view

The things I actually use it for

Debugging a pod that won't stay up

This is my most common use case. Something's crashlooping, I need to figure out why fast.

Run k9s

Connects to your active kubeconfig context instantly.

:pod to get the pod list

Live view of all pods with status, restarts, CPU, memory.

/ to filter by name

Narrow down to the pod you care about.

l to pull up the logs

The error is usually right there.

d to describe it

Check the events section at the bottom for scheduling issues.

s for a shell inside

When you need to poke around directly.

The whole thing takes maybe 30 seconds. Compare that to running kubectl logs, copying the full pod name, running kubectl describe pod, scrolling through the output…

Keeping an eye on resource usage

:podCPU and memory columns that update in real time
:noSame at the node level
:pulsesCluster-wide health overview at a glance

Multi-cluster and namespace juggling

If you're working across multiple clusters or namespaces (and at some point you will be), k9s handles this well.

:ctx

Switch kubeconfig contexts to jump between clusters without leaving k9s.

:ns

Switch namespaces. Pin one so every resource view is automatically scoped to it.

Very useful when you're deep in debugging one particular environment and don't want to accidentally be looking at the wrong cluster.

Configuration

Config lives at ~/.config/k9s/config.yaml on Linux/macOS or %LOCALAPPDATA%\k9s\config.yamlon Windows. Most defaults are fine. Here's what's worth knowing:

~/.config/k9s/config.yaml
k9s:
refreshRate: 2# How often it polls the Kubernetes API, in seconds.
maxConnRetry: 5
enableMouse: false# Mouse support is off by default; the keyboard is faster.
headless: false
currentContext: my-cluster# The kubeconfig context to connect to.
clusters:
my-cluster:
namespace:
active: default# The namespace shown on launch.
favorites:
- default# Pinned namespaces. Quick to switch between.
- kube-system

You can also add custom plugins via ~/.config/k9s/plugins.yaml and apply color themes if you care about that sort of thing.

A few things worth knowing

K9s respects RBAC

You'll only see what your user or service account has permission to see. Safe to hand off without worrying about accidental access.

:xray deploy

Tree view: deployments expand down to ReplicaSets then Pods. Useful for understanding what belongs to what.

ctrl-e

Toggles the header bar if you want more vertical space. Useful on smaller screens.

plain kubectl vs. K9s

Aspect
kubectl
K9s
Interface
Commands you type
Interactive, navigable TUI
Learning curve
You need to know the flags
Visual and discoverable
Speed for exploration
Slower
Much faster
Scriptable
Yes
No
Best for
Automation, pipelines, one-liners
Active investigation and debugging

K9s doesn't replace kubectl. I still use kubectl in scripts and anywhere I need repeatable, automatable commands. But for active cluster work like jumping around, tailing logs and poking at things, k9s is just faster and less friction.

If you're spending any real time working with Kubernetes clusters, give it a shot. It takes about ten minutes to feel natural and you'll wonder how you got by without it.

Links