Erstellen Ihres ersten Docker-Images: Ein umfassender Leitfaden

Im Zeitalter von Cloud Computing und Mikroservices ist Docker zu einer führenden Plattform für das Erstellen, Bereitstellen und Verwalten von Anwendungen in Containern geworden. Die Möglichkeit, Anwendungen und ihre Abhängigkeiten in einem einzigen Image zu verpacken, sorgt für konsistente Umgebungen über Entwicklung, Test und Produktion hinweg. In diesem Artikel werden wir den Prozess der Erstellung Ihres ersten Docker-Images erkunden, zusammen mit Best Practices, häufigen Fallstricken und fortgeschrittenen Techniken.

Was ist Docker?

Docker ist eine Open-Source-Plattform, die die Bereitstellung von Anwendungen in Software-Containern automatisiert. Ein Container ist ein leichtgewichtiges, eigenständiges, ausführbares Paket, das alles enthält, was zum Ausführen einer Software benötigt wird, einschließlich Code, Laufzeitumgebung, Bibliotheken und Systemtools. Diese Kapselung stellt sicher, dass die Anwendung zuverlässig in verschiedenen Computing-Umgebungen läuft.

Schlüsselkonzepte

Bevor wir uns mit der Erstellung von Docker-Images befassen, ist es wichtig, einige grundlegende Konzepte zu verstehen:

• Docker-Image: A read-only template used to create containers. Images can be built from a Dockerfile or pulled from a Docker registry.
• Docker-ContainerEine laufende Instanz eines Docker-Images. Container sind voneinander und vom Host-System isoliert.
• Dockerfile: Eine Textdatei, die Anweisungen enthält, wie ein Docker-Image erstellt werden kann. Jede Anweisung in der Dockerfile erstellt eine Ebene im Image.
• Docker Registry: Eine Sammlung zum Speichern und Teilen von Docker-Images. Das bekannteste Register ist Docker Hub.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie Folgendes haben:

1. Docker InstalliertStellen Sie sicher, dass Docker auf Ihrem Rechner installiert ist. Überprüfen Sie die offizielle Dokumentation. Docker-Installationsanleitung für detaillierte Schritte.
2. Grundverständnis der Kommandozeile: Familiarity with command-line interfaces (CLI) is necessary for executing Docker commands.
3. Text Editor: Jeder Texteditor funktioniert, aber die Vertrautheit mit Code-Editoren wie Visual Studio Code oder Sublime Text kann Ihr Erlebnis verbessern.

Schritt 1: Erstellen einer einfachen Anwendung

Für diese Anleitung erstellen wir eine einfache Python-Webanwendung mit Flask, einem leichtgewichtigen Web-Framework. Befolgen Sie diese Schritte:

1. Set Up the Project Structure

Erstellen Sie ein Verzeichnis für Ihr Projekt:

mkdir my-flask-app
cd my-flask-app

Inside this directory, create the following files:

• app.py: Die Hauptanwendungsdatei.
• requirements.txtEine Datei mit der Auflistung der erforderlichen Python-Pakete.

2. Schreiben Sie die Flask-Anwendung

Öffne app.py in your text editor and add the following code:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hallo, Docker!'

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

Als Nächstes erstellen Sie die requirements.txt Datei und folgende Zeile eingeben:

Flask==2.0.1

Schritt 2: Schreiben der Dockerfile

Nachdem wir unsere Anwendung haben, besteht der nächste Schritt darin, ein Dockerfile zu schreiben, das definiert, wie wir unser Docker-Image bauen.

1. Erstellen Sie eine Dockerfile

Im selben Verzeichnis wie Ihre Anwendungsdateien erstellen Sie eine Datei mit dem Namen Dockerfile (without any extension) and add the following contents:

# Verwende das offizielle Python-Image von Docker Hub als Basis-Image
FROM python:3.9

# Arbeitsverzeichnis im Container festlegen
WORKDIR /usr/src/app

# Anforderungen-Datei in den Container kopieren
COPY requirements.txt ./

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

# Inhalte des aktuellen Verzeichnisses in den Container kopieren
COPY . .

# Port freigeben, auf dem die App läuft
EXPOSE 5000

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

Explanation of Dockerfile Instructions

• FROM python:3.9: This line specifies the base image for our application. We are using the official Python image available on Docker Hub.
• WORKDIR /usr/src/app: Legt das Arbeitsverzeichnis innerhalb des Containers fest. Alle nachfolgenden Befehle werden von diesem Speicherort aus ausgeführt.
• Kopiere requirements.txt nach ./: Kopiert die requirements.txt file from the local directory to the working directory in the container.
• RUN pip install --no-cache-dir -r requirements.txt: Führt einen Befehl aus, um die erforderlichen Pakete zu installieren. Der ohne Cache-Verzeichnis option helps to keep the image smaller by avoiding the caching of installation files.
• COPY . .: Copies all the files from the local directory to the working directory in the container.
• EXPOSE 5000Dokumentiert den Port, auf dem die Anwendung läuft, sodass Benutzer wissen, auf welchen Port sie zugreifen müssen.
• CMD ["python", "app.py"]: Gibt den Standardbefehl an, der ausgeführt wird, wenn ein Container aus dem Image gestartet wird.

Step 3: Building the Docker Image

Nachdem wir unsere Dockerfile geschrieben haben, können wir nun unser Docker-Image erstellen. Führen Sie den folgenden Befehl in Ihrem Terminal aus und stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden:

docker build -t my-flask-app .

Erklärung des Befehls

