Quando si utilizza Docker, iniziamo con un'immagine di base. Lo avviamo, creiamo modifiche e tali modifiche vengono salvate in livelli formando un'altra immagine.

Quindi alla fine ho un'immagine per la mia istanza PostgreSQL e un'immagine per la mia applicazione web, le cui modifiche continuano a persistere.

Che cos'è un contenitore?

Un'istanza di un'immagine è chiamata contenitore. Hai un'immagine, che è un insieme di livelli come descrivi. Se si avvia questa immagine, si dispone di un contenitore in esecuzione di questa immagine. Puoi avere molti contenitori in esecuzione della stessa immagine.

Puoi vedere tutte le tue immagini con docker imagesmentre puoi vedere i tuoi contenitori in esecuzione con docker ps(e puoi vedere tutti i contenitori con docker ps -a).

Quindi un'istanza in esecuzione di un'immagine è un contenitore.

Dal mio articolo sull'automazione delle distribuzioni Docker :

Immagini Docker vs. Contenitori

In Dockerland ci sono immagini e ci sono contenitori . I due sono strettamente correlati, ma distinti. Per me cogliere questa dicotomia ha chiarito immensamente Docker.

Cos'è un'immagine?

Un'immagine è un file inerte, immutabile, che è essenzialmente un'istantanea di un contenitore. Le immagini vengono create con il comando build e produrranno un contenitore all'avvio con run . Le immagini sono memorizzate in un registro Docker come register.hub.docker.com . Poiché possono diventare piuttosto grandi, le immagini sono progettate per essere composte da livelli di altre immagini, consentendo una quantità minima di dati da inviare durante il trasferimento di immagini sulla rete.

Le immagini locali possono essere elencate eseguendo docker images:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu                    13.10               5e019ab7bf6d        2 months ago        180 MB
ubuntu                    14.04               99ec81b80c55        2 months ago        266 MB
ubuntu                    latest              99ec81b80c55        2 months ago        266 MB
ubuntu                    trusty              99ec81b80c55        2 months ago        266 MB
<none>                    <none>              4ab0d9120985        3 months ago        486.5 MB

Alcune cose da notare:

1. ID IMMAGINE sono i primi 12 caratteri dell'identificatore vero per un'immagine. Puoi creare molti tag di una determinata immagine, ma i loro ID saranno tutti uguali (come sopra).
2. VIRTUAL SIZE è virtuale perché sta sommando le dimensioni di tutti i livelli sottostanti distinti. Ciò significa che la somma di tutti i valori in quella colonna è probabilmente molto più grande dello spazio su disco utilizzato da tutte quelle immagini.
3. Il valore nella colonna REPOSITORY deriva dalla -tbandiera del docker buildcomando o dal docker tag-ing di un'immagine esistente. Sei libero di taggare le immagini usando una nomenclatura che ha senso per te, ma sappi che la finestra mobile utilizzerà il tag come posizione del registro in un docker pusho docker pull.
4. La forma completa di un tag è [REGISTRYHOST/][USERNAME/]NAME[:TAG]. Per quanto ubuntusopra, si presuppone che REGISTRYHOST sia registry.hub.docker.com. Quindi, se hai intenzione di archiviare la tua immagine chiamata my-applicationin un registro su docker.example.com, dovresti taggare quell'immagine docker.example.com/my-application.
5. La colonna TAG è solo la parte [: TAG] del tag completo . Questa è una terminologia sfortunata.
6. Il latesttag non è magico, è semplicemente il tag predefinito quando non si specifica un tag.
7. Puoi avere immagini senza tag identificabili solo con i loro ID IMMAGINE. Questi otterranno il <none>TAG e il REPOSITORY. È facile dimenticarsene.

Ulteriori informazioni sulle immagini sono disponibili nella documentazione e nel glossario Docker .

Che cos'è un contenitore?

