Dockerfile Ubuntu: Een beginnersgids voor ontwikkelaars

1. Introductie

Wat zijn Docker en Dockerfile?

Docker heeft de afgelopen jaren snel aan populariteit gewonnen als een manier om het opzetten van ontwikkelomgevingen en het uitrollen van applicaties te stroomlijnen. Docker heeft de unieke mogelijkheid om een applicatie en zijn afhankelijkheden in één “container” te verpakken, die vervolgens overal in dezelfde omgeving kan worden uitgevoerd.
Om deze Docker-container te bouwen, is een blauwdruk genaamd “Dockerfile” nodig. Een Dockerfile is een tekstbestand dat de basis‑OS‑image, te installeren software, omgevingsvariabelen en meer specificeert. Ontwikkelaars kunnen dit bestand gebruiken om automatisch aangepaste omgevingen te bouwen.

Redenen om Ubuntu als basis te kiezen

Bij het maken van een Dockerfile is de eerste stap het specificeren van de basis‑OS‑image. Van de vele opties is Ubuntu bijzonder populair. Ubuntu is een op Debian gebaseerde Linux‑distributie die bekend staat om zijn gebruiksgemak en de flexibiliteit om diverse omgevingen te bouwen dankzij de uitgebreide pakketrepository.
Een Dockerfile gebaseerd op Ubuntu biedt de volgende voordelen:

• Er is veel officiële en community‑documentatie beschikbaar, wat resulteert in een lagere leercurve.
• Veel pakketten en tools kunnen eenvoudig worden geïnstalleerd met APT (Advanced Package Tool).
• Lichtgewicht minimale images (zoals ubuntu:20.04, ubuntu:24.04) worden officieel geleverd.

Doel en doelgroep van dit artikel

In dit artikel richten we ons op het trefwoord “Dockerfile Ubuntu” en geven we een gemakkelijk te begrijpen uitleg voor beginners over hoe je Dockerfiles op basis van Ubuntu maakt.
Specifiek behandelen we alles van de basisstructuur van een Dockerfile tot de stappen om daadwerkelijk een Ubuntu‑omgeving te bouwen, voorbeelden van het installeren van toepassingsomgevingen zoals Python, en veelvoorkomende fouten met hun oplossingen.
Dit artikel is aanbevolen voor:

• Degenen die voor de eerste keer een omgeving willen bouwen met een Dockerfile.
• Degenen die een reproduceerbare ontwikkelomgeving op Ubuntu willen creëren.
• Degenen die hun kennis willen verdiepen, inclusief hoe je problemen oplost.

2. Basisstructuur van een Dockerfile

Wat is een Dockerfile? Het begrijpen van de rol

Een Dockerfile is als een recept voor het maken van een Docker‑image. Het is een tekstbestand dat beschrijft welke basis‑OS te gebruiken, welke software te installeren en welke configuraties toe te passen.
Door het docker build‑commando met dit bestand uit te voeren, kun je eenvoudig zeer reproduceerbare ontwikkel‑ en applicatie‑uitvoeringsomgevingen bouwen.

Voordelen van het gebruik van een Dockerfile:

• Automatisering van het opzetten van de omgeving (geen handmatige stappen meer nodig).
• Elimineert inconsistenties in de omgeving bij ontwikkeling met meerdere teamleden.
• Gemakkelijk te integreren in CI/CD‑pijplijnen.

Veelgebruikte basisinstructies (directieven) in Dockerfile

Een Dockerfile bevat verschillende instructies (directieven), waarvan de volgende het meest representatief zijn. We zullen deze passend combineren om een Dockerfile op basis van Ubuntu te maken.

Minimalistisch voorbeeld van een Ubuntu‑Dockerfile

Hieronder staat een heel eenvoudig voorbeeld van een Dockerfile gebaseerd op Ubuntu.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y
    curl
    vim

CMD ["/bin/bash"]

Deze Dockerfile is geconfigureerd om Ubuntu 24.04 als basis te gebruiken, twee hulpprogramma’s (curl en vim) te installeren, en ten slotte de bash‑shell te starten.

Over het kiezen van Ubuntu‑tags

