Docker op Oege met Docker images¶

Oege biedt de optie, om Docker images te gebruiken. Hiermee is het mogelijk om een actieve backend server in te richten, waarmee je zelf controle hebt over de gebruikte computer taal/applicatie server.

In onderstaande handleiding wordt uitgelegd, hoe je een node.js Docker image kunt gebruiken om een node backend project te ontsluiten. Verder wordt de Apache webserver op Oege gebruikt om zowel een backend server in Docker als een statische html/javascript front-end site te ontsluiten.

Voor deze methode hoef je geen eigen Docker container te bouwen. We koppelen een folder op Oege aan een standaard Docker image en maken zo een tijdelijke Docker container. De files in de folder zijn dan beschikbaar in de tijdelijke Docker container.

Door de juiste Docker image te kiezen, kun je verschillende applicatie servers gebruiken.

Bijvoorbeeld

taal	image	applicatie server	tag lijst
Java	alpine/java:22-jdk	voor java en springboot	https://hub.docker.com/r/alpine/java/tags/
JavaScript (nodejs)	node:20-alpine	voor node	https://hub.docker.com/_/node

Account aanmaken op Oege¶

Volg de instructie op de Oege pagina https://oege.ie.hva.nl/registratie/ om een account op Oege aan te maken.

Backend server via een Docker container¶

Docker maakt het mogelijk om allerlei software op je machine te draaien in een eigen omgeving. Voor meer uitleg kijk hier Op Oege is het mogelijk om Docker in zogenaamd rootless mode te draaien. Zie https://docs.docker.com/engine/security/rootless/ over hoe het werkt.

Poorten mappen werkt, de poorten onder de 1000 zijn privileged, of te wel alleen beschikbaar voor het OS. Je kunt kiezen voor een poort vanaf 1000 tot 65536. Let op: Poorten 8000-10000 zijn ook van buiten de HvA toegankelijk.

Voor deze handleiding is een poort die van buiten toegankelijk is niet nodig, omdat we uiteindelijk de site via de Apache webserver laten draaien.

Je kunt ook werken met Docker compose.

Installeren rootless Docker op je Oege account¶