Per usare una metafora di programmazione, se un'immagine è una classe, un contenitore è un'istanza di una classe, un oggetto runtime. Si spera che i contenitori stiano usando Docker; sono incapsulamenti leggeri e portatili di un ambiente in cui eseguire applicazioni.

Visualizza i contenitori correnti locali con docker ps:

CONTAINER ID        IMAGE                               COMMAND                CREATED             STATUS              PORTS                    NAMES
f2ff1af05450        samalba/docker-registry:latest      /bin/sh -c 'exec doc   4 months ago        Up 12 weeks         0.0.0.0:5000->5000/tcp   docker-registry

Qui sto eseguendo una versione dockerizzata del registro docker, in modo da avere un posto privato dove archiviare le mie immagini. Ancora una volta, alcune cose da notare:

1. Come l'ID IMMAGINE, l'ID CONTAINER è l'identificatore vero per il contenitore. Ha la stessa forma, ma identifica un diverso tipo di oggetto.
2. docker psproduce solo contenitori in esecuzione . È possibile visualizzare tutti i contenitori (in esecuzione o arrestati ) con docker ps -a.
3. NAMES può essere utilizzato per identificare un container avviato tramite il --nameflag.

Come evitare l'accumulo di immagini e contenitori

Una delle mie prime frustrazioni con Docker fu l' accumulo apparentemente costante di immagini senza tag e fermò i container . In una manciata di occasioni questo accumulo ha comportato l'azionamento al massimo di dischi rigidi che rallentavano il mio laptop o arrestavano la mia pipeline di build automatizzata. Parla di "contenitori ovunque"!

Possiamo rimuovere tutte le immagini senza tag combinandole docker rmicon la dangling=truequery recente :

docker images -q --filter "dangling=true" | xargs docker rmi

Docker non sarà in grado di rimuovere le immagini che si trovano dietro i contenitori esistenti, quindi potrebbe essere necessario rimuovere i contenitori arrestati con docker rmprima:

docker rm `docker ps --no-trunc -aq`

Questi sono punti critici noti con Docker e potrebbero essere risolti in versioni future. Tuttavia, con una chiara comprensione di immagini e contenitori, queste situazioni possono essere evitate con un paio di pratiche:

1. Rimuovere sempre un contenitore inutile e fermo con docker rm [CONTAINER_ID].
2. Rimuovere sempre l'immagine dietro un contenitore inutile e fermo con docker rmi [IMAGE_ID].

In parole semplici.

Immagini -

Il file system e l'applicazione di configurazione (sola lettura) utilizzata per creare contenitori. Maggiori dettagli .

Contenitori -

Queste sono istanze in esecuzione di immagini Docker. I contenitori eseguono le applicazioni effettive. Un contenitore include un'applicazione e tutte le sue dipendenze. Condivide il kernel con altri contenitori e viene eseguito come processo isolato nello spazio utente sul sistema operativo host. Maggiori dettagli .

Altri termini importanti da notare:

Demone Docker -

Il servizio in background in esecuzione sull'host che gestisce l'edificio, l'esecuzione e la distribuzione dei contenitori Docker.

Client Docker -

Lo strumento da riga di comando che consente all'utente di interagire con il demone Docker.

Negozio Docker -

Store è, tra le altre cose, un registro di immagini Docker. Puoi pensare al registro come a una directory di tutte le immagini Docker disponibili.

Una foto di questo post sul blog vale più di mille parole.

(Per una comprensione più approfondita, leggi questo .)

Sommario:

• Estrarre l' immagine dall'hub Docker o creare da un file Docker => Fornisce un'immagine Docker (non modificabile).
• Esegui l'immagine ( docker run image_name:tag_name) => Fornisce un'immagine in esecuzione, ad esempio un contenitore (modificabile)

Mentre è più semplice pensare a un contenitore come un'immagine in esecuzione, questo non è abbastanza preciso.

