Introdução
Neste laboratório, você aprenderá como usar efetivamente o comando docker buildx debug build para construir e inspecionar imagens Docker. Você começará construindo uma imagem simples com configurações padrão usando um Dockerfile.
Partindo do básico, você explorará cenários de construção mais avançados, incluindo a incorporação de argumentos de construção e rótulos em suas imagens. Você também aprenderá como direcionar plataformas específicas durante o processo de construção e gerar a imagem resultante em um arquivo. Por fim, o laboratório cobrirá técnicas para controlar o cache de construção e expor com segurança segredos durante a construção, fornecendo uma compreensão abrangente das capacidades do comando docker buildx debug build.
Construir uma imagem simples com configurações padrão
Nesta etapa, você aprenderá como construir uma imagem Docker simples usando um Dockerfile. Um Dockerfile é um documento de texto que contém todos os comandos que um usuário pode chamar na linha de comando para montar uma imagem. O Docker pode construir imagens automaticamente lendo as instruções de um Dockerfile.
Primeiro, navegue até o diretório ~/project, que é seu diretório de trabalho para este laboratório.
cd ~/project
Agora, vamos criar um Dockerfile simples. Criaremos um arquivo chamado Dockerfile no diretório ~/project. Este Dockerfile definirá as etapas para criar uma imagem baseada na imagem base ubuntu e instalar o pacote cowsay.
Use o editor nano para criar e editar o Dockerfile:
nano Dockerfile
Adicione o seguinte conteúdo ao Dockerfile:
FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello, Docker!"]
Vamos detalhar este Dockerfile:
FROM ubuntu:latest: Esta instrução especifica a imagem base para nossa nova imagem. Estamos usando a versão mais recente da imagem Ubuntu oficial do Docker Hub.RUN apt-get update && apt-get install -y cowsay: Esta instrução executa comandos em uma nova camada em cima da imagem atual e confirma os resultados. Aqui, atualizamos a lista de pacotes e instalamos o pacotecowsay. A flag-yresponde automaticamente sim aos prompts.CMD ["cowsay", "Hello, Docker!"]: Esta instrução fornece comandos padrão para um contêiner em execução. Quando um contêiner é iniciado a partir desta imagem sem especificar um comando, ele executarácowsay "Hello, Docker!".
Salve o arquivo pressionando Ctrl + X, depois Y e Enter.
Agora que temos nosso Dockerfile, podemos construir a imagem. Use o comando docker build. O . no final do comando diz ao Docker para procurar o Dockerfile no diretório atual (~/project). Também marcaremos a imagem com um nome, por exemplo, my-cowsay-image.
docker build -t my-cowsay-image .
Este comando executará as instruções no Dockerfile passo a passo. Você verá a saída indicando cada etapa sendo processada, incluindo o download da imagem base (se ainda não estiver presente) e a instalação do cowsay.
Após a conclusão do processo de construção, você pode verificar se a imagem foi criada com sucesso listando as imagens disponíveis usando o comando docker images:
docker images
Você deve ver my-cowsay-image listado na saída.
Finalmente, vamos executar um contêiner a partir da imagem que acabamos de construir para ver se ele funciona como esperado.
docker run my-cowsay-image
Este comando criará e iniciará um novo contêiner baseado em my-cowsay-image. Como definimos uma instrução CMD em nosso Dockerfile, o contêiner executará automaticamente cowsay "Hello, Docker!", e você deverá ver a vaca dizendo "Hello, Docker!" na saída do seu terminal.
Construir uma imagem com argumentos de construção e rótulos
Nesta etapa, você aprenderá como usar argumentos de construção (ARG) e rótulos (LABEL) em seu Dockerfile. Os argumentos de construção permitem que você passe variáveis para o processo de construção, tornando seu Dockerfile mais flexível. Os rótulos são pares chave-valor que você pode anexar a uma imagem para adicionar metadados.
Primeiro, certifique-se de estar no diretório ~/project:
cd ~/project
Agora, vamos modificar o Dockerfile que criamos na etapa anterior. Adicionaremos um argumento de construção para personalizar a mensagem exibida por cowsay e adicionaremos um rótulo à imagem.
Abra o Dockerfile para edição:
nano Dockerfile
Modifique o conteúdo para incluir instruções ARG e LABEL:
FROM ubuntu:latest
ARG MESSAGE="Hello, Docker!"
RUN apt-get update && apt-get install -y cowsay
LABEL maintainer="Your Name <your.email@example.com>"
CMD ["cowsay", "$MESSAGE"]
Vamos analisar as mudanças:
ARG MESSAGE="Hello, Docker!": Esta instrução define um argumento de construção chamadoMESSAGEcom um valor padrão de "Hello, Docker!". Este valor pode ser substituído durante o processo de construção.LABEL maintainer="Your Name <your.email@example.com>": Esta instrução adiciona um rótulo à imagem. Os rótulos são úteis para adicionar informações como o responsável pela manutenção (maintainer), versão ou quaisquer outros metadados relevantes.CMD ["cowsay", "$MESSAGE"]: Mudamos a instruçãoCMDpara usar o valor do argumento de construçãoMESSAGE.
Salve o Dockerfile modificado pressionando Ctrl + X, depois Y e Enter.
Agora, vamos construir a imagem novamente, mas desta vez passaremos um valor para o argumento de construção MESSAGE usando a flag --build-arg. Também daremos a ela uma nova tag, my-custom-cowsay-image.
docker build --build-arg MESSAGE="Building with arguments!" -t my-custom-cowsay-image .
Observe a saída durante o processo de construção. Você deve ver que a instrução ARG é processada e o valor de MESSAGE é definido como "Building with arguments!".
Após a conclusão da construção, vamos executar um contêiner a partir desta nova imagem:
docker run my-custom-cowsay-image
Desta vez, o contêiner deve gerar a mensagem personalizada "Building with arguments!".
Você também pode inspecionar a imagem para ver os rótulos que foram adicionados. Use o comando docker inspect seguido pelo nome da imagem:
docker inspect my-custom-cowsay-image
Na saída, procure a seção "Labels". Você deve encontrar o rótulo maintainer com o valor que você especificou no Dockerfile.
Construir uma imagem direcionada a uma plataforma específica e saída para um arquivo
Nesta etapa, você aprenderá como construir uma imagem Docker para uma plataforma específica e como gerar a imagem construída para um arquivo. Construir para diferentes plataformas é útil quando você precisa implantar seu aplicativo em sistemas com diferentes arquiteturas (por exemplo, ARM vs. x86). A saída para um arquivo permite que você salve a imagem como um arquivo tar, que pode ser facilmente transferido e carregado em outro ambiente Docker.
Primeiro, certifique-se de estar no diretório ~/project:
cd ~/project
Usaremos o mesmo Dockerfile da etapa anterior. Você pode visualizar seu conteúdo usando o comando cat:
cat Dockerfile
A saída deve ser:
FROM ubuntu:latest
ARG MESSAGE="Hello, Docker!"
RUN apt-get update && apt-get install -y cowsay
LABEL maintainer="Your Name <your.email@example.com>"
CMD ["cowsay", "$MESSAGE"]
Agora, vamos construir a imagem especificamente para a plataforma linux/arm64. Usaremos a flag --platform. Observe que a construção para uma plataforma diferente requer o Docker Buildx, que geralmente está incluído nas instalações recentes do Docker.
docker build --platform linux/arm64 -t my-arm64-cowsay-image .
Este comando construirá a imagem para a arquitetura ARM64. Você verá uma saída semelhante às construções anteriores, mas o processo de construção está direcionando uma arquitetura diferente.
Após a conclusão da construção, você pode listar suas imagens para ver a imagem recém-criada. Observe que a coluna ARCHITECTURE mostrará arm64 para esta imagem.
docker images
Em seguida, vamos gerar esta imagem para um arquivo tar. Isso é útil para salvar e compartilhar imagens sem usar um registro. Usaremos a flag --output com a opção type=tar.
docker build --platform linux/arm64 -t my-arm64-cowsay-image . --output type=tar,dest=my-arm64-cowsay-image.tar
Este comando constrói a imagem novamente (potencialmente usando o cache de construção) e, em seguida, a salva como um arquivo tar chamado my-arm64-cowsay-image.tar no diretório ~/project.
Você pode verificar se o arquivo tar foi criado usando o comando ls:
ls -lh my-arm64-cowsay-image.tar
Você deve ver o arquivo listado com seu tamanho. Este arquivo tar contém todas as camadas da my-arm64-cowsay-image. Você pode então transferir este arquivo para outra máquina e carregá-lo usando docker load -i my-arm64-cowsay-image.tar.
Construir uma imagem com controle de cache e exposição de segredos
Nesta etapa, você aprenderá sobre como controlar o cache de construção do Docker e como lidar com segredos durante o processo de construção usando o tipo de montagem secret do BuildKit. O cache de construção pode acelerar significativamente as construções, mas às vezes você precisa desativá-lo. Lidar com segredos de forma segura é crucial para evitar a incorporação de informações confidenciais nas camadas da sua imagem.
Primeiro, certifique-se de estar no diretório ~/project:
cd ~/project
Vamos modificar o Dockerfile para incluir uma etapa para a qual podemos querer controlar o cache e demonstrar o tratamento de segredos. Adicionaremos uma etapa simples de criação de arquivo e uma etapa que hipoteticamente usaria um segredo.
Abra o Dockerfile para edição:
nano Dockerfile
Modifique o conteúdo para incluir um comando RUN que cria um arquivo com um carimbo de data/hora e um espaço reservado para usar um segredo:
FROM ubuntu:latest
ARG MESSAGE="Hello, Docker!"
RUN apt-get update && apt-get install -y cowsay
LABEL maintainer="Your Name <your.email@example.com>"
RUN echo "Build time: $(date)" > /app/build_info.txt
## This is a placeholder for a command that would use a secret
## RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret > /app/secret_info.txt
CMD ["cowsay", "$MESSAGE"]
Adicionamos RUN echo "Build time: $(date)" > /app/build_info.txt. Este comando cria um arquivo /app/build_info.txt contendo o carimbo de data/hora de quando esta camada foi construída. Por padrão, o Docker armazena em cache as camadas. Se você construir a imagem várias vezes sem alterar as instruções antes deste comando RUN, esta camada poderá ser servida do cache e o carimbo de data/hora não será atualizado.
Salve o Dockerfile modificado pressionando Ctrl + X, depois Y e Enter.
Agora, vamos construir a imagem com uma nova tag, my-cached-image.
docker build -t my-cached-image .
Observe a saída. Se você construiu a imagem recentemente, poderá ver ---> Using cache para algumas etapas.
Para demonstrar o controle de cache, vamos construir a imagem novamente, mas desta vez desativaremos o cache para toda a construção usando a flag --no-cache.
docker build --no-cache -t my-no-cache-image .
Você verá que o Docker reconstrói cada camada, mesmo que as instruções não tenham sido alteradas. Isso é útil quando você deseja garantir que todas as dependências sejam buscadas novamente ou quando uma construção anterior falhou de uma forma que corrompeu o cache.
Agora, vamos discutir o tratamento de segredos. A linha comentada ## RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret > /app/secret_info.txt demonstra como você usaria um segredo com o BuildKit. Para usar isso, você precisaria habilitar o BuildKit (que geralmente é habilitado por padrão nas versões recentes do Docker) e fornecer o segredo durante a construção usando a flag --secret.
Por exemplo, se você tivesse um arquivo chamado mysecret.txt contendo seu segredo, você construiria assim (este comando não funcionará como está porque não temos um arquivo mysecret.txt e a linha está comentada, mas mostra a sintaxe):
## docker build --secret id=mysecret,src=mysecret.txt -t my-secret-image .
A instrução RUN --mount=type=secret,id=mysecret torna o conteúdo do segredo disponível em /run/secrets/mysecret apenas durante a etapa de construção. O segredo não está incluído nas camadas finais da imagem. Esta é a maneira segura de lidar com informações confidenciais, como chaves de API ou senhas, durante as construções.
Como não temos um arquivo secreto e a linha está comentada, não executaremos o comando de construção relacionado ao segredo. No entanto, entender o conceito de --no-cache e o tipo de montagem secret é importante para controlar suas construções e lidar com dados confidenciais.
Resumo
Neste laboratório, você aprendeu os fundamentos da construção de imagens Docker usando um Dockerfile. Você começou criando um Dockerfile simples baseado no Ubuntu, instalando um pacote e definindo um comando padrão. Isso apresentou a você as instruções principais FROM, RUN e CMD, e como construir uma imagem usando docker build com uma tag.
Com base nos conceitos básicos, você explorou técnicas de construção de imagens mais avançadas. Você aprendeu como incorporar argumentos de construção e rótulos em seu Dockerfile para personalizar o processo de construção e adicionar metadados à imagem. Você também praticou a construção de imagens para plataformas específicas e a saída da imagem resultante para um arquivo, demonstrando como controlar a saída da construção. Por fim, você se aprofundou no gerenciamento do cache de construção e no tratamento seguro de segredos durante o processo de construção, destacando as melhores práticas para a criação de imagens eficiente e segura.
