Dockerfile - Boas práticas para melhorar o desempenho


Hoje veremos algumas técnicas que quando aplicadas na criação do seu Dockerfile vai melhorar o desempenho do processo de build.

Se você esta chegando agora e não sabe o que é Dockerfile sugiro que acompanhe o meu curso de introdução ao Docker nesta série de artigos: Docker - Uma introdução básica - Macoratti.net

Se quiser apenas recordar os conceitos sobre Dockerfile veja este artigo: Docker - Criando uma imagem com Dockerfile - Macoratti

O Docker cria imagens automaticamente lendo as instruções de um Dockerfile - um arquivo de texto que contém todos os comandos, em ordem, necessários para construir uma determinada imagem. Um Dockerfile adere a um formato específico e um conjunto de instruções que você pode encontrar na referência do Dockerfile.

O comando docker build do docker cria uma imagem a partir de um Dockerfile e de um contexto. O contexto da construção é o conjunto de arquivos em um PATH ou URL de local especificado. O PATH é um diretório em seu sistema de arquivos local. O URL é um local do repositório Git. (Um contexto é processado recursivamente. Portanto, um PATH inclui todos os subdiretórios e o URL inclui o repositório e seus submódulos.)

Dessa forma o processo de criação de imagens usando o Dockerfile e processo de build pode ser resumido a duas etapas:

  1. Criar o arquivo Dockerfile contendo as instruções
  2. Executar o build via comando:  docker build

Embora o processo seja bem simples, a criação do arquivo Dockerfile e a definição das instruções necessárias para criar a imagem pode ser feita de forma a otimizar a criação da imagem e agilizar o processo de build do arquivo Dockerfile.

Vejamos a seguir algumas recomendações que foram coletadas de vários contéudos da web para otimizar e melhorar o desempenho do seu Dockerfile.

1 - A ordem das instruções no Dockerfile é mandatória

A instruções declaradas em um arquivo Dockerfile são executadas em ordem por isso verifique a ordem correta de execução das instruções no seu Dockerfile.

2 - Os contêineres devem ser imutáveis e efêmeros

A imagem definida pelo seu Dockerfile deve gerar contêineres tão efêmeros quanto possível. Por “efêmero”, queremos dizer que o contêiner pode ser parado e destruído, depois reconstruído e substituído usando um conjunto de configuração mínima.

3 - Minimize o número de camadas consolidando as instruções

Cada instrução no Dockerfile adiciona uma camada extra à imagem do docker. O número de instruções e camadas deve ser reduzido ao mínimo, pois isso afeta o desempenho e o tempo de construção.

Assim ao executar um comando RUN, COPY ou ADD procure fazer isso em uma única instrução.

FROM alpine:3.4

RUN apk update
RUN apk add curl
RUN apk add vim
RUN apk add git
FROM alpine:3.4

RUN apk update && \
       apk add curl && \
       apk add vim && \
       apk add git

4 - Evite instalar pacotes desnecessários

Para reduzir a complexidade, as dependências, o tamanho dos arquivos e os tempos de compilação, evite instalar pacotes desnecessários.

5 - Utilize o arquivo .dockerignore

O arquivo .dockerignore atua da mesma forma que o .gitignore excluindo alguns arquivos presentes na pasta do seu Dockerfile.

Crie o seu Dockerfile em uma pasta vazia e adicione apenas os arquivos da aplicação e configuração necessários à construção da imagem Docker. Para aumenter o desempenho exclua arquivos e pastas usando o arquivo .dockerignore nessa pasta.

6 - Declare oque for mais passível de alteração no final do Dockerfile

Lembre-se que o Dockerfile trabalha em camadas, assim, quando o Dockerfile for processado ele vai procurar pela camada que sofreu a modificação e irá refazer as camadas subsequentes.

Assim defina as instruções que vão causar alterações no final do arquivo de forma a otimizar o processo. O comando COPY é um comando que quase sempre vai causar alteração por isso procure colocar a instrução COPY mais no final do arquivo.

Com isso em mente uma recomendação para estruturar seu Dockerfile é :

  1. Instalar as ferramentas necessárias para criar seu aplicativo;
  2. Instalar as dependências, bibliotecas e pacotes;
  3. Constrir sua aplicação;

7 - Um contêiner deve ter uma única responsabilidade

Pense em contêineres como entidades que assumem a responsabilidade para um aspecto do seu projeto. Portanto, projete seu aplicativo de forma que seu servidor da Web, banco de dados, cache de memória e outros componentes tenham seus próprios contêineres dedicados.

Assim nada de colocar em um contêiner a sua aplicação e o banco de dados. Coloque sua aplicação em um contêiner e o banco de dados em outro contêiner.

8 - Faça a ordenação de argumentos em comandos de mais de uma linha

A classificação alfanumérica de argumentos de múltiplas linhas ajuda a evitar a duplicação de pacotes e facilita atualização da lista.

FROM alpine:3.4

RUN apk update && apk add  \
       curl \ 
       git  \
       vim

9 - Processe o Dockerfile usando o cache

Ao criar uma imagem, o Docker percorre as instruções no Dockerfile, executando-as na ordem definida.

À medida que cada instrução é examinada, o Docker procura uma camada de imagem existente em seu cache que possa ser reutilizada, em vez de criar uma nova camada de imagem. Assim ao usar o cache o processo é otimizado.

Se você não quiser usar o cache, use a opção :  --no-cache = true com o comando docker build.

10 - Utilize o menor número de instruções possíveis no Dockerfile

Cada instrução RUN, COPY ou ADD usada no Dockerfile vai criar uma nova camada na imagem, logo, quanto mais comandos você emitir mais camadas a sua imagem vai ter.

Portanto procure enxugar a quantidade de comandos das suas instruções agrupando comandos em uma única instrução quando for possível.

Com essas recomendações seu Dockerfile vai ficar tinindo...

"Aquele que nem mesmo a seu próprio Filho poupou, antes o entregou por todos nós, como nos não dará também com ele todas as coisas ? "
Romanos 8:32

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:


José Carlos Macoratti