Un'immagine è in realtà un modello che può essere trasformato in un contenitore. Per trasformare un'immagine in un contenitore, il motore Docker prende l'immagine, aggiunge in cima un file system di lettura e scrittura e inizializza varie impostazioni tra cui porte di rete, nome del contenitore, ID e limiti delle risorse. Un container in esecuzione ha un processo attualmente in esecuzione, ma un container può anche essere arrestato (o chiuso nella terminologia di Docker). Un contenitore uscito non è uguale a un'immagine, in quanto può essere riavviato e manterrà le sue impostazioni e eventuali modifiche al file system.

Forse spiegare l'intero flusso di lavoro può aiutare.

Tutto inizia con il Dockerfile . Dockerfile è il codice sorgente dell'immagine.

Una volta creato il Dockerfile, lo si crea per creare l' immagine del contenitore. L'immagine è solo la "versione compilata" del "codice sorgente" che è il Dockerfile.

Una volta che hai l'immagine del contenitore, dovresti ridistribuirla usando il registro . Il registro è come un repository Git: puoi spingere e tirare le immagini.

Successivamente, è possibile utilizzare l'immagine per eseguire i contenitori . Un container in esecuzione è molto simile, in molti aspetti, a una macchina virtuale (ma senza l' hypervisor ).

Flusso di lavoro

Ecco il flusso di lavoro end-to-end che mostra i vari comandi e i loro input e output associati. Ciò dovrebbe chiarire la relazione tra un'immagine e un contenitore.

+------------+  docker build   +--------------+  docker run -dt   +-----------+  docker exec -it   +------+
| Dockerfile | --------------> |    Image     | --------------->  | Container | -----------------> | Bash |
+------------+                 +--------------+                   +-----------+                    +------+
                                 ^
                                 | docker pull
                                 |
                               +--------------+
                               |   Registry   |
                               +--------------+

Per elencare le immagini che potresti eseguire, esegui:

docker image ls

Per elencare i contenitori su cui è possibile eseguire i comandi:

docker ps

Non riuscivo a capire il concetto di immagine e livello nonostante la lettura di tutte le domande qui e alla fine mi sono imbattuto in questa eccellente documentazione di Docker (duh!).

L'esempio è davvero la chiave per comprendere l'intero concetto. È un post lungo, quindi sto riassumendo i punti chiave che devono essere veramente colti per ottenere chiarezza.

• Immagine : un'immagine Docker viene creata da una serie di livelli di sola lettura

• Livello : ogni livello rappresenta un'istruzione nel file Docker dell'immagine.

Example: Il file Docker sottostante contiene quattro comandi, ognuno dei quali crea un livello.

DA ubuntu: 15.04

COPIA . / app

Esegui marca / app

CMD python /app/app.py

È importante sottolineare che ogni livello è solo un insieme di differenze rispetto al livello precedente.

• Contenitore . Quando crei un nuovo contenitore, aggiungi un nuovo livello scrivibile sopra i livelli sottostanti . Questo livello è spesso chiamato "livello contenitore". Tutte le modifiche apportate al contenitore in esecuzione, come la scrittura di nuovi file, la modifica di file esistenti e l'eliminazione di file, vengono scritte in questo livello contenitore scrivibile sottile .

Quindi, la principale differenza tra un contenitore e un'immagine è il livello scrivibile in alto . Tutte le scritture nel contenitore che aggiungono nuovi o modificano dati esistenti sono archiviate in questo livello scrivibile. Quando il contenitore viene eliminato, viene eliminato anche il livello scrivibile. L'immagine sottostante rimane invariata.

Comprensione delle immagini dei contenitori cnd dal punto di vista della dimensione su disco

Per visualizzare la dimensione approssimativa di un contenitore in esecuzione, è possibile utilizzare il docker ps -scomando Ottieni sizee virtual sizecome due delle uscite:

• Dimensione: la quantità di dati (su disco) utilizzata per il livello scrivibile di ciascun contenitore

• Dimensione virtuale: la quantità di dati utilizzati per i dati immagine di sola lettura utilizzati dal contenitore. Più contenitori possono condividere alcuni o tutti i dati immagine di sola lettura. Quindi questi non sono additivi. Vale a dire che non è possibile aggiungere tutte le dimensioni virtuali per calcolare la dimensione su disco utilizzata dall'immagine

Un altro concetto importante è la strategia di copia su scrittura

Se un file o una directory esiste in un livello inferiore all'interno dell'immagine e un altro livello (incluso il livello scrivibile) necessita dell'accesso in lettura ad esso, utilizza solo il file esistente. La prima volta che un altro livello deve modificare il file (durante la creazione dell'immagine o l'esecuzione del contenitore), il file viene copiato in quel livello e modificato.

Spero che aiuti qualcun altro come me.

File Docker → (Genera) → Immagine → (Esegui) → Contenitore .

• File Docker : contiene una serie di istruzioni Docker che forniscono il sistema operativo nel modo desiderato e installa / configura tutto il software.

• Immagine : Dockerfile compilato. Risparmia tempo dalla ricostruzione del Dockerfile ogni volta che devi eseguire un container. Ed è un modo per nascondere il codice di fornitura.

• Contenitore : il sistema operativo virtuale stesso. Puoi usarlo ed eseguire tutti i comandi che desideri, come se fosse un ambiente reale. Puoi eseguire oltre 1000 contenitori dalla stessa immagine.

Detto semplicemente, se un'immagine è una classe , un contenitore è un'istanza di una classe è un oggetto runtime .

Un contenitore è solo un file binario eseguibile che deve essere eseguito dal sistema operativo host in base a una serie di restrizioni preimpostate utilizzando un'applicazione (ad esempio Docker) che sa dire al sistema operativo quali restrizioni applicare.

Le restrizioni tipiche sono legate all'isolamento del processo, alla sicurezza (come l'utilizzo della protezione SELinux ) e alle risorse del sistema (memoria, disco, CPU e rete).

Fino a poco tempo fa, solo i kernel nei sistemi basati su Unix supportavano la capacità di eseguire eseguibili con restrizioni rigorose. Ecco perché la maggior parte dei talk container oggi coinvolge principalmente Linux o altre distribuzioni Unix.

Docker è una di quelle applicazioni che sa dire al sistema operativo (principalmente Linux) quali restrizioni eseguire un eseguibile. L'eseguibile è contenuto nell'immagine Docker, che è solo un file tar. Tale eseguibile è di solito una versione ridotta di una distribuzione Linux (Ubuntu, CentOS, Debian, ecc.) Preconfigurata per eseguire una o più applicazioni all'interno.

Sebbene la maggior parte delle persone utilizzi una base Linux come eseguibile, può essere qualsiasi altra applicazione binaria fintanto che il sistema operativo host può eseguirla (vedere la creazione di una semplice immagine di base tramite scratch ). Che il file binario nell'immagine Docker sia un sistema operativo o semplicemente un'applicazione, per l'host del sistema operativo è solo un altro processo, un processo contenuto regolato da limiti predefiniti del sistema operativo.

Altre applicazioni che, come Docker, possono indicare al sistema operativo host quali limiti applicare a un processo mentre è in esecuzione, includono LXC , libvirt e systemd . Docker utilizzava queste applicazioni per interagire indirettamente con il sistema operativo Linux, ma ora Docker interagisce direttamente con Linux usando la propria libreria chiamata " libcontainer ".

Quindi i container sono solo processi in esecuzione in modalità limitata, simile a quello che faceva chroot .

IMO, ciò che distingue Docker da qualsiasi altra tecnologia container è il suo repository (Docker Hub) e i suoi strumenti di gestione che rendono estremamente facile lavorare con i container.

Vedi Docker (software) .

