Il container come concetto è molto simile alla Virtual Machine.
Se la macchina virtuale tende ad emulare il comportamento di una macchina fisica 'reale', dall’hardware fino al software, il container condivide le risorse hardware in esecuzione con il sistema ospitante e anche parte del software (come il kernel).
Invece di virtualizzare l'intera macchina fisica, i container virtualizzano solo il sistema operativo host.
Il container è un pacchetto software 'autosufficienti' che contengono tutto il necessario per far partire un sistema con al suo interno un applicazione.
La containerizzazione implica l'incapsulamento o l'impacchettamento del codice di un software e di tutte le sue dipendenze, in modo che possa essere eseguito in modo uniforme e coerente su qualsiasi infrastruttura.
### Vantaggi container
I container hanno molti vantaggi:
- Leggerezza, condividono il kernel del sistema operativo;
- Isolamento, infatti operano all’interno di uno spazio limitato del sistema operativo ospitante, e non hanno visibilità esterna;
- Portabilità: questa tecnologia si presta ad essere facilmente trasportata da una macchina ad un altra, Spesso basta un file di testo o poco più. Possiamo avere diverse versioni della stessa applicazione sulla stessa macchina senza che vadano in conflitto tra loro.
### Container vs Docker
Se è vero che Docker crea container, non è altrettanto vero che i container sono Docker.
Docker non è l'unico strumento di containerizzazione sul mercato, è soltanto il più conosciuto. Un altro motore di containerizzazione che amo si chiama Podman, sviluppato da Red Hat
## Cos’è Docker
**Docker** è un software open source, multipiattaforma che permette di virtualizzare singole applicazioni in dei**container** che sono isolati dall'**host** (il sistema operativo per intenderci):
- Docker non virtualizza l’hardware ma lo condivide col sistema operativo;
- su Docker non viene virtualizzato un intero sistema operativo, ma una specifica applicazione, contenuta in un immagine che contiene software, dipendenze e che generalmente possiamo trovare nei [repository ufficiali](https://hub.docker.com/).
## Installazione
### Debian
Direttamente dai repository ufficiali:
```
sudo apt install docker.io docker-compose
```
Altrimenti, bisogna seguire questa guida: [Install Docker on Debian 12](https://itsfoss.com/debian-install-docker/)
Dare i comandi `docker --version` e `docker-compose --version` per verificare che l'installazione sia avvenuta con successo.
## Attivazione
Una volta installato per attivare e abilitare il servizio:
```
systemctl enable --now docker
```
## Cos'è un'immagine Docker
Le immagini sono dei file autonomi a più livelli che agiscono come modello per la creazione di container. Sono come una copia congelata, di sola lettura di un container. Le immagini possono essere scambiate attraverso dei registri, come Docker Hub. I container sono semplicemente immagini in esecuzione.
> **NOTA** : Se volessimo utilizzare docker senza ogni volta richiamare il comando `sudo` possiamo aggiungere il nostro utente al gruppo docker con il comando `usermod -aG docker <nomeutente>`
### Persistenza
I container sono pensati per essere distrutti e ricreati più volte a partire dalla stessa immagine.
Questo approccio fa parte del concetto di `infrastruttura immutabile` che garantisce lo stesso container ad ogni nuovo deploy.
Per gestire la persistenza dei dati, Docker fornisce due strade:
- Volumes
- Bind Mounts
I volumi sono uno spazio creato al di fuori dello Union File System del container che può essere acceduto da più container e che viene persistito anche quando non è utilizzato da alcun container.
#### Bind Mounts
Alla stregua dei mount classici di linux, un bind mount è una condivisione di una cartella.
Con questa tipologia di persistenza, andiamo a condividere una cartella dell’host con il container.
Un bind mount è una sorta di symlink, viene fatto un collegamento logico (mount) di un file o di una cartella dell’host in un file o una cartella del container.
Un Dockerfile è un file di testo contenente alcuni comandi comprensibili a Docker da cui è possibile, da un’immagine di partenza, creare una nostra immagine personalizzata. Per essere riconosciuto da Docker, il Docker file dovrà chiamarsi proprio Dockerfile senza estensioni e senza modificare maiuscole e minuscole.
FROM
Imposta l’immagine di base per il Dockerfile; le istruzioni successive si basano su questa immagine. L’immagine di base è specificata come <immagine>:<tag>. Se il tag viene omesso, si presume che sia il più recente, ma è vivamente consigliabile impostare sempre il tag su una versione specifica, per evitare sorprese. Deve essere la prima istruzione in un Dockerfile.
```bash
FROM python:3 #l'immagine di base utilizzata sarà python nella versione 3
FROM node #l'immagine di base sarà l'ultima versione disponibile sul registro
```
WORKDIR
Imposta la directory di lavoro per le successive istruzioni RUN, CMD, ENTRYPOINT, ADD oppure COPY. Può essere usato più volte. Se la cartella specificata non esiste, verrà creata e verrà automaticamente cambiato il percorso di lavoro (questo comando può essere paragonato all’esecuzione del comando mkdir <cartella>&& cd <cartella> di un sistema Unix-based).
```bash
WORKDIR /c1 #la directory di lavoro ora è /c1
WORKDIR c2 #la directory di lavoro ora è /c1/c2
WORKDIR c3 #la directory di lavoro ora è /c1/c2/c3
WORKDIR /app #la directory di lavoro ora è /app
```
ADD
Copia i file dal percorso nel file system ospite o da un dato URL all’interno dell’immagine. Poiché la gamma di funzionalità coperta da ADD è piuttosto ampia, in genere è preferibile usare il comando COPY, di norma più semplice per copiare file e directory nel contesto di build
```bash
ADD file.txt /home/ #copia file.txt nella cartella /home/ del container
ADD file1 file2 /home/ #copia i file specificati nella cartella /home/
```
RUN
Esegue i comandi in un nuovo layer e crea una nuova immagine, spesso definita intermedia. Questo comando viene spesso utilizzato per l’installazione di pacchetti tramite i vari package manager.
```bash
RUN apt update #ricerca degli aggiornamenti del sistema operativo
RUN apt install -y nginx #installa il pacchetto nginx
RUN [ "npm", "start" ] #esegue il comando "npm start"
```
CMD
L’istruzione CMD consente di impostare un comando predefinito, che verrà eseguito solo quando si esegue il container senza specificare un comando. Se il container Docker viene eseguito con un comando, il comando predefinito verrà ignorato.
Se Dockerfile ha più di un’istruzione CMD, tutte le istruzioni CMD tranne l’ultima vengono ignorate.
```bash
CMD echo "Hello world" #stampa "Hello World"
CMD ["echo", "Hello world"] #stampa "Hello World"
```
ENTRYPOINT
È simile all’istruzione CMD, perché consente anche di specificare un comando con dei parametri, ma a differenza è che i parametri non verranno ignorati quando il container Docker viene eseguito con i parametri passati tramite riga di comando.
```bash
ENTRYPOINT ls #elenca file e directory presenti nella cartella di lavoro
docker run -it <immagine> John #stampa "Hello John"
```
Altre informazioni: [https://www.theredcode.it/docker/differenze-tra-run-cmd-e-entrypoint/](https://www.theredcode.it/docker/differenze-tra-run-cmd-e-entrypoint/)
COPY
Utilizzato per copiare file dal file system del sistema host nell’immagine. I caratteri jolly possono essere utilizzati e permettono di specificare più file o directory. Non è possibile specificare percorsi di origine al di fuori del contesto di compilazione.
```bash
COPY file.txt /home/ #copia file.txt nella cartella /home del container
COPY file1 file2 /home/ #copia i file specificati nella cartella /home
COPY file1.py dest.py #copia il contenuto di file1.py nel file dest.py
```
ENV
Imposta le variabili d’ambiente all’interno dell’immagine; queste possono essere indicate in qualsiasi momento all’interno del Dockerfile, ovviamente prima dell’uso effettivo. Le variabili saranno disponibili anche all’interno dell’immagine.
```bash
ENV VERSIONE 1.3
RUN apt install -y pacchetto=$VERSIONE #installa il pacchetto nella versione 1.3
```
EXPOSE
Indica a Docker che il container avrà un processo in ascolto su una o più porte specificate. Queste informazioni vengono utilizzate da Docker durante il collegamento di container o la pubblicazione di porte.
```bash
EXPOSE 8080 #il container sarà in ascolto sulla porta 8080
```
LABEL
Aggiunge metadati a un’immagine; utilizza il formato coppia chiave-valore. Normalmente viene utilizzato per impostare il nome e i dettagli di contatto del manutentore dell’immagine.
```bash
LABEL "nome"="pippo" #assegna alla chiave "nome" il valore "pippo"
LABEL versione="1.0" #assegna alla chiave "versione" il valore "1.0"
LABEL descrizione="Lorem ipsum \
dolor sit amet, consectetur adipiscing elit." #label multiriga
```
USER
Imposta l’utente (tramite nome o tramite UID) da utilizzare nelle successive istruzioni RUN, CMD o ENTRYPOINT. Nota che gli UID sono gli stessi tra l’host e il container, ma i nomi utente possono essere assegnati a UID diversi, il che può rendere le cose difficili quando si impostano le autorizzazioni.
```bash
USER john #le istruzioni successive saranno eseguite con l'utenza john
```
VOLUME
Dichiara il file o la directory specificati come volume.
```bash
VOLUME /volume1 #crea un volume denominato volume1
```
Esempio di Dockerfile:
```bash
FROM node:lts-alpine
EXPOSE 3000
USER node
RUN mkdir -p /home/node/app
WORKDIR /home/node/app
COPY ./package.json .
RUN npm install
COPY . .
CMD [ "npm", "run", "dev" ]
# La seconda istruzione COPY copia il resto del contenuto della cartella corrente (.)
# del file system host nella cartella di lavoro (.) all'interno dell'immagine.
```
## Docker Compose: istruzioni
Docker permette di creare un ed eseguire applicazioni multicontainer attraverso un file YAML, un tipo di file human-readable utilizzato solitamente come file di configurazione. Per fare ciò dobbiamo creare un file denominato docker-compose.yml nel quale andremo ad inserire tutte le nostre configurazioni di ogni singolo servizio che andremo ad aggiungere all’interno del file. Una volta configurato il file, andrà “composto” attraverso un comando docker-compose up, e se tutto è andato per il verso giusto avremo funzionanti i container dei servizi che abbiamo inserito e configurato nel nostro file .yml.
Esempio di un file docker-compose.yml
```bash
version: '2'
services:
# nome del servizio
web:
build: .
# build a partire da un Dockerfile
context: ./path/to/Dockerfile
# nome del file
dockerfile: Dockerfile
# traffico instradato dalla porta 5000 del container sulla 5000 dell'host
ports:
- "5000:5000"
volumes:
- .:/mydata
# nome del servizio
redis:
# immagine che viene scaricata dal registro ufficiale
image: redis
version: "3.8"
services:
db:
image: postgres:12
container_name: notes-db-dev
volumes:
- notes-db-dev-data:/var/lib/postgresql/data
environment:
POSTGRES_DB: notesdb
POSTGRES_PASSWORD: secret
api:
build:
context: ./api
dockerfile: Dockerfile.dev
image: notes-api:dev
container_name: notes-api-dev
environment:
DB_HOST: db ## same as the database service name
DB_DATABASE: notesdb
DB_PASSWORD: secret
volumes:
- /home/node/app/node_modules
- ./api:/home/node/app
ports:
- 3000:3000
volumes:
notes-db-dev-data:
name: notes-db-dev-data
```
**up**
Esegue la build del progetto e avvia i servizi specificati nel file docker-compose.yml.
```bash
$ docker-compose up
```
**down**
Arresta i servizi e rimuove i container, le reti, i volumi e le immagini create tramite comando docker-compose up. Per impostazione predefinita, vengono rimossi i soli container che sono stati creati tramite file docker-compose.yml.
```bash
$ docker-compose down
```
**stop**
Arresta i servizi.
```bash
$ docker-compose stop
```
**ps**
Elenca tutti i container e le relative informazioni rispetto ai servizi avviati tramite il file docker-compose.yml.
```bash
$ docker-compose ps
```
**scale**
Aggiunge o rimuove container per scalare orizzontalmente l’applicazione secondo la dimensione specificata.
```bash
$ docker-compose scale test=6 #crea 6 repliche del container "test"
piccihud