Een applicatie containerizen met Docker

Naarmate machinelearning-applicaties complexer worden, draait het bij het van development naar productie brengen van onze modellen niet alleen om goede code schrijven. Het gaat erom dat onze applicatie consistent draait in verschillende omgevingen. Dit is waar containerization om de hoek komt kijken. Maar wat is containerization precies, en waarom is het een gamechanger voor machinelearning-workflows?

Containerization is een lichte, draagbare manier om een applicatie samen met alle afhankelijkheden, libraries en configuraties te verpakken in één geheel: een container. In tegenstelling tot traditionele virtuele machines (VM’s) delen containers de kernel van het hostsysteem, waardoor ze sneller, efficiënter en makkelijker te schalen zijn. 

Voor data scientists en ML-engineers betekent dit dat je een model op je lokale machine kunt bouwen en het overal kunt uitrollen—op een cloudplatform, een server, of zelfs de laptop van een collega—zonder je zorgen te maken over compatibiliteitsproblemen.

In deze tutorial gaan we een machinelearning-applicatie containerizen met Docker en Kubernetes. Aan het einde weet je hoe je:

1. Een Docker-container bouwt voor je ML-applicatie.
2. Je gecontaineriseerde applicatie uitrolt en beheert met Kubernetes.
3. Je ML-applicatie schaalt en monitort in een productieomgeving.

Ben je nieuw met Docker? Bekijk dan onze gids Docker vanaf nul leren. Je kunt ook onze course volgen, Containerization and Virtualization with Docker and Kubernetes.  

Vereisten

Voordat je begint, is basiskennis van Python, machinelearning-workflows en werken met de command line handig. Bekendheid met Docker-concepten (zoals images, containers, basiscommando’s) is aan te raden, en basiskennis van Kubernetes is optioneel maar helpt bij uitrol en schalen. 

Wat is een gecontaineriseerde applicatie?

Een gecontaineriseerde applicatie is software die samen met alle afhankelijkheden, libraries en configuraties verpakt is in één lichtgewicht eenheid: een container. Voor machinelearning-applicaties betekent dit dat je alles verpakt—van je getrainde model tot de Python-libraries waarop het vertrouwt—zodat je applicatie overal op dezelfde manier draait.

Traditionele applicatie versus gecontaineriseerde applicatie

Waarom containerization belangrijk is voor machinelearning-applicaties

Als je ML-applicaties ontwikkelt, ben je vast het “op mijn machine werkt het”-probleem tegengekomen. Misschien draait je model perfect op je laptop maar faalt het in de cloud, of kan een collega je resultaten niet reproduceren omdat ze andere versies van scikit-learn of TensorFlow hebben geïnstalleerd. 

Containerization lost dit op door een consistente, geïsoleerde omgeving voor je applicatie te creëren. Dit maakt gecontaineriseerde applicaties beter voor ML omdat:

1. Consistentie: je applicatie gedraagt zich hetzelfde in verschillende omgevingen—van development tot test en productie.
2. Isolatie: elke container draait in een eigen omgeving, waardoor conflicten tussen applicaties of afhankelijkheden worden voorkomen.
3. Draagbaarheid: containers kunnen op elk platform draaien dat containerization ondersteunt, of dat nu lokaal is, in de cloud of on-premises.
4. Schaalbaarheid: meer requests afhandelen? Met containers schaal je horizontaal door meerdere instanties te draaien.

Containers versus virtuele machines

Hoewel zowel containers als virtuele machines (VM’s) worden gebruikt om applicaties te isoleren, verschillen ze aanzienlijk in werking en use-cases. Hier volgt een overzicht van de belangrijkste verschillen en voordelen:

Voor ML-applicaties doen deze verschillen ertoe. Als je je model wilt schalen voor meer voorspellingen, of meerdere modelversies wilt uitrollen voor A/B-tests, bieden containers de wendbaarheid en resource-efficiëntie die je nodig hebt.

Wil je meer leren over containerization en virtualisatie? Bekijk dan deze learning track: Containerization and Virtualization with Docker and Kubernetes.

Hoe containerize je een machinelearning-applicatie 

In de onderstaande secties vind je een stapsgewijze gids om een applicatie te containerizen: 

1. Je omgeving instellen

