Développement Docker avec Cursor : Workflows conteneurisés simplifiés

Docker est devenu essentiel pour des environnements de développement cohérents, et les capacités IA de Cursor rendent le travail avec les conteneurs plus rapide et plus intuitif. Ce guide couvre la création de Dockerfile, l'orchestration Docker Compose, les Dev Containers et les workflows de débogage.

Prérequis

Avant de commencer :

• Docker installé et en cours d'exécution sur votre machine
• Cursor (dernière version recommandée)
• Familiarité de base avec les concepts Docker (images, conteneurs, volumes)

Création de Dockerfiles avec Cursor

Génération de Dockerfiles prêts pour la production

Décrivez votre stack applicative et laissez Cursor générer des Dockerfiles optimisés :

Crée un Dockerfile multi-étapes pour une application Next.js 14 qui :
- Utilise Node.js 20 Alpine
- Installe les dépendances avec npm ci
- Compile le bundle de production
- S'exécute en tant qu'utilisateur non-root
- Utilise une image finale minimale

Cursor génère :

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

# Étape de production
FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production

# Créer un utilisateur non-root
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"]

Optimisation des Dockerfiles existants

Collez votre Dockerfile et demandez des améliorations :

Optimise ce Dockerfile pour des builds plus rapides et une image plus petite :
[coller le Dockerfile]

Optimisations courantes suggérées par Cursor :

• Combiner les commandes RUN pour réduire les couches
• Utiliser .dockerignore pour minimiser le contexte
• Exploiter efficacement le cache de build
• Utiliser des tags d'image de base spécifiques au lieu de latest

Bonnes pratiques .dockerignore

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

Stacks de développement Docker Compose

Configuration d'application 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:

Configuration du hot reload

Pour le développement avec rechargement en direct :

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

Astuce sur les volumes

Montez votre code source avec - .:/app mais excluez node_modules avec - /app/node_modules. Cela empêche les conflits entre les node_modules du conteneur et de l'hôte.

Dev Containers dans Cursor

Configuration de .devcontainer

Créez .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 du 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:

Ouverture d'un Dev Container

1. Appuyez sur F1 dans Cursor
2. Sélectionnez Dev Containers: Reopen in Container
3. Cursor construira le conteneur et rouvrira l'espace de travail à l'intérieur

Premier build

Le build initial du conteneur peut prendre plusieurs minutes. Les reconstructions suivantes utilisent le cache Docker et sont beaucoup plus rapides.

Débogage dans les conteneurs

Débogage Node.js

Ajoutez à votre Docker Compose :

services:
  app:
    build: .
    ports:
      - "3000:3000"
      - "9229:9229"  # Port de débogage
    command: node --inspect=0.0.0.0:9229 index.js

Configurez le launch.json de 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>/**"]
    }
  ]
}

Débogage Python dans les conteneurs

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

Workflows Docker courants

Build et run

# Construire l'image
docker build -t myapp:latest .

# Lancer le conteneur
docker run -p 3000:3000 --env-file .env myapp:latest

# Lancer avec montage de volume
docker run -p 3000:3000 -v $(pwd):/app myapp:latest

Migrations de base de données

# Exécuter les migrations dans le conteneur
docker-compose exec app npx prisma migrate deploy

# Seeder la base de données
docker-compose exec app npx prisma db seed

Visualisation des logs

# Suivre tous les logs
docker-compose logs -f

# Service spécifique
docker-compose logs -f app

# 100 dernières lignes
docker-compose logs --tail=100 app

Référence rapide des commandes Docker

Commande	Description
docker ps	Lister les conteneurs en cours d'exécution
docker images	Lister les images locales
docker-compose up -d	Démarrer les services en arrière-plan
docker-compose down	Arrêter et supprimer les conteneurs
docker-compose build	Reconstruire les images
docker exec -it <container> sh	Shell dans un conteneur en cours d'exécution
docker logs -f <container>	Suivre les logs du conteneur
docker system prune	Nettoyer les ressources inutilisées

Dépannage avec Cursor

Le conteneur ne démarre pas

Partagez votre Dockerfile et les logs d'erreur :

Ce conteneur se termine immédiatement avec le code 1. Voici mon Dockerfile et les logs :
[coller le contenu]

Conflits de ports

Error: bind EADDRINUSE :::3000

Cursor suggère de vérifier la disponibilité du port hôte et de modifier les mappages de ports.

Problèmes de permissions

Correction courante pour les problèmes de permissions de volumes :

# Ajouter au Dockerfile
RUN chown -R node:node /app
USER node

Configuration multi-environnement

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

Compose de production

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

Revue de Dockerfile pilotée par IA

Demandez à Cursor d'auditer votre configuration :

Révise cette configuration Docker pour :
1. Les bonnes pratiques de sécurité
2. L'optimisation de la taille de l'image
3. L'efficacité du cache de build
4. La gestion correcte des signaux (PID 1)
5. Les health checks

Ressources connexes

• Guide de développement de bases de données avec Cursor
• Guide de développement d'API avec Cursor
• Guide de l'agent en arrière-plan avec Cursor

Dernière mise à jour : Juillet 2025