Docker no macOS — Comparação e Boas Práticas

Docker no macOS já foi um pesadelo de performance. Mas com o Colima, Orbstack, e as melhorias do Docker Desktop, nunca foi tão fácil ter contentores Linux a correr nativamente no teu Mac: seja Intel ou Apple Silicon.

Quando o Docker chegou ao macOS, corria dentro de uma VM VirtualBox com uma lentidão que fazia qualquer developer suspirar. Os mounts de diretórios eram especialmente dolorosos: npm install dentro de um contentor demorava minutos.

Hoje, o cenário é completamente diferente. Temos Docker Desktop com engine VM acelerada, Colima (open-source, leve), e o Orbstack (o novo miúdo do bairro que promete performance nativa). Cada um com os seus trade-offs.

Vou mostrar-te:

• Comparação: Docker Desktop vs Colima vs Orbstack
• Dockerfile multi-stage para reduzir tamanho (exemplos Go e Python)
• Docker Compose para desenvolvimento com volumes e networks
• Performance: virtiofs vs gRPC FUSE, cache mounts
• Dicas de limpeza e ferramentas auxiliares

⬆ Como o Docker corre no macOS: VM Linux com contentores por cima

Docker desktop vs Colima vs Orbstack

A minha escolha: Para projetos pessoais, uso Colima: é leve, grátis e faz o que preciso. Para clientes que exigem uma GUI e suporte, Docker Desktop é a escolha segura. O Orbstack é o mais promissor dos três, com performance realmente impressionante.

Instalação rápida com Colima

# Instalar Docker CLI + Colima
brew install docker colima

# Iniciar Colima com configurações recomendadas para Apple Silicon
colima start --cpu 4 --memory 8 --disk 50 --vm-type vz --mount-type virtiofs

# Verificar
docker info | grep "Operating System"
# → Operating System: Linux (Colima)

Dockerfile multi-stage para imagens pequenas

Multi-stage builds são a forma mais eficaz de reduzir o tamanho das imagens. O princípio é simples: usa uma imagem grande para compilar/construir, e uma imagem mínima para correr.

Exemplo Go (de 1.2 GB para 15 MB)

# === STAGE 1: Build ===
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o server

# === STAGE 2: Runtime mínimo ===
FROM alpine:3.19
RUN apk add --no-cache ca-certificates tzdata
COPY --from=builder /app/server /server
EXPOSE 8080
CMD ["/server"]

Exemplo Python (de 900 MB para 120 MB)

# === STAGE 1: Dependências ===
FROM python:3.12-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dirs -r requirements.txt

# === STAGE 2: Runtime ===
FROM python:3.12-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY app/ ./app/
ENV PATH=/root/.local/bin:$PATH
CMD ["python", "-m", "app.main"]

⬆ Diferença de tamanho entre single-stage e multi-stage para Go e Python

Docker compose para desenvolvimento

# docker-compose.yml — desenvolvimento local
services:
  app:
    build:
      context: .
      target: dev         # usa stage dev do Dockerfile
    volumes:
      - .:/app            # bind mount para hot-reload
    ports:
      - "3000:3000"
    depends_on:
      - db
    profiles:
      - dev
      - staging

  db:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: devpass

volumes:
  pgdata:

Dica: O uso de profiles no Compose permite ter serviços que só sobem quando queres. Por exemplo, docker compose --profile dev up sobe app + db, mas docker compose --profile staging up pode incluir um sidecar de monitoring.

Performance no macos: virtiofs vs grpc fuse

O pesadelo do Docker no macOS sempre foram os bind mounts: a ponte entre o filesystem do Mac e o da VM Linux. Três tecnologias competem por este lugar:

Para ativar virtiofs no Colima:

colima start --mount-type virtiofs --vm-type vz

Para cache mounts: acelera imenso builds que repetem dependências:

# No Dockerfile (Docker BuildKit)
FROM golang:1.22-alpine AS builder
RUN --mount=type=cache,target=/go/pkg/mod go mod download
RUN --mount=type=cache,target=/root/.cache/go-build go build -o server

Limpeza e manutenção

# Limpar tudo o que não está a ser usado
docker system prune -a --volumes

# Ver espaço ocupado
docker system df

# Limpar imagens não usadas há mais de 24h
docker image prune -a --filter "until=24h"

# Usar docker scout para ver vulnerabilidades
docker scout quickstart
docker scout enable
docker scout analysis minha_imagem:latest

Recapitulando

• Escolhe o runtime certo: Docker Desktop (completo), Colima (leve), Orbstack (rápido)
• Multi-stage builds: Go de 1.2 GB → 15 MB, Python de 900 MB → 120 MB
• Docker Compose com profiles para ambientes dev/staging
• virtiofs para performance de bind mounts no macOS
• Cache mounts para builds mais rápidas com BuildKit
• docker system prune e docker scout para manutenção e segurança

Docker no macOS nunca foi tão bom. Escolhe o runtime que mais se adequa ao teu fluxo, otimiza os teus Dockerfiles com multi-stage, e usa virtiofs para montagens rápidas. Os dias de esperar 5 minutos por um npm install já lá vão.

Recursos adicionais

• Docker Desktop para Mac
• Colima: GitHub
• Orbstack
• Cache mounts: Docker BuildKit
• Docker Scout