knowledgebase/pages/Amministrazione Sistemi Linux.md at 8475988bb7375d403cb2dfe184543fe48c64b720

andrea/knowledgebase

Fork 0

Andrea Fazzi 704ab5e8f7 Auto saved by Logseq

2024-10-16 10:37:12 +02:00

30 KiB

Raw Blame History

{{renderer :tocgen2}}
Lezione n. 1 - Presentazione del corso e test d'ingresso (3 ore)
- Presentazione del docente e del corso
- Somministrazione test d'ingresso
- Discussione risultati del test e correzione

Lezione n .2 - Installazione di Debian11 su VirtualBox (4 ore)

Terminare correzione test d'ingresso

Installare Debian su VirtualBox

Breve presentazione di VirtualBox

Licenza GPLv2

The VirtualBox base package contains the full VirtualBox source code 
and platform binaries and is licensed under the GNU General Public License,
version 2. You can distribute and modify the base package, provided 
that you distribute all modifications under the GPLv2 as well.

Installazione netinst

Configurare locale

Da interfaccia

Da linea di comando

setxkbmap -layout="it"
## oppure
sudo localectl set-keymap it
## oppure
sudo localectl set-x11-keymap it

Due parole sul comando sudo

A cosa serve

Verificare che l'utente attuale lo possa utilizzare

groups ## mostra i gruppi a cui appartiente l'utente

Diventare root
- ```
su - # inserire come password changeme
```

Aggiungere l'utente vboxuser al gruppo sudo

usermod -a -G sudo vboxuser # aggiunge l'utente vboxuser al gruppo sudo
reboot # riavvia la macchina

Modificare la password
- ```
passwd # Loozie
```

Gestire l'installazione dei pacchetti software

sudo apt update
sudo apt upgrade
sudo apt install nome_del_pacchetto

Primi passi con tmux
- Installare tmux
  - ```
  sudo apt install tmux
```
Modificare la passwd
Effettuare il logout

Installare tldr

sudo apt install python3-pip # installa il package manager di python
pip3 install tldr # usa il package manager di python per installare tldr
nano ~/.bashrc # aggiungere ~/.local/bin nel $PATH
source ~/.bashrc
tldr apt # provare il comando

Esercizio: creare un nuovo utente amministratore ed eliminare l'utente di default
- ```
sudo usermod --login andrea vboxuser
```

Lezione 3 - Networking parte 1 (4 0re)
- Installare neofetch
  - ```
  sudo apt install neofetch
  tldr neofetch ## sperimentare il comando dopo aver dato uno sguardo agli esempi
```
- Verificare le impostazioni di rete
  - ```
  ip --brief address
  tldr ip ## sperimentare con altre opzioni
```
- Impostare la modalità bridge in VirtualBox
- Eseguire il comando ping dall'host verso la macchina virtuale dopo aver recuperato l'IP della macchina
  - ```
  tldr ping
```
- Server http tramite uno script #linuxcommandline
  - Prerequisiti: sysstat
    - ```
    sudo apt install sysstat
```
- Script per mettere in ascolto un server http
  - ```
  #!/bin/bash
  
  while true;
    do echo -e "HTTP/1.1 200 OK\n\n$(iostat)" \
    | nc -l -k -pf 8080 -q 1; 
  done
```
  - Rendere lo script eseguibile
    - ```
    chmod +x httpd.sh
```
- Verificare che il server risponda ad una richiesta http
  - ```
  sudo apt install curl
  curl http://localhost:8008
```
  - Inviare una richiesta da un host esterno alla virtual machine
  - Terminare il processo con il comando killall
    - ```
    tldr killall
    killall httpd.sh
```
- Esercizio: modificare il server per mostrare l'output di un altro comando
- Modificare lo script in modo da visualizzare una pagina web
  - ```
  #!/bin/bash
  
  while true;
    do echo -e "HTTP/1.1 200 OK\n\n$(cat index.html)" \
    | nc -l -k -p 8080 -q 1; 
  done
```

