Course
10 Ideen für Docker-Projekte: Von Anfängern bis Fortgeschrittenen
Praktische Erfahrung ist unerlässlich, um Docker zu beherrschen. Docker ist ein zentrales Werkzeug in der modernen Softwareentwicklung und Datenwissenschaft, mit dem du Anwendungen in Containern erstellen, bereitstellen und verwalten kannst.
In diesem Artikel stelle ich Beispiele für Docker-Projekte für Anfänger, Fortgeschrittene und Profis vor, die sich auf mehrstufige Builds, die Optimierung von Docker-Images und die Anwendung von Docker in der Datenwissenschaft konzentrieren. Diese Projekte sind dazu gedacht, dein Verständnis von Docker zu vertiefen und deine praktischen Fähigkeiten zu verbessern.
Erste Schritte mit Docker-Projekten
Bevor du dich in die Projekte stürzt, solltest du sicherstellen, dass du Docker auf deinem Rechner installiert hast. Abhängig von deinem Betriebssystem (Windows, macOS, Linux) kannst du Docker von der offiziellen Docker-Website herunterladen.
Du brauchst außerdem ein grundlegendes Verständnis von:
- Dockerfiles (um zu definieren, was sich in deinen Containern befindet)
- Docker Compose (für Anwendungen mit mehreren Containern)
- Grundlegende CLI-Befehle wie
docker build
,docker run
,docker-compose up
, etc.
Wenn du deine Kenntnisse zu den oben genannten Konzepten auffrischen möchtest, schau dir die Kurse Einführung in Docker oder Containerisierung und Virtualisierungskonzepte an.
Lass uns loslegen!
Docker-Projekte für Einsteiger
Wenn du mit Docker anfängst, ist es wichtig, dass du Projekte auswählst, die deinem Kenntnisstand entsprechen und dich herausfordern, neue Konzepte zu lernen. Hier sind einige Projektideen, die dir den Einstieg erleichtern:
Projekt 1: Einen einfachen Webserver einrichten
In diesem Projekt wirst du einen Docker-Container erstellen, der einen einfachen Webserver mit Nginx betreibt. Nginx ist einer der beliebtesten Open-Source-Webserver für Reverse Proxy, Lastverteilung und mehr. Am Ende dieses Projekts wirst du gelernt haben, wie du mit Docker Container erstellst und ausführst und Ports freigibst, damit die Anwendung von deinem lokalen Rechner aus zugänglich ist.
Schwierigkeitsgrad: Beginner
Verwendete Technologien: Docker, Nginx
Schritt-für-Schritt-Anleitung
- Installiere Docker: Stelle sicher, dass Docker auf deinem System installiert ist.
- Erstelle das Projektverzeichnis: Erstelle einen neuen Ordner und eine
index.html
Datei darin, die von Nginx bedient werden soll. - Schreibe das Dockerfile: Ein Dockerfile ist ein Skript, das die Umgebung des Containers definiert. Sie teilt Docker mit, welches Basis-Image es verwenden soll, welche Dateien es einbinden soll und welche Ports es freigeben soll:
FROM nginx:alpine
COPY ./index.html /usr/share/nginx/html
EXPOSE 80
- Erstelle das Docker-Image: Navigiere zu deinem Projektordner und erstelle das Bild mit:
docker build -t my-nginx-app .
- Starte den Container: Starte den Container und ordne Port 80 des Containers dem Port 8080 auf deinem Rechner zu:
docker run -d -p 8080:80 my-nginx-app
- Greife auf den Webserver zu: Öffne deinen Browser und navigiere zu http://localhost:8080, um deine erstellte Seite zu sehen.
Projekt 2: Dockerisierung eines Python-Skripts
In diesem Projekt geht es darum, ein einfaches Python-Skript zu containerisieren, das Daten aus einer CSV-Datei mithilfe der Pandas-Bibliothek verarbeitet. Ziel ist es, zu lernen, wie man Abhängigkeiten verwaltet und Python-Skripte in Docker-Containern ausführt, sodass das Skript portabel und in jeder Umgebung ausführbar ist.
Schwierigkeitsgrad: Beginner
Verwendete Technologien: Docker, Python, pandas
Schritt-für-Schritt-Anleitung
- Schreibe das Python-Skript: Erstelle ein Skript namens
process_data.py
, das eine CSV-Datei liest und verarbeitet. Hier ist ein Beispielskript:
import pandas as pd
df = pd.read_csv('data.csv')
print(df.describe())
- Erstelle eine
requirements.txt
Datei: Diese Datei listet die Python-Bibliotheken auf, die das Skript benötigt. In diesem Fall brauchen wir nurpandas
:
pandas
- Schreibe das Dockerfile: Diese Datei definiert die Umgebung für das Python-Skript:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "process_data.py"]
- Erstelle das Docker-Image:
docker build -t python-script .
- Starte den Container:
docker run -v $(pwd)/data:/app/data python-script
Projekt 3: Aufbau einer einfachen Multicontainer-Anwendung
Dieses Projekt hilft dir, dich mit Docker Compose vertraut zu machen, indem du eine Multicontainer-Anwendung erstellst. Du wirst eine einfache Webanwendung mit Flask als Frontend und MySQL als Backend-Datenbank erstellen. Mit Docker Compose kannst du mehrere Container verwalten, die zusammenarbeiten.
Schwierigkeitsgrad: Beginner
Verwendete Technologien: Docker, Docker Compose, Flask, MySQL
Schritt-für-Schritt-Anleitung
- Schreibe die Flask-Anwendung: Erstelle eine einfache Flask-App, die sich mit einer MySQL-Datenbank verbindet und eine Nachricht anzeigt. Hier ist ein Beispiel:
from flask import Flask
import mysql.connector
app = Flask(__name__)
def get_db_connection():
connection = mysql.connector.connect(
host="db",
user="root",
password="example",
database="test_db"
)
return connection
@app.route('/')
def hello_world():
connection = get_db_connection()
cursor = connection.cursor()
cursor.execute("SELECT 'Hello, Docker!'")
result = cursor.fetchone()
connection.close()
return str(result[0])
if __name__ == "__main__":
app.run(host='0.0.0.0')
- Erstelle die Datei
docker-compose.yml
: Docker Compose definiert und betreibt Docker-Anwendungen mit mehreren Containern. In dieser Datei definierst du die Flask-App und die MySQL-Datenbankdienste:
version: '3'
services:
db:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: example
MYSQL_DATABASE: test_db
ports:
- "3306:3306"
volumes:
- db_data:/var/lib/mysql
web:
build: .
ports:
- "5000:5000"
depends_on:
- db
environment:
FLASK_ENV: development
volumes:
- .:/app
volumes:
db_data:
- Schreibe das Dockerfile für Flask: Damit wird das Docker-Image für die Flask-Anwendung erstellt:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]
- Baue die Container und lass sie laufen: Verwende Docker Compose, um die gesamte Anwendung hochzufahren:
docker-compose up --build
- Rufe die Flask-App auf: Gehe in deinem Browser auf http://localhost:5000.
Werde Dateningenieur
Docker-Projekte auf mittlerer Ebene
Die folgenden Projekte sind für diejenigen, die ein solides Verständnis der Docker-Grundlagen haben. Diese führen in komplexere Konzepte ein, wie z.B. mehrstufige Builds und Optimierungstechniken.
Projekt 4: Mehrstufiger Build für eine Node.js-Anwendung
Mehrstufige Builds helfen, die Größe von Docker-Images zu reduzieren, indem sie die Build- und die Laufzeitumgebung voneinander trennen. In diesem Projekt wirst du eine Node.js-Anwendung mithilfe von mehrstufigen Builds containerisieren.
Schwierigkeitsgrad: Zwischenbericht
Verwendete Technologien: Docker, Node.js, Nginx
Schritt-für-Schritt-Anleitung
- Erstelle eine einfache Node.js-App: Schreibe einen einfachen Node.js-Server, der eine einfache Nachricht zurückgibt. Hier ist ein Beispiel:
const express = require('express');
const app = express();
app.get('/', (req, res) => res.send('Hello from Node.js'));
app.listen(3000, () => console.log('Server running on port 3000'));
- Schreibe das Dockerfile mit mehrstufigem Build: In der ersten Phase wird die App erstellt, und in der zweiten Phase wird die App mit einem helleren Basisbild ausgeführt.
# Stage 1: Build
FROM node:14 as build-stage
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
# Add the following line if there's a build step for the app
# RUN npm run build
# Stage 2: Run
FROM node:14-slim
WORKDIR /app
COPY --from=build-stage /app .
EXPOSE 3000
ENV NODE_ENV=production
CMD ["node", "server.js"]
- Baue das Bild auf:
docker build -t node-multi-stage .
- Starte den Container:
docker run -p 3000:3000 node-multi-stage
Projekt 5: Dockerisierung eines maschinellen Lernmodells mit TensorFlow
Bei diesem Projekt geht es um die Containerisierung eines maschinellen Lernmodells mit TensorFlow. Das Ziel ist es, eine portable Umgebung zu schaffen, in der du TensorFlow-Modelle auf verschiedenen Systemen ausführen kannst, ohne dich um das zugrunde liegende Setup kümmern zu müssen.
Schwierigkeitsgrad: Zwischenbericht
Verwendete Technologien: Docker, TensorFlow, Python
Schritt-für-Schritt-Anleitung
- Installiere TensorFlow in einem Python-Skript: Erstelle ein Python-Skript
model.py
, das ein vortrainiertes TensorFlow-Modell lädt und ausführt:
import tensorflow as tf
model = tf.keras.applications.MobileNetV2(weights='imagenet')
print("Model loaded successfully")
- Schreibe das Dockerfile: Definiere die Umgebung für TensorFlow in Docker:
FROM tensorflow/tensorflow:latest
WORKDIR /app
COPY . .
CMD ["python", "model.py"]
- Baue das Bild auf:
docker build -t tensorflow-model .
- Starte den Container:
docker run tensorflow-model
Projekt 6: Erstellen einer Data Science-Umgebung mit Jupyter und Docker
In diesem Projekt geht es darum, eine reproduzierbare Data-Science-Umgebung mit Docker und Jupyter-Notebooks zu schaffen. Die Umgebung wird beliebte Python-Bibliotheken wie Pandas, NumPy und Scikit-Learn enthalten.
Schwierigkeitsgrad: Zwischenbericht
Verwendete Technologien: Docker, Jupyter, Python, scikit-learn
Schritt-für-Schritt-Anleitung
- Erstelle die Datei
docker-compose.yml
: Definiere den Jupyter Notebook Service und die notwendigen Bibliotheken. Hier ist ein Beispiel:
version: '3'
services:
jupyter:
image: jupyter/scipy-notebook
ports:
- "8888:8888"
volumes:
- ./notebooks:/home/joelwembo/work
- Starte das Jupyter Notebook: Verwende Docker Compose, um das Jupyter Notebook zu starten.
docker-compose up
- Greife auf das Jupyter Notebook zu: Öffne deinen Browser und gehe auf http://localhost:8888.
Docker-Projekte für Fortgeschrittene
Diese Projekte für Fortgeschrittene konzentrieren sich auf reale Anwendungen und fortgeschrittene Docker-Konzepte wie Deep Learning Pipelines und automatisierte Datenpipelines.
Projekt 7: Die Größe eines Docker-Images für eine Python-Anwendung reduzieren
In diesem Projekt optimierst du ein Docker-Image für eine Python-Anwendung, indem du minimale Basis-Images wie Alpine Linux verwendest und mehrstufige Builds implementierst, um die Größe des Images so klein wie möglich zu halten.
Schwierigkeitsgrad: Fortgeschrittene
Verwendete Technologien: Docker, Python, Alpine Linux
Schritt-für-Schritt-Anleitung
- Schreibe das Python-Skript: Erstelle ein Skript, das Daten mit Pandas analysiert. Hier ist ein Beispielskript:
import pandas as pd
df = pd.read_csv('data.csv')
print(df.head())
- Optimiere das Dockerfile: Verwende mehrstufige Builds und Alpine Linux, um ein leichtgewichtiges Image zu erstellen.
# Stage 1: Build stage
FROM python:3.9-alpine as build-stage
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY script.py .
# Stage 2: Run stage
FROM python:3.9-alpine
WORKDIR /app
COPY --from=build-stage /app/script.py .
CMD ["python", "script.py"]
- Baue das Bild auf:
docker build -t optimized-python-app .
Projekt 8: Dockerisierung einer Deep Learning Pipeline mit PyTorch
In diesem Projekt geht es um die Containerisierung einer Deep Learning-Pipeline mit PyTorch. Der Schwerpunkt liegt auf der Optimierung des Dockerfiles hinsichtlich Leistung und Größe, damit Deep-Learning-Modelle in verschiedenen Umgebungen ausgeführt werden können.
Schwierigkeitsgrad: Fortgeschrittene
Verwendete Technologien: Docker, PyTorch, Python
Schritt-für-Schritt-Anleitung
- Installiere PyTorch in einem Python-Skript: Erstelle ein Skript, das ein vortrainiertes PyTorch-Modell lädt und Inferenzen durchführt. Hier ist ein Beispiel:
import torch
model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)
print("Model loaded successfully")
- Schreibe das Dockerfile: Definiere die Umgebung für PyTorch:
FROM pytorch/pytorch:1.9.0-cuda11.1-cudnn8-runtime
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY model.py .
CMD ["python", "model.py"]
- Baue das Bild auf:
docker build -t pytorch-model .
- Starte den Container:
docker run pytorch-model
Projekt 9: Automatisierung von Datenpipelines mit Apache Airflow und Docker
In diesem Projekt wirst du eine Apache Airflow-Umgebung einrichten und containerisieren, um Datenpipelines zu automatisieren. Apache Airflow ist ein beliebtes Tool zur Orchestrierung komplexer Workflows, das im Data Engineering weit verbreitet ist.
Schwierigkeitsgrad: Fortgeschrittene
Verwendete Technologien: Docker, Apache Airflow, Python, PostgreSQL
Schritt-für-Schritt-Anleitung
- Erstelle die Datei
docker-compose.yml
: Definiere die Airflow-Dienste und die PostgreSQL-Datenbank:
version: '3'
services:
postgres:
image: postgres:latest
environment:
POSTGRES_USER: airflow
POSTGRES_PASSWORD: airflow
POSTGRES_DB: airflow
ports:
- "5432:5432"
volumes:
- postgres_data:/var/lib/postgresql/data
webserver:
image: apache/airflow:latest
environment:
AIRFLOW__CORE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
AIRFLOW__CORE__EXECUTOR: LocalExecutor
depends_on:
- postgres
ports:
- "8080:8080"
volumes:
- ./dags:/opt/airflow/dags
command: ["webserver"]
scheduler:
image: apache/airflow:latest
environment:
AIRFLOW__CORE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
AIRFLOW__CORE__EXECUTOR: LocalExecutor
depends_on:
- postgres
- webserver
volumes:
- ./dags:/opt/airflow/dags
command: ["scheduler"]
volumes:
postgres_data:
- Starte die Airflow-Umgebung: Verwende Docker Compose, um die Airflow-Umgebung einzurichten:
docker-compose up
- Rufe die Airflow-Benutzeroberfläche auf: Öffne deinen Browser und gehe auf http://localhost:8080.
Projekt 10: Bereitstellung einer Data Science API mit FastAPI und Docker
Baue eine Data Science API mit FastAPI und setze sie ein. Du wirst die API mit Docker containerisieren und sie für Produktionsumgebungen optimieren.
Schwierigkeitsgrad: Fortgeschrittene
Verwendete Technologien: Docker, FastAPI, Python, scikit-learn
Schritt-für-Schritt-Anleitung
- Schreibe die FastAPI-Anwendung: Erstelle eine einfache API, die ein maschinelles Lernmodell für Vorhersagen verwendet. Hier ist ein Beispiel:
from fastapi import FastAPI
import pickle
app = FastAPI()
with open("model.pkl", "rb") as f:
model = pickle.load(f)
@app.post("/predict/")
def predict(data: list):
return {"prediction": model.predict(data)}
- Schreibe das Dockerfile: Erstelle ein Dockerfile, das die Umgebung für FastAPI definiert:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
- Baue das Bild auf:
docker build -t fastapi-app .
- Starte den Container:
docker run -p 8000:8000 fastapi-app
Tipps für die Arbeit an Docker-Projekten
Wenn du diese Projekte durcharbeitest, solltest du die folgenden Tipps im Hinterkopf behalten:
- Fang klein an: Beginne mit leicht anspruchsvollen Projekten und gehe dann zu komplexeren Aufgaben über. Der Aufbau von Selbstvertrauen bei einfacheren Aufgaben ist entscheidend.
- Dokumentiere deine Fortschritte: Führe ein detailliertes Protokoll über deine Projekte, um deinen Lernerfolg zu verfolgen und als Referenz für zukünftige Projekte zu verwenden.
- Tritt den Docker-Communities bei: Beteilige dich an Online-Foren und lokalen Treffen, um deine Erfahrungen zu teilen, Fragen zu stellen und von anderen zu lernen.
- Experimentiere und passe sie an: Hab keine Angst, die Projekte zu verändern, verschiedene Ansätze auszuprobieren und neue Docker-Funktionen zu erforschen.
- Lerne weiter: Erweitere dein Docker-Wissen, indem du dich mit fortgeschrittenen Themen und Tools wie Kubernetes, Docker Swarm oder Microservices-Architektur beschäftigst.
Fazit
Die Beherrschung von Docker beinhaltet mehr als nur das Erlernen von Befehlen und Konfigurationen. Es geht darum zu verstehen, wie Docker in die moderne Anwendungsentwicklung, in Data Science Workflows und in das Infrastrukturmanagement passt.
Die Projekte, die ich in diesem Leitfaden vorgestellt habe, liefern einige Ideen, um die grundlegenden Fähigkeiten und praktischen Erfahrungen aufzubauen, die du brauchst, um in der realen Welt zu bestehen.
An diesem Punkt empfehle ich dir, dein Wissen mit diesen Kursen zu vertiefen:
Werde Dateningenieur
FAQs
Was sind die besten Methoden, um effiziente Dockerdateien zu schreiben?
Zu den bewährten Praktiken für das Schreiben effizienter Dockerdateien gehören die Minimierung der Anzahl der Schichten durch die Kombination von Befehlen, die Verwendung von mehrstufigen Builds, um die Größe des Images zu reduzieren, die Auswahl von leichtgewichtigen Basis-Images, das Zwischenspeichern von Abhängigkeiten und die Vermeidung von unnötigen Dateien im endgültigen Image.
Was ist ein mehrstufiger Build in Docker?
Ein mehrstufiger Build ist eine Methode zur Optimierung von Docker-Images durch die Trennung von Build- und Laufzeitumgebung. Das Ergebnis sind kleinere, sicherere Bilder.
Wie kannst du die Größe eines Docker-Images reduzieren?
Verwende minimale Basis-Images, verwalte Abhängigkeiten effizient und verwende mehrstufige Builds, um die Imagegröße zu reduzieren und die Leistung zu verbessern.
Wie behebe ich häufige Fehler beim Erstellen von Docker-Images?
Zu den häufigen Fehlern bei der Erstellung von Docker-Images gehören Rechteprobleme, eine falsche Syntax der Dockerdatei und eine fehlgeschlagene Installation von Abhängigkeiten. Überprüfe zur Fehlerbehebung die Build-Protokolle von Docker, stelle sicher, dass du das richtige Basis-Image verwendest und dass alle Pfade und Dateiberechtigungen korrekt gesetzt sind. Tools wie docker build --no-cache
können helfen, Caching-Probleme zu erkennen.
Kann ich Docker mit Kubernetes für diese Projekte verwenden?
Ja, wenn du mit Docker vertraut bist, kann Kubernetes der nächste Schritt sein. Kubernetes hilft dabei, containerisierte Anwendungen in großem Umfang zu verwalten. Du kannst deine Docker-Projekte in einem Kubernetes-Cluster bereitstellen, um mehrere Instanzen zu verwalten, die Skalierung zu steuern und die Bereitstellung zu automatisieren.
Welche Best Practices gibt es für die Verwaltung von Docker-Volumes und persistenten Daten?
Wenn du mit Docker-Volumes arbeitest, ist es wichtig, benannte Volumes zu verwenden, um sicherzustellen, dass die Daten über Neustarts von Containern hinweg erhalten bleiben. Führe regelmäßig Backups deiner Volumes durch und beobachte, ob es zu Leistungsengpässen aufgrund von Disk-I/O kommt. Vermeide es, sensible Daten direkt in Containern zu speichern; verwende stattdessen sichere Speicherlösungen oder externe Datenbanken.
Was ist der Zweck der ENTRYPOINT-Direktive in einem Dockerfile?
Die Direktive ENTRYPOINT
in einem Dockerfile legt den Befehl fest, der immer ausgeführt wird, wenn ein Container startet. Er ermöglicht es, den Container wie eine ausführbare Datei zu behandeln, der zur Laufzeit Argumente übergeben werden können, was die Flexibilität erhöht.
Was ist der Unterschied zwischen CMD und ENTRYPOINT in einem Dockerfile?
Sowohl CMD
als auch ENTRYPOINT
geben Befehle an, die beim Start eines Containers ausgeführt werden sollen. CMD
bietet jedoch Standardargumente, die überschrieben werden können, während ENTRYPOINT
den Befehl definiert, der immer ausgeführt wird. ENTRYPOINT
ist nützlich, um Container zu erstellen, die sich wie ausführbare Dateien verhalten, während CMD
flexibler ist, um Standardbefehle festzulegen.
Lerne mehr über Docker mit diesen Kursen!
Course
Docker für Fortgeschrittene
Track