/posts/docker/docker_reference/docker_reference.webp

Docker Reference - Guida Completa ai Comandi

Cheat sheet completa per Docker e Docker Compose

2025-04-06 1932 parole 10 minuti

Contenuti

Docker Reference - Guida Completa ai Comandi

Docker è diventato lo standard de facto per la containerizzazione delle applicazioni. Questa guida fornisce una reference completa dei comandi Docker più utilizzati, organizzati per categorie e arricchiti con esempi pratici.

A chi è rivolta questa guida

Questa guida è pensata per sviluppatori e sistemisti che lavorano quotidianamente con Docker e hanno bisogno di un riferimento rapido ai comandi più comuni. Include esempi pratici e best practices.

1. Gestione delle Immagini

Comando	Descrizione	Esempio
docker search ImageName	Restituisce la ricerca dell’immagine fatta su Docker Hub. Posso cercare sia immagini di siti sia nomi di programmi che mi servono	docker search ubuntu
docker pull ImageName	Scarica l’immagine NB: Scarica la versione latest	docker pull ubuntu
docker pull ImageName:tag	Scarica la versione dell’immagine richiesta	docker pull nginx:stable docker pull nginx:mainline
docker image ls	Mostra tutte le immagini scaricate La data è la data di creazione dell’autore
docker image rm NomeImmagine	Rimuove l’immagine selezionata. Può essere rimossa solo se nessun container attivo o stoppato la sta usando	docker image rm ubuntu:latest
docker rmi ImageName:tag	Rimuove l’immagine selezionata e tutti i suoi layer	docker rmi nginx:stable
docker history ImageName	Espande le informazioni del dockerfile dell’immagine	docker history node:latest
docker inspect ImageName:tag	Espande nel dettaglio le informazioni dell’immagine	docker inspect node:latest
docker manifest inspect ImageName	Interroga il manifest e ritorna l’elenco delle versioni compatibili con ogni architettura.	docker manifest inspect nginx docker manifest inspect –verbose nginx
docker run ImageName	Lancia un’immagine Docker	docker run ubuntu
docker run ImageName command	Lancia un’immagine ed esegue un comando. La shell della console non viene attaccata	docker run ubuntu bash
docker run -it ImageName command	Lancia un’immagine e attacca al terminale solo la shell	docker run -it ubuntu bash
docker run -it –name NomeScelto ImageName Command	Il parametro –name mi consente di dare un nome personalizzato al container quando lo lancio per la prima volta	docker run -it prova-ubuntu ubuntu bash
docker rm NomeContainer	Elimina definitivamente un container. Posso usare anche il suo ID. Se uso -f forza la rimozione, anche se il container è in esecuzione	docker rm prova-ubuntu
docker container prune	Elimina tutti i container stoppati
docker attach IdContainer	Mi collego alla shell interattiva di un container in esecuzione. Al posto dell’id posso usare anche il nome del container	docker attach prova-ubuntu
docker start NomeContainer	Rilancia un container che era stato stoppato. I dati del container non vengono cancellati quando lo stoppo	docker start prova-ubuntu
docker run –rm -it –name NomeContainer ImageName Command	Il parametro –rm imposta la cancellazione del container quando lo stoppo.	docker run –rm -it prova-ubuntu ubuntu bash
CTRL+D	Esce da un terminale interattivo, stoppa anche il container
CTRL+P poi CTRL+Q	Esce da un terminale interattivo, non stoppa il container. Mi posso ricollegare
docker ps	Il comando PS (Processes) elenca tutti i container in esecuzione
docker ps –all docker ps -a	Elenca tutti i container in esecuzione e quelli stoppati
docker run -d ImageName command	-d sta per detached. Il comando non blocca la shell da cui è lanciato. Esempio, se tolgo -d la shell resta bloccata per 60 secondi	docker run -d ubuntu sleep 60
docker stop ID docker stop NomeContainer	Stoppa il container selezionato
systemctl stop docker	Stoppa il servizio di docker e stoppa tutti i container
docker run –rm -it ImageName bash -c “Command1;Command2;Command3”	Il parametro -c dopo bash mi consente di specificare più comandi tra virgolette. I comandi si separano con ; o &&	docker run –rm -it ubuntu bash -c “sleep 5; echo ho dormito” docker run –rm -it ubuntu bash -c “sleep 5 && echo ho dormito”
docker logs IdContainer docker logs ContainerName	Stampa la console del container specificato. Con -f (follow) continua a stampare ogni nuova riga che arriva nella console del container	docker logs prova-ubuntu docker logs -f prova-ubuntu
docker kill IdContainer docker kill ContainerName	Stoppa forzatamente un container
docker run –cpus number ImageName	Il parametro –cpus seguito da un numero limita il numero di core che il container può usare	docker run –cpus 4 –rm jojje/cloud-cpu-bench
docker run –memory number+m ImageName	Il parametro –memory limita l’uso della RAM. Il numero va seguito dall’unità di misura (ad esempio m)	docker run –memory 1024m –rm -it ubuntu bash -c “head -c 4096m /dev/zero \| tail \| sleep 10”
docker run -p portaEsterna:portaInterna ImageName	Il parametro -p serve per esporre una porta. Va mappata sia la porta esterna sia quella in ascolto nel container. L’esempio espone la porta 80 sulla 8080 di localhost del mio sistema	docker run -p 8080:80 nginx
docker run -v percorsoEsterno:percorsoContainer ImageName	Il parametro -v mappa una cartella sul sistema host dentro una cartella del container docker	docker run -p 8080:80 -v /home/gianluca/webcontent:/usr/share/nginx/html nginx
docker compose up	Legge il file compose nella cartella corrente, crea e lancia lo stack. Ricorda -d per lanciare in modalità detached	docker compose up -d
docker compose down	Stoppa l’intero stack di container presenti nel docker compose
man docker	Mostra l’help del comando docker e la sintassi
docker volume create NomeVolume	Crea un volume persistente in Docker. Posso specificare un nome	docker volume create test-volume
docker volume ls	Mostra l’elenco di tutti i volumi
docker volume prune	Elimina tutti i volumi che non sono usati da almeno un container. Non elimina i container non anonimi (quelli a cui ho dato un nome) anche se non sono in uso. Per cancellare anche questi serve -a
docker volume inspect HashVolume	Dà maggiori informazioni sul volume

