Talos setup

Omdat jullie net een volledig werkende Docker compose setup maakten, is de stap naar een staging-omgeving niet zo groot meer. Wel maken we meteen een sprong naar Kubernetes, een platform om containers te hosten. Daarvoor is wat voorbereiding nodig van jullie kant. We geven jullie hieronder een volledige tutorial van hoe je dat moet opzetten.

Bij de start van deze opgave heb je normaalgezien een Talos-machine gedeployed. Dat is een Linux-distro die speciaal gebouwd werd voor Kubernetes. We zullen deze cluster zo eenvoudig mogelijk opzetten en gebruik maken van 1 enkele node. De cluster zal zowel voor de staging- als voor de productie-omgeving gebruikt worden.

Wel heeft die nog configuratie nodig om te starten. Een webinterface heeft die distro niet, maar een API wel, en die kan met het commando talosctl gebruikt worden. De status van de vm kan je wel opvolgen door het scherm over te nemen. Daar kan je steeds zien of de cluster actief is etc.

Basisconfig van Talos

We configureren Talos vanop de control-host. Je vindt talosctl niet als package in de standaard repositories. Daarom moet je de binary zelf downloaden op je control-host:

sudo curl -sL -o /usr/local/bin/talosctl https://github.com/siderolabs/talos/releases/latest/download/talosctl-linux-amd64

sudo chmod +x /usr/local/bin/talosctl

talosctl version --client

Eens dat gebeurd is, kunnen we de vm zelf ook gaan configureren. Dat kan met enkele simpele commando's, maar omdat de volgorde belangrijk is, leveren we jullie onderstaand bash-script aan. Dat omvat wat controle-logica om fouten te vermijden, maar is in de basis een wrap rond drie stappen: een talosctl gen config om lokale configbestanden te maken, een talosctl apply-config om die toe te passen en dan een talosctl bootstrap om de cluster te starten.

Pas uiteraard het NODE_IP aan naar je eigen IP-adres. Cluster-name kan je kiezen.

#!/bin/bash

NODE_IP="10.129.80.4"
CLUSTER_NAME="ProjectDockerCluster"
export TALOSCONFIG="./talosconfig"

# Stap 1: configuratiebestanden genereren
talosctl gen config "$CLUSTER_NAME" "https://${NODE_IP}:6443" \
  --config-patch-control-plane 'cluster: { allowSchedulingOnControlPlanes: true }' \
  --force

# Stap 2: config naar de node sturen (node moet in Maintenance mode staan)
talosctl apply-config --insecure --nodes "$NODE_IP" --endpoints "$NODE_IP" --file controlplane.yaml

# Stap 3: wachten tot de node opnieuw is opgestart en dan bootstrappen
echo "Wachten tot de configuratie is toegepast (120 seconden)..."
sleep 120
talosctl bootstrap --nodes "$NODE_IP" --endpoints "$NODE_IP"

Na het uitvoeren van dit bash-script is de Talos-server klaar om te fungeren als single-host Kubernetes cluster. Als we Kubernetes later willen gaan configureren met kubectl, dan moet ook daarvoor de configuratie gedownload worden. Dat doe je met:

talosctl kubeconfig . --nodes NODE_IP --endpoints NODE_IP --talosconfig ./talosconfig
# kopieren van de config-file naar een standaard directory zodat de locatie van de configfile niet telkens moet meegegeven worden met elk commando:

# Maak de standaard map aan voor de kubeconfig-file
mkdir -p ~/.kube

# Kopieer je nieuwe kubeconfig naar de standaardlocatie
cp ./kubeconfig ~/.kube/config

Het resultaat is dus een config-file (met secrets in!) die lokaal in ~/.kube/config terecht komt. Je kan eventueel die file kopieren naar je lokale pc om bijvoorbeeld zelf ook kubectl te kunnen uitvoeren of om een GUI te gebruiken om de status van de server op te volgen. Een suggestie daarbij is om Freelens te gebruiken, een open source tool. Als je daar de kube config in importeert kan je navigeren door de cluster.

