Docker: Comandos de Produção

Exibe a versão do cliente Docker instalada no seu sistema, útil para verificar a compatibilidade e o ambiente.

docker --version

Fornece um resumo detalhado das informações do sistema Docker, incluindo o número de containers (rodando, pausados, parados), imagens, volumes, redes, e configurações do daemon.

docker info

Similar ao `docker info`, este comando pode oferecer uma visão mais específica ou formatada das informações do sistema Docker, dependendo da versão e configuração.

docker system info

Mostra o uso de espaço em disco pelo Docker, detalhando o consumo por imagens, containers, volumes e cache de build, ajudando a identificar onde o espaço está sendo utilizado.

docker system df

Exibe as versões do cliente (CLI) e do servidor (daemon) Docker, permitindo verificar a comunicação e a compatibilidade entre eles.

docker version

Transmite eventos em tempo real do daemon Docker, como criação, início, parada, e destruição de containers, imagens e volumes, útil para monitoramento contínuo.

docker system events

Exibe eventos do daemon Docker ocorridos na última hora, útil para revisar atividades recentes do sistema e depurar problemas que surgiram recentemente.

docker system events --since 1h

Remove dados não utilizados pelo Docker que foram criados há mais de 24 horas, como containers parados, imagens sem tag e cache de build, ajudando a liberar espaço de forma seletiva.

docker system prune --filter until=24h

Lista todos os containers Docker que estão atualmente em execução, mostrando seus IDs, nomes, imagens, comandos, portas mapeadas e status.

docker ps

Lista todos os containers Docker, incluindo aqueles que estão parados ou foram encerrados (`-a` para "all").

docker ps -a

Lista apenas os IDs dos containers Docker que estão em execução, útil para encadear comandos ou scripts automatizados.

docker ps -q

Lista containers em execução com um formato de tabela personalizado, exibindo apenas os nomes, status e portas mapeadas, permitindo uma visualização mais limpa e focada.

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

Executa um novo container a partir da imagem `blueprint-backend` e mapeia a porta `3001` do host para a porta `3001` dentro do container (`-p` para "publish"), permitindo acesso externo ao serviço.

docker run -p 3001:3001 blueprint-backend

Executa um novo container em modo `detached` (segundo plano, `-d`), atribui o nome `backend` (`--name`) e mapeia a porta `3001` do host para a porta `3001` do container.

docker run -d --name backend -p 3001:3001 blueprint-backend

Executa um container da imagem `alpine` em modo interativo (`-i`) com um pseudo-TTY (`-t`), executando o comando `sh`. O container será automaticamente removido (`--rm`) ao ser encerrado.

docker run -it --rm alpine sh

Executa um container da imagem `app` e define a variável de ambiente `NODE_ENV` como `production` (`-e` para "env"), útil para configurar o comportamento da aplicação dentro do container.

docker run -e NODE_ENV=production app

Executa um container da imagem `node`, montando o diretório de trabalho atual do host (`$(pwd)`) como `/app` dentro do container (`-v` para "volume") e definindo `/app` como o diretório de trabalho (`-w`). Em seguida, executa `npm install`.

docker run -v $(pwd):/app -w /app node npm install

Executa um container da imagem `app` e configura uma política de reinício automático (`--restart unless-stopped`), garantindo que o container será reiniciado automaticamente a menos que seja explicitamente parado.

docker run --restart unless-stopped app

Executa um container da imagem `app` e limita a quantidade de memória RAM que ele pode usar a 256 megabytes (`--memory`), útil para controle de recursos.

docker run --memory="256m" app

Executa um container da imagem `app` e limita o uso da CPU a 0.5 (equivalente a 50% de um núcleo de CPU) (`--cpus`), útil para controle de recursos.

docker run --cpus="0.5" app

Envia um sinal SIGTERM para o container especificado, solicitando seu encerramento gracefully. Após um tempo limite, se o container não parar, um SIGKILL é enviado.

docker stop container_name

Para todos os containers Docker em execução, utilizando a saída de `docker ps -q` (que lista apenas os IDs dos containers rodando) como argumento para `docker stop`.

docker stop $(docker ps -q)

