Losjes gesproken begint Docker steeds meer op een universele pakketbeheerder te lijken die op alle mogelijke Linux-platforms werkt. Het neemt containers en gebruikt ze om een heel ander probleem op te lossen waarmee ontwikkelaars worden geconfronteerd. Het probleem is dat ontwikkelaars hun desktopbesturingssysteem (zoals Windows, macOS of Linux met een heleboel desktopgerelateerde pakketten) gebruiken om applicaties te schrijven. De applicatie die ze schrijven draait vaak op een heel ander besturingssysteem op een server ergens met een Linux-distributie die totaal anders is dan die van de laptop van de ontwikkelaar.
Met Docker is het de bedoeling dat uw applicatie verpakt wordt als een Docker-image. Het is de taak van Docker om deze afbeelding te nemen en deze als een containertoepassing voor u uit te voeren. Gecontaineriseerd zijn betekent dat de applicatie en zijn afhankelijkheden in een geïsoleerde omgeving zullen draaien die volledig kan verschillen van de laptop van de ontwikkelaar en zelfs de productieserver. Zolang ze allebei Docker ondersteunen, kunnen ze allebei dezelfde applicatie op exact dezelfde manier uitvoeren.
Anatomie van een Docker-afbeelding
Zoals eerder vermeld, draait een Docker-app op een overeengekomen omgeving. Nu is de vraag hoe creëren we die omgeving? De meeste applicatie-images zouden een Docker-basisimage importeren en hun applicatie daarop bouwen.
Applicaties worden gemaakt van softwarelagen. Een wordpress-containerimage wordt gebouwd met behulp van een httpd-containerimage die op zijn beurt bovenop een Ubuntu-image is gebouwd. De afbeelding waarop een nieuwere afbeelding is gebouwd, staat in Docker-terminologie bekend als de OUDERBEELD. In Dockerfile (we komen later op wat een Dockerfile betekent), wordt deze bovenliggende afbeelding bovenaan het bestand vermeld, zoals hieronder wordt weergegeven:
VAN Ubuntu: 18.04
## Rest van het Docker-bestand
Wanneer dit Dockerfile wordt uitgevoerd, wordt uw toepassing geconverteerd naar een Docker-image (een soort binair bestand) dat u vervolgens naar een register kunt pushen van waaruit het kan worden opgehaald om elders nieuwe containers te maken. Ze zullen echter allemaal Ubuntu:18.04 als hun basisimage hebben en werken alsof het een Ubuntu-systeem is waarin ze worden uitgevoerd.
Je hebt dit misschien opgemerkt toen je probeerde een nieuwe docker-afbeelding te maken.
Dit laat zien hoeveel lagen er worden getrokken voordat de daadwerkelijke toepassing (die misschien maar een paar Megabytes groot is) wordt binnengebracht.
Om deze reden willen we een zogenaamde basisafbeelding maken. Die nergens op gebouwd is. Het sleutelwoord scratch wordt gebruikt om aan te geven dat deze laag niet bovenop iets anders is gebouwd. Zoals zo:
Vanaf het begin## Rest van het Dcoker-bestand
We zullen eerst een eenvoudige hello-world applicatie maken en dan uitzoeken wat de rest van de Dockerfile gaat worden. Het hostsysteem is Ubuntu:18.04 LTS en we gebruiken Docker-versie 17.12.1-ce voor het experiment.
Een statisch binair bestand maken
Docker-containers zijn een verzameling processen die geïsoleerd van de rest van het besturingssysteem worden uitgevoerd. Het enige waar dat proces mee in aanraking komt, is de Kernel. Kernel is verantwoordelijk voor het plannen van deze processen op de CPU, geheugenbeheer en een paar andere basistaken voor het bijhouden van boekingen.
Maar de meeste toepassingen op hoog niveau zijn afhankelijk van veel systeembibliotheken (zoals glibc, musl, klibc, enz ) en veel runtime-afhankelijkheden zoals Python of Node.js of Java Runtime. Het binaire programma van de toepassing heeft niet alle beschikbare bibliotheken, maar wanneer het met de uitvoering begint, roept het die bibliotheken aan vanaf het hostbesturingssysteem.
Omdat we vanaf het begin een afbeelding proberen te maken, zouden we deze aardigheden niet krijgen. Onze applicatie moet dus een statisch bestand of een op zichzelf staand uitvoerbaar bestand zijn.
Laten we beginnen met het maken van een map met de naam MyDockerImage en daarin een bestand hello.cc maken.
$mkdirMijn Docker-afbeelding$CDMijn Docker-afbeelding
$aanrakenhallo.cc
Open hello.cc met uw favoriete teksteditor en voeg de volgende regels erin toe.
#erbij betrekkennamespace std; gebruiken;
inthoofd(){
kosten<< 'Hallo! Dit bericht komt uit een containerN';
opbrengst 0;
}
Dit is een eenvoudig C++-programma dat Hello! Dit bericht …
Om eerder besproken redenen zullen we dit compileren met behulp van de statische vlag. De gebruikte compiler is g++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0.
Om het programma te compileren, voert u in dezelfde map de volgende opdracht uit:
$ g++ -oh hallo-statischHallo.gelijkstroomDit creëert een binair uitvoerbaar bestand hallo in dezelfde map. Dat is ons statische bestand. Test of het werkt zoals bedoeld door de bestandsnaam in de terminal te vermelden.
$./Hallo 
Nu zijn we klaar om dit eenvoudige programma te containeriseren.
Dockerbestand
De Dockerfile bestaat uit een set regels die uw toepassingsbestanden (zoals binaire bestanden, bronbestanden, enz.) samen met verschillende configuratieparameters zoals bestandssysteemlay-out, blootgestelde poorten, enz. en verandert ze in een Docker-afbeeldingsbestand. U kunt het afbeeldingsbestand vervolgens delen met iedereen die die toepassing wil uitvoeren.
We zullen niet ingaan op elke beschikbare optie voor Dockerfile, in plaats daarvan zullen we een zeer minimalistische Dockerfile schrijven. Maak in dezelfde map, waar uw Hallo uitvoerbare bestand zich bevindt, een leeg bestand met de naam Dockerbestand.
$aanrakenDockerbestandOpen het met je favoriete teksteditor en schrijf er de volgende regels in:
VANAF het beginVOEG hallo toe/
CMD['/Hallo']
Kras is geen ouderbeeld. Het geeft Docker eerder aan dat de afbeelding niet bovenop een andere afbeelding is gebouwd. Het is vanaf nul opgebouwd. De opdracht ADD zou het statische binaire bestand |_+_|uit de huidige map nemen en het toevoegen aan de hoofdmap van het afbeeldingsbestand. Wanneer we eindelijk een container zouden uitvoeren op basis van deze afbeelding, zal het uitvoerbare hallo te zien zijn in de hoofdmap zelf op |__+_|
Ten slotte heeft de CMD-regel een string /Hallo deze tekenreeks wordt uitgevoerd als een shell-opdracht wanneer een container wordt gemaakt op basis van deze afbeelding, dus het binaire bestand dat we aan onze container hebben toegevoegd en het bericht afdrukken dat we in onze app hebben geschreven.
Laten we de afbeelding opbouwen door de . aan te roepen docker bouwen commando dat door de inhoud van de Dockerfile zou gaan en de afbeelding zou genereren. Voer de volgende opdracht uit in dezelfde map als de Dockerfile en het uitvoerbare binaire bestand.
$docker bouwen--labelHallo .De –tag hallo vlag stelt de afbeeldingsnaam in op Hallo en de punt ( . ) aan het einde vertelt docker bouwen om in de huidige map te kijken voor Dockerfile en gerelateerde inhoud.
De Docker-container uitvoeren
Om te controleren of de afbeelding die we zojuist hebben gemaakt, wordt weergegeven in de lijst met afbeeldingen, voert u het volgende uit:
$docker-afbeeldingen 
Merk op hoe klein de hallo-afbeelding is in vergelijking met andere afbeeldingen. Het is in ieder geval klaar om als container te draaien,
$havenarbeider, hallo 
Dat is het! Je hebt je eerste minimalistische container helemaal opnieuw gemaakt.
Andere opties
Hoewel het altijd een optie is om helemaal opnieuw afbeeldingen te maken, hebben mensen vaak de neiging om afbeeldingen te maken van andere lichtgewicht Linux-distributies. Afbeeldingen zoals alpine en busybox zijn bijvoorbeeld erg lichtgewicht omgevingen met kleinere bibliotheken zoals musl in plaats van glibc.
Gebruik ze als je ouderafbeelding door te gebruiken VAN alpine: laatste zou ook resulteren in kleinere afbeeldingen. Omdat de basisafbeeldingen slechts 2-5 MB groot zijn. Laat het ons weten als er een Docker-gerelateerd onderwerp is dat u ons als volgende wilt laten behandelen. U kunt ons bereiken op Twitter , Facebook of abonneer je op ons via e-mail.