Een aangepaste NGINX Docker-image bouwen

NGINX in een Docker-container kan in veel omgevingen een betrouwbare webservice leveren. Misschien werk je aan een persoonlijke website, een lichte webservice of een homelab-project. Met Docker houd je alles consistent op verschillende machines en setups. Deze aanpak biedt een manier om NGINX te draaien met minder overheadzorgen bij het schakelen tussen development en production. Het is gebruikelijk om op Docker te vertrouwen voor eenvoudige packaging van de webserver, zodat je je projecten kunt delen zonder omslachtige handmatige stappen.

Dit artikel legt uit hoe je een kant-en-klare NGINX-image draait, hoe je content vanaf je lokale machine serveert en hoe je je eigen image bouwt met maatwerk. Het behandelt ook de stappen voor het instellen van een reverse proxy en het gebruik van Docker Compose voor deployment met meerdere services. Aan het einde zie je hoe je containers beheert met een paar eenvoudige commando’s en krijg je een duidelijk beeld van hoe je Docker en NGINX integreert voor praktische taken.

Ben je nieuw met Docker? Bekijk dan zeker onze Docker voor beginners-gids om alle basisprincipes te leren. 

Wat is Docker NGINX?

Docker NGINX verwijst naar het draaien van de NGINX-webserver in een lichte container. Docker-containers lijken op kleine pakketjes die een applicatie en alle benodigde afhankelijkheden bevatten. 

NGINX is een populaire webserver, bekend om sterke performance, eenvoudige configuratie en flexibele afhandeling van HTTP-verkeer. NGINX combineren met Docker is aantrekkelijk omdat het de omgeving consistent houdt. Of je nu op macOS, Windows of Linux deployt, de inhoud van de container blijft hetzelfde. Dat betekent dat hij zich identiek gedraagt, ongeacht het hostbesturingssysteem.

Een typische Docker-image voor NGINX bevat de serversoftware, een standaardconfiguratie en een mappenstructuur voor gehoste bestanden. Je kunt die container direct draaien of aanpassen door specifieke mappen te mappen, configuratiebestanden te wijzigen of een image te bouwen op basis van je eigen Dockerfile. Daarmee kun je aangepaste modules of scripts toevoegen om NGINX voor jouw applicatie te customizen.

Wil je meer leren over het containerizen van applicaties? Bekijk dan onze How to Containerize an Application Using Docker-tutorial. Die gaat dieper in op het containerizen van machine learning-applicaties met Docker op een beginnersvriendelijke manier. 

Vereisten

Voordat je NGINX-containers gaat draaien, controleer je of Docker geïnstalleerd is. Docker heeft officiële installers voor macOS, Windows en diverse Linux-distributies. De Docker-documentatie biedt een stapsgewijs proces voor elk besturingssysteem. 

Bekijk onze cursus Introduction to Docker voor een uitgebreide gids om met Docker aan de slag te gaan. 

Test je installatie met een snel commando zoals:

docker version
derrickmwiti@Derricks-MacBook-Pro% docker version
Client:
 Version:           28.0.1
 API version:       1.48
 Go version:        go1.23.6
 Git commit:        068a01e
 Built:             Wed Feb 26 10:38:16 2025
 OS/Arch:           darwin/arm64
 Context:           desktop-linux
Server: Docker Desktop 4.39.0 (184744)
 Engine:
  Version:          28.0.1
  API version:      1.48 (minimum version 1.24)
  Go version:       go1.23.6
  Git commit:       bbd0a17
  Built:            Wed Feb 26 10:40:57 2025
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.7.25
  GitCommit:        bcc810d6b9066471b0b6fa75f557a15a1cbf31bb
 runc:
  Version:          1.2.4
  GitCommit:        v1.2.4-0-g6c52b3f
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0Mogelijk gemaakt door

Zie je versiedetails, dan is Docker klaar voor gebruik. Naast Docker zelf heb je internettoegang nodig om de NGINX-image van Docker Hub te pullen. Als je je eigen image wilt maken, heb je een teksteditor nodig om een Dockerfile te schrijven. Elke teksteditor werkt prima, kies er een die jij prettig vindt.

NGINX instellen in een Docker-container

NGINX draaien vanaf een kant-en-klare image is meestal de snelste methode. Je kunt deze in enkele seconden van Docker Hub pullen en vervolgens een container starten. Daarna zie je de standaardpagina in je browser. Dit korte proces is vaak de eerste stap in veel Docker-gebaseerde serversetups.