Voordat we onze ML-applicatie gaan containerizen, moeten we de benodigde tools installeren en onze omgeving voorbereiden. Deze sectie helpt je Docker te installeren en een eenvoudige ML-applicatie klaar te zetten voor containerization.

Tools die je nodig hebt

Om een ML-applicatie te containerizen, heb je het volgende nodig:

1. Docker: een platform om containers te bouwen, te distribueren en te draaien.
2. Kubernetes (optioneel): een orkestratietool om containers op schaal te beheren. (Dit behandelen we later in de tutorial.)

Laten we beginnen met het installeren van Docker.

Stap 1: Docker installeren

Docker is beschikbaar voor Windows, macOS en Linux. Hieronder staan de stappen om Docker te installeren.

Voor Windows/macOS:

1. Ga naar de Docker-website.
2. Download en installeer Docker Desktop.
3. Volg de instructies van de installer.

Voor Linux (Ubuntu/Debian):

Open je terminal en voer de volgende commando’s uit om Docker te installeren:

# Update your package list
sudo apt-get update

# Install required packages to allow apt to use a repository over HTTPS
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common

# Add Docker’s official GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add the Docker repository to your system
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update your package list again
sudo apt-get update

# Install Docker
sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# Verify Docker installation
sudo docker --version

Dit installatieproces voegt de Docker-repository toe aan je systeem, verifieert de echtheid met de GPG-sleutel en installeert de Docker-engine plus de commandlinetools.

Stap 2: Docker-installatie verifiëren 

Controleer na installatie of Docker goed werkt door dit in de command prompt te draaien:

# Check Docker version
docker --version

# Run hello-world container
docker run hello-world

Dit haalt een lichte testimage op en draait die als container. Als het lukt, zie je een welkomstbericht dat bevestigt dat je installatie werkt, zoals hieronder:

Hello from Docker!

2. Je machinelearning-applicatie voorbereiden

Nu Docker is geïnstalleerd, bereiden we een eenvoudige ML-applicatie voor op containerization. Voor deze tutorial gebruiken we een basis-Python-script dat een voorgetraind model laadt en voorspellingen serveert via een Flask-API.

Stap 1: Maak een simpele ML-applicatie

Maak een nieuwe map voor je project en voeg de volgende bestanden toe:

1. app.py: een Python-script dat voorspellingen serveert via een Flask-API.
2. requirements.txt: een bestand met de Python-afhankelijkheden.

De code voor app.py:

# Import required libraries
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from flask import Flask, request, jsonify
import numpy as np

# Initialize Flask app
app = Flask(__name__)

# Load and prepare the model
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

@app.route('/predict', methods=['POST'])
def predict():
    # Get features from request
    features = request.json['features']
    
    # Make prediction
    prediction = model.predict([features])
    
    return jsonify({'prediction': int(prediction[0]),
                   'class_name': iris.target_names[prediction[0]]})

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

De code laadt de Iris-dataset, traint een Random Forest-classificator en zet een Flask-API-endpoint op dat featurewaarden accepteert en voorspellingen teruggeeft. We bouwen dit als webservice om het geschikt te maken voor containerization.

Stap 2: Maak requirements.txt

Het bestand requirements.txt bevat de Python-libraries die nodig zijn om het script te draaien. Maak dit bestand in dezelfde map als app.py:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
flask==2.0.1

Dit specificeert de exacte versies van Python-pakketten die onze applicatie nodig heeft. Gefixeerde versies zorgen ervoor dat onze gecontaineriseerde applicatie consistent en reproduceerbaar is.

Nu onze omgeving klaar is en de ML-applicatie gereed, kunnen we onze eerste Docker-container bouwen. In de volgende sectie schrijven we een Dockerfile en bouwen we een Docker-image voor onze Flask-gebaseerde ML-applicatie.

3. Je eerste Docker-container bouwen

Nu onze ML-applicatie klaar is, gaan we deze containerizen met Docker. Dit houdt in dat we een Dockerfile maken: een script met instructies om een Docker-image te bouwen. Zodra de image gebouwd is, kunnen we die als container draaien.

Voorbeeld Dockerfile: een Dockerfile schrijven

Een Dockerfile is een tekstbestand met alle commando’s om een image samen te stellen. Zo maak je er één voor onze Flask-ML-app.

