A kubectl plugin for viewing Kubernetes cluster resource allocation, utilization, and live monitoring. Provides quick insights into CPU and memory usage across nodes, namespaces, pods, and deployments.

• 📊 Multiple Output Formats - Text, Pretty tables, JSON, Dashboard, Pie charts, and more
• 🔄 Live Monitoring - Real-time TUI with auto-refresh for continuous observation
• 🎯 Multiple View Modes - Nodes (default), Namespaces with navigation, Pods, and Deployments
• 📈 Resource Metrics - CPU and memory requests, limits, and actual usage with ratio formatting
• ☁️ Cloud Provider Integration - Auto-detects AWS/GCP and displays node metadata if present; columns hidden on bare-metal unless enabled
• 🔍 Flexible Filtering - Label and field selectors for targeted views
• 📏 Value Display Options - Human-readable ratios or raw Kubernetes resource values
• 🛠️ Performance Optimizations - Parallel API fetching, watch cache, and batch operations for large clusters

• Installation
  • Krew (Recommended)
  • From Source
• Quick Start
• Usage
  • Static View
  • Live View
• Output Formats
• Filtering and Selection
• Cloud Provider Integration
• Configuration
• Examples
• Requirements
• Development
• License

The easiest way to install glance is through krew:

kubectl krew update
kubectl krew install glance

Build from source with Go 1.25 or higher:

git clone https://gitlab.com/davidxarnold/glance.git
cd glance
make build
cp target/kubectl-glance /usr/local/bin/

# View cluster resources (pretty output is now the default)
kubectl glance

# Start live monitoring with interactive TUI
kubectl glance live

# View with simple text output (no colors)
kubectl glance -o txt

# Monitor specific namespace pods in real-time
kubectl glance live  # then press 'p' and use ←→ to navigate namespaces

kubectl glance provides a point-in-time snapshot of cluster resources, showing allocation and utilization across nodes.

kubectl glance

Example Output:

┌──────────────────────────────────────────────────────────────────────────────┐
│ CLUSTER: https://k8s.example.com:6443                                        │
│ CPU: ████████░░░░░░░░░░░░ 44.4% (7.1/16)    Nodes: 3 Ready                   │
│ MEM: ██████░░░░░░░░░░░░░░ 19.4% (6.1/31.4Gi)                                 │
└──────────────────────────────────────────────────────────────────────────────┘
 NODE NAME       STATUS  PROVIDERID  ALLOCATABLE  ALLOCATABLE  ALLOCATED  ALLOCATED  USAGE   USAGE     
                                     CPU          MEM          CPU REQ    CPU LIM    CPU     MEM       
 node-1          Ready   aws://...   4            8053040Ki    1.250      2.000      0.186   1172Mi 
 node-2          Ready   aws://...   4            8053040Ki    2.100      3.500      1.420   1856Mi
 node-3          Ready   aws://...   8            16106080Ki   3.750      6.000      2.340   3240Mi
 TOTALS                              16           32212160Ki   7.100      11.500     3.946   6268Mi

Choose from multiple output formats to suit your workflow:

Examples:

# Default pretty output with cluster summary and visual indicators
kubectl glance

# Simple text output with ASCII borders
kubectl glance -o txt

# JSON output for automation
kubectl glance -o json | jq '.totals.totalUsageCPU'

# Visual dashboard
kubectl glance -o dash

# Pie chart visualization
kubectl glance -o pie

# Show cloud provider columns (AWS/GCP node details) if detected (default)
kubectl glance
# Force cloud info columns ON (even on bare-metal)
kubectl glance --show-cloud-provider=true
# Force cloud info columns OFF (even if detected)
kubectl glance --show-cloud-provider=false

# Display pod-level resource details
kubectl glance -p
kubectl glance --pods

# Show exact values instead of human-readable (e.g., 1000m vs 1)
kubectl glance --exact

# Combine options
kubectl glance -c -p -o pretty --exact

kubectl glance live provides a continuously updating TUI (Terminal User Interface) for real-time cluster monitoring, similar to kubectl top but with much richer information and multiple view modes.

kubectl glance live

Features:

• 🔄 Auto-refresh every 2 seconds (configurable)
• 🎯 Four different view modes
• ⌨️ Keyboard-driven navigation
• 📊 Live resource metrics from metrics-server
• 📊 Visual progress bars with color indicators (🟢🟡🔴)
• 📈 Cluster summary dashboard showing aggregate stats
• ✓ Status icons for nodes, pods, and deployments
• 🎨 Color-coded rows based on utilization levels
• 🎛️ Interactive toggles for display options
• 📱 Terminal responsive

Switch between views using keyboard shortcuts:

Default View: Nodes view shows cluster-wide node status on startup.

Namespace Navigation:

• In Namespaces view: Use ↑↓ arrows to select a namespace, press Enter to view pods in that namespace
• In Pods/Deployments views: Use ←→ arrows to cycle through namespaces
• Use --namespace or -N flag to start with a specific namespace

Sort Modes: Press s to cycle through sort modes:

• Status (default) - Non-running/NotReady items first
• Name - Alphabetical order
• CPU - By CPU usage descending
• Memory - By memory usage descending

Progress Bars:

• Visual bars under each resource metric (CPU request, limit, usage; Memory request, limit, usage)
• Shows resource utilization at a glance with filled/unfilled blocks
• Toggle with b key
• Optional percentage display with % key

Menu Bar:

• Bottom menu shows current toggle states with checkboxes (☑/☐)
• Indicates which features are enabled/disabled
• Always visible for quick reference

Compact Mode:

• Toggle with c key
• Hides detailed help text to maximize data display area
• Useful for smaller terminals or when focused on metrics

# Start live view with default settings
kubectl glance live

# Custom refresh interval (5 seconds)
kubectl glance live -r 5
kubectl glance live --refresh 10

# Workflow examples:
# 1. Start in namespaces view, toggle bars and percentages
kubectl glance live
# Press 'b' to see progress bars
# Press '%' to add percentages to bars

# 2. Monitor specific namespace pods
kubectl glance live
# Press 'p' to switch to pods view
# Use ←→ to navigate to your namespace

# 3. Compact mode for smaller terminals
kubectl glance live
# Press 'c' to enable compact mode
# Press 'b' to hide bars if needed

# 4. Node monitoring with visual feedback
kubectl glance live
# Press 'o' for nodes view
# Progress bars show capacity utilization

The live view now includes a cluster summary dashboard and color-coded progress bars:

┌─────────────────────────────────────────────────────────────────────────────┐
│ CLUSTER SUMMARY                                                              │
│ CPU: 🟢 ████████░░░░░░░░ 45.2% (7.2/16 cores)  Nodes: ✓ 3 healthy          │
│ MEM: 🟡 ██████████████░░ 72.5% (23.2/32 Gi)    Pods: 42 running            │
└─────────────────────────────────────────────────────────────────────────────┘

NODE         STATUS      CPU CAP  CPU ALLOC  CPU USE  MEM CAP  MEM ALLOC  MEM USE  PODS
node-1       ✓ Ready     4        2.5        1.8      8Gi      4Gi        3.2Gi    15
             🟡 ████████████░░░░  45%
             🟡 ██████████████░░  63%
             🟢 ██████████░░░░░░  45%

node-2       ✓ Ready     4        3.0        2.1      8Gi      6Gi        5.8Gi    18
             🟡 ████████████████  75%
             🔴 ██████████████████ 95%
             🟡 ██████████████░░  73%

Color Indicators:

• 🟢 Green: < 50% utilization (healthy)
• 🟡 Yellow: 50-90% utilization (warning)
• 🔴 Red: > 90% utilization (critical)

Status Icons:

• ✓ Ready / ⊘ NotReady (nodes)
• ● Running / ○ Pending / ✗ Failed (pods)
• ✓ Ready / ✗ NotReady / ○ Partial (deployments)

The bars use Unicode block characters (█ for filled, ░ for empty) to provide instant visual feedback on resource utilization.

Namespaces View (n)

• Lists all namespaces in the cluster
• CPU and memory requests/limits/usage per namespace
• Pod count per namespace
• Sorted alphabetically

Pods View (p)

