Este guia de referência rápida (Cheat Sheet) compila os comandos Docker mais utilizados, organizados por funcionalidade, para otimizar o desenvolvimento e a administração de ambientes conteinerizados.

# Verifica o status atual do serviço Docker no sistema operacional (Systemd)
sudo systemctl status docker
 
# Exibe informações detalhadas sobre a versão do cliente e do servidor (daemon) Docker
docker version
# Exibe apenas a versão do cliente Docker
docker --version
 
# Apresenta um resumo detalhado das configurações do sistema Docker (armazenamento, rede, etc.)
docker info
 
# Exibe um fluxo em tempo real do uso de recursos (CPU, Memória, I/O de Rede) dos containers ativos
docker stats
 
# Lista os processos em execução dentro de um container específico
docker top <container_id>
 
# Exibe um fluxo em tempo real dos eventos do daemon Docker (criação, início, parada, etc.)
docker events
 
# Lista containers ativos com um formato de tabela personalizado (ID, Nome, Status, Portas)
docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"
 
# Retorna informações de baixo nível em formato JSON sobre um objeto Docker (container, imagem, volume, rede)
docker inspect <nome_ou_id>

# Listagem de Containers
docker ps              # Lista todos os containers atualmente em execução
docker ps -a           # Lista todos os containers, incluindo aqueles que foram parados
docker ps -aq          # Lista apenas os IDs de todos os containers (útil para encadeamento de comandos)
docker ps -f "status=running"  # Lista containers ativos, aplicando filtros (ex: status=running)
 
# Controle de Containers
docker start <container>       # Inicia um ou mais containers parados
docker stop <container>        # Envia um sinal SIGTERM para parar um container de forma graciosa
docker restart <container>     # Para e inicia um container especificado
docker pause <container>       # Suspende todos os processos em um container
docker unpause <container>     # Retoma todos os processos em um container pausado
 
# Remoção de Containers
docker rm <container>          # Remove um container parado
docker rm -f <container>       # Força a remoção de um container em execução (enviando SIGKILL)
docker rm -f $(docker ps -aq)  # Remove todos os containers (ativos e parados) forçadamente
 
# Execução de Comandos
docker exec -it <container> bash         # Abre um terminal interativo (shell) dentro do container
docker exec <container> ls -la           # Executa um comando único no container
docker exec -u root <container> bash     # Executa um comando como o usuário 'root' dentro do container
 
# Operações de Arquivos
docker cp <container>:<caminho> <local>  # Copia arquivos do container para o host
docker cp <local> <container>:<caminho>  # Copia arquivos do host para o container
 
# Outras Operações
docker rename <antigo> <novo>            # Renomeia um container existente
docker export <container> > arquivo.tar  # Exporta o sistema de arquivos de um container para um arquivo TAR
docker import arquivo.tar                # Cria uma imagem a partir de um arquivo TAR exportado

# Listagem de Imagens
docker images
docker image ls                        # Alias para docker images
docker images -a                       # Lista todas as imagens, incluindo as camadas intermediárias (dangling)
 
# Obtenção de Imagens
docker pull <imagem>:<tag>             # Baixa uma imagem específica de um registry (ex: Docker Hub)
docker pull <imagem>:latest            # Baixa a imagem com a tag 'latest' (padrão se a tag for omitida)
 
# Remoção de Imagens
docker rmi <imagem_id>                 # Remove uma imagem pelo ID (apenas se não estiver em uso)
docker rmi -f <imagem_id>              # Força a remoção de uma imagem
docker image prune                     # Remove imagens não utilizadas (sem tags e não referenciadas por containers)
docker image prune -a                  # Remove todas as imagens não utilizadas, incluindo as camadas intermediárias
 
# Construção de Imagens (Build)
docker build -t nome:tag .             # Constrói uma imagem a partir do Dockerfile no diretório atual, atribuindo uma tag
docker build --no-cache -t nome:tag .  # Constrói a imagem sem usar o cache de camadas
docker build --build-arg VAR=valor .   # Passa variáveis de ambiente (build-args) para o processo de construção
 
# Distribuição de Imagens
docker tag <imagem_id> novo:tag        # Cria uma nova tag para uma imagem existente
docker push usuario/repositorio:tag    # Envia a imagem para um registry remoto (ex: Docker Hub)
 
# Backup e Restauração de Imagens
docker save -o imagem.tar nome:tag     # Salva uma ou mais imagens em um arquivo TAR (inclui metadados e histórico)
docker load -i imagem.tar              # Carrega imagens de um arquivo TAR
 
