Comprensione del filatore

Concordo con me che l'impatto che Docker sta avendo sul mondo della tecnologia è enorme. Sta salvando gli sviluppatori di software e gli amministratori di sistema allo stesso modo.

In questo articolo, imparerai una parte molto cruciale dell'intera configurazione Docker, Dockerfile. Dockerfile utilizza una struttura semplice. Mentre questa semplicità è una buona cosa, dà spazio agli individui per hackerare i comandi insieme, senza comprendere appieno l'impatto.

Alla fine di questo articolo, avrai una migliore comprensione di Dockerfile. Quindi, sarai in grado di scrivere fikerfile che capisci.

All'interno del Dockerfile

Dockerfile è fondamentalmente un file di testo. Ma, a differenza dei normali file di testo, vedrai che non ha un .TXT estensione del file. Dockerfile è un file che salverai come Dockerfile, senza estensioni di file.

In questo Dockerfile esiste tutti i comandi utilizzati per assemblare un'immagine Docker. Mentre puoi trasmettere questi comandi nella CLI Docker quando costruisci un'immagine, concorderai che è meglio praticare avere un file per questo, quindi le cose possono essere meglio organizzate.

I comandi nel Dockerfile sono fondamentali per costruire un'immagine Docker.

Ecco perché:

Ogni riga di comando in Dockerfile crea i livelli che compongono l'immagine Docker. A condizione che il Dockerfile rimanga lo stesso, ogni volta che si costruisci un'immagine, è certo che otterresti gli stessi risultati. Tuttavia, quando aggiungi una nuova riga di comando, Docker crea semplicemente quel livello e lo aggiunge ai livelli esistenti.

Proprio come fa il compilatore o l'interprete ai linguaggi di programmazione, Docker legge Dockerfile dall'alto verso il basso. Quindi, il posizionamento dei comandi conta molto.

A differenza della maggior parte dei linguaggi di programmazione, i comandi in Dockerfile non sono sensibili al caso. Ma vedrai da esempio Dockerfiles che i comandi sono scritti in maiuscolo. Questo non è altro che una convenzione, che dovresti seguire anche tu.

Come i linguaggi di programmazione, puoi scrivere commenti nei tuoi Dockerfiles. I commenti in Dockerfiles sono indicati usando il simbolo hash o libbra # All'inizio della linea. Dovresti notare che supporta solo commenti a una riga, quindi per scrivere commenti multi-line, utilizzerai il simbolo hash su ogni riga.

Attento però, non tutti i simboli hash che vedi in un fikerfile sono commenti. I simboli hash potrebbero anche indicare Direttive del parser. Le direttive del parser sono comandi nel fikerfile che indicano il modo in cui il fikerfile dovrebbe essere letto.

Solo due direttive di parser sono disponibili su Docker al momento della stesura di questo articolo. Loro sono il fuga E sintassi Direttive del parser. IL sintassi La direttiva è disponibile su Docker solo quando è in esecuzione su un backend Buildkit.

IL fuga La direttiva funziona ovunque. IL fuga La direttiva ti consente di decidere quale simbolo usa Docker come personaggio di fuga.

Puoi avere nel tuo Dockerfile, una linea simile a quella sotto:

Copia indice.HTML C: \\ documenti

Non dovresti ancora preoccuparti di ciò che fa il comando, concentrati sulla posizione del file. L'uso del comando sopra in un'immagine Docker basata su Windows, è valido. Ma ricorderete che Docker è basato su Linux, quindi utilizza la retroscena \ come personaggio di fuga a causa di convenzioni di Linux. Pertanto, quando Docker legge attraverso Dockerfile, sfuggirà alla retromarcia invece di leggerlo come percorso di file.

Per cambiare questo comportamento, utilizzerai il fuga Direttiva parser come visto di seguito:

# Escape = '

Questa direttiva fa sì che Docker usi il backtick come personaggio di fuga, invece della retroscena. Per utilizzare la direttiva Parser, dovrai metterlo in cima al Dockerfile, altrimenti contarà solo come un commento, devi posizionarlo anche al di sopra dei commenti, se hai i commenti nella parte superiore del file.

Istruzioni Dockerfile

Docker si basa su ogni riga di comando nel Dockerfile ed li esegue, costruendo un livello per ogni riga nel processo.

Avrai bisogno di una comprensione dei comandi per scrivere Dockerfiles. Un punto di cautela però: molti comandi Dockerfile fanno cose simili. Non devi preoccuparti, potrai capire anche quei comandi.

Ecco un elenco dei comandi che imparerai:

• DA
• ETICHETTA
• Env
• ESPORRE
• CORRERE
• COPIA
• Workdir
• Cmd

DA

Ricorda che l'obiettivo principale di Docker è di virtualizzare le cose a livello di sistema operativo (OS), creando contenitori. Pertanto, qualunque immagine creano Docker dal tuo Dockerfile deve essere basato su un sistema operativo esistente, tranne, stai costruendo un'immagine di base.

Il comando dal comando viene utilizzato per indicare ciò che si intendi utilizzare come immagine di base. Se si intende costruire su un'immagine di base, dal comando dovere Sii il primo comando nelle direttive e commenti del parser Dockerfile-ASIES.