Login met ssh in terminal(macOS) of putty (windows) op oege.ie.hva.nl (Wachtwoord vergeten, ga naar https://oege.ie.hva.nl )

run

dockerd-rootless-setuptool.sh install ⏎

en let goed op de tekst die je ziet om je PATH te zetten zoals export PATH=enz. (cut+paste). (wat is PATH?) 3. Test Docker met bijv.

```bash
docker run hello-world ⏎
```

Installeren van je backend¶

Gebruik een ftp-programma en de gegevens van Oege om nadat je een build hebt gedaan van je project dit in een folder op Oege te zetten.

Build je project.
maak verbinding met Oege en maak daar een folder aan bv met de naam api
plaats de backend bestanden in deze folder.
Ga terug naar je terminal en type ls -al (wat is ls) nu zie je alle files en folders in de root van jouw omgeving op Oege.
type nu cd api (wat is cd) enter nu ben je in de api folder (of type de naam, die jij aan je folder hebt gegeven)
Als je nu weer ls -al typt, dan zie je jouw backend files.
Nu gaan we met Docker starten. Kopieer deze regel naar een tekstfile en vervang {poort}:
```
docker run --rm -itd -v "$PWD":/usr/src/app -w /usr/src/app --name=node_web1 -p {poort}:8080 node:20-alpine node index.js ⏎
```
Kies een poort nummer tussen 8000 en 10000 bv iets boven 9000 en vervang {poort} met dit nummer. Nu kopieer je dit nog een keer en plakt het via je terminal op Oege en druk daarna op de return knop.

NB Je kunt online opzoeken, wat alle vlaggen betekenen.
Met docker logs node_web1 kun je de logfile van je container bekijken. 8. Nu is je node server gestart binnen de Docker container. Je kunt nu met je browser en Postman je de backend testen via URL http://oege.ie.hva.nl:{poort}/. Vervang {poort} door jouw poort nummer. 9. gelukt?
Je kunt de container ook stoppen met het volgende commando,
```
docker container stop ⏎
```
Om de container op te ruimen type je
```
docker container rm node_web1 ⏎
```
De naam van de container is unique, dus als je een fout krijgt bij het opstarten, dan kan het zijn dat er nog een oude versie niet is opgeruimd.
Als je nu je terminal/putty afsluit, dan zul je merken, dat je Docker container vlak daarna ook stopt. Dit komt omdat rootless Docker draait met jouw gebruiker en Linux ruimt jouw processen op, zodra je de terminal sluit. Met onderstaande, kun je dit standaard gedrag aanpassen.
```
loginctl enable-linger $(whoami) ⏎
systemctl --user enable docker ⏎
```

frontend webserver¶

Hiervoor kunnen we nu de Apache webserver op Oege gebruiken.

Open de .env.production file in wwwroot en vul daar de URL naar de backend in, plus het poortnummer dat je gebruikte in je backend Docker regel. En build nog een keer.
Ga met je FTP-programma nu op Oege naar de folder /Html en kopieer de files uit de dist/web folder daarnaartoe.
Open je browser en kijk of de site laadt. De link naar je Oege site kun je aanmaken op de Oege homepage via de ‘Mijn Oege Website’ optie.
Als alles goed is, dan zie je nu je site. Alleen er is nog wel een probleem. Je site draait met https en de backend op http(zonder encryptie). Dit vinden browsers niet goed en blokkeren nu je http calls naar de backend. Je kun dit oplossen
- In Firefox door op het slotje te klikken -> op ‘verbinding beveiligd’ te klikken en de bescherming uit te schakelen.
- In Chrome door vlak voor je URL op het symbooltje te klikken -> site settings te klikken -> en te scrollen naar ‘Insecure content’ en dit op allow te zetten.

Als alles is goed gegaan, heb je nu een werkende site, Al is deze nog niet helemaal productie ready. Je kunt natuurlijk niet van je gebruikers verwachten, dat ze de bescherming tegen mee kijken van de browser uitzetten.

backend webserver proxy¶

Ook dit is oplosbaar, door een trucje uit te halen met de webserver. Deze kan namelijk behalve webbestanden opsturen ook proxieën. Dit houdt in, dat je een verbinding maakt met de webserver, en dat deze dan vervolgens een verbinding maakt met de node backend server. Als website bezoeker merk je hier verder niets van.

Login met ssh/putty op oege.ie.hva.nl
type
```
cd Html ⏎
```
Nu sta je in de web folder op Oege.(met ls -al kun je de webbestanden zien) 3. Maak nu een folder aan, dit wordt de ingang op je backend. bv api, type
```
mkdir api ⏎
```
Dit maakt een folder aan met de naam api. Maar een andere naam mag dus ook. Vervang dan wel in de rest van de opdrachten api door die naam. 4. type
```
cd api ⏎
```
Nu sta je in de api folder. 5. type

touch .htaccess ⏎

Dit maakt een lege file aan met de naam .htaccess 6. type

```bash
nano .htaccess ⏎
```

Kopieer en plak onderstaande in de .htaccess file.
```
RewriteEngine On
RewriteRule ^(.+)\$ "http://oege.ie.hva.nl:{poort}/\$1" [P]
```
En vervang {poort} door je backend poort nummer.

Zo, en wat doet deze .htaccess file. Hiermee kun je extra instelling aan je webserver toevoegen, zoek maar eens op Apache en .htaccess. In dit geval gebruiken wij het om een URL die binnenkomt op de apache webserver door te geven aan je backend server. De regel met RewriteRule ^(.+)$ "http://oege.ie.hva.nl:{poort}/$1" zorgt hiervoor. De regex ^(.+)$ leest de binnen komende URL en plakt die op de plek van de $1 8. control x of ctrl x en save 9. Ga nu naar je ontwikkelomgeving en open de .env.production file in /src/web/ en vul daar VITE_API_URL=”{de URL naar je site op Oege}/api/” in. En buildt nog een keer. 10. Ga met je FTP-programma nu op Oege naar de folder /Html en kopieer de files uit de dist/web folder daarnaartoe. 11. Open je browser en ververs je pagina, nu zou ook je backend via https bereikbaar moeten zijn. En kun je de aanpassingen in Firefox/Chrome weer terugdraaien.

open poort¶

Het is nu nog mogelijk om rechtstreeks bij de backend te komen zonder gebruik van encryptie. Bv door naar http://oege.ie.hva.nl:{poort}/ te gaan met postman.

Kun je aangeven, waarom dit niet wenselijk is?

Tip, misschien is je eerste gedachte om hier een firewall voor te gebruiken. Dit is niet nodig. Je kunt dit oplossen met de instellingen van je Docker container. Door naast de poort ook te binden aan 127.0.0.1 of localhost. -p 127.0.0.1:{poort}:8080 i.p.v. -p {poort}:8080 Nu accepteert de Docker omgeving geen verbindingen meer, die niet vanaf de machine komen waar Docker op draait.

En nu voor Java¶

Bovenstaande geldt nu ook op een klein verschil na de regel om de Docker container te starten.

docker run --rm -itd -v "$PWD":/usr/src/app -w /usr/src/app --name=java_web1 -p {poort}:8080  alpine/java:22-jdk java -jar productpricing-0.0.1-SNAPSHOT.jar ⏎

De regel is vrijwel hetzelfde als bij Node.js. We gebruiken een ander image (alpine/java:22-jdk) en i.p.v. node index.js, staat er nu java -jar productpricing-0.0.1-SNAPSHOT.jar

Of te wel door de juiste Image te kiezen, kun je verschillende omgevingen op Oege draaien.

Iets over Docker

In het onderstaande kun je zien, dat Docker een geïsoleerde omgeving creëert. je kunt namelijk ook in de container gaan. En als je nu kijkt met welke user je bent ingelogd, dan zie je, dat die veranderd naar root nadat je in de Docker container bent gestapt.

connect met Oege via ssh.
type whoami ⏎ nu zie je de naam van de user, waarmee je bent ingelogd op Oege.
ga naar je backend folder. en type
```
docker run --rm -itd -v "$PWD":/usr/src/app -w /usr/src/app --name=node_web1 -p {poort}:8080 node:20-alpine /bin/sh ⏎
```
Vervang weer de {poort} en druk daarna op enter. De rede, dat je nu in de container kunt stappen, komt door het einde van deze opdracht. Je hebt nu node index.js vervangen door /bin/sh. node index.js start je node.js backend en /bin/sh start de sh shell. Voor Linux is de shell de plek waar je als gebruiker je commando’s kunt geven.
nu gaan we in de Docker container type:
```
docker attach node_web1 ⏎
```
nu zit je in de Docker container. type
```
whoami ⏎
```
nu zie je dat de username is veranderd in root. Ook als je met cd en ls rondloopt in de container zul je zien, dat het file systeem anders is, dan het filesysteem van Oege. 5. Als je nu weer teruggaat naar de api folder, dan kun je daar node nu zelf starten door daar
```
node index.js ⏎
```
te typen.
Met Ctrl+C stop je de node.js server.

Met
```
exit ⏎
```
stap je uit de container en ruim je de Docker container op.