Skip to main content

systemd: Übung

Teil 1 (geführt): Ping-Pong-Server

Der Ping-Pong-Server, den wir bereits bei den SSH-Übungen kennengelernt haben, kann dazu verwendet werden, die Konnektivität zwischen verschiedenen Systemen zu testen.

Dieser Server wurde bisher immer manuell gestartet. Neu soll er als Service automatisch gestartet (und bei Ausfällen: automatisch neugestartet) werden.

Aufgabe 1: Ping-Pong-Server vorbereiten

Der Ping-Pong-Server steht als Datei pingpong.go zur Verfügung und kann auf dem Server folgendermassen heruntergeladen werden:

wget https://m346.frickelbude.ch/files/pingpong.go

Kompiliere das ausführbare Programm:

go build pingpong.go

Neu befindet sich die ausführbare Datei pingpong im Verzeichnis. Starte den Server:

./pingpong

Rufe im Browser die URL IP-ADRESSE:8000/ping auf, wobei du IP-ADRESSE durch die IP-Adresse deiner VM ersetzen musst. Du solltest ungefähr folgende Ausgabe erhalten (die Portnummer kann abweichen):

pong back to 127.0.0.1:57494

Im Terminal kannst du nun den Ping-Pong-Server mit der Tastenkombination [Ctrl]-[C] wieder stoppen.

Verschiebe das ausführbare pingpong-Programm an einen anderen Ort, damit es auch für andere Benutzer des Systems verfügbar wird:

sudo mv pingpong /usr/local/bin/

Aufgabe 2: Ping-Pong-Service konfigurieren

Damit der Ping-Pong-Server mit systemd verwaltet werden kann, muss eine sogenannte Service-Unit eingerichtet werden. Öffne einen Texteditor und erstelle eine Datei, welche du mit folgendem Inhalt unter /home/user/pingpong.service abspeicherst:

[Unit]
Description=ping-pong server: you ping it, it pongs you
Documentation=https://github.com/patrickbucher/pingpong
After=network.target

[Service]
ExecStart=/usr/local/bin/pingpong
Type=simple
Restart=always

[Install]
WantedBy=multi-user.target

Verschiebe diese Datei ins Verzeichnis /etc/systemd/system/:

sudo mv pingpong.service /etc/systemd/system/

Lade die angepasste systemd-Konfiguration neu:

sudo systemctl daemon-reload

Erläuterungen zum Service-Unit-File

Hierzu einige allgemeine Erklärungen zu den einzelnen Abschnitten und Direktiven:

  • [Unit]: allgemeine Informationen zum Service
    • Description: eine kurze Beschreibung des Services
    • Documentation: ein Verweis auf eine Manpage oder auf eine Webseite mit Dokumentation
    • After: Abhängigkeiten zu anderen Services
  • [Service]: Konfiguration des Services
    • ExecStart: der Befehl zum Starten des Services
    • Type: die Art der Service-Ausführung
  • [Install]: Informationen zur Installation des Services
    • WantedBy: an welchem Punkt des Systemstarts der Servie ausgeführt werden soll

Wichtig sind bei diesem Beispiel die folgenden Direktiven:

  • After=network.target: Der Service wird erst ausgeführt, wenn das Netzwerk bereit ist.
  • ExecStart=/usr/local/bin/pingpong: Der Service wird durch die Ausführung dieser Datei gestartet.
  • WantedBy=multi-user.target: Der Service soll automatisch gestartet werden, wenn das System beim Hochfahren in den Mehrbenutzermodus wechselt.

Aufgabe 3: Ping-Pong-Service starten, beenden und neustarten

Der Ping-Pong-Service kann nun folgendermassen gestartet werden:

sudo systemctl start pingpong.service

Ermittle den Zustand des Services mit folgendem Befehl:

systemctl status pingpong.service

Die Ausgabe sollte auf der dritten Zeile folgende Angabe enthalten:

Active: active (running) since ...

Ist dies nicht der Fall, kontrolliere noch einmal alle Schritte der ersten beiden Aufgaben und starten den Service erneut wie oben beschrieben mit systemctl start.

Hat alles funktioniert, rufe testhalber erneut im Browser die Seite IP-ADRESSE:8000/ping auf.

Stoppe den Service nun wieder:

sudo systemctl stop pingpong.service

Starte den Service automatisch beim Systemstart, indem du folgenden Befehl ausführst:

sudo systemctl enable --now pingpong.service

Mit dem --now-Flag wird der Service auch sofort gestartet.

Teste den Service erneut im Browser. Starten ihn anschliessend mit folgendem Befehl neu:

sudo systemctl restart pingpong.service

Beim nächsten Aufruf im Browser sollte sich nun in der Antwort die Portnummer geändert haben.

Aufgabe 4: Logdaten vom Ping-Pong-Service einsehen

Da der Ping-Pong-Server nicht mehr manuell über das Terminal gestartet wird, können wir dessen Logmeldungen nicht mehr auf dem Bildschirm sehen. Diese Meldungen werden stattdessen ins sogenannte Journal geschrieben.

