Docker na prática: instalar, criar sua primeira imagem e subir app com banco

Docker é a ferramenta que empacota uma aplicação e tudo de que ela precisa (bibliotecas, runtime, configuração) em uma imagem, e roda essa imagem como um container isolado. O mesmo pacote funciona no notebook, no servidor e na nuvem, o que acaba com o clássico "na minha máquina funciona".

Este tutorial vai do zero até uma aplicação web com banco de dados, em sete passos. Os comandos foram conferidos na documentação oficial do Docker em outubro de 2026, quando a versão mais recente do Docker Engine era a 29.9.1, lançada em 14 de outubro de 2026 segundo as notas de versão.

Antes de começar: imagem, container e o que muda em relação a uma VM

Três termos aparecem o tempo todo:

• Imagem: o pacote somente leitura, montado em camadas a partir de um arquivo chamado Dockerfile.
• Container: uma instância em execução de uma imagem. Da mesma imagem saem quantos containers você quiser.
• Registro: onde as imagens ficam guardadas para download, como o Docker Hub ou os registros de cada nuvem.

O container não carrega um sistema operacional inteiro. Ele usa o kernel do Linux da máquina hospedeira, com isolamento de processos, rede e limites de CPU e memória. Por isso sobe em segundos e ocupa megabytes, enquanto uma máquina virtual traz o próprio kernel e costuma ocupar gigabytes.

Os dois convivem: na nuvem, a maior parte dos containers roda dentro de VMs. O papel de cada camada está em o que é computação em nuvem.

Passo 1: instale o Docker Engine no Ubuntu

No Linux, o caminho recomendado é o repositório oficial do Docker. Em outubro de 2026, a documentação lista suporte a Ubuntu 22.04 LTS, 24.04 LTS, 26.04 LTS e 26.10, em 64 bits. Primeiro, remova pacotes antigos que conflitam:

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-compose-v2 docker-doc docker-buildx podman-docker containerd runc | cut -f1)

Depois, adicione a chave e o repositório oficial:

sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Confira se funcionou:

sudo systemctl status docker
sudo docker run hello-world

Existe um script de conveniência (get.docker.com), mas a própria documentação diz que ele é para testes e desenvolvimento e não foi feito para atualizar uma instalação existente. Em servidor de produção, prefira o repositório.

Usar sem sudo, sabendo o que isso significa

Para rodar comandos sem sudo, a documentação de pós-instalação manda adicionar seu usuário ao grupo docker:

sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker
docker run hello-world

O aviso oficial é direto: o grupo docker concede privilégios equivalentes a root. Só coloque nele usuários em quem você confiaria a senha de administrador do servidor.

E no Windows ou no Mac?

Nesses sistemas, o caminho comum é o Docker Desktop, que roda os containers Linux numa camada de virtualização. Ele não é gratuito para todo mundo: em outubro de 2026, a licença permite uso gratuito para uso pessoal, educação, projetos open source não comerciais e empresas com menos de 250 funcionários e menos de US$ 10 milhões de receita anual. Acima disso, é preciso uma assinatura paga (Pro, Team ou Business). O Docker Engine no Linux é open source e não entra nessa regra.

Passo 2: rode um servidor web e publique a porta com segurança

O primeiro container útil é um servidor Nginx:

docker run -d --name web -p 127.0.0.1:8080:80 nginx:stable

O -d deixa o container rodando em segundo plano, --name dá um nome fácil de lembrar e -p liga a porta 8080 da máquina à porta 80 do container. Abra http://localhost:8080 e a página padrão do Nginx aparece.

O 127.0.0.1 no início não é detalhe. A documentação do Docker avisa que publicar portas "é inseguro por padrão": sem o endereço, a porta fica acessível para qualquer um que alcance a máquina. Em servidores com o firewall ufw, a documentação de instalação alerta que as portas publicadas pelo Docker passam por fora das regras do ufw. Num VPS exposto à internet, publique em 127.0.0.1 e coloque um proxy reverso na frente.

Para parar e remover:

docker stop web
docker rm web

Passo 3: crie sua própria imagem com um Dockerfile

Agora uma aplicação sua. Crie uma pasta com três arquivos.

app.py:

from flask import Flask

app = Flask(__name__)

@app.get("/")
def inicio():
    return "Olá do container!"

requirements.txt:

flask

Dockerfile:

FROM python:3.13-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
RUN useradd --create-home appuser
USER appuser
EXPOSE 8000
CMD ["flask", "--app", "app", "run", "--host=0.0.0.0", "--port=8000"]

Três escolhas desse Dockerfile evitam problemas comuns:

1. Copiar requirements.txt antes do código. Cada instrução gera uma camada em cache; se só o app.py mudar, o Docker reaproveita a camada das dependências e o build fica muito mais rápido.
2. Imagem slim. A variante enxuta da imagem oficial do Python tem menos pacotes, o que reduz o tamanho e a superfície de ataque.
3. USER appuser. O processo deixa de rodar como root dentro do container.

Construa e rode:

docker build -t minha-api:1.0 .
docker run -d --name api -p 127.0.0.1:8000:8000 minha-api:1.0
curl http://localhost:8000

O servidor embutido do Flask serve para desenvolvimento. Em produção, troque o CMD por um servidor WSGI, como o Gunicorn, adicionado ao requirements.txt.

Passo 4: guarde dados em volumes

Tudo o que é gravado dentro do container some quando ele é removido. Para dados que precisam sobreviver, como um banco, use um volume nomeado:

docker volume create dados-pg
docker run -d --name banco \
  -e POSTGRES_PASSWORD=troque-esta-senha \
  -v dados-pg:/var/lib/postgresql \
  postgres:18

Se você remover e recriar o container banco apontando para o mesmo volume, os dados continuam lá. Volume não é backup: ele fica no mesmo disco da máquina. Copie os dados para outro lugar com a ferramenta do próprio banco (no PostgreSQL, pg_dump).

Passo 5: suba aplicação e banco juntos com o Compose

Digitar docker run com dez opções não escala. O Docker Compose descreve os serviços em um arquivo compose.yaml, e o exemplo abaixo segue o padrão da documentação oficial para fazer a aplicação esperar o banco ficar pronto:

services:
  api:
    build: .
    ports:
      - "127.0.0.1:8000:8000"
    environment:
      DATABASE_URL: postgresql://app:${DB_PASSWORD}@db:5432/app
    depends_on:
      db:
        condition: service_healthy
        restart: true

  db:
    image: postgres:18
    environment:
      POSTGRES_USER: app
      POSTGRES_DB: app
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - dados-pg:/var/lib/postgresql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 10s
      retries: 5
      start_period: 30s
      timeout: 10s

volumes:
  dados-pg:

A senha vem de um arquivo .env na mesma pasta (DB_PASSWORD=...), que não deve ir para o repositório Git. Dentro da rede criada pelo Compose, a aplicação encontra o banco pelo nome do serviço, db. Comandos do dia a dia:

docker compose up -d        # cria e sobe tudo
docker compose ps           # estado dos serviços
docker compose logs -f api  # acompanha os logs da aplicação
docker compose down         # para e remove os containers (o volume fica)

O Compose resolve bem uma máquina só. Quando a aplicação precisa de vários servidores, recuperação automática e atualização sem parada, o próximo degrau é a orquestração, tema do guia sobre Kubernetes.

Passo 6: investigue quando algo dá errado

Passo 7: os erros que mais travam iniciantes

• "permission denied" no socket do Docker. Seu usuário não está no grupo docker ou a sessão não foi reiniciada depois do usermod. Rode newgrp docker ou saia e entre de novo.
• "port is already allocated". Outro processo ou container já usa a porta. Escolha outra porta do lado esquerdo do -p ou pare o que está ocupando.
• Container que sobe e para na hora. O processo principal terminou ou falhou. Leia docker logs; um container só vive enquanto o comando do CMD estiver rodando.
• Limite de downloads do Docker Hub. Em outubro de 2026, a documentação informa 100 pulls a cada 6 horas para usuários sem login (por endereço IPv4 ou sub-rede IPv6 /64) e 200 para contas Personal autenticadas. Servidores de CI que baixam muitas imagens devem fazer login ou usar um registro próprio.
• Usar a tag latest em produção. Ela muda sem aviso. Fixe a versão (postgres:18, minha-api:1.0) para saber exatamente o que está rodando.
• Senha dentro da imagem. Qualquer pessoa com acesso à imagem consegue ler as camadas. Passe segredos por variável de ambiente, arquivo .env fora do Git ou o mecanismo de segredos da plataforma.
• Disco cheio depois de meses. Imagens antigas e logs se acumulam. Acompanhe com docker system df e limpe com os comandos prune.

Containers também ajudam a testar ferramentas sem instalar nada no sistema; o guia para rodar IA local com o Ollama é um exemplo de serviço que tem imagem oficial. Para cuidar do servidor onde tudo isso roda, veja o checklist de VPS e hospedagem.

Fontes

• Docker Docs. Install Docker Engine on Ubuntu.
• Docker Docs. Linux post-installation steps.
• Docker Docs. Docker Engine release notes.
• Docker Docs. Port publishing and mapping.
• Docker Docs. Control startup order in Compose.
• Docker Docs. Docker Desktop license agreement.
• Docker Docs. Docker Hub usage and limits.
• Docker Docs. Dockerfile reference.