Dockerfile mit Ubuntu: Ein umfassender Leitfaden von Anfänger bis Fortgeschrittene für das Erstellen von Docker-Images

1. Einführung

Was sind Docker und Dockerfiles?

In den letzten Jahren hat Docker rasch an Popularität gewonnen als effiziente Methode, um Entwicklungsumgebungen und die Bereitstellung von Anwendungen zu optimieren. Docker verpackt Anwendungen und ihre Abhängigkeiten in eine einzige Einheit namens „Container“, die konsistent in verschiedenen Umgebungen ausgeführt werden kann.

Um diese Docker-Container zu erstellen, ist ein Bauplan namens Dockerfile erforderlich. Ein Dockerfile ist eine Textdatei, die das Basis-Betriebssystem-Image, installierte Software, Umgebungsvariablen und andere Konfigurationsdetails definiert. Entwickler können es verwenden, um automatisch angepasste Umgebungen zu erstellen.

Warum Ubuntu als Basis-Image verwenden?

Beim Erstellen eines Dockerfiles ist der erste Schritt die Auswahl eines Basis-Betriebssystem-Images. Unter den vielen verfügbaren Optionen ist Ubuntu eines der beliebtesten. Ubuntu ist eine auf Debian basierende Linux-Distribution, die für ihre Benutzerfreundlichkeit und flexible Umgebungseinrichtung bekannt ist, unterstützt durch ein umfangreiches Paket-Ökosystem.

Ubuntu-basierte Dockerfiles bieten mehrere Vorteile:

• Umfangreiche offizielle und Community-Dokumentation, was zu einer geringen Lernkurve führt
• Einfache Installation von Paketen und Tools mit APT
• Offiziell bereitgestellte leichte und minimale Images (wie ubuntu:20.04 und ubuntu:24.04 )

Zweck dieses Artikels und Zielgruppe

Dieser Artikel konzentriert sich auf das Keyword „Dockerfile Ubuntu“ und erklärt, wie man Ubuntu-basierte Dockerfiles erstellt, auf eine Weise, die für Anfänger leicht verständlich ist.

Er deckt alles ab, von der grundlegenden Struktur eines Dockerfiles bis hin zu schrittweisen Anleitungen zum Erstellen einer Ubuntu-Umgebung, Beispielen für die Einrichtung von Anwendungs-Umgebungen wie Python und gängigen Fehlern mit ihren Lösungen.

Dieser Artikel wird empfohlen für:

• Diejenigen, die Umgebungen mit Dockerfiles zum ersten Mal erstellen möchten
• Entwickler, die reproduzierbare Entwicklungsumgebungen auf Ubuntu erstellen wollen
• Jeder, der sein Verständnis vertiefen möchte, einschließlich Troubleshooting-Techniken

2. Grundlegende Struktur eines Dockerfiles

Was ist ein Dockerfile und welche Rolle spielt es?

Ein Dockerfile ist wie ein Rezept zum Erstellen von Docker-Images. Es definiert, welches Basis-Betriebssystem verwendet werden soll, welche Software installiert werden muss und wie die Umgebung konfiguriert wird.

Durch Ausführen des Befehls docker build basierend auf dieser Datei können Sie leicht hochgradig reproduzierbare Entwicklungsumgebungen und Laufzeitumgebungen erstellen.

Vorteile der Verwendung von Dockerfiles:

• Automatisierte Umgebungseinrichtung (kein manueller Wiederholungsaufwand)
• Eliminierung von Umgebungsinkonsistenzen in der Team-Entwicklung
• Einfache Integration in CI/CD-Pipelines

Häufig verwendete Dockerfile-Anweisungen

Ein Dockerfile besteht aus mehreren Anweisungen (Direktiven). Die folgenden sind einige der am häufigsten verwendeten. Durch angemessene Kombination können Sie ein Ubuntu-basiertes Dockerfile erstellen.

Minimales Beispiel für ein Ubuntu-basiertes Dockerfile

Das Folgende ist ein sehr grundlegendes Beispiel für ein Dockerfile mit Ubuntu als Basis-Image.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    curl \
    vim

CMD ["/bin/bash"]

Dieses Dockerfile verwendet Ubuntu 24.04 als Basis-Image, installiert die Hilfsprogramme curl und vim und startet eine Bash-Shell, wenn der Container gestartet wird.

