Come ridurre le dimensioni dell'immagine Docker nei contenitori Docker

La creazione e la distribuzione dell'immagine Docker impiega troppo tempo? Ci vogliono ore per esportare? Smetti di perdere tempo e accelera questi processi sviluppando un'immagine più piccola. In questo tutorial imparerai tre trucchi per ridurre le dimensioni dell'immagine Docker.

Iniziamo!

Prerequisiti

Questo tutorial sarà una dimostrazione pratica. Se desideri continuare, assicurati di avere quanto segue:

• Docker Desktop o Motore. Sono disponibili versioni Docker per Linux, Windows e macOS. Questo tutorial utilizza Docker versione 20.10.8 build 3967b7d su un computer Ubuntu 18.04 LTS.

• Node.js. Questo tutorial utilizza Node.js versione 10.10.0 ma dovrebbe funzionare anche con le versioni più recenti.

• Avrai bisogno di un editor di codice come Visual Studio Code, vim e nano . Questo tutorial utilizza nano.

Creazione di un'immagine Docker

Probabilmente hai già un'immagine Docker in giro che vuoi ridurre. Non. In questo tutorial, inizierai da zero creando un'immagine Docker per i tuoi test.

Inizierai creando un contenitore per un'applicazione Node.js L'applicazione Node.js che utilizzerai è l'esempio Hello World Express.js che mostra il testo "Hello World!" nel tuo browser.

1. Innanzitutto, apri una sessione del terminale e crea una directory in cui creerai l'immagine Docker e i file associati. Per questo esempio, la directory di lavoro sarà ~/docker_demo .

# Create the project directory
mdkir ~/docker_demo
# Change the current directory to your working directory
cd ~/docker_demo

Quindi, crea tre file nella tua directory di lavoro. Questi file sono:

• index.js:il punto di partenza per la tua applicazione di esempio.
• package.json – contiene i metadati della tua applicazione.
• File Docker – contiene le istruzioni per creare l'immagine Docker. Esegui il comando seguente nel terminale per creare tutti questi file contemporaneamente.

touch index.js package.json Dockerfile

3. Apri index.js nel tuo editor di codice, compilalo con il codice seguente e salva.

const express = require('express')
const app = express()

app.get('/', (req, res) => res.send('Hello World!'))

app.listen(3000, () => {
  console.log(`Example app listening on port 3000!`)
})

4. Quindi, apri package.json file per la modifica, copia e incolla il codice sottostante e salva.

{
  "name": "hello-world",
  "version": "1.0.0",
  "main": "index.js",
  "dependencies": {
    "express": "^4.16.2"
  },
  "scripts": {
    "start": "node index.js"
  }
}

5. Allo stesso modo, modifica il Dockerfile per popolare il codice qui sotto e salvare il file.

# use the Node.js parent image 
FROM node:8 

# set a directory for the app
WORKDIR /app
# copy all the files to the container
COPY . .
# install dependencies
RUN npm install
# define the port number the container should expose
EXPOSE 3000

# run the application
CMD ["npm", "start"]

6. Esegui il seguente docker build comando per creare la tua immagine Docker. Il -t facoltativo flag tagga la tua immagine con un nome per renderla identificabile. Questo esempio usa il nome 'mia_app.'

docker build -t my_app .

7. Quando Docker ha completato la creazione dell'immagine, esegui il comando seguente per visualizzare l'immagine contrassegnata con 'my_app.'

Il grep Il comando è disponibile solo su Linux, ma per visualizzare la tua immagine su altri sistemi operativi, esegui il comando docker images e cerca l'immagine con il tag 'my_app.'

docker images | grep my_app

Come mostrato nell'immagine seguente, la dimensione dell'immagine Docker è 904 MB.

8. Ora verifica che la tua immagine funzioni correttamente. Esegui il seguente comando di esecuzione della finestra mobile. Questo comando utilizzerà l'immagine Docker per creare un contenitore in cui verrà eseguita l'applicazione.

