
If you run Kubernetes, there is a good chance k9s is open in one of your terminals right now. It is the fastest way to find a pod, tail its logs, and describe it. But when a rollout goes wrong, you want to know more: is one replica struggling, or is the whole deployment affected?
k9s shows a pod's CPU and memory as of right now. For historical resource usage, request rates, errors and latency, you usually leave the terminal, open a browser, and find the right dashboard.
The Dash0 CLI brings those metrics into k9s. Select a pod, container or workload, press Shift-D, and investigate without losing your place.
One key: Shift-D
Select a pod or a container in k9s and press Shift-D. This is what you get, here for the product catalog service of the OpenTelemetry demo:

The page has three sections:
- CPU and memory: Usage against the pod's requests and limits, with the change since the start of the range. The share of the limit turns yellow above 80% and red above 90%, so a pod about to hit its limit stands out.
- Requests: The request rate, error rate and duration (p50, p95 and p99) of the
SERVERspans the pod handles. In other words, the RED metrics of whatever service runs in the pod. - Logs: Log records in the range by severity, with errors and warnings counted separately.
The requests and logs sections only appear when the pod sends spans or logs. A pod that only has infrastructure metrics gets CPU and memory.
The page refreshes every 30 seconds. A few keys do the rest:
1to4: Switch the range between 15 minutes, 1 hour, 6 hours and 24 hours.r: Refresh now.o,t,l: Open the pod's metrics, traces or logs in Dash0, filtered to the pod and over the same range. The page tells you something is wrong. The trace tells you why.qorEsc: Back to k9s.
A page taller than your terminal scrolls with the arrow keys, PgUp and PgDn, or j and k if your fingers live in vim. In a terminal narrower than about 100 columns, the charts stack instead of sitting side by side.
From one pod to the whole deployment
During a rollout, opening pods one by one only tells part of the story. Select a deployment in k9s and press Shift-D to see metrics across all its pods, along with the number currently running.
The page starts with the total across pods. Press a to cycle through the average, minimum and maximum values at each step. CPU and memory usage, requests and limits are aggregated separately: the highest usage and the highest limit can belong to different pods.

Press p for a line per pod. It shows up to eight of the busiest pods. On the CPU and memory charts, the pods closest to their limits come first. That makes it easier to spot uneven load or find a replica running hot while the deployment's total looks fine.