Remove um container Docker específico. O container deve estar parado antes de ser removido, a menos que a flag `-f` (force) seja usada.

docker rm container_name

Remove todos os containers Docker, tanto os em execução quanto os parados, utilizando a saída de `docker ps -aq` (que lista todos os IDs) como argumento para `docker rm`.

docker rm $(docker ps -aq)

Reinicia um container Docker em execução, parando-o e iniciando-o novamente.

docker restart container_name

Pausa todos os processos dentro de um container em execução, suspendendo-o temporariamente sem encerrá-lo, liberando recursos da CPU mas mantendo a memória.

docker pause container_name

Despausa um container que foi previamente pausado, permitindo que seus processos continuem a execução.

docker unpause container_name

Força a parada imediata de um container Docker enviando um sinal SIGKILL, sem esperar que ele encerre gracefuly. Use com cautela, pois pode resultar em perda de dados.

docker kill container_name

Lista todas as imagens Docker armazenadas localmente, mostrando seus repositórios, tags, IDs e tamanhos.

docker images

Lista todas as imagens Docker, incluindo as camadas intermediárias (`-a` para "all"), que normalmente são ocultas e podem consumir espaço.

docker images -a

Lista imagens Docker com um formato de tabela personalizado, exibindo repositório, tag e tamanho, para uma visualização mais organizada e focada.

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

Constrói uma imagem Docker a partir do `Dockerfile` localizado no diretório `./backend` e a taggeia com o nome `blueprint-backend` (`-t` para "tag").

docker build -t blueprint-backend ./backend

Constrói uma imagem Docker a partir do `Dockerfile` localizado no diretório `./frontend` e a taggeia com o nome `blueprint-frontend`.

docker build -t blueprint-frontend ./frontend

Constrói uma imagem Docker a partir do `Dockerfile` no diretório atual, sem utilizar o cache de camadas (`--no-cache`), garantindo que todas as etapas sejam executadas do zero, e a taggeia como `app:latest`.

docker build --no-cache -t app:latest .

Constrói uma imagem Docker a partir do `Dockerfile` no diretório atual, utilizando um estágio específico de build (`--target production`) definido no Dockerfile multi-stage, e a taggeia como `app:prod`.

docker build --target production -t app:prod .

Constrói uma imagem Docker a partir do `Dockerfile` no diretório atual, passando um argumento de build (`--build-arg NODE_ENV=production`) que pode ser usado dentro do Dockerfile durante o processo de build, e a taggeia como `app`.

docker build --build-arg NODE_ENV=production -t app .

Constrói uma imagem Docker com uma saída de progresso detalhada e sem formatação especial (`--progress=plain`), útil para depuração em ambientes CI/CD ou quando a saída padrão não é um TTY.

docker build --progress=plain -t app .

Constrói uma imagem Docker e "achata" as camadas resultantes em uma única camada após a imagem base, reduzindo o número de camadas e, potencialmente, o tamanho final da imagem (`--squash`).

docker build --squash -t app .

Constrói uma imagem Docker e adiciona um rótulo (label) `version=1.0` (`--label`) à imagem, útil para metadados, organização e filtragem.

docker build --label version=1.0 -t app .

Remove uma imagem Docker específica do armazenamento local. A imagem não pode estar em uso por nenhum container para ser removida.

docker rmi image_name

Remove todas as imagens Docker não utilizadas, utilizando a saída de `docker images -q` (que lista apenas os IDs das imagens) como argumento para `docker rmi`.

docker rmi $(docker images -q)

Remove imagens Docker que não estão associadas a nenhum container e não possuem tags (imagens "penduradas" ou "órfãs"), liberando espaço em disco.

docker image prune

Remove todas as imagens Docker não utilizadas, incluindo as camadas intermediárias (`-a` para "all"), que não são referenciadas por nenhuma imagem nomeada.

docker image prune -a

Cria uma nova tag (`target:1.0`) para uma imagem existente (`source:latest`), permitindo referenciar a mesma imagem com nomes diferentes ou versões específicas.

docker tag source:latest target:1.0

Envia uma imagem Docker para um registro remoto (`registry.com/app:latest`), tornando-a disponível para outros usuários ou sistemas.

docker push registry.com/app:latest