docker run -p 3000:3000 -ti --rm --init my_app

Se l'applicazione si avvia correttamente, viene visualizzato il messaggio "Esempio di app in ascolto sulla porta 3000!" verrà stampato nel tuo terminale.

9. Per verificare il funzionamento dell'applicazione, apri il browser e vai a http://localhost:3000/. Il testo "Hello World!" dovrebbe essere visualizzato come mostrato nell'immagine seguente.

10. Per terminare l'applicazione e tornare al prompt del terminale, premere CTRL+C .

Ridurre una dimensione dell'immagine Docker

Ora che hai un'immagine Docker, è tempo di imparare a ridurre le dimensioni dell'immagine! Le sezioni seguenti illustrano tre metodi per ridurre le dimensioni dell'immagine Docker.

Metodo 1:applicazione di build multifase

Avere file Dockerfile separati per lo sviluppo e la produzione era una pratica comune.

Il Dockerfile di sviluppo conteneva tutto il necessario per costruire l'applicazione, mentre quello di produzione includeva ciò di cui l'applicazione aveva bisogno per funzionare. Questo metodo produce l'immagine di produzione finale con le dimensioni ottimali. Ma gestire due Dockerfile è inutilmente complicato.

Dall'introduzione delle build multifase nella versione 17.05, gli sviluppatori ora hanno bisogno di un solo Dockerfile contenente più FROM istruzioni per separare le fasi di sviluppo e produzione. Pertanto, copiando selettivamente gli artefatti da una fase di costruzione all'altra.

Ora è il momento di utilizzare le build multifase nella tua immagine!

1. Apri il tuo Dockerfile nell'editor di codice e sostituisci il suo contenuto con il codice seguente. Questo nuovo codice Dockerfile ha due fasi di costruzione, come indicato dai due FROM Linee.

Per impostazione predefinita, le fasi di compilazione non hanno nomi e il codice può farvi riferimento solo come numero intero nell'ordine in cui appaiono (a partire da zero) nel Dockerfile. Puoi aggiungere il as <name> al FROM riga per assegnare un nome alla fase di costruzione per una migliore identificazione .

# the develop build stage using the node parent image
FROM node:8 as develop

# set a directory for the app
WORKDIR /app
# copy all the files to the container
COPY . .
# install dependencies
RUN npm install

# the production build stage using the node parent image
FROM node:8

# Copy only the build artifact from the first (develop) build stage
# Any intermediate artifacts used to build your application are not included in the final image.
COPY --from=develop /app /

# define the port number the container should expose
EXPOSE 3000

# run the application
CMD ["npm", "start"]

2. Crea la tua nuova immagine con il nome my_app_multi_stage_builds eseguendo il comando seguente.

docker build -t my_app_multi_stage_builds .

3. Dopo la compilazione, visualizzare la dimensione dell'immagine aggiornata eseguendo il comando seguente.

docker images | grep my_app_multi_stage_builds

L'applicazione di esempio è piccola e presenta solo alcuni artefatti intermedi. Ma c'è ancora una riduzione di 1 MB rispetto alla precedente build dell'immagine Docker.

Metodo 2:utilizzo di un'immagine genitore leggera

A meno che tu non crei un'immagine Docker da zero (usando il file FROM scratch direttiva), ogni immagine Docker ha un'immagine padre. Il File Docker i file nelle sezioni precedenti usano node:8 come immagine principale durante la compilazione.

Se la tua applicazione non richiede una versione specifica del sistema operativo per l'esecuzione, considera la possibilità di scambiare l'immagine principale con una più leggera. Se utilizzi Linux, l'immagine più leggera in Docker Hub è Alpine.

Ora è il momento di imparare a sostituire l'immagine principale con Alpine!

