Docker - Xand-r/IT-Landscape GitHub Wiki

In het eerste deel van deze wiki gaan we het hebben over docker. Docker is een programma dat veel terug komt binnen het vak IT Landscapes. Je kan er namelijk ook veel mee doen. We gaan dit dan ook doorheen deze wiki nog veel gebruiken. Daarom is het belangrijk dat we deze wiki beginnen met een goeie basis te leggen van Docker.

Voor we beginnen over de toepassingen en functies van docker gaan we eerst zien wat docker exact is. Docker is eigenlijk een programma dat gebruikt word bij het development proces. Het helpt ontwikkelaars om applicaties overal te bouwen, te delen, uit te voeren en te verifiëren zonder vervelende configuratie of beheer van de omgeving.

Voor Docker bestond waren er een aantal problemen die regelmatig voor kwamen binnen de omgeving van softwareontwikkeling. Mensen zaten bijvoorbeeld vaak met het probleem dat applicaties waar ze aan bezig waren werkte op hun machine maar niet op de server of andere machines. Om dit op te lossen zijn ze dan gebruik beginnen maken van Virtual Machines maar die waren zwaar en traag. In 2013 is dan Docker gepubliceerd door het bedrijf dotCloud dat zich later dan hernoemt heeft naar Docker Inc. Dit programma maakte gebruik van lightweight containers dat veel problemen binnen het software development oploste.

De manier waarop docker tewerk gaat is uiteindelijk niet heel ingewikkeld. Docker start bij een dockerfile. Een dockerfile is eigenlijk een bestand dat je in je project aanmaakt waar een heel aantal instructies in staan van en voor Docker. Later gaan we hier een beetje dieper in.
Daarna gaat Docker aan de hand van jouw instucties/dockerfile een image aanmaken. Dit is een beetje de blauwdruk van je project binnen Docker.
Als laatste stap word dan aan de hand van die image/blauwdruk zo een lightweight container gemaakt. Dit is dan eigenlijk een running instantie van jouw eigen project.

Om Docker te gebruik gaan we het natuurlijk moeten installeren. In dit segment gaan we stap voor stap over het installatie proces gaan aan de hand van wat screenshots om het duidelijk te maken.

Stap 1). Ga naar de volgende link: https://www.docker.com/products/docker-desktop/ en hover over de knop "Download Docker Desktop" waarna je gelang van je systeem een van de zichtbare opties gaat selecteren. Voor windows word de AMD64 versie aangeraden wegens dit een stabiele optie is in vergelijking tot de andere optie.
Nu gaat er een .exe gedownload worden.

Stap 2) Nu mag je de file die je net gedownload hebt uitvoeren. Windows gaat je hierbij een permissie melding geven. Hier klik je gewoon op "Yes". Hierna zal de install wizard openen. Hier gaan we verder naar stap 3.

Docker Wizard

Stap 3) Voor de 3de stap is het gewoon de wizard volgende. Hierbij gaat het vooral op "next" klikken zijn. Op het eerste scherm dat je ook hierboven in de screenshot kan zien mag alles laten staan hoe het is. Moest je liever geen icoontje op je desktop krijgen kan je altijd de laatste optie uitvinken. Na je dan op ok geklikt hebt gaat de wizard alles beginnen installeren voor jou.
Zodra de wizard klaar is met alles te installeren en unpacken is het eigenlijk klaar. Je mag dan gewoon op "Close" drukken en Docker is klaar om te gaan.

Voor we verder gaan met de wiki mag je eerst Docker eens voor het eerst opstarten. Bij het opstarten gaat er eerst een schermpje komen waar je wat dingen moet accepteren. Dit zijn dingen die niet echt iets met de normale gebruiker zijn. Het gaat er hier om dat grote bedrijven een speciale licensie moeten gebruiken in plaats van de standaard Docker. Dit mag je gewoon accepteren.

Zodra je dat hebt gedaan mag je gewoon inloggen via de gewenste methode (of eerst een account maken) en dan zijn we klaar om verder te gaan met deze wiki.

