Cloud & DevOps

Docker Containerization explicado de forma simples (com diagramas e código real)

Docker Containerization: o essencial em um artigo — código real, diagramas e etapas concretas, extraídos de um curso de 41 lições.

REHOUMA Haythem

12 Jun 2026 • 12 min read

Um guia que vai direto ao ponto: Docker Containerization dissecado com diagramas, exemplos concretos e comandos testados. Tudo vem de um curso estruturado de 12 capítulos — aqui está o melhor.

tl;dr

Instalar uma VM UBUNTU
Descobrir docker
Comandos essenciais
Dockerfile
Containerizar Flask

~$ cat ./parcours.md # Docker Containerization — 11 capítulos

Instalar uma VM UBUNTU

→ Baixar VirtualBox e a ISO Ubuntu→ Criar a VM e instalar Ubuntu+ 1 mais lições

Descobrir docker

→ O que é Docker e por que usá-lo ?→ Instalar Docker no Ubuntu+ 1 mais lições

Comandos essenciais

→ Os comandos fundamentais→ Portas, volumes e variáveis de ambiente+ 2 mais lições

Dockerfile

→ Anatomia de um Dockerfile→ Construir e executar sua primeira imagem+ 1 mais lições

Containerizar Flask

→ Revisão Flask e criação da aplicação→ Dockerfile Flask, build e run+ 1 mais lições

Containerizar FastAPI

→ Revisão FastAPI e criação da API→ Dockerfile FastAPI e Swagger UI+ 1 mais lições

Containerizar Streamlit

→ Revisão Streamlit e criação do dashboard→ Dockerfile Streamlit e configuração headless+ 1 mais lições

Docker-compose

→ Por que Docker Compose ?→ Projeto Flask + PostgreSQL+ 2 mais lições

🏁

Projeto final (+ 3 capítulos no caminho)

→ Você sai com um projeto concreto e demonstrável

Anatomia de um Dockerfile

NOTEObjetivo — Compreender o que é um Dockerfile, dominar cada instrução e escrever seu primeiro Dockerfile para criar uma imagem Docker personalizada.

WARNINGAntes de começar — Este lab pressupõe que você seguiu os módulos anteriores. Se encontrar conflitos de nomes, portas já em uso, ou se o Docker não responder corretamente, use estes comandos para recomeçar do zero:

bash

# Arrêter TOUS les conteneurs en cours
docker stop $(docker ps -a -q)

# Supprimer TOUS les conteneurs
docker rm $(docker ps -a -q)

# Supprimer TOUTES les images (optionnel)
docker rmi $(docker images -q)

# Forcer la suppression si une image résiste
docker rmi -f $(docker images -q)

⚠ Atenção — Estes comandos apagam tudo. Use-os apenas se quiser recomeçar de um ambiente limpo. A opção -f (force) remove até as imagens usadas por contêineres.

Objetivos pedagógicos

TIPAo final deste módulo — Você será capaz de dominar estas competências essenciais.

O que é um Dockerfile?

Um Dockerfile é um arquivo de texto que contém uma série de instruções para construir uma imagem Docker. É como uma receita de cozinha: cada instrução é uma etapa que transforma a imagem base em sua imagem personalizada.

NOTEAnalogia — Pense no Dockerfile como uma receita de cozinha:

FROM = Os ingredientes básicos (farinha, manteiga...)
WORKDIR = A bancada de trabalho (a mesa da cozinha)
COPY = Adicionar ingredientes (açúcar, ovos...)
RUN = Preparar (misturar, cozinhar...)
EXPOSE = Indicar a apresentação (o prato de servir)
CMD = Servir o prato (o comando final)

Imagem base

O Dockerfile sempre parte de uma imagem existente (FROM). Nunca se começa do zero.

Instruções

Cada linha é uma instrução que modifica a imagem: copiar arquivos, instalar pacotes, configurar...

Imagem final

O resultado é uma imagem personalizada pronta para ser executada com docker run.

As instruções principais

FROM – Imagem base

Primeira instrução de um Dockerfile. Ela define a imagem inicial sobre a qual se constrói.

