Pfthb

Natively that is not possible, yet. See also this feature request.

So far you need to do that in your containers CMD to wait until all required services are there.

In the Dockerfiles CMD you could refer to your own start script that wraps starting up your container service. Before you start it, you wait for a depending one like:

Dockerfile

FROM python:2-onbuild
RUN ["pip", "install", "pika"]
ADD start.sh /start.sh
CMD ["/start.sh"]

start.sh

#!/bin/bash
while ! nc -z rabbitmq 5672; do sleep 3; done
python rabbit.py

Probably you need to install netcat in your Dockerfile as well. I do not know what is pre-installed on the python image.

There are a few tools out there that provide easy to use waiting logic, for simple tcp port checks:

• 
  wait-for-it


• dockerize

For more complex waits:

• 
  goss - Explanation blog
  

Using restart: unless-stopped or restart: always may solve this problem.

If worker container stops when rabbitMQ is not ready, it will be restarted until it is.

Quite recently they've added the depends_on feature.

Edit:

As of compose version 2.1+ you can use depends_on in conjunction with healthcheck to achieve this:

From the docs:

version: '2.1'
services:
 web:
 build: .
 depends_on:
 db:
 condition: service_healthy
 redis:
 condition: service_started
 redis:
 image: redis
 db:
 image: redis
 healthcheck:
 test: "exit 0"

Before version 2.1

You can still use depends_on, but it only effects the order in which services are started - not if they are ready before the dependant service is started.

It seems to require at least version 1.6.0.

Usage would look something like this:

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

From the docs:

Express dependency between services, which has two effects:

• docker-compose up will start services in dependency order. In the following example, db and redis will be started before web.


• docker-compose up SERVICE will automatically include SERVICE’s dependencies. In the following example, docker-compose up web will also create and start db and redis.

Note: As I understand it, although this does set the order in which containers are loaded. It does not guarantee that the service inside the container has actually loaded.

For example, you postgres container might be up. But the postgres service itself might still be initializing within the container.

you can also just add it to the command option eg.

command: bash -c "sleep 5; start.sh"

https://github.com/docker/compose/issues/374#issuecomment-156546513

to wait on a port you can also use something like this

command: bash -c "while ! curl -s rabbitmq:5672 > /dev/null; do echo waiting for xxx; sleep 3; done; start.sh"

to increment the waiting time you can hack a bit more:

command: bash -c "for i in 1..100 ; do if ! curl -s rabbitmq:5672 > /dev/null ; then echo waiting on rabbitmq for $i seconds; sleep $i; fi; done; start.sh"

You can also solve this by setting an endpoint which waits for the service to be up by using netcat (using the docker-wait script). I like this approach as you still have a clean command section in your docker-compose.yml and you don't need to add docker specific code to your application:

version: '2'
services:
 db:
 image: postgres
 django:
 build: .
 command: python manage.py runserver 0.0.0.0:8000
 entrypoint: ./docker-entrypoint.sh db 5432
 volumes:
 - .:/code
 ports:
 - "8000:8000"
 depends_on:
 - db

Then your docker-entrypoint.sh:

#!/bin/sh

postgres_host=$1
postgres_port=$2
shift 2
cmd="$@"

# wait for the postgres docker to be running
while ! nc $postgres_host $postgres_port; do
 >&2 echo "Postgres is unavailable - sleeping"
 sleep 1
done

>&2 echo "Postgres is up - executing command"

# run the command
exec $cmd

This is nowadays documented in the official docker documentation.

PS: You should install netcat in your docker instance if this is not available. To do so add this to your Docker file :

RUN apt-get update && apt-get install netcat-openbsd -y 

For container start ordering use

depends_on:

For waiting previous container start use script

entrypoint: ./wait-for-it.sh db:5432

This article will help you
https://docs.docker.com/compose/startup-order/

restart: on-failure
did the trick for me..see below

---
version: '2.1'
services:
 consumer:
 image: golang:alpine
 volumes:
 - ./:/go/src/srv-consumer
 working_dir: /go/src/srv-consumer
 environment:
 AMQP_DSN: "amqp://guest:guest@rabbitmq:5672"
 command: go run cmd/main.go
 links:
 - rabbitmq
 restart: on-failure

 rabbitmq:
 image: rabbitmq:3.7-management-alpine
 ports:
 - "15672:15672"
 - "5672:5672"

There is a ready to use utility called "docker-wait" that can be used for waiting.

basing on this blog post https://8thlight.com/blog/dariusz-pasciak/2016/10/17/docker-compose-wait-for-dependencies.html

I configured my docker-compose.yml as shown below:

version: "3.1"

services:
 rabbitmq:
 image: rabbitmq:3.7.2-management-alpine
 restart: always
 environment:
 RABBITMQ_HIPE_COMPILE: 1
 RABBITMQ_MANAGEMENT: 1
 RABBITMQ_VM_MEMORY_HIGH_WATERMARK: 0.2
 RABBITMQ_DEFAULT_USER: "rabbitmq"
 RABBITMQ_DEFAULT_PASS: "rabbitmq"
 ports:
 - "15672:15672"
 - "5672:5672"
 volumes:
 - data:/var/lib/rabbitmq:rw

 start_dependencies:
 image: alpine:latest
 links:
 - rabbitmq
 command: >
 /bin/sh -c "
 echo Waiting for rabbitmq service start...;
 while ! nc -z rabbitmq 5672;
 do
 sleep 1;
 done;
 echo Connected!;
 "

volumes:
 data: 

Then I do for run =>:

docker-compose up start_dependencies

rabbitmq service will start in daemon mode, start_dependencies will finish the work.

One of the alternative solution is to use a container orchestration solution like Kubernetes. Kubernetes has support for init containers which run to completion before other containers can start. You can find an example here with SQL Server 2017 Linux container where API container uses init container to initialise a database

https://www.handsonarchitect.com/2018/08/understand-kubernetes-object-init.html

I couldn't use this approach, I actually can't use volume in docker-compose, in both cases I didn't work:

s-flyway_1_d7a78571d25c | env: can't execute 'bash': No such file or
directory docker_s-flyway_1_d7a78571d25c exited with code 127

What am I missing here ? I'm a little lost about it right now.....

Project link:
https://github.com/jbrasileiro/introducing-example/blob/master/introducing-example-docker-flyway/src/docker/docker-compose.yml

Dockerfile

FROM dhoer/flyway:alpine
COPY ./sql/*.sql /flyway/sql
VOLUME ./wait-for-it.sh:/usr/local/bin/wait-for-it.sh
ADD ./wait-for-it.sh /
RUN chmod 777 /wait-for-it.sh 

docker version : '3'

version: '3'
services:
 hello-world:
 image: ubuntu
 volumes:
 - ./wait-for-it.sh:/usr/local/bin/wait-for-it.sh
 command:
 - wait-for-it.sh
 - github.com:80
 - --
 - echo
 - "hello world"

docker version : '2'

version: '2'
services:
 s-postgres:
 image: postgres:9.4-alpine
 hostname: host-postgres
 environment:
 - POSTGRES_USER=postgres
 - POSTGRES_PASSWORD=postgres
 - POSTGRES_DB=postgres
 networks:
 - network-docker
 s-flyway:
 image: dhoer/flyway:alpine
 build: flyway/
 entrypoint: /wait-for-it.sh s-postgres 5432 --timeout=0 --strict
 command: -url=jdbc:postgresql://s-postgres:5432/postgres -baselineOnMigrate=true -schemas=public -user=postgres -password=postgres migrate
 networks:
 - network-docker
 depends_on:
 - s-postgres
networks:
 network-docker:
 driver: bridge