Docker: 150 Comandos do Primeiro Container à Produção

Docker resolve um problema velho: "na minha máquina funciona". Ele empacota a aplicação com tudo de que ela precisa — runtime, bibliotecas, configuração — em uma imagem que roda igual em qualquer lugar.

Estes 150 comandos vão do primeiro docker run ao diagnóstico de container que morre em produção. Os exemplos usam a CLI moderna (docker container ...) mencionando o atalho clássico quando ele é o mais usado.

Container não é máquina virtual. Ele compartilha o kernel do host e isola só o que precisa (processos, rede, sistema de arquivos). É por isso que sobe em milissegundos e pesa megabytes em vez de gigabytes.

Índice

• 1–20 · Primeiros passos
• 21–42 · Imagens
• 43–64 · Containers no dia a dia
• 65–86 · Dockerfile
• 87–100 · Volumes e dados
• 101–114 · Redes
• 115–132 · Docker Compose
• 133–150 · Produção, segurança e diagnóstico

Primeiros passos

Verificar a instalação, subir o primeiro container e entender o que aconteceu.

1. Versão e informações

Confirma que o cliente conversa com o daemon.

docker version
docker info

2. Primeiro container

Baixa a imagem, cria o container, executa e sai. O "olá mundo" do Docker.

docker run hello-world

3. docker run

Cria e inicia um container a partir de uma imagem.

docker run nginx

4. Rodar em segundo plano

-d (detached) devolve o terminal e deixa o container rodando.

docker run -d nginx

5. Publicar porta

-p host:container expõe o serviço na sua máquina.

docker run -d -p 8080:80 nginx
# acesse http://localhost:8080

6. Dar nome ao container

Sem --name, o Docker inventa um nome aleatório e você perde tempo procurando.

docker run -d --name meu-nginx -p 8080:80 nginx

7. Modo interativo

-it conecta seu terminal ao container — indispensável para shell.

docker run -it ubuntu bash

8. Remover ao sair

--rm apaga o container assim que ele para. Ideal para teste rápido.

docker run --rm -it alpine sh

9. Variáveis de ambiente

A forma padrão de configurar aplicação em container.

docker run -d -e POSTGRES_PASSWORD=senha -e POSTGRES_DB=loja postgres:16

10. Variáveis de um arquivo

Evita expor segredo no histórico do shell.

docker run --env-file .env -d minha-app

11. Listar containers ativos

O comando que você mais vai digitar.

docker ps

12. Listar todos os containers

-a inclui os parados — onde costuma estar o que falhou.

docker ps -a

13. Formatar a saída do ps

Deixa a lista legível em terminal estreito.

docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

14. Parar e iniciar

stop envia SIGTERM e espera; start religa o mesmo container.

docker stop meu-nginx
docker start meu-nginx

15. Reiniciar

Atalho para stop + start.

docker restart meu-nginx

16. Matar container

SIGKILL imediato, sem encerramento gracioso. Último recurso.

docker kill meu-nginx

17. Remover container

Apaga o container parado; -f força mesmo em execução.

docker rm meu-nginx
docker rm -f meu-nginx

18. Ver logs

A primeira coisa a fazer quando algo não funciona.

docker logs meu-nginx

19. Acompanhar logs ao vivo

-f segue a saída; --tail limita o histórico inicial.

docker logs -f --tail 100 meu-nginx

20. Executar comando em container rodando

Abre um shell dentro do container em execução.

docker exec -it meu-nginx bash
docker exec -it meu-alpine sh   # imagens Alpine não têm bash

Imagens

A imagem é o molde; o container é a instância em execução.

21. Listar imagens

Mostra o que está baixado e quanto ocupa.

docker images
docker image ls

22. Baixar imagem

Traz do registro sem executar.

docker pull postgres:16

23. Tags de versão

Nunca use latest em produção: ela muda sem aviso e quebra o que funcionava.

docker pull node:20-alpine
docker pull node:20.11.1-alpine3.19   # ainda mais específico

24. Buscar imagem

Procura no Docker Hub pela linha de comando.

docker search postgres