2. Gestione dei Container

Comandi di Controllo Container

Comando	Descrizione	Esempio
`docker ps`	Mostra container in esecuzione	`docker ps -a` (mostra tutti)
`docker start <container>`	Avvia un container stoppato	`docker start my-container`
`docker stop <container>`	Stoppa un container	`docker stop my-container`
`docker restart <container>`	Riavvia un container	`docker restart my-container`
`docker kill <container>`	Termina forzatamente un container	`docker kill my-container`

Esempi di Script Utili

Creare container multipli:

1
2
3
4


for i in {1..10}
do
  docker run -d --name "container-$i" ubuntu sleep 600
done

Stoppare tutti i container:

1
2
3
4


for container in $(docker ps -q)
do
  docker stop $container
done

Esempi pratici:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# Lanciare uno script in un container
docker run --name conta --rm ubuntu bash -c "for c in {1..100}; do sleep 1; date +%T; done"

# Vedere i log di un container in tempo reale
docker run -d --name conta ubuntu bash -c "for c in {1..100}; do sleep 1; date +%T; done"
docker logs -f conta

# Limitare le risorse di un container
# CPU: limitare a 2 core
docker run --cpus 2 --rm jojje/cloud-cpu-bench

# RAM: limitare a 1GB
docker run --memory 1024m --rm ubuntu bash -c "head -c 4096m /dev/zero | tail"

3. Gestione dei Volumi

Comandi per i Volumi

Comando	Descrizione	Esempio
`docker volume create <name>`	Crea un volume named	`docker volume create mydata`
`docker volume ls`	Lista tutti i volumi	`docker volume ls`
`docker volume inspect <name>`	Mostra dettagli del volume	`docker volume inspect mydata`
`docker volume prune`	Rimuove volumi non utilizzati	`docker volume prune -f`

Differenza tra Volumi e Bind Mounts

Bind Mounts:

Mappano una directory dell’host nel container
Prestazioni elevate
Modifiche bidirezionali

1

docker run -v /host/path:/container/path nginx

Volumi Docker:

Gestiti da Docker
Persistono anche dopo la rimozione del container
Possono essere condivisi tra container

1

docker run -v mydata:/data nginx

4. Docker Compose

Docker Compose permette di definire e gestire applicazioni multi-container attraverso file YAML. È essenziale per orchestrare stack complessi in sviluppo e produzione.

Best Practices Docker Compose

Utilizzare sempre indentazione a 2 spazi
Tutti i servizi nello stesso compose condividono la stessa rete di default
Usare file .env per le variabili sensibili
Specificare sempre versioni delle immagini in produzione

Comandi Docker Compose

Comando	Descrizione	Esempio
`docker compose up`	Avvia lo stack	`docker compose up -d`
`docker compose down`	Stoppa e rimuove lo stack	`docker compose down`
`docker compose ps`	Mostra servizi attivi	`docker compose ps`
`docker compose logs`	Mostra log dei servizi	`docker compose logs -f`
`docker compose exec`	Esegue comandi nel container	`docker compose exec web bash`

Stack LEMP (Linux, Nginx, MySQL, PHP)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


