Como usar o comando docker compose stop para gerenciar serviços

DockerBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como usar o comando docker compose stop para gerenciar serviços definidos em um arquivo Docker Compose. Começaremos preparando um projeto Docker Compose simples, que inclui a instalação do Docker Compose e a criação de um arquivo básico docker-compose.yml.

Após a configuração do projeto, você praticará a inicialização dos serviços definidos no arquivo Compose. O cerne do laboratório se concentra no uso do comando docker compose stop para parar todos os serviços em execução, parar um serviço específico e parar serviços com um tempo limite especificado. Essa experiência prática fornecerá a você habilidades práticas para controlar o ciclo de vida de suas aplicações Docker multi-container usando o Docker Compose.

Prepare um projeto Docker Compose simples

Nesta etapa, prepararemos um projeto Docker Compose simples. Docker Compose é uma ferramenta para definir e executar aplicações Docker multi-container. Com o Compose, você usa um arquivo YAML para configurar os serviços da sua aplicação. Em seguida, com um único comando, você cria e inicia todos os serviços a partir da sua configuração.

Como o Docker Compose não está pré-instalado no ambiente LabEx, precisamos instalá-lo primeiro. Faremos o download do binário do Docker Compose e o tornaremos executável.

Primeiro, vamos baixar o binário do Docker Compose. Usaremos curl para baixar a versão estável mais recente.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Este comando baixa o binário do Docker Compose para a arquitetura do seu sistema e o salva em /usr/local/bin/docker-compose.

Em seguida, precisamos tornar o binário baixado executável.

sudo chmod +x /usr/local/bin/docker-compose

Este comando adiciona permissões de execução ao binário do Docker Compose.

Agora, vamos verificar a instalação verificando a versão do Docker Compose.

docker-compose --version

Você deve ver a versão do Docker Compose instalada na saída, confirmando que a instalação foi bem-sucedida.

Agora que o Docker Compose está instalado, vamos criar um projeto Docker Compose simples. Criaremos um diretório para nosso projeto e, em seguida, criaremos um arquivo docker-compose.yml dentro dele.

Primeiro, crie um diretório chamado my-compose-app no seu diretório home.

mkdir ~/project/my-compose-app

Navegue para o diretório recém-criado.

cd ~/project/my-compose-app

Agora, criaremos um arquivo docker-compose.yml. Este arquivo definirá os serviços para nossa aplicação. Usaremos nano para criar e editar o arquivo.

nano docker-compose.yml

Dentro do editor nano, cole o seguinte conteúdo:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
  app:
    image: ubuntu:latest
    command: tail -f /dev/null

Vamos detalhar este arquivo docker-compose.yml:

  • version: '3.8' especifica a versão do formato do arquivo Docker Compose.
  • services: define os serviços que compõem sua aplicação.
  • web: define um serviço chamado web.
    • image: nginx:latest especifica que este serviço usará a imagem Docker nginx:latest. Se a imagem não estiver disponível localmente, o Docker Compose a puxará do Docker Hub.
    • ports: mapeia a porta 80 na máquina host para a porta 80 no container web.
  • app: define um serviço chamado app.
    • image: ubuntu:latest especifica que este serviço usará a imagem Docker ubuntu:latest.
    • command: tail -f /dev/null especifica o comando a ser executado quando o container app iniciar. Este comando mantém o container em execução indefinidamente sem sair.

Salve o arquivo pressionando Ctrl + X, depois Y e, em seguida, Enter.

Antes de podermos iniciar os serviços, precisamos garantir que as imagens Docker necessárias estejam disponíveis. Embora o Docker Compose puxe as imagens se elas não estiverem presentes, é uma boa prática puxá-las explicitamente de antemão, especialmente em ambientes com acesso limitado à internet ou para uma inicialização mais rápida.

Vamos puxar a imagem nginx:latest.

docker pull nginx:latest

Este comando baixa a imagem nginx:latest do Docker Hub.

Em seguida, vamos puxar a imagem ubuntu:latest.

