Docker para Iniciantes: Contêineres Simplificados

31 de março de 2026 · 12 min de leitura

O Que É Docker?

Docker é uma plataforma que permite empacotar aplicações e suas dependências em contêineres leves e portáteis. Pense em um contêiner como uma pequena caixa autossuficiente que contém tudo o que sua aplicação precisa para executar: código, runtime, bibliotecas e ferramentas do sistema. Chega de problemas do tipo "funciona na minha máquina".

Antes do Docker, implantar software significava instalar dependências manualmente, configurar servidores e torcer para que nada entrasse em conflito. Você gastaria horas configurando versões do Python, pacotes do Node.js, drivers de banco de dados e bibliotecas do sistema. Depois faria tudo de novo nos servidores de staging e produção, rezando para que as configurações correspondessem.

O Docker elimina esse caos garantindo que sua aplicação execute de forma idêntica em qualquer lugar — seu laptop, a máquina de um colega, servidores de staging ou produção. O contêiner se torna a unidade de implantação, não apenas o código da aplicação.

O Docker se tornou a ferramenta padrão para desenvolvimento de software moderno. Seja construindo microsserviços, configurando pipelines de CI/CD ou apenas querendo um ambiente de desenvolvimento consistente, o Docker torna isso possível com sobrecarga mínima. Empresas como Netflix, Spotify e PayPal executam milhões de contêineres em produção todos os dias.

Contêineres vs Máquinas Virtuais

Contêineres e máquinas virtuais fornecem isolamento, mas funcionam de maneira muito diferente internamente. Entender essa diferença é crucial para apreciar por que os contêineres se tornaram tão populares.

Máquinas Virtuais executam um sistema operacional completo com seu próprio kernel sobre um hypervisor. Cada VM precisa de sua própria instalação de SO, consumindo gigabytes de espaço em disco e memória significativa. Os tempos de inicialização são medidos em minutos. Se você executar três VMs, estará executando três sistemas operacionais completos simultaneamente.

Contêineres compartilham o kernel do SO host e apenas empacotam a camada de aplicação. Eles têm megabytes de tamanho (não gigabytes), iniciam em segundos (não minutos), e você pode executar dezenas em uma única máquina sem problemas.

# Abordagem VM: Cada aplicação recebe um SO completo
App A → SO Convidado → Hypervisor → SO Host → Hardware
App B → SO Convidado → Hypervisor → SO Host → Hardware

# Abordagem Contêiner: Aplicações compartilham o kernel
App A → Runtime de Contêiner → SO Host → Hardware
App B → Runtime de Contêiner → SO Host → Hardware

Essa arquitetura leve torna os contêineres ideais para microsserviços, onde você pode executar centenas de pequenos serviços em vez de uma aplicação monolítica. A eficiência de recursos é impressionante — um servidor que executa 10 VMs pode executar confortavelmente 100 contêineres.

Dito isso, as VMs não estão obsoletas. Elas fornecem isolamento mais forte, pois cada VM tem seu próprio kernel. Para cargas de trabalho críticas de segurança ou quando você precisa executar diferentes sistemas operacionais, as VMs continuam sendo a melhor escolha. Muitas organizações usam ambas: VMs para isolamento de infraestrutura e contêineres para implantação de aplicações.

Conceitos Fundamentais do Docker

O Docker tem alguns conceitos-chave que você precisa entender antes de mergulhar em comandos e Dockerfiles. Esses blocos de construção formam a base de como o Docker funciona.

Imagens

Uma imagem Docker é um modelo somente leitura contendo o código da sua aplicação, runtime, bibliotecas e dependências. Pense nela como um snapshot ou blueprint. As imagens são construídas a partir de instruções em um Dockerfile e armazenadas em registros como o Docker Hub.

As imagens são compostas de camadas. Cada instrução em um Dockerfile cria uma nova camada. O Docker armazena essas camadas em cache, então se você reconstruir uma imagem e apenas a última camada mudou, o Docker reutiliza as camadas em cache. Isso torna as construções incrivelmente rápidas.

Contêineres

Um contêiner é uma instância em execução de uma imagem. Você pode criar múltiplos contêineres a partir da mesma imagem, e cada um executa isoladamente. Quando você para um contêiner, quaisquer alterações feitas dentro dele são perdidas, a menos que você as salve explicitamente ou use volumes.

Os contêineres são efêmeros por design. Essa imutabilidade é um recurso, não um bug — garante consistência e torna o escalonamento trivial.

Dockerfile

Um Dockerfile é um arquivo de texto contendo instruções para construir uma imagem Docker. Ele especifica a imagem base, copia seu código, instala dependências e define como executar sua aplicação. Vamos nos aprofundar em Dockerfiles em uma seção posterior.

Registro Docker

Um registro é um sistema de armazenamento e distribuição para imagens Docker. O Docker Hub é o registro público padrão, hospedando milhões de imagens. Você também pode executar registros privados para aplicações proprietárias. Quando você executa docker pull nginx, o Docker baixa a imagem nginx do Docker Hub.

Volumes

Volumes são o mecanismo do Docker para persistir dados. Como os contêineres são efêmeros, quaisquer dados gravados dentro de um contêiner desaparecem quando ele para. Os volumes permitem armazenar dados fora do sistema de arquivos do contêiner, sobrevivendo a reinicializações e exclusões de contêineres.

Comandos Essenciais do Docker

