So reduzieren Sie die Docker-Image-Größe in Docker-Containern

Dauert das Erstellen und Bereitstellen Ihres Docker-Images zu lange? Dauert der Export Stunden? Verschwenden Sie keine Zeit mehr und beschleunigen Sie diese Prozesse, indem Sie ein kleineres Bild entwickeln. In diesem Tutorial lernen Sie drei Tricks kennen, um die Größe Ihres Docker-Images zu reduzieren.

Fangen wir an!

Voraussetzungen

Dieses Tutorial wird eine praktische Demonstration sein. Wenn Sie mitmachen möchten, stellen Sie sicher, dass Sie Folgendes haben:

• Docker-Desktop oder -Engine. Es gibt Docker-Versionen für Linux, Windows und macOS. Dieses Tutorial verwendet Docker-Version 20.10.8 Build 3967b7d auf einem Ubuntu 18.04 LTS-Computer.

• Node.js. Dieses Tutorial verwendet Node.js Version 10.10.0, sollte aber auch mit neueren Versionen funktionieren.

• Sie benötigen einen Code-Editor wie Visual Studio Code, vim und nano . Dieses Tutorial verwendet nano.

Erstellen eines Docker-Images

Wahrscheinlich haben Sie bereits ein Docker-Image herumliegen, das Sie verkleinern möchten. Nicht. In diesem Tutorial fangen Sie neu an, indem Sie ein Docker-Image für Ihre Tests erstellen.

Sie beginnen mit dem Erstellen eines Containers für eine Node.js-Anwendung. Die von Ihnen verwendete Node.js-Anwendung ist das Beispiel „Hello World Express.js“, das den Text „Hello World!“ anzeigt in Ihrem Browser.

1. Öffnen Sie zunächst eine Terminalsitzung und erstellen Sie ein Verzeichnis, in dem Sie Ihr Docker-Image und die zugehörigen Dateien erstellen. In diesem Beispiel ist das Arbeitsverzeichnis ~/docker_demo .

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

Erstellen Sie als Nächstes drei Dateien in Ihrem Arbeitsverzeichnis. Diese Dateien sind:

• index.js – der Ausgangspunkt für Ihre Beispielanwendung.
• Paket.json – enthält die Metadaten Ihrer Anwendung.
• Dockerfile – enthält die Anweisungen zum Erstellen Ihres Docker-Images. Führen Sie den folgenden Befehl im Terminal aus, um alle diese Dateien auf einmal zu erstellen.

touch index.js package.json Dockerfile

3. Öffnen Sie index.js Füllen Sie es in Ihrem Code-Editor mit dem folgenden Code aus und speichern Sie es.

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. Als nächstes öffnen Sie die package.json Datei zum Bearbeiten, kopieren Sie den folgenden Code, fügen Sie ihn ein und speichern Sie ihn.

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

5. Bearbeiten Sie auf die gleiche Weise das Dockerfile um den Code unten auszufüllen und die Datei zu speichern.

# 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. Führen Sie den folgenden docker build aus Befehl, um Ihr Docker-Image zu erstellen. Das optionale -t flag kennzeichnet Ihr Bild mit einem Namen, um es identifizierbar zu machen. Dieses Beispiel verwendet den Namen ‘my_app.’

docker build -t my_app .

7. Wenn Docker das Erstellen des Images abgeschlossen hat, führen Sie den folgenden Befehl aus, um Ihr Image mit dem Tag ‘my_app.‘ anzuzeigen

Das grep Der Befehl ist nur unter Linux verfügbar, aber um Ihr Image auf anderen Betriebssystemen anzuzeigen, führen Sie den Befehl docker images aus und suchen Sie nach dem Bild mit dem Tag „my_app.“

docker images | grep my_app

Wie im folgenden Bild gezeigt, beträgt die Docker-Image-Größe 904 MB.

8. Überprüfen Sie nun, ob Ihr Bild korrekt funktioniert. Führen Sie den folgenden Docker-Run-Befehl aus. Dieser Befehl verwendet Ihr Docker-Image, um einen Container zu erstellen, in dem Ihre Anwendung ausgeführt wird.

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

