Docker Container erstellen und bereitstellen

Einführung

Dieses Tutorial führt Sie durch den Prozess der Erstellung effizienter Docker-Images mithilfe von Dockerfiles. Sie lernen, Docker-Images und Dockerfiles zu verstehen, Dockerfile-Layers für Leistung zu optimieren, den Docker-Image-Cache für schnellere Builds zu verwalten und mehrstufige Builds zu nutzen, um optimierte Images zu erstellen. Am Ende dieses Tutorials verfügen Sie über das Wissen, Docker-Images zu erstellen, die schlank, effizient und einfach zu warten sind.

Docker-Grundlagen

Was ist Docker?

Docker ist eine leistungsstarke Containerisierungstechnologie, die die Softwarebereitstellung und -entwicklung revolutioniert. Sie ermöglicht es Entwicklern, Anwendungen mit allen Abhängigkeiten in standardisierte Einheiten, sogenannte Container, zu verpacken und so eine konsistente Leistung in verschiedenen Computernumgebungen sicherzustellen.

Kernkonzepte der Containerisierung

Containerisierung ermöglicht es Anwendungen, in isolierten Umgebungen zu laufen, was mehrere entscheidende Vorteile bietet:

Konzept	Beschreibung
Isolation	Container laufen unabhängig voneinander, ohne sich gegenseitig zu beeinträchtigen
Portabilität	Anwendungen können konsistent auf verschiedenen Systemen bereitgestellt werden
Effizienz	Leichter als herkömmliche virtuelle Maschinen

Docker-Architektur

graph TD
    A[Docker Client] --> B[Docker Daemon]
    B --> C[Container Runtime]
    B --> D[Image Repository]
    C --> E[Containers]

Installation unter Ubuntu 22.04

## Paketindex aktualisieren
sudo apt update

## Abhängigkeiten installieren
sudo apt install apt-transport-https ca-certificates curl software-properties-common

## Offiziellen Docker GPG-Schlüssel hinzufügen
curl -fsSL | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

## Stable-Repository einrichten
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg]  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

## Docker Engine installieren
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

Überprüfung der Docker-Installation

## Docker-Version prüfen
docker --version

## Docker-Installation testen
sudo docker run hello-world

Wichtige Docker-Komponenten

Docker Client: Befehlszeilenschnittstelle zur Interaktion mit Docker
Docker Daemon: Hintergrunddienst, der Container und Images verwaltet
Docker Images: Schreibgeschützte Vorlagen zur Erstellung von Containern
Docker Container: Laufende Instanzen von Docker-Images

Grundlegende Docker-Befehle

## Liste der laufenden Container anzeigen
docker ps

## Liste aller Container anzeigen
docker ps -a

## Ein Image ziehen
docker pull ubuntu

## Einen Container starten
docker run -it ubuntu /bin/bash

Docker-Image-Erstellung

Docker-Images verstehen

Docker-Images sind schreibgeschützte Vorlagen, die als Grundlage für die Erstellung von Containern dienen. Sie enthalten alles, was zum Ausführen einer Anwendung benötigt wird, einschließlich Code, Laufzeitumgebung, Bibliotheken und Systemtools.

Dockerfile-Grundlagen

Ein Dockerfile ist eine Textdatei, die Anweisungen zum Erstellen eines Docker-Images enthält. Jede Anweisung erstellt eine neue Schicht im Image.

graph TD
    A[Dockerfile] --> B[Basis-Image]
    A --> C[Anwendung Dateien kopieren]
    A --> D[Abhängigkeiten installieren]
    A --> E[Umgebung konfigurieren]
    A --> F[Startbefehl definieren]

Beispiel-Dockerfile für eine Python-Anwendung

## Verwendung des offiziellen Python-Laufzeitumgebungs-Basis-Images
FROM python:3.9-slim

## Arbeitsverzeichnis im Container setzen
WORKDIR /app

## requirements.txt-Datei kopieren
COPY requirements.txt .

## Notwendige Pakete installieren
RUN pip install --no-cache-dir -r requirements.txt

## Anwendungscode kopieren
COPY . .

## Portnummer spezifizieren
EXPOSE 5000

## Befehl zum Ausführen der Anwendung definieren
CMD ["python", "app.py"]

Image-Erstellungsstrategien