# Histórico
docker history <imagem>                # Exibe o histórico de camadas e comandos usados para construir a imagem

# Listagem de Volumes
docker volume ls
docker volume ls -q                    # Lista apenas os nomes dos volumes
 
# Criação de Volumes
docker volume create <nome>            # Cria um volume nomeado para persistência de dados
 
# Inspeção
docker volume inspect <nome>           # Exibe informações detalhadas sobre o volume, incluindo o ponto de montagem no host
 
# Remoção de Volumes
docker volume rm <nome>                # Remove um volume específico (apenas se não estiver em uso)
docker volume prune                    # Remove todos os volumes não utilizados (não referenciados por containers)
 
# Backup de Volume (Exemplo)
# Cria um backup compactado do volume para o diretório atual do host
docker run --rm -v <volume>:/data -v $(pwd):/backup alpine tar czf /backup/backup.tar.gz /data
 
# Restauração de Volume (Exemplo)
# Restaura o conteúdo de um backup compactado para o volume
docker run --rm -v <volume>:/data -v $(pwd):/backup alpine sh -c "tar xzf /backup/backup.tar.gz -C /data"

# Listagem de Networks
docker network ls                      # Lista todas as redes Docker disponíveis
 
# Criação de Networks
docker network create <nome>           # Cria uma nova rede (padrão: bridge)
docker network create --driver bridge <nome> # Cria uma rede do tipo bridge (isolamento de containers no mesmo host)
docker network create --subnet 172.20.0.0/16 <nome> # Cria uma rede com um bloco de IP específico
 
# Inspeção
docker network inspect <nome>          # Exibe informações detalhadas sobre a rede, incluindo containers conectados
 
# Conexão/Desconexão
docker network connect <network> <container>    # Conecta um container a uma rede existente
docker network disconnect <network> <container> # Desconecta um container de uma rede
 
# Remoção de Networks
docker network rm <nome>               # Remove uma rede específica (apenas se não houver containers conectados)
docker network prune                   # Remove todas as redes não utilizadas

# Limpeza Completa (Cuidado: remove dados não utilizados)
# Remove containers parados, imagens sem tag, volumes não utilizados e redes não utilizadas
docker system prune -a --volumes       
# Força a remoção completa sem solicitar confirmação
docker system prune -af                
 
# Limpeza Seletiva
docker container prune                 # Remove containers parados
docker image prune                     # Remove imagens sem tag (dangling)
docker volume prune                    # Remove volumes não utilizados
docker network prune                   # Remove redes não utilizadas
docker builder prune                   # Limpa o cache de build do BuildKit
 
# Análise de Uso de Espaço
docker system df                       # Exibe um resumo do espaço em disco usado por objetos Docker
docker system df -v                    # Exibe o uso de espaço de forma detalhada
 
# Remoção de Containers Parados (Status: Exited)
docker rm $(docker ps -aq -f status=exited)
 
# Remove containers parados há mais de 24h
docker container prune --filter "until=24h"  

# Visualização de Logs
docker logs <container>                # Exibe os logs do container desde o início
docker logs -f <container>             # Segue (follow) a saída de log em tempo real
docker logs --tail 50 <container>      # Exibe apenas as últimas 50 linhas de log
docker logs --since 10m <container>    # Exibe logs gerados nos últimos 10 minutos
docker logs -t <container>             # Inclui timestamps (carimbos de data/hora) nos logs
 
# Logs com Docker Compose
docker-compose logs -f                 # Segue os logs de todos os serviços definidos no docker-compose.yml
docker-compose logs -f serviço1 serviço2 # Segue os logs de serviços específicos
 
# Exportação de Logs
docker logs <container> > logs.txt     # Redireciona a saída de log para um arquivo
 
# Inspeção de Configuração
# Filtra e exibe seções importantes da configuração do container (Config, Env, Mounts)
docker inspect <container> | grep -A 10 -B 10 "Config\|Env\|Mounts"

# Controle de Ciclo de Vida
docker-compose up -d                   # Constrói (se necessário) e inicia os serviços em segundo plano (detached)
docker-compose up -d --build           # Força a reconstrução das imagens antes de iniciar
docker-compose down                    # Para e remove containers, redes e volumes padrão
docker-compose down -v                 # Para e remove containers, redes e volumes nomeados (definidos no compose)
 
# Status e Logs
docker-compose ps                      # Lista o status dos serviços
docker-compose logs -f                 # Segue os logs de todos os serviços
docker-compose logs -f <serviço>       # Segue os logs de um serviço específico
 