The same workflow covers StatefulSets, DaemonSets, ReplicaSets, Jobs and CronJobs. From a terminal, you can also open a workload directly:
dash0 -X k8s deployments watch checkout -n shopThe workload's error rate and latency percentiles cover all its requests. The errors line shows only under total and maximum: a pod that served no failed request has no error series, so an average or minimum would leave it out and read too high.
Set it up in three steps
You need a cluster monitored by the Dash0 operator, which collects the pod metrics the page draws.
1. Install or update the dash0 CLI.
brew install --cask dash0hq/dash0-cli/dash0Other platforms are covered in the installation instructions.
The pod page needs dash0 CLI v1.22.1 or later. Run
dash0 versionto check yours.
2. Log in. Find your API URL under Settings → Endpoints. dash0 login opens your browser and stores the session in a CLI profile. No auth token to copy, and no token in your shell profile or in a k9s config file.
dash0 login --profile default --api-url <api_url>The CLI renews the access token while the page stays open, so a pod page you left running over lunch still refreshes when you come back.
3. Add the plugin to k9s. k9s info prints where your plugins.yaml lives (on macOS, ~/Library/Application Support/k9s/plugins.yaml). Add these three entries for pods, containers and workloads:
plugins.yamlplugins:
dash0-pod-metrics:
shortCut: Shift-D
description: Dash0 telemetry
scopes:
- pods
command: dash0
background: false
confirm: false
args: [-X, k8s, pods, watch, -o, page, --pause-on-error, --context, $CONTEXT, -n, $NAMESPACE, $NAME]
dash0-container-metrics:
shortCut: Shift-D
description: Dash0 telemetry
scopes:
- containers
command: dash0
background: false
confirm: false
args: [-X, k8s, pods, watch, -o, page, --pause-on-error, --context, $CONTEXT, -n, $NAMESPACE, $POD]
dash0-workload-metrics:
shortCut: Shift-D
description: Dash0 telemetry
scopes:
- deployments
- statefulsets
- daemonsets
- replicasets
- jobs
- cronjobs
command: dash0
background: false
confirm: false
args: [-X, k8s, $RESOURCE_NAME, watch, -o, page, --pause-on-error, --context, $CONTEXT, -n, $NAMESPACE, $NAME]Two of the arguments are there on purpose:
-o page: Keeps the terminal page even when k9s runs inside an AI agent's session, where the CLI would otherwise print JSON (more on that below).--pause-on-error: Waits for a key before exiting on an error, such as an expired login. Without it, k9s clears the screen before you can read the message.
-X turns on experimental commands. These views are new, and their flags may still change.
That's it. Select a pod or workload, press Shift-D.
Where the numbers come from
The page queries Dash0's Prometheus API using Kubernetes resource attributes. Pod views match the namespace and pod name. Workload views match the namespace and the workload name, such as k8s_deployment_name, and Dash0 aggregates the pods in the query:
| Section | Metrics |
|---|---|
| CPU | k8s.pod.cpu.usage, k8s.container.cpu_request, k8s.container.cpu_limit |
| Memory | k8s.pod.memory.working_set, k8s.container.memory_request, k8s.container.memory_limit |
| Requests | dash0.spans and dash0.spans.duration for the pods' SERVER spans |
| Logs | dash0.logs by otel_log_severity_range |
| Running pods | k8s.pod.phase for workloads |
For resource metrics, Dash0 counts pod usage and container requests or limits once before aggregating them. Resource-limit warnings compare each pod's usage with its own limit, so a workload's maximum usage is never divided by another pod's maximum limit. A pod has a limit only when every container in it has one, because a container without a limit can use the whole node. A workload has a limit line only when every pod with usage has a limit.
None of this needs a dashboard or recording rule. If the operator collects the Kubernetes metrics and applications send spans and logs, the page has what it needs.
One profile per cluster
Most teams have more than one Dash0 organization or dataset: one for production, one for staging. k9s supports per-context plugin files. Put a copy of the relevant plugin entries in clusters/<cluster>/<context>/plugins.yaml and name the profile before k8s. For a pod:
args: [-X, --profile, production, k8s, pods, watch, -o, page, --pause-on-error, --context, $CONTEXT, -n, $NAMESPACE, $NAME]For workload views, use the same --profile option with k8s, $RESOURCE_NAME, watch in the workload entry. The page header shows the selected profile.
Workload names such as checkout often repeat across clusters. If the same Dash0 dataset receives telemetry from multiple clusters, add --cluster <name> after watch to restrict the query. Without it, matching workloads in multiple clusters can contribute to the totals. k9s' $CONTEXT is a kubeconfig context, not Dash0's k8s.cluster.name, so the page shows it in the header but does not filter by it.
Without k9s
The same page runs directly in any terminal, without k9s:
# Watch one pod
dash0 -X k8s pods watch <pod> -n <namespace>
# Compare pods of a deployment
dash0 -X k8s deployments watch checkout -n shop --per-pod
# Show the highest values across a deployment's pods
dash0 -X k8s deployments watch checkout -n shop --aggregate max--range 24h opens a longer range. --once draws a single frame to stdout and exits, handy for posting metrics in an incident channel. --light (or DITT0_THEME=light) draws in Dash0's light colours:

The same metrics for your coding agent
The dash0 CLI detects when an AI coding agent runs it, such as Claude Code, Cursor or Codex, and switches to agent mode. In agent mode the same command prints JSON instead of drawing a page: the time series behind every panel, plus the Dash0 links behind o, t and l.
$ dash0 -X k8s pods watch <pod> -n <namespace> --range 15m
{
"namespace": "otel-demo",
"kind": "pod",
"name": "opentelemetry-demo-productcatalogservice-8ffc485d4-4p95v",
"pod": "opentelemetry-demo-productcatalogservice-8ffc485d4-4p95v",
"step": "1m0s",
"timestamps": ["2026-11-16T14:58:00Z", "2026-11-16T14:59:00Z", ...],
"series": {
"requests": [5.3, 6.07, 7.2, ...],
"errors": [0.033, 0.033, 0.067, ...],
"p95": [0.0038, 0.0030, 0.0035, ...],
"logs:ERROR": [2, 2, 4, ...],
...
},
"links": {"metrics": "https://app.dash0.com/goto/metrics/...", "traces": "...", "logs": "..."}
}An agent can also inspect an entire workload without asking for each pod in turn:
dash0 -X k8s deployments watch checkout -n shop -o json --per-podWorkload JSON includes the resource kind and name, selected aggregate mode, a pods series with the number of running pods, and per-pod series when --per-pod is set. This lets an agent compare replicas and follow up using the included Dash0 links. -o json provides the same data outside agent mode, for scripts.
Try it
The pod and workload views ship in the dash0 CLI, so there is nothing extra to build or install. Update the CLI, log in once, add the three plugin entries to plugins.yaml, and press Shift-D on the pod or workload you want to investigate. The full flag reference is in the dash0 CLI docs.
k9s tells you what is running. Dash0 tells you how it is doing. Now they share a terminal.