De NGINX Docker-image pullen

De officiële NGINX-image is publiek beschikbaar op Docker Hub onder de naam nginx. 

Pull hem zo:

docker pull nginx
derrickmwiti@Derricks-MacBook-Pro % docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
4c7c1a5bd3af: Download complete 
bef2ee7fab45: Download complete 
d9b636547744: Downloading [======================>                            ]  12.58MB/28.04MB
0994e771ba34: Downloading [===>                                               ]  3.146MB/40.56MB
589701e352f8: Download complete 
13f89c653285: Download complete 
8e77214beb25: Download complete Mogelijk gemaakt door

Dit gaat naar het registry en haalt de nieuwste versie op. Als alles klaar is, kun je controleren dat hij lokaal aanwezig is:

docker images
derrickmwiti@Derricks-MacBook-Pro% docker images
REPOSITORY                                                                     TAG                                                                           IMAGE ID       CREATED         SIZE

nginx                                                                          latest                                                                        124b44bfc9cc   6 weeks ago     280MB
keras-custom-training-container                                                latest                                                                                                                                     <none>                                                                        7de0f04013e5   7                                                  Mogelijk gemaakt door

Dat commando toont een lijst met images in je lokale bibliotheek. Je zou de nginx-image in de tabel moeten zien. Dat betekent dat je klaar bent om er een container van te maken. Ontdek een lijst met images die je nodig kunt hebben voor je data science-projecten in onze Top 12 Docker Container Images for Machine Learning and AI-tutorial. 

De NGINX-container draaien

Zodra de NGINX-image op je systeem staat, kun je de container starten met één commando:

docker run --name mynginx -p 8080:80 -d nginx
derrickmwiti@Derricks-MacBook-Pro % docker run --name mynginx -p 8080:80 -d nginx
ec44d1a43016e9684b602437b967c0ed8e11c933a8a76b341b68c25168d2af70Mogelijk gemaakt door

Dit commando doet meerdere dingen. Het draait een container met de naam mynginx op de achtergrond (vanwege de optie -d). Het mappt poort 8080 op je hostmachine naar poort 80 in de container. Die port mapping betekent dat je in je browser naar http://localhost:8080 kunt gaan en de standaard NGINX-pagina ziet. De container gebruikt de nginx-image die van Docker Hub is gepulld.

De nieuwe container zou moeten blijven draaien omdat NGINX actief is. Als je de logs bekijkt met:

docker logs mynginx
derrickmwiti@Derricks-MacBook-Pro % docker logs mynginx
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
/docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
/docker-entrypoint.sh: Configuration complete; ready for start up
2025/03/20 04:33:10 [notice] 1#1: using the "epoll" event method
2025/03/20 04:33:10 [notice] 1#1: nginx/1.27.4
2025/03/20 04:33:10 [notice] 1#1: built by gcc 12.2.0 (Debian 12.2.0-14) 
2025/03/20 04:33:10 [notice] 1#1: OS: Linux 6.10.14-linuxkit
2025/03/20 04:33:10 [notice] 1#1: getrlimit(RLIMIT_NOFILE): 1048576:1048576
2025/03/20 04:33:10 [notice] 1#1: start worker processes
2025/03/20 04:3Mogelijk gemaakt door

Je ziet eventuele berichten die NGINX heeft gelogd. 

Eigen content serveren met NGINX

Misschien wil je een HTML-pagina serveren in plaats van de standaardpagina in de containerimage. Je kunt een eenvoudig bestand op je lokale machine maken en dat in de container mounten. Zo houd je je content gescheiden van de container. Telkens wanneer je je pagina aanpast, kun je de browser verversen om de wijziging te zien.

Een aangepaste HTML-pagina maken

Kies een handige locatie op je lokale machine. Bijvoorbeeld een map html_content in je homedirectory. Maak daar een bestand index.html. Dat kan er zo uitzien:

<html>
<head>
    <title>My NGINX Page</title>
</head>
<body>
    <h1>Hello from my Docker NGINX setup!</h1>
    <p>This is a custom page served from a local folder.</p>
</body>
</html>Mogelijk gemaakt door