• docker buildDer Befehl zum Erstellen eines Docker-Images.
• -t my-flask-app: The -t flag tags the image with a name (meine Flask-App).
• .: Gibt den Build-Kontext an, der das aktuelle Verzeichnis ist.

Schritt 4: Starten des Docker-Containers

Sobald das Image erfolgreich erstellt wurde, können Sie es mit dem folgenden Befehl ausführen:

docker run -p 5000:5000 my-flask-app

Erklärung des Befehls

• docker run: The command to create and start a container from an image.
• -p 5000:5000Port 5000 auf dem Host wird auf Port 5000 im Container abgebildet, um Zugriff auf die Flask-Anwendung zu ermöglichen.
• meine Flask-App: The name of the image to run.

Nach der Ausführung dieses Befehls solltest du eine Ausgabe sehen, die anzeigt, dass die Flask-App läuft. Du kannst nun in deinem Webbrowser auf die Anwendung zugreifen, indem du zu ... navigierst. http://localhost:5000.

Schritt 5: Verwalten von Docker-Images und Containern

Auflistung von Docker-Images

To view the images currently available on your machine, use the command:

docker images

2. Auflistung laufender Container

Zum Anzeigen der aktuell laufenden Container verwenden Sie:

docker ps

3. Anhalten eines Containers

Wenn Sie einen laufenden Container stoppen müssen, können Sie seine Container-ID (die Sie von docker ps):

docker stop 

4. Removing Containers and Images

To remove a stopped container, use:

Docker-Container entfernen 

To remove an image, use:

docker rmi my-flask-app

Beste Praktiken für Docker-Images

Die Erstellung von Docker-Images mag auf den ersten Blick einfach erscheinen; die Einhaltung von Best Practices kann jedoch Effizienz, Sicherheit und Wartbarkeit erheblich verbessern.

1. Verwenden Sie offizielle Basis-Images

Always prefer official images from Docker Hub as your base images. They are regularly updated and maintained to mitigate security vulnerabilities.

2. Minimize the Number of Layers

Jede Anweisung in einer Dockerfile erstellt eine Schicht im Image. Um Ihre Images schlank zu halten, kombinieren Sie Befehle, wo möglich. Zum Beispiel zusammenführen. KOPIE Befehle beim Kopieren mehrerer Dateien.

3. Clean Up Intermediate Files

Wenn Ihr Build-Prozess temporäre Dateien generiert, entfernen Sie diese, um die Image-Größe klein zu halten. Zum Beispiel, nachdem Sie Pakete installiert haben, räumen Sie den Cache auf.

4. Use .dockerignore

Just like .gitignore, die .dockerignore file can be used to exclude files and directories from the Docker build context, helping to reduce the build context size.

5. Pin Dependency Versions

Geben Sie immer die genaue Version Ihrer Abhängigkeiten in Ihrer requirements.txt um unerwartete Änderungen oder Inkompatibilitäten beim erneuten Erstellen des Images zu vermeiden.

Fortgeschrittene Techniken

Sobald Sie sich mit den Grundlagen vertraut gemacht haben, möchten Sie vielleicht einige erweiterte Techniken erkunden, die Ihre Docker-Erfahrung weiter verbessern können.

1. Multi-Stage Builds

Mehrstufige Builds ermöglichen es Ihnen, die finale Image-Größe durch die Verwendung mehrerer Stufen zu reduzieren. FROM Anweisungen in einer Dockerfile. Diese Technik eignet sich für das Kompilieren von Anwendungen, bei denen eine Build-Umgebung benötigt wird, die sich von der Produktionsumgebung unterscheidet.

# Erste Stufe: Erstellen
FROM python:3.9 AS builder

WORKDIR /usr/src/app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

# Zweite Stufe: Produktion
FROM python:3.9

WORKDIR /usr/src/app
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY . .

EXPOSE 5000
CMD ["python", "app.py"]

2. Docker Compose

Bei der Arbeit mit mehrcontainerigen Anwendungen ist Docker Compose ein unverzichtbares Werkzeug. Es ermöglicht Ihnen, mehrcontainerige Docker-Anwendungen mit einer einfachen YAML-Datei zu definieren und auszuführen. docker-compose.yml file to define your application services, networks, and volumes.

3. Versionierung Ihrer Bilder

Es ist eine gute Praxis, Ihre Docker-Images zu versionieren, um Verwirrung zu vermeiden. Verwenden Sie semantische Versionierung (z. B.,)., my-flask-app:1.0.0) to label different releases and ensure that you can roll back to previous versions if necessary.

Fazit

Die Erstellung Ihres ersten Docker-Images kann eine Welt voller Möglichkeiten für die konsistente und effiziente Bereitstellung von Anwendungen eröffnen. Indem Sie die Schritte in dieser Anleitung befolgen und bewährte Verfahren einhalten, sind Sie auf einem guten Weg, Docker zu meistern. Während Sie sich fortgeschrittenen Techniken widmen, wird das Potenzial zur Optimierung und Skalierung Ihrer Anwendungen weiter wachsen.

Docker not only simplifies deployment but also enhances collaboration across development teams, allowing for a smoother transition from development to production. Whether you are developing microservices or monolithic applications, Docker is an essential tool in modern software development workflows.

Während Sie Ihre Reise fortsetzen, nehmen Sie den Lernprozess an, experimentieren Sie mit verschiedenen Konfigurationen und nutzen Sie die umfangreiche Community-Unterstützung, die verfügbar ist. Viel Spaß beim Dockern!