Guida rapida ai comandi Linux — Oltre 200 comandi per attività

-P

stampa il percorso fisico con i collegamenti simbolici risolti

-L

stampa il percorso logico, mantenendo i collegamenti simbolici (predefinito)

pwd

pwd -P

-l

formato lungo: permessi, proprietario, dimensione, data

-a

include i file nascosti (dotfile)

-h

dimensioni leggibili (con -l): 4.0K, 12M

-t

ordina per data di modifica, dal più recente

-r

inverte l'ordinamento

-S

ordina per dimensione, dal più grande

-d

elenca la directory stessa, non il suo contenuto

-1

un nome per riga

-R

entra ricorsivamente nelle sottodirectory

ls -lah

ls -ltr

ls -lS | head

ls -ld */

macOS/BSD: Le opzioni sopra funzionano su macOS. Lì il colore si attiva con -G (le versioni recenti di macOS accettano anche --color).

-L N

scende al massimo di N livelli

-a

include i file nascosti

-d

solo directory

-I pattern

salta i nomi che corrispondono al pattern

tree -L 2 -I 'node_modules|.git'

Non installato per impostazione predefinita nella maggior parte delle distribuzioni: apt install tree / dnf install tree.

-p

crea le directory padre se necessario; nessun errore se esiste già

-m mode

imposta i permessi, es. -m 700

-v

stampa ogni directory creata

mkdir -p project/src/components

mkdir -p app/{src,tests,docs}

-p

rimuove anche le directory padre vuote

rmdir old-folder

-c

non crea il file se non esiste

-t stamp

imposta una data e ora specifica

-r ref

copia le date di un altro file

touch notes.txt

touch -t 202601011200 file

macOS/BSD: touch -d di GNU accetta testo libero come -d '2 days ago'; su macOS -d accetta solo YYYY-MM-DDThh:mm:SS.

-r, -R

copia le directory in modo ricorsivo

-a

archivio: ricorsivo, mantiene permessi, date, collegamenti simbolici

-i

chiede prima di sovrascrivere

-n

non sovrascrive mai un file esistente

-u

copia solo se l'origine è più recente (GNU)

-v

stampa ogni file copiato

cp report.pdf ~/backup/

cp -a site/ /srv/site-backup

cp -i *.conf /etc/myapp/

macOS/BSD: cp di macOS ha -a, -R, -i, -n ma non -u. Con cp di BSD una barra finale sull'origine (cp -R src/ dst) copia il contenuto di src, non src stessa.

-i

chiede prima di sovrascrivere

-n

non sovrascrive mai

-v

stampa ogni spostamento

-t dir

sposta in dir (GNU; comodo con xargs)

mv draft.txt final.txt

mv *.jpg photos/

mv -n new.conf /etc/app/app.conf

mv sostituisce senza avvisare un file di destinazione esistente, a meno che tu non usi -i o -n.

-i

chiede prima di ogni rimozione

-I

chiede una sola volta prima di rimuovere più di tre file o in modo ricorsivo (GNU)

-r

rimuove le directory e il loro contenuto

-f

ignora i file mancanti, non chiede mai conferma

-v

stampa ogni file rimosso

rm old.log

rm -i *.bak

rm -- -weird-name.txt

Dalla riga di comando non c'è cestino né annulla. Eliminato significa perso.

rm -rf build/

rm -rf -- "${BUILD_DIR:?}/"

Attenzione: Nessuna conferma, nessun annulla. Uno spazio di troppo (rm -rf / tmp) o una variabile vuota (rm -rf "$DIR/"*) eliminano molto più del previsto. rm di GNU si rifiuta di rimuovere / stessa (--preserve-root è predefinito), ma niente protegge /home o /etc. Esegui prima ls sul percorso esatto.

-s

collegamento simbolico (senza ottieni un collegamento fisico)

-f

sostituisce un collegamento esistente

-n

tratta un collegamento esistente a una directory come un file normale (da usare con -f)

ln -s /opt/app/bin/app /usr/local/bin/app

ln -sfn releases/v2 current

L'ordine è prima la destinazione, poi il nome del nuovo collegamento, lo stesso ordine di cp.

realpath ../config.yml

readlink -f /usr/bin/python3

macOS/BSD: Le versioni attuali di macOS hanno sia realpath sia readlink -f; quelle molto vecchie non avevano né l'uno né l'altro.

-i

stampa il tipo MIME (Linux)

-b

breve: omette il nome del file

file download.bin

file -i notes.txt

macOS/BSD: Su macOS l'opzione MIME è -I (maiuscola); lì -i minuscola significa altro.

-c FORMAT

output personalizzato GNU: %s dimensione, %y mtime, %U proprietario, %a permessi ottali, %n nome

stat file.txt

stat -c '%a %U %s %n' *

macOS/BSD: macOS usa -f, non -c, con lettere diverse: stat -f '%Lp %Su %z %N' file.

-d

crea una directory invece di un file