1. Modifica il tuo Dockerfile e sostituisci il secondo FROM node:8 riga con FROM node:8-alpine . Questo nuovo FROM l'istruzione, Docker, utilizzerà node-8-alpine come immagine principale. Ora la tua immagine finale verrà eseguita su Alpine anziché su Node.

# the first build stage using the node parent image
FROM node:8 as build

# set a directory for the app
WORKDIR /app
# copy all the files to the container
COPY . .
# install dependencies
RUN npm install

# the second build stage using the node-8-alpine parent image
FROM node:8-alpine

# copy the required artifacts to from the first build stage
COPY --from=build /app /
# define the port number the container should expose
EXPOSE 3000

# run the application
CMD ["npm", "start"]

2. Esegui il comando seguente per creare l'immagine Docker con il nome my_app_alpine.

docker build -t my_app_alpine .

3. Infine, visualizza la dimensione dell'immagine aggiornata eseguendo il comando seguente.

docker images | grep my_app_alpine

La dimensione finale dell'immagine Docker è ora di soli 75,2 MB. Una significativa riduzione di 827,8 MB!

Metodo 3:creazione di un file .dockerignore

Docker è un'applicazione client-server composta dal client Docker o dalla CLI e dal demone Docker, che gestisce le immagini Docker (e i contenitori, le reti e i volumi).

La CLI compila un contesto di compilazione costituito dai file da includere nell'immagine da costruire. La CLI cerca anche un file .dockerignore che elenca i file da ignorare prima di inviare il contesto di compilazione al demone Docker. Di conseguenza, la copia di meno file riduce le dimensioni dell'immagine Docker.

Ora è il momento di applicare un file .dockerignore alla tua build!

1. Innanzitutto, crea un nuovo file vuoto chiamato .dockerignore .

touch .dockerignore

2. Quindi, crea un file fittizio che farai ignorare Docker durante le build. In questo esempio, crea un file README.md fittizio con una dimensione di 2 MB.

Se su un computer Linux, eseguire il comando fallocate di seguito per creare il file.

fallocate -l 2MB README.md

Se su un computer Windows, eseguire invece il comando fsutil.

fsutil file createnew README.md 2000000

3. Quindi, crea la tua nuova immagine Docker eseguendo il comando seguente. Poiché il file README.md si trova nella stessa directory, aspettarsi che questo file fittizio faccia parte dell'immagine Docker risultante.

docker build -t my_app_readme .

4. Visualizza la dimensione dell'immagine aggiornata eseguendo il comando seguente.

docker images | grep my_app_readme

Come previsto, con l'inclusione del file README.md, la dimensione dell'immagine Docker finale è aumentata di 2 MB.

5. Ora escludi tutti i file con .md estensione dalla build dell'immagine. Per farlo, modifica .dockerignore file e riempilo con il codice seguente.

# ignore markdown files
.md

I file Markdown (.md) in genere non influiscono sulla funzionalità di un'applicazione e sono generalmente sicuri da escludere dalle build. Altri file che puoi escludere sono i registri di compilazione, gli script di test, la cartella .git del tuo repository e tutti i file che includono informazioni riservate (come le password).

6. Ora che hai aggiornato il file ignore, esegui nuovamente il comando di build dell'immagine Docker come mostrato di seguito.

docker build -t my_app_dockerignore .

7. Infine, esegui il comando seguente per visualizzare la nuova dimensione dell'immagine Docker, incluso il file README.md.

docker images | grep my_app_dockerignore

Ora che il file README.md è fuori dalla nuova build, la dimensione dell'immagine Docker è scesa a 75,2 MB!

Conclusione

In questo tutorial, hai appreso i diversi metodi per ridurre le dimensioni dell'immagine Docker. Hai imparato a utilizzare build multifase, creare da un'immagine principale più piccola ed escludere file non essenziali.

La prossima volta che Docker impiega troppo tempo per la creazione e la distribuzione, non trattenerti e applica le tue conoscenze per ottimizzare le dimensioni dell'immagine Docker. Quale metodo pensi che utilizzerai di più?