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

Question

Estou usando o docker-compose .

Alguns comandos como up -d service_name ou start service_name estão retornando imediatamente e isso é bastante útil se você não quiser que os contêineres em execução dependam do estado do shell, como acontece com up service_name regular. O único caso de uso é executá-lo de algum tipo de servidor de integração / entrega contínuo.

Mas essa maneira de executar / iniciar serviços não fornece nenhum feedback sobre o estado real do serviço posteriormente.

A referência Docker Compose CLI para o comando up menciona a opção relevante, mas, quanto a versão 1.7.1 , é mutuamente exclusivo com -d :

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

Posso de alguma forma verificar manualmente se o container está de fato funcionando e não parou por causa de algum erro?

    

Answer 1

• 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 ps mostra 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 ps mostra versões curtas de IDs por padrão, portanto, precisamos especificar --no-trunc flag.

    

Answer 2

Quanto à versão 1.7.1 , não há comandos embutidos.

Em vez disso, o exec pode ser usado de maneira semelhante.

Quando você o executa para o serviço que tem alguns containers, ele rodará 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 tem contêineres em serviço , ele mostrará um erro:

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

Então, ele pode ser usado para verificar se há algum contêiner "vivo" para determinado serviço.

    

Answer 3

Você pode executar:

docker-compose ps -q service-name

E você receberá o ID do contêiner se service-name estiver em execução. Algo como:

18a04e61240d8ffaf4dc3f021effe9e951572ef0cb31da7ce6118f681f585c7f

Se o serviço não está sendo executado, a saída está vazia, então se você quiser usar isso em um script, você pode fazer algo como:

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

    

Answer 4

Eu tive uma necessidade semelhante. No entanto, tenho um restart: always no meu ambiente. Por isso, pode ser um pouco complicado detectar se algo está falhando e reiniciando em um loop.

Eu fiz uma verificação de Icinga / Nagios para comparar também os horários criados e de início. Talvez seja útil para alguém mais abaixo da linha:

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

    

Answer 5

Se você assumir este cenário:

Os contêineres
• iniciam e são executados indefinidamente ou param imediatamente com um código de erro (por exemplo, para configurações ausentes)
• você faz a verificação apenas uma vez depois que o docker compõe up -d retorna

você pode verificar se há algum contêiner 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 ser interrompidos imediatamente sem erros (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 o 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
  '

Os dotenv_check.js e dotenv_check.php são scripts que saem com um código de erro no caso de uma variável env requerida estar ausente.

O comando set -e , instrui o script a interromper o erro, que, por sua vez, interromperá imediatamente o contêiner. Sobre o set-e