Cloud & DevOps — Studiegids

01 — ☁ The Cloud

📦 On-Premise → Cloud

Vroeger: servers in een serverruimte op het bedrijfsperceel (on-premise). Nadelen:

💰 Hoge initiële kosten (hardware, licenties)
🔧 Veel onderhoud & IT-personeel nodig
📉 Beperkte schaalbaarheid
📵 Lage betrouwbaarheid (geen redundantie)
🔓 Volledige verantwoordelijkheid voor security

🏢 Datacenter Evolutie

Bedrijven centraliseerden server-ruimtes in datacenters: dedicated gebouwen met power, koeling, security en backup. Vereist speciale voorzieningen:

⚡ PDUs (Power Distribution Units), UPS, diesel generators
❄ Hot/cold aisle cooling, CRAC-systemen
🧯 Mantraps, gasblusinstallaties, camera's

📊 Uptime Institute — Tier Systeem

Tier	Redundantie	Uptime	Max. downtime/jaar
Tier 1	Geen	99.67%	28.8 uur
Tier 2	Gedeeltelijk	99.74%	22 uur
Tier 3	Meerdere paden, 1 actief	99.98%	1.6 uur
Tier 4	Volledig redundant	99.995%	26.3 min

Redundantie = kritieke componenten dupliceren zodat als één faalt, de andere het overneemt. Vb.: dubbele voedingen, meerdere internet-providers.

🇧🇪 Belgische datacenter voorbeelden: LCL (Brussels-West, Antwerpen, Diegem) • Interxion / Digital Realty (Zaventem) • Greenhouse Datacenters • Microsoft & Google cloud regio's.

🎩 Private Cloud

Bedrijf bouwt/huurt datacenter en biedt hosting aan. Voorbeeld: RCloud (Inetum-RealDolmen) in LCL/InterXion.

✅ Privacy (exacte locatie bekend), maatwerk, eigen ingenieurs ter plaatse
⚠ Langzamer, duurder, minder services

🌎 Public Cloud

Hyperscale datacenters wereldwijd. AWS, Azure, GCP, IBM Cloud. Exacte locatie servers onbekend.

✅ Snel starten, cost-effective, grote variëteit
⚠ Privacy-wetten lastiger, geen maatwerk

🌐 Hybrid Cloud

Combinatie van public + private. Best of both worlds. Voorbeeld in België: Cegeka.

Er zijn ook andere modellen: Co-location (ruimte verhuren in datacenter), Community cloud, Multi-cloud.

⚖ Cloud vs On-Premise — Voordelen Cloud

Aspect	On-Premise	Cloud
Kosten	Hoog upfront (CAPEX)	Pay-as-you-go (OPEX)
Onderhoud	Eigen IT-team nodig	Provider beheert alles
Schaalbaarheid	Moeilijk/traag	On-demand in minuten
Betrouwbaarheid	Kwetsbaar voor uitval	Redundante infra wereldwijd
Security	Eigen verantwoordelijkheid	Shared responsibility + tools

📈 Scalability vs Elasticity

Load Balancing: verdeelt werkbelasting over meerdere servers.

Scalability: manueel of via regels extra servers opstarten als een drempel overschreden wordt. Minder dynamisch.

Elasticity: automatisch en sneller, volgt vraag real-time op. Kostenoptimalisatie.

📶 HA & DR

High Availability (HA): zorgt dat services altijd beschikbaar zijn. Gebruikt geo-redundantie (≥200 km afstand).

Disaster Recovery (DR): backup + herstel bij grote rampen. Gebruikt beschikbaarheidszones/regio's.

🛡 Security: Confidentiality & Integrity

Encryptie: data onleesbaar maken, enkel te ontcijferen met sleutel.
Firewalls: in/uitgaand verkeer filteren.
Authenticatie: identiteit verifiëren (wachtwoord, token, biometrie).
Autorisatie: toegangsniveaus bepalen via policies/rollen.

Confidentialiteit: data alleen toegankelijk voor bevoegden.
Integriteit: data alleen aanpasbaar door bevoegden.

☁ Service Modellen

Model	Beschrijving	Verantw. gebruiker	Voorbeeld Azure
IaaS Infra as a Service	Ruwe compute: VM's, opslag, netwerk, OS	Hoog — alles boven hardware	Virtual Machines
PaaS Platform as a Service	Pre-configured platforms: DB, webserver, dev-tools	Middel — apps & data	Azure Web Apps
SaaS Software as a Service	Kant-en-klare software (e-mail, CRM)	Laag — enkel gebruik	Microsoft 365

🔵 Azure — Sleutelconcepten

Regions: geografisch gebied met 1+ datacenters. Ondersteunt HA en DR. Vb.: "West Europe".
Availability Zones: fysiek gescheiden datacenters binnen één regio.
Subscriptions: billing/management grens. Één account kan meerdere subscriptions hebben.
Resource Groups: logische container voor gerelateerde resources. Heeft naam + locatie.

💰 Azure Factuurpunten

Service type: compute per uur/seconde, storage per GB
Usage: hoeveel je verbruikt
Location: Japan duurder dan India
Performance tier: A/B/D/F-series VM's hebben elk eigen prijs