Ter controle zou je in de werkmap dus enkele bestanden moeten ziet staan, waaronder de kubeconfig-file:

[student@Control-host-iactest opgavedocker]$ ls
configcluster.sh  controlplane.yaml  kubeconfig  talosconfig  worker.yaml

Nu staat de cluster helemaal klaar voor gebruik.

Laten we alvast ook de tools klaarzetten om later kubernetes te gaan beheren van deze machine:

De repo toevoegen:

# This overwrites any existing configuration in /etc/yum.repos.d/kubernetes.repo
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.36/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.36/rpm/repodata/repomd.xml.key
EOF

installatie:

sudo yum install -y kubectl

Ook in de tools installeren we al enkele tools. De belangrijkste is de gateway, maar je krijgt ook een baseline van ons cadeau. In dat tweede commando worden eigenlijk alle componenten klaargezet om meteen een werkende applicatie online te kunnen zetten. Bekijk gerust eens de objecten die je daarin vindt.

daarvoor moeten enkele commando's uitgevoerd worden:

# installeer de gateway-component op de cluster
kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.5.1/standard-install.yaml

# deploy een voorbeeldopstelling die je later kan uitbreiden.
kubectl apply -f https://gitlab.com/ikdoeict/public/k8s/-/raw/main/examples/single-node-talos/demo-singlenode.yaml?ref_type=heads

Om de cluster helemaal klaar te maken, moeten we er ook voor zorgen dat die contact kan leggen met je Gitlab registry om daar de containers te downloaden. Maak daarvoor een token in Gitlab. Je kan dat limiteren in scope en ook een vervaldatum geven. Doe dat ook voor je veiligheid.

Voer daarna onderstaand commando uit:

for ns in production staging; do
  kubectl create secret docker-registry gitlab-registry \
    --docker-server=registry.gitlab.com \
    --docker-username=<GITLABUSERNAME> \
    --docker-password=<GITLABTOKEN> \
    --docker-email=<EMAILADRES> \
    --namespace=$ns
done

Testen van de Talos server

Je wil natuurlijk weten waarvoor al het bovenstaande dient. Met de commando's maken we een configuratie klaar waar je straks je containers kan gaan deployen. De details van hoe Kubernetes werkt zien we ook nog in andere vakken, maar met deze configuratie staat eigenlijk bijna alles klaar.

Testen kan door even te surfen naar een voorbeeldapplicatie op die server.

http://[IPvandeTalosServer]:8000/demo

Daar staat - als alles goed ging- een nginx testpagina klaar:

Jullie zullen later in dit project ook kunnen deployen naar andere paden zoals /api .

Extra:

Niet noodzakelijk voor deze opgave, maar wel interessant is dat je ook in details de load van applicaties kan opvolgen in Kubernetes. Maar niks gaat vanzelf in Kubernetes, dus als die wil activeren, is ook daarvoor... een container nodig (metrics-server).

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

# patch nodig specifiek voor Talos
kubectl patch deployment metrics-server -n kube-system \
  --type='json' \
  -p='[{"op":"add","path":"/spec/template/spec/containers/0/args/-","value":"--kubelet-insecure-tls"}]'

Testen van de metrics-server

voer kubectl top nodes uit, daar zou je moeten de huidige load kunnen zien op de cluster nodes. In Freelens krijg je echter nog steeds geen mooie grafieken te zien. Wil je die ook, dan is Prometheus nodig om time series te bewaren. Dat kan je installeren (.. nog extra containers dus), maar deze is wel relatief resource-intensief. Als je enkel actuele waardes wil zien is die niet nodig.

Enkele voorbeelden:

[student@Control-host-iactest kubernetes]$ kubectl top nodes
NAME                CPU(cores)   CPU(%)   MEMORY(bytes)   MEMORY(%)   
k8s-talos-iactest   750m         18%      1738Mi          54% 

[student@Control-host-iactest kubernetes]$ kubectl top pod -n production
NAME                           CPU(cores)   MEMORY(bytes)   
backend-api-bcd76c69f-cb5ng    2m           48Mi            
frontend-vue-586ff9659-27rvf   1m           4Mi