Docker vanaf nul leren: een gids voor dataprofessionals

Stap 3: Voer je eerste container uit

Nu Docker is geïnstalleerd, is het tijd om je eerste container te draaien. We beginnen met de simpele hello-world-image, perfect voor beginners.

1. Open je terminal (of Command Prompt op Windows) en voer de volgende opdracht uit:

sudo docker run hello-world

Deze opdracht vertelt Docker om lokaal te zoeken naar de hello-world-image. Als die niet wordt gevonden, haalt Docker de image op van Docker Hub en voert die vervolgens uit.

Als Docker correct is geïnstalleerd, zie je het bericht “Hello from Docker!” met daarbij details over hoe het Docker‑proces werkt. Deze output bevestigt dat Docker de image succesvol heeft opgehaald, een nieuwe container heeft gemaakt en de code daarin heeft uitgevoerd.

Stap 4: Bouw je eerste Docker-image

In deze stap maak je een aangepaste Docker-image voor een eenvoudig data‑scienceproject. Deze image bevat Python en gangbare data‑sciencelibraries zoals pandas, NumPy en scikit‑learn.

1. Maak een nieuwe map aan:

• • Begin met het maken van een nieuwe map voor je project en navigeer erin:

mkdir my-data-science-app
cd my-data-science-app

2. Maak een Dockerfile aan:

Maak in deze map een bestand met de naam Dockerfile (zonder extensie):

# Use an official Python runtime as a parent image
FROM python:3.8-slim
 
# Set the working directory in the container
WORKDIR /app
 
# Copy the current directory contents into the container at /app
COPY . /app
 
# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
 
# Make port 8888 available to the world outside this container
EXPOSE 8888
 
# Run a Jupyter notebook server when the container launches
CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

De Dockerfile doet het volgende:

• FROM python:3.8-slim: Dit stelt de basis‑image in op Python 3.8 in de “slim”-variant, een minimale versie van Python, ideaal voor een lichte data‑scienceomgeving.
• WORKDIR /app: Dit stelt de werkmap binnen de container in op /app. Alle volgende opdrachten worden binnen deze map uitgevoerd.
• COPY . /app: Dit kopieert alle bestanden uit je huidige map op de hostmachine naar de map /app in de container. Dit omvat doorgaans je data‑scripts en configuratiebestanden.
• RUN pip install --no-cache-dir -r requirements.txt: Dit installeert de Python‑libraries die in requirements.txt staan. Veelgebruikte libraries voor data science zijn onder andere pandas, NumPy en scikit‑learn.
• EXPOSE 8888: Dit stelt poort 8888 beschikbaar voor de hostmachine, de standaardpoort voor Jupyter‑notebooks.
• CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]: Deze opdracht start een Jupyter‑notebookserver wanneer de container start, zodat je die via je webbrowser kunt bereiken.

3. Maak een requirements.txt-bestand aan:

Maak in dezelfde map een requirements.txt-bestand om de Python‑pakketten te vermelden die je applicatie nodig heeft:

pandas
numpy
scikit-learn
matplotlib

Dit bestand bevat de Python‑libraries die in je Docker‑container worden geïnstalleerd.

4. Bouw de Docker‑image:

• Met de Dockerfile en requirements.txt gereed, bouw je je Docker‑image met de volgende opdracht:

sudo docker build -t my-data-science-app .

De bovenstaande opdracht doet het volgende:

• docker build: Start het proces om een Docker‑image te bouwen.
• -t my-data-science-app: Met de -t‑optie tag je de image als “my-data-science-app”.
• .: De punt aan het einde specificeert de buildcontext, oftewel de huidige map. Docker gebruikt de bestanden in deze map om de image te bouwen.

5. Draai de Docker‑image:

Wanneer het buildproces klaar is, kun je je nieuwe Docker‑image als container draaien:

sudo docker run -p 8888:8888 my-data-science-app

Laten we de opdracht ontleden:

• docker run: Start een container op basis van de opgegeven image.
• -p 8888:8888: De -p‑optie mappt poort 8888 op je lokale machine naar poort 8888 in de container, zodat je de Jupyter Notebook‑server kunt bereiken via localhost:8888 in je browser.
• my-data-science-app: Dit specificeert de image die moet draaien.