tmp=$(mktemp -d) && trap 'rm -rf "$tmp"' EXIT

-n

numera tutte le righe

-A

mostra le tabulazioni come ^I e le fine riga come $ (GNU); rivela i fine riga CRLF

cat /etc/os-release

cat part1.txt part2.txt > whole.txt

cat -A script.sh | head

macOS/BSD: cat di macOS non ha -A; usa cat -vet per la stessa vista.

tac access.log | head

macOS/BSD: Non disponibile su macOS; usa tail -r file.

Space / b

pagina giù / su

/text

cerca in avanti; n successivo, N precedente

g / G

vai all'inizio / alla fine

F

segue il file come tail -f; Ctrl+C per fermare

q

esce

-N

mostra i numeri di riga

-S

non manda a capo le righe lunghe (scorrimento laterale)

less /var/log/syslog

journalctl -u nginx | less -S

-n N

le prime N righe (predefinito 10)

-c N

i primi N byte

-n -N

tutto tranne le ultime N righe (GNU)

head -n 20 data.csv

head -c 512 file.bin | xxd

macOS/BSD: head di macOS non accetta valori negativi.

-n N

le ultime N righe (predefinito 10)

-n +N

parte dalla riga N

-f

continua a stampare mentre il file cresce

-F

segue per nome, resiste alla rotazione dei log

tail -n 50 app.log

tail -F /var/log/nginx/access.log

tail -n +2 data.csv

Ctrl+O

salva

Ctrl+X

esci

Ctrl+W

cerca

Ctrl+K / Ctrl+U

taglia riga / incolla

Alt+U

annulla

sudo nano /etc/hosts

La barra in fondo allo schermo mostra i tasti; ^ significa Ctrl e M- significa Alt.

i

modalità inserimento (scrivi il testo)

Esc

torna alla modalità normale

:w / :q / :wq

salva / esci / salva ed esci

:q!

esci senza salvare

/text

cerca; n per il successivo

dd / yy / p

elimina riga / copia riga / incolla

u / Ctrl+R

annulla / ripeti

vim +42 app.py

-u

formato unificato (quello usato da patch e git)

-r

confronta le directory in modo ricorsivo

-q

dice solo se i file sono diversi

-w

ignora tutti gli spazi

-y

affiancati

diff -u old.conf new.conf

diff -rq dir1/ dir2/

diff <(sort a.txt) <(sort b.txt)

Confronta testi affiancati nel browser →

-a

aggiunge in fondo invece di sovrascrivere

make 2>&1 | tee build.log

echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf

printf '%s\n' "$var"

printf '%-12s %6.2f\n' disk 93.5

echo -e ed echo -n si comportano diversamente da una shell all'altra; printf si comporta allo stesso modo ovunque.

xxd image.png | head

hexdump -C file.bin | head

xxd fa parte dei pacchetti di vim; hexdump è in util-linux (bsdextrautils nelle versioni più recenti di Debian/Ubuntu).

-n N

solo stringhe lunghe almeno N caratteri (predefinito 4)

strings -n 8 firmware.bin | less

Su Linux fa parte di binutils.

ls -l deploy.sh

Il primo carattere è il tipo (- file, d directory, l collegamento simbolico). Poi tre terzine: proprietario, gruppo, tutti gli altri. r=4, w=2, x=1, quindi rwxr-x--- è 750.

Converti rwx in ottale con il calcolatore chmod →

-R

applica a una directory e a tutto il suo contenuto

-v

riporta ogni modifica

chmod 644 index.html

chmod 755 deploy.sh

chmod 600 ~/.ssh/id_ed25519

Calcola il valore ottale con il calcolatore chmod →

chmod +x script.sh

chmod go-w file

chmod -R u=rwX,go=rX site/

Crea modalità simboliche e ottali con il calcolatore chmod →

find site/ -type d -exec chmod 755 {} +

find site/ -type f -exec chmod 644 {} +

Attenzione: Dà a ogni utente e a ogni servizio compromesso sulla macchina accesso in scrittura all'intero albero, rende eseguibili tutti i file e fa sì che OpenSSH rifiuti le chiavi in una ~/.ssh con 777. Applicato a /etc o /usr può rompere sudo e il sistema. Correggi invece la proprietà con chown, oppure usa i due comandi find.

Scegli la modalità meno permissiva che funziona →

-R

ricorsivo

user:

con i due punti finali e senza gruppo, imposta anche il gruppo al gruppo di login dell'utente

sudo chown -R www-data:www-data /var/www/site

sudo chown "$USER": file.txt

Attenzione: sudo chown -R su /, /usr o /etc cancella i bit setuid e le proprietà su cui si basano sudo, passwd e i servizi; di solito per rimediare serve reinstallare. Ricontrolla il percorso.

umask

umask 077

La maschera rimuove bit: i file partono da 666 e le directory da 777, quindi 022 dà 644 e 755.

-i

shell di login di root

-u user

esegue come quell'utente invece che come root

