Readiness controls traffic; liveness controls restarts. A failed readiness probe marks a Pod unready and removes it from Service backends without restarting its container. A failed liveness probe tells the kubelet that the process needs recovery, so the kubelet restarts the container after the configured failure threshold. A startupProbe protects slow initialization by delaying both checks until startup succeeds.
At a glance: two probes, two different decisions
Kubernetes does not treat a container that is merely running as ready to serve users. The kubelet evaluates probe results separately, and the Service uses readiness state while the kubelet uses liveness state for recovery decisions.
As an Amazon Associate I earn from qualifying purchases.
| Probe | Question it answers | When it fails | Best scope | Typical lifecycle use |
|---|---|---|---|---|
| Readiness | Can this container accept useful requests right now? | The Pod is marked unready and is removed from Service load-balancing eligibility. The container is not automatically restarted. | Current ability to serve, including temporary initialization, draining, or a dependency that is essential to the requests this Pod handles. | Runs throughout the container lifecycle, including after startup. |
| Liveness | Is the process unhealthy enough that restarting it is an appropriate recovery action? | After the configured consecutive-failure threshold, the kubelet restarts the container. | A cheap, local indication of a deadlock or process that is alive but cannot make progress. | Begins after any startup gate has succeeded and continues while the container runs. |
| Startup | Has lengthy initialization completed? | The container is treated as failed startup after its threshold, allowing normal container-restart behavior. | Bootstrapping work such as loading a large state set, migrations, or expensive configuration initialization. | Gates liveness and readiness until it succeeds. |
The practical consequence is easy to remember: readiness protects users from a temporarily unsuitable instance, while liveness protects the workload from a process that needs to be restarted. Mixing those meanings is a common cause of traffic blackouts and restart storms.
What a readiness probe checks
A readiness check should answer whether the application can successfully handle the requests that the Service is about to send. When it fails, Kubernetes marks the Pod unready, and Services stop selecting that Pod as a traffic destination. The process remains alive, so it can finish initialization or recover without losing its in-memory state.
#1 Best Overall
- [Ultra-Lightweight Ear Buds Designed for Small Ears] Each earbud weighs only 3.7g and features a compact, ergonomic in-ear design made especially for small ears. Secure, low-profile, and comfortable for workouts, all-day wear or overnight sleeping.The ultra-slim profile sits flush in your ear with no hard edges poking or rubbing, so you can even sleep on your side without discomfort.
- [Immersive Stereo Sound with TOZO OrigX Technology] TOZO OrigX tuning delivers clear vocals, balanced mids, and natural stereo sound for music, podcasts, and videos.
- [Long Battery Life for Daily Use] Get up to 7 hours of playtime on a single charge, with up to 32 hours total using the charging case—ideal for workdays, commuting, and extended listening sessions.
- [Bluetooth 5.3 & Stable Connection] Bluetooth 5.3 provides fast pairing, stable wireless performance, and reduced dropouts as you move around home or office.
- [Deep Bass with Clear Vocals] High-performance drivers produce punchy bass while keeping vocals clean and detailed for everyday listening.
Appropriate readiness conditions
- The application is still loading models, caches, routes, or other state required to answer requests.
- The application has entered a deliberate drain period before shutdown or a planned handoff.
- A dependency is temporarily unavailable and requests handled by this Pod cannot succeed without it.
- A local queue, worker pool, or resource limit means the instance cannot accept more work for the moment.
Readiness is evaluated for the entire time the container exists, not only during startup. A Pod can become ready, later fail readiness during a dependency outage, and become ready again after the condition clears. Configure successThreshold when you need multiple consecutive successes before admitting traffic again; that can reduce readiness flapping.
Give the endpoint honest semantics
Returning success before the application can serve real requests admits traffic too early. Returning failure for a nonessential dependency has the opposite problem: healthy capacity is drained even though the Pod could still answer the requests that matter. Define the endpoint around the actual contract of the Service, not around whether a single background task is behind schedule.
What a liveness probe checks
Liveness is a recovery signal. Use it when a failed check means that restarting the container is more likely to restore service than waiting for the current process. A deadlocked request loop, an event loop that no longer makes progress, or an unrecoverable internal state can justify a liveness failure.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Keep liveness local and inexpensive
A liveness handler should normally inspect the process itself and complete quickly. It should not require a database query, a remote API call, or a long dependency chain merely to prove that the process is alive. A transient downstream outage can otherwise make every Pod fail liveness at once. Kubernetes warns that an incorrectly implemented liveness probe can create cascading failures: overloaded Pods restart, clients lose requests, and the remaining Pods receive still more work.
Why dependency checks usually do not belong in liveness
Suppose a database has a short network interruption while the application process is healthy and able to reconnect. If the liveness endpoint reports that database failure, the kubelet restarts the container. The restart does not repair the database and may discard useful state, increase load, and repeat across replicas. Put that condition in readiness when requests truly cannot be served, or expose it as a separate metric and alert when the process can continue operating.
How startupProbe protects slow applications
A startupProbe is an initialization gate. While it has not succeeded, Kubernetes does not begin liveness or readiness probing. This prevents a slow but functioning application from being killed by a liveness deadline designed for steady-state operation.
Rank #2
- 【IP68 Waterproof Multifunctinal Smart Watch】Torjalph fitness activity tracker smart watch is IP68 waterproof technology ,you can wear it when swimming,handwashing,it's rain-proof which means that you perform multiple exercise modes outside without worrying about sweat or rain corroding your fitness smart watch,and this watch equipped with a 230 mAh large capacity battery magnetic charging ,and this sports activity tracker watch can be used 5-7 days If fully charged.
- 【Larger 1.83'' Full Screen Watch & Multi-dial Selection】1.83 inch full HD color touch screen smart watch for men / women provides excellent 240*284 resolution image quality ,This Bluetooth smart watch offers a better touch experience and remarkable immersion and ,more than 200 watch faces for you to choose from App"Da Fit ", you can change the dial style according to your mood to wear keeping the world on your wrist
- 【Accurate Activity Tracker Smart Watch 】sports watch activity tracker uses sweat and dust resistant breathable silicone strap, our Fitness Tracker Smart Watch for Android iOS Phones supports 12 sports modes,walking,running,bicycle,swimming,badminton,basketball,football,rope skipping. This bluetooth calls smart watch for men women is lightweight and stylish, bringing more convenient and relaxing sports experience while also providing more protection.
- 【Your 24 Hour Personal Daily Health Monitor】Fitness watch for women men full touch screen IP67 waterproof bluetooth smartwatch for Android iOS Phones with heart rate blood pressure monitor multifunction Andriod smart watch with steps counter sleep monitor sports fitness watch, monitoring blood oxygen saturation allows you to understand your physical condition in real time to track fitness progress ,to know your health status in time.
- 【More Functions Bluetooth Call Smart Watch】This fitness activity smart watch full screen for iPhone and Android phones includes a bunch of new features including:The bluetooth smart watch can hang up the phone, receive and display WhatsAPP /Text /Facebook /Twitter /Messenger reminder.Support sedentary reminder, alarm clock, stopwatch, timer,weather information,music control, remote camera control compatible with Android 5.0 and above or iOS 9.0 and above smartphones.
Size the startup budget for the worst expected startup, not the average on a quiet node. The budget represented by a probe is approximately failureThreshold × periodSeconds. Kubernetes documentation illustrates failureThreshold: 30 and periodSeconds: 10, which allows 300 seconds (30 × 10) before startup is considered failed. That is an example configuration, not a benchmark or a universal recommendation.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteWhen to add a startup probe
- Cold starts load a large data set or build an index.
- Database migrations or configuration generation can occasionally take several minutes.
- JIT compilation, certificate loading, or hardware discovery varies significantly between nodes.
- Normal liveness timing is intentionally strict once the application is serving.
After startup succeeds, the regular readiness and liveness probes take over. If startup never succeeds, investigate initialization rather than loosening liveness indefinitely.
Probe handlers and endpoint requirements
Kubernetes supports HTTP, TCP, gRPC, and exec probes. Select the handler that tests the smallest useful signal for the process.
HTTP
Use a dedicated, low-cost endpoint with a minimal response body. The handler must listen on the Pod IP and the configured port; binding only to an unreachable address or specifying the wrong port makes the probe fail even when the application works inside the container. Keep readiness and liveness paths distinct when they have different semantics, such as /ready and /live.
TCP
A TCP probe verifies that a connection can be established on the configured port. It does not prove that a request can be processed, that a protocol is speaking correctly, or that required dependencies are available. Use it only when an open listener is a sufficient health signal.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →gRPC
A gRPC probe must target the correct port and health-check service name. An incorrect service name, an unsupported or unimplemented health-check protocol, or a port mismatch counts as probe failure. Confirm that the server exposes the health service expected by the probe configuration.
Rank #3
- [Low Noise High Fidelity] New bee guitar cord with 22AWG oxygen-free-copper center conductors provides enhanced signal transfer, the PVC insulation material and the high-density stranded copper double shield provide noise rejection for quiet operation
- [Ideal for Choice] New bee 1/4 straight and right angle metal connectors, ensures a secure connection in any instrument, pedal, or amp jack. L shape great fro on stage guitar stands
- [Wide Compatible] Suitable for mixer, power amplifier, microphone, effector, decoder, equalizer, electoronic organ, electric guitar, electric bass and other electronic equipments. Widely used in the installation of smart home, karaoke speaker, professional stage audio, etc
- [Easy Disassemble] Making incidental repairs quick and easy! Very nice, flexible cable
- [Dont Hesite to Order] 24 hours customer services and professional technology team are standing by
Exec
An exec probe runs a command inside the container. The command should be deterministic and short; avoid scripts that depend on optional tools, network access, or mutable shell state. An exec check that works in an interactive shell may still fail under the container’s actual user, environment, or filesystem.
Configuration fields that determine behavior
| Field | Meaning | Design implication |
|---|---|---|
initialDelaySeconds |
Delay before probing begins, unless a successful startup probe gates the later probes. | Use it only for a predictable initial delay; a startup probe is safer when startup time varies. |
periodSeconds |
Interval between probes. The documented default is 10 seconds and the minimum is 1 second. | Short intervals detect changes faster but add handler and kubelet work. |
timeoutSeconds |
Time allowed for an individual probe response. | Set it above normal handler latency while still catching a genuinely stuck check. |
failureThreshold |
Consecutive failures required before the probe’s failure action is taken. | For readiness, it controls how quickly traffic is removed; for liveness, it controls how much transient delay is tolerated before restart. |
successThreshold |
Consecutive successes required to declare recovery. | Readiness can use a value greater than one to reduce flapping; use the value supported by the probe type and your Kubernetes version. |
terminationGracePeriodSeconds |
Grace period used when the kubelet terminates a failed container, subject to Kubernetes version and field behavior. | Allow enough time for the process to close connections and flush state, but do not use a long grace period to hide a probe that is failing continuously. |
For a failure budget, distinguish the time allowed for one response (timeoutSeconds) from the time until action after repeated failures (failureThreshold and periodSeconds). Treat those as separate design decisions.
A complete Deployment pattern
The following pattern gives each signal a separate purpose: startup allows a five-minute worst-case initialization, readiness controls traffic, and liveness checks only local progress.
apiVersion: apps/v1
kind: Deployment
metadata:
name: orders-api
spec:
replicas: 3
selector:
matchLabels:
app: orders-api
template:
metadata:
labels:
app: orders-api
spec:
containers:
- name: api
image: example/orders-api:2.4
ports:
- name: http
containerPort: 8080
startupProbe:
httpGet:
path: /startup
port: http
periodSeconds: 10
failureThreshold: 30
readinessProbe:
httpGet:
path: /ready
port: http
periodSeconds: 5
timeoutSeconds: 2
failureThreshold: 2
successThreshold: 2
livenessProbe:
httpGet:
path: /live
port: http
periodSeconds: 10
timeoutSeconds: 2
failureThreshold: 3
In this example, a temporary readiness failure removes the replica from Service backends after the configured consecutive failures, while two successful checks are required before it is admitted again. A liveness failure takes three consecutive failed checks before the kubelet restarts the container. The startup budget is 30 checks at 10-second intervals, or 300 seconds.
Separate gRPC example
startupProbe:
grpc:
port: 50051
service: orders-startup
periodSeconds: 10
failureThreshold: 30
readinessProbe:
grpc:
port: 50051
service: orders-readiness
livenessProbe:
grpc:
port: 50051
service: orders-liveness
Only use service names that the server actually implements. If the health protocol or name is wrong, Kubernetes reports probe failure even though the gRPC process may be listening.
Why a Pod can be Running but receive no traffic
Running describes the container phase: the container has started and has not terminated. It does not assert that the Pod is Ready or that a Service currently has the Pod in its backend set.
Rank #4
- Digital Family Calendar: BSIMB digital calendar wall touch screen puts an end to your chaotic life. Designed for busy families, the digital calendar keeps you organised and in step with your family. Assign different colours and tasks to each family member to make family scheduling easier and more intuitive.
- Easy Setup and Auto-Sync: Plug in, connect to WLAN and auto-syn your electric calendar in minutes. Digital wall calendar compatible with Google calendar, iCloud calendar, Outlook calendar, Cozi calendar and Yahoo calendar. Add events directly on the device or through the ecalendar app. Electronic calendar stays current whether you're at work or traveling—no manual updates needed.
- All-In-One Home Assistant: Smart calendar builds habits and encourage independence with personalised chores. Display daily meal plan to reduce the daily ‘What's for dinner?’ stress. To-do lists keep track of everything you want. Turning chores into valuable achievements with stars and rewards, making life easier and more enjoyable.
- Manage Anytime Anywhere: BSIMB electronic calendar for family stay connected with the powerful ecalendar app. Access and manage your digital wall calendar anytime, anywhere with free features like stars & rewards, photo screensaver, chore charts, meals plans, to-do lists etc. Electronic planner paid features like Magic Import tailor advanced tools for users with special needs.
- Stay in Touch with Loved Ones: Share photos or videos from your phone to electronic wall calendar with app, instantly update your life moment, and keep in touch with your family, especially those who are far away; you can also surprise your smart calendar digital wall by sending him a wish card; it's also great for keeping tech-illiterate elders in touch with the youngsters.
1. The readiness probe is failing
A wrong path, port, protocol, status response, or response timeout leaves the Pod running but unready. The Service then excludes it from load balancing. Inspect the Pod conditions and events rather than inferring health from the phase alone.
Free tools Windows power users keep installed
One-click scans. No signup required.
2. The probe reaches the wrong place
Verify that the application listens on the Pod IP, not only on an address inaccessible from the kubelet’s probe path. Check the named port or number, container port, HTTP path, and protocol. A typo in any one of these produces the same operational symptom: no ready backend.
3. The readiness endpoint has overly broad dependency logic
If the endpoint fails for a nonessential cache, metrics exporter, or optional upstream, it can drain every replica while user-facing request handling remains possible. Refine the endpoint to the dependencies required for the Service’s actual contract.
4. The Service selects no ready endpoints
Even a correctly probing Pod will not receive Service traffic if the Service selector does not match its labels. Check the Service selector and the generated EndpointSlices separately from Pod status. This distinguishes a probe problem from a routing or label problem.
5. Startup protection is missing
A slow application may fail liveness during initialization, restart repeatedly, and never reach readiness. Add a startup probe with a budget covering the worst startup path, then keep steady-state liveness timing appropriate for a running process.
Recommended Free Tools
Failure modes caused by misconfiguration
| Misconfiguration | What Kubernetes observes | Operational result | Correction |
|---|---|---|---|
| Wrong HTTP path or port | The kubelet cannot obtain the intended response. | Readiness fails and the Pod is removed from Service backends; liveness can also trigger restarts if it uses the same bad target. | Test the exact path and port from the Pod, then align the manifest with the listener. |
| Wrong protocol or gRPC service | The handler is unreachable or the health service is not implemented. | Repeated probe failures despite a process that appears to be running. | Match the configured handler and service name to the server’s implementation. |
| Liveness depends on a database or upstream | A transient downstream failure looks like a dead process. | Unnecessary restarts, possible restart storms, and amplified load on remaining replicas. | Keep liveness local; put request-critical dependency availability in readiness. |
| No startup probe for slow initialization | Liveness times out before initialization completes. | The container is killed before it can become useful. | Add a startup gate or size startup timing for the worst expected initialization. |
| Readiness succeeds too early | The endpoint reports success before request handling is complete. | Traffic arrives at an instance that returns errors or times out. | Make readiness success represent real ability to serve. |
| Readiness fails for optional work | A nonessential condition is treated as an outage. | Healthy capacity is drained and a rollout may appear stalled. | Separate optional health information from the traffic gate. |
| Probe is too sensitive to load | Short-lived latency spikes become failures. | Readiness flaps or liveness restarts containers during peak demand. | Use realistic timeouts, intervals, and thresholds; keep the handler cheap. |
Choosing readiness, liveness, or neither for dependencies
Classify a condition by the action that should follow its failure, rather than by whether the condition sounds important.
| Condition | Recommended signal | Reason |
|---|---|---|
| Application has not loaded required state | Startup first, then readiness if the state can be lost or reloaded later | Do not admit traffic before initialization; later temporary unavailability should drain traffic without killing the process. |
| Database is briefly unreachable, but reconnect is possible | Readiness, if requests cannot succeed without it; otherwise an alert or metric | Removing traffic is safer than restarting every process for a remote outage. |
| Process is deadlocked and cannot make progress | Liveness | A restart is an intentional recovery action. |
| Optional analytics or telemetry backend is down | Usually neither readiness nor liveness | User-facing service can remain available; expose the condition through observability instead. |
| Instance is deliberately draining before termination | Readiness | Stop new Service traffic while allowing the process to shut down cleanly. |
| Health endpoint itself performs a long remote transaction | Redesign the endpoint | A probe should not become a new dependency chain or a source of load. |
Timing design without guesswork
Start with the application’s measured behavior under expected load, then choose tolerances that reflect the consequence of each signal.
- Startup: budget for the slowest normal initialization path. The illustrative 30-by-10-second configuration permits 300 seconds, but your application may need less or more.
- Readiness: choose how quickly traffic should be withdrawn when the Pod cannot serve, and how many successes are needed before re-entry. A small failure threshold removes a bad backend quickly; a higher success threshold prevents rapid oscillation.
- Liveness: tolerate ordinary scheduler pauses, garbage collection, and peak request latency. A liveness restart is disruptive, so its threshold should represent a genuine stuck process rather than a single slow response.
- Timeout: keep the probe handler much cheaper than a user request and set the timeout above its normal execution time. Raising the timeout cannot fix a handler that blocks on an unavailable dependency.
- Grace period: allow orderly cleanup after a restart while recognizing that a long grace period delays replacement of a truly wedged process.
Do not solve every false positive by increasing every number. First determine whether the endpoint is testing the right condition and whether the probe itself is overloaded.
Debugging a traffic stall step by step
- Check phase and readiness separately. Run
kubectl get pods -n NAMESPACE -o wideand inspect theREADYcolumn. A value such as0/1withRunningindicates a live but unready container. - Read Pod events. Run
kubectl describe pod POD -n NAMESPACE. Look for readiness or liveness failure messages, connection errors, timeouts, HTTP path errors, and the actual port Kubernetes attempted. - Inspect application logs. Use
kubectl logs POD -n NAMESPACE -c CONTAINERand correlate initialization, dependency, and shutdown messages with the probe failures. - Verify the handler from inside the Pod. Use an available HTTP client or a temporary diagnostic container to request the exact readiness and liveness paths on the configured port. Confirm the listener is reachable through the Pod IP and that the response matches the endpoint’s intended semantics.
- Check the manifest’s effective values. Run
kubectl get pod POD -n NAMESPACE -o yamland verify the rendered path, port, handler type, interval, timeout, thresholds, and any startup probe. This catches a template value that differs from the source file. - Inspect Service selection. Run
kubectl get svc SERVICE -n NAMESPACE -o yamlto confirm the selector, then inspectkubectl get endpointslice -n NAMESPACE -l kubernetes.io/service-name=SERVICE -o wide. If no ready addresses appear, determine whether readiness is failing or the selector is wrong. - Test the route independently. A direct Pod request can succeed while the Service has no endpoints, or the Service can have endpoints while an ingress or network policy blocks clients. Separate probe health from later network layers.
- Change one cause at a time. Fix the path or port, dependency semantics, or startup budget before changing thresholds. Record the resulting events and endpoint state so a temporary improvement is not mistaken for a durable fix.
Observability and rollout behavior
Probe failures are operational events, not just configuration details. Monitor readiness transitions, liveness restarts, startup failures, and the number of ready endpoints. A readiness failure that removes too many replicas can make a Deployment rollout appear stalled even though containers remain in the Running phase.
Use events to identify what the kubelet observed, logs to explain why the application returned that result, and EndpointSlice state to confirm whether the Service actually has destinations. These three views answer different questions and should not be substituted for one another.
Graceful draining and termination
When an instance must stop accepting new work, make readiness fail deliberately before termination. This expresses the traffic decision without pretending that the process is dead. The kubelet’s termination grace period then controls how long the container has to close connections and finish cleanup, subject to the Kubernetes version and the field behavior in use.
Do not use liveness to implement routine draining. A liveness failure asks Kubernetes to restart a process; a drain is a traffic-management decision and belongs in readiness.
Kubernetes API-server health names are separate
The Kubernetes API server exposes livez for liveness and readyz for readiness. The older healthz endpoint is deprecated for this purpose. These API-server endpoints are related conceptually but are not the same as an application container’s livenessProbe and readinessProbe fields. Do not infer an application’s Pod readiness from an API-server endpoint, or vice versa.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteA practical design checklist
- Can you state in one sentence what each endpoint proves?
- Does readiness represent the Pod’s ability to serve the specific Service, rather than a generic idea of health?
- Would a liveness failure still be appropriate if every external dependency were temporarily unavailable?
- Does a startup probe cover the slowest normal initialization path?
- Are the handler type, port, path, protocol, and gRPC service name implemented exactly as configured?
- Does the endpoint listen on the Pod IP and return quickly with a minimal response?
- Are timeout, period, and failure thresholds tolerant of normal load but responsive to genuine failure?
- Have you verified both Pod readiness and the Service’s selected EndpointSlices?
- Can events, logs, and endpoint state tell an operator why traffic stopped?
The durable rule is simple: use readiness to decide whether traffic should arrive, liveness to decide whether a restart is warranted, and startup to keep slow initialization from being misclassified as failure. A Pod is not ready merely because it is running, and a dependency outage is not automatically a reason to restart every process that depends on it.
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.
