</>Codding
Docker & DevOps0/18 lições

Módulo 1 • Containers

Dockerfile

Ferramentas e leitura
Leitura100%
Aula guiada50–75 min5 etapas práticas

Nesta aula, você vai compreender Dockerfile com explicação progressiva, exemplo resolvido, checagens e prática. Nada de apenas copiar: cada etapa prepara a próxima.

Antes de começar: Leia a aula anterior do módulo se algum termo parecer novo. Você pode testar o exemplo antes de continuar.

Ao terminar, você vai conseguir

  • Explicar Dockerfile com suas próprias palavras
  • Reconhecer as partes importantes em um exemplo real
  • Identificar e corrigir os erros mais frequentes
  • Aplicar o conteúdo em uma atividade prática
1

Cenário

Identifique o objetivo, as restrições e os riscos.

2

Decisão

Escolha como aplicar Dockerfile e justifique.

3

Evidência

Confira o resultado com critérios observáveis.

0/6 atividades
1

Entenda o problema

O que é Dockerfile

Container empacota aplicação e dependências em uma unidade que roda igual na sua máquina e no servidor. Acaba o 'na minha máquina funciona'.

Cheque seu entendimento

Qual a diferença entre imagem e container?

1 de 5

O que você aprendeu

  • Container empacota aplicação e dependências em uma unidade que roda igual na sua máquina e no servidor. Acaba o 'na minha máquina funciona'.
  • -p liga a porta do host à do container; -e injeta configuração sem reconstruir a imagem.
  • Evite: Guardar dados dentro do container e perdê-los no próximo deploy.
  • Evite: Colocar segredos na imagem em vez de variáveis de ambiente.

Videoaulas sobre este tema

Se você aprende melhor assistindo, abrimos uma seleção de aulas em vídeo em português sobre exatamente este assunto.

Aula em vídeo sobre este temaVídeos em português explicando "Dockerfile" passo a passo.Vendo alguém programar issoExemplos práticos, com o código sendo escrito na tela.Playlist completa de Docker & DevOpsCurso em vídeo do começo ao fim, para acompanhar junto com o módulo "Containers".

Quiz rápido

0/2 • 0 certas

1. Qual a diferença entre imagem e container?

2. Onde deve ficar a configuração sensível de um container?

Laboratório

1/4

1. Faça funcionar

Laboratório de Dockerfile: execute o exemplo, identifique entrada, processamento e saída e altere pelo menos um valor para observar como o resultado muda.

Abrir no playground
  • Checkpoints da prática (1/4)
  • Escreva sua versão a partir do modeloO texto do editor ainda é igual ao modelo inicial. Altere pelo menos uma linha para que a prática conte como sua.
  • Nenhuma lacuna deixada em branco
  • Execute seu códigoClique em “Verificar resposta” para rodar seu código e comparar a saída com o esperado.
  • Resultado ainda não confereEsperado: o programa rodar sem erro. Se aparecer uma mensagem de erro, leia a última linha: ela indica a linha e o tipo do problema.

Escreva sua solução e clique em Verificar.

Tire sua dúvida

Cada resposta é conferida contra o material desta lição antes de aparecer. Sem IA por trás e sem inventar nada.

Dockerfile

Docker & DevOps • Módulo 1: Containers • Codding — material para estudo offline

Aluno: ______________________________ Data: ____ / ____ / ______

Nesta aula, você vai compreender Dockerfile com explicação progressiva, exemplo resolvido, checagens e prática. Nada de apenas copiar: cada etapa prepara a próxima.

Objetivos da aula

  • Explicar Dockerfile com suas próprias palavras
  • Reconhecer as partes importantes em um exemplo real
  • Identificar e corrigir os erros mais frequentes
  • Aplicar o conteúdo em uma atividade prática

Pré-requisito: Leia a aula anterior do módulo se algum termo parecer novo. Você pode testar o exemplo antes de continuar. • Duração: 50–75 min

Explicação passo a passo

1. O que é Dockerfile

Container empacota aplicação e dependências em uma unidade que roda igual na sua máquina e no servidor. Acaba o 'na minha máquina funciona'.

Checkpoint: Qual a diferença entre imagem e container? — Resposta: Imagem é o molde imutável; container é uma execução dela

2. Como pensar antes de fazer

Imagem é o molde (somente leitura), container é a execução dela. O Dockerfile descreve a imagem em camadas: cada instrução vira uma camada cacheada, por isso copiar o package.json e instalar dependências ANTES de copiar o código deixa o build muito mais rápido.

Dica: Não decore a forma. Tente explicar com suas palavras qual problema “Dockerfile” resolve.

3. Exemplo completo, do início ao resultado

Container é efêmero: tudo que ele escreve some ao ser recriado. Dados que precisam sobreviver vão para volumes ou serviços externos, e configuração entra por variáveis de ambiente — nunca fixa na imagem.

# Dockerfile
# FROM node:20-alpine
# WORKDIR /app
# COPY package*.json ./      <- primeiro só as dependências (cache)
# RUN npm ci
# COPY . .
# CMD ["node", "server.js"]

docker build -t minha-api .
docker run -p 3000:3000 -e NODE_ENV=production minha-api
docker ps                 # containers rodando
docker logs -f <id>       # acompanhar logs
echo "pipeline: build -> testes -> imagem -> deploy"
TrechoO que faz
# DockerfileComentário de orientação: documenta a intenção sem executar uma ação.
# FROM node:20-alpineComentário de orientação: documenta a intenção sem executar uma ação.
# WORKDIR /appComentário de orientação: documenta a intenção sem executar uma ação.
# COPY package*.json ./ <- primeiro só as dependências (cache)Comentário de orientação: documenta a intenção sem executar uma ação.
# RUN npm ciComentário de orientação: documenta a intenção sem executar uma ação.
# COPY . .Comentário de orientação: documenta a intenção sem executar uma ação.
# CMD ["node", "server.js"]Comentário de orientação: documenta a intenção sem executar uma ação.
docker build -t minha-api .Contribui para a transformação principal mostrada neste exemplo.

