Desenvolvimento Docker com Cursor: Simplificando Fluxos Baseados em Contêineres

Cursor Docker Development

O Docker tornou-se essencial para ambientes de desenvolvimento consistentes, e os recursos de IA do Cursor podem tornar o trabalho com contêineres mais rápido e intuitivo. Este guia aborda geração de Dockerfile, orquestração com Docker Compose, Dev Containers e fluxos de trabalho de depuração.

Pré-requisitos

Antes de começar, você precisará de:

Docker instalado e em execução em sua máquina
Cursor (versão mais recente recomendada)
Noções básicas de conceitos Docker (imagens, contêineres, volumes)

Gerando Dockerfiles com Cursor

Dockerfile de Produção

Descreva sua stack de aplicação e deixe o Cursor gerar um Dockerfile otimizado:

Crie um Dockerfile multi-stage para uma aplicação Next.js 14 com:
- Node.js 20 Alpine
- Instalação de dependências com npm ci
- Build do bundle de produção
- Execução como usuário não-root
- Imagem final mínima

Resultado gerado pelo Cursor:

# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production

# Create non-root user
RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

COPY --from=builder /app/public ./public
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs
EXPOSE 3000
ENV PORT=3000
ENV HOSTNAME="0.0.0.0"

CMD ["node", "server.js"]

Otimizando Dockerfiles Existentes

Cole um Dockerfile e peça melhorias:

Otimize este Dockerfile para builds mais rápidos e menor tamanho de imagem:
[Colar Dockerfile]

Otimizações comuns sugeridas pelo Cursor:

Combinar comandos RUN para reduzir camadas
Usar .dockerignore para minimizar contexto
Aproveitar o cache de build efetivamente
Usar tags específicas de imagem base em vez de latest

Melhores Práticas para .dockerignore

node_modules
npm-debug.log
Dockerfile
.dockerignore
.git
.gitignore
README.md
.env
.env.local
.env.production
.nyc_output
coverage
.vscode
.idea

Stack de Desenvolvimento com Docker Compose

Configuração de Aplicação Full-Stack

version: '3.8'
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
      - REDIS_URL=redis://redis:6379
    volumes:
      - .:/app
      - /app/node_modules
    depends_on:
      - db
      - redis

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: myapp
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - app

volumes:
  postgres_data:

Configuração de Hot Reload

Ambiente de desenvolvimento com recarregamento ao vivo:

services:
  dev:
    build:
      context: .
      target: builder
    command: npm run dev
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
    environment:
      - CHOKIDAR_USEPOLLING=true
      - WATCHPACK_POLLING=true

Truque de Volumes

Monte o código-fonte com - .:/app, mas exclua node_modules com - /app/node_modules. Isso evita conflitos entre node_modules do contêiner e do host.

Dev Containers no Cursor

Configuração do .devcontainer

Crie .devcontainer/devcontainer.json:

{
  "name": "Node.js & PostgreSQL",
  "dockerComposeFile": "docker-compose.yml",
  "service": "app",
  "workspaceFolder": "/workspace",
  "features": {
    "ghcr.io/devcontainers/features/node:1": {
      "version": "20"
    },
    "ghcr.io/devcontainers/features/git:1": {}
  },
  "customizations": {
    "vscode": {
      "extensions": [
        "Prisma.prisma",
        "esbenp.prettier-vscode",
        "dbaeumer.vscode-eslint"
      ],
      "settings": {
        "terminal.integrated.defaultProfile.linux": "bash"
      }
    }
  },
  "postCreateCommand": "npm install",
  "forwardPorts": [3000, 5432],
  "remoteUser": "node"
}

Docker Compose para Dev Container

version: '3.8'
services:
  app:
    image: mcr.microsoft.com/devcontainers/javascript-node:20
    volumes:
      - ..:/workspace:cached
    command: sleep infinity
    network_mode: service:db

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: dev
      POSTGRES_DB: workspace
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  postgres-data:

Abrindo no Dev Container

Pressione F1 no Cursor
Selecione Dev Containers: Reopen in Container
O Cursor construirá o contêiner e reabrirá o workspace dentro dele

Primeiro Build