Um zu sehen, was auf dem System gerade alles läuft, kann das Journal fortlaufend ausgegeben werden:

sudo journalctl -f

Öffne ein zweites Terminal und starte dort den Ping-Pong-Service neu:

sudo systemctl restart pingpong.service

In der Journal-Ausgabe solltest du nun entsprechende Meldungen über den Neustart des Ping-Pong-Servers sehen.

Stoppe die fortlaufende Anzeige des Journals mit mit [Ctrl]-[C].

Starte dafür die fortlaufende Anzeige der Meldungen, die den Ping-Pong-Server betreffen:

sudo journalctl -fu pingpong.service

Starte nun den Ping-Pong-Service in einem anderen Terminal neu und rufe die URL IP-ADRESSE:8000/ping einige Male auf.

Unterbreche die fortlaufende Ausgabe des Journals wieder mit [Ctrl]-[C].

Aufgabe 5: Startparameter vom Server-Prozess anpassen

Der Ping-Pong-Server unterstützt zwei Flags:

$ pingpong -help
Usage of pingpong:
-addr string
        web server host/ip (default "0.0.0.0")
-port uint
        web server port (default 8000)
  • Das -addr-Flag ist standardmässig auf 0.0.0.0 eingestellt, wodurch Verbindungen von überall her zugelassen werden.
  • Das -port-Flag ist standardmässig auf 8000 eingestellt.

Möchte man dem Ping-Pong-Server beispielsweise einen Proxy vorschalten, können diese beiden Flags nützlich sein:

  • -addr 127.0.0.1: Es sollen nur noch Verbindungen von localhost entgegengenommen werden, damit man von aussen nicht um den Proxy herumkommt. (Mit dem Cloud-VM-Setup ist diese Einstellung aber nicht sinnvoll.)
  • -port 8001: Der Service soll unter Port 8001 laufen, da der Port 8000 neu vom Proxy besetzt wird.

Öffne die Unit-Datei /etc/systemd/system/pingpong.service mit einem Texteditor (hier: mit nano):

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

Passe nun die ExecStart-Direktive folgendermassen an:

ExecStart=/usr/local/bin/pingpong -addr 0.0.0.0 -port 8001

Speichere die Datei mit [Ctrl]-[O] und [Enter] ab. Schliesse den editor mit [Ctrl]-[X].

Lade Snun die angepasste systemd-Konfiguration neu:

sudo systemctl daemon-reload

Starte den Ping-Pong-Service neu:

sudo systemctl restart pingpong.service

Rufe im Browser die URL IP-ADRESSE:8001/ping auf, um zu testen, ob der Server wirklich unter dem neuen Port 8001 läuft.

Aufgabe 6: Privilegien des Ping-Pong-Services einschränken

Führe den folgenden Befehl aus:

ps -e -o pid,user,args | grep pingpong

Erläuterungen:

  • Mit ps werden laufende Prozesse angezeigt.
    • Mit -e (“everything”) werden alle Prozesse angezeigt.
    • Mit -o (“output) werden die auszugebenden Spalten festgelegt.
      • pid steht für die Prozess-ID.
      • user steht für den ausführenden Benutzer des Prozesses.
      • args steht für die Befehlszeile, mit welcher der Prozess gestartet worden ist.
  • Mit grep wird die Ausgabe nach dem Wort pingpong gefiltert.

Du solltest ungefähr folgende Ausgabe sehen, wobei die erste Spalte (pid) variieren kann:

6384 root     /usr/local/bin/pingpong -addr 127.0.0.1 -port 8001
6515 user     grep pingpong

Der Prozess hat die PID 6384 und wird durch den Benutzer root ausgeführt. Die zweite Zeile steht für den grep-Befehl, womit die Filterung der Ausgabe stattfindet.

Die Ausführung durch root ist problematisch, da der Prozess nun mit Administratoren-Rechten läuft. Im Falle einer Sicherheitslücke im Ping-Pong-Server könnte ein Angreifer Administratoren-Rechte erhalten.

Erstelle einen neuen Benutzer namens pingpong:

sudo useradd -M -U pingpong
  • Mit -M wird kein Home-Verzeichnis für den neuen Benutzer erstellt.
  • Mit -U wird gleich eine Benutzergruppe für den neuen Benutzer erstellt.

Damit der Ping-Pong-Service mit dem entsprechenden Benutzer ausgeführt wird, muss die Service-Unit entsprechend angepasst werden.

Öffne die Unit-Datei /etc/systemd/system/pingpong.service:

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

Erweitere den [Service]-Abschnitt um die folgenden beiden Direktiven:

User=pingpong
Group=pingpong

Speichere ([Ctrl]-[O] [Enter]) und schliesse ([Ctrl]-[X]) den Texteditor.

Lade die systemd-Konfiguration neu:

sudo systemctl daemon-reload

Starte nun den Ping-Pong-Service neu:

sudo systemctl restart pingpong.service