25. Construir imagem

Lê o Dockerfile do diretório e gera a imagem com a tag informada.

docker build -t minha-app:1.0 .

26. Build com Dockerfile específico

Quando há mais de um (produção, desenvolvimento, teste).

docker build -f Dockerfile.prod -t minha-app:prod .

27. Build sem cache

Força refazer todas as camadas — útil quando o cache está mascarando um problema.

docker build --no-cache -t minha-app:1.0 .

28. Build com argumentos

ARG parametriza o build (não confundir com ENV, que vale em execução).

docker build --build-arg NODE_VERSION=20 -t minha-app .

29. Marcar com outra tag

A mesma imagem pode ter vários nomes.

docker tag minha-app:1.0 usuario/minha-app:latest

30. Enviar para o registro

Publica no Docker Hub ou em registro privado.

docker login
docker push usuario/minha-app:1.0

31. Registro privado

O nome da imagem carrega o endereço do registro.

docker tag minha-app registry.empresa.com/time/minha-app:1.0
docker push registry.empresa.com/time/minha-app:1.0

32. Remover imagem

Só sai se nenhum container depender dela.

docker rmi minha-app:1.0
docker image rm -f minha-app:1.0

33. Histórico de camadas

Mostra cada camada e seu tamanho — é assim que se descobre o que engordou a imagem.

docker history minha-app:1.0

34. Inspecionar imagem

Metadados completos: variáveis, entrypoint, portas, camadas.

docker inspect minha-app:1.0

35. Exportar e importar imagem

Move imagem entre máquinas sem registro, por arquivo.

docker save -o minha-app.tar minha-app:1.0
docker load -i minha-app.tar

36. Imagens pendentes (dangling)

Camadas órfãs de builds antigos, que só ocupam disco.

docker images -f "dangling=true"
docker image prune

37. Limpar imagens sem uso

-a remove todas as que não têm container associado. Libera muito espaço.

docker image prune -a

38. Imagens base enxutas

Alpine tem ~5 MB; distroless não tem nem shell. Menos superfície, menos vulnerabilidade.

# 1.1 GB
FROM node:20
# 130 MB
FROM node:20-alpine
# ~50 MB, sem shell nem gerenciador de pacotes
FROM gcr.io/distroless/nodejs20-debian12

39. Escanear vulnerabilidades

Verifica CVEs conhecidas nas dependências da imagem.

docker scout cves minha-app:1.0
trivy image minha-app:1.0

40. Ver o tamanho real

Compara o tamanho das imagens para achar a gorda.

docker images --format "{{.Repository}}:{{.Tag}}\t{{.Size}}" | sort -k2 -h

41. Extrair arquivo de uma imagem

Cria um container temporário só para copiar algo de dentro.

id=$(docker create minha-app:1.0)
docker cp $id:/app/dist ./dist
docker rm $id

42. Multiplataforma (buildx)

Gera a mesma imagem para amd64 e arm64 — necessário para Apple Silicon e Graviton.

docker buildx build --platform linux/amd64,linux/arm64 -t usuario/app:1.0 --push .

Containers no dia a dia

Inspecionar, copiar, limitar e entender o que está acontecendo lá dentro.

43. Inspecionar container

JSON completo: rede, volumes, variáveis, estado, código de saída.

docker inspect meu-nginx

44. Extrair um campo do inspect

Com template Go, você pega só o que precisa.

docker inspect -f '{{.State.Status}}' meu-nginx
docker inspect -f '{{.NetworkSettings.IPAddress}}' meu-nginx

45. Uso de recursos ao vivo

CPU, memória, rede e I/O de cada container — o top do Docker.

docker stats
docker stats --no-stream

46. Processos do container

O que está rodando lá dentro, visto do host.

docker top meu-nginx

47. Copiar arquivos

Move arquivos entre host e container nos dois sentidos.

docker cp ./config.json meu-nginx:/etc/app/config.json
docker cp meu-nginx:/var/log/nginx/error.log ./error.log

48. Ver o que mudou no sistema de arquivos

Lista arquivos criados (A), alterados (C) e removidos (D) desde a imagem.