• Lists all pods in selected namespace
• CPU and memory requests/limits/usage per pod
• Pod status (Running, Pending, etc.)
• Navigate namespaces with ←→ arrows

Nodes View (o)

• Lists all nodes in the cluster
• Node capacity (total available resources)
• Allocated resources (sum of pod requests)
• Actual usage from metrics-server
• Pod count per node

Deployments View (d)

• Lists all deployments in selected namespace
• Total resource requests/limits across all replicas
• Desired replica count
• Ready replica count
• Available replica count
• Navigate namespaces with ←→ arrows

Glance supports multiple output formats for different use cases:

Clean ASCII table with borders, status column, utilization percentages, and cluster capacity summary. Ideal for environments without color support or for piping to other tools.

kubectl glance -o txt

Features:

• ASCII box borders for clear structure
• Sorted node output for consistency
• CPU % and MEM % utilization columns
• Node status column (Ready/NotReady)
• Cluster capacity summary section

Full-featured colored output with cluster summary dashboard, progress bars, and status indicators. Best for interactive terminal sessions.

kubectl glance
kubectl glance -o pretty

Features:

• 📊 Cluster summary dashboard with aggregate CPU/memory stats
• 📈 Visual progress bars with utilization percentages
• 🟢🟡🔴 Color-coded indicators based on thresholds (<50% green, 50-90% yellow, >90% red)
• ✓/⊘ Status icons for node health
• 📉 Sparkline trend indicators
• Grouped display (NotReady nodes shown first)
• Color-coded utilization cells

Machine-readable JSON output perfect for automation, monitoring systems, and scripting.

kubectl glance -o json

# Example: Extract total CPU usage with jq
kubectl glance -o json | jq -r '.totals.totalUsageCPU'

# Example: Get all node stats
kubectl glance -o json | jq '.nodeMap'

JSON Structure:

{
  "nodeMap": {
    "node-1": {
      "nodeName": "node-1",
      "status": "Ready",
      "allocatableCPU": "4",
      "allocatableMemory": "8053040Ki",
      "totalAllocatedCPUrequests": "1.25",
      "totalAllocatedCPULimits": "2.0",
      "totalAllocatedMemoryRequests": "396Mi",
      "totalAllocatedMemoryLimits": "1024Mi",
      "usageCPU": "0.186",
      "usageMemory": "1172Mi"
    }
  },
  "totals": {
    "totalAllocatableCPU": "4",
    "totalAllocatableMemory": "8053040Ki",
    ...
  }
}

Terminal-based dashboard with visual elements and organized sections.

kubectl glance -o dash

Visual representations of resource utilization:

# Pie chart showing resource distribution
kubectl glance -o pie

# Bar charts and graphs
kubectl glance -o chart

Filter resources using Kubernetes label and field selectors:

# Filter nodes by environment label
kubectl glance --selector environment=production

# Multiple labels (AND logic)
kubectl glance --selector app=nginx,tier=frontend

# Short form
kubectl glance -l app=myapp

# Filter by specific field values
kubectl glance --field-selector metadata.name=node-1

# Multiple field selectors
kubectl glance --field-selector status.phase=Running,spec.nodeName=node-1

# Combine label and field selectors
kubectl glance --selector app=nginx --field-selector status.phase=Running -o pretty

Glance can fetch additional metadata from cloud providers (AWS and GCP) to enrich node information. Cloud provider columns are shown by default only if a supported provider is detected (AWS/GCP). On bare-metal or unknown providers, columns are hidden unless the flag is set.

# Cloud info columns are shown by default if AWS/GCP is detected
kubectl glance
# Force cloud info columns ON (even on bare-metal)
kubectl glance --show-cloud-provider=true
# Force cloud info columns OFF (even if detected)
kubectl glance --show-cloud-provider=false

What You Get:

• AWS EC2: Instance type, availability zone, region, instance ID
• GCP GCE: Machine type, zone, project ID, instance ID

Cloud provider credentials must be configured:

AWS:

• AWS credentials in ~/.aws/credentials or environment variables
• IAM permissions: ec2:DescribeInstances

GCP:

• Application Default Credentials or service account
• Permissions: compute.instances.get

Behavior:

• If no supported cloud provider is detected, glance hides cloud columns by default (no API calls made)
• Use --show-cloud-provider=true to force columns on, or --show-cloud-provider=false to force off

# View with cloud provider columns (if detected)
kubectl glance -o pretty
# Force cloud columns ON
kubectl glance --show-cloud-provider=true -o pretty
# JSON output always includes cloud fields if present
kubectl glance -o json | jq '.nodeMap[].cloudInfo'

Notes:

• --node-limit and --pod-limit are useful for large clusters (>100 nodes) to improve performance
• Sort mode can be changed dynamically in live view by pressing s
• Namespace can be changed interactively using Left/Right arrow keys

Glance respects standard Kubernetes environment variables:

# Use specific kubeconfig
export KUBECONFIG=~/.kube/config-production
kubectl glance

# Set default namespace
export KUBECTL_NAMESPACE=my-namespace
kubectl glance

# Set log level (trace, debug, info, warn, error, fatal)
# When set to debug or info, logs are written to ~/.glance/<level>-glance.log
export GLANCE_LOG_LEVEL=debug
kubectl glance

Create ~/.glance for persistent configuration (YAML format):

selector: "environment=production"
output: pretty
show-cloud-provider: auto   # auto (default), true, or false
exact: false
log-level: warn  # trace, debug, info, warn, error, fatal
namespace: ""    # Initial namespace for live view (empty = all namespaces)

# Cloud info caching (live mode only)
cloud-cache-ttl: 5m      # TTL for cloud provider info cache (default: 5m)
cloud-cache-disk: false  # Persist cache to ~/.glance/cloud-cache.json (default: false)

# Column visibility (live mode - persisted when toggled with i/v/a keys)
show-node-version: false # Show node version column (default: false)
show-node-age: false     # Show node age column (default: false)

Cloud Cache Settings:

• cloud-cache-ttl: Duration to cache AWS/GCP instance type info. Valid units: s, m, h. Example: 300s, 5m, 1h
• cloud-cache-disk: When true, cache persists between sessions in ~/.glance/cloud-cache.json

Column Visibility:

• Initial state loaded from config file
• Changes made with i (cloud), v (version), a (age) keys are automatically saved
• Requires config file to exist for persistence

By default, glance uses warn level logging which minimizes terminal output. For debugging:

• Set GLANCE_LOG_LEVEL=debug environment variable, or
• Add log-level: debug to your ~/.glance config file

Log files are written to:

• ~/.glance/<level>-glance.log (preferred), or
• /tmp/<level>-glance.log (fallback)

Log files are only created for trace, debug, or info levels.

# Quick cluster overview
kubectl glance -o pretty

# Monitor production namespace in real-time
kubectl glance live
# Press 'p' for pods, then navigate to production namespace

# Check specific application resources
kubectl glance --selector app=nginx -p -o pretty

# Export cluster state for reporting
kubectl glance -o json > cluster-report-$(date +%Y%m%d).json

# Compare resource requests vs usage
kubectl glance -o pretty | grep -E "ALLOCATED|USAGE"

# Monitor cluster during deployment
kubectl glance live -r 1  # 1-second refresh

# Check nodes with cloud info
kubectl glance -c --field-selector metadata.name=node-1

# Get exact values for billing/capacity planning
kubectl glance --exact -o json > capacity-report.json

#!/bin/bash
# Alert if CPU usage exceeds 80%

USAGE=$(kubectl glance -o json | jq -r '.totals.totalUsageCPU' | cut -d'.' -f1)
if [ "$USAGE" -gt 80 ]; then
  echo "ALERT: CPU usage at ${USAGE}%"
  # Send notification...
fi

#!/bin/bash
# Daily capacity report

kubectl glance --exact -o json | jq '{
  date: now | strftime("%Y-%m-%d"),
  totalNodes: .nodeMap | length,
  totalCPU: .totals.totalAllocatableCPU,
  usedCPU: .totals.totalUsageCPU,
  totalMemory: .totals.totalAllocatableMemory,
  usedMemory: .totals.totalUsageMemory
}' > capacity-$(date +%Y%m%d).json

• Kubernetes: 1.12 or higher (tested with 1.31)
• Metrics Server: Required for usage statistics and live view
  • Install: kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

