$
Impara Manuale Linux
it
XP:0
L

Ospite.

Utente Livello 1

Progresso XP0 / 300
Completato0 / 150
Distintivi Sbloccati0

Nessuna registrazione richiesta. I progressi sono salvati localmente. Esporta il codice per giocare su un altro dispositivo.

DISTINTIVI OTTENUTI

Pratica di Terminale Linux Online — Impara Facendo.

Padroneggia i comandi Linux essenziali attraverso un gioco bash gratuito e una simulazione interattiva del file system.

Terminale Linux Online150+ Missioni & ObiettiviPratica di Terminale GratuitaGioco di Apprendimento Bash Interattivo

Percorso di Apprendimento Interattivo & Obiettivi del Terminale.

Il tuo percorso completo per imparare Linux con obiettivi strutturati. Clicca su un nodo sbloccato per aprire il tuo terminale interattivo.

1. Fondamenti del File System

Missione 1Bloccato

Immagina di entrare in un'enorme e buia biblioteca con milioni di libri, ma di non avere una mappa e di non ricordare nemmeno la targhetta con il tuo nome. Prima di poter cercare qualsiasi cosa, devi sapere chi sei e dove ti trovi. Nella shell Linux iniziamo con le stesse identiche domande! - Il comando `whoami` stampa il nome utente con cui sei attualmente loggato. - Il comando `pwd` (stampa directory di lavoro) agisce come un GPS, mostrandoti il ​​percorso esatto della cartella in cui ti trovi attualmente.

Missione 2Bloccato

Ora che sai dove ti trovi, come puoi guardarti intorno e spostarti in una stanza diversa in questa libreria digitale? In Linux, lo facciamo usando due semplici comandi: - `ls`: è come accendere le luci in una stanza per vedere tutti i file e le cartelle al suo interno. - `cd <path>`: abbreviazione di "cambia directory", ti consente di attraversare una porta per entrare in un'altra cartella. Per specificare dove vuoi andare, puoi utilizzare percorsi **assoluti** (a partire dalla radice `/` del sistema, come `/var/log`) o percorsi **relativi** (in base a dove ti trovi adesso, come usare `..` per tornare alla cartella principale).

Missione 3Bloccato

A standard `ls` lists only the names of files, giving you no indication of how large they are, who owns them, or when they were last modified. In Linux, we inspect detailed file metadata using the long listing option: - The `-l` (long) option shows permissions, link counts, file owner, group, exact size in bytes, and last modification date. - The `-h` (human-readable) option, when combined with `-l` as `ls -lh`, translates raw byte counts into intuitive units like `K` (kilobytes), `M` (megabytes), and `G` (gigabytes).

Missione 4Bloccato

Immagina che la tua scrivania sia piena di fogli sparsi e che tu abbia bisogno di cartelle fisiche per mantenere le cose in ordine. In Linux, organizziamo i file creando cartelle (directory) utilizzando il comando `mkdir` (make directory). L'esecuzione di `mkdir code` crea una nuova cartella denominata "codice" proprio dove ti trovi. Puoi creare cartelle ovunque nel filesystem fornendo a `mkdir` un percorso relativo o assoluto.

Missione 5Bloccato

Immagina di provare a costruire un set di bambole nidificabili, ma devi costruire quelle più esterne prima di poter costruire quella piccola all'interno. Per impostazione predefinita, `mkdir` è così: rifiuta di creare una cartella all'interno di cartelle che non esistono ancora. Per evitare il fastidio di creare cartelle una per una, utilizziamo un interruttore: - L'opzione `-p` (o `--parents`) indica a `mkdir` di creare automaticamente eventuali cartelle principali mancanti nel percorso verso la cartella finale. Ad esempio, `mkdir -p workspace/src/utils` crea `workspace`, `workspace/src` e `workspace/src/utils` tutto in un unico comando. **Perché è importante**: se esegui `mkdir workspace/src/utils` senza `-p` e `workspace` e `workspace/src` non esistono già, otterrai: `mkdir: cannot create directory 'workspace/src/utils': No such file or directory`. Il flag `-p` risolve questo problema creando automaticamente tutte le cartelle principali mancanti.

Missione 6Bloccato

When navigating complex project directories, flat listings from `ls` make it difficult to visualize nested structures. The `tree` command recursively lists directory contents in a clear, tree-like ASCII visual hierarchy with branch lines showing directory nesting. In large repositories, a full recursive tree can produce thousands of lines. To keep output manageable, use the `-L <level>` switch (e.g., `tree -L 2`) to restrict visualization depth to a specific number of directory levels.

Missione 7Bloccato

Ogni sistema Linux segue una gerarchia di filesystem standard a partire dalla directory root `/`. A differenza di Windows (che utilizza lettere di unità come `C:` o `D:`), Linux unifica tutti i file e lo spazio di archiviazione in `/`. Ecco le directory di sistema chiave che ogni utente Linux dovrebbe conoscere: - `/` (Root): la cartella principale di livello superiore dell'intero sistema. - `/etc`: contiene le configurazioni del sistema (ad esempio `/etc/hosts`, `/etc/passwd`). - `/var`: contiene dati variabili che cambiano nel tempo (registri, spool, cache come `/var/log`). - `/home`: Cartelle personali dell'utente (es. `/home/learner`). - `/tmp`: area di archiviazione temporanea per file temporanei. - `/usr`: utilità utente, applicazioni e librerie di sistema.

Missione 8Bloccato

In Linux, file extensions (like `.txt` or `.png`) are merely hints for humans—the operating system does not rely on them. To identify what a file truly contains, the `file` command reads the file's binary header (magic bytes) and determines its actual format (ASCII text, ELF executable, gzip archive, etc.). To inspect deep filesystem metadata beyond what `ls -l` shows, the `stat` command displays the file's exact size in bytes, allocated blocks, filesystem inode number, octal access permissions (e.g. `0644`), and exact timestamps: Access (`atime`), Modify (`mtime`), and Change (`ctime`).

Missione 9Bloccato

Ti sei mai sentito sopraffatto quando la tua scrivania è ricoperta di appunti e documenti disordinati? Il tuo terminale può diventare altrettanto disordinato. Quando lo fa, puoi spazzare via tutto il vecchio testo e ricominciare da capo. - Il comando `clear` cancella lo schermo visibile, facendo scorrere l'output precedente fuori dalla vista in modo da avere una tela nuova e vuota nella parte superiore del terminale.

Missione 10Bloccato

Quando acquisti un nuovo gioco da tavolo, di solito dai un'occhiata al regolamento o alla scheda di riferimento per vedere quali mosse sono consentite. Nel nostro emulatore di terminale, hai un cheat sheet integrato! - Il comando `help` elenca ogni singolo comando supportato da questo simulatore, insieme ai dettagli sul supporto del piping o del reindirizzamento degli output.

👑 Boss · Missione 11Bloccato

EMERGENCY ALERT: A faulty CI/CD deployment script executed an unconstrained cleanup routine and wiped the directory tree under `/home/learner/app`. The backend production daemon refuses to start until the project directory structure is restored. To recover, you must reconstruct the missing directory hierarchy: create `/home/learner/app/logs`, `/home/learner/app/config`, and the nested module directory `/home/learner/app/src/modules`. No step-by-step hints are provided for Boss Challenges. Inspect the system, plan your approach, and verify your filesystem state.

2. Manipolazione dei File

Missione 12Bloccato

Immagina di voler iniziare a scrivere una nuova voce di diario, ma prima hai bisogno di un pezzo di carta bianco. In Linux, prendiamo un nuovo file di testo vuoto usando il comando `touch`. - Il comando `touch` crea un file nuovo e vuoto se non esiste ancora (come eseguire `touch draft.txt` per creare `draft.txt`). Se il file esiste già, aggiorna semplicemente il timestamp dell'"ultima modifica" del file senza modificarne il contenuto. Inseriamo un file nella nostra nuova cartella progetti.

Missione 13Bloccato

Pensa ad aprire una cartella, estrarre una pagina di testo e sollevarla per leggerla. In Linux, leggiamo i file istantaneamente senza aprire un pesante editor di testo utilizzando il comando `cat` (concatena). - Il comando `cat` stampa l'intero contenuto di un file direttamente sullo schermo del terminale. Ad esempio, l'esecuzione di `cat notes.txt` ti consente di vedere immediatamente cosa è scritto all'interno di `notes.txt`.

Missione 14Bloccato

Ora che puoi leggere un intero file con `cat`, cosa succede se il file ha migliaia di righe e vuoi vedere solo la parte superiore o inferiore? Il dump di un file enorme con `cat` inonda lo schermo. Usiamo invece `head` e `tail` per sbirciare i bordi. - Il comando `head` visualizza le prime 10 righe di un file per impostazione predefinita. Puoi modificarlo utilizzando `-n <number>` (ad esempio `head -n 5 log.txt` per le prime 5 righe). - Il comando `tail` visualizza le ultime 10 righe per impostazione predefinita, supportando la stessa opzione `-n`. - Fondamentalmente, `tail -f` (follow) monitora un file in tempo reale, mostrando le nuove righe man mano che vengono scritte dal sistema. Questo è lo strumento preferito dagli amministratori di sistema per guardare i registri in tempo reale.

Missione 15Bloccato

Sbirciare nella parte superiore e inferiore di un file con `head` e `tail` è fantastico, ma cosa succede se devi sfogliare un lungo file di configurazione pagina per pagina? Ecco a cosa servono i cercapersone come `less` e `more`. - I cercapersone caricano i file in modo interattivo, mostrando una pagina di testo alla volta per evitare rallentamenti del sistema su file di grandi dimensioni. - `less` è la scelta moderna, che ti consente di scorrere sia avanti che indietro utilizzando i tasti freccia, cercare testo con `/` e uscire premendo `q`. - `more` è un cercapersone più vecchio e più semplice che scorre solo in avanti.

Missione 16Bloccato

Se dici a un robot di "dipingere la mia camera da letto di blu", deve sapere se "la mia camera da letto" è un unico posto o se "mia" e "camera da letto" sono due istruzioni diverse. Linux usa gli spazi per separare i comandi dai loro argomenti. Quindi se esegui `mkdir my folder`, Linux pensa che tu voglia creare due cartelle separate: una chiamata "my" e un'altra chiamata "folder"! - Per dire a Linux che un nome con spazi è un singolo elemento, dobbiamo racchiuderlo tra virgolette (`"my folder"` o `'my folder'`) o utilizzare una barra rovesciata per evitare lo spazio (`my\ folder`).

Missione 17Bloccato

Se vuoi scrivere un messaggio su una lavagna, prima pulisci completamente la lavagna e poi scrivi le nuove parole. In Linux, scriviamo messaggi su file utilizzando l'operatore `>` (reindirizzamento dell'output). - Il comando `echo "message"` normalmente stampa il testo sullo schermo. - Aggiungendo il simbolo `>`, reindirizziamo invece quel testo in un file. Ad esempio, `echo "Hi" > greeting.txt` scrive "Ciao" in `greeting.txt`. Se il file contiene già del testo, `>` lo sovrascrive completamente con il nuovo messaggio.

Missione 18Bloccato