Baixa uma imagem Docker de um registro remoto (`registry.com/app:latest`) para o armazenamento local do seu sistema.

docker pull registry.com/app:latest

Exibe a saída de log padrão (stdout/stderr) de um container Docker específico, útil para depuração e monitoramento.

docker logs container_name

Exibe os logs de um container em tempo real, seguindo novas entradas (`-f` para "follow"), mantendo a conexão aberta e mostrando os logs à medida que são gerados.

docker logs -f container_name

Exibe as últimas 50 linhas de log de um container específico (`--tail`), útil para uma rápida verificação de eventos recentes sem carregar todo o histórico.

docker logs --tail 50 container_name

Exibe os logs de um container gerados nas últimas 2 horas (`--since`), permitindo filtrar logs por período de tempo para focar em eventos recentes.

docker logs --since="2h" container_name

Exibe os logs de um container, adicionando um timestamp a cada linha de log (`--timestamps`), o que é útil para análise cronológica e correlação de eventos.

docker logs --timestamps container_name

Exibe um fluxo em tempo real de estatísticas de uso de recursos (CPU, memória, rede, I/O de disco) para todos os containers em execução, útil para monitoramento de desempenho e identificação de gargalos.

docker stats

Exibe estatísticas de uso de recursos em tempo real para um container Docker específico, permitindo focar no desempenho de um único serviço.

docker stats container_name

Exibe os processos em execução dentro de um container Docker específico, similar ao comando `top` do Linux, útil para depuração e verificação de quais processos estão ativos.

docker top container_name

Exibe um instantâneo estático das estatísticas de uso de recursos para os containers em execução, sem o fluxo contínuo em tempo real (`--no-stream`), útil para capturas pontuais.

docker stats --no-stream

Exibe estatísticas de uso de recursos dos containers com um formato de tabela personalizado, mostrando o nome do container e o percentual de uso da CPU, para uma visualização concisa.

docker stats --format "table {{.Container}}\t{{.CPUPerc}}"

Transmite eventos em tempo real do daemon Docker, como criação, início, parada, e destruição de containers, imagens e volumes, útil para auditoria e automação.

docker events

Exibe informações detalhadas de baixo nível sobre um container Docker específico em formato JSON, incluindo configurações de rede, volumes, status, metadados e histórico de eventos.

docker inspect container_name

Exibe informações detalhadas de baixo nível sobre uma imagem Docker específica em formato JSON, incluindo camadas, metadados, configurações de portas e variáveis de ambiente.

docker inspect image_name

Executa o comando `bash` dentro de um container Docker em execução, alocando um pseudo-TTY (`-t`) e mantendo a entrada padrão aberta (`-i`) para interação, permitindo acesso ao shell do container.

docker exec -it container_name bash

Executa o comando `sh` (shell básico) dentro de um container Docker em execução em modo interativo com pseudo-TTY, útil quando `bash` não está disponível no container.

docker exec -it container_name sh

Executa um comando específico (`ls -la /app`) dentro de um container Docker em execução, sem necessidade de interação com um shell.

docker exec container_name ls -la /app

Copia o arquivo `file.txt` do host para o diretório `/app/` dentro do container especificado (`container_name`).

docker cp file.txt container_name:/app/

Copia o diretório `logs` de dentro do container especificado (`container_name:/app/logs`) para o diretório local `./logs` no host.

docker cp container_name:/app/logs ./logs

Exibe os mapeamentos de portas para um container Docker específico, mostrando quais portas do host estão conectadas a quais portas do container.

docker port container_name

Executa um container da imagem `nginx` e mapeia a porta `8080` do host para a porta `80` do container (`-p` para "publish"), permitindo acesso ao servidor web.

docker run -p 8080:80 nginx

Executa um container da imagem `nginx` e mapeia automaticamente todas as portas expostas no `Dockerfile` do container para portas aleatórias e não utilizadas no host (`-P` para "publish all").

docker run -P nginx

Executa o comando `bash` dentro de um container em execução como o usuário `root` (`-u`), útil para tarefas administrativas que requerem privilégios elevados.

docker exec -u root container bash

