Introdução
Neste laboratório, você aprenderá como usar o comando docker buildx history import para importar o histórico de construção (build history). Começaremos criando um Dockerfile simples que constrói uma imagem baseada em Ubuntu e instala o pacote curl.
Após a criação do Dockerfile, você construirá a imagem e exportará seu histórico de construção. Finalmente, você importará este histórico de construção no Docker Desktop e verificará se o histórico foi importado com sucesso. Este exercício prático demonstrará a aplicação prática da importação do histórico de construção para melhor rastreabilidade e depuração de suas construções Docker.
Criar um Dockerfile de exemplo
Nesta etapa, criaremos um Dockerfile simples. 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.
Criaremos um Dockerfile que constrói uma imagem baseada na imagem Ubuntu mais recente e instala o pacote curl.
Primeiro, navegue até o diretório ~/project se você ainda não estiver lá.
cd ~/project
Agora, crie um novo arquivo chamado Dockerfile no diretório ~/project usando o editor nano.
nano Dockerfile
Dentro do editor nano, adicione o seguinte conteúdo ao Dockerfile:
FROM ubuntu:latest
RUN apt-get update && apt-get install -y curl
Vamos detalhar as instruções neste 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 curl: Esta instrução executa comandos em uma nova camada (layer) sobre a imagem atual e commita os resultados. Aqui, estamos atualizando a lista de pacotes e instalando o pacotecurlusando o gerenciador de pacotesapt-get. A flag-yresponde automaticamente sim a quaisquer prompts durante a instalação.
Após adicionar o conteúdo, salve o arquivo e saia do nano pressionando Ctrl + X, depois Y para confirmar o salvamento e Enter para confirmar o nome do arquivo.
Você pode verificar o conteúdo do Dockerfile usando o comando cat:
cat Dockerfile
A saída deve mostrar o conteúdo que você acabou de adicionar ao arquivo.
Construir uma imagem e exportar o histórico de construção
Nesta etapa, construiremos uma imagem Docker a partir do Dockerfile que criamos na etapa anterior e, em seguida, exportaremos o histórico de construção (build history) desta imagem.
Primeiro, certifique-se de estar no diretório ~/project onde seu Dockerfile está localizado.
cd ~/project
Agora, vamos construir a imagem Docker usando o comando docker build. Marcaremos a imagem com o nome my-ubuntu-curl e a tag latest. O . no final do comando diz ao Docker para procurar o Dockerfile no diretório atual.
docker build -t my-ubuntu-curl:latest .
Você verá uma saída indicando o processo de construção, incluindo o download da imagem base e a execução do comando apt-get. Este processo pode levar alguns minutos, dependendo da sua conexão com a internet.
Assim que a construção for concluída, você pode verificar se a imagem foi criada listando suas imagens Docker locais:
docker images
Você deve ver my-ubuntu-curl na lista de imagens.
Agora, exportaremos o histórico de construção desta imagem. O histórico de construção mostra as camadas (layers) que compõem a imagem e os comandos usados para criar cada camada. Podemos exportar este histórico para um arquivo usando o comando docker history e redirecionando a saída para um arquivo.
Vamos exportar o histórico para um arquivo chamado build_history.txt no diretório ~/project.
docker history my-ubuntu-curl:latest > build_history.txt
Este comando pega a saída de docker history my-ubuntu-curl:latest e a escreve no arquivo build_history.txt.
Você pode visualizar o conteúdo do arquivo de histórico exportado usando o comando cat:
cat build_history.txt
A saída mostrará uma tabela com informações sobre cada camada na imagem, incluindo o ID da camada, tempo de criação, tamanho e o comando usado para criá-la.
Importar o histórico de construção no Docker Desktop
Nesta etapa, simularemos a importação do histórico de construção que exportamos na etapa anterior no Docker Desktop. Embora não possamos interagir diretamente com uma instância gráfica do Docker Desktop neste ambiente de terminal, podemos demonstrar o conceito e o processo de transferência de arquivos.
Em um cenário real, após exportar o arquivo build_history.txt do seu ambiente de construção (como esta VM LabEx), você normalmente transferiria este arquivo para a máquina onde o Docker Desktop está instalado. Métodos comuns para transferir arquivos incluem o uso de scp, sftp ou serviços de armazenamento em nuvem.
Para o propósito deste laboratório, assumiremos que você transferiu o arquivo build_history.txt para sua máquina local onde o Docker Desktop está sendo executado.
Depois que o arquivo estiver em sua máquina local, você abriria o Docker Desktop. O Docker Desktop fornece uma interface gráfica para gerenciar suas imagens, contêineres e volumes Docker. Embora não haja um botão direto "importar histórico de construção" no Docker Desktop que leia este formato de arquivo de texto específico, as informações dentro de build_history.txt são valiosas para entender como uma imagem foi construída.
Os desenvolvedores geralmente usam este histórico de construção para:
- Entender as camadas (layers) de uma imagem.
- Depurar problemas com as construções de imagens.
- Recriar o processo de construção em uma máquina diferente.
- Documentar o processo de criação da imagem.
Para simular a "importação" e tornar o histórico de construção acessível para a próxima etapa de verificação, simplesmente garantiremos que o arquivo build_history.txt esteja presente no diretório ~/project, como se estivesse pronto para ser examinado ou usado por uma ferramenta que pudesse analisá-lo.
Você pode confirmar que o arquivo ainda está no diretório ~/project:
ls ~/project/build_history.txt
Se o arquivo existir, o comando exibirá seu caminho. Se não existir, você poderá ver uma mensagem de erro.
Em um ambiente real do Docker Desktop, você normalmente usaria a interface gráfica para inspecionar imagens e suas camadas, o que fornece uma visão semelhante às informações em build_history.txt. Algumas ferramentas ou scripts avançados também podem ser usados para analisar e visualizar esses dados de histórico.
Como estamos em um ambiente de terminal, a presença do arquivo build_history.txt no local esperado significa a conclusão do objetivo desta etapa dentro do contexto do laboratório.
Verificar o histórico de construção importado
Nesta etapa final, verificaremos o conteúdo do arquivo de histórico de construção que "importamos" (garantindo sua presença) na etapa anterior. Isso simula o processo de examinar o histórico de construção dentro de um ambiente Docker Desktop ou usando ferramentas para analisar o histórico exportado.
Usaremos ferramentas simples de linha de comando para verificar se o arquivo build_history.txt contém as informações esperadas, procurando especificamente evidências da imagem base ubuntu e do comando de instalação curl.
Primeiro, certifique-se de estar no diretório ~/project.
cd ~/project
Agora, vamos usar o comando grep para pesquisar as informações da imagem base no arquivo build_history.txt. Esperamos ver uma linha indicando o uso da imagem ubuntu.
grep "ubuntu" ~/project/build_history.txt
A saída deve mostrar uma linha contendo "ubuntu", provavelmente relacionada à instrução inicial FROM ubuntu:latest em seu Dockerfile.
Em seguida, vamos pesquisar o comando que instalou o curl. Esperamos ver uma linha contendo "apt-get install -y curl".
grep "apt-get install -y curl" ~/project/build_history.txt
A saída deve mostrar uma linha contendo o comando usado para instalar o curl.
Esses comandos grep demonstram como você pode verificar programaticamente aspectos do histórico de construção. Em um ambiente real do Docker Desktop, você inspecionaria visualmente as camadas e seus comandos associados através da interface gráfica.
Encontrar com sucesso essas informações-chave no arquivo build_history.txt confirma que o histórico de construção foi exportado corretamente e está disponível para inspeção, completando o objetivo deste laboratório.
Resumo
Neste laboratório, aprendemos como usar o comando docker buildx history import para gerenciar o histórico de construção do Docker. Começamos criando um Dockerfile simples baseado no Ubuntu e instalando o pacote curl. Isso demonstrou o processo fundamental de definir as camadas e instruções de uma imagem.
Após a criação do Dockerfile, prosseguimos para construir a imagem e exportar seu histórico de construção. Esta etapa é crucial para entender como capturar e preservar as informações detalhadas sobre o processo de construção da imagem. Finalmente, importamos este histórico de construção exportado no Docker Desktop e verificamos se o histórico foi integrado com sucesso, demonstrando a aplicação prática do comando buildx history import para compartilhar ou migrar informações de construção.