1. Maak in dezelfde map als app.py en requirements.txt een nieuw bestand aan met de naam Dockerfile (zonder extensie).
2. Voeg de volgende inhoud toe aan de Dockerfile:

# Use an official Python runtime as the base image
FROM python:3.9-slim

# Set the working directory in the container
WORKDIR /app

# Copy the requirements file into the container
COPY requirements.txt .

# Install the Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code into the container
COPY . .

# Expose port 5000 for the Flask app
EXPOSE 5000

# Define the command to run the Flask app
CMD ["python", "app.py"]

Uitleg:

• FROM python:3.9-slim: we gebruiken de officiële Python 3.9 slim-image als basis. De slim-variant is lichtgewicht en ideaal voor gecontaineriseerde apps.
• WORKDIR /app: dit stelt de werkmap binnen de container in op /app. Alle volgende commando’s draaien vanaf hier.
• COPY requirements.txt .: kopieert het bestand requirements.txt naar de container.
• RUN pip install --no-cache-dir -r requirements.txt: installeert de Python-afhankelijkheden uit requirements.txt. De vlag --no-cache-dir verkleint de image door geen cache op te slaan.
• COPY . .: kopieert alle bestanden uit de huidige map naar de map /app in de container.
• EXPOSE 5000: opent poort 5000, de poort waarop onze Flask-app luistert.
• CMD ["python", "app.py"]: definieert het commando om de Flask-app te starten wanneer de container opstart.

De Docker-image bouwen en testen

Met de Dockerfile op zijn plek kunnen we nu de image bouwen en als container draaien. 

Stap 1: Bouw de Docker-image

Draai dit commando in de terminal om de image te bouwen:

docker build -t ml-flask-app .

Dit bouwt een Docker-image op basis van de Dockerfile in de huidige map. De vlag -t ml-flask-app tagt de image met de naam ml-flask-app, zodat je die later makkelijk kunt refereren.

Stap 2: Draai de Docker-container

Als de image klaar is, draai je hem als container met:

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

Dit start een container op basis van de ml-flask-app-image. De vlag -p 5000:5000 koppelt poort 5000 op je machine aan poort 5000 in de container, zodat je de Flask-app kunt benaderen via je browser of een tool als curl.

Stap 3: Test de gecontaineriseerde applicatie

Open een nieuwe terminal en stuur een testrequest naar de Flask-app in de container:

curl -X POST -H "Content-Type: application/json" -d '{"input": [5.1, 3.5, 1.4, 0.2]}' http://localhost:5000/predict

Je zou zo’n response moeten zien:

{
  "prediction": 0
}

Dit betekent dat de gecontaineriseerde Flask-app succesvol draait en klaar is om voorspellingen te serveren.

Veelvoorkomende problemen debuggen

Loop je tegen problemen aan bij het bouwen of draaien van de container, probeer dan dit:

Bekijk Docker-logs: gebruik dit commando om logs van een draaiende container te zien:

docker logs <container_id>

Controleer de Dockerfile-syntax: check op typfouten of syntaxfouten.

Controleer poortconflicten: zorg dat poort 5000 niet al in gebruik is. Zo ja, map dan naar een andere poort, bijvoorbeeld:

docker run -p 5001:5000 ml-flask-app

Bouw de image opnieuw:

Als je wijzigingen hebt aangebracht in de Dockerfile of code, bouw de image dan opnieuw met:

docker build -t ml-flask-app .

Nu we de Docker-container succesvol hebben gebouwd en getest, is de volgende stap om te leren hoe je de gecontaineriseerde applicatie beheert en schaalt. In de volgende sectie verkennen we hoe je Kubernetes gebruikt om onze ML-app uit te rollen en te schalen.

Bekijk meer Docker-projecten in onze gids 10 Docker-projectideeën: van beginner tot gevorderd.

Je gecontaineriseerde applicatie draaien

Nu we onze Docker-container hebben gebouwd, kijken we hoe je die effectief beheert. Deze sectie behandelt essentiële Docker-commando’s om containers te starten, stoppen en inspecteren, en hoe je met logs en poorten werkt.

Containers beheren met Docker

Docker biedt krachtige commando’s om containers te beheren. Dit zijn de meest gebruikte.

Een container starten

Om een container te starten vanuit een image gebruik je docker run. Bijvoorbeeld:

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

