Otimizando imagens do Docker

Desenvolvedores gostam de trabalhar com o Docker por sua flexibilidade e facilidade de uso. Ao criar aplicativos, vale a pena investir o tempo extra otimizando imagens do Docker e Dockerfiles. A otimização ajudará as equipes a compartilhar imagens menores, melhorar o desempenho e facilitar a depuração de problemas. Abaixo estão algumas recomendações para criar imagens e dockerfiles melhores.

Otimizando imagens do Docker

Imagens grandes do Docker podem dificultar o compartilhamento. Além disso, imagens grandes diminuem a execução. Portanto, otimizar as imagens pode ajudar com o processo geral de desenvolvimento e produção.

Selecione imagens base adequadas

As imagens disponíveis no Docker Hub já estão otimizadas. Em vez de construir o seu próprio, é uma boa ideia usar as imagens otimizadas disponíveis. Por exemplo, se você precisar de uma imagem Redis, você terá a opção de construí -la em uma imagem do Ubuntu ou baixar diretamente o Redis One. Usar a imagem Redis já construída é uma opção melhor, porque os desenvolvedores já cuidaram de quaisquer pacotes redundantes.

Use construções de vários estágios

A nova opção de vários estágios no Docker (desde a versão 17.05) pode ajudá -lo a criar maneiras inteligentes de otimizar suas imagens. Você pode criar um aplicativo e depois transferi -lo para um novo ambiente limpo para implantar. Ele garantirá que apenas as bibliotecas e dependências de tempo de execução necessárias façam parte da imagem final.

Reduza o número de camadas

Ao construir uma imagem, preste atenção às camadas criadas por Dockerfiles. Cada comando run cria uma nova camada. Portanto, a combinação das camadas pode reduzir o tamanho da imagem. Um exemplo simples é o apt-get. Geralmente, os usuários executam o comando assim:

Isso criará duas camadas. Mas a combinação dos comandos criará uma única camada na imagem final:

Portanto, combinações inteligentes de comandos podem levar a imagens menores.

Construir imagens base personalizadas

Docker cache imagens. Se você precisar de várias instâncias das mesmas camadas, é uma boa ideia olhar para otimizar as camadas e criar uma imagem base personalizada. Ele acelerará os tempos de carregamento e facilitará o rastreamento.

Construa imagens em cima da produção

As imagens de teste requerem mais ferramentas e bibliotecas para testar os recursos. É uma boa ideia usar a imagem de produção como base e criar imagens de teste em cima dela. Os arquivos de teste desnecessários estarão fora da base. Portanto, as imagens de produção permanecerão pequenas e limpas para implantação.

Evite armazenar dados de aplicativos

O armazenamento de dados do aplicativo no contêiner aumentará suas imagens. Para ambientes de produção, sempre use o recurso de volume para manter o contêiner separado dos dados.

Melhores práticas para escrever doces

Dockerfiles permitem que os desenvolvedores codificam processos. Então, é uma ótima ferramenta para melhorar o processo de criação de imagens do Docker. Aqui estão algumas práticas que ajudarão você a melhorar seu desenvolvimento.

Design Recipientes efêmeros

Tente projetar recipientes que sejam fáceis de criar e destruir. Se os contêineres dependem demais de ambientes e configurações periféricas, eles são mais difíceis de manter. Portanto, projetar contêineres sem estado pode ajudar a simplificar o sistema.

Usar .Dockerignore para otimizar imagens

Se você tem uma compilação complicada que passa por vários diretórios recursivamente, todos os arquivos e diretórios são enviados para o Docker Daemon. Pode resultar em imagens maiores e tempos de construção mais lentos. Você pode usar o .Dockerignore para excluir arquivos e pastas desnecessárias que complicam o processo de construção.

Use construções de vários estágios