docker diff meu-nginx

49. Limitar memória

Sem limite, um container pode derrubar o host inteiro.

docker run -d --memory 512m --memory-swap 512m minha-app

50. Limitar CPU

--cpus define quantos núcleos o container pode usar.

docker run -d --cpus 1.5 minha-app

51. Política de reinício

Faz o container voltar sozinho depois de falha ou reboot.

docker run -d --restart unless-stopped minha-app
# opções: no | on-failure | on-failure:3 | always | unless-stopped

52. Healthcheck

O Docker passa a saber se o container está saudável, não só no ar.

docker run -d --health-cmd "curl -f http://localhost/health || exit 1" \
  --health-interval 30s --health-retries 3 minha-app

53. Ver o estado de saúde

Mostra o resultado das últimas verificações.

docker inspect -f '{{.State.Health.Status}}' minha-app

54. Código de saída

Diz por que o container morreu — 137 é OOM/kill, 1 é erro da aplicação.

docker inspect -f '{{.State.ExitCode}}' minha-app
docker ps -a --filter "exited=137"

55. Executar como outro usuário

Entra no container com um usuário específico (útil para depurar permissão).

docker exec -u root -it minha-app sh

56. Rodar com usuário não-root

Container rodando como root é risco desnecessário.

docker run -d --user 1000:1000 minha-app

57. Renomear container

Sem recriar nada.

docker rename nome-antigo nome-novo

58. Pausar e retomar

Congela os processos sem encerrar o container.

docker pause minha-app
docker unpause minha-app

59. Esperar o container terminar

Bloqueia até a saída e devolve o código — útil em script.

docker wait minha-app

60. Eventos do daemon

Fluxo ao vivo de tudo que acontece: criação, morte, health, rede.

docker events --filter container=minha-app

61. Portas publicadas

Descobre para onde o container está mapeado.

docker port meu-nginx

62. Remover todos os containers parados

Limpeza rotineira.

docker container prune

63. Parar tudo de uma vez

Emergência ou fim de expediente.

docker stop $(docker ps -q)

64. Commitar container em imagem

Congela o estado atual como imagem. Serve para depuração — nunca como forma de construir imagem.

docker commit minha-app minha-app:debug

Dockerfile

A receita da imagem. Cada instrução vira uma camada — e a ordem importa muito.

65. FROM

Imagem base. Primeira instrução de todo Dockerfile.

FROM node:20-alpine

66. WORKDIR

Define o diretório de trabalho e o cria se não existir. Melhor que RUN cd.

WORKDIR /app

67. COPY

Copia do contexto de build para dentro da imagem.

COPY package.json package-lock.json ./
COPY src ./src

68. ADD

Como o COPY, mas também baixa URL e descompacta tar. Prefira COPY: menos surpresa.

ADD https://exemplo.com/arquivo.tar.gz /tmp/

69. RUN

Executa um comando no build e congela o resultado em uma camada.

RUN npm ci --omit=dev

70. Encadear RUN

Cada RUN é uma camada. Junte comandos relacionados e limpe na mesma linha.

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

71. Ordem das camadas (cache)

O truque que mais acelera build: copie o manifesto e instale antes de copiar o código.

COPY package*.json ./
RUN npm ci            # só refaz quando as dependências mudam
COPY . .              # muda a cada commit, mas é a última camada

72. ENV

Variável de ambiente disponível no build e na execução.

ENV NODE_ENV=production PORT=3000

73. ARG

Variável só do build. Não fica na imagem final — mas aparece no histórico, então nada de segredo.

ARG NODE_VERSION=20
FROM node:${NODE_VERSION}-alpine

74. EXPOSE

Documenta a porta usada. Não publica nada sozinho — quem publica é o -p.

EXPOSE 3000

75. CMD

Comando padrão do container, substituível na linha de comando.

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

76. ENTRYPOINT

Comando fixo. Combinado com CMD, vira "programa + argumentos padrão".

ENTRYPOINT ["node"]
CMD ["server.js"]

77. Forma exec x shell

