Dockerfile: criação e estrutura do arquivo

2.1 Conceitos básicos do Dockerfile

Dockerfile — é um arquivo de texto, contendo uma sequência de comandos que o Docker usa para criar uma imagem. Ele funciona como uma "receita", descrevendo como a imagem deve ser construída — da camada base até o estado final. Entender a estrutura e o processo de criação de um Dockerfile é importante para usar o Docker de forma eficiente.

Conceitos básicos do Dockerfile:

1. Idempotência: os comandos no Dockerfile devem ser idempotentes — sua execução repetida deve produzir o mesmo resultado.
2. Sequência: os comandos são executados sequencialmente, de cima para baixo. A ordem importa, pois cada comando cria uma nova camada da imagem.
3. Estrutura em camadas: praticamente cada instrução adiciona uma nova camada à imagem. Essas camadas são armazenadas em cache, permitindo otimizar o processo de build.

Estrutura do Dockerfile:

O Dockerfile é composto por instruções, cada uma delas executa uma função específica. Aqui estão as principais:

1. FROM: define a imagem base que será usada para criar a nova imagem.
2. MAINTAINER: identifica o autor do Dockerfile (obsoleta, mas útil para informação).
3. RUN: executa comandos no container e cria uma nova camada.
4. COPY: copia arquivos e diretórios do contexto de build para o sistema de arquivos do container.
5. ADD: copia arquivos e diretórios, suporta extração de arquivos compactados e download de arquivos via URL.
6. WORKDIR: define o diretório de trabalho para os comandos subsequentes.
7. ENV: define variáveis de ambiente.
8. CMD: especifica o comando padrão que será executado quando o container for iniciado.
9. ENTRYPOINT: define o comando que será executado quando o container for iniciado, com possibilidade de passar argumentos.
10. EXPOSE: indica as portas que o container usará.
11. VOLUME: cria um ponto de montagem para volumes externos.

2.2 Criando o Dockerfile

Exemplo de criação de um Dockerfile

Bora ver um exemplo básico de como criar um Dockerfile pra uma aplicação web em Node.js.

Passo 1: Criando o Dockerfile básico

Crie um arquivo chamado Dockerfile na raiz do seu projeto e manda essas linhas aí:

# Usando uma imagem base do Node.js
FROM node:14

# Configurando o diretório de trabalho
WORKDIR /app

# Copiando package.json e package-lock.json
COPY package*.json ./

# Instalando as dependências
RUN npm install

# Copiando todos os arquivos do projeto
COPY . .

# Informando a porta que vai ser usada pelo app
EXPOSE 3000

# Definindo o comando pra rodar o app
CMD ["node", "app.js"]

Esse Dockerfile faz o seguinte:

1. FROM node:14: usa a imagem oficial do Node.js versão 14 como base.
2. WORKDIR /app: configura o diretório de trabalho pras próximas comandos.
3. COPY package*.json ./: copia os arquivos package.json e package-lock.json pro diretório de trabalho.
4. RUN npm install: instala as dependências do package.json.
5. COPY . .: copia todos os arquivos do projeto pro diretório de trabalho no container.
6. EXPOSE 3000: indica que o app vai usar a porta 3000.
7. CMD ["node", "app.js"]: define o comando pra rodar o app.

Passo 2: Build da imagem

Depois de criar o Dockerfile, faça o build da imagem com o comando docker build:

docker build -t my-node-app .

Esse comando vai criar uma imagem chamada my-node-app usando o Dockerfile da pasta atual.

Passo 3: Rodando o container

Agora, bora rodar o container a partir da imagem criada com o comando docker run:

docker run -d -p 3000:3000 my-node-app

Esse exemplo executa o container em segundo plano e redireciona a porta 3000 do container pra porta 3000 da máquina host. Agora dá pra acessar o app pelo http://localhost:3000.

2.3 Instruções adicionais do Dockerfile

1. Configuração de variáveis de ambiente

Você pode definir variáveis de ambiente, que estarão disponíveis no container, usando a instrução ENV.

ENV NODE_ENV=production

2. Uso de vários comandos RUN

Às vezes, vale a pena combinar vários comandos em uma única instrução RUN para reduzir o número de camadas, diminuir o tamanho da imagem e acelerar a construção.

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

Útil! Se o comando não couber em uma linha, você pode usar o símbolo \ para continuar na próxima linha. Isso será interpretado como um único comando.

Útil! Para escrever vários comandos em uma única linha, você pode usar &&: command1 && command2 && command3. Isso permite executar vários comandos consecutivamente.

Otimização da ordem de comandos

Para usar o cache do Docker de forma eficaz, copie primeiro os arquivos que raramente mudam (por exemplo, package.json) e instale as dependências antes de adicionar os outros arquivos do projeto.

Exemplo de um Dockerfile avançado

Em projetos mais complexos, pode ser necessário um Dockerfile mais avançado com configurações adicionais.

# Usando uma imagem base mínima do Node.js
FROM node:14-alpine

# Configurando o diretório de trabalho
WORKDIR /usr/src/app

# Copiando package.json e instalando dependências
COPY package*.json ./
RUN npm install --only=production

# Copiando o código fonte
COPY . .

# Indicando a porta para funcionamento
EXPOSE 8080

# Configurando variáveis de ambiente
ENV NODE_ENV=production

# Executando o aplicativo
CMD ["node", "server.js"]