Tools: Pricing Calculator, Cost Management Portal, Billing Alerts.

Optimaliseren: juiste service level kiezen, auto-scaling, reserved instances (tot 72% korting).

🎯 QUIZ — The Cloud

Welke Tier van het Uptime Institute heeft volledig redundante paden (beide actief) en een verwachte uptime van 99.995%?

Tier 4 heeft volledig redundante én actieve paden en slechts 26.3 minuten downtime per jaar.

Wat is het verschil tussen Scalability en Elasticity?

Scalability = minder dynamisch, werkt met thresholds. Elasticity = volledig automatisch, volgt vraag op de voet voor maximale kostenoptimalisatie.

Een klant wil een VM huren waarbij hij het OS zelf installeert en configureert. Welk service model past hier het best?

IaaS = Infra as a Service. De gebruiker krijgt ruwe compute (VM's, netwerk, OS) en is zelf verantwoordelijk voor alles daarboven.

Welke eigenschap is een voordeel van Private Cloud ten opzichte van Public Cloud?

Private Cloud biedt betere privacy: exacte locatie van data is bekend, handig voor compliance met specifieke wetgeving.

Welke Azure-resource is een logische container die gerelateerde services groepeert en waarop je policies en tags kan toepassen?

Een Resource Group is een logische container met naam + locatie. Je beheert resources als eenheid en past policies/permissions/tags toe op heel de groep.

Wat is Geo-Redundantie in de context van High Availability?

Geo-redundantie dupliceert data/systemen naar een ander datacenter op ≥200 km om beschermd te zijn tegen regionale rampen.

vragen correct

02 — 📦 Containers

🤔 Waarom containers?

Probleem: meerdere kleine apps op aparte VM's = verspilling. Elke VM heeft een volledig OS → veel overhead.

      Oplossing: containers — kleine, geïsoleerde omgevingen met enkel de applicatiecode + dependencies. Delen de kernel van de host → veel minder overhead.
    

🆚 VM vs Container

Aspect	VM	Container
OS	Volledige eigen kernel + drivers	Deelt kernel van de host
Grootte	Gigabytes (incl. OS)	Megabytes (enkel filesystem)
Startup	Minuten	Seconden
Isolatie	Volledige hardware-isolatie	OS-niveau isolatie
Beheerd door	Hypervisor (ESXi, KVM, Hyper-V)	Container engine (Docker, LXC)

🐧 Wat is een Kernel?

De kernel is de kern van een OS: beheert communicatie tussen hardware en software (geheugen, processen, schijf, system calls). Containers delen de host-kernel → ze kunnen geen ander OS draaien dan het host-OS.

⚙ Processen & PID 1 in een Container

Elke container draait één hoofdproces (PID 1). Dit proces controleert de volledige lifecycle:

Container stopt als PID 1 stopt — ook al lopen andere achtergrondprocessen nog
Container heeft altijd minstens 1 actief proces nodig
Docker = wrapper rond een proces (met eigen filesystem & netwerk)

Flags die het procesgedrag bepalen: -it (interactief, stdin open) en -d (detached, achtergrond).

📦 Structuur van een Container

Filesystem: gebaseerd op een base image (bv. Alpine of Debian)
Applicatie: de code die de logica uitvoert
Dependencies: system libraries (openssl), taal-specifiek (Python), tools (git)
Configuratie: env-variabelen, poort, log-niveau, DB-connectionstring

📅 Geschiedenis van Containers

2001: Linux-VServer — eerste container-technologie op Linux
2008: LXC (Linux Containers) — combineert cgroups (resources alloceren) + namespaces (resources isoleren)
2013: Docker — game-changer, portabele container images, grote community
2014: Kubernetes — orchestratie van containers op schaal (van Google)
2014: Open Container Initiative (OCI) — standaardisatie van container-formaten
Nu: AWS ECS, Google GKE, Azure Kubernetes Service (AKS)

🍪 Docker: Images vs Containers

Container Image = een statisch snapshot/template met alle files, dependencies en configuratie. Zoals een koekjesvorm (cookie cutter).

Container = een runtime instantie van een image. Efemeer (gemakkelijk aanmaken/stoppen/verwijderen). Wijzigingen in een container beïnvloeden de image NIET. Zoals een koekje gebakken met de koekjesvorm.

      Docker Hub = cloud-gebaseerde registry voor het delen van container images. Bevat officiële images (nginx, mysql, tensorflow). Je kan images pushen en pullen.
    

🏔 Alpine Linux

Minimalistisch, small image size, snel te starten, weinig resources. Mist veel standaard libraries. Gebruikt apk als package manager. Voorkeur in containers.

🐧 Debian Linux

Stabiel, groot software-repository, meer libraries beschikbaar. Grotere image size. Gebruikt apt als package manager. Geschikter voor complexe apps.

🖥 Docker Commando's

Commando	Beschrijving
`docker run <image>`	Maakt altijd een NIEUWE container aan en start die
`docker run -it`	Interactieve terminal (stdin attached)
`docker run -d`	Detached mode (achtergrond)
`docker run -p 8080:80`	Port mapping: host:container
`docker run -P`	Alle EXPOSED poorten automatisch naar random host-poorten mappen
`docker run -e VAR=val`	Environment variabele instellen
`docker run -v host:container`	Volume / bind mount koppelen (bv. `-v $(pwd):/app`)
`docker run --name naam`	Container een naam geven
`docker run --network net`	Container aan een specifiek netwerk koppelen
`docker ps`	Toont draaiende containers
`docker ps -a`	Alle containers (ook gestopt)
`docker start <id>`	Start gestopte container opnieuw (GEEN nieuwe)
`docker stop <id>`	Stop een draaiende container
`docker rm <id>`	Verwijder een container
`docker exec -it <id> sh`	Voer commando uit in draaiende container
`docker attach <id>`	Verbind CLI aan draaiende container
`docker logs <id>`	Logs bekijken van container

🚪 Poorten: Houses & Doors

IP/hostname = huisadres. Poortnummer = deurnummer. Poort 80 = HTTP, 22 = SSH, 3306 = MySQL.

-p 3307:3306 → host poort 3307 mapt naar container poort 3306.

Port conflict: twee services op dezelfde host-poort = onmogelijk. Oplossing: andere host-poort kiezen (bv. 3308:3306).

📁 Volumes & Bind Mounts

Containers zijn efemeer → data gaat verloren bij verwijderen. Oplossing: volumes.

Type	Beschrijving
Volume	Docker-beheerde opslag in `/var/lib/docker/volumes`. Makkelijk backuppen, deelbaar.
Bind Mount	Deelt een map van je computer met de container. Beide zien dezelfde bestanden.

docker volume create myvol
docker volume ls
docker volume inspect myvol
docker volume rm myvol
docker volume prune
docker run -v myvol:/data image

MySQL voorbeeld: -v mysqldata:/var/lib/mysql → data blijft bestaan ook na container removal.

⚡ Redis

Redis = in-memory key-value database. Extreem snel. Docker image: redis.

Caching
Pub/sub systemen
Session storage
Rate limiting

🎯 QUIZ — Containers

Wat is het fundamentele verschil tussen een container engine (Docker) en een hypervisor?

Container engine = OS-virtualisatie (deelt host-kernel). Hypervisor = hardware-virtualisatie (volledige OS per VM, meer flexibel maar zwaarder).

Wat gebeurt er als je docker run hello-world uitvoert en de image niet lokaal aanwezig is?

Bij elke docker run wordt eerst lokaal gezocht. Niet gevonden? → automatisch pull van Docker Hub (de default registry).

Je draait: docker run -it alpine ash, maakt een bestand "hello.txt", en daarna docker run alpine ls. Wat zie je?

Container isolatie! Elke `docker run` start een nieuwe, volledig geïsoleerde instantie. Wijzigingen in container A zijn onzichtbaar voor container B.

Je wil een MySQL container starten die in de achtergrond draait op host-poort 3307. Welk commando is correct?

-d = detached (achtergrond), -p host:container poort. Het juiste formaat is altijd -p HOSTPOORT:CONTAINERPOORT.

Wat is het verschil tussen docker run en docker start?

docker run = altijd nieuw. docker start = bestaande container (heeft container ID nodig) opnieuw opstarten.

vragen correct

03 — 🏗 Crafting a Container

📸 Methode 1: Instance Promotion (commit)

Start een container interactief → installeer software → commit als image.

# 1. Start container
docker run -it ubuntu bash
# 2. Installeer iets
apt-get install -y figlet
exit
# 3. Commit als image
docker commit <container_id>
docker image tag <id> ourfiglet

📄 Methode 2: Dockerfile (aanbevolen)

Instructies in een tekstbestand → reproduceerbaar, deelbaar, versiebeheersbaar.

# Dockerfile
FROM ubuntu
RUN apt-get update && apt-get install -y figlet

docker build -t ourfiglet .

📖 Dockerfile Instructies

Instructie	Functie	Voorbeeld
`FROM`	Basis image (verplicht, eerste lijn)	`FROM python:3.9-slim`
`RUN`	Commando uitvoeren TIJDENS build	`RUN apt-get install -y curl`
`COPY`	Bestanden kopiëren van host naar image	`COPY app.py /app/app.py`
`WORKDIR`	Werkdirectory instellen	`WORKDIR /app`
`CMD`	Standaard commando bij container start (overschrijfbaar)	`CMD ["python","app.py"]`
`ENTRYPOINT`	Vaste startcommando (niet overschrijfbaar)	`ENTRYPOINT ["python"]`
`EXPOSE`	Documenteert poort (publiceert NIET)	`EXPOSE 80 443`
`ENV`	Env-variabele (beschikbaar bij build & runtime)	`ENV PORT=8080`
`ARG`	Build-time variabele (ENKEL tijdens build, NIET bij runtime)	`ARG VERSION=1.0`
`ADD`	Zoals COPY maar ook URLs en auto-unzip van tar-archief	`ADD archive.tar.gz /app/`

🌐 Volledig voorbeeld: NodeJS app

DOCKERFILE
FROM alpine
RUN apk update && apk add nodejs
COPY . /app
WORKDIR /app
CMD ["node", "index.js"]

# Bouwen met tag en versienummer
docker build -t hello:v0.1 .
# Draaien
docker container run hello:v0.1

De tag na : is de versie. Default = latest.

🧅 Image Layers & Caching

Elke Dockerfile-instructie maakt een nieuwe laag. Lagen zijn immutable (niet aanpasbaar).

Bij docker build: als een laag ongewijzigd is, gebruikt Docker de cache → sneller bouwen.

Bij het draaien van een container wordt er een extra schrijfbare laag bovenop gelegd (changes worden hier bijgehouden).

# Layers bekijken
docker history hello:v0.1
# Inspect layers als JSON
docker image inspect --format "{{ json .RootFS.Layers }}" hello:v0.1

Twee images met dezelfde base image (bv. Alpine) delen dezelfde onderste laag (zelfde SHA256 hash).

🚀 Push naar Docker Hub

# Build met jouw Docker ID in de naam
docker build -t JOUW_ID/testwebsite:latest .
# Login
docker login -u JOUW_ID -p JOUW_WACHTWOORD
# Push
docker push JOUW_ID/testwebsite:latest

De suffix :latest overschrijft de laatste versie. Gebruik versienummers voor releases (bv. :v1.2.0).

🎯 QUIZ — Crafting a Container

Welke Dockerfile instructie voert een commando uit TIJDENS het bouwen van de image (niet bij het starten van de container)?

RUN wordt uitgevoerd tijdens het `docker build` proces en creëert een nieuwe laag. CMD en ENTRYPOINT worden uitgevoerd bij het starten van de container.

Wat doet EXPOSE in een Dockerfile?

EXPOSE is documentatie. De werkelijke port binding/publishing doe je met -p bij `docker run`.

Je past de index.js aan en bouwt v0.2. Je merkt dat stap 2 (RUN apk add nodejs) de cache gebruikt. Wat betekent dit?

Layers zijn immutable. Als een laag ongewijzigd is, gebruikt Docker de cache en slaat die stap over → significant snellere builds.

Wat is het verschil tussen CMD en ENTRYPOINT?

CMD kan overschreven worden via `docker run image anderecommand`. ENTRYPOINT is het vaste startpunt; extra argumenten worden eraan toegevoegd.

vragen correct

04 — ♾ DevOps & Pipelines

♾ Wat is DevOps?

DevOps = set van practices, tools en cultuurfilosofie die software development en IT operations automatiseert en integreert. Doel: de kloof tussen Developers en Operations overbruggen voor betere samenwerking en efficiëntie.

      De DevOps lifecycle heeft 8 fasen (∞-vorm): Plan → Code → Build → Test → Release → Deploy → Operate → Monitor → terug naar Plan.
    

⚙ GitHub Actions — Hoe werkt het?

GitHub zoekt naar .yml bestanden in .github/workflows/
Bij een trigger (bv. push) start GitHub een runner virtual machine in de cloud voor elke job
De stappen worden uitgevoerd in die VM
Na de job wordt de VM vernietigd

📋 Workflow.yml Structuur

YAML
name: Pipeline               # naam in GitHub UI

on:
  push:
    branches: [ main ]       # trigger bij push naar main

permissions:
  contents: write           # schrijfrechten voor workflow

jobs:
  mijn-job:
    runs-on: ubuntu-latest  # type runner VM
    needs: andere-job        # wacht op andere-job
    steps:
      - name: Stap beschrijving
        uses: actions/checkout@v2  # built-in action
      - name: Run commando
        run: echo "hello"
        with:                    # parameters voor 'uses'
          key: value

🔑 Workflow Sleutelwoorden

name: naam van de workflow
on: trigger-event (push, pull_request, ...)
branches: welke branches triggeren
jobs: verzameling van taken
runs-on: type runner (ubuntu-latest)
needs: dependency op andere job
steps: stappen in een job
uses: gebruik een bestaande Action
run: shell-commando uitvoeren
with: parameters voor een Action

🔐 GitHub Secrets

Gevoelige info (wachtwoorden, tokens) veilig opslaan. Beschikbaar via ${{ secrets.NAAM }}.

Instellen via: Settings → Secrets and variables → Actions → New repository secret

Voorbeelden: DOCKERHUB_USERNAME, DOCKERHUB_PASSWORD, GITHUB_TOKEN (automatisch door GitHub).

📈 CI / CD / CD — Wat is het verschil?

Term	Staat voor	Wanneer bereikt?
CI Continuous Integration	Automatisch code testen bij elke push	Na de Test-stap in de pipeline
CD Continuous Delivery	Software automatisch gereed maken voor deployment (bv. Docker image bouwen)	Na de Release-stap (package/container)
CD Continuous Deployment	Software automatisch deployen naar productie	Na de Deploy-stap (live zetten)

🔍 SonarCloud — Code Kwaliteit

SonarCloud analyseert code automatisch in de pipeline. Issue-categorieën:

Categorie	Betekenis
🐞 Bugs	Code die onjuist gedrag veroorzaakt (logica-fout)
🔓 Vulnerabilities	Security-risico's die dringend gefixed moeten worden (bv. SQL injection)
🛡 Security Hotspots	Gevoelige code die een review nodig heeft (bv. encryptie-logica)
☢ Code Smells	Slechte structuur/design — geen bug, maar moeilijker te onderhouden

Quality Gate: set drempelwaarden (bv. 0 bugs, 0 vulnerabilities, coverage ≥ 80%). Code haalt gate NIET → pipeline faalt → geen deployment.

🏗 Volledige CI/CD Workflow (website voorbeeld)

YAML
jobs:
  test:                             # CI: HTML/CSS validatie
    steps:
      - uses: actions/checkout@v2
      - uses: Cyb3r-Jak3/html5validator-action@v7.2.0
        with: { root: ./, css: true }

  delivery:                         # CD: Docker image bouwen + pushen
    needs: test
    steps:
      - uses: actions/checkout@v2
      - run: docker build -t ${{ secrets.DOCKERHUB_USERNAME }}/website .
      - uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_PASSWORD }}
      - run: docker push ${{ secrets.DOCKERHUB_USERNAME }}/website

  deploy:                           # CD: Deploy naar GitHub Pages
    needs: test
    steps:
      - uses: actions/checkout@v2
      - uses: peaceiris/actions-gh-pages@v4
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: .