Dit start een container van de ml-flask-app-image en koppelt poort 5000 lokaal aan poort 5000 in de container.

Wil je de container op de achtergrond draaien (detached mode), voeg dan de -d vlag toe:

docker run -d -p 5000:5000 ml-flask-app

Hiermee draait de container op de achtergrond, zodat je terminal vrij blijft.

Een container stoppen

Om een draaiende container te stoppen, zoek eerst het container-ID met:

docker ps

Dit toont alle draaiende containers met IDs, namen en details. Stop vervolgens de container met:

docker stop <container_id>

Bijvoorbeeld:

docker stop a1b2c3d4e5f6

Een container inspecteren

Gebruik docker inspect om gedetailleerde info over een container te bekijken:

docker inspect <container_id>

Dit geeft JSON-uitvoer met details zoals netwerksettings, gemounte volumes en omgevingsvariabelen.

Containers weergeven

Om alle containers te zien (draaiend en gestopt), gebruik je:

docker ps -a

Handig om de status te checken en container-ID’s te vinden.

Werken met logs en poorten

Logs en poorten zijn cruciaal voor debugging en toegang tot onze gecontaineriseerde applicatie. Zo werk je ermee.

Container-logs bekijken

De logs van een draaiende container bekijk je met:

docker logs <container_id>

Bijvoorbeeld:

docker logs a1b2c3d4e5f6

Dit toont de output van je applicatie, inclusief errors of berichten. Wil je live meekijken (zoals tail -f), voeg dan de vlag -f toe:

docker logs -f <container_id>

Poorten mappen

Bij het draaien van een container kun je containerpoorten aan lokale poorten koppelen met de vlag -p. Bijvoorbeeld:

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

Dit koppelt poort 5000 in de container aan poort 5000 lokaal. Is poort 5000 al bezet, map dan zo:

docker run -p 5001:5000 ml-flask-app

Je Flask-app is dan bereikbaar op http://localhost:5001.

Poortbindings checken

Om te zien welke poorten zijn gemapt voor een draaiende container, gebruik je:

docker port <container_id>

Dit toont de poortmappings van de container—handig bij het debuggen van connectiviteitsproblemen. In de volgende sectie bekijken we hoe je onze gecontaineriseerde ML-app op Kubernetes uitrolt en op schaal beheert.

Schalen met Kubernetes

Zodra onze applicatie gecontaineriseerd is, kunnen we die uitrollen met Kubernetes. Kubernetes automatiseert de uitrol, het schalen en het beheer van gecontaineriseerde applicaties, waardoor grootschalige workloads eenvoudiger te verwerken zijn. In deze sectie rollen we onze ML-app uit op een Kubernetes-cluster.

Containers uitrollen op Kubernetes

Kubernetes gebruikt YAML-bestanden om de gewenste toestand van je applicatie te definiëren. Deze beschrijven hoe je containers moeten worden uitgerold, geschaald en beheerd. We beginnen met een Kubernetes Deployment voor onze Flask-ML-app.

Stap 1: Schrijf een Kubernetes deployment YAML-bestand

Maak een bestand ml-flask-app-deployment.yaml met de volgende inhoud:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-flask-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-flask-app
  template:
    metadata:
      labels:
        app: ml-flask-app
    spec:
      containers:
      - name: ml-flask-app
        image: ml-flask-app
        ports:
        - containerPort: 5000

Dit YAML-bestand definieert:

•  Een Deployment met de naam ml-flask-app.
• Drie replicas van de applicatie voor hoge beschikbaarheid.
• Een container die de ml-flask-app-image gebruikt die we eerder bouwden.
• Een containerPort van 5000, de poort waarop onze Flask-app luistert.

Stap 2: De applicatie uitrollen

Rol de applicatie uit op Kubernetes met het commando kubectl apply:

kubectl apply -f ml-flask-app-deployment.yaml

Dit vertelt Kubernetes de resources in het YAML-bestand aan te maken. Je checkt de status met:

kubectl get deployments

Dit toont de status van je deployment, inclusief het aantal draaiende replicas.

Stap 3: De applicatie exposen

Maak om de applicatie buiten het cluster bereikbaar te maken een Service. Maak het bestand ml-flask-app-service.yaml met:

apiVersion: v1
kind: Service
metadata:
  name: ml-flask-app-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 5000
  selector:
    app: ml-flask-app

Dit YAML-bestand definieert:

• Een Service met de naam ml-flask-app-service.
• Type LoadBalancer, dat de app naar het internet exposeert.
• Een mapping van poort 80 (extern) naar poort 5000 (intern).

Pas de Service toe met:

kubectl apply -f ml-flask-app-service.yaml

Je bekijkt de status van de Service met:

kubectl get services

Dit toont het externe IP-adres waarop je applicatie bereikbaar is.

Schalen en monitoren

Kubernetes maakt het gemakkelijk om je applicatie te schalen en prestaties te monitoren. Zo pak je dat aan.

De applicatie schalen

Update het aantal replicas in de deployment. Om bijvoorbeeld naar 5 replicas te schalen, draai je:

kubectl scale deployment ml-flask-app --replicas=5

Je kunt ook het veld replicas in het YAML-bestand aanpassen en opnieuw toepassen:

spec:
  replicas: 5

Draai daarna:

kubectl apply -f ml-flask-app-deployment.yaml

De applicatie monitoren

Kubernetes biedt verschillende tools om te monitoren. Dit zijn er een paar.

Gebruik kubectl logs om de logs van een specifieke pod te bekijken:

kubectl logs <pod_name>
 

Gebruik kubectl get pods om de status van je pods te checken:

kubectl get pods

Gebruik kubectl top om CPU- en geheugengebruik te zien:

kubectl top pods

Autoscaling

Kubernetes ondersteunt ook Horizontal Pod Autoscaler (HPA), die automatisch het aantal pods schaalt op basis van CPU- of geheugengebruik. Inschenken met:

kubectl autoscale deployment ml-flask-app --cpu-percent=50 --min=3 --max=10

Dit zorgt dat de deployment tussen 3 en 10 replicas schaalt op basis van CPU-gebruik.

Best practices voor Kubernetes-deployments

Volg deze best practices bij het uitrollen op Kubernetes.

Gebruik resource-limieten

Definieer CPU- en geheugenlimieten om resource-uitputting te voorkomen:

resources:
   limits:
     cpu: "1"
     memory: "512Mi"

Gebruik liveness- en readiness-probes

Voeg healthchecks toe om zeker te zijn dat je app goed draait:

livenessProbe:
  httpGet:
    path: /health
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /ready
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
   

Gebruik namespaces

Organiseer resources met namespaces om conflicten te vermijden:

kubectl create namespace ml-app
kubectl apply -f ml-flask-app-deployment.yaml -n ml-app

In de volgende sectie behandelen we tips voor het optimaliseren van Dockerfiles, dependencybeheer en security.

Best practices voor het containerizen van ML-applicaties

Machinelearning-applicaties containerizen kent uitdagingen zoals grote afhankelijkheden, reproduceerbaarheid en security. Hier zijn best practices om robuuste gecontaineriseerde ML-apps te bouwen.

Dockerfiles optimaliseren

Een goed geoptimaliseerde Dockerfile verlaagt buildtijden en imagesizes aanzienlijk. Tips:

Gebruik multi-stage builds

Multi-stage builds laten je meerdere FROM-statements in één Dockerfile gebruiken. Zo verklein je de uiteindelijke image door overbodige bestanden en afhankelijkheden uit tussenstappen weg te laten. Bijvoorbeeld:

# Stage 1: Build the application
FROM python:3.9-slim as builder

WORKDIR /app
COPY requirements.txt .
RUN pip install --user -r requirements.txt

COPY . .

# Stage 2: Create the final image
FROM python:3.9-slim

WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY --from=builder /app .

ENV PATH=/root/.local/bin:$PATH
EXPOSE 5000
CMD ["python", "app.py"]

Deze Dockerfile:

• Gebruikt een builder-stage om dependencies te installeren en de app te bouwen.
• Kopieert alleen de benodigde bestanden (zoals geïnstalleerde dependencies en app-code) naar de finale image, wat de grootte reduceert.

Minimaliseer lagen

Elke instructie in een Dockerfile maakt een nieuwe laag. Om het aantal lagen en de imagegrootte te beperken:

• Combineer meerdere RUN-commando’s met &&.
• Gebruik COPY in plaats van ADD tenzij je de extra functionaliteit van ADD nodig hebt.

