For a Node.js container running in Kubernetes, use startup, readiness, and liveness probes for three different decisions: whether initialization has finished, whether a Pod should receive traffic, and whether the process should be restarted. During a rollout, monitor those signals alongside Deployment progress; a missed rollout deadline reports a stalled update but does not automatically roll it back.
What each Kubernetes probe controls
| Signal | What it answers | What failure does |
|---|---|---|
| Startup | Has the application finished starting? | Readiness and liveness checks wait until the startup probe succeeds. |
| Readiness | Should this Pod receive Service traffic now? | The Pod remains running but is marked not ready and is not used as a Service backend. |
| Liveness | Is the process in a failure state from which a restart may help? | Repeated failures mark the container unhealthy and trigger a restart. |
Kubernetes documents the readiness behavior in its probe overview. These signals are not interchangeable: a process can be alive but not ready to serve, and a slow-starting process may need time before either readiness or liveness should be evaluated.
As an Amazon Associate I earn from qualifying purchases.
How to design probe behavior for a Node.js service
Use startup to cover initialization
Configure a startup probe when application initialization can take time. Until it succeeds, Kubernetes does not run that container’s readiness or liveness probes, preventing those checks from treating a still-starting process as failed. Kubernetes gives an illustrative startup allowance using failureThreshold: 30 and periodSeconds: 10, which corresponds to 300 seconds. That is a documentation example, not a measured Node.js startup time or a universal setting.
Use readiness to gate traffic
Make readiness represent whether the instance can serve the requests it is expected to handle. When it fails, Kubernetes keeps the container running while making the Pod ineligible as a Service backend. This makes readiness the appropriate signal for temporary inability to serve, rather than a reason by itself to restart the process.
#1 Best Overall
Reserve liveness for recoverable-by-restart failures
Liveness should detect conditions where restarting the process can plausibly restore progress, such as a deadlock. Avoid treating every temporarily unavailable dependency as a liveness failure. Kubernetes warns that incorrect liveness probes can cause cascading failures: restarting Pods during load may leave the remaining instances with more work and less capacity.
Readiness and liveness can use the same endpoint in some applications, but the consequences still differ. Choose each probe’s predicate for its operational purpose, and keep health endpoints inexpensive with minimal response bodies. For HTTP probes, Kubernetes considers status codes from 200 through 399 successful; the kubelet stops reading the response body after 10 KiB. See the official probe configuration guidance.
Rank #2
Set detection windows from observed behavior
Kubernetes API defaults are periodSeconds: 10, timeoutSeconds: 1, and failureThreshold: 3. They describe default configuration values, not recommended values for every service. A short timeout or low failure threshold may react to transient load; a long detection window may delay removing an unhealthy instance or restarting a stuck one.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Estimate the detection window from the configured interval, timeout, and threshold, then validate it against the service’s measured initialization, load variation, and recovery behavior. The right values depend on the endpoint’s response time and the failure the probe is meant to catch; do not copy the startup example as a Node.js benchmark.
Rank #3
Monitor a rolling update and respond to a stall
-
Follow the update with
kubectl rollout status deployment/<deployment-name>, substituting the Deployment’s actual name. -
If progress stalls, inspect the Deployment’s
Progressingcondition and recent events. Failing new Pods are one documented cause to investigate; also examine whether the new Pods are failing startup, readiness, or liveness checks. -
Account for
progressDeadlineSeconds: its documented default is 600 seconds. When the deadline expires, Kubernetes surfacesProgressing=Falsewith a progress-deadline-exceeded condition and marks the Deployment stalled.Recommended Free Tools
Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy. -
Choose remediation based on the failure. A deadline is an alerting and status signal, not an automatic rollback: the Deployment controller continues processing the Deployment. Correct the underlying issue or decide to roll back using revision history.
See Kubernetes’ Deployment documentation for rollout progress behavior.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Check revision history before rolling back
Kubernetes supports inspecting Deployment rollout history and rolling a Deployment back to an earlier revision. The Deployment API documents a default revisionHistoryLimit of 10 old ReplicaSets. Confirm that the revision you need is still available rather than assuming a rollback target will be retained.
A rollback restores an earlier Pod template; it does not by itself establish that every application-level change is reversible. Before choosing it, consider whether database migrations, queued messages, external side effects, and configuration changes remain compatible with the earlier version. Those are operational compatibility checks, not behaviors guaranteed by Kubernetes. The Deployment reference describes revision history and rollback.
Make cohort rollouts a measured policy
Kubernetes probe and Deployment behavior does not prescribe cohort sizes, canary percentages, traffic-split thresholds, or automatic rollback criteria. Set those choices using the service’s capacity, observability, and service-level objectives rather than applying an unsupported universal recipe.
- Before expansion: define what readiness, error rates, latency, and capacity must look like before sending a larger cohort.
- During each stage: observe the new cohort’s probe failures and user-facing service signals, not just whether Pods are running.
- For abort decisions: state in advance which observable conditions pause expansion and who decides whether to remediate or roll back.
The exact thresholds are service-specific. Probe configuration governs Pod health and traffic eligibility; it does not replace a rollout policy or prove that an application change is safe to reverse.
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.