Use sempre a forma exec (JSON): na forma shell o processo vira filho do /bin/sh e não recebe os sinais.

CMD ["node", "server.js"]     # exec — recebe SIGTERM
CMD node server.js            # shell — não recebe

78. USER

Troca o usuário. Tudo depois disso roda sem root.

RUN addgroup -S app && adduser -S app -G app
USER app

79. VOLUME

Marca um diretório como ponto de montagem de dado persistente.

VOLUME ["/var/lib/postgresql/data"]

80. HEALTHCHECK

Ensina o Docker a verificar se a aplicação está mesmo respondendo.

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1

81. LABEL

Metadados da imagem: versão, autor, origem do código.

LABEL org.opencontainers.image.source="https://github.com/usuario/projeto"

82. .dockerignore

Reduz o contexto de build. Sem ele, você manda node_modules e .git para o daemon a cada build.

node_modules
.git
.env
dist
*.log

83. Multi-stage build

Compila em uma etapa e copia só o resultado para a imagem final. Corta centenas de MB.

FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/node_modules ./node_modules
USER node
CMD ["node", "dist/server.js"]

84. Copiar de outra imagem

--from aceita qualquer imagem, não só um estágio anterior.

COPY --from=nginx:alpine /etc/nginx/nginx.conf /etc/nginx/nginx.conf

85. Cache de dependências (BuildKit)

Mantém o cache do gerenciador entre builds, sem inchar a imagem.

RUN --mount=type=cache,target=/root/.npm npm ci

86. Segredo no build

Usa a credencial durante o build sem gravá-la em nenhuma camada.

RUN --mount=type=secret,id=npmrc,target=/root/.npmrc npm ci
# docker build --secret id=npmrc,src=$HOME/.npmrc .

Volumes e dados

Container é descartável; dado não pode ser. É para isso que existem os volumes.

87. Criar volume

Volume nomeado, gerenciado pelo Docker.

docker volume create dados-postgres

88. Listar e inspecionar

Mostra onde o volume vive no host.

docker volume ls
docker volume inspect dados-postgres

89. Usar volume no container

O dado sobrevive à remoção do container.

docker run -d -v dados-postgres:/var/lib/postgresql/data postgres:16

90. Bind mount

Monta uma pasta do host. É o que dá hot reload no desenvolvimento.

docker run -d -v $(pwd)/src:/app/src minha-app

91. Sintaxe --mount

Mais explícita que -v e recomendada em scripts.

docker run -d --mount type=bind,source=$(pwd)/src,target=/app/src minha-app

92. Montagem somente leitura

Container que não deveria escrever, não escreve.

docker run -d -v $(pwd)/config:/app/config:ro minha-app

93. Volume x bind mount

Volume para dado de produção (o Docker gerencia); bind mount para código em desenvolvimento.

# produção
docker run -v dados:/var/lib/mysql mysql:8
# desenvolvimento
docker run -v $(pwd):/app node:20 npm run dev

94. tmpfs

Sistema de arquivos em memória: some quando o container para. Bom para dado sensível.

docker run -d --tmpfs /tmp:rw,size=64m minha-app

95. Backup de volume

Container temporário que empacota o conteúdo do volume.

docker run --rm -v dados-postgres:/dados -v $(pwd):/backup alpine \
  tar czf /backup/dados-postgres.tar.gz -C /dados .

96. Restaurar volume

Caminho inverso do backup.

docker run --rm -v dados-postgres:/dados -v $(pwd):/backup alpine \
  tar xzf /backup/dados-postgres.tar.gz -C /dados

97. Remover volume

Volume não some junto com o container — é preciso apagar de propósito.

docker volume rm dados-postgres

98. Limpar volumes órfãos

Cuidado: isso apaga dado de verdade. Confira a lista antes.

docker volume ls -f dangling=true
docker volume prune

99. Remover container com o volume

-v apaga os volumes anônimos daquele container.

docker rm -v minha-app

100. Permissão em bind mount

Erro clássico no Linux: o UID de dentro não é o mesmo de fora.

docker run -d --user $(id -u):$(id -g) -v $(pwd):/app minha-app

