# Systemd

# Aufbewahrungszeit Journal von Systemd konfigurieren

<p class="callout info">Getestet mit Arch Linux am 25.09.2020</p>

Mit der Zeit wird das Journal (der /var/log/syslog Ersatz von Systemd) immer länger. Es läßt sich aber auch eine Retention konfigurieren, die z.B. die Logs nach einer Woche löscht. Dazu muss die Konfigurationsdatei wie folgt editiert werden:

<div id="bkmrk-maxretentionsec%3D1wee"><div>```
MaxRetentionSec=1week
```

</div></div>Aus der Manpage zu journald.conf:

<div id="bkmrk-maxretentionsec%3D-the"><div>```
MaxRetentionSec=
  The maximum time to store journal entries. This controls whether journal files containing entries older than the specified time span are deleted. Normally, time-based deletion of old journal files 
  should not be required as size-based deletion with options such as SystemMaxUse= should be sufficient to ensure that journal files do not grow without bounds. However, to enforce data retention 
  policies, it might make sense to change this value from the default of 0 (which turns off this feature). This setting also takes time values which may be suffixed with the units "year", "month", 
  "week", "day", "h" or " m" to override the default time unit of seconds.
```

</div></div>Es gibt noch ein paar andere Möglichkeiten, z.B. nach einer bestimmten Größe zu rotieren. Diese sind in der Manpage dokumentiert: `man journald.conf`

# Einfache Kommandos beim Systemstart ausführen

<div id="bkmrk-%5Bunit%5D-description%3Dd"><div>```
[Unit]
Description=Disable segment offloading
Wants=network-online.target
After=network-online.target

[Service]
Type=oneshot
RemainAfterExit = yes
ExecStart=/usr/sbin/ethtool -K eno1 tso off gso off
ExecStart=/usr/sbin/ethtool -K vmbr0 tso off gso off

[Install]
WantedBy=multi-user.target
```

</div></div>Beim Typ „oneshot“ können mehrere ExecStart Befehle konfiguriert werden.

# Kernel-Modul beim Systemstart laden und Parameter setzen

Nur ein kurzes Beispiel, früher™ wurde das über die rc.local gemacht.

<div id="bkmrk-%5Bunit%5D-description-%3D">```
[Unit]
Description = Required settings to mount unencrypted cifs shares
After = NetworkManager-wait-online.service network.target network-online.target dbus.service
Wants = NetworkManager-wait-online.service network-online.target
 
[Service]
Type = oneshot
RemainAfterExit = yes
ExecStart = /bin/bash -c "modprobe cifs; echo 0x27 > /proc/fs/cifs/SecurityFlags"
 
[Install]
WantedBy = multi-user.target
```

</div>

# NTP-Client in systemd konfigurieren

Die NTP-Server werden mit Leerzeichen getrennt in der timesyncd.conf hinterlegt.

<div id="bkmrk-%2Fetc%2Fsystemd%2Ftimesyn"><div><dl class="code"><dt>/etc/systemd/timesyncd.conf</dt><dd>```
[Time]
Servers=0.ntp.wavecon.de 1.ntp.wavecon.de
```

</dd></dl></div></div>Der Service muss noch aktiviert und gestartet werden

<div id="bkmrk-systemctl-enable-sys"><div>```
systemctl enable systemd-timesyncd.service
systemctl start systemd-timesyncd.service
```

</div></div>Über `systemctl status systemd-timesyncd.service` kann man dann auch sehen ob er tut was er soll.

# Verzeichnis für PID-File in /run durch systemd anlegen lassen

Systemd kann sich um das Anlegen eines Verzeichnisses in /run kümmern, wenn die zu startende Applikation dazu selbst keine Berechtigung hat. Dazu muss der Parameter „RuntimeDirectory“ im Unit-File hinzugefügt werden.

Beispiel für Cerebro (eine Monitoring-GUI für Elasticsearch):

<div id="bkmrk-%5Bunit%5D-description%3Dc"><div>```
[Unit]
Description=Cerebro

[Service]
Type=simple
User=elasticsearch
Group=elasticsearch
RuntimeDirectory=cerebro
ExecStart=/srv/cerebro/current/bin/cerebro "-Dpidfile.path=/var/run/cerebro/cerebro.pid"
Restart=always
WorkingDirectory=/srv/cerebro

[Install]
WantedBy=multi-user.target
```

</div></div>Das Verzeichnis in /run gehört dem User und der Gruppe, die im Unit-File angegeben sind. Die Modes lassen sich über den Parameter RuntimeDirectoryMode ändern.

# Kernel-Setting Transparent Hugepage konfigurieren