De delivery en deploy jobs draaien parallel omdat ze allebei needs: test hebben (niet van elkaar afhankelijk).

🎯 QUIZ — DevOps & Pipelines

Wat is Continuous Integration (CI)?

CI = Continuous Integration. Bij elke code push worden automatisch tests uitgevoerd → vroeg fouten opsporen, stabiele codebase.

Wat doet needs: test in een GitHub Actions job?

`needs` definieert een dependency. De job wacht tot de opgegeven job succesvol is voltooid voor hij start.

Waar moet je een workflow.yml bestand plaatsen zodat GitHub Actions het herkent?

GitHub scant automatisch de `.github/workflows/` map voor YAML bestanden die als workflow/pipeline dienen.

Wat is het verschil tussen Continuous Delivery en Continuous Deployment?

Delivery = release-klaar (package beschikbaar, bv. Docker Hub). Deployment = automatisch live zetten naar productie zonder menselijke tussenkomst.

vragen correct

05 — 🧱 Building Code

🌍 Drie Taaltypen

Type	Hoe?	Build nodig?	Talen
Interpreted	Interpreter leest & voert code lijn per lijn uit (runtime)	Nee	Python, JavaScript, Ruby, PHP
Compiled	Compiler vertaalt naar machine code (.exe) voor een specifiek platform	Ja → .exe	C, C++, Go, Rust
Hybrid	Compiled naar bytecode (.class), dan geïnterpreteerd door JVM/CLR	Ja → .jar/.dll	Java, C#