-l

elenca cosa ti è consentito eseguire

-k

dimentica le credenziali memorizzate

sudo systemctl restart nginx

sudo !!

sudo -u postgres psql

-m

modifica (aggiunge) una voce

-x

rimuove una voce

-b

rimuove tutte le voci ACL

-R

ricorsivo

-d

imposta una ACL predefinita ereditata dai nuovi file

setfacl -m u:alice:rw report.xlsx

getfacl report.xlsx

setfacl -R -m g:devs:rwX /srv/app

Un + alla fine della stringa di permessi di ls -l indica che il file ha una ACL.

sudo chattr +i /etc/resolv.conf

lsattr /etc/resolv.conf

Supportato su ext4, XFS, Btrfs. Se compare "Operation not permitted" anche da root, controlla lsattr.

aux

tutti i processi con CPU, memoria, utente (stile BSD)

-ef

tutti i processi con PID del padre (stile System V)

-o

sceglie le colonne

--sort=-%mem

ordina per memoria, dal valore più alto (procps)

ps aux | grep [n]ginx

ps aux --sort=-%mem | head

ps -o pid,ppid,etime,cmd -p 1234

macOS/BSD: ps di macOS non ha --sort; usa ps aux -m (per memoria) o ps aux -r (per CPU).

P / M

ordina per CPU / memoria (top di Linux)

1

mostra ogni core della CPU

k

termina un processo tramite PID

q

esce

-b -n 1

un'istantanea in modalità batch, per gli script

top -b -n 1 | head -20

macOS/BSD: top di macOS è un programma diverso: ordina con top -o cpu o top -o mem.

F3 or /

cerca

F4

filtra

F6

sceglie la colonna di ordinamento

F9

invia un segnale (kill)

t

vista ad albero

htop -u www-data

Installalo con apt install htop / dnf install htop.

-a

mostra la riga di comando completa (procps di Linux)

-f

confronta con l'intera riga di comando, non solo con il nome

-u user

solo i processi di quell'utente

-x

corrispondenza esatta del nome

pgrep -a nginx

pgrep -f 'python manage.py runserver'

macOS/BSD: Su macOS -a significa "includi gli antenati"; usa pgrep -lf per vedere nomi e argomenti.

pkill -f "node server.js"

pkill -HUP nginx

pgrep -af node

I pattern sono espressioni regolari cercate in qualsiasi punto del nome; pkill node colpisce anche nodejs-helper. Controlla prima con pgrep.

(none) / -15 / -TERM

chiede al processo di uscire in modo pulito (predefinito)

-9 / -KILL

terminazione forzata; non può essere intercettata, nessuna pulizia

-1 / -HUP

molti demoni ricaricano la configurazione

-l

elenca i nomi dei segnali

kill 1234

kill -9 1234

kill %1

Prova prima un semplice kill e aspetta qualche secondo: -9 salta la pulizia, quindi possono restare file temporanei, lock e dati scritti a metà.

killall firefox

Su Linux fa parte del pacchetto psmisc.

jobs

bg %1

fg %1

Ctrl+Z sospende il programma in primo piano (si ferma finché non usi bg o fg).

nohup ./server > server.log 2>&1 &

Per tutto ciò che deve durare a lungo, un servizio systemd (vedi Servizi e log) o tmux è più robusto.

Ctrl+B d

stacca (la sessione continua a girare)

Ctrl+B c

nuova finestra

Ctrl+B % / Ctrl+B "

divide sinistra/destra / sopra/sotto

tmux ls

elenca le sessioni

tmux new -s deploy

tmux attach -t deploy

Installalo con il gestore di pacchetti. GNU screen è l'alternativa più vecchia (Ctrl+A d per staccare, screen -r per ricollegarsi).

nice -n 19 tar -czf backup.tgz /data

sudo renice -n -5 -p 1234

La niceness va da -20 (priorità massima) a 19 (minima). Solo root può scendere sotto 0.

timeout 30s curl -s https://example.com/health

timeout -s KILL 5m ./job.sh

Esce con stato 124 quando viene raggiunto il limite di tempo.

sudo fuser -vm /mnt/usb

sudo fuser -v 8080/tcp

Attenzione: fuser -k termina senza conferma ogni processo che usa la destinazione; su un punto di mount può includere la tua stessa shell.

-a

tutto

-r

release del kernel

-m

architettura della macchina: x86_64, aarch64

uname -r

uname -m

cat /etc/os-release

lsb_release -a

macOS/BSD: macOS: sw_vers.

uptime

Il carico è il numero di processi in esecuzione o in attesa. Confrontalo con il numero di CPU (nproc): un carico di 4 su 4 core significa piena occupazione.

free -h

macOS/BSD: macOS: vm_stat, oppure top -l 1 | grep PhysMem.

Linux usa la RAM inutilizzata come cache del disco, quindi "free" sembra basso anche su una macchina sana. "available" è ciò che i programmi possono ancora ottenere.

lscpu