Lezione n. 4 - Creazione di una pendrive #Ventoy (3 ore)

Scaricare Ventoy

wget https://github.com/ventoy/Ventoy/releases/download/v1.0.88/ventoy-1.0.88-linux.tar.gz

Estrarre un archivio targz (tarball)
- ```
tar xvzf ventoy-1.0.88-linux.tar.gz
```

Individuare il device relativo alla pendrive utilizzando il comando df

man df # documentazione ufficiale
tldr df # documentazione della community
df -h # mostra lo spazio libero sui device montati sul sistema (con visualizzazione human-readable)

Assicurarsi che il device non sia montato

sudo umount /dev/sdb1 # smonta la partizione 1 del device /dev/sdb

Creare una pendrive #ventoy
- ```
sudo ./Ventoy2Disk -i /dev/sdb
```
Creare un file "persistente" con #ventoy
- ```
sudo ./CreatePersistenceImg -s 5120
```

Dopo aver montato la pendrive e creato le cartelle ventoy e persistence

mv persistence.dat /media/vboxuser/Ventoy/persistence
sync # per effettuare il flush dell'I/O

Scaricare la iso di #PopOS

cd /media/vboxuser/Ventoy
wget https://iso.pop-os.org/22.04/amd64/intel/21/pop-os_22.04_amd64_intel_21.iso

Configurare #ventoy mediante il file di configurazione ventoy/ventoy.json

nano /media/vboxuser/Ventoy/ventoy/ventoy.json

{
    "persistence": [
        {
            "image": "pop-os_22.04_amd64_intel_21.iso",
            "backend": "/persistence/popos.dat"
        }
    ]
}

Usare il comando tree per verificare che tutti i file siano nel posto giusto

sudo apt install tree
tree /media/vboxuser/Ventoy
tldr tree # documentazione
man tree # documentazione

Lezione 5 - Installazione di un sistema GNU/Linux (4 ore)
- Terminare configurazione pendrive Ventoy
- Tentare di configurare i driver NVIDIA dalla live
- Altrimenti installare PopOS su disco rigido della macchina studente
- Come partizionare l'harddisk
  - Partizione di root /
    - Tipo ext4
  - Partizione di swap
    - Tipo linux-swap
  - Partizione di boot
    - Tipo fat32
- Prima configurazione del nuovo sistema #PopOS
  - Aggiornare il pacchetto localizzazione (regione, lingua)
  - Aumentare dimensione del carattere
  - Installare tmux
- Scaricare #logseq e dare qualche informazione sul suo utilizzo
  - ```
  wget https://github.com/logseq/logseq/releases/download/0.8.16/Logseq-linux-x64-0.8.16.AppImage
```

Lezione 6 - Sistemi di revisione (3 ore)

Introduzione a git
Creazione e configurazione di un account su codeberg.org

Revisionare i propri appunti con git

Inizializzare un repository

mkdir test_appunti && cd test_appunti
touch README.md
git init
git checkout -b main
git add README.md
git commit -m "First commit"
git remote add origin https://codeberg.org/andreafazzi/test_appunti.git
git push -u origin main

Effettuare la prima modifica (modificare il README.md)
- ```
nano README.md
```

Aggiungere un contenuto simile a questo:

# Appunti corso Amministrazione Sistemi Linux

Questo repository contiente gli appunti presi durante le lezioni del corso.

Verificare lo stato del repository
- ```
git status
```
Mostrare le differenze tra lo stato attuale e l'ultimo commit
- ```
git diff
```

Eseguire il commit della modifica

git commit -a -m 'Aggiunto primo contenuto file README'

Mostrare i log delle modifiche (storia del branch)
- ```
git log
```
Eseguire il push della modifica sul server git
- ```
git push -u origin main
```

Creazione chiave pubblica e upload su codeberg

ssh-keygen -t rsa
cat ~/.ssh/id_rsa.pub | xclip -selection clipboard

Lezione 7 - (4 ore)

Molto di questo materiale è stato tratto dal libro

