Health checks in Compose in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Health check status output in Docker Compose

Given this Docker Compose service with a health check, what will be the output of docker-compose ps after the container starts and the health check passes?

Docker

services:
  web:
    image: nginx
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 10s
      timeout: 5s
      retries: 3

A web docker-entrypoint.sh nginx - Up (unhealthy)

B web docker-entrypoint.sh nginx - Up (healthy)

C web docker-entrypoint.sh nginx - Up (starting)

D web docker-entrypoint.sh nginx - Exited (0)

💡 Hint

Think about what the health check does and how Docker reports container health.

The health check runs curl to check if the web server responds. If it succeeds, Docker marks the container as healthy, so the status shows 'Up (healthy)'.

🧠 Conceptual

intermediate

Purpose of health checks in Docker Compose

What is the main purpose of defining a health check in a Docker Compose service?

A To expose the container's ports to the host

B To automatically restart the container if it crashes

C To limit the container's CPU and memory usage

D To monitor if the container's application is working correctly

💡 Hint

Think about what health means for a running service.

Health checks let Docker know if the app inside the container is running properly, beyond just the container being up.

❓ Configuration

advanced

Correct health check syntax in Docker Compose

Which of these Docker Compose health check configurations is syntactically correct and will run a command every 30 seconds with a 10-second timeout?

A

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"]
  interval: 30s
  timeout: 10s

B

healthcheck:
  test: curl -f http://localhost
  interval: 30s
  timeout: 10s

C

healthcheck:
  test: curl -f http://localhost
  interval: 30
  timeout: 10

D

healthcheck:
  test: ["curl", "-f", "http://localhost"]
  interval: 30s
  timeout: 10s

💡 Hint

The test command must be an array starting with CMD for Compose health checks.

Option A uses the correct array syntax with CMD and valid interval and timeout units. Others have syntax errors or missing CMD.

❓ Troubleshoot

advanced

Diagnosing failing health checks in Compose

You have a health check in Compose that always reports 'unhealthy'. Which command helps you see the detailed health check logs for the container?

A docker-compose logs --follow

B docker-compose ps

C docker inspect --format='{{json .State.Health}}' <container_id>

D docker stats <container_id>

💡 Hint

You want to see the health check results stored in container state.

The docker inspect command with .State.Health shows health check logs and status details.

🔀 Workflow

expert

Using health checks to control service startup order

In Docker Compose, how can you ensure that a service app starts only after the db service is healthy?

A Use <code>depends_on:</code> with <code>condition: service_healthy</code> for <code>app</code> on <code>db</code>

B Use <code>depends_on:</code> with <code>condition: service_started</code> for <code>app</code> on <code>db</code>

C Start <code>db</code> manually before <code>app</code> using separate commands

D Set <code>restart: always</code> on <code>app</code> service

💡 Hint

Compose supports waiting for health status in depends_on since version 3.4.

Using depends_on with condition: service_healthy makes Compose wait for the db service to be healthy before starting app.

Practice

1. What is the main purpose of a health check in a Docker Compose service?

easy

A. To restart the container automatically

B. To verify if the container's application is running correctly

C. To build the container image

D. To expose ports to the host machine

Solution

1. Step 1: Understand health check purpose

   Health checks run commands inside the container to confirm the app is working well.

2. Step 2: Differentiate from other Docker tasks

   Restarting, building, and exposing ports are separate Docker tasks, not health checks.

3. Final Answer:

   To verify if the container's application is running correctly -> Option B

4. Quick Check:

   Health check = verify app status [OK]

Hint: Health checks confirm app health inside containers [OK]

Common Mistakes:

• Confusing health checks with container restart policies
• Thinking health checks build images
• Mixing health checks with port mapping

2. Which of the following is the correct syntax to add a health check in a Docker Compose service?

easy

A. healthcheck: { run: "curl http://localhost" }

B. health_check: { command: "curl http://localhost" }

C. healthcheck: { test: ["CMD", "curl", "-f", "http://localhost"] }

