Docker: Algumas boas práticas para a criação de Dockerfiles

Dockerfiles são a base para a construção de imagens Docker, que são fundamentais no desenvolvimento e implantação de aplicações containerizadas. Para criar Dockerfiles robustos e fáceis de manter, é importante seguir algumas boas práticas. Vamos explorar algumas delas com exemplos práticos.

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

FROM alpine:3.4

RUN apk update
RUN apk add curl
RUN apk add vim
RUN apk add git

Modifique seu Dockerfile.

FROM alpine:3.4

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

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.

2- 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.

3- 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.

4- 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 com o comando docker build.

docker build --no-cache -t minha-aplicacao .

5- Utilize somente as imagens oficiais

6- Construa imagens usando Multi-stage

Uma abordagem de multi-stage bem elaborada inclui somente os binários e as dependências mínimas necessárias na imagem final, diminuindo o tempo de build e podendo reduzir a superfície de ataques e vulnerabilidades, além de diminuir significativamente o tamanho da imagem final.

Exemplo de um script em go

// Arquivo main.go
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

# Arquivo Dockerfile
FROM golang:1.21.0-alpine3.17

WORKDIR /app
ADD main.go /app/

RUN go build -o script-deltaops main.go

CMD ["./script-deltaops"]

No exemplo anterior, eu criei um script em Go que realiza o build para gerar um binário. Observando a imagem acima, no retorno do comando docker images, o tamanho da imagem está em 250 MB.

A seguir, vamos criar um Dockerfile utilizando a abordagem de multi-stage build e aplicá-la, a fim de comparar o resultado.

# Arquivo Dockerfile Multistage

# Construção da imagem para fazer o Build
FROM golang:1.21.0-alpine3.17 AS novo-build
WORKDIR /app
ADD main.go /app/
RUN go build -o script-deltaops main.go
# Copia do binario gerado pelo Build 
FROM alpine:latest
WORKDIR /app
COPY --from=novo-build /app/script-deltaops /app/script-deltaops
CMD ["./app/script-deltaops"]

Observando as imagens acima, temos duas versões do ‘hello-world’: uma com single-stage build e outra com multi-stage build. O resultado é bastante interessante, pois a abordagem de multi-stage build utiliza a primeira etapa para realizar a construção e a segunda etapa para a execução, gerando uma imagem Docker final com um tamanho muito menor.

7- Utilize imagens otimizadas, como a imagem Alpine, por exemplo.

Usamos a:latesttag, pois essa é a tag de imagem padrão que o Docker pega do Docker Hub. Conforme mostrado acima com Python, se buscar a por alpineversão da imagem reduz em quase 95%!

Neste post, consegui apresentar algumas das principais boas práticas para a criação de Dockerfiles. No entanto, existem muitas outras práticas que podem ser abordadas em futuros posts.

Ainda assim, estas dicas já ajudam muito a melhorar o desempenho e reduzir o tamanho das suas imagens Docker, evitando que você envie ‘um tijolo’ para produção kk .

Continuaremos explorando novas técnicas e melhores práticas para que você possa criar Dockerfiles cada vez mais eficientes e otimizados.

Então, é isso pessoal. Não se esqueçam de nos seguir nas redes sociais.

https://deltaops.com.br/

https://www.linkedin.com/company/deltaopscloud/

✨ Referência:

Building best practices

Escrito por 🖋️ Diogo Lima
Sócio Fundador da Empresa DeltaOps