10 Docker-projectideeën: van beginner tot gevorderd

Docker-projecten op gemiddeld niveau

De volgende projecten zijn voor wie de basis van Docker goed beheerst. Ze introduceren complexere concepten, zoals multi-stage builds en optimalisatietechnieken.

Project 4: Multi-stage build voor een Node.js-applicatie

Multi-stage builds helpen de grootte van Docker-images te verkleinen door de build- en runtime-omgevingen te scheiden. In dit project dockerize je een Node.js-applicatie met behulp van multi-stage builds.

Moeilijkheidsgraad: Gemiddeld

Gebruikte technologieën: Docker, Node.js, Nginx

Stapsgewijze instructies

• Maak een eenvoudige Node.js-app: Schrijf een basis-Node.js-server die een eenvoudig bericht teruggeeft. Hier is een voorbeeld:

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'));

• Schrijf de Dockerfile met multi-stage build: De eerste fase bouwt de app, en de tweede fase draait de app met een lichtere basisimage.

# 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"]

• Bouw de image:

docker build -t node-multi-stage .

• Draai de container:

docker run -p 3000:3000 node-multi-stage

Project 5: Een machinelearningmodel dockerizen met TensorFlow

In dit project containerize je een machinelearningmodel met TensorFlow. Het doel is een draagbare omgeving te maken waarin je TensorFlow-modellen op verschillende systemen kunt draaien zonder je zorgen te maken over de onderliggende setup.

Moeilijkheidsgraad: Gemiddeld

Gebruikte technologieën: Docker, TensorFlow, Python

Stapsgewijze instructies

• Installeer TensorFlow in een Python-script: Maak een Python-script model.py dat een voorgetraind TensorFlow-model laadt en draait:

import tensorflow as tf
model = tf.keras.applications.MobileNetV2(weights='imagenet')
print("Model loaded successfully")

• Schrijf de Dockerfile: Definieer de omgeving voor TensorFlow binnen Docker:

FROM tensorflow/tensorflow:latest
WORKDIR /app
COPY . .
CMD ["python", "model.py"]

• Bouw de image:

docker build -t tensorflow-model .

• Draai de container:

docker run tensorflow-model

Project 6: Een data science-omgeving maken met Jupyter en Docker

Dit project richt zich op het creëren van een reproduceerbare data science-omgeving met Docker en Jupyter Notebooks. De omgeving bevat populaire Python-bibliotheken zoals pandas, NumPy en scikit-learn.

Moeilijkheidsgraad: Gemiddeld

Gebruikte technologieën: Docker, Jupyter, Python, scikit-learn

Stapsgewijze instructies

• Maak het bestand docker-compose.yml: Definieer de Jupyter Notebook-service en de benodigde bibliotheken. Hier is een voorbeeld:

version: '3'
services:
  jupyter:
    	image: jupyter/scipy-notebook
    	ports:
    	- "8888:8888"
    	volumes:
    	- ./notebooks:/home/joelwembo/work

• Start de Jupyter Notebook: Gebruik Docker Compose om de Jupyter Notebook te starten.

docker-compose up

• Open de Jupyter Notebook: Open je browser en ga naar http://localhost:8888.

Docker-projecten voor gevorderden

Deze projecten voor gevorderden focussen op realistische toepassingen en geavanceerde Docker-concepten, zoals deep learning-pijplijnen en geautomatiseerde datapijplijnen.

Project 7: De grootte van een Docker-image verkleinen voor een Python-applicatie

In dit project optimaliseer je een Docker-image voor een Python-app door minimale basisimages zoals Alpine Linux te gebruiken en multi-stage builds toe te passen om de image zo klein mogelijk te houden.

Moeilijkheidsgraad: Gevorderd

Gebruikte technologieën: Docker, Python, Alpine Linux

Stapsgewijze instructies

• Schrijf het Python-script: Maak een script dat data analyseert met pandas. Hier is een voorbeeldscript:

import pandas as pd
df = pd.read_csv('data.csv')
print(df.head())

