Creazione di un'immagine Docker da zero

Creating Docker Image From Scratch



Il vantaggio principale di Docker rispetto a qualsiasi altra tecnologia di containerizzazione è che Docker è rivolto agli sviluppatori e alle loro applicazioni upstack. Mentre le corrette tecnologie di containerizzazione come LXC , zone e carceri sono mirati da una prospettiva operativa o, per dirla semplicemente, queste piattaforme sono un sostituto per le macchine virtuali in esecuzione sul cloud. Dove, Docker è un sostituto per pacchetti e binari eseguibili.

In parole povere, Docker sta diventando sempre più simile a un gestore di pacchetti universale che funziona su tutte le possibili piattaforme Linux. Prende i contenitori e li usa per risolvere un problema completamente diverso che gli sviluppatori devono affrontare. Il problema è che gli sviluppatori usano il loro sistema operativo desktop (come Windows, macOS o Linux con una tonnellata di pacchetti relativi al desktop) per scrivere applicazioni. L'applicazione che scrivono spesso viene eseguita su un sistema operativo completamente diverso su un server da qualche parte con una distribuzione Linux completamente diversa da quella del laptop dello sviluppatore.







Con Docker l'idea è che la tua applicazione venga impacchettata come un'immagine Docker. È compito di Docker prendere questa immagine ed eseguirla come un'applicazione containerizzata per te. Essere containerizzati significa che l'applicazione e le sue dipendenze verranno eseguite in un ambiente isolato che può differire completamente dal laptop dello sviluppatore e persino dal server di produzione. Finché entrambi supportano Docker, entrambi possono eseguire la stessa applicazione nello stesso identico modo.



Anatomia di un'immagine Docker

Come accennato in precedenza, un'app Docker verrà eseguita in un ambiente concordato. Ora la domanda è come creiamo quell'ambiente? La maggior parte delle immagini dell'applicazione importerebbe un'immagine di base Docker e creerebbe la propria applicazione su di essa.



Le applicazioni sono costituite da strati di software. Un'immagine contenitore wordpress viene creata utilizzando un'immagine contenitore httpd che, a sua volta, è costruita su un'immagine Ubuntu. L'immagine su cui è costruita un'immagine più recente è nota come IMMAGINE GENITORE nella terminologia Docker. In Dockerfile (arriveremo a cosa significa un Dockerfile, un po' più tardi), questa immagine genitore è menzionata nella parte superiore del file come mostrato di seguito:





DA Ubuntu: 18.04
## Resto del Dockerfile

Questo Dockerfile quando viene eseguito converte la tua applicazione in un'immagine Docker (una sorta di binario) che puoi quindi inviare a un registro da dove può essere estratto per creare nuovi contenitori altrove. Tuttavia, avranno tutti Ubuntu: 18.04 come immagine di base e funzioneranno come se si trattasse di un sistema Ubuntu in cui stanno eseguendo.

Potresti averlo notato quando provi a estrarre una nuova immagine docker.



Creazione di un'immagine Docker da zero

Questo mostra quanti livelli vengono estratti prima che venga introdotta l'applicazione effettiva (che potrebbe avere una dimensione di solo pochi Megabyte).

Per questo motivo, vorremmo creare quella che è nota come immagine di base. Che non è costruito sopra nient'altro. La parola chiave scratch viene utilizzata per indicare che questo livello non è costruito sopra nient'altro. Così:

Da zero
## Resto del file Dcoker

Per prima cosa creeremo una semplice applicazione Hello World e poi scopriremo quale sarà il resto del Dockerfile. Il sistema host è Ubuntu: 18.04 LTS e stiamo usando la versione Docker 17.12.1-ce per l'esperimento.

Creazione di un binario statico

I contenitori Docker sono una raccolta di processi in esecuzione isolati dal resto del sistema operativo. L'unica cosa con cui il processo è in contatto è il kernel. Il kernel è responsabile della pianificazione di questi processi sulla CPU, della gestione della memoria e di alcune altre attività di mantenimento della prenotazione di base.

Ma la maggior parte delle applicazioni di alto livello dipende da molte librerie di sistema (come glibc, musl, klibc, ecc ) e molte dipendenze di runtime come Python o Node.js o Java Runtime. Il binario dell'applicazione non ha tutte le librerie disponibili al suo interno, ma quando inizia l'esecuzione chiama quelle librerie dal sistema operativo host.