Executa o comando `sleep 60` dentro de um container em execução em modo `detached` (segundo plano, `-d`), sem bloquear o terminal atual.

docker exec -d container sleep 60

Executa um comando (`cmd`) dentro de um container em execução, passando uma variável de ambiente (`--env VAR=value`) que será disponível apenas para a execução desse comando.

docker exec -it container --env VAR=value cmd

Remove todos os dados não utilizados pelo Docker, incluindo containers parados, redes não utilizadas e imagens penduradas, mas não volumes por padrão.

docker system prune

Remove todos os dados não utilizados pelo Docker, incluindo containers parados, redes não utilizadas, imagens penduradas e todas as imagens sem tag (`-a` para "all").

docker system prune -a

Remove todos os dados não utilizados pelo Docker, incluindo volumes não referenciados por nenhum container (`--volumes`), além de containers parados, redes e imagens penduradas.

docker system prune --volumes

Remove todos os containers Docker que estão parados, liberando recursos e espaço em disco.

docker container prune

Remove imagens Docker que não estão associadas a nenhum container e não possuem tags (imagens "penduradas" ou "órfãs").

docker image prune

Remove todos os volumes Docker que não estão sendo utilizados por nenhum container, liberando espaço em disco. Use com cautela para evitar perda de dados.

docker volume prune

Remove todas as redes Docker que não estão sendo utilizadas por nenhum container, liberando recursos de rede.

docker network prune

Exibe o uso de espaço em disco pelo Docker de forma detalhada (`-v` para "verbose"), mostrando informações mais granulares sobre o consumo de cada tipo de recurso.

docker system df -v

Exibe eventos do daemon Docker, filtrando apenas os eventos relacionados a containers (`--filter type=container`), útil para monitorar atividades específicas.

docker system events --filter type=container

Limpa o cache de build do Docker, removendo camadas intermediárias não utilizadas, o que pode liberar espaço em disco e resolver problemas de build.

docker builder prune

Exibe um resumo do uso de espaço em disco pelo Docker, detalhando o consumo por imagens, containers, volumes e cache de build.

docker system df

Lista imagens Docker com um formato de tabela personalizado, exibindo repositório, tag e tamanho, para uma análise rápida do espaço ocupado por imagens.

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

Exibe a versão do Docker Compose instalada, útil para verificar a compatibilidade e os recursos disponíveis.

docker-compose --version

Constrói, (re)cria, inicia e anexa-se aos containers para todos os serviços definidos no arquivo `docker-compose.yml`, executando em primeiro plano e exibindo os logs.

docker-compose up

Constrói, (re)cria, inicia e anexa-se aos containers para todos os serviços definidos no arquivo `docker-compose.yml`, executando em modo `detached` (segundo plano).

docker-compose up -d

Inicia apenas o serviço `backend` e suas dependências definidas no arquivo `docker-compose.yml`.

docker-compose up backend

Constrói as imagens dos serviços antes de iniciar os containers, garantindo que as imagens estejam atualizadas com as últimas alterações no `Dockerfile`.

docker-compose up --build

Recria todos os containers, mesmo que não haja alterações na configuração ou imagem, útil para resolver problemas ou aplicar novas configurações.

docker-compose up --force-recreate

Remove containers de serviços que não estão mais definidos no arquivo `docker-compose.yml` (órfãos) ao iniciar, limpando o ambiente.

docker-compose up --remove-orphans

Inicia um serviço específico sem iniciar suas dependências, útil para testar um componente isoladamente.

docker-compose up --no-deps

Define um tempo limite de 30 segundos para o desligamento graceful dos containers ao parar ou reiniciar os serviços durante o `up`.

docker-compose up --timeout 30

Para e remove os containers, redes e volumes padrão criados por `docker-compose up`.

docker-compose down

Para e remove os containers, redes e também os volumes nomeados definidos no arquivo `docker-compose.yml` (`-v` para "volumes").

docker-compose down -v

Para os containers dos serviços definidos no `docker-compose.yml`, mas não os remove, permitindo que sejam reiniciados posteriormente com `docker-compose start`.

docker-compose stop

Para apenas o container do serviço `backend` definido no `docker-compose.yml`.

docker-compose stop backend