Il concetto chiave di Docker è quello di semplificare la creazione di "macchine" che in questo caso possono essere considerate contenitori. Il contenitore aiuta nella riutilizzabilità, consentendo di creare e rilasciare contenitori con facilità.

Le immagini raffigurano lo stato di un contenitore in ogni momento. Quindi il flusso di lavoro di base è:

1. creare un'immagine
2. avviare un contenitore
3. apportare modifiche al contenitore
4. salvare il contenitore come immagine

Come hanno indicato molte risposte: si crea Dockerfile per ottenere un'immagine e si esegue l' immagine per ottenere un contenitore .

Tuttavia, i seguenti passaggi mi hanno aiutato a capire meglio cosa sono l'immagine e il contenitore Docker:

1) Crea Dockerfile:

docker build -t my_image dir_with_dockerfile

2) Salva l'immagine su .tarfile

docker save -o my_file.tar my_image_id

my_file.tarmemorizzerà l'immagine. Aprilo contar -xvf my_file.tar e vedrai tutti i livelli. Se ti immergi più a fondo in ogni livello, puoi vedere quali modifiche sono state aggiunte in ogni livello. (Dovrebbero essere abbastanza vicini ai comandi nel Dockerfile).

3) Per dare un'occhiata all'interno di un contenitore, puoi fare:

sudo docker run -it my_image bash

e puoi vedere che è molto simile a un sistema operativo.

L'immagine è equivalente a una definizione di classe in OOP e i livelli sono metodi e proprietà diversi di quella classe.

Il contenitore è l'istanza effettiva dell'immagine proprio come il modo in cui un oggetto è un'istanza o un'istanza di una classe.

Penso che sia meglio spiegare all'inizio.

Supponiamo di eseguire il comando docker run hello-world. Che succede?

Chiama la CLI Docker, che è responsabile di prendere i comandi Docker e trasformarsi in comandi del server Docker . Non appena il server Docker riceve un comando per eseguire un'immagine , controlla se la cache delle immagini contiene un'immagine con un nome simile.

Supponiamo che il ciao-mondo non esista. Il server Docker va su Docker Hub (Docker Hub è solo un repository gratuito di immagini) e chiede, hey Hub, hai un'immagine chiamata hello-world? Hub risposte - sì, lo faccio. Allora dammelo, per favore. E inizia il processo di download. Non appena l' immagine Docker viene scaricata, il server Docker la inserisce nella cache dell'immagine .

Quindi, prima di spiegare quali sono le immagini Docker e i contenitori Docker, iniziamo con un'introduzione sul sistema operativo sul tuo computer e su come esegue il software.

Quando esegui, ad esempio, Chrome sul tuo computer, chiama il sistema operativo, il sistema operativo stesso chiama il kernel e chiede, ehi, voglio eseguire questo programma. Il kernel riesce a eseguire i file dal tuo disco rigido.

Ora immagina di avere due programmi, Chrome e Node.js. Chrome richiede l'esecuzione di Python versione 2 e Node.js richiede l'esecuzione di Python versione 3. Se hai installato solo Python v2 sul tuo computer, verrà eseguito solo Chrome.

Per far funzionare entrambi i casi, in qualche modo è necessario utilizzare una funzionalità del sistema operativo nota come namespace. Uno spazio dei nomi è una funzionalità che ti dà l'opportunità di isolare processi, disco rigido, rete, utenti, nomi host e così via.

Quindi, quando parliamo di un'immagine , in realtà parliamo di un'istantanea del file system. L' immagine è un file fisico che contiene le indicazioni e metadati per costruire una specifica contenitore . Il contenitore stesso è un'istanza di un'immagine ; isola il disco rigido usando lo spazio dei nomi che è disponibile solo per questo contenitore . Quindi un contenitore è un processo o un insieme di processi che raggruppa diverse risorse assegnate ad esso.