Comandi di base per la navigazione all'interno del filesystem

Comando ls
- Serve per mostrare l'elenco dei file presenti nella cartella
- ```
ls -l # l'opzione -l mostra un elenco dettagliato
```
Comando pwd
- Serve per mostrare il percorso in cui ci si trova
- ```
pwd
```

Comando cd

Serve per cambiare directory

cd apps/ # entra nella cartella apps
cd .. # risale al livello di cartella precedente
cd ../.. # risale di due livelli
cd # senza argomenti cambia nella cartella $HOME
cd - # riporta nella cartella in cui ci si trovava precedentemente

Comando file
- Mostra il tipo di file
- ```
file /etc/fstab
```
Comando less
- Impagina file molto lunghi (facilita la lettura)
- ```
less /etc/passwd
```
Comando whereis
- Mostra il percorso in cui si trova un file
- ```
whereis ls # mostra dove si trova il comando ls
```

Comandi per la manipolazione di file o cartelle

Uso delle wildcards

* soddisfa qualsiasi carattere

ls *.html # mostra tutti i file che hanno come estensione html

? soddisfa un singolo carattere

ls foo? # mostra i file di nome foo+un_solo_carattere

[[:class]] soddisfa classi di caratteri

ls BACKUP.[0-9][0-9][0-9] # mostra i file che hanno come estensione un numero composto da 3 cifre

Il comando cp

Copia file o cartelle

cp *.html cartella_di_destinazione
cp -r nome_cartella nome_cartella_destinazione/ # copia ricorsivamente

Il comando mkdir

Crea una cartella

mkdir nome_cartella
mkdir -p nome_cartella/nome_sottocartella # crea la cartella e la sottocartella

Il comando mv

Muove un file o cartella oppure rinomina

mv vecchio_nome nuovo_nome
mv partenza destinazione

Il comando rm
- Rimuove file o cartelle
- ```
rm nome_file
rm -rf nome_cartella
```

Il comando ln

Crea link tra file e cartelle

ln -s nome_file nome_link # crea un link simbolico

Il comando lsof

Mostra l'utente che ha aperto un file

touch foo
tail -f foo
lsof foo # su un altro terminale o pane

Esercitarsi con il playground
- da pag. 34 a pag. 41 del libro

Un playground su server reali

SadServers
Soluzione 1
- ```
lsof nomelog
```

Soluzione 2

cat access.log | awk '{print $1}' | sort | uniq -c | sort -r | head -1 | awk '{print $2}' > highestip.txt
``` #awk #bash

Lezione 8 - Lavorare con i comandi e reindirizzamento dell'I/O (3 ore)
- Comando type
  - Identifica il tipo di comando (script, binario, etc)
  - ```
  type ls
  type cp
```
- Comando which
  - Mostra il percorso del comando
  - ```
  which cp
```
- Comandi per la guida in linea man, help, info, apropos
  - ```
  man cd
  help cd
  info cd
  apropos partition
  info coreutils
```
- ((63e9f40f-4ab2-4527-9f22-2ac906a41249))
- Utilizzo degli alias per incapsulare più comando dentro uno solo
  - Aggiungere il seguente alias all'interno di .bashrc
  - ```
  alias lss='ls -lt'
```
- Ricordarsi di ricaricare la configurazione
- Il comando alias mostra tutti gli alias attivi nel terminale
  - ```
  alias
  
  ## Output
  alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
  alias egrep='egrep --color=auto'
  alias fgrep='fgrep --color=auto'
  alias grep='grep --color=auto'
  alias l='ls -CF'
  alias la='ls -A'
  alias ll='ls -alF'
  alias ls='ls --color=auto'
  alias lss='ls -lt'
```
  - Gli alias possono essere inseriti dentro un file separato ~/.bash_aliases
- Reindirizzamento
  - Reindirizzamento di stdout verso un file
    - ```
    ls -l > ls-stdout.txt
    ls -l >> ls-stdout.txt
```
- Reindirizzamento di stderr verso un file
  - ```
  ls /foo 2> ls-stderr.txt
