New Crowdin updates

docs/books/admin_guide/11-tasks.fr.md

@@ -146,7 +146,7 @@ Exemple :
 | ------ | ------------------------------------------------------------------------ |
 | `-e`   | Modifier le fichier de planification avec vi                             |
 | `-l`   | Affiche le contenu du fichier de planification                           |
-| `- u`  | Nom de l'utilisateur dont le fichier de planification doit être manipulé |
+| `-u`   | Nom de l'utilisateur dont le fichier de planification doit être manipulé |
 | `-r`   | Supprime le fichier de planification                                     |
 
 !!! Warning "Avertissement"

docs/books/learning_ansible/02-advanced.it.md

@@ -116,7 +116,7 @@ Per visualizzare una variabile, è necessario attivare il modulo `di debug` come
 
 ```
 - ansible.builtin.debug:
-    var: "{{ service['debian'] }}"
+    var: service['debian']
 ```
 
 È anche possibile utilizzare la variabile all'interno di un testo:

docs/gemstones/systemd_service_for_python_script.de.md

@@ -0,0 +1,176 @@
+---
+title: Service `systemd` - Python Script
+author: Antoine Le Morvan
+contributors: Steven Spencer
+tested_with: 8.6, 9.0
+tags:
+  - python
+  - systemd
+  - cron
+---
+
+# `systemd` Dienst für ein Python-Skript
+
+Wenn Sie wie viele Sysadmins ein Fan von Cron-Skripten sind, die mit `* * * * * * /I/launch/my/script.sh` gestartet werden, sollte dieser Artikel Sie an eine andere Möglichkeit erinnern, dies mit der ganzen Leichtigkeit des `systemd` zu tun.
+
+Wir schreiben ein Python-Skript, das eine Endlosschleife zur Ausführung der von Ihnen definierten Aktionen bereitstellt.
+
+Wir werden sehen, wie dieses Skript als `systemd` Dienst ausgeführt wird, wie die Protokolle in Journalctl anzeigt werden können, was passiert, wenn das Skript abstürzt.
+
+## Voraussetzungen
+
+Beginnen wir damit, einige Python-Abhängigkeiten zu installieren, die für das Skript benötigt werden, um das Kommando journalctl zu verwenden:
+
+```
+shell > sudo dnf install python36-devel systemd-devel
+shell > sudo pip3 install systemd
+```
+
+## Skript entwerfen
+
+Lass uns das folgende Skript `my_service.py` anschauen:
+
+```
+"""
+Sample script to run as script
+"""
+import time
+import logging
+import sys
+from systemd.journal import JournaldLogHandler
+
+# Get an instance of the logger
+LOGGER = logging.getLogger(__name__)
+
+# Instantiate the JournaldLogHandler to hook into systemd
+JOURNALD_HANDLER = JournaldLogHandler()
+JOURNALD_HANDLER.setFormatter(logging.Formatter(
+    '[%(levelname)s] %(message)s'
+))
+
+# Add the journald handler to the current logger
+LOGGER.addHandler(JOURNALD_HANDLER)
+LOGGER.setLevel(logging.INFO)
+
+class Service(): # pylint: disable=too-few-public-methods
+    """
+    Launch an infinite loop
+    """
+    def __init__(self):
+
+        duration = 0
+
+        while True:
+            time.sleep(60)
+            duration += 60
+            LOGGER.info("Total duration: %s", str(duration))
+            # will failed after 4 minutes
+            if duration > 240:
+                sys.exit(1)
+
+if __name__ == '__main__':
+
+    LOGGER.info("Starting the service")
+    Service()
+```
+
+Wir beginnen damit, die notwendigen Variablen zu instanziieren, um Logs dem Journal zu senden. Das Skript startet dann eine unendliche Schleife und pausiert für 60 Sekunden (was das Minimum einer Cron-Ausführung ist, so dass wir unter diese Grenze gehen können).
+
+!!! note "Anmerkung"
+
+    Der Autor benutzt dieses Skript in einer fortgeschrittenen Form, die kontinuierlich eine Datenbank abfragt und Jobs basierend auf den über die Rundeck API abgerufenen Informationen ausführt
+
+## Integration in Systemd
+
+Jetzt, da wir ein Skript haben, das als Grundlage für Ihre Phantasie dienen kann, können wir es als System-Dienst installieren.
+
+Lass uns die Datei `my_service.service` erstellen und sie nach `/etc/systemd/system/` kopieren.
+
+```
+[Unit]
+Description=My Service
+After=multi-user.target
+
+[Service]
+Type=simple
+Restart=always
+ExecStart=/usr/bin/python3 my_service.py
+WorkingDirectory=/opt/my_service/
+
+StandardOutput=syslog
+StandardError=syslog
+SyslogIdentifier=my_service
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Wie Sie sehen können, wird das Skript von `/opt/my_service/` gestartet. Denken Sie daran, den Pfad an Ihr Skript und die Syslog-Kennung anzupassen.
+
+Neuen Dienst aktivieren und starten:
+
+```
+shell > sudo systemctl daemon-reload
+shell > sudo systemctl enable my_service.service
+shell > sudo systemctl start my_service.service
+```
+
+## Tests
+
+Wir können die Protokolle jetzt via journalctl anzeigen:
+
+```
+shell > journalctl -f -u my_service
+oct. 14 11:07:48 rocky8 systemd[1]: Started My Service.
+oct. 14 11:07:49 rocky8 __main__[270267]: [INFO] Starting the service
+oct. 14 11:08:49 rocky8 __main__[270267]: [INFO] Total duration: 60
+oct. 14 11:09:49 rocky8 __main__[270267]: [INFO] Total duration: 120
+```
+
+Lass uns nun sehen, was passiert, wenn das Skript abgestürzt ist:
+
+```
+shell > ps -elf | grep my_service
+4 S root      270267       1  0  80   0 - 82385 -      11:07 ?        00:00:00 /usr/bin/python3 my_service.py
+shell > sudo kill -9 270267
+```
+
+```
+shell > journalctl -f -u my_service
+oct. 14 11:10:49 rocky8 __main__[270267]: [INFO] Total duration: 180
+oct. 14 11:11:49 rocky8 __main__[270267]: [INFO] Total duration: 240
+oct. 14 11:12:19 rocky8 systemd[1]: my_service.service: Main process exited, code=killed, status=9/KILL
+oct. 14 11:12:19 rocky8 systemd[1]: my_service.service: Failed with result 'signal'.
+oct. 14 11:12:19 rocky8 systemd[1]: my_service.service: Service RestartSec=100ms expired, scheduling restart.
+oct. 14 11:12:19 rocky8 systemd[1]: my_service.service: Scheduled restart job, restart counter is at 1.
+oct. 14 11:12:19 rocky8 systemd[1]: Stopped My Service.
+oct. 14 11:12:19 rocky8 systemd[1]: Started My Service.
+oct. 14 11:12:19 rocky8 __main__[270863]: [INFO] Starting the service
+```
+
+Wir können auch 5 Minuten warten, bis das Skript selbst abstürzt (entfernen Sie dies für Ihre Produktion):
+
+```
+oct. 14 11:16:02 rocky8 systemd[1]: Started My Service.
+oct. 14 11:16:03 rocky8 __main__[271507]: [INFO] Starting the service
+oct. 14 11:17:03 rocky8 __main__[271507]: [INFO] Total duration: 60
+oct. 14 11:18:03 rocky8 __main__[271507]: [INFO] Total duration: 120
+oct. 14 11:19:03 rocky8 __main__[271507]: [INFO] Total duration: 180
+oct. 14 11:20:03 rocky8 __main__[271507]: [INFO] Total duration: 240
+oct. 14 11:21:03 rocky8 __main__[271507]: [INFO] Total duration: 300
+oct. 14 11:21:03 rocky8 systemd[1]: my_service.service: Main process exited, code=exited, status=1/FAILURE
+oct. 14 11:21:03 rocky8 systemd[1]: my_service.service: Failed with result 'exit-code'.
+oct. 14 11:21:03 rocky8 systemd[1]: my_service.service: Service RestartSec=100ms expired, scheduling restart.
+oct. 14 11:21:03 rocky8 systemd[1]: my_service.service: Scheduled restart job, restart counter is at 1.
+oct. 14 11:21:03 rocky8 systemd[1]: Stopped My Service.
+oct. 14 11:21:03 rocky8 systemd[1]: Started My Service.
+oct. 14 11:21:03 rocky8 __main__[271993]: [INFO] Starting the service
+```
+
+Wie Sie sehen können, ist die Neustartfunktion von systemd sehr nützlich.
+
+## Fazit
+
+`systemd` und `journald` stellen uns die Werkzeuge zur Verfügung, um robuste und leistungsstarke Skripte so einfach wie möglich zu machen, dass sie unsere alten zuverlässigen Crontab-Skripte ersetzen.
+
+Wir hoffen, dass dieser Vorschlag für Sie nützlich sein wird.

docs/gemstones/view_kernel_conf.de.md

@@ -0,0 +1,158 @@
+---
+title: Aktuelle Kernelkonfiguration anzeigen
+author: David Hensley
+contributors: Steven Spencer
+tested_with: 8.5
+tags:
+  - kernel
+  - config
+  - modules
+  - kmod
+---
+
+# Aktuelle Kernelkonfiguration anzeigen
+
+Der Linux-Kernel speichert laufende Kernelinformationen an zwei Stellen durch spezielle Dateisysteme: ([Eine Zusammenfassung von ihnen](https://www.landoflinux.com/linux_procfs_sysfs.html))
+
+  - Der ältere [procfs](https://man7.org/linux/man-pages/man5/procfs.5.html), der `/proc` mountet (vergewissern Sie sich über `mount -l -t proc`)
+  - Die neueren [sysfs](https://man7.org/linux/man-pages/man5/sysfs.5.html) die `/sys` mountet (überprüfen mit `mount -l -t sysfs`)
+
+!!! warning "Warnhinweis"
+
+    Seien Sie vorsichtig, wenn Sie die hier genannten Dateien untersuchen, Änderungen können das Verhalten des aktuellen Kernels ändern!
+
+
+Diese beiden Schnittstellen erlauben es Ihnen, die Parameter des aktuell laufenden Kernels anzuzeigen und zu ändern.
+
+Beachten Sie, dass, wenn Sie auf einigen Dateien ein [`ls`](https://man7.org/linux/man-pages/man1/ls.1.html) -l ausführen, wird von diesen Dateien die Länge „0“ angezeigt, wenn Sie sie jedoch mit [`cat`](https://man7.org/linux/man-pages/man1/cat.1.html), enthalten sie tatsächlich Daten. Die meisten davon sind ASCII und editierbar, einige sind jedoch binär. In beiden Fällen Befehle wie [`file`](https://man7.org/linux/man-pages/man1/file.1.html) oder <a href= „https://man7.org/linux/man-pages/man2/lstat.2.html“>`stat`</a> gibt normalerweise nur „leere Datei“ oder „0“ für Längen zurück, obwohl sie Ihnen andere Informationen anzeigen.
+
+Bevorzugte und Standardprogramme für die Interaktion mit diesen Funktionen sind [`lsmod`](https://man7.org/linux/man-pages/man8/lsmod.8.html), [`modinfo`](https://man7.org/linux/man-pages/man8/modinfo.8.html), und [`sysctl`](https://man7.org/linux/man-pages/man8/sysctl.8.html), unter anderem.
+
+```bash
+sysctl -a | grep -i <keyword>
+```
+
+```bash
+lsmod | grep -i <keyword>
+```
+
+```bash
+modinfo <module>
+```
+
+Ihre aktuelle "Kernel-Release" Version ist:
+
+`uname -r` und ersetze den Rückgabewert in Befehlen durch `$(uname -r)`
+
+RHEL und Derivate (Fedora, CentOS Stream, Scientific Linux, RockyLinux, Almalinux, et. al.) speichert auch die Konfiguration, die für bootbare installierte Kernel im Verzeichnis `/boot` verwendet wird, das Grub2 als ASCII-Dateien verwendet:
+
+```bash
+/boot/config-<kernel-release>
+```
+
+Um die aktuell laufende Kernelkonfiguration auf einen bestimmten Wert zu überprüfen:
+
+```bash
+cat /boot/config-$(uname -r) | grep -i <keyword>
+```
+
+Ergebnisse werden angezeigt:
+
+  - "=m" wenn als Kernelmodul kompiliert
+  - "=y" wenn statisch in den Kernel kompiliert
+  - "is not set", wenn diese Einstellung auskommentiert wurde
+  - numerischer Wert
+  - String-Wert
+
+Einige Distributionen, wie Gentoo und Arch, verwenden das `configs` Kernelmodul um `/proc/config.gz` standardmäßig bereitzustellen:
+
+```bash
+zcat /proc/config.gz | grep -i <keyword>
+zgrep <keyword> /proc/config.gz
+```
+
+Für jede Distribution, wenn Ihr laufender Kernel sowohl `CONFIG_IKCONFIG` als auch `CONFIG_IKCONFIG_PROC` gesetzt hat und wenn
+
+```bash
+ls -lh /sys/module/configs
+```
+
+existiert und ist ausführbar (durchsuchbar bei einem Verzeichnis), dann können Sie `/proc/config.gz` mit diesem Befehl generieren, wenn er nicht vorhanden ist:
+
+```bash
+modprobe configs
+```
+
+!!! note "aktivierte Repos"
+
+    Dieses Dokument deckt derzeit keine Kernel-Pakete ab, die möglicherweise von Nicht-Standard-Repos stammen, wie z.B.:
+
+    appstream-debug, appstream-source, baseos-debug, baseos-source oder devel
+
+
+Die `kernel-devel` Pakete installieren die Konfigurationsdatei, die verwendet wird, um jedes installierte Standard-Kernel-Paket als ASCII-Datei an der folgenden Stelle zu kompilieren:
+
+```bash
+/usr/src/kernels/<kernel-release>/.config
+```
+
+Diese Datei wird häufiger durch einen symlinked Pfad aufgerufen, der von den `kernel-core` Paketen bereitgestellt wird:
+
+```bash
+/lib/modules/<kernel-release>/build/ -> /usr/src/kernels/<kernel-release>/
+```
+
+Wenn Sie `kernel-debug-devel` Pakete installiert haben, haben Sie auch dieses Verzeichnis:
+
+```bash
+ /usr/src/kernels/<kernel-release>+debug/
+```
+
+Sie können in jedem der folgenden Informationen zu den Konfigurationswerten durchsuchen, die zum Erstellen eines installierten Kernels verwendet werden:
+
+```bash
+/lib/modules/<kernel-release>/config
+/lib/modules/<kernel-release>/build/.config
+/usr/src/kernels/<kernel-release>/.config
+/usr/src/kernels/<kernel-release>+debug/.config
+```
+
+Konfigurierte Module für den aktuell laufenden Kernel, ob kompiliert wie eingebaut (i.e., statisch in den Kernel selbst) oder ein ladbares Modul, werden von Unterverzeichnissen mit dem Namen des Moduls aufgelistet:
+
+```bash
+/sys/module/
+```
+
+Für jede installierte Kernel-Veröffentlichung können Sie diese Dateien überprüfen, um zu sehen, welche Werte in diesem Kernel kompiliert wurden, und welche Version von [GCC](https://man7.org/linux/man-pages/man1/gcc.1.html) verwendet wurde, um es zu kompilieren:
+
+```bash
+cat /lib/modules/$(uname -r)/config | grep -i <keyword>
+```
+
+```bash
+cat /lib/modules/$(uname -r)/build/.config | grep -i <keyword>
+```
+
+```bash
+cat /usr/src/kernels/$(uname -r)/.config | grep -i <keyword>
+```
+
+```bash
+cat /usr/src/kernels/$(uname -r)+debug/.config | grep -i <keyword>
+```
+
+```bash
+ls -lh /sys/module/ | grep -i <keyword>
+```
+
+Sie können in der Datei nach Abhängigkeiten des Kernelmoduls suchen:
+
+```bash
+/lib/modules/<kernel-release>/modules.dep
+```
+
+aber es ist einfacher, die Ausgabe des Feldes "Used-by" in [`lsmod`](https://man7.org/linux/man-pages/man8/lsmod.8.html) zu lesen oder zu parsen.
+
+## Referenzen:
+
+[depmod](https://man7.org/linux/man-pages/man8/depmod.8.html), [ls](https://man7.org/linux/man-pages/man1/ls.1.html), [lsmod](https://man7.org/linux/man-pages/man8/lsmod.8.html), [modinfo](https://man7.org/linux/man-pages/man8/modinfo.8.html), [modprobe](https://man7.org/linux/man-pages/man8/modprobe.8.html), [modules.dep](https://man7.org/linux/man-pages/man5/modules.dep.5.html), [namespaces](https://man7.org/linux/man-pages/man7/namespaces.7.html), [procfs](https://man7.org/linux/man-pages/man5/procfs.5.html), [sysctl](https://man7.org/linux/man-pages/man8/sysctl.8.html), [sysfs](https://man7.org/linux/man-pages/man5/sysfs.5.html), [uname](https://man7.org/linux/man-pages/man8/uname26.8.html)