output

FROM python:3.11-slim

NOTEExplicação — Usamos a imagem oficial Python 3.11 na versão slim (versão leve, sem ferramentas desnecessárias). Isso nos dá um sistema Linux com Python 3.11 já instalado.

WORKDIR – Diretório de trabalho

Define o diretório de trabalho dentro do contêiner. Todas as instruções seguintes (COPY, RUN, CMD) serão executadas nesse diretório.

output

WORKDIR /app

TIPBoa prática — Sempre use WORKDIR em vez de RUN cd /app. WORKDIR cria o diretório automaticamente se ele não existir e persiste para todas as instruções seguintes.

COPY – Copiar arquivos

Copia arquivos da sua máquina (o «contexto de build») para o contêiner.

output

COPY . .

O primeiro . = o diretório atual na sua máquina. O segundo . = o WORKDIR no contêiner (/app).

Layers, cache e boas práticas

NOTEObjetivo — Compreender o sistema de layers e cache do Docker, e aplicar as boas práticas para escrever Dockerfiles otimizados.

bash

# Arrêter TOUS les conteneurs en cours
docker stop $(docker ps -a -q)

# Supprimer TOUS les conteneurs
docker rm $(docker ps -a -q)

# Supprimer TOUTES les images (optionnel)
docker rmi $(docker images -q)

# Forcer la suppression si une image résiste
docker rmi -f $(docker images -q)

⚠ Atenção — Estes comandos apagam tudo. Use-os apenas se quiser recomeçar de um ambiente limpo. A opção -f (force) remove até as imagens usadas por contêineres.

Objetivos pedagógicos

TIPAo final deste módulo — Você será capaz de dominar estas competências essenciais.

Cada instrução = 1 layer

Quando o Docker executa um Dockerfile, cada instrução (FROM, RUN, COPY, etc.) cria um novo layer (camada). Uma imagem Docker é uma pilha de layers empilhados uns sobre os outros.

output

FROM python:3.11-slim     ← Layer 1 (image de base)
WORKDIR /app              ← Layer 2
COPY requirements.txt .   ← Layer 3
RUN pip install ...       ← Layer 4
COPY . .                  ← Layer 5
CMD ["python", "app.py"]  ← Layer 6 (métadonnées)

NOTEPor que layers? — Os layers permitem ao Docker:

Compartilhar layers comuns entre várias imagens (ex: todas as imagens Python compartilham o mesmo layer base)
Colocar em cache os layers para acelerar os builds
Reduzir o espaço em disco armazenando cada layer apenas uma vez

O cache do Docker

O Docker coloca em cache cada layer. Durante um rebuild, o Docker verifica se um layer mudou. Se nada mudou, ele reutiliza o layer em cache em vez de reconstruí-lo.

WARNINGRegra fundamental — Se um layer mudar, todos os layers seguintes são reconstruídos, mesmo que não tenham mudado. Por isso a ordem das instruções é crucial.

Ordem ruim vs ordem boa

RUIM: requirements depois de COPY . .

output

FROM python:3.11-slim
WORKDIR /app
COPY . .                            ← Tout le code source
RUN pip install -r requirements.txt ← Installation des dépendances
CMD ["python", "app.py"]

WARNINGProblema — A cada modificação do seu código (mesmo um espaço em app.py), o layer COPY . . muda. Como ele está antes de RUN pip install, o Docker precisa reinstalar todas as dependências a cada build. Em um projeto com muitas dependências, isso pode levar vários minutos.

BOM: requirements antes de COPY . .

