Docker Compose vs Dockerfile

Dockerfile: Costruire Immagini Docker

Cos'è Dockerfile?

Il Dockerfile è un file di testo che contiene tutte le istruzioni per costruire un'immagine Docker. Definisce cosa deve essere incluso nell'immagine e come configurarla.

Quando Usare Cosa

• Solo Dockerfile: Applicazioni singole, immagini base personalizzate, CI/CD pipelines

• Docker Compose: Sviluppo locale, ambienti di testing, applicazioni microservizi

• Entrambi: Scenari reali dove Compose usa immagini buildate con Dockerfile

Quando usare Dockerfile:

• Creazione di immagini personalizzate

• Definizione dell'ambiente di runtime

• Packaging di applicazioni

• Automazione del build process

Esempio Dockerfile:

# Immagine base
FROM node:18-alpine

# Imposta la directory di lavoro
WORKDIR /app

# Copia i file di dipendenza
COPY package*.json ./

# Installa le dipendenze
RUN npm install

# Copia il codice sorgente
COPY . .

# Espone la porta
EXPOSE 3000

# Comando di avvio
CMD ["npm", "start"]

Build dell'immagine:

docker build -t mia-app:latest .

---

Docker Compose: Orchestrazione di Container

Cos'è Docker Compose?

Docker Compose è uno strumento per definire e gestire applicazioni multi-container. Usa un file YAML per configurare i servizi, reti e volumi dell'applicazione.

Quando usare Docker Compose:

• Applicazioni multi-container

• Ambienti di sviluppo

• Testing di architetture complesse

• Deploy locali

---

Esempi Pratici Confrontati

Scenario 1: Applicazione Web Semplice

Solo Dockerfile:

FROM nginx:alpine
COPY html /usr/share/nginx/html
EXPOSE 80

docker build -t mio-sito .
docker run -p 8080:80 mio-sito

Con Docker Compose:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html

docker compose up 

Scenario 2: Applicazione Multi-Servizio (Web + Database)

Dockerfile per l'applicazione:

FROM python:3.9
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Docker Compose per l'orchestrazione:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/mydb
    depends_on:
      - db
    volumes:
      - .:/app

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Scenario 3: Ambiente di Sviluppo Complesso

version: '3.8'
services:
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    volumes:
      - ./frontend:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development

  backend:
    build: ./backend
    ports:
      - "8000:8000"
    volumes:
      - ./backend:/app
    environment:
      - DEBUG=True
      - DATABASE_URL=postgresql://user:pass@db:5432/devdb
    depends_on:
      - db

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: devdb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
    volumes:
      - postgres_data:/var/lib/postgresql/data

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

volumes:
  postgres_data:

---

Differenze Chiave

Caratteristica	Dockerfile	Docker Compose
Scopo	Build immagini	Orchestrazione container
Sintassi	Istruzioni Docker	YAML
Multi-container	No	Sì
Rete	Manuale	Automatizzata
Volumi	Manuale	Configurabile
Variabili d'ambiente	ENV instruction	Sezione environment

---

Best Practices

Dockerfile:

# Usa immagini ufficiali
FROM node:18-alpine

# Multi-stage build per ridurre dimensioni
FROM base AS builder
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

# Ordina le istruzioni per caching
COPY package*.json ./
RUN npm install
COPY . .

# Usa utenti non-root
USER node

# Health check
HEALTHCHECK --interval=30s CMD curl -f http://localhost:3000/health

Docker Compose:

version: '3.8'
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.prod
    environment:
      - NODE_ENV=production
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M

  # Configurazione di rete personalizzata
networks:
  default:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

---

Comandi Utili

Docker Compose:

# Avvia tutti i servizi
docker compose up

# Avvia in background
docker compose up -d

# Ferma i servizi
docker compose down

# Visualizza log
docker compose logs

# Esegui comando in un servizio
docker compose exec web bash

# Ricrea i container
docker compose up --force-recreate

Solo Docker:

# Build immagine
docker build -t myapp .

# Esegui container
docker run -p 3000:3000 myapp

# Esegui con variabili d'ambiente
docker run -e DEBUG=1 -p 3000:3000 myapp