mywiki/container/docker.md

Virtualizzazione

Container

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 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.

Installazione

Debian

Direttamente dai repository ufficiali:

sudo apt install docker.io docker-compose

Altrimenti, bisogna seguire questa guida: Install Docker on Debian 12

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.

Dockerfile e Docker compose

Maggiori informazioni ai link sottostanti:

Docker compose

Per dockerfile:

https://dockertutorial.it/dockerfile-from-run-arg-e-cmd/

https://dockertutorial.it/dockerfile-tutti-i-comandi/

Comandi principali

Creare un container (senza avviarlo)

docker create <IMMAGINE>
root@vbox:~# docker create hello-world

Rinominare un container esistente

docker rename <NOME CONTAINER> <NUOVO NOME>
root@vbox:~# docker rename c1 c2

Eseguire un container

docker run <IMMAGINE> <COMANDO>
root@vbox:~# docker run myapp

docker run --rm <IMMAGINE>
root@vbox:~# docker run -rm myapp     # rimuove il container quando questo termina l'esecuzione
root@vbox:~# docker run -td myapp     # avvia un container e lo mantiene in esecuzione.
root@vbox:~# docker run -it myapp     # avvia il container in maniera interattiva
root@vbox:~# docker run -it -rm myapp

Eliminare un container

docker rm <CONTAINER>
root@vbox:~# docker rm c1
## Questo comando può essere eseguito solo se il container non è in esecuzione, altrimenti verrà restituito un errore.

Aggiornare la configurazione di uno o più container

docker update <CONTAINER>
root@vbox:~# docker update c1

Avvio e arresto dei container

#Avviare un container
docker start <CONTAINER>
#Interrompere un container in esecuzione
docker stop <CONTAINER>
#Riavviare un container
docker restart <CONTAINER>

Uccidere un container

docker kill <CONTAINER>
root@vbox:~# docker kill c1

Ottenere informazioni

Elencare i container in esecuzione

docker ps
root@vbox:~# docker ps

NOTA: Con l’opzione -a viene prodotta una lista contenente sia i container in esecuzione sia quelli che sono arrestati.

Elencare i registri da un container in esecuzione

docker logs <CONTAINER>
root@vbox:~# docker logs

Ispezionare

docker inspect <OBJECT_NAME/ID>
root@vbox:~# docker inspect image1

Elencare gli eventi in tempo reale da un container

docker events <CONTAINER>
root@vbox:~# docker events image1

Mostrare mappatura porta (o specifica) per un container

docker port <CONTAINER>
root@vbox:~# docker port c1

Processi in esecuzione in un container

docker top <CONTAINER>
root@vbox:~# docker top c1

Statistiche sull’utilizzo delle risorse in tempo reale dei container

docker stats <CONTAINER>
root@vbox:~# docker stats c1

Mostrare le modifiche ai file (o directory) su un file system

docker diff <CONTAINER>
root@vbox:~# docker diff c1

Elencare tutte le immagini archiviate localmente

docker image ls
root@vbox:~# docker image ls

Mostrare la storia di un’immagine

docker history <IMMAGINE>
root@vbox:~# docker history image1

Reti

Elencare le reti presenti

docker network ls
root@vbox:~# docker network ls

Rimuovere una o più reti

docker network rm [RETE]
root@vbox:~# docker network rm custom-network

Mostrare informazioni su una o più reti

docker network inspect [RETE]
root@vbox:~# docker network inspect custom-network

Connettere un container a una rete

docker network connect [RETE] <CONTAINER>
root@vbox:~# docker network connect custom-network

Disconnettere un container da una rete

root@vbox:~# docker network disconnect [NETWORK] <CONTAINER>
root@vbox:~# docker network disconnect custom-network

Dockerfile: istruzioni

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 :. 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.

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 && cd di un sistema Unix-based).

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

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.

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.

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.

ENTRYPOINT ls     #elenca file e directory presenti nella cartella di lavoro
ENTRYPOINT ["/bin/echo", "Hello"]     #stampa "Hello"
ENTRYPOINT ["/bin/echo", "Hello"]     #stampa "Hello world"
CMD ["world"]

docker run -it <immagine> John        #stampa "Hello John"

Altre informazioni: 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.

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.

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.

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.

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.

USER john     #le istruzioni successive saranno eseguite con l'utenza john

VOLUME

Dichiara il file o la directory specificati come volume.

VOLUME /volume1     #crea un volume denominato volume1

Esempio di Dockerfile:

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

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.

$ 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.

$ docker-compose down

stop

Arresta i servizi.

$ docker-compose stop

ps

Elenca tutti i container e le relative informazioni rispetto ai servizi avviati tramite il file docker-compose.yml.

$ docker-compose ps

scale

Aggiunge o rimuove container per scalare orizzontalmente l’applicazione secondo la dimensione specificata.

$ docker-compose scale test=6     #crea 6 repliche del container "test"

rm

Arresta ed elimina i servizi.

$ docker-compose rm

Collegamenti

• https://linuxhub.it/articles/howto-Installazione-ed-utilizzo-di-Docker-su-Linux/
• https://linuxhub.it/articles/pausadev-container-vm-wsl/
• https://www.freecodecamp.org/italian/news/il-manuale-docker/#introduzione-alla-containerizzazione-e-a-docker
• https://dockertutorial.it/
• https://linuxhub.it/articles/howto-creare-un-file-yaml-per-docker/
• https://linuxhub.it/articles/howto-creare-un-Dockerfile/