```
  - Reindirizzamento di entrambi stdout e stderr
    - ```
    ls /foo &> ls-stdout-stderr.txt
```
- Reindirizzamento utilizzando la | (pipe)
  - ```
  ls -l /usr/bin | less
```
  - Differenza tra > e | ((63e9ff48-7e2c-4799-9b74-e5f18aa09935))
  - Esempi
    - ls /bin /usr/bin | sort | less ls /bin /usr/bin | sort | uniq | less ls /bin /usr/bin | sort | uniq -d | less ls /bin /usr/bin | sort | uniq | wc -l
  - Analizzare i log prodotti da un server reale
    - Scaricare l'eseguibile dal NAS dell'Accademia
    - Avviare il server
    - Analizzare i log
      
      Calcolare il tempo medio di risposta (in microsecondi)
      
      cat server.log | awk '{print $9}' | sed -e 's/µs|//' | awk '{ total += $0; count++ } END { print total/count }'
Lezione 9 - Docker e preparazione al test finale (4 ore)
- Assegnare codici univoci per modulo online
- Installare #docker su sistemi Ubuntu based
  - Documentazione di riferimento
    - https://docs.docker.com/engine/install/ubuntu/
  - Prerequisiti
    - ```
    sudo apt-get update
    sudo apt-get install \
         ca-certificates \
         curl \
         gnupg \
         lsb-release
    sudo mkdir -m 0755 -p /etc/apt/keyrings
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
    echo \
      "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
      $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```
- Docker engine
  - ```
  sudo apt-get update
  sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```
  - Verifica dell'installazione
    - ```
    sudo docker run hello-world
```
- Eseguire docker come non-root
  - ```
   sudo groupadd docker
   sudo usermod -aG docker $USER
   docker run hello-world
```
- Preparare ambiente playground
  - Clonare il repository con le immagini Docker
    - ```
    git clone https://git.andreafazzi.eu/andrea/acp.git
```
- Costruire e lanciare il container
  - ```
  docker compose up --build
```
  - Eseguire accesso ssh al container (su un altro pane o window di tmux)
    - ```
    ssh -p 2222 test@localhost # password "test"
```
- Svolgere l'esercizio
  - Seguire il seguente URL e leggere le istruzioni riportate sul modulo
    - https://sondaggi.andreafazzi.eu/767197
  - Rimuovi il file autosave.tmp dalla cartella ~/playground/service1, e produci un checksum della lista dei file contenuti nella cartella dopo la rimozione.
  - Comunicare attraverso modulo il risultato di
    - ls | sha1sum
- Esercizi proposti durante la lezione
  - Esercizio 1
    - Installa il comando nano
    - Entra nella playground
    - Crea una cartella di nome docs all'interno della cartella service2
    - Crea un file foo.md e inserisci il seguente testo
      
      # Intestazione 1 Paragrafo.
    - La risposta da inviare si ottiene facendo
      
      cat foo.md | sha1sum
  - Esercizio 2
    - Muovi i file bar e biz dentro playground/service3/etc
    - Copia il file foo dentro playground/service3/etc/conf
Lezione 10 - Riflessioni sul test e ripasso (ore 2)
- Attività in cui gli studenti hanno riscontrato maggiori difficoltà
  - Gestione dei file nascosti
    - ```
    ls -a
    tree -a
    rm .*
```
- Copia di backup di una cartella
  - ```
  cp -r foo foo.bk
```
  - Reindirizzamento e uso del comando sort
    - ```
    ls /bin /usr/bin | sort | uniq