A construção inicial do contêiner pode levar alguns minutos. Reconstruções subsequentes usarão o cache do Docker e serão muito mais rápidas.

Depurando Dentro de Contêineres

Depuração Node.js

Adicione ao Docker Compose:

services:
  app:
    build: .
    ports:
      - "3000:3000"
      - "9229:9229"  # Debug port
    command: node --inspect=0.0.0.0:9229 index.js

Configuração do launch.json no Cursor:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Docker: Attach to Node",
      "type": "node",
      "request": "attach",
      "port": 9229,
      "address": "localhost",
      "localRoot": "${workspaceFolder}",
      "remoteRoot": "/app",
      "skipFiles": ["<node_internals>/**"]
    }
  ]
}

Depuração Python em Contêiner

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "-m", "debugpy", "--listen", "0.0.0.0:5678", "--wait-for-client", "app.py"]

Fluxos de Trabalho Docker Comuns

Build e Run

# Build image
docker build -t myapp:latest .

# Run container
docker run -p 3000:3000 --env-file .env myapp:latest

# Run with volume mount
docker run -p 3000:3000 -v $(pwd):/app myapp:latest

Migrações de Banco de Dados

# Run migrations in container
docker-compose exec app npx prisma migrate deploy

# Seed database
docker-compose exec app npx prisma db seed

Visualizando Logs

# Follow all logs
docker-compose logs -f

# Specific service
docker-compose logs -f app

# Last 100 lines
docker-compose logs --tail=100 app

Referência Rápida de Comandos Docker

Comando	Descrição
`docker ps`	Listar contêineres em execução
`docker images`	Listar imagens locais
`docker-compose up -d`	Iniciar serviços em segundo plano
`docker-compose down`	Parar e remover contêineres
`docker-compose build`	Reconstruir imagens
`docker exec -it <container> sh`	Acessar shell de contêiner em execução
`docker logs -f <container>`	Acompanhar logs do contêiner
`docker system prune`	Limpar recursos não utilizados

Solução de Problemas com Cursor

Contêiner Não Inicia

Compartilhe seu Dockerfile e logs de erro:

Este contêiner está saindo imediatamente com código 1. O Dockerfile e os logs são:
[Colar conteúdo]

Conflitos de Porta

Error: bind EADDRINUSE :::3000

O Cursor verificará a disponibilidade de portas do host e sugerirá modificar o mapeamento de portas.

Problemas de Permissão

Correção comum para problemas de permissão de volumes:

# Add to Dockerfile
RUN chown -R node:node /app
USER node

Configuração Multi-Ambiente

project/
  docker/
    Dockerfile.dev
    Dockerfile.prod
  docker-compose.yml
  docker-compose.prod.yml
  docker-compose.override.yml

Compose de Produção

version: '3.8'
services:
  app:
    build:
      context: ..
      dockerfile: docker/Dockerfile.prod
    restart: always
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '1'
          memory: 512M

Auditoria de Dockerfile com IA

Peça ao Cursor para auditar sua configuração:

Revise esta configuração Docker quanto a:
Melhores práticas de segurança
Otimização de tamanho de imagem
Eficiência de cache de build
Manuseio adequado de sinais (PID 1)
Health checks

Recursos Relacionados

Última atualização: Julho de 2025

Pré-requisitos​

Gerando Dockerfiles com Cursor​

Dockerfile de Produção​

Otimizando Dockerfiles Existentes​

Melhores Práticas para .dockerignore​

Stack de Desenvolvimento com Docker Compose​

Configuração de Aplicação Full-Stack​

Configuração de Hot Reload​

Dev Containers no Cursor​

Configuração do .devcontainer​

Docker Compose para Dev Container​

Abrindo no Dev Container​

Depurando Dentro de Contêineres​

Depuração Node.js​

Depuração Python em Contêiner​

Fluxos de Trabalho Docker Comuns​

Build e Run​

Migrações de Banco de Dados​

Visualizando Logs​

Referência Rápida de Comandos Docker​

Solução de Problemas com Cursor​

Contêiner Não Inicia​

Conflitos de Porta​

Problemas de Permissão​

Configuração Multi-Ambiente​

Compose de Produção​

Auditoria de Dockerfile com IA​

Recursos Relacionados​