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 comparar as três opções principais — Docker Desktop, Colima e Orbstack — mostrar-te multi-stage builds para reduzir imagens, configurar Docker Compose para desenvolvimento, otimizar performance com virtiofs e cache mounts, e dar dicas de limpeza e manutenção.

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.27-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-dir -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.27-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"
# Resumo rápido de vulnerabilidades (Docker Scout)
docker scout quickview minha_imagem:latest
# Listar os CVEs encontrados
docker scout cves minha_imagem:latest
# Sugestões de atualização da imagem base
docker scout recommendations 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