Waiting for Dependencies with Docker Compose

Docker Compose provides a powerful way to manage multiple containers and services. However, when working with dependent services, it’s essential to ensure that each service is fully started before moving on to the next one. In this tutorial, we’ll explore how to wait for dependencies using Docker Compose.

Understanding the Problem

When you have multiple services that depend on each other, starting them in the correct order can be challenging. For example, if your web application depends on a database service, you need to ensure that the database is fully started before launching the web application.

Using depends_on with Docker Compose

The depends_on directive allows you to specify the dependencies between services. However, this only guarantees the order in which the containers are started, not whether the services within those containers are ready.

To demonstrate this, let’s consider a simple example using two services: web and db. The web service depends on the db service.

version: '2'
services:
  web:
    build: .
    depends_on:
      - db
  db:
    image: postgres

In this case, Docker Compose will start the db container before starting the web container. However, it does not guarantee that the PostgreSQL service within the db container is fully started.

Using Health Checks with Docker Compose

To ensure that a service is fully started, you can use health checks. A health check is a command that checks whether a service is healthy or not.

Let’s modify our previous example to include a health check for the db service.

version: '2.1'
services:
  web:
    build: .
    depends_on:
      db:
        condition: service_healthy
  db:
    image: postgres
    healthcheck:
      test: ["CMD", "pg_isready"]
      interval: 10s
      timeout: 5s
      retries: 3

In this example, the healthcheck directive specifies a command that checks whether the PostgreSQL service is ready. The depends_on directive now uses the condition: service_healthy parameter to wait for the db service to be healthy before starting the web service.

Using restart Policy with Docker Compose

Another approach is to use the restart policy to restart containers that fail due to dependencies not being ready. For example:

version: '3'
services:
  web:
    build: .
    depends_on:
      - db
    restart: on-failure
  db:
    image: postgres

In this case, if the web container fails because the db service is not ready, it will be restarted until it succeeds.

Best Practices

When working with dependencies and Docker Compose, keep the following best practices in mind:

• Use health checks to ensure that services are fully started before moving on to dependent services.
• Use depends_on with caution, as it only guarantees the order in which containers are started, not whether services within those containers are ready.
• Consider using restart policies to handle failures due to dependencies not being ready.

By following these best practices and using Docker Compose’s built-in features, you can ensure that your dependent services start correctly and minimize downtime due to dependency issues.