docker pull ubuntu:latest

Este comando baixa a imagem ubuntu:latest do Docker Hub.

Agora você preparou com sucesso um projeto Docker Compose simples com dois serviços, web e app, e puxou as imagens Docker necessárias.

Iniciar os serviços definidos no arquivo Compose

Nesta etapa, iniciaremos os serviços definidos no arquivo docker-compose.yml que criamos na etapa anterior. Docker Compose fornece um comando simples para construir, criar e iniciar todos os serviços em sua configuração.

Certifique-se de estar no diretório ~/project/my-compose-app onde seu arquivo docker-compose.yml está localizado.

cd ~/project/my-compose-app

Para iniciar os serviços, usaremos o comando docker-compose up. Por padrão, docker-compose up inicia os containers em primeiro plano e imprime os logs de cada container.

docker-compose up

Quando você executa este comando, o Docker Compose irá:

  1. Procurar o arquivo docker-compose.yml no diretório atual.
  2. Construir ou puxar as imagens Docker necessárias para cada serviço, caso elas ainda não estejam disponíveis.
  3. Criar e iniciar os containers para cada serviço.
  4. Exibir os logs de todos os containers em execução no seu terminal.

Você verá uma saída indicando que as redes e os containers estão sendo criados e iniciados. Os logs dos containers web (nginx) e app (ubuntu) serão exibidos.

Como queremos que os serviços sejam executados em segundo plano para que possamos continuar usando o terminal, podemos parar a execução atual pressionando Ctrl + C.

Para executar os serviços em modo detached (em segundo plano), podemos usar a flag -d com o comando docker-compose up.

docker-compose up -d

Este comando iniciará os serviços em segundo plano e imprimirá os nomes dos containers criados.

Agora que os serviços estão sendo executados em modo detached, você pode verificar o status dos containers em execução usando o comando docker ps.

docker ps

Você deve ver dois containers em execução: um para o serviço web (baseado na imagem nginx) e um para o serviço app (baseado na imagem ubuntu). A saída mostrará informações sobre os containers, incluindo seus IDs, imagens, status e portas.

Para verificar se o serviço web está acessível, podemos usar curl para acessar o servidor nginx em execução na porta 80. Como mapeamos a porta 80 no host para a porta 80 no container web, podemos acessá-lo diretamente da VM LabEx.

curl http://localhost:80

Você deve ver o conteúdo HTML padrão servido pelo servidor web nginx, o que confirma que o serviço web está em execução e acessível.

Parar todos os serviços em execução

Nesta etapa, aprenderemos como parar todos os serviços que estão atualmente em execução como parte do nosso projeto Docker Compose. Docker Compose fornece um comando conveniente para parar todos os containers definidos no arquivo docker-compose.yml.

Certifique-se de estar no diretório ~/project/my-compose-app onde seu arquivo docker-compose.yml está localizado.

cd ~/project/my-compose-app

Para parar todos os serviços em execução, usamos o comando docker-compose down. Este comando para e remove os containers, redes e volumes definidos no arquivo docker-compose.yml.

docker-compose down

Quando você executa este comando, o Docker Compose irá:

  1. Parar os containers em execução de forma adequada.
  2. Remover os containers parados.
  3. Remover as redes criadas pelo Docker Compose para este projeto.
  4. Remover quaisquer volumes definidos no arquivo docker-compose.yml (a menos que explicitamente instruído a não fazê-lo).

Você verá uma saída indicando que os containers e as redes estão sendo parados e removidos.

Após executar docker-compose down, você pode verificar se os containers não estão mais em execução usando o comando docker ps.

docker ps

Este comando lista os containers atualmente em execução. Como paramos todos os serviços, você não deve ver os containers web ou app na saída. A saída deve mostrar apenas a linha do cabeçalho ou estar vazia se nenhum outro container estiver em execução no seu sistema.

Parar os serviços com docker-compose down é a maneira padrão de limpar os recursos do seu projeto Docker Compose quando você terminar de usá-los.

Parar um serviço específico

