Docker health checks எவ்வாறு செயல்படுகின்றன மற்றும் அவை ஏன் முக்கியமானவை?

Question

Accepted Answer

ஒரு **health check** Docker (அல்லது ஒரு orchestrator) க்கு கொண்டெய்னரின் application உண்மையில் **செயல்படுகிறதா** என்பதை தீர்மானிக்க வழிவகை செய்கிறது, வெறும் இயங்கி கொண்டிருப்பது மட்டுமல்ல. ஒரு கொண்டெய்னரின் process இயக்கத்தில் இருக்கும் போது app உடைந்திருக்கலாம் (தொங்கிவிட்டது, அதன் database ஐ அடைய முடியாது) — health checks இதை கண்டறிந்து platform எதிர்வினை தெரிவிக்க முடிகிறது.

## Health check வரையறுப்பு

```dockerfile
# in a Dockerfile
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1
# → Docker runs this command periodically; exit 0 = healthy, non-zero = unhealthy
```

```yaml
# in docker-compose.yml
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
  interval: 30s
  timeout: 3s
  retries: 3
  start_period: 10s    # grace period on startup before failures count
```

Docker அவ்வப்போது health-check command ஐ இயக்குகிறது; கொண்டெய்னரின் status `healthy` அல்லது `unhealthy` என்று மாறுகிறது (result ன் அடிப்படையில், `docker ps` இல் தெரிகிறது).

## இயங்குவது vs healthy (முக்கிய வேறுபாடு)

```text
RUNNING → the container's process is alive (but the APP might be hung/broken)
HEALTHY → the health check confirms the app actually WORKS (responds correctly)
→ A container can be RUNNING but NOT HEALTHY (e.g. the app deadlocked, lost its DB).
  Without a health check, the platform only knows "running" — and keeps sending traffic
  to a broken container.
```

## Health checks ஏன் செயல்பாட்டளவில் முக்கியமானவை

```text
✓ ORCHESTRATORS use them: restart unhealthy containers; route traffic only to healthy ones
✓ Compose depends_on: condition: service_healthy → wait for real readiness
✓ LIVENESS (is it alive? restart if not) vs READINESS (ready for traffic? hold traffic if not)
  → Kubernetes uses liveness + readiness probes (the same concept, more granular)
✓ Prevents serving requests from broken-but-running containers
```

## ஏன் இது முக்கியமானது

Docker health checks ஐ புரிந்துகொள்வது **நம்பகமான containerized applications இயக்குவதற்கு** முக்கியமாகும், எனவே இது மதிப்புள்ள செயல்பாட்டு அறிவாகும்।

முக்கியமான insight என்பது **இயங்குவது மற்றும் healthy க்கு இடையிலான வேறுபாடு**: ஒரு கொண்டெய்னரின் process **உயிருடன் இருக்கும் போது application உண்மையில் உடைந்திருக்கலாம்** (தொங்கிவிட்டது, deadlocked, அதன் database ஐ அடைய முடியாது) — மற்றும் health check இல்லாமல், platform கொண்டெய்னர்