Wenn die Anwendung korrekt startet, wird die Meldung „Beispiel-App, die auf Port 3000 lauscht!“ angezeigt wird in Ihrem Terminal ausgedruckt.

9. Um zu überprüfen, ob Ihre Anwendung funktioniert, öffnen Sie Ihren Browser und navigieren Sie zu http://localhost:3000/. Der Text „Hello World!“ sollte wie im folgenden Bild dargestellt angezeigt werden.

10. Um die Anwendung zu beenden und zur Terminal-Eingabeaufforderung zurückzukehren, drücken Sie CTRL+C .

Reduzieren der Größe eines Docker-Images

Jetzt, da Sie ein Docker-Image haben, ist es an der Zeit zu lernen, wie Sie die Größe Ihres Images reduzieren können! Die folgenden Abschnitte behandeln drei Methoden, um die Größe Ihres Docker-Images zu verkleinern.

Methode 1:Anwenden mehrstufiger Builds

Es war gängige Praxis, separate Dockerfile-Dateien für Entwicklung und Produktion zu haben.

Die Entwicklungs-Dockerdatei enthielt alles, was zum Erstellen der Anwendung erforderlich war, während die Produktionsdatei alles enthielt, was die Anwendung zum Ausführen benötigte. Dieses Verfahren erzeugt das endgültige Produktionsbild mit der optimalen Größe. Aber die Verwaltung von zwei Dockerfiles ist unnötig kompliziert.

Seit der Einführung von mehrstufigen Builds in Version 17.05 benötigen Entwickler nur noch ein Dockerfile enthält mehrere FROM Anweisungen zur Trennung der Entwicklungs- und Produktionsphase. So können Artefakte selektiv von einer Build-Phase in eine andere kopiert werden.

Jetzt ist es an der Zeit, mehrstufige Builds in Ihrem Image zu verwenden!

1. Öffnen Sie Ihr Dockerfile im Code-Editor und ersetzen Sie seinen Inhalt durch den folgenden Code. Dieser neue Dockerfile-Code hat zwei Build-Phasen, wie durch die beiden FROM angegeben Linien.

Standardmäßig haben Build-Stufen keine Namen, und Ihr Code kann sie nur als Ganzzahl in der Reihenfolge referenzieren, in der sie in der Docker-Datei erscheinen (beginnend bei Null). Sie können den as <name> anhängen zum FROM Zeile, um der Build-Phase zur besseren Identifizierung einen Namen zuzuweisen .

# 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. Erstellen Sie Ihr neues Image mit dem Namen my_app_multi_stage_builds indem Sie den folgenden Befehl ausführen.

docker build -t my_app_multi_stage_builds .

3. Zeigen Sie nach dem Build die aktualisierte Image-Größe an, indem Sie den folgenden Befehl ausführen.

docker images | grep my_app_multi_stage_builds

Die Beispielanwendung ist klein und weist nur wenige Zwischenartefakte auf. Aber es gibt immer noch eine Reduzierung von 1 MB im Vergleich zum vorherigen Docker-Image-Build.

Methode 2:Verwenden eines einfachen übergeordneten Bildes

Es sei denn, Sie erstellen ein Docker-Image von Grund auf neu (mithilfe der FROM scratch Direktive) hat jedes Docker-Image ein übergeordnetes Image. Das Dockerfile Dateien in den vorherigen Abschnitten verwenden node:8 als übergeordnetes Image während des Builds.

Wenn für die Ausführung Ihrer Anwendung keine bestimmte Betriebssystemversion erforderlich ist, sollten Sie in Betracht ziehen, Ihr übergeordnetes Image durch ein leichteres zu ersetzen. Wenn Sie Linux verwenden, ist Alpine das einfachste Image in Docker Hub.

Jetzt ist es an der Zeit zu lernen, wie man das übergeordnete Bild durch Alpine ersetzt!

1. Bearbeiten Sie Ihr Dockerfile und ersetzen Sie den zweiten FROM node:8 Zeile mit FROM node:8-alpine . Dieses neue FROM Anweisung, Docker, verwendet node-8-alpine als übergeordnetes Image. Jetzt wird Ihr endgültiges Image auf Alpine statt auf Node ausgeführt.

# 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. Führen Sie den folgenden Befehl aus, um das Docker-Image mit dem Namen my_app_alpine. zu erstellen

