Una guida per principianti a una build Docker multistage

Build Multi-Stage Docker è il processo per specificare una serie di build in un file Docker. In altre parole, il Dockerfile contiene più "DA"Dichiarazioni in un singolo file e la nuova istruzione utilizza istruzioni di base diverse o precedenti. La build multistage consente agli sviluppatori di abbattere il processo di sviluppo in multistage. Inoltre, l'istruzione di base viene definita istruzioni di installazione o di configurazione e altre istruzioni utilizzano le dipendenze delle istruzioni di base per funzionare correttamente.

Questo articolo fornirà una guida a una build Docker multistage.

Una guida per principianti a una build Docker multistage

Al fine di creare un'immagine Docker tramite Dockerfile semplice e build Dockerfile a più stadi, dai un'occhiata ai metodi elencati:

• Come costruire una semplice immagine Docker?
• Come costruire un'immagine Docker da Dockerfile multistage?

Come costruire una semplice immagine Docker?

Per creare una semplice immagine Docker usando un semplice Dockerfile, passare attraverso le istruzioni fornite.

Passaggio 1: Open Terminal
Dalle finestre "Avviare"Menu, apri il terminale GIT:

Passaggio 2: crea una nuova directory
Successivamente, crea una nuova directory di progetto utilizzando il comando indicato:

$ mkdir multistage

Successivamente, apri la directory del progetto con l'aiuto di "CD"Comando:

$ cd multistage

Passaggio 3: creare file di programma
Crea e apri un nuovo file di programma per implementare il "Golang" programma. Ad esempio, abbiamo creato un "principale.andare" file:

$ nano main.andare

Incolla il codice fornito nel "principale.andare" file. Questo programma stamperà il semplice output "Ciao! Benvenuti in LinuxHint Tutorial"Sull'host locale:

importazione (
"FMT"
"tronco d'albero"
"net/http"
)
gestore func (w http.Responsewriter, r *http.Richiesta)
fmt.Fprintf (w, "ciao! Benvenuto in LinuxHint Tutorial ")

func main ()
http.Handlefunc ("/", gestore)
tronco d'albero.Fatale (http.Ascoltandserve ("0.0.0.0: 8080 ", zero))

Premere "Ctrl+O"Per salvare le modifiche e"Ctrl+X" uscire.

Passaggio 4: crea Dockerfile
Crea e apri un nuovo Dockerfile nell'editor di testo Nano usando il "Nano Dockerfile"Comando:

$ nano Dockerfile

Incolla il seguente codice all'interno del "Dockerfile"Ciò istruirà il contenitore su come distribuire il progetto:

Da golang: 1.8
Workdir/go/src/app
Copia principale.andare .
Esegui GO Build -O Webserver .
Cmd ["./server web"]

Premere "Ctrl+O"Per salvare il file e"Ctrl+X"Per uscire dall'editore:

Passaggio 5: crea immagine Docker
Con l'aiuto di Dockerfile, crea una nuova immagine Docker attraverso "Build Docker"Comando. IL "-T"Il tag viene utilizzato per specificare il tag/nome immagine:

$ Docker Build -t Nuovo Web-Image .

Passaggio 6: esegui l'immagine Docker
Dopo aver creato l'immagine Docker, utilizzare il comando di seguito per eseguire l'immagine Docker. IL "-P"L'opzione viene utilizzata per specificare il numero di porta in cui il contenitore Docker eseguirà il programma:

$ Docker Run -P 8080: 8080 Nuova Image

Dopodiché, naviga su "http: // localhost: 8080"Per verificare se l'applicazione è in esecuzione o meno:

Dall'output di cui sopra, puoi vedere che abbiamo distribuito con successo l'applicazione su LocalHost:

Passaggio 7: controlla le immagini Docker
Infine, eseguire il “Immagini Docker "Comando per controllare le informazioni aggiuntive sull'immagine Docker appena creata:

$ Docker Image Nuova immagine

Si può osservare che la dimensione dell'immagine Docker è troppo enorme per eseguire il piccolo progetto. In tale scenario, la build a più fasi può essere utilizzata per ridurre la dimensione dell'immagine Docker:

Come costruire un'immagine Docker da Dockerfile multistage?

Per creare un fikerfile a più stadi per abbattere i processi di sviluppo in fasi e ridurre le dimensioni dell'immagine, dai un'occhiata ai passaggi forniti.

Passaggio 1: Apri Dockerfile
Innanzitutto, apri Dockerfile nel "Nano Editor di testo"Attraverso il comando menzionato:

$ nano Dockerfile

Passaggio 2: crea Dockerfile multistage
Incolla il seguente codice in Dockerfile. Si può notare che il file Docker contiene più di uno "DA"Dichiarazione, il che significa che stiamo creando un Dockerfile a più stadi:

Da golang: 1.8 come base
Workdir/go/src/app
Copia principale.andare .
Esegui GO Build -O Webserver .
Da alpino
Workdir /app
Copia - -from = base/go/src/app/app/
Cmd ["./server web"]

Premere "Ctrl+O"Per salvare le modifiche e"Ctrl+X"Per uscire dall'editore.

Passaggio 3: crea immagine Docker
Ora, costruisci la nuova immagine Docker con l'aiuto di una build multistage. A tale scopo, eseguire il comando dato:

$ Docker Build -t Nuovo Web-Image .

Ancora una volta, controlla le informazioni aggiuntive sull'immagine Docker tramite "Immagini Docker"Comando:

$ Docker Image Nuova immagine

L'output mostra che abbiamo creato correttamente un file Docker e la dimensione del file Docker è ridotta solo a "12.9 MB":

Passaggio 4: esegui l'immagine Docker
Infine, esegui l'immagine Docker per eseguire il contenitore per verificare se l'immagine Docker funziona correttamente o meno:

$ Docker Run -P 8080: 8080 Nuova Image

Apri il server host locale navigando su "http: // localhost: 8080"Sul browser:

L'output mostra che abbiamo distribuito con successo il programma attraverso una build multistage.

Conclusione

La build multistage Docker specifica la serie di build in fasi. Per creare una Dockerfile a più stadi, specificare più di una dichiarazione "da" e fare riferimento alla prima "DA"Dichiarazione come costruzione di base. Successivamente, crea una nuova immagine Docker usando "Docker build -t ."Comando. Il post ha elaborato una guida completa a una build Docker multistage.