services:
  php:
    image: 'php:8.1-fpm'
    container_name: app-php
    volumes:
      - './app:/var/www/html'
    networks:
      - app-network

  nginx:
    image: 'nginx:latest'
    container_name: app-nginx
    ports:
      - '8080:80'
      - '8443:443'
    volumes:
      - './app:/var/www/html:ro'  # :ro = read-only
      - './config/nginx:/etc/nginx/conf.d'
    depends_on:
      - php
    networks:
      - app-network

  mysql:
    image: 'mysql:8.0'
    container_name: app-mysql
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: myapp
      MYSQL_USER: appuser
      MYSQL_PASSWORD: apppass
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - app-network

volumes:
  mysql-data:

networks:
  app-network:
    driver: bridge

Restart Policy

Le restart policy definiscono il comportamento dei container in caso di crash o riavvio del sistema:

1
2
3
4
5
6
7


services:
  web:
    image: nginx
    restart: "no"          # Mai riavviare (default)
    # restart: always       # Sempre riavviare
    # restart: on-failure   # Riavvia solo in caso di errore
    # restart: unless-stopped  # Riavvia sempre tranne se stoppato manualmente

5. Gestione delle Variabili d’Ambiente

File .env

Creare un file .env nella stessa directory del docker-compose.yml:

1
2
3
4
5


# .env file
APP_NAME=myapp
MYSQL_ROOT_PASSWORD=supersecret
MYSQL_DATABASE=myapp_db
NGINX_PORT=8080

Utilizzo nel docker-compose.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


services:
  php:
    image: 'php:8.1-fpm'
    container_name: '${APP_NAME:?err}-php'
    volumes:
      - './app:/var/www/html'

  nginx:
    image: 'nginx:latest'
    container_name: '${APP_NAME:?err}-nginx'
    ports:
      - '${NGINX_PORT:-8080}:80'
    volumes:
      - './app:/var/www/html'
      - './config/nginx:/etc/nginx/conf.d'

  mysql:
    image: 'mysql:8.0'
    container_name: '${APP_NAME:?err}-mysql'
    restart: 'on-failure'
    environment:
      MYSQL_ROOT_PASSWORD: '${MYSQL_ROOT_PASSWORD:?err}'
      MYSQL_DATABASE: '${MYSQL_DATABASE}'
    volumes:
      - mysql-data:/var/lib/mysql

volumes:
  mysql-data:

Sicurezza

Il file .env deve essere nella stessa directory del docker-compose.yml
Aggiungere sempre .env al .gitignore per non committare credenziali
Usare la sintassi ${VAR:?err} per variabili obbligatorie

6. Networking e Sicurezza

Reti Docker

Docker crea automaticamente una rete per ogni Compose stack, ma è possibile personalizzarle:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true  # Rete isolata, senza accesso esterno

services:
  web:
    image: nginx
    networks:
      - frontend

  api:
    image: myapi
    networks:
      - frontend
      - backend

  db:
    image: mysql
    networks:
      - backend  # Solo accessibile dall'API

Health Checks

Implementare controlli di salute per i servizi:

1
2
3
4
5
6
7
8
9


services:
  web:
    image: nginx
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

7. Best Practices per la Produzione

Ottimizzazione delle Immagini

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# Usa immagini Alpine per dimensioni ridotte
FROM node:18-alpine

# Utente non-root per sicurezza
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
USER nextjs

# Multi-stage build per ridurre dimensioni
FROM node:18-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine AS runner
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules

Logging e Monitoring

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


services:
  app:
    image: myapp
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'

Backup e Disaster Recovery

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# Backup di un volume
docker run --rm \
  -v myapp_mysql-data:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/mysql-backup.tar.gz -C /data .

# Restore di un volume
docker run --rm \
  -v myapp_mysql-data:/data \
  -v $(pwd):/backup \
  alpine tar xzf /backup/mysql-backup.tar.gz -C /data

8. Troubleshooting Comune

Problemi Frequenti

Problema	Causa	Soluzione
Container non si avvia	Porta già occupata	Cambiare porta o stoppare il processo
Volumi non persistenti	Uso di bind mount errato	Verificare path assoluti
Rete non raggiungibile	Servizi su reti diverse	Verificare configurazione network
Performance scarse	Limiti di risorse	Aumentare CPU/RAM limits

Comandi di Debug

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# Ispezionare un container
docker inspect <container>

# Entrare in un container in esecuzione
docker exec -it <container> bash

# Monitorare risorse in tempo reale
docker stats

# Visualizzare tutti i processi Docker
docker system df
docker system prune  # Pulizia generale

Conclusioni

Docker e Docker Compose sono strumenti essenziali per lo sviluppo moderno. Questa reference copre i comandi più utilizzati quotidianamente, ma Docker offre molte altre funzionalità avanzate per scenari specifici.

Risorse utili per approfondire:

Prossimi passi

Per scenari di produzione complessi, considera l’uso di orchestratori come Kubernetes o Docker Swarm per gestire cluster di container su più nodi.