Poiché stiamo cercando di creare un'immagine da zero, non otterremmo queste sottigliezze. Quindi la nostra applicazione deve essere un file statico o un eseguibile autonomo.

Iniziamo creando una cartella chiamata MyDockerImage e creando al suo interno un file hello.cc.

$mkdirMyDockerImage
$cdMyDockerImage
$toccociao.cc

Apri hello.cc usando il tuo editor di testo preferito e aggiungi le seguenti righe al suo interno.

#includere
usando lo spazio dei nomi std;
intprincipale(){
costo<< 'Ciao! Questo messaggio arriva da un container ';
Restituzione 0;

}

Questo è un semplice programma C++ che stampa Hello! Questo messaggio …

Per i motivi discussi in precedenza, lo compileremo utilizzando il flag statico. Il compilatore utilizzato è g++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0.

Per compilare il programma, nella stessa directory eseguire il seguente comando:

$ g++ -o ciao-staticoCiao.DC

Questo crea un file eseguibile binario ciao nella stessa directory. Questo è il nostro file statico. Verifica se funziona come previsto citando il nome del file nel terminale.

$./Ciao

Ora siamo pronti per containerizzare questo semplice programma.

Dockerfile

Il Dockerfile consiste in una serie di regole che prendono i file dell'applicazione (come binari, file sorgente, ecc.) insieme a vari parametri di configurazione come il layout del file system, le porte esposte, ecc. e li trasforma in un file di immagine Docker. Puoi quindi condividere il file immagine con chiunque desideri eseguire quell'applicazione.

Non esamineremo tutte le opzioni disponibili per Dockerfile, ma scriveremo un Dockerfile molto minimalista. Nella stessa directory, dove risiede il tuo eseguibile Hello, crea un file vuoto chiamato Dockerfile.

$toccoDockerfile

Aprilo con il tuo editor di testo preferito e scrivici le seguenti righe:

Da zero
AGGIUNGI ciao/
CMD['/Ciao']

graffio non è un'immagine genitore. Piuttosto indica Docker che l'immagine non è costruita su nessun'altra immagine. È costruito da zero. Il comando ADD prenderà il binario statico chiamato |_+_| dalla directory corrente e lo aggiungerà alla directory principale del file immagine. Quando finalmente eseguiremo un contenitore basato su questa immagine, l'eseguibile hello verrà visualizzato all'interno della directory radice stessa in |_+_|

Infine, la linea CMD ha una stringa /Ciao questa stringa verrà eseguita come comando di shell ogni volta che viene creato un contenitore da questa immagine, quindi il file binario che abbiamo aggiunto al nostro contenitore e stamperemo il messaggio che abbiamo scritto nella nostra app.

Costruiamo l'immagine invocando il costruzione della finestra mobile comando che passerebbe attraverso il contenuto del Dockerfile e genererebbe l'immagine. Eseguire il comando seguente nella stessa directory del Dockerfile e del binario eseguibile.

$costruzione della finestra mobile--etichettaCiao .

Il –tag ciao flag imposta il nome dell'immagine su Ciao e il punto ( . ) alla fine racconta costruzione della finestra mobile per esaminare la directory corrente per Dockerfile e relativi contenuti.

Esecuzione del contenitore Docker

Per verificare se l'immagine appena creata viene visualizzata nell'elenco delle immagini, esegui:

$immagini docker

Nota quanto è piccola l'immagine di saluto rispetto ad altre immagini. In ogni caso, è pronto per essere eseguito come contenitore,

$docker corri ciao

Questo è tutto! Hai creato il tuo primo contenitore minimalista da zero.

Altre opzioni

Sebbene la creazione di immagini da zero sia sempre un'opzione, le persone spesso tendono a creare immagini da altre distribuzioni Linux leggere. Ad esempio, immagini come alpine e busybox sono ambienti davvero leggeri con librerie più piccole come musl invece di glibc.

Usandoli come immagine genitore usando DA alpino: più recente produrrebbe anche immagini più piccole. Poiché le immagini di base hanno una dimensione di soli 2-5 MB. Facci sapere se c'è qualche argomento relativo a Docker che potresti voler trattare in seguito. Puoi raggiungerci su Twitter , Facebook o iscriviti a noi via e-mail.