Otimizar Dockerfiles do Windows
Há muitas maneiras de otimizar o processo de build e as imagens resultantes do Docker. Este artigo explica como funciona o processo de build do Docker e como criar imagens de maneira ideal para contêineres do Windows.
Camadas de imagem no build do Docker
Para otimizar o build do Docker, você precisará saber como funciona o build do Docker. Durante o processo de build do Docker, um Dockerfile é consumido e cada instrução acionável é executada, uma de cada vez, em seu próprio contêiner temporário. O resultado é uma nova camada de imagem para cada instrução acionável.
Por exemplo, o Dockerfile de exemplo a seguir usa a imagem base do sistema operacional mcr.microsoft.com/windows/servercore:ltsc2019, instala o IIS e, em seguida, cria um site simples.
# Sample Dockerfile
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN dism /online /enable-feature /all /featurename:iis-webserver /NoRestart
RUN echo "Hello World - Dockerfile" > c:\inetpub\wwwroot\index.html
CMD [ "cmd" ]
Você pode esperar que esse Dockerfile produza uma imagem com duas camadas: uma para a imagem do sistema operacional do contêiner e outra que inclua o IIS e o site. No entanto, a imagem real tem muitas camadas, e cada camada depende da anterior.
Para tornar isso mais claro, vamos executar o comando docker history na imagem criadas pelo Dockerfile de exemplo.
docker history iis
IMAGE CREATED CREATED BY SIZE COMMENT
f4caf476e909 16 seconds ago cmd /S /C REM (nop) CMD ["cmd"] 41.84 kB
f0e017e5b088 21 seconds ago cmd /S /C echo "Hello World - Dockerfile" > c 6.816 MB
88438e174b7c About a minute ago cmd /S /C dism /online /enable-feature /all / 162.7 MB
6801d964fda5 4 months ago 0 B
O resultado nos mostra que essa imagem tem quatro camadas: a camada base e três camadas adicionais que são mapeadas para cada instrução no Dockerfile. A camada inferior (6801d964fda5 neste exemplo) representa a imagem do sistema operacional base. Uma camada acima é a instalação do IIS. A próxima camada inclui o novo site e assim por diante.
Os Dockerfiles podem ser escritos para minimizar as camadas de imagem, otimizar o desempenho de build e otimizar a acessibilidade por meio da legibilidade. Por fim, há várias maneiras de concluir a mesma tarefa de build de imagem. O entendimento de como o formato do Dockerfile afeta o tempo de build e a imagem criada por ele aprimora a experiência de automação.
Otimizar o tamanho da imagem
Dependendo dos seus requisitos de espaço, o tamanho da imagem pode ser um fator importante ao criar imagens de contêiner do Docker. As imagens de contêiner são movidas entre host e Registros, exportadas e importadas e, por fim, consomem espaço. Esta seção explicará como minimizar o tamanho da imagem durante o processo de build do Docker para contêineres do Windows.
Para obter mais informações sobre as melhores práticas do Dockerfile, confira Melhores práticas de composição de Dockerfiles em Docker.com.
Agrupar ações relacionadas
Como cada instrução RUN criar uma camada na imagem de contêiner, o agrupamento de ações em uma só instrução RUN pode reduzir o número de camadas em um Dockerfile. Embora minimizar as camadas possa não afetar muito o tamanho da imagem, agrupar as ações relacionadas pode, o que será visto nos exemplos a seguir.
Nesta seção, vamos comparar dois Dockerfiles de exemplo que executam as mesmas ações. No entanto, um Dockerfile tem uma instrução por ação, enquanto o outro tinha as ações relacionadas agrupadas.
O Dockerfile de exemplo desagrupado a seguir baixa o Python para Windows, instala-o e remove o arquivo de instalação baixado após a conclusão da instalação. Nesse Dockerfile, cada ação recebe a própria instrução RUN.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN powershell.exe -Command Invoke-WebRequest "https://www.python.org/ftp/python/3.5.1/python-3.5.1.exe" -OutFile c:\python-3.5.1.exe
RUN powershell.exe -Command Start-Process c:\python-3.5.1.exe -ArgumentList '/quiet InstallAllUsers=1 PrependPath=1' -Wait
RUN powershell.exe -Command Remove-Item c:\python-3.5.1.exe -Force
A imagem resultante consiste em três camadas adicionais, uma para cada instrução RUN.
docker history doc-example-1
IMAGE CREATED CREATED BY SIZE COMMENT
a395ca26777f 15 seconds ago cmd /S /C powershell.exe -Command Remove-Item 24.56 MB
6c137f466d28 28 seconds ago cmd /S /C powershell.exe -Command Start-Proce 178.6 MB
957147160e8d 3 minutes ago cmd /S /C powershell.exe -Command Invoke-WebR 125.7 MB
O segundo exemplo é um Dockerfile que executa exatamente a mesma operação. No entanto, todas as ações relacionadas foram agrupadas em uma só instrução RUN. Cada etapa na instrução RUN está em uma nova linha do Dockerfile, enquanto o caractere '\' é usado para a quebra automática de linha.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN powershell.exe -Command \
$ErrorActionPreference = 'Stop'; \
Invoke-WebRequest https://www.python.org/ftp/python/3.5.1/python-3.5.1.exe -OutFile c:\python-3.5.1.exe ; \
Start-Process c:\python-3.5.1.exe -ArgumentList '/quiet InstallAllUsers=1 PrependPath=1' -Wait ; \
Remove-Item c:\python-3.5.1.exe -Force
A imagem resultante tem apenas uma camada adicional para a instrução RUN.
docker history doc-example-2
IMAGE CREATED CREATED BY SIZE COMMENT
69e44f37c748 54 seconds ago cmd /S /C powershell.exe -Command $ErrorAct 216.3 MB
Remover arquivos em excesso
Se houver um arquivo no Dockerfile, como um instalador, de que você não precisará depois que ele for usado, remova-o para reduzir o tamanho da imagem. Isso deve ocorrer na mesma etapa em que o arquivo foi copiado para a camada de imagem. Isso impede que o arquivo persista em uma camada da imagem de nível inferior.
No Dockerfile de exemplo a seguir, o pacote do Python é baixado, executado e, em seguida, removido. Isso tudo concluído em uma operação RUN e resulta em uma única camada de imagem.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN powershell.exe -Command \
$ErrorActionPreference = 'Stop'; \
Invoke-WebRequest https://www.python.org/ftp/python/3.5.1/python-3.5.1.exe -OutFile c:\python-3.5.1.exe ; \
Start-Process c:\python-3.5.1.exe -ArgumentList '/quiet InstallAllUsers=1 PrependPath=1' -Wait ; \
Remove-Item c:\python-3.5.1.exe -Force
Otimizar a velocidade de build
Várias linhas
Você pode dividir as operações em várias instruções individuais para otimizar a velocidade de build do Docker. Várias operações RUN aumentam a eficácia do cache, porque camadas individuais são criadas para cada instrução RUN. Se uma instrução idêntica já tiver sido executada em outra operação de build do Docker, essa operação armazenada em cache (camada de imagem) será reutilizada, resultando na redução do runtime de build do Docker.
No exemplo a seguir, os Pacotes Redistribuíveis do Apache e do Visual Studio são baixados, instalados e, em seguida, limpos com a remoção dos arquivos que não são mais necessários. Tudo isso é feito com uma só instrução RUN. Se uma dessas ações for atualizada, todas as ações serão executadas novamente.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN powershell -Command \
# Download software ; \
wget https://www.apachelounge.com/download/VC11/binaries/httpd-2.4.18-win32-VC11.zip -OutFile c:\apache.zip ; \
wget "https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x86.exe" -OutFile c:\vcredist.exe ; \
wget -Uri http://windows.php.net/downloads/releases/php-5.5.33-Win32-VC11-x86.zip -OutFile c:\php.zip ; \
# Install Software ; \
Expand-Archive -Path c:\php.zip -DestinationPath c:\php ; \
Expand-Archive -Path c:\apache.zip -DestinationPath c:\ ; \
Start-Process c:\vcredist.exe -ArgumentList '/quiet' -Wait ; \
# Remove unneeded files ; \
Remove-Item c:\apache.zip -Force; \
Remove-Item c:\vcredist.exe -Force; \
Remove-Item c:\php.zip
A imagem resultante tem duas camadas: uma para a imagem base do sistema operacional e outra que contém todas as operações da única instrução RUN.
docker history doc-sample-1
IMAGE CREATED CREATED BY SIZE COMMENT
9bdf3a21fd41 8 minutes ago cmd /S /C powershell -Command Invoke-WebR 205.8 MB
6801d964fda5 5 months ago 0 B
Por comparação, aqui estão as mesmas ações divididas em três instruções RUN. Nesse caso, cada instrução RUN é armazenada em cache em uma camada da imagem de contêiner, e somente aquelas que foram alteradas precisam ser executadas novamente em builds seguintes do Dockerfile.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN powershell -Command \
$ErrorActionPreference = 'Stop'; \
wget https://www.apachelounge.com/download/VC11/binaries/httpd-2.4.18-win32-VC11.zip -OutFile c:\apache.zip ; \
Expand-Archive -Path c:\apache.zip -DestinationPath c:\ ; \
Remove-Item c:\apache.zip -Force
RUN powershell -Command \
$ErrorActionPreference = 'Stop'; \
wget "https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x86.exe" -OutFile c:\vcredist.exe ; \
Start-Process c:\vcredist.exe -ArgumentList '/quiet' -Wait ; \
Remove-Item c:\vcredist.exe -Force
RUN powershell -Command \
$ErrorActionPreference = 'Stop'; \
wget http://windows.php.net/downloads/releases/php-5.5.33-Win32-VC11-x86.zip -OutFile c:\php.zip ; \
Expand-Archive -Path c:\php.zip -DestinationPath c:\php ; \
Remove-Item c:\php.zip -Force
A imagem resultante consiste em quatro camadas: uma camada para a imagem base do sistema operacional e cada uma das três instruções RUN. Como cada instrução RUN foi executada na própria camada, as execuções seguintes desse Dockerfile ou um conjunto idêntico de instruções em outro Dockerfile usarão camadas de imagem armazenadas em cache, reduzindo o tempo de build.
docker history doc-sample-2
IMAGE CREATED CREATED BY SIZE COMMENT
ddf43b1f3751 6 days ago cmd /S /C powershell -Command Sleep 2 ; Inv 127.2 MB
d43abb81204a 7 days ago cmd /S /C powershell -Command Sleep 2 ; Inv 66.46 MB
7a21073861a1 7 days ago cmd /S /C powershell -Command Sleep 2 ; Inv 115.8 MB
6801d964fda5 5 months ago
A maneira de ordenar as instruções é importante ao trabalhar com caches de imagem, como você verá na próxima seção.
Como ordenar instruções
Um Dockerfile é processado de cima para baixo, cada instrução comparada com as camadas em cache. Quando for encontrada uma instrução sem uma camada de cache, essa instrução e todas as instruções subsequentes serão processadas em novas camadas de imagem de contêiner. Por isso, a ordem na qual as instruções são colocadas é importante. Coloque as instruções que permanecerão constantes em direção à parte superior do Dockerfile. Coloque as instruções que poderão mudar na direção da parte inferior do Dockerfile. Isso reduz a probabilidade de negar o cache existente.
Os exemplos a seguir mostram como a ordenação de instrução do Dockerfile pode afetar a eficácia do cache. Este Dockerfile de exemplo simples tem quatro pastas numeradas.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN mkdir test-1
RUN mkdir test-2
RUN mkdir test-3
RUN mkdir test-4
A imagem resultante tem cinco camadas: uma para a imagem base do sistema operacional e cada uma das instruções RUN.
docker history doc-sample-1
IMAGE CREATED CREATED BY SIZE COMMENT
afba1a3def0a 38 seconds ago cmd /S /C mkdir test-4 42.46 MB
86f1fe772d5c 49 seconds ago cmd /S /C mkdir test-3 42.35 MB
68fda53ce682 About a minute ago cmd /S /C mkdir test-2 6.745 MB
5e5aa8ba1bc2 About a minute ago cmd /S /C mkdir test-1 7.12 MB
6801d964fda5 5 months ago 0 B
Este próximo Dockerfile foi ligeiramente modificado, com a terceira instrução RUN alterada para um novo arquivo. Quando o build do Docker é executado em relação a esse Dockerfile, as três primeiras instruções, que são idênticas às do último exemplo, usam as camadas de imagem em cache. No entanto, como as instruções RUN alteradas não estão armazenadas em cache, uma camada é criada para a instrução alterada e todas as instruções seguintes.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN mkdir test-1
RUN mkdir test-2
RUN mkdir test-5
RUN mkdir test-4
Ao comparar as IDs de imagem da nova imagem com a que está no primeiro exemplo desta seção, você observará que as três primeiras camadas de baixo para cima são compartilhadas, mas a quarta e a quinta são exclusivas.
docker history doc-sample-2
IMAGE CREATED CREATED BY SIZE COMMENT
c92cc95632fb 28 seconds ago cmd /S /C mkdir test-4 5.644 MB
2f05e6f5c523 37 seconds ago cmd /S /C mkdir test-5 5.01 MB
68fda53ce682 3 minutes ago cmd /S /C mkdir test-2 6.745 MB
5e5aa8ba1bc2 4 minutes ago cmd /S /C mkdir test-1 7.12 MB
6801d964fda5 5 months ago 0 B
Otimização cosmética
Maiúsculas e minúsculas nas instruções
As instruções do Dockerfile não diferenciam maiúsculas de minúsculas, mas a convenção é usar letras maiúsculas. Isso aprimora a legibilidade diferenciando a chamada e a operação da instrução. Os dois exemplos a seguir comparam um Dockerfile em minúsculas e outro em maiúsculas.
Este é um Dockerfile em minúsculas:
# Sample Dockerfile
from mcr.microsoft.com/windows/servercore:ltsc2019
run dism /online /enable-feature /all /featurename:iis-webserver /NoRestart
run echo "Hello World - Dockerfile" > c:\inetpub\wwwroot\index.html
cmd [ "cmd" ]
Este é o mesmo Dockerfile que usa letras maiúsculas:
# Sample Dockerfile
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN dism /online /enable-feature /all /featurename:iis-webserver /NoRestart
RUN echo "Hello World - Dockerfile" > c:\inetpub\wwwroot\index.html
CMD [ "cmd" ]
Quebra automática de linha
Operações longas e complexas podem ser separadas em várias linhas usando o caractere de barra invertida \. O Dockerfile a seguir instala o pacote redistribuível do Visual Studio, remove os arquivos do instalador e cria um arquivo de configuração. Essas três operações são todas especificadas em uma linha.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN powershell -Command c:\vcredist_x86.exe /quiet ; Remove-Item c:\vcredist_x86.exe -Force ; New-Item c:\config.ini
O comando pode ser dividido com barras invertidas, de modo que cada operação de uma instrução RUN seja especificada na própria linha.
FROM mcr.microsoft.com/windows/servercore:ltsc2019
RUN powershell -Command \
$ErrorActionPreference = 'Stop'; \
Start-Process c:\vcredist_x86.exe -ArgumentList '/quiet' -Wait ; \
Remove-Item c:\vcredist_x86.exe -Force ; \
New-Item c:\config.ini