Dieses Setting ist wichtig z.B. für MongoDB oder Redis (auch für andere [Datenbanken](https://www.percona.com/blog/transparent-huge-pages-refresher/)!). Beide Services wollen das gerne auf 'never' haben.

Mit systemd ist das recht einfach. Folgendes in /etc/tmpfiles.d/disable-thp.conf einfügen:

```bash
#Type Path                                                  Mode UID GID  Age Argument
w     /sys/kernel/mm/transparent_hugepage/enabled           -    -   -    -   never
w     /sys/kernel/mm/transparent_hugepage/defrag            -    -   -    -   never
```

und folgendes Kommando ausführen:

```
systemd-tmpfiles --create --prefix=/sys/kernel/mm/transparent_hugepage/ /etc/tmpfiles.d/disable-thp.conf
```

und überprüfen:

```
grep -E . /sys/kernel/mm/transparent_hugepage/defrag /sys/kernel/mm/transparent_hugepage/enabled
```

und hier für schnelles Copy&amp;Paste zusammengefasst

```bash
cat >/etc/tmpfiles.d/disable-thp.conf <<EOF
#Type Path                                                  Mode UID GID  Age Argument
w     /sys/kernel/mm/transparent_hugepage/enabled           -    -   -    -   never
w     /sys/kernel/mm/transparent_hugepage/defrag            -    -   -    -   never
EOF
systemd-tmpfiles --create --prefix=/sys/kernel/mm/transparent_hugepage/ /etc/tmpfiles.d/disable-thp.conf
grep -E . /sys/kernel/mm/transparent_hugepage/defrag /sys/kernel/mm/transparent_hugepage/enabled
```

# Limits setzen/überschreiben mit systemd

Wie kann ich Limits für Services setzen, die via systemd gestartet werden? Meine Einstellungen in` /etc/security/limits.conf` oder `/etc/security/limits.d/*.conf` werden ignoriert, da diese nur von pam\_limits.so verwendet werden, was systemd nicht nutzt.

Um die Limit anzupassen muss das systemd unit angepasst werden, z.B. für MySQL:

```
$ systemctl edit mysql.service
# einfügen und speichern:
[Service]
LimitNOFILE=500000

# Service neu starten
$ systemctl restart mysql.service
```

Im systemctl status sieht man jetzt den Override

```
$ systemctl status mysql.service
● mysql.service - Percona Server
     Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset: enabled)
    Drop-In: /etc/systemd/system/mysql.service.d
             └─override.conf

```

Limits für alle Prozesse überschreiben

```bash
mkdir -p /etc/systemd/system.conf.d/
cat >/etc/systemd/system.conf.d/10-filelimit.conf <<EOF
[Manager]
DefaultLimitNOFILE=500000
EOF
systemctl daemon-reload
## ggf. Reboot!
```

Folgende Limits können überschrieben werden:

```
           ┌──────────────────┬───────────────────┬────────────────────────────┬────────────────────────────────────────────────────────────────┐
           │ Directive        │ ulimit equivalent │ Unit                       │ Notes                                                          │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitCPU=        │ ulimit -t         │ Seconds                    │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitFSIZE=      │ ulimit -f         │ Bytes                      │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitDATA=       │ ulimit -d         │ Bytes                      │ Don't use. This limits the allowed address range, not memory   │
           │                  │                   │                            │ use! Defaults to unlimited and should not be lowered. To limit │
           │                  │                   │                            │ memory use, see MemoryMax= in systemd.resource-control(5).     │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitSTACK=      │ ulimit -s         │ Bytes                      │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitCORE=       │ ulimit -c         │ Bytes                      │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitRSS=        │ ulimit -m         │ Bytes                      │ Don't use. No effect on Linux.                                 │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitNOFILE=     │ ulimit -n         │ Number of File Descriptors │ Don't use. Be careful when raising the soft limit above 1024,  │
           │                  │                   │                            │ since select(2) cannot function with file descriptors above    │
           │                  │                   │                            │ 1023 on Linux. Nowadays, the hard limit defaults to 524288, a  │
           │                  │                   │                            │ very high value compared to historical defaults. Typically     │
           │                  │                   │                            │ applications should increase their soft limit to the hard      │
           │                  │                   │                            │ limit on their own, if they are OK with working with file      │
           │                  │                   │                            │ descriptors above 1023, i.e. do not use select(2). Note that   │
           │                  │                   │                            │ file descriptors are nowadays accounted like any other form of │
           │                  │                   │                            │ memory, thus there should not be any need to lower the hard    │
           │                  │                   │                            │ limit. Use MemoryMax= to control overall service memory use,   │
           │                  │                   │                            │ including file descriptor memory.                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitAS=         │ ulimit -v         │ Bytes                      │ Don't use. This limits the allowed address range, not memory   │
           │                  │                   │                            │ use! Defaults to unlimited and should not be lowered. To limit │
           │                  │                   │                            │ memory use, see MemoryMax= in systemd.resource-control(5).     │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitNPROC=      │ ulimit -u         │ Number of Processes        │ This limit is enforced based on the number of processes        │
           │                  │                   │                            │ belonging to the user. Typically it's better to track          │
           │                  │                   │                            │ processes per service, i.e. use TasksMax=, see                 │
           │                  │                   │                            │ systemd.resource-control(5).                                   │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitMEMLOCK=    │ ulimit -l         │ Bytes                      │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitLOCKS=      │ ulimit -x         │ Number of Locks            │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitSIGPENDING= │ ulimit -i         │ Number of Queued Signals   │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitMSGQUEUE=   │ ulimit -q         │ Bytes                      │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitNICE=       │ ulimit -e         │ Nice Level                 │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitRTPRIO=     │ ulimit -r         │ Realtime Priority          │ -                                                              │
           ├──────────────────┼───────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────┤
           │ LimitRTTIME=     │ ulimit -R         │ Microseconds               │ -                                                              │
           └──────────────────┴───────────────────┴────────────────────────────┴────────────────────────────────────────────────────────────────┘


```

Weitere Infos in den manpages

```bash
man 5 systemd.exec
man 5 systemd.resource-control
```