trimstray/test-your-sysadmin-skillsUna raccolta di domande e risposte per test di amministrazione di sistema Linux. Metti alla prova le tue conoscenze e competenze in diversi ambiti con queste Q/A.
:star:
"Un grande amministratore non ha bisogno di sapere tutto, ma deve essere in grado di trovare soluzioni straordinarie a progetti impossibili." - cwheeler33 (ServerFault)
:star:
"La mia abilità è far funzionare le cose, non conoscere un miliardo di fatti. [...] Se devo riparare un sistema, identifico il problema, controllo i log e cerco gli errori. Se devo implementare una soluzione, cerco la soluzione giusta, la implemento e la documentò; successivamente ho solo un'idea generale di come funziona a meno che non interagisca frequentemente... è per questo che si documenta." - Sparcrypt (Reddit)
ℹ️ Questo progetto contiene 284 domande e risposte che possono essere utilizzate per testare le tue conoscenze o durante un colloquio/esame per posizioni come Amministratore di sistema Linux (*nix).
✔️ Le risposte sono solo esempi e non esauriscono l'intero argomento. La maggior parte contiene risorse utili per una comprensione più approfondita.
⚠️ Le domande contrassegnate con *** non hanno ancora risposta o la risposta è incompleta - fai una pull request per aggiungerle!
🚥 Se trovi qualcosa che non ha senso o che non sembra corretto, per favore fai una pull request e aggiungi spiegazioni valide e ben motivate per le tue modifiche o commenti.
📚 Per migliorare le tue conoscenze/competenze, consulta devops-interview-questions. Sembra davvero interessante.
» Tutti i suggerimenti sono benvenuti «
La mia distribuzione Linux preferita:
Risorse utili:
GNU non è esattamente un sistema operativo. È più un insieme di regole o filosofie che governano il software libero, che allo stesso tempo hanno dato vita a un mucchio di strumenti mentre si cercava di creare un sistema operativo. Quindi gli strumenti GNU sono fondamentalmente versioni aperte di strumenti già esistenti, ma reimplementati per conformarsi ai principi del software aperto. GNU/Linux è un'integrazione di questi strumenti con il kernel Linux per formare un sistema operativo completo, ma esistono altri GNU, ad esempio GNU/Hurd.
Unix e BSD sono implementazioni "più vecchie" di POSIX che hanno vari livelli di "chiusura". Unix è solitamente completamente closed source, ma esistono tante versioni di Unix quante sono le Linux (se non di più). BSD non è solitamente considerato "aperto", ma all'epoca della sua release era considerato molto aperto. La sua licenza permetteva anche un uso commerciale con molte meno restrizioni rispetto alle licenze più "aperte" dell'epoca.
Linux è il più recente dei quattro. In senso stretto, è "solo un kernel"; tuttavia, in generale, è considerato un sistema operativo completo quando combinato con gli strumenti GNU e altri componenti fondamentali.
Le principali differenze tra questi riguardano i loro ideali. Unix, Linux e BSD hanno ideali diversi che implementano. Sono tutti POSIX e sono fondamentalmente intercambiabili. Risolvono alcuni degli stessi problemi in modi diversi. Quindi, a parte gli ideali e il modo in cui scelgono di implementare gli standard POSIX, c'è poca differenza.
Per maggiori informazioni, suggerisco di leggere un breve articolo sulla creazione di GNU, OSS, Linux, BSD e UNIX. Saranno orientati verso le loro singole idee, ma quegli articoli dovrebbero darti un'idea migliore delle differenze.
Risorse utili:
CLI è l'acronimo di Command Line Interface (Interfaccia a riga di comando) o Command Language Interpreter. La riga di comando è uno dei modi più potenti per controllare il sistema/computer.
Nei sistemi Unix-like, CLI è l'interfaccia attraverso cui un utente può digitare comandi per farli eseguire al sistema. La CLI è molto potente, ma non è molto tollerante agli errori.
La CLI ti permette di eseguire manipolazioni con gli interni del sistema e con il codice in modo molto più preciso. Offre maggiore flessibilità e controllo rispetto a una GUI, indipendentemente dal sistema operativo utilizzato. Molti programmi che potresti voler utilizzare, ad esempio ospitati su Github, richiedono anche l'esecuzione di alcuni comandi sulla CLI per farli funzionare.
I miei strumenti preferiti
screen - multiplexer di terminale gratuito; posso avviare una sessione e i miei terminali vengono salvati anche se la connessione si perde, così posso riprenderli più tardi o da casassh - il comando più prezioso in assoluto da imparare; posso usarlo per fare cose sorprendenti:
sshfsrsync senza demone rsync avviandone uno tramite sshvi/vim - l'editor di testo più popolare e potente; è universale, funziona molto velocemente, anche su file grandibash-completion - contiene una serie di regole di completamento predefinite per la shellBASH è la mia preferita. È una questione di preferenze personali; amo la sintassi e mi "clicca" subito. La sintassi per il reindirizzamento input/output (>>, << 2>&1, 2>, 1>, ecc.) è simile a quella del C++, il che mi facilita nel riconoscimento.
Mi piace anche la shell ZSH, perché è molto più personalizzabile di BASH. Ha il framework Oh-My-Zsh, un completamento contestuale potente basato su tab, pattern matching/globbing potenziato, moduli caricabili e altro.
Risorse utili:
man [nomecomando] può essere usato per vedere una descrizione di un comando (es.: man less, man cat)-h o --help alcuni programmi stampano le istruzioni quando viene passato questo parametro (es.: python -h e python --help)w - molte informazioni utili con l'uptime del servertop - puoi vedere tutti i processi in esecuzione, ordinarli per CPU, utilizzo memoria e altronetstat - per sapere su quale porta e IP il tuo server è in ascolto e quali processi li usanodf - riporta la quantità di spazio su disco disponibile utilizzato dai filesystemhistory - ti dice cosa è stato eseguito in precedenza dall'utente a cui sei connessoRisorse utili:
ls -al?Nell'ordine dell'output:```bash -rwxrw-r-- 1 root root 2048 Jan 13 07:11 db.dump
- permessi del file,
- numero di link,
- nome del proprietario,
- gruppo del proprietario,
- dimensione del file,
- data dell'ultima modifica,
- nome del file/directory
I permessi del file vengono visualizzati come segue:
- il primo carattere è `-` o `l` o `d`, `d` indica una directory, `-` rappresenta un file, `l` è un symlink (collegamento simbolico) - tipo speciale di file
- tre gruppi di caratteri, tre volte, che indicano i permessi per proprietario, gruppo e altri:
- `r` = leggibile
- `w` = scrivibile
- `x` = eseguibile
Nel tuo esempio `-rwxrw-r--`, significa che la riga visualizzata è:
- un file regolare (visualizzato come `-`)
- leggibile, scrivibile ed eseguibile dal proprietario (`rwx`)
- leggibile, scrivibile, ma non eseguibile dal gruppo (`rw-`)
- leggibile ma non scrivibile né eseguibile dagli altri (`r--`)
Risorse utili:
- [Cosa significano i campi nell'output di ls -al? (originale)](https://unix.stackexchange.com/questions/103114/what-do-the-fields-in-ls-al-output-mean)
</details>
<details>
<summary><b>Come si ottiene un elenco degli utenti che hanno effettuato l'accesso?</b></summary><br>
Per un riepilogo degli utenti che hanno effettuato l'accesso, inclusi ogni accesso di un nome utente, i terminali a cui gli utenti sono collegati, la data/ora del login e possibilmente il computer da cui stanno effettuando la connessione, digita:```bash
# It uses /var/run/utmp and /var/log/wtmp files to get the details.
who
Il vantaggio più significativo di eseguire un processo in background è che puoi svolgere qualsiasi altra operazione simultaneamente mentre altri processi sono in esecuzione in background. Quindi, più processi possono essere completati in background mentre stai lavorando su processi diversi. Questo può essere ottenuto aggiungendo il carattere speciale & alla fine del comando.
Generalmente, le applicazioni che richiedono troppo tempo per essere eseguite e non richiedono interazione con l'utente vengono inviate in background in modo da poter continuare il nostro lavoro nel terminale.
Ad esempio, se vuoi scaricare qualcosa in background, puoi fare:```bash wget https://url-to-download.com/download.tar.gz &
Quando esegui il comando sopra ottieni il seguente output:```bash
[1] 2203
Qui 1 è il numero di serie del job e 2203 è il PID del job. Puoi vedere i job in esecuzione in background usando il seguente comando:```bash jobs
Quando esegui un job in background, ti dà un PID del job, puoi uccidere il job in esecuzione in background usando il seguente comando:```bash
kill PID
Sostituisci il PID con il PID del job. Se hai un solo job in esecuzione, puoi portarlo in primo piano usando:```bash fg
Se hai più job in esecuzione in background, puoi portare qualsiasi job in primo piano utilizzando:```bash
fg %#
Sostituisci il # con il numero seriale del lavoro.
Risorse utili:
Da completare.
Eseguire (tutto) come root è negativo perché:
Stupidità: niente ti impedisce di fare un errore per disattenzione. Se devi modificare il sistema in modo potenzialmente dannoso, devi usare sudo, che garantisce una pausa (mentre inserisci la password) per assicurarti di non stare per commettere un errore.
Sicurezza: è più difficile violare il sistema se non conosci l'account di login dell'utente amministratore. root significa che hai già la metà delle credenziali di amministrazione.
Non ne hai realmente bisogno: se devi eseguire diversi comandi come root e sei infastidito dall'inserire più volte la password quando sudo è scaduto, ti basta fare sudo -i e diventi root. Vuoi eseguire comandi con pipe? Usa sudo sh -c "comando1 | comando2".
Puoi sempre usarlo nella console di ripristino: la console di ripristino ti permette di recuperare da un grave errore o risolvere un problema causato da un'app (che hai comunque dovuto eseguire con sudo). Ubuntu non ha una password per l'account root in questo caso, ma puoi cercare online come modificarlo – questo renderà più difficile per chiunque abbia accesso fisico alla tua macchina fare danni.
Risorse utili:
Usa top/htop per entrambe. Con i comandi free e vmstat puoi visualizzare rispettivamente le statistiche della memoria fisica e virtuale. Con l'aiuto del comando sar puoi vedere l'utilizzo della CPU e altre statistiche (ma sar non è nemmeno installato nella maggior parte dei sistemi).
Risorse utili:
I carichi medi di Linux sono "medie del carico di sistema" che mostrano la richiesta di thread (task) in esecuzione sul sistema come numero medio di thread in esecuzione più in attesa. Questa misura la domanda, che può essere superiore a ciò che il sistema sta attualmente elaborando. La maggior parte degli strumenti mostra tre medie, per 1, 5 e 15 minuti.
Questi 3 numeri non sono i numeri per le diverse CPU. Sono valori medi del numero di carico per un dato periodo di tempo (degli ultimi 1, 5 e 15 minuti).
Il carico medio è solitamente descritto come "lunghezza media della coda di esecuzione". Quindi pochi processi o thread che consumano CPU possono alzare il carico medio sopra 1. Non c'è problema se il carico medio è inferiore al numero totale di core della CPU. Ma se supera il numero di CPU, significa che alcuni thread/processi rimarranno in coda, pronti per essere eseguiti, ma in attesa di una CPU libera.
Ha lo scopo di darti un'idea dello stato del sistema, mediato su diversi periodi di tempo. Poiché è mediato, ci vuole tempo perché torni a 0 dopo un carico pesante sul sistema.
Alcune interpretazioni:
Risorse utili:
Le password non vengono memorizzate da nessuna parte sul sistema. Quello che viene memorizzato in /etc/shadow sono i cosiddetti hash delle password.
Un hash di un testo viene creato applicando una cosiddetta funzione unidirezionale al testo (password), generando così una stringa da confrontare. Per progettazione è "impossibile" (computazionalmente irrealizzabile) invertire il processo.
Le versioni più vecchie di Unix memorizzavano le password crittografate in /etc/passwd insieme ad altre informazioni su ogni account.
Le versioni più recenti hanno semplicemente un * nel campo corrispondente in /etc/passwd e usano /etc/shadow per memorizzare la password, anche per garantire che nessuno abbia accesso in lettura alle password quando servono solo le altre informazioni (shadow è solitamente protetto più fortemente di passwd).
Per maggiori informazioni consulta man crypt, man shadow, man passwd.
Risorse utili:
Per cambiare tutte le directory ad esempio a 755 (drwxr-xr-x):```bash
find /opt/data -type d -exec chmod 755 {} ;
Per cambiare tutti i file ad esempio in **644** (`-rw-r--r--`):```bash
find /opt/data -type f -exec chmod 644 {} \;
Risorse utili:
Sembra che a un certo punto venga sovrascritta la variabile d'ambiente PATH predefinita. Il tipo di errori che hai indica che PATH non contiene, ad esempio, /bin, dove risiedono i comandi (incluso bash).
Un modo per iniziare a fare debugging del tuo script bash o comando sarebbe avviare una subshell con l'opzione -x:```bash
bash --login -x
Questo ti mostrerà ogni comando e i suoi argomenti che viene eseguito all'avvio di quella shell. È anche molto utile mostrare i valori della variabile `PATH`:```bash
echo $PATH
Se esegui questo:```bash PATH=/bin:/sbin:/usr/bin:/usr/sbin
la maggior parte dei comandi dovrebbe iniziare a funzionare - e poi puoi modificare `~/.bash_profile` invece di `~/.bashrc` e correggere ciò che sta resettando `PATH` lì. I valori predefiniti della variabile `PATH` per **root** e altri utenti si trovano nel file `/etc/profile`.
Risorsa utile:
- [Come aggiungere correttamente un percorso a PATH?](https://unix.stackexchange.com/questions/26047/how-to-correctly-add-a-path-to-path)
</details>
<details>
<summary><b>Stai premendo <code>CTRL + C</code> ma il tuo script è ancora in esecuzione. Come fermarlo?</b></summary><br>
Nella maggior parte dei casi, puoi fermare uno script in esecuzione usando la combinazione di tasti `CTRL + C`. Questa invia un segnale di interrupt (SIGINT) allo script, che ne termina l'esecuzione. Se questo non funziona e lo script è ancora in esecuzione, puoi provare a usare la combinazione `CTRL + \`, che invia un segnale di quit (SIGQUIT) allo script, che potrebbe terminarlo immediatamente.
In alternativa, se stai usando un terminale o un'interfaccia a riga di comando, puoi provare a usare il comando `kill` per inviare un segnale al processo dello script. Puoi trovare l'ID del processo (PID) dello script usando i comandi `ps` o `top`, e poi usare `kill` con il PID per fermare lo script.
In alcuni casi, potresti aver bisogno di usare il comando `kill -9` per forzare lo script a fermarsi, poiché il normale comando kill potrebbe non funzionare se lo script è bloccato o non risponde. L'opzione `-9` invia un segnale SIGKILL, che forza il processo a fermarsi immediatamente.
</details>
<details>
<summary><b>Cos'è il comando <code>grep</code>? Come abbinare più stringhe sulla stessa riga?</b></summary><br>
Le utilità `grep` sono una famiglia di strumenti Unix, incluse `egrep` e `fgrep`.
`grep` cerca nei file pattern. Se stai cercando un pattern specifico nell'output di un altro comando, `grep` evidenzia le righe pertinenti. Usa questo comando grep per cercare nei file di log, processi specifici e altro ancora.
Per abbinare più stringhe:```bash
grep -E "string1|string2" filename
Se vuoi eseguire ogni comando solo se il precedente ha avuto successo, allora combinali usando l'operatore &&:```bash
cd /my_folder && rm *.jar && svn co path to repo && mvn compile package install
Se uno dei comandi fallisce, allora tutti gli altri comandi successivi non verranno eseguiti.
Se si desidera eseguire tutti i comandi indipendentemente dal fatto che i precedenti siano falliti o meno, separarli con punti e virgola:```bash
cd /my_folder; rm *.jar; svn co path to repo; mvn compile package install
Nel tuo caso, penso che tu voglia il primo caso in cui l'esecuzione del comando successivo dipende dal successo del precedente.
Puoi anche mettere tutti i comandi in uno script ed eseguire quello invece:```bash
#! /bin/sh
cd /my_folder
&& rm *.jar
&& svn co path to repo
&& mvn compile package install
Risorse utili:
- [Esegui e combina più comandi Linux in una riga (originale)](https://stackoverflow.com/questions/13077241/execute-combine-multiple-linux-commands-in-one-line)
</details>```bash
chmod a+x /path/to/file
a - per tutti gli utentix - per il permesso di esecuzioner - per il permesso di letturaw - per il permesso di scritturaPer sincronizzare il contenuto di dir1 in dir2 sullo stesso sistema, digita:```bash rsync -av --progress --delete dir1/ dir2
- `-a`, `--archive` - modalità archivio
- `--delete` - elimina file estranei dalle directory di destinazione
- `-v`, `--verbose` - modalità verbosa (aumenta la verbosità)
- `--progress` - mostra l'avanzamento durante il trasferimento
Risorse utili:
- [Come posso sincronizzare due directory locali? (originale](https://unix.stackexchange.com/questions/392536/how-can-i-sync-two-local-directories)
- [Sincronizzare cartelle con rsync](https://www.jveweb.net/en/archives/2010/11/synchronizing-folders-with-rsync.html)
</details>
<details>
<summary><b>Molte attività di manutenzione di base richiedono di modificare i file di configurazione. Spiega i modi per annullare le modifiche apportate.</b></summary><br>
- backup manuale di un file prima della modifica (con espansione di parentesi graffe come: `cp filename{,.orig}`)
- copia manuale della struttura di directory in cui è archiviato il file (es. `cp`, `rsync` o `tar`)
- crea un backup del file originale nel tuo editor (es. imposta regole nel file di configurazione del tuo editor)
- la soluzione migliore è usare `git` (o qualsiasi altro sistema di controllo versione) per tenere traccia dei file di configurazione (es. `etckeeper` per la directory `/etc`)
Risorse utili:
- [Backup di un file con .bak prima dell'estensione del nome file](https://unix.stackexchange.com/questions/66376/backup-file-with-bak-before-filename-extension)
- [È una buona idea usare git per il controllo di versione dei file di configurazione?](https://superuser.com/questions/1037211/is-it-a-good-idea-to-use-git-for-configuration-file-version-controlling)
</details>
<details>
<summary><b>Devi trovare tutti i file più grandi di 20MB. Come fai?</b></summary><br>```bash
find / -type f -size +20M
sudo su - e non solo sudo su?sudo è presente nella maggior parte delle distribuzioni Linux moderne in cui (ma non sempre) l'utente root è disabilitato e non ha password impostata. Quindi non puoi passare all'utente root con su (puoi provare). Devi invocare sudo con privilegi di root: sudo su.
su si limita a cambiare utente, fornendo una shell normale con un ambiente quasi identico a quello del vecchio utente.
su - invoca una shell di login dopo aver cambiato utente. Una shell di login reimposta la maggior parte delle variabili d'ambiente, fornendo una base pulita.
Risorse utili:
Sono essenziali per investigare i problemi sul sistema. La gestione dei log è assolutamente critica per la sicurezza IT.
Server, firewall e altre apparecchiature IT conservano file di log che registrano eventi e transazioni importanti. Queste informazioni possono fornire indizi cruciali sull'attività ostile che colpisce la rete dall'interno e dall'esterno. I dati di log possono anche fornire informazioni per identificare e risolvere problemi delle apparecchiature, inclusi problemi di configurazione e guasti hardware.
È il registro del tuo server che indica chi è venuto sul tuo sito, quando e esattamente cosa hanno visualizzato. È incredibilmente dettagliato e mostra:
Fattori da considerare:
Raccogliendo e analizzando i log, puoi capire cosa accade all'interno della tua rete. Ogni file di log contiene molte informazioni che possono essere preziose, specialmente se sai come leggerle e analizzarle.
Risorse utili:
Un backup incrementale è un tipo di backup che copia solo i file che sono cambiati dal backup precedente.
Risorse utili:
Un RAID (Redundant Array of Inexpensive Disks) è una tecnologia utilizzata per aumentare le prestazioni e/o l'affidabilità dell'archiviazione dei dati.
Risorse utili:
Se non specificato, il comportamento di useradd dipenderà dalla variabile USERGROUPS_ENAB contenuta in /etc/login.defs. Il comportamento predefinito (USERGROUPS_ENAB yes) prevede la creazione di un gruppo con lo stesso nome dell'utente, con GID uguale a UID.
Risorse utili:
Da completare.
Risorse utili:
Da completare.
Le cose più importanti da capire sul modello OSI (o qualsiasi altro modello) sono:
Risorse utili:
VLAN e subnet risolvono problemi diversi. Le VLAN operano al Livello 2, modificando quindi i domini di broadcast (per esempio). Mentre le subnet sono al Livello 3 nel contesto attuale.
Subnet - è un intervallo di indirizzi IP determinato da una parte di un indirizzo (spesso chiamato indirizzo di rete) e una maschera di sottorete (netmask). Ad esempio, se la netmask è 255.255.255.0 (o /24 in breve) e l'indirizzo di rete è 192.168.10.0, allora ciò definisce un intervallo di indirizzi IP da 192.168.10.0 a 192.168.10.255. La forma abbreviata per scriverlo è 192.168.10.0/24.
VLAN - un buon modo di pensarci è "partizionamento dello switch". Supponiamo di avere uno switch a 8 porte che supporta le VLAN. Puoi assegnare 4 porte a una VLAN (ad esempio VLAN 1) e 4 porte a un'altra VLAN (ad esempio VLAN 2). VLAN 1 non vedrà il traffico di VLAN 2 e viceversa; logicamente ora hai due switch separati. Normalmente su uno switch, se lo switch non ha visto un indirizzo MAC, "inonderà" il traffico su tutte le altre porte. Le impediscono questo.
POP e IMAP sono entrambi protocolli per recuperare messaggi da un server di posta a un client di posta.
POP (Post Office Protocol) utilizza un push unidirezionale dal server di posta al client. In modo predefinito, questo invierà i messaggi al client POP e li rimuoverà dal server di posta, anche se è possibile configurare il server di posta per conservare tutti i messaggi. Qualsiasi azione esegui sul messaggio nel client di posta (etichettatura, eliminazione, spostamento in una cartella) non si rifletterà sul server di posta e quindi sarà inaccessibile ad altri client di posta che prelevano dal server. POP utilizza poco spazio di archiviazione sul server di posta e può essere considerato più sicuro poiché i messaggi esistono solo su un client di posta anziché sul server e su più client.
IMAP (Internet Message Access Protocol) utilizza una comunicazione bidirezionale tra server di posta e client. Eliminare o etichettare un messaggio nel client di posta configurato con IMAP eliminerà o etichetterà anche il messaggio sul server. IMAP consente un'esperienza simile quando si accede alla posta da diversi client o dispositivi, poiché i messaggi possono esistere nello stesso stato su più dispositivi. IMAP può anche risparmiare spazio su disco sul client di posta sincronizzando selettivamente i messaggi ed eliminando quelli più vecchi dal client, dato che può recuperarli dal server in seguito se necessario.
Scegli IMAP se devi accedere ai messaggi da più dispositivi e vuoi risparmiare spazio su disco sul dispositivo client. Scegli POP se vuoi risparmiare spazio su disco sul server di posta, accedere ai messaggi solo da un dispositivo client e assicurarti che i messaggi non esistano su più sistemi.
Utilizzando i comandi netstat -nr, route -n o ip route show possiamo vedere il percorso predefinito e le tabelle di routing.
Risorse utili:
Bene, la differenza più probabile è che devi comunque fare una risoluzione effettiva di localhost da qualche parte.
Se usi 127.0.0.1, allora il software (intelligente) lo convertirà direttamente in un indirizzo IP e lo utilizzerà. Alcune implementazioni di gethostbyname rileveranno il formato con punti (e presumibilmente il formato IPv6 equivalente) e non eseguiranno affatto una risoluzione.
Altrimenti, il nome deve essere risolto. E non c'è garanzia che il tuo file hosts venga effettivamente utilizzato per quella risoluzione (prima o del tutto), quindi localhost potrebbe diventare un indirizzo IP completamente diverso.
Con questo intendo dire che, su alcuni sistemi, il file hosts locale può essere bypassato. Il file host.conf controlla questo su Linux (e molti altri Unix).
Se usi un socket di dominio Unix, sarà leggermente più veloce rispetto all'uso di TCP/IP (a causa della minore overhead). Windows utilizza TCP/IP come impostazione predefinita, mentre Linux tenta di utilizzare un socket di dominio Unix se scegli localhost e TCP/IP se usi 127.0.0.1.
Risorse utili:
ping?ping utilizza ICMP, in particolare i pacchetti ICMP echo request e ICMP echo reply. Non esiste una 'porta' associata a ICMP. Le porte sono associate ai due protocolli del livello di trasporto IP, TCP e UDP. ICMP, TCP e UDP sono "fratelli"; non si basano l'uno sull'altro, ma sono tre protocolli separati che girano sopra IP.
I pacchetti ICMP sono identificati dal campo 'protocol' nell'intestazione del datagramma IP. ICMP non utilizza i servizi di comunicazione UDP o TCP, ma utilizza i servizi di comunicazione IP grezzi (raw). Ciò significa che il messaggio ICMP viene trasportato direttamente nel campo dati di un datagramma IP. raw deriva da come questo è implementato nel software: per creare e inviare un messaggio ICMP, si apre un socket raw, si costruisce un buffer contenente il messaggio ICMP e poi si scrive il buffer contenente il messaggio nel socket raw.
Il valore del protocollo IP per ICMP è 1. Il campo protocollo fa parte dell'intestazione IP e identifica cosa si trova nella parte dati del datagramma IP.
Tuttavia, puoi usare nmap per vedere se le porte sono aperte o meno:```bash
nmap -p 80 example.com
Risorse utili:
- [Ping Port Number](https://networkengineering.stackexchange.com/questions/42463/ping-port-number)
- [Is it possible to ping an address:port?](https://superuser.com/questions/769541/is-it-possible-to-ping-an-addressport)
</details>
<details>
<summary><b>Il Server A non può comunicare con il Server B. Descrivi le possibili ragioni in pochi passi.</b></summary><br>
Per risolvere i problemi di comunicazione tra server, è meglio seguire idealmente lo stack TCP/IP:
1. **Livello Applicativo**: i servizi sono attivi e funzionanti su entrambi i server? Sono configurati correttamente (es. associare l'IP e la porta corretti)? I log di applicazione e di sistema mostrano errori significativi?
2. **Livello di Trasporto**: le porte utilizzate dall'applicazione sono aperte (prova telnet!)? È possibile eseguire il ping del server?
3. **Livello di Rete**: c'è un firewall sulla rete o sul sistema operativo configurato correttamente? Lo stack IP è configurato correttamente (IP, route, DNS, ecc.)? Switch e router funzionano (controlla la tabella ARP!)?
4. **Livello Fisico**: i server sono connessi a una rete? Si stanno perdendo pacchetti?
</details>
<details>
<summary><b>Perché i nomi host non si risolvono sul tuo server? Risolvi questo problema. ***</b></summary><br>
Da completare.
</details>
<details>
<summary><b>Come risolvere il nome di dominio (usando DNS esterni) con CLI? È possibile risolvere gli IP in nomi di dominio?</b></summary><br>
Esempi per risolvere un indirizzo IP in nome di dominio:```bash
# with host command:
host domain.com 8.8.8.8
# with dig command:
dig @9.9.9.9 google.com
# with nslookup command:
nslookup domain.com 8.8.8.8
telnet o nc?nc -vz code42.example.com 5432
</details>
<details>
<summary><b>Perché dovresti evitare <code>telnet</code> per amministrare un sistema da remoto?</b></summary><br>
I sistemi operativi moderni hanno disattivato tutti i servizi potenzialmente insicuri per impostazione predefinita. D'altra parte, alcuni fornitori di dispositivi di rete consentono ancora di stabilire una comunicazione utilizzando il protocollo telnet.
**Telnet** utilizza il metodo meno sicuro per la comunicazione. Invia i dati attraverso la rete in formato testo semplice e chiunque può facilmente scoprire la password utilizzando uno strumento di rete.
Nel caso di **Telnet**, ciò include il passaggio delle credenziali di accesso in testo semplice, il che significa che chiunque esegua uno sniffer sulla tua rete può trovare le informazioni necessarie per prendere il controllo di un dispositivo in pochi secondi intercettando una sessione di login **Telnet**.
Risorse utili:
- [Telnet e SSH come alternativa sicura](https://www.ssh.com/ssh/telnet)
- [Come telnet a un indirizzo IP su una porta specifica?](https://superuser.com/questions/339107/how-to-telnet-to-an-ip-address-on-a-specific-port)
</details>
<details>
<summary><b>Qual è la differenza tra <code>wget</code> e <code>curl</code>?</b></summary><br>
Le differenze principali sono: il principale punto di forza di `wget` rispetto a `curl` è la capacità di scaricare ricorsivamente. `wget` è solo da riga di comando. `curl` supporta FTP, FTPS, HTTP, HTTPS, SCP, SFTP, TFTP, TELNET, DICT, LDAP, LDAPS, FILE, POP3, IMAP, SMTP, RTMP e RTSP.
Risorse utili:
- [Qual è la differenza tra curl e wget? (originale)](https://unix.stackexchange.com/questions/47434/what-is-the-difference-between-curl-and-wget)
</details>
<details>
<summary><b>Cos'è SSH e come funziona?</b></summary><br>
**SSH** sta per **Secure Shell**. È un protocollo che ti permette di passare da un server "A" a una sessione shell su un server "B". Ti consente di interagire con il tuo server "B".
Per stabilire una connessione **SSH**, la macchina remota (server A) deve eseguire un software chiamato demone **SSH** e il computer dell'utente (server B) deve avere un client **SSH**.
Il demone **SSH** e il client **SSH** ascoltano le connessioni su una porta di rete specifica (predefinita 22), autenticano le richieste di connessione e generano l'ambiente appropriato se l'utente fornisce le credenziali corrette.
Risorse utili:
- [Comprendere il processo di crittografia e connessione SSH](https://www.digitalocean.com/community/tutorials/understanding-the-ssh-encryption-and-connection-process)
</details>
<details>
<summary><b>La maggior parte dei tutorial suggerisce di utilizzare l'autenticazione con chiave SSH piuttosto che quella con password. Perché è considerata più sicura?</b></summary><br>
Una **chiave SSH** è una credenziale di accesso nel protocollo SSH. La sua funzione è simile a quella di nomi utente e password, ma le chiavi sono utilizzate principalmente per processi automatizzati e per implementare il single sign-on da parte di amministratori di sistema e utenti esperti.
Invece di richiedere la password di un utente, è possibile confermare l'identità del cliente utilizzando algoritmi di crittografia asimmetrica, con chiavi pubbliche e private.
Se il tuo servizio SSH consente solo l'autenticazione con chiave pubblica, un attaccante ha bisogno di una copia di una chiave privata corrispondente a una chiave pubblica memorizzata sul server.
Se il tuo servizio SSH consente l'autenticazione basata su password, il tuo server SSH connesso a Internet sarà martellato giorno e notte da bot-net che cercano di indovinare nomi utente e password. Il bot net non ha bisogno di informazioni, può semplicemente provare nomi popolari e password popolari. Oltre a questo, intasa i tuoi log.
Risorse utili:
- [Autenticazione basata su chiave (Autenticazione con chiave pubblica)](http://www.crypto-it.net/eng/tools/key-based-authentication.html)
- [Autenticazione SSH con password vs. chiave](https://security.stackexchange.com/questions/33381/ssh-password-vs-key-authentication)
</details>
<details>
<summary><b>Cos'è un filtro di pacchetti e come funziona?</b></summary><br>
**Il filtraggio dei pacchetti** è una tecnica firewall utilizzata per controllare l'accesso alla rete monitorando i pacchetti in uscita e in entrata e permettendo loro di passare o fermarsi in base agli indirizzi IP di origine e destinazione, ai protocolli e alle porte.
Il filtraggio dei pacchetti è appropriato dove ci sono requisiti di sicurezza modesti. Le reti interne (private) di molte organizzazioni non sono altamente segmentate. Non sono necessari firewall altamente sofisticati per isolare una parte dell'organizzazione da un'altra.
Tuttavia è prudente fornire una qualche forma di protezione della rete di produzione da un laboratorio o rete sperimentale. Un dispositivo di filtraggio dei pacchetti è una misura molto appropriata per fornire isolamento di una sottorete da un'altra.
Operando al livello di rete e al livello di trasporto della pila di protocolli TCP/IP, ogni pacchetto viene esaminato mentre entra nella pila di protocolli. Le intestazioni di rete e di trasporto vengono esaminate attentamente per le seguenti informazioni:
- **protocollo (intestazione IP, livello di rete)** - nell'intestazione IP, il byte 9 (ricorda che il conteggio dei byte inizia da zero) identifica il protocollo del pacchetto. La maggior parte dei dispositivi di filtraggio ha la capacità di distinguere tra TCP, UDP e ICMP.
- **indirizzo di origine (intestazione IP, livello di rete)** - l'indirizzo di origine è l'indirizzo IP a 32 bit dell'host che ha creato il pacchetto.
- **indirizzo di destinazione (intestazione IP, livello di rete)** - l'indirizzo di destinazione è l'indirizzo IP a 32 bit dell'host a cui è destinato il pacchetto.
- **porta di origine (intestazione TCP o UDP, livello di trasporto)** - ciascuna estremità di una connessione di rete TCP o UDP è associata a una porta. Le porte TCP sono separate e distinte dalle porte UDP. Le porte numerate sotto 1024 sono riservate – hanno un uso specificamente definito. Le porte numerate sopra 1024 (incluse) sono note come porte effimere. Possono essere utilizzate come un fornitore sceglie. Per un elenco delle porte "ben note", fare riferimento a RFP1700. La porta di origine è un numero di porta effimero assegnato pseudo-casualmente. Pertanto spesso non è molto utile filtrare in base alla porta di origine.
- **porta di destinazione (intestazione TCP o UDP, livello di trasporto)** - il numero della porta di destinazione indica una porta a cui il pacchetto viene inviato. Ogni servizio sull'host di destinazione ascolta su una porta. Alcune porte ben note che potrebbero essere filtrate sono 20/TCP e 21/TCP - connessione/dati ftp, 23/TCP - telnet, 80/TCP - http e 53/TCP - trasferimenti di zona DNS.
- **stato della connessione (intestazione TCP, livello di trasporto)** - lo stato della connessione indica se il pacchetto è il primo pacchetto della sessione di rete. Il bit ACK nell'intestazione TCP è impostato su "false" o 0 se questo è il primo pacchetto nella sessione. È semplice impedire a un host di stabilire una connessione rifiutando o scartando qualsiasi pacchetto che abbia il bit ACK impostato su "false" o 0.
Risorse utili:
- [Costruire firewall Internet - Filtraggio dei pacchetti](http://web.deu.edu.tr/static/oreily/networking/firewall/ch06_01.htm)
</details>
<details>
<summary><b>Quali sono i vantaggi dell'utilizzo di un server proxy inverso?</b></summary><br>
**Nascondere la topologia e le caratteristiche dei tuoi server back-end**
Il **server proxy inverso** può nascondere la presenza e le caratteristiche del server di origine. Agisce come intermediario tra il cloud Internet e il server web. È utile per ragioni di sicurezza, specialmente quando si utilizzano servizi di hosting web.
**Consente la manutenzione trasparente dei server back-end**
Le modifiche che apporti ai server che girano dietro un proxy inverso saranno completamente trasparenti per i tuoi utenti finali.
**Bilanciamento del carico**
Il proxy inverso applicherà quindi un algoritmo di bilanciamento del carico come round robin, round robin pesato, minimo numero di connessioni, minimo numero di connessioni pesato o casuale, per distribuire il carico tra i server del cluster.
Quando un server si blocca, il sistema eseguirà automaticamente il failover al server successivo e gli utenti potranno continuare con le loro attività di trasferimento file sicure.
**Offloading/terminazione SSL**
Gestisce le connessioni HTTPS in arrivo, decrittando le richieste e passando le richieste non crittografate ai server web.
**Mascheramento IP**
Utilizzando un singolo IP ma diversi URL per instradare verso diversi server back-end.
Risorse utili:
- [I vantaggi di un proxy inverso](https://dzone.com/articles/benefits-reverse-proxy)
</details>
<details>
<summary><b>Qual è la differenza tra un router e un gateway? Cos'è il gateway predefinito?</b></summary><br>
**Router** descrive la funzione tecnica generale (forwarding di livello 3) o un dispositivo hardware destinato a tale scopo, mentre gateway descrive la funzione per il segmento locale (fornire connettività altrove). Si potrebbe anche affermare che "_si imposta un router come gateway_". Un altro termine è hop che descrive il forwarding tra sottoreti.
Il termine **gateway predefinito** è usato per indicare il router sulla tua LAN che ha la responsabilità di essere il primo punto di contatto per il traffico verso computer al di fuori della LAN.
È solo una questione di prospettiva, il dispositivo è lo stesso.
Risorse utili:
- [Differenza tra router e gateway (originale)](https://networkengineering.stackexchange.com/questions/51426/difference-between-router-and-gateway)
</details>
<details>
<summary><b>Spiega la funzione di ciascuno dei seguenti record DNS: SOA, PTR, A, MX e CNAME.</b></summary><br>
I **record DNS** sono sostanzialmente file di mapping che dicono al server DNS a quale indirizzo IP è associato ogni dominio e come gestire le richieste inviate a ciascun dominio. Alcune sintassi di **record DNS** comunemente utilizzate in quasi tutte le configurazioni di record DNS sono `A`, `AAAA`, `CNAME`, `MX`, `PTR`, `NS`, `SOA`, `SRV`, `TXT` e `NAPTR`.
- **SOA** - Start Of Authority
- **A** - Record di mapping degli indirizzi
- **AAAA** - Record di indirizzi IP versione 6
- **CNAME** - Record di nome canonico
- **MX** - Record di scambio di posta
- **NS** - Record di server dei nomi
- **PTR** - Record di puntatore per lookup inverso
Risorse utili:
- [Elenco dei tipi di record DNS](https://en.wikipedia.org/wiki/List_of_DNS_record_types)
</details>
<details>
<summary><b>Perché gli indirizzi MAC non potrebbero essere usati al posto di IPv4/6 per il networking?</b></summary><br>
Il modello **OSI** spiega perché non ha senso prendere decisioni di routing, un concetto di **livello 3**, basate su un meccanismo fisico di **livello 2**.
Il networking moderno è suddiviso in molti livelli diversi per realizzare la comunicazione end-to-end. La tua scheda di rete (a cui si riferisce l'indirizzo MAC - indirizzo fisico) deve essere responsabile solo della comunicazione con i peer sulla sua rete fisica.
La comunicazione che puoi realizzare con il tuo indirizzo **MAC** sarà limitata ad altri dispositivi che risiedono all'interno del contatto fisico con la tua macchina. Su Internet, ad esempio, non sei fisicamente connesso a ogni macchina. Ecco perché utilizziamo il meccanismo **TCP/IP** (un indirizzo logico di **livello 3**) quando dobbiamo comunicare con una macchina a cui non siamo fisicamente connessi.
**IP** è uno schema di numerazione arbitrario imposto in modo gerarchico su un gruppo di computer per distinguerli logicamente come gruppo (questo è ciò che è una sottorete). L'invio di messaggi tra questi gruppi è effettuato tramite tabelle di routing, a loro volta suddivise in più livelli in modo da non dover tenere traccia di ogni singola sottorete.
È anche abbastanza facile relazionarlo a un'altra coppia di sistemi. Hai un numero di identificazione rilasciato dallo stato, perché avresti bisogno di un indirizzo postale se quel numero ID è già unico per te? Hai bisogno dell'indirizzo postale perché è un sistema arbitrario che descrive dove dovrebbe andare la destinazione unica per le comunicazioni a te.
D'altra parte, la distribuzione degli indirizzi **MAC** attraverso la rete è casuale e completamente estranea alla topologia. Il raggruppamento delle rotte sarebbe impossibile, ogni router dovrebbe tenere traccia delle rotte per ogni singolo dispositivo che inoltra il traffico attraverso di esso. Questo è ciò che fanno gli switch di **livello 2**, e non scala bene oltre un certo numero di host.
Risorse utili:
- [Perché gli indirizzi MAC non potrebbero essere usati al posto di IPv4/6 per il networking? (originale)](https://serverfault.com/questions/410626/why-couldnt-mac-addresses-be-used-instead-of-ipv46-for-networking)
</details>
<details>
<summary><b>Qual è la maschera di sottorete IPv4 più piccola che può essere applicata a una rete contenente fino a 30 dispositivi?</b></summary><br>
Che tu abbia una VLAN standard `/24` per utenti finali, una `/30` per collegamenti punto a punto, o qualcosa nel mezzo, una sottorete che deve contenere fino a 30 dispositivi risulta essere una `/27` - o una maschera di sottorete di `255.255.255.224`.
Risorse utili:
- [Come si calcolano i numeri di prefisso, rete, sottorete e host?](https://networkengineering.stackexchange.com/questions/7106/how-do-you-calculate-the-prefix-network-subnet-and-host-numbers)
- [La barra dopo un indirizzo IP - Notazione CIDR](https://networkengineering.stackexchange.com/questions/3697/the-slash-after-an-ip-address-cidr-notation)
- [Perché ci sono 3 intervalli di indirizzi IPv4 privati?](https://networkengineering.stackexchange.com/questions/32119/why-are-there-3-ranges-of-private-ipv4-addresses)
- [Calcolatore IP](http://jodies.de/ipcalc)
</details>
<details>
<summary><b>Quali sono alcuni codici di stato HTTP comuni?</b></summary><br>
- **1xx** - Risposte informative - comunica informazioni a livello di protocollo di trasferimento
- **2xx** - Successo - indica che la richiesta del client è stata accettata con successo
- **3xx** - Reindirizzamento - indica che il client deve intraprendere un'azione aggiuntiva per completare la richiesta
- **4xx** - Errore lato client - questa categoria di codici di stato di errore indica la responsabilità del client
- **5xx** - Errore lato server - il server si assume la responsabilità per questi codici di stato di errore
Risorse utili:
- [Codici di stato HTTP](https://httpstatuses.com/)
</details>
###### Domande DevOps (5)
<details>
<summary><b>Cos'è DevOps? Cosa è più importante per il successo di una comunità DevOps: come comunicano le persone o gli strumenti che scegli di implementare? ***</b></summary><br>
**DevOps** è un team coeso che si impegna sia in attività di sviluppo che di operazioni, oppure sono team separati di operazioni e sviluppo che lavorano molto a stretto contatto. È più un 'modo' di lavorare in collaborazione con altri dipartimenti per raggiungere obiettivi comuni.
</details>
<details>
<summary><b>Cos'è un controllo di versione? I tuoi messaggi di commit sono ben fatti?</b></summary><br>
È un sistema che registra le modifiche a un file o a un insieme di file nel tempo in modo da poter richiamare versioni specifiche in seguito. I sistemi di controllo di versione consistono in un repository centrale condiviso dove i membri del team possono fare il commit delle modifiche a un file o a un insieme di file. Poi puoi menzionare gli usi del controllo di versione.
Il controllo di versione ti consente di:
- ripristinare i file a uno stato precedente
- ripristinare l'intero progetto a uno stato precedente
- confrontare le modifiche nel tempo
- vedere chi ha modificato qualcosa che potrebbe causare un problema
- chi ha introdotto un problema e quando
Le sette regole per un grande messaggio di commit:
- separare l'oggetto dal corpo con una riga vuota
- limitare la riga dell'oggetto a 50 caratteri
- usare la maiuscola nell'oggetto
- non terminare l'oggetto con un punto
- usare il modo imperativo nell'oggetto
- andare a capo nel corpo a 72 caratteri
- usare il corpo per spiegare cosa e perché, non come
Risorse utili:
- [Iniziare - Informazioni sul controllo di versione (originale)](https://git-scm.com/book/en/v2/Getting-Started-About-Version-Control)
</details>
<details>
<summary><b>Spiega alcuni comandi di base di <code>git</code>.</b></summary><br>
- `git init` - creare un nuovo repository locale
- `git commit -m "messaggio"` - fare il commit delle modifiche al head
- `git status` - elencare i file che hai aggiunto con `git add` e anche fare il commit di eventuali file che hai modificato da allora
- `git push origin master` - inviare le modifiche al ramo master del tuo repository remoto
</details>
<details>
<summary><b>Spiega una semplice pipeline di Continuous Integration.</b></summary><br>
- clonare il repository
- fase di deploy (QA)
- ambiente di test (QA)
- fase di deploy (PROD)
</details>
<details>
<summary><b>Spiega alcuni comandi di base di <code>docker</code>.</b></summary><br>
- `docker ps` - mostrare i container in esecuzione
- `docker ps -a` - mostrare tutti i container
- `docker images` - mostrare le immagini docker
- `docker logs <container-id|container-name>` - ottenere i log dal container
- `docker network ls` - mostrare tutte le reti docker
- `docker volumes ls` - mostrare tutti i volumi docker
- `docker exec -it <container-id|container-name> bash` - eseguire bash in un container con shell interattiva
</details>
###### Domande di Sicurezza Informatica (1)
<details>
<summary><b>Cos'è una Configurazione di Sicurezza Errata?</b></summary><br>
**La configurazione di sicurezza errata** è una vulnerabilità quando un dispositivo/applicazione/rete è configurato in modo tale da poter essere sfruttato da un attaccante per trarne vantaggio. Questo può essere semplice come lasciare il nome utente/password predefiniti invariati o troppo semplici per gli account del dispositivo, ecc.
</details>
### :diamond_shape_with_a_dot_inside: <a name="regular-sysadmin">Sysadmin Regolare</a>
###### Domande di Sistema (60)
<details>
<summary><b>Parlami della tua esperienza con gli ambienti di produzione? ***</b></summary><br>
Da completare.
</details>
<details>
<summary><b>Quale distribuzione sceglieresti per eseguire un server web importante? ***</b></summary><br>
Da completare.
</details>
<details>
<summary><b>Spiega in pochi punti il processo di avvio del sistema Linux.</b></summary><br>
**BIOS**: La forma estesa di BIOS è Basic Input Output System che esegue controlli di integrità, cerca e carica, e poi esegue il bootloader.
**Bootloader**: Poiché le fasi precedenti non sono specifiche del sistema operativo, il processo di avvio basato su BIOS per le architetture x86 e x86-64 è considerato iniziare quando il codice del master boot record (MBR) viene eseguito in modalità reale e viene caricato il bootloader di primo stadio. Nei sistemi UEFI, un payload, come il kernel Linux, può essere eseguito direttamente. Quindi non è necessario alcun bootloader. Alcuni bootloader popolari: **GRUB**, **Syslinux/Isolinux** o **Lilo**.
**Kernel**: Il kernel in Linux gestisce tutti i processi del sistema operativo, come la gestione della memoria, la pianificazione dei task, I/O, comunicazione tra processi e il controllo generale del sistema. Viene caricato in due fasi - nella prima fase, il kernel (come file immagine compresso) viene caricato in memoria e decompresso, e vengono impostate alcune funzioni fondamentali come la gestione base della memoria.
**Init**: È il genitore di tutti i processi sul sistema, viene eseguito dal kernel ed è responsabile dell'avvio di tutti gli altri processi.
- `SysV init` - Il compito di init è "far funzionare tutto come dovrebbe una volta che il kernel è completamente in esecuzione. Essenzialmente stabilisce e gestisce l'intero spazio utente. Questo include il controllo e il montaggio dei filesystem, l'avvio dei servizi utente necessari e infine il passaggio a un ambiente utente quando l'avvio del sistema è completato.
- `systemd` - Gli sviluppatori di systemd miravano a sostituire il sistema init Linux ereditato da Unix System V. Come init, systemd è un demone che gestisce altri demoni. Tutti i demoni, incluso systemd, sono processi in background. Systemd è il primo demone ad avviarsi (durante l'avvio) e l'ultimo demone a terminare (durante lo spegnimento).
- `runinit` - runinit è uno schema init per sistemi operativi simili a Unix che inizializza, supervisiona e termina i processi in tutto il sistema operativo. È una reimplementazione del toolkit di supervisione dei processi daemontools che gira su Linux, Mac OS X, \*BSD e sistemi operativi Solaris.
Risorse utili:
- [Analisi del processo di avvio di Linux](https://opensource.com/article/18/1/analyzing-linux-boot-process)
- [Processo di avvio di systemd: uno sguardo approfondito in Linux](https://linoxide.com/linux-how-to/systemd-boot-process/)
</details>
<details>
<summary><b>Come e perché i demoni Linux abbandonano i privilegi? Perché alcuni demoni necessitano dei permessi di root per avviarsi? Spiega. ***</b></summary>
Da completare.
</details>
<details>
<summary><b>Perché un carico di 1.00 non è ideale su una macchina single-core?</b></summary><br>Il problema con un carico di 1.00 è che non hai margine di manovra. In pratica, molti amministratori di sistema tracciano una linea a 0.70.
La "Regola empirica da tenere d'occhio": 0.70. Se la tua media di carico rimane stabilmente sopra 0.70, è il momento di indagare prima che la situazione peggiori.
La "Regola empirica da risolvere subito": 1.00. Se la tua media di carico rimane stabilmente sopra 1.00, trova il problema e risolvilo immediatamente. Altrimenti, verrai svegliato nel cuore della notte e non sarà divertente.
Regola empirica: 5.0. Se la tua media di carico supera 5.00, potresti essere in seri guai: il tuo server si blocca o rallenta notevolmente, e questo accadrà (inspiegabilmente) nel momento peggiore possibile, come nel cuore della notte o mentre tieni una presentazione a una conferenza. Non lasciare che arrivi a quel punto.
Risorse utili:
- [Modo corretto di interpretare il carico di sistema su un processore a 4 core e 8 thread](https://serverfault.com/questions/618130/proper-way-of-interpreting-system-load-on-a-4-core-8-thread-processor)
- [Comprendere il carico della CPU in Linux – quando dovresti preoccuparti?](http://blog.scoutapp.com/articles/2009/07/31/understanding-load-averages)
</details>
<details>
<summary><b>Cosa significa quando l'utente effettivo è root, ma l'ID utente reale è ancora il tuo nome?</b></summary><br>
L'**ID utente reale** è chi sei veramente (l'utente che possiede il processo), mentre l'**ID utente effettivo** è ciò che il sistema operativo controlla per decidere se ti è permesso fare qualcosa (nella maggior parte dei casi, ci sono alcune eccezioni).
Quando accedi, la shell di login imposta sia l'**ID utente reale che quello effettivo** allo stesso valore (il tuo **ID utente reale**) come fornito dal file delle password.
Se, per esempio, esegui setuid e, oltre a funzionare come un altro utente (ad esempio **root**), il programma setuid dovrebbe anche fare qualcosa per tuo conto.
Dopo aver eseguito setuid, avrà il tuo **ID reale** (poiché sei il proprietario del processo) e l'ID utente effettivo del proprietario del file (ad esempio **root**) poiché è setuid.
Usiamo il caso di `passwd`:```bash
-rwsr-xr-x 1 root root 45396 may 25 2012 /usr/bin/passwd
Usare logrotate è il modo usuale per gestire i file di log. Ma invece di aggiungere contenuto a /etc/logrotate.conf dovresti aggiungere il tuo job a /etc/logrotate.d/, altrimenti dovresti guardare più differenze dei file di configurazione durante gli aggiornamenti di release.
Se viene scritto attivamente, non hai molto che puoi fare per troncarlo. Le tue uniche opzioni sono troncare il file:```bash : >/var/log/massive-logfile
È molto utile, perché tronca il file senza interrompere i processi.
Risorse utili:
- [Come usare logrotate per gestire i file di log](https://www.linode.com/docs/uptime/logs/use-logrotate-to-manage-log-files/)
- [Log di sistema](https://www.ibm.com/developerworks/library/l-lpic1-108-2/index.html)
</details>
<details>
<summary><b>Come il kernel Linux crea, gestisce e elimina i processi nel sistema? ***</b></summary><br>
Da completare.
Risorse utili:
- [Processi Linux](https://www.tldp.org/LDP/tlk/kernel/processes.html)
</details>
<details>
<summary><b>Spiegare le informazioni selezionate che si possono vedere in <code>top</code> e <code>htop</code>. Come diagnosticare il carico, l'elevato tempo utente e i problemi di memoria insufficiente con questi strumenti? ***</b></summary><br>
Da completare.
Risorse utili:
- [top spiegato visivamente](https://www.svennd.be/top-explained-visually/)
- [htop spiegato visivamente](https://codeahoy.com/2017/01/20/hhtop-explained-visually/)
- [Spiegazione di tutto ciò che si può vedere in htop/top su Linux](https://peteris.rocks/blog/htop/)
</details>
<details>
<summary><b>Come riconosceresti un processo che sta monopolizzando le risorse? </b></summary><br>
`top` funziona abbastanza bene, purché si guardino i numeri giusti.
- **M** Ordina per utilizzo corrente della memoria residente
- **T** Ordina per utilizzo totale (o cumulativo) della CPU
- **P** Ordina per utilizzo corrente della CPU (questo è l'aggiornamento predefinito)
- **?** Mostra un riepilogo dell'utilizzo per tutti i comandi di top
Questa è un'informazione molto importante da ottenere quando si risolvono i problemi del perché un processo del computer è lento e si prendono decisioni su quali processi terminare/software disinstallare.
Risorse utili:
- [Come trovare i processi che stanno monopolizzando la macchina](https://superuser.com/questions/326300/how-to-find-the-processes-which-are-hogging-the-machine)
</details>
<details>
<summary><b>Devi aggiornare il servizio <code>ntpd</code> su 200 server. Qual è il modo migliore per aggiornarli tutti all'ultima versione?</b></summary><br>
Utilizzando un approccio **Infrastruttura come Codice**, ci sono diversi modi validi:
1. **Modello di gestione delle modifiche tramite sincronizzazione della configurazione**:
Esistono strumenti di gestione della configurazione (Ansible, Chef, Puppet, Saltstack, ...) che possono essere utilizzati per aggiornare automaticamente il servizio `ntpd` su tutti i server. Per mantenere stabili i sistemi, i pacchetti di sistema sui server vengono solitamente aggiornati automaticamente solo con gli aggiornamenti di sicurezza. Le versioni principali o minori dei pacchetti sono solitamente bloccate per versione nelle definizioni di configurazione per prevenire una configurazione errata del servizio. La modifica viene quindi distribuita cambiando la versione di `ntpd` nella definizione di configurazione.
Con questo approccio, è importante fare attenzione quando si distribuiscono modifiche nell'infrastruttura in modo massiccio. La pipeline di distribuzione dovrebbe includere test unitari, di integrazione e di sistema, e alla fine essere distribuita prima nell'ambiente di staging per verificare la configurazione. Se i test dimostrano la correttezza della configurazione, la distribuzione dovrebbe essere effettuata con un'implementazione incrementale con la possibilità di eseguire il rollback in caso di errori o guasti.
2. **Modello dei server immutabili**:
Nel modello del server immutabile, l'intera unità (server, contenitore) viene sostituita da una nuova immagine aggiornata invece di apportare modifiche al server in esecuzione (questo elimina la deriva della configurazione). Con questo approccio di solito si crea un'immagine del server con strumenti come Packer o Docker con Dockerfile. Questa immagine viene poi testata e distribuita in modo simile all'opzione sopra (1.), ma ora utilizzando tecniche come Canary Release, che ha anche la capacità di implementazione incrementale e rollback.
Risorse utili:
- [Infrastructure as a Code - Capitolo 8: Pattern per l'aggiornamento e la modifica dei server](http://shop.oreilly.com/product/0636920039297.do)
</details>
<details>
<summary><b>Come impostare permanentemente <code>$PATH</code> su Linux/Unix? Perché questa variabile è così importante? ***</b></summary>
Da completare.
</details>
<details>
<summary><b>Quando il server si avvia, alcuni errori appaiono sulla console. Come esaminare i messaggi di avvio e dove sono memorizzati?</b></summary><br>
La tua console ha due tipi di messaggi:
- **generati dal kernel** (tramite printk)
- **generati dallo spazio utente** (di solito il tuo sistema init)
I messaggi del kernel sono sempre memorizzati nel buffer **kmsg**, visibili tramite il comando `dmesg`. Vengono anche spesso copiati nel tuo **syslog**. Questo vale anche per i messaggi dello spazio utente scritti in `/dev/kmsg`, ma sono piuttosto rari.
Nel frattempo, quando lo spazio utente scrive il suo testo di stato di avvio elaborato su `/dev/console` o `/dev/tty1`, non viene memorizzato da nessuna parte. Va solo sullo schermo e basta.
`dmesg` viene utilizzato per esaminare i messaggi di avvio contenuti nel ring buffer del kernel. Un ring buffer è un buffer di dimensione fissa per il quale qualsiasi nuovo dato aggiunto sovrascrive i dati più vecchi in esso contenuti.
Mostra le operazioni una volta completato il processo di avvio, come le opzioni della riga di comando passate al kernel; componenti hardware rilevati, eventi quando viene aggiunto un nuovo dispositivo USB, o errori come il guasto della scheda di interfaccia di rete (NIC) e i driver segnalano nessuna attività di collegamento rilevata sulla rete e molto altro.
Se la registrazione di sistema viene effettuata tramite il componente journal, dovresti usare `journalctl`. Mostra messaggi che includono messaggi del kernel e di avvio; messaggi da syslog o vari servizi.
Problemi/errori di avvio richiedono che un amministratore di sistema esamini alcuni file importanti insieme a comandi particolari (gestiti diversamente dalle diverse versioni di Linux):
- `/var/log/boot.log` - log di avvio del sistema, contiene tutto ciò che si è svolto durante l'avvio del sistema
- `/var/log/messages` - memorizza i messaggi globali di sistema, inclusi i messaggi registrati durante l'avvio del sistema
- `/var/log/dmesg` - contiene le informazioni del ring buffer del kernel
Risorse utili:
- [Come visualizzare tutti i messaggi di avvio in Linux dopo l'avvio? (originale)](https://superuser.com/questions/1188407/how-to-view-all-boot-messages-in-linux-after-booting)
- [Differenze nei file di log /var/log/{syslog,dmesg,messages}](https://superuser.com/questions/565927/differences-in-var-log-syslog-dmesg-messages-log-files)
- [Come si possono esaminare in seguito i messaggi che scorrono durante l'avvio di un sistema Debian?](https://serverfault.com/questions/516411/all-debian-boot-messages)
</details>
<details>
<summary><b>Utilizzo dello swap troppo alto. Quali sono le ragioni di ciò e come risolvere i problemi di swapping?</b></summary><br>
Lo **swap** è una quantità limitata di memoria fisica allocata per l'uso da parte del sistema operativo quando la memoria disponibile è stata completamente utilizzata. È una gestione della memoria che comporta lo scambio di sezioni di memoria da e verso la memoria fisica.
Se il sistema necessita di più risorse di memoria e la RAM è piena, le pagine inattive in memoria vengono spostate nello spazio di swap. Sebbene lo swap possa aiutare le macchine con poca RAM, non dovrebbe essere considerato un sostituto di più RAM. Lo spazio di swap si trova sui dischi rigidi, che hanno un tempo di accesso più lento rispetto alla memoria fisica.
Il carico di lavoro aumenta la domanda di RAM. Stai eseguendo un carico di lavoro che richiede più memoria. L'utilizzo dell'intero swap lo indica. Inoltre, cambiare `swappiness` a **1** potrebbe non essere una decisione saggia. Impostare `swappiness` a **1** non significa che lo swapping non verrà eseguito. Indica solo quanto aggressivo sarà il kernel rispetto allo swapping, non elimina lo swapping. Lo swapping avverrà se necessario.
- **Aumentare la dimensione dello spazio di swap** - in primo luogo, si avrebbe un aumento dell'uso del disco. Se i dischi non sono abbastanza veloci da tenere il passo, il sistema potrebbe finire per trashing, e si potrebbero sperimentare rallentamenti mentre i dati vengono scambiati dentro e fuori dalla memoria. Ciò si tradurrebbe in un collo di bottiglia.
- **Aggiungere più RAM** - la vera soluzione è aggiungere più memoria. Non c'è sostituto per la RAM, e se hai abbastanza memoria, farai meno swapping.
Per monitorare l'utilizzo dello spazio di swap:
- `cat /proc/swaps` - per vedere la dimensione totale e utilizzata dello swap
- `grep SwapTotal /proc/meminfo` - per mostrare lo spazio totale di swap
- `free` - per visualizzare la quantità di memoria di sistema libera e utilizzata (anche swap)
- `vmstat` - per controllare le statistiche di swapping
- `top`, `htop` - per controllare l'utilizzo dello spazio di swap
- `atop` - per mostrare se il sistema sta sovraallocando memoria
- oppure usa un comando shell one-liner per elencare tutte le applicazioni con quanto spazio di swap stanno utilizzando in kilobyte:```bash
for _fd in /proc/*/status ; do
awk '/VmSwap|Name/{printf $2 " " $3}END{ print ""}' $_fd
done | sort -k 2 -n -r | less
Su Linux e altri sistemi operativi simili a Unix, i nuovi file vengono creati con un insieme predefinito di permessi. In particolare, i permessi di un nuovo file possono essere limitati in un modo specifico applicando una "maschera" di permessi chiamata umask. Il comando umask viene utilizzato per impostare questa maschera o per mostrarne il valore corrente.
Per modificare in modo permanente (ad esempio impostare umask 02):
~/.profile~/.bashrc~/.zshrc~/.cshrcUseful resources:
Sotto il file system, i file sono rappresentati da inode (o forse da più inode, non sono sicuro)
Quando si elimina un file, viene rimosso un collegamento all'inode sottostante. L'inode viene eliminato (o reso eliminabile/sovrascrivibile) solo quando tutti i collegamenti all'inode sono stati eliminati.
Una volta creato un hard link, il collegamento è all'inode. Eliminare, rinominare o spostare il file originale non influirà sull'hard link perché esso si collega all'inode sottostante. Qualsiasi modifica ai dati sull'inode si riflette in tutti i file che fanno riferimento a quell'inode.
Nota: gli hard link sono validi solo all'interno dello stesso file system. I link simbolici possono attraversare file system perché sono semplicemente il nome di un altro file.
Differenze:
Useful resources:
SUID/GUID?Questa è probabilmente una delle cose più fastidiose che la gente sbaglia sempre. Il bit SUID/GUID e lo sticky-bit sono due cose completamente diverse.
Se esegui man chmod puoi leggere informazioni su SUID e sticky-bits.
SUID/GUID
Quello che la pagina man sopra sta cercando di dire è che la posizione che il bit x occupa in rwxrwxrwx per l'ottale utente (1° gruppo di rwx) e l'ottale gruppo (2° gruppo di rwx) può assumere uno stato aggiuntivo in cui la x diventa una s. Quando ciò accade, questo file, se eseguito (se è un programma e non solo uno script di shell), verrà eseguito con i permessi del proprietario o del gruppo del file.
Quindi se il file è di proprietà di root e il bit SUID è attivato, il programma verrà eseguito come root. Anche se lo esegui come utente normale. La stessa cosa vale per il bit GUID.
Esempi:
nessun suid/guid - sono impostati solo i bit rwxr-xr-x.```bash
ls -lt b.pl
-rwxr-xr-x 1 root root 179 Jan 9 01:01 b.pl
**suid e bit eseguibile dell'utente abilitato (s minuscola)** - i bit `rwsr-x-r-x` sono impostati.```bash
chmod u+s b.pl
ls -lt b.pl
-rwsr-xr-x 1 root root 179 Jan 9 01:01 b.pl
suid abilitato e bit eseguibile disabilitato (S maiuscola) - i bit rwSr-xr-x sono impostati.```bash
chmod u-x b.pl
ls -lt b.pl
-rwSr-xr-x 1 root root 179 Jan 9 01:01 b.pl
**guid e bit eseguibile del gruppo abilitato (s minuscola)** - i bit `rwxr-sr-x` sono impostati.```bash
chmod g+s b.pl
ls -lt b.pl
-rwxr-sr-x 1 root root 179 Jan 9 01:01 b.pl
LC_ALL=C prima di un comando? In quali casi è utile?LC_ALL è la variabile d'ambiente che sovrascrive tutte le altre impostazioni di localizzazione. Imposta tutte le variabili di tipo LC_ in una volta a una specifica locale.
Il motivo principale per impostare LC_ALL=C prima di un comando è semplicemente per ottenere output in inglese (cambiare genericamente la locale usata dal comando).
D'altra parte, è importante anche per aumentare la velocità di esecuzione dei comandi con LC_ALL=C, ad esempio grep o fgrep. Usare la locale LC_ALL=C ha aumentato le prestazioni e ridotto i tempi di esecuzione dei comandi.
Ad esempio, se imposti LC_ALL=en_US.utf8, il tuo sistema apre molti file dalla directory /usr/lib/locale. Con LC_ALL=C viene eseguita una quantità minima di operazioni di apertura e lettura.
Se vuoi ripristinare tutte le impostazioni normali (originali) della locale per la sessione:```bash LC_ALL=
Da completare.
1) Requisiti principali - tieni a mente questo
/var/www/app01/htmlumask corretto per gli utenti e suid/sgid (solo per situazioni specifiche)2) Directory delle applicazioni
/var/www contiene una directory per ogni sito web (isolamento delle app), es. /var/www/app01, `/var/www/app02````bash
mkdir /var/www/{app01,app02}
**3) Proprietario e gruppo dell'applicazione**
Ogni applicazione ha un **proprietario** designato (es. **u01-prod**, **u02-prod**) e un **gruppo** (es. **g01-prod**, **g02-prod**) che sono impostati come proprietari di tutti i file e le directory nella directory del sito web:```bash
chown -R u01-prod:g01-prod /var/www/app01
chown -R u02-prod:g02-prod /var/www/app02
4) Proprietario e gruppo degli sviluppatori
Tutti gli utenti che mantengono il sito web hanno i propri gruppi e sono collegati al gruppo dell'applicazione:```bash id alice uid=2000(alice) gid=4000(alice) groups=8000(g01-prod) id bob uid=2001(bob) gid=4001(bob) groups=8000(g01-prod),8001(g02-prod)
Per impostare i parametri del kernel in Unix-like, modifica prima il file /etc/sysctl.conf, dopo aver apportato le modifiche salva il file ed esegui il comando sysctl -p; questo comando renderà le modifiche permanenti senza riavviare la macchina.
Risorse utili:
/proc./proc è un filesystem virtuale che fornisce informazioni dettagliate sul kernel, l'hardware e i processi in esecuzione.
Poiché /proc contiene file virtuali, viene chiamato filesystem virtuale. Questi file virtuali hanno qualità uniche. La maggior parte di essi è elencata con dimensione zero byte.
File virtuali come /proc/interrupts, /proc/meminfo, /proc/mounts e /proc/partitions forniscono un'istantanea aggiornata dell'hardware del sistema. Altri: il file /proc/filesystems e la directory /proc/sys/ forniscono informazioni di configurazione di sistema e interfacce.
Risorse utili:
Da completare.
Nei filesystem ext3/ext4 sono disponibili tre tipi di journaling:
Un inode è una struttura dati su un filesystem in Linux e altri sistemi operativi simili a Unix che memorizza tutte le informazioni su un file tranne il suo nome e i dati effettivi. Una struttura dati è un modo di memorizzare i dati in modo che possano essere utilizzati in modo efficiente.
Un file Unix è memorizzato in due parti diverse del disco: i blocchi dati e gli inode. Non entrerò nei dettagli di superblocchi e altre informazioni esoteriche. I blocchi dati contengono il "contenuto" del file. Le informazioni sul file sono memorizzate altrove: nell'inode.
Il numero di inode di un file può essere facilmente trovato usando il comando ls, che per impostazione predefinita elenca gli oggetti (file, link e directory) nella directory corrente (cioè la directory in cui l'utente sta lavorando), con la sua opzione -i. Quindi, ad esempio, il seguente comando mostrerà il nome di ogni oggetto nella directory corrente insieme al suo numero di inode:```bash
ls -i
`df's` opzione `-i` indica di fornire informazioni sugli inode su ogni filesystem anziché sullo spazio disponibile. Specificamente, dice a df di restituire per ogni filesystem montato il numero totale di inode, il numero di inode liberi, il numero di inode usati e la percentuale di inode usati. Questa opzione può essere usata insieme all'opzione `-h` come segue per rendere l'output più facile da leggere:```bash
df -hi
Trovare file tramite inode
Se conosci l'inode, puoi trovarlo usando il comando find:```bash find . -inum 435304 -print
**Eliminare file con nomi strani**
A volte vengono creati file con caratteri strani nel nome. Il file system Unix permette qualsiasi carattere come parte di un nome di file, tranne il null (ASCII 000) o "/". Ogni altro carattere è permesso.
Gli utenti possono creare file con caratteri che rendono difficile vedere la directory o il file. Possono creare la directory ".. " con uno spazio alla fine, o creare un file che ha un backspace nel nome, usando:```bash
touch `printf "aa\bb"`
ls -l mostra attributi file come punti interrogativi. Cosa significa e quali passi intraprenderai per rimuovere file "zombie" inutilizzati?Questo problema potrebbe essere più difficile da risolvere perché potrebbero essere necessari diversi passaggi - a volte si ottiene test/file: Permission denied, test/file: No such file or directory o test/file: Input/output error.
Ciò accade quando l'utente non può eseguire stat() sui file (che richiede permessi di esecuzione), ma può leggere le voci della directory (che richiede accesso in lettura sulla directory). Quindi si ottiene un elenco di file nella directory, ma non si possono ottenere informazioni sui file perché non possono essere letti. Se hai una directory con permesso di lettura ma non di esecuzione, vedrai questo.
Alcuni processi come rsync generano file temporanei che vengono creati e rimossi rapidamente, causando errori se si tenta di chiamare altri semplici comandi di gestione dei file come rm, mv ecc.
Esempio di output:```bash ?????????? ? ? ? ? ? sess_kee6fu9ag7tiph2jae
1) modificare i permessi: `chmod 0777 sess_kee6fu9ag7tiph2jae` e provare a rimuovere
2) cambiare proprietario: `chown root:root sess_kee6fu9ag7tiph2jae` e provare a rimuovere
3) modificare permessi e proprietario per la directory: `chmod -R 0777 dir/ && chown -R root:root dir/` e provare a rimuovere
4) ricreare il file: `touch sess_kee6fu9ag7tiph2jae` e provare a rimuovere
5) fare attenzione ad altri processi in esecuzione sul server ad esempio `rsync`, a volte questo può essere un errore transitorio quando un server NFS è pesantemente sovraccarico
6) trovare l'inode del file: `ls -i`, e provare a rimuovere: `find . -inum <inode_num> -delete`
7) rimontare (se possibile) il filesystem
8) avviare il sistema in modalità single-user e riparare il filesystem con `fsck`
Risorse utili:
- [Punti interrogativi in ls di directory. Anche errori IO.](https://serverfault.com/questions/65616/question-marks-showing-in-ls-of-directory-io-errors-too)
</details>
<details>
<summary><b>LVM sì o LVM no. Quali vantaggi offre?</b></summary><br>
- LVM rende molto facile spostare i filesystem
- puoi estendere un volume group su un nuovo volume fisico
- spostare un numero qualsiasi di volumi logici da un vecchio volume fisico
- rimuovere quel volume dal volume group senza bisogno di smontare alcuna partizione
- puoi anche creare snapshot di volumi logici per fare backup
- LVM ha il supporto integrato per il mirroring, così puoi avere un volume logico replicato su più volumi fisici
- LVM supporta anche TRIM
Risorse utili:
- [Cos'è LVM e a cosa serve?](https://askubuntu.com/questions/3596/what-is-lvm-and-what-is-it-used-for)
</details>
<details>
<summary><b>Come aumentare la dimensione di una partizione LVM?</b></summary><br>
Usa il comando `lvextend` per ridimensionare la partizione LVM.
- estendere la dimensione di 500MB:```bash
lvextend -L +500M /dev/vgroup/lvolume
Ad esempio (con il comando visudo):```bash
user1 ALL=(user2) NOPASSWD: /opt/scripts/bin/generate.sh
I comandi devono usare percorsi assoluti! Quindi esegui `sudo -u user2 /opt/scripts/bin/generate.sh` da una shell dell'utente user1.
</details>
<details>
<summary><b>Come verificare se si sta eseguendo come root in uno script bash? A cosa bisogna prestare attenzione?</b></summary><br>
In uno script bash, ci sono diversi modi per verificare se l'utente in esecuzione è root.
Come avvertimento, non controllare se un utente è root utilizzando il nome utente root. Nulla garantisce che l'utente con ID 0 si chiami root. È una convenzione molto forte seguita ampiamente, ma chiunque potrebbe rinominare il superuser con un altro nome.
Penso che il modo migliore quando si usa bash sia usare `$EUID` perché `$UID` potrebbe essere modificato e non riflettere l'utente reale che sta eseguendo lo script.```bash
if (( $EUID != 0 )); then
echo "Please run as root"
exit
fi
nobody? Dimmi le differenze nell'eseguire il servizio httpd come account nobody e www-data.In molte varianti Unix, nobody è il nome convenzionale di un account utente che non possiede file, non appartiene a gruppi privilegiati e non ha abilità se non quelle che ogni altro utente possiede.
È comune eseguire demoni come nobody, specialmente server, per limitare i danni che un utente malintenzionato potrebbe causare se riuscisse a prenderne il controllo.
Tuttavia, l'utilità di questa tecnica è ridotta se più di un demone viene eseguito in questo modo, perché il controllo di un demone fornirebbe il controllo di tutti gli altri. Il motivo è che i processi posseduti da nobody hanno la capacità di inviarsi segnali a vicenda e persino di eseguire il debug reciproco, consentendo loro di leggere o addirittura modificare la memoria l'uno dell'altro.
Quando dovrei usare l'account nobody?
Quando non sono richieste autorizzazioni per le operazioni di un programma. Ciò è particolarmente evidente quando non ci sarà mai alcuna attività su disco.
Un esempio reale è memcached (una cache/database/oggetto in memoria chiave-valore), in esecuzione sul mio computer e sul mio server sotto l'account nobody. Perché? Perché semplicemente non ha bisogno di alcuna autorizzazione e dargli un account che avesse accesso in scrittura ai file sarebbe un rischio inutile.
Il comando che cerchi si chiama tee:
foo | tee output.file
Ad esempio, se ti interessa solo stdout:
ls -a | tee output.file
Se vuoi includere stderr, fai:
program [arguments...] 2>&1 | tee outfile
2>&1 reindirizza il canale 2 (stderr/errore standard) nel canale 1 (stdout/output standard), in modo che entrambi vengano scritti come stdout. Vengono anche diretti al file di output specificato grazie al comando tee.
Inoltre, se vuoi aggiungere al file di log, usa tee -a come:
program [arguments...] 2>&1 | tee -a outfile
./script o bash script?Dovresti usare #!/usr/bin/env bash per portabilità: diversi *nix posizionano bash in posti diversi, e usare /usr/bin/env è una soluzione alternativa per eseguire il primo bash trovato nel PATH.
Eseguire ./script fa esattamente questo e richiede il permesso di esecuzione sul file, ma è agnostico rispetto al tipo di programma. Potrebbe essere uno script bash, uno script sh, o uno script Perl, Python, awk o expect, o un eseguibile binario vero e proprio. Eseguire bash script lo forzerebbe a essere eseguito sotto sh, invece che altro.
Risorse utili:
Usa nohup per far sì che il tuo processo ignori il segnale di hangup:
nohup long-running-command &
``````bash
nohup long-running-process &
exit
o se vuoi usare GNU Screen:```bash screen -d -m long-running-process exit
Risorse utili:
- [5 modi per mantenere attive le sessioni SSH remote e i processi dopo la disconnessione](https://www.tecmint.com/keep-remote-ssh-sessions-running-after-disconnection/)
</details>
<details>
<summary><b>Qual è lo scopo principale delle autorità di certificazione intermedie?</b></summary><br>
Per scoprire lo scopo principale di una CA intermedia, dovresti prima imparare cosa sono le **CA radice**, le **CA intermedie** e la **Catena di fiducia del certificato SSL**.
**Le CA radice** sono CA primarie che di solito non firmano direttamente certificati per entità finali/server. Emettono certificati radice che sono generalmente preinstallati in tutti i browser, dispositivi mobili e applicazioni. La chiave privata di questi certificati viene utilizzata per firmare altri certificati successivi chiamati certificati intermedi. Le CA radice sono solitamente mantenute "offline" e in un ambiente altamente sicuro con accesso rigorosamente limitato.
**Le CA intermedie** sono CA subordinate alla CA radice di uno o più livelli, da essa fidate per firmare certificati per suo conto. Lo scopo di creare e utilizzare CA intermedie è principalmente per la sicurezza perché se la chiave privata intermedia viene compromessa, la CA radice può revocare il certificato intermedio e crearne uno nuovo con una nuova coppia di chiavi crittografiche.
**La Catena di fiducia del certificato SSL** è l'elenco di certificati SSL, dal certificato radice al certificato dell'entità finale/server. Perché un certificato SSL sia attendibile, deve essere emesso da una CA fidata inclusa nell'elenco delle CA fidate del dispositivo di connessione (browser, mobile e applicazione). Pertanto, il dispositivo di connessione verificherà l'affidabilità di ciascun certificato SSL nella Catena di fiducia fino a trovare una corrispondenza con quello emesso da una CA fidata.
La struttura **CA radice-CA intermedia** è creata da ogni CA principale per proteggersi dagli effetti disastrosi di una compromissione della chiave radice. Se una chiave radice viene compromessa, renderebbe inaffidabili la radice e tutti i certificati subordinati. Per questo motivo, creare una CA intermedia è una buona pratica per garantire una protezione rigorosa della chiave radice primaria.
Risorse utili:
- [Come funzionano le catene di certificati](https://knowledge.digicert.com/solution/SO16297.html)
</details>
<details>
<summary><b>Come ricaricare PostgreSQL dopo modifiche alla configurazione?</b></summary><br>
Soluzione 1:```bash
systemctl reload postgresql
.profile. Come ricaricare la shell senza uscire?Il modo migliore è exec $SHELL -l perché exec sostituisce il processo corrente con uno nuovo. Un'altra buona soluzione (ma diversa) è . ~/.profile.
Risorse utili:
| Il tipo di capitolo | Numero di domande | Breve descrizione |
|---|
| Introduzione | ||
| 🔸 Domande semplici | 14 domande | Rilassate, divertenti e semplici - sono ottime per iniziare. |
| Conoscenze generali | ||
| 🔸 Sysadmin Junior | 65 domande | Abbastanza semplici e dirette basate su conoscenze di base. |
| 🔸 Sysadmin Regolare | 94 domande | Livello medio di domande per chi ha buone conoscenze. |
| 🔸 Sysadmin Senior | 99 domande | Domande difficili e indovinelli. Mettiti alla prova se vuoi essere bravo. |
| Conoscenze segrete | ||
| 🔸 Sysadmin Guru | 12 domande | Domande davvero profonde per conoscere un Guru Sysadmin. |
Suggerimenti e Trucchi
CTRL + Rpopd/pushd e altri built-in della shell che ti permettono di manipolare lo stack delle directoryCTRL + U, CTRL + E!* - tutti gli argomenti dell'ultimo comando!! - l'intero ultimo comando!ssh - ultimo comando che inizia con sshRisorse utili:
Per informazioni dettagliate, inclusi nome utente, terminale, numero IP del computer di origine, l'ora in cui è iniziato l'accesso, eventuali tempi di inattività, cicli CPU del processo, cicli CPU del job e il comando attualmente in esecuzione, inserire:```bash
w
Importante anche per visualizzare un elenco degli ultimi utenti che hanno effettuato l'accesso, inserisci:```bash
# It uses /var/log/wtmp.
last
Risorse utili:
o```bash grep -e "string1" -e "string2" filename
Risorse utili:
- [Cos'è grep e come si usa? (originale)](https://kb.iu.edu/d/afiy)
</details>
<details>
<summary><b>Spiega i comandi per il contenuto dei file con la descrizione.</b></summary><br>
- `head`: per controllare l'inizio di un file.
- `tail`: per controllare la fine del file. È l'inverso del comando head.
- `cat`: usato per visualizzare, creare, concatenare i file.
- `more`: usato per visualizzare il testo nella finestra del terminale in forma di pager.
- `less`: usato per visualizzare il testo in senso inverso e fornisce anche il movimento riga per riga.
Risorse utili:
- [Visualizzare file di testo dal prompt della shell](https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/4/html/Step_by_Step_Guide/s1-viewingtext-terminal.html)
</details>
<details>
<summary><b>Segnali POSIX SIGHUP, SIGINT, SIGKILL e SIGTERM. Spiega.</b></summary><br>
- **SIGHUP** - viene inviato a un processo quando il suo terminale di controllo viene chiuso. Originariamente progettato per notificare al processo una caduta di linea seriale (un hangup). Molti demone ricaricheranno i loro file di configurazione e riapriranno i loro file di log invece di uscire quando ricevono questo segnale.
- **SIGINT** - viene inviato a un processo dal suo terminale di controllo quando un utente desidera interrompere il processo. Tipicamente avviato premendo `Ctrl+C`, ma su alcuni sistemi si può usare il carattere "delete" o il tasto "break".
- **SIGKILL** - viene inviato a un processo per farlo terminare immediatamente (kill). A differenza di **SIGTERM** e **SIGINT**, questo segnale non può essere catturato o ignorato, e il processo ricevente non può eseguire alcuna pulizia al momento della ricezione.
- **SIGTERM** - viene inviato a un processo per richiederne la terminazione. A differenza del segnale **SIGKILL**, può essere catturato e interpretato o ignorato dal processo. Ciò consente al processo di eseguire una terminazione pulita rilasciando risorse e salvando lo stato se appropriato. **SIGINT** è quasi identico a **SIGTERM**.
Risorse utili:
- [Segnali POSIX](https://dsa.cs.tsinghua.edu.cn/oj/static/unix_signal.html)
- [Introduzione alla programmazione dei segnali Unix](http://titania.ctie.monash.edu.au/signals/)
</details>
<details>
<summary><b>Cosa fa il comando <code>kill</code>?</b></summary><br>
Nei sistemi operativi Unix e Unix-like, `kill` è un comando usato per inviare un segnale a un processo. Di default, il messaggio inviato è il segnale di terminazione, che richiede l'uscita del processo. Ma `kill` è un termine un po' improprio; il segnale inviato potrebbe non avere nulla a che fare con l'uccisione del processo.
Risorse utili:
- [Padroneggiare il comando "Kill" in Linux](https://www.maketecheasier.com/kill-command-in-linux/)
</details>
<details>
<summary><b>Qual è la differenza tra <code>rm</code> e <code>rm -rf</code>?</b></summary><br>
`rm` elimina solo i file specificati (e non le directory). Con `-rf` come dici:
- `-r`, `-R`, `--recursive` elimina ricorsivamente il contenuto di una directory, inclusi file nascosti e sottodirectory
- `-f`, `--force` ignora i file inesistenti, non chiedere mai conferma
Risorse utili:
- [Qual è la differenza tra `rm -r` e `rm -f`?](https://superuser.com/questions/1126206/what-is-the-difference-between-rm-r-and-rm-f)
</details>
<details>
<summary><b>Come faccio a usare <code>grep</code> ricorsivamente? Spiega con diversi esempi. ***</b></summary>
Da completare.
</details>
<details>
<summary><b><code>archive.tgz</code> ha ~30 GB. Come si elenca il suo contenuto e si estrae un solo file?</b></summary><br>```bash
# list of content
tar tf archive.tgz
# extract file
tar xf archive.tgz filename
Risorse utili:
Risorse utili:
Risorse utili:
La subnet non è altro che un intervallo di indirizzi IP che aiuta gli host a comunicare sui livelli 2 e 3. Ogni subnet non richiede una propria VLAN. Le VLAN sono implementate per l'isolamento (sono una sandbox per la comunicazione di livello 2; due sistemi di VLAN diverse non possono comunicare, ma ciò può essere fatto tramite routing Inter-VLAN), facilità di gestione e sicurezza.
Risorse utili:
| SERVIZIO | PORTA |
|---|---|
| SMTP | 25 |
| FTP | 20 per il trasferimento dati e 21 per la connessione stabilita |
| DNS | 53 |
| DHCP | 67/UDP per il server DHCP, 68/UDP per il client DHCP |
| SSH | 22 |
Risorse utili:
Puoi (a volte) risolvere un indirizzo IP in un hostname. Un indirizzo IP può essere memorizzato in un record PTR. Puoi quindi fare:```bash dig A
Per cercare l'indirizzo IPv4 di un host, o:```bash
dig AAAA <hostname>
Per cercare l'indirizzo IPv6 di un host, oppure:```bash dig PTR ZZZ.YYY.XXX.WWW.in-addr.arpa.
Per cercare il nome host per l'indirizzo IPv4 `WWW.XXX.YYY.ZZZ` (nota che gli ottetti sono invertiti), oppure:```bash
dig PTR b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.
Risorse utili:
Quando user2 vuole cambiare la propria password, esegue /usr/bin/passwd.
Il RUID sarà user2 ma l'EUID di quel processo sarà root.
user2 può usare solo passwd per cambiare la propria password, perché internamente passwd controlla il RUID e, se non è root, le sue azioni saranno limitate alla password dell'utente reale.
È necessario che l'EUID diventi root nel caso di passwd perché il processo deve scrivere su /etc/passwd e/o /etc/shadow.
Risorse utili:
Useful resources:
| Umask | Risultato file | Risultato directory |
|---|---|---|
| 000 | 666 rw- rw- rw- | 777 rwx rwx rwx |
| 002 | 664 rw- rw- r-- | 775 rwx rwx r-x |
| 022 | 644 rw- r-- r-- | 755 rwx r-x r-x |
| 027 | 640 rw- r-- --- | 750 rwx r-x --- |
| 077 | 600 rw---- --- | 700 rwx --- --- |
| 277 | 400 r-- --- --- | 500 r-x --- --- |
Useful resources:
guid abilitato & bit eseguibile disabilitato (S maiuscola) - i bit rwxr-Sr-x sono impostati.```bash
chmod g-x b.pl
ls -lt b.pl
-rwxr-Sr-x 1 root root 179 Jan 9 01:01 b.pl
**sticky bit**
Il sticky bit invece è indicato con `t`, come per la directory `/tmp`:```bash
ls -l /|grep tmp
drwxrwxrwt. 168 root root 28672 Jun 14 08:36 tmp
Questo bit avrebbe dovuto essere sempre chiamato bit di eliminazione ristretta dato che è quello che realmente significa. Quando questo bit di modalità è abilitato, rende una directory tale per cui gli utenti possono eliminare solo file e directory al suo interno di cui sono proprietari.
Risorse utili:
Se `LC_ALL` non funziona, prova a usare `LANG` (se ancora non funziona, prova `LANGUAGE`):```bash
LANG=C date +%A
Monday
Risorse utili:
Quindi l'utente **alice** ha privilegi standard per `/var/www/app01` e l'utente **bob** ha privilegi standard per `/var/www/app01` e `/var/www/app02`.
**5) Proprietario e gruppo del server web**
Tutti i file o le directory che devono essere scritti dal webserver hanno il loro proprietario. Se il webserver è Apache, il proprietario/gruppo predefinito sono **apache:apache** o **www-data:www-data** e per Nginx sarà **nginx:nginx**. Non modificare queste impostazioni.
Se le applicazioni funzionano con server applicativi come un **uwsgi** o **php-fpm**, bisogna impostare l'utente e il gruppo appropriati (ad es. per **app01** sarà **u01-prod:g01-prod**) nei file di configurazione specifici.
**6) Permessi**
Imposta correttamente i permessi con **Access Control Lists**:```bash
# For web server
setfacl -Rdm "g:apache:rwx" /var/www/app01
setfacl -Rm "g:apache:rwx" /var/www/app01
# For developers
setfacl -Rdm "g:g01-prod:rwx" /var/www/app01
setfacl -Rm "g:g01-prod:rwx" /var/www/app01
Se usi SELinux ricorda il contesto di sicurezza:```bash chcon -R system_u:object_r:httpd_sys_content_t /var/www/app01
**7) Errori di sicurezza**
- Proprietario **root** per file e directory
- **root** non esegue mai alcun file nella directory del sito web e non dovrebbe crearvi file
- permessi troppo ampi come **777** che rendono alcuni file critici scrivibili e leggibili da tutti
- evitare di creare script di manutenzione o altri file critici con suid root
Se permetti al tuo sito di modificare i file che costituiscono il codice che esegue il sito, rendi molto più facile per qualcuno prendere il controllo del tuo server.
Uno strumento di caricamento file permette agli utenti di caricare un file con qualsiasi nome e qualsiasi contenuto. Ciò consente a un utente di caricare uno script PHP di relay di posta sul tuo sito, che può posizionare ovunque per trasformare il tuo server in una macchina per inoltrare email commerciali non richieste. Questo script potrebbe anche essere usato per leggere ogni indirizzo email dal tuo database o altre informazioni personali.
Se l'utente malintenzionato può caricare un file con qualsiasi nome ma non controllare i contenuti, allora potrebbe facilmente caricare un file che sovrascrive il tuo `index.php` (o un altro file critico) e rompere il tuo sito.
Risorse utili:
- [Come impostare i permessi Linux per la cartella WWW?](https://serverfault.com/questions/124800/how-to-setup-linux-permissions-for-the-www-folder)
- [Quali permessi dovrebbero avere i file/cartelle del mio sito web su un webserver Linux?](https://serverfault.com/questions/357108/what-permissions-should-my-website-files-folders-have-on-a-linux-webserver)
- [Insidie di sicurezza dei programmi setgid](https://www.agwa.name/blog/post/security_pitfalls_of_setgid_programs)
</details>
<details>
<summary><b>Quali passi verranno eseguiti da init quando esegui <code>telinit 1</code> dal run level 3? Quale sarà il risultato finale? Se usi <code>telinit 6</code> invece del comando <code>reboot</code>, il tuo server verrà riavviato? ***</b></summary><br>
Da completare.
Risorse utili:
- [Quali differenze ci saranno se uso “telinit 6” invece del comando “reboot” per riavviare il computer?](https://unix.stackexchange.com/questions/434560/what-differences-it-will-make-if-i-use-telinit-6-instead-of-reboot-command)
</details>
<details>
<summary><b>Ho dimenticato la password di root! Cosa devo fare in BSD? Qual è lo scopo di avviare in modalità utente singolo?</b></summary><br>
Riavvia il sistema, digita `boot -s` al prompt `Boot:` per entrare in **modalità utente singolo**.
Alla domanda sulla shell da usare, premi `Invio` che mostrerà un prompt `#`.
Digita `mount -urw /` per rimontare il filesystem di root in lettura/scrittura, poi esegui `mount -a` per rimontare tutti i filesystem.
Esegui `passwd root` per cambiare la password di root, poi esegui `exit` per continuare l'avvio.
La **modalità utente singolo** dovrebbe fondamentalmente permetterti di accedere con accesso root e cambiare praticamente qualsiasi cosa. Ad esempio, potresti usare la modalità utente singolo per ripristinare un database master danneggiato o un database di sistema, o quando cambi opzioni di configurazione del server (es. recupero password).
Risorse utili:
- [Reimpostare o recuperare la password di root in FreeBSD](https://www.cyberciti.biz/tips/howto-freebsd-reset-recover-root-password.html)
- [Definizione della modalità utente singolo](http://www.linfo.org/single_user_mode.html)
</details>
<details>
<summary><b>Come potresti modificare un file di testo senza utilizzare un editor di testo?</b></summary><br>
Per esempio:<br>```bash
# cat >filename ... - overwrite file
# cat >>filename ... - append to file
cat > filename << __EOF__
data
__EOF__
Ora cosa succede quando usi il comando ls:```bash
ls
aa?b
ls | grep 'a'
ab
Nota che quando `ls` invia il risultato a un terminale, inserisce un "**?**" nel nome del file per mostrare un carattere non stampabile. Puoi eliminare questo file usando `rm -i *` e ti chiederà conferma prima di eliminare ogni file. Ma puoi anche usare `find` per rimuovere il file, una volta che conosci il numero di inode.```bash
ls -i
435304 aa?b
find . -inum 435304 -delete
Risorse utili:
e `resize2fs` o `xfs_growfs` per ridimensionare il filesystem:
- per filesystem ext:```bash
resize2fs /dev/vgroup/lvolume
Risorse utili:
- [Estensione di un volume logico](https://www.tldp.org/HOWTO/LVM-HOWTO/extendlv.html)
</details>
<details>
<summary><b>Cos'è un processo zombie/defunto?</b></summary><br>
È un processo che ha completato l'esecuzione (tramite la chiamata di sistema `exit`) ma ha ancora un'entry nella tabella dei processi: è un processo nello "**stato Terminato**".
I processi contrassegnati **defunct** sono processi morti (i cosiddetti "zombie") che rimangono perché il loro genitore non li ha distrutti correttamente. Questi processi verranno distrutti da init se il processo genitore termina.
Risorse utili:
- [Cos'è un processo <defunct> e perché non viene ucciso?](https://askubuntu.com/questions/201303/what-is-a-defunct-process-and-why-doesnt-it-get-killed)
</details>
<details>
<summary><b>Qual è il modo corretto per aggiornare/aggiornare un sistema in produzione? Automatizzi questi processi? Imposti tempi di inattività per essi? Scrivi raccomandazioni. ***</b></summary><br>
Da completare.
</details>
<details>
<summary><b>Il tuo amico durante la configurazione del server MySQL ti ha chiesto: <i>Dovrei eseguire <code>sudo mysql_secure_installation</code> dopo aver installato mysql?</i> Cosa ne pensi? </b></summary><br>
Sarebbe meglio se esegui il comando poiché fornisce molte opzioni di sicurezza come:
- Puoi impostare una password per gli account root
- Puoi rimuovere gli account root accessibili dall'esterno dell'host locale
- Puoi rimuovere gli account utente anonimi
- Puoi rimuovere il database di test, che di default può essere accessibile da utenti anonimi
Risorse utili:
- [Qual è lo scopo dell'uso di mysql_secure_installation?](https://stackoverflow.com/questions/20760908/what-is-purpose-of-using-mysql-secure-installation)
</details>
<details>
<summary><b>Presenta e spiega i buoni modi di usare il comando <code>kill</code>.</b></summary><br>
Parlando di uccidere processi, non usare mai `kill -9/SIGKILL` se non assolutamente necessario. Questo kill può causare problemi a causa della sua forza bruta.
Prova sempre a usare la seguente semplice procedura:
- primo, invia il segnale **SIGTERM** (`kill -15`) che dice al processo di spegnersi ed è generalmente accettato come segnale da usare quando si spegne in modo pulito (ma ricorda che questo segnale può essere ignorato).
- poi prova a inviare il segnale **SIGHUP** (`kill -1`) che è comunemente usato per dire a un processo di spegnersi e riavviarsi, anche questo segnale può essere catturato e ignorato da un processo.
La stragrande maggioranza delle volte, questo è tutto ciò di cui hai bisogno – ed è molto più pulito.
Risorse utili:
- [Quando non dovrei kill -9 un processo?](https://unix.stackexchange.com/questions/8916/when-should-i-not-kill-9-a-process)
- [SIGTERM vs. SIGKILL](https://major.io/2010/03/18/sigterm-vs-sigkill/)
</details>
<details>
<summary><b>Cos'è il comando <code>strace</code> e come dovrebbe essere usato? Spiega un esempio di connessione a un processo già in esecuzione.</b></summary><br>
`strace` è un potente strumento a riga di comando per il debug e la risoluzione dei problemi in sistemi operativi Unix-like come Linux. Cattura e registra tutte le chiamate di sistema effettuate da un processo e i segnali ricevuti dal processo.
**Panoramica su strace**
`strace` può essere visto come un debugger leggero. Permette a un programmatore/utente di scoprire rapidamente come un programma interagisce con il sistema operativo. Lo fa monitorando le chiamate di sistema e i segnali.
**Usi**
Buono quando non hai il codice sorgente o non vuoi preoccuparti di esaminarlo a fondo. Inoltre, utile per il tuo codice se non hai voglia di aprire **GDB**, ma sei solo interessato a capire l'interazione esterna.
**Esempio di collegamento al processo**
`strace -p <PID>` - per collegare un processo a strace.
`strace -e trace=read,write -p <PID>` - con questo puoi anche tracciare un processo/programma per un evento, come read e write (in questo esempio). Quindi qui stamperà tutti quegli eventi che includono chiamate di sistema read e write da parte del processo.
Altri esempi
- `-e trace=network` - traccia tutte le chiamate di sistema relative alla rete.
- `-e trace=signal` - traccia tutte le chiamate di sistema relative ai segnali.
- `-e trace=ipc` - traccia tutte le chiamate di sistema relative all'IPC.
- `-e trace=desc` - traccia tutte le chiamate di sistema relative ai descrittori di file.
- `-e trace=memory` - traccia tutte le chiamate di sistema relative al mapping della memoria.
Risorse utili:
- [Come dovrebbe essere usato strace? (originale)](https://stackoverflow.com/questions/174942/how-should-strace-be-used)
- [Come si collega strace a un processo già in esecuzione? (originale)](https://stackoverflow.com/questions/7482076/how-does-strace-connect-to-an-already-running-process)
- [strace: per divertimento, profitto e debug](http://timetobleed.com/hello-world/)
</details>
<details>
<summary><b>Quando useresti le liste di controllo degli accessi invece o in combinazione con il comando <code>chmod</code>? ***</b></summary><br>
Da completare.
</details>
<details>
<summary><b>Quali algoritmi sono supportati nel file <code>/etc/shadow</code>?</b></summary><br>
Gli algoritmi attuali tipici sono:
- MD5
- SHA-1 (anche chiamato SHA)
entrambi non dovrebbero più essere usati per scopi crittografici/di sicurezza!!
- SHA-256
- SHA-512
- SHA-3 (KECCAK è stato annunciato vincitore della competizione per un nuovo algoritmo di hashing approvato a livello federale nell'ottobre 2012)
Risorse utili:
- [Qual è l'algoritmo usato per crittografare le password Linux?](https://crypto.stackexchange.com/questions/40841/what-is-the-algorithm-used-to-encrypt-linux-passwords)
- [Come trovare l'algoritmo di hashing usato per offuscare le password?](https://unix.stackexchange.com/questions/430141/how-to-find-the-hashing-algorithm-used-to-obfuscate-passwords)
</details>
<details>
<summary><b>Qual è l'uso di ulimit nei sistemi Unix-like?</b></summary><br>
La maggior parte dei sistemi operativi Unix-like, inclusi Linux e BSD, forniscono modi per limitare e controllare l'uso delle risorse di sistema come thread, file e connessioni di rete su base per-processo e per-utente. Questi "**ulimits**" impediscono a singoli utenti di usare troppe risorse di sistema.
</details>
<details>
<summary><b>Cosa sono i limiti soft e i limiti hard?</b></summary><br>
**Hard limit** è il massimo consentito a un utente, impostato dal superutente o root. Questo valore è impostato nel file `/etc/security/limits.conf`. L'utente può aumentare il **soft limit** da solo nei momenti di bisogno di più risorse, ma non può impostare il **soft limit** più alto del **hard limit**.
</details>
<details>
<summary><b>Durante la configurazione di HAProxy per funzionare con Redis ottieni <code>General socket error (Permission denied)</code> dal log. SELinux è abilitato. Spiega la risoluzione dei problemi di base di SELinux in CLI. ***</b></summary><br>
Risorse utili:
- [Risoluzione dei problemi di base di SELinux in CLI](https://access.redhat.com/articles/2191331)
</details>
<details>
<summary><b>Hai configurato un login con chiave RSA ma il tuo server mostra <code>Server refused our key</code> come previsto. Dove cercheresti la causa del problema?</b></summary><br>
**Lato server**
Impostare `LogLevel VERBOSE` nel file `/etc/ssh/sshd_config` è probabilmente ciò che ti serve, anche se ci sono livelli più alti:
I fallimenti di autenticazione SSH sono registrati in `/var/log/auth.log`, `/var/log/secure` o `/var/log/audit/audit.log`.
Il seguente dovrebbe darti solo le righe di log relative a SSH (per esempio):```bash
grep 'sshd' /var/log/auth.log
Successivamente, il comando più semplice per elencare tutti i login SSH falliti è quello mostrato di seguito:```bash grep "Failed password" /var/log/auth.log
è anche utile:```bash
grep "Failed\|Failure" /var/log/auth.log
Sulle distribuzioni Linux più recenti puoi interrogare il file di log di runtime mantenuto dal demone Systemd tramite il comando journalctl (ssh.service o sshd.service). Per esempio:```bash
journalctl _SYSTEMD_UNIT=ssh.service | egrep "Failed|Failure"
**Lato client**
Inoltre, dovresti eseguire il client SSH con `-v|--verbose` - è al primo livello di verbosità. Successivamente, puoi abilitare ulteriore verbosità (livello 2 e 3) per ancora più messaggi di debug, come mostrato con ad esempio `-vv`.
Risorse utili:
- [Abilita la modalità di debug in SSH per risolvere problemi di connettività](https://www.tecmint.com/enable-debugging-mode-in-ssh/)
</details>
<details>
<summary><b>Perché la maggior parte delle distribuzioni usa ext4, invece di XFS o altri filesystem? Perché ce ne sono così tanti? ***</b></summary><br>
Da completare.
</details>
<details>
<summary><b>Un project manager ha bisogno di un nuovo SQL Server. Cosa chiedi a lui/lei? ***</b></summary><br>
Voglio che il DBA ponga domande come:
- Quanto grande sarà il database? (se possiamo aggiungere il database a un server esistente)
- Quanto è critico il database? (riguardo a clustering, disaster recovery, alta disponibilità)
</details>
<details>
<summary><b>Crea un file con 100 righe con valori casuali.</b></summary><br>
Per esempio:```bash
cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 100 > /path/to/file
Un buon esempio sono anche i server web. Immagina se Apache fosse eseguito come root e qualcuno trovasse un modo per inviare comandi personalizzati alla console tramite Apache: avrebbe accesso all'intero sistema.
L'account nobody viene anche usato come shell ristretta per dare agli utenti accesso al filesystem senza una shell vera e propria come bash. Ciò dovrebbe impedire loro di eseguire cose.
nobody o www-data per httpd (Apache)
All'avvio, Apache necessita dell'accesso root, ma lo rilascia rapidamente e assume l'identità di un utente non privilegiato. Questo utente può essere nobody o apache o www-data.
Diverse applicazioni usano l'utente nobody come predefinito. Ad esempio, probabilmente non vorrai mai che il servizio Apache sovrascriva file che appartengono a bind. Avere un account per servizio tende a essere un'ottima idea.
Far eseguire Apache come nobody:nobody è piuttosto semplice: basta aggiornare le impostazioni di utente e gruppo. Ma come ho detto sopra, non raccomando particolarmente quel particolare utente/gruppo. È del tutto possibile che in futuro tu possa essere tentato di aggiungere al sistema un servizio che viene eseguito anch'esso come nobody, e dimenticherai di aver concesso accesso in scrittura sul filesystem all'utente nobody.
Se in qualche modo nobody venisse compromesso, potrebbe potenzialmente avere un impatto maggiore rispetto a un utente isolato per applicazione, come www-data. Naturalmente, molto dipenderà dalle autorizzazioni di file e gruppo. nobody utilizza le autorizzazioni di "altri", mentre un utente specifico dell'applicazione potrebbe essere configurato per consentire l'accesso in lettura ai file, ma altri potrebbero comunque essere negati.
Risorse utili:
Soluzione 2:``` su - postgres /usr/bin/pg_ctl reload
Soluzione 3:```
SELECT pg_reload_conf();