---
title: "Talos Linux: wat een onveranderlijk OS anders maakt | A-Line"
description: "Wat Talos Linux is, hoe het verschilt van Ubuntu, Flatcar en Bottlerocket, hoe upgrades en debuggen werken zonder SSH, en wat je nakijkt voor je overstapt."
canonical: https://a-line.be/nl/guides/talos-linux-immutable-os-kubernetes/
lang: nl-BE
---

> Index of every page on this site: https://a-line.be/llms.txt

# Talos Linux: wat een onveranderlijk OS anders maakt

Door [Arthur De Witte](https://a-line.be/nl/authors/arthur-de-witte/) — Gepubliceerd 26 maart 2026 — Bijgewerkt 30 oktober 2026 — 10 min lezen

De meeste teams patchen hun Kubernetes-control plane op schema en scannen elk container-image dat ze uitrollen. Het besturingssysteem onder de nodes krijgt minder aandacht: een standaard Ubuntu-installatie, SSH open voor de dag dat er iets stukgaat, en een configuratietool die af en toe draait. Op dat OS belandt een aanvaller die uit een container ontsnapt, en daar stapelen kleine handmatige fixes zich op tot geen twee nodes nog helemaal gelijk zijn. Deze gids gaat over Talos Linux, een OS dat gemaakt is om Kubernetes te draaien en niets anders, en over wat er verandert als je het gebruikt.

Kort gezegd

Talos Linux is een minimaal, alleen-lezen OS dat enkel Kubernetes draait. Het heeft geen shell, geen SSH en geen pakketbeheerder. Je beheert elke node via een API, met een tool die `talosctl` heet, en je beschrijft de hele node in één configuratiebestand.

Dat haalt het meeste weg van wat er misloopt op gewone nodes: verschillen tussen machines, tools die een aanvaller kan gebruiken, en upgrades die halverwege stilvallen. Daar staat een andere manier van debuggen tegenover, en sommige agents die een gewone Linux-host verwachten, moeten aangepast worden. Plan beide in voor je een cluster verhuist.

## Wat “onveranderlijk” betekent voor een node

Op een gewone distributie starten alle nodes identiek en groeien ze daarna uit elkaar. Iemand installeert tijdens een incident een debugtool en haalt die nooit meer weg. Een configuratierun faalt halverwege op één machine. Een kernelinstelling wordt met de hand aangepast om een theorie te testen. Na een jaar gedragen de nodes in één pool zich net iets anders, en niemand kan precies zeggen hoe.

Een onveranderlijk OS voorkomt dat door het systeem zelf alleen-lezen te maken. Je past geen draaiende node aan; je past de beschrijving aan en rolt een nieuwe uit. Hoe ver dat gaat, verschilt per OS:

- **Flatcar Container Linux** houdt `/usr` alleen-lezen, maar de rest van het systeem is beschrijfbaar en SSH werkt zoals altijd.
- **Bottlerocket** maakt het hele root-bestandssysteem alleen-lezen en zet SSH standaard uit. Om te debuggen start je een aparte admin-container.
- **Talos Linux** draait volledig vanaf een gecomprimeerd, alleen-lezen image. De paar bestanden onder `/etc` die Kubernetes nodig heeft, worden gegenereerd uit de machineconfiguratie, en extra drivers of tools komen als system extensions mee wanneer het image gebouwd wordt, niet achteraf.

## Wat een gewoon OS allemaal meebrengt

Een Kubernetes-node heeft een kernel nodig, een container-runtime, de kubelet en wat netwerk. Een standaard serverinstallatie levert veel meer: shells, compilers, mailtools, runtimes voor programmeertalen. Elk pakket dat je niet gebruikt, krijgt toch beveiligingsmeldingen, en elke melding moet gelezen, beoordeeld en gepatcht worden.

De kernel zelf heeft het al druk genoeg. In 2025 kreeg hij 5.530 CVE’s, 28% meer dan het jaar ervoor ([CIQ](https://ciq.com/blog/linux-kernel-cves-2025-what-security-leaders-need-to-know-to-prepare-for-2026/)). Talos draait ook een Linux-kernel, dus een kleiner OS laat die niet verdwijnen. Wat het wel verandert, is de rest van de lijst, en hoeveel werk het is om een gepatchte kernel op elke node te krijgen.

De NIST-gids over containerbeveiliging raadt precies dat aan: draai containers op een OS dat ervoor gemaakt is, omdat een kleiner OS minder biedt om aan te vallen ([NIST SP 800-190](https://csrc.nist.gov/publications/detail/sp/800-190/final)).

## Hoe Talos werkt

Talos vervangt het grootste deel van een gewone Linux-userland door één programma. `machined` start als eerste proces en draait al de rest: de container-runtime, de kubelet en een handvol systeemdiensten. Er is geen systemd, geen bash en geen coreutils.

**Je praat met een node via een API.** Elke node biedt een gRPC-API aan, beveiligd met wederzijdse TLS, en `talosctl` is de client. Wat je elders over SSH doet, is hier een commando:

```bash
talosctl --nodes 10.0.0.5 logs kubelet     # de logs van een dienst
talosctl --nodes 10.0.0.5 dmesg            # kernelmeldingen
talosctl --nodes 10.0.0.5 pcap --interface eth0   # verkeer opvangen
talosctl --nodes 10.0.0.5 dashboard        # live overzicht van de node
```

**De node is een configuratiebestand.** Eén YAML-document beschrijft de machine: zijn rol, netwerk, schijven en de Kubernetes-versie die hij draait. Een worker kan er zo uitzien:

```yaml
version: v1alpha1
machine:
  type: worker
  network:
    hostname: worker-01
    interfaces:
      - interface: eth0
        dhcp: true
  kubelet:
    image: ghcr.io/siderolabs/kubelet:v1.34.0
cluster:
  controlPlane:
    endpoint: https://10.0.0.10:6443
```

Het echte bestand is langer. `talosctl gen config` genereert het, samen met de certificaten en tokens die de node nodig heeft om bij de cluster te komen. Bewaar het in versiebeheer zoals elke andere configuratie, met de geheimen versleuteld.

Het resultaat is een heel klein systeem. Sidero Labs, het bedrijf achter Talos, telde de programma’s die een standaardinstallatie op een node zet:

Programma's op een standaardinstallatie, per OS

Ruwe aantallen, minder betekent minder voor een aanvaller om te gebruiken. Geteld door [Sidero Labs](https://www.siderolabs.com/blog/talos-linux-vs-flatcar/)

| OS           | Programma's (ongeveer) |
| ------------ | ---------------------- |
| Ubuntu       | 3.000+                 |
| Flatcar      | 2.300+                 |
| Bottlerocket | \~200                  |
| Talos Linux  | 12                     |

## Wat een aanvaller vindt op een Talos-node

Stel dat iemand uit een container ontsnapt en op de host belandt. Op een gewone node vindt die een shell, `curl`, een pakketbeheerder en vaak een SSH-sleutel die de volgende machine opent. Op Talos is er geen shell om te starten en bijna niets om uit te voeren. Het OS kan niet aangepast worden, en een herstart via de API brengt de node terug vanaf zijn image.

Dat maakt een node niet onbreekbaar. Een kernel-exploit blijft een kernel-exploit, en data onder `/var`, zoals container-images en pod-volumes, overleeft een herstart. Maar de meeste stappen na een inbraak hangen af van tools en beschrijfbare plekken die Talos niet heeft.

| Wat een aanvaller probeert                  | Gewone distributie                                  | Talos Linux                                           |
| ------------------------------------------- | --------------------------------------------------- | ----------------------------------------------------- |
| Via SSH naar andere nodes gaan              | Werkt als er een sleutel of wachtwoord te vinden is | Geen SSH-server op de node                            |
| Tools gebruiken die al op de node staan     | Duizenden programma’s om uit te kiezen              | 12 programma’s en geen shell                          |
| Iets achterlaten dat een herstart overleeft | Systeemmappen zijn beschrijfbaar                    | Het OS is alleen-lezen en komt terug vanaf zijn image |
| De configuratie met de hand aanpassen       | Blijft tot iemand het merkt                         | Kan alleen via de API, vanuit het configuratiebestand |
| Een lokale gebruiker toevoegen              | `/etc/passwd` aanpassen                             | Er zijn geen gebruikersaccounts                       |

## Talos, Bottlerocket of Flatcar

Alle drie zijn gemaakt voor containers. Ze verschillen in hoe streng ze zijn, en dat bepaalt waar elk past.

| OS           | Wat alleen-lezen is      | Toegang tot een shell                           | Draait                              | Past het best bij                                  |
| ------------ | ------------------------ | ----------------------------------------------- | ----------------------------------- | -------------------------------------------------- |
| Talos Linux  | Het hele OS              | Geen, alleen de API                             | Alleen Kubernetes                   | Clusters op bare metal, in de cloud of aan de edge |
| Bottlerocket | Het root-bestandssysteem | Standaard uit, admin-container als het nodig is | Containers, gemaakt voor EKS en ECS | Clusters op AWS                                    |
| Flatcar      | `/usr`                   | SSH zoals altijd                                | Elke containerworkload              | Stap voor stap weg van een gewone distributie      |

Wil je de strengste opzet en draai je toch al Kubernetes, dan gaat Talos het verst. Zit je op AWS en wil je de tools van de provider, dan past Bottlerocket beter. Leunt je team nog op SSH en verander je liever één ding tegelijk, dan is Flatcar de zachtere start.

## Upgrades die niet halverwege kunnen stoppen

Op een gewone distributie verandert een upgrade pakketten één voor één op een draaiend systeem. Faalt die halverwege, dan heb je een node die noch de oude versie is, noch de nieuwe.

Talos upgradet het hele OS-image in één keer:

```bash
talosctl upgrade --nodes 10.0.0.5 \
  --image ghcr.io/siderolabs/installer:v1.12.6
talosctl version --nodes 10.0.0.5
```

Talos zet de node op cordon, maakt hem leeg, schrijft het nieuwe image naast het image waar hij van draait, en herstart erin. Start de nieuwe versie niet op, dan start de node de vorige opnieuw. Hoe dan ook draait de node een volledige, gekende versie. Flatcar en Bottlerocket gebruiken hetzelfde idee met twee slots; Talos voegt toe dat het hele OS, configuratie inbegrepen, uit dat ene image komt.

Druk op een knop om worker-01 te upgraden van v1.12.5 naar v1.12.6, of om te zien wat er gebeurt als de nieuwe versie niet opstart.

Kubernetes zelf upgrade je apart, met `talosctl upgrade-k8s --to 1.34.1`, dat de control plane en de kubelets één voor één bijwerkt. Upgrade eerst één node, kijk hem na, en doe dan de rest. Een node leegmaken loopt alleen goed af als je apps het verlies van een pod overleven; de [gids over een Discord-bot online houden](https://a-line.be/nl/guides/highly-available-discord-bots/) toont één manier om daarvoor te bouwen.

## Wie het in productie draait

**PostFinance**, een van de grootste banken van Zwitserland, verhuisde 35 Kubernetes-clusters in een afgeschermde omgeving zonder internettoegang van kubeadm en Ansible naar Cluster API en Talos, zonder downtime ([Camptocamp](https://camptocamp.com/en/news-events/talos-linux)). Een deel van de tools die ze ervoor bouwden, publiceerden ze als [TOPF](https://github.com/postfinance/topf), een orchestrator voor Talos.

**JYSK**, de winkelketen, draait Talos in meer dan 3.400 winkels in 48 landen. De node in elke winkel wordt gebouwd vanaf hetzelfde image en krijgt zijn configuratie bij de eerste start ([Sidero Labs](https://www.siderolabs.com/case-studies/supporting-jysks-digital-transformation-with-3400-strong-edge-deployment/)).

Beide gevallen hebben dezelfde nood: veel machines die identiek moeten blijven, met weinig mensen die erop kunnen inloggen.

## Wat je opgeeft

**Tools op de host.** Er staat geen `tcpdump`, `strace` of `htop` op de node. `talosctl pcap`, `logs` en `dashboard` dekken de meeste noden. Voor de rest start `kubectl debug node/worker-01` een pod met je eigen tools op die node. Kan een node de API-server niet bereiken, dan is een [traceroute](https://a-line.be/nl/guides/how-traceroute-works/) vanuit zo’n pod vaak de snelste eerste blik.

**Agents die een gewone host verwachten.** DaemonSets die host-paden zoals `/var/log/journal` mounten, of zelf kernelmodules laden, kunnen falen. De meeste monitoring- en beveiligingsagents hebben een opzet voor Talos, maar kijk ze elk na.

**Gewoontes.** “Even inloggen en kijken” werkt niet meer, voor niemand. Runbooks moeten herschreven worden, en de eerste incidenten duren langer terwijl het team `talosctl` leert.

**Een kleinere community.** Het project is actief ([GitHub](https://github.com/siderolabs/talos)), maar er zijn veel minder forumantwoorden en blogposts dan voor Ubuntu. Reken erop dat je meer in de documentatie leest.

**Alleen Kubernetes.** Moet een machine ook iets buiten Kubernetes draaien, dan is Talos er het verkeerde OS voor.

## Voor je een cluster verhuist

1. **Lijst je DaemonSets op** en zoek naar mounts van host-paden, geprivilegieerde containers en alles wat systemd of journald verwacht.
2. **Kijk je monitoring- en logging-agents na** op ondersteuning voor Talos. Containerlogs staan in `/var/log/pods`; de logs van Talos’ eigen diensten kun je elders naartoe sturen met `machine.logging` in de configuratie.
3. **Lijst de kernelmodules op die je laadt** met `lsmod` op een huidige node. Wat niet in het standaardimage zit, komt als system extension, toegevoegd wanneer je het image bouwt.
4. **Herschrijf je runbooks** zodat elke stap die SSH gebruikte een tegenhanger heeft met `talosctl` of `kubectl debug`.
5. **Plan de verhuis naast elkaar.** Bouw een Talos-cluster naast de huidige en verhuis workloads één voor één, zodat teruggaan neerkomt op ze terugzetten.

## Test hoe je leest

Drie situaties uit een Talos-cluster. Beslis zelf of elk ervan een echt probleem toont, en open dan het antwoord.

### SSH wordt geweigerd

```
$ ssh admin@worker-03
ssh: connect to host worker-03 port 22: Connection refused
```

**Is dit een echt probleem?**

**Nee.** Talos heeft geen SSH-server, dus zo antwoordt elke gezonde node.

Er is niets stuk; er luistert gewoon niets op poort 22. Vraag het aan de node via zijn API, bijvoorbeeld met `talosctl –nodes worker-03 logs kubelet` of `talosctl –nodes worker-03 dashboard`.

### De upgrade die niet bleef

```
node       worker-07
gevraagd   v1.12.6
draait     v1.12.5
status     Ready
uptime     4 minuten
```

**Is dit een echt probleem?**

**Ja.** De node herstartte maar draait de oude versie: de nieuwe startte niet op, en Talos viel terug.

De node is gezond en werkt, en dat is de terugval die zijn werk doet. Maar de upgrade is mislukt, en hij zal ook op de andere nodes mislukken. Lees `talosctl –nodes worker-07 dmesg` om te zien waarom de nieuwe versie niet startte; een ontbrekende system extension of een verkeerd kernelargument zijn vaak de oorzaak. Los dat op voor je nog iets upgradet.

### De log-shipper die niet start

```
daemonset  log-shipper
pods       0 van 6 klaar
status     CrashLoopBackOff
laatste    open /var/log/journal: no such file or directory
```

**Is dit een echt probleem?**

**Ja.** De agent verwacht journald, en Talos heeft dat niet.

Dit is een van de agents die je in de checklist hierboven vindt. Laat hem `/var/log/pods` lezen voor containerlogs, en laat Talos de logs van zijn eigen diensten naar je logsysteem sturen met `machine.logging` in de machineconfiguratie.

## Dit op A-Line.cloud

Alles hierboven kun je zelf doen, en voor een team dat zijn nodes zelf wil beheren, is het de moeite om te leren. Wil je het platform eronder liever niet zelf beheren, dan doet A-Line.cloud het voor je op Talos:

- **Je eigen Talos-cluster.** Geen enkele andere klant draait workloads in het cluster. Opslag en builds zijn gedeelde platformdiensten, en nodes zijn standaard shared-vCPU.
- **Geen nodes om te beheren.** Jij zet apps live; de nodes eronder zijn onze zorg.
- **Rolling deploys** die pas verdergaan als de nieuwe versie klaar is, en terugrollen als een deploy mislukt.
- **Builds vanuit GitHub** en certificaten die voor je geregeld worden, zonder Kubernetes-YAML om te schrijven.

A-Line.cloud werkt voorlopig op uitnodiging. Draai je apps op Kubernetes en zorg je liever niet zelf voor de nodes, [vraag dan toegang aan](https://a-line.be/nl/request-access/) en vertel ons wat je vandaag draait.

## Veelgestelde vragen

### Is Talos Linux gratis?

Ja. Talos is open source onder de Mozilla Public License 2.0. Sidero Labs, het bedrijf erachter, verkoopt Omni, een dienst om Talos-clusters te beheren, en ondersteuning. Je hebt geen van beide nodig om Talos te draaien.

### Kan ik via SSH op een Talos-node?

Nee. Talos heeft geen SSH-server en geen shell. Alles gaat via de API met `talosctl`, en om met de hand te debuggen start je een pod op de node met `kubectl debug`.

### Wat gebeurt er als een node crasht?

Hij herstart vanaf hetzelfde image met dezelfde configuratie en komt terug in de cluster. Het OS komt precies terug zoals het was; data onder `/var`, zoals container-images en volumes, blijft.

### Hoe verhuis ik een bestaande cluster naar Talos?

De meeste teams bouwen een nieuwe Talos-cluster naast de huidige en verhuizen workloads, één app tegelijk. Grotere opzetten, zoals die van PostFinance, gebruiken Cluster API om machines geleidelijk te vervangen.

## Waar je begint

Zet één Talos-worker in een testcluster en draai je DaemonSets erop. DaemonSets die een gewone host verwachten, zijn het gebruikelijke struikelblok. Wat op die ene node breekt, is je verhuislijst.
