The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →To monitor complex Kubernetes Deployments, combine rollout and Pod status with resource metrics, application logs and traces, probe behavior, and—in Harbor’s case—Harbor’s own metrics. A green dashboard or a CPU-and-memory snapshot alone cannot establish that an application is healthy: it may miss failed requests, unready replicas, or a growing queue.
How do I monitor complex Kubernetes Deployments? Start by checking whether the workload is progressing and serving traffic, then correlate Kubernetes signals with application behavior. Use Harbor as a concrete example of how service-specific telemetry adds information that generic container metrics cannot.
As an Amazon Associate I earn from qualifying purchases.
What to monitor: signals from cluster to application
Kubernetes observability is commonly organized around metrics, logs, and traces. Metrics show measurements over time, logs record events, and traces connect the timing and relationships of operations across components. Correlating them helps locate whether a symptom originates in the workload, a dependency, or the cluster. Kubernetes observability documentation describes these signal types and approaches to collecting them.
Deployment and Pod state
Begin with object state: is the Deployment progressing, and does it have the expected available replicas? Inspect affected Pods and recent events for scheduling issues, failed rollouts, or container-state problems. Those conditions tell you where to investigate; metrics and logs help explain why they occurred.
#1 Best Overall
Resource and component metrics
Collect CPU and memory alongside relevant component measurements. Kubernetes components expose Prometheus-format metrics, and the kubelet provides additional endpoints, including /metrics/cadvisor, /metrics/resource, and /metrics/probes. Add-ons such as kube-state-metrics can provide telemetry about Kubernetes object status. Which endpoints and add-ons are available depends on the cluster’s configuration. See the observability documentation and Kubernetes metrics reference.
Application signals
Collect application-level metrics, logs, and traces when the workload emits them. Centralized log collection and trace pipelines make it possible to compare application behavior with cluster and container signals. The implementations and instrumentation depend on the application and environment; Kubernetes does not prescribe one universal pipeline.
Why kubectl top is only a quick check
The Kubernetes resource metrics pipeline provides limited CPU and memory measurements for nodes and Pods. When the Metrics API is available, kubectl top is useful for a current resource snapshot, and resource metrics also support autoscaling use cases. But this data is not a substitute for a full monitoring pipeline with historical metrics and other signals. A full pipeline can also expose custom or external metrics to autoscaling mechanisms through an adapter. Kubernetes’ resource metrics pipeline documentation explains the scope and limitation.
Kubernetes documentation does not select one monitoring pipeline for every cluster. The appropriate approach depends on needs, budget, and technical resources; the ecosystem includes open-source systems and paid SaaS options. Choose based on signal coverage, retention and scale, integration needs, and the team’s ability to operate the system—not a feature-count comparison.
Rank #3
Use probes for distinct operational jobs
Startup, liveness, and readiness probes are not interchangeable health checks. A startup probe checks whether an application has started. When configured, Kubernetes waits for it to succeed before running liveness or readiness probes, which can accommodate longer initialization. A liveness probe detects a container that should be restarted; readiness determines whether it should receive traffic.
As the Kubernetes documentation puts it, “Based on the probe results, Kubernetes can restart unhealthy containers or stop sending traffic to containers that are not ready.” A probe is therefore both a signal and an operational control: an overly aggressive liveness check can trigger restarts, while readiness can keep traffic away from a container that is not ready. Choose checks that reflect the application’s actual state rather than assuming one configuration fits every workload. See Liveness, Readiness, and Startup Probes.
What Harbor metrics add
Harbor documents Prometheus-format metrics from its exporter, core, jobservice, and registry components. They include runtime and API performance data, in-flight request measurements, registry metrics, and business data drawn from Harbor’s database. Harbor documentation says metrics can be enabled in Harbor v2.2 and later; the endpoint and metrics port or path depend on configuration. Check the documentation for the version you run before applying configuration: Harbor documentation.
Free tools Windows power users keep installed
One-click scans. No signup required.
Metric families to inspect
harbor_healthreports Harbor’s current status.harbor_upreports running status by component, including core, database, jobservice, portal, Redis, registry, registryctl, and Trivy.harbor_task_queue_sizeandharbor_task_queue_latencydescribe queued Harbor jobs and how long they wait.- Other exporter metrics cover project and repository counts, quota use, artifact pulls, and artifact totals.
These Harbor-specific signals can reveal service health or queued work that generic Pod CPU and memory measurements do not describe. Interpret them alongside the state and resource use of Harbor’s Kubernetes workloads, not in isolation.
Best Value
Scrape Harbor in Kubernetes
For a Harbor instance running in Kubernetes, Harbor’s documentation describes enabling metrics in the Harbor Helm chart’s values.yaml and defining a Prometheus Operator ServiceMonitor that selects Harbor’s Service. The example uses the monitoring.coreos.com/v1 API and a metrics endpoint named metrics. Before using it, verify the installed chart’s Service labels and metrics port name, and confirm that the monitoring stack discovers and scrapes the endpoint. Chart values and scrape configuration can differ across installations; the Harbor documentation is the version-specific reference.
A practical sequence for dashboards and triage
Use this as an operational sequence, not as a dashboard layout prescribed by Kubernetes. Start with the symptom and follow its dependencies until you find an actionable cause.
- Check rollout and availability. Inspect Deployment rollout status, available replicas, affected Pods, and recent events. Look for scheduling failures, stalled rollouts, or container-state changes.
- Compare resource use with capacity. Use
kubectl topfor a quick CPU and memory view if the Metrics API is installed. For ongoing and historical analysis, use a full metrics pipeline and compare Pod use with node capacity. - Review probes and restarts. Check readiness and liveness behavior, restart counts, and probe metrics if collected. The kubelet has a
/metrics/probesendpoint, and the Kubernetes metrics reference documents a probe counter by result. - Correlate application behavior. Compare application metrics and request traces with container and system logs to determine which layer is failing.
- For Harbor, inspect service-specific signals. Review
harbor_health, component-levelharbor_up, and task queue size and latency alongside the Kubernetes state of Harbor’s Pods. - Choose an operational response. Depending on the evidence, restore capacity, investigate an unhealthy dependency or queued work, or correct rollout or configuration problems. Tie alerts to a service objective or a condition with a clear owner and response.
Build monitoring around decisions, not dashboard color
A useful dashboard connects a symptom to the evidence and action that matter. For example, a deployment with available replicas may still be returning errors; a Harbor queue can grow even when its Pods do not show obvious resource pressure. Pair object state with relevant measurements and application signals so operators can distinguish “running” from “working.”
- Coverage: decide whether resource metrics alone are sufficient or whether you also need object status, logs, traces, and application-specific measurements.
- Ownership: weigh the control and maintenance work of self-managed collection and storage against the operating model of a managed service.
- Retention and scale: account for whether you need only current resource inspection or historical analysis across multiple clusters.
- Integration: verify Kubernetes discovery, Prometheus/OpenMetrics compatibility, Harbor endpoint scraping, and any custom metrics API required for autoscaling.
- Actionability: ensure an alert names an owner and a response, and maps to a service objective or a condition operators can act on.
There is no universal CPU, memory, queue, or probe threshold established for every Kubernetes application. Set limits and alerts from service objectives and observed baselines, then tune them as workload behavior changes. Exact PromQL, YAML, alert limits, and dashboard panels depend on the Kubernetes and Harbor versions, chart values, scrape implementation, and objectives in your environment.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