Dat is een basis-HTML-pagina. Je kunt elke tekst of styling toevoegen die je wilt. Voeg afbeeldingen of JavaScript toe, of wat verder bij je behoeften past.

De HTML-pagina mappen naar de NGINX-container

De officiële NGINX-image serveert standaard content uit /usr/share/nginx/html. Je kunt je lokale map naar die locatie in de container mappen. Dat doe je met de -v (volume) vlag in Docker. Stop een eventuele bestaande container met de naam mynginx om een poortconflict te voorkomen:

docker stop mynginx
docker rm mynginxMogelijk gemaakt door

Start daarna een nieuwe container:

docker run --name mynginx -p 8080:80 -d \
    -v /Users/derrickmwiti/Documents/html_content:/usr/share/nginx/html \
    nginx
6f68085733eeac418c3302e5c580a4f7c5c0c36d3591d8e2a7f35f69f6308d18Mogelijk gemaakt door

Vervang /path/to/html_content  door het werkelijke pad op jouw computer. Zo zal de container, wanneer je naar http://localhost:8080 surft, het HTML-bestand serveren dat je in html_content hebt geplaatst. Als je het index.html noemt, zal NGINX dat bestand automatisch laden.

Die aanpak is handig wanneer je de content regelmatig wilt aanpassen. Je hoeft de container niet telkens opnieuw te bouwen. De server haalt de content on the fly uit je lokale map. 

Krijg je een permissiewaarschuwing, zorg er dan voor dat jouw lokale gebruiker en Docker die map kunnen lezen. 

Op Linux kan dat betekenen dat je eigenaarschap of bestandspermissies aanpast. Op Windows of macOS kan het betekenen dat je Docker toegang geeft tot je schijf.

Een aangepaste NGINX Docker-image bouwen

Een lokale map mounten is een snelle oplossing voor simpel testen. Misschien wil je extra modules, speciale configuratie of een andere tweak. Dan is een image bouwen handig. 

Docker maakt het eenvoudig om een klein receptbestand te maken, een Dockerfile, die een container precies zo inricht als jij wilt. Daarna heb je een image die je kunt delen met anderen of naar een registry kunt pushen. Dat kan handiger zijn dan mensen vragen om allerlei lokale bestanden te mounten.

Een Dockerfile maken

Een Dockerfile is gewoon een tekstbestand. Je kunt het Dockerfile noemen of een andere naam kiezen. Plaats het in een nieuwe directory. Hier is een eenvoudig voorbeeld:

FROM nginx:latest

COPY index.html /usr/share/nginx/html/index.htmlMogelijk gemaakt door

Dit gebruikt de officiële nginx:latest-image als basis. Vervolgens kopieert het een lokaal bestand met de naam index.html naar de standaardmap voor webcontent in de container. Je kunt meer regels toevoegen als dat nodig is. Je kunt bijvoorbeeld een aangepaste nginx.conf kopiëren of modules toevoegen die je wilt installeren. Dat hangt af van je behoeften. Als je alleen een statische pagina wilt plaatsen, is het bovenstaande snippet voldoende.

Als je die Dockerfile klaar hebt, voeg je de aangepaste index.html toe in dezelfde map. Daarna kun je bouwen. Het gebruikelijke commando is:

docker build -t mynginximage .
[+] Building 2.6s (7/7) FINISHED                                                                                                                                                       docker:desktop-linux
 => [internal] load build definition from Dockerfile                                                                                                                                                   0.0s
 => => transferring dockerfile: 245B                                                                                                                                                                   0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                                                                                                                        0.0s
 => [internal] load .dockerignore                                                                                                                                                                      0.0s
 => => transferring context: 2B                                                                                                                                                                        0.0s
 => [internal] load build context                                                                                                                                                                      0.0s
 => => transferring context: 365B                                                                                                                                                                      0.0s
 => [1/2] FROM docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => => resolve docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => [2/2] COPY index.html /usr/share/nginx/html/index.html                                                                                                                                             0.0s
 => exporting to image                                                                                                                                                                                 0.1s
 => => exporting layers                                                                                                                                                                                0.0s
 => => exporting manifest sha256:19dd719772fd7ac839fadb7d49862f84422f4571a442994ffaca152e9674553a                                                                                                      0.0s
 => => exporting config sha256:e974f3ab92a0278e419f0fe4c5a6fc43fafb4a75da27895d90c4f2d5d385daa1                                                                                                        0.0s
 => => exporting attestation manifest sha256:e391b0212e5a100bd9132fbbd6cb4052e288dbbcba093839b55f8b197131372b                                                                                          0.0s
 => => exporting manifest list sha256:d35c2bbe10ab0b7e46d1ef8fba6c6cb28628eb9c283db02607e32e95b62e14d5                                                                                                 0.0s
 => => naming to docker.io/library/mynginximage:latest                                                                                                                                                 0.0s
 => => unpacking to docker.io/library/mynginximage:latest                                                                                                                                              0.0sMogelijk gemaakt door