make -j"$(nproc)"

macOS/BSD: macOS: sysctl -n hw.ncpu e sysctl -n machdep.cpu.brand_string.

-T

date e ore leggibili

-w

segue i nuovi messaggi

--level=err,warn

solo i problemi

sudo dmesg -T | tail -30

sudo dmesg -T | grep -i 'out of memory'

vmstat 1 5

iostat -xz 1

iostat fa parte del pacchetto sysstat.

+%F

AAAA-MM-GG

+%s

timestamp Unix (secondi)

-d 'text'

analizza una data: tomorrow, 2 days ago, @1700000000 (GNU)

-u

UTC

date '+%Y-%m-%d %H:%M:%S'

date +%s

date -d @1700000000

date -d '2 days ago' +%F

macOS/BSD: date di macOS non ha -d. Usa date -r 1700000000 per un timestamp, date -v-2d per "2 giorni fa" e date -j -f '%Y-%m-%d' 2026-10-18 +%s per analizzare una data.

Converti i timestamp con il convertitore di timestamp Unix →

-h

dimensioni leggibili

-T

mostra il tipo di file system (GNU)

-i

uso degli inode invece dei byte

df -h

df -h .

df -i

macOS/BSD: Su macOS, -T filtra per tipo invece di mostrarlo.

-s

un totale per argomento

-h

leggibile

-d N

limite di profondità (forma lunga GNU: --max-depth=N)

-x

resta su un solo file system

du -sh /var/log

du -h -d 1 | sort -h

sudo du -xh -d 1 / | sort -h | tail

macOS/BSD: du di macOS ha -d ma non --max-depth.

sudo ncdu -x /

Installalo con apt install ncdu / dnf install ncdu.

-f

tipo di file system, etichetta, UUID, punto di mount

lsblk

lsblk -f

macOS/BSD: macOS: diskutil list.

sudo umount /mnt/usb

sudo umount -l /mnt/nas

"target is busy" significa che un processo (spesso la tua stessa shell posizionata in quella directory) lo sta usando: trovalo con fuser -vm o lsof.

UUID=3f6c...  /data  ext4  defaults,nofail  0  2

sudo mount -a

Un errore di battitura in fstab può mandare il prossimo avvio in modalità di emergenza. Esegui sempre sudo mount -a (o findmnt --verify) dopo averlo modificato.

sudo fdisk -l

sudo parted /dev/sdb print

Attenzione: Scrivere una tabella delle partizioni (w in fdisk, mklabel in parted) rende irraggiungibili i dati esistenti su quel disco. Verifica prima il nome del dispositivo con lsblk; /dev/sda e /dev/sdb si scambiano facilmente.

sudo mkfs.ext4 -L data /dev/sdb1

sudo mkfs.vfat -F 32 /dev/sdc1

Attenzione: Cancella immediatamente il file system sulla destinazione, senza conferma se il dispositivo non è montato. Controlla il dispositivo con lsblk -f; formattare /dev/sda invece di /dev/sda1, o il disco sbagliato, lo distrugge.

sudo fsck -f /dev/sdb1

Attenzione: Non eseguire mai fsck su un file system montato in lettura e scrittura: può danneggiarlo. Smontalo prima, oppure, per il file system root, avvia da un supporto di ripristino.

if= / of=

file o dispositivo di input / output

bs=4M

dimensione del blocco; più grande è più veloce

status=progress

mostra i byte copiati (GNU)

conv=fsync

svuota i dati sul dispositivo prima di uscire

sudo dd if=ubuntu.iso of=/dev/sdX bs=4M status=progress conv=fsync

dd if=/dev/zero of=test.img bs=1M count=100

Attenzione: dd sovrascrive la destinazione of= senza chiedere. Invertire if= e of=, o scegliere il /dev/sdX sbagliato, cancella quel disco. Controlla con lsblk subito prima di eseguirlo.

macOS/BSD: macOS: usa come destinazione /dev/rdiskN (da diskutil list) dopo diskutil unmountDisk, usa bs=4m e premi Ctrl+T per vedere l'avanzamento.

swapon --show

sudo fallocate -l 2G /swapfile && sudo chmod 600 /swapfile && sudo mkswap /swapfile && sudo swapon /swapfile

Su Btrfs un file di swap richiede passaggi aggiuntivi (btrfs filesystem mkswapfile nelle versioni recenti di btrfs-progs).

shred -u -n 3 secrets.txt

Attenzione: Irreversibile. Nota anche che non è affidabile su SSD, file system con journaling o copy-on-write (Btrfs, ZFS) o qualsiasi cosa con snapshot; per una protezione reale usa la crittografia dell'intero disco.

ip -br a

ip a show eth0

hostname -I

macOS/BSD: macOS: ifconfig, oppure ipconfig getifaddr en0.

ip sostituisce il vecchio ifconfig (net-tools), che molte distribuzioni non installano più.

Calcola l'intervallo di rete con il calcolatore di subnet →

