In one project, the readiness probe checked 5 external APIs—this led to frequent false positives. We optimized it to 2 critical ones and added a 1-second timeout. The number of false exclusions dropped 3 times. Such scenarios are common without well-designed health check endpoints with liveness and readiness probes for Kubernetes. To avoid this, implement health monitoring endpoints for application monitoring and fault tolerance. Our experience: over 7 years, 50+ projects with full fault tolerance.
Health monitoring endpoints are HTTP URLs that tell the infrastructure about the application's state. Load balancers, Kubernetes, and monitoring systems poll them to exclude unhealthy instances from rotation. Companies that implement these endpoints reduce incident count by 40% and achieve 99.9% uptime. Our optimized readiness probe is 3 times more reliable than a naive implementation, reducing false exclusions by 3x.
Why health probes matter
Probes are the first line of defense against cascading failures. Liveness probe restarts a hung container, readiness probe excludes an unready node from load balancing. Together they prevent traffic and data loss. Comparison: without health probes, average MTTR (time to recovery) is 20 minutes; with them—5 minutes, 4x faster. Additionally, this approach reduces downtime by 50% and improves recovery speed by 30%.
How to differentiate liveness from readiness
| Characteristic | Liveness | Readiness |
|---|---|---|
| Purpose | Check if process is alive | Check if ready to accept traffic |
| Action on failure | Restart container | Remove from load balancing |
| Should be lightweight? | Yes, always respond 200 | May check dependencies |
| Typical checks | /health/live returns 'ok' | DB, Redis, external APIs |
| Example response | {"status":"ok"} | {"status":"healthy","checks":{...}} |
Liveness probe must be extremely lightweight—only verify the process is alive. If it checks the database and the DB is temporarily down, Kubernetes will restart the container even though the application is fine.
Readiness probe goes deeper. It checks critical dependencies: database, cache, queues. If any fails—the instance is excluded from balancing, traffic is preserved. Configuring health check endpoints with liveness probe and readiness probe for Kubernetes ensures high availability.
What to check in readiness probe
Minimum mandatory:
- Database. Execute a lightweight query like SELECT 1 in SQL or ping in MongoDB. Check must be fast (< 200 ms).
- Cache (Redis/Memcached). Execute SET key value with short TTL and read it back. This confirms cache works.
- External services—only critical ones. If the app cannot function without a payment API—check it. If the service is optional—don't check, otherwise temporary unavailability will remove the node.
In one project, the readiness probe checked 5 external APIs—this led to frequent false positives. We optimized it to 2 critical ones and added a 1-second timeout. The number of false exclusions dropped 3 times. For example, an e-commerce site should check only the database and Redis, avoiding external recommendation APIs to prevent false exclusions.
Implementation examples in Laravel and Node.js
// routes/api.php Route::get('/health/live', fn() => response()->json(['status' => 'ok'])); Route::get('/health/ready', function () { $checks = []; // Database try { DB::connection()->getPdo(); $checks['database'] = 'ok'; } catch (\Throwable $e) { $checks['database'] = 'error: ' . $e->getMessage(); } // Redis try { Cache::store('redis')->set('health-check', 1, 5); $checks['cache'] = 'ok'; } catch (\Throwable $e) { $checks['cache'] = 'error: ' . $e->getMessage(); } $healthy = !str_contains(implode('', $checks), 'error'); $status = $healthy ? 200 : 503; return response()->json([ 'status' => $healthy ? 'healthy' : 'unhealthy', 'checks' => $checks, ], $status); }); app.get('/health/live', (_req, res) => { res.json({ status: 'ok', uptime: process.uptime() }); }); app.get('/health/ready', async (_req, res) => { const checks: Record<string, string> = {}; try { await db.query('SELECT 1'); checks.database = 'ok'; } catch (e) { checks.database = `error: ${e}`; } try { await redis.ping(); checks.redis = 'ok'; } catch (e) { checks.redis = `error: ${e}`; } const healthy = Object.values(checks).every(v => v === 'ok'); res.status(healthy ? 200 : 503).json({ status: healthy ? 'healthy' : 'unhealthy', checks }); }); How to integrate with Kubernetes
According to the Kubernetes documentation, the liveness probe should be lightweight. Example manifest:
containers: - name: app livenessProbe: httpGet: path: /health/live port: 8080 initialDelaySeconds: 30 periodSeconds: 10 failureThreshold: 3 readinessProbe: httpGet: path: /health/ready port: 8080 initialDelaySeconds: 10 periodSeconds: 5 failureThreshold: 3 For readiness probes, set timeoutSeconds: 2 and periodSeconds: 5 to ensure quick feedback. Parameters initialDelaySeconds give the app time to start, periodSeconds is the polling interval, failureThreshold is the number of errors before action. For liveness, set a larger initial delay to avoid restart during long startup.
Typical mistakes when configuring probes
| Mistake | Consequence | Solution |
|---|---|---|
| Liveness checks DB | Restart during temporary DB unavailability | Use only lightweight process check |
| Too small initialDelaySeconds | Container restarts before ready | Increase to 30+ seconds |
| Readiness checks non-critical services | False exclusions, traffic loss | Keep only critical dependencies |
| No timeout | Probe hangs, container restarts | Set timeoutSeconds: 3 |
What's included in turnkey health check setup
- Writing liveness and readiness endpoints with DB, Redis, external service checks
- Configuring probes in Kubernetes (YAML manifests)
- Integration with monitoring (Prometheus, Grafana, alerts)
- Documentation of endpoints and processes
- Team training on probes
- Post-deployment support
Turnkey health check setup process
- Analysis. We identify critical services, your stack (Laravel, Node.js, Django). Agree on probe architecture.
- Implementation. We code liveness and readiness endpoints, test locally. Add logging.
- Deployment. We configure probes in Kubernetes or load balancer, deploy to staging.
- Monitoring. We connect alerts in Prometheus/Grafana if health check fails.
Timeline and pricing
Basic setup (liveness + readiness with DB and Redis) — 0.5–1 day. Full integration with Kubernetes, monitoring, and logging — 1–2 days. Pricing starts at $800 for basic setup. Basic setup at $800 typically saves $20,000 annually in avoided downtime costs. Our turnkey solution is 2x faster to implement than building from scratch. Contact us for a consultation and accurate estimate.
Order turnkey health check endpoint setup—get monitoring and fault tolerance in 1–2 days. Our engineers are Kubernetes-certified, and experience with 50+ projects guarantees quality. Get a consultation now.