Wat is een daemon in de informatica?

De term daemon komt uit de oude Griekse mythologie en verwees naar een immaterieel wezen dat invloed had op de menselijke wereld.

In de informatica, vooral in UNIX-achtige besturingssystemen, is een daemon een achtergrondproces dat draait zonder directe interactie van de gebruiker. Het is niet afhankelijk van een terminal of gebruikersinterface en wordt meestal gestart bij het opstarten van het systeem of onder bepaalde voorwaarden.

Wat is een daemon

De hoofdtaak van een daemon is het leveren van specifieke diensten aan andere processen of gebruikers. Een daemon kan bijvoorbeeld luisteren op netwerkpoorten en wachten op verbindingen, systeemgebeurtenissen monitoren en reageren wanneer aan bepaalde voorwaarden wordt voldaan, geplande taken beheren (zoals cron), e-mails verzenden (sendmail) en nog veel meer.

In Windows is de dichtstbijzijnde tegenhanger van een daemon een service. Het verschil ligt voornamelijk in hoe ze worden gestart, geregistreerd, beheerd en geconfigureerd binnen het besturingssysteem. Hun doel is echter hetzelfde: zorgen voor een continue werking van bepaalde functies of diensten op de achtergrond.

Belangrijkste kenmerken van een daemon

• Draait op de achtergrond: gebruikers zien meestal geen interface van de daemon; hij schrijft niet naar de standaarduitvoer (of leidt die om naar logbestanden) en vraagt geen toetsenbordinvoer.

• Autonoom: een daemon wordt gestart bij het opstarten van het systeem, wanneer hij wordt geactiveerd door een init-systeem (zoals systemd), of handmatig door de gebruiker (via scripts, cron, enz.).

• Langdurig actief: idealiter blijft een daemon onbeperkt draaien, tenzij zich een kritieke fout voordoet of een expliciet stopsignaal wordt ontvangen.

• Geïsoleerd: draait meestal onder een apart gebruikers- of groepsaccount met beperkte rechten, wat diensten veiliger en eenvoudiger te beheren maakt.

• Logging: in plaats van standaardinvoer/-uitvoer te gebruiken, schrijft de daemon informatie naar logbestanden of naar de systeemlogger (journald, syslog, enz.), wat nuttig is voor debugging en diagnose.

Daemons in Linux

Historisch gezien worden bijna alle systeemachtergrondtaken in Linux geïmplementeerd als daemons. Het besturingssysteem bevat er tientallen, elk verantwoordelijk voor een specifieke functie. Enkele voorbeelden:

• sshd (Secure Shell Daemon): luistert standaard op poort 22 en maakt het mogelijk voor externe gebruikers om verbinding te maken via versleutelde SSH. Zonder sshd is externe terminaltoegang vrijwel onmogelijk.

• cron: een taakplanner-daemon. Controleert crontab-vermeldingen en voert scripts of opdrachten uit volgens een schema, zoals logopschoning, rapportverzending of systeemcontroles.

• syslogd / rsyslog / journald: systeemlog-daemons die berichten verzamelen van de kernel, hulpprogramma’s, andere daemons en toepassingen, en deze opslaan in logbestanden of het journal.

• NetworkManager of Wicd: daemons die netwerkconfiguraties beheren — ze automatiseren verbindingen met bekabelde/draadloze netwerken, schakelen tussen netwerken, configureren VPN’s en meer.

Deze daemons worden gestart bij het opstarten van het systeem en geregistreerd bij de systeemservicemanager (bijv. systemd). Ze blijven actief tot het systeem wordt uitgeschakeld of opnieuw wordt opgestart. Gebruikers interageren indirect met hen — via configuratiebestanden, terminalopdrachten (service, systemctl) of netwerkverzoeken (als de daemon een HTTP/S-, SSH- of andere netwerkinterface biedt).

Hoe je daemons maakt en beheert

Om een daemon te implementeren, volg je deze stappen:

1. Proces forken: het ouderproces roept fork() aan en blijft de daemoncode uitvoeren in het kindproces.