Voor het volgende deeltje gaan we een paar basiscommando's zien. Deze commando's gaan de basis leggen van Docker en zijn ook zo goed als de meest gebruikte commando's. Hierdoor gaan we later in de wiki niet meer moeten stoppen om bepaalde simpele commando's uit te leggen.
Ik ga alle commando's die ik hier ga tonen een kleine uitleg geven met dan ook een screenshot en een voorbeeld van een situatie waarin dit commando gebruikt zou worden.
Nog voor we verder gaan is het natuurlijk belangrijk dat het duidelijk is hoe we deze commando's moeten uitvoeren. Wel ten eerste moet docker desktop geinstalleerd zijn op je pc. Gelukkige hebben we dat in het vorige stukje al gezien. Als dat in orde is heb je juist nog toegang nodig tot een command prompt of een terminal. Dit is iets dat standaard op elke pc staat. De plaats waar we deze commando's gaan uitvoeren is CMD of Powershell. Welke je gebruikt maakt niet veel uit.

• docker --version
  Dit is het meest basis commando dat er is. Dit commando toont aan op welke versie van docker je bezig bent. Dit kan handig zijn bij problemen met Docker.

• docker build .
  Dit is het commando dat de dockerfile uit jouw project gaat omvormen tot een image. Het punt dat je ziet is de directory van je dockerfile. Dit betekend dat als je dockerfile in dezelfde folder zit als waarin je bezig bent dat een punt voldoende is. Anders ga je hier een pad moeten toevoegen naar je dockerfile.
  Dit commando komt met een paar opties ofwel flags genoemt die je kan gebruiken. De meest gebruikte zijn:
  
  +docker build -t myproject . : de -t staat voor tag of naam. Hiermee geef je de image en naam die anders zonder de tag automatisch gegenereerd zou worden.
  

• docker run _imagename_
  Het commando "docker run" gaat een bestaande image genaamd imagename gebruiken om een container te starten.
  Meest gebruikte flags:
  
  +docker run --name _imagename_ : de --name flag heeft het zelfde effect als de -t flag bij het vorige commando. Dit gaat een naam geven aan je container die anders willekeurig gegenereerd zou worden.
  
  +docker run -d/--detach _imagename_ : de -d of --detach flag gaat er voor zorgen dat je container die je wilt starten in de achtergrond gestart word. Dit betekend dat je terminal niet bezet blijft met alle info van de nieuw gestarte container.
  
  +docker run -p 8080:80 _imagename_ : de -p flag geeft jou de optie om een port aan de nieuw gestarte container te binden. Dankzij deze port kan je dan via een browser communiceren met de container om dan zo je applicatie te bezichtigen.
  
  

• docker stop
  Als je een container kan starten moet je deze natuurlijk ook kunnen stoppen. Daarvoor is het commando "docker stop" er. Dit is een zeer simpel en zelfsprekend commando.
  
  

• docker ps
  Het commando "docker ps" is ook een zeer simpel commando. Hiermee ga je eigenlijk kijken naar alle actieve containers. Je terminal gaat dan een lijst weergeven van alle containers die actief zijn.
  Meest gebruikte flags:
  
  +docker ps -a/--all : De -a of --all flag zorgt ervoor dat je alle containers te zien krijgt en niet alleen de actieve containers.
  
  +docker ps -q/--quiet : De -q of --quiet flag zorgt ervoor dat alleen de id's van de containers getoont worden. Dit zou bijvoorbeeld handig zijn voor scripten.
  
  

• docker images
  Het commando "docker images" gaat een overzicht geven van alle images die lokaal beschikbaar zijn. Standaard gaat dit informatie weergeven over de images zoals:
  +repository (naam)
  +image ID
  +aanmaakdatum
  +grootte
  Meest gebruikte flags:
  
  +docker images -q/--quiet : de -q of --quiet tag in deze context doet exact hetzelfde als bij het "docker ps" commando. Dit gaat er voor zorgen dat alleen de ID van de image getoont word.
  
  +docker images -f/--filter : de -f of --filter tag is vrij vanzelfsprekend. Dankzij deze tag gaan we kunnen filteren op verschillende parameters zoals naam, datum, etc.

