Aggiunta di systemd

dispensa/Makefile

@@ -2,7 +2,7 @@ PDFDIR=pdf
 MDS=$(wildcard *.md)
 PDFS=$(patsubst %.md,$(PDFDIR)/%.pdf, $(MDS))
 TEMPLATE_ARGS=-V titlepage=true -V titlepage-text-color=000000 -V titlepage-color=B2DFEE -V titlepage-background=./background.pdf
-PANDOC_ARGS=-N -V lang=it --template default.latex  -s
+PANDOC_ARGS=-N -V lang=it --template default.latex  -s --toc
 
 .PHONY : all
 

dispensa/cybersecurity_linux.md

@@ -207,10 +207,10 @@ separato, ad esempio in `~/.config/tmux/split.conf`.
 new -s splitted_session # crea una nuova sessione
 
 selectp -t 0 # seleziona il primo pannello
-splitw -h -p 50 # divide il pannello corrente orizzontalmente in due parti
+splitw -h # divide il pannello corrente orizzontalmente in due parti
 
 selectp -t 1 # seleziona il nuovo secondo pannello
-splitw -v -p 50 # divide il pannello corrente verticalmente in due parti
+splitw -v # divide il pannello corrente verticalmente in due parti
 selectp -t 0 # torna al primo pannello
 ```
 
@@ -233,6 +233,7 @@ simile a quello riportato sotto.
 |    |    |
 -----------
 |         | 
+|         |
 -----------
 ```
 # Secure Shell
@@ -366,16 +367,16 @@ mosh utente@host -- tmux
 
 ## Riferimenti
 
-[1] https://www.ssh.com/academy/ssh/copy-id
+- [1] https://www.ssh.com/academy/ssh/copy-id
-[2] https://www.techtarget.com/searchsecurity/tutorial/Use-ssh-keygen-to-create-SSH-key-pairs-and-more
+- [2] https://www.techtarget.com/searchsecurity/tutorial/Use-ssh-keygen-to-create-SSH-key-pairs-and-more
-[3] https://alexhost.com/faq/using-ssh-copy-id-ssh-keygen-commands-in-linux/
+- [3] https://alexhost.com/faq/using-ssh-copy-id-ssh-keygen-commands-in-linux/
-[4] https://www.ssh.com/academy/ssh/keygen
+- [4] https://www.ssh.com/academy/ssh/keygen
-[5] https://www.digitalocean.com/community/tutorials/ssh-essentials-working-with-ssh-servers-clients-and-keys
+- [5] https://www.digitalocean.com/community/tutorials/ssh-essentials-working-with-ssh-servers-clients-and-keys
-[6] https://docs.oracle.com/en/operating-systems/oracle-linux/openssh/openssh-WorkingwithSSHKeyPairs.html
+- [6] https://docs.oracle.com/en/operating-systems/oracle-linux/openssh/openssh-WorkingwithSSHKeyPairs.html
-[7] https://www.redhat.com/sysadmin/configure-ssh-keygen
+- [7] https://www.redhat.com/sysadmin/configure-ssh-keygen
-[8] https://www.digitalocean.com/community/tutorials/how-to-configure-ssh-key-based-authentication-on-a-linux-server
+- [8] https://www.digitalocean.com/community/tutorials/how-to-configure-ssh-key-based-authentication-on-a-linux-server
-[9] https://www.thegeekstuff.com/2008/11/3-steps-to-perform-ssh-login-without-password-using-ssh-keygen-ssh-copy-id/
+- [9] https://www.thegeekstuff.com/2008/11/3-steps-to-perform-ssh-login-without-password-using-ssh-keygen-ssh-copy-id/
-[10] https://mosh.org/
+- [10] https://mosh.org/
 
 ### Esercizio
 
@@ -391,3 +392,495 @@ suddivisione della finestra. L'accesso via ssh dev'essere senza password.
 Effettuando un ssh da locale verso locale, una volta effettuato
 l'acccesso, la sessione tmux dev'essere automaticamente avviata.
 