ip r

ip route get 1.1.1.1

sudo ip route add 10.20.0.0/16 via 192.168.1.1

Controlla gli intervalli CIDR con il calcolatore di subnet →

ip link

sudo ip link set eth0 down && sudo ip link set eth0 up

Attenzione: Disattivare l'interfaccia attraverso cui sei connesso via SSH interrompe la sessione.

-t / -u

TCP / UDP

-l

solo socket in ascolto

-p

mostra il processo (sudo per vedere quelli di altri utenti)

-n

porte numeriche, niente DNS

-s

conteggi riepilogativi

sudo ss -tulpn

ss -tn state established '( dport = :443 )'

ss -s

macOS/BSD: macOS: lsof -iTCP -sTCP:LISTEN -n -P, oppure netstat -an.

ss sostituisce netstat; netstat -tulpn funziona ancora dove è installato net-tools.

-I

solo intestazioni (richiesta HEAD)

-L

segue i reindirizzamenti

-o file / -O

salva in un file / salva con il nome remoto

-s / -S

silenzioso / ma mostra comunque gli errori

-f

fallisce (uscita 22) con HTTP 4xx/5xx invece di stampare la pagina di errore

-v

dettagliato: intestazioni di richiesta e risposta, TLS

curl -I https://example.com

curl -LO https://example.com/file.tar.gz

curl -s -o /dev/null -w '%{http_code}\n' https://example.com

curl -fsSL https://example.com/install.sh -o install.sh

Converti un comando curl in Python, JavaScript o Go →

-d data

corpo della richiesta; implica POST

--data-binary @file

invia un file così com'è

-H header

aggiunge un'intestazione

-X METHOD

PUT, PATCH, DELETE…

-u user:pass

autenticazione di base

curl -H 'Content-Type: application/json' -d '{"name":"Ada"}' https://api.example.com/users

curl -H "Authorization: Bearer $TOKEN" https://api.example.com/me

curl -X DELETE https://api.example.com/users/42

Cerca il codice di stato che hai ricevuto →

-c

riprende un download parziale

-O file

salva come (usa -O- per stdout)

-q

silenzioso

-r -np

ricorsivo, non risale mai alla directory padre

wget -c https://example.com/big.iso

wget -qO- https://example.com/data.json | jq .

macOS/BSD: Non presente su macOS di serie; usa curl -LO (curl -C - -LO per riprendere).

dig +short example.com

dig MX example.com

dig @1.1.1.1 example.com

dig -x 8.8.8.8

dig +trace example.com

Nome del pacchetto: dnsutils (Debian/Ubuntu) o bind-utils (Fedora/RHEL).

resolvectl status

sudo resolvectl flush-caches

macOS/BSD: macOS: sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder.

Solo sui sistemi che usano systemd-resolved (Ubuntu, Fedora per impostazione predefinita).

-c N

si ferma dopo N pacchetti

-i sec

intervallo tra i pacchetti

-4 / -6

forza IPv4 / IPv6

ping -c 4 example.com

Su Linux e macOS ping continua finché non premi Ctrl+C, a meno che tu non usi -c (Windows si ferma dopo 4). Nessuna risposta non significa sempre che sia irraggiungibile: molti host bloccano ICMP.

traceroute -n example.com

tracepath example.com

macOS/BSD: macOS ha traceroute ma non tracepath.

Su Linux potrebbe essere necessario installare traceroute; tracepath (iputils) di solito c'è.

mtr -rw -c 100 example.com

Combina ping e traceroute. Una perdita su un solo hop intermedio di solito è quel router che dà bassa priorità a ICMP; una perdita che prosegue fino alla fine è reale.

-L 5432:localhost:5432

la porta locale 5432 raggiunge la porta 5432 sul server

-R 8080:localhost:3000

la porta 8080 del server raggiunge la tua 3000 locale

-D 1080

proxy SOCKS sulla porta locale 1080

-N

nessun comando remoto, solo il tunnel

ssh -N -L 5432:localhost:5432 alice@db-host

ssh -N -D 1080 alice@host

-r

copia directory

-P port

porta (P maiuscola; ssh usa -p minuscola)

-i key

file di identità

scp report.pdf alice@host:/tmp/

scp alice@host:/var/log/app.log .

scp -r -P 2222 site/ alice@host:~/

Da OpenSSH 9.0, scp usa internamente il protocollo SFTP. Per copie grandi o ripetute rsync è più veloce perché invia solo le modifiche.

-a

archivio: ricorsivo, mantiene permessi, date, collegamenti

-v

dettagliato

-z

comprime durante il trasferimento

-P

avanzamento e ripresa dei file parziali

-n

prova a vuoto: mostra cosa succederebbe

--exclude 'pattern'

salta dei file

-e 'ssh -p 2222'

opzioni SSH personalizzate

rsync -avzP site/ deploy@host:/srv/site/

rsync -av --exclude 'node_modules' ./ /backup/app/

