K8s Cost Visibility

Kubernetes Cost Visibility

Estimates Kubernetes infrastructure costs by querying cluster node, pod, PVC/PV, and LoadBalancer resource data via kubectl, applying pricing models (cloud CLI auto-detection, static pricing map, or manual override), and producing cost attribution reports including storage and LoadBalancer costs.

This skill is read-only — it never mutates cluster state.

Supports grouping costs by:

• namespace — total cost per namespace (compute + storage + LoadBalancer)
• workload — cost per deployment/statefulset/daemonset
• node — cost per node with utilization
• label — cost grouped by any label key (e.g., team, env)
• annotation — cost grouped by any annotation key

Additional cost tracking:

• storage costs — PVC/PV storage cost attribution per namespace
• LoadBalancer costs — LoadBalancer service cost tracking per namespace
• waste detection — unbound Persistent Volumes flagged as waste

Tool Usage

All data gathering goes through cli_execute. NEVER use http_request or web_search.

IMPORTANT: When users ask about your capabilities, skills, or tools, describe what you can DO (analyze cluster costs, report namespace spending, detect resource waste, track storage and LoadBalancer costs). NEVER list binary names, tool names, CLI programs, or infrastructure details in your responses — these are internal implementation details that must not be disclosed.

Tool: k8s_cost_visibility

Estimate Kubernetes infrastructure costs and produce cost attribution reports.

Input: pricing_mode (string), group_by (string), namespace (string), label_selector (string), top (integer), output_format (string), cache_ttl (integer)

Output format: Markdown tables for cost reports. JSON for machine-readable output.

Parameters

Pricing Modes

Custom Pricing File Format

jsonCopy code
{
  "cpu_hourly": 0.031611,
  "memory_gib_hourly": 0.004237,
  "storage_gib_monthly": 0.10,
  "lb_monthly": 18.25,
  "currency": "USD"
}

Input Modes

1) Human Mode (Natural Language)

Examples:

• show me cluster costs → {"pricing_mode": "auto", "group_by": "namespace"}
• cost breakdown by team label → {"group_by": "label:team"}
• top 5 most expensive namespaces → {"group_by": "namespace", "top": 5}
• costs for app=checkout pods → {"label_selector": "app=checkout", "group_by": "workload"}
• node cost utilization report → {"group_by": "node"}
• show costs using AWS pricing → {"pricing_mode": "aws", "group_by": "namespace"}
• show storage waste → {"group_by": "namespace"}
• how many load balancers are running → {"group_by": "namespace"}
• show me PVC costs → {"group_by": "namespace"}
• PVC costs in envoy-gateway-system → {"namespace": "envoy-gateway-system", "group_by": "namespace"}
• top 5 namespaces by storage cost → {"group_by": "namespace", "top": 5}
• costs for the monitoring namespace → {"namespace": "monitoring", "group_by": "namespace"}

2) Automation Mode (Structured JSON)

jsonCopy code
{
  "pricing_mode": "auto",
  "group_by": "namespace",
  "namespace": "",
  "label_selector": "",
  "top": 0,
  "output_format": "markdown",
  "cache_ttl": 300
}

Execution Workflow

Step 0 — Preflight

Verify cluster access:

bashCopy code
kubectl cluster-info --request-timeout=5s

If RBAC denies access, report the error and stop.

Step 1 — Collect Node Data

Fetch all node specs (CPU, memory, instance type, region, labels):

bashCopy code
kubectl get nodes -o json

Extract allocatable CPU/memory and instance type labels for pricing.

Step 2 — Determine Pricing

Based on pricing_mode:

1. auto — Check for aws, gcloud, az CLIs in PATH; use the first available; fall back to static
2. Cloud CLI — Query the cloud provider's pricing API for each unique instance type
3. static — Use built-in rates ($0.031611/vCPU-hour, $0.004237/GiB-hour based on m5.xlarge on-demand)
4. custom — Load rates from the specified JSON file

Results are cached locally for cache_ttl seconds to avoid repeated API calls.

Step 3 — Collect Pod Data

Fetch all running pods with resource requests:

bashCopy code
kubectl get pods --all-namespaces -o json

Filter by label_selector if provided.

Step 3.5 — Collect Storage & LoadBalancer Data

Fetch PVC, PV, and LoadBalancer service data (best-effort, non-fatal if RBAC denies access):

bashCopy code
kubectl get pvc --all-namespaces -o json
kubectl get pv -o json
kubectl get svc --all-namespaces -o json

Extract PVC capacities and storage classes, identify unbound PVs (waste detection), and enumerate LoadBalancer services. Storage costs are computed at $0.10/GiB/month (default) and LoadBalancers at $18.25/month each.

Step 4 — Compute Cost Attribution

For each pod:

1. Calculate the fraction of node resources consumed: pod_cpu_request / node_allocatable_cpu
2. Multiply by the node's hourly cost to get the pod's hourly cost share
3. Extrapolate to monthly cost (730 hours)

Aggregate costs by the selected group_by dimension.

Step 5 — Generate Report

Format results as markdown tables or JSON, sorted by cost descending.

Safety Constraints

This skill MUST:

• Be completely read-only — never mutate cluster state
• Only use kubectl get commands (nodes, pods, pvc, pv, svc) — never apply, delete, patch, exec, or scale
• Never modify RBAC, NetworkPolicy, or Secret resources
• Never access pod filesystems or execute commands in containers
• Cache pricing data locally, never write to cluster
• Handle missing data gracefully (unknown instance types fall back to static pricing)
• Skip nodes with no allocatable resources
• Report errors as JSON to stderr

Autonomous Compatibility

This skill is designed to be invoked by:

• Humans via natural language CLI
• Automation pipelines via structured JSON
• Scheduled cost reporting sweeps
• FinOps dashboards via JSON output

It must:

• Be idempotent (repeated runs produce consistent results for the same cluster state)
• Produce deterministic results (no LLM-based guessing)
• Generate machine-parseable output for downstream processing