+# Introduzione a `systemd`
+
+Systemd è un sistema di inizializzazione e gestione dei servizi per
+Linux, che sostituisce il tradizionale SysVinit. È progettato per
+essere il punto di partenza per il sistema operativo, gestendo l'avvio
+dei servizi, la gestione delle sessioni utente, la configurazione di
+rete e molto altro. In Arch Linux, systemd è l'impostazione
+predefinita e viene utilizzato per gestire l'avvio del sistema e i
+servizi.
+
+Systemd utilizza i "target" per raggruppare le unità insieme tramite
+dipendenze e come punti di sincronizzazione standardizzati. Questi
+servono uno scopo simile ai runlevel di SysVinit ma agiscono
+leggermente diversamente. Ogni target è nominato invece di essere
+numerato e serve uno scopo specifico con la possibilità di avere più
+attivi allo stesso tempo.
+
+## Riferimenti
+
+- [1] https://wiki.archlinux.org/title/systemd
+- [2] https://bbs.archlinux.org/viewtopic.php?id=214188
+- [3] https://www.reddit.com/r/archlinux/comments/4lzxs3/why_did_archlinux_embrace_systemd/
+- [4] https://stackoverflow.com/questions/10297969/systemd-on-arch-linux
+- [5] https://wiki.archlinux.org/title/Systemd/User
+- [6] https://superuser.com/questions/1025091/start-a-systemd-user-service-at-boot
+- [7] https://halestrom.net/darksleep/blog/005_distrohop_p1/
+- [8] https://www.youtube.com/watch?v=M51mbTRyL6U
+
+## Gestione di `systemd`
+
+`systemctl` è il comando principale utilizzato per esaminare e
+controllare lo stato di `systemd` in un sistema Arch Linux. Questo
+strumento è fondamentale per la gestione dei servizi e delle unità del
+sistema. Ecco alcuni esempi di utilizzo di `systemctl`:
+
+### Avvio e Arresto di Servizi
+
+Per avviare un servizio, ad esempio `sshd`, si utilizza:
+
+```bash
+sudo systemctl start sshd
+```
+
+Per fermare lo stesso servizio:
+
+```bash
+sudo systemctl stop sshd
+```
+
+### Abilitazione e Disabilitazione di Servizi all'Avvio
+
+Per abilitare un servizio all'avvio del sistema:
+
+```bash
+sudo systemctl enable sshd
+```
+
+Per disabilitare l'avvio automatico del servizio:
+
+```bash
+sudo systemctl disable sshd
+```
+
+### Controllo dello Stato dei Servizi
+
+Per controllare lo stato corrente di un servizio:
+
+```bash
+systemctl status sshd
+```
+
+### Gestione dei Target
+
+I target in systemd rappresentano stati di sistema o configurazioni
+specifiche. Per vedere il target corrente:
+
+```bash
+systemctl get-default
+```
+
+Per cambiare il target di default al prossimo avvio:
+
+```bash
+sudo systemctl set-default multi-user.target
+```
+
+### Utilizzo di systemctl su una macchina remota
+
+È possibile utilizzare `systemctl` per controllare un'istanza di
+`systemd` su una macchina remota tramite SSH:
+
+```bash
+systemctl -H user@host status sshd
+```
+
+### Diagnostica dei servizi
+
+Per visualizzare i servizi che hanno manifestato problemi alla partenza:
+
+```bash
+systemctl --state=failed
+```
+
+### Riferimenti
+
+- [1] https://wiki.archlinux.org/title/systemd
+- [2] https://man.archlinux.org/man/systemctl.1.en
+- [3] https://wiki.archlinux.org/title/Systemd/User
+- [4] https://bbs.archlinux.org/viewtopic.php?id=260255
+- [5] https://gist.github.com/bugyt/c149de4ba5b1ea79a077
+- [6] https://superuser.com/questions/1025091/start-a-systemd-user-service-at-boot
+- [7] https://wiki.archlinux.org/title/systemd/Timers
+- [8] https://www.reddit.com/r/linux4noobs/comments/18fklyi/using_systemd_to_automatically_run_commands_on/
+- [9] https://stackoverflow.com/questions/10297969/systemd-on-arch-linux
+- [10] https://man.archlinux.org/man/systemd.unit.5.en
+
+## Utilizzo di `journalctl`
+
+`journalctl` è uno strumento potente per la gestione dei log in
+sistemi che utilizzano `systemd`, come Arch Linux. Questo strumento
+consente di visualizzare, filtrare e analizzare i messaggi di log
+generati dal sistema e dai servizi. Ecco alcuni esempi notevoli di
+utilizzo di `journalctl`:
+
+### Visualizzazione dei Log
+
+Per visualizzare tutti i messaggi di log:
+
+```bash
+journalctl
+```
+
+### Filtraggio dei Messaggi di Log
+
+- Per visualizzare tutti i messaggi che corrispondono a un pattern specifico:
+
+```bash
+journalctl --grep=PATTERN
+```
+
+- Per visualizzare tutti i messaggi dal boot corrente:
+
+```bash
+journalctl -b
+```
+
+- Per visualizzare i messaggi dal boot precedente:
+
+```bash
+journalctl -b -1
+```
+
+- Per visualizzare i messaggi da una data specifica:
+
+```bash
+journalctl --since="2022-01-01"
+```
+
+- Per visualizzare i messaggi degli ultimi 20 minuti:
+
+```bash
+journalctl --since "20 min ago"
+```
+
+### Seguire i nuovi messaggi
+
+Per seguire i nuovi messaggi di log in tempo reale:
+
+```bash
+journalctl -f
+```
+
+### Visualizzazione per Unità di Servizio
+
+- Per visualizzare tutti i messaggi per un servizio specifico, ad esempio `httpd`:
+
+```bash
+journalctl -u httpd.service
+```
+
+- Per visualizzare i messaggi di log per un'unità utente specifica, ad esempio `dbus`:
+
+```bash
+journalctl --user -u dbus
+```
+
+### Visualizzazione dei Messaggi di Errore
+
+Per visualizzare solo i messaggi di errore, critico e allarme:
+
+```bash
+journalctl -p err..alert
+```
+
+### Visualizzazione del Buffer del Kernel
+
+Per visualizzare i messaggi del buffer del kernel:
+
+```bash
+journalctl -k
+```
+
+### Visualizzazione dei Log in un File Specifico
+
+Se il directory dei log contiene una grande quantità di dati di log,
+`journalctl` può richiedere diversi minuti per filtrare l'output. Può
+essere significativamente velocizzato utilizzando l'opzione `--file`
+per forzare `journalctl` a cercare solo nel journal più recente:
+
+```bash
+journalctl --file /var/log/journal/*/system.journal -f
+```
+
+### Esercizio
+
+Utilizzando il terminal multiplexer `tmux` suddividi il terminale in
+due pannelli. Nel pannello di sinistra esegui `journalctl` in modo da
+visualizzare i log del servizio `sshd`. Nel pannello di destra
+connettiti al server ssh in esecuzione sulla tua macchina. Qualora il
+servizio non fosse in esecuzione, fallo partire utilizzando
+`systemctl`. Salva una porzione dei log in un file di testo come prova
+di aver svolto l'esercizio.
+
+### Riferimenti
+
+- [1] https://wiki.archlinux.org/title/Systemd/Journal
+- [2] https://man.archlinux.org/man/journalctl.1.en
+- [3] https://www.debugpoint.com/systemd-journalctl/
+- [4] https://serverfault.com/questions/721963/how-do-you-use-systemds-journalctl-patterns
+- [5] https://www.loggly.com/ultimate-guide/using-journalctl/
+- [6] https://bbs.archlinux.org/viewtopic.php?id=208480
+- [7] https://unix.stackexchange.com/questions/199988/how-to-inspect-systemd-journal-files-directly
+- [8] https://kb.adamsdesk.com/operating_system/arch_linux_quick_reference_commands/
+- [9] https://www.reddit.com/r/archlinux/comments/lskkdt/always_check_your_journalctl_when_weird_problems/
+- [10] https://wiki.archlinux.org/title/systemd
+
+## Timer di `systemd`
+
+`systemd/Timers` in Arch Linux sono unità di sistema che permettono di
+pianificare l'esecuzione di servizi o eventi in base a specifici
+intervalli di tempo o eventi di sistema. Questi timer possono essere
+utilizzati come alternativa a `cron` per la pianificazione di
+attività. I timer di `systemd` supportano eventi di tempo calendario e
+monotonici, e possono essere eseguiti in modo asincrono.
+
+### Tipi di Timer
+
+- **Timer Realtime (o Wallclock Timers)**: Attivano un evento in base
+  a un calendario, similmente a come funzionano i cronjobs. Utilizzano
+  l'opzione `OnCalendar=` per definire l'evento.
+- **Timer Monotonici**: Attivano dopo un intervallo di tempo relativo
+  a un punto di partenza variabile. Si fermano se il computer viene
+  sospeso temporaneamente o spento. Esempi comuni includono
+  `OnBootSec` e `OnUnitActiveSec` [1].
+
+### Creazione di un Timer
+
+Per creare un timer, è necessario creare un file di unità con
+estensione `.timer` che descriva quando e come il timer deve attivare
+un'unità di servizio corrispondente. Ad esempio, per creare un timer
+che esegue un servizio ogni giorno alle 12:00, il file del timer
+potrebbe essere simile a questo:
+
+```ini
+[Unit]
+Description=Esegui il mio servizio giornaliero
+
+[Timer]
+OnCalendar=daily
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+```
+
+E il file del servizio corrispondente potrebbe essere:
+
+```ini
+[Unit]
+Description=Il mio servizio giornaliero
+
+[Service]
+ExecStart=/path/to/my-service
+```
+
+La sintassi `OnCalendar` in `systemd` è utilizzata per specificare
+quando un timer deve essere attivato, offrendo una maggiore
+flessibilità rispetto al formato cron tradizionale. La sintassi
+`OnCalendar` segue il formato `DOW YYYY-MM-DD HH:MM:SS`, dove `DOW` è
+il giorno della settimana (opzionale), e gli altri campi possono
+utilizzare un asterisco (`*`) per corrispondere a qualsiasi valore per
+quella posizione. Se l'ora non è specificata, viene assunta come
+`00:00:00`. Se la data non è specificata ma l'ora è, il prossimo match
+potrebbe essere oggi o domani, a seconda dell'ora corrente [5].
+
+Ecco alcuni esempi di come utilizzare `OnCalendar`:
+
+- Per eseguire un evento ogni giorno alle 10:00, puoi usare:
+ ```ini
+ OnCalendar=*-*-* 10:00:00
+ ```
+- Per eseguire un evento ogni anno il 15 ottobre alle 17:48:00, puoi usare:
+ ```ini
+ OnCalendar=*-10-15 17:48:00
+ ```
+- Per eseguire un evento ogni anno il 1 gennaio alle 00:00:00, puoi usare:
+ ```ini
+ OnCalendar=*-01-01 00:00:00
+ ```
+- Puoi anche combinare questi campi per specificare eventi più precisi. Ad esempio, per eseguire un evento ogni mercoledì alle 17:48:00, puoi usare:
+ ```ini
+ OnCalendar=Wed *-*-* 17:48:00
+ ```
+ Questo può anche essere scritto come:
+ ```ini
+ OnCalendar=3Wed, 17:48
+ ```
+
+Sì, `OnCalendar` in `systemd` ammette alias come "daily" per
+specificare intervalli di tempo più comuni. Questo alias può essere
+utilizzato per semplificare la pianificazione di eventi ricorrenti. Ad
+esempio, per eseguire un evento ogni giorno, puoi semplicemente
+utilizzare:
+
+```ini
+OnCalendar=daily
+```
+
+Questo è equivalente a specificare l'evento per ogni giorno alle
+00:00:00. Altri alias comuni includono "weekly", "monthly", "yearly",
+e specifici giorni della settimana come "Mon", "Tue", "Wed", ecc.
+
+Per esempio, per eseguire un evento ogni lunedì alle 10:00, potresti
+usare:
+
+```ini
+OnCalendar=Mon 10:00:00
+```
+
+O per eseguire un evento ogni settimana, potresti usare:
+
+```ini
+OnCalendar=weekly
+```
+
+Questi alias rendono più semplice e leggibile la configurazione dei
+timer in `systemd`, specialmente per intervalli di tempo ricorrenti
+comuni [4].
+
+`systemd` offre strumenti come `systemd-analyze calendar` per validare
+e esaminare gli eventi del calendario utilizzati in
+un'espressione. Questo strumento analizza un'espressione di evento del
+calendario e fornisce la forma normalizzata e altre informazioni, come
+la data e l'ora del prossimo "elapso" (cioè, corrispondenza) e la
+quantità approssimativa di tempo prima che raggiunga il tempo di
+attivazione [5].
+
+### Gestione dei Timer
+
+Per abilitare e avviare un timer, utilizza i comandi `systemctl
+enable` e `systemctl start`, ricordando di aggiungere il suffisso
+`.timer` al nome dell'unità. Per visualizzare tutti i timer attivi,
+esegui:
+
+```bash
+systemctl list-timers
+```
+
+Per elencare tutti i timer (inclusi quelli inattivi), usa:
+
+```bash
+systemctl list-timers --all
+```
+
+Se un timer si sincronizza, potrebbe essere utile eliminare il suo
+file `stamp-*` in `/var/lib/systemd/timers` (o
+`~/.local/share/systemd/` nel caso dei timer utente). Questi file di
+lunghezza zero contrassegnano l'ultima volta in cui ogni timer è stato
+eseguito. Se vengono eliminati, verranno ricostruiti al prossimo avvio
+del loro timer [1].
+
+### Esempi di Utilizzo
+
+Per impostare un timer che effettui il backup della cartella home ogni
+mattina alle 10:00, e che si assicuri che il backup venga effettuato
+anche se il PC è spento, segui questi passaggi. Questo esempio
+utilizza un timer e un servizio di `systemd` per eseguire il backup.
+
+#### Creazione del Servizio
+
+Prima di tutto, crea un file di servizio che eseguirà il backup. Puoi
+chiamarlo `home-backup.service` e metterlo in `/etc/systemd/system/`
+per un backup a livello di sistema, o in `~/.config/systemd/user/` per
+un backup a livello utente.
+
+```ini
+[Unit]
+Description=Backup della cartella home
+
+[Service]
+Type=oneshot
+ExecStart=/path/to/your/backup-script.sh
+```
+
+Assicurati che lo script di backup (`/path/to/your/backup-script.sh`)
+sia eseguibile e che contenga i comandi necessari per il backup.
+
+#### Creazione del Timer
+
+Successivamente, crea un file di timer che attiverà il servizio sopra
+ogni mattina alle 10:00. Anche questo file va in
+`/etc/systemd/system/` per un backup a livello di sistema, o in
+`~/.config/systemd/user/` per un backup a livello utente. Chiamalo
+`home-backup.timer`.
+
+```ini
+[Unit]
+Description=Timer per il backup della cartella home
+
+[Timer]
+OnCalendar=*-*-* 10:00:00
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+```
+
+L'opzione `Persistent=true` assicura che il timer si attivi non appena
+il sistema è avviato, anche se il tempo previsto per l'esecuzione è
+passato.
+
+#### Abilitazione e Avvio del Timer
+
+Per abilitare il timer, esegui:
+
+```bash
+sudo systemctl enable home-backup.timer
+```
+
+E per avviare il timer immediatamente, senza doverlo abilitare:
+
+```bash
+sudo systemctl start home-backup.timer
+```
+
+Se stai creando un timer a livello utente, sostituisci `sudo` con
+`--user` nei comandi sopra.
+
+#### Verifica
+
+Per verificare che il timer sia attivo e pianificato correttamente,
+puoi usare:
+
+```bash
+systemctl list-timers
+```
+
+Questo mostrerà tutti i timer attivi, inclusi quelli pianificati per
+il futuro.
+
+#### Considerazioni
+
+- Assicurati che lo script di backup sia configurato correttamente e
+  che abbia i permessi necessari per eseguire il backup.
+- Se il tuo sistema è spento quando il timer dovrebbe attivarsi, il
+  timer si attiverà al prossimo avvio del sistema, grazie all'opzione
+  `Persistent=true`.
+- Ricorda che i timer a livello utente richiedono che l'utente sia
+  loggato per funzionare, a meno che non sia configurato per "linger"
+  con `loginctl enable-linger $USER`.
+
+Questo metodo ti permette di pianificare il backup della cartella home
+ogni mattina alle 10:00, garantendo che il backup venga effettuato
+anche se il PC è spento al momento previsto per il backup [1].
+
+### Riferimenti
+
+- [1] https://wiki.archlinux.org/title/Systemd/Timers
+- [2] https://linuxconfig.org/how-to-schedule-tasks-with-systemd-timers-in-linux
+- [3] https://www.airplane.dev/blog/systemd-timer-how-to-schedule-tasks-with-systemd
+- [4] https://man.archlinux.org/man/systemd.timer.5
+- [5] https://opensource.com/article/20/7/systemd-timers
+- [6] https://wiki.archlinux.org/title/Systemd
+- [7] https://lloydrochester.com/post/unix/systemd-timer-example/
+- [8] https://unix.stackexchange.com/questions/704109/configure-systemd-timer-to-run-every-hour-after-first-run
+- [9] https://linuxman.co/linux-desktop/easily-automate-maintenance-in-arch-linux-with-the-power-of-systemd-timers/
+- [10] https://www.fosslinux.com/48317/scheduling-tasks-systemd-timers-linux.htm
+- [11] https://www.binaryte.com/blog/systemd-timers-tutorial-for-scheduling-tasks
+- [12] https://www.learnlinux.tv/automate-your-tasks-with-systemd-timers-a-step-by-step-guide/
+- [13] https://blog.devgenius.io/devops-in-linux-systemd-timer-4e95f57b6d71
+- [14] https://dashdash.io/5/systemd.timer
+- [15] https://techviewleo.com/configuring-cron-jobs-in-linux-using-systemd-timers/