Docker per Sviluppatori: Guida Pratica

Docker ha rivoluzionato il modo in cui gli sviluppatori costruiscono, distribuiscono e eseguono le applicazioni. Con i container, il classico problema "funziona sulla mia macchina" diventa finalmente un ricordo del passato. In questa guida pratica vediamo come sfruttare Docker nel flusso di lavoro quotidiano.

Concetti Fondamentali

Prima di sporcarci le mani, è importante chiarire alcuni concetti chiave:

• Image — Snapshot immutabile del filesystem e della configurazione di un ambiente
• Container — Istanza in esecuzione di un'image, isolata e con propria rete
• Dockerfile — File di testo con le istruzioni per costruire un'image
• Docker Compose — Tool per orchestrare più container che lavorano insieme
• Registry — Repository dove vengono pubblicate le image (Docker Hub, GHCR, ECR)

Il Tuo Primo Dockerfile

Un Dockerfile per una app Laravel:

FROM php:8.3-fpm-alpine

# Installa dipendenze sistema
RUN apk add --no-cache 
    postgresql-dev 
    git 
    unzip 
    && docker-php-ext-install pdo pdo_pgsql

# Installa Composer
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

WORKDIR /var/www/html

# Copia dipendenze prima del codice (cache layer)
COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader --no-interaction

# Copia il resto dell'applicazione
COPY . .

RUN php artisan config:cache 
    && php artisan route:cache 
    && php artisan view:cache

EXPOSE 9000
CMD ["php-fpm"]

Docker Compose per lo Sviluppo Locale

Un docker-compose.yml completo per un progetto Laravel:

services:
  app:
    build: .
    volumes:
      - .:/var/www/html
    depends_on:
      - db
      - redis
    environment:
      DB_HOST: db
      REDIS_HOST: redis

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - .:/var/www/html
      - ./docker/nginx.conf:/etc/nginx/conf.d/default.conf
    depends_on:
      - app

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine

volumes:
  db_data:

Comandi Essenziali

I comandi Docker che userai ogni giorno:

# Avvia tutti i servizi in background
docker compose up -d

# Visualizza i log in tempo reale
docker compose logs -f app

# Esegui un comando in un container running
docker compose exec app php artisan migrate

# Entra nella shell di un container
docker compose exec app sh

# Ricostruisci l'image dopo modifiche al Dockerfile
docker compose build --no-cache app

# Ferma e rimuovi container (mantiene i volumi)
docker compose down

# Ferma e rimuovi tutto, inclusi i volumi
docker compose down -v

Multi-stage Build per Produzione

Riduci drasticamente la dimensione dell'image finale con i multi-stage build:

# Stage 1: build delle dipendenze Node
FROM node:20-alpine AS frontend
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: build PHP
FROM php:8.3-fpm-alpine AS backend
COPY --from=frontend /app/public/build /var/www/html/public/build
# ... resto della configurazione PHP

# Stage 3: image finale minimale
FROM php:8.3-fpm-alpine AS production
COPY --from=backend /var/www/html /var/www/html
# Solo i file necessari, niente tool di build

Best Practices

• Non usare latest in produzione — Specifica sempre la versione esatta dell'image
• Un processo per container — Un container = un servizio (app, db, redis separati)
• Usa .dockerignore — Escludi node_modules, .git, log, .env dall'image
• Variabili d'ambiente per i segreti — Mai hardcodare password nel Dockerfile
• Layer caching — Copia i file che cambiano raramente (composer.json) prima del codice sorgente

Conclusioni

Docker semplifica enormemente la gestione degli ambienti di sviluppo e rende il deploy prevedibile e riproducibile. Una volta che hai containerizzato la tua app, scalare su Kubernetes o migrare su un nuovo server diventa un'operazione di pochi minuti.

Inizia con docker compose up e non tornerai più indietro.