De punt aan het einde geeft de huidige directory aan als buildcontext. Docker leest de Dockerfile in die directory. Je eindigt met een image genaamd mynginximage op je lokale systeem. Controleer met:

docker images
mynginximage                                                                   latest                                                                        d35c2bbe10ab   36 seconds ago   281MBMogelijk gemaakt door

Je zou de nieuwe naam in de lijst moeten zien. Deze aanpak betekent dat je Dockerfile en HTML zijn samengevoegd in één image. Je hoeft tijdens runtime niets te mounten.

De aangepaste image bouwen en draaien

Nu je mynginximage hebt gebouwd, kun je hem draaien:

docker run --name mycustomnginx -p 8080:80 -d mynginximageMogelijk gemaakt door

Zorg dat je de vorige container stopt om poortconflicten te voorkomen. 

Deze container serveert automatisch de pagina die je in de Dockerfile hebt geplaatst. Als je een browser opent op http://localhost:8080, zou je die HTML-tekst moeten zien. 

Je kunt je Dockerfile delen met anderen of de gebouwde image naar een registry pushen. Dan kunnen je teamgenoten of collega’s hem opzetten zonder lokale mappen te kopiëren.

Daarmee rond je het bouwen van een minimale aangepaste NGINX-image af. Je begon met de officiële basis, kopieerde een of twee bestanden en produceerde een nieuwe container die je eigen site bevat. Je kunt de Dockerfile verder uitbreiden. Bijvoorbeeld door de configuratie te wisselen om PHP met php-fpm in een multistage build af te handelen of modules toe te voegen die NGINX standaard niet meelevert.

Deze aanpak onderstreept de flexibiliteit van Docker: elke laag in de Dockerfile kan een bepaalde taak uitvoeren, en de uiteindelijke image is gemakkelijk te distribueren. Je hebt controle over de webcontent, plus de mogelijkheid om instellingen te tweaken zodat je container bij je project past. 

Verken deze 10 Docker-projectideeën om Docker te leren met hands-on projecten gericht op het bouwen en optimaliseren van data science-applicaties.

NGINX instellen als reverse proxy

NGINX kan inkomende requests doorsturen naar andere services op hetzelfde systeem of zelfs naar services op aparte machines. Dit wordt doorgaans een reverse proxy-setup genoemd. Je kunt NGINX vóór een groep applicaties plaatsen zodat requests via één enkel toegangspunt verlopen. 

Dit is gebruikelijk wanneer je meerdere Docker-containers hebt die op verschillende poorten luisteren en je één domeinnaam voor alles wilt. NGINX luistert op een standaardpoort, zoals 80 of 443, en routeert vervolgens het verkeer naar de juiste service op basis van pad, hostnaam of andere factoren.

Reverse proxy begrijpen

Wanneer NGINX op deze manier is geconfigureerd, is de client zich niet bewust van de communicatie op de achtergrond. NGINX fungeert als het publieke gezicht, ontvangt en forward requests en stuurt vervolgens responses terug naar de client. 

Dit ontwerp vereenvoudigt je netwerkstructuur. Het biedt ook de mogelijkheid om caching aan te passen, TLS-certificaten toe te voegen, load balancing te regelen of andere geavanceerde taken uit te voeren. Het is vaak eenvoudiger om dit op één plek te beheren dan het over meerdere services te verspreiden.

Een typisch scenario kan een container zijn die NGINX op poort 80 draait en requests doorstuurt naar een applicatiecontainer op poort 3000. Terwijl de client http://yourdomain.com bezoekt, wordt het verkeer achter de schermen naar een aparte container geleid. 

Dat kan je applicatiecontainer toestaan zijn standaardpoort te behouden, met minimale overhead voor de gebruiker. Een andere reden is dat je de interne details van je services wilt verbergen of een uniforme URL-structuur wilt presenteren.