# Execução e Reinício
docker-compose exec <serviço> bash     # Abre um terminal interativo no container de um serviço
docker-compose restart                 # Reinicia todos os serviços
docker-compose restart <serviço>       # Reinicia um serviço específico
docker-compose pause                   # Pausa todos os serviços
docker-compose unpause                 # Despausa todos os serviços
 
# Outras Operações
docker-compose stop                    # Para os serviços sem removê-los
docker-compose start                   # Inicia os serviços parados
docker-compose pull                    # Atualiza as imagens dos serviços
docker-compose config                  # Valida e exibe a configuração final do compose file
 
# Escalonamento
docker-compose up -d --scale serviço=3 # Escala o serviço para 3 instâncias
 
# Rebuild Específico
docker-compose build <serviço>         # Reconstrói a imagem de um serviço específico

# Habilitar BuildKit (necessário para buildx)
export DOCKER_BUILDKIT=1
 
# Construção Multiplataforma
# Constrói a imagem para múltiplas arquiteturas (ex: amd64 e arm64)
docker buildx build --platform linux/amd64,linux/arm64 -t nome:tag .
# Constrói, faz o push e cria um manifesto multi-arquitetura no registry
docker buildx build --push -t usuario/repo:tag --platform linux/amd64,linux/arm64 .
 
# Gerenciamento de Builders
docker buildx create --name mybuilder --use # Cria e usa um novo builder (ex: para usar o driver 'docker-container')
docker buildx inspect --bootstrap          # Inicia o builder e exibe suas informações
 
# Listagem de Builders
docker buildx ls

# Análise de Vulnerabilidades (Requer Docker Scout ou Snyk)
docker scan <imagem>                   # Executa um scan de vulnerabilidades na imagem (via Snyk)
docker scout cves <imagem>             # Exibe vulnerabilidades (CVEs) conhecidas na imagem (via Docker Scout)
 
# Verificação de Assinaturas (Notary)
docker trust inspect <imagem>          # Verifica se a imagem possui assinaturas digitais confiáveis
 
# Execução Segura de Containers
docker run --read-only <imagem>        # Monta o sistema de arquivos raiz do container como somente leitura
docker run --security-opt no-new-privileges <imagem> # Impede que processos ganhem novos privilégios
# Limita as capacidades do kernel (capabilities) disponíveis para o container
docker run --cap-drop ALL --cap-add NET_BIND_SERVICE <imagem> 

# Listar Tags de uma Imagem no Registry
# Usa a API do Docker Hub para listar todas as tags disponíveis para uma imagem (ex: nginx)
curl -s https://registry.hub.docker.com/v2/repositories/library/nginx/tags/ | jq -r '.results[].name'
 
# Ver Labels de uma Imagem
# Extrai e exibe os metadados (Labels) definidos na imagem em formato JSON
docker inspect --format='{{json .Config.Labels}}' <imagem> | jq

# Obter Endereço IP do Container
# Extrai o IP do container na rede padrão
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' <container>
 
# Obter ID do Container pelo Nome
# Retorna o ID do container com o nome especificado
docker ps -aqf "name=<nome>"
 
# Verificar se Container Está Rodando
# Retorna '1' se o container com o nome especificado estiver ativo, '0' caso contrário
docker ps -f "name=<nome>" -f "status=running" --format "{{.ID}}" | wc -l
 
# Aguardar Container Estar Saudável (Healthcheck)
# Loop de espera até que o status de saúde (Health Status) do container seja 'healthy'
while ! docker inspect --format='{{.State.Health.Status}}' <container> | grep -q healthy; do sleep 1; done
 
# Backup de Todos os Volumes (Avançado)
# Cria um arquivo TAR compactado de todos os volumes do Docker (localizados em /var/lib/docker/volumes)
docker run --rm -v /var/lib/docker/volumes:/volumes -v $(pwd):/backup alpine tar czf /backup/volumes-backup.tar.gz /volumes

# Análise de Espaço em Disco
# Exibe os 20 diretórios que mais consomem espaço dentro do diretório de dados do Docker
du -h /var/lib/docker/ | sort -rh | head -20
# Exibe o uso de espaço em disco do sistema de arquivos onde o Docker armazena seus dados
df -h /var/lib/docker
 
# Análise de Inodes
df -i /var/lib/docker # Verifica o uso de inodes (número de arquivos) no sistema de arquivos do Docker
 