Auswahl des passenden Ubuntu-Tags

Ubuntu-Docker-Images werden im offiziellen Docker-Hub-Repository veröffentlicht. Während die Angabe von ubuntu:latest die neueste Version verwendet, wird die explizite Fixierung einer Version empfohlen.

Zum Beispiel:

• ubuntu:22.04 (LTS: Long-Term Support, Fokus auf Stabilität)
• ubuntu:24.04 (Neueste LTS, Fokus auf neue Features)

Wählen Sie die Version basierend darauf, ob Stabilität oder neue Features Ihre Priorität haben.

3. Praktisch: Erstellen eines Ubuntu-basierten Dockerfiles

Installieren erforderlicher Pakete in einer Ubuntu-Umgebung

Wenn Sie eine Ubuntu‑Umgebung mit einem Dockerfile erstellen, ist es häufig nötig, zusätzliche Pakete zu installieren. Zum Beispiel werden die folgenden Hilfsprogramme häufig beim Einrichten einer Entwicklungsumgebung verwendet:

• curl : Zum Herunterladen von Dateien und Testen von APIs
• vim : Ein leichter Texteditor
• git : Versionsverwaltungssystem
• build-essential : Wesentliche Werkzeuge zum Erstellen von C/C++‑Programmen

Um diese Pakete in einem Dockerfile zu installieren, verwenden Sie die Anweisung RUN.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    curl \
    vim \
    git \
    build-essential

Durch das vorherige Ausführen von apt-get update stellen Sie sicher, dass die neuesten Paketlisten vor der Installation abgerufen werden.

Konfiguration einer nicht‑interaktiven Installation

Unter Ubuntu kann apt-get install manchmal Benutzereingaben erfordern. Interaktive Vorgänge sind jedoch während Docker‑Builds nicht möglich. Um dies zu vermeiden, empfiehlt es sich, eine Umgebungsvariable zu setzen und den nicht‑interaktiven Modus zu aktivieren.

ENV DEBIAN_FRONTEND=noninteractive

Damit werden Eingabeaufforderungen wie die Auswahl von Locale oder Zeitzone unterdrückt und die Installation kann reibungslos fortgesetzt werden.

Reduzierung der Image‑Größe durch Entfernen unnötigen Caches

Bei der Verwendung von APT können heruntergeladene temporäre Dateien (Cache) im Image verbleiben und dessen Endgröße erhöhen. Sie können die Image‑Größe reduzieren, indem Sie den Cache wie folgt entfernen:

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

Das Kombinieren mehrerer Befehle in einer einzigen RUN‑Anweisung hilft ebenfalls, unnötige Zunahmen von Image‑Layers zu verhindern.

Best Practices für das Schreiben von Dockerfiles

In realen Entwicklungsumgebungen werden die folgenden Dockerfile‑Best Practices breit empfohlen:

• RUN‑Anweisungen nach Möglichkeit kombinieren, um die Anzahl der Layers zu reduzieren
• Versionen und Einstellungen explizit mit ENV definieren
• Kommentare verwenden, um den Zweck jedes Schrittes klar zu beschreiben
• Unnötige Dateien mit rm und --no-install-recommends entfernen

Beispiel:

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

Dieser Ansatz führt zu einem leichteren und besser wartbaren Dockerfile.

4. Erstellen und Verifizieren von Docker‑Images

Ein Docker‑Image aus einem Dockerfile bauen

Sobald Ihr Dockerfile fertig ist, besteht der nächste Schritt darin, ein Docker‑Image zu bauen. Dies geschieht mit dem Befehl docker build. Führen Sie den folgenden Befehl im Verzeichnis aus, das Ihr Dockerfile enthält:

docker build -t my-ubuntu-image .

• Die Option -t weist dem Image einen Namen (Tag) zu. In diesem Beispiel heißt das Image my-ubuntu-image.
• Der Punkt (.) bezieht sich auf das aktuelle Verzeichnis, das das Dockerfile enthält.

Docker liest die Anweisungen im Dockerfile nacheinander und erstellt das Image entsprechend.

Das erstellte Docker‑Image prüfen

Nachdem das Image erfolgreich gebaut wurde, können Sie es mit folgendem Befehl überprüfen:

docker images

