Docker-Images Schritt für Schritt erstellen

Einführung

Dieses umfassende Docker-Tutorial bietet Entwicklern und DevOps-Experten grundlegende Kenntnisse zum Erstellen, Verwalten und Verstehen von Docker-Images. Durch die Erkundung von Image-Komponenten, Schichtstrukturen und praktischen Implementierungsmethoden erwerben die Lernenden praktische Fähigkeiten in der Containerisierung und der Anwendungsverpackung.

Docker-Images-Grundlagen

Was sind Docker-Images?

Docker-Images sind schreibgeschützte Vorlagen, die zum Erstellen von Containern verwendet werden. Sie enthalten vorkonfigurierte Softwareumgebungen, Anwendungscode, Abhängigkeiten und Laufzeiteinstellungen. Docker-Images dienen als Blaupausen für die Bereitstellung konsistenter und reproduzierbarer Anwendungsumgebungen auf verschiedenen Systemen.

Hauptkomponenten von Docker-Images

graph TD A[Docker-Image] --> B[Basisschicht] A --> C[Anwendungsschicht] A --> D[Konfigurationsschicht]

Komponente	Beschreibung	Beispiel
Basisschicht	Grundlegendes Betriebssystem	Ubuntu 22.04
Anwendungsschicht	Software und Abhängigkeiten	Python 3.9, nginx
Konfigurationsschicht	Laufzeiteinstellungen	Umgebungsvariablen

Erstellen eines einfachen Docker-Images

Hier ist ein Beispiel für die Erstellung eines einfachen Python-Webanwendungs-Images:

## Projektverzeichnis erstellen
mkdir docker-demo
cd docker-demo

## Dockerfile erstellen
touch Dockerfile

## Dockerfile-Inhalt
cat > Dockerfile << EOL
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y python3 python3-pip
WORKDIR /app
COPY app.py .
RUN pip3 install flask
EXPOSE 5000
CMD ["python3", "app.py"]
EOL

## Beispiel-Flask-Anwendung erstellen
cat > app.py << EOL
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Docker-Image-Beispiel"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
EOL

## Docker-Image erstellen
docker build -t python-web-app .

Image-Schichten und Speicherung

Docker-Images bestehen aus mehreren schreibgeschützten Schichten. Jede Anweisung im Dockerfile erstellt eine neue Schicht, was eine effiziente Speicherung und schnelle Imageerstellung ermöglicht. Beim Erstellen eines Images zwischerspeichert Docker diese Schichten, um die Build-Zeiten zu optimieren und die Festplattenspeicherplatznutzung zu reduzieren.

Image-Identifizierung

Docker-Images werden durch Folgendes eindeutig identifiziert:

Repository-Name
Tag
Image-ID

Beispiel: ubuntu:22.04 oder python-web-app:latest

Docker-Images erstellen

Dockerfile: Die Blaupause für die Imageerstellung

Ein Dockerfile ist eine Textdatei, die Anweisungen zum Erstellen eines Docker-Images enthält. Jede Anweisung erzeugt eine neue Schicht im Image und definiert die Umgebung, Abhängigkeiten und die Anwendungsconfiguration.

graph TD A[Dockerfile] --> B[Basis-Image] A --> C[Abhängigkeiten installieren] A --> D[Anwendungscode kopieren] A --> E[Laufzeit konfigurieren]

Dockerfile-Anweisungsarten

Anweisung	Zweck	Beispiel
FROM	Basis-Image spezifizieren	FROM ubuntu:22.04
RUN	Befehle ausführen	RUN apt-get update
COPY	Dateien in das Image kopieren	COPY app/ /application
WORKDIR	Arbeitsverzeichnis setzen	WORKDIR /app
EXPOSE	Netzwerkports definieren	EXPOSE 8080
CMD	Standard-Containerbefehl	CMD ["python", "app.py"]

Praktisches Beispiel zum Erstellen eines Docker-Images

## Projektstruktur erstellen
mkdir -p /tmp/docker-nodejs-app
cd /tmp/docker-nodejs-app

## Dockerfile erstellen
cat > Dockerfile << EOL
FROM node:16-alpine
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]
EOL