D. healthcheck: { check: "curl http://localhost" }

Solution

1. Step 1: Recall Docker Compose healthcheck syntax

   The correct key is 'healthcheck' with a 'test' array specifying the command.

2. Step 2: Validate command format

   The 'test' must be an array starting with 'CMD' followed by the command and arguments.

3. Final Answer:

   healthcheck: { test: ["CMD", "curl", "-f", "http://localhost"] } -> Option C

4. Quick Check:

   Use 'healthcheck' with 'test' array [OK]

Hint: Use 'healthcheck' and 'test' array with CMD for commands [OK]

Common Mistakes:

• Using wrong keys like 'health_check' or 'run'
• Passing command as a string instead of array
• Omitting 'CMD' in the test array

3. Given this Compose snippet, what will be the health status if the curl command fails?

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"]
  interval: 10s
  retries: 3

medium

A. The container will be marked as unhealthy after 3 failed attempts

B. The container will restart automatically after the first failure

C. The container will ignore the failure and stay healthy

D. The container will stop immediately on failure

Solution

1. Step 1: Understand retries and failure effect

   The health check runs every 10 seconds and allows 3 retries before marking unhealthy.

2. Step 2: Identify container behavior on failure

   Failing the test 3 times marks the container unhealthy; it does not restart or stop automatically.

3. Final Answer:

   The container will be marked as unhealthy after 3 failed attempts -> Option A

4. Quick Check:

   Retries control unhealthy marking, not restart [OK]

Hint: Retries count failures before unhealthy status [OK]

Common Mistakes:

• Assuming container restarts on health check failure
• Thinking container stops immediately on failure
• Ignoring the retries setting

4. You added this health check to your Compose file but it never reports healthy:

healthcheck:
  test: curl -f http://localhost || exit 1
  interval: 5s
  retries: 2

What is the problem?

medium

A. The test command must be an array starting with CMD

B. The interval value must be in milliseconds

C. Retries cannot be less than 3

D. The healthcheck key should be under volumes

Solution

1. Step 1: Check healthcheck test syntax

   Docker Compose requires the test command as an array starting with 'CMD' or 'CMD-SHELL'.

2. Step 2: Identify why string command fails

   Using a plain string without array causes Compose to ignore or fail the health check.

3. Final Answer:

   The test command must be an array starting with CMD -> Option A

4. Quick Check:

   Use array with CMD for test command [OK]

Hint: Healthcheck test must be array with CMD or CMD-SHELL [OK]

Common Mistakes:

• Writing test as plain string instead of array
• Misplacing healthcheck under wrong keys
• Using invalid interval units

5. You want a service in Docker Compose to be considered healthy only if a custom script check.sh inside the container returns success within 5 seconds. Which Compose healthcheck configuration is best?

hard

A. healthcheck:
test: ["CMD-SHELL", "./check.sh"]
interval: 10s
retries: 3

B. healthcheck:
test: ["CMD-SHELL", "timeout 5s ./check.sh"]
interval: 10s
retries: 3

C. healthcheck:
test: ["CMD", "./check.sh"]
interval: 5s
retries: 1

D. healthcheck:
test: ["CMD", "./check.sh"]
timeout: 5s
interval: 10s
retries: 3

Solution

1. Step 1: Understand timeout usage in healthcheck

   The 'timeout' key sets max time for the test command to run; here 5 seconds is needed.

2. Step 2: Choose correct test format and timing

   Using 'CMD' with './check.sh' is valid; 'timeout' controls max duration; interval and retries set frequency and tolerance.

3. Final Answer:

   healthcheck: test: ["CMD", "./check.sh"] timeout: 5s interval: 10s retries: 3 -> Option D

4. Quick Check:

   Use 'timeout' key to limit test duration [OK]

Hint: Use 'timeout' key to limit healthcheck command time [OK]

Common Mistakes:

• Using shell timeout inside test instead of 'timeout' key
• Confusing interval and timeout values
• Omitting retries leading to quick unhealthy status