Docker per Svogliati

# macOS
brew install --cask docker
# Apri Docker Desktop dall'applicazione, aspetta che la balena sia ferma

# Linux (Docker Engine - senza GUI)
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER   # così non serve sudo ogni volta
newgrp docker                     # applica subito

# Verifica
docker --version
Docker version 27.x.x, build abc123

# Il test definitivo
docker run hello-world
Hello from Docker!
This message shows that your installation appears to be working correctly.

# Parti da un'immagine base (il "sistema operativo")
FROM node:20-alpine          # Alpine = versione leggera (~50MB vs ~1GB)

# Cartella di lavoro dentro il container
WORKDIR /app

# Copia PRIMA solo package.json (per sfruttare la cache dei layer)
COPY package*.json ./

# Installa le dipendenze (questo layer viene cachato!)
RUN npm ci --only=production

# ORA copia il resto del codice
COPY . .

# Esponi la porta (documentazione, non apre davvero)
EXPOSE 3000

# Utente non-root (sicurezza!)
USER node

# Comando di avvio
CMD ["node", "server.js"]

# Costruisci l'immagine (il . è il contesto, la cartella con il Dockerfile)
docker build -t mia-app:1.0 .
#    -t = tag (nome:versione)

# Eseguila
docker run -d --name mia-app -p 3000:3000 mia-app:1.0

# Vedi i layer e la dimensione
docker history mia-app:1.0

# Stage 1: Compila
FROM golang:1.22 AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o server .

# Stage 2: Immagine finale (solo il binario!)
FROM alpine:3.19
COPY --from=builder /app/server /server
EXPOSE 8080
CMD ["/server"]

# Risultato: immagine da ~15MB invece di ~1GB 🚀

node_modules
.git
.env
.env.*
*.md
.vscode
.idea
docker-compose*.yml
Dockerfile*
.DS_Store

# docker-compose.yml (o compose.yml, entrambi funzionano)

services:

  # La tua app
  app:
    build: .                       # Usa il Dockerfile nella cartella corrente
    ports:
      - "3000:3000"               # host:container
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
      - REDIS_URL=redis://cache:6379
    depends_on:                   # Parte DOPO db e cache
      - db
      - cache
    volumes:
      - ./src:/app/src             # Hot reload! Modifichi il codice e si aggiorna
    restart: unless-stopped       # Si riavvia da solo se crasha

  # PostgreSQL
  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - db-data:/var/lib/postgresql/data   # Dati persistenti!
    ports:
      - "5432:5432"               # Opzionale: per connetterti da fuori

  # Redis (cache)
  cache:
    image: redis:7-alpine
    ports:
      - "6379:6379"

# Volumi con nome (persistono tra i restart)
volumes:
  db-data:

# Avvia tutto (build se necessario)
docker compose up -d           # -d = background

# Avvia e forza rebuild delle immagini
docker compose up -d --build

# Ferma tutto
docker compose down

# Ferma e CANCELLA i volumi (⚠️ cancella i dati del DB!)
docker compose down -v

# Vedi i log di tutti i servizi
docker compose logs -f

# Log di un servizio specifico
docker compose logs -f app

# Stato dei servizi
docker compose ps

# Esegui un comando in un servizio
docker compose exec app /bin/sh
docker compose exec db psql -U user mydb

# Riavvia un singolo servizio
docker compose restart app

# Scala un servizio (più istanze)
docker compose up -d --scale app=3

POSTGRES_USER=admin
POSTGRES_PASSWORD=super_segreta_123
POSTGRES_DB=produzione
APP_PORT=3000

services:
  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=${POSTGRES_DB}
  app:
    ports:
      - "${APP_PORT}:3000"

# Vedi le reti
docker network ls

# Crea una rete custom
docker network create mia-rete

# Collega un container a una rete
docker run -d --name app --network mia-rete nginx

# Ispeziona una rete (chi c'è connesso)
docker network inspect mia-rete

# In Docker Compose non serve fare niente:
# i container si vedono per NOME del servizio automaticamente
# app raggiunge db con "db:5432", cache con "cache:6379"

# 1. VOLUME (gestito da Docker - CONSIGLIATO per dati)
docker run -d -v db-data:/var/lib/postgresql/data postgres
# Docker gestisce dove salvare. Performante, portabile.

# 2. BIND MOUNT (cartella dell'host - CONSIGLIATO per sviluppo)
docker run -d -v $(pwd)/src:/app/src mia-app
# Monta la cartella src del tuo PC dentro il container.
# Modifichi un file sul PC → si aggiorna nel container. Hot reload!

# 3. TMPFS (solo in memoria - per dati temporanei)
docker run -d --tmpfs /tmp mia-app

# Comandi utili
docker volume ls              # lista volumi
docker volume inspect db-data  # dettagli
docker volume rm db-data       # cancella
docker volume prune            # cancella tutti quelli non in uso

# 1. Login
docker login

# 2. Tagga l'immagine con il tuo username
docker tag mia-app:1.0 tuoutente/mia-app:1.0

# 3. Pusha
docker push tuoutente/mia-app:1.0

# 4. Da un altro PC, chiunque può scaricarla
docker pull tuoutente/mia-app:1.0

# GitHub Container Registry
docker login ghcr.io
docker tag mia-app:1.0 ghcr.io/tuoutente/mia-app:1.0
docker push ghcr.io/tuoutente/mia-app:1.0

# GitLab Container Registry
docker login registry.gitlab.com
docker tag mia-app:1.0 registry.gitlab.com/tuogruppo/tuorepo:1.0
docker push registry.gitlab.com/tuogruppo/tuorepo:1.0

# AWS ECR / Google GCR / Azure ACR: stessa logica, login diverso

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

services:
  app:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 3s
      retries: 3
      start_period: 10s

# La tua app deve loggare su STDOUT/STDERR, non su file
# Docker li cattura automaticamente

# Vedi i log
docker logs mia-app
docker logs --since 1h mia-app     # ultima ora
docker logs --tail 100 mia-app     # ultime 100 righe

# Limita la dimensione dei log (in compose)

services:
  app:
    logging:
      driver: json-file
      options:
        max-size: "10m"      # Max 10MB per file di log
        max-file: "3"        # Max 3 file (rotazione)