Instruções principais do Dockerfile

3.1 Instrução FROM

Então, só relembrando, Dockerfile é um arquivo de texto que contém instruções pra criar uma imagem Docker. Cada instrução no Dockerfile realiza uma tarefa específica e cria uma nova camada na imagem. Nessa aula, a gente vai dar uma olhada mais detalhada nas instruções principais do Dockerfile: FROM, RUN, COPY e CMD, que são cruciais pra criar imagens Docker funcionais e eficientes.

A instrução FROM define a imagem base, a partir da qual uma nova imagem será criada. É a primeira instrução em qualquer Dockerfile e determina o ponto inicial pra construção da imagem.

Sintaxe

FROM <image>[:<tag>] [AS <name>]

Onde:

• <image>: nome da imagem base.
• <tag>: (opcional) versão da imagem base. O padrão é latest.
• AS <name>: (opcional) define um nome pra essa etapa da construção (usado em construção de múltiplas etapas).

Exemplos

Usando a imagem base Ubuntu:

FROM ubuntu:20.04

Usando a imagem oficial do Node.js:

FROM node:14

Usando construção de múltiplas etapas pra otimização:

FROM node:14 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

Nesse exemplo, são usadas duas imagens base. A primeira (node:14) é usada pra construir o aplicativo, e a segunda (nginx:alpine) serve pra criar um servidor leve que vai servir arquivos estáticos.

Graças à construção de múltiplas etapas, a imagem final contém apenas o conjunto mínimo de arquivos e programas (neste caso Nginx e os arquivos estáticos construídos), tornando-a mais leve e rápida de implantar.

3.2 Instrução RUN

A instrução RUN executa comandos dentro do container e cria uma nova camada na imagem. Essa instrução é usada pra instalar pacotes, configurar o ambiente e executar outros comandos necessários pra preparar a imagem.

Sintaxe:

RUN <command>

Onde:

• <command>: o comando que será executado dentro do container.

Exemplos:

Instalar pacotes na imagem do Ubuntu:

RUN apt-get update && apt-get install -y curl git

Compilar código:

RUN gcc -o myapp myapp.c

Combinando vários comandos

Pra reduzir o número de camadas, diminuir o tamanho da image e acelerar a construção, é recomendado combinar vários comandos em uma única instrução RUN.

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

3.3 Instrução COPY

A instrução COPY copia arquivos e diretórios do contexto de construção para o sistema de arquivos do container. Isso é útil para mover o código-fonte, arquivos de configuração e outros recursos para o container.

Sintaxe:

COPY <src> <dest>

Onde:

• <src>: caminho para os arquivos ou diretórios no contexto de construção.
• <dest>: caminho de destino no container.

Exemplos:

Copiar todo o conteúdo do diretório atual para o diretório de trabalho do container:

COPY . /app

Copiar arquivos individuais:

COPY package.json /app/package.json
COPY server.js /app/server.js

Usando .dockerignore

Para excluir arquivos desnecessários do processo de cópia, você pode usar o arquivo .dockerignore, que funciona de forma semelhante ao .gitignore.

node_modules
dist
*.log

3.4 Instrução CMD

A instrução CMD define o comando que será executado ao iniciar o container. Diferente do RUN, que é executado no estágio de build, o CMD é executado ao iniciar o container a partir da imagem criada.

Sintaxe:

CMD ["executable","param1","param2"]

Ou

CMD command param1 param2

Onde:

• ["executable","param1","param2"]: forma exec, que é preferível para garantir um tratamento adequado de sinais.
• command param1 param2: forma shell, que executa o comando no shell.

Exemplos:

Rodando uma aplicação Node.js:

CMD ["node", "app.js"]

Rodando um script shell:

CMD /usr/bin/myscript.sh

Diferença entre CMD e ENTRYPOINT

CMD define um comando padrão que pode ser sobrescrito ao iniciar o container. ENTRYPOINT define um comando fixo que será sempre executado ao iniciar o container.

Exemplo de uso do ENTRYPOINT:

ENTRYPOINT ["python", "script.py"]
CMD ["arg1"]

Nesse exemplo, o ENTRYPOINT roda o script Python, enquanto o CMD passa os argumentos que podem ser alterados ao iniciar o container.

Exemplo de Dockerfile com instruções principais

        
# Usando a imagem base do Node.js
FROM node:14
        
# Definindo o diretório de trabalho
WORKDIR /app
        
# Copiando os arquivos package.json e package-lock.json
COPY package*.json ./
        
# Instalando as dependências
RUN npm install
        
# Copiando o código fonte da aplicação
COPY . .
        
# Definindo a porta que será usada pela aplicação
EXPOSE 3000
        
# Definindo o comando para rodar a aplicação
CMD ["node", "app.js"]