Monitoring and Metrics

View resource utilization metrics and performance data in Kubernetes Dashboard

Kubernetes Dashboard integrates with metrics-server to provide real-time insights into cluster resource utilization. This guide covers how to view and interpret metrics for nodes, pods, and other resources.

Overview

Dashboard uses the dashboard-metrics-scraper sidecar to collect and store metrics data, providing:

• CPU and memory usage graphs
• Historical sparklines in list views
• Resource utilization trends
• Per-pod and per-node metrics

Metrics collection requires metrics-server to be running in your cluster. The metrics-scraper is deployed by default with Kubernetes Dashboard.

Prerequisites

Installing metrics-server

Verify metrics-server is running:

kubectl top nodes

If the command fails, install metrics-server:

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Verify installation:

kubectl get deployment metrics-server -n kube-system
kubectl top pod

Dashboard Metrics Scraper

The metrics scraper is automatically deployed with Dashboard. It:

• Queries the Metrics API every 60 seconds
• Stores data points in a SQLite database
• Serves metrics to the Dashboard frontend
• Maintains historical data for sparklines and graphs

Metrics Architecture

The metrics flow:

Metrics Data Structure

The scraper stores metrics in a structured format (modules/metrics-scraper/pkg/api/dashboard/types.go:28-75):

type SidecarMetric struct {
    DataPoints   []DataPoint
    MetricPoints []MetricPoint
    MetricName   string
    UIDs         []types.UID
}

type MetricPoint struct {
    Timestamp time.Time
    Value     uint64
}

type DataPoint struct {
    X int64  // Timestamp
    Y int64  // Value
}

Database Schema

Metrics are stored in two tables:

Pods Table:

CREATE TABLE pods (
    namespace TEXT,
    name TEXT,
    uid TEXT,
    time TEXT,
    cpu INTEGER,
    memory INTEGER
)

Nodes Table:

CREATE TABLE nodes (
    name TEXT,
    uid TEXT,
    time TEXT,
    cpu INTEGER,
    memory INTEGER
)

Viewing Node Metrics

Access node metrics at Cluster → Nodes.

Node Metrics Display

CPU Usage

Shows CPU utilization in millicores and percentage

Memory Usage

Displays memory consumption in bytes and percentage

Pod Count

Number of pods running on the node

Allocation

Resource requests vs. capacity

Node Detail Metrics

Click on a node to view detailed metrics:

• CPU Chart: Historical CPU usage over time
• Memory Chart: Historical memory consumption
• Resource Allocation: Visual breakdown of allocated resources
• Capacity: Total node capacity vs. requests vs. limits

Hover over chart data points to see exact values and timestamps.

Viewing Pod Metrics

Access pod metrics at Workloads → Pods.

List View Sparklines

The pod list displays mini sparkline graphs showing:

• Recent CPU usage trend
• Recent memory usage trend
• Visual indication of resource consumption patterns

Pod Detail Metrics

The pod detail page shows:

type PodMetrics struct {
    CPUUsage    int64  // Current CPU in millicores
    MemoryUsage int64  // Current memory in bytes
    CPUHistory  []DataPoint
    MemoryHistory []DataPoint
}

CPU Metrics

• Current Usage: Millicores currently consumed
• Requested: CPU requests defined in pod spec
• Limited: CPU limits defined in pod spec
• Usage Graph: Historical CPU consumption

Memory Metrics

• Current Usage: Bytes currently consumed
• Requested: Memory requests in pod spec
• Limited: Memory limits in pod spec
• Usage Graph: Historical memory consumption

Metrics API Endpoints

The metrics scraper exposes REST endpoints (modules/metrics-scraper/pkg/api/dashboard/dashboard.go:33-36):

Node Metrics

GET /nodes/{nodeName}/metrics/{metricName}/{whatever}

Example:

curl http://dashboard-metrics-scraper/nodes/node-1/metrics/cpu/

Response:

{
  "items": [
    {
      "metricName": "cpu",
      "metricPoints": [
        {"timestamp": "2026-03-05T10:30:00Z", "value": 450000000},
        {"timestamp": "2026-03-05T10:31:00Z", "value": 520000000}
      ],
      "dataPoints": [{"x": 1709637000, "y": 450}],
      "uids": ["node-1-uid"]
    }
  ]
}

Pod Metrics

GET /namespaces/{namespace}/pod-list/{podName}/metrics/{metricName}/{whatever}

Example:

curl http://dashboard-metrics-scraper/namespaces/default/pod-list/nginx-abc/metrics/memory/

Deployment Metrics

View aggregated metrics for deployments at Workloads → Deployments.

The deployment view shows (modules/api/pkg/resource/deployment/list.go:31-44):

type DeploymentList struct {
    ListMeta          types.ListMeta
    CumulativeMetrics []metricapi.Metric
    Status            common.ResourceStatus
    Deployments       []Deployment
    Errors            []error
}

Cumulative metrics include:

• Aggregate CPU usage across all pods
• Aggregate memory usage across all pods
• Per-deployment sparklines
• Resource utilization trends

Metrics Configuration

Customize metrics behavior with Dashboard flags:

API Container Flags

--metrics-scraper-service-name=kubernetes-dashboard-metrics-scraper
--namespace=kubernetes-dashboard
--metric-client-check-period=30s

Metrics Scraper Flags

--db-file=/tmp/metrics.db
--metric-resolution=1m
--metric-duration=15m

The --metric-client-check-period flag controls health check frequency. Dashboard disables metrics if the scraper becomes unavailable.

Understanding Metrics Data

CPU Metrics

CPU is measured in millicores:

• 1000m = 1 full CPU core
• 500m = 0.5 CPU cores
• 100m = 10% of one CPU core

Memory Metrics

Memory is measured in bytes:

• 1024 bytes = 1 KiB
• 1048576 bytes = 1 MiB
• 1073741824 bytes = 1 GiB

Time Windows

Default retention:

• Scrape Interval: 60 seconds
• Retention Period: 15 minutes
• Database Size: Automatically managed

Troubleshooting

Metrics not displayed

Check metrics-server installation:

kubectl get pods -n kube-system | grep metrics-server
kubectl top nodes

Verify metrics-scraper is running:

kubectl get pods -n kubernetes-dashboard | grep metrics-scraper
kubectl logs -n kubernetes-dashboard deployment/kubernetes-dashboard-metrics-scraper

Metrics lag or outdated

Check the scrape interval and database health:

kubectl logs -n kubernetes-dashboard deployment/kubernetes-dashboard-metrics-scraper --tail=50

Restart the metrics scraper:

kubectl rollout restart deployment/kubernetes-dashboard-metrics-scraper -n kubernetes-dashboard

High memory usage by scraper

Reduce retention period or scrape interval:

--metric-duration=10m  # Reduce from 15m

Metrics Integration

Dashboard integrates with the metrics ecosystem:

Supported Metrics Providers

metrics-server

Default metrics provider using the Metrics API

Custom Providers

Extend via the integration framework

Integration Framework

The integration framework (modules/api/pkg/integration/manager.go) supports:

• Multiple metric providers
• Health checking and failover
• Provider registration and discovery

Dashboard currently integrates metrics-server by default. The integration framework allows for future expansion to providers like Prometheus or custom metrics APIs.

Best Practices

Monitor resource utilization regularly

Check metrics weekly to identify resource bottlenecks and optimize allocations.

Set appropriate resource limits

Use metrics data to determine realistic CPU and memory limits for your workloads.

Alert on anomalies

Integrate external monitoring systems for alerting on unusual metric patterns.

Scale based on metrics

Use HorizontalPodAutoscaler (HPA) to automatically scale based on CPU/memory metrics.

Next Steps

Viewing Logs

Access container logs for debugging

Integrations

Learn about third-party monitoring integrations