Linux per sviluppatori: navigazione filesystem, permessi e comandi base — Guida operativa

Se sei uno sviluppatore o un sysadmin alle prime armi, il terminale Linux può sembrare un muro di testo ostile. Lo vediamo ogni giorno nei progetti che ci arrivano: sviluppatori che su WordPress sanno fare tutto, ma quando devono collegarsi via SSH a un server e spostare un file vanno in crisi. Il risultato? Perdite di tempo, permessi sbagliati che bloccano il sito, comandi eseguiti nella directory sbagliata che cancellano dati. Non serve essere guru di Unix per lavorare bene. Basta padroneggiare una manciata di comandi e capire come funziona il filesystem Linux. Noi, di Meteora Web, ci lavoriamo ogni giorno: gestiamo server, deployamo applicazioni Laravel, configuriamo certificati SSL, e tutto parte da lì. In questa guida ti portiamo dritto al punto: cosa devi sapere per navigare, leggere e modificare file in Linux senza paura.

Il filesystem Linux: non è Windows, ed è meglio

La prima cosa da capire è che Linux non ha lettere di unità (C:, D:). Tutto parte da / (root), un unico albero che contiene ogni file, dispositivo e risorsa. Non c'è un "C:\\Programmi" — c'è /usr, /var, /etc. Ogni directory ha uno scopo preciso, definito dallo standard FHS (Filesystem Hierarchy Standard).

Errori comuni che vediamo: provare a scrivere percorsi alla Windows (backslash), dimenticare che Linux è case-sensitive (MioFile.txt e miofile.txt sono due file diversi), o non capire la differenza tra percorso assoluto e relativo.

Percorsi assoluti e relativi

Un percorso assoluto parte da / e indica esattamente dove si trova un file. Esempio: /home/meteora/progetti/sito/index.html. Un percorso relativo parte dalla directory corrente. Se sei in /home/meteora/progetti, sito/index.html è relativo.

Due directory speciali: . (directory corrente) e .. (directory padre). Ti serviranno continuamente.

Da fare subito: apri il terminale e digita pwd (print working directory). Ti dice dove sei. Poi ls -la per vedere i file (compresi quelli nascosti). Poi cd /var/log e di nuovo pwd per spostarti. Fallo ora, senza leggere oltre. Ti serve memoria muscolare.

Comandi essenziali per navigare

Ecco la lista dei comandi che usiamo ogni giorno, con esempi reali:

pwd                      # mostra la directory corrente
ls                       # elenca file e directory
ls -l                    # elenco dettagliato (permessi, proprietario, dimensione, data)
ls -la                   # come sopra, inclusi file nascosti (iniziano con .)
cd /percorso             # cambia directory
cd ..                    # torna alla directory padre
cd ~                     # torna alla home dell'utente
cd -                     # torna all'ultima directory visitata
mkdir nuova_cartella     # crea una directory
rmdir cartella_vuota     # rimuove una directory vuota
rm file.txt              # rimuove un file (ATTENZIONE: non va nel Cestino)
rm -rf cartella/         # rimuove cartella e tutto il suo contenuto (USARE CON CAUTELA)
cp sorgente destinazione # copia file
dir1/ dir2/              # copia ricorsiva di directory
mv sorgente destinazione # sposta o rinomina file
mv file.txt nuova.txt    # rinomina

Attenzione: rm -rf è il comando più pericoloso. Noi lo usiamo con estrema consapevolezza, mai su / o su directory di sistema senza aver fatto un backup. Un cliente una volta ha lanciato rm -rf /var/www invece di rm -rf ./var/www — ha cancellato mezza configurazione. Sempre controllare prima di premere Invio.

Permessi: chi può fare cosa

In Linux ogni file e directory ha un proprietario, un gruppo e tre livelli di permessi: lettura (r), scrittura (w) ed esecuzione (x). I permessi si applicano a tre categorie: proprietario (u), gruppo (g), altri (o).

Vedili con ls -l. L'output inizia con una stringa tipo -rw-r--r--. Il primo carattere indica il tipo (- file, d directory, l link). I successivi 9 sono tre gruppi da 3: proprietario, gruppo, altri. Esempio: -rwxr-xr-- significa: proprietario può leggere, scrivere, eseguire; gruppo può leggere, eseguire; altri solo leggere.

Perché è importante? Se imposti i permessi sbagliati su un sito web, Apache o Nginx non riesce a leggere i file e il sito va in errore 403. Se dai permessi di scrittura a tutto il mondo (777), apri la porta a chiunque possa scrivere codice malevolo. Lo vediamo spesso: sviluppatori che per risolvere "non funziona" impostano 777 su tutto. Sbagliato.

Cambiare permessi con chmod

Il comando chmod modifica i permessi. Si usa con notazione simbolica o numerica (ottale).

Notazione simbolica: chmod u+x file.sh aggiunge esecuzione al proprietario. chmod g-w file.txt toglie scrittura al gruppo. chmod o=r file.txt imposta gli altri solo in lettura.