📝 Interpreted (Python)

⚡ Langzamer: lijn per lijn
💾 Meer geheugen: source + tussenresultaten
🔎 Fouten pas bij runtime
✅ Cross-platform (interpreter installeren)
✅ Dynamic typing mogelijk

🗜 Compiled (C/C++)

⚡ Sneller: al vertaald naar machine code
💾 Minder geheugen: geoptimaliseerd
🔎 Fouten bij compile-time (vroeger)
⚠ Platform-specifiek: .exe voor Windows werkt niet op Linux
Hercompilatie nodig per platform

☕ Java: De Hybride Aanpak

Java is compiled + interpreted = cross-platform via de JVM.

      Stap 1 (Compiled): javac compileert .java bestanden naar bytecode (.class bestanden). Platform-onafhankelijk!

      Stap 2 (Interpreted): De JVM (Java Virtual Machine) laadt de .class bestanden en interpreteert de bytecode naar native machine code. JIT-compilatie voor snelheid.

Resultaat: "Write once, run anywhere" — als er een JVM is, draait de code.

🔨 Maven voor Java

Maven = build automation tool voor Java. Beheert libraries, buildprocess en documentatie. Configureert via pom.xml.

XML (pom.xml)
<groupId>fact.it</groupId>         <!-- Groep/organisatie -->
<artifactId>example-bicycle</artifactId> <!-- Projectnaam -->
<version>0.0.1-SNAPSHOT</version>  <!-- Versie -->
<dependencies>...</dependencies>   <!-- Libraries -->
<build><plugins>...</plugins></build> <!-- Build plugins -->

