43

I am using the docker-compose.

Some commands like up -d service_name or start service_name are returning right away and this is pretty useful if you don't want the containers running to depend on the state of the shell, like they do with regular up service_name. The one use-case is running it from some kind of continious integration/delivery server.

But this way of running/starting services does not provide any feedback about the actual state of the service afterwards.

The Docker Compose CLI reference for up command does mention the relevant option, but, as for version 1.7.1, it is mutually exclusive with -d:

--abort-on-container-exit  Stops all containers if any container was stopped.
                           *Incompatible with -d.*

Can I somehow manually check that the container is indeed working and haven't stopped because of some error?

Ivan Kolmychek
  • 1,154
  • 2
  • 9
  • 13

10 Answers10

35
  • 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
elquimista
  • 466
  • 4
  • 5
  • Nice one, and it also addresses problem with current answer that was stated in comments. Marking this as a new answer. – Ivan Kolmychek Oct 16 '18 at 06:01
  • 3
    If you are using a restart policy you also need to filter it to only include running containers (rather than ones in a restarting state): `docker ps -q -f "status=running" --no-trunc | grep $(docker-compose ps -q )` – Max Oct 20 '18 at 21:58
  • 1
    This works but throws a "grep usage" warning if the service isn't running, in other words, when the `grep ....` part ends up with an empty string. – Dzhuneyt Jul 12 '19 at 08:25
  • @Dzhuneyt I know, yes, you are right. Thoughts on to avoid/handle that grep warning? – elquimista Jul 12 '19 at 14:40
  • 2
    @elquimista Yes, I solved it using the OR operator: ```if [ -z `docker-compose ps -q mysql` ] || [ -z `docker ps -q --no-trunc | grep $(docker-compose ps -q mysql)` ]; then```. What this does is: it first checks if the service exists at all (even if it's stopped) and the second part checks if the existing service is actually running. You might want to include this in your example for future readers that glance over the accepted answer only. I think it's useful. – Dzhuneyt Jul 15 '19 at 08:49
  • @Dzhuneyt wow, thanks a lot! I've updated my answer. – elquimista Jul 15 '19 at 11:13
  • You can do it all in a single command without an error from grep if the input is quoted, `if [ -z "$( docker ps -q --no-trunc | grep "$( docker-compose ps -q )" )" ]`. – chawkinsuf May 16 '20 at 20:46
15

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.

Ivan Kolmychek
  • 1,154
  • 2
  • 9
  • 13
13

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.

Scott Weldon
  • 105
  • 1
  • 5
drew2g
  • 131
  • 1
  • 2
  • Looks like docker changed the flags, using `docker-compose ps --status running | grep ` worked for me (v20.10.7) – tharkay Jul 21 '21 at 09:11
  • `| grep -Fxe ` in case the service you're checking for also has another service with that name in, e.g. `app` and `console-app`, `grep app` would match both – Andy May 13 '22 at 10:57
5

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
alejandropg
  • 183
  • 1
  • 1
  • Yes, that works too. Marked this as answer now. – Ivan Kolmychek Feb 05 '18 at 13:06
  • 18
    This doesn't tell you if the container is running or not, just if it exists or not. Try doing `docker-compose up` then Ctrl-C. `docker-compose ps` should then show that the container states are _not_ "Up", but `docker-compose ps -q service-name` still gives you an id. – djanderson Feb 22 '18 at 22:13
2

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)
jof
  • 121
  • 1
1

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)
Elembivios
  • 11
  • 2
  • but how do you ensure its really running and not crashed as in the original question? – djdomi Jul 21 '21 at 13:23
  • For the actual state of your application add HEALTHCHECK to your Dockerfile. Afterwards you can inspect it with: docker inspect --format "{{.State.Health.Status}}" $(docker-compose ps -q your_service_name) – Elembivios Jul 22 '21 at 09:12
  • i suggest to add the fact to your answer – djdomi Jul 22 '21 at 10:08
1

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.

George Mauer
  • 479
  • 3
  • 7
  • 13
  • I had to change `$4` to either `$5` or `$6` depending on if the command had any spaces in it. – Andy Aug 09 '22 at 00:14
0

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
Matthew D. Scholefield
  • 101
  • 2
0

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
Ivan Nikolaev
  • 1
  • 2
0

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

Fabio
  • 161
  • 1
  • 3