Como usar o comando docker compose up para gerenciar contêineres

Introdução

Neste laboratório, você aprenderá como gerenciar contêineres de forma eficaz usando o comando docker compose up. Abordaremos o uso fundamental do docker compose up para iniciar serviços definidos em um arquivo docker-compose.yml, incluindo a execução de serviços em primeiro plano (foreground) e em modo detached.

Além disso, você explorará opções avançadas do docker compose up, como forçar a recriação de contêineres com force-recreate, evitar recriações desnecessárias com no-recreate e construir automaticamente imagens antes de iniciar os contêineres. Ao final deste laboratório, você estará proficiente no uso do docker compose up para vários cenários de gerenciamento de contêineres.

Iniciar serviços com docker compose up

Nesta etapa, você aprenderá como iniciar serviços definidos em um arquivo docker-compose.yml usando o comando docker compose up. Antes de começarmos, precisamos instalar o Docker Compose, pois ele não está pré-instalado neste ambiente.

Primeiro, vamos instalar o Docker Compose. Faremos o download da versão estável mais recente e a tornaremos executável.

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
sudo chmod +x /usr/local/bin/docker-compose

Agora que o Docker Compose está instalado, vamos criar um arquivo docker-compose.yml simples para definir um serviço. Criaremos um arquivo chamado docker-compose.yml no seu diretório ~/project.

nano ~/project/docker-compose.yml

Adicione o seguinte conteúdo ao arquivo:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Este arquivo docker-compose.yml define um único serviço chamado web. Ele usa a imagem nginx:latest e mapeia a porta 80 no host para a porta 80 no contêiner.

Agora, vamos usar docker compose up para iniciar o serviço. Navegue até o diretório ~/project e execute o comando.

cd ~/project
docker compose up

Você verá uma saída indicando que o Docker Compose está criando e iniciando o contêiner web. Por padrão, docker compose up é executado em primeiro plano (foreground), mostrando os logs dos serviços em execução.

Para verificar se o contêiner Nginx está em execução, você pode abrir um novo terminal ou usar curl para acessar o servidor web.

curl http://localhost

Você deve ver a saída HTML da página de boas-vindas padrão do Nginx. Isso confirma que o serviço web está em execução e acessível.

Para parar os serviços, pressione Ctrl+C no terminal onde docker compose up está sendo executado. Isso irá parar e remover os contêineres.

Executar serviços em modo detached (desanexado)

Na etapa anterior, você iniciou os serviços usando docker compose up, que foi executado em primeiro plano. Isso é útil para depuração, mas para executar serviços em produção ou em segundo plano, você vai querer usar o modo detached.

O modo detached significa que o Docker Compose iniciará os contêineres e, em seguida, sairá, deixando os contêineres em execução em segundo plano. Isso permite que você continue usando seu terminal para outras tarefas.

Para executar os serviços em modo detached, você simplesmente adiciona a flag -d ao comando docker compose up. Certifique-se de estar no diretório ~/project onde seu arquivo docker-compose.yml está localizado.

cd ~/project
docker compose up -d

Você verá uma saída indicando que os contêineres estão sendo criados e iniciados, mas o comando retornará ao prompt do terminal assim que os serviços estiverem em execução.

Para verificar se o contêiner está em execução em segundo plano, você pode usar o comando docker ps para listar os contêineres em execução.

docker ps

Você deve ver uma entrada para o contêiner project-web-1 (o nome é tipicamente [nome_do_diretório]-[nome_do_serviço]-[número_da_instância]).

Você ainda pode acessar o servidor web Nginx usando curl para confirmar que está funcionando.

curl http://localhost

Você deve novamente ver a saída HTML da página de boas-vindas padrão do Nginx.

Para parar os serviços que foram iniciados em modo detached, você pode usar o comando docker compose down no mesmo diretório do seu arquivo docker-compose.yml.

docker compose down

Este comando irá parar e remover os contêineres, redes e volumes criados por docker compose up.

Recriar contêineres com force-recreate

Na etapa anterior, você aprendeu como executar serviços em modo detached. Por padrão, quando você executa docker compose up novamente com o mesmo arquivo docker-compose.yml e os contêineres já estão em execução, o Docker Compose não recriará os contêineres, a menos que haja alterações na definição do serviço (como a imagem ou as portas).

Às vezes, você pode querer forçar o Docker Compose a parar e recriar os contêineres, mesmo que não haja alterações na definição do serviço. Isso pode ser útil para aplicar atualizações que não envolvem a alteração do arquivo docker-compose.yml, ou simplesmente para garantir um novo começo para o contêiner.

Para forçar a recriação de contêineres, você pode usar a flag --force-recreate com o comando docker compose up.

Primeiro, certifique-se de que seu serviço web esteja em execução em modo detached da etapa anterior. Caso contrário, execute:

cd ~/project
docker compose up -d

Agora, vamos executar docker compose up novamente com a flag --force-recreate.

cd ~/project
docker compose up -d --force-recreate

Você verá uma saída indicando que o Docker Compose está parando e, em seguida, recriando o contêiner web. Mesmo que o arquivo docker-compose.yml não tenha sido alterado, a flag --force-recreate diz ao Docker Compose para derrubar o contêiner existente e construir um novo com base na configuração atual.