macOS/BSD: Le versioni recenti di macOS includono openrsync invece di rsync; le opzioni comuni funzionano, alcune più rare no.

src/ significa "il contenuto di src"; src senza barra significa "la cartella src". Sbagliare crea cartelle annidate (dest/src/…).

rsync -avn --delete site/ /srv/site/

rsync -av --delete site/ /srv/site/

Attenzione: Elimina tutto ciò che in dest non è presente nell'origine. Invertire origine e destinazione, o un percorso di origine vuoto o sbagliato, cancella la destinazione. Esegui sempre prima con -n.

nc -zv db.internal 5432

nc -l 9000

Le opzioni variano tra le versioni di netcat: quella tradizionale richiede nc -l -p 9000.

sudo ufw status verbose

sudo ufw allow 22/tcp

sudo ufw allow from 10.0.0.0/8 to any port 5432

Attenzione: sudo ufw enable su un server remoto senza aver prima consentito SSH (ufw allow OpenSSH o 22/tcp) ti chiude fuori.

sudo firewall-cmd --list-all

sudo firewall-cmd --permanent --add-service=https && sudo firewall-cmd --reload

sudo firewall-cmd --permanent --add-port=8080/tcp

Senza --permanent una regola dura fino al prossimo reload o riavvio.

-m

crea la directory home (non è il comportamento predefinito in tutte le distribuzioni)

-s /bin/bash

shell di login

-G group1,group2

gruppi supplementari

sudo useradd -m -s /bin/bash alice && sudo passwd alice

Su Debian/Ubuntu, adduser alice è l'alternativa interattiva più comoda che configura directory home e password.

sudo usermod -aG docker alice

sudo usermod -aG sudo alice

Attenzione: Senza -a, usermod -G sostituisce tutti i gruppi supplementari dell'utente, il che può togliere l'accesso a sudo. Le modifiche ai gruppi si applicano al login successivo (oppure esegui newgrp docker).

sudo userdel -r olduser

Attenzione: -r elimina definitivamente la directory home e i suoi file. Fai prima un backup, oppure blocca l'account (passwd -l).

sudo visudo -f /etc/sudoers.d/deploy

deploy ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart myapp

visudo controlla la sintassi prima di salvare. Modificare /etc/sudoers con un editor normale e commettere un errore può chiudere fuori tutti da sudo.

-c

crea

-z / -j / -J

compressione gzip / bzip2 / xz

-f file

nome del file di archivio (mettilo subito dopo f)

-v

elenca i file man mano che vengono aggiunti

--exclude='pattern'

esclude dei file

tar -czf site-2026-10-18.tar.gz site/

tar -cJf logs.tar.xz --exclude='*.tmp' logs/

-x

estrai

-C dir

estrae in dir (deve esistere)

--strip-components=1

elimina la cartella di primo livello

tar -xf archive.tar.gz

tar -xzf app.tar.gz -C /opt/app --strip-components=1

tar --zstd -cf data.tar.zst data/

zstd -d file.zst

Richiede GNU tar 1.31+ (o un bsdtar recente) e il programma zstd.

-k

mantiene l'originale

-d

decomprime (come gunzip)

-9

compressione migliore

gzip -k access.log

zcat access.log.gz | grep 404

zgrep 500 access.log.*.gz

Senza -k, gzip sostituisce il file con la versione .gz.

zip -r site.zip site/

zip -r site.zip site/ -x '*.git*' '*/node_modules/*'

zip -e cifra con il vecchio schema ZipCrypto, che è debole. Per una vera riservatezza usa 7z o gpg.

7z x archive.7z

7z a -p backup.7z docs/

7z l archive.rar

Pacchetto: p7zip-full / 7zip su Debian/Ubuntu, p7zip o 7zip su Fedora/Arch.

sha256sum ubuntu.iso

sha256sum -c SHA256SUMS --ignore-missing

macOS/BSD: macOS: shasum -a 256 file (e shasum -a 256 -c SUMSFILE).

Calcola l'hash di un testo o di un file nel browser →

-name

glob che distingue maiuscole e minuscole

-iname

senza distinzione tra maiuscole e minuscole

-path

confronta l'intero percorso

find . -name '*.log'

find / -iname 'nginx.conf' 2>/dev/null

-mtime -1

modificati nelle ultime 24 ore

-mtime +30

più di 30 giorni fa

-mmin -60

negli ultimi 60 minuti

-newer ref

più recenti del file ref

find /var/log -type f -mtime +30

find . -type f -mmin -15

find /tmp/app -name '*.tmp' -mtime +7 -print

find /tmp/app -name '*.tmp' -mtime +7 -delete

Attenzione: L'ordine conta: -delete agisce nel punto in cui compare, quindi find . -delete -name "*.tmp" elimina tutto sotto . prima ancora che venga applicato il test sul nome. Metti -delete per ultimo ed esegui prima con -print.

locate -i nginx.conf

sudo updatedb

