Check is container/service running with docker-compose

• docker-compose ps -q <service_name> will display the container ID no matter it's running or not, as long as it was created.
• docker ps shows only those that are actually running.

Let's combine these two commands:

if [ -z `docker ps -q --no-trunc | grep $(docker-compose ps -q <service_name>)` ]; then
  echo "No, it's not running."
else
  echo "Yes, it's running."
fi

docker ps shows short version of IDs by default, so we need to specify --no-trunc flag.

UPDATE: It threw "grep usage" warning if the service was not running. Thanks to @Dzhuneyt, here's the updated answer.

if [ -z `docker-compose ps -q <service_name>` ] || [ -z `docker ps -q --no-trunc | grep $(docker-compose ps -q <service_name>)` ]; then
  echo "No, it's not running."
else
  echo "Yes, it's running."
fi

As for version 1.7.1, there are no such commands built-in.

Instead, the exec can be used in similar way.

When you run it for the service which has some containers up it will run ok:

~/apperture-science $ docker-compose exec chell echo 'Still alive!'
Still alive!
~/apperture-science $ echo $?
0

But when you run it for the service which has no running service containers, it will show an error:

~/apperture-science $ docker-compose exec glados echo "Still alive!"
ERROR: No container found for apperture-science-glados_1
~/apperture-science $ echo $?
1

So, it can be used in order to check, is there any "alive" containers for given service.

To see all services running:

docker-compose ps --services --filter "status=running"

To see if your-service is running:

docker-compose ps --services --filter "status=running" | grep <your-service>

Note that --filter must be used with --services for some foreign reason.

You can run:

docker-compose ps -q service-name

And you will get the id of the container if service-name is running. Something like:

18a04e61240d8ffaf4dc3f021effe9e951572ef0cb31da7ce6118f681f585c7f

If the service is not running the output is empty, so if you want to use this in a script you can do something like:

IS_RUNNING=`docker-compose ps -q service-name`
if [[ "$IS_RUNNING" != "" ]]; then
    echo "The service is running!!!"
fi

I had a similar need. However, I have a restart: always in my environment. So it can be a bit tricky to detect if something is crashing and restarting in a loop.

I made an Icinga/Nagios check to also compare the created and start times. Maybe it's useful to someone else down the line:

#!/usr/bin/env python
from __future__ import print_function
import argparse
from datetime import timedelta
from datetime import datetime
import sys

from dateutil.parser import parse as parse_date
import docker
import pytz
parser = argparse.ArgumentParser()
parser.add_argument("compose_project",
                    help="The name of the docker-compose project")
parser.add_argument("compose_service",
                    help="The name of the docker-compose service")
args = vars(parser.parse_args())

client = docker.from_env()
service_containers = client.containers.list(filters={
    "label": [
        "com.docker.compose.oneoff=False",
        "com.docker.compose.project={}".format(args["compose_project"]),
        "com.docker.compose.service={}".format(args["compose_service"])
    ]})

if len(service_containers) == 0:
    print("CRITICAL: project({})/service({}) doesn't exist!".format(
        args["compose_project"], args["compose_service"]))
    sys.exit(2)
elif len(service_containers) > 1:
    print("CRITICAL: project({})/service({}) has more than 1 "
          "container!".format(
              args["compose_project"], args["compose_service"]))
    sys.exit(2)

service_container = service_containers[0]
created_at = parse_date(service_container.attrs['Created'])
status = service_container.attrs['State']['Status']
started_at = parse_date(service_container.attrs['State']['StartedAt'])
now = datetime.utcnow().replace(tzinfo=pytz.utc)
uptime = now - started_at

if status in ['stopped', 'exited', 'dead']:
    print("CRITICAL: project({})/service({}) is status={}".format(
        args["compose_project"], args["compose_service"], status))
    sys.exit(2)

if (started_at - created_at) > timedelta(minutes=5):
    if uptime < timedelta(seconds=5):
        print("CRITICAL: project({})/service({}) appears to be "
              "crash-looping".format(
                  args["compose_project"], args["compose_service"]))
        sys.exit(2)

if status == "restarting":
    print("WARNING: project({})/service({}) is restarting".format(
        args["compose_project"], args["compose_service"]))
    sys.exit(1)

print ("OK: project({})/service({}) is up for {}".format(
    args["compose_project"], args["compose_service"], uptime
))
sys.exit(0)

How about this?

docker-compose ps | awk '$4 == "Up" {print $1}' | grep <service-name>

you list the processes, select the lines where "Up" is in column 4 and filter through for a match on the service name.

Here is a simple one liner that returns the current status of the service:

docker inspect --format "{{.State.Status}}" $(docker-compose ps -q your_service_name)

This is returning only the status of docker container. If you want to check for the actual state of your application you should add HEALTHCHECK to your Dockerfile (https://docs.docker.com/engine/reference/builder/#healthcheck). Afterwards you can inspect it with:

docker inspect --format "{{.State.Health.Status}}" $(docker-compose ps -q your_service_name)

If you assume this scenario:

• containers either start and run indefinitely or stop immediately with an error code (i.e. for missing configuration)
• you do the check only once after docker-compose up -d returns

you can check if there is any stopped container due to an error with: docker ps -a | grep 'Exited (255)'.

This check works correctly even in case of containers which are expected to stop immediately with no error (i.e. data containers), as their status (from docker ps -a) is marked as Exited (0).

For example, in our docker-compose.yml, we start our containers with:

command: sh -c 'node dotenv_check.js && pm2 start --no-daemon src/worker.js --watch'

For php-fpm, we use a similar command:

command: >-
  sh -c '
  set -e;
  for PROJECT in frontend backend; do
    cd /var/www/$${PROJECT};
    php dotenv_check.php;
  done;
  php-fpm
  '

The dotenv_check.js and dotenv_check.php are scripts which exit with an error code in case a required env variable is missing.

The set -e command, tells the script to stop on error, which, in turns, will immediately stop the container. About set-e

Here's a simplified one-liner based on almquista's answer:

docker ps -q --no-trunc | grep -q "^$(docker-compose ps -q app-service)$"

We use grep's -q flag so a non-zero exit code indicates the service is not running. For example:

if docker ps -q --no-trunc | grep -q "^$(dc-audo-dev ps -q app-service)$"; then
    echo "Container is still running..."
fi

You can grep for (healthy) or/and (unhealthy) images to act properly.

In this example, i'm probing docker-compose each 5 seconds for running service with (healthy) status. If script will find such service, it will break execution. If script will exceed 300 seconds, it will exit with error code.

#!/bin/bash
SECONDS=0
LIMIT=300
x=$(docker-compose -f /mnt/<service>/docker-compose.yaml ps <service> | grep -c '(healthy)')
while [[ $x == "0" ]]; do
    echo "Please wait until <service> becomes healthy"
    sleep 5
    x=$(docker-compose -f /mnt/<service>/docker-compose.yaml ps <service> | grep -c '(healthy)')
    EXPIRED=$SECONDS
    if [[ $x == "1" ]]; then
      echo "<service> is healthy..."
      break
    elif [[ $LIMIT -lt $EXPIRED ]]; then
      echo "<service> startup has exceeded 5m timeout, exiting!"
      exit 1
    fi
done