Verifique se o contêiner/serviço está em execução com o docker-compose

• docker-compose ps -q <service_name>exibirá o ID do contêiner, independentemente de estar em execução ou não, desde que tenha sido criado.
• docker psmostra apenas aqueles que estão realmente em execução.

Vamos combinar esses dois comandos:

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 psmostra a versão curta dos IDs por padrão, portanto, precisamos especificar o --no-truncsinalizador.

ATUALIZAÇÃO : lançou um aviso de "uso do grep" se o serviço não estava em execução. Graças a @Dzhuneyt, aqui está a resposta atualizada.

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

Quanto à versão 1.7.1, não existem tais comandos integrados.

Em vez disso, o execpode ser usado de maneira semelhante.

Quando você executá-lo para o serviço que possui alguns contêineres, ele será executado ok:

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

Mas quando você o executa para o serviço que não possui contêineres de serviço em execução , ele mostra um erro:

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

Assim, pode ser usado para verificar se há contêineres "vivos" para determinado serviço.

Para ver todos os serviços em execução:

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

Para ver se o seu serviço está em execução:

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

Observe que --filterdeve ser usado com --servicespor algum motivo estranho.

Você pode correr:

docker-compose ps -q service-name

E você obterá o id do contêiner se service-nameestiver em execução. Algo como:

18a04e61240d8ffaf4dc3f021effe9e951572ef0cb31da7ce6118f681f585c7f

Se o serviço não estiver em execução, a saída estará vazia, portanto, se você quiser usar isso em um script, poderá fazer algo como:

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

Eu tinha uma necessidade semelhante. No entanto, eu tenho um restart: alwaysem meu ambiente. Portanto, pode ser um pouco complicado detectar se algo está travando e reiniciando em um loop.

Fiz uma verificação do Icinga/Nagios para comparar também os horários de criação e início. Talvez seja útil para alguém no futuro:

#!/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)

Que tal agora?

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

você lista os processos, seleciona as linhas em que "Up" está na coluna 4 e filtra por uma correspondência no nome do serviço.

Aqui está um forro simples que retorna o status atual do serviço:

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

Isso está retornando apenas o status do contêiner docker. Se você deseja verificar o estado real do seu aplicativo, adicione HEALTHCHECK ao seu Dockerfile ( https://docs.docker.com/engine/reference/builder/#healthcheck ). Depois, você pode inspecioná-lo com:

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

Se você assumir este cenário:

• os contêineres iniciam e executam indefinidamente ou param imediatamente com um código de erro (ou seja, por falta de configuração)
• você faz a verificação apenas uma vez depois que docker-compose up -d retorna

você pode verificar se existe algum container parado devido a um erro com: docker ps -a | grep 'Exited (255)'.

Essa verificação funciona corretamente mesmo no caso de contêineres que devem parar imediatamente sem erro (ou seja, contêineres de dados), pois seu status (de docker ps -a) é marcado como Exited (0).

Por exemplo, em nosso docker-compose.yml, iniciamos nossos contêineres com:

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

Para php-fpm, usamos um comando semelhante:

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

O dotenv_check.jse dotenv_check.phpsão scripts que saem com um código de erro caso uma variável env necessária esteja ausente.

O set -ecomando informa ao script para parar em caso de erro, o que, por sua vez, interromperá imediatamente o contêiner. Sobre set-e

Aqui está um one-liner simplificado com base na resposta do almquista:

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

Usamos o -qsinalizador do grep para que um código de saída diferente de zero indique que o serviço não está em execução. Por exemplo:

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

Você pode grep para que (healthy)as (unhealthy)imagens funcionem corretamente.

Neste exemplo, estou testando o docker-compose a cada 5 segundos para executar o serviço com (healthy)status. Se o script encontrar esse serviço, ele interromperá a execução. Se o script exceder 300 segundos, ele sairá com o código de erro.

#!/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