Invece di pulire la lavagna, cosa succede se vuoi semplicemente aggiungere una nuova riga in fondo? In Linux, aggiungiamo testo alla fine di un file senza toccare il contenuto esistente utilizzando l'operatore `>>` (append redirezione). - L'operatore `>>` aggiunge il nuovo testo alla fine del file. Ad esempio, `echo "New Line" >> logs.txt` aggiunge "Nuova riga" alla fine di `logs.txt` mantenendo tutti i tuoi vecchi registri al sicuro.

Missione 19Bloccato

Immagina di riorganizzare la tua stanza: a volte vuoi fare una fotocopia di un documento da tenere in un altro cassetto, e altre volte vuoi semplicemente prendere una cartella e farla scorrere in un nuovo scaffale o cambiarne l'etichetta. Lo facciamo in Linux con semplici comandi: - `cp <source> <destination>` crea un duplicato identico di un file in una nuova posizione. - `mv <source> <destination>` sposta un file in una nuova cartella o rinomina il file se lo tieni nella stessa cartella (ad esempio, `mv old.txt new.txt`).

Missione 20Bloccato

Immagina di avere una pila di cartelle etichettate "log_monday", "log_tuesday" e "log_wednesday" e di volerle aprire e leggere tutte contemporaneamente senza digitare tutti i nomi. Linux ti consente di utilizzare i **caratteri jolly** come scorciatoie di ricerca! - Il simbolo `*` corrisponde a qualsiasi carattere di qualsiasi lunghezza. Ad esempio, `cat log_*` legge ogni file che inizia con "log_". - Il simbolo `?` funge da segnaposto a carattere singolo. Ad esempio, `log_?.txt` corrisponde a `log_1.txt` ma ignorerà `log_12.txt`.

Missione 21Bloccato

Quando ripulisci la tua scrivania fisica, potresti gettare i vecchi documenti in un cestino per il riciclaggio dove potrai recuperarli se hai commesso un errore. In Linux non esiste una rete di sicurezza: quando elimini qualcosa dal terminale, scompare per sempre! - Il comando `rm` elimina i file. - Poiché le cartelle possono contenere altri file, `rm` non eliminerà una cartella per impostazione predefinita. È necessario aggiungere il flag `-r` (ricorsivo) per dire a Linux di immergersi ed eliminare la cartella insieme a tutto ciò che contiene. **Perché è importante**: se esegui `rm downloads` senza `-r` quando `downloads` è una cartella, otterrai: `rm: cannot remove 'downloads': Is a directory`. Il flag `-r` dice a Linux di eliminare ricorsivamente la cartella e tutto ciò che contiene.

Missione 22Bloccato

Bash **brace expansion** `{}` is a powerful productivity feature that generates arbitrary string combinations before commands run, eliminating repetitive typing: - Comma-separated lists: `mkdir -p app/{src,bin,logs}` expands to `app/src`, `app/bin`, and `app/logs` in a single command. - Numeric or alphabetic ranges: `touch file_{1..3}.txt` expands to `file_1.txt`, `file_2.txt`, and `file_3.txt`. When deleting folders, `rm -r` deletes everything recursively without safety checks. By contrast, `rmdir` provides a strict safety guarantee: it **only removes directories that are completely empty**, preventing accidental loss of files.

👑 Boss · Missione 23Bloccato

INCIDENT REPORT: An aborted container update left messy temporary build artifacts in `/home/learner`. The leftover files `temp_install.tmp` and `old_log.txt` are creating conflicts. Furthermore, the verified staging configuration `/home/learner/staging.conf` was never promoted to production. Purge the obsolete temporary files and establish `/home/learner/production.conf` with the configuration from staging. This is a Boss Challenge: evaluate the files, execute the cleanup, and prepare the production configuration.

3. Pipe e Filtraggio

Missione 24Bloccato

Immagina una catena di montaggio in cui un lavoratore avvolge un prodotto e lo consegna immediatamente al lavoratore successivo per imballarlo in una scatola, senza bisogno di stoccaggio intermedio. In Linux, colleghiamo i comandi esattamente in questo modo utilizzando una **pipe** (`|`). - Una pipe (`|`) instrada l'output di un comando direttamente nell'input del comando successivo. Ad esempio, `ls | wc -l` elenca i file e passa immediatamente l'elenco a `wc -l` (conteggio parole - righe), che li conta al volo senza bisogno di file temporanei. **Perché è importante**: se esegui `wc` senza `-l`, verranno restituiti tre numeri separati: righe, parole e byte (ad esempio, ` 5 10 85`). Ciò ne rende difficile l'utilizzo in pipeline o script che necessitano di un conteggio pulito e di un solo numero. Il flag `-l` limita l'output al solo conteggio delle righe.

Missione 25Bloccato

Immagina di ordinare un mazzo di carte in cui i duplicati sono sparsi ovunque. Per individuare e rimuovere facilmente i duplicati, devi prima raggruppare insieme le carte identiche. In Linux, il comando `uniq` filtra le righe ripetute, ma ha un problema: **rileva solo i duplicati che sono uno accanto all'altro**! - Per rimuovere tutti i duplicati da un elenco disordinato, devi prima ordinare le righe utilizzando `sort` e quindi passare il risultato a `uniq`. Ad esempio, `sort raw.txt | uniq` organizza e pulisce l'elenco in una volta sola.

Missione 26Bloccato

Immagina di sfogliare un enorme registro di migliaia di pagine per scoprire ogni volta che si è verificato un errore di sistema. Farlo manualmente richiederebbe ore! In Linux, utilizziamo `grep` come lente d'ingrandimento digitale per cercare istantaneamente parole o schemi specifici. - Il comando `grep` filtra i file o il testo trasmesso, stampando solo le righe che corrispondono alla parola di ricerca. Ad esempio, l'esecuzione di `grep "ERROR" logs.txt` esegue la scansione del file ed estrae solo le righe contenenti "ERROR".

Missione 27Bloccato

In plumbing, a T-pipe splits a single water stream into two paths. In Linux, the `tee` command does the exact same thing with text streams: it reads standard input and writes it simultaneously to both the screen (stdout) and one or more files. E.g.: `cmd | tee output.log`. Furthermore, `tee` solves a classic Linux permissions pitfall: running `sudo echo "config" > /etc/app.conf` fails because redirection `>` is handled by your unprivileged shell before `sudo` executes. Piping to `sudo tee -a /etc/app.conf` (where `-a` appends) runs `tee` with superuser privileges, safely writing to protected system files.

Missione 28Bloccato

In production environments, servers fail when configuration files silently diverge over time—a problem called "configuration drift". The `diff` utility compares two text files line by line and highlights every difference: - Standard format: `diff file1.conf file2.conf` uses `<` to indicate lines from the first file and `>` for lines in the second file. - Unified format: `diff -u file1.conf file2.conf` produces unified diff output (`-` for removed lines, `+` for added lines), which is the standard format used by Git patches and modern pull requests.

Missione 29Bloccato

While basic `grep` searches for exact strings, production log analysis requires powerful matching flags: - `-i`: Case-insensitive search (matches `error`, `Error`, or `ERROR`). - `-v`: Invert match (prints lines that do **not** match the given pattern, perfect for stripping noise). - `-r` (or `-R`): Recursive directory search across all subdirectories and files. - `-E`: Extended regular expressions (supports `|` alternation for multiple patterns, `+`, and parentheses without escape backslashes).

👑 Boss · Missione 30Bloccato

SECURITY ALERT: The server logged dozens of suspicious requests in `/home/learner/access.log`. The SOC team needs a clean, deduplicated list of attacking IP addresses to update the network firewall blocklist. Process the raw web server log to extract all unique IP addresses, sort them, and save the result into `/home/learner/banned_ips.txt`. Analyze the data pipeline and construct a command pipeline to generate the required forensic report.

4. Reindirizzamento e Sicurezza

Missione 31Bloccato

Immagina di gestire un'attività in cui solo i manager possono firmare assegni, i dipendenti possono leggere gli orari e i visitatori possono solo guardare l'insegna del negozio. In Linux controlliamo chi può leggere, scrivere o eseguire file utilizzando un sistema di sicurezza di numeri (chiamato rappresentazione ottale): - `7` = Accesso completo: lettura + scrittura + esecuzione (`rwx`) - `6` = Modifica accesso: Lettura + Scrittura (`rw-`) - `5` = Accesso in lettura ed esecuzione: Lettura + Esegui (`r-x`) - `4` = Accesso di sola lettura: Lettura (`r--`) Applichiamo queste impostazioni con `chmod <octal> <file>`. Ad esempio, `chmod 755 script.sh` ti consente di eseguire lo script, mentre altri possono solo leggerlo ed eseguirlo. Abbiamo uno script denominato `deploy.sh` che al momento è bloccato: rendiamolo eseguibile!

Missione 32Bloccato

Pensa a un cassetto segreto sotto la scrivania dove conservi le impostazioni di sistema in modo che non ingombrano lo spazio di lavoro principale. In Linux creiamo file nascosti semplicemente iniziando i loro nomi con un punto (`.`). - Questi dotfile (come `.bashrc` o `.config`) memorizzano le preferenze dell'utente e le impostazioni di configurazione dietro le quinte. - Un comando standard `ls` non li mostrerà. Per dare un'occhiata a questi file nascosti, devi aggiungere il flag `-a` (tutti), eseguendo `ls -a`. **Perché è importante**: se esegui `ls` senza `-a`, i file nascosti (i cui nomi iniziano con `.`) vengono completamente omessi dall'output. Non vedrai file importanti come `.config_names` e potresti pensare che manchino. Il flag `-a` indica a `ls` di elencare tutti i file, compresi quelli nascosti.

Missione 33Bloccato

Immagina di acquistare una casa e di dover registrare ufficialmente l'atto sotto il nome di un nuovo proprietario. In Linux, ogni file e cartella ha un proprietario ufficiale e un gruppo. Se devi cedere la proprietà di un file a qualcun altro (come l'amministratore di sistema), utilizza il comando `chown` (cambia proprietario). - Poiché modificare il proprietario di un file è un'azione di sicurezza delicata, è necessario prefissarlo con `sudo` per eseguirlo con privilegi amministrativi. Ad esempio, `sudo chown root reports.csv` assegna il file all'utente "root".

Missione 34Bloccato

Immagina di vivere in un condominio sicuro dove una guardia di sicurezza sta all'ingresso controllando gli ID e bloccando i visitatori non autorizzati. In Linux, un **firewall** funge da guardia di sicurezza per le porte di rete. - Il comando `ufw` (Uncomplicated Firewall) è un'interfaccia intuitiva per la gestione delle regole del firewall. L'esecuzione di `sudo ufw status` mostra se il firewall è attivo e quali porte (come la porta 22 per SSH o la porta 80 per i server Web) sono aperte. - Il comando `iptables` è lo strumento Netfilter tradizionale di basso livello che blocca o reindirizza effettivamente i pacchetti. L'esecuzione di `sudo iptables -L` elenca le catene di sicurezza attive e le regole di corrispondenza dei pacchetti.

Missione 35Bloccato

In Linux, every process opens three standard I/O streams: - File descriptor `0`: `stdin` (Standard Input) - File descriptor `1`: `stdout` (Standard Output — where normal output goes) - File descriptor `2`: `stderr` (Standard Error — where error messages go) When you run `cmd > output.txt`, only stdout is saved; error messages still appear on your screen. To redirect errors separately, specify file descriptor 2: `cmd 2> errors.log`. To silence noisy errors completely, redirect them to the Linux null device (black hole): `cmd 2> /dev/null`. To combine both stdout and stderr into one stream or file, use `&> output.log` or `cmd > output.log 2>&1`.

