Docker tutorial: de container-service installeren en gebruiken

Zijn Docker-containers een goed alternatief voor de gangbare virtuele machines?

’Build, Ship and Run Any App, Anywhere’ – dit is het motto van de open source container-service Docker, een flexibel en efficiënt alternatief om hardwarecomponenten op basis van virtuele machines (VM's) te emuleren. In deze Docker-tutorial voor beginners gaan we in op de verschillende virtualisatietechnieken en stellen het open source-project Docker voor door middel van een gedetailleerde handleiding.

Bij de klassieke hardwarevirtualisatie worden verschillende gastbesturingssystemen op een hoofdbesturingssysteem opgestart. Met Docker lopen de applicaties als geïsoleerde processen op één fysiek systeem met behulp van zogenoemde containers. Als het gaat om virtualisatie op basis van containers heb je het daarom ook vaak over operating system-level virtualization.

In de onderstaande grafiek zijn de belangrijkste verschillen wat betreft de architectonische opbouw van de twee virtualisatietechnieken te zien.

Terwijl iedere virtuele machine een eigen besturingssysteem heeft, delen Docker-containers de kernel van het hostsysteem

Beide technieken geven ontwikkelaars en systeembeheerders de mogelijkheid om verschillende applicaties met verschillende eisen tegelijkertijd op één fysiek systeem te gebruiken. Er zijn echter grote verschillen wat betreft efficiëntie en portabiliteit.

Container: overhead bij virtualisatie voorkomen

Als toepassingen in het kader van klassieke hardwarevisualisatie worden afgeschermd, gebeurt dit met behulp van een zogenoemde hypervisor. De hypervisor is een abstractielaag tussen het hostsysteem en de virtuele gastsystemen. Ieder gastsysteem wordt in dit geval als complete machine met eigen besturingssysteem-kernel gerealiseerd. De hardwareresources van het hostsysteem (CPU, geheugen, plaats op de harde schijf, beschikbare randapparatuur) worden door de hypervisor evenredig verdeeld.

Daarentegen wordt bij de virtualisatie met containers geen compleet gastsysteem nagebootst. In plaats daarvan worden applicaties in containers opgestart. Deze delen weliswaar dezelfde kernel, namelijk de kernel van het hostsysteem, maar draaien als geïsoleerde processen binnen de user-space.

Het grote voordeel van virtualisatie op basis van containers is dus het feit dat je applicaties met verschillende systeemeisen geïsoleerd van elkaar kunt uitvoeren zonder overhead door een afzonderlijk gastsysteem. De container-technologie maakt gebruik van twee basisfuncties van de Linux-kernel: control groups (Cgroups) en kernel-namespaces.

• Cgroups beperken de toegang van processen op resources zoals het geheugen, CPU en I/O-poorten en voorkomen zo dat het proces zoveel resources gebruikt, dat andere lopende processen worden belemmerd.

• Namespaces (naamruimtes) zorgen ervoor dat een proces en de kindprocessen daarvan worden beperkt tot een bepaald gedeelte van het gebruikte systeem. Om processen te isoleren, gebruikt Docker namespaces op vijf verschillende gebieden.

• Systeemidentificatie (UTS): bij virtualisatie op basis van containers wordt gebruikgemaakt van UTS-namespaces om containers een eigen host- en domeinnaam te geven.
• Proces-ID's (PID): iedere Docker-container gebruikt een eigen naamruimte voor proces-ID's. Processen die buiten een container lopen, zijn binnen de container niet zichtbaar. Daardoor kunnen processen die op hetzelfde hostsysteem staan, maar door containers worden geïsoleerd, dezelfde PID's hebben zonder dat er conflicten ontstaan.
• Interproces-communicatie (IPC): IPC-namespaces isoleren processen binnen een container zodanig dat communicatie met processen buiten de container niet mogelijk is.
• Netwerk (NET): met netwerk-namespaces kun je aan iedere container afzonderlijke netwerkresources toewijzen zoals IP-adressen of routing-protocollen.
• Mount (MNT) : door mount-namespaces kan een geïsoleerd proces nooit het gehele systeem van de host zien, maar slechts een deel hiervan. Over het algemeen is dit deel een speciaal voor de container gecreëerde image.
  
  

De procesisolatie van Docker baseert zich tot versie 0.8.1 op Linux-containers (LXC). Sinds versie 0.9 hebben gebruikers toegang tot het zelfontwikkelde formaat Libcontainer. Zo is het mogelijk om Docker op verschillende platformen te gebruiken en één container op verschillende hostsystemen te laten draaien. Daardoor kunnen er Docker-versies voor Windows en macOS worden aangeboden.

Schaalbaar, hoge beschikbaarheid en portabel

De container-technologie is niet alleen een efficiënt alternatief voor de klassieke hardwarevirtualisatie. Software-containers maken het ook mogelijk om applicaties platformoverschrijdend en in verschillende infrastructuren in te zetten, zonder dat deze moeten worden aangepast aan de hard- of softwareconfiguraties van het gebruikte hostsysteem.

Bij Docker worden zogenoemde images gebruikt als portable kopieën van software-containers. De inhoud van container-images bestaat uit afzonderlijke applicaties inclusief alle bibliotheken, binaire bestanden en configuratiegegevens die nodig zijn voor de looptijd van de geïsoleerde applicatieprocessen. Daardoor zijn de eisen aan het hostsysteem minimaal. Als je het Docker-platform als abstractielaag hebt geïnstalleerd, kun je applicatie-containers heen en weer schuiven tussen verschillende besturingssystemen zoals Linux, Windows en macOS, zonder ze extra te moeten configureren. Docker is daardoor de ideale basis voor het realiseren van schaalbare software-architectuur met een hoge beschikbaarheid. Docker wordt gebruikt op productiesystemen door bedrijven zoals Spotify, Google, eBay en Zalando.

Docker: opbouw en functies

Docker is het bekendste software-project met een virtualisatietechniek die zich op containers baseert. Aan het open source-platform liggen drie elementen ten grondslag: om containers te gebruiken, hebben de gebruikers alleen de Docker-engine en speciale Docker-images nodig die je via de Docker-hub kunt verkrijgen of zelf kunt creëren.

Docker images

Net zoals virtuele machines zijn Docker-containers op images gebaseerd. Een image is een alleen-lezenbestand met alle informatie die de Docker-engine nodig heeft om een container te creëren. Een Docker-image is een verplaatsbare kopie van een container en wordt als tekstbestand geschreven. Je hebt het dan over een Dockerfile. Als je een container op een systeem wilt opstarten, moet het image lokaal beschikbaar zijn. Als dit niet het geval is, moet je eerst een pakket met het benodigde image downloaden. Het gedownloade image stelt het systeem en alle parameters beschikbaar die het systeem nodig heeft om te draaien. Een container kan worden gezien als een lopend proces van een image.

De Docker-hub

De Docker-hub is een registry-cloud voor software-repositorys, of eenvoudig gezegd: een bibliotheek voor Docker-images. De online service is verdeeld in een public repository en een private repository. In het public repository deel kunnen gebruikers zelf ontwikkelde images uploaden en met de community delen. Hier staan bovendien een aantal officiële images van de Docker-ontwikkelaars en gevestigde open source-projecten ter beschikking. Images die in de private repository van de registry worden geüpload, zijn niet voor iedereen toegankelijk, maar kunnen specifiek met bijvoorbeeld collega's, vrienden en bekenden worden gedeeld. De Docker-hub kun je bereiken via hub.docker.com.

De Docker-engine

De Docker-engine vormt de kern van het Docker-project. Dit is een open source client/server-applicatie waarvan de actuele versie op alle gevestigde platformen voor gebruikers ter beschikking staat.

De basis van de Docker-engine bestaat uit drie onderdelen: een daemon met server-functies, een application programming interface (API) op basis van representational state transfer (REST) en de terminal van het besturingssysteem (CLI) als client.

• De Docker-daemon: als server wordt bij de Docker-engine van een daemon-proces gebruikgemaakt. De Docker-daemon loopt op de achtergrond van het hostsysteem en zorgt voor de centrale besturing van de Docker-engine. Dit betekent dat de daemon alle images, containers en netwerken creëert en beheert.
• De REST-API: de REST-API specificeert een aantal interfaces waardoor andere programma's met de Docker-daemon kunnen communiceren om aanwijzingen te geven. Een van deze programma's is de terminal van het besturingssysteem.
• De terminal: als client-programma gebruikt Docker de terminal van het besturingssysteem. Deze communiceert met de Docker-daemon via de REST-API en zorgt ervoor dat gebruikers hem met behulp van scripts en gebruikerscommando's kunnen sturen.

Met Docker kunnen gebruikers software-containers direct vanuit de terminal opstarten, stoppen en beheren. De daemon wordt bestuurd met behulp van het commando docker en met commando's zoals build (creëer), pull (download) en run (start op). Client en server kunnen hierbij op hetzelfde systeem staan. Als alternatief kunnen gebruikers een Docker-daemon via een ander systeem gebruiken. Afhankelijk van de soort verbinding die moet worden opgebouwd, verloopt de communicatie tussen client en server via de REST-API, UNIX-sockets of een netwerkinterface.

De onderstaande grafiek laat zien hoe de afzonderlijke Docker-onderdelen samenwerken. In het voorbeeld worden de commando's docker build, docker pull en docker run gebruikt.

De Docker-architectuur baseert zich op een client (terminal), server (Docker-daemon) en registry (Docker-hub) die samenwerken

Het commando docker build laat de Docker-daemon een image creëren (gestippelde lijn). Daarvoor moet er een passend Dockerfile beschikbaar zijn. Als het image niet zelf wordt gecreëerd, maar uit een repository in de Docker-hub moet worden gedownload, wordt gebruikgemaakt van het commando docker pull (onderbroken lijn). Als de Docker-daemon via docker run de opdracht krijgt om een container op te starten, controleert het achtergrondprogramma eerst of er lokaal een passend container-image beschikbaar is. Als dit het geval is, wordt de container uitgevoerd (doorgetrokken lijn). Als de daemon het image niet kan vinden, begint hij automatisch deze uit de repository te pullen.

De Docker-engine installeren

Hoewel Docker in het begin uitsluitend werd gebruikt op Linuxdistributies, is de actuele versie van de container-engine over het algemeen platformonafhankelijk. Installatiepakketten zijn beschikbaar voor Microsoft Windows, macOS en voor cloud-services zoals Amazon Web Services (AWS) en Microsoft Azure. De ondersteunde Linuxdistributies zijn o.a.:

• CentOS
• Debian
• Fedora
• Oracle Linux
• Red Hat Enterprise Linux
• Ubuntu
• openSUSE
• SUSE Linux Enterprise
  
  

Bovendien zijn er Docker-distributies die door de community worden onderhouden voor:

• Arch Linux
• CRUX Linux
• Gentoo Linux
  
  

Hieronder volgt een handleiding om de Docker-engine op de populaire Linuxdistributie Ubuntu te installeren. Uitgebreide installatiehandleidingen voor andere platformen zijn te vinden in de Engelstalige Docker-documentatie.

Afhankelijk van de eisen en voorwaarden, zijn er drie mogelijkheden om het container-platform Docker op het Ubuntu-systeem te installeren:

• Handmatige installatie via DEB-pakket
• Installatie vanuit de Docker-repository
• Installatie vanuit de Ubuntu-repository
  
  

Het is belangrijk om naar de systeemeisen van de Docker-engine te kijken voordat je begint.

Systeemeisen

Om de actuele versie van Docker op je Ubuntu-distributie te installeren, heb je de 64-bitversie van een van de onderstaande Ubuntu-versies nodig:

• Yakkety 16.10
• Xenial 16.04 (LTS)
• Trusty 14.04 (LTS)
  
  

Voor de Docker-installatie

De onderstaande handleiding baseert zich op de Ubuntu-versie Xenial 16.04 (LTS). Bij Yakkety 16.10 is het verloop van de installatie hetzelfde. Gebruikers van Trusty 14.04 (LTS) wordt aangeraden voor de installatie van Docker eerst de linux-image-extra-* pakketten te installeren. Daardoor krijgt de Docker-engine toegang tot de opslagdriver van AUFS.

Een gemakkelijke methode om ervoor te zorgen dat Linux geüpdatet blijft, is de geïntegreerde pakketmanager APT (Advanced Packaging Tool). Met onderstaande stappen installeer je de aanvullende pakketten voor Trusty 14.04:

1. Terminal openen: start Ubuntu en open de terminal – bijvoorbeeld via de toetsencombinatie [CTRL] + [ALT] + [T].

Gebruik de toevoeging sudo om via de terminal commando’s te geven als beheerder.

2. Pakketlijsten updaten: voer het volgende commando in om de lokale pakket-index van je systeem te actualiseren. Bevestig het commando met de [ENTER]-toets.

$ sudo apt-get update

Door de toevoeging sudo kun je commando's als beheerder (superuser ‘root’) uitvoeren. Eventueel heb je root-rechten nodig om bepaalde commando's te laten uitvoeren. In dit geval vereist Ubuntu het beheerderwachtwoord. Als alternatief is het ook mogelijk om via sudo -s de beheerderfunctie te activeren.

Let op: als je een wachtwoord in de Ubuntu-terminal intypt, worden er geen placeholder-tekens getoond

Als je met het wachtwoord hebt bewezen dat jij een root-gebruiker bent, begint Ubuntu het update-proces. De status kun je in de terminal zien.

Het commando sudo apt-get update actualiseert de lijst met beschikbare pakketten

Aanvullende pakketten installeren: als alle pakketbeschrijvingen zijn geüpdatet, kun je de nieuwe pakketten installeren. Daarvoor stelt de pakket-manager APT het commando apt-get install ‘pakketnaam’ ter beschikking. Gebruik onderstaand commando in de terminal om de aanbevolen aanvullende pakketten voor Trusty 14.04 uit de Ubuntu-repository te downloaden en op het systeem te installeren. Bevestig het commando met [ENTER].

$ sudo apt-get install -y --no-install-recommends \

            linux-image-extra-$(uname -r) \

            linux-image-extra-virtual

Het wordt aanbevolen om, voordat nieuwe pakketten worden geïnstalleerd, de lokale pakketlijst te actualiseren

Zodra de aanvullende pakketten voor Trusty 14.04 zijn gedownload, kun je ook op deze Ubuntu-versie gebruik maken van alle functies van het Docker-platform.

Weet je niet welke Ubuntu-versie jouw systeem heeft? Of weet je niet zeker of je de 64-bit-architectuur hebt die nodig is om Docker te installeren? Met behulp van het volgende commando kun je de kernel-versie en de systeemarchitectuur via de Ubuntu-terminal opzoeken:

$ sudo uname –rm

De gebruikte Ubuntu-versie, de release en de codename kun je met het volgende commando opzoeken:

$ sudo lsb_release –a

Ook met Ubuntu kun je systeeminformatie eenvoudig via de terminal verkrijgen

Handmatige installatie via DEB-pakket

In principe kun je Docker als DEB-pakket downloaden en handmatig installeren. Het installatiepakket dat je daarvoor nodig hebt, is hier beschikbaar:

Docker als DEB-pakket downloaden

Download het DEB-bestand voor de gewenste Ubuntu-versie en begin de installatie met behulp van dit commando via de Ubuntu-terminal:

$ sudo dpkg -i /path/to/package.deb

Bij een handmatige installatie moeten ook alle software-updates handmatig worden gestart. De Docker-documentatie raadt daarom aan om de repository van Docker te gebruiken. Daardoor is het mogelijk om het container-platform eenvoudig vanuit de Ubuntu-terminal te installeren en ervoor te zorgen dat altijd de nieuwste versie is geïnstalleerd.

In de onderstaande handleiding leggen we uit hoe je Docker volgens de aanbevolen stappen installeert.

Installatie vanuit de Docker-repository

De aanbevolen manier om het container-platform te installeren, is via de Docker-repository. Wij laten zien hoe je jouw systeem moet configureren, zodat de pakket-manager APT via HTTPS toegang heeft tot de Docker-repository.

1. Pakketten installeren: gebruik het volgende commando om de pakketten te installeren die nodig zijn om toegang tot de Docker-repository te krijgen.

$ sudo apt-get install -y --no-install-recommends \ 
				apt-transport-https \
				ca-certificates \
				curl \
				software-properties-common

In de terminal kun je het installatieproces volgen

2. GPG-sleutel toevoegen: voeg de officiële GPG-sleutel van Docker toe.

$ curl -fsSL https://apt.dockerproject.org/gpg | sudo apt-key add -

Als de gekozen sleutel is toegevoegd, geeft Ubuntu dit in de Terminal door middel van een ‘OK’ aan

3. GPG-sleutel verifiëren: controleer of de GPG-sleutel de volgende ID heeft: 5811 8E89 F3A9 1289 7C07 0ADB F762 2157 2C52 609D. Gebruik daarvoor dit commando:

$ apt-key fingerprint 58118E89F3A912897C070ADBF76221572C52609D

In de terminal komt het volgende te staan:

pub   4096R/2C52609D 2015-07-14
Key fingerprint = 5811 8E89 F3A9 1289 7C07  0ADB F762 2157 2C52 609D
uid                  Docker Release Tool (releasedocker) 

Vergelijk de mededeling in de terminal met de GPG-sleutel van Docker

4. Docker-repository configureren: gebruik onderstaand commando om toegang tot het stabiele Docker-repository te garanderen:

$ sudo add-apt-repository \
				"deb https://apt.dockerproject.org/repo/ \
				ubuntu-$(lsb_release -cs) \
				main"

Configureer de toegang tot de stabiele Docker-repository

Het systeem is nu compleet voorbereid om het container-platform vanuit de Docker-repository te installeren.

5. Pakket-index actualiseren: voordat je de Docker-engine verder installeert, wordt aanbevolen om de pakket-index van je besturingssysteem opnieuw te actualiseren. Gebruik daarvoor weer het commando:

$ sudo apt-get update

6. Docker-installatie vanuit de repository: er zijn twee mogelijkheden om de Docker-engine vanuit de Docker-repository te downloaden en op je Ubuntu-systeem te installeren. Als je de nieuwste versie van de Docker-engine wilt downloaden, gebruik je het commando:

$ sudo apt-get -y install docker-engine

Controleer hoe het installatieproces vordert via de terminal

Het container-platform kan worden gebruikt zodra de installatie is afgesloten.

De Docker-daemon start automatisch. Als er al een oudere versie van het container-platform in je systeem stond voordat Docker werd geïnstalleerd, wordt deze vervangen door de nieuwe geïnstalleerde software.

In plaats van de nieuwste versie kan ook een van de oudere versies van Docker-engine worden geïnstalleerd. Dit kan zinvol zijn als de engine op productiesystemen wordt toegepast. Gebruikers vinden het soms fijner om oudere, gevestigde versies te gebruiken in plaats van nieuwere software-versies.

Een lijst van de beschikbare Docker-versies voor jouw systeem krijg je met het commando:

$ apt-cache madison docker-engine

Kies de Docker-release die je wilt downloaden uit de lijst van beschikbare software-versies

Om een speciale Docker-versie te installeren, moet je je commando aanvullen met de toevoeging die bij de versie hoort (bijv. 1.12.5-0). Gebruik hiervoor het gelijkteken (=) na de pakketnaam (in dit geval docker-engine) gevolgd door de toevoeging.

$ sudo apt-get -y install docker-engine=

Installatie vanuit de Ubuntu-repository

Wie geen gebruik wil maken van de Docker-repository, kan het container-platform via de repository van het eigen besturingssysteem downloaden.

Gebruik het volgende commando om een Docker-pakket te installeren, dat de Ubuntu-community ter beschikking stelt:

$ sudo apt-get install -y docker.io

Proefrun

Nadat de installaties succesvol zijn afgesloten, is het verstandig om te controleren of het container-platform zonder problemen loopt. De ontwikkelaars stellen daarvoor een eenvoudige hello-world-container ter beschikking. Controleer je Docker-installatie door onderstaand commando in de Ubuntu-terminal in te geven en met [ENTER] te bevestigen:

$ sudo docker run hello-world

Het commando docker run laat de Docker-daemon een container met de naam hello-world zoeken en opstarten. Als de Docker-installatie zonder fouten is afgerond, krijg je een mededeling die overeenkomt met onderstaand screenshot.

De begroeting "Hello from Docker" laat zien dat de Docker-installatie succesvol is afgesloten

Wat heeft deze mededeling in de terminal te betekenen? Om het commando docker run hello-world uit te voeren, zoekt de Docker-daemon eerst tussen de lokale bestanden op je systeem naar de bijbehorende container-image. Omdat je de container hello-world voor het eerst gebruikt, kan de daemon het image niet vinden. Je krijgt het bericht "Unable to find image" ("Het image kon niet worden gevonden").

$ sudo docker run hello-world
				[sudo] password for osboxes:
				Unable to find image 'hello-world:latest' locally

Als Docker de gezochte image op het lokale systeem niet kan vinden, start de daemon een downloadproces (pulling) vanuit de Docker-repository.

latest: Pulling from library/hello-world
78445dd45222: Pull complete
Digest: sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7
Status: Downloaded newer image for hello-world:latest

Als dit is gelukt, krijg je het bericht: "Downloaded newer image for hello-world:latest" ("Nieuwe image voor hello-world:latest gedownload"). Vervolgens wordt de container gestart. Hierin staat een hello-world-script met een bericht van de ontwikkelaars:

Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
3. The Docker daemon created a new container from that image which runs 
the executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, 
which sent it to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash 
Share images, automate workflows, and more with a free Docker ID:
https://cloud.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/engine/userguide/

Voor jou betekent deze tekst: De Docker-installatie is gelukt.

Docker de-installeren

Net zo eenvoudig als de installatie van de Docker-engine via de terminal, is de de-installatie van het container-platform. Typ onderstaand commando in de Ubuntu-terminal als je het Docker-pakket van je systeem wilt verwijderen, en bevestig met [ENTER]:

$ sudo apt-get purge docker-engine

Nadat de informatie die voor de de-installatie nodig is, is ingelezen, dien je het commando opnieuw te bevestigen.

De-installeer de Docker-platform met het commando apt-get purge

De-installeer de Docker-platform met het commando apt-get purge

Typ ‘Y’ (Yes) in om verder te gaan en bevestig met [ENTER]. Kies ‘n’ om de de-installatie te stoppen.

Images en containers worden bij de de-installatie van de Docker-engine niet automatisch verwijderd. Je kunt ze verwijderen met het commando:

$ sudo rm -rf /var/lib/docker

Als je nog andere configuratiebestanden hebt geïnstalleerd, moet je deze handmatig verwijderen.

Werken met Docker

Heb je gecontroleerd of de Docker-engine goed is geïnstalleerd en zonder problemen loopt? Dan wordt het tijd om naar de mogelijkheden van het container-platform te kijken. Hier leer je hoe je de Docker-engine vanuit de terminal kunt besturen, welke mogelijkheden de Docker-hub biedt en waarom de Docker-container het begin van een nieuw tijdperk voor applicaties kan zijn.

De Docker-engine besturen

Vanaf versie 16.04 gebruikt Ubuntu het achtergrondprogramma systemd (afkorting van ‘System-Daemon’) om processen te beheren. Systemd is een init-proces dat ook wordt gebruikt bij andere Linuxdistributies zoals RHEL, CentOS en Fedora. Over het algemeen heeft systemd de proces-ID 1. Als eerste proces van het systeem is de daemon verantwoordelijk om alle volgende processen op te starten, te controleren en af te sluiten. Bij oudere Ubuntu-versies (14.10 en ouder) wordt dit door het achtergrondprogramma upstart gedaan.

Ook de Docker-daemon kan via systemd worden bestuurd. Bij standaardinstelling is het container-platform zo geconfigureerd dat de daemon automatisch opstart als het systeem wordt geboot. Deze instelling kun je individueel veranderen met behulp van het commando systemctl.

Met systemctl stuur je commando's naar systemd om een proces te besturen of de status ervan te zien. De opbouw van het commando is:

systemctl [OPTIE] [COMMANDO]

Sommige commando's hebben betrekking op bepaalde resources (bijvoorbeeld Docker). In de terminologie van systemd wordt dit units (eenheden) genoemd. In dit geval bestaat het commando uit een instructie en de naam van de unit die wordt bedoeld.

Gebruik het commando systemctl in combinatie met onderstaande commando's als je de auto-start van de Docker-daemon wilt activeren (enable) of deactiveren (disable):

$ sudo systemctl enable docker

$ sudo systemctl disable docker

Met het commando systemctl kun je bovendien de status van een unit aanvragen:

$ sudo systemctl status docker

Als de Docker-engine op jouw Ubuntu-systeem geactiveerd is, moet de mededeling in de terminal overeenkomen met het onderstaande screenshot:

Statusaanvraag via systemctl: De Docker-engine is geactiveerd (running)

Als de Docker-engine op dat moment gedeactiveerd is, staat er in de status inactive (dead). In dit geval moet je Docker handmatig opstarten om containers te gebruiken.

Statusaanvraag via systemctl: De Docker-engine is inactief (dead)

Gebruik de volgende commando's om de Docker-engine handmatig op te starten, te stoppen of opnieuw op te starten.

Gebruik systemctl in combinatie met het commando start om de gedeactiveerde daemon op te starten:

$ sudo systemctl start docker

Als je de Docker-daemon wilt afsluiten, gebruik je het commando stop:

$ sudo systemctl stop docker

Je kunt de engine opnieuw opstarten met het commando restart:

$ sudo systemctl restart docker

De Docker-hub gebruiken

Als de Docker-engine het hart van het container-platform weerspiegelt, kun je de Docker-hub als ziel van het open source-project zien. Hier komt de community samen. Gebruikers vinden in de registry-cloud alles wat ze nodig hebben om van de Docker-installatie een levendig systeem te maken.

De online service biedt verschillende officiële repository’s aan met meer dan 100.000 gratis apps. Gebruikers kunnen een eigen image-archief creëren en deze samen met werkgroepen gebruiken. Naast de professionele support door de ontwikkelaars, vinden beginners ook aansluiting bij de gebruikerscommunity. Een forum voor community-support is te vinden op GitHub.

Je persoonlijke Docker-ID krijg je gratis bij de registratie. Bron: hub.docker.com

In de Docker-hub aanmelden

Het kost niets om je bij de Docker-hub aan te melden. Gebruikers hebben alleen een e-mailadres en een zelfgekozen Docker-ID nodig. Deze wordt later gebruikt als persoonlijke repository-namespace en geeft gebruikers toegang tot alle Docker-services. Onderdeel van het aanbod zijn naast de Docker-hub ook de Docker-cloud, de Docker-store en een selectie aan bèta-programma's. Bovendien kun je je met de Docker-ID inloggen op het Docker-support-center, het Docker-success-portal en de Docker-fora.

Om je aan te melden, moet je vijf stappen doorlopen:

1. Docker-ID kiezen: Als je een account aanmaakt, kies je een gebruikersnaam die je later als persoonlijke Docker-ID gaat gebruiken. Je gebruikersnaam voor de Docker-hub en alle andere services van Docker moet 4 tot 30 tekens hebben. Je mag alleen gebruikmaken van getallen en kleine letters.
2. E-mailadres opgeven: vermeld je actuele e-mailadres. Je moet je registratie bij Docker-hub via e-mail bevestigen.
3. Wachtwoord kiezen: kies een geheim wachtwoord met 6 tot 128 tekens.
4. Registratie versturen: klik op ‘Sign up’ om je registratie te versturen. Als je gegevens zijn ontvangen, stuurt Docker een link naar het aangegeven e-mailadres ter verificatie.
5. E-mailadres bevestigen: bevestig je e-mailadres door op de verificatielink te klikken.

Je kunt meteen na de registratie via de browser gebruikmaken van de online services van het Docker-project. Hier kun je repository’s en werkgroepen aanmaken of met ‘explore’ op zoek gaan naar resources in de Docker-hub.

Het dashboard van de Docker-hub

Als alternatief is het mogelijk om je met behulp van docker login direct via de terminal van je besturingssysteem aan te melden. Een gedetailleerde beschrijving van het commando vind je in de Docker-documentatie.

In principe kun je ook zonder account en Docker-ID gebruikmaken van de Docker-hub, maar dan kun je alleen images uit de publieke repository’s downloaden. Zonder Docker-ID is het niet mogelijk om eigen images te uploaden (push).

Repository’s in de Docker-hub creëren

Met een gratis Docker-hub-account beschik je over één private repository en heb je de mogelijkheid zo veel public repository’s te creëren als je wilt. Indien nodig kun je meer private repository’s verkrijgen door een upgrade te kopen.

Volg onderstaande stappen om een repository aan te maken:

1. Namespace kiezen: nieuwe repository’s worden automatisch bij de namespace van je Docker-ID ingedeeld. Je hebt echter ook de mogelijkheid om de ID van een organisatie waarvan je lid bent aan te geven.
2. Repository benoemen: kies een naam voor de nieuwe repository.
3. Beschrijving toevoegen: voeg een korte beschrijving en een uitgebreide handleiding toe.
4. Zichtbaarheid instellen: kies of de repository toegankelijk is voor iedereen (public) of alleen voor jezelf of je organisatie (private).

Bevestig alle gegevens door op ‘Create’ te klikken.

De Docker-hub: je repositorys worden automatisch in de namespace van jouw Docker-ID gecreëerd.

Teams & organisaties creëren

Met de hub geeft Docker je een cloud-platform waarop je zelfgecreëerde images centraal kunt beheren en eenvoudig met werkgroepen kunt delen. In de Docker-terminologie worden deze ‘organisaties’ genoemd. Net zoals gebruikersaccounts krijgen organisaties individuele ID's, waarmee ze images kunnen uploaden en downloaden. Rechten en rollen binnen een organisatie kun je via teams bepalen. Gebruikers die deel uitmaken van het team ‘owners’ kunnen bijvoorbeeld private en public repository’s aanmaken en bepalen wie toegang tot de repository’s heeft.

Ook werkgroepen worden direct via het dashboard aangemaakt en beheerd. Aanvullende informatie over organisaties en teams is in de Docker-documentatie te lezen.

Met images en containers werken

De Docker-hub is de eerste plaats om Docker-resources te vinden en is daarom een centraal punt in onze handleiding over images en containers. De ontwikkelaars stellen hier o.a. het demo-image whalesay ter beschikking dat als basis dient voor onze Docker-tutorial.

Docker-images downloaden

Het whalesay-image vind je door de startpagina van de Docker-hub te openen en whalesay in de zoekbalk rechts naast het Docker-logo in te typen.

Doorzoek de Docker-hub met behulp van de zoekbalk of via het tabblad ‘Explore’. Bron: hub.docker.com

Klik in de lijst met resultaten op de ressource met de naam docker/whalesay om de public repository voor deze image te openen.

Docker-repositorys hebben altijd dezelfde indeling. Het eerste vak omvat de naam van de image, de categorie van de repository en het tijdstip van de laatste upload (last pushed).

In de repository vinden gebruikers over het algemeen alle informatie die ze nodig hebben om het image te gebruiken. Bron: hub.docker.com

Bovendien heeft ieder Docker-repository de volgende informatievakken:

• Short Description: korte beschrijving van de ressource
• Full Description: uitgebreide beschrijving, over het algemeen inclusief handleiding
• Docker Pull Command: terminalcommando om het image uit de repository te downloaden (pull)
• Owner: informatie over degene die de repository heeft aangemaakt
• Comments: vak voor commentaar aan het einde van de pagina

Aan de informatievakken van de repository kun je zien dat whalesay een gemodificeerde versie van het open source perl-script cowsay is. Het programma, dat door Tony Monroe in 1999 is ontwikkeld, genereert in zijn oorspronkelijke versie een ASCII-grafiek in de vorm van een koe die samen met een mededeling in de terminal van de gebruiker verschijnt.

Gebruik het commando docker pull met onderstaande opbouw om docker/whalesay te downloaden.

$ docker pull [OPTIONS] NAME [:TAG|@DIGEST]

Het commando docker pull laat de daemon een image uit de repository downloaden. Welke image precies wordt gedownload, bepaal je door de image-naam (NAME) aan te geven. Bovendien kun je aangeven hoe Docker het gewenste commando moet uitvoeren (OPTIONS). Daarnaast kun je gebruikmaken van tags (:TAG) en individuele identificatienummers (@DIGEST), waardoor het mogelijk is om een bepaalde versie van een image te downloaden.

Een lokale kopie van de docker/whalesay-images krijg je dus met het commando:

$ docker pull docker/whalesay

Normaal gesproken kun je deze stap echter overslaan. Als je een container wilt openen, downloadt de Docker-daemon images die hij niet op het lokale systeem kan vinden automatisch vanuit de repository.

Docker-images als container opstarten

Gebruik het commando docker run met onderstaande opbouw om een Docker-image op te starten:

$ docker run [OPTIONS] IMAGE [:TAG|@DIGEST] [CMD] [ARG...]

Het enige verplichte deel van het commando docker run is de naam van het gewenste Docker-image. Ook als je de container opstart, heb je de mogelijkheid extra opties, TAG's en DIGEST's te definiëren. Bovendien kun je het commando docker run met andere commando's combineren die worden uitgevoerd als de container opstart. In dit geval wordt de CMD (COMMAND, een door de image creator gedefinieerd commando dat bij het starten automatisch wordt uitgevoerd) overschreven. Andere optionele configuraties kun je door aanvullende argumenten (ARG...) definiëren. Hiermee kun je bijvoorbeeld gebruikers toevoegen of omgevingsvariabelen (environment-variables) gebruiken.

Gebruik het commando

$ docker run docker/whalesay cowsay boo

om het als image beschikbare perl-script te downloaden en in een container uit te voeren. Je zult zien dat whalesay op één belangrijk punt verschilt van het oorspronkelijke script.

Als docker/whalesay met het standaardcommando wordt uitgevoerd, zegt de walvis alleen een kort "boo"

Als het image docker/whalesay wordt uitgevoerd, geeft het script een ASCII-grafiek in de vorm van een walvis weer in de terminal met het bericht "Boo" dat vanwege het cowsay-commando wordt uitgevoerd.

Net zoals bij de proefrun zoekt de daemon het gewenste image eerst tussen de lokale bestanden. Omdat er lokaal geen pakket met deze naam te vinden is, begint de daemon een pulling vanuit de Docker-repository. Vervolgens start de daemon het gemodificeerde cowsay-programma op. Als dit is gebeurd, wordt de container automatisch afgesloten.

Net zoals cowsay kun je ook met whalesay van Docker het programmaverloop aanpassen om het bericht in de terminal te veranderen. Deze functie kun je testen door het "Boo" in het oorspronkelijke commando door een willekeurige tekst te vervangen – bijvoorbeeld door een flauwe walvissengrap.

$ sudo docker run docker/whalesay cowsay What did the shark say to the whale? 
What are you blubbering about?

Bepaal zelf wat de Docker-walvis zegt

Alle Docker-images op het lokale systeem weergeven

Weet je niet zeker of je een bepaald image al hebt gedownload? Vraag dan een overzicht met alle images op jouw lokale systeem aan. Gebruik daarvoor het commando:

$ sudo docker image

Het commando docker image geeft alle lokale images inclusief bestandsgrootte, tags en image-ID weer.

Het overzicht geeft de images hello-world en docker/whalesay weer

Als je een container opstart, wordt het image waarop de container zich baseert als kopie uit de repository gedownload en op je computer opgeslagen. Zo spaar je tijd, als je deze later nog eens wilt gebruiken. Het image wordt dan alleen opnieuw gedownload als de image-bron verandert – bijvoorbeeld als in de repository een nieuwe versie ter beschikking staat.

Alle containers op het lokale systeem weergeven

Gebruik het commando docker ps in combinatie met de optie --all (kort: -a), als je een overzicht van alle containers wilt hebben die op je systeem lopen of liepen:

$ sudo docker ps -a

Het overzicht geeft alle containers weer die op de Docker-engine zijn opgestart

Het terminalbericht omvat informatie zoals de container-ID, de image waarop de betreffende container zich baseert, het commando dat werd gebruikt om de betreffende container op te starten, het tijdstip waarop de betreffende container werd opgestart en de actuele status.

Gebruik het commando docker ps zonder verdere opties als je alleen de containers wilt zien die op dat moment op je systeem worden uitgevoerd:

$ sudo docker ps

Als het goed is, staan er op dit moment nog geen lopende containers op je systeem.

Docker-images

Je weet nu hoe je een image in de Docker-hub vindt, deze downloadt en op ieder systeem uitvoert dat de Docker-engine heeft geïnstalleerd. Maar met Docker heb je tot veel meer diensten toegang dan alleen het omvangrijke app-aanbod. Het platform biedt ook nog uitgebreide mogelijkheden om eigen images te creëren en met andere ontwikkelaars te delen.

In de inleidende hoofdstukken van deze tutorial heb je al gelezen dat het Docker-image zich op een zogenoemd Dockerfile baseert. Dockerfiles zijn een soort van montagehandleiding voor images. Het zijn eenvoudige tekstbestanden met alle stappen die Docker nodig heeft om een image te creëren. Leer met onderstaande stappen hoe je zo'n Dockerfile schrijft en hoe je Docker beveelt om dit als basis voor een eigen image te gebruiken.

1. Nieuwe registry maken: de Docker-ontwikkelaars raden aan om voor iedere Dockerfile een eigen registry aan te maken. Je kunt een registry op Linux eenvoudig via de terminal aanmaken. Gebruik het onderstaande commando om een registry met de naam mydockerbuild aan te maken.

$ mkdir mydockerbuild

Nieuwe registry’s creëer je met het commando mkdir

2. In de nieuwe registry navigeren: gebruik het commando cd om in de nieuwe werkregistry te navigeren.

$ cd mydockerbuild

Met het commando cd wissel je naar een andere werkregistry

3. Nieuw tekstbestand aanmaken: ook tekstbestanden kun je op Ubuntu eenvoudig via de terminal creëren. Gebruik daarvoor een editor zoals Nano of Vim. Creëer in de registry mydockerbuild een tekstbestand met de naam Dockerfile.

$ nano Dockerfile

De teksteditor Nano is reeds geïnstalleerd op alle Ubuntu-versies

4. Dockerfile schrijven: het nieuwe tekstbestand is een bauwplan voor je zelfontwikkelde image. Bij deze Docker-tutorial programmeren we een image niet in zijn geheel. In plaats daarvan gebruiken we de demo-image docker/whalesay als patroon. Het image voegen we via het commando FROM aan de Dockerfile toe. Gebruik de tag :latest om naar de nieuwste versie van het image te verwijzen.

FROM docker/whalesay:latest

Tot nu functioneerde docker/whalesay zo, dat je zelf kon aangeven wat de walvis zegt. In de terminal verschijnt precies de tekst die je daarvoor in combinatie met het commando om de container op te starten hebt gebruikt. Maar het is natuurlijk veel interessanter als het script automatisch steeds nieuwe teksten zou genereren. Dit kun je bijvoorbeeld met het programma fortunes realiseren dat op ieder Linuxsysteem beschikbaar is. De basisfunctie van fortunes is het genereren van filosofische uitspraken en grappige aforismen. Gebruik onderstaand commando om je lokale pakket-index te actualiseren en fortunes te installeren:

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

Vervolgens definieer je een CMD-statement. Dit wordt na het commando RUN uitgevoerd, als er niet tijdens het openen (docker run image CMD) overheen is geschreven. Gebruik

CMD /usr/games/fortune -a | cowsay

om het programma fortunes met de optie -a ("kies uit alle databases") uit te voeren en de mededelingen via het programma cowsay in de terminal te laten zien.

Je Dockerfile moet er nu als volgt uitzien:

FROM docker/whalesay:latest
RUN apt-get -y update && apt-get install -y fortunes
CMD /usr/games/fortune -a | cowsay

Let op: commando's binnen een Dockerfile bestaan altijd uit alleen maar één regel en beginnen altijd met een sleutelwoord. De syntaxis van het systeem is case-insensitive - het maakt dus niet uit of je hoofdletters of kleine letters gebruikt. Het is echter gebruikelijk om sleutelwoorden altijd met hoofdletters te schrijven.

Je kunt de teksteditor Nano besturen via de toetsencombinaties die in de voettekst staan

5. Tekstbestand opslaan: sla je bestand op. Gebruik de toetsencombinatie [CTRL] + [O] als je de editor Nano gebruikt en bevestig met [ENTER]. Nano meldt nu dat drie regels in het gekozen bestand zijn geschreven. Beëindig de teksteditor met de toetsencombinatie [CTRL] + [X].

6. Image vanuit Dockerfile creëren: om een image vanuit een Dockerfile aan te maken, moet je eerst naar de registry navigeren, waarin je het tekstbestand hebt opgeslagen. Je creëert een image met het commando docker build. Als je het image individueel een naam of tag wilt geven, moet je gebruikmaken van de optie -t en vervolgens de gewenste combinatie van naam en tag toevoegen. Gebruik de standaardopbouw .

Bij het actuele voorbeeld is het de bedoeling een image met de naam docker-whale aan te maken:

$ docker build -t docker-whale .

De afsluitende punt geeft aan dat de Dockerfile die als basis dient, in de gekozen registry te vinden is. Als alternatief is het mogelijk om een bestandspad of URL naar het bronbestand aan te geven.

Een image via docker build creëren

Het build-proces begint zodra je het commando met [ENTER] hebt bevestigd. Eerst controleert de Docker-daemon of alle bestanden ter beschikking staan die hij nodig heeft om een image aan te maken. In de Docker-terminologie worden deze samengevat onder het begrip ‘context’. In de terminal verschijnt de statusmelding:

Sending build context to Docker daemon 2.048 kB

Vervolgens wordt het image docker/whalesay met de tag :latest gelokaliseerd:

Step 1/3 : FROM docker/whalesay:latest
---> 6b362a9f73eb

Als de context die nodig is om het image te creëren in zijn geheel beschikbaar is, start de Docker-daemon het via FROM toegevoegde image-patroon in een tijdelijke container op en gaat naar het volgende commando in de Dockerfile. Bij het actuele voorbeeld gaat het om een RUN-commando waardoor het programma fortunes wordt geïnstalleerd.

Step 2 : RUN apt-get -y update && apt-get install -y fortunes
---> Running in 80b81eda1a11
…etc.

Aan het einde van iedere stap die wordt gezet om een image te maken, geeft Docker je een ID voor de layer (laag) die tijdens deze stap is aangemaakt. Iedere regel in de Dockerfile die als basis dient, is in dit geval een layer van het image dat daarop is opgebouwd.

Als het RUN-commando is beëindigd, stopt de Docker-daemon de daarvoor gecreëerde container, verwijdert hem en start een nieuwe tijdelijke container op voor de layer van het CMS-statement.

Step 3/3 : CMD /usr/games/fortune -a | cowsay
---> Running in c3ac46675e7a
---> 4419af61d32d
Removing intermediate container c3ac46675e7a

Wanneer je aan het einde komt van het proces waarin je een image creëert, wordt ook de tijdelijke container, die in stap 3 is aangemaakt, afgesloten en verwijderd. Docker geeft de ID van de nieuwe image aan:

Successfully built 4419af61d32d

Docker-images worden met meerdere layers (lagen) gemaakt

Je nieuwe image vind je onder de naam docker-whale in het overzicht van je lokaal opgeslagen images.

$ sudo docker images

De nieuwe image in het image-overzicht

Om een container uit je nieuwe image op te starten, gebruik je het commando sudo docker run in combinatie met de naam van de image.

$ sudo docker run docker-whale

Als het image foutloos vanuit de Dockerfile is aangemaakt, is je walvis nu in staat om filosofische en grappige uitspraken te maken. Let op: iedere keer dat je de container opnieuw start, wordt een andere uitspraak gegenereerd.

Vanwege fortunes geeft de ASCII-walvis nu aforismen weer

Docker-images taggen en in de Docker-hub uploaden

Als je je zelfgemaakte image docker-whale in de hub wilt uploaden, zodat de community of werkgroepen er toegang tot hebben, moet je hem eerst verbinden met een gelijknamige repository in je persoonlijke namespace. In de Docker-terminologie wordt deze stap tagging genoemd.

Volg onderstaande stappen om een image via de Docker-hub te publiceren:

1. Repository creëren: meld je met je Docker-ID en je persoonlijke wachtwoord aan bij de Docker-hub en creëer een public repository met de naam docker-whale.

Creëer een repository voor je zelfgemaakte image. Bron: hub.docker.com

2. Image-ID vastleggen: bepaal de ID van je zelfgemaakte image docker-whale met het commando docker images.

$ sudo docker images
REPOSITORY IMAGE ID CREATED SIZE
docker-whale 4419af61d32d 22 hours ago 275 MB
hello-world 48b5124b2768 6 weeks ago 1.84 kB
docker/whalesay latest 6b362a9f73e 21 monthsago 247MB

In ons geval is de Image-ID 4419af61d32d. Het ID hebben we nodig voor het tagging tijdens de volgende stap.

Het commando docker images geeft alle images weer die op je systeem zijn opgeslagen

3. Image taggen: tag je image docker-whale met het commando docker tag en de onderstaande opbouw:

$ sudo docker tag [Image-ID][Docker-ID]/[Image-Name]:[TAG]

Met ons voorbeeld is het commando voor het taggen:

$ sudo docker tag 4419af61d32d myfreedockerid/docker-whale:latest

Controleer je overzicht via docker images om te zien of je image juist is getagd. Je Docker-ID moet nu ook in de naam van de repository staan.

Met het commando docker tag verbind je images met je Docker-ID

4. Image uploaden: om je image te uploaden, moet je je eerst bij de Docker-hub aanmelden. Dit doe je via het commando docker login.

 $ sudo docker login

De terminal vraagt je om je gebruikersnaam (de Docker-ID) en je wachtwoord in te typen.

Voordat je een image in de Docker-hub kunt uploaden, moet je je aanmelden

Zodra je succesvol bent aangemeld, kun je het commando docker push gebruiken om je image in de nieuw aangemaakte repository te uploaden.

$ sudo docker push myfreedockerid/docker-whale

Het uploaden duurt slechts enkele seconden. De actuele status kun je in de terminal zien.

Het image is na het uploaden beschikbaar in de Docker-hub onder de vastgelegde tag latest

Meld je via de browser bij de Docker-hub aan om de geüploade image te zien.

De laatste actualisering van je repository wordt bij de gedetailleerde informatie weergegeven. Bron: hub.docker.com

Onder het tabblad ‘Tags’ in de Docker-hub-repository verschijnt een overzicht van de verschillende image-versies.

De laatste actualisering van je repository wordt bij de gedetailleerde informatie weergegeven. Bron: hub.docker.com

Als je meer dan één image per repository wilt uploaden, moet je verschillende tags gebruiken om verschillende versies van je image aan te bieden. Bijvoorbeeld:

myfreedockerid/docker-whale:latest
myfreedockerid/docker-whale:version1
myfreedockerid/docker-whale:version2

Er wordt aangeraden om images van verschillende projecten in afzonderlijke repository’s aan te bieden.

Na de upload hebben alle Docker-gebruikers via de public repository toegang tot je zelfgemaakte image.

5. Proefrun: controleer of je bestand juist is geüpload door het betreffende image te downloaden.

Je moet de lokale versie van het image eerst verwijderen, voordat je een kopie met dezelfde tag kunt downloaden. Anders vermeldt Docker dat de actuele versie van de gewenste image reeds beschikbaar is.

Als een image lokaal beschikbaar is, wordt het pull-commando stopgezet

Gebruik het commando docker rmi in combinatie met het betreffende image-ID om lokale Docker-images te verwijderen. Het ID kun je zoals eerder beschreven via docker images opzoeken. Als Docker een probleem vermeldt – bijvoorbeeld omdat een image-ID wordt gebruikt in verschillende repository’s of in een container – kun je het commando met de optie --force (kort: -f) afdwingen, om het bestand alsnog te verwijderen.

sudo docker rmi -f 4419af61d32d

Gebruik het commando docker rmi in combinatie met de optie -f om het verwijderen van bestanden af te dwingen

Controleer opnieuw het overzicht van alle lokale images:

$ sudo docker Images

De verwijderde bestanden staan nu niet meer in het terminal-bericht. Gebruik nu het in de repository aangegeven pull-commando om een nieuwe kopie van het image uit de Docker-hub te downloaden:

$ sudo docker pull myfreedockerid/docker-whale

Het eerder gepubliceerde image is gedownload

Van beginner tot Docker-professional

In onze Docker-tutorial hebben we laten zien dat er belangrijke verschillen zijn tussen het eenvoudige container-platform en de klassieke hardware-virtualisatie. Docker baseert zich op software-containers en voorkomt overhead door een virtueel gastbesturingssysteem. Containers delen de kernel van een gezamenlijke host en creëren als geïsoleerd proces in de user-space alles wat voor de looptijd van een applicatie nodig is. Dat resulteert in ongekende portabiliteit. Met Docker kun je één software-container platformoverschrijdend op verschillende systemen laten lopen. Hiervoor moet je alleen de Docker-engine lokaal installeren en toegang tot de cloud van Docker-hub hebben.

Hoe snel je met Docker een functionerend container-platform kunt ontwikkelen, hebben we aan de hand van het voorbeeld van de populaire Linuxdistributie Ubuntu laten zien. Je hebt geleerd hoe je Docker op Ubuntu installeert en inricht, hoe je applicaties als images vanuit de Docker-hub downloadt en lokaal in containers laat lopen. Je hebt zelf een Dockerfile geschreven, daarvan een eigen image gemaakt en deze via de cloud toegankelijk gemaakt voor andere Docker-gebruikers. Kortom, je kunt nu met de basics van het container-platform omgaan.

Maar de Docker-wereld is groot. In de loop van tijd heeft het populaire open source-project zich ontwikkeld tot een levendig ecosysteem. Bovendien hebben verschillende concurrenten alternatieve containerplatformen op de markt voorgesteld. Voor beheerders is Docker vooral interessant als complexe applicaties met meerdere containers tegelijkertijd op verschillende systemen moeten lopen. Docker beschikt over diverse functies om zo'n cluster te beheren. Ook garandeert Docker een hoge mate van veiligheid, om bijvoorbeeld een IT-disaster zo veel mogelijk te voorkomen.