Otimização do Dockerfile

6.1 Introdução à otimização de imagens

As imagens Docker são compactas, mas mesmo assim ocupam espaço. Então, diminuir o tamanho delas é super importante porque isso ajuda a melhorar a performance, acelerar o download e o deploy dos containers, além de reduzir os custos de armazenamento. Dá pra otimizar a imagem melhorando o Dockerfile, que pode ser organizado de formas diferentes. Nessa aula, vamos ver algumas estratégias e as melhores práticas pra criar imagens Docker otimizadas e leves.

Por que é importante diminuir o tamanho das imagens Docker?

1. Velocidade de deploy: imagens menores fazem o download mais rápido do registro Docker e são lançadas nos containers mais rapidamente, o que é essencial em sistemas automatizados de CI/CD.
2. Uso eficiente de recursos: imagens leves ocupam menos espaço no disco, economizam recursos de rede ao serem transferidas e garantem um uso mais eficiente do poder computacional.
3. Segurança: imagens menores geralmente têm menos componentes desnecessários, o que reduz o risco de vulnerabilidades potenciais.
4. Simplificação de atualizações: atualizar imagens leves é mais rápido e utiliza menos recursos, o que acelera o processo de manutenção.

6.2 Estratégias para reduzir o tamanho de imagens Docker

1. Usar imagens base mínimas

A escolha da imagem base afeta diretamente o tamanho final da imagem Docker. Usar imagens base mínimas, como alpine, permite reduzir significativamente o tamanho da imagem.

Exemplo:

Substituir a imagem ubuntu por alpine:

# FROM ubuntu:20.04
FROM alpine:3.12

alpine é uma distro Linux leve que ocupa cerca de 5 MB, enquanto a imagem ubuntu pode ocupar centenas de megabytes.

2. Minimizar o número de camadas

Cada instrução no Dockerfile adiciona uma nova camada à imagem. Combinar vários comandos em uma única instrução RUN reduz o número de camadas, o que ajuda a diminuir o tamanho geral da imagem.

Exemplo:

Antes da otimização:

RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y git
RUN rm -rf /var/lib/apt/lists/*

Depois da otimização:

RUN apt-get update && apt-get install -y curl git && rm -rf /var/lib/apt/lists/*

Remover o cache do gerenciador de pacotes (rm -rf /var/lib/apt/lists/*) também reduz o tamanho da imagem, eliminando arquivos temporários criados durante a instalação.

3. Remover arquivos temporários

Remover arquivos temporários e dados desnecessários após a instalação dos pacotes ajuda a manter a imagem limpa e leve.

Exemplo:

RUN apt-get update && apt-get install -y curl git && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

4. Usar o .dockerignore

O arquivo .dockerignore ajuda a excluir arquivos e diretórios desnecessários do contexto de build, o que reduz o tamanho da imagem e acelera o processo de build.

Exemplo de .dockerignore:

node_modules
dist
*.log
Dockerfile*
.dockerignore

5. Build multi-stage (multi-stage builds)

O build multi-stage permite usar várias imagens intermediárias para criar uma imagem final leve, contendo apenas os arquivos e dependências necessários.

Exemplo:

# Etapa de build
FROM node:14 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Etapa final
FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html

Neste exemplo, a primeira etapa cria o build da aplicação, e a etapa final usa apenas os resultados do build, reduzindo o tamanho da imagem final.

6. Otimizar a instalação de pacotes

Instalar apenas os pacotes necessários e usar opções dos gerenciadores de pacotes para instalações mínimas ajuda a reduzir o tamanho da imagem.

Exemplo:

Usando o parâmetro --no-install-recommends com apt-get:

RUN apt-get update && apt-get install -y --no-install-recommends curl git && \
    rm -rf /var/lib/apt/lists/*

7. Comprimir e minimizar dados

Usar ferramentas para comprimir e minimizar dados ajuda a reduzir o tamanho da imagem.

Exemplo:

Comprimir arquivos de texto e logs:

RUN gzip /path/to/large/file.log

8. Remover bibliotecas e dependências não utilizadas

Remover bibliotecas e dependências não utilizadas após a instalação dos pacotes necessários ajuda a manter a imagem leve.

Exemplo:

Para aplicações Python:

RUN pip install --no-cache-dir -r requirements.txt

6.3 Exemplos de Dockerfile Otimizados

Exemplo 1: Dockerfile Otimizado para Node.js

FROM node:14-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
        
FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html

Esse exemplo usa construção multi-stage. Primeiro, o app é construído em um estágio intermediário, e depois só os resultados da construção são copiados pra imagem final baseada no Nginx.

Exemplo 2: Dockerfile Otimizado para Python

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Nesse exemplo, uma imagem base leve python:3.9-slim é usada. A instalação das dependências é colocada em um passo separado, o que permite usar o cache do Docker, caso o arquivo requirements.txt não tenha sido alterado.