📦 Maven Commando's

Commando	Wat doet het?	Output
`mvn compile`	Compileert .java naar .class bestanden	`/target/classes/`
`mvn test`	Bouwt code eerst, daarna unit tests uitvoeren	Test-resultaten
`mvn package`	Bouwt + test + verpakt in .jar bestand (ook tests)	`/target/*.jar`

# JAR uitvoeren
java -jar .\example-bicycle-0.0.1-SNAPSHOT.jar

De naam van de JAR = artifactId + version uit pom.xml.

🧪 Unit Tests

Unit tests testen individuele methodes of klassen in isolatie. In Java met JUnit.

JAVA
@Test
public void testGetEmailAddress() {
    Student student = new Student("r123456", "Jan", "Janssen");
    assertEquals("r123456@student.thomasmore.be",
                  student.getEmailAddress());
}

Maven voert automatisch alle tests uit bij mvn test en mvn package.

🐍 pytest — Python Testing

pytest: populair Python test-framework. Eenvoudige syntax, krachtige output.

Gebruikt in DevOps voor het automatisch testen van Python applicaties tijdens CI/CD.

🏷 GitHub Tags & Releases

GitHub Tags: markeren een specifieke versie van de code in Git.

GitHub Releases: volledige release-pakketten gebaseerd op tags (downloadbaar bestand, release notes).