ETICHETTA

Dockerfile necessita di metadati e il comando etichetta è ciò che useresti per crearli. Dopo aver costruito un'immagine e aver eseguito un contenitore, puoi usare il Docker Ispect comanda di trovare informazioni sul contenitore.

Env

Variabili ambientali. Parole familiari? Bene, il comando Env viene utilizzato per impostare le variabili di ambiente durante la costruzione dell'immagine Docker. Vedrai anche che le variabili di ambiente impostate sono anche accessibili dopo aver lanciato il contenitore.

Dockerfile ha un comando simile a Env, noto come Arg. Tuttavia, qualunque variabile di ambiente sia impostata utilizzando Arg è disponibile solo durante la costruzione dell'immagine, ma non dopo aver lanciato il contenitore.

ESPORRE

Allo stesso modo in cui la tua macchina locale Docker è l'host Docker in queste porte Case-Has per la comunicazione come 8080, 5000, ecc. è lo stesso modo in cui i contenitori Docker hanno porte.

Utilizzerai il comando Expose per scegliere quali porte dovrebbero essere disponibili per comunicare con un contenitore.

Quando si eseguono contenitori Docker, è possibile passare nel -P Argomento noto come Publish, che è simile al comando Expose.

Ecco la differenza sottile: si utilizza il comando Expose per aprire le porte ad altri contenitori Docker, mentre il -P L'argomento viene utilizzato per aprire le porte all'ambiente esterno i.e. Al di fuori del contenitore Docker.

Se non si utilizza Espose o -P Per niente, il contenitore Docker non sarà accessibile tramite porte all'esterno del contenitore o altri contenitori Docker.

CORRERE

Durante la creazione di un'immagine Docker, potrebbe essere necessario eseguire comandi per motivi come l'installazione di applicazioni e pacchetti per far parte dell'immagine.

Usando il comando di corsa, puoi fare tutto questo. Ma ricorda: i comandi vengono eseguiti solo quando stai costruendo l'immagine Docker.

COPIA

Esistono diversi motivi per copiare i file dal tuo host Docker all'immagine Docker. Alcuni file che ti piacerebbe copiare potrebbero essere i file di configurazione o il codice sorgente-se lo eseguiresti nel contenitore Docker.

Per copiare i file dall'host Docker in un'immagine Docker, è possibile utilizzare il comando Copia.

C'è il comando ADD simile alla copia ed è un po 'diverso. Mentre la copia può copiare solo i file dall'host Docker all'immagine Docker, Aggiungi può copiare i file da un URL ed estrarre anche file compressi all'immagine Docker.

Perché utilizzare copia invece di aggiungere? Bene, capirai che la copia dei file da un URL è un'attività che puoi eseguire con Curl usando il comando di esecuzione. Puoi anche estrarre file nell'immagine Docker usando anche il comando di esecuzione.

Tuttavia, non c'è nulla di sbagliato nell'uso di ADD per estrarre direttamente i file compressi nell'immagine Docker.

Workdir

Ricorda il comando di corsa? È possibile utilizzare il comando Esegui per eseguire i comandi nell'immagine Docker. Tuttavia, a volte avrai un motivo per eseguire un comando in determinate directory. Ad esempio, per decomprimere un file, devi essere nella directory del file zip o indicarlo.

Ecco dove WorkDir è utile. WorkDir consente di modificare la directory mentre Docker crea l'immagine e la nuova directory rimane la directory corrente per il resto delle istruzioni di build.

Cmd

Il tuo contenitore Docker è di solito impostato per eseguire un processo. Ma come fa a sapere quale processo eseguire? È attraverso il comando cmd. Il comando CMD viene utilizzato per eseguire i comandi mentre Docker lancia il contenitore Docker dall'immagine.

Mentre è possibile specificare il comando da eseguire al momento dell'avvio dalla riga di comando, i comandi dichiarati sull'istruzione CMD rimangono il valore predefinito.

Docker può eseguire un solo comando CMD. Pertanto, se si inserisce due o più istruzioni CMD, Docker eseguirebbe solo l'ultimo i.e. il più recente.

EntryPoint è simile a CMD, tuttavia, è possibile eseguire i comandi durante l'avvio e non sovrascriverebbe le istruzioni che hai definito a EntryPoint.

Esempio

In questo esempio, vedrai un'implementazione di quasi tutti i comandi discussi sopra. Vedrai come sarebbe eseguita un'applicazione di pallone in un contenitore Docker. Se non sai cos'è il pallone, Fask è un framework web scritto in Python per la creazione di applicazioni Web.

È abbastanza semplice, quindi non è necessario avere alcuna conoscenza della lingua per eseguire l'esempio.

Per cominciare, dovrai installare Git sulla tua macchina. Dopo aver installato Git, clonerai il codice sorgente dal repository GitHub qui.

Innanzitutto, crea una nuova directory. Avrai il codice sorgente e il fikerfile in questa directory. Puoi creare una directory-tu puoi chiamarlo Docker-Sample-e Dockerfile usando i comandi di seguito:

MKDIR Docker-Sample && CD Docker-Sample
Tocca Dockerfile

Ricorda che Dockerfile è solo un file di testo semplice? Ricordi anche che non dovrebbe avere il .TXT estensione? Troverai quella discussione all'inizio della sezione "Inside the Dockerfile", se l'hai perso.

Successivamente, scaricherai il codice sorgente da GitHub usando il clone git comando come visto di seguito:

Git clone https: // github.com/craigkerstiens/flask-helloworld.idiota

Puoi controllare il contenuto del Flask-Helloworld Directory:

LS FLASK-Helloworld

Vedrai i seguenti file:

• Markdown.primo: Contiene i dettagli del progetto, ma non importanti per questo esempio. Non dovresti preoccuparti.
• Procfile: Contiene comandi per eseguire i progetti su un server. Non dovresti nemmeno preoccuparti.
• app.Py: Contiene il codice che eseguirai nel contenitore Docker.
• Requisiti.TXT: Contiene le dipendenze app.Py Il file deve essere eseguito correttamente.

Scrivere il Dockerfile

Questo Dockerfile ha tutte le istruzioni Docker discusse sopra. Ha anche commenti in esso, per aiutarti a capire cosa fa ogni riga.

# Dall'istruzione sceglie l'immagine genitore per Docker.
# Questo esempio utilizza alpino.
# Alpine è un'immagine Docker minima di dimensioni molto ridotte
Da alpino: 3.3

# L'istruzione dell'etichetta crea etichette.
# La prima etichetta è manutenzione con il valore di valore Linux.
# La seconda etichetta è appname con il value palla ciao. Mondo
# Puoi avere tutte le coppie chiave per valore che vuoi.
# Puoi anche scegliere qualsiasi nome per le chiavi.
# La scelta di manutenzione e appname in questo esempio
# è una scelta personale.
Etichetta "manteneder" = "Linux suggerimenti" "AppName" = "Flask Hello World"

# ENV Istruzioni assegna variabili di ambiente.
# La directory /USR /SRC detiene i programmi scaricati,
# sia una fonte o un binario prima di installarli.
Env Applococation /USR /SRC

# Copia i file o le directory delle copie delle istruzioni,
# dall'host Docker all'immagine Docker.
# Coperai il codice sorgente sull'immagine Docker.
# Il comando seguente utilizza la variabile Set Environment.
Copia Flask-Hellowlerld $ Application/Flask-Helloworld

# Usando di nuovo l'istruzione ENV.
Env FlaskApp $ Applococation/Flask-Helloworld

# L'istruzione WorkDir modifica la directory corrente nell'immagine Docker.
# Il comando seguente modifica la directory in/usr/src/blfask-helloworld.
# La directory target utilizza la variabile di ambiente.
Workdir $ flaskapp/

# Esegui i comandi esegue le istruzioni,
# proprio come fai sul terminale,
# ma nell'immagine Docker.
# Il comando di seguito installa Python, PIP e le dipendenze dell'app.
# Le dipendenze sono nei requisiti.file txt.
Esegui apk add-aggiorna python py-pip
Esegui PIP Installa -PIP AGGIORNAMENTO
Esegui i requisiti di installazione PIP -R.TXT # Expose Istruction Apre la porta per comunicare con il contenitore Docker.
# L'app Flask utilizza la porta 5000, quindi esporrai la porta 5000.
Esporre i comandi con le istruzioni cmd 5000 #,
# ma i comandi vengono eseguiti quando il contenitore Docker viene lanciato.
# È possibile utilizzare solo un'istruzione CMD.
Cmd ["python", app.py "]

Costruire l'immagine Docker

Dopo aver scritto Dockerfile, è possibile creare l'immagine Docker con il comando qui sotto:

sudo docker build -t sample_image .

Qui, Sample_Image è il nome dell'immagine Docker. Puoi dargli un altro nome. Il punto (.) alla fine del comando indica che i file con cui stai lavorando sono nella directory corrente.

Esecuzione del contenitore Docker

Per eseguire il contenitore Docker, è possibile utilizzare il Docker Run comando sotto:

Sudo Docker Run -ip 5000: 5000 Sample_Image: più recente

Il parametro -i assicura che il contenitore Docker viene eseguito in modalità interattiva e il parametro -p lega la porta dell'host Docker alla porta del contenitore Docker. Pensalo come: Docker-Host: Docker-Container.

Dopo aver lanciato il container Docker, puoi visitare LocalHost: 5000 nel browser per vedere i risultati dell'applicazione del pallone.

Conclusione

Dockerfile è il progetto per un'immagine Docker. Comprendere come funziona Dockerfiles e essere in grado di scriverli comodamente renderebbe la tua esperienza di Docker.

Lavorando per questo attraverso questo articolo, hai visto come funziona Dockerfiles. Spero che tu capisca anche cosa significano le principali istruzioni Docker e puoi essere in grado di usarle nella costruzione delle tue immagini Docker.

Qualsiasi domanda che tu abbia relativo a Dockerfiles sarebbe il benvenuto. Grazie per aver letto.