Un'immagine Docker racchiude l'applicazione e l'ambiente richiesti dall'applicazione per essere eseguiti e un contenitore è un'istanza in esecuzione dell'immagine.

Le immagini sono la parte impaccante di Docker, analoga al "codice sorgente" o ad un "programma". I contenitori sono la parte di esecuzione di Docker, analoga a un "processo".

Nella domanda, si fa riferimento solo alla parte "programma" e questa è l'immagine. La parte "in esecuzione" di Docker è il contenitore. Quando viene eseguito un contenitore e vengono apportate modifiche, è come se il processo apportasse una modifica al proprio codice sorgente e lo salvasse come nuova immagine.

Come nell'aspetto della programmazione,

L'immagine è il codice sorgente.

Quando il codice sorgente viene compilato e compilato, viene chiamato un'applicazione.

Simile a quello "quando viene creata un'istanza per l'immagine", viene chiamato " contenitore ".

L' immagine è una "istantanea" di un container . Puoi creare immagini da un contenitore (nuove "istantanee") e puoi anche avviare nuovi contenitori da un'immagine (creare un'istanza "istantanea").

Ad esempio, è possibile creare un'istanza di un nuovo contenitore da un'immagine di base, eseguire alcuni comandi nel contenitore e quindi snapshot come nuova immagine. Quindi è possibile eseguire 100 contenitori da quella nuova immagine.

Altre cose da considerare:

• Un'immagine è composta da livelli e i livelli sono "diff" di istantanee (quindi quando si preme un'immagine, è sufficiente inviare "diff" al registro).
• Un Dockerfile definisce alcuni comandi sopra un'immagine di base, che crea nuovi livelli ("diff") che danno come risultato una nuova immagine ("istantanea").
• I tag immagine non sono solo tag. Sono il "nome completo" dell'immagine ("repository: tag"). Se la stessa immagine ha più nomi, viene mostrata più volte durante l'operazione docker images.

Vorrei riempire qui la parte mancante tra docker imagese containers. Docker utilizza un file system unione ( UFS ) per i contenitori, che consente di montare più file system in una gerarchia e di apparire come un singolo file system. Il filesystem dall'immagine è stato montato come read-onlylayer e tutte le modifiche al container in esecuzione vengono fatte su un read-writelayer montato sopra di esso. Per questo motivo, Docker deve solo guardare il livello di lettura / scrittura più in alto per trovare le modifiche apportate al sistema in esecuzione.

Per una falsa analogia di programmazione, puoi pensare che Docker abbia una ImageFactory astratta che contiene le ImageFactories che provengono dal negozio .

Quindi, una volta che si desidera creare un'app da quella ImageFactory, si avrà un nuovo contenitore e sarà possibile modificarlo come si desidera. DotNetImageFactory sarà immutabile, poiché agisce come una classe di fabbrica astratta, dove fornisce solo le istanze desiderate.

IContainer newDotNetApp = ImageFactory.DotNetImageFactory.CreateNew(appOptions);
newDotNetApp.ChangeDescription("I am making changes on this instance");
newDotNetApp.Run();

In breve:

Il contenitore è una divisione (virtuale) in un kernel che condivide un sistema operativo comune ed esegue un'immagine (immagine Docker).

Un contenitore è un'applicazione autosostenibile che avrà pacchetti e tutte le dipendenze necessarie per eseguire il codice.

Un contenitore Docker esegue un'istanza di un'immagine. Puoi mettere in relazione un'immagine con un programma e un contenitore con un processo :)

Un'immagine appartiene a una classe come contenitore per un oggetto.

Un contenitore è un'istanza di un'immagine come un oggetto è un'istanza di una classe.

Dockerfile è come il tuo script Bash che produce un tarball (immagine Docker).

I contenitori Docker sono come la versione estratta del tarball. Puoi avere tutte le copie che vuoi in diverse cartelle (i contenitori).