Liveness check
A liveness check is an automated health test that determines whether a running workload remains functional or should be restarted.
Kubernetes in Action, Second Edition
A liveness probe is a Kubernetes health check that determines whether a container's application is functioning and can trigger container termination after failure.
- How it is used
- Detects applications that stop functioning while their processes continue running, so Kubernetes can terminate unhealthy containers.
- How deep it goes
- Explains three probe mechanisms, manifest settings, failure thresholds, restart observation, and handler design; does not develop a complete application health endpoint.
- Examples
- Uses a two-container HTTP probe manifest, a forced HTTP 503 observed through kubectl events, and a combined startup-and-liveness manifest.
- What you can do after
- Operate/configure it by choosing a probe, setting failure timing, and inspecting events and restart counts after a failure.
Read how Kubernetes in Action, Second Edition explains liveness check →
Kubernetes for Developers
A liveness probe is a Kubernetes health check that determines whether a running container is still functioning and should be allowed to continue running.
- How it is used
- Signals when Kubernetes should restart a running but stuck or unresponsive workload.
- How deep it goes
- Explains probe behavior, HTTP endpoint design, failure tolerance, and a command-based worker check, without exhaustively cataloging probe options.
- Examples
- Uses an HTTP health endpoint, a database-connection scenario, and a worker timestamp checked by a shell command.
- What you can do after
- Operate/configure it with a Deployment livenessProbe and choose an HTTP or command check suited to the workload.
Read how Kubernetes for Developers explains liveness check →
Machine Learning Platform Engineering
A periodic check that determines whether a running workload should be restarted because its process is no longer healthy.
- How it is used
- Protects Kubernetes-hosted inference services by detecting failed processes and enabling pod recovery.
- How deep it goes
- Explains periodic endpoint calls and restart behavior, but does not provide probe configuration details.
- Examples
- Uses /healthz for liveness, /readyz for readiness, and BentoML’s built-in endpoints as concrete operational examples.
- What you can do after
- Operate/configure Kubernetes pod management around service liveness and distinguish restart checks from traffic-readiness checks.
Read how Machine Learning Platform Engineering explains liveness check →
Learn Docker in a Month of Lunches, Second Edition
A liveness probe is a Kubernetes container probe that determines whether a container should be restarted.
- How it is used
- Uses a container health endpoint to trigger restarts when an application instance repeatedly fails.
- How deep it goes
- Defines HTTP checking, intervals, and restart effects without detailing failure thresholds or probe internals.
- Examples
- Uses an HTTP GET request to /healthz every 20 seconds in a numbers-api Deployment.
- What you can do after
- Operate/configure Kubernetes Deployments with an HTTP liveness probe and verify Pod restarts using kubectl.
Read how Learn Docker in a Month of Lunches, Second Edition explains liveness check →
Quarkus in Action
A Kubernetes liveness probe periodically determines whether a container should be restarted because its application is no longer recoverable.
- How it is used
- Uses an HTTP health endpoint as the target for Kubernetes liveness probes, enabling restarts when an application cannot recover.
- How deep it goes
- Defines failure meaning and Kubernetes response, but does not detail probe timing configuration or custom liveness implementation.
- Examples
- Uses /q/health/live, the SmallRye Health extension, Dev UI, and aggregate JSON health output as concrete artifacts.
- What you can do after
- Operate health monitoring by adding SmallRye Health and querying aggregate or liveness-specific HTTP endpoints.
Spring in Action, Sixth Edition
A liveness probe is a health indicator that tells an orchestrator whether an application is healthy enough to continue running without being restarted.
- How it is used
- Uses Actuator health groups to let Kubernetes decide whether to keep an application running or replace its pod.
- How deep it goes
- Defines liveness, contrasts readiness, and shows Spring Boot and Kubernetes configuration without detailing probe implementation internals.
- Examples
- Shows application.yml probe enablement, Kubernetes HTTP probes, and programmatic LivenessState availability events.
- What you can do after
- Operate/configure Spring Boot and Kubernetes liveness probes for restart decisions and distinguish them from traffic readiness.
Read how Spring in Action, Sixth Edition explains liveness check →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A liveness probe is a Kubernetes health-check configuration that determines whether a container or pod is still functioning and should continue running.
- How it is used
- Uses Kubernetes health checks to detect stuck microservices and trigger automated restarts.
- How deep it goes
- Explains probe roles and shows HTTP Deployment configuration, without detailing endpoint implementation.
- Examples
- Uses a gateway Deployment with /alive and /ready HTTP endpoints and a history service depending on RabbitMQ.
- What you can do after
- Configure Kubernetes Deployments with HTTP liveness probes that support automatic recovery from unhealthy services.
Related concepts
- health checkkind of · A health check is an assessment or probe that determines whether a system, service, or component is functioning acceptably according to defined criteria.
- Kubernetesused by · Kubernetes is an open-source platform for orchestrating and automating the deployment, scaling, and management of containerized workloads across computing clusters.
- readiness checkcontrasts with · A readiness check is a health probe that determines whether a running service or workload is prepared to receive requests or traffic.
- exec probeincludes · An exec probe is a Kubernetes probe that runs a command inside a container and evaluates whether it exits successfully.
- health check endpointuses · A health check endpoint is an API endpoint that reports whether an application or service is operating correctly or ready to handle requests.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.