We weten nu hoe we met een container kunnen werken, hoe we een image bouwen uit een Dockerfile, etc. Maar wat is een Dockerfile nu precies. Een Dockerfile is een tekstbestand met een aantal instructies die Docker gebruikt om een Docker image te bouwen. Het definieert stap voor stap hoe een container moet worden opgebouwd.
Voor we bij het voorbeeld komen wil ik even laten weten dat het programma dat gebruikt word om het voorbeeld te tonen Visual Studio Code (VSCode) is. Dit is een CLI ofwel een programma om code te schrijven. Zoals bij het Docker build commando is het hier belangrijk dat de commando worden uitgevoert in de juiste directories. Hiervoor is VSCode ook zeer handig. Door binnen VSCode op een folder rechter muisknop te klikken kan je een terminal openen binnen die geselecteerde folder. Hierdoor word het veel makkelijker om commando's uit te voeren op de juiste locaties. Aan de hand van een voorbeeld gaan we nu door een dockerfile gaan. Ik ga elke lijn zo goed mogelijk uitleggen zodat je een wat dieper inzicht hebt van Dockerfiles.
Voorbeeld:

*FROM node:18-alpine :
Deze regel specificeert de basis image waarop de container wordt gebouwd. In dit geval gebruiken we node:18-alpine. Dit is een lichte versie van nodejs. Deze basis images kan je online ook terug vinden.

*WORKDIR /app :
Deze regel is vrij vanzelfsprekend. Het stelt de werkdirectory in binnen de container op /app. Alle volgende stappen van de Dockerfile worden ook dan in deze directory gedaan. Moest deze nog niet bestaan maakt Docker deze ook aan.

*COPY . . :
Hier gaan we nu alles binnen de lokale directory waar de dockerfile in staat kopieren naar die werkdirectory /app.

Dit is een heel simpel voorbeeld van een dockerfile maar het is genoeg om een eigen container te kunnen opbouwen. Dockerfile is veel uitgebreider dan dit maar deze wiki gaat niet alleen over Docker dus dat is hier momenteel niet relevant.

Docker Compose is een tool die ontworpen is om toepassingen die uit meerdere containers bestaan eenvoudig te definiëren, configureren en op te starten. In plaats van meerdere docker run-commando’s te typen voor elke afzonderlijke container, kun je met Docker Compose een enkel configuratiebestand (docker-compose.yml) gebruiken.

Hoe werkt dat nu exact? Docker Compose maakt gebruik van een bestand genaamd docker-compose.yml, waarin je beschrijft welke containers je applicatie nodig heeft, hoe ze moeten worden opgestart en hoe ze met elkaar communiceren.

Ook hier is het belangrijk dat we in de juiste directory werken. Zoals bij Dockerfile gaan we hier ook gebruik maken van VSCode.
Aan de hand van een voorbeeld gaan we weer een dieper inzicht tonen op hoe zo een Docker Compose file nu werkt. Ik ga elke lijn dan ook weer zo goed mogelijk uit proberen te leggen.
Voorbeeld:

* services:
Hiermee start je de definitie van alle services/containers die samen je applicatie vormen. In ons geval hebben we dus 2 containers (web en redis).

* build: . :
In het geval van deze container gaan we zeggen dat het geen image moet gebruiken/downloaden maar dat hij er zelf een moet maken. Dit is waar de "build" voor staat. In dit geval zeggen we dan ook dat hij gewoon de dockerfile moet gebruiken uit de directory waar onze Docker Compose in staat.



* ports: :
Hier geef je poortkoppelingen op: welke poort op je host machine moet gekoppeld worden aan welke poort binnen de container. Dit is hetzelfde concept als in de dockerfile. Via deze ports ga je kunnen communiceren met je containers.

* image: "redis:alpine":
Voor de 2de service/container moet Docker Compose een image van Redis downloaden van Docker Hub.

Zodra je Docker Compose file dan klaar is kan je binnen de directory waar dit bestand staat dan het commando `docker compose up` uitvoeren en dan worden alle containers gemaakt en gestart zoals gewenst. Ook hier hebben we weer gebruik gemaakt van een zeer simpel voorbeeld van Docker Compose. Docker Compose is capable tot veel meer dan hetgene dat hier getoont is. Aan de andere hand hebben we nu een goed verstaan van Docker Compose om het zelf te kunnen gebruiken.