Docker ENTRYPOINT uitgelegd: gebruik, syntaxis en best practices

Docker ENTRYPOINT is een Dockerfile-instructie die het standaardcommando definieert en beheert dat wordt uitgevoerd wanneer je container start. Als je ENTRYPOINT goed beheerst, wordt het eenvoudiger om voorspelbare, reproduceerbare en onderhoudbare containers te ontwikkelen die zich gedragen zoals verwacht. 

Deze gids helpt DevOps-engineers, backendontwikkelaars en software-engineers met enige ervaring om ENTRYPOINT vol vertrouwen te gebruiken en veelvoorkomende valkuilen te vermijden.

Ben je nieuw met Docker? Bekijk dan onze introductie tot de Docker-tutorial, want deze tutorial gaat uit van enige basiskennis van Docker. Wil je praktisch aan de slag met Docker, bekijk dan onze Introduction to Docker-cursus. 

Wat is Docker ENTRYPOINT?

ENTRYPOINT definieert het standaardcommando dat wordt uitgevoerd telkens wanneer je Dockercontainer start. In tegenstelling tot CMD zorgt de ENTRYPOINT-instructie voor consistentie door commando’s te bieden die elke keer dat de container start draaien.

Hoe werkt Docker ENTRYPOINT?

ENTRYPOINT in een Dockerfile definieert het hoofdcommando dat altijd draait wanneer je een container uit een image start. Het is alsof je zegt: “Welke argumenten de gebruiker ook meegeeft bij het starten van deze container, begin altijd met dit commando.”

We gaan dieper in op Dockerfiles in onze tutorial How to Containerize an Application Using Docker. 

Voorbeeld in een Dockerfile:

ENTRYPOINT ["python", "app.py"]Mogelijk gemaakt door

Als je nu draait:

docker run myimageMogelijk gemaakt door

Dan wordt altijd uitgevoerd:

python app.pyMogelijk gemaakt door

Hier is een stroomdiagram van hoe ENTRYPOINT werkt:

+---------------------------+

|       Dockerfile          |

+---------------------------+

|                           |

|  ENTRYPOINT ["app"]       |

|  CMD ["--default-arg"]    |

+---------------------------+

             |

             v

+---------------------------+

|   Build Docker Image      |

+---------------------------+

             |

             v

+---------------------------+

|    Run Container          |

|   (docker run image)      |

+---------------------------+

             |

             v

+---------------------------+

| Executed Command:         |

|   app --default-arg       |

+---------------------------+

Override CMD at Runtime:

(docker run image --custom-arg)

             |

             v

+---------------------------+

| Executed Command:         |

|   app --custom-arg        |

+---------------------------+

Override ENTRYPOINT at Runtime:

(docker run --entrypoint /bin/bash image)

             |

             v

+---------------------------+

| Executed Command:         |

|   /bin/bash               |

+---------------------------+Mogelijk gemaakt door

Basisprincipes van Docker ENTRYPOINT

De basis begrijpen vergroot je vertrouwen om ENTRYPOINT effectief te gebruiken.

Conceptueel kader

ENTRYPOINT specificeert het uitvoerbare bestand of script dat automatisch draait wanneer je container start. Het is het hoofdproces van je container en zorgt voor voorspelbaar gedrag.

Kernsynthaxis

De Dockerfile-syntaxis voor ENTRYPOINT is eenvoudig en wordt meestal samen met CMD gebruikt om standaardargumenten of -parameters te bieden. ENTRYPOINT definieert het uitvoerbare bestand, terwijl CMD standaardargumenten specificeert die door ENTRYPOINT worden gebruikt.

Het begrijpen van Docker-concepten zoals ENTRYPOINT is cruciaal om te excelleren in data science-sollicitaties. Verken veelvoorkomende vragen in onze Top 26 Docker Interview Questions and Answers for 2025. 

ENTRYPOINT-syntaxisvormen

Docker ENTRYPOINT kent twee verschillende vormen: shell- en exec-vorm. Het kennen van de verschillen helpt je om goed te kiezen.

Shell-vorm

Voorbeeldsyntaxis: 

ENTRYPOINT /usr/bin/ping -c 3 localhost

De shell-vorm biedt eenvoudige integratie van shellfuncties (variabele substitutie, omgevingsmanipulatie).

Maar het kan leiden tot slechte signaalafhandeling; het draait binnen een tussenliggend /bin/sh-proces in plaats van direct als PID 1, wat problemen kan geven bij het stoppen en herstarten van containers.