Redes

Como os containers conversam entre si e com o mundo.

101. Listar redes

Toda instalação já vem com bridge, host e none.

docker network ls

102. Criar rede

Rede própria do projeto: os containers se enxergam pelo nome.

docker network create minha-rede

103. Conectar container à rede

Na criação ou depois, com o container já rodando.

docker run -d --network minha-rede --name api minha-app
docker network connect minha-rede outro-container

104. DNS interno

Dentro da rede, o nome do container é o host. Não use IP.

# de dentro do container "api":
curl http://banco:5432
# em vez de http://172.18.0.3:5432

105. Inspecionar rede

Mostra a faixa de IP e quem está conectado.

docker network inspect minha-rede

106. Desconectar e remover

Rede em uso não pode ser removida.

docker network disconnect minha-rede api
docker network rm minha-rede

107. Modo host

Sem isolamento de rede: o container usa a pilha do host. Rápido, porém sem isolamento (Linux).

docker run -d --network host nginx

108. Sem rede

Isolamento total. Bom para processar dado não confiável.

docker run --rm --network none alpine ip addr

109. Publicar em interface específica

Expõe só no localhost, não na rede inteira.

docker run -d -p 127.0.0.1:8080:80 nginx

110. Publicar faixa e UDP

Também dá para expor intervalos e outro protocolo.

docker run -d -p 8000-8010:8000-8010 minha-app
docker run -d -p 53:53/udp meu-dns

111. Acessar o host de dentro do container

host.docker.internal resolve para a máquina hospedeira.

curl http://host.docker.internal:5432

112. Descobrir o IP do container

Quando você realmente precisa dele.

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' api

113. Testar conectividade

Container descartável só para diagnosticar a rede.

docker run --rm --network minha-rede alpine ping -c 3 banco
docker run --rm --network minha-rede nicolaka/netshoot nslookup api

114. Limpar redes sem uso

Limpeza de rotina.

docker network prune

Docker Compose

Vários containers descritos em um arquivo e subidos com um comando.

115. compose.yaml básico

Descreve serviços, portas, variáveis e dependências.

services:
  api:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://app:senha@banco:5432/loja
    depends_on:
      banco:
        condition: service_healthy

  banco:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: senha
      POSTGRES_DB: loja
    volumes:
      - dados:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app"]
      interval: 5s
      retries: 5

volumes:
  dados:

116. Subir tudo

-d em segundo plano; sem ele, os logs ficam no terminal.

docker compose up -d

117. Subir reconstruindo

Força rebuild das imagens antes de subir.

docker compose up -d --build

118. Derrubar

down remove containers e redes; com -v, apaga também os volumes.

docker compose down
docker compose down -v   # apaga os dados!

119. Ver serviços

Status de cada serviço da stack.

docker compose ps

120. Logs da stack

Todos os serviços juntos, ou um específico.

docker compose logs -f
docker compose logs -f api --tail 100

121. Executar comando em um serviço

exec no container em execução; run cria um novo.

docker compose exec api sh
docker compose run --rm api npm run migrate

122. Reiniciar um serviço

Sem mexer no resto da stack.

docker compose restart api

123. Escalar réplicas

Sobe várias instâncias do mesmo serviço.

docker compose up -d --scale worker=3

124. Validar o arquivo

Mostra a configuração final, com variáveis já resolvidas.

docker compose config

125. Vários arquivos

Um base e um por ambiente — o segundo sobrescreve o primeiro.

docker compose -f compose.yaml -f compose.prod.yaml up -d

126. Arquivo .env

O Compose lê o .env do diretório automaticamente.

# .env
POSTGRES_PASSWORD=senha-forte

# compose.yaml
environment:
  POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}

127. Profiles

Serviços que só sobem quando você pede — como ferramentas de desenvolvimento.

services:
  adminer:
    image: adminer
    profiles: ["dev"]

# docker compose --profile dev up -d

128. depends_on com healthcheck

Sem condition, o Compose só espera o container iniciar, não ficar pronto.

depends_on:
  banco:
    condition: service_healthy

