Cursor Docker-Entwicklung: Containerisierte Workflows leicht gemacht

Docker ist für konsistente Entwicklungsumgebungen unverzichtbar geworden, und die KI-Funktionen von Cursor machen die Arbeit mit Containern schneller und intuitiver. Dieser Leitfaden deckt Dockerfile-Erstellung, Docker Compose-Orchestrierung, Dev Containers und Debugging-Workflows ab.

Voraussetzungen

Bevor Sie beginnen:

• Docker installiert und auf Ihrem Rechner lauffähig
• Cursor (neueste Version empfohlen)
• Grundvertrautheit mit Docker-Konzepten (Images, Container, Volumes)

Dockerfiles mit Cursor erstellen

Produktionsreife Dockerfiles generieren

Beschreiben Sie Ihren Anwendungsstack und lassen Sie Cursor optimierte Dockerfiles generieren:

Erstelle ein Multi-Stage-Dockerfile für eine Next.js 14-Anwendung, das:
- Node.js 20 Alpine verwendet
- Abhängigkeiten mit npm ci installiert
- Das Produktionsbundle baut
- Als Nicht-Root-Benutzer läuft
- Ein minimales finales Image verwendet

Cursor generiert:

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

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

# Nicht-Root-Benutzer erstellen
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"]

Bestehende Dockerfiles optimieren

Fügen Sie Ihr Dockerfile ein und bitten Sie um Verbesserungen:

Optimiere dieses Dockerfile für schnellere Builds und kleinere Image-Größe:
[Dockerfile einfügen]

Häufige Optimierungen, die Cursor vorschlägt:

• RUN-Befehle kombinieren, um Layer zu reduzieren
• .dockerignore verwenden, um Kontext zu minimieren
• Build-Cache effektiv nutzen
• Spezifische Basis-Image-Tags statt latest verwenden

.dockerignore Best Practices

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

Docker Compose Entwicklungs-Stacks

Full-Stack-Anwendungs-Setup

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:

Hot-Reload-Setup

Für die Entwicklung mit Live-Reloading:

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

Volume-Trick

Mounten Sie Ihren Quellcode mit - .:/app, aber schließen Sie node_modules mit - /app/node_modules aus. Dies verhindert Konflikte zwischen Container- und Host-node_modules.

Dev Containers in Cursor

.devcontainer einrichten

Erstellen Sie .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"
}

Dev Container Docker Compose

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:

Einen Dev Container öffnen

1. Drücken Sie F1 in Cursor
2. Wählen Sie Dev Containers: Reopen in Container
3. Cursor wird den Container bauen und den Arbeitsbereich darin erneut öffnen

Erster Build

Der initiale Container-Build kann mehrere Minuten dauern. Nachfolgende Rebuilds nutzen den Docker-Cache und sind viel schneller.

Debugging in Containern

Node.js-Debugging

Fügen Sie zu Ihrem Docker Compose hinzu:

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

Konfigurieren Sie Cursor launch.json:

{
  "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>/**"]
    }
  ]
}

Python-Debugging in Containern

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"]

Häufige Docker-Workflows

Build und Run

# Image bauen
docker build -t myapp:latest .

# Container starten
docker run -p 3000:3000 --env-file .env myapp:latest

# Mit Volume-Mount starten
docker run -p 3000:3000 -v $(pwd):/app myapp:latest

Datenbank-Migrationen

# Migrationen im Container ausführen
docker-compose exec app npx prisma migrate deploy

# Datenbank seeden
docker-compose exec app npx prisma db seed

Logs anzeigen

# Alle Logs verfolgen
docker-compose logs -f

# Spezifischer Service
docker-compose logs -f app

# Letzte 100 Zeilen
docker-compose logs --tail=100 app

Docker-Befehle Kurzreferenz

Befehl	Beschreibung
docker ps	Laufende Container auflisten
docker images	Lokale Images auflisten
docker-compose up -d	Services im Hintergrund starten
docker-compose down	Container stoppen und entfernen
docker-compose build	Images neu bauen
docker exec -it <container> sh	Shell in laufenden Container
docker logs -f <container>	Container-Logs verfolgen
docker system prune	Ungenutzte Ressourcen bereinigen

Fehlersuche mit Cursor

Container startet nicht

Teilen Sie Ihr Dockerfile und die Fehlerlogs:

Dieser Container wird sofort mit Code 1 beendet. Hier ist mein Dockerfile und die Logs:
[Inhalt einfügen]

Port-Konflikte

Error: bind EADDRINUSE :::3000

Cursor schlägt vor, die Host-Port-Verfügbarkeit zu prüfen und Port-Mappings zu ändern.

Berechtigungsprobleme

Häufige Lösung für Volume-Berechtigungsprobleme:

# Zum Dockerfile hinzufügen
RUN chown -R node:node /app
USER node

Multi-Umgebungs-Konfiguration

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

Produktions-Compose

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

KI-gestützte Dockerfile-Überprüfung

Bitten Sie Cursor, Ihr Setup zu auditieren:

Überprüfe dieses Docker-Setup auf:
1. Sicherheits-Best-Practices
2. Image-Größen-Optimierung
3. Build-Cache-Effizienz
4. Korrekte Signalbehandlung (PID 1)
5. Health Checks

Verwandte Ressourcen

• Cursor Datenbankentwicklungsleitfaden
• Cursor API-Entwicklungsleitfaden
• Cursor Hintergrund-Agent-Leitfaden

Zuletzt aktualisiert: Juli 2025