Missione 36Bloccato

In automated scripts and cloud deployment routines (like Dockerfiles or cloud-init), opening an interactive text editor like nano is impossible. Instead, Bash uses **Here-Documents** (`<<EOF`) to inject multi-line blocks of text directly into commands. The syntax `cat <<EOF > config.env` tells the shell to capture all following lines into `config.env` until a line containing only the delimiter word `EOF` is reached.

Missione 37Bloccato

Whenever a program creates a new file or folder, its initial permissions are determined by the **umask** (user file-creation mode mask). The umask acts as a filter that strips away permissions from maximum defaults (`666` for files, `777` for directories): - Standard umask `022` subtracts group/other write permissions, yielding `644` (`rw-r--r--`) for files and `755` (`rwxr-xr-x`) for folders. - Running `umask 027` tightens security by stripping all permissions from "others", yielding `640` and `750`. To change only the group owner of a file without altering its user owner, use `chgrp <group> <file>`.

Missione 38Bloccato

Standard file permissions (`rwx`) have three special bits that provide advanced access models: - **Sticky Bit (`+t` or octal `1000`)**: Set on shared directories like `/tmp`. Anyone can create files, but users can only delete or rename files they own. Displayed as `t` in `ls -l` (e.g. `drwxrwxrwt`). - **SUID (Set User ID, `u+s` or octal `4000`)**: When set on an executable binary, standard users run the binary with the file owner's privileges (usually root). Displayed as `s` in owner execute position (e.g. `-rwsr-xr-x`). Essential for tools like `/usr/bin/passwd`. - **Security Auditing**: Attackers frequently abuse SUID binaries for privilege escalation. Sysadmins audit systems for SUID binaries using: `find / -perm -4000 2> /dev/null`.

Missione 39Bloccato

Standard Linux permissions only support one user owner, one group, and others. When complex enterprise collaboration requires granting distinct rights to multiple users or groups on a single file, **POSIX Access Control Lists (ACLs)** are used: - `getfacl <file>`: Reads and displays the file's extended ACL entries (user, group, mask, other). - `setfacl -m u:<username>:<perms> <file>`: Modifies the ACL to grant specific permissions (`r`, `w`, `x`) to an individual user without changing the file owner. - Notice that when a file has an ACL, `ls -l` displays a `+` symbol at the end of the permission string (e.g., `-rw-rw-r--+`).

👑 Boss · Missione 40Bloccato

AUDIT FAILURE: An internal compliance scanner raised a critical security finding: `/etc/vault.conf` containing sensitive credentials was deployed with permissive `777` permissions and is owned by `learner` instead of `root`. Remediate the vulnerability immediately by changing the owner of `/etc/vault.conf` to `root:root` and locking down permissions to strict `600` (read/write for owner only). Inspect the file with `ls -l` before and after running your remediation.

5. Superutente e Pacchetti

Missione 41Bloccato

Immagina di lavorare sul tuo computer con un account standard per impedire l'eliminazione accidentale di file critici del sistema operativo. Quando è necessario installare software o modificare le impostazioni di sistema, il computer richiede l'autorizzazione dell'amministratore. In Linux utilizziamo `sudo` (abbreviazione di "superuser do") come chiave magnetica amministrativa. - L'utente `root` è l'account amministratore principale con il controllo completo sul sistema. - Agli utenti standard viene impedito di leggere file sensibili (come il database delle password `/etc/shadow`). Digitando `sudo` prima di un comando, lo esegui con poteri di amministratore temporanei per aggirare questi blocchi.

Missione 42Bloccato

Pensa ad installare app sul tuo smartphone utilizzando l'App Store o Google Play Store. È sicuro, curato e automatizzato. In Linux, utilizziamo un app store da riga di comando chiamato gestore di pacchetti per recuperare e installare il software in modo sicuro. - Sui sistemi Ubuntu/Debian, il gestore di pacchetti standard è `apt` (Advanced Packaging Tool). - L'installazione del software modifica le cartelle a livello di sistema, quindi è sempre necessario autorizzarlo utilizzando `sudo`. Ad esempio, `sudo apt install tree` scarica e installa il visualizzatore di directory "albero".

Missione 43Bloccato

Prima di installare il software su Linux, come si scoprono quali pacchetti sono disponibili nel repository? In Linux utilizziamo `apt search` per interrogare il catalogo software tramite parola chiave. - Il comando `apt search <keyword>` analizza le descrizioni del repository ed elenca i pacchetti software corrispondenti insieme alle relative versioni. - A differenza di `apt install`, la ricerca nei repository dei pacchetti legge solo i file di indice del catalogo locale e **non** richiede i privilegi di superutente (`sudo`).

Missione 44Bloccato

Quando si disinstalla il software su Linux, lo standard `apt remove` disinstalla i binari dell'applicazione ma lascia i file di configurazione del sistema nel caso in cui si reinstalli in seguito. Per eliminare completamente un pacchetto software E cancellare tutti i file di configurazione associati, utilizziamo `apt purge` (o `apt remove --purge`). - Il comando `sudo apt purge <package>` rimuove l'applicazione e cancella tutti i file di configurazione rimanenti. - Poiché l'eliminazione modifica le cartelle e i file di configurazione a livello di sistema, richiede privilegi di superutente (`sudo`).

Missione 45Bloccato

Mentre `apt` automatizza il download e la risoluzione delle dipendenze dei pacchetti dai repository, cosa succede se hai già scaricato manualmente un file del pacchetto `.deb` e desideri controllarlo o installarlo? In Linux utilizziamo `dpkg` (pacchetto Debian) per interagire direttamente con i pacchetti. - Il comando `dpkg -l` elenca tutti i pacchetti attualmente installati sul tuo sistema Debian/Ubuntu. - Il comando `dpkg -s <package>` visualizza informazioni su stato, versione e architettura per un pacchetto specifico.

Missione 46Bloccato

Non tutti gli ambienti Linux sono basati su Debian/Ubuntu. Se lavori su sistemi RedHat, Fedora o CentOS, non troverai `apt` o `dpkg`. Gestirai invece i pacchetti utilizzando i gestori di pacchetti `yum` più vecchi o moderni `dnf` (Dandified YUM). - Il comando `dnf check-update` (o `yum check-update`) si connette ai repository RedHat per cercare gli aggiornamenti dei pacchetti disponibili. - Il comando `dnf install <package>` recupera e installa programmi simili a `apt install`.

Missione 47Bloccato

New system administrators often confuse updating and upgrading. In Debian and Ubuntu environments: - `sudo apt update`: Refreshes your local cache of package lists from upstream repository servers (`/etc/apt/sources.list`). It discovers which newer package versions exist, but **does not modify or upgrade any software** on disk. - `sudo apt upgrade`: Compares your currently installed software against the refreshed list and downloads/installs the newer package versions. Running `apt upgrade` without running `apt update` first will either install outdated versions or fail completely because your system does not know newer releases exist!

Missione 48Bloccato

In cross-distribution Linux environments, you will frequently encounter formats beyond Debian `.deb` packages: - **RPM (`rpm`)**: The native package format for RedHat, CentOS, and Fedora. Use `rpm -qa` to list every installed RPM package, and `rpm -qi <package>` to query deep metadata (version, build architecture, signature, description). - **Snap (`snap`)**: Canonical's universal containerized package system. Snaps bundle all dependencies in an isolated sandbox across any Linux distro. Inspect installed snaps with `snap list` and install new tools with `sudo snap install <package>`.

👑 Boss · Missione 49Bloccato

INCIDENT RESPONSE: An unauthorized script dropped a suspicious unsigned package archive `/tmp/corrupt_pkg.deb` into temporary storage. Furthermore, the standard network diagnostic utility `curl` is missing or unverified in the system catalog. Cleanse the temporary directory by purging `/tmp/corrupt_pkg.deb` and ensure the package manager has `curl` installed and ready for service.

6. Disco e Risorse di Sistema

Missione 50Bloccato

Immagina di provare a scaricare un videogioco enorme e di ricevere un errore di "memoria piena", ma non sei sicuro di quale unità disco sia il collo di bottiglia. In Linux, controlliamo la capacità di archiviazione del nostro sistema utilizzando il comando `df` (disk free). - Il comando `df` visualizza lo spazio totale, utilizzato e disponibile su tutte le unità connesse. - Eseguendo `df -h` (aggiungendo il flag `-h` per "leggibile dall'uomo"), vedi lo spazio di archiviazione in gigabyte (G) e megabyte (M) invece di confondere i conteggi dei blocchi, rendendo facile individuare quale unità (come `/` o `/home`) è piena. **Perché è importante**: se esegui `df` senza `-h`, le dimensioni vengono visualizzate in numeri grezzi di blocchi da 1K (ad esempio, `49258284` invece di `47G`), che è estremamente difficile da leggere e calcolare per un essere umano. Il flag `-h` formatta queste dimensioni in gigabyte (G) e megabyte (M) a misura d'uomo.

Missione 51Bloccato

Una volta che sai *quale* unità è piena, come trovi la cartella specifica che sta accumulando tutto il tuo spazio? È la cartella dei download o forse qualche cache nascosta? Risolviamo questo mistero utilizzando il comando `du` (utilizzo del disco). - `du <directory>` elenca la dimensione di una cartella e di ogni sottocartella al suo interno. - `du -sh <directory>` (dove `-s` significa "riepilogo" e `-h` significa "leggibile") calcola e stampa un'unica dimensione totale pulita per quella cartella specifica. **Perché è importante**: se esegui `du` senza `-s`, verrà scaricato un enorme muro di testo che elenca ogni singola sottodirectory e file in modo ricorsivo, anziché fornire un singolo riepilogo. Il flag `-s` riepiloga la dimensione totale della cartella e `-h` la rende leggibile.

Missione 52Bloccato

Immagina che il tuo laptop inizi a rallentare, le pagine Web si blocchino e il passaggio da un'app all'altra sia dolorosamente lento. Questo di solito significa che il tuo computer sta esaurendo la memoria attiva (RAM). In Linux, possiamo verificare quanto respiro ha il nostro sistema utilizzando il comando `free`. - Il comando `free` mostra la memoria fisica totale, utilizzata e disponibile (RAM) e lo spazio di swap. - L'aggiunta del flag `-h` (in esecuzione `free -h`) formatta le dimensioni della memoria in gigabyte (GB) e megabyte (MB) di facile lettura in modo da poter sapere se un programma sta consumando tutte le risorse. **Perché è importante**: se esegui `free` senza `-h`, l'utilizzo della memoria viene stampato in kilobyte grezzi (ad esempio, `16323456` invece di `16G`), il che è difficile da interpretare rapidamente. Il flag `-h` ridimensiona automaticamente i numeri in gigabyte (G) o megabyte (M) per una facile lettura.

Missione 53Bloccato