Você pode verificar se o contêiner foi recriado verificando o ID do contêiner usando docker ps. O ID do contêiner deve ser diferente daquele que você viu antes de executar o comando com --force-recreate.

docker ps

Observe o ID do contêiner na saída.

Para limpar, pare os serviços em execução:

cd ~/project
docker compose down

Impedir a recriação com no-recreate

Na etapa anterior, você aprendeu como forçar a recriação de contêineres usando a flag --force-recreate. Agora, vamos analisar o cenário oposto: prevenir a recriação.

Como mencionado anteriormente, por padrão, docker compose up não recriará contêineres se eles já estiverem em execução e sua configuração no arquivo docker-compose.yml não tiver sido alterada. No entanto, pode haver situações em que você deseja garantir explicitamente que os contêineres existentes não sejam recriados, mesmo que haja pequenas alterações que, de outra forma, possam acionar uma recriação.

Para evitar a recriação de contêineres, você pode usar a flag --no-recreate com o comando docker compose up.

Primeiro, certifique-se de que seu serviço web esteja parado. Se estiver em execução, pare-o usando:

cd ~/project
docker compose down

Agora, vamos iniciar o serviço usando docker compose up -d.

cd ~/project
docker compose up -d

Verifique se o contêiner está em execução:

docker ps

Observe o ID do contêiner.

Agora, vamos executar docker compose up novamente com a flag --no-recreate.

cd ~/project
docker compose up -d --no-recreate

Você verá uma saída indicando que o serviço está atualizado e o contêiner não está sendo recriado. Se você verificar docker ps novamente, verá que o ID do contêiner é o mesmo de antes.

docker ps

Isso demonstra que a flag --no-recreate impediu com sucesso que o Docker Compose recriasse o contêiner existente.

Para limpar, pare os serviços em execução:

cd ~/project
docker compose down

Construir imagens antes de iniciar os contêineres

Nas etapas anteriores, usamos imagens Docker pré-construídas do Docker Hub (como nginx:latest). No entanto, você frequentemente precisará construir suas próprias imagens Docker personalizadas para suas aplicações.

O Docker Compose pode construir automaticamente imagens definidas em seu arquivo docker-compose.yml antes de iniciar os serviços. Isso é normalmente feito especificando um contexto build em vez de um nome image para um serviço.

Vamos modificar nosso arquivo docker-compose.yml para construir uma imagem Nginx personalizada simples.

Primeiro, crie um novo diretório chamado nginx_custom dentro de ~/project.

cd ~/project
mkdir nginx_custom

Agora, crie um Dockerfile dentro do diretório nginx_custom.

nano ~/project/nginx_custom/Dockerfile

Adicione o seguinte conteúdo ao Dockerfile:

FROM nginx:latest
RUN echo '<h1>Hello from Custom Nginx!</h1>' >/usr/share/nginx/html/index.html

Este Dockerfile começa com a imagem oficial nginx:latest e, em seguida, substitui o arquivo index.html padrão por um personalizado.

Em seguida, modifique seu arquivo ~/project/docker-compose.yml para usar este Dockerfile para construir a imagem do serviço web. Abra o arquivo para edição:

nano ~/project/docker-compose.yml

Altere a definição do serviço web para usar build em vez de image:

version: "3.8"
services:
  web:
    build: ./nginx_custom
    ports:
      - "80:80"

Agora, quando você executar docker compose up, o Docker Compose primeiro construirá a imagem definida pelo Dockerfile no diretório ./nginx_custom e, em seguida, iniciará um contêiner usando essa imagem recém-construída.

Certifique-se de estar no diretório ~/project e execute:

cd ~/project
docker compose up -d

Você verá uma saída indicando que o Docker Compose está construindo a imagem e, em seguida, criando e iniciando o contêiner.

Para verificar se a página Nginx personalizada está sendo servida, use curl:

curl http://localhost

Você deve ver a saída <h1>Hello from Custom Nginx!</h1>, confirmando que a imagem foi construída e o contêiner está em execução com o conteúdo personalizado.

Para limpar, pare os serviços em execução:

cd ~/project
docker compose down

Resumo

Neste laboratório, você aprendeu como usar o comando docker compose up para gerenciar contêineres. Você começou instalando o Docker Compose e criando um arquivo docker-compose.yml simples para definir um serviço web usando a imagem Nginx. Em seguida, você usou docker compose up para iniciar o serviço, observando que ele é executado em primeiro plano por padrão e exibe os logs do contêiner. Você verificou o serviço em execução acessando a página de boas-vindas do Nginx.

O laboratório também introduziu a execução de serviços em modo detached (desanexado) usando a flag -d, permitindo que o comando saia enquanto os contêineres continuam em execução em segundo plano. Você aprendeu como forçar a recriação de contêineres, mesmo que sua configuração não tenha sido alterada, usando a flag --force-recreate e como impedir a recriação de contêineres existentes com a flag --no-recreate. Por fim, você explorou a flag --build para construir ou reconstruir imagens antes de iniciar os contêineres, garantindo que a imagem mais recente seja usada.