COPY --link é um novo recurso do BuildKit que pode acelerar substancialmente as compilações de imagens do Docker. Ele funciona copiando arquivos em camadas de imagem independentes que não dependem da presença de seus predecessores. Você pode adicionar novo conteúdo a imagens sem que a imagem base exista em seu sistema.
Esse recurso foi adicionado como parte do Buildx v0.8 em março de 2022. Ele está incluído na versão 20.10.14 da CLI do Docker, portanto, você já deve ter acesso se estiver executando a versão mais recente.
Neste artigo, mostraremos o que --link faz e explica como funciona. Veremos também algumas das situações em que não deveria ser usado.
O que é “–hyperlink”?
--link é um novo argumento opcional para o Dockerfile existente COPY instrução. Ele altera a maneira como as cópias funcionam criando uma nova camada de instantâneo cada vez que você a u.s..
Common COPY instruções adicionam arquivos à camada que os precede no Dockerfile. O conteúdo dessa camada precisa existir em seu disco para que o novo conteúdo possa ser mesclado em:
FROM alpine COPY my-file /my-file COPY another-file /another-file
O Dockerfile acima copia my-file na camada produzida pelo comando anterior. Depois de FROM instrução, a imagem consiste no conteúdo da Alpine:
bin/ dev/ and many others/ ...
O primeiro COPY instrução produz uma imagem que inclui tudo da Alpine, bem como o my-file Arquivo:
my-file bin/ dev/ and many others/ ...
E o segundo COPY instrução adiciona another-file em cima desta imagem:
another-file my-file bin/ dev/ and many others/ ...
A camada produzida por cada instrução inclui tudo o que veio antes dela, bem como qualquer coisa recém-adicionada. No ultimate da compilação, o Docker u.s. um processo de diferenciação para descobrir as alterações em cada camada. O blob de imagem ultimate contém apenas os arquivos que foram adicionados em cada estágio de instantâneo, mas isso não é refletido no processo de montagem durante a compilação.
Apresentando “–hyperlink”
“–hyperlink” modifica COPY para criar um novo sistema de arquivos autônomo toda vez que for usado. Em vez de copiar os novos arquivos no topo da camada anterior, eles são enviados para um native completamente diferente para se tornarem uma camada independente. As camadas são posteriormente vinculadas para produzir a imagem ultimate.
Vamos alterar o Dockerfile de exemplo para usar --link:
FROM alpine COPY --link my-file /my-file COPY --link another-file /another-file
O resultado da FROM A instrução permanece inalterada – ela produz a camada Alpine, com todo o conteúdo dessa imagem:
bin/ dev/ and many others/ ...
O primeiro COPY instrução tem um efeito visivelmente diferente. Desta vez, outra camada independente é criada. É um novo sistema de arquivos contendo apenas my-file:
my-file
Então o segundo COPY instrução cria outro novo instantâneo com apenas another-file:
another-file
Quando a compilação é concluída, o Docker armazena esses instantâneos independentes como novos arquivos de camada (tarballs). Os tarballs são ligados de volta à cadeia de camadas anteriores, construindo a imagem ultimate. Isso consiste em todos os três instantâneos mesclados, resultando em um sistema de arquivos que corresponde ao unique quando os contêineres são criados:
my-file another-file bin/ dev/ and many others/ ...
Esta imagem do projeto BuildKit ilustra as diferenças entre as duas abordagens.
Adicionando “COPY –hyperlink” às suas compilações
COPY --link só está disponível quando você está usando o BuildKit para criar suas imagens. Ou execute sua compilação com docker buildx --create ou usar docker construct com o DOCKER_BUILDKIT=1 conjunto de variáveis de ambiente.
Você também deve optar pela sintaxe do Dockerfile v1.4 usando um comentário na parte awesome do arquivo:
# syntax=docker/dockerfile:1.4 FROM alpine:newest COPY --link my-file /my-file COPY --link another-file /another-file
Agora você pode construir sua imagem com suporte para cópias vinculadas:
DOCKER_BUILDKIT=1 docker construct -t my-image:newest .
Imagens criadas a partir de Dockerfiles usando COPY --link pode ser usado como qualquer outro. Você pode iniciar um contêiner com docker run e empurre-os diretamente para os registros. o --link sinalizador afeta apenas como o conteúdo é adicionado às camadas da imagem durante a construção.
Por que as cópias vinculadas são importantes
Usando o --link sinalizador permite que os caches de compilação sejam reutilizados mesmo quando o conteúdo COPY em mudanças. Além disso, as compilações podem ser concluídas sem que a imagem de base exista em sua máquina.
Voltando ao exemplo acima, padrão COPY comportamento requer o alpine imagem exista em seu host do Docker antes que o novo conteúdo possa ser adicionado. A imagem será baixada automaticamente durante a compilação se você não a tiver puxado anteriormente.
Com cópias vinculadas, o Docker não precisa do alpine conteúdo da imagem. Ele puxa o alpine manifest, cria novas camadas independentes para os arquivos copiados e, em seguida, cria um manifesto revisado que vincula as camadas às fornecidas por alpine. O conteúdo do alpine picture – seus blobs de camada – só serão baixados se você iniciar um contêiner de sua nova imagem ou exportá-lo para um arquivo tar. Quando você envia a imagem para um registro, esse registro armazenará suas novas camadas e adquirirá remotamente a alpine uns.
Essa funcionalidade também facilita rebases de imagem eficientes. Talvez você esteja atualmente distribuindo uma imagem do Docker usando a versão mais recente do Ubuntu 20.04 LTS:
FROM golang AS construct ... RUN move construct -o /app . FROM ubuntu:20.04 COPY --link --from=construct /app /bin/app ENTRYPOINT ["/bin/app"]
Você pode construir a imagem com o cache habilitado usando o BuildKit’s --cache-to bandeira. o inline cache armazena dados de cache de compilação dentro da imagem de saída, onde podem ser reutilizados em compilações subsequentes:
docker buildx construct --cache-to sort=inline -t example-image:20.04 .
Agora, digamos que você gostaria de fornecer uma imagem baseada no próximo LTS após seu lançamento, o Ubuntu 22.04:
FROM golang AS construct ... RUN move construct -o /app . FROM ubuntu:22.04 COPY --link --from=construct /app /bin/app ENTRYPOINT ["/bin/app"]
Reconstrua a imagem usando os dados de cache incorporados na versão unique:
docker buildx construct --cache-from example-image:20.04 -t example-image:22.04 .
A compilação será concluída quase instantaneamente. Usando os dados em cache da imagem existente, o Docker pode verificar os arquivos necessários para construir /app não mudaram. Isso significa que o cache para a camada independente criada pelo COPY instrução permanece válida. Como essa camada não depende de nenhuma outra, o ubuntu:22.04 a imagem também não será puxada. O Docker apenas vincula a camada de instantâneo que contém /bin/app em um novo manifesto dentro do ubuntu:22.04 cadeia de camadas. A camada de instantâneo é efetivamente “rebaseada” em uma nova imagem pai, sem que ocorra nenhuma operação do sistema de arquivos.
O modelo também otimiza compilações de vários estágios, onde podem ocorrer alterações entre qualquer um dos estágios:
FROM golang AS construct RUN move construct -o /app . FROM config-builder AS config RUN generate-config --out /config.yaml FROM ubuntu:newest COPY --link --from=config /config.yaml construct.conf COPY --link --from=construct /app /bin/app
Sem --linkqualquer alteração na geração config.yaml causas ubuntu:newest a ser puxado e o arquivo a ser copiado. O binário então precisa ser recompilado, pois seu cache é invalidado pelas alterações no sistema de arquivos. Com cópias vinculadas, uma alteração config.yaml permite que a compilação proceed sem puxar ubuntu:newest ou recompilar o binário. A camada de instantâneo com construct.conf within é simplesmente substituído por uma nova versão que é independente de todas as outras camadas.
Quando não usar
Existem algumas situações em que o --link sinalizador não funcionará corretamente. Como ele copia os arquivos em uma nova camada, em vez de adicioná-los em cima da anterior, você não pode usar referências ambíguas como seu caminho de destino:
COPY --link my-file /knowledge
Com um common COPY instrução, my-file será copiado para /knowledge/my-file E se /knowledge já existe como um diretório na imagem. Com --linko sistema de arquivos da camada de destino sempre estará vazio, então my-file é escrito para /knowledge.
A mesma consideração se aplica à resolução de hyperlinks simbólicos. Padrão COPY get to the bottom of automaticamente os caminhos de destino que são hyperlinks simbólicos na imagem. Quando você está usando --linkesse comportamento não é suportado, pois o hyperlink simbólico não existirá na camada independente da cópia.
É recomendável que você comece a usar --link onde essas limitações não se aplicam. Adotar esse recurso acelerará suas compilações e tornará o cache mais poderoso. Se você não puder remover imediatamente os caminhos de destino ambíguos ou com hyperlinks simbólicos, poderá continuar usando o COPY instrução. É devido a essas mudanças incompatíveis com versões anteriores que --link é um sinalizador opcional, em vez do novo padrão.
Resumo
BuildKit’s COPY --link é um novo recurso do Dockerfile que pode tornar as compilações mais rápidas e eficientes. Imagens usando cópias vinculadas não precisam puxar camadas anteriores apenas para que os arquivos possam ser copiados para elas. O Docker cria uma nova camada independente para cada COPY em vez disso, liga essas camadas de volta à cadeia.
Você pode começar a usar cópias vinculadas agora se estiver criando imagens com o BuildKit e a versão mais recente do Buildx ou Docker CLI. Adotar “–hyperlink” é uma nova etapa de criação do Docker de prática recomendada, desde que você não seja afetado pelas alterações necessárias à resolução do caminho de destino.
Fonte da Notícia: www.howtogeek.com