```
- Un'alternativa a less è more
- Utilizzo del comando grep
  - Serve per cercare pattern all'interno di stringhe
  - Riferimento su The Linux Command Line ((63f8410b-4adb-47aa-8091-00c675e1af7e))
  - Esempio
    - ls /bin /usr/bin | sort | uniq | grep zip
Lezione 11 - Utilizzare la linea di comando (3 ore)
- Command line editing
  - Movimenti del cursore ((63fd831a-57e8-4348-8f2c-8067839c0a23))
    - Comando clear
      - Ripulisce il terminale
      - clear
      - Oppure in alternativa combinazione di tasti CTRL+l
    - Comando history
      - Mostra la storia dei comandi eseguiti sul terminale
      - history history | grep clear # mostra tutte le volte che si è utilizzato il comando clear
    - Spostarsi sulla linea di comando
      - Per andare rispettivamente alla fine e all'inizio della linea si utilizza la combinazione CTRL+a e CTRL+e
      - Per spostarsi di parola in parola utilizza la combinazione ALT+f e ALT+b
  - Modifiche del testo ((63fe1156-ffb9-40ce-9737-a519ef32883b))
    - Rimozione di un carattere CTRL+d
    - Trasposizione di un carattere CTRL+t
    - Trasposizione di una parola ALT+t
    - Cambia maiuscolo/minuscolo ALT+u e ALT+l
    - Per eliminare solo una parola utilizzare ALT+d
  - Copia/incolla
    - Per tagliare si usa CTRL+k dall'inizio della linea (CTRL+a)
    - Per incollare si usa CTRL+y
    - Per tagliare dalla posizione del cursore fino all'inizio della linea CTRL+u
  - Autocompletamento
    - Utilizzare il tasto TAB
  - Utilizzare la cronologia
    - Il comando per mostrare la cronologia è history
    - Tabella con i comandi da utilizzare per muoversi nella cronologia ((63fe1d66-1d9f-4568-a795-cb194dacf51a))
Lezione 12 - Gestione dei permessi (4 ore)
- I sistemi appartenenti alla famiglia #Unix sono tipicamente multiutente (oltre che multitasking)
- Linux non fa differenza, motivo per cui è necessario saper gestire i permessi che utenti e gruppi possono vantare su file e cartelle
- I file di sistema che governano gli utenti, i gruppi e le password sono
  - /etc/passwd - utenti
  - /etc/group - gruppi
  - /etc/shadow - password
- Il comando id fornisce informazioni relativamente all'utente corrente che vengono prese appunto dai file citati sopra
  - ```
  id
```
- Creiamo una cartella $HOME/permessi e proviamo a scrivere un file all'interno di essa. Vediamo quali sono i permessi di default che gli vengono attribuiti
  - ```
  mkdir permessi
  cd permessi
  > foo.txt
  ls -l
```
- Impariamo ad interpretare i primi 10 caratteri mostrati dal comando ls -l
  - ((64002855-f933-46ab-914e-088f9bb9a827))
  - ((6400286b-8674-4370-951e-8583bbc91765))
  - ((6400289f-294a-4463-9856-55715229e68e))
  - ((640028d3-a5ad-4d07-9f7b-cfcfa89fe48a))
- Esempio notevole
  - Se ho una cartella senza permesso di scrittura (flag w) posso modificare i file all'interno ma non posso rinominarli, eliminarli o creali.
- Utilizziamo il comando chmod per modificare i permessi su file e cartelle
  - ```
  rm foo
  > foo.txt
  chmod 600 foo.txt
```
- Notazione simbolica utilizzata da chmod ((640029df-7b7e-47c3-9b49-3c69beff0270)) con esempi ((640029f1-841a-44f4-b0bd-10bd134c61d9))
- Esercizio
  - Create un file foo.txt
  - Resettate tutti i permessi utilizzando chmod 000 foo.txt
  - Impostate i permessi in modo simbolico utilizzando u+x,go=rx
  - Trovate la sequenza ottale che setta gli stessi permessi di sopra
- Esercizio
  - Crea una cartella che sia attraversabile solo dall'utente
  - Crea un file che sia eseguibile per tutti
  - Crea un file che sia leggibile da tutti ed eseguibile solo dall'utente
  - Crea una cartella che non sia scrivibile dal gruppo e dagli altri
  - Crea all'interno di una cartella un file che possa essere modificato ma non eliminato dalla stessa
  - Crea una cartella attraversabile solo dal gruppo e all'interno di essa una sotto cartella attraversabile solo dall'utente
- Il comando umask controlla come vengono impostati i permessi quando un file viene creato
  - Per vedere come è impostata la maschera basta eseguire il comando umask senza argomenti
    - ```
    umask