Damit wird eine Liste der lokal gespeicherten Docker‑Images angezeigt, einschließlich folgender Informationen:

• REPOSITORY (Image‑Name)
• TAG
• IMAGE ID (eindeutiger Bezeichner)
• CREATED (Erstellungsdatum)
• SIZE

Beispiel:

REPOSITORY        TAG       IMAGE ID       CREATED          SIZE
my-ubuntu-image   latest    abcd1234abcd   5 minutes ago    189MB

Damit wird bestätigt, dass das Image korrekt registriert wurde.

Einen Docker‑Container zur Verifizierung starten

Um zu prüfen, ob das erstellte Image wie erwartet funktioniert, starten Sie einen Docker‑Container mit folgendem Befehl:

docker run -it my-ubuntu-image

• Die Option -it startet eine interaktive Terminal‑Sitzung.
• Bei Erfolg erscheint ein Bash‑Prompt, der anzeigt, dass Sie sich im Ubuntu‑Container befinden.

Im Container können Sie die installierten Werkzeuge mit Befehlen wie diesen überprüfen:

curl --version
vim --version

Wenn diese Befehle korrekt funktionieren, ist Ihr Dockerfile richtig konfiguriert.

Aufräumen nicht verwendeter Images und Container

Wiederholte Builds und Experimente können nicht verwendete Docker-Images und -Container auf Ihrem System hinterlassen. Es wird empfohlen, diese regelmäßig mit den folgenden Befehlen zu bereinigen:

• Gestoppte Container entfernen:

  docker container prune
  

• Unbenutzte Images entfernen:

  docker image prune
  

• Alle nicht genutzten Daten entfernen (mit Vorsicht verwenden):

  docker system prune
  

Diese Vorgänge helfen, Plattenplatz zu sparen und potenzielle Probleme zu verhindern.

5. Fortgeschritten: Aufbau einer Python-Umgebung

Aktivieren von Python in einem Ubuntu‑basierten Dockerfile

Beim Aufbau einer Ubuntu‑Umgebung mit einem Dockerfile ermöglicht das Hinzufügen einer Python‑Laufzeitumgebung eine Vielzahl von Anwendungsfällen, einschließlich Entwicklung, Testen und maschinellem Lernen. Obwohl Python unter Ubuntu standardmäßig bereits installiert sein kann, ist es gängige Praxis, es explizit zu konfigurieren, um eine bessere Versions‑ und Paketverwaltung zu gewährleisten.

Installation von Python mit APT

Der einfachste Ansatz ist, Python über APT‑Pakete zu installieren. Nachfolgend ein Beispiel:

FROM ubuntu:24.04

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

Diese Methode liefert eine stabile System‑Python‑Version (wie Python 3.10 oder 3.12, abhängig von der Ubuntu‑Version). Sie können außerdem zusätzliche Python‑Pakete mit dem Befehl pip installieren.

Verwaltung von Python‑Versionen mit pyenv

Wenn Sie eine bestimmte Python‑Version benötigen oder zwischen mehreren Versionen wechseln möchten, wird die Verwendung von pyenv dringend empfohlen.

Das folgende Beispiel zeigt, wie man Python 3.11.6 mit pyenv in einem Dockerfile installiert:

FROM ubuntu:24.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \
    git \
    curl \
    make \
    build-essential \
    libssl-dev \
    zlib1g-dev \
    libbz2-dev \
    libreadline-dev \
    libsqlite3-dev \
    wget \
    llvm \
    libncurses5-dev \
    libncursesw5-dev \
    xz-utils \
    tk-dev \
    libffi-dev \
    liblzma-dev \
    && rm -rf /var/lib/apt/lists/*

# Install pyenv
RUN git clone https://github.com/pyenv/pyenv.git ~/.pyenv

ENV PYENV_ROOT="$HOME/.pyenv"
ENV PATH="$PYENV_ROOT/bin:$PATH"

RUN echo 'eval "$(pyenv init --path)"' >> ~/.bashrc

# Install a specific Python version
RUN pyenv install 3.11.6 && pyenv global 3.11.6

Diese Einrichtung bietet eine flexible und gut kontrollierte Python‑Umgebung.

Verwaltung von Paketen mit requirements.txt

Die meisten realen Projekte benötigen mehrere Python‑Bibliotheken. Diese Abhängigkeiten werden üblicherweise mit einer requirements.txt‑Datei verwaltet.

Erstellen Sie zunächst eine requirements.txt‑Datei im Stammverzeichnis Ihres Projekts:

flask==2.3.2
requests>=2.25.1
pandas

Verweisen Sie dann in Ihrem Dockerfile wie folgt darauf:

COPY requirements.txt /app/requirements.txt
WORKDIR /app

RUN pip install --no-cache-dir -r requirements.txt

Damit können alle benötigten Bibliotheken auf einmal installiert werden, was die Reproduzierbarkeit der Umgebung erheblich verbessert.

Bewährte Vorgehensweisen

• Beim Einsatz von Python hilft das Erstellen einer virtuellen Umgebung mit virtualenv oder venv, Abhängigkeitskonflikte zu vermeiden.
• Die Verwendung von Cache‑Unterdrückungsoptionen wie --no-cache-dir reduziert die Größe des Docker‑Images.
• Das Ausführen von pip install --upgrade pip vor der Installation von Paketen kann helfen, Installationsfehler zu vermeiden.

6. Häufige Probleme und Fehlersuche

Berechtigungsfehler

Beispiel:

Permission denied

Dieser Fehler tritt auf, wenn kopierte Dateien keine Ausführungsrechte besitzen oder wenn Dateieigentümer und Ausführungsbenutzer falsch konfiguriert sind.

Lösung:

• Datei ausführbar machen:

  RUN chmod +x script.sh
  

• Dateieigentümer bei Bedarf ändern:

  RUN chown root:root /path/to/file
  

Paket nicht gefunden oder Installationsfehler

Beispiel:

E: Unable to locate package xxx

Dieser Fehler tritt typischerweise auf, wenn apt-get update nicht ausgeführt wurde oder der Paketname falsch ist.

Lösung:

• Führen Sie immer apt-get update aus, bevor Sie Pakete installieren:

  RUN apt-get update && apt-get install -y curl
  

• Überprüfen Sie die Paketnamen und achten Sie auf Tippfehler

Netzwerkbezogene Fehler

Beispiel:

Temporary failure resolving 'deb.debian.org'

Dieser Fehler weist auf ein DNS‑Auflösungsproblem während des Build‑Vorgangs hin.

Lösung:

• Ein Neustart des Docker‑Daemons kann das Problem beheben:

  sudo systemctl restart docker
  

• Überprüfen Sie die Docker‑DNS‑Einstellungen, indem Sie DNS‑Server in /etc/docker/daemon.json hinzufügen:

  {
    "dns": ["8.8.8.8", "8.8.4.4"]
  }
  

Build mit veraltetem Cache

Docker verwendet schichtbasiertes Caching, um Builds zu beschleunigen. Dadurch werden Änderungen an einer Dockerfile nicht immer sofort wirksam.

Lösung:

• Neu bauen ohne Cache:

  docker build --no-cache -t my-image .
  

Container beendet sich sofort oder Startbefehl wird nicht ausgeführt

Ursachen:

• Der in CMD oder ENTRYPOINT angegebene Befehl enthält einen Fehler
• Die Verwendung von CMD ["/bin/bash"] ohne interaktiven Modus führt zu einem sofortigen Beenden

Lösung:

• Starten Sie den Container im Debug‑Modus:

  docker run -it my-image /bin/bash
  

• Verstehen Sie die Unterschiede zwischen CMD und ENTRYPOINT und verwenden Sie sie entsprechend

Durch das Erkennen und Beheben dieser Probleme werden Ihre Fähigkeiten im Entwerfen von Dockerfiles stetig besser. Wenn Fehler auftreten, lesen Sie die Fehlermeldungen sorgfältig und ermitteln Sie, welche Anweisung und welche Schicht das Problem verursacht haben.

7. Zusammenfassung

Wichtige Erkenntnisse für das Erstellen von Ubuntu‑basierten Dockerfiles

Dieser Artikel bietet eine schrittweise Erklärung, wie man Ubuntu‑Umgebungen mit Dockerfiles erstellt, und deckt sowohl grundlegende als auch fortgeschrittene Themen ab. Lassen Sie uns die wichtigsten Punkte noch einmal durchgehen:

• Dockerfile‑Grundlagen verstehen ist der erste Schritt – Anweisungen wie FROM, RUN, CMD und ENV ermöglichen die automatisierte Erstellung von Umgebungen.
• Ubuntu ist ein stabiles und flexibles Basis‑Image – Sein umfangreiches Paket‑Ökosystem, die große Nutzerbasis und die LTS‑Versionen machen es ideal für Entwicklungsumgebungen.
• Praktisches Paketmanagement erlaubt die Installation notwendiger Werkzeuge und Bibliotheken – Der korrekte Einsatz von apt-get, das Aufräumen des Caches und nicht‑interaktive Installationen sind essenziell.
• Praktische Umgebungen wie Python lassen sich vollständig mit Dockerfiles realisieren – Werkzeuge wie pyenv, pip und requirements.txt sorgen für reproduzierbare Setups.
• Fehlerbehebungskompetenzen wirken sich direkt auf stabile Abläufe aus – Das Verständnis von Berechtigungen, Netzwerk und Build‑Cache‑Verhalten steigert die Produktivität erheblich.

Nächste Schritte beim Dockerfile‑Lernen

Sobald Sie sich mit Dockerfiles sicher fühlen, können Sie Ihre Fähigkeiten über die Entwicklung hinaus auf Tests und Produktions‑Deployments ausweiten. Erwägen Sie, die folgenden Themen zu erkunden:

• Verwaltung von Multi‑Container‑Setups mit Docker Compose
• Integration mit CI/CD‑Tools wie GitHub Actions und GitLab CI
• Arbeit mit Container‑Orchestrierungsplattformen wie Kubernetes

Offizielle Dokumentation und Referenzlinks

• Docker Official Documentation (Japanese)
• Docker Hub – Official Ubuntu Images
• pyenv GitHub Repository

8. FAQ (Häufig gestellte Fragen)

Q1. Welche Ubuntu‑Version sollte ich in einer Dockerfile wählen?

A1. In den meisten Fällen wird empfohlen, eine LTS‑Version (Long Term Support) zu wählen, da sie Stabilität und langfristige Wartung bietet. Versionen wie ubuntu:22.04 und ubuntu:20.04 sind weit verbreitet und werden fünf Jahre lang unterstützt.

Wenn Sie die neuesten Pakete oder Sprachversionen benötigen, können Sie eine neuere Version wie ubuntu:24.04 wählen, jedoch sollte diese gründlich getestet werden.

Q2. Warum meldet apt-get install „Paket nicht gefunden“?

A2. Der häufigste Grund ist, dass apt-get update nicht vorher ausgeführt wurde. Ohne die Aktualisierung der Paketliste kann APT die gewünschten Pakete nicht finden.

Korrektes Beispiel:

RUN apt-get update && apt-get install -y curl

Stellen Sie außerdem sicher, dass Paketnamen korrekt und nicht veraltet sind (z. B. verwenden Sie python3 anstelle von python).

Q3. Wie setze ich Umgebungsvariablen in einem Dockerfile?

A3. Verwenden Sie die Anweisung ENV, um Umgebungsvariablen zu definieren, die sowohl während der Build‑Zeit als auch zur Laufzeit des Containers verfügbar sind.

Beispiel:

ENV DEBIAN_FRONTEND=noninteractive

Dies wird häufig verwendet, um interaktive Eingabeaufforderungen bei APT‑Installationen zu unterdrücken. Umgebungsvariablen sind zudem nützlich für die Anwendungs‑Konfiguration und API‑Schlüssel.

Q4. Was ist der Unterschied zwischen CMD und ENTRYPOINT?

A4. Beide geben Befehle an, die beim Start eines Containers ausgeführt werden, aber ihr Verhalten unterscheidet sich.

Beispiel:

CMD ["python3", "app.py"]
# vs
ENTRYPOINT ["python3"]
CMD ["app.py"]

Im letzteren Fall können Sie Argumente mit docker run my-image another_script.py übergeben.

Q5. Warum werden meine Dockerfile-Änderungen nicht übernommen?

A5. Docker verwendet einen Build‑Cache, wodurch unveränderte Schichten selbst nach einer Änderung am Dockerfile erneut verwendet werden können.

Lösung:

docker build --no-cache -t my-image .

Dies erzwingt einen kompletten Neuaufbau und stellt sicher, dass alle Änderungen übernommen werden.