Stap 5: Gebruik Docker Compose

Docker Compose is een essentieel hulpmiddel voor het beheren van applicaties met meerdere containers. In een data‑scienceproject heb je mogelijk aparte containers nodig voor verschillende componenten, zoals een Jupyter‑notebook, een database voor opslag en een tool voor datavisualisatie.

Met Docker Compose definieer je deze services in één YAML‑bestand, zodat je je volledige data‑scienceomgeving met één opdracht kunt opstarten.

1. Maak een docker-compose.yml-bestand aan:

• Maak in je projectmap een bestand met de naam docker-compose.yml en zet de volgende regels in het bestand:

version: '3.8'
services:
  jupyter:
        image: jupyter/scipy-notebook:latest
        volumes:
        - ./notebooks:/home/joelwembo/work
        ports:
        - "8888:8888"
        environment:
        - JUPYTER_ENABLE_LAB=yes
 
  postgres:
        image: postgres:13-alpine
        environment:
        POSTGRES_USER: myuser
        POSTGRES_PASSWORD: mypassword
        POSTGRES_DB: mydatabase
        volumes:
        - postgres_data:/var/lib/postgresql/data
        ports:
        - "5432:5432"
 
  redis:
        image: redis:alpine
        ports:
        - "6379:6379"
 
volumes:
  postgres_data:
 

Laten we doornemen wat het Docker Compose‑bestand doet:

• version: '3.8': Dit specificeert de versie van het Docker Compose‑bestandsformaat. Versie 3.8 is een veelgebruikte versie met veel features.
• services:: De services‑sectie definieert de verschillende containers (services) waaruit je applicatie bestaat.
• jupyter:: Deze service vertegenwoordigt een Jupyter‑notebookomgeving die essentieel is voor interactieve data‑analyse.
• image: jupyter/scipy-notebook:latest: Dit specificeert de Docker‑image voor de Jupyter‑notebook, inclusief populaire data‑sciencelibraries zoals NumPy, pandas en matplotlib.
• volumes: - ./notebooks:/home/joelwembo/work: Dit mount de map notebooks op je hostmachine naar /home/joelwembo/work in de container, zodat je je notebooks kunt bewaren en delen. Let op: Dit is mijn persoonlijke pad en dat van jou zal anders zijn.
• ports: - "8888:8888": Dit mappt poort 8888 op je hostmachine naar poort 8888 in de container, de standaardpoort voor Jupyter‑notebooks.
• environment: - JUPYTER_ENABLE_LAB=yes: Dit schakelt JupyterLab in, een krachtigere interface voor werken met Jupyter‑notebooks.
• postgres:: Deze service draait een PostgreSQL‑database, vaak gebruikt voor het opslaan en beheren van grote datasets in data‑scienceprojecten.
• image: postgres:13-alpine: Dit specificeert de Docker‑image voor PostgreSQL versie 13, gebaseerd op de lichte Alpine Linux‑distributie.
• environment:: Deze omgevingsvariabelen configureren de database met een gebruiker, wachtwoord en databasenaam.
• volumes: - postgres_data:/var/lib/postgresql/data: Dit mount een Docker‑volume om databasegegevens buiten de container te bewaren, zodat je data niet verloren gaat wanneer de container wordt gestopt.
• ports: - "5432:5432": Dit mappt poort 5432 op je hostmachine naar poort 5432 in de container, de standaardpoort voor PostgreSQL.
• redis:: Deze service draait een Redis‑server, die kan worden gebruikt als snelle in‑memory datastore of cache.
• image: redis:alpine: Dit specificeert de Redis‑image met de lichte Alpine‑variant.
• ports: - "6379:6379": Dit mappt poort 6379 op je hostmachine naar poort 6379 in de container, de standaardpoort voor Redis.
• volumes:: Deze sectie definieert benoemde volumes die gedeeld kunnen worden tussen services of data kunnen bewaren bij het herstarten van containers.
• postgres_data:: Hiermee maak je een benoemd volume aan voor het bewaren van PostgreSQL‑data.

Om je multi‑containerapplicatie te starten, voer je simpelweg het volgende uit:

sudo docker compose up

Deze opdracht bouwt de images (indien nodig) en start de containers die in je docker-compose.yml staan. Hiermee worden zowel de webapplicatie als de Redis‑service opgestart en kunnen ze met elkaar communiceren zoals gedefinieerd.

Je hebt nu je eerste Docker‑applicatie gedeployed! Mooi toch? Laten we nu een plan uitwerken voor je continue leertraject.

Een voorbeeldleerplan voor Docker

Hier is een week‑voor‑weekplan dat je kunt volgen. Pas het gerust aan je eigen behoeften aan. 

Als je een duidelijker pad nodig hebt, is de skill track Containerization and Virtualization with Docker and Kubernetes perfect voor jou. Deze bevat vier essentiële cursussen.

Week 1: Raak vertrouwd met Docker‑basiskennis

• Doel: Begrijp de kernconcepten van Docker en basiscommando’s.
• Taken:
• Installeer Docker en stel Docker Desktop in.
• Leer Docker‑commando’s: docker run, docker ps, docker stop, docker rm, enz.
• Draai eenvoudige containers voor tools voor data‑exploratie zoals Ubuntu of Alpine en probeer basiscommando’s.
• Verken officiële Docker‑images en draai containers voor basisvisualisatietools (bijv. een eenvoudige matplotlib‑container).
• Bronnen: Containerization and Virtualization Concepts-cursus, Introduction to Docker-cursus.

Week 2: Bouw en draai Docker‑images voor datatools

• Doel: Leer aangepaste Docker‑images maken en beheren.
• Taken:
• Schrijf een Dockerfile voor een basis data‑analyseomgeving (bijv. Python met Pandas en NumPy).
• Bouw de Docker‑image met docker build.
• Draai containers van je aangepaste image en test datatools zoals Jupyter Notebook.
• Maak Dockerfiles voor TensorFlow en PostgreSQL en zorg voor de juiste configuratie en koppeling.
• Bronnen: Introduction to Docker-cursus.

Week 3: Verken Docker Compose

• Doel: Begrijp en gebruik Docker Compose voor multi‑containeropstellingen.
• Taken:
• Installeer Docker Compose en leer de basis.
• Schrijf docker-compose.yml-bestanden om multi‑containerapplicaties te definiëren.
• Oefen met voorbeelden zoals een webapplicatie met een backend‑database (bijv. een Flask‑app met PostgreSQL).
• Experimenteer met verschillende configuraties en service‑afhankelijkheden.
• Bronnen: Intermediate Docker-cursus.

Week 4: Verdiep je in Docker‑netwerken en volumes

• Doel: Beheers de netwerk‑ en opslagmogelijkheden van Docker.
• Taken:
• Leer over Docker‑netwerken en hoe je ze maakt (bridge, host, overlay).
• Oefen met het maken van custom netwerken en het koppelen van containers eraan.
• Verken Docker‑volumes voor persistente opslag en oefen met het aanmaken en beheren ervan.
• Implementeer een setup waarbij containers via een custom netwerk communiceren en volumes gebruiken voor databehoud.
• Bronnen: Intermediate Docker-cursus.

Week 5: Docker‑containers in productie deployen en beheren

• Doel: Begrijp het deployen en beheren van containers in productie.
• Taken:
• Leer best practices voor het deployen van Docker‑containers (bijv. via Docker Hub of een privéregistry).
• Verken containerorchestratie met Docker Swarm: services creëren en beheren.
• Begrijp het schalen van containers en het beheren van logs.
• Experimenteer met het deployen van een gecontaineriseerde applicatie naar een staging‑ of productieomgeving.
• Bronnen: Intermediate Docker-cursus.

Week 6: Introductie tot Kubernetes voor containerorchestratie

• Doel: Maak kennis met Kubernetes voor het schalen en beheren van gecontaineriseerde applicaties.
• Taken:
• Installeer en stel een lokale Kubernetes‑omgeving in (bijv. Minikube of Kind).
• Leer de basis van Kubernetes: pods, services, deployments en namespaces.
• Deploy een eenvoudige gecontaineriseerde applicatie op Kubernetes.
• Verken het schalen en beheren van applicaties met Kubernetes, met focus op het draaien van een gecontaineriseerde datatool zoals Jupyter.
• Bronnen: Introduction to Kubernetes-cursus.