output

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .             ← Seulement les dépendances
RUN pip install -r requirements.txt ← Installation (caché si requirements.txt n'a pas changé)
COPY . .                            ← Le code source (change souvent)
CMD ["python", "app.py"]

TIPVantagem — Quando você modifica seu código-fonte, apenas o layer COPY . . muda. As dependências (pip install) ficam em cache e não são reinstaladas. O build passa de vários minutos para poucos segundos.

Ordem ruim

Ordem boa

Demonstração: observar o cache

TIPExercício guiado — Vamos observar o cache em ação com dois builds sucessivos.

Etapa 1: Criar o projeto

bash

mkdir ~/demo-cache
cd ~/demo-cache

Crie requirements.txt:

bash

touch requirements.txt
nano requirements.txt

Construir e executar sua primeira imagem

NOTEObjetivo — Construir sua primeira imagem Docker a partir de um Dockerfile, executá-la e compreender o papel do arquivo .dockerignore.

bash

# Arrêter TOUS les conteneurs en cours
docker stop $(docker ps -a -q)

# Supprimer TOUS les conteneurs
docker rm $(docker ps -a -q)

# Supprimer TOUTES les images (optionnel)
docker rmi $(docker images -q)

# Forcer la suppression si une image résiste
docker rmi -f $(docker images -q)

⚠ Atenção — Estes comandos apagam tudo. Use-os apenas se quiser recomeçar de um ambiente limpo. A opção -f (force) remove até as imagens usadas por contêineres.

Objetivos pedagógicos

TIPAo final deste módulo — Você será capaz de dominar estas competências essenciais.

Criar o projeto

Etapa 1: Criar a pasta do projeto

bash

mkdir ~/mon-premier-docker
cd ~/mon-premier-docker

Etapa 2: Criar o script Python

Crie um arquivo hello.py:

bash

touch hello.py
nano hello.py

Cole este conteúdo e salve (Ctrl + O, Enter, Ctrl + X):

output

print("Bonjour depuis Docker !")

TIPDica rápida — Você pode criar o arquivo diretamente pelo terminal:

bash

echo 'print("Bonjour depuis Docker !")' > hello.py

Verifique o conteúdo do arquivo:

bash

cat hello.py

Etapa 3: Criar o Dockerfile

Crie um arquivo chamado Dockerfile (sem extensão):

bash

touch Dockerfile
nano Dockerfile

Cole este conteúdo e salve (Ctrl + O, Enter, Ctrl + X):

output

FROM python:3.11-slim
WORKDIR /app
COPY hello.py .
CMD ["python", "hello.py"]

va-plus-loin

Este artigo cobre os trechos mais úteis — o curso completo Docker Containerization (12 capítulos, 41 lições, exercícios corrigidos e projeto final) leva você até o fim.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

Quanto tempo para aprender Docker Containerization?

Com uma progressão estruturada (12 capítulos, 41 lições curtas e práticas), você atinge um nível operacional em algumas semanas dedicando 30 a 60 minutos por dia. O importante é praticar cada conceito imediatamente.

É preciso ter pré-requisitos?

Básicos de informática são suficientes. Se você sabe usar um terminal e ler código simples, está pronto.

Por onde começar na prática?

Reproduza os comandos deste artigo e depois siga o curso completo Docker Containerization: ele encadeia as 41 lições em ordem, com exercícios e projeto final.

./a-lire-aussi

→ Maîtriser Linux expliqué simplement (avec schémas et vrai code)→ Python Sécurité Ports Linux : les 9 étapes clés pour passer de zéro à opérationnel → Full Stack AI AWS Bedrock en pratique : le code et les commandes qui comptent vraiment

📬 Quer receber este tipo de guia toda semana? Inscreva-se gratuitamente — código real, zero enrolação.

Anatomia de um Dockerfile

Objetivos pedagógicos

O que é um Dockerfile?

Imagem base

Instruções

Imagem final

As instruções principais

FROM – Imagem base

WORKDIR – Diretório de trabalho

COPY – Copiar arquivos

Layers, cache e boas práticas

Objetivos pedagógicos

Cada instrução = 1 layer

O cache do Docker

Ordem ruim vs ordem boa

RUIM: requirements depois de COPY . .

BOM: requirements antes de COPY . .

Ordem ruim

Ordem boa

Demonstração: observar o cache

Etapa 1: Criar o projeto

Construir e executar sua primeira imagem

Objetivos pedagógicos

Criar o projeto

Etapa 1: Criar a pasta do projeto

Etapa 2: Criar o script Python

Etapa 3: Criar o Dockerfile

FAQ

Stay up to date