# Limpeza de Logs de Containers Ativos
# Zera o conteúdo dos arquivos de log JSON dos containers (útil para liberar espaço sem parar o container)
truncate -s 0 /var/lib/docker/containers/*/*-json.log
 
# Verificação de Processos
ps aux | grep docker # Lista todos os processos relacionados ao Docker no host
 
# Reinício do Daemon Docker
sudo systemctl restart docker # Reinicia o serviço principal do Docker
 
# Verificação de Eventos Recentes
docker events --since '1h' # Exibe eventos do Docker ocorridos na última hora
 
# Teste de Conexão
docker run --rm hello-world # Executa o container de teste 'hello-world' para verificar a funcionalidade básica

alias dps='docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"' # Containers ativos em formato de tabela
alias dls='docker ps -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"' # Todos os containers em formato de tabela
alias dim='docker images'              # Lista de imagens
alias dvol='docker volume ls'          # Lista de volumes
alias dnet='docker network ls'         # Lista de redes
alias dlog='docker logs -f'            # Seguir logs de um container
alias dexec='docker exec -it'          # Acesso interativo a um container
alias dstop='docker stop'              # Parar container
alias dstart='docker start'            # Iniciar container
alias drm='docker rm'                  # Remover container
alias drmi='docker rmi'                # Remover imagem
alias dprune='docker system prune -af' # Limpeza completa forçada
alias dstat='docker stats'             # Monitoramento de recursos em tempo real
alias dcup='docker-compose up -d'      # Iniciar compose em background
alias dcdown='docker-compose down'     # Parar e remover compose
alias dclog='docker-compose logs -f'   # Seguir logs do compose

# Build com Cache Externo
# Usa uma imagem remota como fonte de cache para builds (útil em pipelines CI/CD)
docker build --cache-from tipo=registry,ref=usuario/repo:cache -t nome:tag .
 
# Multi-stage Build Otimizado
# Constrói a imagem até um estágio específico (ex: 'desenvolvimento' ou 'produção')
docker build --target desenvolvimento -t nome:dev .
docker build --target produção -t nome:prod .
 
# Healthcheck Customizado
# Define um comando de verificação de saúde que o Docker usará para determinar o status do container
docker run --health-cmd="curl -f http://localhost/ || exit 1" --health-interval=30s <imagem>
 
# Limitação de Recursos
# Limita a memória e o uso de CPU disponíveis para o container
docker run --memory="512m" --cpus="1.0" --cpu-shares=1024 <imagem>
 
# Mapeamento de Portas Avançado
docker run -p 8080:80 -p 8443:443 <imagem>  # Mapeia múltiplas portas
docker run -p 0.0.0.0:8080:80 <imagem>     # Especifica a interface de rede (0.0.0.0 = todas)
 
# Mounts Temporários (tmpfs)
# Cria um sistema de arquivos temporário na memória do host para o container
docker run --tmpfs /tmp:rw,noexec,nosuid,size=100m <imagem>

# Parar Todos os Containers (Forçado)
docker kill $(docker ps -q) # Envia um sinal SIGKILL para todos os containers ativos
 
# Limpeza Total (Extremo Cuidado!)
docker system prune -a -f --volumes # Limpeza completa forçada (containers, imagens, volumes, redes)
docker rm -f $(docker ps -aq)       # Remove todos os containers (ativos e parados)
docker rmi -f $(docker images -aq)  # Remove todas as imagens
docker volume rm $(docker volume ls -q) # Remove todos os volumes
docker network rm $(docker network ls -q) 2>/dev/null # Remove todas as redes
 
# Reiniciar Serviço Docker
sudo systemctl stop docker
sudo systemctl start docker
 
# Matar Processos Docker Zombies
# Identifica e encerra processos Docker que podem estar travados ou em estado zombie
sudo kill -9 $(ps aux | grep docker | grep -v grep | awk '{print $2}')

# ctop - Monitoramento Interativo de Containers
# Executa o ctop para um dashboard em tempo real do uso de recursos dos containers
docker run --rm -ti --name=ctop --volume /var/run/docker.sock:/var/run/docker.sock:ro quay.io/vektorlab/ctop:latest
 
# lazydocker - Interface TUI para Docker
# Executa o lazydocker para uma interface de usuário baseada em terminal (TUI)
docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock lazyteam/lazydocker
 
# dive - Análise de Camadas de Imagens Docker
# Executa o dive para explorar o conteúdo e otimizar o tamanho das camadas de uma imagem
docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock wagoodman/dive:latest <imagem>
 
# trivy - Scanner de Vulnerabilidades (Alternativa)
# Executa o Trivy para escanear vulnerabilidades em uma imagem
docker run --rm aquasec/trivy:latest image <imagem>

Aviso de Segurança: Comandos que utilizam $(…) para remoção em massa são extremamente potentes. Sempre verifique o que será removido executando apenas a parte interna primeiro (ex: docker ps -aq) antes de rodar o comando completo.

# Remove TODOS os containers (ativos e parados)
docker rm -f $(docker ps -aq)
 
# Remove containers parados (Status: Exited)
docker rm $(docker ps -aq -f status=exited)
 
# Remove containers por filtro (ex: nome específico)
docker rm $(docker ps -aq -f "name=prefixo")

# Remove TODAS as imagens
docker rmi -f $(docker images -aq)
 
# Remove imagens intermediárias/sem tag (dangling)
docker rmi $(docker images -q -f dangling=true)
 
# Remove imagens por filtro (ex: nome específico)
docker rmi $(docker images -q -f "reference=nome/*")

# Remove TODAS as redes (exceto bridge, host, none - que são padrão do sistema)
docker network rm $(docker network ls -q)
 
# Remove redes por filtro (ex: redes não usadas por containers)
docker network rm $(docker network ls -q -f "type=custom")

docker volume rm $(docker volume ls -q)

# Containers criados há mais de 24h
docker rm $(docker ps -aq -f "status=exited" --filter "created>=24h")
 
# Imagens criadas há mais de 30 dias
docker image prune -a --filter "until=720h"

# Containers com nome começando com "test-"
docker rm -f $(docker ps -aq --filter "name=^/test-")
 
# Imagens com tag "none" ou específica
docker rmi $(docker images | grep "none" | awk '{print $3}')
docker rmi $(docker images | grep "dev-" | awk '{print $3}')

limpeza.sh

#!/bin/bash
# Remove tudo de forma segura (pergunta confirmação)
 
echo "=== LIMPEZA COMPLETA DOCKER ==="
echo "1. Parando todos os containers..."
docker stop $(docker ps -q) 2>/dev/null
 
echo "2. Removendo containers..."
docker rm -f $(docker ps -aq) 2>/dev/null
 
echo "3. Removendo imagens..."
docker rmi -f $(docker images -aq) 2>/dev/null
 
echo "4. Removendo volumes..."
docker volume rm $(docker volume ls -q) 2>/dev/null
 
echo "5. Removendo redes..."
docker network rm $(docker network ls -q | grep -v "bridge\|host\|none") 2>/dev/null
 
echo "6. Limpando cache builder..."
docker builder prune -f
 
echo "Limpeza completa!"

limpeza.sh

#!/bin/bash
# Remove apenas recursos não utilizados
 
echo "=== LIMPEZA SEGURA ==="
docker system prune -a -f --volumes

# Remove TODOS os containers, redes e volumes definidos no compose
docker-compose down --rmi all --volumes
 
# Remove imagens órfãs do compose
docker-compose down --rmi orphan
 
# Remove tudo (incluindo volumes nomeados)
docker-compose down -v --remove-orphans

1. Use com cuidado: Sempre verifique o que será removido antes:

# Primeiro liste, depois remova
docker volume ls -q  # Veja o que será removido
docker volume rm $(docker volume ls -q)  # Agora remova

2. Preserve volumes importantes: Se precisar preservar alguns volumes:

# Remove todos EXCETO os volumes nomeados importantes
docker volume rm $(docker volume ls -q | grep -v "importante\|backup")

3. Use prune para limpeza inteligente:

# Remove containers parados há mais de 1 semana
docker container prune --filter "until=168h"
 
# Remove imagens não usadas há mais de 1 mês
docker image prune -a --filter "until=720h"

# Limpeza completa (pergunta confirmação)
alias docker-nuke='docker rm -f $(docker ps -aq) 2>/dev/null; docker rmi -f $(docker images -aq) 2>/dev/null; docker volume rm $(docker volume ls -q) 2>/dev/null; docker network rm $(docker network ls -q) 2>/dev/null'
 
# Limpeza segura (apenas não utilizados)
alias docker-clean='docker system prune -a -f --volumes'
 
# Listar tudo antes de remover
alias docker-ls-all='echo "Containers:" && docker ps -a && echo -e "\nImagens:" && docker images && echo -e "\nVolumes:" && docker volume ls && echo -e "\nRedes:" && docker network ls'