Ubuntu Docker‑images zijn beschikbaar op de officiële Docker Hub‑repository. Hoewel ubuntu:latest de nieuwste versie gebruikt, is het aan te raden om expliciet een versie vast te zetten.
Bijvoorbeeld:

• ubuntu:22.04 (LTS: Long‑Term‑Support‑versie, legt de nadruk op stabiliteit)
• ubuntu:24.04 (Nieuwste LTS‑kandidaat, legt de nadruk op functionaliteit)

Bepaal of je stabiliteit of nieuwe functionaliteit wilt prioriteren, afhankelijk van je doel.

3. Oefening: Een Ubuntu‑Dockerfile maken

Benodigde pakketten installeren voor de Ubuntu‑omgeving

Wanneer je een Ubuntu-omgeving bouwt met behulp van een Dockerfile, heb je vaak aanvullende pakketten nodig om te installeren. Bijvoorbeeld, de volgende hulpprogramma’s worden vaak gebruikt om een ontwikkelomgeving in te stellen:

• curl : Voor het ophalen van bestanden en het controleren van API’s.
• vim : Een eenvoudige teksteditor.
• git : Een versiebeheersysteem.
• build-essential : Een verzameling basistools die nodig zijn voor het bouwen van C/C++-programma’s.

Om deze in een Dockerfile te installeren, gebruik je de RUN-instructie.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y
    curl
    vim
    git
    build-essential

Door eerst apt-get update uit te voeren, zorg je ervoor dat de nieuwste pakketlijsten worden verkregen voordat de installatie plaatsvindt.

Instellen van Niet-Interactieve Installatie

In Ubuntu kan apt-get install invoer van de gebruiker vereisen, maar interactieve bewerkingen zijn niet mogelijk tijdens het Docker-buildproces. Daarom wordt aanbevolen om de omgevingsvariabele als volgt in te stellen om de installatie in niet-interactieve modus uit te voeren.

ENV DEBIAN_FRONTEND=noninteractive

Dit zal prompts overslaan zoals “Regional Settings” die verschijnen tijdens de pakketconfiguratie, waardoor de installatie soepel kan verlopen.

Beeldgrootte Verkleinen door Onnodige Cache te Verwijderen

Bij het gebruik van APT kunnen gedownloade tijdelijke bestanden (cache) in het beeld blijven, waardoor het uiteindelijke Docker-beeld groter wordt. Je kunt de beeldgrootte verkleinen door deze cache als volgt te verwijderen:

RUN apt-get update && apt-get install -y
    curl
    vim
    && rm -rf /var/lib/apt/lists/*

Door meerdere commando’s te combineren in één RUN-statement zoals dit, kun je ook voorkomen dat onnodige lagen worden aangemaakt.

Best Practices: Je Dockerfile Organiseren

In werkelijke ontwikkelomgevingen worden de volgende best practices voor het schrijven van Dockerfiles aanbevolen:

• Combineer RUN-instructies zoveel mogelijk om het aantal lagen te verminderen.
• Definieer versies en configuraties expliciet met ENV.
• Gebruik opmerkingen om het doel van elke bewerking duidelijk te vermelden.
• Gebruik rm en --no-install-recommends om onnodige bestanden te vermijden.

Voorbeeld:

RUN apt-get update && apt-get install -y --no-install-recommends
    curl
    git
    && rm -rf /var/lib/apt/lists/*

Door dit te doen, kun je een lichter en beter onderhoudbare Dockerfile bouwen.

4. Docker-Beeld Bouwen en Verifiëren

Een Docker-Beeld Bouwen vanuit een Dockerfile

Zodra je je Dockerfile hebt geschreven, is de volgende stap om het Docker-beeld te bouwen. Dit doe je met het docker build-commando. Voer het volgende commando uit in de map waar je Dockerfile zich bevindt:

docker build -t my-ubuntu-image .

• De optie -t wordt gebruikt om het beeld een naam (tag) te geven. In dit voorbeeld noemen we het my-ubuntu-image.
• De . verwijst naar de huidige map waar de Dockerfile zich bevindt.

Wanneer je dit commando uitvoert, zal Docker de instructies in de Dockerfile sequentieel lezen en een nieuw beeld dienovereenkomstig bouwen.

Het Gebouwde Docker-Beeld Verifiëren

Na voltooiing van de beeldcreatie kun je het verifiëren met het volgende commando:

docker images

Dit zal een lijst van lokaal bestaande Docker-beelden weergeven, en je kunt de volgende informatie controleren:

• REPOSITORY (beeldnaam)
• TAG (tag)
• IMAGE ID (uniek identificator)
• CREATED (aanmaakdatum en -tijd)
• SIZE (grootte)

Voorbeeld:

REPOSITORY         TAG       IMAGE ID       CREATED         SIZE
my-ubuntu-image    latest    abcd1234abcd    5 minutes ago   189MB

Dit bevestigt dat het door jou aangemaakte beeld succesvol is geregistreerd.

Een Docker-Container Starten en Werking Verifiëren

Om te verifiëren dat het aangemaakte beeld correct functioneert, laten we een Docker-container starten. Gebruik het volgende commando:

docker run -it my-ubuntu-image

• Het specificeren van de -it optie stelt je in staat een terminal in interactieve modus te starten.
• Als het succesvol start, verschijnt er een bash‑prompt binnen de container, en bevind je je in een staat alsof je bent ingelogd in een Ubuntu‑omgeving.

Binnen de container kun je commando’s uitvoeren zoals de volgende om te controleren of de geïnstalleerde tools correct werken:

curl --version
vim --version

Als er geen problemen zijn, is het Dockerfile succesvol geschreven.

Onnodige afbeeldingen en containers opruimen

Naar je builds en experimenten herhaalt, kunnen onnodige Docker‑images en containers lokaal ophopen. Het wordt aanbevolen ze periodiek op te ruimen met commando’s zoals de volgende:

• Gestopte containers verwijderen:

  docker container prune
  

• Ongebruikte images verwijderen:

  docker image prune
  

• Alle ongebruikte data verwijderen (Let op!):

  docker system prune
  

Deze handelingen helpen om schijfruimte te besparen en problemen te voorkomen.

5. Toepassing: Een Python‑omgeving bouwen

Python bruikbaar maken in een op Ubuntu gebaseerd Dockerfile

Door een Python‑uitvoeringsomgeving toe te voegen bij het bouwen van een Ubuntu‑omgeving met een Dockerfile, kun je een breed scala aan toepassingen ondersteunen, zoals ontwikkeling, testen en machine learning. Hoewel Ubuntu mogelijk al Python heeft geïnstalleerd, is het gebruikelijk om het expliciet zelf te bouwen vanuit het oogpunt van versie‑ en pakketbeheer.

Hoe Python te installeren met apt

De eenvoudigste manier is Python te installeren via APT‑pakketten. Hier is een voorbeeld:

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y
    python3
    python3-pip
    && rm -rf /var/lib/apt/lists/*

Met deze methode kun je de stabiele versie van Python gebruiken die op het systeem is geïnstalleerd (meestal Python 3.10 of 3.12, enz.). Daarnaast kun je Python‑pakketten toevoegen met het pip‑commando.

Python‑versies beheren met pyenv

Als je een specifieke Python‑versie wilt gebruiken of wilt schakelen tussen meerdere versies, is het gebruik van pyenv handig.
Hieronder een voorbeeld van het gebruik van pyenv om Python 3.11.6 te installeren in een Dockerfile:

FROM ubuntu:24.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y
    git
    curl
    make
    build-essential
    libssl-dev
    zlib1g-dev
    libbz2-dev
    libreadline-dev
    libsqlite3-dev
    wget
    llvm
    libncurses5-dev
    libncursesw5-dev
    xz-utils
    tk-dev
    libffi-dev
    liblzma-dev
    && rm -rf /var/lib/apt/lists/*

# Install pyenv
RUN git clone [https://github.com/pyenv/pyenv.git](https://github.com/pyenv/pyenv.git) ~/.pyenv

ENV PYENV_ROOT="$HOME/.pyenv"
ENV PATH="$PYENV_ROOT/bin:$PATH"

RUN echo 'eval "$(pyenv init --path)"' >> ~/.bashrc

# Install a specific Python version
RUN pyenv install 3.11.6 && pyenv global 3.11.6

Dit stelt je in staat je Python‑omgeving flexibeler te bouwen en te beheren.

Pakketbeheer met requirements.txt

In echte projecten heb je vaak meerdere Python‑bibliotheken nodig. requirements.txt wordt gebruikt om deze te beheren.
Maak eerst een requirements.txt‑bestand aan in de hoofdmap van je project:

flask==2.3.2
requests>=2.25.1
pandas

Vervolgens beschrijf je het in het Dockerfile als volgt:

COPY requirements.txt /app/requirements.txt
WORKDIR /app

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

Dit stelt je in staat de benodigde bibliotheken in één keer te installeren, waardoor de reproduceerbaarheid van je ontwikkelomgeving toeneemt.

Best practices

• Bij het gebruik van Python kan het bouwen van een virtuele omgeving met virtualenv of venv helpen afhankelijkheidsconflicten te voorkomen.
• Je kunt de grootte van je Docker‑image verkleinen door de cache te verwijderen (--no-cache-dir).
• Het installeren van de nieuwste versie van pip met pip install --upgrade pip vóór het installeren van Python‑pakketten kan fouten voorkomen.

6. Veelvoorkomende problemen en oplossingen

Toestemmingsfouten

Voorbeeld:

Permission denied

Dit gebeurt wanneer het gekopieerde bestand geen uitvoerrechten heeft of wanneer de bestandseigenaar/uitvoerende gebruiker niet geschikt is.

Oplossingen:

• Maak het bestand uitvoerbaar:

  RUN chmod +x script.sh
  

• Verander de gebruiker indien nodig:

  RUN chown root:root /path/to/file
  

Pakket Niet Gevonden of Kan Niet Worden Geïnstalleerd

Voorbeeld:

E: Unable to locate package xxx

Deze fout treedt op wanneer apt-get update niet is uitgevoerd of wanneer de opgegeven pakketnaam onjuist is.

Oplossingen:

• Schrijf altijd apt-get update vóór install :

  RUN apt-get update && apt-get install -y curl
  

• Controleer de pakketnaam op typefouten en zorg dat deze correct is.

Netwerkgerelateerde Fouten

Voorbeeld:

Temporary failure resolving 'deb.debian.org'

Dit type fout treedt op wanneer DNS‑resolutie faalt tijdens het bouwproces.

Oplossingen:

• Het opnieuw starten van de Docker‑daemon kan het probleem oplossen:

  sudo systemctl restart docker
  

• Controleer de Docker DNS‑instellingen (voeg DNS‑specificaties toe aan /etc/docker/daemon.json ):

  {
    "dns": ["8.8.8.8", "8.8.4.4"]
  }
  

Build Blijft in een Oude Staat Door Cache‑effect

Docker gebruikt een laag‑voor‑laag cache voor snelheid. Hierdoor kan het zijn dat, zelfs als je de Dockerfile wijzigt, deze niet zoals bedoeld wordt gebouwd omdat gecachte lagen opnieuw worden gebruikt.

Oplossing:

• Bouw opnieuw zonder de cache te gebruiken:

  docker build --no-cache -t my-image .
  

Opstartcommando in Container Fails to Execute or Exits Immediately

Oorzaken:

• Het commando gespecificeerd in CMD of ENTRYPOINT ondervindt een fout.
• Zelfs als je ["/bin/bash"] opgeeft in CMD, zal het onmiddellijk afsluiten als het niet interactief wordt uitgevoerd.

Oplossingen:

• Start de container voor debugging en controleer:

  docker run -it my-image /bin/bash
  

• Begrijp het verschil tussen CMD en ENTRYPOINT en gebruik ze op de juiste manier voor jouw doel.

Door deze problemen te ervaren, zullen je Dockerfile‑ontwerpvaardigheden zeker verbeteren. Wanneer je een probleem tegenkomt, lees dan kalm de foutmelding en traceer zorgvuldig welke laag of instructie de oorzaak is.

7. Conclusie

Belangrijke Punten voor het Maken van Ubuntu‑gebaseerde Dockerfiles Opnieuw Bevestigen

In dit artikel hebben we stap voor stap van basis tot toegepaste methoden uitgelegd over hoe je een Ubuntu‑omgeving bouwt met een Dockerfile. Laten we hier de belangrijke punten herhalen.

• **Het begrijpen van de basisstructuur van een Dockerfile is de eerste stap. Je kunt de omgeving automatiseren door instructies zoals FROM, RUN, CMD en ENV te combineren.
• Ubuntu is een stabiele en zeer flexibele basisimage. De rijke pakketrepository, grote gebruikersbasis en de beschikbaarheid van LTS‑versies maken het geschikt als basis voor ontwikkelomgevingen.
• Je kunt benodigde tools en bibliotheken installeren via praktisch pakketbeheer. Weten hoe je apt-get gebruikt, cache verwijdert en niet‑interactieve installaties uitvoert, is essentieel.
• Praktische omgevingen zoals Python bouwen is ook mogelijk met een Dockerfile. Tools zoals pyenv, pip en requirements.txt stellen je in staat om zeer reproduceerbare ontwikkelomgevingen te creëren.
• Probleemoplossende vaardigheden leiden direct tot stabiele werking. Het begrijpen van veelvoorkomende valkuilen zoals permissies, netwerkproblemen en build‑cache kan de ontwikkelings efficiëntie aanzienlijk verbeteren.

Volgende Stappen voor het Leren van Dockerfile

Het kunnen omgaan met Dockerfiles stelt je in staat een breed scala aan toepassingen te ondersteunen, niet alleen in ontwikkeling maar ook in testen en het uitrollen naar productieomgevingen. Voor toekomstige leerdoelen is het nuttig om door te gaan naar volgende onderwerpen:

• Beheren van multi‑container configuraties met Docker Compose.
• Integratie met CI/CD‑tools (GitHub Actions, GitLab CI, enz.).
• Samenwerking met containerorchestratietools zoals Kubernetes. FAQ (Veelgestelde Vragen)

V1. Welke Ubuntu‑versie moet ik kiezen in mijn Dockerfile?

A1. In principe, als je stabiliteit en langdurige ondersteuning prioriteert, is het gebruikelijk om een LTS (Long Term Support) versie te kiezen. Bijvoorbeeld, ubuntu:22.04 en ubuntu:20.04 worden in veel ontwikkelomgevingen gebruikt en kunnen met vertrouwen worden ingezet vanwege hun 5‑jaar ondersteuningsperiode. Aan de andere kant, als je de nieuwste pakketten en taalversies wilt gebruiken, kun je een nieuwere release kiezen zoals ubuntu:24.04, maar we raden aan deze eerst te testen.

Q2. Why do I get “Package not found” when using apt-get install?

A2. De meest voorkomende reden is dat je niet eerst apt-get update hebt uitgevoerd. Als je probeert te installeren zonder de pakketlijst bij te werken, krijg je een fout omdat het betreffende pakket niet gevonden kan worden in de verouderde lijst.
Correct voorbeeld van gebruik:

RUN apt-get update && apt-get install -y curl

Wees ook voorzichtig met typefouten in pakketnamen en verouderde pakketnamen (bijv. python3 in plaats van python).

Q3. How do I set environment variables in a Dockerfile?

A3. Je stelt omgevingsvariabelen in met de ENV‑instructie. Deze omgevingsvariabele is geldig zowel tijdens de build als tijdens de uitvoering van de container.
Voorbeeld:

ENV DEBIAN_FRONTEND=noninteractive

Dit is een typische instelling die wordt gebruikt om interactieve prompts tijdens APT‑installatie te onderdrukken. Het wordt ook gebruikt om applicatie‑configuraties en API‑sleutels in de Dockerfile in te stellen.

Q4. What is the difference between CMD and ENTRYPOINT in a Dockerfile?

A4. Beide geven opdrachten op die worden uitgevoerd wanneer de container start, maar er zijn verschillen in hun gebruik en gedrag.

Voorbeeld:

CMD ["python3", "app.py"]
# vs
ENTRYPOINT ["python3"]
CMD ["app.py"]

In het laatste geval kun je de CMD als argument doorgeven in de vorm van docker run my-image another_script.py.

Q5. I edited my Dockerfile, but the changes are not reflected. Why?

A5. Docker gebruikt cache tijdens het build‑proces, dus zelfs als je kleine wijzigingen in de Dockerfile aanbrengt, kunnen gecachte lagen nog steeds worden gebruikt.
Oplossing:

docker build --no-cache -t my-image .

Dit voert een nieuwe build uit zonder de cache te gebruiken, en alle wijzigingen worden weergegeven.