Immagina di dover risolvere i problemi di un server che ha iniziato a comportarsi in modo anomalo e di dover sapere se si è riavviato di recente o di controllare esattamente quale versione del sistema operativo è in esecuzione. Possiamo interrogare questi dettagli del sistema in pochi secondi: - Il comando `uptime` ti dice esattamente da quanto tempo il tuo computer è in funzione dall'ultimo avvio, insieme a quanto è stato occupato (carico del sistema). - Il comando `uname -a` (nome unix) stampa un rapporto completo del kernel del sistema, del nome della piattaforma e dell'architettura della macchina. **Perché è importante**: se esegui `uname` senza `-a`, viene restituito solo il nome del sistema operativo di base (ad esempio, `Linux`). Tralascia dettagli critici come la versione del kernel, il nome della piattaforma e l'architettura del processore. Il flag `-a` stampa tutti i dettagli del sistema disponibili in un unico report.

Missione 54Bloccato

Quando si risolvono i problemi relativi alle prestazioni del sistema o si distribuiscono applicazioni ad alta richiesta, è necessario conoscere le capacità della CPU del sistema. In Linux, leggiamo informazioni dettagliate sull'architettura della CPU utilizzando il comando `lscpu`. - Il comando `lscpu` visualizza i dettagli del processore come modello di CPU, fornitore, velocità di clock, numero di core, dettagli di hyper-threading e dimensioni della cache, direttamente dal filesystem del kernel.

Missione 55Bloccato

Quando un database o un'applicazione Web viene eseguito lentamente, come si determina se il problema è un collo di bottiglia della CPU o un disco rigido lento? In Linux, monitoriamo i parametri delle prestazioni di output/input del sistema utilizzando `iostat`. - Il comando `iostat` visualizza le statistiche dei report sull'utilizzo della CPU e sulla velocità effettiva di lettura/scrittura del dispositivo attivo, aiutandoti a identificare la congestione del disco.

Missione 56Bloccato

Before a disk can store files, it is divided into storage blocks and partitions formatted with filesystems. In Linux: - `lsblk`: Lists block storage devices (hard drives, NVMe SSDs, flash drives) in an intuitive tree showing parent drives (like `sda`, `sdb`), child partitions (like `sda1`, `sdb1`), sizes, and active mountpoints. Adding `-f` shows filesystem types and UUIDs. - `sudo blkid`: Queries disk headers directly to print device Universally Unique Identifiers (UUIDs), filesystem formats (such as `ext4`, `xfs`, `vfat`), and partition labels used in boot and mount configurations.

Missione 57Bloccato