Strategie	Beschreibung	Anwendungsfall
Einstufiger Build	Einfache, direkte Builds	Kleine, unkomplizierte Anwendungen
Mehrstufiger Build	Optimierung von Imagegröße und Sicherheit	Komplexe Anwendungen mit Build-Abhängigkeiten

Beispiel für einen mehrstufigen Build

## Stufe 1: Build-Stufe
FROM maven:3.8.1-openjdk-11 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn package

## Stufe 2: Laufzeit-Stufe
FROM openjdk:11-jre-slim
WORKDIR /app
COPY --from=build /app/target/myapp.jar .
EXPOSE 8080
CMD ["java", "-jar", "myapp.jar"]

Docker-Images erstellen und verwalten

## Image erstellen
docker build -t myapp:v1 .

## Lokale Images auflisten
docker images

## Image entfernen
docker rmi myapp:v1

## Image taggen
docker tag myapp:v1 myregistry/myapp:latest

Optimierungsmethoden für Images

Verwendung minimaler Basis-Images
Minimierung der Schichtanzahl
Nutzung des Build-Cache
Entfernen unnötiger Dateien
Verwendung der .dockerignore-Datei

Docker-Image-Schichten

graph TD
    A[Basis-Image-Schicht] --> B[Abhängigkeits-Installationsschicht]
    B --> C[Anwendungsschicht]
    C --> D[Konfigurationsschicht]
    D --> E[Eingangs-Schicht]

Container-Verwaltung

Container-Lebenszyklus-Verwaltung

Docker-Container haben einen komplexen Lebenszyklus mit mehreren Zuständen und Verwaltungsstrategien. Das Verständnis dieser Zustände ist entscheidend für eine effektive Container-Orchestrierung.

graph LR
    A[Erstellt] --> B[Läuft]
    B --> C[Pausiert]
    B --> D[Angehalten]
    D --> E[Entfernt]

Grundlegende Container-Operationen

Operation	Befehl	Beschreibung
Start	`docker start <container>`	Einen angehaltenen Container starten
Stopp	`docker stop <container>`	Einen laufenden Container sauber stoppen
Neustart	`docker restart <container>`	Einen Container stoppen und starten
Entfernen	`docker rm <container>`	Einen Container löschen

Erweiterte Container-Verwaltung

## Container im losgelösten Modus ausführen
docker run -d --name webserver nginx

## Containerdetails anzeigen
docker inspect webserver

## Container-Logs anzeigen
docker logs webserver

## Befehle innerhalb eines laufenden Containers ausführen
docker exec -it webserver /bin/bash

Ressourcenverwaltung und Einschränkungen

## CPU und Speicher begrenzen
docker run -d \
  --cpus="1.5" \
  --memory="512m" \
  --name limited-container \
  nginx

Container-Netzwerke

graph TD
    A[Host-Netzwerk] --> B[Bridge-Netzwerk]
    B --> C[Benutzerdefiniertes Netzwerk]
    C --> D[Overlay-Netzwerk]

Beispiel für die Netzwerkkonfiguration

## Benutzerdefiniertes Netzwerk erstellen
docker network create myapp-network

## Container im benutzerdefinierten Netzwerk ausführen
docker run -d --network=myapp-network --name db postgres
docker run -d --network=myapp-network --name webapp nginx

Skalierung von Containern

## Verwenden Sie Docker Compose für die Skalierung
version: '3'
services:
webapp:
image: nginx
deploy:
replicas: 5

Leistungsüberwachung

## Echtzeit-Containerstatistiken
docker stats

## Liste der laufenden Container mit Ressourcenverbrauch
docker ps -q | xargs docker stats --no-stream

Container-Backup und -Migration

## Container als Tar-Archiv exportieren
docker export container_name > container.tar

## Container aus dem Archiv importieren
docker import container.tar new_image_name

Zusammenfassung

In diesem umfassenden Tutorial haben Sie gelernt, wie Sie effiziente Docker-Images mithilfe von Dockerfiles erstellen. Sie haben die Grundlagen von Docker-Images und Dockerfiles erkundet und Techniken zur Optimierung von Dockerfile-Layern, zur Verwaltung des Docker-Image-Cache und zur Nutzung von Multi-Stage-Builds entdeckt. Indem Sie diese Best Practices befolgen, können Sie Docker-Images erstellen, die kleiner, schneller zu erstellen und einfacher zu warten sind, was letztendlich Ihre Docker-basierten Anwendungsentwicklungs- und Bereitstellungs-Workflows verbessert.