```
- Il risultato 0002 è un numero in notazione ottale che ha il seguente significato
- Con i comandi su e sudosi può rispettivamente effettuare il login con altro utente e eseguire un comando come utente root ((64005e37-358e-4dc9-bda1-1e8b8139f129))
- Il comando chown consente di modificare proprietario e gruppo di file e cartelle
  - ```
  chown andrea:backup foo.txt
```
- Il comando per modificare (o impostare) la password di un utente è passwd
  - ```
  passwd andrea # modifica la password dell'utente andrea
  passwd # modifica la password dell'utente attuale
```
Lezione 13 - Processi e shell expansion (4 ore)
- I processi sono i "programmi" in esecuzione sulla macchina
- Sono identificati da un codice univoco chiamato pid (process ID)
- Il processo init è il primo ad essere eseguito dal #kernel è ha PID=1
- Il comando che mostra i processi attivi sulla macchina è ps ((640618dc-9bc7-4503-8bac-c75d782f1d3c))
  - ```
  ps # mostra i processi relativi all'attuale sessione di terminale
  ps x # mostra i processi relativi all'utente
  ps aux # mostra i processi appartenenti a *tutti* gli utenti
```
- Il comando top visualizza i processi in tempo reale ((64061a22-6494-4e10-9689-369c326978c7))
  - ```
  top
```
- {:height 438, :width 582}
- Lanciamo da terminale il programma gedit
  - ```
  gedit
```
- Notiamo come non si ottiene nuovamente il controllo del terminale prima che il programma venga chiuso
- Per terminare "con grazia" (gracefully) il processo premere la combinazione di tasti CTRL+c
- Per lanciare un processo da terminale e metterlo in background occorre utilizzare il carattere &
  - ```
  gedit &
```
  - Per fermare un processo lanciato in foreground e farlo ripartire in background
    - ```
    gedit # premere CTRL+z
    jobs # mostra i processi lanciati dal terminale attuale
    bg %1
```
- Per terminare un processo si utilizza il comando kill seguito dal pid del processo ((64061d9d-cf1f-4178-a1c7-3bdf67cb4d64))
  - ```
  gedit &
  kill PID # sostituire PID con il numero di processo mostrato dopo l'esecuzione della prima linea
