Guia Completo de Docker: Comandos, Dockerfile e Docker Compose
Este documento reúne anotações essenciais sobre Docker, cobrindo desde comandos básicos até a orquestração de containers com Docker Compose. Ideal para quem busca um guia prático e direto ao ponto para gerenciar seus ambientes conteinerizados.
- Comandos Essenciais do Docker
Esta seção apresenta os comandos mais utilizados para interagir com containers e imagens Docker.
•
Listar todos os containers (incluindo os parados):
docker ps -a
•
Rodar uma imagem (criar e iniciar um container):
docker run [nome_da_imagem]
•
Listar apenas os containers em execução:
docker ps
•
Acessar o shell de um container em execução:
docker exec -it [container_id_ou_nome] /bin/bash
•
Remover uma imagem:
docker image rm
•
Baixar uma imagem do Docker Hub:
docker pull
•
Listar volumes Docker:
docker volume ls
•
Parar um container em execução:
docker stop
•
Deletar um container:
docker rm
•
Iniciar um container parado:
docker start
•
Listar todos os comandos Docker disponíveis:
docker --help
•
Deletar todos os recursos não utilizados (containers, volumes, imagens e redes):
docker system prune -a
- Conceitos Fundamentais
Alguns conceitos importantes para entender o funcionamento do Docker.
•
Docker Hub: É um repositório público onde você pode encontrar e compartilhar imagens Docker. Funciona como um GitHub para imagens de containers.
•
Portabilidade dos Containers: Nos containers, você isola apenas as aplicações e suas dependências, tornando-os portáteis para qualquer sistema operacional. Isso significa que um container rodará da mesma forma em diferentes ambientes, desde que o Docker esteja instalado.
•
Compatibilidade: O Docker suporta apenas máquinas Linux de 64 bits para a execução nativa de containers Linux. Em outros sistemas operacionais (como Windows e macOS), ele utiliza máquinas virtuais para rodar o ambiente Linux.
- Dockerfile: Construindo Suas Imagens
O Dockerfile é um script que contém instruções para construir uma imagem Docker. Cada instrução cria uma camada na imagem, otimizando o processo de build.
•
Regra Geral: Os comandos Docker dentro de um Dockerfile devem ser sempre escritos em letras maiúsculas.
Comandos Comuns no Dockerfile
•
FROM :: Define a imagem base para a sua nova imagem. Por exemplo, FROM python:3.12 puxa a imagem oficial do Python versão 3.12 do Docker Hub.
•
WORKDIR : Define o diretório de trabalho para os comandos subsequentes no container. Se o diretório não existir, ele será criado. Se não for definido, os comandos serão executados na raiz do sistema de arquivos do container (/). Exemplo: WORKDIR /app.
•
COPY : Copia arquivos ou diretórios do seu contexto de build (máquina local) para o sistema de arquivos do container. Exemplo: COPY . . copia todo o conteúdo do diretório atual para o diretório de trabalho no container.
•
RUN : Executa um comando dentro do container durante o processo de build. É usado para instalar pacotes, configurar o ambiente, etc. Exemplo: RUN pip install -r requirements.txt para instalar dependências Python.
•
EXPOSE : Informa ao Docker que o container escutará na porta especificada em tempo de execução. Não publica a porta automaticamente, apenas documenta. Para publicar, use a flag -p no docker run ou no Docker Compose. Exemplo: EXPOSE 8000.
•
CMD ["executavel", "param1", "param2"]: Define o comando padrão a ser executado quando um container é iniciado a partir da imagem. Só pode haver um CMD por Dockerfile. Se você especificar um comando ao rodar o container (docker run ), ele sobrescreverá o CMD.
Exemplo de Dockerfile e Observações
Plain Text
FROM python:3.9-slim
WORKDIR /sge
COPY . .
RUN pip install --upgrade pip
RUN pip install -r requirements.txt
RUN python manage.py migrate
EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
•
Ordem dos Comandos: Tudo que acontece antes do CMD no Dockerfile é parte do processo de build da imagem. O CMD é o comando que será executado quando o container for iniciado.
•
Variáveis de Ambiente Python (para logs detalhados): Para obter logs mais específicos da linguagem Python, inclua as seguintes variáveis de ambiente no seu Dockerfile (geralmente após o WORKDIR):
•
ENV PYTHONUNBUFFERED 1
•
ENV PYTHONDONTWRITEBYTECODE 1
Construindo a Imagem
Após criar o Dockerfile, construa a imagem a partir do diretório do projeto:
docker build --tag sge:0.1 .
•
--tag sge:0.1: Atribui um nome (sge) e uma tag (0.1) à imagem. Isso é crucial para versionamento e identificação.
•
.: Indica que o Dockerfile está no diretório atual.
- Redes Docker
As redes Docker permitem que containers se comuniquem entre si e com o host. Por padrão, o Docker cria três redes:
•
bridge: A rede padrão para novos containers. Containers na mesma rede bridge podem se comunicar por nome.
•
host: Remove o isolamento de rede entre o container e o host, permitindo que o container use a rede do host diretamente.
•
none: Desabilita completamente a rede para o container.
Gerenciando Redes
•
Listar redes existentes:
docker network ls
•
Criar uma nova rede:
docker network create
Estrutura Básica de Projeto Docker com Rede
Em um cenário de aplicação web e banco de dados, você pode ter uma rede personalizada para a comunicação entre os serviços:
Plain Text
+-------------------------------------------------------+
| MINHA_REDE |
| +-------------+ +-------------+ |
| | Container 1 |--------->| Container 2 | |
| | Aplicação Web | | Banco de Dados| |
| | (ex: Python) | | (ex: PostgreSQL)| |
| +-------------+ +-------------+ |
+-------------------------------------------------------+
•
Comunicação por Nome: Dentro da mesma rede Docker, os containers podem se comunicar usando o nome do serviço (que é o nome do container).
- Docker Compose: Orquestração de Múltiplos Containers
O Docker Compose é uma ferramenta para definir e executar aplicações Docker multi-container. Ele usa um arquivo YAML para configurar todos os serviços da sua aplicação de uma só vez.
•
Nome do Arquivo: Por padrão, o arquivo de configuração do Docker Compose é nomeado docker-compose.yml e deve ser criado na raiz do seu projeto.
•
Nomes de Serviços: Os nomes dos serviços no arquivo docker-compose.yml devem ser em minúsculo e são usados para a comunicação entre os containers dentro da rede do Compose.
Exemplo de docker-compose.yml
YAML
version: '3.8'
services:
sge_web:
build: .
restart: always
ports:
- "8000:8000"
depends_on:
- sge_db
sge_db:
image: postgres:15
ports:
- "5432:5432"
volumes:
- postgres_data:/var/lib/postgresql/data/
environment:
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
- POSTGRES_DB=sge
volumes:
postgres_data:
Explicação dos Campos:
•
services:: Define os diferentes serviços (containers) da sua aplicação.
•
sge_web: Nome do serviço para a aplicação web.
•
build: .: Indica que o Docker deve construir a imagem para este serviço a partir de um Dockerfile localizado no diretório atual (.).
•
restart: always: Configura o container para sempre reiniciar automaticamente se ele parar por qualquer motivo (erro, reinício do Docker, etc.).
•
ports: - "8000:8000": Mapeia a porta 8000 do container para a porta 8000 da máquina host, permitindo acesso externo à aplicação.
•
depends_on: - sge_db: Garante que o serviço sge_web só será iniciado após o serviço sge_db estar em execução e saudável. Isso é útil para garantir que o banco de dados esteja pronto antes da aplicação tentar se conectar.
•
sge_db: Nome do serviço para o banco de dados PostgreSQL.
•
image: postgres:15: Especifica que a imagem a ser usada é postgres na versão 15, que será puxada do Docker Hub.
•
ports: - "5432:5432": Mapeia a porta padrão do PostgreSQL (5432) do container para a porta 5432 da máquina host.
•
volumes: - postgres_data:/var/lib/postgresql/data/: Cria um volume nomeado (postgres_data) e o monta no diretório /var/lib/postgresql/data/ dentro do container. Isso garante que os dados do banco de dados sejam persistidos mesmo se o container for removido.
•
environment:: Define variáveis de ambiente que serão passadas para o container. Essenciais para configurar o PostgreSQL (usuário, senha, nome do banco).
•
volumes:: Declara os volumes nomeados que serão utilizados pelos serviços. Isso é importante para a persistência de dados.
Comandos do Docker Compose
•
Subir a aplicação (criar e iniciar todos os serviços):
docker-compose up
•
O Docker Compose automaticamente cria uma rede padrão para todos os containers declarados no arquivo, permitindo que eles se comuniquem entre si.
•
Reconstruir e subir a aplicação (útil após alterações no Dockerfile ou dependências):
docker-compose up --build
•
Verificar logs de um serviço específico:
docker-compose logs -f
•
-f: Segue os logs em tempo real.
- Ignorando Arquivos com .dockerignore
Para otimizar o processo de build da imagem e evitar copiar arquivos desnecessários para o contexto do Docker, você pode criar um arquivo .dockerignore na raiz do seu projeto. Ele funciona de forma similar ao .gitignore.
Exemplos de arquivos/pastas a ignorar:
•
.venv (ambientes virtuais Python)
•
.git (diretório do Git)
•
.gitignore (o próprio arquivo .gitignore)
•
pycache (arquivos de cache do Python)
•
*.log (arquivos de log)
•
node_modules (dependências Node.js)
Top comments (0)