PID 1 is het eerste proces dat tijdens het opstarten van het systeem wordt gestart. In Docker beheert het PID 1-proces alle andere processen binnen de container. 

Exec-vorm

Voorbeeldsyntaxis: 

ENTRYPOINT ["/usr/bin/ping", "-c", "3"]

De exec-vorm zorgt voor directe commando-uitvoering als PID 1, wat leidt tot betrouwbare signaalafhandeling en controle.

Wel mist het directe shellondersteuning of automatische expansie van omgevingsvariabelen; voor shell-achtig gedrag is extra scripting nodig.

ENTRYPOINT vs CMD: belangrijkste verschillen en use-cases

Het onderscheiden van ENTRYPOINT en CMD voorkomt verwarring en zorgt voor voorspelbaar containergedrag.

Uitvoeringsprioriteit

ENTRYPOINT stelt het uitvoerbare bestand in dat altijd draait, terwijl CMD standaardargumenten levert. Als zowel ENTRYPOINT als CMD zijn gedefinieerd, krijgt ENTRYPOINT voorrang en wordt het uitgevoerd met de waarden van CMD als argumenten, tenzij dit expliciet tijdens runtime wordt overschreven.

Use-case-scenario’s

ENTRYPOINT gebruik je wanneer je bij elke start een consistent, afgedwongen commando wilt, zoals bij single-command-containers of wrapperscripts rond legacy-applicaties. CMD is daarentegen geschikt om standaardargumenten te specificeren, met meer flexibiliteit voor runtime-overrides.

Onze Top 18 Docker Commands to Build, Run, and Manage Containers behandelt essentiële Docker-commando’s, van containerbasis tot volumes en networking, zodat je applicaties vol vertrouwen in verschillende omgevingen kunt beheren.

Praktisch voorbeeld

Een typische combinatie van ENTRYPOINT en CMD wordt geïllustreerd door deze Dockerfile:

FROM ubuntu
ENTRYPOINT ["/usr/bin/ping", "-c", "3"]
CMD ["localhost"]Mogelijk gemaakt door

Deze Dockercontainer verstuurt standaard altijd drie pings naar localhost. Gebruikers kunnen dit standaarddoel tijdens runtime eenvoudig overschrijven met andere hosts, terwijl het voorspelbare gedrag van ENTRYPOINT behouden blijft:

docker run ping-container google.comMogelijk gemaakt door

Meer leren over het deployen van applicaties met Docker? Bekijk onze cursus Containerization and Virtualization with Docker and Kubernetes. 

ENTRYPOINT combineren met CMD

Door ENTRYPOINT op de juiste manier te combineren met CMD krijg je flexibiliteit zonder consistentie te verliezen.

CMD als standaardargumenten

Met ENTRYPOINT stel je het hoofdcommando betrouwbaar in; CMD levert standaardparameters die je eenvoudig kunt overschrijven zonder images te herbouwen.

Runtime-overrides van argumenten

Argumenten die je meegeeft bij docker run overschrijven alleen de door CMD gedefinieerde standaardwaarden. ENTRYPOINT blijft consistent, wat de gebruikerservaring vereenvoudigt.

ENTRYPOINT tijdens runtime overschrijven

Docker laat toe om ENTRYPOINT direct tijdens runtime te overschrijven, zodat je kunt debuggen zonder je Dockerfile-image te herbouwen.

Gebruik van de entrypoint-vlag

Docker biedt een eenvoudige vlag --entrypoint die het containergedrag tijdelijk wijzigt.

docker run -it --entrypoint /bin/bash my-containerMogelijk gemaakt door

Tijdelijke overrides maken troubleshooting via de shell mogelijk, zodat je veelvoorkomende opstartproblemen kunt oplossen zonder images te herbouwen of noemenswaardige vertragingen.

ENTRYPOINT-gedrag aanpassen

Docker biedt flexibiliteit wanneer ENTRYPOINT geavanceerdere aanpassing vereist.

ENTRYPOINT tijdens runtime overschrijven

Je kunt het ENTRYPOINT-commando dynamisch tijdens runtime overschrijven met docker run --entrypoint om snel te debuggen of van context te wisselen zonder je Dockerfile telkens aan te passen.

ENTRYPOINT met argumenten