In Unix systems, disk drives do not have isolated drive letters like `C:\` or `D:\`. Instead, all filesystems attach into a unified directory tree: - `sudo mount <device> <directory>`: Attaches a formatted block partition (e.g. `/dev/sdb1`) into an existing directory folder (the "mountpoint", e.g. `/mnt/data`). - `sudo umount <directory>`: Safely detaches the filesystem, committing unwritten buffers to disk before unplugging or reformatting. - `/etc/fstab`: The static filesystem table file describing which partitions automatically mount at boot time, their mount options, and dump/fsck pass priorities.

Missione 58Bloccato

When hardware devices attach, drives fail, or the Linux kernel encounters system memory exhaustion, kernel messages are written to a special memory area called the **Kernel Ring Buffer**. - `dmesg`: Dumps raw kernel boot and runtime log messages. - `dmesg -T`: Converts raw timestamps into readable date and time strings. - Pipelining `dmesg | grep -i error` or filtering for "Out of memory" reveals low-level driver failures and Out-Of-Memory (OOM) killer terminations.

👑 Boss · Missione 59Bloccato

CRITICAL ALERT: Root filesystem capacity has hit 99%! Production monitoring reports that an unhandled core dump `/var/log/huge_core_dump.log` is suffocating system storage. Locate the runaway file, delete `/var/log/huge_core_dump.log` to reclaim space, and create a status confirmation log `/home/learner/disk_recovery.txt` containing a summary of recovered capacity.

7. Gestione dei Processi

Missione 60Bloccato

Pensa al tuo sistema operativo come a un ufficio affollato in cui a ogni dipendente (o programma in esecuzione) viene assegnato un nome univoco chiamato ID processo (PID). In Linux chiamiamo questi programmi attivi **processi** e li elenchiamo utilizzando il comando `ps`. - L'esecuzione di `ps` da sola mostra solo i programmi in esecuzione nella finestra del terminale corrente. - L'esecuzione di `ps aux` agisce come un registro principale dell'ufficio, elencando ogni singolo programma attivo in esecuzione nell'intero sistema, chi lo ha avviato e quanta CPU e memoria sta utilizzando. **Perché è importante**: se esegui `ps` senza `aux`, vedrai solo i processi in esecuzione nella finestra del terminale corrente (di solito solo `bash` e `ps` stesso). Non vedrai servizi in background, processi di sistema o programmi eseguiti da altri utenti. Le opzioni `aux` rivelano tutti i processi in esecuzione a livello di sistema.

Missione 61Bloccato

Immagina di guardare una foto statica di un'autostrada invece di guardare il feed di una telecamera sul traffico in tempo reale. Mentre `ps` ti offre una rapida istantanea di ciò che è in esecuzione in questo momento, `top` ti consente di guardare le prestazioni del tuo sistema in tempo reale. - Il comando `top` avvia una dashboard interattiva in tempo reale che si aggiorna ogni pochi secondi. Visualizza l'utilizzo della CPU, le medie di carico e classifica dinamicamente i processi più pesanti in esecuzione in questo preciso momento.

Missione 62Bloccato

Nei sistemi simili a Unix, "tutto è un file". Ciò significa che non solo i file di testo e le cartelle, ma anche i socket di rete, l'hardware di sistema e i processi vengono trattati come file. Per scoprire a quali file si accede e da quali programmi in esecuzione, utilizziamo `lsof` (List Open Files). - L'esecuzione di `lsof` visualizza un elenco completo di tutti i file aperti, insieme all'ID processo (PID) e al comando che li ha aperti. - Ad esempio, l'esecuzione di `lsof -i` elenca tutti i file/socket di rete, il che è estremamente utile per scoprire quale processo è in ascolto su una porta di rete specifica (come la porta 80).

Missione 63Bloccato

Immagina che un'app sul tuo telefono si blocchi, bloccando completamente lo schermo e che tu debba forzarne la chiusura per far funzionare di nuovo le cose senza intoppi. In Linux, interrompiamo il comportamento anomalo o blocchiamo i programmi utilizzando il comando `kill` seguito dall'ID processo (PID) del programma. - L'esecuzione di `kill 1234` invia una richiesta cortese chiedendo al programma di salvare il proprio lavoro e di chiudersi. - Se è bloccato e ignora la richiesta gentile, `kill -9 1234` forza il sistema operativo a spegnerlo immediatamente. Abbiamo un processo fuori controllo con PID `9999` che monopolizza tutta la nostra CPU: spegniamolo!

Missione 64Bloccato

Immagina di provare a copiare una cartella di grandi dimensioni su un'unità USB, ma mentre copia, vuoi continuare a lavorare e digitare altri comandi nella stessa finestra. In Linux, possiamo eseguire attività che richiedono molto tempo in " background " in modo che non blocchino la nostra riga di comando. - L'aggiunta di una e commerciale `&` alla fine di un comando (come `sleep 100 &`) indica al terminale di eseguirlo in background e di restituirti immediatamente il prompt. - Il comando `jobs` mostra ciò che è attualmente in esecuzione in background. - Il comando `fg` (in primo piano) riporta un'attività in background al centro della scena.

Missione 65Bloccato

In un ufficio occupato, alcune attività a bassa priorità (come l'archiviazione delle ricevute) possono attendere, mentre le richieste ad alta priorità devono essere gestite immediatamente. Linux gestisce la priorità dei processi utilizzando valori di **niceness** che vanno da -20 (priorità più alta) a 19 (priorità più bassa). - Il comando `nice` avvia un processo con una priorità personalizzata. Per esempio. `nice -n 10 sleep 5` avvia un comando di sospensione con una priorità "polite" pari a 10. - Il comando `renice` altera la priorità di pianificazione di un processo già in esecuzione. Ad esempio, `sudo renice +5 9999` abbassa la priorità del processo 9999.

Missione 66Bloccato

Abbiamo già visto come avviare un'attività in background utilizzando `&` e ripristinarla utilizzando `fg`. Ma cosa succede se hai avviato un comando senza `&` o lo hai sospeso con `Ctrl+Z`? Puoi riprenderlo in background utilizzando `bg`! - Il comando `bg` riprende i lavori sospesi, consentendone l'esecuzione in background senza bloccare il prompt del terminale.

Missione 67Bloccato

In fast-paced system operations, looking up process IDs with `ps aux | grep name` just to pass a numerical PID into `kill` is slow and error-prone. Linux provides process lookup and signal tools that operate directly by process name: - `pgrep <pattern>`: Scans active processes and returns matching PIDs. Adding `-a` outputs the full command line alongside the PID. - `pkill <pattern>`: Sends termination signals directly to all processes matching the pattern (e.g. `pkill -9 miner`). - `killall <name>`: Kills processes matching the exact binary executable name.

Missione 68Bloccato

Long-running tasks need two critical abilities: surviving unexpected network disconnects, and real-time execution monitoring without manual re-typing: - `nohup <command> &`: Runs a command immune to SIGHUP (hangup signals). If your SSH session drops or terminal closes, the program continues executing in the background, redirecting stdout/stderr into `nohup.out`. - `watch -n <seconds> <command>`: Repeatedly executes a command at a set interval (default 2s), clearing the screen to display a live updating dashboard of system state.

👑 Boss · Missione 69Bloccato

SERVER THROTTLED: CPU load average has spiked above 25.0. An unauthenticated background script (PID 9999 running `rogue_process.sh`) is monopolizing 99.1% of processor cycles and starving application threads. Inspect the active process table to discover the rogue PID, determine its signal tolerance, and kill the process immediately so it ceases execution.

8. Risoluzione Problemi di Rete

Missione 70Bloccato

Immagina di provare a caricare una pagina web, ma il tuo browser gira all'infinito, lasciandoti a chiederti se il Wi-Fi di casa è disconnesso o se il sito web stesso si è bloccato. In Linux, testiamo la nostra connessione di rete di base utilizzando il comando `ping`. - Il comando `ping` invia piccoli pacchetti di dati a un server (come `google.com`) e misura quanti millisecondi sono necessari per ricevere una risposta. - Su Linux, `ping` continuerà a funzionare per sempre per impostazione predefinita. Per fermarlo dopo alcuni tentativi, utilizziamo il flag `-c` (conteggio), eseguendo `ping -c 3 google.com`. **Perché è importante**: se esegui `ping google.com` senza `-c`, continuerà a inviare pacchetti e a stampare output all'infinito. Dovrai interromperlo manualmente con `Ctrl+C` per eseguire qualsiasi altro comando. Il flag `-c 3` interrompe automaticamente il comando dopo aver inviato esattamente 3 pacchetti.

Missione 71Bloccato

Immagina di configurare una stampante di rete o condividere file con il computer di un amico sullo stesso Wi-Fi e di dover conoscere l'indirizzo IP locale della tua macchina. In Linux, controlliamo l'hardware e gli IP della nostra rete utilizzando il comando `ip`. - L'esecuzione di `ip addr` (o semplicemente `ip a`) stampa un elenco di tutti i dispositivi di interfaccia di rete (come `eth0` per Ethernet cablata o `wlan0` per wireless) insieme agli indirizzi IP locali assegnati.

Missione 72Bloccato

Prima che la moderna suite di comandi `ip` diventasse standard, gli amministratori di sistema Linux si affidavano a `ifconfig` (configuratore di interfacce) per visualizzare e gestire le interfacce di rete. - Il comando `ifconfig` visualizza le interfacce di rete attive, la configurazione IP locale, i dettagli della maschera di rete e gli indirizzi hardware MAC. Sebbene deprecato su alcune distribuzioni più recenti, rimane ampiamente utilizzato sui server legacy.

Missione 73Bloccato

Sulle moderne workstation e server Linux, le interfacce di rete sono gestite da un demone di sistema chiamato NetworkManager. Invece di modificare manualmente i file di configurazione, configuriamo i dettagli della rete utilizzando `nmcli`. - Il comando `nmcli` (NetworkManager CLI) consente di ispezionare le connessioni hardware, gli stati dei dispositivi e le reti Wi-Fi attive.

Missione 74Bloccato

Quando si configura un database o un server Web, è necessario verificare che il servizio sia in esecuzione e in ascolto sulla porta corretta e verificare se vengono stabilite connessioni non autorizzate. Lo facciamo utilizzando `netstat` o `ss`. - Il comando `netstat` (statistiche di rete) è uno strumento classico per mostrare le connessioni TCP e le porte di ascolto. Per esempio. `netstat -tuln` elenca le porte di ascolto TCP/UDP. - Il comando `ss` (statistiche socket) è l'alternativa moderna e più veloce a `netstat` che visualizza i dettagli della connessione socket direttamente dallo spazio dei nomi del kernel.

Missione 75Bloccato

Quando una pagina Web non viene caricata, come si identifica se il problema riguarda il router di casa, il provider di servizi Internet (ISP) o il server di destinazione? In Linux tracciamo i pacchetti utilizzando `traceroute`. - Il comando `traceroute` elenca ogni gateway router (hop) che un pacchetto attraversa nel suo percorso verso un server remoto, insieme alla latenza di risposta per ogni hop.

Missione 76Bloccato

Immagina di voler scaricare un file o prendere il codice di uno script di installazione direttamente da un server web senza aprire un browser e fare clic sul pulsante "Download". In Linux, recuperiamo i dati web utilizzando `curl` (abbreviazione di "URL cliente"). - L'esecuzione di `curl <url>` scarica il contenuto della pagina e lo stampa direttamente sullo schermo. - Per salvare il contenuto scaricato come file invece di visualizzarlo, lo abbiniamo al reindirizzamento `>` o al flag di output `-o`.

Missione 77Bloccato

When your machine translates a human-readable domain name like `example.com` into an IP address like `93.184.216.34`, it queries DNS nameservers configured in `/etc/resolv.conf`. - `/etc/resolv.conf`: Contains your system's primary and fallback DNS nameservers. - `dig <domain>`: The de-facto standard administrator tool for testing DNS queries, returning response headers, query latency, and record TTLs. Adding `+short` prints only the final IP answer. - `nslookup <domain>` and `host <domain>`: Lightweight queries for checking A/AAAA and MX mail exchange records.

Missione 78Bloccato

When your server sends a packet to an IP address outside its local subnet, how does the kernel know which router or network card interface to send it through? It consults the **Kernel IP Routing Table**. - `ip route` (or `ip r` / `ip ro`): Displays active routing table entries. - The line starting with `default via <IP> dev <interface>` defines your **Default Gateway** (your router), which handles all internet traffic not addressed to a local subnet.

Missione 79Bloccato

Two everyday network maintenance tasks are testing whether remote ports are open and downloading files without browsers: - `nc` (Netcat): Often called the "Swiss Army Knife" of TCP/IP. Running `nc -zv <host> <port>` scans a target port without sending application data (`-z` for zero-I/O port scanning, `-v` for verbose output), instantly confirming if a firewall or service is responding. - `wget`: The robust non-interactive network downloader. Running `wget -O <output-file> <url>` downloads files reliably, resuming broken connections.

Missione 80Bloccato

Every computer on a network possesses a hostname that identifies it to other machines and shell prompts (e.g., `learner@bashquest:~$`). In modern systemd environments: - `hostname`: Displays the current simple system hostname. - `hostnamectl`: Displays complete system identification metadata, including operating system release, kernel build version, hardware chassis, and virtualization hypervisor. - `sudo hostnamectl set-hostname <name>`: Persistently updates the hostname across reboots by modifying `/etc/hostname` and updating the systemd hostnamed daemon.

👑 Boss · Missione 81Bloccato

SECURITY COMPROMISE: An attacker injected a DNS poisoning entry `0.0.0.0 evil-tracker.local` directly into `/etc/hosts`, corrupting internal hostname resolution. Remediate the threat: edit or clean `/etc/hosts` to remove all references to `evil-tracker.local`, and record `evil-tracker.local` in `/etc/blocked_hosts.conf` so the domain is permanently logged for network blacklisting.

9. Ricerca di File

Missione 82Bloccato

Immagina di smarrire un importante file di testo da qualche parte nella tua cartella utente e di dover cercare tra dozzine di directory nidificate una per una. In Linux, evitiamo la ricerca manuale utilizzando l'utilità `find` come motore di ricerca velocissimo a livello di sistema. - Il comando `find` effettua la ricerca negli alberi di directory in base a nome, dimensione, tipo o data. - La sintassi è `find <where> -name "<pattern>"`. Ad esempio, `find . -name "*.txt"` cerca nella directory corrente e in tutte le sottocartelle i file che terminano con `.txt`. **Perché è importante**: se esegui `find . "*.log"` senza `-name`, riceverai l'errore: `find: paths must precede expression: '*.log'`. Il flag `-name` è necessario per specificare che il modello successivo deve essere confrontato con i nomi dei file.

Missione 83Bloccato

Immagina di aver digitato un comando diagnostico di rete lungo e complesso dieci minuti fa e ora devi eseguirlo di nuovo, ma non ricordi le opzioni esatte o la sintassi. Invece di grattarti la testa o scriverlo dappertutto, Linux lo ricorda per te! - Il comando `history` visualizza un elenco numerato di tutti i comandi che hai eseguito di recente. - Puoi rieseguire rapidamente qualsiasi elemento digitando un punto esclamativo seguito dal numero dell'elenco (come `!42` per rieseguire il comando n. 42).

Missione 84Bloccato

Immagina di provare a utilizzare un nuovo comando, ma non sei sicuro di quali flag supporta o di come dovrebbero essere formattati i suoi input. Invece di cercare online, Linux ha un manuale utente ufficiale e completo integrato direttamente nel terminale! - Il comando `man` (manuale) seguito da qualsiasi nome di utilità (ad esempio, `man ls`) apre una guida di riferimento dettagliata. - All'interno della guida, scorri con i tasti freccia, cerca con "/", e premi `q` per chiudere il manuale e tornare al prompt.

Missione 85Bloccato

Beyond basic filename queries, `find` is a powerhouse filter engine for automated system cleanup and log rotation: - `-size +50M`: Filters for files strictly larger than 50 Megabytes (`+` for greater than, `-` for less than). - `-mtime -7`: Filters for files modified within the last 7 days. - `-exec <cmd> {} +`: Passes all matched files directly into a command in batches, replacing `{}` with matched file paths. Combining these allows single-line system maintenance, such as finding and purging runaway logs: `find /var/log -size +50M -exec rm {} +`.

Missione 86Bloccato

When `find` is too slow because it scans the live disk tree, and you need to inspect command binaries vs shell builtins: - `sudo updatedb`: Crawls the entire filesystem and builds a high-speed precomputed search index database (`mlocate.db`). - `locate <name>`: Instantly searches the indexed database in milliseconds instead of seconds. - `whereis <cmd>`: Locates binary executables, source files, and man pages in standard system paths. - `type <name>`: Identifies whether a command is a shell builtin (e.g. `cd`, `umask`), an alias (e.g. `ll`), or an external binary disk file (e.g. `/bin/ls`).

Missione 87Bloccato

When you know what task you want to achieve, but don't remember the exact Linux command name, or when you need a quick one-line summary of what an unfamiliar command does: - `apropos <keyword>`: Searches through the short one-line description summaries of **all manual pages** on the system, returning any command related to that concept (e.g. `apropos partition`, `apropos process`). - `whatis <cmd>`: Displays the exact single-line summary from section 1 or 8 of that specific tool's manual page (e.g. `whatis ls`, `whatis grep`).

👑 Boss · Missione 88Bloccato

DISASTER RECOVERY: Before an unexpected reboot, a database administrator saved an encrypted backup archive named `db_backup_secure.tar.gz`, but failed to document its path. It is lost somewhere on the filesystem. Locate the misplaced archive file anywhere across the system hierarchy, and restore it to its designated safe haven: copy it to `/home/learner/backups/db_backup_secure.tar.gz`.

10. Servizi e Systemd

Missione 89Bloccato

Immagina di ospitare un sito Web sul tuo computer, ma i visitatori ricevono un errore "impossibile raggiungere il sito" perché il programma del server Web in background non è in esecuzione. In Linux, i processi in background che si avviano automaticamente e vengono eseguiti in background (come database, firewall o server Web) sono chiamati **servizi** e li gestiamo utilizzando `systemctl`. - Il comando `systemctl status <service>` controlla se un servizio è attivo o arrestato. - Poiché l'avvio o l'arresto di un servizio influisce su tutti gli utenti e sulla sicurezza del sistema, è necessario utilizzare `sudo` per eseguire comandi come `sudo systemctl start <service>` o `sudo systemctl stop <service>`.

Missione 90Bloccato

Ora che puoi avviare e arrestare i servizi in background con `systemctl`, come puoi risolverli quando falliscono? L'utilità `journalctl` consente di controllare i log di sistema generati dai servizi gestiti da systemd. - Per impostazione predefinita, `journalctl` mostra tutti i registri di sistema. Poiché questo può essere enorme, li filtriamo per rimanere concentrati. - L'opzione `-u <service>` filtra i log per mostrare solo i messaggi di un servizio specifico (ad esempio `journalctl -u apache2`). - L'opzione `-n <number>` mostra solo le voci più recenti (ad esempio `journalctl -n 5` per gli ultimi 5 registri). - Il flag `-f` (follow) visualizza i log in tempo reale mentre vengono scritti.

Missione 91Bloccato

Starting a service with `systemctl start` only launches it for the current session. If the server reboots, the service will stay offline unless you configure it to start automatically on system initialization. - To start a service at boot, run `sudo systemctl enable <service>`. - To verify whether a service is scheduled to launch at boot, run `systemctl is-enabled <service>`. - When creating or editing systemd unit files, always notify systemd to reload its configuration cache with `sudo systemctl daemon-reload`. - To disable a service from starting at boot, run `sudo systemctl disable <service>`.

Missione 92Bloccato

Accurate system time is critical for log auditing, authentication protocols (Kerberos, TLS certificates), and scheduled database backups. - The `timedatectl` utility queries and changes the system clock and its timezone. - View the current time settings, RTC, and active timezone with `timedatectl status` (or simply `timedatectl`). - Set the system timezone using superuser rights: `sudo timedatectl set-timezone UTC`. - When shutting down or restarting production servers, use the `shutdown` command with safety delays and broadcast notices: `sudo shutdown -r now` (reboots immediately) or `sudo shutdown -c` (cancels scheduled shutdowns).

👑 Boss · Missione 93Bloccato

OUTAGE REPORT: The primary HTTP frontend service `apache2.service` crashed and is currently in an `inactive (dead)` state. Client web requests are timing out. Inspect the service status with your service management tools, discover the problem, and use `systemctl` with superuser privileges to restart or start `apache2` so it returns to `active (running)`.

11. Modifica di Testo da Terminale

Missione 94Bloccato

Immagina di accedere tramite SSH a un server cloud remoto in cui non disponi di un desktop grafico o di un cursore e devi correggere rapidamente una riga in un file di configurazione. In questi scenari, è necessario utilizzare un editor di testo del terminale come `nano`. - L'esecuzione di `nano <filename>` carica un editor di testo semplice e leggero direttamente nella finestra della shell. - Le scorciatoie vengono sempre visualizzate nella parte inferiore dello schermo: premi `Ctrl+O` per scrivere (salvare) le modifiche e `Ctrl+X` per uscire dall'editor.

Missione 95Bloccato

Vim is one of the most powerful and ubiquitous terminal text editors in Linux. Unlike traditional graphical editors, Vim is **modal**: - **Normal Mode**: The default mode used for navigation, deleting, and issuing commands. - **Insert Mode**: The mode used for typing text. Press `i` from Normal Mode to start typing. - **Return to Normal Mode**: Press `Esc` at any time to leave Insert Mode. - **Command-Line Mode**: From Normal Mode, press `:` to type commands at the bottom prompt: - `:w` writes (saves) the file. - `:q` quits the editor. - `:wq` (or `:x`) saves and exits in one step. - `:q!` quits immediately, discarding all unsaved changes.

Missione 96Bloccato

Once you master Normal mode commands, Vim allows lightning-fast text manipulation without touching a mouse: - `dd`: Delete (cut) the entire current line into the yank buffer. - `yy`: Yank (copy) the current line. - `p`: Paste the yank buffer on the line below the cursor. - `/pattern`: Search forward through the file for text matching `pattern`. - `:%s/old/new/g`: Global search and replace throughout the entire file without manual edits.

👑 Boss · Missione 97Bloccato

CONFIGURATION CORRUPTION: A late-night config commit broke `/home/learner/server.conf`. The file contains invalid directives: `host=0.0.0.0.0` (malformed IP) and `port=99999` (outside the 1-65535 port range). Open `/home/learner/server.conf` with your text editor (nano, vim, or shell tools) and correct the file so that `host=127.0.0.1`, `port=80`, and `max_connections=500` are set.

12. Scripting Shell e Automazione

Missione 98Bloccato

Immagina di avere un elenco di 20 attività che devi eseguire ogni singola mattina. Scriverli manualmente è noioso e lascia spazio a errori di battitura. In Linux, raggruppiamo i comandi in un file chiamato script di shell in modo da poterli eseguire tutti in una volta! - Ogni script inizia con uno "shebang" (`#!/bin/bash`) sulla prima riga per indicare al sistema quale interprete shell utilizzare per eseguire il file. - Dopo aver salvato lo script, lo rendi eseguibile concedendogli l'autorizzazione di esecuzione tramite `chmod 755 script.sh` e quindi eseguendolo con `./script.sh`.

