Como usar o comando docker compose build para construir serviços

Introdução

Neste laboratório, você aprenderá como usar efetivamente o comando docker compose build para construir serviços definidos em um arquivo Docker Compose. Você começará preparando um arquivo Docker Compose simples para definir uma aplicação multi-container.

Após a configuração, você construirá os serviços usando o comando docker compose build. Em seguida, explorará como reconstruir serviços após fazer alterações em seus Dockerfiles correspondentes. Finalmente, você aprenderá como construir serviços com argumentos de construção e como utilizar a opção --no-cache para uma construção limpa.

Preparar um arquivo Docker Compose simples

Nesta etapa, você aprenderá como criar um arquivo Docker Compose básico para definir e gerenciar aplicações Docker multi-container. 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. Então, com um único comando, você cria e inicia todos os serviços a partir da sua configuração.

Primeiro, vamos instalar o Docker Compose. Como ele não vem pré-instalado no ambiente LabEx, precisamos baixar o binário.

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 da página oficial de releases do GitHub e o salva em /usr/local/bin/docker-compose. As partes $(uname -s) e $(uname -m) detectam automaticamente seu sistema operacional e arquitetura para baixar o binário correto.

Em seguida, precisamos dar permissões de execução ao binário baixado.

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

Este comando torna o comando docker-compose executável.

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

docker-compose --version

Você deve ver uma saída semelhante a Docker Compose version v2.20.2, confirmando que o Docker Compose está instalado corretamente.

Agora, vamos criar um arquivo Docker Compose simples. Definiremos um serviço que usa a imagem nginx.

Navegue até o diretório do seu projeto.

cd ~/project

Crie um novo arquivo chamado docker-compose.yml usando o editor nano.

nano docker-compose.yml

Adicione o seguinte conteúdo ao arquivo:

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

Vamos detalhar este arquivo:

• version: '3.8' especifica a versão do formato do arquivo Docker Compose.
• services: define os diferentes serviços que compõem sua aplicação.
• web: é o nome do nosso serviço. Você pode escolher qualquer nome que desejar.
• image: nginx:latest especifica a imagem Docker a ser usada para este serviço. Neste caso, estamos usando a versão mais recente da imagem oficial do Nginx.
• ports: mapeia portas entre a máquina host e o container. "80:80" mapeia a porta 80 no host para a porta 80 no container.

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

Agora, vamos baixar a imagem nginx:latest que especificamos em nosso arquivo docker-compose.yml. Embora o Docker Compose possa baixar imagens automaticamente quando você executa docker-compose up, é uma boa prática baixar explicitamente as imagens de antemão, especialmente em um ambiente de laboratório, para garantir que elas estejam disponíveis.

docker pull nginx:latest

Este comando baixa a imagem nginx:latest do Docker Hub. Você verá uma saída indicando o progresso do download.

Construir serviços usando docker compose build

Na etapa anterior, criamos um arquivo docker-compose.yml simples que usa uma imagem Docker existente (nginx). Docker Compose também pode construir imagens a partir de um Dockerfile. Isso é útil quando você precisa personalizar uma imagem ou construir uma imagem para sua própria aplicação.

Nesta etapa, modificaremos nosso arquivo docker-compose.yml para construir uma imagem a partir de um Dockerfile em vez de usar uma imagem pré-construída.

Primeiro, vamos criar um Dockerfile simples no diretório ~/project.

nano ~/project/Dockerfile

Adicione o seguinte conteúdo ao Dockerfile:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello, Docker Compose!"]

Vamos explicar este Dockerfile:

• FROM ubuntu:latest especifica a imagem base para nossa nova imagem. Estamos usando a versão mais recente da imagem oficial do Ubuntu.
• RUN apt-get update && apt-get install -y cowsay atualiza a lista de pacotes e instala o pacote cowsay. O comando cowsay exibe uma mensagem em um balão de fala desenhado por uma vaca.
• CMD ["cowsay", "Hello, Docker Compose!"] define o comando padrão a ser executado quando um container é iniciado a partir desta imagem.

Salve o Dockerfile pressionando Ctrl + X, depois Y e Enter.

Agora, vamos modificar nosso arquivo docker-compose.yml para usar este Dockerfile. Abra o arquivo para edição:

nano ~/project/docker-compose.yml

Altere o conteúdo para o seguinte:

version: "3.8"
services:
  cow:
    build: .

Neste docker-compose.yml atualizado:

• Mudamos o nome do serviço de web para cow para refletir melhor seu propósito.
• Substituímos a diretiva image: por build: .. A diretiva build: . diz ao Docker Compose para construir a imagem para este serviço usando o Dockerfile localizado no diretório atual (.).

Salve o arquivo docker-compose.yml pressionando Ctrl + X, depois Y e Enter.

Agora, podemos usar o comando docker-compose build para construir a imagem para o serviço cow. Certifique-se de estar no diretório ~/project.

cd ~/project
docker-compose build

Este comando lerá o arquivo docker-compose.yml, encontrará o serviço cow e construirá a imagem com base no Dockerfile no diretório atual. Você verá a saída mostrando as etapas do processo de construção, incluindo o download da imagem base do Ubuntu, a atualização de pacotes e a instalação do cowsay.

Após a conclusão da construção, você pode verificar se a imagem foi criada listando suas imagens Docker locais.

docker images

Você deve ver uma imagem com um nome como project_cow (Docker Compose nomeia automaticamente as imagens com base no nome do diretório e no nome do serviço) e uma tag como latest.

