Docker per principianti: comandi essenziali + workflow reale

Docker ti permette di far girare applicazioni in container: ambienti isolati e riproducibili, perfetti per evitare la classica frase “sul mio PC funziona”.

Sotto trovi una lista pratica (stile cheatsheet) dei comandi più utili, il tuo primo Dockerfile e un mini workflow reale per iniziare subito.

1. Immagini (images)

#

docker pull nginx:latest - scarica un’immagine da Docker Hub

docker images (o docker image ls) - elenca le immagini presenti in locale

docker rmi nginx:latest - rimuove un’immagine

docker image prune - cancella le immagini “dangling” (senza tag)

docker image prune -a - cancella tutte le immagini non usate da nessun container (attenzione)

2. Container: avviare, fermare, ispezionare

#

docker run hello-world - esegue un container di test

docker ps - mostra i container attivi

docker ps -a - mostra tutti i container (anche quelli fermi)

docker stop <container> - ferma un container

docker start <container> - avvia di nuovo un container fermo

docker restart <container> - riavvia un container

docker rm <container> - elimina un container (deve essere fermo, oppure usa -f)

3. Run “come si deve”: porte, nome, background

#

docker run -d --name web -p 8080:80 nginx:latest - avvia Nginx in background e mappa la porta 8080 del tuo PC sulla porta 80 del container

• -d = detached (in background)
• --name = un nome più comodo dell’ID
• -p host:container = port mapping
• --rm = elimina il container quando si ferma (comodo per i test)

Ora apri http://localhost:8080 nel browser e vedrai la pagina di benvenuto di Nginx.

4. Log e debug rapido

#

docker logs web - mostra i log

docker logs -f web - segue i log in tempo reale

docker exec -it web /bin/sh - apre una shell dentro il container

docker inspect web - mostra tutti i dettagli del container (rete, volumi, variabili…)

Tip: su alcune immagini è disponibile /bin/bash, ma nelle immagini Alpine c’è solo sh.

5. Copiare file da/verso container

#

docker cp web:/etc/nginx/nginx.conf ./nginx.conf - copia dal container al tuo PC

docker cp ./index.html web:/usr/share/nginx/html/index.html - copia dal PC al container

6. Volumi: persistenza dei dati (fondamentale)

#

Senza volumi, i dati scritti nel container spariscono quando il container viene eliminato. Con i volumi li rendi persistenti.

docker volume ls - elenca i volumi

docker volume create mydata - crea un volume

docker run -d --name db -e POSTGRES_PASSWORD=pass -v mydata:/var/lib/postgresql/data postgres:16 - Postgres con dati persistenti

docker run -d -p 8080:80 -v "$(pwd)/sito":/usr/share/nginx/html nginx - “bind mount”: monta una cartella del tuo PC nel container (ottimo in sviluppo)

docker volume rm mydata - elimina un volume (attenzione: perdi i dati)

7. Network: far parlare i container tra loro

#

docker network ls - elenca le reti

docker network create app-net - crea una rete

docker run -d --name db --network app-net -e POSTGRES_PASSWORD=pass postgres:16 - DB nella rete

docker run -d --name api --network app-net my-api:latest - API nella stessa rete

Così api può raggiungere db usando il nome db come hostname.

8. Pulizia: liberare spazio senza fare danni

#

docker system df - mostra quanto spazio usano immagini, container e volumi

docker container prune - elimina i container fermi

docker image prune - elimina le immagini dangling

docker system prune - pulizia più aggressiva: container fermi, reti inutilizzate, immagini dangling e cache di build (i volumi restano, a meno di aggiungere --volumes)

9. Build: creare la tua immagine

#

Un Dockerfile è la “ricetta” della tua immagine. Ecco un esempio minimo per un’app Node.js:

# Immagine di partenza
FROM node:22-alpine

# Cartella di lavoro dentro il container
WORKDIR /app

# Prima solo i file delle dipendenze: così Docker riusa la cache se non cambiano
COPY package*.json ./
RUN npm ci --omit=dev

# Poi il resto del codice
COPY . .

EXPOSE 3000
CMD ["node", "server.js"]

docker build -t myapp:1.0 . - crea l’immagine dal Dockerfile nella cartella corrente

docker run -p 3000:3000 myapp:1.0 - avvia l’immagine appena creata

Tip: aggiungi un file .dockerignore con node_modules e .git, così la build è più veloce e l’immagine più leggera.

10. Mini workflow reale (copiabile): database + pannello di amministrazione con Docker Compose

#

Esempio docker-compose.yml (Postgres + pgAdmin):

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: pass
      POSTGRES_USER: user
      POSTGRES_DB: appdb
    ports:
      - "5432:5432"
    volumes:
      - dbdata:/var/lib/postgresql/data

  pgadmin:
    image: dpage/pgadmin4
    environment:
      PGADMIN_DEFAULT_EMAIL: [email protected]
      PGADMIN_DEFAULT_PASSWORD: pass
    ports:
      - "5050:80"
    depends_on:
      - db

volumes:
  dbdata:

Comandi:

docker compose up -d - avvia tutto in background

docker compose ps - stato dei servizi

docker compose logs -f - log in tempo reale

docker compose down - ferma e rimuove i container (i volumi restano)

docker compose down -v - ferma tutto e cancella anche i volumi (attenzione: perdi i dati)

Apri http://localhost:5050, accedi a pgAdmin e collega il server usando db come host.

Sicurezza: le password scritte nel file vanno bene solo in locale. Nei progetti reali spostale in un file .env (da non pubblicare su Git) o usa i secrets.

Bonus: 5 concetti che ti chiariscono Docker in 30 secondi

#

• Image = “template” dell’app (immutabile)
• Container = istanza in esecuzione di un’immagine
• Volume = spazio persistente per i dati
• Network = rete virtuale per la comunicazione tra container
• Compose = modo semplice per gestire più container insieme

Impara 2-3 comandi a settimana e vedrai che Docker smetterà di sembrare “magia nera”.