Waarom systemd in plaats van de app gewoon op de achtergrond draaien?

Een achtergrondproces (met & of nohup) sterft bij een herstart, komt niet terug als het crasht en verspreidt zijn logs. Een systemd-service start automatisch bij het opstarten, herstart bij een fout en stuurt zijn uitvoer naar journalctl. Het is de standaard, betrouwbare manier om iets langlevends op Linux te draaien.

Waar horen unit-bestanden?

Je eigen services horen in /etc/systemd/system/, één bestand per service, met een naam als iets.service. Voer na het maken of bewerken 'systemctl daemon-reload' uit zodat systemd de wijziging oppikt, activeer hem daarna en start hem.

Wat doet 'Restart=always', en zijn er nadelen?

Het vertelt systemd de service telkens te herstarten als hij stopt, om welke reden dan ook — de sleutel om iets draaiend te houden. Het enige addertje is een crashlus: als de app bij het starten meteen faalt, blijft systemd hem herstarten. Voeg 'RestartSec=5' toe om pogingen te spreiden, en bekijk de logs om de onderliggende fout op te lossen.

Hoe zie ik de logs van de service?

Gebruik 'journalctl -u yourservice -f' om de live-uitvoer te volgen, of zonder -f om de geschiedenis te lezen. systemd vangt stdout en stderr automatisch op, dus je hoeft zelf geen logbestanden aan te sluiten.

Moet de service als root draaien?

Liever niet. Maak een toegewijde niet-root-gebruiker en stel 'User=' in de unit in, zodat een compromittering van de app niet de hele machine weggeeft. Draai alleen als root wanneer de service dat echt nodig heeft.

Een systemd-service maken om een app draaiend te houden

Verander elk script of elke app in een beheerde service die start bij het opstarten, herstart als hij crasht en logt naar journalctl. Schrijf een unit-bestand, activeer het en controleer de status — de standaardmanier om iets 24/7 op Linux te draaien.

Een app draaien met & of nohup gaat prima tot de server herstart, het proces crasht of je zijn logs wilt vinden — dan valt het uit elkaar. systemd is het standaardantwoord: het start je app bij het opstarten, herstart hem als hij sterft en vangt zijn logs op. Een script of binary in een beheerde service veranderen is één klein bestand.

1. Schrijf een unit-bestand

Maak /etc/systemd/system/myapp.service:

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

[Service]
User=myapp
WorkingDirectory=/opt/myapp
ExecStart=/usr/bin/python3 /opt/myapp/run.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Pas ExecStart, WorkingDirectory en User aan je app aan. Restart=always is wat hem in leven houdt.

2. Maak een toegewijde gebruiker (aanbevolen)

sudo useradd --system --no-create-home --shell /usr/sbin/nologin myapp
sudo chown -R myapp:myapp /opt/myapp

Als niet-root-gebruiker draaien beperkt de schade als de app ooit gecompromitteerd wordt.

3. Activeer hem en start hem

sudo systemctl daemon-reload
sudo systemctl enable --now myapp

enable laat hem starten bij het opstarten; --now start hem meteen.

4. Controleer status en logs

sudo systemctl status myapp
journalctl -u myapp -f       # live-logs volgen

Dagelijkse commando's

sudo systemctl restart myapp   # herstarten na een wijziging
sudo systemctl stop myapp      # hem stoppen
sudo systemctl disable myapp   # niet meer starten bij het opstarten

Eerlijke waarschuwingen

Voer daemon-reload uit na het bewerken van een unit-bestand, anders gebruikt systemd de oude versie.
Let op crashlussen. Als de app meteen faalt, blijft Restart=always eeuwig proberen — RestartSec=5 spreidt de pogingen; los de grondfout op via de logs.
Verkies een niet-root User= zodat een gecompromitteerde app niet de hele server bezit.

Volgende stappen

Een systemd-service is hoe je wat dan ook 24/7 draaiend houdt — bijvoorbeeld een AI-agent die de klok rond draait of de relay achter een zelf-gehoste RustDesk-server. Is je app in plaats daarvan gecontaineriseerd, dan speelt Dockers --restart unless-stopped dezelfde rol — zie hoe je Docker installeert.