```
  - Utilizzo di killall per terminare più processi contemporaneamente
  - Spegnere o riavviare il sistema con i comandi reboot e shutdown
Lezione 14 - Ambiente di lavoro e vim (4 ore)
- Ancora su variabili d'ambiente
- L'editor vim ((640966bc-75b5-4236-b5c7-4cade85ea9b2))
- Le shell expansion sono sostituzioni agite dalla shell ((6407488d-1857-4bc0-bcd9-f9f1f026d723))
- Molto importante la ((640752a8-bc64-40d1-8538-10a7cc137314))
  - ```
  file $(ls -d /usr/bin/* | grep zip)
```
Lezione 15 - Gestione dei dispositivi di archiviazione (4 ore)
- La lezione presenterà gli strumenti necessari per la gestione dei dispositivi di archiviazione su sistemi GNU/Linux
- In GNU/Linux esiste il concetto di mount ovvero il dispositivo di archiviazione viene "montato" sul filesystem del sistema operativo
  - Il file /etc/fstab contiene le informazioni sui dispositivi che vengono montati nella fase di boot ((6410411a-37f6-436d-bed8-bfad7b56416b))
    - ```
    cat /etc/fstab
```
- Il comando mount viene utilizzato per montare i device sul filesytem del sistema operativo
  - ```
  mount # senza opzioni mostra i dispositivi attualmente montati
```
- Smontare e cambiare punto di montaggio
  - ```
  umount /dev/sdX
  sudo mkdir -p /mnt/usbdrive
  mount /mnt/usbdrive
```
- Partizionare e formattare una pendrive
  - Il comando per gestire le partizioni di un disco è fdisk
  - Una volta individuato il device da partizionare è possibile eseguire fdisk ed interagire con esso mediante tastiera
  - ```
  fdisk /dev/sdX
```
- Partizionare non basta! Serve anche formattare (creare il filesystem). Il comando utile è mkfs #storage #linuxcommandline
  - ```
  sudo mkfs -t ext4 /dev/sdX
```
- Per effettuare un controllo del filesystem si utilizza il comando fsck (assicurarsi che il device non sia montato)
  - ```
  sudo fsck /dev/sdX
```
- Copia 1:1 con dd
  - ```
  dd if=/dev/sdb of=flash_drive.img status=progress
```
- Metodi checksum per controllo integrità
- Generare un'immagine ISO a partire da una cartella ((6410a253-8d61-4b98-ac06-90fedc8fb7fb)) #backup #storage #linuxcommandline
  - ```
  genisoimage -o cd-rom.iso -R -J ~/cd-rom-files
```
- Montare un'immagine ISO #linuxcommandline #storage
  - ```
  mkdir /mnt/iso_image
  mount -t iso9660 -o loop image.iso /mnt/iso_image
```
Scenari reali di amministrazione
- Presentare agli allievi il resoconto relativo alla Migrazione sito LES
Lezione 16 - Networking Parte 1 (3 ore)
- Uso del comando ping
  - Viene utilizzato per verificare che un host sia raggiungibile
  - ```
  ping 8.8.8.8 # DNS di google
  ping www.google.it
```
- Uso del comando tracepath
  - Viene utilizzato per tracciare il "percorso" si un pacchetto da una sorgente ad una destinazione
  - ```
  tracepath www.google.com
  tracepath housecloud.andreafazzi.eu
```
- Uso del comando ip
  - Sostituisce l'ormai deprecato ifconfig
  - ```
  ip a
  ip --brief a
  ip --brief address
```
- Uso del comando netstat
  - Fornisce statistiche e informazioni sulle interfacce di rete
  - ```
  netstat -ie # informazioni sulle interfacce
  netstat -r # informazioni sulle tabelle di routing del kernel
```
- Uso del comando ssh
  - Prima di procedere con lo studio del comando ssh occorre installare e configurare una macchina virtuale utilizzando #qemu e il frontend virt-manager
  - Determinare l'indirizzo IP della macchina virtuale
  - Primo accesso con ssh
    - ```
    ssh nomeutente@indirizzo_ip
```
- Eseguire un comando remoto
  - ```
  ssh nomeutente@indirizzo_ip ls -l
```
  - Copiare file con scp
    - ```
    scp -r sorgente nomeutente@indirizzo_ip:destinazione
```
Lezione 17 - Networking Parte 2 (3 ore)
- Avviare la macchina virtuale con debian11
- Installare #podman
  - Raggiungere il sito web ufficiale
  - Installare il pacchetto podman
    - ```
    sudo apt-get -y install podman
```
- Consultare la documentazione per familiarizzare con i comandi principali
- Creare un alias per #docker
  - ```
  alias docker='podman'
```
- Installare podman-compose
  - Pagina Github con istruzioni per l'installazione
  - ```
  pip3 install podman-compose --user
```
- Configurare il container #ngnix
  - Creare il file docker-compose.yml
    - ```
    mkdir -p $HOME/srv/blog
    cd $HOME/srv/blog
    touch docker-compose.yml
    nano docker-compose.yml # oppure vim
```
- ```
version: "3"

services:

  blog:
    image: nginx
    container_name: blog
    restart: unless-stopped
    volumes:
      - ./html:/usr/share/nginx/html:ro
```
  - Eseguire il container
    - ```
    podman-compose up
```
- Esplorare le caratteristiche del container in esecuzione
- Esporre la porta
- Sviluppo in locale e copia su macchina virtuale
  - Creare un file index.html
  - Copiare il file sulla macchina remota
  - Visitare l'IP della macchina remota tramite browser
  - Installare #Publii e sperimentare
Lezione 18 - RHEL9 Parte 1 (4 ore)
- Utilizzo dei volumi in docker
- Modifica dei permessi
- Utilizzo di rsync per effettuare la sincronizzazione con il server remoto
  - Installare rsync anche sul server remoto
    - ```
    sudo apt install rsync
```
- ```
rsync -rauLP source remote_host:path/to/remote_directory
```
- Installazione di RHEL9 sistema su VM
- Registrazione dell'installazione
- Aggiungere l'utente al gruppo wheel
  - ```
  su -
  usermod -aG wheel afazzi # non c'è gruppo sudo in RHEL9 ma wheel
```
Lezione 19
- Gestione dei log con journalctl
  - Articolo di RedHat
  - Articolo di dev.to
  - Altro articolo di dev.to
- Configurazione di #openvpn su #RHEL
  - Attivazione di alcuni repository
  - Installazione di #openvpn
    - ```
    subscription-manager repos --enable codeready-builder-for-rhel-9-$(arch)-rpms
    dnf install https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rp
    sudo dnf update
    sudo dnf install openvpn
```
- Creazione account presso HackTheBox
- Lettura della documentazione per iniziare ad operare con l'obiettivo ((64213e22-0f77-403d-a7b0-c04beae0bc21))
- Utilizzo di nmap per scoprire le porte esposte
  - ```
  sudo nmap -sV IP
```
Lezione 20
- Cronjob con RHEL9
- Utilizzo di #restic per i backup
  - Documentazione ufficiale del comando
- Esercizi di ripasso
Lezione 21

30 KiB Raw Blame History

Lezione n. 1 - Presentazione del corso e test d'ingresso (3 ore)

Lezione n .2 - Installazione di Debian11 su VirtualBox (4 ore)

Lezione 3 - Networking parte 1 (4 0re)

Lezione n. 4 - Creazione di una pendrive #Ventoy (3 ore)

Lezione 5 - Installazione di un sistema GNU/Linux (4 ore)

Lezione 6 - Sistemi di revisione (3 ore)

Lezione 7 - (4 ore)

Comandi di base per la navigazione all'interno del filesystem

Comandi per la manipolazione di file o cartelle

Un playground su server reali

Soluzione 1

Soluzione 2

Lezione 8 - Lavorare con i comandi e reindirizzamento dell'I/O (3 ore)

Reindirizzamento

Analizzare i log prodotti da un server reale

Lezione 9 - Docker e preparazione al test finale (4 ore)

Installare #docker su sistemi Ubuntu based

Documentazione di riferimento

Prerequisiti

Docker engine

Verifica dell'installazione

Eseguire docker come non-root

Preparare ambiente playground

Esercizio 1

Esercizio 2

Lezione 10 - Riflessioni sul test e ripasso (ore 2)

Lezione 11 - Utilizzare la linea di comando (3 ore)

Command line editing

Movimenti del cursore ((63fd831a-57e8-4348-8f2c-8067839c0a23))

Modifiche del testo ((63fe1156-ffb9-40ce-9737-a519ef32883b))

Copia/incolla

Autocompletamento

Utilizzare la cronologia

Lezione 12 - Gestione dei permessi (4 ore)

Esempio notevole

Lezione 13 - Processi e shell expansion (4 ore)

Lezione 14 - Ambiente di lavoro e vim (4 ore)

Lezione 15 - Gestione dei dispositivi di archiviazione (4 ore)

Scenari reali di amministrazione

Lezione 16 - Networking Parte 1 (3 ore)

Lezione 17 - Networking Parte 2 (3 ore)

Installare #podman

Installare podman-compose

Configurare il container #ngnix

Lezione 18 - RHEL9 Parte 1 (4 ore)

Lezione 19

Lezione 20

Lezione 21

30 KiB

Raw Blame History

Installare `podman-compose`