Tips en manieren om Docker te leren

Tot slot enkele tips en best practices om je leerpad voor Docker te versnellen.

Oefen regelmatig

De sleutel tot het beheersen van Docker is consequent, hands‑on oefenen. Begin met persoonlijke projecten, zoals het containerizen van een eenvoudige website of het opzetten van een lokale ontwikkelomgeving. 

Word je comfortabeler, daag jezelf dan uit met complexere taken, zoals het bouwen van een multi‑containerapplicatie of het deployen van een webserver. 

Regelmatig experimenteren met verschillende use‑cases—zoals het maken van custom Docker‑images of het configureren van een CI/CD‑pipeline—zal je inzicht verdiepen en belangrijke concepten verankeren. Daarnaast is deelnemen aan online Docker‑challenges of oefeningen een uitstekende manier om je vaardigheden gericht te testen en te verbeteren.

Gebruik online bronnen

Online bronnen zijn onmisbaar om Docker te leren. De officiële Docker‑documentatie is een uitstekend startpunt met gezaghebbende en actuele informatie. 

Daarnaast zijn er veel uitgebreide cursussen beschikbaar op platforms zoals DataCamp, die je door het leerproces kunnen begeleiden. 

Voor wie liever visueel leert, bieden YouTube‑tutorials van het officiële Docker‑kanaal en andere docenten nuttige, toegankelijke content om je begrip te versterken.

Sluit je aan bij de Docker‑community

Meedoen aan de Docker‑community is een krachtige manier om je leerproces te versnellen. Doe mee op fora zoals Docker Community Forums en Reddit om ideeën uit te wisselen, vragen te stellen en ervaringen te delen met andere lerenden en professionals. 

Het bijwonen van Docker‑meetups, webinars of conferenties is ook een geweldige manier om bij te blijven met trends in de sector en je netwerk uit te breiden.

Werk aan open‑sourceprojecten

Bijdragen aan open‑sourceprojecten die Docker gebruiken, kan een fantastische manier zijn om praktische, real‑world ervaring op te doen. 

Websites zoals GitHub bieden kansen om samen te werken aan Docker‑gerelateerde projecten, zodat je van anderen leert en je vaardigheden in diverse contexten toepast. De samenwerking die inherent is aan open source stelt je bloot aan verschillende aanpakken en oplossingen, waardoor je een dieper begrip van de mogelijkheden van Docker ontwikkelt.

Blijf up‑to‑date

Tot slot is up‑to‑date blijven met de laatste ontwikkelingen rond Docker essentieel om vaardig te blijven. Houd de officiële blog en releasenotes van Docker in de gaten voor updates over nieuwe features of wijzigingen. Door deel te nemen aan community‑discussies op fora en sociale media blijf je op de hoogte van opkomende trends en best practices, zodat je je Docker‑skills continu kunt aanscherpen.

Met regelmatige oefening, actieve community‑betrokkenheid en continu leren bouw je een sterke basis in Docker en blijf je uitgerust voor de nieuwste ontwikkelingen in het vakgebied.

Conclusie

Docker heeft het deployen van applicaties en datamanagement getransformeerd door applicaties en hun dependencies te verpakken in geïsoleerde containers. Dit lost veelvoorkomende uitdagingen op, zoals inconsistente omgevingen, en zorgt voor consistente, schaalbare en efficiënte workflows voor dataprofessionals.

Deze gids gaf je de basisstappen om Docker onder de knie te krijgen, van kernconcepten tot hands‑on deployments. Wil je je kennis verder verdiepen, bekijk dan de Introduction to Docker en Intermediate Docker-cursussen op DataCamp. Naarmate je vordert, is het uitbreiden van je vaardigheden met orchestratietools zoals Kubernetes net zo belangrijk—bekijk de Introduction to Kubernetes-cursus om te beginnen.

Door regelmatig te oefenen, beschikbare bronnen te gebruiken en betrokken te blijven bij de community, benut je het volledige potentieel van Docker voor het beheren van complexe dataomgevingen.