Je (web)applicatie containeriseren

In deze tijd van digitale transformatie wordt het steeds belangrijker om je applicaties snel en efficiënt te implementeren en te onderhouden. Containerisatie is een technologie die hierbij kan helpen. Door je applicatie te containeriseren, maak je gebruik van een 'container', die alle benodigdheden bevat om jouw applicatie uit te voeren. Hierdoor kan je applicatie eenvoudig worden uitgevoerd op elk systeem dat containerondersteuning biedt, zoals ons Kubernetes-platform.

In deze handleiding laten we aan de hand van een dynamische website (met Apache, MariaDB en PHP) zien hoe je jouw applicatie kunt containeriseren met behulp van Docker en vervolgens op een Kubernetes-cluster gebruikt.

Je applicatie containeriseren

Stap 1

Maak en open een bestand genaamd Dockerfile (zonder extensie) voor je applicatie, bijvoorbeeld voor Linux:

nano Dockerfile

Je bent vrij om het Dockerfile bestand in een directory naar keuze te plaatsen.

Stap 2

In dit bestand plaats je informatie over hoe de container image moet worden opgebouwd. De Dockerfile moet daarvoor de volgende stappen bevatten, zie ook de toelichting in de code:

• Op basis van welk besturingssysteem de installatie wordt uitgevoerd, bijvoorbeeld AlmaLinux of Ubuntu.
• Het installeren van de benodigde software en afhankelijkheden, zoals Apache en PHP.
• Het kopiëren van je website-bestanden naar de juiste locatie in de container.
• Eventuele configuratieaanpassingen van de gebruikte software, zoals het configureren van Apache om de website te hosten.

Let op dat je de gegevens hieronder aanpast naar die van jouw eigen configuratie.

# Het besturingssysteem op basis waarvan de image wordt gemaakt. 
    # Beschikbare besturingssystemen vind je op https://hub.docker.com/search?image_filter=official&q=&type=image
    # Specifieke versienummers zoals Ubuntu:22.04 zijn toegestaan
    FROM almalinux:9
    # Installeer de benodigde software en dependencies
    RUN dnf -y update && \
        dnf -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm && \
        dnf -y install https://rpms.remirepo.net/enterprise/remi-release-9.rpm && \
        dnf -y module install php:remi-8.2 && \
        dnf -y install httpd php-common php-cli php-fpm && \
        dnf -y install mariadb-server mariadb 
    # Kopieer de website-bestanden en database naar de container
    COPY . /var/www/html/
    COPY mydatabase.sql /tmp/
    # Start mariadb
    CMD mariadb start
    # Maak de database en gebruiker aan (pas deze gegevens naar wens aan)
    CMD mysql -e "CREATE DATABASE mydatabase; \
                  GRANT ALL PRIVILEGES ON mydatabase.* TO 'myuser'@'localhost' IDENTIFIED BY 'mypassword';" 
    # Importeer de database dump
    CMD mysql mydatabase < /tmp/mydatabase.sql
    # Configureer Apache om de website te hosten 
    RUN sed -i 's/Listen 80/Listen 8080/' /etc/httpd/conf/httpd.conf && \ 
        sed -i 's/#ServerName www.example.com:80/ServerName localhost:8080/' /etc/httpd/conf/httpd.conf && \
        echo "IncludeOptional /etc/httpd/conf.d/*.conf" >> /etc/httpd/conf/httpd.conf
    # Stel de juiste permissies in voor de website-bestanden
    RUN chown -R apache:apache /var/www/html 
    # Start de Apache-service 
    CMD httpd start 
    EXPOSE 8080 CMD 
    ["/usr/sbin/httpd", "-D", "FOREGROUND"] 

Stap 3

Maak de container image op basis van de aangemaakte Dockerfile met het 'docker build'-commando. Vervang hierbij 'my-website' naar wens door een andere naam voor jouw applicatie en 'latest' door een versienummer.

docker build -t my-website:latest .

De punt aan het einde van de regel geeft aan dat de Dockerfile in de huidige map gebruikt moet worden. Als de Dockerfile zich in een andere map bevindt, kun je de volgende syntax gebruiken:

docker build -t my-website:latest -f /path/to/Dockerfile .

Het 'docker build'-commando maakt de container image aan op de lokale Docker-daemon, niet in de huidige map. Dat betekent dat je de container image niet terugziet in de directory waar je het commando hebt uitgevoerd, maar wordt opgeslagen in de interne image cache van de Docker-daemon. Deze images kun je bekijken met het volgende commando:

docker images

Je krijgt hiermee een lijst te zien van alle lokale container images die momenteel aanwezig zijn in de interne image cache van de Docker-daemon. De nieuw gemaakte container image zou daar moeten verschijnen met de naam en tag die je hebt opgegeven bij het 'docker build'-commando.

Deze handleiding is vooral gericht op het gebruik van de gecontaineriseerde applicatie op een Kubernetes-platform. Als je echter de container image wilt delen of opslaan voor andere doeleinden, kunt je deze bijvoorbeeld exporteren naar een tar-bestand met het 'docker save'-commando en vervolgens importeren op een andere locatie met het 'docker load'-commando.

docker save -o <save image to path> <image name>
    docker load -i <path to image tar file>

Stap 4

Gebruik het Docker-commando push om de container image naar een registry te sturen, zodat je het kunt gebruiken op een kubernetes-platform.

In veel gevallen wil je waarschijnlijk het liefste je container image privé houden en naar je eigen container image registry pushen (bijvoorbeeld een eigen Docker registry). Om een gecontainerizeerde applicatie naar bijvoorbeeld een eigen registry te pushen, zijn er drie stappen nodig:

• Verbind met je eigen registry (vervang example.com door de hostname van jouw server):

docker login example.com
    

• Tag je container image met de registry URL (vervang my-image door de naam van je gecontaineriseerde applicatie uit stap 3):

docker tag my-image example.com/my-image

• Push je container image naar de registry:

docker push example.com/my-image 

Of push je container naar de publieke Docker-registry als je wilt dat je container image publiekelijk toegankelijk is:

docker push my-website:latest

Vervang hier my-website:latest door de naam en tag van je applicatie zoals je die in stap 3 hebt aangemaakt.

Leuk! Je hebt je container gemaakt en die is beschikbaar, maar hoe deploy je die? Dat leggen we uit in onze handleiding 'Je gecontainerizeerde image deployen in een Kubernetes-cluster'.