Missione 99Bloccato

Immagina di creare un messaggio di benvenuto personalizzato per un sito web. Non vorrai scrivere uno script separato per il nome di ogni singolo cliente! Invece, scrivi uno script che accetta un nome come input quando lo esegui. - Negli script bash, variabili come `$1`, `$2` e così via contengono gli "argomenti" o gli input che passi alla riga di comando. - Ad esempio, l'esecuzione di `./greet.sh Alice` significa che `$1` all'interno dello script conterrà automaticamente il testo "Alice". Allo stesso modo, `$#` tiene traccia di quanti input ha fornito l'utente.

Missione 100Bloccato

Immagina di creare uno script che elabori un report CSV, ma si blocca se il file di report non esiste effettivamente sul disco. Per prevenire errori, scriviamo script che prendono decisioni utilizzando la logica condizionale `if/else`. - Controlliamo le condizioni utilizzando parentesi: `if [ -f "$1" ]; then ... fi`. - Il flag `-f` controlla se un percorso punta a un file, mentre `-d` controlla se si tratta di una directory. Lo script ramifica le sue azioni a seconda che la condizione risulti vera o falsa.

Missione 101Bloccato

Immagina di avere una cartella di 100 file di registro e di dover fare una copia di backup di ognuno di essi. Copiarli singolarmente sarebbe estenuante. In Linux, utilizziamo i cicli `for` per ripetere automaticamente la stessa azione su un intero elenco di elementi! - Un ciclo `for` (come `for file in *.txt; do ... done`) esegue un'iterazione su ogni elemento che corrisponde a un modello, elaborandoli uno dopo l'altro in una frazione di secondo.

Missione 102Bloccato

Hai scritto cicli e condizionali per automatizzare le azioni negli script. Ma man mano che i tuoi script crescono, copiare e incollare la stessa logica più e più volte li rende difficili da mantenere. In bash possiamo raggruppare i comandi in funzioni riutilizzabili. - Per definire una funzione, la dichiariamo con il nome seguito da parentesi e parentesi graffe: `log_msg() { echo "msg"; }`. - Le funzioni possono ricevere argomenti proprio come gli script di shell, a cui si accede utilizzando i parametri di posizione locale `$1`, `$2`, ecc. all'interno del corpo della funzione. - Per chiamare una funzione, usa semplicemente il suo nome come qualsiasi altro comando: `log_msg "Backup started"`.

Missione 103Bloccato

Ora che hai scritto script di shell robusti, non vorrai accedere a mezzanotte solo per eseguire il tuo assistente di backup. Linux fornisce il servizio `cron` per eseguire comandi o script automaticamente in momenti specifici. - Il servizio cron controlla una tabella di pianificazione chiamata `crontab`. - Ogni pianificazione cron ha 5 campi che rappresentano l'ora: `minute hour day-of-month month day-of-week` seguito dal comando. - Ad esempio, `30 2 * * * /path/to/script.sh` esegue uno script ogni giorno alle 2:30. - Usiamo `crontab -l` per elencare i nostri lavori cron attivi e `crontab <filename>` per caricare le pianificazioni da un file.

Missione 104Bloccato

Every command executed in Linux returns an **exit status code** between 0 and 255 upon completion: - `0`: Success (no errors occurred). - `1-255`: Failure or error code. - The special shell parameter `$?` stores the exit code of the immediately preceding command: `echo $?`. Shell logic operators chain commands based on exit codes: - `cmd1 && cmd2`: Logical AND. Runs `cmd2` **only if** `cmd1` succeeds (exit code 0). - `cmd1 || cmd2`: Logical OR. Runs `cmd2` **only if** `cmd1` fails (non-zero exit code). Combining them creates clean resilient commands: `mkdir backup && cp app.db backup/ || echo "Backup failed"`.

Missione 105Bloccato

Interactive and automated scripts rely on two essential shell capabilities: 1. **User Input (`read`)**: Prompts the user to enter data and stores the response in a shell variable. The `-p` flag prints a custom prompt string: `read -p "Enter username: " USERNAME` 2. **Command Substitution (`$(...)`)**: Executes a command in a subshell and substitutes its standard output into the variable or command line: `TODAY=$(date +%F)` This lets you create dynamic timestamped filenames and automated reports.

Missione 106Bloccato

Two of the most common control structures in systems engineering scripts are file-reading loops and case branches: 1. **File-reading `while` loop**: Reads input line by line safely using `read -r` without interpreting escape characters: `while read -r line; do echo "Processing: $line"; done < names.txt` 2. **`case` statement**: Matches a variable against multiple patterns cleaner than multiple `if/elif` blocks: `case $1 in start) systemctl start app ;; stop) systemctl stop app ;; *) echo "Usage: $0 {start|stop}" ;; esac`

👑 Boss · Missione 107Bloccato

OPERATIONAL REQUIREMENT: Deploy an automated system health-check script at `/home/learner/healthcheck.sh`. The script must be a valid executable Bash script containing the `#!/bin/bash` shebang on line 1, must output the token `SYSTEM_OK`, and must have executable permissions (`755` or `rwxr-xr-x`) so monitoring agents can invoke it directly without errors.

13. Elaborazione Testo Avanzata

Missione 108Bloccato

Immagina di avere un enorme file di dump del database e di dover sostituire tutte le occorrenze di un vecchio indirizzo IP del server con uno nuovo. Aprirlo in un editor potrebbe bloccare il computer. In Linux, modifichiamo al volo i flussi di testo utilizzando `sed` (abbreviazione di "stream editor"). - La sintassi di base è `sed "s/old/new/g" file.txt` per trovare e sostituire il testo. - L'aggiunta del flag `-i` (sul posto) salva le sostituzioni direttamente nel file stesso, anziché limitarsi a stampare il testo modificato sullo schermo. **Perché è importante**: se esegui `sed "s/port=80/port=8080/g" server.conf` senza `-i`, verrà stampato solo il testo modificato sullo schermo del terminale. Il file vero e proprio rimane completamente invariato. Il flag `-i` (sul posto) è necessario per salvare le modifiche direttamente nel file.

Missione 109Bloccato

Immagina di ricevere un grande foglio di calcolo salvato come testo semplice, in cui le colonne sono separate da virgole o spazi e devi estrarre solo la primissima colonna di dati. In Linux, analizziamo colonne di testo strutturate utilizzando il potente linguaggio `awk`. - Per impostazione predefinita, `awk` divide le righe in base agli spazi, assegnando la colonna 1 a `$1`, la colonna 2 a `$2` e così via. - Il flag `-F` ti consente di specificare un separatore personalizzato (come `-F:` per i due punti). Ad esempio, `awk -F: '{print $1}' /etc/passwd` estrae solo i nomi utente da un elenco separato da due punti. **Perché è importante**: se esegui `awk '{print $1}' /etc/shadow` senza `-F:`, `awk` dividerà le righe in base agli spazi bianchi (impostazione predefinita) anziché ai due punti. Poiché le righe del file shadow non hanno spazi, l'intera riga viene trattata come un singolo campo, stampando i dettagli completi dell'hash di ogni utente. Il flag `-F:` impone invece a `awk` di dividere le colonne in base ai due punti.

Missione 110Bloccato

Immagina di lavorare con un foglio di calcolo CSV con date e nomi di transazioni. Vuoi estrarre solo la prima colonna (date) e convertire tutto il testo in lettere maiuscole per coerenza. In Linux, possiamo combinare strumenti di analisi leggeri in una pipeline: - Il comando `cut` ritaglia colonne specifiche dal testo strutturato. Ad esempio, `cut -d, -f1` divide le righe in virgole (`-d,`) ed estrae la prima colonna (`-f1`). - Il comando `tr` (traduci) trasforma i caratteri dall'input standard, come scambiare caratteri minuscoli con maiuscoli (`tr "a-z" "A-Z"`). **Perché è importante**: se esegui `cut reports.csv` senza `-d,` e `-f1`, otterrai: `cut: you must specify a list of bytes, characters, or fields`. Se specifichi `-f1` ma ometti `-d,`, per impostazione predefinita viene utilizzato il tabulazioni, il che significa che non dividerà un file CSV e stamperà semplicemente l'intera riga. Il flag `-d,` definisce la virgola come separatore di colonna e `-f1` gli dice di estrarre solo la prima colonna.