Fornito da plocate o mlocate; l'indice viene ricostruito ogni giorno, quindi i file creati oggi possono mancare finché non viene eseguito updatedb.

-i

ignora maiuscole e minuscole

-n

mostra i numeri di riga

-v

inverte: righe che non corrispondono

-w

solo parole intere

-c

conta le righe corrispondenti

-o

stampa solo la parte corrispondente

-F

stringa fissa, niente regex

grep -n 'ERROR' app.log

grep -v '^#' nginx.conf | grep -v '^$'

grep -c 'Failed password' /var/log/auth.log

-r

ricorsivo

-l

solo i nomi dei file

--include='*.py'

solo questi file

--exclude-dir=node_modules

salta delle cartelle

grep -rn 'TODO' src/

grep -rl --include='*.php' 'mysql_connect' .

grep -rn --exclude-dir={.git,node_modules} 'apiKey' .

grep -E 'error|warn' app.log

grep -Eo '[0-9]{1,3}(\.[0-9]{1,3}){3}' access.log | sort | uniq -c | sort -rn | head

grep -P '\d{4}-\d{2}-\d{2}' file

macOS/BSD: -E funziona ovunque; -P (PCRE) è una funzionalità di GNU e non è disponibile in tutte le versioni di macOS.

Prova il pattern nel tester regex →

g

sostituisce ogni corrispondenza sulla riga, non solo la prima

-E

regex estesa (gruppi senza barre rovesciate)

I

corrispondenza senza distinzione tra maiuscole e minuscole (GNU)

sed 's/http:/https:/g' links.txt

sed 's|/usr/local|/opt|g' paths.txt

sed -E 's/([0-9]+)px/\1rem/g' style.css

sed -i 's/^#Port 22/Port 2222/' /etc/ssh/sshd_config

sed -i.bak 's/foo/bar/g' config.ini

macOS/BSD: sed di macOS richiede un argomento dopo -i: sed -i '' 's/foo/bar/g' file. sed di GNU legge '' come script, quindi l'unica forma che funziona su entrambi è -i.bak.

-F sep

separatore di campo (predefinito: sequenze di spazi/tabulazioni)

$1 … $NF

campi; $NF è l'ultimo, $0 l'intera riga

NR

numero di riga

awk '{print $1}' access.log

awk -F: '{print $1, $7}' /etc/passwd

awk -F, 'NR>1 {print $2}' data.csv

cut -d, -f1,3 data.csv

cut -d: -f1 /etc/passwd

cut -c1-10 file

cut considera ogni delimitatore come separatore di campo, quindi due spazi significano un campo vuoto. Per un output allineato con spazi usa awk.

-n

numerico

-r

inverso

-h

dimensioni leggibili: 2K < 1M < 3G

-k 2,2

ordina solo per il campo 2

-t ,

separatore di campo

-u

elimina i duplicati

-V

ordine di versione: 1.9 < 1.10

du -sh * | sort -h

sort -t, -k3,3nr data.csv

sort -u emails.txt > unique.txt

-c

antepone a ogni riga il suo conteggio

-d

solo le righe che si ripetono

-u

solo le righe che compaiono una volta

sort ips.txt | uniq -c | sort -rn | head

uniq comprime solo i duplicati adiacenti, quindi ordina prima.

wc -l access.log

ls | wc -l

grep -c '' file

Conta parole e caratteri nel browser →

tr 'a-z' 'A-Z' < in.txt

tr -d '\r' < windows.txt > unix.txt

tr -s ' ' < file

tr '\n' ',' < list.txt

tr legge solo lo standard input, quindi reindirizza il file con <.

-0

l'input è separato da NUL (da abbinare a find -print0); sicuro con gli spazi

-n N

al massimo N argomenti per comando

-P N

esegue N comandi in parallelo

-I {}

sostituisce {} con ogni riga di input

-r

non esegue il comando se l'input è vuoto (GNU)

find . -name '*.log' -print0 | xargs -0 rm -f

cat urls.txt | xargs -n 1 -P 4 curl -sO

ls *.png | xargs -I {} cp {} /backup/{}

macOS/BSD: xargs di GNU esegue il comando una volta anche con input vuoto a meno che tu non usi -r; xargs di macOS salta l'input vuoto per impostazione predefinita e accetta -r per compatibilità.

.

formattazione leggibile

-r

stringhe grezze, senza virgolette

-c

compatto, una riga per risultato

.[]

itera su un array

select(cond)

mantiene gli elementi corrispondenti

jq . response.json

jq -r '.items[].name' data.json

jq -r '.[] | select(.active) | .email' users.json

curl -s https://api.github.com/repos/jqlang/jq | jq '.stargazers_count'

Installalo con apt/dnf install jq. È incluso nelle versioni recenti di macOS.

Formatta e valida JSON nel browser →

printf '%s' 'user:pass' | base64

echo dXNlcjpwYXNz | base64 -d

base64 -w 0 image.png > image.b64