Notazione numerica: ogni permesso vale un numero: r=4, w=2, x=1. Si somma. chmod 755 file significa: proprietario 7 (rwx), gruppo 5 (r-x), altri 5 (r-x). Questo è lo standard per directory e script. I file di solito 644 (rw-r--r--).

chmod 644 index.html           # file web standard
chmod 755 script.sh            # script eseguibile
chmod -R 755 public/           # ricorsivo su directory
chmod u+x ~/.ssh/id_rsa        # chiave privata SSH deve essere 600
chmod 600 ~/.ssh/id_rsa        # meglio: solo proprietario legge

Errore comune: dimenticare che per entrare in una directory serve il permesso di esecuzione (x). Se imposti 600 su una directory, non puoi farci cd anche se hai permessi di lettura.

Proprietario e gruppo con chown

chown cambia proprietario e gruppo. Esempio: sudo chown utente:gruppo file.txt. Spesso serve quando si clona un repository o si spostano file tra utenti. Noi lo usiamo per assegnare i file del sito all'utente www-data e al gruppo developers.

sudo chown -R www-data:www-data /var/www/miosito
sudo chown -R $(whoami):$(id -gn) ./progetto

Umask: permessi predefiniti

Ogni nuovo file o directory ha permessi predefiniti. umask è una maschera che sottrae letteralmente permessi. Valore comune: 022 — significa che il gruppo e gli altri perdono il permesso di scrittura. File creati con 644, directory con 755. Se imposti umask 077, solo il proprietario legge e scrive (più sicuro).

Verificalo con umask. Per cambiarlo permanentemente, modifica ~/.bashrc o /etc/profile.

Comandi base che salvano la giornata

Oltre a navigare e gestire permessi, ci sono alcuni comandi che ogni sviluppatore deve conoscere per lavorare sul server. Li usiamo quotidianamente per debug, log e automazione.

Leggere file: cat, less, head, tail

cat file.txt          # stampa tutto il contenuto
less file.txt         # naviga paginato (q per uscire)
head -n 20 file.txt   # prime 20 righe
tail -n 50 file.txt   # ultime 50 righe
tail -f file.log      # segue in tempo reale le nuove righe (fondamentale per log)

Scenario reale: un cliente ci chiama perché il sito dà errore 500. Noi ci colleghiamo via SSH, andiamo in /var/log/nginx/error.log e lanciamo tail -f error.log. In tempo reale vediamo l'errore: PHP memory exhausted. Risolviamo in due minuti.

Cercare testo con grep

grep è il tuo miglior amico per trovare testo all'interno di file. Sintassi base: grep "parola" file.txt. Opzioni utili: -r ricorsivo, -i case-insensitive, -n mostra numero riga.

grep -rn "Fatal error" /var/www/progetto/
grep -i "errore" /var/log/*.log

Noi lo usiamo per cercare configurazioni, debug, o trovare rapidamente dove viene usata una variabile in un codice legacy.

Trovare file con find

Quando non ricordi dove hai messo quel file di configurazione, find ti salva. Esempio: find /etc -name "*.conf".

find /var/www -name "wp-config.php"
find /home -type f -size +100M    # file più grandi di 100MB
find . -mtime -1                  # file modificati nelle ultime 24 ore

Documentazione sempre a portata: man e --help

Non ricordi un'opzione? man comando apre il manuale (premi q per uscire). Oppure comando --help per una sintesi rapida. Noi lo usiamo continuamente — nessuno sa a memoria tutte le flag di rsync o tar.

Eseguire comandi con privilegi: sudo

Molte operazioni di sistema richiedono permessi di root. sudo ti permette di eseguire un comando come superutente. Esempio: sudo apt update. Attenzione: sudo rm -rf / è distruttivo; controlla sempre cosa stai eseguendo.

sudo systemctl restart nginx
sudo -u www-data php artisan cache:clear

In sintesi — cosa fare adesso

Ecco la checklist operativa per prendere confidenza con Linux:

1. Apri il terminale e naviga per mezz'ora: pwd, ls -la, cd, mkdir prova, rmdir prova. Crea una struttura di directory come quella di un progetto (src, public, config).
2. Esercitati con i permessi: crea un file, modifica con chmod 644, chmod 755, verifica con ls -l. Poi prova chown (se hai sudo o su un server di test).
3. Leggi un file di log: vai in /var/log/syslog o /var/log/apache2/error.log (se presente) e usa tail -f mentre fai una richiesta al server. Vedi apparire le righe in tempo reale.
4. Cerca un testo: usa grep -rn "Permessi" /etc/ per trovare tutti i file di configurazione che contengono la parola. Capisci la sintassi.
5. Archivia questo foglio: tieni a mente i comandi base, ma sappi che man e --help sono sempre lì. Non serve memorizzare tutto.

Noi, di Meteora Web, abbiamo formato decine di sviluppatori con questo metodo. All'inizio sembra ostico, ma dopo una settimana di pratica il terminale diventa più veloce di qualsiasi interfaccia grafica. E quando gestisci un server in produzione, la velocità fa la differenza tra un downtime di 10 minuti e uno di 2 ore.