Ospite.
Utente Livello 1
Nessuna registrazione richiesta. I progressi sono salvati localmente. Esporta il codice per giocare su un altro dispositivo.
DISTINTIVI OTTENUTI
AIUTO & NOTE LEGALI
Pratica di Terminale Linux Online — Impara Facendo.
Padroneggia i comandi Linux essenziali attraverso un gioco bash gratuito e una simulazione interattiva del file system.
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
Chi sono e dove sono?
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.
Navigazione ed elenco dei file
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).
Struttura della directory Linux e FHS
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.
Creazione di directory
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.
Directory e opzioni nidificate
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.
Cancellare lo schermo
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.
Trovare l'aiuto di Shell
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.
2. Manipolazione dei File
Creazione di file vuoti
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.
Lettura del contenuto del file
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`.
Sbirciare i file (testa e coda)
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.
Scorrimento interattivo dei file (meno e più)
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.
Gestire gli spazi nei nomi dei file
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`).
Scrittura e sovrascrittura di file
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.
Aggiunta ai file
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.
Copia e spostamento di file
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`).
Caratteri jolly e operazioni su più file
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`.
Rimozione di file e cartelle
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.
3. Pipe e Filtraggio
Introduzione a Pipes & wc
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.
Ordinamento e ricerca di carte uniche
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.
Filtraggio con grep
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".
4. Reindirizzamento e Sicurezza
Modifica delle autorizzazioni dei file
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!
File e configurazioni nascosti
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.
Modifica della proprietà del file
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".
Firewall Linux (ufw e iptables)
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.
5. Superutente e Pacchetti
Privilegi di superutente (sudo)
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.
Gestione dei pacchetti (apt)
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".
Ricerca di pacchetti (ricerca apt)
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`).
Eliminazione dei pacchetti (apt purge)
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`).
Gestione dei pacchetti Debian (dpkg)
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.
Gestori di pacchetti RedHat (yum e dnf)
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`.
6. Disco e Risorse di Sistema
Controllo dello spazio su disco (df)
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.
Trovare le dimensioni delle directory (du)
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.
Controllo dell'utilizzo della memoria (gratuito)
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.
Tempo di attività del sistema e dettagli del kernel
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.
Visualizzazione dei dettagli della CPU (lscpu)
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.
Statistiche I/O e CPU (iostat)
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.
7. Gestione dei Processi
Elenco dei processi in esecuzione (ps)
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.
Monitor interattivo dei processi (in alto)
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.
Elenco dei file aperti (lsof)
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).
Arresto dei processi non autorizzati (uccisione)
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!
Esecuzione di lavori in background
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.
Cortesia del processo (nice & renice)
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.
Ripresa dei lavori in background (bg)
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.
8. Risoluzione Problemi di Rete
Testare la connettività (ping)
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.
Interfacce di rete e IP locale
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.
Controllo delle interfacce (ifconfig)
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.
Connessioni di rete (nmcli)
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.
Statistiche socket e connessione (netstat e ss)
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.
Tracciamento dei percorsi dei pacchetti (traceroute)
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.
Download di file Web (curl)
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`.
9. Ricerca di File
Trovare file per nome (trova)
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.
Controllo della cronologia dei comandi
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).
Pagine del manuale di consultazione
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.
10. Servizi e Systemd
Controllo dei servizi (systemctl)
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>`.
Registrazione di sistema (journalctl)
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.
11. Modifica di Testo da Terminale
Modifica dei file di configurazione (nano)
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.
12. Scripting Shell e Automazione
Scrivere il tuo primo script Bash
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`.
Variabili e argomenti ($1)
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.
Logica condizionale (if/else)
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.
Automatizzare con i loop
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.
Logica riutilizzabile (funzioni bash)
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"`.
Pianificazione delle attività (crontab)
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.
13. Elaborazione Testo Avanzata
Modifica del flusso con sed
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.
Estrazione dati con awk
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.
Traduzione e taglio dei dati
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.
14. Ambiente e Utenti
Gestione delle variabili d'ambiente
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`.
Archivi e compressione (tar)
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.
Compressione file (gzip e gunzip)
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.
Archiviazione con zip e decompressione
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.
Compressione alternativa (bzip2 & xz)
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.
Ispezione dell'ambiente
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.
Trovare i comandi (quali)
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.
Scorciatoie personalizzate della shell (alias)
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`.
15. File System Avanzato
Creazione di collegamenti (ln -s)
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.
Elaborazione dei risultati della ricerca (xargs)
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.
16. Accesso Remoto e Amministrazione Utenti
Amministrazione utente (useradd e passwd)
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.
Gestione degli utenti (adduser e userdel)
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.
Visualizzazione delle identità utente (id)
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.
Amministrazione gruppi (groupadd e gruppi)
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.
Eliminazione di gruppi (groupdel)
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.
Cambio dei contesti di sicurezza (su)
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`.
Secure Shell Access (ssh)
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`.
Trasferimento sicuro dei file (scp)
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.
Who Am I and Where Am I?.
Riferimento Comandi
Lista di Controllo
Suggerimenti Rivelati
File Explorer
Cos'è BashQuest?
Piattaforma gratuita per fare pratica con il terminale Linux online e gioco educativo Bash. Esegui comandi reali su un filesystem virtuale con convalida istantanea.
Cos'è BashQuest?
BashQuest è una piattaforma gratuita di pratica del terminale Linux online e un gioco educativo creato per l'apprendimento attivo. A differenza dei soliti corsi video passivi, impari digitando comandi reali direttamente nel browser.
BashQuest offre una simulazione completa del terminale con obiettivi didattici strutturati, al 100% sicura e funzionante nel browser.
Perché ho creato questo progetto
Quando ho iniziato a studiare Linux, avevo paura di rompere il mio computer con un comando sbagliato. Volevo creare un ambiente privo di rischi dove chiunque potesse imparare Linux gratis senza installare macchine virtuali.
La ripetizione con feedback immediato sviluppa memoria muscolare autentica: digitare comandi, analizzare l'output e correggere gli errori.
Pratica del Terminale Linux Online con Riscontro Immediato
L'apprendimento è molto più rapido ed efficace quando si fa pratica subito. BashQuest offre un terminale simulato che valida ogni esercizio in tempo reale.
Un Terminale Linux Virtuale per un Apprendimento Efficace
BashQuest offre una simulazione completa del terminale con obiettivi didattici strutturati, al 100% sicura e funzionante nel browser.
Perché la Pratica Migliora la Memorizzazione
La ripetizione con feedback immediato sviluppa memoria muscolare autentica: digitare comandi, analizzare l'output e correggere gli errori.
Cosa imparerai
Il nostro programma progressivo copre 16 aree fondamentali dell'amministrazione di sistema Linux:
Fondamenti del File System
Manipolazione dei File
Pipe e Filtraggio
Reindirizzamento e Sicurezza
Superutente e Pacchetti
Disco e Risorse di Sistema
Gestione dei Processi
Risoluzione Problemi di Rete
Ricerca di File
Servizi e Systemd
Modifica di Testo da Terminale
Scripting Shell e Automazione
Elaborazione Testo Avanzata
Ambiente e Utenti
File System Avanzato
Accesso Remoto e Amministrazione Utenti
Strumenti Web & Utility Linux
Calcolatore permessi chmod, generatore cron, tester regex e guida rapida ai comandi.
Chmod calculator
Octal & symbolic output
chmod 000 [file]Cron job explainer
Plain-English translation
Command synthesizer
Pick a task, get the command
Select a task above to see the command.
—