Health check
A health check is an assessment of whether a system, service, or component is functioning acceptably and is available or ready for its intended work.
Learn Docker in a Month of Lunches, Second Edition
A health check is an automated test that determines whether an application is functioning correctly rather than merely having a running process.
- How it is used
- Makes application failures visible when a container’s main process is still running.
- How deep it goes
- Works through Dockerfile checks, container inspection, custom utilities, and Compose timing settings; defers production replacement to a container platform.
- Examples
- Uses an API that returns HTTP 500 after three requests and an exercise checking a Node.js app’s simulated memory use.
- What you can do after
- Operate/configure it in Docker images and Compose, then inspect whether a running application has become unhealthy.
Read how Learn Docker in a Month of Lunches, Second Edition explains health check →
Quarkus in Action
A health check is an evaluation that reports whether an application or one of its dependencies is functioning correctly, typically with a binary outcome.
- How it is used
- Reports application or dependency health for manual monitoring and Kubernetes probes.
- How deep it goes
- Works through an automatic JDBC readiness check and a custom wellness implementation, without detailing Kubernetes probe configuration.
- Examples
- Uses an Inventory service’s MySQL connection failure and an inventory-count wellness check.
- What you can do after
- Apply it via Quarkus SmallRye Health to inspect automatic checks and implement a custom wellness check.
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
A health check is an automated test that determines whether a website or backend target is able to receive traffic and provide an expected response.
- How it is used
- Keeps load-balancer traffic on healthy targets and detects website outages through an external scheduled check.
- How deep it goes
- Walks through console-based scheduling and gives concrete target-group settings, but does not detail health-check algorithms.
- Examples
- Uses a website GET request with expected text and a target-group check of `/index.html` accepting HTTP 200–299.
- What you can do after
- Operate/configure it with a Lambda blueprint and scheduled rule, or with Application Load Balancer target-group settings.
Acing the Frontend Interview
A health check is an automated test of whether a node, process, service, or dependency is operational and responsive.
- How it is used
- Uses automated probes to detect failures, control traffic eligibility, restart instances, and reduce downtime.
- How deep it goes
- Explains operational consequences and named implementations, but stops short of probe configuration details or failure-threshold design.
- Examples
- Uses load balancers, Kubernetes readiness and liveness probes, AWS or GCP instance pings, Consul, Eureka, and Istio.
- What you can do after
- Operate/configure systems that reroute traffic or restart instances when health checks identify unresponsive components.
Read how Acing the Frontend Interview explains health check →
Build and Orchestrator in Go (From Scratch)
A health check is an operation that evaluates whether a running task is functioning normally, typically by calling an endpoint and interpreting its response.
- How it is used
- Drives automatic task recovery by polling task endpoints and restarting unhealthy or failed tasks.
- How deep it goes
- Works through task fields, URL construction, Docker port lookup, polling, state updates, and bounded restart logic.
- Examples
- Demonstrates an echo service whose /health returns 200 and /healthfail returns 500, then observes restarts.
- What you can do after
- Operate/configure it by declaring a task endpoint and using health-check results to trigger bounded restarts.
Read how Build and Orchestrator in Go (From Scratch) explains health check →
Machine Learning Platform Engineering
A diagnostic test that determines whether a service or execution unit is functioning and able to handle requests.
- How it is used
- Supports Kubernetes monitoring, pod management, traffic gating, and troubleshooting for deployed model services.
- How deep it goes
- Defines health, liveness, and readiness roles with endpoint behavior, but does not detail custom implementation code.
- Examples
- Uses /healthz and /readyz endpoints, pod initialization failures, BentoML services, and Kubernetes probe behavior.
- What you can do after
- Operate/configure deployed services with liveness and readiness monitoring in Kubernetes environments.
Read how Machine Learning Platform Engineering explains health check →
Build Financial Software with Generative AI (From Scratch)
A health check is an automated test or status evaluation that determines whether an application or runtime component is functioning acceptably.
- How it is used
- Uses health checks to monitor application and container status in a multi-container system.
- How deep it goes
- Explains health states and walks through configuring and verifying a PostgreSQL container check, while briefly distinguishing readiness from liveness.
- Examples
- Uses a health_check database table, an application status endpoint, and a PostgreSQL pg_isready check.
- What you can do after
- Operate/configure a PostgreSQL container health check and inspect its status with docker ps.
Read how Build Financial Software with Generative AI (From Scratch) explains health check →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A health check is an automated assessment of whether a running service or workload is functioning and available according to defined criteria.
- How it is used
- Uses automated checks to monitor microservice availability and trigger protective action in production.
- How deep it goes
- Defines readiness and liveness probes and shows their Kubernetes configuration, but does not detail probe implementation logic.
- Examples
- Uses gateway HTTP endpoints, Kubernetes Deployment YAML, RabbitMQ startup, and Kubernetes pod restarts as concrete examples.
- What you can do after
- Operate/configure Kubernetes probes that delay traffic until readiness and restart workloads that fail liveness checks.
Designing AI Systems
A health check is an automated test that determines whether a running service instance is functioning and able to receive work.
- How it is used
- Coordinates container startup, shutdown, restart, and traffic routing through liveness and readiness signals.
- How deep it goes
- Distinguishes endpoint behavior and lifecycle effects, but stops short of implementation code or dependency-specific checks.
- Examples
- Uses HTTP 200 and 503 responses, startup initialization, dependency connection, request draining, and rolling replica replacement.
- What you can do after
- Operate/configure service lifecycle behavior by separating restart signals from traffic-readiness signals.
Kubernetes for Developers
A health check is an operational test or signal indicating whether an application or process is functioning correctly.
- How it is used
- Uses application health signals to keep deployments available and route traffic only to ready replicas.
- How deep it goes
- Explains liveness, readiness, failure conditions, and HTTP, TCP, and Bash implementations, stopping short of exhaustive configuration guidance.
- Examples
- Demonstrates /healthz over HTTP, TCP connectivity on port 25, and Bash tests for background tasks.
- What you can do after
- Operate/configure Kubernetes probes that restart unhealthy containers and protect traffic during application updates.
Building Distributed Applications that Work
A health check is an automated assessment of whether an application or dependency is ready and functioning sufficiently for interaction.
- How it is used
- Uses endpoint responses to let Aspire assess whether services are ready to interact with other systems.
- How deep it goes
- Implements a self-check and maps basic and live-tag endpoints, while leaving production protections scenario-specific.
- Examples
- Uses a self-check tagged live and /health and /alive endpoints, with /alive filtering checks by tag.
- What you can do after
- Configure health-check registrations and HTTP endpoints for Aspire-hosted applications.
Read how Building Distributed Applications that Work explains health check →
Also covered in
- Shipping Go: Develop, deliver, discuss, design, and go again
- Road to Kubernetes
- Go by Example
- gRPC Microservices in Go
- Build Applications with Local AI Models on a Mac
What to know first
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- HTTP requestAn HTTP request is a message sent by a client to a server using the Hypertext Transfer Protocol, specifying a method and target and optionally including headers and a body.
- serverA server is a computer system or software process that provides data, resources, or services to other systems, typically by responding to requests.
- HTTPHTTP is an application-layer protocol that defines request-and-response communication for transferring resource representations and related metadata between networked systems.
Related concepts
- liveness checkincludes · A liveness check is an automated health test that determines whether a running workload remains functional or should be restarted.
- readiness checkincludes · A readiness check is a health probe that determines whether a running service or workload is prepared to receive requests or traffic.
- auto-scaling groupused by · An auto-scaling group is a managed collection of compute instances whose capacity is automatically adjusted according to configured policies, conditions, or workload demand.
- Cloud Run serviceused by · A Cloud Run service is a managed container workload that receives network requests and serves traffic through a public endpoint.
- Dockeruses · Docker is a platform and toolset for building, distributing, and running applications in containers.
Questions about health check
What is health check?
A health check is an assessment of whether a system, service, or component is functioning acceptably and is available or ready for its intended work.
Which Manning books explain health check?
Learn Docker in a Month of Lunches, Second Edition, Quarkus in Action, Amazon Web Services in Action, Third Edition: An in-depth guide to AWS, Acing the Frontend Interview, Build and Orchestrator in Go (From Scratch), Machine Learning Platform Engineering, Build Financial Software with Generative AI (From Scratch), Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform and 3 more.
What should I know before learning health check?
Manning books that teach health check usually introduce container, HTTP request, server and HTTP first.
What kinds of health check are there?
Kinds of health check include liveness check and readiness check.
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.