Missione 111Bloccato

Modern cloud infrastructure, Kubernetes, Docker, and REST APIs all communicate in JSON. The `jq` command-line JSON processor is the industry standard tool for slicing, filtering, and mapping structured JSON data in terminal pipelines. - Pretty-print and syntax validate JSON: `cat api.json | jq '.'` (or `jq '.' api.json`). - Extract specific keys: `jq '.version' api.json`. - Access array items and nested object fields: `jq '.users[0].name' api.json`. - Output unquoted raw strings (ideal for shell variables): `jq -r '.users[0].name' api.json`.

Missione 112Bloccato

When troubleshooting DDoS attacks, brute force login attempts, or high-traffic API endpoints, sysadmins rely on one classic pipeline composed of `sort`, `uniq -c`, and `sort -nr`. 1. `sort access.log`: Groups identical lines together (a mandatory prerequisite for `uniq`). 2. `uniq -c`: Counts the number of duplicate occurrences for each unique line, prefixing each line with its tally count. 3. `sort -nr`: Sorts the tally lines **numerically** (`-n`) and in **reverse** (`-r`) order so the most frequent occurrences appear at the top. 4. `head -n 5`: Isolates the top 5 most frequent entries.

Missione 113Bloccato

Binary executables and database files cannot be read with `cat` or text editors without corrupting the terminal display. Linux provides dedicated tools for inspecting compiled binaries and memory dumps: - `strings <file>`: Scans binary files and extracts continuous human-readable ASCII/UTF-8 character sequences (defaulting to 4+ characters). Essential for finding hardcoded URLs, secret keys, version strings, or embedded error messages in compiled software. - `xxd <file>` or `hexdump -C <file>`: Creates a canonical two-column hexadecimal and ASCII dump of binary files to inspect magic bytes (like `ELF` headers) and binary data offsets.

👑 Boss · Missione 114Bloccato

ETL DATA INCIDENT: A legacy mainframe exported `/home/learner/messy_data.csv` using unconventional formatting: fields are separated by colons and rows end with semicolons (`alice:dev:engineering;`). The analytics ingestion engine rejects this format. Transform the file into clean CSV format at `/home/learner/clean_users.csv`, containing only the user and department (fields 1 and 3) separated by commas (`alice,engineering`), with semicolons stripped.

14. Ambiente e Configurazione Shell

Missione 115Bloccato

Immagina di distribuire un'applicazione Web e di dover sapere se eseguire in un sandbox locale di "sviluppo" sicuro o connettersi al database di "produzione" live. In Linux, passiamo configurazioni come questa ai programmi in esecuzione utilizzando **variabili d'ambiente**. - Usiamo il comando `export` per definire una variabile in modo che qualsiasi programma avviato dalla nostra shell possa leggerla. Ad esempio, `export APP_ENV=production`. - Per verificare o visualizzare il valore di una variabile, anteponiamo al suo nome il simbolo del dollaro: `echo $APP_ENV`.

Missione 116Bloccato

Immagina di provare a eseguire il debug di uno script che continua a fallire perché non riesce a trovare il percorso di un programma o di voler vedere quale account utente è attivo in questo terminale. In Linux, tutte queste configurazioni a livello di sessione vengono archiviate insieme. - Il comando `env` stampa una directory completa di tutte le variabili di ambiente attualmente caricate nella sessione attiva, consentendoti di verificare le configurazioni in una volta sola.

Missione 117Bloccato

Ora che hai familiarità con le variabili di ambiente attive come `PATH` (che memorizza le directory in cui Linux cerca i comandi), come trovi il percorso esatto del file del programma che viene eseguito quando digiti `ls` o `grep`? Usiamo `which` per individuare i binari dei comandi. - Il comando `which` cerca le cartelle elencate nella variabile `$PATH` e stampa il percorso assoluto del binario eseguito quando viene eseguito il comando (ad esempio `which ls` restituisce `/bin/ls`). - Questo è utile per scoprire dove è installato uno strumento o risolvere conflitti tra più versioni dello stesso strumento.

Missione 118Bloccato

Digitare comandi lunghi con più flag può diventare estenuante. In Linux possiamo creare scorciatoie personalizzate chiamate alias. Ad esempio, puoi associare `ll` per eseguire `ls -la` automaticamente. - Per creare un alias temporaneo, esegui `alias name='command'` (ad esempio `alias ll='ls -la'`). - L'esecuzione di `alias` senza argomenti elenca tutti gli alias attivi nella sessione corrente. - Per rendere gli alias permanenti dopo i riavvii, in genere vengono scritti nei file di configurazione `.bashrc` o `.bash_profile`.

Missione 119Bloccato

When you edit your startup scripts like `~/.bashrc` to add new environment variables or aliases, those changes do not automatically affect your current shell session. Traditionally, users had to log out and log back in. In Linux, we use the `source` command (or its POSIX shorthand `.`) to read and execute commands from a file directly in the current shell context. - Syntax: `source ~/.bashrc` or `. ~/.bashrc` - This loads newly defined variables, updated `$PATH` directories, and aliases immediately without killing your session.

Missione 120Bloccato

During debugging or deployment, you may temporarily export sensitive API keys, database credentials, or create test shortcuts. Leaving these variables active in your environment can cause security leaks or unintended script behavior. Linux provides `unset` to delete variables and `unalias` to delete custom command shortcuts. - `unset SECRET_KEY`: Permanently deletes the `SECRET_KEY` variable from the current environment. - `unalias la`: Removes the shortcut `la` so typing `la` no longer executes `ls -a`.

👑 Boss · Missione 121Bloccato

SECURITY BREACH: A malicious session injected a backdoor path `/tmp/evil_bin` into `/home/learner/.bashrc`, attempting to hijack user commands. Eradicate the persistence mechanism: clean `/home/learner/.bashrc` by removing all references to `evil_bin`, and delete the `/tmp/evil_bin` directory entirely from the system.

15. Archiviazione, Backup e Checksum

Missione 122Bloccato

Immagina di avere una cartella contenente 500 registri del server e di volerla inviare via email a un collega o eseguirne il backup nell'archivio cloud. L'invio di 500 file singoli è lento e inefficiente. In Linux, li comprimiamo in un unico file compatto simile a zip utilizzando `tar` (abbreviazione di "archivio su nastro"). - Creiamo archivi compressi utilizzando i flag: `-c` (crea), `-z` (comprimi con gzip), `-v` (elenco dettagliato dei file) e `-f` (specifica il nome del file). Ad esempio, `tar -czvf backup.tar.gz folder/` raggruppa e comprime la directory. **Perché è importante**: se esegui `tar -cz logs.tar.gz logs` senza `-f`, otterrai: `tar: Refusing to write archive contents to terminal`. Il flag `-f` è fondamentale perché indica a `tar` di scrivere l'output in un file invece di inviare dati di archivio binario grezzi direttamente al terminale. I flag `-c` e `-z` sono inoltre necessari rispettivamente per creare e comprimere l'archivio.

Missione 123Bloccato

Immagina di avere un singolo file di testo contenente un enorme set di dati e di voler ridurne le dimensioni per risparmiare spazio su disco o accelerare la condivisione. In Linux, comprimiamo i singoli file utilizzando `gzip` e li ripristiniamo utilizzando `gunzip`. - Il comando `gzip <filename>` comprime un file, sostituendolo con una versione compressa che termina con `.gz` (es. `backup.txt` diventa `backup.txt.gz`). - Il comando `gunzip <filename.gz>` decomprime il file, ripristinando la versione originale.

Missione 124Bloccato

Mentre `tar` e `gzip` sono standard su Linux, `zip` è il formato di archivio più comune nel mondo multipiattaforma (Windows/macOS). In Linux, confezioniamo e comprimiamo i file in file zip utilizzando `zip` e li estraiamo utilizzando `unzip`. - Il comando `zip <archive.zip> <files>` crea un archivio zip. - Il comando `unzip <archive.zip>` estrae i file dall'archivio.

Missione 125Bloccato

Oltre `gzip` e `zip`, Linux supporta altri formati di compressione ottimizzati per rapporti di compressione più elevati a scapito della velocità della CPU. Questi sono `bzip2` (bz2) e `xz` (xz). - Il comando `bzip2 <file>` comprime un file, generando `<file>.bz2`. - Il comando `xz <file>` utilizza la compressione LZMA senza perdita di dati per creare `<file>.xz`, che produce dimensioni di file eccezionalmente piccole, rendendolo ideale per le versioni del kernel Linux.

Missione 126Bloccato

Immagina di avere un file di configurazione sepolto in una cartella nidificata, ad esempio `/var/www/html/configs/app/settings.conf`, ma devi modificarlo costantemente. Invece di digitare ogni volta il lungo percorso della cartella, vuoi un rapido collegamento sul desktop. In Linux, lo facciamo creando collegamenti. - **Hard Link**: un clone diretto che punta ai dati del file non elaborato. Se elimini il file originale, il collegamento continua a funzionare. - **Link simbolico (Soft Link)**: un collegamento basato sul percorso (proprio come i collegamenti di Windows). Se elimini il file originale, il collegamento si interrompe. Li creiamo utilizzando `ln -s target link_name`. **Perché è importante**: se esegui `ln logs/app.log app_link.log` senza `-s`, creerai un collegamento reale invece di un collegamento simbolico. Se i file risiedono su partizioni del disco diverse, otterrai: `ln: failed to create hard link: Invalid cross-device link`. Il flag `-s` crea un collegamento simbolico flessibile (scorciatoia) che funziona su diverse unità e directory.

Missione 127Bloccato

Immagina di aver eseguito una ricerca che ha restituito 100 file temporanei e ora di volerli eliminare tutti. L'output della ricerca è solo un elenco di nomi di testo sullo schermo: come inserisci questi nomi come input diretti al comando Elimina? In Linux, colmiamo questa lacuna utilizzando `xargs`. - Il comando `xargs` (esegui argomenti) prende righe di input standard (come l'elenco dei file da `find`) e le fornisce una per una come argomenti a un altro comando. - Ad esempio, `find . -name "*.tmp" | xargs rm` trova tutti i file temporanei e li rimuove tutti in un unico passaggio.

Missione 128Bloccato

DANGLING LINK ALERT: Following a log consolidation migration, the operational link at `/home/learner/links/current_log` became dangling because its original target was moved. Repair the link farm: update the symbolic link `/home/learner/links/current_log` so it points directly to the real system logging destination `/var/log/syslog`.

Missione 129Bloccato

While `cp` blindly copies entire files every time, `rsync` (remote sync) uses a delta-transfer algorithm to copy only files and bytes that have changed. It is the gold standard for server migrations, incremental directory backups, and continuous mirroring. - `-a` (archive): Preserves timestamps, symlinks, permissions, and operates recursively. - `-v` (verbose): Shows which files are being copied. - `-z` (compress): Compresses file data during transmission. - Notice trailing slashes: `rsync -avz src/ backup/` copies the contents of `src/` inside `backup/`.