As compilações com vários estágios são um novo recurso do Docker desde a versão 17.05. Ele permite que os desenvolvedores construam várias imagens no mesmo Dockerfile e mova artefatos de um contêiner para outro no próprio DockerFile. Assim, você pode ter artefatos menores e otimizados em sua imagem final sem usar scripts complicados para obter os mesmos resultados.

Instale os pacotes necessários apenas

Dockerfile deve instalar apenas os pacotes mínimos necessários para executar os serviços. Cada pacote requer espaço na imagem. Portanto, certos aplicativos como ping ou editor de texto podem ser desnecessários no contexto do serviço que será executado no contêiner. Compreender os requisitos de um determinado serviço pode ajudá -lo a escrever melhores arquivos de docker que podem criar imagens otimizadas.

Pense em microsserviços

Projetar dockerfiles com a arquitetura de microsserviços em mente pode ser útil. Nem sempre é possível implantar um processo por contêiner. Mas os desenvolvedores podem pensar em como distribuir seus processos de maneira mais proativa e tomar decisões que ajudarão a implantar serviços de maneira dissociada. Recipientes são um ajuste natural para design modular. Portanto, seus dockerfiles devem aproveitar as oportunidades que o Docker oferece.

Considere o efeito das instruções sobre camadas

Execute apenas, copie e adicione os Dockerfiles Crie novas camadas desde a versão 1.10. Outras instruções não afetam diretamente o tamanho das imagens finais. Então você deve estar vigilante quando eles usam esses comandos. Além disso, a combinação de vários comandos pode diminuir o número de camadas. Menos camadas significam tamanhos menores.

Classificar argumentos de várias linhas

Sempre que você tem um argumento de várias linhas, classifique os argumentos alfanumericamente para melhorar a manutenção do código. Argumentos aleatórios podem levar a duplicações. Eles também são mais difíceis de atualizar. Um bom exemplo:

Evite usar: mais recente

Se você estiver usando do [Imagename]: mais recente, poderá ter problemas sempre que a imagem mudar. Pode se tornar um problema difícil de rastrear. Usando tags específicas pode garantir que você saiba a imagem exata que está sendo usada no registro do Docker.

Adicione apenas arquivos necessários do diretório

Os comandos do Dockerfile são executados consecutivamente para criar imagens e só cria camadas que ainda não estão presentes. Suponha que você tenha um pacote.JSON para NPM e requisitos.txt para pip. Você pode escrever o seguinte Dockerfile onde o pacote.json e requisitos.txt estão na pasta MyCode:

No entanto, toda vez que há uma mudança em qualquer um dos arquivos no mycode, ambos os comandos de execução precisam ser reconstruídos. Em vez disso, se o código for escrito da seguinte maneira:

Em seguida, os comandos de corrida serão independentes um do outro e alteram em um único arquivo na pasta MyCode não afetarão os comandos NPM e PIP RUN. Olhar para dependências como essa pode ajudá -lo a escrever Dockerfiles Better.

Um estudo mais aprofundado

As técnicas e as melhores práticas acima devem ajudá -lo a criar imagens menores do Docker e escrever melhores doces. Aqui estão os links para ajudá -lo a descobrir mais informações sobre diferentes tópicos:

• Melhores práticas de desenvolvimento do Docker
• Docker Builds de vários estágios
• Referência do arquivo do docker

Referências:

• https: // docs.Docker.com/desenvolver/dev-best-practicits/
• https: // docs.Docker.com/mecanismo/userguida/eng-image/dockerfile_best-practices/
• https: // docs.Docker.com/mecanismo/userguida/Eng-image/BaseImages/
• https: // docs.Docker.com/mecanismo/userguida/eng-image/multistage-build/
• https: // blog.Faça pela moda.com/redução do tamanho da imagem/tamanho/
• https: // hackernoon.com/dicas para redutor de redutor-size-size-876095DA3B34
• https: // docs.Docker.com/mecanismo/referência/construtor/#Dockerignore-File
• https: // runnable.com/blog/9 common-dockerfile-mistakes

https: // linuxhint.com/install-and-use-docker-on-ubuntu/