Bijvoorbeeld:

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

Gebruik lichtgewicht base images

Kies lichte base images zoals python:3.9-slim in plaats van grotere zoals python:3.9. Slim-images bevatten alleen essentiële pakketten en verkleinen zo de image.

Afhankelijkheden en reproduceerbaarheid beheren

Reproduceerbaarheid is cruciaal in ML-workflows. Zo beheer je dependencies en borg je reproduceerbaarheid in gecontaineriseerde apps.

Gebruik requirements.txt of pipen

Zet al je Python-afhankelijkheden in een requirements.txt-bestand of gebruik pipenv om ze te beheren. Bijvoorbeeld:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2

Installeer de afhankelijkheden in je Dockerfile:

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

Versies van afhankelijkheden vastzetten

Zet altijd versies vast om onverwachte wijzigingen te voorkomen. Bijvoorbeeld:

scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2

Gebruik omgevingsvariabelen voor configuratie

Gebruik omgevingsvariabelen voor configuratie in plaats van waarden hardcoden. Dit maakt je container flexibeler en makkelijker te configureren in verschillende omgevingen. Bijvoorbeeld:

ENV MODEL_PATH=/app/models/model.pkl

Lees de variabele vervolgens uit in je applicatie:

import os
model_path = os.getenv('MODEL_PATH')

Security-overwegingen

Security is cruciaal bij gecontaineriseerde apps. Houd hier rekening mee:

Voorkom draaien als root

Containers draaien als root kan veiligheidsrisico’s opleveren. Maak in plaats daarvan een niet-rootgebruiker en draai als die gebruiker. Bijvoorbeeld:

# Create a non-root user
RUN useradd -m myuser

# Switch to the non-root user
USER myuser

# Set the working directory
WORKDIR /home/myuser/app

# Copy the application code
COPY --chown=myuser:myuser . .

# Run the application
CMD ["python", "app.py"]

Scan images op kwetsbaarheden

Gebruik tools als Trivy of Clair om je Docker-images te scannen op kwetsbaarheden. Bijvoorbeeld met Trivy:

trivy image ml-flask-app

Beheer secrets veilig

Hardcode nooit gevoelige info zoals API-keys of databasecredentials in je Dockerfile of code. Gebruik Kubernetes Secrets of Docker Secrets. In Kubernetes bijvoorbeeld:

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  api_key: <base64-encoded-api-key>

Mount de secret daarna als omgevingsvariabele in je deployment:

env:
- name: API_KEY
  valueFrom:
    secretKeyRef:
      name: my-secret
      key: api_key

Testen en debuggen

Testen en debuggen zijn essentieel om zeker te zijn dat je gecontaineriseerde app werkt zoals verwacht. Tips:

Lokaal testen

Test lokaal met Docker voordat je naar Kubernetes gaat. Bijvoorbeeld:

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

Logs gebruiken voor debugging

Gebruik docker logs of kubectl logs om issues te debuggen. Bijvoorbeeld:

docker logs <container_id>
kubectl logs <pod_name>

Testen automatiseren

Gebruik CI/CD-pijplijnen om testen en uitrol te automatiseren. Tools zoals GitHub Actions, GitLab CI of Jenkins helpen je geautomatiseerde workflows opzetten.

Door deze best practices te volgen, bouwen we efficiënte, reproduceerbare en veilige gecontaineriseerde ML-applicaties. Van Dockerfiles optimaliseren tot dependencybeheer en security—met deze strategieën stroomlijn je ML-workflows en rol je modellen met vertrouwen uit.

Conclusie

ML-applicaties containerizen met Docker en Kubernetes vereenvoudigt uitrol, waarborgt reproduceerbaarheid en verbetert schaalbaarheid. Door best practices te volgen—zoals Dockerfiles optimaliseren, afhankelijkheden beheren en security prioriteren—bouwen we robuuste, efficiënte en veilige ML-workflows.

Wil je verder leren over containerization en je ML-workflows verbeteren? Bekijk deze courses:

• Introduction to Docker Course
• Intermediate Docker Course
• Introduction to Kubernetes Course
• Docker for Data Science: An Introduction
• Become a Machine Learning Scientist in Python
• Machine Learning Fundamentals in Python Track