Missione 130Bloccato

When downloading critical software, ISO images, or backup tarballs over the network, files can become corrupted by transmission errors or tampered with by malicious actors. In Linux, cryptographic checksums verify file integrity bit-for-bit. - `sha256sum <file>`: Computes a 256-bit SHA-2 cryptographic hash. - `md5sum <file>`: Computes a 128-bit MD5 digest. - If a single bit in the file changes, the entire hash string changes completely (the avalanche effect).

Missione 131Bloccato

Sometimes system administrators need to manipulate raw disk blocks rather than regular filesystem files—such as creating empty swapfiles, zeroing out drives, or writing ISO images directly to USB disks. We use `dd` (dataset definition). - `dd if=<source> of=<destination> bs=<block_size> count=<number>` clones raw blocks. - E.g. `dd if=/dev/zero of=disk.img bs=1M count=1` creates a 1MB dummy disk file filled with null bytes. - When automation scripts require scratch files without race conditions or overwriting existing user data, `mktemp` creates uniquely named files under `/tmp`.

👑 Boss · Missione 132Bloccato

DATA INTEGRITY INCIDENT: The nightly backup pipeline flagged a corrupted archive in `/home/learner/backups/data_backup.tar.gz`. The mission-critical archive failed integrity checks. 1. Run `sha256sum -c checksums.sha256` inside `/home/learner/backups` (or `sha256sum -c /home/learner/backups/checksums.sha256`) to confirm the corrupted file (`FAILED`). 2. Overwrite the corrupted archive by copying the pristine valid backup from the system cache at `/var/backups/data_backup.tar.gz` into `/home/learner/backups/data_backup.tar.gz`. 3. Re-verify the backup using `sha256sum -c checksums.sha256` to confirm integrity (`data_backup.tar.gz: OK`).

16. Accesso Remoto e Amministrazione Utenti

Missione 133Bloccato

Finora hai lavorato come utente `learner`. Ma nei server reali, gli amministratori di sistema devono gestire più account. Impariamo come aggiungere nuovi utenti e impostare le loro password. - Il comando `useradd` crea un nuovo account utente. Poiché la creazione di account influisce sulla sicurezza del sistema, deve essere eseguita con privilegi di superutente (ad esempio `sudo useradd deployer`). - Il comando `passwd` imposta o modifica la password di un utente. Esegui come `sudo passwd deployer` per impostare la password dell'utente del distributore.

Missione 134Bloccato

Mentre `useradd` è un'utilità di basso livello che registra semplicemente i dettagli dell'utente nei file di configurazione del sistema, i sistemi Debian/Ubuntu forniscono uno script interattivo di alto livello chiamato `adduser` che automatizza la creazione di cartelle home, l'impostazione delle password e l'inizializzazione degli ambienti shell. Al contrario, `userdel` elimina in modo pulito gli account utente. - L'esecuzione di `sudo adduser tester` ti guida attraverso la configurazione dell'utente in modo interattivo. - L'esecuzione di `sudo userdel tester` elimina l'account utente.

Missione 135Bloccato

Quando si risolvono gli errori di autorizzazione, è necessario verificare l'esatto contesto dell'utente e dell'identificatore di gruppo in cui si sta eseguendo. Lo facciamo utilizzando `id`. - L'esecuzione di `id` stampa l'ID utente (UID), l'ID gruppo primario (GID) dell'utente corrente e tutti gli elenchi di gruppi supplementari. - L'esecuzione di `id <username>` richiede informazioni per un utente specifico.

Missione 136Bloccato

In Linux, gli utenti sono organizzati in **gruppi** per condividere facilmente i permessi. Ad esempio, tutti gli sviluppatori potrebbero appartenere a un gruppo denominato `developers`. Questo ci consente di condividere file con l'intero team contemporaneamente. - Il comando `groupadd` crea un nuovo gruppo. Poiché si tratta di una configurazione di sistema, richiede privilegi di superutente (ad esempio `sudo groupadd developers`). - Il comando `groups [username]` elenca tutti i gruppi a cui appartiene un utente. Eseguito senza argomenti, visualizza i gruppi per l'utente corrente.

Missione 137Bloccato

Quando i team di progetto riorganizzano o disattivano i servizi, i gruppi di sicurezza corrispondenti devono essere ripuliti. In Linux, eliminiamo i gruppi utilizzando `groupdel`. - Il comando `groupdel <group_name>` elimina permanentemente un gruppo dai file di configurazione del sistema, richiedendo privilegi di superutente.

Missione 138Bloccato

Ora che hai creato l'account `deployer`, come accedi localmente per testarne l'ambiente? In Linux, utilizziamo il comando `su` (utente sostitutivo) per cambiare account senza disconnettersi. - Il comando `su <username>` passa la shell del terminale corrente alla sessione di quell'utente. - Una volta cambiato, l'esecuzione di `whoami` rifletterà il nuovo nome utente. - Per tornare alla sessione dell'account utente originale, digita `exit` o premi `Ctrl+D`.

Missione 139Bloccato

Cambiare utente localmente è utile, ma nel cloud computing i server risiedono in data center remoti. Per connetterci in modo sicuro tramite la rete, utilizziamo `ssh` (Secure Shell). - Il comando `ssh` crittografa la connessione tra la tua macchina e un host remoto per evitare intercettazioni. - Sintassi: `ssh user@hostname` o `ssh user@ip_address` (es. `ssh admin@192.168.1.100`). - Alla prima connessione ti verrà chiesto di verificare l'autenticità dell'host remoto visualizzando un'impronta digitale ECDSA univoca. **Nota:** poiché si tratta di un sandbox basato su browser, non esiste un vero server remoto a cui connettersi. L'esecuzione di questo comando mostrerà immediatamente il modello di output previsto nel mondo reale (verifica dell'host, connessione, sessione), anziché un'effettiva sessione interattiva dal vivo. In un vero terminale, ssh ti lascerebbe in una shell remota veramente separata finché non digiti `exit`.

Missione 140Bloccato

Ora che sai come accedere a un server remoto tramite SSH, come copi un file locale (come un archivio di backup) su di esso? Il comando `scp` (copia protetta) copia i file in modo sicuro tra host utilizzando SSH dietro le quinte. - La sintassi è `scp source_path user@host:destination_path`. - Ad esempio, `scp log.txt admin@192.168.1.100:/tmp/` copia il file `log.txt` locale nella cartella remota `/tmp/`. **Nota:** Proprio come con ssh, qui non esiste un vero server remoto: l'esecuzione di questo comando conferma che il file locale esiste e mostra l'output di trasferimento previsto, ma in realtà non invia i dati da nessuna parte.

Missione 141Bloccato

When onboarding engineers or automation service accounts, you must configure their supplementary group memberships and default login shells. In Linux, `usermod` modifies existing accounts in `/etc/passwd` and `/etc/group`. - `-aG <group>`: Appends the user to supplementary groups without removing them from existing groups. (CRITICAL: omitting `-a` would replace all existing secondary groups!). - `-s <shell>`: Specifies the new login shell (e.g. `/bin/bash` or `/usr/sbin/nologin`).

Missione 142Bloccato

Password authentication on remote SSH servers is vulnerable to brute-force attacks and credential stuffing. Production infrastructure relies on asymmetric SSH keypair authentication. - `ssh-keygen -t ed25519`: Generates a high-security Ed25519 public/private keypair (`~/.ssh/id_ed25519` and `~/.ssh/id_ed25519.pub`). - `ssh-copy-id deployer@192.168.1.50`: Automatically appends your local public key to the remote user's `~/.ssh/authorized_keys` file, enabling passwordless login.

Missione 143Bloccato

When investigating unexpected system load or performing security audits on multi-tenant servers, you must know who is logged in and what commands they are executing. - `who`: Prints logged-in usernames, terminal devices (TTY/PTS), and login timestamps. - `w`: Comprehensive snapshot showing system uptime, load averages, logged-in users, and their currently running processes. - `last`: Parses `/var/log/wtmp` to show recent system reboot and user login history.

Missione 144Bloccato

When working over SSH, closing your laptop lid or losing Wi-Fi sends a hangup signal (SIGHUP) that immediately terminates your long-running builds, database dumps, and tests. A terminal multiplexer like `tmux` runs persistent virtual terminals on the server independent of your SSH connection. - `tmux new -s <name>`: Starts a new persistent session. - `tmux ls`: Lists all running sessions. - `tmux attach -t <name>`: Re-attaches to a running session from any computer at any time.

👑 Boss · Missione 145Bloccato

FINAL SECURITY AUDIT: An intrusion detection audit revealed that an unauthorized user account `backdoor` was quietly added to `/etc/passwd`, and an unauthorized administrative group `rogue_admins` was added to `/etc/group`. Audit and cleanse the authentication databases: inspect the files with `cat` or `grep`, safely remove the `backdoor` user using `sudo userdel backdoor`, and delete the `rogue_admins` group using `sudo groupdel rogue_admins`. Verify that both unauthorized entries have been completely eradicated.

17. Git e Container Linux

Missione 146Bloccato

Modern Linux servers and cloud infrastructure rely on Git for version control, continuous integration, and infrastructure-as-code deployments. Let's master the core introspection commands. - `git status`: Checks working tree and staging area state, revealing modified, untracked, and staged files. - `git diff`: Shows line-by-line differences between modified files and the last commit. - `git log`: Displays commit hashes, author metadata, and change messages.

Missione 147Bloccato

Docker encapsulates applications inside isolated Linux cgroups and namespaces (containers). As a DevOps engineer or sysadmin, troubleshooting containerized workloads requires inspecting running containers and executing commands within their namespaces. - `docker ps`: Lists running containers, container IDs, images, uptime, and mapped network ports. - `docker logs <container>`: Streams standard output and error logs generated by the containerized service. - `docker exec -it <container> <command>`: Executes an interactive or diagnostic command directly inside the container namespace.

Missione 148Bloccato

In Git version control, modifications made to working files must be staged before they can be committed into repository history. - `git add <file>`: Stages modified files into the index (e.g., `git add server.js`), preparing them for commit. - `git commit -m "<message>"`: Records a permanent snapshot of staged changes with a descriptive message (e.g., `git commit -m "Fix config"`). - `git branch`: Lists all local repository branches and indicates the currently active branch with an asterisk.

Missione 149Bloccato

Managing microservices in production requires controlling container lifecycle states when restarting services after configuration changes or stopping unneeded containers. - `docker restart <name>`: Gracefully stops and immediately starts a running container (e.g., `docker restart web-api`). - `docker stop <name>`: Stops an actively running container (e.g., `docker stop web-api`). - `docker start <name>`: Boots up an existing stopped container without creating a new instance (e.g., `docker start web-api`).

👑 Boss · Missione 150Bloccato

PRODUCTION OUTAGE: The production web service in container `web-api` is failing health checks because `server.js` was modified with the wrong port. 1. Check the failure logs using `docker logs web-api`. 2. Inspect the repository changes using `git status` and `git diff`. 3. Stage the fix by running `git add server.js`. 4. Commit the fix with `git commit -m "Fix port binding for production"`. 5. Restart the containerized service using `docker restart web-api` to apply the hotfix.