Als je ooit een opdracht of twee moest uitvoeren in je Docker-container bij het opstarten, is deze handleiding iets voor jou. Met de Dockerfile ENTRYPOINT en CMD instructies kun je zoveel opstartopdrachten uitvoeren als je wilt.
In deze handleiding leer je hoe je de ENTRYPOINT en CMD instructies gebruikt om opstartopdrachten uit te voeren in een Dockerfile en begrijp je de verschillen tussen hen.
Vereisten
Omdat deze handleiding een praktische demonstratie zal zijn, zorg ervoor dat je het volgende klaar hebt staan:
- A Windows 10 PC – Windows 10 v10.0.19042 was used in this tutorial.
- Docker Desktop – Deze handleiding maakt gebruik van Docker Desktop v3.3.1.
Creëren van een Dockerfile
Voordat je Docker-container-opstartopdrachten kunt uitvoeren, moet je eerst een Dockerfile maken. Een Dockerfile is een tekstbestand dat een lijst met opdrachten bevat om containers te bouwen, Docker-images te maken en bepaalt hoe een Docker-image wordt gemaakt.
1. Open eerst PowerShell als administrator.
2. Maak een nieuwe map aan om het Docker-bestand en alle bijbehorende bestanden op te slaan die in deze tutorial worden gebruikt, en ga naar die map. Deze tutorial maakt gebruik van ~/docker.
3. Maak nu een leeg tekstbestand met de naam Dockerfile met de volgende opdracht.
Als alternatief kunt u een Dockerfile maken met de volgende opdracht als u Linux of Mac OS gebruikt.
4. Voeg tot slot de volgende inhoud toe aan het Dockerfile
U heeft nu een binnenkort te gebruiken Dockerfile gemaakt!
Het bouwen van een Docker-image
Nu u uw Dockerfile heeft gemaakt, moet u een Docker-image bouwen om de opdrachten uit te voeren die in uw Dockerfile ENTRYPOINT- en CMD-instructies zijn geschreven. Een manier om een image te bouwen, is door de build-opdracht te gebruiken.
Terwijl u zich in de ~/docker-map bevindt, voert u de volgende opdracht uit. De onderstaande opdracht maakt een Docker-image met de naam demo (-t demo) vanuit het Docker-bestand in ~/docker door de huidige werkmap op te geven (.).
Het uitvoeren van een Docker-container
Nadat u het Docker-image heeft gebouwd, heeft u een container nodig om het Docker-image uit te voeren dat de opdrachten uitvoert uit de Dockerfile ENTRYPOINT- en CMD-instructies.
Om een Docker-container uit te voeren, roep je het run commando aan om een beschrijfbare containerlaag over de Docker-image (demo) te creëren. Het onderstaande voorbeeld maakt gebruik van de -it parameter om interactief verbinding te maken met de container, zodat je de voorbeelduitvoer kunt zien.
Exec vs. Shell Form
Wanneer je begint te werken met een Dockerfile en ontdekt hoe je opstartopdrachten kunt uitvoeren, kom je misschien twee verschillende methoden tegen om deze opdrachten te definiëren. Elke methode roept opdrachten aan, maar doet dit op een iets andere manier.
Wanneer Docker opdrachten uitvoert, kan dit rechtstreeks worden gedaan via exec of via de shell van de container (/bin/sh -c op Linux of cmd /S /C op Windows) genaamd shell.
Je zult merken dat opdrachten die worden uitgevoerd via exec een instructie hebben gevolgd door de uitvoerbare bestanden om aan te roepen gevolgd door één of meer commandoregelargumenten, zoals hieronder getoond.
Het schrijven van opdrachten in shell vorm vereist daarentegen niet dat opdrachten in vierkante haken worden geplaatst, zoals hieronder getoond.
Als je geen argument opgeeft aan
CMD, zal Docker altijd het commando uitvoeren in exec-vorm, bijvoorbeeldCMD <commando>.
Als je net begint, maakt het niet veel uit om onderscheid te maken tussen deze twee commando-oproepen, maar naarmate je meer gevorderd raakt, zul je al snel de voor- en nadelen van elk zien.
Het uitvoeren van opstartopdrachten
Laten we nu de kern van deze handleiding ingaan en je handen vuil maken door een paar voorbeelden door te lopen van het uitvoeren van opstartopdrachten binnen een Dockerfile met de instructies ENTRYPOINT en CMD.
1. Open de Dockerfile die je eerder hebt aangemaakt in je favoriete teksteditor.
2. Kopieer en plak de inhoud van het voorbeeld Dockerfile in je Dockerfile, zoals hieronder weergegeven, en sla het op.
Deze Dockerfile maakt een laag met gebruik van de ubuntu:20.04 als basisimage. Het vertelt vervolgens Docker om de echo-opdracht aan te roepen en geeft het de argumenten Hello world voor zowel de Dockerfile CMD als ENTRYPOINT instructies met gebruik van exec en shell vormen.
3. Terwijl je je in de ~/docker directory bevindt, bouw je het nieuwe image door docker build uit te voeren en noem het demo. De onderstaande opdracht tagt het image als demo en zoekt naar een Dockerfile in de huidige werkdirectory (.).
4. Voer nu een container uit met behulp van het image en start een Docker-container op basis van het eerder gemaakte Docker-image. Je zult nu zien dat de container Hello world retourneert, wat afkomstig is van de CMD-instructie die in de Dockerfile is opgegeven.
Het gebruik van variabelen in een Dockerfile
Soms ken je mogelijk de exacte commandoregelargumenten die je vooraf aan een commando moet doorgeven niet. De argumenten die je aan een commando moet doorgeven, worden alleen tijdens runtime blootgelegd. In plaats van statisch commandoregelargumenten toe te wijzen, kun je die argumenten vastleggen en doorgeven aan commando’s met variabelen.
Je kunt Dockerfile-variabelen alleen gebruiken in de
shell-vorm. Docker ondersteunt geen variabelen in commando’s die worden aangeroepen via deexec-vorm.
Open de Dockerfile opnieuw in je favoriete teksteditor, vervang alles binnenin door de volgende reeks commando’s en sla het op.
Je zult merken dat deze keer de Dockerfile omgevingsvariabelen gebruikt en deze worden weergegeven met ENV. In het onderstaande voorbeeld definieert de Dockerfile een omgevingsvariabele genaamd name met een waarde van friend. Eenmaal gemaakt, wordt deze omgevingsvariabele vervolgens aangeroepen via $name.
Wanneer Docker een container uitvoert op basis van deze Dockerfile, zal het het echo-commando oproepen en het argument Welcome, friend doorgeven.
Maak nu de Docker-image en voer de container opnieuw uit, eventueel met opgave van een tag-naam shellform. Je zult merken dat Docker het echo-commando aanroept en de verwachte output retourneert.
Combinatie van Dockerfile ENTRYPOINT- en CMD-instructies.
Veel van de tijd zul je opstartopdrachten aanroepen in CMD of ENTRYPOINT-instructies. Uiteindelijk kun je zoveel opdrachten aanroepen als je wilt met elk van deze methoden. Maar je kunt ook één opdracht aanroepen en er “op voortbouwen” met behulp van beide instructies.
Voortbouwend op de vorige voorbeelden, misschien heb je een Dockerfile die eruitziet als het onderstaande voorbeeld. Zoals het is, als je een image maakt en een container uitvoert vanaf die image, zou Docker de echo-opdracht aanroepen en Hello retourneren.
Misschien heb je nog een argument dat je aan de echo-opdracht wilt doorgeven, maar niet meteen. Misschien wil je dat verderop in de Dockerfile doen. Door de CMD-instructie aan te roepen zonder een opdracht, kun je dat doen.
Wanneer je een opdracht specificeert om uit te voeren via de
ENTRYPOINT-instructie gevolgd door deCMD-instructie, neemt Docker automatisch aan dat de waarde die aanCMDwordt doorgegeven een argument is; geen opdracht.
Voeg nu een referentie naar een CMD-instructie toe zonder een opdracht, alleen een argument genaamd world, zoals hieronder getoond.
Het combineren van instructies moet altijd in exec-vorm worden geschreven vanwege het “array-achtige” gedrag van het specificeren van waarden afzonderlijk gescheiden door komma’s versus alles in één string.
Na het bouwen van het image en het uitvoeren van de container vanaf het image, kun je zien dat in plaats van twee regels output (Hello en world), Docker slechts één regel retourneert, wat betekent dat slechts één echo-opdracht wordt aangeroepen.
Conclusie
Je zou nu een goed begrip moeten hebben van het uitvoeren van Docker-containeropstartopdrachten via zowel de CMD– als ENTRYPOINT-instructies in een Docker-bestand. Elke instructie is een beetje anders maar bereikt dezelfde taak en kan zelfs samen worden gebruikt.
Kun je een scenario bedenken waarin je de voorkeur zou geven aan het gebruik van CMD boven ENTRYPOINT om een opstartopdracht uit te voeren?