## package.json erstellen
cat > package.json << EOL
{
  "name": "nodejs-docker-app",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.17.1"
  }
}
EOL

## Einfacher Express-Server erstellen
cat > server.js << EOL
const express = require('express');
const app = express();
const PORT = 3000;

app.get('/', (req, res) => {
  res.send('Docker Image Build Example');
});

app.listen(PORT, () => {
  console.log($(Server läuft auf Port ${PORT}));
});
EOL

## Docker-Image erstellen
docker build -t nodejs-web-app .

## Imageerstellung überprüfen
docker images

Image-Build-Kontext

Der Build-Kontext ist der Verzeichnispfad, der das Dockerfile und die referenzierten Dateien enthält. Docker sendet dieses gesamte Verzeichnis während der Imageerstellung an den Docker-Daemon, was eine umfassende Imageerstellung ermöglicht.

Mehrstufige Builds

Mehrstufige Builds ermöglichen die Erstellung kleinerer und effizienterer Images, indem mehrere FROM-Anweisungen in einem einzigen Dockerfile verwendet werden. Dabei werden Build-Zeit-Abhängigkeiten von Laufzeitumgebungen getrennt.

Image-Verwaltungstechniken

Optimierungsstrategien für Docker-Images

Eine effiziente Imageverwaltung umfasst die Reduzierung der Imagegröße, die Minimierung der Schichtanzahl und die Implementierung bewährter Verfahren für die Imageerstellung und -speicherung.

graph TD A[Imageverwaltung] --> B[Größenreduzierung] A --> C[Schichtoptimierung] A --> D[Imageversionierung] A --> E[Registryverwaltung]

Techniken zur Reduzierung der Imagegröße

Technik	Beschreibung	Beispiel
Alpine-Basis-Images	Minimale Linux-Distribution	FROM alpine:3.15
Mehrstufige Builds	Separate Build- und Laufzeitumgebungen	Mehrere FROM-Anweisungen
.dockerignore	Unnötige Dateien ausschließen	Verhindert große Dateitransfers

Verwaltung des Docker-Image-Lebenszyklus

## Lokale Images auflisten
docker images

## Nicht verwendete Images entfernen
docker image prune

## Images taggen und versionieren
docker tag original-image:latest myregistry/image:v1.0

## In Docker Registry pushen
docker push myregistry/image:v1.0

## Spezifische Imageversion ziehen
docker pull myregistry/image:v1.0

Beispiel für erweiterte Imageoptimierung

## Optimiertes Dockerfile erstellen
cat > Dockerfile << EOL
## Mehrstufiger Build für Python-Anwendung
FROM python:3.9-alpine AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

FROM python:3.9-alpine
WORKDIR /app
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY . .
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser
CMD ["python", "app.py"]
EOL

## requirements-Datei erstellen
cat > requirements.txt << EOL
flask==2.1.0
gunicorn==20.1.0
EOL

## Optimiertes Image erstellen
docker build -t optimized-python-app:slim .

## Imagegröße analysieren
docker images | grep optimized-python-app

Docker-Registry-Verwaltung

Docker-Registries bieten zentralisierte Image-Speicherung und -Distribution. Sie unterstützen Versionierung, Zugriffskontrolle und effiziente Imagefreigabe innerhalb von Entwicklungsteams und Umgebungen.

Caching von Imageschichten

Docker zwischerspeichert Imageschichten, um nachfolgende Builds zu beschleunigen. Die Anordnung der Dockerfile-Anweisungen von den am wenigsten bis zu den am häufigsten ändernden Anweisungen minimiert die Rebuild-Zeit und optimiert den Imageerstellungsprozess.

Zusammenfassung

Docker-Images sind grundlegend für die moderne Softwarebereitstellung und bieten eine konsistente und effiziente Möglichkeit, Anwendungen mit ihren Abhängigkeiten zu verpacken. Durch das Erlernen der Imageerstellungstechniken, das Verständnis der Schichtmechanismen und die Nutzung von Dockerfile-Anweisungen können Entwickler ihre Entwicklungsworkflows optimieren und zuverlässige, portierbare Anwendungsumgebungen auf verschiedenen Systemen gewährleisten.