NGINX configureren voor reverse proxy

Hiervoor heb je een configuratiebestand nodig voor aangepaste NGINX dat proxy-directives gebruikt. Je kunt dit doen door een nieuw configuratiebestand te mounten wanneer je de container draait, of door een aangepaste image te bouwen die het bevat. Hier is een eenvoudig voorbeeld om het algemene idee te illustreren:

server {
    listen 80;

    location / {
        proxy_pass http://myapp:3000/;
    }
}Mogelijk gemaakt door

In het bovenstaande snippet wordt elke request die op poort 80 bij je NGINX-container binnenkomt, doorgestuurd naar myapp:3000. De naam myapp suggereert dat er een andere container is die onder die naam bereikbaar is, wat gebruikelijk is met Docker-netwerken. 

Gebruik je losse containers, dan kun je het IP-adres van de container mappen of het IP van de host gebruiken. Je kunt ook uitgebreidere instellingen toevoegen, zoals proxy_set_header Host $host, of timeouts aanpassen aan je applicatie.

Als je ervoor kiest om dit bestand tijdens runtime te mounten, kun je zoiets doen als:

docker run --name nginxproxy -p 8080:80 -d \
    -v /path/to/nginx.conf:/etc/nginx/conf.d/default.conf \
    --network mynetwork \
    nginxMogelijk gemaakt door

Dit commando draait de NGINX-container en mount je lokale nginx.conf als de standaardconfiguratie. Het verbindt de container ook met een Docker-netwerk genaamd mynetwork, waar je andere container (myapp) zich bevindt. Dat is vaak de eenvoudigste aanpak als je je configuratie buiten de container wilt houden. 

Je kunt dat bestand ook in een Dockerfile stoppen als je een statische inrichting wilt. Beide benaderingen werken, zolang de verwijzingen overeenkomen met hoe je je containers en netwerken hebt benoemd.

Dit ontwerp geeft je de mogelijkheid om één domein of IP voor al je webservices te hebben, samen met een gemeenschappelijke poort. Als je met meerdere back-endcontainers werkt, kun je meerdere locations in je configuratie definiëren, elk wijzend naar een andere containerpoort. NGINX kan dan naar elke service routeren op basis van het URL-pad. Dat is een populaire aanpak voor microservices omdat het de toegangspunten overzichtelijk bundelt.

Docker Compose gebruiken voor NGINX-deployment

Een reverse proxy wordt vaak nuttiger wanneer je meerdere containers hebt die samenwerken. Docker Compose is een tool waarmee je veel services in één bestand kunt definiëren. Vervolgens kun je ze met één commando op- of afschalen. Het verkleint de kans op fouten bij het aanmaken van containers of het mappen van poorten, omdat alle details in een standaardbestand staan.

Introductie tot Docker Compose

Docker Compose stelt je in staat sets van containers te beheren. Je beschrijft elke service, specificeert de te gebruiken image, te publiceren poorten, te mounten volumes en toe te treden netwerken. Daarna start een simpel commando (docker compose up -d) alles in één keer. 

Deze aanpak is handig voor lokale development of staging-omgevingen waar je meerdere Docker-containers moet coördineren. Het gebruikelijke bestandsformaat is YAML.

Hoewel Docker Compose op verschillende besturingssystemen kan werken, moet je ervoor zorgen dat het is geïnstalleerd en herkend. Moderne Docker Desktop-installaties bevatten het vaak standaard. Controleer je versie met:

docker compose version
Docker Compose version v2.33.1-desktop.1Mogelijk gemaakt door

Zie je de versiedetails, dan kun je verder. Zo niet, raadpleeg dan de Docker-documentatie om te zien hoe je Docker Compose inschakelt of installeert.

Een docker-compose.yml-bestand maken

Het bestand bevat doorgaans een services-sectie. Hieronder staat een eenvoudig voorbeeld van een docker-compose.yml-bestand dat een enkele NGINX-container opzet om statische content te serveren: 

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/htmlMogelijk gemaakt door

Zo lees je het bestand:

• services: Definieert de services (containers) die je applicatie vormen.