• kubectl: 1.12 or higher
• Go: 1.25 or higher (for building from source)
• Terminal: Supports ANSI colors (for pretty output and live view)

Required RBAC permissions:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: glance-viewer
rules:
- apiGroups: [""]
  resources: ["nodes", "pods", "namespaces"]
  verbs: ["get", "list"]
- apiGroups: ["apps"]
  resources: ["deployments"]
  verbs: ["get", "list"]
- apiGroups: ["metrics.k8s.io"]
  resources: ["nodes", "pods"]
  verbs: ["get", "list"]

Glance is optimized for large Kubernetes clusters with advanced performance features:

• Parallel API Fetching - Uses Go errgroup for concurrent node, pod, and namespace queries
• Watch Cache - Leverages Kubernetes API server's watch cache (resourceVersion="0") to reduce etcd load
• Batch Operations - Single pod list call with in-memory grouping eliminates N+1 query problem
• Smart Limits - Configurable node and pod limits prevent display overload in large clusters

Glance automatically detects large clusters (>100 nodes) and warns about performance considerations:

# For clusters with 100+ nodes, glance shows a warning:
WARN Large cluster detected (150 nodes). Using --node-limit=20 for performance.
Consider using --watch mode for real-time updates with lower API load.

# Increase display limits for larger terminals
kubectl glance live --node-limit=50 --pod-limit=200

# Increase API concurrency for faster fetching
kubectl glance live --max-concurrent=100

# Sort by specific criteria to focus on problem areas
kubectl glance live --sort-by=cpu  # Show highest CPU usage first

# Build binary
make build

# Run tests
make test

# Run linter
make lint

# Format code
make fmt

# Check everything
make check

glance/
├── cmd/                 # Main application entry point
├── pkg/
│   ├── cmd/            # Command implementations
│   │   ├── glance.go   # Main command and static view
│   │   ├── live.go     # Live TUI implementation
│   │   ├── render.go   # Output formatting
│   │   ├── types.go    # Data structures
│   │   ├── aws.go      # AWS integration
│   │   └── gce.go      # GCP integration
│   └── util/           # Utility functions
├── plugins/krew/       # Krew plugin manifest
└── version/            # Version information

# Run all tests
go test ./...

# Run with coverage
go test -cover ./...

# Run specific test
go test ./pkg/cmd -run TestLive

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Run make check
6. Submit a pull request

The project uses GitLab CI/CD to automate releases. Here's how to create a new release:

• GL_CI_TOKEN CI/CD variable set in GitLab with write access to the repository
• Version updated in version/version.go

# 1. Update version in version/version.go
vim version/version.go

# 2. Build all platforms, create archives, generate checksums, update krew manifest
make release

# 3. Review the updated krew manifest
cat plugins/krew/glance.yaml

# 4. Commit and tag
git add -A && git commit -m "Release v$(make release_version)"
make tag-release
git push && git push --tags

# 5. Upload archives to GitLab release page
# Files are in: target/archives/

Simply push a version tag to trigger the full release pipeline:

# 1. Update version in version/version.go and commit
vim version/version.go
git add -A && git commit -m "Prepare release v0.1.0"
git push

# 2. Create and push tag (triggers release)
git tag v0.1.0
git push --tags

The CI pipeline will automatically:

1. Run lint and tests
2. Build binaries for all platforms (darwin/linux amd64/arm64, windows amd64)
3. Create .tar.gz archives
4. Generate SHA256 checksums
5. Create a GitLab Release with downloadable artifacts
6. Update the krew manifest with new version and checksums

After creating a release:

1. Fork kubernetes-sigs/krew-index
2. Copy plugins/krew/glance.yaml to plugins/glance.yaml in your fork
3. Submit a PR to the krew-index repository
4. Wait for review and approval

Apache License 2.0 - See LICENSE for details.

• Issues: https://gitlab.com/davidxarnold/glance/-/issues
• Repository: https://gitlab.com/davidxarnold/glance

Built with:

• Cobra - CLI framework
• termui - Terminal UI components
• go-pretty - Table rendering
• client-go - Kubernetes API client