Dica: -p liga a porta do host à do container; -e injeta configuração sem reconstruir a imagem.

Checkpoint: Onde deve ficar a configuração sensível de um container? — Resposta: Em variáveis de ambiente/segredos injetados na execução

4. Do detalhe para o todo

CI roda testes e build a cada push; CD publica automaticamente quando a CI passa. O valor está em entregar pequeno e frequente: erro pequeno é fácil de achar e de reverter.

5. Erros comuns e como corrigi-los

1. Guardar dados dentro do container e perdê-los no próximo deploy. 2. Colocar segredos na imagem em vez de variáveis de ambiente. 3. Copiar o código antes das dependências e invalidar o cache a cada build.

Dica: Quando algo der errado, compare uma diferença por vez com o exemplo. Evite mudar várias partes ao mesmo tempo.

Prática guiada

1. 1. Faça funcionar

Laboratório de Dockerfile: execute o exemplo, identifique entrada, processamento e saída e altere pelo menos um valor para observar como o resultado muda.

# Dockerfile
# FROM node:20-alpine
# WORKDIR /app
# COPY package*.json ./      <- primeiro só as dependências (cache)
# RUN npm ci
# COPY . .
# CMD ["node", "server.js"]

docker build -t minha-api .
docker run -p 3000:3000 -e NODE_ENV=production minha-api
docker ps                 # containers rodando
docker logs -f <id>       # acompanhar logs
echo "pipeline: build -> testes -> imagem -> deploy"

Dica: Volte ao exemplo resolvido e compare a estrutura. Guardar dados dentro do container e perdê-los no próximo deploy.

2. 2. Preveja antes de testar

Sem executar, explique qual resultado o exemplo de Dockerfile deve produzir e qual parte é responsável por ele.

Minha previsão:

A parte responsável pelo resultado:

Como vou conferir:

Dica: Use o modelo mental da aula: entrada, transformação e evidência observável.

3. 3. Encontre e corrija o erro

Use o exemplo de Dockerfile, identifique um risco citado na aula e registre ou implemente a correção.

# Dockerfile
# FROM node:20-alpine
# WORKDIR /app
# COPY package*.json ./      <- primeiro só as dependências (cache)
# RUN npm ci
# COPY . .
# CMD ["node", "server.js"]

docker build -t minha-api .
docker run -p 3000:3000 -e NODE_ENV=production minha-api
docker ps                 # containers rodando
docker logs -f <id>       # acompanhar logs
echo "pipeline: build -> testes -> imagem -> deploy"

Dica: Guardar dados dentro do container e perdê-los no próximo deploy.

4. 4. Aplique em um caso novo

Crie uma variação própria usando Dockerfile. Mude os dados ou o cenário e demonstre que o resultado continua correto.

# Dockerfile
# FROM node:20-alpine
# WORKDIR /app
# COPY package*.json ./      <- primeiro só as dependências (cache)
# RUN npm ci
# COPY . .
# CMD ["node", "server.js"]

docker build -t minha-api .
docker run -p 3000:3000 -e NODE_ENV=production minha-api
docker ps                 # containers rodando
docker logs -f <id>       # acompanhar logs
echo "pipeline: build -> testes -> imagem -> deploy"

Dica: Mantenha a estrutura que já funcionou e altere uma decisão por vez.

Revisão

  • Container empacota aplicação e dependências em uma unidade que roda igual na sua máquina e no servidor. Acaba o 'na minha máquina funciona'.
  • -p liga a porta do host à do container; -e injeta configuração sem reconstruir a imagem.
  • Evite: Guardar dados dentro do container e perdê-los no próximo deploy.
  • Evite: Colocar segredos na imagem em vez de variáveis de ambiente.

Exemplo comentado

# Dockerfile
# FROM node:20-alpine
# WORKDIR /app
# COPY package*.json ./      <- primeiro só as dependências (cache)
# RUN npm ci
# COPY . .
# CMD ["node", "server.js"]

docker build -t minha-api .
docker run -p 3000:3000 -e NODE_ENV=production minha-api
docker ps                 # containers rodando
docker logs -f <id>       # acompanhar logs
echo "pipeline: build -> testes -> imagem -> deploy"

-p liga a porta do host à do container; -e injeta configuração sem reconstruir a imagem.

Erros comuns

  • Guardar dados dentro do container e perdê-los no próximo deploy.
  • Colocar segredos na imagem em vez de variáveis de ambiente.
  • Copiar o código antes das dependências e invalidar o cache a cada build.

Quiz e gabarito completo

  1. 1. Qual a diferença entre imagem e container?

    • a) Nenhuma
    • b) Imagem é o molde imutável; container é uma execução dela
    • c) Container é maior
    • d) Imagem só existe na nuvem

    Gabarito: b) Imagem é o molde imutável; container é uma execução dela — Uma imagem gera quantos containers você quiser.

  2. 2. Onde deve ficar a configuração sensível de um container?

    • a) No Dockerfile
    • b) Em variáveis de ambiente/segredos injetados na execução
    • c) No código
    • d) No README

    Gabarito: b) Em variáveis de ambiente/segredos injetados na execução — A imagem é distribuída; segredo nela vaza.

Codding • Docker & DevOps • Dockerfile • Prova final e certificado em codding.lovable.app/cursos/docker-devops/prova