Base de Conhecimento

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== GUIA DE REFERÊNCIA RÁPIDA DOCKER - COMANDOS ESSENCIAIS ======

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.

===== 1. GERENCIAMENTO DE RECURSOS BÁSICOS =====

==== 1.1. MONITORAMENTO E INFORMAÇÕES DO SISTEMA ====

<code bash>
# 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>
</code>

==== 1.2. GERENCIAMENTO DE CONTAINERS ====

<code bash>
# 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
</code>

==== 1.3. GERENCIAMENTO DE IMAGENS ====

<code bash>
# 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
</code>

==== 1.4. GERENCIAMENTO DE VOLUMES ====

<code bash>
# 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"
</code>

==== 1.5. GERENCIAMENTO DE NETWORKS ====

<code bash>
# 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
</code>

===== 2. LIMPEZA E REMOÇÃO EM LOTE (OTIMIZAÇÃO DE ESPAÇO) =====

==== 2.1. LIMPEZA GERAL E MANUTENÇÃO ====

<code bash>
# 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
</code>

==== 2.2. REMOÇÃO EM MASSA (USANDO COMMAND SUBSTITUTION) ====

<note warning>
**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.
</note>

=== Containers ===
<code bash>
# 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")
</code>

=== Imagens ===
<code bash>
# 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/*")
</code>

=== Redes (Networks) ===
<code bash>
# 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")
</code>

=== Volumes ===
<code bash>
# Remove TODOS os volumes
docker volume rm $(docker volume ls -q)
</code>

==== 2.3. COMANDOS COM FILTROS ESPECÍFICOS ====

<code bash>
# Remover por idade/tempo
# 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"

# Remove containers com status exited há mais de 1 semana
docker container prune --filter "until=168h" --filter "label!=keep"

# Remove volumes não utilizados há mais de 30 dias
docker volume prune --filter "until=720h"

# Remover por padrão de nome/tag
# 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}')
</code>

==== 2.4. SCRIPTS DE LIMPEZA ====

=== Script: limpeza_total.sh (Limpeza Completa em Etapas) ===
<file bash 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!"
</file>

=== Script: limpeza_segura.sh (Remove Apenas Não Utilizados) ===
<file bash limpeza.sh>
#!/bin/bash
# Remove apenas recursos não utilizados

echo "=== LIMPEZA SEGURA ==="
docker system prune -a -f --volumes
</file>

===== 3. DICAS AVANÇADAS E DEBUG =====

==== 3.1. DOCKER COMPOSE (GERENCIAMENTO MULTI-CONTAINER) ====

<code bash>
# 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

# Comandos Úteis para Limpeza do Compose
# 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
</code>

==== 3.2. DOCKER BUILDX (CONSTRUÇÃO MULTIPLATAFORMA) ====

<code bash>
# 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
</code>

==== 3.3. SEGURANÇA E AUDITORIA ====

<code bash>
# 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> 
</code>

==== 3.4. TAGS E METADADOS ====

<code bash>
# 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
</code>

==== 3.5. COMANDOS ÚTEIS PARA SCRIPTS ====

<code bash>
# 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
</code>

==== 3.6. LOGS E DEBUG DE CONTAINERS ====

<code bash>
# 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"
</code>

==== 3.7. DEBUG E TROUBLESHOOTING DO HOST ====

<code bash>
# 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
</code>

==== 3.8. EMERGÊNCIA (QUANDO O DOCKER NÃO RESPONDE) ====

<code bash>
# 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}')
</code>

==== 3.9. FERRAMENTAS COMPLEMENTARES ====

<code bash>
# 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>
</code>

==== 3.10. DOCKER SWARM (OPCIONAL) ====

<code bash>
# Remover todos os serviços do Swarm
docker service rm $(docker service ls -q)

# Remover todos os segredos
docker secret rm $(docker secret ls -q)

# Remover todas as configurações
docker config rm $(docker config ls -q)
</code>

===== 4. DICAS IMPORTANTES E ALIASES =====

==== 4.1. DICAS IMPORTANTES ====

1. **Use com cuidado**: Sempre verifique o que será removido antes:
<code bash>
# Primeiro liste, depois remova
docker volume ls -q  # Veja o que será removido
docker volume rm $(docker volume ls -q)  # Agora remova
</code>

2. **Preserve volumes importantes**: Se precisar preservar alguns volumes:
<code bash>
# Remove todos EXCETO os volumes nomeados importantes
docker volume rm $(docker volume ls -q | grep -v "importante\|backup")
</code>

3. **Use prune para limpeza inteligente**:
<code bash>
# 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"
</code>

4. **Verifique o que será removido (dry-run)**:
<code bash>
# Containers que seriam removidos
docker ps -aq --filter "status=exited"

# Imagens que seriam removidas (dangling)
docker images -q -f dangling=true

# Volumes não utilizados (dry-run)
docker volume ls -q -f dangling=true
</code>

==== 4.2. ALIASES AVANÇADOS (ADICIONAR AO ~/.bashrc) ====

<code bash>
# 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'

# Containers ativos em formato de tabela
alias dps='docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"' 

# Todos os containers em formato de tabela
alias dls='docker ps -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"' 

# Lista de imagens
alias dim='docker images'              

# Lista de volumes
alias dvol='docker volume ls'          

# Lista de redes
alias dnet='docker network ls'         

# Seguir logs de um container
alias dlog='docker logs -f'            

# Acesso interativo a um container
alias dexec='docker exec -it'          

# Parar container
alias dstop='docker stop'              

# Iniciar container
alias dstart='docker start'            

# Remover container
alias drm='docker rm'                  

# Remover imagem
alias drmi='docker rmi'                

# Limpeza completa forçada
alias dprune='docker system prune -af' 

# Monitoramento de recursos em tempo real
alias dstat='docker stats'             

# Iniciar compose em background
alias dcup='docker-compose up -d'      

# Parar e remover compose
alias dcdown='docker-compose down'     

# Seguir logs do compose
alias dclog='docker-compose logs -f'   
</code>

===== 5. COMANDOS AVANÇADOS (ADICIONAIS) =====

<code bash>
# 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>
</code>

===== 6. SCRIPTS DE LIMPEZA (Blocos de Arquivo) =====

=== Script de Limpeza Total ===
<file bash limpeza_total.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!"
</file>

=== Script de Limpeza Segura ===
<file bash limpeza_segura.sh>
#!/bin/bash
# Remove apenas recursos não utilizados

echo "=== LIMPEZA SEGURA ==="
docker system prune -a -f --volumes
</file>

===== 7. COMANDOS DOCKER COMPOSE (ADICIONAIS) =====

<code bash>
# 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
</code>