Para e remove os containers, redes e também as imagens criadas pelos serviços (`--rmi all`), liberando mais espaço em disco.

docker-compose down --rmi all

Define um tempo limite de 10 segundos para o desligamento graceful dos containers ao parar os serviços com `down`.

docker-compose down --timeout 10

Remove os containers parados sem pedir confirmação (`-f` para "force").

docker-compose rm -f

Para e remove os containers, redes e também quaisquer containers que não são mais referenciados no arquivo `docker-compose.yml`.

docker-compose down --remove-orphans

Exibe a saída de log consolidada de todos os serviços definidos no `docker-compose.yml`.

docker-compose logs

Exibe a saída de log de todos os serviços em tempo real, seguindo novas entradas (`-f` para "follow"), mantendo a conexão aberta.

docker-compose logs -f

Exibe a saída de log apenas do serviço `backend`.

docker-compose logs backend

Executa o comando `bash` dentro do container do serviço `backend`, permitindo acesso interativo ao shell do container.

docker-compose exec backend bash

Executa um comando específico (`cargo build`) dentro do container do serviço `backend`.

docker-compose exec backend cargo build

Exibe as últimas 50 linhas de log do serviço `backend`.

docker-compose logs --tail 50 backend

Exibe os logs do serviço `backend` gerados na última hora.

docker-compose logs --since="1h" backend

Executa o comando `ls -la` dentro do container do serviço `backend` sem alocar um pseudo-TTY (`-T`), útil para scripts automatizados ou quando a saída não precisa de formatação interativa.

docker-compose exec -T backend ls -la

Executa o comando `bash` dentro do container do serviço `backend` como o usuário `root` (`-u`), útil para tarefas administrativas que requerem privilégios elevados.

docker-compose exec -u root backend bash

Constrói as imagens para todos os serviços que possuem um `build` definido no `docker-compose.yml`.

docker-compose build

Constrói a imagem apenas para o serviço `backend`.

docker-compose build backend

Constrói as imagens dos serviços sem utilizar o cache de camadas, garantindo um build limpo e do zero, útil para resolver problemas de cache.

docker-compose build --no-cache

Inicia os serviços em modo `detached` e escala o serviço `backend` para 3 instâncias, útil para balanceamento de carga ou testes de desempenho.

docker-compose up -d --scale backend=3

Baixa as imagens mais recentes para todos os serviços definidos no `docker-compose.yml` de seus respectivos repositórios.

docker-compose pull

Valida e exibe a configuração efetiva do `docker-compose.yml` (e arquivos de override), útil para depuração da configuração antes de iniciar os serviços.

docker-compose config

Lista todos os containers criados pelo Docker Compose, mostrando seu status, portas e nomes, similar ao `docker ps` mas focado nos serviços do Compose.

docker-compose ps

Constrói as imagens para múltiplos serviços em paralelo, acelerando o processo de build para projetos com muitos serviços.

docker-compose build --parallel

Constrói as imagens com uma saída de progresso detalhada e sem formatação especial, útil para ambientes CI/CD ou logs.

docker-compose build --progress=plain

Inicia os serviços e escala múltiplos serviços simultaneamente, por exemplo, `web` para 2 instâncias e `db` para 1 instância, em uma única operação.

docker-compose up --scale web=2 --scale db=1

Executa um comando one-off em um novo container do serviço `backend`, passando uma variável de ambiente `VAR` com o valor `value` inline.

docker-compose run --env VAR=value backend

Executa um comando one-off em um novo container do serviço `backend`, carregando variáveis de ambiente de um arquivo `.env` específico.

docker-compose run --env-file .env backend

Exibe apenas os nomes dos serviços definidos na configuração do `docker-compose.yml`, útil para scripts ou automação.

docker-compose config --services

Inicia os serviços utilizando variáveis de ambiente definidas em um arquivo `prod.env` específico, sobrescrevendo ou complementando as do `.env` padrão, para diferentes ambientes.

docker-compose --env-file prod.env up

Executa o comando `env` dentro de um novo container do serviço `backend` e o remove (`--rm`) após a execução, para listar as variáveis de ambiente disponíveis para o serviço.

docker-compose run --rm backend env

