Direkt zum Inhalt
HeimDer blogDatentechnik

10 Ideen für Docker-Projekte: Von Anfängern bis Fortgeschrittenen

Lerne Docker mit diesen praktischen Projektideen für alle Fähigkeitsstufen, vom Anfänger bis zum Fortgeschrittenen, die sich auf das Erstellen und Optimieren von Data Science-Anwendungen konzentrieren.
Aktualisierte 9. Okt. 2024  · 22 Min. lesen

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 nur pandas:
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

Werde Dateningenieur

Werde ein Dateningenieur durch fortgeschrittenes Python-Lernen
Kostenloses Lernen Beginnen

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

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

Beweise deine Fähigkeiten als einsatzbereiter Datentechniker.

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.

Themen

Lerne mehr über Docker mit diesen Kursen!

Zertifizierung verfügbar

Course

Einführung in Docker

4 hr
19.3K
Erhalte eine Einführung in Docker und entdecke seine Bedeutung im Werkzeugkasten von Datenexperten. Erfahre mehr über Docker Container, Images und mehr.
See DetailsRight Arrow
Start Course
Mehr anzeigenRight Arrow