# I comandi Linux più importanti Come la maggior parte dei sistemi operativi, anche Linux ti mette a disposizione una **shell**, che può essere utilizzata per controllare il sistema utilizzando **comandi dalla riga di comando**. Tutte le impostazioni che puoi apportare tramite l’[interfaccia grafica (Graphical User Interface, GUI)](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/che-cose-una-gui/) si possono anche applicare dalla shell. Ti indichiamo i comandi Linux più importanti spiegandoti la loro funzione e applicazione. ## Elenco dei 50 comandi Linux più importanti
Comando Descrizione
sudo Esegue comandi con i permessi di altri utenti
ls Elenca i contenuti delle directory
cd Naviga nell’albero delle directory
touch Crea un nuovo file
mkdir Crea una nuova directory
rm Rimuove file
rmdir Rimuove una directory
mv Sposta o rinomina file o directory
cp Copia file o directory
pwd Visualizza la posizione corrente nell’albero delle directory
zip Scrive file in archivi zip
unzip Estrae file dagli archivi zip
ln Crea un collegamento simbolico
cat Unisce i contenuti dei file
grep Cerca file di testo
diff Trova differenze tra file di testo
cmp Trova differenze a livello di byte tra file
tar Scrive ed estrae file in archivi tar
echo Emette stringhe su specifiche standard
clear Svuota il terminale
ssh Si connette a un altro computer attraverso *Secure Shell*
wget Scarica un file direttamente da internet
ping Invia richieste al server e misura la latenza
ftp, sftp Trasferisce file tramite (S)FTP
ip Interroga e configura le interfacce di rete
apt/pacman/yum Scarica e gestisce pacchetti software
netstat Visualizza lo stato delle interfacce di rete
traceroute Traccia i pacchetti di dati
route Visualizza e modifica le tabelle di instradamento IP
dig Richiede informazioni DNS
mount/unmount Integra i file system (impostare/montare)
dd Copia file, partizioni o supporti di dati con precisione di bit
chmod Gestisce i permessi di accesso
chown Cambia il proprietario di un file
adduser Aggiunge/modifica account utente
passwd Crea/modifica le password per gli account utente
groupadd Crea gruppi di utenti
chattr Gestisce gli attributi dei file
lsattr Visualizza gli attributi dei file
chgrp Gestisce l’appartenenza a gruppi di file e directory
man Richiama il manuale utente
shutdown, reboot Spegne/riavvia il sistema
top Fornisce un riassunto dinamico dei processi
lscpu Visualizza le informazioni sul processore
lshw Visualizza le informazioni sull’hardware
kill Arresta e termina il processo tramite PID
killall Arresta e termina i processi tramite nome
nice Definisce le priorità dei processi
pgrep Determina il PID attraverso un termine di ricerca
ps Visualizza l’elenco di tutti i processi in esecuzione
### Comando sudo su Linux Il [comando sudo su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-sudo-su-linux/) (*substitute user do*) può essere anteposto alle chiamate del programma per eseguirle con i permessi di un altro utente. Perciò, di solito, è necessario inserire una password. Il comando `sudo` richiede quindi sempre la password dell’utente in questione. Se il comando viene trasmesso senza nomi utente, il super utente root viene utilizzato come utente di destinazione. ```bash sudo -u NOMEUTENTE CHIAMATAPROGRAMMA ``` ### Comando ls su Linux Il [comando ls su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-ls-su-linux/) sta per *list* e viene utilizzato per mostrare il contenuto di una cartella (i nomi di tutti i file e di tutte le cartelle che si trovano nella cartella indicata). La sintassi del comando è la seguente: ```bash ls [OPZIONI] CARTELLA ``` Se `ls` viene utilizzato senza indicare la cartella, il comando elenca il contenuto della cartella corrente. Grazie a opzioni aggiuntive definisci quali informazioni vengono indicate e come vengono visualizzate. ### Comando cd su Linux Il [comando cd su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-cd-su-linux/) sta per *change directory* e serve per navigare tra le cartelle. La sintassi del comando è la seguente: ```bash cd [OPZIONE] CARTELLA ``` Se non viene inserita una cartella di destinazione, `cd` si sposta automaticamente nella cartella home dell’utente. Se `cd` viene seguito da un segno meno (-), si ritorna alla cartella precedente. ### Comando touch su Linux Il [comando touch su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-touch-su-linux/) viene utilizzato per modificare la marca temporale di accesso e di modifica. Se `touch` viene applicato a un file inesistente, allora verrà automaticamente creato. Il comando è perciò indicato anche per creare file vuoti. Utilizza `touch` ricorrendo allo schema seguente: ```bash touch [OPZIONI] FILE ``` Per impostare la marca temporale di un file alla data desiderata, utilizza l’opzione `-t` comprensiva dell’ora nel formato `[JJ]MMTThhmm[.ss]`. Esempio: ```bash touch -t 1703231037 file.txt ``` La marca temporale di accesso e di modifica viene impostata al 23 marzo 2017, 10:37. La modifica si può limitare tramite le opzioni `-a` e `-m` alla marca temporale di accesso o di modifica. Se il comando `touch` viene utilizzato senza l’opzione `-t`, viene applicata la marca temporale corrente. ### Comando mkdir su Linux Il [comando mkdir su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-mkdir-su-linux/) sta per *make directory* e consente agli utenti Linux di creare nuove cartelle. Utilizza la sintassi seguente per creare una nuova cartella in quella corrente: ```bash mkdir [OPZIONE] NOMECARTELLA ``` Se una cartella deve essere creata in una determinata cartella di destinazione, indica il percorso assoluto o relativo per giungere alla cartella. ### Comando rm su Linux Il [comando rm su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-rm-su-linux/) (*remove*) elimina file o intere cartelle permanentemente. Lo schema alla base dell’esecuzione del programma è il seguente: ```bash rm [OPZIONI] FILE/CARTELLA ``` Per eliminare una cartella comprensiva di tutte le sottocartelle, utilizza `rm` con l’opzione `-R` (*--recursive*). ### Comando rmdir su Linux Se desideri eliminare una cartella in particolare, utilizza il comando `rmdir` (*remove directory*) basandoti sulla seguente sintassi: ```bash rmdir [OPZIONE] CARTELLA ``` Con `rmdir` puoi rimuovere solo le cartelle vuote. Per eliminare una cartella con tutti i file e le sottocartelle, utilizza il comando rm (remove) con l’opzione `-r`. In altri articoli trovi ulteriori metodi su come [cancellare un file su Linux](https://www.ionos.it/digitalguide/server/configurazione/cancellare-file-linux/) o su come [eliminare una directory in Linux](https://www.ionos.it/digitalguide/server/configurazione/eliminare-una-directory-in-linux/). ### Comando mv su Linux Il [comando mv su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-mv-su-linux/) (*move*) copia un file o una cartella, eliminando l’elemento originario. Se ciò accade all’interno della stessa cartella, `mv` può essere utilizzato per rinominare i file. Lo schema alla base dell’esecuzione del programma è il seguente: ```bash mv [OPZIONE] ORIGINE DESTINAZIONE ``` ### Comando cp su Linux Il [comando cp su Linux](https://www.ionos.it/digitalguide/server/configurazione/linux-comando-cp/) (*copy*) viene utilizzato per copiare i file e le cartelle. La sintassi di base del comando è la seguente: ```bash cp [OPZIONI] ORIGINE DESTINAZIONE ``` ORIGINE è l’elemento che deve essere copiato. Come DESTINAZIONE del processo di copia viene definito un file o una cartella. Se definisci un file preesistente come file di destinazione il suo contenuto verrà sovrascritto con quello del file di origine. In alternativa, hai la possibilità di creare il file di destinazione come nuovo file con il nome desiderato. ### Comando pwd su Linux Utilizza il [comando pwd su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-pwd-su-linux/) (abbreviazione di *print working directory*) per farti mostrare il nome della cartella corrente in cui stai lavorando. La sintassi del comando è la seguente: ```bash pwd [OPZIONI] ``` ### Comando zip su Linux Usa il comando `zip` per comprimere diversi file in un archivio zip. La sintassi del comando è la seguente: ```bash zip DESTINAZIONE FILE ``` DESTINAZIONE è il nome o il percorso del file zip risultante. FILE si riferisce ai nomi o ai percorsi dei file da comprimere (separati da spazi). ### Comando unzip su Linux Con `unzip` puoi estrarre i file dagli archivi zip. La sintassi è questa: ```bash unzip FILE.zip -d DESTINAZIONE ``` Qui FILE si riferisce all’archivio zip da cui devono essere estratti i file. Opzionalmente, puoi usare l’opzione -d DESTINAZIONE per specificare una directory di destinazione in cui memorizzare i file risultanti. Altrimenti i file vengono memorizzati nella directory corrente. ### Comando ln su Linux Il [comando ln su Linux](https://www.ionos.it/digitalguide/server/configurazione/linux-comando-ln/) (abbreviazione di *link*) genera un collegamento a un file o a una cartella. Così viene generato un’ulteriore voce per questo file che ti consente di accedere al file relativo tramite un altro percorso. Il programma della riga di comando `ln` deve almeno sempre contenere il percorso al file originario. ```bash ln [OPZIONI] percorso/al/file/originario ``` Il link viene creato, in questo caso, con lo stesso nome nella cartella in cui si sta lavorando. Alternativamente hai la possibilità di indicare un percorso di destinazione e di dare un qualsiasi nome al collegamento: ```bash ln [OPZIONI] percorso/al/file/originario percorso/al/collegamento ``` ### Comando cat su Linux Il [comando cat su Linux](https://www.ionos.it/digitalguide/server/configurazione/linux-comando-cat/) (abbreviazione di *concatenate*) è stato sviluppato come strumento per l’unione dei contenuti dei file e può essere utilizzato come pager per visualizzare i contenuti dei file nel terminale. Apri nel terminale `cat` con la seguente sintassi per inserire un file e riceverlo nello `stdout` (standard output): ```bash cat OPZIONI FILE ``` Più file vengono separati da spazi: ```bash cat OPZIONI FILE1 FILE 2 ``` ### Comando grep su Linux Con il [comando grep su Linux](https://www.ionos.it/digitalguide/server/configurazione/linux-comando-grep/) si possono fare ricerche nei file di testo. Come schema di ricerca vengono utilizzate le più svariate sequenze di caratteri o espressioni regolari. Utilizza *grep* ricorrendo allo schema seguente: ```bash grep [OPZIONI] SCHEMARICERCA [FILE] ``` Se `grep` si imbatte in una stringa che corrisponde allo schema di ricerca, il numero della riga viene visualizzato nel terminale con l’indicazione del nome del file. Solitamente `grep` viene utilizzato su tutti i file nella cartella corrente. L’opzione `-r` consente una ricerca ricorsiva nelle sottocartelle. ### Comando diff su Linux Il comando `diff` serve a confrontare due file. In alternativa, si può stabilire tramite `diff` se due cartelle contengono gli stessi file. La visualizzazione nel terminale avviene ricorrendo alla sintassi seguente: ```bash diff [OPZIONI] FILE1 FILE2 ``` ### Comando cmp su Linux `cmp` fa parte del pacchetto `diff` e serve come questo per confrontare i contenuti dei file. Diversamente da come avviene su `diff`, la sincronizzazione avviene quindi sul livello di byte e si adatta in particolare per i file binari. Utilizza `cmp` ricorrendo alla seguente sintassi: ```bash cmp [OPZIONI] FILE1 FILE2 ``` Se `cmp` riscontra delle differenze, il comando restituisce il numero della riga e di byte della prima divergenza trovata nel terminale. ### Comando tar su Linux Il comando `tar` consente di scrivere diversi file e cartelle sequenzialmente in un file `tar` e ripristinarli a partire da questo, se necessario. A differenza del classico formato zip di Windows, tutti i permessi utente del file archiviato rimangono invariati anche dopo la decompressione. Usa la sintassi seguente: ```bash tar [OPZIONI] FILE ``` Se desideri creare un nuovo archivio, utilizza `tar` con le opzioni `-c` (generare un nuovo archivio) e `-f` (scrivere un archivio nel file indicato o estrarlo da questo). Per saperne di più, consulta il nostro articolo “[Creare backup con tar: come funziona l’archiviazione](https://www.ionos.it/digitalguide/server/tools-o-strumenti/backup-con-tar/)”. ### Comando echo su Linux Utilizza il [comando echo su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-echo-di-linux/) per riprodurre le catene di caratteri per riga sullo standard output (solitamente il terminale). La sintassi generale del programma è la seguente: ```bash echo [OPZIONI] STRINGA ``` ### Comando clear su Linux Utilizza il comando `clear` per rimuovere il contenuto dello schermo. ```bash clear ``` Così ottieni un terminale vuoto con aperta solo la finestra della riga di comando. Gli input immessi precedentemente rimangono però memorizzati nello scrollback buffer (cache di scorrimento). Al posto di usare questo comando, si può anche svuotare il terminale tramite la combinazione di tasti \[CTRL\] + \[L\]. ### Comando ssh su Linux Puoi utilizzare `ssh` per collegare il computer a un computer esterno tramite il protocollo SSH. In questo modo ti troverai quindi nella shell dell’altro computer. La sintassi è la seguente: ```bash ssh NOMEUTENTE@NOMEHOST ``` In questo caso, NOMEUTENTE e NOMEHOST indicano rispettivamente il nome utente con cui si desidera accedere e l’indirizzo del computer esterno. ### Comando wget su Linux Puoi utilizzare il [comando wget su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-wget-su-linux/) per scaricare file da internet. Usa la seguente sintassi: ```bash wget [OPZIONE] LINK ``` LINK è l’URL con il quale si trova il file. Puoi anche utilizzare l’argomento opzionale `-c` per continuare un download interrotto. ### Comando ping su Linux Utilizza il [comando ping su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-ping-su-linux/) per verificare la raggiungibilità di altri computer nella rete. La seguente sintassi è alla base del comando: ```bash ping [OPZIONI] OBIETTIVO ``` Insieme al tempo di andata e ritorno del pacchetto (*Round trip time*, RTT), ovvero l’intervallo compreso tra l’invio del pacchetto e la ricezione della risposta, `ping` fornisce anche l’indirizzo IP del sistema di destinazione nel terminale. Puoi usare argomenti opzionali per impostare il numero di pacchetti o di secondi dopo i quali `ping` termina autonomamente. ### Comando ftp o sftp su Linux Questo comando ti dà la possibilità di scambiare file tra un sistema locale e un altro computer in rete. Utilizza [FTP (File Transfer Protocol](https://www.ionos.it/digitalguide/server/know-how/file-transfer-protocol/) ricorrendo allo schema seguente per instaurare una connessione al server FTP del computer di destinazione. ```bash ftp [OPZIONI] [HOST[PORTA]] ``` L’indirizzamento avviene tramite nome host o indirizzo IP. L’indicazione di un numero di porta è opzionale. Utilizza FTP solo nelle reti di cui ti fidi, poiché questo protocollo non è sicuro. Per motivi di sicurezza, è quasi sempre preferibile usare [SFTP (SSH File Transfer Protocol)](https://www.ionos.it/digitalguide/server/know-how/sftp-ssh-file-transfer-protocol/). Il comando Linux `sftp` funziona secondo lo stesso principio di `ftp`, ma in questo caso il trasferimento è criptato. SFTP utilizza [Secure Shell (SSH)](https://www.ionos.it/digitalguide/server/tools-o-strumenti/ssh/) come standard, inclusi i suoi metodi di autenticazione. In un altro articolo ti spieghiamo come utilizzare le [chiavi SSH per la connessione alla rete](https://www.ionos.it/digitalguide/server/sicurezza/come-utilizzare-chiavi-ssh-per-la-vostra-connessione/). ### Comando ip su Linux Il programma della riga di comando `ip` fa parte della raccolta di programmi `iproute2`, con cui si possono richiedere e configurare dal terminale le interfacce di rete. La sintassi generale del comando è la seguente: ```bash ip [OPZIONI] OGGETTO [COMANDO [ARGOMENTI]] ``` Grazie a oggetti, sottocomandi e altri argomenti definisci quale azione viene eseguita tramite `ip`. Il programma supporta diversi oggetti come `address` (indirizzo IP), `link` (interfaccia di rete), `route` (voce nelle tabelle di instradamento) o `tunnel`, ai quali si possono applicare i sottocomandi come `add`, `change`, `del`, `list` o `show`. Ad esempio, se desideri richiamare l’indirizzo IP di un’altra interfaccia di rete specifica (ad esempio `eth0`), utilizza il comando `ip` insieme all’oggetto `address`, il comando `show` e l’argomento `dev eth0`: ```bash ip address show dev eth0 ``` Ti spieghiamo come [visualizzare un indirizzo IP su Linux](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/linux-visualizzare-lindirizzo-ip/) in modo più dettagliato in un altro articolo. ### Comandi apt, pacman e yum su Linux Ogni distribuzione Linux dispone di un **gestore di pacchetti** con il quale è possibile scaricare e gestire i pacchetti software. La sintassi per l’installazione delle applicazioni è la seguente: ```bash apt install [PACCHETTO] # Distribuzioni basate su Debian come Ubuntu pacman -S [PACCHETTO] # Distribuzioni basate su Arch yum install [PACCHETTO] # Distribuzioni basate su Red Hat ``` Qui `[PACCHETTO]` è il nome del pacchetto o del programma che vorresti installare. Nella maggior parte dei casi, questi comandi devono essere eseguiti tramite `sudo` in modalità root. Per altre distribuzioni che utilizzano altri gestori di pacchetti, i comandi possono differire. Ogni gestore ha anche comandi per rimuovere i pacchetti, aggiornare l’elenco dei pacchetti e aggiornare tutti i pacchetti installati, ecc. Su Ubuntu, questi comandi sono i seguenti. ```bash apt remove [PACCHETTO] # rimuove i pacchetti apt update # aggiorna l’elenco dei pacchetti apt upgrade # aggiorna i pacchetti ``` ### Comando netstat su Linux Il programma della riga di comando `netstat` serve per fornire lo stato delle interfacce di rete. La sintassi generale del comando è la seguente: ```bash netstat [OPZIONI] ``` Utilizza `netstat` senza opzione per farti mostrare tutti i socket aperti nel terminale. Alternativamente usa le seguenti opzioni per visualizzare le tabelle di instradamento (`-r`), le statistiche delle interfacce (`-i`), le connessioni mascherate (`-M`) o i messaggi del collegamento di rete (`-N`). Per saperne di più, consulta la nostra [introduzione a netstat](https://www.ionos.it/digitalguide/server/tools-o-strumenti/introduzione-a-netstat/). ### Comando traceroute su Linux Per tracciare il percorso di trasporto di un pacchetto di dati IP tra il sistema e un computer di destinazione, utilizza il comando [traceroute per seguire il percorso dei pacchetti](https://www.ionos.it/digitalguide/server/tools-o-strumenti/seguire-i-pacchetti-dati-con-traceroute/). Usa il seguente schema: ```bash traceroute [OPZIONI] NOMEHOST ``` Tramite `traceroute` si può individuare quale router e nodi internet ha attraversato un pacchetto IP durante il percorso per giungere al computer di destinazione, utile ad esempio per approfondire la causa di un ritardo nella trasmissione. ### Comando route su Linux Con il programma della riga di comando `route` si possono richiedere e modificare le tabelle di instradamento IP del kernel. La sintassi seguente è alla base del comando: ```bash route [OPZIONI] [add|del] [-net|-host] [DESTINAZIONE] ``` Utilizza il comando senza opzione per farti mostrare completamente la tabella di routing del kernel: ```bash route ``` Se desideri impostare un percorso alla rete, utilizza il sottocomando `add`. ```bash route add -net 10.0.0.0 ``` ### Comando dig su Linux `dig` è uno strumento di lookup con il quale richiedere le informazioni dei server DNS e visualizzarle nel terminale. Il programma della riga di comando viene solitamente utilizzato ricorrendo allo schema seguente per richiedere l’indirizzo IP e altre informazioni DNS su un nome di dominio dato: ```bash dig [@SERVER] [DOMINIO] [TIPO] ``` SERVER è il server DNS che deve essere ricercato in base alle informazioni desiderate. Per impostazione predefinita, viene utilizzato il server predefinito del file `etc/resolv.conf`. DOMINIO sta a indicare il nome di dominio al quale devono essere comunicate le informazioni DNS. Come TIPO si può definire il tipo di richiesta, ad esempio ANY (tutte le voci), A (record IPv4 di un host) o AAAA (record IPv6 di un host). Il record A è definito come tipo di richiesta standard. ### Comandi mount e unmount su Linux Se un file system deve essere collegato tramite terminale nella struttura di cartelle del sistema operativo, su Linux si utilizza il programma della riga di comando `mount`. La sintassi generale del comando è la seguente: ```bash mount [OPZIONI] DISPOSITIVO PUNTO_DI_MONTAGGIO ``` DISPOSITIVO = il percorso al file del dispositivo del supporto di memoria che vorresti montare come partizione. PUNTO\_DI\_MONTAGGIO = il punto nella struttura di cartelle del tuo sistema operativo sul quale vorresti montare la partizione. Il punto di montaggio viene indicato spesso come percorso assoluto. Esempio: ```bash mount /dev/sdd /media/usb ``` Il dispositivo `sdd` viene montato nella cartella `/media/usb`. ### Comando dd su Linux Il programma della riga di comando `dd` consente una copia in cui i dati vengono analizzati bit per bit da un input file (`if`) e vengono scritti in un output file (`of`). La seguente sintassi è alla base del programma: ```bash dd if=origine of=destinazione [OPZIONI] ``` Come origine e destinazione si possono indicare così sia i singoli file che le partizioni intere (ad esempio /dev/sda1) o un dispositivo di memoria completo (ad esempio /dev/sda). ```bash dd if=/dev/sda5 of=/dev/sdb1 ``` ### Comando chmod su Linux Il comando `chmod` (abbreviazione di *change mode*) serve per l’assegnazione dei permessi nei file system compatibili con UNIX (ad esempio ext2, ext3, ext4, reiser, xfs). La sintassi generale del comando è la seguente: ```bash chmod [OPZIONI] MODALITÀ FILE ``` o anche ```bash chmod [OPZIONI] MODALITÀ CARTELLA ``` Il segnaposto MODALITÀ serve per indicare la maschera dei permessi da applicare. Nel nostro articolo di approfondimento sull’[assegnazione dei permessi di accesso con chmod](https://www.ionos.it/digitalguide/server/know-how/lassegnazione-dei-permessi-con-il-comando/), scopri come crearla e a cosa devi prestare attenzione durante il processo. Grazie all’opzione `-R` si possono estendere in modo ricorsivo i permessi dati alle sottocartelle e ai file contenuti in una cartella. ### Comando chown su Linux Il [comando chown su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-chown-di-linux/) sta per *change owner* e ti dà la possibilità di modificare le impostazioni del proprietario di un file o di una cartella secondo lo schema seguente: ```bash chown [OPZIONI] [UTENTE][:[GRUPPO]] FILE ``` o anche ```bash chown [OPZIONI] [UTENTE][:[GRUPPO]] CARTELLA ``` Per impostare i permessi proprietari per gli utenti o i gruppi, hai a disposizione quattro possibilità di combinazione. Il proprietario e il gruppo vengono impostati nuovamente in base ai dati forniti: ```bash chown [OPZIONI] proprietario_nome:gruppi_nome file.txt # Il gruppo viene impostato nuovamente in base ai dati forniti, l’utente rimane invariato: chown [OPZIONI] :gruppi_nome file.txt # Il proprietario viene impostato nuovamente in base ai dati forniti, il gruppo rimane invariato: chown [OPZIONI] proprietario_nome file.txt # L’utente viene impostato nuovamente in base ai dati forniti. Il gruppo viene impostato sul gruppo standard dell’utente che ha effettuato il login: chown [OPZIONI] proprietario_nome: file.txt # Le modifiche si possono rendere ricorsive e applicare quindi alle sottocartelle grazie all’OPZIONE `-R`. ``` ### Comando adduser su Linux Il modo più semplice per creare un account utente è usare il programma della riga di comando `adduser`. Si tratta di uno script Perl basato sul [comando Linux useradd](https://www.ionos.it/digitalguide/server/configurazione/comando-useradd-su-linux/) e offre le stesse funzioni in una forma facile da usare. Il comando `adduser` richiede i permessi di root e si usa secondo la sintassi seguente: ```bash adduser [OPZIONI] NOMEUTENTE ``` Se usi `adduser` senza opzioni, oltre a un nuovo account utente, vengono creati automaticamente un ID utente, una cartella home e un gruppo utente omonimo. ```bash adduser test ``` Dopo segue un dialogo interattivo in cui si possono definire la password e le informazioni utente avanzate, come nome reale, numero dell’ufficio, numeri di telefono, ecc. ### Comando passwd su Linux Utilizza il [comando passwd su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-passwd-su-linux/) per cambiare la password di un utente o definire gli intervalli di blocco o di modifica. La sintassi alla base del comando è la seguente: ```bash passwd [OPZIONI] NOMEUTENTE ``` Se desideri cambiare la password di un altro utente, hai bisogno dei permessi di root. Per cambiare la password, utilizza il comando `passwd` senza nome utente. Se la password dell’utente selezionato dovesse essere bloccata, usa il comando `passwd` con l’opzione `-l` (*lock*). Ulteriori opzioni offrono la possibilità di definire una durata di validità per le password (`-x`), gli intervalli di avviso (`-w`) e di blocco (`-i`). ### Comando groupadd su Linux Il programma della riga di comando `groupadd` serve a creare nuovi gruppi utente. Utilizza `groupadd` con permessi di root ricorrendo allo schema seguente: ```bash sudo groupadd [OPZIONI] GRUPPO ``` Ogni nuovo gruppo creato ottiene un ID del gruppo univoco (GID). Gli ID dei gruppi compresi tra 0 e 99 sono destinati ai gruppi di sistema. Se desideri definire in autonomia il GID di un nuovo gruppo utente, utilizza il comando `groupadd` con l’opzione `-g` (GID). Se vorresti creare un gruppo di sistema, usa l’opzione `-r` (root). ### Comando chattr su Linux Il programma della riga di comando `chattr` (abbreviazione di *change attribute*) ti permette di dare degli attributi ai file o alle cartelle. Per impostare un attributo, utilizza `chattr` ricorrendo alla sintassi seguente: ```bash chattr [OPZIONI] +ATTRIBUTO FILE ``` Sostituisci il segno più con il segno meno per rimuovere nuovamente gli attributi. Ad esempio, imposta l’attributo `-i` per impedire cambiamenti (cancellazioni o modifiche) a un file o a una directory. Scopri altri attributi e possibili opzioni sulla pagina del manuale del programma `chattr`. ### Comando lsattr su Linux Se desideri visualizzare quali attributi sono stati impostati per un file o una cartella, utilizza il comando `lsattr` (abbreviazione di *list attributes*) ricorrendo allo schema seguente: ```bash lsattr [OPZIONI] FILE/CARTELLA ``` ### Comando chgrp su Linux Il comando `chgrp` sta per *change group* e viene utilizzato per la gestione dell’appartenenza ai gruppi dei file e delle cartelle. Per poter usare `chgrp` su un file o una cartella selezionata, devi disporre di permessi proprietari o root. Inoltre, puoi scegliere solo gruppi dei quali fai parte. La sintassi per utilizzare `chgrp` è la seguente: ```bash chgrp [OPZIONI] GRUPPO FILE ``` o: ```bash chgrp [OPZIONI] GRUPPO CARTELLA ``` L’opzione `-R` include le sottocartelle e i file contenuti in una cartella. ### Comando man su Linux Il comando `man` apre le pagine del manuale (*man pages*) della tua distribuzione Linux direttamente nel terminale. Utilizza lo schema seguente per visualizzare la pagina del manuale: ```bash man [OPZIONE] ARGOMENTO ``` Le man pages di Linux sono suddivise in 10 tematiche: comandi utente, chiamate al sistema, funzioni del linguaggio di programmazione C, formati dei file, file di configurazione, giochi, varie, comandi per l’amministrazione del sistema, funzioni del kernel e nuovi comandi. ### Comando shutdown su Linux Il [comando shutdown su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-shutdown-di-linux/) può essere utilizzato dagli utenti root per arrestare il sistema. La sintassi di base del comando è la seguente: ```bash shutdown [OPZIONI] [TEMPO] [MESSAGGIO] ``` Se vorresti predisporre uno shutdown, hai la possibilità di definire un orario in cui il sistema deve essere arrestato. Per fare ciò inserisci un’indicazione temporale concreta (hh:mm) o utilizza la funzione di countdown (+m). Gli altri utenti sul sistema ricevono un avviso di shutdown a cui può essere aggiunto, se necessario, un messaggio personalizzato. Se il comando `shutdown` viene utilizzato con l’opzione `–r`, segue all’arresto del sistema un reboot. ### Comando top su Linux Con il comando `top` visualizzi un riepilogo dinamico di tutti i processi in corso. Lo schema alla base del comando è il seguente: ```bash top [OPZIONI] ``` Il risultato delle informazioni del processo si può regolare grazie a diverse opzioni. Inoltre, il riepilogo dei processi `top` (tra gli altri) supporta le seguenti hotkeys per filtrare l’output: - \[P\] = filtra l’output secondo il carico della CPU - \[M\] = filtra l’output secondo l’uso della memoria - \[N\] = filtra l’output numericamente per PID - \[A\] = filtra l’output in base all’età - \[T\] = filtra l’output in base al tempo - \[U NOMEUTENTE o UID\] = filtra l’output a seconda del rispettivo utente Utilizza l’Hotkey \[H\] per visualizzare una pagina di aiuto e \[Q\] per uscire dal riepilogo dei processi. ### Comando lscpu su Linux Utilizza `lscpu` (abbreviazione di *list cpu*) ricorrendo allo schema seguente per visualizzare le informazioni sull’architettura CPU nel terminale. ```bash lscpu [OPZIONI] ``` Le possibili opzioni sono contenute nelle pagine del manuale del sistema operativo. ### Comando lshw su Linux Il comando `lshw` sta per *list hardware* e ti fornisce le informazioni sui componenti hardware nel terminale. Utilizza `lshw` ricorrendo allo schema seguente: ```bash lshw [OPZIONI] ``` Il comando supporta diverse opzioni con cui puoi adattare il formato di output (`-html`, `-xml`, `-short`, `-businfo`) così come le informazioni mostrate (ad esempio `-sanitize` per nascondere le informazioni sensibili). ### Comando kill su Linux Con `kill` si attiva un programma della riga di comando con cui si possono fermare e terminare i processi. Il comando viene trasmesso ricorrendo allo schema seguente con un segnale desiderato e l’ID del processo selezionato. ```bash kill [OPZIONI] [-SEGNALE] PID ``` I segnali comuni sono: 1. `TERM`: predispone che un processo termini autonomamente (standard) 2. `KILL`: forza la chiusura di un processo (tramite il sistema) 3. `STOP`: ferma un processo 4. `CONT`: consente a un processo fermato di riprendere ### Comando killall su Linux Utilizza il [comando killall su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-killall-di-linux/) insieme a una precisa parola chiave per terminare solo i processi con un nome specifico (vengono comparati i primi 15 caratteri). ```bash killall [OPZIONI] [-SEGNALE] [NOMEPROCESSO] ``` L’opzione `-e` (*--exact*) consente di estendere il confronto a tutti i caratteri del nome del processo. ### Comando nice su Linux Il comando `nice` assegna a un processo all’avvio un valore nice compreso tra -20 e +19 in passaggi di numeri interi secondo il quale viene distribuita la capacità di calcolo disponibile per il sistema. L’intervallo da -20 a +19 corrisponde ai livelli di priorità Linux da 100 fino a 139. Un processo con un valore nice di -20 ha così una priorità più alta rispetto a un processo con un valore nice di 19. La sintassi generale è la seguente: ```bash nice [OPZIONE] [COMANDO] ``` Senza ulteriori indicazioni ogni processo si avvia con un valore nice di 0. Utilizza l’opzione `-n` per definire le priorità dei processi. Così è da fare attenzione al fatto che si possono dare delle priorità negative solo con i permessi di root. ### Comando pgrep su Linux Il programma della riga di comando `pgrep` compara la lista dei processi in corso con una parola chiave e fornisce in caso di coincidenza il relativo PID. La sintassi generale del comando è la seguente: ```bash pgrep [OPZIONI] parola chiave ``` Solitamente `pgrep` restituisce i PID di tutti i processi che contengono la parola chiave. Se la ricerca deve essere limitata a termini con la dicitura esatta, utilizza il comando con l’opzione `-x`. Se oltre al PID desideri visualizzare anche il nome del processo, usa `pgrep` con l’opzione `-l`. `pgrep` supporta (in modo analogo a `grep`) parole chiave basate su espressioni regolari. ### Comando ps su Linux Il [comando ps su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-ps-su-linux/) fornisce una lista di tutti i processi in corso nel terminale. ```bash ps [OPZIONI] ``` Se hai bisogno di un risultato più dettagliato, utilizza `ps` con le opzioni `-f` (dettagliato) o `-F` (molto dettagliato). Altre possibili opzioni sono contenute nelle pagine del manuale del sistema operativo. ## Altri comandi Linux ### Comandi di base Nella categoria dei comandi di base rientrano i comandi di Linux essenziali che servono a **controllare il terminale**. Scopri così come svuotare l’area visibile del terminale, come richiamare dalla cronologia i precedenti comandi immessi nel terminale o come terminare una sessione. **1.exit** Il comando `exit` termina la sessione corrente e chiude il terminale. ```bash exit ``` In alternativa, utilizza la combinazione di tasti \[CTRL\] + \[D\]. **2. help** Utilizza il comando `help` per farti mostrare una lista di tutti i comandi shell integrati (comandi built-in). Inserisci il comando `help` insieme a un comando shell per ricevere una piccola descrizione del corrispettivo comando. ```bash help COMANDO ``` **3. history** Su bash vengono memorizzati nella cronologia (in inglese “history”) gli ultimi 500 comandi che hai inserito nella riga di comando. Questa funzione ti aiuta durante l’immissione degli input e ti consente di ricercare nella lista dei comandi precedenti con i tasti freccia e di eseguirli nuovamente. Si possono ricercare delle parole chiave nella cronologia tramite la combinazione di tasti \[CTRL\] + \[R\]. Alternativamente hai la possibilità di farti mostrare la lista completa numerata nel terminale. Per fare ciò, utilizza il comando `history` senza opzioni e argomenti. ```bash history ``` Se desideri filtrare il risultato, combina `history` con una [pipe su Linux](https://www.ionos.it/digitalguide/server/configurazione/pipe-su-linux/) e il programma della riga di comando `grep` (vedi opzioni di ricerca) e una parola chiave. ```bash history | grep PAROLA CHIAVE ``` ### Pagine di aiuto Non sai come andare oltre? Niente paura! Su Linux hai a disposizione diverse **pagine di aiuto e di documentazione**, come le pagine del manuale di Unix (conosciute anche come “man pages”) e le pagine informative GNU visualizzabili direttamente dal terminale. Queste guide comprendono una descrizione dettagliata di tutti i programmi della riga di comando, dei collegamenti del sistema, dei file di configurazione, dei formati e delle funzioni del kernel. Con il [comando whatis su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-whatis-su-linux/) e `apropos` nella categoria delle pagine di aiuto trovi anche i programmi della riga di comando con cui puoi ricercare le parole chiave presenti nelle pagine del manuale del tuo sistema operativo. **1. apropos** Utilizza `apropos` per ricercare le parole chiave nei titoli delle pagine e delle descrizioni contenute nel manuale del tuo sistema operativo. Orientati sullo schema seguente: ```bash apropos [OPZIONI] PAROLA CHIAVE ``` Il comando supporta diverse opzioni. Delimita la ricerca alla dicitura esatta con l’opzione `-e` o utilizza il segnaposto (`-w '*PAROLA CHIAVE'`) e le [espressioni regolari](https://www.ionos.it/digitalguide/siti-web/creare-siti/espressioni-regolari/) (`-r`). **2. info** Tramite il comando `info` si possono visualizzare le pagine informative GNU su un tema specifico. Ciò corrisponde nella maggior parte dei casi alle pagine del manuale che si possono richiamare tramite `man`, ma al contrario di queste mostrano dei collegamenti che ti agevolano la navigazione nel manuale. Utilizza la sintassi seguente: ```bash info [OPZIONE] TEMA ``` Se non inserisci l’opzione e il tema, vieni indirizzato al menu principale delle pagine informative GNU. **3. pinfo** Con `pinfo` hai a disposizione una variante del programma della riga di comando `info` che si ispira al browser della riga di comando Lynx e ti fa visualizzare le pagine informative con i link evidenziati con diversi colori. Utilizza `pinfo` basandoti sullo stesso schema del comando `info`. ```bash pinfo [OPZIONI] TEMA ``` **4. whatis** Il programma della riga di comando `whatis` serve per ricercare le parole chiave nel manuale. Visualizza il programma con una qualsiasi parola per ricercare nel manuale del tuo sistema operativo delle corrispondenze esatte. Se esiste un corrispettivo, `whatis` ne fornisce una breve descrizione nel terminale. ```bash whatis [OPZIONI] PAROLA CHIAVE ``` Anche `whatis` (`-w ‘*PAROLA CHIAVE’`) supporta segnaposti ed espressioni regolari (`-r`). ### Operazioni con le cartelle Utilizza i comandi Linux per effettuare operazioni con le cartelle per creare, eliminare e gestire cartelle e i relativi file sul tuo sistema dal terminale, oltre che per navigare nelle cartelle. Tra i comandi più importanti di questa categoria rientrano `cd`, `ls`, `mkdir`, `rmdir`. **1. chroot** Il comando `chroot` (abbreviazione di *change root*) viene utilizzato per eseguire un comando in un’altra root. L’istruzione `chroot` viene ad esempio usata per isolare i programmi critici dal resto del [file system](https://www.ionos.it/digitalguide/server/know-how/file-system/). Per aprire il programma sono richiesti i permessi di root e il comando si orienta allo schema seguente: ```bash chroot CARTELLA COMANDO ``` **2. mkdirhier** Con `mkdirhier` si può creare una gerarchia di cartelle completa con un unico comando: ```bash mkdirhier [OPZIONE] /home/user/cartella1/cartella2/cartella3 ``` Se `cartella1` e `cartella2` esistono già, `mkdirhier` crea solo la `cartella3`. Altrimenti vengono generate tutte e tre le cartelle. **3. tree** Mentre `ls` elenca solo il contenuto delle cartelle, con il comando `tree` si può mostrare la gerarchia completa delle cartelle, in modo ricorsivo, all’interno della struttura ad albero. La sintassi del comando è la seguente: ```bash tree [OPZIONI] [CARTELLA] ``` ### Operazioni con i file I comandi Linux di questa sezione consentono di eseguire diverse operazioni con i file direttamente dal terminale. Utilizza i comandi Linux di base come `cp`, `mv` e `rm` per copiare, spostare, rinominare o eliminare i file dal tuo sistema. **1. basename** Al comando `basename` viene trasmesso un percorso del file; è presente solo il nome del file senza il percorso antecedente. La sintassi del comando è la seguente: ```bash basename [OPZIONI] Percorso/al/file [SUFFISSO] ``` Il comando può essere ampliato a più file grazie alle opzioni. **2. comm** Utilizza il comando `comm` per comparare i file ordinati (ad esempio tramite `sort`) per righe. La sintassi alla base del programma è la seguente: ```bash comm [OPZIONI] FILE1 FILE2 ``` Il programma supporta tre opzioni: - -1 = per eliminare le righe uniche dal `FILE1` - -2 = per eliminare le righe uniche dal `FILE2` - -3 = per eliminare tutte le righe che sono contenute in entrambi i file **3. cut** Il comando `cut` ti consente di estrarre dalle righe di un testo di un file dei contenuti per colonne (per esempio file di log o CSV). La sintassi del comando è la seguente: ```bash cut [OPZIONI] FILE ``` La posizione precisa di una parte da estrarre viene definita tramite le opzioni `-b` (posizione dei byte), `-c` (posizione del carattere), `-d` (separatore) e `-f` (campo). **4. dirname** `dirname` è il contrario di `basename`. Il comando consente di estrarre una parte di percorso da un percorso del file e di visualizzarlo nel terminale senza indicare il nome del file. La sintassi del comando è la seguente: ```bash dirname [OPZIONI] percorso/al/file ``` **5. file** Con il comando `file` si possono ottenere le informazioni relative al tipo di file preso in considerazione. Lo schema alla base della visualizzazione è il seguente: ```bash file [OPZIONI] FILE ``` **6. lsof** Il [comando lsof su Linux](https://www.ionos.it/digitalguide/server/configurazione/lsof-su-linux/) sta per *list open files*, un programma che ti mostra nel terminale le informazioni sui file aperti, ordinati per PID (ID del processo o process ID). La visualizzazione nel terminale avviene secondo lo schema seguente: ```bash lsof [OPZIONI] ``` Visto che i sistemi compatibili con UNIX come Linux seguono il principio “Everything is a file“ (in italiano: “tutto è un file”), la lista mostrata dal comando `lsof` è conseguentemente lunga. Di solito vengono perciò utilizzate le opzioni per delimitare il risultato. **7. md5sum** Grazie al comando `md5sum` si possono calcolare e verificare le somme di controllo (checksum) in MD5 per i file. **8. paste** In maniera analoga a `cat` anche il comando `paste` consente la visualizzazione dei contenuti del file nello standard output. Tuttavia, mentre `cat` unisce solo i contenuti uno dietro l’altro, `paste` li collega per colonne. Lo schema di base del comando è il seguente: ```bash paste [OPZIONI] FILE1 FILE2 … ``` Grazie all’opzione `-d` si può scegliere in modo personalizzato quale separatore utilizza `paste`. Le schede vengono utilizzate come divisori standard. Tramite l’opzione `-s` (seriale) si può inoltre attivare una seconda modalità dove vengono trasmesse tutte le righe del primo file inserito nella prima riga dell’output. I dati di tutti gli altri file inseriti seguono in righe separate di output. Ogni riga dell’output contiene così solo i contenuti di un file inserito. **9. rename** `rename` è un programma della riga di comando che consente di rinominare file e cartelle tramite espressioni regolari. A differenza di `mv`, `rename` è adatto per le operazioni dei file in cui devono essere adattati parzialmente o interamente i nomi di più file. Utilizza `rename` ricorrendo allo schema seguente: ```bash rename [OPZIONI] 'ESPRESSIONE_REGOLARE' FILE ``` Le espressioni regolari seguono per le sostituzioni la seguente sintassi: ```bash s/SCHEMARICERCA/SOSTITUZIONE/MODIFICATORE ``` **10. shred** `shred` è un programma della riga di comando che consente la rimozione sicura dei file. Gli elementi selezionati vengono sovrascritti durante il processo di eliminazione e non si possono così neanche ripristinare con mezzi specifici. La sintassi generale del comando è la seguente: ```bash shred [OPZIONI] FILE ``` **11. sort** Utilizza il comando `sort` per ordinare liste di file e output di programmi per riga in ordine numerico e alfabetico. La sintassi generale del comando è la seguente: ```bash sort [OPZIONI] FILE ``` Il metodo di ordinamento si può regolare grazie alle opzioni: ad esempio quelle numeriche (`-n`), casuali (`-R`) o in successione inversa (`-r`). **12. split** Il comando `split` viene utilizzato per suddividere i file. La sintassi alla base è la seguente: ```bash split [OPZIONI] [INPUT [PREFISSO]] ``` Il segnaposto INPUT corrisponde al file che deve essere suddiviso. Il *PREFISSO* viene inserito per i nomi dei file parziali. Lo schema a cui questo processo di denominazione aderisce è il seguente: ```bash PREFISSOaa, PREFISSOab, PREFISSOac … ``` Se non viene definito nessun prefisso, `split` ricorre al prefisso standard `x`. Con l’opzione `-b` (byte) si possono definire le dimensioni dei file parziali. L’indicazione viene fatta a scelta in byte (b), kilobyte (k) o megabyte (m). Esempio: ```bash split -b 95m archivio.tgz split-archivio.tgz. ``` **13. stat** Con il comando `stat` (*status*) si possono visualizzare le marche temporali di accesso, di modifica dei file e delle cartelle selezionate. La sintassi generale del comando è la seguente: ```bash stat [OPZIONI] FILE ``` Il formato di output è regolabile grazie alle opzioni. **14. uniq** Il comando `uniq` viene solitamente utilizzato in combinazione con `sort` per ripulire i file ordinati dalle righe doppie. Nel seguente esempio il comando `sort` viene collegato tramite pipe (`|`) al comando `uniq` per ordinare prima di tutto il file e infine restituirlo senza righe doppie: ```bash sort file.txt | uniq ``` ### Opzioni di ricerca Linux offre diversi comandi con i quali si può cercare direttamente partendo dal terminale. **1. find** Il [comando `find` di Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-find-di-linux/) è un programma della riga di comando che serve per la ricerca dei file. La sintassi è la seguente: ```bash find [OPZIONI] [CARTELLA] [CONDIZIONEDIRICERCA][AZIONI] ``` La cartella inserita risulta la cartella di partenza della ricerca. La ricerca avviene così nella cartella standard e nelle sue sottocartelle. Se non inserisci nessuna cartella, `find` inizia la ricerca dalla cartella di lavoro corrente. Le opzioni ti permettono di definire dei criteri di ricerca e delle azioni. Come azione standard è preimpostata `-print` che indica la visualizzazione dei nomi dei file completi di tutti i risultati di ricerca nello standard ouput (di norma il terminale). Altre opzioni consentono di filtrare in base al nome del file, alla dimensione del file, all’ora di accesso, ecc. Queste opzioni sono elencate nella pagina man corrispondente. **2. locate** Anche il programma della riga di comando `locate` permette una ricerca di file dal terminale. A differenza di `find` non viene però ricercata la cartella dei file, ma un database aggiornato regolarmente e creato specificamente per questo motivo. Perciò `locate` fornisce dei risultati di ricerca in modo nettamente più veloce rispetto a `find`. Per ricercare nel database un file specifico, si utilizza `locate` ricorrendo allo schema seguente: ```bash locate SCHEMARICERCA ``` Lo schema di ricerca può contenere metacaratteri, come il segnaposto (`*`). Metti uno schema di ricerca di questo tipo tra virgolette per effettuare un’interpretazione tramite la shell. **3. tre-agrep** Anche `tre-agrep` serve per la ricerca di stringhe nei file di testo in base a schemi di ricerca. A differenza di `grep`, qui non vengono visualizzati solo termini con la dicitura esatta, ma anche quelli approssimativi che presentano un’inversione delle lettere o hanno dei caratteri mancanti. Il programma si appoggia alla libreria TRE e la rende utilizzabile nella riga di comando. La sintassi di `tre-agrep` corrisponde a quella del comando `grep`: ```bash tre-agrep [OPZIONI] SCHEMARICERCA FILE ``` Si può definire un numero massimo di errori tramite le opzioni. Nel seguente esempio viene tollerata al massimo una divergenza dallo schema di ricerca. ```bash tre-agrep -1 'Linux' test.txt ``` **4. updatedb** Una ricerca tramite `locate` è affidabile solo se il file `/var/lib/locatedb` viene continuamente aggiornato e presenta quindi tutte le ultime modifiche apportate. Il comando `updatedb` ti consente di aggiornare manualmente il database. Fai attenzione al fatto che per utilizzarlo hai bisogno dei permessi di root: ```bash updatedb ``` **5. whereis** Con il comando `whereis` localizzi i file binari, del codice sorgente o dei file del manuale relativo ai programmi selezionati. La sintassi generale del comando è la seguente: ```bash whereis [OPZIONI] PROGRAMMA ``` Grazie alle opzioni la ricerca si può limitare a precisi tipi di file o cartelle. **6. which** Se desideri individuare il file binario di un programma, utilizza il comando `which` ricorrendo allo schema seguente, per visualizzare il percorso nel terminale. ```bash which [OPZIONI] PROGRAMMA ``` Nella modalità standard `which` restituisce il primo file che viene trovato. Utilizza l’opzione `-a` per farti mostrare tutti i file che soddisfano il criterio di ricerca. ### Informazioni utente Utilizza i programmi della riga di comando della categoria seguente per visualizzare **informazioni più dettagliate sugli utenti registrati sul sistema**, sui gruppi di cui fanno parte e sui processi. **1. finger** Il programma della riga di comando `finger` serve a visualizzare le informazioni utente. Per fare ciò si inserisce il comando omonimo combinato con il nome utente desiderato: ```bash finger [Opzioni] [NOMEUTENTE] ``` Utilizza `finger` senza nome utente per visualizzare le informazioni sul tuo account. **2. groups** Il comando `groups` elenca le appartenenze ai gruppi di un account utente selezionato. Usa `groups` senza nome utente per elencare tutti i gruppi dei quali fa parte il tuo account utente. Utilizza il comando ricorrendo allo schema seguente: ```bash groups [OPZIONI] [NOMEUTENTE] ``` **3. id** Il comando `id` restituisce gli identificativi degli utenti e dei gruppi dell’account utente scelto. Individua i tuoi ID inserendo il comando senza nome utente. ```bash id [OPZIONI] [NOMEUTENTE] ``` Si può limitare l’output tramite opzioni. **4. last** Utilizza il comando `last` ricorrendo allo schema seguente per visualizzare una lista degli ultimi utenti che hanno effettuato l’accesso comprensivi della data di login e logout: ```bash last [OPZIONI] [NOMEUTENTE] ``` Le informazioni corrispondenti vengono visualizzate dal file `wtmp` contenuto in `/var/log/wtmp`. Se desideri solo richiedere le informazioni di un account specifico, inserisci il comando con il nome utente desiderato. **5. w** Il comando `w` fornisce una lista di tutti gli utenti che hanno effettuato l’accesso comprensivi di tutti i processi eseguiti da questi. Utilizza `w` insieme a un nome utente per limitare il comando a questo utente: ```bash w [OPZIONI] [NOMEUTENTE] ``` Il tipo e il formato dell’output si possono adattare tramite opzioni, se necessario. **6. who** Il comando `who` ti fornisce informazioni dettagliate sull’utente che ha effettuato l’accesso al sistema. La sintassi generale del comando è la seguente: ```bash who [OPZIONE] [FILEORIGINARIO] ``` Di norma `who` si riferisce ai dati sugli utenti che hanno effettuato l’accesso attualmente, presi dal file `/var/run/utmp`. Opzionalmente può essere indicato come fonte delle informazioni uno dei seguenti file. **7. whoami** Utilizza il comando `whoami` per visualizzare il tuo nome utente. ```bash whoami [OPZIONI] ``` ### Gestione dell’account utente Linux ti offre una serie di programmi con cui creare, eliminare e gestire direttamente dal terminale account utente e gruppi. Nella tabella qui di seguito trovi un riepilogo dei più importanti **comandi Linux per la gestione dell’account utente**. Inoltre, in questa categoria trovi i comandi Linux per il terminale che ti consentono di visualizzare i programmi con i permessi degli altri utenti, inclusi quelli del super utente root. **1. chfn** Il comando `chfn` (abbreviazione di *change finger*) ti permette di modificare le informazioni avanzate di un account utente come i nomi reali, il numero dell’ufficio, così come i numeri di telefono privati e aziendali. La sintassi generale di `chfn` è la seguente: ```bash chfn [OPZIONE "NUOVO VALORE"] [NOMEUTENTE] ``` Grazie alle opzioni `-f` (nome reale), `-r` (numero di telefono), `-w` (numero di servizio) e `-h` (numero privato) definisci quale informazione utente sarà sostituita con un nuovo valore. **2. chsh** Il comando `chsh` (abbreviazione di *change shell*) modifica il login della shell di un utente selezionato. Per l’inserimento orientati sullo schema seguente: ```bash chsh [OPZIONI] NOMEUTENTE ``` Puoi utilizzare l’opzione `-s` per cambiare la shell di login di un account utente. **3. deluser** Il programma della riga di comando `deluser` elimina tutte le voci di un account utente selezionato dai file dell’account di sistema. L’esecuzione di `deluser` richiede permessi di root e si orienta sullo schema seguente: ```bash deluser [OPZIONI] NOMEUTENTE ``` Se desideri cancellare la directory home o tutti i file dell’account utente, utilizza le opzioni `--remove-home` o `--remove-all-files`. Altre opzioni si trovano nella pagina del manuale del comando. **4. delgroup** Il comando `delgroup` (abbreviazione di *delete group*) elimina un gruppo utente già esistente. Per poter eseguire il comando sono necessari permessi di root. La sintassi generale di `delgroup` è la seguente: ```bash delgroup [OPZIONI] GRUPPO ``` **5. groupmod** Tramite `groupmod` si possono modificare il nome e l’ID del gruppo (GID) di un gruppo utente già esistente. Il comando viene utilizzato con permessi di root ricorrendo allo schema seguente: ```bash groupmod OPZIONI GRUPPO ``` Utilizza `groupmod` con l’opzione `-g` per modificare il GID. Usando l’opzione `-n` si sovrascrive il nome del gruppo. **6. newgrp** `newgrp` (abbreviazione di *new group*) è un comando che consente agli utenti che hanno effettuato l’accesso di cambiare il loro ID del gruppo corrente senza che debbano di nuovo fare il login o disconnettersi. La sintassi generale del comando è la seguente: ```bash newgrp [-] [GRUPPO] ``` Se a `newgrp` viene assegnato il parametro opzionale \[-\], il cambio di gruppo porta al riavvio dell’ambiente utente, di modo che l’utente debba effettuare l’accesso nuovamente. Se `newgrp` viene usato senza specificare un gruppo, viene utilizzato il gruppo standard indicato nella cartella `/etc/passwd`. **7. su** Anche il comando `su` consente un cambio temporaneo per eseguire i programmi con i permessi di un account utente di destinazione A differenza di `sudo`, viene richiesta la password dell’utente di destinazione e i comandi non vengono eseguiti direttamente. La sintassi generale del comando è la seguente: ```bash su [OPZIONI] [NOMEUTENTE] ``` Un’esecuzione senza NOMEUTENTE seleziona `root` come account utente di destinazione. **8. usermod** Il comando `usermod` ti dà la possibilità di modificare gli account utente già esistenti. Utilizza `usermod` con i permessi di root ricorrendo allo schema seguente: ```bash usermod [OPZIONI] NOMEUTENTE ``` Le opzioni consentono di definire le modifiche da apportare. Ad esempio, puoi usare l’opzione `-l NUOVO_NOME` per cambiare il nome dell’utente. Trovi altre opzioni nella pagina man corrispondente. ### Comandi di sistema Nella categoria “Comandi di sistema” trovi le direttive di Linux di base per l’amministrazione del sistema. Utilizza i seguenti comandi per riavviare e spegnere il sistema dal terminale, anche a tempo, se lo desideri. **1. logger** Utilizza `logger` ricorrendo allo schema seguente: ```bash logger "IL TUO MESSAGGIO" ``` Trovi il log di sistema su `/var/log/syslog`. **2. reboot** `reboot` è un comando che porta a un riavvio del sistema. Per riavviare il sistema, il comando deve essere eseguito con i permessi di root. ```bash reboot [OPZIONI] ``` **3. rtcwake** `rtcwake` è un comando che permette di avviare e arrestare il sistema a un orario determinato. La sintassi di base del comando è la seguente: ```bash rtcwake [OPZIONI] [MODALITÀ] [Tempo] ``` Scegli una modalità precisa (`-m MODALITÀ`) in cui deve essere impostato il sistema per un tempo preciso in secondi (`-s TEMPO IN SECONDI`). In alternativa, hai la possibilità di riportare il tuo sistema in funzione a un orario definito (`-t TEMPOUNIX`). ### Informazioni di sistema Nella categoria “Informazioni di sistema” abbiamo raccolto i programmi della riga di comando con i quali **visualizzi informazioni e avvisi di stato**, in modo da porter farti un’idea completa sullo stato del tuo sistema. **1. date** Il comando `date` ti fornisce l’ora del sistema comprensiva di data. ```bash date [OPZIONI] [FORMATOOUTPUT] ``` Se desideri lavorare con una data precisa (vedi `rtcwake`), puoi definirla con l’opzione `-d ‘DATA’`. Inoltre, vengono supportate diverse opzioni con cui si possono trasmettere informazioni sulla data e l’orario nel formato desiderato. **2. df** Utilizza il comando `df` (*disk free*) ricorrendo allo schema seguente: ```bash df [OPZIONI][FILE] ``` Se il comando viene utilizzato in combinazione con un file preciso, il sistema indica solo lo spazio libero della partizione in cui si trova il file. Altrimenti, viene visualizzato lo spazio libero sul disco rigido delle partizioni montate. L’opzione `-l` (*locale*) limita `df` ai file system locali. Sono supportate anche opzioni con cui è possibile personalizzare il formato di output. **3. dmesg** Il programma `dmesg` (abbreviazione di *display message*) fornisce avvisi del ring buffer del kernel dal terminale e ti consente così di localizzare gli errori hardware e dei driver. Utilizza `dmesg` ricorrendo allo schema seguente: ```bash dmesg [OPZIONI] ``` L’output `dmesg` comprende tutti gli avvisi del processo di boot ed è quindi lungo. Il programma della riga di comando viene perciò utilizzato spesso in combinazione con un pager come `more`, `less` o `tail`. **4. free** Il comando `free` visualizza l’uso della RAM. La sintassi generale è la seguente: ```bash free [OPZIONI] ``` Come risultato ottieni due dati: `Mem` (*Memory*) e `Swap`. Anche `free` supporta l’opzione `-h` con cui si può visualizzare l’uso della memoria in un formato leggibile per gli esseri umani. **5. hostname** Utilizza il comando `hostname` ricorrendo allo schema seguente per farti mostrare il nome del DNS del sistema. ```bash hostname [OPZIONI] ``` **6. uname** Il comando `uname` sta per *unix name* e viene utilizzato per visualizzare le informazioni di sistema relative al kernel. Il comando supporta diverse opzioni con le quali si può filtrare l’output secondo le informazioni desiderate, che si trovano nella voce man corrispondente. ```bash uname [OPZIONI] ``` **7. uptime** Se desideri sapere da quanto tempo il tuo sistema funziona dall’ultimo boot, utilizza il comando `uptime` ricorrendo allo schema seguente: ```bash uptime ``` **8. vmstat** Grazie allo strumento di monitoraggio `vmstat` si possono visualizzare le informazioni sulla memoria virtuale, sui processi di scrittura e di lettura sul disco fisso, così come sull’attività della CPU. Esegui `vmstat` ricorrendo allo schema seguente per visualizzare i valori medi dall’ultimo avvio del sistema. ```bash vmstat [OPZIONI] ``` In alternativa, `vmstat` offre una modalità di monitoraggio progressiva in cui i valori di sistema vengono visualizzati nell’intervallo di tempo desiderato in secondi. ```bash vmstat [OPZIONI] [INTERVALLO [RIPETIZIONI]] ``` ### Informazioni dell’hardware I comandi di Linux di questa categoria ti forniscono **informazioni più dettagliate sui componenti hardware** che sono alla base del tuo sistema. **1. lspci** Utilizza `lspci` (abbreviazione di *list pci*) ricorrendo allo schema seguente per farti mostrare informazioni più dettagliate sui dispositivi PCI. ```bash lspci [OPZIONI] ``` Le possibili opzioni sono contenute nelle pagine del manuale del sistema operativo. **2. lsusb** Utilizza `lsusb` (abbreviazione di *list usb*) per farti mostrare le informazioni dettagliate sui dispositivi USB nel terminale. ```bash lsusb [OPZIONI] ``` Le possibili opzioni sono contenute nelle pagine del manuale del sistema operativo. ### Gestione dei processi Su Linux con il nome di istanza si indica un programma in corso e che risulta quindi essere un processo. I seguenti comandi del terminale rientrano tra quelli standard della gestione dei processi e ti consentono di **controllare tutti i processi sul tuo sistema comodamente dal terminale** e di controllarli, se necessario. **1. chrt** `chrt` è un programma della riga di comando per il controllo dei processi avanzati che consente di individuare e modificare gli attributi in tempo reale (regola di scheduling e priorità) dei processi in corso o di eseguire i comandi e i relativi argomenti con specifici attributi in tempo reale. La sintassi generale del comando è la seguente: ```bash chrt [OPZIONI] [PRIORITÀ] PID/COMANDO [ARGOMENTI] ``` Utilizza `chrt` senza indicare una priorità e con l’opzione `-p`, per individuare gli attributi in tempo reale dei processi selezionati. Inoltre, `chrt` dà la possibilità di modificare o definire la regola di scheduling di un processo in corso o avviato nuovamente grazie alle opzioni. Per ulteriori informazioni al riguardo, consulta la voce man corrispondente. **2. ionice** Il comando `ionice` viene utilizzato per influenzare la priorità di un processo che utilizza l’interfaccia I/O del kernel. La sintassi generale del comando è la seguente: ```bash ionice [OPZIONI] COMANDO ``` Per poter eseguire `ionice`, servono i permessi di root. Il comando distingue tre classi di scheduling che vengono trasmesse tramite l’opzione `-cNUMERO`. I valori numerici possibili sono 1, 2 e 3. - 1 = Real Time: l’azione I/O viene eseguita subito. - 2 = Best Effort: l’azione I/O viene eseguita il più velocemente possibile. - 3 = Idle: l’azione I/O viene eseguita solo quando nessun altro processo richiede un tempo I/O. **3. nohup** Non appena la sessione del terminale viene chiusa (ad esempio tramite `exit`), solitamente vengono anche terminati automaticamente tutti i processi correlati. Il [comando nohup su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-nohup-su-linux/) (abbreviazione di *no hangup*) separa un processo dalla sessione corrente e gli consente di farlo continuare anche dopo che ci si è disconnessi dal sistema. ```bash nohup COMANDO ``` **4. pidof** Il programma della riga di comando `pidof` restituisce i numeri identificativi del processo (PID) di tutti i processi di un programma. Individua i PID tramite `pidof` ricorrendo allo schema seguente: ```bash pidof [OPZIONI] PROGRAMMA ``` Se desideri farti mostrare solo il primo ID del processo, utilizza `pidof` insieme all’opzione `-s` (abbreviazione di *single shot*). **5. pidkill** Come `kill` anche `pkill` invia un segnale a un processo selezionato. L’indirizzamento così non avviene tramite il PID. Al suo posto viene trasmessa una parola chiave che viene confrontata con il nome di un processo in corso e che può essere formulata come un’espressione regolare. Anche `pkill` trasmette il segnale standard TERM, a patto che non venga definito nessun altro segnale. La sintassi generale del comando è la seguente: ```bash pkill [OPZIONI] [-SEGNALE] [PAROLACHIAVE] ``` Grazie ad altre opzioni il comando si può limitare ai processi di un utente specifico (`-U UID`), ai processi figlio di un processo genitore specifico (`-P PID`), ai processi più nuovi (`-n`) o a quelli più vecchi (`-o`). **6. pstree** Utilizza `pstree` per farti mostrare tutti i processi in corso in una struttura ad albero. La sintassi generale del comando è la seguente: ```bash pstree [OPZIONI] ``` Il formato e la portata dell’output possono essere personalizzati con varie opzioni. **7. renice** Il comando `renice` consente di regolare la priorità di un processo in corso. La sintassi generale è la seguente: ```bash renice PRIORITÀ [OPZIONI] ``` L’indirizzamento avviene grazie a opzioni tramite l’ID del processo (`-p PID`), gli ID del gruppo (`-g GID`) o un nome utente (`-u UTENTE`). **8. sleep** Il [comando sleep su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-sleep-su-linux/) ti consente di interrompere la sessione corrente nel terminale per il periodo di tempo indicato. La sintassi generale del comando è la seguente: ```bash sleep NUMERO[SUFFISSO] ``` Se utilizzi `sleep` senza il suffisso, il numero indicato viene interpretato come un arco di tempo in secondi (s). In alternativa, hai la possibilità di interrompere la sessione nel terminale per dei minuti (m), delle ore (h) o dei giorni (d). **9. taskset** Il comando `taskset` serve per il controllo avanzato dei processi, che viene usato sui sistemi a più processori per assegnare processi o comandi a processori specifici. Il comando richiede permessi di root e utilizza uno dei seguenti schemi: ```bash taskset [OPZIONI] MASCHERA COMANDO taskset [OPZIONI] -p PID ``` L’assegnazione di un processo/comando al processore avviene grazie a una maschera bit esadecimale. Visto che una simile assegnazione tramite una maschera di bit è poco intuitiva, `taskset` viene utilizzato solitamente con l’opzione `-c` (`--cpu-list`) che consente un’assegnazione numerica dei processori (ad esempio 0, 5 7, 9-11). ### Pager Desideri tenere tutto sotto controllo anche nel caso di file con più pagine? Con un programma della riga di comando dalla categoria “Pager”, selezioni miratamente quali paragrafi farti mostrare nel terminale e, se necessario, scorri nelle pagine del file in modo interattivo. **1. head** Il [comando head di Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-head-di-linux/) viene utilizzato per visualizzare la prima parte di un file. La sintassi generale del comando è la seguente: ```bash head [OPZIONI] File ``` Utilizza l’opzione `-n NUMERO_RIGHE` per definire quante righe devono essere visualizzate a partire dalle prime. **2. less** Il comando della riga di comando `less` consente di mostrare il contenuto di un file di testo nel terminale. La sintassi generale è la seguente: ```bash less [OPZIONI] FILE ``` L’output viene visualizzato automaticamente in modo interattivo, così da consentirti di sfogliare il documento selezionato o di procedere con una ricerca tramite parole chiave. Il tasto \[Q\] termina la modalità di lettura interattiva. Altri tasti di controllo e possibili opzioni sono contenute nelle pagine del manuale del sistema operativo. **3. tail** Mentre, solitamente, `head` indica le prime 10 righe di un file selezionato, il [comando tail di Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-tail-di-linux/) ne mostra le ultime 10 righe. Entrambi i pager vengono utilizzati ricorrendo allo stesso schema (vedi `head`). ### Editor Su Linux non hai bisogno di nessun programma grafico di elaborazione dei testi per adattare i file di configurazione, modificare parti di codici o scrivere dei brevi appunti. I **semplici editor di testo** si possono richiamare facilmente e senza ritardi dal terminale. Di seguito ti presentiamo tre programmi che dovresti conoscere. **1. emacs** *Emacs* è un editor di testo multipiattaforma che è ampliabile a proprio piacimento per mezzo di un’interfaccia di programmazione. Di solito si avvia con l’interfaccia grafica, può però essere aperto anche con l’opzione `--no-window-system` nel terminale. ```bash emacs --no-window-system ``` Emacs dispone di un tutorial integrato che si apre tramite la combinazione di tasti \[CTRL\] + \[H\], \[T\]. **2. nano** *Nano* è un editor di testo basato sul terminale. La varietà di funzioni offerta è inferiore rispetto ad altri editor simili (come *Vim*), si contraddistingue però per un’usabilità particolarmente user-friendly. La sintassi generale del programma è la seguente: ```bash nano [OPZIONI] FILE ``` Il programma apre il file indicato in una finestra di editing nel terminale. Se apri Nano senza dare alcun nome al file, può venire creato un nuovo file di testo che viene salvato nella cartella selezionata attualmente. **3. vim** Vim (abbreviazione di *Vi Improved*) è uno sviluppo dell’editor di testo *Vi*. Si distingue per le innumerevoli estensioni, come l’evidenziazione della sintassi, un sistema di aiuto completo, scripting nativo, l’autocompletamento del codice e una selezione del testo visiva. Il programma open source ti offre diverse modalità di funzionamento per l’elaborazione di file esclusivamente di testo e può venire utilizzato a proprio piacimento dal terminale o come applicazione autonoma con un’interfaccia grafica (*GVim*). Un campo di applicazione principale del programma è l’elaborazione del codice del programma. Se avvii Vim dalla console, il suo utilizzo avviene tramite tastiera. Solitamente il programma viene aperto con un file di testo ricorrendo allo schema seguente. ```bash vim [OPZIONI] FILE ``` Il programma `vimtutor` offre un’introduzione completa a Vim che avvii sempre dalla riga di comando. Inoltre, trovi maggiori informazioni sull’installazione e le diverse modalità di funzionamento del programma nel nostro articolo di base sull’[editor per Linux Vim](https://www.ionos.it/digitalguide/server/tools-o-strumenti/editor-per-linux-elaborare-il-codice-con-vim/). ### Gestione della rete Su Linux anche la **gestione della rete** avviene comodamente dal terminale. Indipendentemente dal fatto che verifichi la connessione, richiedi le informazioni DNS, configuri le interfacce o desideri trasmettere i file a un altro computer nella rete, con i seguenti programmi basta un singolo comando per attuare concretamente il tuo proposito. **1. arp** Il programma della riga di comando `arp` ti consente di aprire e manipolare la cache [ARP](https://www.ionos.it/digitalguide/server/know-how/che-cose-arp-risoluzione-dellindirizzo-in-rete/) del tuo sistema operativo. Utilizza `arp` senza modificatore per farti mostrare il contenuto della tabella ARP nel terminale. ```bash arp [OPZIONE] ``` Alternativamente hai la possibilità di limitare l’output con le opzioni o creare o eliminare voci: - `-a NOMEHOST` = limita l’output alle voci per specifici [nomi host](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/hostname/) (in alternativa all’indirizzo IP) - `-s NOMEHOST INDIRIZZO_MAC` = crea una voce ARP con il nome host e l’indirizzo MAC specificati - `-d NOMEHOST` = cancella la voce ARP **2. iw** Il programma della riga di comando `iw` serve per la configurazione di interfacce Wi-Fi e si è affermata come un’alternativa più attuale a `iwconfig`. Alla base del comando si trova una sintassi simile a quella di `ip`: ```bash iw [OPZIONI] OGGETTO [COMANDO] ``` Dei possibili oggetti sono: - dev NOME\_INTERFACCIA = interfaccia di rete - phy NOME\_DEL\_DISPOSITIVO = dispositivo Wi-Fi (tramite nome) - phy#INDICE\_DEL\_DISPOSITIVO = dispositivo Wi-Fi (tramite indice) - reg = Regulatory Agent (agente di regolazione) per la configurazione delle impostazioni dei paesi e delle regioni Trovi un riepilogo dei comandi e delle opzioni possibili nella voce man corrispondente. **3. nslookup** Come `dig` anche [nslookup](https://www.ionos.it/digitalguide/server/tools-o-strumenti/nslookup/) serve per la risoluzione dei nomi. Il programma della riga di comando è disponibile in due modalità: interattiva e non interattiva. Se desideri utilizzare `nslookup` in modalità non interattiva, richiama il programma in combinazione con un nome host o un indirizzo IP. ```bash nslookup [OPZIONI] [HOST/IP] ``` Per avviare la modalità interattiva, inserisci il comando `nslookup` nel terminale senza alcuna aggiunta e poi digita i nomi host o indirizzi IP per visualizzare gli indirizzi IP o i nomi host associati. Visto che il programma è **ufficialmente datato**, viene consigliato agli utenti di ricorrere piuttosto a `dig`. **4. rsync** Il programma della riga di comando `rsync` consente di sincronizzare i file in locale o all’interno di una rete. Perciò vengono prima di tutto confrontate le dimensioni e il tempo di modifica dei file coinvolti. La sintassi del comando è la seguente: ```bash rsync [OPZIONI] ORIGINE DESTINAZIONE ``` Il comando `rsync` viene solitamente eseguito con l’opzione `–a` che si occupa del fatto che tutte le sottocartelle e i link simbolici vengono copiati, mantenendo inalterati tutti i permessi utente. **5. scp** Con il [comando scp di Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-scp-di-linux/) (abbreviazione di *secure copy*) hai direttamente a disposizione dal terminale un altro programma per la trasmissione sicura dei dati nella rete: infatti `scp` copia i dati da un computer a un altro e utilizza così anche il protocollo di rete SSH. Il client funziona un po’ come l’opzione dei file `cp`, ma viene utilizzato su ogni piattaforma ricorrendo alla seguente sintassi: ```bash scp [OPZIONI] FILE [[user@]remote_host:]PERCORSO ``` Inserendo il percorso del computer rimosso vengono anteposti il nome utente e il rispettivo nome host. Si possono indirizzare esplicitamente i file locali tramite percorsi relativi o assoluti. Esempio: ```bash scp /home/max/images/image.jpg max@example.com:/home/max/archive ``` Altre opzioni ti offrono la possibilità di apportare modifiche alla modalità di trasmissione e alle impostazioni di crittografia. **6. tty** Il comando `tty` restituisce il nome del file del terminale che è definito come input standard. La sintassi generale del comando è la seguente: ```bash tty [OPZIONI] ``` ### Archiviare e comprimere Linux offre diverse tecnologie con cui si possono comprimere e raccogliere i file in archivi. Bisogna prestare però attenzione al fatto che non tutti gli **archivi sono compressi**. Così `tar`, un programma per l’archiviazione dei file, viene solitamente combinato con i programmi di compressione, come `gzip`, `bzip2` o `xz`. **1. gzip** Con `gzip` si indica un programma con il quale si possono comprimere e decomprimere i file comodamente tramite la riga di comando. La sintassi generale del comando è la seguente: ```bash gzip [OPZIONI] FILE ``` Fai attenzione che `gzip`, di norma, elimina il file originario durante il procedimento di compressione. Si può impedire con l’opzione `-k`. Il programma può essere applicato su più file allo stesso tempo. Così viene convertito ogni file in uscita in un file gz autonomo. Se desideri scrivere più file in un archivio compresso comune, utilizza `gzip` insieme al programma di archiviazione `tar`. Se desideri decomprimere un file gz, utilizza il comando `gzip` con l’opzione `-d`. **2. bzip2** Un’alternativa amata a `gzip` è rappresentata dal programma della riga di comando `bzip2` che utilizza la stessa sintassi di `gzip`, ma si basa su un processo di compressione a tre livelli che consente un grado di compressione nettamente più elevato. I file che sono stati compressi con `bzip2`, presentano l’estensione `.bz2`. Utilizza `bzip` secondo lo schema seguente per comprimere i file. ```bash bzip2 [OPZIONI] FILE ``` Anche `bzip2` si può applicare agli archivi `tar`. La decompressione avviene analogamente a `gzip` grazie all’opzione `-d`. **3. xz** Il programma della riga di comando `xz` converte i file nell’omonimo formato di compressione dati `xz`. Il programma si basa sullo stesso schema di `gzip` e `bzip2`. ```bash xz [OPZIONI] FILE ``` I file che sono stati compressi con `xz` presentano l’estensione `.xz`. La decompressione avviene come su `gzip` e `bzip` con l’opzione `-d`. In alternativa, può essere utilizzato il comando `unxz`. Analogamente ai file `gz` e `bz2`, anche i file di archivio `xz` non sono dei file di archivio. Se desideri scrivere più file nello stesso file compresso xz, devi ricorrere anche in questo programma di compressione allo strumento di archiviazione `tar`. **4. cpio** Con cpio (abbreviazione di *copy in, copy out*) si indica un programma di archiviazione con il quale si possono scrivere dati in un file di archivio (.cpio) ed estrarlo da questo. ### Gestione della partizione Se su Linux desideri accedere a un file system su un’altra partizione, questo deve essere prima di tutto collegato alla struttura delle cartelle del tuo sistema operativo. Si parla di “mount” (o “montatura”) di una partizione. Se necessario, il processo può avvenire tramite l’interfaccia utente grafica. In alternativa, vi sono i programmi della riga di comando come `lsblk`, `blkid` e `mount` che richiedono informazioni sui dispositivi a blocchi e li montano o smontano, se necessario. **1. lsblk** Utilizza il comando `lsblk` (abbreviazione di *list block devices*) per farti mostrare tutti i dispositivi a blocchi e le partizioni come struttura ad albero. Non devono però essere collegati per forza. La seguente sintassi è alla base del comando: ```bash lsblk [OPZIONI] ``` Se necessario, si può modificare il risultato grazie all’opzione `-o` (*--output*) e una lista degli attributi desiderati personalizzati per richiedere informazioni aggiuntive come il numero di identificazione (UUID), il file system (FSTYPE) o lo stato (STATE). Nelle impostazioni standard i dispositivi di archiviazione vuoti vengono saltati. Se desideri inserire anche questi nel riepilogo, utilizza il comando `lsblk` insieme all’opzione `-a` (*--all*). Per richiedere solo le informazioni su un dispositivo preciso, utilizza `lsblk` ricorrendo allo schema seguente: ```bash lsblk [OPZIONI] DISPOSITIVO ``` **2. blkid** In modo simile a `lsblk`, anche `blkid` fornisce informazioni sui dispositivi a blocchi collegati. Utilizza `blkid` ricorrendo allo schema seguente per richiedere il numero di identificazione (`UUID`) e il tipo di file system (`TYPE`) di tutti i dispositivi a blocchi collegati. ```bash blkid [OPZIONI] ``` Ottieni un risultato tabellare grazie all’opzione `-o` combinata con il valore `list`. ```bash blkid [OPZIONI] DISPOSITIVO ``` ### Varie Di seguito trovi una lista di altri comandi standard su Linux che non sono classificabili in nessun’altra delle categorie presentate. **1. alias** L’interazione con la shell avviene solitamente tramite comandi che possono essere utilizzati per richiamare **programmi a riga di comando** con lo stesso nome. Si utilizza una chiamata di programma per ogni azione che si desidera eseguire tramite il terminale. Il [comando alias su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-alias-su-linux/) consente di definire nomi brevi per le chiamate ai programmi. Utilizza `alias` secondo il seguente schema: ```bash alias NOMIGNOLO= 'COMANDO' ``` Sostituisci il segnaposto COMANDO con un comando qualsiasi comprensivo di opzioni. Questo viene collegato con la sequenza di numero impostata per il segnaposto NOMIGNOLO. **2. at** Apri il programma della riga di comando `at` basandoti sullo schema seguente per eseguire un comando programmato. ```bash at INDICAZIONETEMPORALE ``` Infine, dai il comando e chiudi la modalità interattiva con \[CTRL\] + \[D\]. **3. cal** Utilizza `cal` basandoti sullo schema seguente per farti mostrare il calendario nel terminale. ```bash cal [OPZIONI] [[MESE] anno] ``` **4. pr** Utilizza il programma della riga di comando `pr` per preparare i file di testo per la stampa. La sintassi generale del comando è la seguente: ```bash pr [OPZIONI] File ``` Nell’impostazione standard `pr` genera una pagina di header che comprende il nome del file, la data corrente e il numero delle pagine. **5. script** Il programma della riga di comando `script` ti permette di registrare una sessione del terminale nel file `typescript`. Se su `typescript` si rileva già una registrazione di una sessione precedente, questa verrà sovrascritta. La registrazione parte automaticamente aprendo il programma: ```bash script ``` Utilizza la combinazione di tasti \[CTRL\] + \[D\] per terminare la registrazione. Se desideri salvare la registrazione in un altro file, invece che su `typescript`, apri `script` insieme al nome del file o al percorso. **6. seq** Utilizza il comando `seq` per farti restituire una serie di numeri sullo standard output. Definisci così un valore iniziale, uno finale e un incremento a scelta. ```bash seq [OPZIONI] VALOREINIZIALE INCREMENTO VALOREFINALE ``` **7. tasksel** Il programma della riga di comando tasksel serve a facilitare l’installazione delle applicazioni standard (server di posta elettronica, server DNS, server OpenSSH, server LAMP, ecc.). Utilizza lo strumento per installare automaticamente i pacchetti e i programmi necessari per svolgere un compito nella giusta sequenza. Apri `tasksel` con l’opzione `--list-tasks` per farti mostrare una lista di tutte le applicazioni standard disponibili. ```bash tasksel --list-tasks ``` Se desideri richiamare altre informazioni su un’applicazione standard presente in questa lista, utilizza `tasksel` con l’opzione `--task-desc` e il relativo compito. Se desideri farti elencare tutti i pacchetti che appartengono al compito “mail-server“, utilizza `tasksel` insieme all’opzione `--task-packages`. Avvia un’installazione di tutti i pacchetti di un’applicazione standard grazie al sottocomando `install`. Per fare ciò è necessario disporre dei permessi di root. **8. tee** Il [comando tee di Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-tee-di-linux/) è un programma della riga di comando con cui si può raddoppiare l’output di un programma. Così viene inoltrato un output allo standard output e un altro viene scritto nel file trasmesso dal comando `tee`. ```bash tee [OPZIONI] FILE ``` Solitamente `tee` viene utilizzato in combinazione con l’operatore pipe (`|`). ```bash ls | tee esempio.txt ``` **9. time** Utilizza il comando `time` basandoti sullo schema seguente per individuare il tempo di esecuzione dei programmi, che avvii tramite il terminale. ```bash time [OPZIONI] Comando [ARGOMENTI] ``` **10. tr** Utilizza `tr` per eliminare una quantità qualsiasi di caratteri o sostituirla con un’altra. Perciò `tr` legge il flusso di dati dello standard input e lo scrive con la modifica desiderata nello standard output. Se deve essere sostituita una quantità di caratteri con un’altra, `tr` viene utilizzato con due argomenti. ```bash tr OPZIONE QUANTITÀDICARATTERI1 QUANTITÀDICARATTERI2 ``` Il secondo argomento (QUANTITÀDICARATTERI2) sostituisce il primo (QUANTITÀDICARATTERI1). Se desideri eliminare una sequenza di caratteri, utilizza `tr` con l’opzione `–d` e trasmetti la sequenza da eliminare come argomento. ```bash tr -d QUANTITÀDICARATTERI ``` Il programma della riga di comando si utilizza solitamente insieme agli operatori di reindirizzamento (< e >) per apportare modifiche ai file. ```bash tr 'a-z' 'A-Z' < esempio1.txt > esempio2.txt ``` `tr` legge il contenuto del file `esempio1.txt`, sostituisce le lettere minuscole da “a” a “z” con le corrispettive maiuscole e scrive l’output nel file `esempio2.txt`. **11. wall** Il programma della riga di comando `wall` ti consente di recapitare un messaggio a tutti quegli utenti che hanno effettuato l’accesso al sistema. Per inviare il messaggio, si avvia il programma con il comando seguente: ```bash wall ``` Conferma il comando con \[Invio\] e inserisci il tuo messaggio. Anche questo viene confermato con \[Invio\] e inviato tramite la combinazione di tasti \[CTRL\]+\[D\]. Tutti gli utenti registrati sul sistema ricevono il tuo messaggio nel terminale come messaggio broadcast. Attenzione: per poter ricevere messaggi devi assegnare agli altri utenti il permesso di scrittura nel tuo terminale. Utilizza perciò il comando `mesg`. Se desideri inviare i contenuti dei file a tutti gli utenti registrati, utilizza `wall` insieme all’operatore di reindirizzamento e al relativo nome del file: ```bash wall < NOMEFILE ``` **12. watch** Il programma della riga di comando `watch` ti consente di eseguire un comando a intervalli di tempo regolari. La seguente sintassi è alla base del programma: ```bash watch [OPZIONI] COMANDO ``` Definisci l’intervallo temporale, in cui il comando trasmesso viene richiamato periodicamente con `watch`, tramite l’opzione `-n SECONDI`. Si può terminare `watch` tramite la combinazione di tasti \[CTRL\] + \[C\]. **13. wc** Il [comando wc su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-wc-su-linux/) (abbreviazione di *word count*) ti restituisce, se necessario, il numero delle righe, delle parole, delle lettere, dei caratteri e/o dei byte presenti in un file di testo. La sintassi generale del comando è la seguente: ```bash wc [OPZIONI] FILE ``` Se `wc` viene aperto senza opzioni, l’output si basa sullo schema `RIGHE PAROLE CARATTERI FILE`. Per un output filtrato il programma della riga di comando supporta le opzioni: `-l` (righe), `-c` (byte), `-m` (caratteri), `-L` (lunghezza della riga più lunga) e `-w` (parole). **14. xargs** Il [comando xargs su Linux](https://www.ionos.it/digitalguide/server/configurazione/comando-xargs-su-linux/) ti consente di trasmettere a un comando l’output di un comando precedente come argomento. Solitamente viene utilizzato l’operatore di reindirizzamento pipe (`|`). Utilizza `xargs` basandoti sulla seguente sintassi: ```bash COMANDO1 | xargs [OPZIONI] COMANDO2 ``` `xargs` viene ad esempio utilizzato in combinazione con il comando `find`. Nell’esempio seguente `find` individua nella cartella attuale tutti i file che si abbinano allo schema di ricerca `\*.tmp` e restituisce il loro nome nello standard output. Là i nomi dei file vengono accettati da `xargs` e trasmessi come argomenti al comando `rm`. ```bash find . -name '*.tmp' | xargs rm ``` Il riepilogo proposto qui non ha alcuna pretesa di completezza, ma comprende solo i comandi Linux principali, mostrati con una selezione di alcuni esempi di applicazione per semplificare il lavoro giornaliero con i sistemi operativi simili a Unix. Nelle pagine del manuale del tuo sistema operativo è presente una descrizione completa dei programmi della riga di comando qui presentati e di tutti gli altri comandi. Una versione online di queste pagine di aiuto e della documentazione viene messa a disposizione nell’ambito del [progetto delle man pages di Linux](https://www.kernel.org/doc/man-pages/ "Progetto delle man pages di Linux di Michael Kerrisk"), create da Michael Kerrisk. This is a markdown version of: [https://www.ionos.it/digitalguide/server/configurazione/i-comandi-principali-di-linux-una-spiegazione/](https://www.ionos.it/digitalguide/server/configurazione/i-comandi-principali-di-linux-una-spiegazione/) for AI/LLM consumption.