O que são compilações do Docker em vários estágios?

As compilações de vários estágios do Docker permitem que você escreva Dockerfiles com várias instruções FROM. Isso significa que você pode criar imagens derivadas de várias bases, o que pode ajudar a reduzir o tamanho de sua construção final.

As imagens do Docker são criadas selecionando uma imagem de base usando a instrução FROM. Em seguida, você adiciona camadas a essa imagem adicionando comandos ao Dockerfile.

Com compilações de vários estágios, você pode dividir seu Dockerfile em várias seções. Cada estágio tem sua própria instrução FROM para que você possa envolver mais de uma imagem em suas compilações. Os estágios são construídos sequencialmente e podem fazer referência a seus predecessores, portanto, você pode copiar a saída de uma camada para a próxima.

Construções de vários estágios em ação

Vamos ver como você pode criar uma construção de vários estágios. Estamos trabalhando com um projeto básico de PHP que usa o Composer para suas dependências e o Sass para suas folhas de estilo.

Aqui está um Dockerfile de vários estágios que encapsula toda a nossa construção:

FROM node: 14 AS sass WORKDIR / example RUN npm install -g node-sass COPY example. scss. EXECUTE node-sass example. scss example. css   FROM php: 8.0-apache COPY --from = composer: 2 / usr / bin / composer / usr / bin / composer COPY composer. json. COPY composer. lock. RUN composer install --no-dev COPY --from = sass /example/example. css example. css COPY index. php. COPIAR src / src

Imediatamente, você observará que temos duas instruções FROM que dividem nosso Dockerfile em duas seções lógicas. A primeira etapa é dedicada à compilação do Sass, enquanto a segunda se concentra em combinar tudo no contêiner final.

Estamos usando a implementação node-sass do Sass. Portanto, começamos com uma imagem de base Node. JS, na qual instalamos o node-sass globalmente a partir do npm. Em seguida, usamos node-sass para compilar nossa folha de estilo example. scss no CSS example. css puro. O resumo de alto nível deste estágio é que pegamos uma imagem de base, executamos um comando e obtemos uma saída que gostaríamos de usar posteriormente em nossa construção (example. css).

O próximo estágio apresenta a imagem base do nosso aplicativo: php8.0-apache. A última instrução FROM em seu Dockerfile define a imagem que seus contêineres acabarão executando. Nossa imagem de nó anterior é irrelevante para os contêineres de nosso aplicativo – ele é usado puramente como uma ferramenta de conveniência de tempo de construção.

Em seguida, usaremos o Composer para instalar nossas dependências do PHP. O Composer é o gerenciador de pacotes do PHP, mas não está incluído nas imagens oficiais do Docker do PHP. Portanto, copiamos o binário em nosso contêiner a partir da imagem dedicada do Composer.

Não precisamos de uma instrução FROM para fazer isso. Como não estamos executando nenhum comando na imagem do Composer, podemos usar o sinalizador --from com COPY para fazer referência à imagem. Normalmente, o COPY copia arquivos do contexto local de construção para a imagem; com --from e um nome de imagem, ele &’ criará um novo contêiner usando essa imagem e, em seguida, copiará o arquivo especificado dele.

Mais tarde, nosso Dockerfile usa COPY - de novo, desta vez em uma forma diferente. De volta ao início, escrevemos nossa primeira instrução FROM como nó FROM: 14 AS sass. A cláusula AS criou um estágio nomeado chamado sass.

Agora fazemos referência ao contêiner transiente criado por este estágio usando COPY --from = sass. Isso nos permite copiar nosso CSS embutido em nossa imagem final. O restante das etapas são operações COPY de rotina, usadas para obter nosso código-fonte em nosso diretório de trabalho local.

Vantagens de construções em vários estágios

Compilações em vários estágios permitem criar rotinas de compilação complexas com um único Dockerfile. Antes de sua introdução, era comum que projetos complexos usassem vários Dockerfiles, um para cada estágio de sua construção. Em seguida, eles precisavam ser orquestrados por scripts de shell escritos manualmente.

Com compilações de vários estágios, todo o nosso sistema de compilação pode estar contido em um único arquivo. Você não precisa de nenhum script de wrapper para levar seu projeto da base de código bruta à imagem final do aplicativo. Uma compilação docker regular -t my-image: latest. é suficiente.

Essa simplificação também oferece oportunidades para melhorar a eficiência de suas imagens. As imagens do Docker podem ficar grandes, especialmente se você estiver usando um runtime de linguagem como base.

Pegue a imagem oficial do golang: ela está perto de 300 MB. Tradicionalmente, você pode copiar seu código-fonte Go na imagem e usá-lo para compilar seu binário. Em seguida, você copia seu binário de volta para sua máquina host antes de iniciar outra compilação. Este usaria um Dockerfile com uma imagem base leve, como alpina (cerca de 10 MB). Você adicionaria seu binário novamente, resultando em uma imagem muito menor do que se usasse a base de golang original para executar seus contêineres.

Com compilações de vários estágios, este tipo de sistema é muito mais fácil de implementar:

DE golang: mais recente WORKDIR / go COPY app. go. EXECUTE, vá construir -o meu-binário   DE alpine: mais recente WORKDIR / app COPY --from = build / go / my-binary. CMD [" ./ meu-binário "]

Em oito linhas, conseguimos realizar um procedimento que anteriormente precisaria de pelo menos três arquivos – um Dockerfile golang, um Dockerfile alpino e um script de shell para gerenciar as etapas intermediárias.

Conclusão

Compilações em vários estágios podem simplificar drasticamente a construção de imagens complexas do Docker. Eles permitem que você envolva várias etapas de construção interconectadas que podem transmitir os artefatos de saída.

O modelo também promove a eficiência de construção. A facilidade com que você pode fazer referência a diferentes imagens de base ajuda os desenvolvedores a garantir que a saída final seja a menor possível. Você se beneficiará de custos reduzidos de armazenamento e largura de banda, que podem ser significativos ao usar o Docker em um sistema CI / CD.