• web: Deze service gebruikt de nieuwste NGINX-image.
• ports: Mappt poort 80 in de container naar poort 8080 op je hostmachine. Hierdoor kun je de webserver bereiken via http://localhost:8080.
• volumes: Mount de lokale html-directory naar de standaard contentmap van NGINX in de container (/usr/share/nginx/html). Deze setup stelt NGINX in staat je aangepaste statische content te serveren.

Services deployen met Docker Compose

Maak in dezelfde directory als je docker-compose.yml-bestand een submap met de naam html.

Plaats je statische HTML-bestanden (bijv. index.html) in deze map html. In dit geval heb ik ter demonstratie een eenvoudige pagina met Bootstrap-styling gemaakt. 

Open een terminal en navigeer naar je projectdirectory met het docker-compose.yml-bestand.

Voer het volgende commando uit om de service te starten:

docker compose up -d
[+] Running 1/1
 ✔ Container html_content-web-1  Started Mogelijk gemaakt door

De vlag -d draait de container in detached-modus, zodat hij op de achtergrond blijft draaien.

Docker Compose kijkt naar het docker-compose.yml-bestand in de huidige directory. Het pullt images die nog niet aanwezig zijn en start vervolgens elke container. 

Open je webbrowser en ga naar http://localhost:8080.

Je zou je statische content door NGINX geserveerd moeten zien.

Je kunt de status van je draaiende services inspecteren met:

docker compose psMogelijk gemaakt door

Moet alles down, dan kan één commando de containers verwijderen:

docker compose downMogelijk gemaakt door

Dat stopt en verwijdert ze allemaal in één keer. Wil je de volledige omgeving reproduceren, kopieer dan simpelweg het Docker Compose-bestand en de relevante code naar een nieuwe machine en voer dezelfde commando’s uit. Zo krijg je consistente resultaten met minimale handmatige stappen.

NGINX-containers beheren

Hoewel de Docker Compose-aanpak populair is voor workflows met meerdere services, moet je soms gewoon één container of een kleine cluster beheren. Docker biedt een paar basiscommando’s om te zien wat er draait, containers te pauzeren of te stoppen en ze indien nodig te verwijderen. 

Deze zijn essentieel voor het huishoudelijk werk, zeker als je met meerdere NGINX-containers of herhaalde builds experimenteert.

Draaiende containers bekijken

Als je wilt zien welke containers draaien, kun je gebruiken:

docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginxMogelijk gemaakt door

Dat commando toont een tabel met actieve containers, elk met een ID, image, naam en meer. Wil je alle containers zien, inclusief gestopte, gebruik dan:

docker ps -aMogelijk gemaakt door

Dit toont elke container die op je systeem bestaat, ook degenen die geëindigd zijn. Het is vaak handig om te zien welke containers er nog staan van eerdere runs. Je kunt containers hebben met de namen mynginx, mycustomnginx of iets anders als je met meerdere images hebt geëxperimenteerd.

Containers stoppen en verwijderen

Ben je klaar met een container, dan kun je hem op naam stoppen:

docker stop mynginx
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginxMogelijk gemaakt door

Dat vertelt Docker om een stop-signaal naar de container te sturen, waardoor NGINX netjes zou moeten afsluiten. Wil je de container daarna meteen verwijderen, doe dan:

docker rm mynginxMogelijk gemaakt door

Wil je liever één commando dat in één keer stopt en verwijdert, probeer dan:

docker rm -f mynginxMogelijk gemaakt door

Dat forceert de verwijdering en stopt de container als hij nog draait. Wees voorzichtig met die aanpak in een productieomgeving, omdat het de container beëindigt zonder een graceful shutdown. Een ander huishoudcommando is docker rmi, dat images van je systeem verwijdert. 

Dat is handig als je bepaalde images niet langer nodig hebt en ruimte wilt vrijmaken. Docker verwijdert echter alleen images die niet worden gebruikt door een draaiende container.

Conclusie

NGINX in Docker is een handige manier om webpagina’s te serveren of verkeer naar andere services te routeren. Je kunt de officiële image draaien of je eigen bouwen met een eenvoudige Dockerfile. Docker Compose kan meerdere containers coördineren, waardoor complexe setups makkelijker te beheren zijn. 

Met deze methoden kun je content leveren, forwarding afhandelen en een betrouwbare omgeving voor webprojecten onderhouden. 

Wil je Docker liever hands-on leren? Bekijk dan onze Introduction to Docker Course en ontdek waarom het onmisbaar is in de toolkit van data-professionals.