## 👻 De onzichtbare helpers van Linux: Daemons en Units {#sec-6e36ad82c8cb}

Als je een [[Linux]] systeem beheert, merk je dat talloze 'daemons' op de achtergrond draaien. We beheren ze met een tool genaamd `systemd`. Wat is de relatie tussen deze twee, en waarom hebben ze zulke unieke namen? Net zoals er filosofie schuilt achter een enkele coderegel, zit er een duidelijke ontwerpintentie achter de structuur van een Linux-systeem.

![linux_daemon_and_systemd_concept](/media/editor_temp/6/a66caf8f-e91b-4373-af97-e3f7158d0194.png "Afbeelding van systemd dat instructies geeft aan verschillende daemons")

## 1. Waarom 'Daemon'? : De slimme, onzichtbare entiteit {#sec-facc962b0b1c}
De naam 'daemon' komt oorspronkelijk van de **'Daemons'** uit de Griekse mythologie, beschermgeesten die onzichtbaar hulp boden tussen goden en mensen. Na de hypothese van 'Maxwell's Demon', voorgesteld door natuurkundige Maxwell, gaven MIT-ontwikkelaars in 1963 deze naam aan **"programma's die zelfstandig op de achtergrond werken zonder tussenkomst van de gebruiker."**

*   **Essentie:** Een daemon communiceert niet direct met de gebruiker. Het is een **'achtergrondproces'** dat in het geheugen blijft draaien, zelfs nadat de terminal is afgesloten, wachtend op netwerkverzoeken of het monitoren van de systeemstatus.

## 2. Is systemd ook een daemon? : "De master daemon die daemons beheert" {#sec-37340e1c3330}
Ja, dat klopt. De **'d'** aan het einde van de naam is het bewijs. `systemd` is het **eerste proces (PID 1)** dat wordt uitgevoerd nadat de [[Linux]]-kernel is opgestart, en het is de **'master daemon'** die alle andere daemons aanstuurt en beheert.

Voorheen was de manier waarop [[Linux]] daemons beheerde nogal chaotisch. `systemd` verscheen om deze verwarring weg te nemen en alle systeemcomponenten volgens een **gestandaardiseerd formaat** te beheren. Dit gestandaardiseerde formaat is de **'Unit'**.

## 3. Unit: De 'standaard werkinstructie' die daemons aanstuurt {#sec-c8112a55b96d}
Als een daemon de 'entiteit' is die het eigenlijke werk uitvoert, dan is een **unit de 'werkinstructie' die beschrijft hoe die entiteit moet worden beheerd.** De master daemon `systemd` leest deze instructie (Unit) die we hebben opgesteld en activeert of deactiveert elke daemon volgens de inhoud.

*   **Duidelijkheid van intentie:** Zonder het unit-formaat zou elke ontwikkelaar de code voor het uitvoeren van daemons anders hebben geschreven. Dankzij de standaard instructie (Unit, bijvoorbeeld een `.service`-bestand) kunnen we echter **"in welke omgeving, in welke volgorde, en hoe te herstarten bij problemen"** zeer nauwkeurig en robuust definiëren.
*   **Flexibele schaalbaarheid:** Units zijn niet alleen voor daemons (Services). Ze behandelen alle elementen van Linux, zoals 'timers' die taken op specifieke tijden uitvoeren, en 'mounts' voor het koppelen van apparaten, in hetzelfde 'werkinstructie'-formaat. Hierdoor kan het hele systeem met een consistente logica worden uitgebreid.



## 4. De relatie in één oogopslag {#sec-ea68ba1a28f7}

| Categorie | Daemon | systemd Unit |
| :--- | :--- | :--- |
| **Identiteit** | Een **proces** dat daadwerkelijk in het geheugen draait | Een **specificatiebestand** met systeeminstellingen |
| **Rol** | Voert daadwerkelijke functies uit op de achtergrond | Definieert de uitvoeringsvoorwaarden en het gedrag van een daemon |
| **Analogie** | Een **werker** die stil op de achtergrond werkt | De **werkinstructie** die de werker volgt |

> **Samenvattend:**   
> De master daemon `systemd` leest de **Unit (werkinstructie)** en stuurt talloze **daemons (werkers)** aan, zodat ze precies volgens de vastgestelde regels functioneren. 


## 5. De identiteit van de werker varieert: Correct onderscheid maken tussen 'Daemon' en 'Service Unit' {#sec-40ea0fcb27a7}

Wanneer we spreken over het 'starten van een service', is de vorm van de werker (daemon) die daadwerkelijk op de achtergrond draait niet eenduidig. Elk programma dat op de achtergrond draait, ongeacht de programmeertaal of vorm, kan een daemon zijn.  

**Verschillende vormen van werkers:**

- Script Daemon: Als je zelfgeschreven Python-code, zoals die voor Django of FastAPI, als unit registreert, wordt het een Python-daemon die via de `python3`-interpreter draait.

- Binaire Daemon: Programma's zoals Nginx en sshd, die vooraf zijn gecompileerd in talen als C of Go, zijn daemons in de vorm van uitvoerbare bestanden.

- Shell Script Daemon: Zelfs een eenvoudig `.sh`-bestand dat in een oneindige lus op de achtergrond draait, kan een uitstekende werker (daemon) zijn.

**Een service unit is de 'verbinding':**

Strikt genomen zijn `sshd` of je Python-script zelf geen 'service'. Het zijn slechts daemons (werkers). Het `.service`-bestand (unit) dat we zelf aanmaken in de `/etc/systemd/system/`-directory, of dat automatisch wordt geregistreerd wanneer een pakket wordt geïnstalleerd, is de werkinstructie die die werker registreert als een officieel onderdeel van het systeem.  

## Conclusie {#sec-5483fdb76f6}

Een daemon verwijst naar de status van een 'programma dat op de achtergrond werkt', en een service unit is de gestandaardiseerde specificatie die de master `systemd` in staat stelt die daemon te beheren. Dankzij deze instructie kan `systemd` op dezelfde manier commando's geven, ongeacht of de werker een Python-script of een binair bestand is.

Wat vind je ervan? Ik gebruik [[Linux]] nu zo'n 4 tot 5 jaar als mijn primaire systeem, en hoewel ik dacht dat ik de concepten van deze twee begreep, vond ik het heel moeilijk om ze aan iemand anders uit te leggen. Ik denk dat ik dacht dat ik het wist, maar het eigenlijk nog niet volledig had begrepen. Nu ik eindelijk mijn eigen definities heb geformuleerd en de zaken op een rijtje heb gezet, voelt mijn hoofd helder aan. Schrijven is toch leuk. Zelfs als het tijd kost, helpt het me om mijn gedachten te ordenen.