2. Loskoppelen van de besturingsterminal (setsid): om gebruikersinterferentie te voorkomen (bijv. sluiten van de terminal), roept de daemon setsid() aan om een nieuwe sessie te starten en de leider ervan te worden.

3. Standaardinvoer/-uitvoerdescriptoren sluiten: omdat de daemon niet naar het scherm moet schrijven of op invoer wachten, worden stdin, stdout en stderr gesloten of omgeleid naar logbestanden.

4. Signalen en logging afhandelen: om een nette afsluiting of herladen van configuraties te ondersteunen, moet de daemon signalen (SIGTERM, SIGHUP, enz.) afhandelen. Logging gebeurt meestal via syslog of bestanden.

5. Hoofdlus: na initialisatie gaat de daemon de hoofdlus in: wachten op gebeurtenissen, ze afhandelen en herhalen totdat hij wordt gestopt.

Laten we zien hoe je een daemon maakt op Ubuntu 22.04 met een Hostman cloudserver.

1. De daemon schrijven in C

Maak een bestand genaamd mydaemon.c en voeg de volgende code toe:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>

int main() {
    // Syslog openen
    openlog("mydaemon", LOG_PID, LOG_DAEMON);
    syslog(LOG_NOTICE, "Daemon started");

    // Oneindige hoofdlus
    while (1) {
        // Achtergrondtaken: monitoring, wachtrijverwerking, enz.
        syslog(LOG_NOTICE, "Performing task...");
        sleep(60);
    }

    // Als de lus ooit wordt verlaten
    syslog(LOG_NOTICE, "Daemon stopped");
    closelog();

    return 0;
}

2. Het programma compileren

Werk eerst de pakketten bij:

sudo apt update && sudo apt upgrade

Installeer de GCC-compiler als die nog niet is geïnstalleerd:

sudo apt install gcc

Compileer de daemon:

gcc mydaemon.c -o mydaemon

3. Het uitvoerbare bestand verplaatsen

Verplaats het binaire bestand naar /usr/local/bin/, een standaardlocatie voor aangepaste hulpprogramma’s:

mv mydaemon /usr/local/bin/mydaemon

4. Een systemd-service maken

Maak een unitbestand genaamd mydaemon.service:

sudo nano /etc/systemd/system/mydaemon.service

Voeg de volgende inhoud toe:

[Unit]
Description=My Daemon
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/mydaemon
Restart=on-failure

[Install]
WantedBy=multi-user.target

Uitleg van de velden:

• Description: beschrijving die wordt weergegeven in systemctl status.
• After=network.target: zorgt ervoor dat de daemon start nadat het netwerk actief is.
• Type=simple: de daemon forkt niet; hij draait als één enkel proces.
• ExecStart: pad naar het uitvoerbare bestand van de daemon.
• Restart=on-failure: start automatisch opnieuw als de daemon crasht.
• WantedBy=multi-user.target: zorgt ervoor dat de service start in de standaard multi-user omgeving.

5. De daemon starten en monitoren

sudo systemctl daemon-reload          # Herlaad systemd-configuratie
sudo systemctl start mydaemon         # Start de daemon
sudo systemctl status mydaemon        # Controleer de status

Als alles werkt, toont de status active. Om logs te bekijken:

journalctl -u mydaemon.service -e

Voorbeelden van gebruik van daemons

• Webservers

Hun taak is te luisteren op een netwerkpoort (meestal 80 of 443), HTTP/HTTPS-verzoeken te accepteren, een antwoord te genereren (zoals een HTML-pagina of JSON-gegevens) en dit terug te sturen naar de client. In de meeste gevallen start een webserver bij het opstarten en blijft draaien tot de server wordt uitgeschakeld of gestopt (bijv. systemctl stop nginx).

• Databasedaemons

MySQL/MariaDB, PostgreSQL, MongoDB — dit zijn allemaal daemons. Ze starten met het systeem en draaien op de achtergrond terwijl ze verzoeken van clienttoepassingen of webservices accepteren. Deze daemons loggen activiteiten, ondersteunen configuratie via bestanden en worden beheerd met hulpprogramma’s (of systemd).