129. Limites de recursos

Evita que um serviço consuma a máquina toda.

deploy:
  resources:
    limits:
      cpus: "1.5"
      memory: 512M

130. Parar sem remover

Mantém os containers para religar depois.

docker compose stop
docker compose start

131. Baixar imagens da stack

Atualiza as imagens antes de subir.

docker compose pull

132. Ver o consumo da stack

stats filtrado pelos containers do projeto.

docker compose top
docker stats $(docker compose ps -q)

Produção, segurança e diagnóstico

O que separa um container que roda na sua máquina de um que aguenta produção.

133. Uso de disco do Docker

Mostra quanto imagens, containers, volumes e cache estão ocupando.

docker system df
docker system df -v

134. Limpeza geral

-a também remove imagens sem container. Confira antes — --volumes apaga dados.

docker system prune
docker system prune -a
docker system prune -a --volumes

135. Limitar o tamanho dos logs

Log de container cresce sem limite e enche o disco do servidor. Este é o erro nº 1 em produção.

# /etc/docker/daemon.json
{
  "log-driver": "json-file",
  "log-opts": { "max-size": "10m", "max-file": "3" }
}

136. Rodar sem root

Container root + volume no host = risco real de comprometer a máquina.

USER node               # no Dockerfile
docker run --user 1000:1000 minha-app

137. Sistema de arquivos somente leitura

Se a aplicação não precisa escrever, não deixe.

docker run -d --read-only --tmpfs /tmp minha-app

138. Descartar capabilities

Remove privilégios do kernel que a aplicação não usa.

docker run -d --cap-drop ALL --cap-add NET_BIND_SERVICE nginx

139. Impedir escalada de privilégio

Bloqueia binário com setuid ganhando privilégio dentro do container.

docker run -d --security-opt no-new-privileges minha-app

140. Nunca use --privileged

Equivale a dar root do host ao container. Só em casos muito específicos e conscientes.

# evite
docker run --privileged minha-app

141. Não exponha o socket do Docker

Montar /var/run/docker.sock dá controle total do host a quem estiver no container.

# perigoso
docker run -v /var/run/docker.sock:/var/run/docker.sock minha-app

142. Encerramento gracioso

O Docker manda SIGTERM e espera 10s antes do SIGKILL. Sua aplicação precisa tratar o sinal.

docker stop -t 30 minha-app

143. Init para zumbis

--init insere um init mínimo que recolhe processos órfãos.

docker run -d --init minha-app

144. Container que reinicia sem parar

Veja o log da execução anterior para achar a causa.

docker ps -a
docker logs --tail 200 minha-app
docker inspect -f '{{.State.ExitCode}} {{.State.Error}}' minha-app

145. Diagnosticar OOM

Exit 137 quase sempre é falta de memória.

docker inspect -f '{{.State.OOMKilled}}' minha-app
docker stats --no-stream minha-app

146. Depurar imagem sem shell

Distroless não tem shell: use um container auxiliar no mesmo namespace.

docker run --rm -it --pid container:minha-app --network container:minha-app \
  nicolaka/netshoot sh

147. Testar a imagem localmente

Rode como produção antes de publicar: sem bind mount, com as variáveis reais.

docker run --rm -p 3000:3000 --env-file .env.production minha-app:1.0

148. Registro e versão imutável

Publique com tag de versão e faça o deploy pelo digest — garantia de que é exatamente aquela imagem.

docker push usuario/app:1.4.2
docker inspect --format='{{index .RepoDigests 0}}' usuario/app:1.4.2

149. Docker no CI

Build e push dentro do pipeline, com cache entre execuções.

docker buildx build --push \
  --cache-from type=registry,ref=usuario/app:cache \
  --cache-to type=registry,ref=usuario/app:cache,mode=max \
  -t usuario/app:$GIT_SHA .

150. Quando ir para o Kubernetes

Compose resolve um servidor. Vários nós, escala automática e rolling update pedem orquestrador.

# Compose: 1 host, stack simples, time pequeno
# Kubernetes: múltiplos nós, autoscaling, deploy sem downtime