• Optimaliseer de Dockerfile: Gebruik multi-stage builds en Alpine Linux om een lichtgewicht image te maken.

# 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"]

• Bouw de image:

docker build -t optimized-python-app .

Project 8: Een deep learning-pijplijn dockerizen met PyTorch

In dit project containerize je een deep learning-pijplijn met PyTorch. De focus ligt op het optimaliseren van de Dockerfile voor prestaties en grootte, zodat je deep learning-modellen eenvoudig in verschillende omgevingen kunt draaien.

Moeilijkheidsgraad: Gevorderd

Gebruikte technologieën: Docker, PyTorch, Python

Stapsgewijze instructies

• Installeer PyTorch in een Python-script: Maak een script dat een voorgetraind PyTorch-model laadt en inferentie uitvoert. Hier is een voorbeeld:

import torch
model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)
print("Model loaded successfully")

• Schrijf de Dockerfile: Definieer de omgeving voor 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"]

• Bouw de image:

docker build -t pytorch-model .

• Draai de container:

docker run pytorch-model 

Project 9: Datapijplijnen automatiseren met Apache Airflow en Docker

In dit project zet je een Apache Airflow-omgeving op en containerize je die om datapijplijnen te automatiseren. Apache Airflow is een populaire tool voor het orkestreren van complexe workflows die veel wordt gebruikt in data engineering.

Moeilijkheidsgraad: Gevorderd

Gebruikte technologieën: Docker, Apache Airflow, Python, PostgreSQL

Stapsgewijze instructies

• Maak het bestand docker-compose.yml: Definieer de Airflow-services en de PostgreSQL-database:

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:

• Start de Airflow-omgeving: Gebruik Docker Compose om de Airflow-omgeving op te starten:

docker-compose up

• Open de Airflow-UI: Open je browser en ga naar http://localhost:8080.

Project 10: Een data science-API deployen met FastAPI en Docker

Bouw en deploy een data science-API met FastAPI. Je containerize de API met Docker en focust op optimalisatie voor productieomgevingen.

Moeilijkheidsgraad: Gevorderd

Gebruikte technologieën: Docker, FastAPI, Python, scikit-learn

Stapsgewijze instructies

• Schrijf de FastAPI-applicatie: Maak een eenvoudige API die een machinelearningmodel gebruikt voor voorspellingen. Hier is een voorbeeld:

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)}

• Schrijf de Dockerfile: Maak een Dockerfile die de omgeving voor FastAPI definieert:

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"]

• Bouw de image:

docker build -t fastapi-app .

• Draai de container:

docker run -p 8000:8000 fastapi-app

Tips voor het werken aan Docker-projecten

Houd tijdens deze projecten de volgende tips in gedachten:

• Begin klein: Start met licht uitdagende projecten en ga dan door naar complexere taken. Zelfvertrouwen opbouwen met eenvoudiger werk is cruciaal.
• Documenteer je voortgang: Houd een gedetailleerd logboek bij van je projecten om je leerproces te volgen en als naslag voor toekomstige projecten.
• Sluit je aan bij Docker-communities: Doe mee aan online fora en lokale meetups om ervaringen te delen, vragen te stellen en van anderen te leren.
• Experimenteer en pas aan: Wees niet bang om de projecten aan te passen, andere aanpakken te proberen en nieuwe Docker-features te verkennen.
• Blijf leren: Breid je Docker-kennis uit door geavanceerde topics en tools te verkennen zoals Kubernetes, Docker Swarm of microservices-architectuur.

Conclusie

Docker beheersen is meer dan alleen commando’s en configuraties leren. Het gaat erom te begrijpen hoe Docker past binnen moderne applicatieontwikkeling, data science-workflows en infrastructuurbeheer.

De projecten in deze gids geven je ideeën om de basisvaardigheden en praktische ervaring op te bouwen die je uiteindelijk in realistische scenario’s laten uitblinken.

Op dit punt raad ik aan je kennis te versterken met deze cursussen:

• Intermediate Docker
• Introduction to Kubernetes