docker build -t my_app_alpine .

3. Zeigen Sie schließlich die aktualisierte Bildgröße an, indem Sie den folgenden Befehl ausführen.

docker images | grep my_app_alpine

Die endgültige Docker-Image-Größe beträgt jetzt nur noch 75,2 MB. Eine deutliche Reduzierung um 827,8 MB!

Methode 3:Erstellen einer .dockerignore-Datei

Docker ist eine Client-Server-Anwendung, die aus dem Docker-Client oder CLI und dem Docker-Daemon besteht, der Docker-Images (und Container, Netzwerke und Volumes) verwaltet.

Die CLI kompiliert einen Build-Kontext bestehend aus den Dateien, die in das zu erstellende Image eingeschlossen werden sollen. Die CLI sucht auch nach einer .dockerignore-Datei, die die zu ignorierenden Dateien auflistet, bevor der Build-Kontext an den Docker-Daemon gesendet wird. Infolgedessen verringert das Kopieren von weniger Dateien die Docker-Image-Größe.

Jetzt ist es an der Zeit, eine .dockerignore-Datei auf Ihren Build anzuwenden!

1. Erstellen Sie zunächst eine neue leere Datei namens .dockerignore .

touch .dockerignore

2. Erstellen Sie als Nächstes eine Dummy-Datei, die Docker während des Builds ignorieren soll. Erstellen Sie in diesem Beispiel eine Dummy-README.md-Datei, die 2 MB groß ist.

Führen Sie auf einem Linux-Computer den folgenden Befehl fallocate aus, um die Datei zu erstellen.

fallocate -l 2MB README.md

Führen Sie auf einem Windows-Computer stattdessen den Befehl fsutil aus.

fsutil file createnew README.md 2000000

3. Erstellen Sie als Nächstes Ihr neues Docker-Image, indem Sie den folgenden Befehl ausführen. Da sich die Datei README.md im selben Verzeichnis befindet, sollten Sie davon ausgehen, dass diese Dummy-Datei Teil des resultierenden Docker-Images ist.

docker build -t my_app_readme .

4. Zeigen Sie die aktualisierte Bildgröße an, indem Sie den folgenden Befehl ausführen.

docker images | grep my_app_readme

Wie erwartet, erhöhte sich die endgültige Docker-Image-Größe mit der Aufnahme der README.md-Datei um 2 MB.

5. Schließen Sie nun alle Dateien mit der .md aus Erweiterung aus dem Image-Build. Bearbeiten Sie dazu die Datei .dockerignore Datei und füllen Sie sie mit dem folgenden Code.

# ignore markdown files
.md

Markdown-Dateien (.md) wirken sich in der Regel nicht auf die Funktionalität einer Anwendung aus und können im Allgemeinen sicher von Builds ausgeschlossen werden. Andere Dateien, die Sie ausschließen können, sind Build-Protokolle, Testskripts, der .git-Ordner Ihres Repositorys und alle Dateien, die vertrauliche Informationen (z. B. Passwörter) enthalten.

6. Nachdem Sie die Ignore-Datei aktualisiert haben, führen Sie den Docker-Image-Build-Befehl erneut aus, wie unten gezeigt.

docker build -t my_app_dockerignore .

7. Führen Sie zuletzt den folgenden Befehl aus, um die neue Docker-Image-Größe anzuzeigen, einschließlich der Datei README.md.

docker images | grep my_app_dockerignore

Jetzt, da die README.md-Datei aus dem neuen Build entfernt wurde, ist die Größe des Docker-Images auf 75,2 MB gesunken!

Schlussfolgerung

In diesem Tutorial haben Sie die verschiedenen Methoden zum Reduzieren der Größe Ihres Docker-Images kennengelernt. Sie haben gelernt, mehrstufige Builds zu verwenden, aus einem kleineren übergeordneten Image zu erstellen und unwesentliche Dateien auszuschließen.

Wenn Docker das nächste Mal zu lange zum Erstellen und Bereitstellen braucht, halten Sie sich nicht zurück und wenden Sie Ihr Wissen an, um die Größe Ihres Docker-Images zu optimieren. Welche Methode werden Sie Ihrer Meinung nach am häufigsten verwenden?