Beide zijn key in de Release en Deploy stappen van de DevOps lifecycle.

🐳 Java in CI/CD Pipeline (GitHub Actions)

YAML
jobs:
  build-and-test:
    steps:
      - uses: actions/checkout@v2
      - name: Set up JDK 11
        uses: actions/setup-java@v2
        with: { java-version: '11', distribution: 'adopt' }
      - name: Test with Maven
        run: mvn test -B          # -B = batch mode (minder output)

  deliver-container:
    needs: build-and-test
    steps:
      - name: Build JAR
        run: mvn package -B
      - name: Build Docker image
        run: docker build -t ${{ secrets.DOCKERHUB_USERNAME }}/app .

  deliver-jar:               # Upload als GitHub Artifact
    needs: build-and-test
    steps:
      - uses: actions/upload-artifact@v4
        with:
          name: zipped-project-jar-file
          path: target/*.jar

📦 GitHub Artifacts

Bestanden (bv. .jar, test-resultaten) tijdelijk opslaan op GitHub en beschikbaar stellen voor download. Gebruik: actions/upload-artifact. Zichtbaar in het Actions tab → Summary.

Voordeel: software uitleveren zonder container (alternatief voor Docker Hub).

🎯 QUIZ — Building Code

Hoe verschilt Java van pure interpreted talen zoals Python op het gebied van compilatie?

Java = hybrid: compiled naar bytecode (platform-onafhankelijk), daarna geïnterpreteerd door JVM. "Write once, run anywhere."

Welk Maven commando bouwt de code, voert unit tests uit EN verpakt alles in een .jar bestand?

mvn package = compile + test + package naar .jar. Het .jar bestand staat in /target/.

Wat is een Unit Test?

Unit tests = kleine, geïsoleerde tests van één methode/klasse. Doel: individuele componenten correct laten werken voor integratie.

Waarom is een .jar bestand handiger dan losse .class bestanden voor distributie?

JAR (Java ARchive) = alles in één bestand. Je hoeft niet alle afzonderlijke library-paden op te geven zoals bij losse .class bestanden.

vragen correct

06 — 🛳 Infrastructure as Code

🛳 Operate-stap in DevOps

De Operate stap beheert en onderhoudt applicaties en infra na deployment. Focust op vlot, efficiënt en betrouwbaar draaien in productie.

      IaC (Infrastructure as Code) = infra beheren en provisioneren via machine-leesbare definitiebestanden in plaats van manuele processen. Code die ook leesbaar is voor mensen.
    

✅ Waarom IaC? Voordelen

Automatisering: sneller infra deployen en configureren
Samenwerking: configuraties in versiebeheer (Git), wijzigingen traceerbaar
Schaalbaarheid: snel up/down schalen via code
Reproducibiliteit: zelfde setup in dev, test én productie
Vermindert menselijke fouten: geen manuele stappen

🐳 Docker Compose = IaC

Docker Compose definieert multi-container applicaties in een docker-compose.yml bestand. Declaratief: je beschrijft de gewenste toestand, niet de stappen.

docker run commando	Docker Compose equivalent
`docker run -d --name mydb -p 3307:3306 -e MYSQL_ROOT_PASSWORD=abc123 mysql:latest`	Zie YAML hieronder

YAML
services:
  mydb:
    image: mysql:latest
    container_name: mydb
    ports:
      - "3307:3306"
    environment:
      MYSQL_ROOT_PASSWORD: abc123

⚙ Docker Compose Commando's

Commando	Functie
`docker compose up -d`	Start alle services in achtergrond
`docker compose up --remove-orphans`	Start op en verwijdert verouderde containers
`docker compose down`	Stop en verwijder containers
`docker compose build`	Herbouwt images van Dockerfiles
`docker compose ps`	Lijst van alle services in het project
`docker compose -p naam up -d`	Deploy met custom projectnaam

🔗 Containers verbinden + Netwerken

YAML
services:
  app:
    build: ./app         # bouwt Dockerfile in ./app map
    networks:
      example-network:
        ipv4_address: 172.16.238.10

  db:
    image: mysql:latest
    volumes:           # persistente opslag
      - db-data:/var/lib/mysql
    networks:
      example-network:
        ipv4_address: 172.16.238.11
    depends_on:        # wacht op app
      - app

networks:
  example-network:
    driver: bridge     # containers op zelfde host communiceren

bridge driver: containers op dezelfde host kunnen communiceren.
Containers vinden elkaar via de service-naam (bv. app:8000).

📋 Compose YAML Structuur

services: elk service = één containertype
image: Docker Hub image gebruiken
build: Dockerfile bouwen (geeft map op)
container_name: naam van de container
ports: host:container port mapping
environment: env-variabelen
volumes: persistente opslag
depends_on: wacht op andere service
networks: welk netwerk de service gebruikt
env_file: .env bestand laden
restart: herstart-policy (unless-stopped)

🎯 QUIZ — IaC & Docker Compose

Waarom wordt Docker Compose beschouwd als Infrastructure as Code (IaC)?

IaC = infra als code. Docker Compose beschrijft declaratief de gewenste toestand, is in Git te bewaren, te reviewen en reproduceerbaar in elke omgeving.

Wat doet depends_on in een docker-compose.yml?

depends_on = opstartvolgorde. Grafana start pas nadat Prometheus gestart is (want Grafana heeft Prometheus nodig als datasource).

Je hebt twee MySQL containers nodig maar ze conflicteren op dezelfde poort. Welke configuratie lost dit op?

Elke host-poort kan maar door één service gebruikt worden. Oplossing: verschillende host-poorten (3307, 3308), zelfde container-poort (3306).

Wanneer gebruik je build: ./app in plaats van image: naam in Docker Compose?

build: verwijst naar een map met een Dockerfile. Docker Compose bouwt dan automatisch de image bij `docker compose up` of `docker compose build`.

vragen correct

07 — ⏱ Monitoring & More

⏱ Monitor-stap in DevOps

Monitoring = prestaties en gezondheid van applicaties en systemen in real-time bewaken. Sluit de ♾ lus: bij fout/bug → terug naar Plan voor nieuwe code.

Doelen: vroege foutdetectie, minimale downtime, security, betere klantenervaring.

📊 Drie pijlers van Monitoring

Pijler	Wat?	Gebruik
📑 Logs	Chronologisch record van events met tijdstempel	Debugging, security auditing, incident response
📊 Metrics	Numerieke data: CPU, geheugen, response time	Real-time gezondheid, trends, KPIs
🚨 Alerts	Notificaties bij drempelwaarden of patronen	Snel reageren op problemen

📑 Python Logging Module

Level	Gebruik
`DEBUG`	Gedetailleerde info voor diagnose (niet in productie)
`INFO`	Bevestiging dat alles werkt zoals verwacht
`WARNING`	Potentieel probleem, geen fout maar let op
`ERROR`	Serieus probleem, functie niet uitgevoerd
`CRITICAL`	Programma kan mogelijk niet verder

PYTHON
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# File handler: logt DEBUG en hoger naar bestand
fh = logging.FileHandler('myapp.log')
fh.setLevel(logging.DEBUG)

# Console handler: enkel ERROR en hoger
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)

formatter = logging.Formatter(
  '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
logger.addHandler(fh)
logger.addHandler(ch)

📊 Metrics: Operationele voorbeelden

CPU Usage: % CPU-gebruik door de service
Memory Consumption: hoeveelheid geheugen in gebruik
Network I/O: data in/uit de service
Disk I/O: lees/schrijf-operaties op schijf
Container Health: status van draaiende containers

🔥 Prometheus

Open-source monitoring toolkit. Slaat metrics op als time series data (metriek + tijdstempel + labels).

Kenmerken:

Pull model: Prometheus haalt zelf metrics op bij targets via HTTP /metrics endpoint
PromQL: eigen query-taal voor data analyseren
Stand-alone opslag: eigen time series database
Configureerbaar via prometheus.yml

⚙ prometheus.yml Structuur

YAML
global:
  scrape_interval: 15s         # hoe vaak scrapen

scrape_configs:
  - job_name: 'prometheus'      # scrape zichzelf
    scrape_interval: 15s
    metrics_path: /prometheus/metrics
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'app'             # scrape de FastAPI app
    scrape_interval: 5s        # vaker, 5 seconden
    static_configs:
      - targets: ['app:8000']   # 'app' = service naam in compose!

Default metrics_path = /metrics. De naam app:8000 verwijst naar de Docker Compose service-naam.

📈 Stack: FastAPI + Prometheus + Grafana

FastAPI: app die /metrics endpoint exposeert via prometheus_fastapi_instrumentator
Prometheus: scrapet elke 5-15s de /metrics endpoints en bewaart de data
Grafana: verbindt met Prometheus als datasource, toont dashboards

# Docker Compose netwerk voorbeeld
networks:
  example-network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.16.238.0/24

Elk component krijgt een vast IP in hetzelfde subnet. Ze communiceren via service-namen.

📊 Grafana Dashboard Aanmaken (stappen)

Grafana → Data Sources → Add Prometheus
Create Dashboard → Add Panel
Kies een metric (bv. http_requests_total)
Pas labels toe (bv. status="500")
Stel filters in (tijdsbereik)
Pas chart type en titel aan → Save

🎯 KPIs & SLAs

KPIs (Key Performance Indicators): metrics die direct gekoppeld zijn aan klanteneisen. Voorbeelden voor een API:

Response Time: tijd om een request te verwerken
Error Rate: % requests met fout
Availability: % tijd dat de API bereikbaar is

SLA (Service Level Agreement): formeel contract met concrete service levels. Voorbeelden:

Response Time ≤ 300ms
Error Rate < 1% per maand
Availability ≥ 99.95% per maand

SLA niet gehaald? → remediation steps of financiële compensatie.

🚨 Alerts

Alerts worden getriggerd op basis van:

Metrics: bv. CPU > 90% voor 5 minuten
Logs: bv. ERROR-patroon gedetecteerd

Alert niveaus (vergelijkbaar met logging levels): Warning, Critical. Bij detectie → team verwittigd → snel actie.

🔨 Load Testing & Locust

Load testing: simuleren van echte gebruikers of zwaar verkeer om te testen hoe het systeem reageert onder stress.

Waarom nuttig: schaalbaarheid testen, bottlenecks ontdekken, storingen voorkomen bij hoog verkeer.

Wanneer: tijdens de Testing of Monitoring stap van de DevOps lifecycle, of voor grote updates/releases.

Locust: open-source load testing tool. Je schrijft Python-code die gebruikersgedrag simuleert.

🎯 QUIZ — Monitoring & More

Wat is het "pull model" van Prometheus?

Prometheus = pull model. Het scrapet actief de /metrics endpoint van applicaties op ingestelde intervallers (bv. elke 15s).

Welk Python logging level gebruik je voor berichten die enkel nuttig zijn tijdens debugging en niet in productie getoond worden?

DEBUG = laagste niveau. Gedetailleerde informatie voor diagnose. Typisch uitgeschakeld in productie maar actief tijdens ontwikkeling.

Wat is een SLA (Service Level Agreement)?

SLA = contract met meetbare doelstellingen (service levels). Niet gehaald? → compensatie of remediation. KPIs meten of de SLA gehaald wordt.

Waarom is de DevOps lifecycle een ∞ (oneindig) symbool?

Het ∞ symbool symboliseert de continue lus: na monitoring gaat het team terug naar Plan, nieuwe features/fixes worden gecodeerd, gebouwd, getest en gedeployed. Eindeloos verbeterend.

In de Prometheus+Grafana+FastAPI setup: welke rol speelt Grafana?

Grafana = visualisatietool. Verbindt met Prometheus (datasource), bevraagt data via PromQL en toont het in dashboards. Het bewaart zelf geen data.

vragen correct

Cloud &DevOps

📦 On-Premise → Cloud

🏢 Datacenter Evolutie

📊 Uptime Institute — Tier Systeem

🎩 Private Cloud

🌎 Public Cloud

🌐 Hybrid Cloud

⚖ Cloud vs On-Premise — Voordelen Cloud

📈 Scalability vs Elasticity

📶 HA & DR

🛡 Security: Confidentiality & Integrity

☁ Service Modellen

🔵 Azure — Sleutelconcepten

💰 Azure Factuurpunten

🎯 QUIZ — The Cloud

🤔 Waarom containers?

🆚 VM vs Container

🐧 Wat is een Kernel?

⚙ Processen & PID 1 in een Container

📦 Structuur van een Container

📅 Geschiedenis van Containers

🍪 Docker: Images vs Containers

🏔 Alpine Linux

🐧 Debian Linux

🖥 Docker Commando's

🚪 Poorten: Houses & Doors

📁 Volumes & Bind Mounts

⚡ Redis

🎯 QUIZ — Containers

📸 Methode 1: Instance Promotion (commit)

📄 Methode 2: Dockerfile (aanbevolen)

📖 Dockerfile Instructies

🌐 Volledig voorbeeld: NodeJS app

🧅 Image Layers & Caching

🚀 Push naar Docker Hub

🎯 QUIZ — Crafting a Container

♾ Wat is DevOps?

⚙ GitHub Actions — Hoe werkt het?

📋 Workflow.yml Structuur

🔑 Workflow Sleutelwoorden

🔐 GitHub Secrets

📈 CI / CD / CD — Wat is het verschil?

🔍 SonarCloud — Code Kwaliteit

🏗 Volledige CI/CD Workflow (website voorbeeld)

🎯 QUIZ — DevOps & Pipelines

🌍 Drie Taaltypen

📝 Interpreted (Python)

🗜 Compiled (C/C++)

☕ Java: De Hybride Aanpak

🔨 Maven voor Java

📦 Maven Commando's

🧪 Unit Tests

🐍 pytest — Python Testing

🏷 GitHub Tags & Releases

🐳 Java in CI/CD Pipeline (GitHub Actions)

📦 GitHub Artifacts

🎯 QUIZ — Building Code

🛳 Operate-stap in DevOps

✅ Waarom IaC? Voordelen

🐳 Docker Compose = IaC

⚙ Docker Compose Commando's

🔗 Containers verbinden + Netwerken

📋 Compose YAML Structuur

🎯 QUIZ — IaC & Docker Compose

⏱ Monitor-stap in DevOps

📊 Drie pijlers van Monitoring

📑 Python Logging Module

📊 Metrics: Operationele voorbeelden

🔥 Prometheus

⚙ prometheus.yml Structuur

📈 Stack: FastAPI + Prometheus + Grafana

📊 Grafana Dashboard Aanmaken (stappen)

🎯 KPIs & SLAs

🚨 Alerts

🔨 Load Testing & Locust

🎯 QUIZ — Monitoring & More

Cloud &
DevOps