Argumenten die aan containers worden doorgegeven, worden tijdens runtime ENTRYPOINT-parameters; best practices adviseren om de complexiteit van ENTRYPOINT minimaal te houden en CMD te gebruiken voor maximale duidelijkheid en controle.

Wrapperscripts

Bash-scripts die als ENTRYPOINT-commando’s worden gebruikt, kunnen conditionele opstartlogica uitvoeren, wachten op afhankelijke services (zoals databases), setuptaken afhandelen en meer, terwijl de Dockerfile-syntaxis overzichtelijk blijft.

Praktijkvoorbeelden en patronen

Praktische ENTRYPOINT-toepassingen laten typische, realistische gebruiken zien. Laten we er een paar bekijken.

Single-command-containers 

Voor een Flask-setup:

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["python", "app.py"]
CMD ["--port", "8080"]Mogelijk gemaakt door

In bovenstaande Dockerfile:

• ENTRYPOINT ["python", "app.py"]  stelt het standaarduitvoerbare commando in. Dit draait wanneer de container start.
• CMD ["--port", "8080"]  levert standaardargumenten (--port 8080) aan het ENTRYPOINT-commando.

Het volledige standaardcommando dat wordt uitgevoerd, is:

python app.py --port 8080Mogelijk gemaakt door

 Als je CMD overschrijft bij het draaien van de container (bijv. docker run myimage --port 9090), vervangt dat --port 8080.

Script als ENTRYPOINT 

Dit wordt gebruikt om conditionele logica in te richten: 

entrypoint.sh:

#!/bin/sh
until nc -z db_host 5432; do
  echo "Waiting for database to become available."
  sleep 2
done
exec python app.py "$@"Mogelijk gemaakt door

Dockerfile:

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
COPY entrypoint.sh .
RUN chmod +x entrypoint.sh
ENTRYPOINT ["./entrypoint.sh"]
CMD ["--port", "8080"]Mogelijk gemaakt door

In bovenstaande bestanden:

• entrypoint.sh wordt gebruikt om te wachten op de databaseverbinding.
• exec python app.py "$@"  vervangt het huidige shellproces door python app.py en geeft eventuele extra argumenten door. "$@" komt van CMD of docker run-parameters.
• COPY entrypoint.sh  kopieert het script entrypoint.sh naar de /app-directory van de container.
• ENTRYPOINT ["./entrypoint.sh"] stelt entrypoint.sh in als het standaard opstartscript wanneer de container draait.
• CMD ["--port", "8080"] levert standaardargumenten die worden doorgegeven aan het entrypoint.sh-script en uiteindelijk aan python app.py. Het uiteindelijke commando ziet er zo uit: python app.py --port 8080. 

Signaalafhandeling en PID 1

De vorm van ENTRYPOINT heeft een grote impact op Docker’s vermogen om signalen af te handelen vanwege het belang van PID 1. Laten we dat verder verkennen: 

Exec-vorm en PID 1

Exec-vorm draait commando’s rechtstreeks als Docker’s PID 1-proces, wat de betrouwbaarheid van signaaldoorgifte en correct stoppen of herstarten verbetert.

Beperkingen van de shell-vorm

Shell-vorm voegt een tussenliggende shell toe. Hierdoor bereiken terminatiesignalen de applicatieprocessen niet goed, met het risico op vastgelopen of niet-reagerende containers.

ENTRYPOINT-gedrag debuggen

Het troubleshooten van entrypoint-configuraties wordt eenvoudiger met bepaalde technieken en trucjes. Laten we die hieronder bekijken. 

--entrypoint gebruiken voor debugging

Tijdelijke overrides maken snel interactieve debuggingshells binnen je containers mogelijk zonder images te herbouwen. Zo kun je verschillende zaken in je applicatie testen zonder de image opnieuw te bouwen. 

ENTRYPOINT-logs bekijken

Het checken van uitvoerlogs met docker logs vereenvoudigt het traceren van de uitvoering en het snel en duidelijk vinden van configuratieproblemen.

Dockerfile niet aanpassen voor tijdelijk testen

Debugvriendelijke runtime-overrides van ENTRYPOINT laten je issues isoleren en corrigeren zonder containerimages steeds opnieuw te wijzigen en te bouwen.

Optimalisatietechnieken en best practices

Hieronder staan enkele aanbevolen optimalisaties om de betrouwbaarheid en het onderhoud van ENTRYPOINT te verbeteren.

Gebruik exec-vorm voor signaalafhandeling