• Taakplanners (cron, atd)

De cron-daemon controleert de planningslijst (crontab) en voert programma’s uit op door de gebruiker gespecificeerde tijden of intervallen. Dit maakt het mogelijk om back-ups, systeemupdates, controles en vele andere routinetaken te automatiseren.

atd is een vergelijkbare daemon, maar voert taken slechts één keer uit op een bepaald moment (in tegenstelling tot cron, die ze regelmatig uitvoert).

• Toegangs- en controlediensten (sshd, xrdp)

sshd (Secure Shell Daemon) biedt externe toegang via het SSH-protocol. xrdp maakt externe desktopverbindingen mogelijk via het RDP-protocol. Het werkt als een daemon die luistert naar netwerkverbindingen op een opgegeven poort.

• Init-systeemdaemons (systemd, init, Upstart)

In moderne systemen wordt de rol van de “hoofd-daemon” vervuld door systemd (dat het oudere SysV-init-systeem vervangt). systemd is het eerste proces dat start na de kernel en is verantwoordelijk voor het starten en beheren van alle andere diensten en processen. Het start ze parallel en behandelt hun afhankelijkheden. Simpel gezegd, systemd is zelf een daemon die alle andere in het systeem “orkestreert”.

Voordelen en nadelen van daemons

Voordelen:

• Automatisering: daemons maken het mogelijk om systeemgedrag te automatiseren — van het reageren op netwerkverzoeken tot het plannen van taken — zonder gebruikersinterventie.

• Isolatie: door te draaien onder aparte gebruikers- of groepsaccounts en losgekoppeld van terminals, wordt de beveiliging verhoogd door potentiële schade te beperken in geval van een inbreuk.

• Continue werking: een daemon kan doorgaan met het leveren van diensten (zoals een webserver) zonder onderbreking, zelfs als de gebruiker uitlogt of de console sluit.

• Beheerbaarheid: Linux biedt systeemtools (zoals systemd, init-scripts) om alle daemons centraal te beheren: starten, stoppen, herstarten en loggen.

Nadelen:

• Complexe foutopsporing: omdat daemons op de achtergrond draaien en niets naar de console schrijven, vereist debugging uitgebreide logging en complexere instellingen (debug-flags, tracing, enz.).

• Beveiligingsrisico’s: als een daemon draait met verhoogde rechten (bijv. als root), kan een kwetsbaarheid het hele systeem compromitteren. Het is beter om daemons uit te voeren met beperkte accounts.

• Afhankelijkheidsbeheer: sommige daemons kunnen falen als ze bijvoorbeeld netwerktoegang nodig hebben voordat het netwerk actief is. Moderne init-systemen lossen dit op, maar met klassieke SysV-init-scripts was dit een veelvoorkomend probleem.

• Hogere resourceconsumptie: elk voortdurend draaiend achtergrondproces verbruikt systeembronnen (geheugen, CPU-tijd). Te veel daemons kunnen de prestaties beïnvloeden, vooral op systemen met beperkte middelen.

Conclusie

Daemons vormen een essentieel onderdeel van de architectuur van Linux-besturingssystemen en bieden uitgebreide mogelijkheden voor automatisering en achtergrondservices. Ze stellen beheerders in staat om netwerkoperaties, geplande taken, logging, beveiligingssystemen en vele andere componenten flexibel te configureren.

Het schrijven van je eigen daemon vereist begrip van processen, signalen, systeemaanroepen en zorgvuldige aandacht voor logging en beveiliging.

Moderne init-systemen (vooral systemd) hebben het beheer van daemons en de servicelogica vereenvoudigd, waardoor het maken van aangepaste services gestructureerder en flexibeler is geworden. Toch blijft het een complex vakgebied dat zorgvuldige planning, debugging en voortdurend onderhoud vereist.

Als je op zoek bent naar een betrouwbare, krachtige en betaalbare oplossing voor je workflows, biedt Hostman Linux VPS-hostingopties, waaronder Debian VPS, Ubuntu VPS en VPS CentOS.