Überprüfe noch einmal, mit welchem Benutzer der Service nun ausgeführt wird:

ps -e -o pid,user,args | grep pingpong

Die Ausgabe sollte ungefähr folgendermassen aussehen:

6649 pingpong /usr/local/bin/pingpong -addr 127.0.0.1 -port 8001
6704 user     grep pingpong

Teil 2 (selbständig): RustFS

Mit RustFS hast du bereits gearbeitet. Dabei wurde der RustFS-Server manuell ausgeführt und – teils versehentlich – wieder mit [Ctrl]-[C] gestoppt.

Neu soll RustFS als Service ausgeführt und beim Start des Betriebssystems automatisch mitgestartet werden.

Aufgabe 7: RustFS vorbereiten

Die beiden ausführbaren Dateien rustfs und rc sollten bereits auf dem System vorhanden sein.

Erstelle einen eigenen Benutzer für RustFS:

sudo useradd -m -d /home/rustfs -U -s /usr/bin/bash rustfs

Dieses mal wird mit -m -d /home/rustfs ein Home-Verzeichnis für den neuen Benutzer angelegt. Mit -s /usr/bin/bash wird die Bash als Login-Shell gesetzt.

Erstellen weiter ein RustFS-Datenverzeichnis:

sudo -u rustfs mkdir /home/rustfs/rustfs-data

Mit sudo -u rustfs wird der Befehl mit dem Benutzer rustfs ausgeführt, sodass das neu erstellte Verzeichnis gleich ihm gehört.

Starte eine neue Shell-Sitzung mit dem Benutzer rustfs:

sudo su - rustfs

Starte nun RustFS ein letztes Mal manuell, indem du die folgenden Befehle auf der Shell eingibst:

export RUSTFS_ACCESS_KEY=rustfs
export RUSTFS_SECRET_KEY=topsecret
rustfs server ~/rustfs-data

Überprüfe im Browser unter der URL IP-ADRESSE:9001 ob RustFS wirklich läuft.

Wechsle zurück ins Terminal und stoppe RustFS wieder mit [Ctrl]-[C].

Verlassen die Terminal-Sitzung des Benutzes rustfs mit dem exit-Befehl, sodass du wieder folgende Eingabeaufforderung siehst:

user@VORNAME_NACHNAME:~$

Aufgabe 8: RustFS-Service konfigurieren und ausführen

Kopiere die pingpong.service-Unit-Datei als rustfs.service ins Home-Verzeichnis:

cp /etc/systemd/system/pingpong.service ~/rustfs.service

Öffnen die Datei nun in einem Textedito.

Passen die folgenden Direktiven an:

  • Abschnitt [Unit]
    • Description: Beschreiben Sie in eigenen Worten, was RustFS macht.
    • Documentation: Fügen Sie einen Link auf die RustFS-Dokumentation ein.
  • Abschnitt [Service]
    • ExecStart: Verwenden Sie die Befehlszeile von Aufgabe 7.
    • User und Group: Tragen Sie den richtigen Benutzer bzw. die richtige Benutzergruppe ein.

Fügen dem [Service]-Abschnitt weitere Direktiven hinzu:

  • WorkingDirectory: Verwenden das Home-Verzeichnis des ausführenden Benutzers.
  • Enviromment: Setzen die nötigen Umgebungsvariablen. Verwenden pro Umgebungsvariable eine eigene Environment-Direktive.

Verschiebe die Datei nun ins systemd-Konfigurationsverzeichnis:

sudo mv ~/rustfs.service /etc/systemd/system/

Laden die systemd-Konfiguration neu und starten den RustFS-Service:

sudo systemctl daemon-reload
sudo systemctl start rustfs.service

Überprüfen im Browser und mit systemd status, ob RustFS wirklich läuft.

Ist dies nicht der Fall, überprüfe und korrigiere das Service-Unit-File.

Läuft RustFS, aktiviere den Service für den nächsten Systemstart:

sudo systemctl enable rustfs.service

Aufgabe 9: Umgebungsvariablen auslagern

Lege mit dem Benutzer rustfs die Datei /home/rustfs/environment an:

sudo -u rustfs touch /home/rustfs/environment

Ersetze die Environment-Direktiven aus der Unit-Datei /etc/systemd/system/rustfs.service durch eine einzige EnvironmentFile-Direktive und definiere die Umgebungsvariablen stattdessen in folgender Form in /home/rustfs/environment:

Variable1=Wert1
Variable2=Wert2

Schränke die Zugriffsrechte dieser Datei auf den Benutzer rustfs (und auf die Benutzer seiner Gruppe) ein:

sudo -u rustfs chmod 640 /home/rustfs/environment

Lade die systemd-Konfiguration neu und starte den RustFS-Service neu.

Dadurch werden Benutzernamen und Passwort nicht mehr in der Systemkonfiguration sondern im Home-Verzeichnis des jeweiligen Benutzers abgelegt, was eine höhere Sicherheit bietet. Unit-Dateien in /etc/systemd/system können alle Benutzer einsehen.