Executa o comando `printenv` dentro do container *em execução* do serviço `backend` para listar suas variáveis de ambiente.

docker-compose exec backend printenv

Inicia os serviços sob um nome de projeto específico (`--project-name projeto`), o que afeta os nomes dos containers, redes e volumes criados, útil para isolar ambientes.

docker-compose --project-name projeto up

Inicia os serviços em modo `detached`, especificando o driver de volume `local` para volumes definidos nos serviços. Geralmente, o driver é configurado diretamente no `docker-compose.yml`.

docker-compose up -d --volume-driver local

Executa o comando `ls /data` dentro do container do serviço `backend` para listar o conteúdo de um volume montado em `/data`.

docker-compose exec backend ls /data

Executa o comando `ls /shared` em um novo container do serviço `backend` (que é removido após a execução) para listar o conteúdo de um volume compartilhado montado em `/shared`.

docker-compose run --rm backend ls /shared

Este comando não adiciona um alias de rede diretamente via `up`. Aliases de rede para serviços são definidos dentro da configuração de rede do serviço no arquivo `docker-compose.yml` para permitir que outros serviços o encontrem por esse nome.

docker-compose up --network-alias web

Executa o comando `ping database` dentro do container do serviço `backend` para testar a conectividade de rede com o serviço `database`.

docker-compose exec backend ping database

Para e remove os containers, redes e todos os volumes nomeados definidos no arquivo `docker-compose.yml`.

docker-compose down --volumes

Lista todos os volumes Docker e filtra aqueles que contêm o nome do projeto (`projeto`), útil para identificar volumes criados pelo Docker Compose.

docker volume ls | grep projeto

Lista todas as redes Docker e filtra aquelas que contêm o nome do projeto (`projeto`), útil para identificar redes criadas pelo Docker Compose.

docker network ls | grep projeto

Inicia o serviço `backend` sem iniciar suas dependências, útil para isolar e testar um único serviço.

docker-compose up --no-deps backend

Recria os containers de um serviço específico sem iniciar suas dependências, útil para forçar uma recriação sem afetar outros serviços.

docker-compose up --force-recreate --no-deps

Reinicia o container do serviço `backend`.

docker-compose restart backend

Reinicia todos os containers dos serviços definidos no `docker-compose.yml`.

docker-compose restart

Pausa o container do serviço `backend`, suspendendo seus processos sem encerrá-lo.

docker-compose pause backend

Despausa o container do serviço `backend` que foi previamente pausado.

docker-compose unpause backend

Força a parada imediata do container do serviço `backend` enviando um sinal SIGKILL, sem esperar um desligamento graceful.

docker-compose kill backend

Reduz o número de instâncias do serviço `backend` para zero, efetivamente parando e removendo todos os containers associados a ele.

docker-compose up --scale backend=0

Inicia os serviços utilizando um arquivo `docker-compose` alternativo (`docker-compose.prod.yml`) em vez do padrão, útil para diferentes ambientes (produção, desenvolvimento).

docker-compose -f docker-compose.prod.yml up

Inicia os serviços combinando as configurações de múltiplos arquivos `docker-compose`, onde o segundo arquivo (`override.yml`) pode sobrescrever ou estender o primeiro.

docker-compose -f docker-compose.yml -f docker-compose.override.yml up

Ativa o modo de compatibilidade, que tenta converter opções de `deploy` do Compose para opções de `run` do Docker, útil para compatibilidade com Docker Swarm.

docker-compose --compatibility up

Inicia os serviços e exibe uma saída detalhada (`--verbose`) do que o Docker Compose está fazendo, útil para depuração de problemas de inicialização.

docker-compose --verbose up

Inicia os serviços, desabilitando a saída ANSI (cores) no terminal (`--no-ansi`), útil para logs em sistemas que não interpretam códigos de cor ou para logs em arquivos.

docker-compose --no-ansi up

Inicia os serviços que pertencem ao perfil `dev` (`--profile`), permitindo ativar/desativar grupos de serviços com base no ambiente ou propósito.

docker-compose --profile dev up

Inicia os serviços que pertencem aos perfis `dev` E `test`, ativando múltiplos grupos de serviços simultaneamente.

docker-compose --profile dev --profile test up