Vamos percorrer os comandos Docker que você usará diariamente. Eles cobrem todo o ciclo de vida do contêiner, desde baixar imagens até limpar recursos.

Trabalhando com Imagens

# Baixar uma imagem do Docker Hub
docker pull ubuntu:22.04

# Listar todas as imagens locais
docker images

# Remover uma imagem
docker rmi ubuntu:22.04

# Construir uma imagem a partir de um Dockerfile
docker build -t myapp:1.0 .

# Marcar uma imagem para enviar a um registro
docker tag myapp:1.0 username/myapp:1.0

# Enviar uma imagem para um registro
docker push username/myapp:1.0

Executando Contêineres

# Executar um contêiner em primeiro plano
docker run ubuntu:22.04 echo "Hello Docker"

# Executar um contêiner em modo desanexado (background)
docker run -d nginx

# Executar com um nome personalizado
docker run -d --name my-nginx nginx

# Executar com mapeamento de porta (host:contêiner)
docker run -d -p 8080:80 nginx

# Executar com variáveis de ambiente
docker run -d -e POSTGRES_PASSWORD=secret postgres

# Executar com montagem de volume
docker run -d -v /host/path:/container/path nginx

# Executar interativamente com um shell
docker run -it ubuntu:22.04 /bin/bash

Gerenciando Contêineres

# Listar contêineres em execução
docker ps

# Listar todos os contêineres (incluindo parados)
docker ps -a

# Parar um contêiner
docker stop my-nginx

# Iniciar um contêiner parado
docker start my-nginx

# Reiniciar um contêiner
docker restart my-nginx

# Remover um contêiner
docker rm my-nginx

# Remover um contêiner em execução (forçar)
docker rm -f my-nginx

# Ver logs do contêiner
docker logs my-nginx

# Seguir logs em tempo real
docker logs -f my-nginx

# Executar um comando em um contêiner em execução
docker exec my-nginx ls /usr/share/nginx/html

# Abrir um shell em um contêiner em execução
docker exec -it my-nginx /bin/bash

# Ver uso de recursos do contêiner
docker stats

# Inspecionar detalhes do contêiner
docker inspect my-nginx

Comandos de Limpeza

# Remover todos os contêineres parados
docker container prune

# Remover imagens não utilizadas
docker image prune

# Remover volumes não utilizados
docker volume prune

# Remover tudo não utilizado (contêineres, imagens, redes, volumes)
docker system prune -a

As flags -it merecem menção especial. -i mantém o STDIN aberto (interativo), e -t aloca um pseudo-TTY (terminal). Juntas, elas permitem interagir com o contêiner como uma sessão de shell normal.

Escrevendo Dockerfiles

Um Dockerfile é onde a mágica acontece. É uma receita para construir sua imagem Docker, especificando exatamente o que vai no seu contêiner. Vamos detalhar as instruções mais importantes e melhores práticas.

Estrutura Básica do Dockerfile

# Começar de uma imagem base
FROM node:18-alpine

# Definir o diretório de trabalho
WORKDIR /app

# Copiar arquivos de pacote
COPY package*.json ./

# Instalar dependências
RUN npm install

# Copiar código da aplicação
COPY . .

# Expor a porta em que sua aplicação executa
EXPOSE 3000

# Definir o comando para executar sua aplicação
CMD ["node", "server.js"]

Instruções Principais do Dockerfile

FROM especifica a imagem base. Sempre use tags de versão específicas (como node:18-alpine) em vez de latest para garantir construções reproduzíveis. Variantes Alpine são menores e mais seguras.

WORKDIR define o diretório de trabalho para instruções subsequentes. Ele cria o diretório se não existir. Isso é mais limpo do que usar RUN cd /app.

COPY copia arquivos da sua máquina host para a imagem. A sintaxe é COPY origem destino. Use COPY . . para copiar tudo, mas tenha cuidado com o que você inclui (use .dockerignore).

RUN executa comandos durante o processo de construção. Cada instrução RUN cria uma nova camada. Encadeie comandos com && para reduzir camadas:

# Ruim: Cria 3 camadas
RUN apt-get update
RUN apt-get install -y curl
RUN apt-get clean

# Bom: Cria 1 camada
RUN apt-get update && \
    apt-get install -y curl && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

EXPOSE documenta em qual porta sua aplicação escuta. Ele não publica a porta de fato — isso acontece com docker run -p.

CMD especifica o comando padrão a ser executado quando o contêiner inicia. Use o formato de array JSON (["executável", "param1"]) para evitar problemas de processamento de shell.

ENTRYPOINT é similar ao CMD, mas mais difícil de sobrescrever. Use-o quando quiser que seu contêiner se comporte como um executável. Você pode combinar ENTRYPOINT e CMD para padrões flexíveis.

Construções Multi-Estágio

Construções multi-estágio permitem usar múltiplas instruções FROM em um Dockerfile. Isso é incrivelmente poderoso para criar imagens de produção pequenas enquanto mantém as ferramentas de construção separadas.

# Estágio de construção
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Estágio de produção
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./
EXPOSE 3000
CMD ["node", "dist/server.js"]

A imagem de produção contém apenas o código compilado e dependências de runtime, não as ferramentas de construção. Isso pode reduzir o tamanho da imagem em 70% ou mais.

Arquivo .dockerignore

Crie um arquivo .dockerignore para excluir arquivos do contexto de construção. Isso acelera as construções e reduz o tamanho da imagem.

node_modules
npm-debug.log
.git
.env
*.md
.DS_Store
coverage
.vscode