Dockerfile: Erstellen und Struktur der Datei

2.1 Grundkonzepte von Dockerfile

Dockerfile — das ist eine Textdatei, die eine Abfolge von Befehlen enthält, die Docker nutzt, um ein Image zu erstellen. Es dient als ein „Rezept“, das beschreibt, wie ein Image vom Basisschicht bis zum endgültigen Zustand aufgebaut werden soll. Das Verständnis der Struktur und des Erstellungsvorgangs eines Dockerfile ist wichtig für die effiziente Nutzung von Docker.

Grundkonzepte von Dockerfile:

1. Idempotenz: Befehle im Dockerfile sollten idempotent sein — ihre wiederholte Ausführung liefert dasselbe Ergebnis.
2. Abfolge: Befehle werden in Reihenfolge von oben nach unten ausgeführt. Die Reihenfolge ist wichtig, da jeder Befehl eine neue Schicht des Images erstellt.
3. Schichtstruktur: Praktisch jeder Befehl fügt eine neue Schicht zum Image hinzu. Diese Schichten werden zwischengespeichert, was den Erstellungsprozess optimiert.

Struktur von Dockerfile:

Ein Dockerfile besteht aus Anweisungen, von denen jede eine spezifische Funktion ausführt. Hier sind die wichtigsten:

1. FROM: legt das Basis-Image fest, das zur Erstellung eines neuen Images verwendet wird.
2. MAINTAINER: definiert den Autor des Dockerfile (veraltet, aber nützlich für Informationen).
3. RUN: führt Befehle im Container aus und erstellt eine neue Schicht.
4. COPY: kopiert Dateien und Verzeichnisse aus dem Build-Kontext in das Dateisystem des Containers.
5. ADD: kopiert Dateien und Verzeichnisse, unterstützt das Extrahieren von Archiven und das Laden von Dateien aus URLs.
6. WORKDIR: legt das Arbeitsverzeichnis für die nachfolgenden Befehle fest.
7. ENV: setzt Umgebungsvariablen.
8. CMD: definiert den Standardbefehl, der beim Start des Containers ausgeführt wird.
9. ENTRYPOINT: legt den Befehl fest, der beim Start des Containers ausgeführt wird, mit der Möglichkeit, Argumente zu übergeben.
10. EXPOSE: gibt Ports an, die der Container verwendet.
11. VOLUME: erstellt einen Mount-Punkt für externe Volumes.

2.2 Erstellen eines Dockerfile

Beispiel für das Erstellen eines Dockerfile

Lass uns ein einfaches Beispiel zur Erstellung eines Dockerfile für eine Node.js-Webanwendung durchgehen.

Schritt 1: Basis-Dockerfile erstellen

Erstelle eine Datei mit dem Namen Dockerfile im Root deines Projekts und füge folgende Zeilen hinzu:

# Basis-Image von Node.js verwenden
FROM node:14

# Arbeitsverzeichnis setzen
WORKDIR /app

# package.json und package-lock.json kopieren
COPY package*.json ./

# Abhängigkeiten installieren
RUN npm install

# Alle Projektdateien kopieren
COPY . .

# Port definieren, der von der App genutzt wird
EXPOSE 3000

# Befehl zum Starten der Anwendung angeben
CMD ["node", "app.js"]

Dieses Dockerfile führt die folgenden Aktionen aus:

1. FROM node:14: verwendet das offizielle Node.js-Image der Version 14 als Basis.
2. WORKDIR /app: setzt das Arbeitsverzeichnis für die nachfolgenden Befehle.
3. COPY package*.json ./: kopiert die Dateien package.json und package-lock.json ins Arbeitsverzeichnis.
4. RUN npm install: installiert Abhängigkeiten aus der package.json.
5. COPY . .: kopiert alle Projektdateien ins Arbeitsverzeichnis des Containers.
6. EXPOSE 3000: gibt an, dass die Anwendung den Port 3000 nutzt.
7. CMD ["node", "app.js"]: definiert den Befehl zum Starten der Anwendung.

Schritt 2: Image bauen

Nach dem Erstellen des Dockerfile baue das Image mit dem Befehl docker build:

docker build -t my-node-app .

Dieser Befehl erstellt ein Image mit dem Namen my-node-app, unter Verwendung des Dockerfile im aktuellen Verzeichnis.

Schritt 3: Container starten

Starte den Container basierend auf dem erstellten Image mit dem Befehl docker run:

docker run -d -p 3000:3000 my-node-app

Dieses Beispiel startet den Container im Hintergrund und mappt Port 3000 des Containers auf Port 3000 der Host-Maschine. Nun kannst du auf die Anwendung unter http://localhost:3000 zugreifen.

2.3 Zusätzliche Anweisungen für Dockerfile

1. Festlegen von Environment-Variablen

Du kannst Environment-Variablen definieren, die im Container verfügbar sind, indem du die Anweisung ENV verwendest.

ENV NODE_ENV=production

2. Verwendung mehrerer RUN-Befehle

Manchmal ist es sinnvoll, mehrere Befehle in einer RUN-Anweisung zu kombinieren, um die Anzahl der Layer zu reduzieren, die Image-Größe zu verringern und den Build-Prozess zu beschleunigen.

RUN apt-get update && apt-get install -y \
  curl \
  git \
  && rm -rf /var/lib/apt/lists/*

Nützlich! Wenn ein Befehl nicht in eine Zeile passt, kannst du das Zeichen \ verwenden, um in der nächsten Zeile fortzufahren. Dies wird als ein einzelner Befehl interpretiert.

Nützlich! Um mehrere Befehle in einer Zeile zu schreiben, kannst du && verwenden: command1 && command2 && command3. Dadurch werden mehrere Befehle nacheinander ausgeführt.

Optimierung der Befehlsreihenfolge

Um den Docker-Cache effizient zu nutzen, kopiere zuerst Dateien, die sich selten ändern (z.B. package.json), und installiere Abhängigkeiten, bevor du die restlichen Projektdateien hinzufügst.

Beispiel für ein erweitertes Dockerfile

In komplexeren Projekten kann ein erweitertes Dockerfile mit zusätzlichen Konfigurationen erforderlich sein.

# Verwende ein minimales Node.js-Base-Image
FROM node:14-alpine

# Setze das Arbeitsverzeichnis
WORKDIR /usr/src/app

# Kopiere package.json und installiere Abhängigkeiten
COPY package*.json ./
RUN npm install --only=production

# Kopiere den Quellcode
COPY . .

# Definiere den Port für den Betrieb
EXPOSE 8080

# Setze Environment-Variablen
ENV NODE_ENV=production

# Starte die Anwendung
CMD ["node", "server.js"]