Reconstruir serviços após alterar o Dockerfile

Na etapa anterior, construímos uma imagem Docker usando um Dockerfile e docker-compose build. O que acontece se fizermos alterações no Dockerfile? O Docker usa um mecanismo de cache para acelerar o processo de construção. Se uma camada no Dockerfile não foi alterada, o Docker usará a versão em cache em vez de reconstruí-la. No entanto, se uma camada ou quaisquer camadas subsequentes forem alteradas, o Docker reconstruirá essas camadas.

Nesta etapa, modificaremos nosso Dockerfile e, em seguida, reconstruiremos a imagem para ver como o Docker lida com as alterações.

Primeiro, vamos modificar o Dockerfile para alterar a mensagem exibida pelo cowsay. Abra o Dockerfile para edição:

nano ~/project/Dockerfile

Altere a linha CMD para o seguinte:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello again, Docker Compose!"]

Mudamos a mensagem de "Hello, Docker Compose!" para "Hello again, Docker Compose!".

Salve o Dockerfile pressionando Ctrl + X, depois Y e Enter.

Agora, vamos reconstruir a imagem usando o comando docker-compose build novamente. Certifique-se de estar no diretório ~/project.

cd ~/project
docker-compose build

Observe a saída do processo de construção. Você notará que as duas primeiras etapas (FROM ubuntu:latest e RUN apt-get update && apt-get install -y cowsay) provavelmente usarão as camadas em cache da construção anterior. No entanto, a última etapa (CMD ["cowsay", "Hello again, Docker Compose!"]) será reconstruída porque alteramos essa linha no Dockerfile.

Após a conclusão da construção, você pode verificar se a imagem foi atualizada listando suas imagens Docker locais.

docker images

A imagem project_cow agora deve refletir as alterações feitas no Dockerfile. Embora o ID da imagem possa mudar, o nome e a tag permanecerão os mesmos.

Para confirmar ainda mais a alteração, podemos executar um container a partir desta imagem recém-construída e ver a saída.

docker run project_cow

Você deve ver a saída do cowsay com a mensagem atualizada: "Hello again, Docker Compose!".

Construir serviços com argumentos de build e sem cache

Nesta etapa, exploraremos duas opções avançadas de construção com Docker Compose: usar argumentos de construção e construir sem cache.

Argumentos de construção permitem que você passe variáveis para o processo de construção do Docker. Isso é útil para personalizar a construção com base em diferentes ambientes ou configurações sem alterar o próprio Dockerfile.

Primeiro, vamos modificar nosso Dockerfile para aceitar um argumento de construção. Abra o Dockerfile para edição:

nano ~/project/Dockerfile

Altere o conteúdo para o seguinte:

FROM ubuntu:latest
ARG MESSAGE="Hello from build argument!"
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "$MESSAGE"]

Adicionamos uma instrução ARG MESSAGE para definir um argumento de construção chamado MESSAGE com um valor padrão. Também alteramos a instrução CMD para usar este argumento.

Salve o Dockerfile pressionando Ctrl + X, depois Y e Enter.

Agora, vamos modificar nosso arquivo docker-compose.yml para passar um valor para este argumento de construção. Abra o arquivo para edição:

nano ~/project/docker-compose.yml

Altere o conteúdo para o seguinte:

version: "3.8"
services:
  cow:
    build:
      context: .
      args:
        MESSAGE: "Custom message from Compose!"

Mudamos a diretiva build: para um objeto com context: e args:.

• context: . especifica o contexto de construção, que é o diretório que contém o Dockerfile.
• args: é um mapa de argumentos de construção para passar para o Dockerfile. Estamos passando o valor "Custom message from Compose!" para o argumento MESSAGE.

Salve o arquivo docker-compose.yml pressionando Ctrl + X, depois Y e Enter.

Agora, vamos construir a imagem com o argumento de construção. Certifique-se de estar no diretório ~/project.

cd ~/project
docker-compose build

Observe a saída da construção. Você deve ver que o argumento de construção é usado durante o processo de construção.

Após a conclusão da construção, vamos executar um container a partir desta imagem para ver a saída.

docker run project_cow

Você deve ver a saída do cowsay com a mensagem "Custom message from Compose!". Isso confirma que o argumento de construção foi passado e usado com sucesso.

Às vezes, você pode querer forçar o Docker a reconstruir todas as camadas, ignorando o cache. Isso é útil quando você suspeita de problemas de cache ou deseja garantir uma construção limpa. Você pode fazer isso usando a flag --no-cache com o comando docker-compose build.

Vamos tentar reconstruir a imagem com a flag --no-cache.

docker-compose build --no-cache

Observe a saída da construção novamente. Desta vez, você verá que o Docker não usa nenhuma camada em cache e reconstrói cada etapa no Dockerfile. Este processo levará mais tempo do que uma construção em cache.

Após a conclusão da construção, você pode executar o container novamente para confirmar que a mensagem ainda é aquela passada via argumento de construção.

docker run project_cow

Você ainda deve ver "Custom message from Compose!". A flag --no-cache afeta apenas o processo de construção, não a configuração definida em docker-compose.yml.

Resumo

Neste laboratório, você aprendeu como preparar um arquivo Docker Compose simples, instalando o Docker Compose e criando um arquivo docker-compose.yml para definir um serviço usando a imagem nginx. Em seguida, você praticou a construção de serviços usando o comando docker compose build, incluindo a reconstrução de serviços após modificar o Dockerfile e a construção de serviços com argumentos de construção e sem usar o cache.