Valida e exibe a configuração do `docker-compose.yml`, resolvendo e substituindo todas as variáveis de ambiente pelos seus valores atuais, útil para verificar a configuração final.

docker-compose config --resolve-env-vars

Inicia os serviços definidos em `docker-compose.test.yml` e encerra todos os outros containers se um deles sair (`--abort-on-container-exit`), ideal para ambientes de teste automatizados onde a falha de um teste deve parar tudo.

docker-compose -f docker-compose.test.yml up --abort-on-container-exit

Inicia os serviços definidos em `docker-compose.ci.yml`, reconstruindo as imagens, para um ambiente de Integração Contínua (CI) garantindo que o ambiente esteja sempre atualizado.

docker-compose -f docker-compose.ci.yml up --build

Executa o comando `npm test` em um novo container do serviço `backend` e o remove (`--rm`) após a execução, ideal para rodar testes unitários ou de integração de forma isolada.

docker-compose run --rm backend npm test

Executa a ferramenta de lint `flake8` em um novo container do serviço `backend` e o remove (`--rm`) após a execução, para análise estática de código Python.

docker-compose run --rm backend flake8 .

Executa o comando `python manage.py migrate` em um novo container do serviço `backend` e o remove (`--rm`) após a execução, para aplicar migrações de banco de dados em aplicações Django.

docker-compose run --rm backend python manage.py migrate

Executa o comando `python manage.py collectstatic` dentro do container em execução do serviço `backend` para coletar arquivos estáticos em aplicações Django.

docker-compose exec backend python manage.py collectstatic

Primeiro, para e remove todos os serviços e suas redes (`down`), e depois os inicia novamente, reconstruindo as imagens (`up --build`), útil para um "reset" completo do ambiente de desenvolvimento.

docker-compose down && docker-compose up --build

Exibe a versão do Docker Compose V2, que é integrada ao cliente Docker (o comando `compose` é um subcomando de `docker`).

docker compose version

Inicia os serviços definidos no arquivo `docker-compose.yml` usando a sintaxe da versão V2 do Docker Compose.

docker compose up

Monitora o sistema de arquivos e reinicia ou reconstrói serviços automaticamente quando alterações são detectadas, útil para desenvolvimento local com feedback instantâneo.

docker compose watch

Tenta converter um arquivo `docker-compose.yml` da versão V1 para a sintaxe da versão V2, útil para migração. (Comando alpha, pode mudar).

docker compose alpha convert

Valida e exibe a configuração efetiva do `docker-compose.yml` em formato JSON, útil para processamento programático ou integração com outras ferramentas.

docker compose config --format json

Executa o comando `bash` em um novo container do serviço `backend` (V2) e o remove (`--rm`) após a execução.

docker compose run --rm backend bash

Inicia os serviços e espera até que todos os containers estejam saudáveis (healthcheck) antes de considerar o comando completo, útil em scripts de CI/CD para garantir que a aplicação esteja pronta.

docker compose up --wait

Inicia os serviços e anexa-se aos logs de todos os serviços, incluindo suas dependências, útil para observar o início completo da aplicação e depurar problemas de inicialização entre serviços.

docker compose up --attach dependencies

Copia arquivos ou diretórios de dentro do container do serviço `backend` para um diretório local no host, usando a sintaxe V2 do Docker Compose.

docker compose cp backend:/app ./local

Para e remove os serviços com um tempo limite de 30 segundos para o desligamento graceful, usando a sintaxe V2 do Docker Compose.

docker compose down --timeout 30

Lista todas as redes Docker no sistema, mostrando seus IDs, nomes, drivers e escopos, útil para entender a topologia de rede.

docker network ls

Exibe informações detalhadas de baixo nível sobre a rede Docker `bridge` em formato JSON, incluindo containers conectados, configurações de IP e opções.

docker network inspect bridge

Cria uma nova rede Docker chamada `blueprint-net` usando o driver `bridge`, permitindo que containers conectados a ela se comuniquem facilmente por nome.

docker network create --driver bridge blueprint-net

Remove uma rede Docker específica. A rede deve estar vazia (sem containers conectados) para ser removida.

docker network rm network_name