macOS/BSD: base64 di macOS non va a capo per impostazione predefinita e non ha -w. Usa -d per decodificare (le versioni meno recenti di macOS usavano -D).

Codifica o decodifica Base64 nel browser →

sudo systemctl restart nginx

sudo systemctl reload nginx

Quando possibile verifica la configurazione prima di riavviare, es. sudo nginx -t, così un errore di battitura non manda giù il sito.

-u unit

un servizio

-f

segue

-n N

ultime N righe

--since '1 hour ago'

anche: today, yesterday, 2026-10-18 09:00

-p err

priorità err e superiori

-b / -b -1

avvio attuale / avvio precedente

-e

salta alla fine

journalctl -u nginx -f

journalctl -u myapp --since '10 min ago'

journalctl -b -1 -p err

journalctl --disk-usage

sudo journalctl --vacuum-size=500M

sudo journalctl --vacuum-time=14d

Per un limite permanente imposta SystemMaxUse= in /etc/systemd/journald.conf.

sudo tail -f /var/log/syslog

sudo tail -f /var/log/auth.log

Alcune distribuzioni (Fedora, Arch) conservano i log solo nel journal, a meno che non sia installato rsyslog.

crontab -e

crontab -l

crontab -l > crontab.bak

Crea e spiega la pianificazione con il generatore di espressioni cron →

30 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

*/15 * * * * /usr/local/bin/check.sh

0 9 * * 1-5 /usr/local/bin/report.sh

@reboot /usr/local/bin/startup.sh

Cron gira con un PATH minimo e senza il profilo della shell: usa percorsi assoluti. Un % nel comando va scritto come \%.

Verifica il significato di un'espressione cron →

crontab -l > ~/crontab.bak && crontab -r

crontab ~/crontab.bak

Attenzione: Elimina tutti i tuoi job cron senza chiedere conferma, e r è proprio accanto a e sulla tastiera. Alcune implementazioni di cron offrono -i per chiedere prima (crontab -ri).

0 3 * * * root /usr/local/bin/cleanup.sh

ls /etc/cron.daily/

Su Debian e Ubuntu i file in /etc/cron.d il cui nome contiene un punto vengono ignorati, quindi chiamalo backup, non backup.cron.

echo 'systemctl restart myapp' | sudo at 02:00

echo './report.sh' | at now + 30 minutes

atq

atrm 3

Richiede il pacchetto at e il servizio atd in esecuzione.

ls -l > listing.txt

echo 'done' >> progress.log

set -o noclobber

La shell svuota il file prima che il comando venga eseguito, quindi sort file > file ti lascia un file vuoto. Scrivi su un nuovo nome, poi usa mv.

echo "Today is $(date +%A)"

echo $(( 1024 * 4 ))

diff <(ls dir1) <(ls dir2)

I backtick `comando` sono la vecchia forma di $(comando); $( ) si può annidare ed è più leggibile.

ls *.jpg

rm photo-??.png

cp config.{yml,yml.bak}

shopt -s globstar; ls **/*.md

Per impostazione predefinita i glob non includono i dotfile (shopt -s dotglob lo cambia). Se non c'è corrispondenza, bash passa il pattern letteralmente, a meno che non sia impostato shopt -s nullglob.

export NODE_ENV=production

DEBUG=1 ./app

printenv | sort

unset DEBUG

Si perdono quando la shell termina. Metti gli export in ~/.bashrc (shell interattive) o ~/.profile (shell di login) per conservarle.

sudo !!

cd !$

!42

^foo^bar

Con HISTCONTROL=ignorespace (predefinito su Ubuntu come parte di ignoreboth), un comando digitato con uno spazio iniziale non viene salvato: utile per i comandi con dati segreti.

Ctrl+R

cerca a ritroso nella cronologia; premi di nuovo per corrispondenze più vecchie

Ctrl+A / Ctrl+E

inizio / fine riga

Ctrl+U / Ctrl+K

taglia fino all'inizio / alla fine della riga

Ctrl+W

taglia la parola precedente

Ctrl+Y

incolla ciò che hai tagliato

Alt+B / Alt+F

indietro / avanti di una parola

Alt+.

inserisce l'ultimo argomento del comando precedente

Ctrl+L

pulisce lo schermo

Ctrl+C

annulla il comando in esecuzione

Ctrl+D

fine dell'input; su una riga vuota chiude la shell

Tab Tab

mostra i completamenti

bind -P | less

Guida rapida alle scorciatoie da tastiera per Mac →

#!/usr/bin/env bash
set -euo pipefail
name="${1:-world}"
if [[ -f "$name.txt" ]]; then
  echo "found $name.txt"
fi
for f in *.log; do
  echo "$f"
done

chmod +x script.sh && ./script.sh Ada

bash -x script.sh

$1 … $9 sono gli argomenti, "$@" sono tutti, $# è quanti sono. [[ ]] è di bash; negli script POSIX sh usa [ ].

Cicli e condizioni di Bash a confronto con CMD e PowerShell →