Introdução
Neste laboratório, você aprenderá como construir e gerenciar imagens Docker de múltiplas arquiteturas usando o comando docker manifest create. Imagens de múltiplas arquiteturas são essenciais para implantar aplicações em diversos ambientes com diferentes arquiteturas de CPU, como amd64 e arm64.
O laboratório irá guiá-lo através do processo de preparação de imagens de múltiplas arquiteturas, habilitando recursos experimentais e criando uma instância de construtor de múltiplas arquiteturas. Em seguida, você criará uma lista de manifestos que agrupa essas imagens, inspecionará a lista de manifestos criada para verificar seu conteúdo e, finalmente, enviará a lista de manifestos para um registro, tornando sua imagem de múltiplas arquiteturas disponível para implantação em várias plataformas.
Preparar imagens de múltiplas arquiteturas
Nesta etapa, prepararemos imagens de múltiplas arquiteturas. Imagens de múltiplas arquiteturas permitem que você construa e envie imagens que podem ser executadas em diferentes arquiteturas, como amd64 e arm64. Isso é útil para implantar aplicações em vários ambientes, incluindo servidores em nuvem, dispositivos de borda e máquinas locais.
Primeiro, precisamos habilitar os recursos experimentais no Docker. Isso nos permite usar o comando buildx, que é necessário para construir imagens de múltiplas arquiteturas. Podemos fazer isso criando ou modificando o arquivo de configuração do Docker.
Abra o arquivo de configuração do Docker usando nano:
nano ~/.docker/config.json
Se o arquivo não existir, nano o criará. Adicione o seguinte conteúdo ao arquivo. Se o arquivo já existir, adicione a linha "experimental": "enabled" dentro do objeto JSON principal.
{
"experimental": "enabled"
}
Salve o arquivo pressionando Ctrl + X, depois Y e Enter.
Em seguida, precisamos criar uma nova instância de construtor que suporte múltiplas arquiteturas. Uma instância de construtor é um componente do Docker que gerencia o processo de construção.
Crie uma nova instância de construtor chamada mybuilder:
docker buildx create --name mybuilder --use
Este comando cria uma nova instância de construtor chamada mybuilder e a define como o construtor padrão para operações de construção subsequentes. A saída deve indicar que o construtor foi criado e está sendo usado.
Agora, vamos construir uma imagem simples de múltiplas arquiteturas. Usaremos um Dockerfile básico que cria uma imagem baseada no Alpine Linux.
Crie um diretório para nosso projeto e navegue até ele:
mkdir ~/project/multiarch-demo
cd ~/project/multiarch-demo
Crie um Dockerfile neste diretório:
nano Dockerfile
Adicione o seguinte conteúdo ao Dockerfile:
FROM alpine:latest
CMD ["echo", "Hello from multi-architecture image!"]
Salve o Dockerfile pressionando Ctrl + X, depois Y e Enter.
Agora, construa a imagem para as arquiteturas linux/amd64 e linux/arm64 e envie-a para um registro fictício. Usaremos localhost:5000 como um espaço reservado para o registro. Em um cenário real, você substituiria isso pelo endereço real do seu registro.
Construa e envie a imagem de múltiplas arquiteturas:
docker buildx build --platform linux/amd64,linux/arm64 -t localhost:5000/multiarch-demo:latest --push .
Este comando constrói a imagem para as plataformas especificadas (linux/amd64 e linux/arm64), a marca como localhost:5000/multiarch-demo:latest e a envia para o registro localhost:5000. A saída mostrará o processo de construção para cada arquitetura e a operação de envio.
Criar uma lista de manifestos para as imagens
Nesta etapa, criaremos uma lista de manifestos para as imagens de múltiplas arquiteturas que construímos na etapa anterior. Uma lista de manifestos é uma lista de manifestos de imagem, cada um para uma arquitetura diferente. Quando você puxa uma imagem usando uma lista de manifestos, o Docker seleciona automaticamente a imagem correta para sua arquitetura.
Usaremos o comando docker manifest create para criar a lista de manifestos. Este comando recebe o nome da lista de manifestos que você deseja criar, seguido pelos nomes das imagens que você deseja incluir na lista.
Crie uma lista de manifestos chamada localhost:5000/multiarch-demo:latest:
docker manifest create localhost:5000/multiarch-demo:latest \
localhost:5000/multiarch-demo:latest@sha256:$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | head -n 1) \
localhost:5000/multiarch-demo:latest@sha256:$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | tail -n 1)
Vamos detalhar este comando:
docker manifest create localhost:5000/multiarch-demo:latest: Isso especifica o nome da lista de manifestos que estamos criando.localhost:5000/multiarch-demo:latest@sha256:...: Estas são as imagens que estamos adicionando à lista de manifestos. Estamos usando o nome da imagem seguido por@sha256:e o digest (resumo) da imagem. O digest identifica exclusivamente uma camada de imagem específica.$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | head -n 1): Esta cadeia de comandos recupera o digest da primeira imagem listada pordocker buildx imagetools inspect.$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | tail -n 1): Esta cadeia de comandos recupera o digest da segunda imagem listada pordocker buildx imagetools inspect.
A saída do comando docker manifest create será o digest da lista de manifestos recém-criada.
Inspecionar a lista de manifestos criada
Nesta etapa, inspecionaremos a lista de manifestos que criamos na etapa anterior. Inspecionar a lista de manifestos nos permite ver quais imagens estão incluídas na lista e seus detalhes, como arquitetura e sistema operacional.
Usaremos o comando docker manifest inspect para visualizar os detalhes da lista de manifestos.
Inspecione a lista de manifestos localhost:5000/multiarch-demo:latest:
docker manifest inspect localhost:5000/multiarch-demo:latest
A saída deste comando será um documento JSON que descreve a lista de manifestos. Você deve ver um array de "manifests" (manifestos), cada um representando uma imagem para uma arquitetura diferente. Procure o campo "platform" dentro de cada entrada de manifesto para ver a arquitetura e o sistema operacional. Você deve ver entradas para linux/amd64 e linux/arm64.
Esta inspeção confirma que nossa lista de manifestos inclui corretamente as imagens para as diferentes arquiteturas que construímos.
Enviar a lista de manifestos para um registro
Nesta etapa, enviaremos a lista de manifestos que criamos para um registro. Enviar a lista de manifestos a torna disponível para que outros possam puxar a imagem de múltiplas arquiteturas. Quando alguém puxa a imagem usando a tag da lista de manifestos, o Docker fará o download automaticamente da imagem correta para a arquitetura do seu sistema.
Usaremos o comando docker manifest push para enviar a lista de manifestos.
Envie a lista de manifestos localhost:5000/multiarch-demo:latest para o registro:
docker manifest push localhost:5000/multiarch-demo:latest
Este comando envia a lista de manifestos e todas as imagens que ela referencia para o registro especificado (localhost:5000). Como já enviamos as imagens individuais na primeira etapa usando docker buildx build --push, este comando envia principalmente a própria lista de manifestos.
A saída mostrará o progresso do envio da lista de manifestos.
Após enviar a lista de manifestos, você pode verificar se ela está disponível no registro. Embora não tenhamos um registro em execução neste ambiente de laboratório para consultar diretamente, a execução bem-sucedida do comando docker manifest push indica que a lista de manifestos foi preparada para envio.
Para simular a puxada da imagem de múltiplas arquiteturas e verificar se o Docker seleciona a arquitetura correta, você pode tentar puxar a imagem em um sistema com uma arquitetura diferente (se disponível). No entanto, dentro deste ambiente de laboratório, podemos confiar no comando de envio bem-sucedido e na etapa de inspeção anterior para confirmar que a lista de manifestos está pronta.
Resumo
Neste laboratório, aprendemos como preparar imagens de múltiplas arquiteturas usando o Docker. Isso envolve habilitar recursos experimentais no Docker para utilizar o comando buildx, que é essencial para construir imagens compatíveis com diferentes arquiteturas como amd64 e arm64. Configuramos o cliente Docker modificando o arquivo config.json para habilitar recursos experimentais. Em seguida, criamos uma nova instância de builder chamada mybuilder usando docker buildx create --name mybuilder --use, que é capaz de gerenciar construções de múltiplas arquiteturas. Finalmente, configuramos um diretório de projeto básico e criamos um Dockerfile simples baseado no Alpine Linux como base para construir nossa imagem de múltiplas arquiteturas.