Geef altijd de voorkeur aan de exec-vorm voor correcte terminatiesignalen en betere algehele betrouwbaarheid en beheerbaarheid van containers.

ENTRYPOINT en CMD effectief combineren

Scheid je uitvoerbare bestand (ENTRYPOINT) van standaard runtime-argumenten (CMD) en gebruik runtime-overrides voor maximale flexibiliteit en eenvoudig beheer.

Beperk complexiteit in ENTRYPOINT

Houd ENTRYPOINT eenvoudig en verplaats complexe opstartlogica of -condities naar aparte scripts om de complexiteit beheersbaar te houden en de helderheid te vergroten.

Geavanceerde use-cases en patronen

Laten we enkele geavanceerde ENTRYPOINT-use-cases en patronen verkennen.

Multistage-builds met ENTRYPOINT

ENTRYPOINT in de uiteindelijke Dockerstages zorgt voor betrouwbare uitvoering en levert schonere builds die specifiek zijn afgestemd op productietaken binnen CI/CD-workflows.

Dynamische ENTRYPOINT-scripts

ENTRYPOINT-scripts kunnen hun opstartlogica dynamisch aanpassen op basis van omgevingsvariabelen of runtime-argumenten, zodat ze naadloos inspelen op verschillende applicatiecontexten.

ENTRYPOINT voor CI/CD-pijplijnen

Het inzetten van ENTRYPOINT verbetert de consistentie tussen test- en productieomgevingen en zorgt voor voorspelbaar runtimegedrag en herhaalbaarheid. Je kunt bijvoorbeeld ENTRYPOINT instellen op een script dat automatisch tests draait. 

Andere toepassingen zijn onder meer: 

• Een ENTRYPOINT dat wacht op de database, vervolgens migraties uitvoert en ten slotte de app start.
• Een ENTRYPOINT dat assets compileert, code lint of configuraties automatisch valideert.
• ENTRYPOINT-scripts kunnen omgevingen (dev, staging, productie) detecteren en instellingen bij de containerstart dienovereenkomstig aanpassen. 

Hier is een voorbeeld van een Dockerimage dat automatisch tests draait:

FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["pytest"]Mogelijk gemaakt door

Het .gitlab-ci.yml ziet er zo uit:

build-test:
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t myapp-test .
    - docker run myapp-test  # <-- No need to specify 'pytest', ENTRYPOINT does itMogelijk gemaakt door

Wanneer docker run wordt uitgevoerd, triggert dit automatisch pytest in de container. Zo worden alle tests meteen gevonden en uitgevoerd. 

Er zijn verschillende voordelen aan het gebruik van ENTRYPOINT in CI/CD:

• Elke container start en gedraagt zich op dezelfde manier. 
• Vereenvoudigt CI/CD-scripts omdat je niet telkens volledige commando’s hoeft mee te geven. 
• Automatiseert pre-start-checks, testruns en migraties, waardoor de kans op menselijke fouten kleiner wordt. 

Veelvoorkomende valkuilen en troubleshooting

ENTRYPOINT kent enkele valkuilen die je in je workflows het best vermijdt.

Verkeerd gebruik van de shell-vorm

Shell-vorm belemmert signalen en containerbeheerders; geef altijd de voorkeur aan de exec-vorm voor correcte signaalafhandeling, nette containerexits en schoon stoppen.

ENTRYPOINT onnodig ingewikkeld maken

Complexe scripts zonder helderheid of betrouwbaarheid maken debuggen en onderhoud lastiger. Eenvoudige ENTRYPOINT-sets maken troubleshooting aanzienlijk makkelijker.

Conclusie

Door Docker ENTRYPOINT goed te begrijpen en toe te passen, bouw je voorspelbare, betrouwbare en onderhoudbare Dockercontainers voor je applicaties. Correct gebruikt creëert ENTRYPOINT consistentie zonder flexibiliteit op te offeren dankzij Docker’s krachtige overridesysteem. Door zorgvuldig te experimenteren met ENTRYPOINT-patronen en de hierboven beschreven best practices te volgen, wordt Dockergebruik aanzienlijk eenvoudiger en leiden deployments en beheer in productie tot soepelere cycli.

Bekijk onze Docker-cursussen om meer Docker-onderwerpen te verkennen, zoals:

• Introduction to Docker
• Containerization and Virtualization Concepts 
• Containerization and Virtualization with Docker and Kubernetes
• Intermediate Docker