Nesta etapa, aprenderemos como parar um serviço específico dentro do nosso projeto Docker Compose, em vez de parar todos os serviços de uma vez. Isso é útil quando você só precisa reiniciar ou parar um único componente da sua aplicação.

Primeiro, vamos garantir que nossos serviços estejam em execução. Navegue até o diretório do projeto e inicie os serviços em modo detached.

cd ~/project/my-compose-app
docker-compose up -d

Verifique se os serviços web e app estão em execução usando docker ps.

docker ps

Você deve ver ambos os containers listados como em execução.

Agora, vamos parar apenas o serviço app. Para parar um serviço específico, usamos o comando docker-compose stop seguido pelo nome do serviço.

docker-compose stop app

Este comando enviará um sinal de parada ao container para o serviço app e aguardará que ele pare de forma adequada.

Após executar o comando, vamos verificar o status dos containers novamente.

docker ps

Você agora deve ver apenas o container web listado como em execução. O container app não deve mais estar na lista de containers em execução.

Para confirmar que o container app foi parado, você também pode usar docker ps -a, que mostra todos os containers, incluindo os parados.

docker ps -a

Você deve ver o container app listado com o status Exited.

Parar um serviço específico permite que você gerencie componentes individuais da sua aplicação sem afetar outros. Isso é particularmente útil durante o desenvolvimento ou ao solucionar problemas de um serviço específico.

Parar serviços com um tempo limite (timeout)

Nesta etapa, exploraremos como parar serviços com um tempo limite especificado. Quando você para um container, o Docker envia um sinal SIGTERM para o processo principal no container, dando-lhe tempo para desligar de forma adequada. Se o processo não sair dentro de um certo período, o Docker envia um sinal SIGKILL para forçá-lo a parar. Por padrão, este tempo limite é de 10 segundos. Você pode ajustar este tempo limite usando a flag -t ou --timeout com os comandos docker-compose stop ou docker-compose down.

Primeiro, vamos garantir que nossos serviços estejam em execução. Navegue até o diretório do projeto e inicie os serviços em modo detached.

cd ~/project/my-compose-app
docker-compose up -d

Verifique se ambos os serviços estão em execução:

docker ps

Agora, vamos parar o serviço web com um tempo limite de 5 segundos.

docker-compose stop -t 5 web

Este comando diz ao Docker Compose para parar o serviço web e esperar no máximo 5 segundos para que o container pare de forma adequada após o envio do sinal SIGTERM. Se o container não parar dentro de 5 segundos, o Docker enviará um sinal SIGKILL.

Você verá uma saída indicando que o serviço web está sendo parado.

Vamos verificar o status dos containers novamente:

docker ps

Você agora deve ver apenas o container app em execução. O container web deve estar parado.

Da mesma forma, você pode aplicar um tempo limite ao parar todos os serviços usando docker-compose down. Vamos parar todos os serviços com um tempo limite de 3 segundos.

docker-compose down -t 3

Este comando tentará parar todos os serviços definidos no arquivo docker-compose.yml, esperando no máximo 3 segundos para que cada container pare de forma adequada antes de forçá-lo a parar.

Verifique se nenhum container está em execução após executar o comando:

docker ps

A saída não deve mostrar nenhum container em execução.

Usar a opção de tempo limite é importante para garantir que suas aplicações tenham tempo suficiente para realizar tarefas de limpeza antes de serem paradas, evitando corrupção de dados ou outros problemas.

Resumo

Neste laboratório, aprendemos como preparar um projeto Docker Compose simples. Isso envolveu a instalação do Docker Compose, baixando o binário e tornando-o executável, e então verificando a instalação. Em seguida, criamos um diretório de projeto e um arquivo docker-compose.yml para definir os serviços para nossa aplicação.

Também aprendemos como gerenciar o ciclo de vida dos serviços definidos no arquivo Compose usando o comando docker compose stop. Isso incluiu iniciar todos os serviços, parar todos os serviços em execução, parar um serviço específico e parar serviços com um tempo limite especificado.