Lista todos os volumes Docker armazenados localmente, mostrando seus nomes e drivers, útil para gerenciar a persistência de dados.

docker volume ls

Exibe informações detalhadas de baixo nível sobre um volume Docker específico em formato JSON, incluindo seu driver, ponto de montagem e opções.

docker volume inspect volume_name

Remove um volume Docker específico. O volume não pode estar em uso por nenhum container. Use com cautela para evitar perda de dados.

docker volume rm volume_name

Executa um container da imagem `alpine` e monta um volume nomeado (`nome_volume`) no diretório `/data` dentro do container, garantindo persistência de dados.

docker run -v nome_volume:/data alpine

Executa o comando `ping container2` dentro do `container1` para testar a conectividade de rede entre dois containers na mesma rede Docker.

docker exec -it container1 ping container2

Executa o comando `curl` dentro do container `frontend` para testar a acessibilidade e o status de saúde de uma API no container `backend` na porta `3001`.

docker exec frontend curl http://backend:3001/health

Conecta um container Docker existente a uma rede Docker específica (neste caso, a rede `bridge`), permitindo que ele se comunique com outros containers nessa rede.

docker network connect bridge container

Desconecta um container Docker de uma rede específica (neste caso, a rede `bridge`), isolando-o dessa rede.

docker network disconnect bridge container

Cria um novo volume Docker nomeado `data`, que pode ser usado para persistir dados entre containers ou entre o host e containers, independentemente do ciclo de vida do container.

docker volume create --name data

Verifica as versões do cliente e do servidor (daemon) Docker, útil para confirmar se o Docker está instalado e se o daemon está respondendo.

docker version

Verifica o status do serviço Docker no Linux usando `systemctl`, mostrando se o daemon está ativo, rodando e quaisquer mensagens de log recentes do sistema.

systemctl status docker

Verifica o status do serviço Docker no Windows usando `Get-Service` (PowerShell), mostrando se o serviço está em execução.

Get-Service docker

Adiciona o usuário atual (`$USER`) ao grupo `docker` no Linux, concedendo permissões para executar comandos Docker sem `sudo`. Requer logout/login ou `newgrp docker` para aplicar.

sudo usermod -aG docker $USER

Altera o grupo primário do shell atual para `docker`, aplicando as permissões do grupo sem a necessidade de fazer logout e login novamente. Útil após adicionar o usuário ao grupo docker.

newgrp docker

Exibe um resumo do uso de espaço em disco pelo Docker, detalhando o consumo por imagens, containers, volumes e cache de build, útil para diagnosticar problemas de espaço.

docker system df

Remove todos os dados não utilizados pelo Docker, incluindo containers parados, redes não utilizadas, imagens penduradas e todas as imagens sem tag (`-a` para "all"), liberando o máximo de espaço possível.

docker system prune -a

Lista todas as redes Docker no sistema, mostrando seus IDs, nomes, drivers e escopos, útil para diagnosticar problemas de conectividade entre containers.

docker network ls

Exibe informações detalhadas de baixo nível sobre a rede Docker `bridge` em formato JSON, incluindo containers conectados e configurações de IP, crucial para depuração de rede.

docker network inspect bridge

Exibe os logs do serviço Docker no Linux usando `journalctl`, útil para depurar problemas com o daemon Docker em si, como falhas de inicialização ou erros internos.

journalctl -u docker.service

Exibe os logs de eventos relacionados ao Docker no Windows usando `Get-EventLog` (PowerShell), útil para depurar problemas no sistema operacional ou no serviço Docker.

Get-EventLog -LogName Application -Source Docker

Lista todos os contextos Docker disponíveis, que permitem alternar facilmente entre diferentes hosts Docker (local, remoto, cloud), útil para verificar qual ambiente está sendo alvo dos comandos.

docker context ls

Muda o contexto Docker ativo para `my-context`, direcionando os comandos Docker subsequentes para o host ou ambiente definido nesse contexto. Essencial ao trabalhar com múltiplos ambientes Docker.

docker context use my-context

Verifica a assinatura de confiança de uma imagem Docker específica, garantindo que a imagem não foi adulterada e vem de uma fonte confiável, importante para segurança.

docker trust inspect image:tag