Guida ai comandi da terminale: differenze tra le versioni

Vai alla navigazione Vai alla ricerca

Guida ai comandi da terminale (visualizza wikitesto)

Versione delle 16:48, 11 feb 2014

68 603 byte rimossi ,  11 feb 2014
split
(split)
Riga 1: Riga 1:
{{Versioni compatibili}}
{{Versioni compatibili}}
= Introduzione =
== Introduzione ==
Quale utente Linux non ha mai avuto bisogno di una raccolta di comandi base per gestire il suo sistema operativo al migliore dei modi da terminale?<br>
Quale utente Linux non ha mai avuto bisogno di una raccolta di comandi base per gestire il suo sistema operativo al migliore dei modi da terminale?<br>
Questa pagina nasce in loro supporto. Qui proverò a creare una raccolta dei comandi base più utili, in modo da venire in aiuto di coloro che ne cercano uno per compiere la rispettiva operazione.<br>
Questa pagina nasce in loro supporto. Qui proverò a creare una raccolta dei comandi base più utili, in modo da venire in aiuto di coloro che ne cercano uno per compiere la rispettiva operazione.<br>
{{ Warningbox | Nella guida viene talvolta usata l'opzione <code>-r</code> abbinata ad alcuni comandi. È utile rimarcare e tenere a mente che la ricorsività del comando derivante dall'utilizzo di questa opzione può avere effetti distruttivi sul sistema e che va quindi usata con cognizione di causa.}}
{{ Warningbox | Nella guida viene talvolta usata l'opzione <code>-r</code> abbinata ad alcuni comandi. È utile rimarcare e tenere a mente che la ricorsività del comando derivante dall'utilizzo di questa opzione può avere effetti distruttivi sul sistema e che va quindi usata con cognizione di causa.}}


= Gestione di repository e pacchetti =
== [[Guida ai comandi da terminale - Gestione di repository e pacchetti|Gestione di repository e pacchetti]] ==
== Definizione di repository ==
== [[Guida ai comandi da terminale - Operazioni con programmi non presenti nei repository|Operazioni con programmi non presenti nei repository]] ==
Il repository è un archivio ordinato dove sono raccolti i pacchetti software della vostra distribuzione (siano essi pacchetti binari o sorgenti), in modo ben organizzato e costantemente aggiornato. Da questi repository è possibile installare tutto il software che vi occorre per la vostra Debian. Per ottenere più informazioni potete dirigervi [[Indice_Guide#Gestione_dei_Pacchetti | qui]] .
== [[Guida ai comandi da terminale - Gestione di file e directory|Gestione di file e directory]] ==
== [[Guida ai comandi da terminale - Gestione utenti|Gestione utenti]] ==
== [[Guida ai comandi da terminale - Compiere operazioni con sudo|Compiere operazioni con sudo]] ==
== [[Guida ai comandi da terminale - Gestione del sistema|Gestione del sistema]] ==
== [[Guida ai comandi da terminale - Gestione del File System|Gestione del File System]] ==
== [[Guida ai comandi da terminale - Gestione dell'hardware|Gestione dell'hardware]] ==
== [[Guida ai comandi da terminale - Varie e approfondimenti|Varie e approfondimenti]] ==


== Modifica della lista dei repository ==
La lista dei [[repository]] configurati per il vostro sistema si trova nel file <code>/etc/apt/sources.list</code>. Per modificarla basta aprire il file con un qualsiasi editor di testo. Quindi, se vogliamo aprirlo con Gedit (editor di testo visuale; occorre avere un ambiente grafico installato) digiteremo:
<pre>
gedit /etc/apt/sources.list
</pre>
Se vogliamo aprirlo con Nano (editor di testo su console) digiteremo:
<pre>
nano /etc/apt/sources.list
</pre>
Con Vim (altro editor di testo per console):
<pre>
vim /etc/apt/sources.list
</pre>
E così via. Vi ricordo che questo file ha i permessi di scrittura riservati all’amministratore (root) o ad un sudoer. Se avete impostato al vostro utente i permessi di sudoer, o siete su Ubuntu, vi basterà aggiungere sudo prima di ogni comando (<code>sudo gedit</code> invece di <code>gedit</code>, ad esempio) per avere i permessi di scrittura e poter salvare il file. Se siete root, potete copiare ed incollare i comandi citati sopra sul terminale senza modificarli nella sintassi.


== Aggiornamento del sistema operativo ==
Per aggiornare Debian con gli ultimi pacchetti disponibili per la vostra versione dovrete lanciare due comandi:
<pre>
apt-get update
apt-get upgrade
</pre>
Queste operazioni possono essere fatte solo da un sudoer o da un root.
== Installazione di un programma o di un pacchetto ==
Se vogliamo installare un programma o un pacchetto presente nei repository a vostra disposizione, ci basterà semplicemente digitare da terminale:
<pre>
apt-get install programma
</pre>
oppure:
<pre>
aptitude install programma
</pre>
Se vogliamo installare, ad esempio, VLC, digitiamo:
<pre>
apt-get install vlc
</pre>
Il nome del programma, e la possibilità di installarlo in questo modo, dipendono dalla presenza dei pacchetti nella vostra lista repository e dal loro nome. Una lista completa dei pacchetti repo presenti nel vostro sistema la avete andando su Sistema –> Amministrazione –> Gestore pacchetti Synaptic, e per poterli installare ovviamente avrete bisogno di permessi di sudoer o di [[root]].
Se il vostro programma non compare nell'elenco, ma avete trovato in giro dei repository che lo includono (righe di testo), per utilizzarle dovrete integrarle nella vostra lista repository, seguite il paragrafo “Modifica della lista dei repository”.
== Ricerca di un pacchetto e informazioni ==
Volete installare un programma, ma non conoscete il nome del pacchetto con il quale è stato inserito nei repository di Debian?<br>
Il seguente comando può esservi di aiuto:
<pre>
apt-cache search nome_pacchetto
</pre>
Il comando esegue una ricerca full text all'interno dei nomi e delle descrizioni dei pacchetti dei repository abilitati. Ad esempio:
<pre>
apt-cache search tellico
</pre>
ci restituirà:
<pre>
alexandria - a GNOME application for managing book collections
tellico - collection manager for books, videos, music
tellico-data - collection manager for books, videos, music [data]
tellico-scripts - collection manager for books, videos, music [scripts]
</pre>
Quindi possiamo ottenere varie informazioni sul pacchetto che cerchiamo con:
<pre>
apt-cache show nome_pacchetto
</pre>
Ad esempio:
<pre>
apt-cache show tellico
</pre>
Elencare le sole dipendenze:
* dirette (necessarie)
<pre>
apt-cache depends tellico
</pre>
* indirette (raccomandate o utili a seconda del tipo di richiesta o configurazione del sistema)
<pre>
apt-cache rdepends tellico
</pre>
Informazioni su quale repository abbia la priorità (utile nella gestione del pinning):
<pre>
apt-cache policy tellico
</pre>
Visionare il changelog prima di aggiornare il pacchetto:
<pre>
apt-get changelog tellico
</pre>
Sapere perché un pacchetto è installato o perché andrebbe installato:
<pre>
aptitude why tellico
</pre>
Sapere perché un pacchetto non è installato e se genera conflitti:
<pre>
aptitude why-not tellico
</pre>
== Disinstallazione base di un programma o di un pacchetto ==
Si utilizza lo stesso strumento visto prima per l'installazione dei pacchetti. Digitiamo quindi:
<pre>
apt-get remove programma
</pre>
Se vogliamo rimuovere VLC:
<pre>
apt-get remove vlc
</pre>
Questo tipo di disinstallazione disinstalla il programma, ma lascia all’interno del sistema i file di configurazione del programma. Per poter eseguire il comando di disinstallazione descritto avrete bisogno di permessi di sudoer o di root.
== Disinstallazione completa di un programma o di un pacchetto ==
La differenza tra questa disinstallazione e quella base consiste nella liberazione completa dello spazio occupato dal programma che vogliamo rimuovere dal sistema. Con questo tipo di disinstallazione, infatti, oltre a disinstallare il programma dal sistema, cancelleremo anche i pacchetti e i relativi file di configurazione, che altrimenti non verrebbero rimossi, e che occuperebbero spazio inutile nel caso in cui non avessimo alcuna intenzione di reinstallare in futuro il programma. Digitiamo:
<pre>
apt-get remove --purge programma
</pre>
Oppure:
<pre>
apt-get purge programma
</pre>
Oppure:
<pre>
aptitude purge programma
</pre>
Se vogliamo rimuovere VLC:
<pre>
apt-get remove --purge vlc
</pre>
O in alternativa:
<pre>
apt-get purge vlc
</pre>
Per poter eseguire il comando di disinstallazione descritto avrete bisogno di permessi di sudoer o di root.
== Reinstallazione di un programma o di un pacchetto ==
Se abbiamo un programma già installato nel sistema, ma per un qualsiasi motivo volessimo reinstallarlo, il comando è:
<pre>
apt-get install --reinstall programma
</pre>
Se vogliamo reinstallare VLC:
<pre>
apt-get install --reinstall vlc
</pre>
Per poter eseguire il comando di reinstallazione descritto avrete bisogno di permessi di sudoer o di root.
== Rimozione di un pacchetto non disinstallato completamente ==
Per rimuovere completamente i pacchetti già disinstallati che, per qualche motivo, non riuscite a eliminare con <code>apt</code>, digitare:
<pre>
dpkg -P programma
</pre>
Se volessimo “purgare” VLC:
<pre>
dpkg -P vlc
</pre>
== Pulizia della cache dei pacchetti ==
Per ripulire la cache dei pacchetti scaricati si utilizzano i comandi:
<pre>
apt-get clean
</pre>
O anche:
<pre>
apt-get autoclean
</pre>
Per poter eseguire il comando avrete bisogno di permessi di sudoer o di root.
== Installazione dei sorgenti dei pacchetti ==
A volte può esserci utile il download di codici sorgente, magari per correggere da noi una compilazione errata, o ricompilarlo reindirizzando delle dipendenze, o qualsiasi altro motivo.
Possiamo farlo da aptitude, semplicemente con il comando:
<pre>
apt-get source programma
</pre>
Se volessimo ottenere i source di VLC:
<pre>
apt-get source vlc
</pre>
Non sono richiesti particolari permessi, per cui potete farlo anche da semplici user, il risultato non cambia.
== Determinare a quale pacchetto appartiene un file ==
Per ottenere il nome del pacchetto a cui appartiene un file:
<pre>
dpkg --search nome_file
</pre>
Ad esempio:
<pre>
dpkg --search /bin/cat
coreutils: /bin/cat
</pre>
= Operazioni con programmi non presenti nei repository =
== Premessa ==
A mio parere, prima di procedere con l'installazione di un programma, è sempre bene verificare attentamente che non sia già presente nei repository ufficiali o in qualche repository aggiuntivo messo a disposizione, ad esempio, dagli sviluppatori del programma stesso. Installando da repository, infatti, si mantiene il sistema pulito e, soprattutto, si mantiene un archivio unico e completo di tutti i programmi installati, con la possibilità di rimuoverli utilizzando pochi strumenti nativi di Debian.
== Compilazione dei sorgenti di un programma ==
I sorgenti di un programma sono di solito contenuti in un file con estensione <code>.tar.gz</code>. Un file di questo genere è in gergo chiamato ''tarball'' e in genere vanno compiute due operazioni per compilarlo ed installarlo.
* La prima è quella di scompattarlo:
<pre>
$ tar -xzvf nome_programma.tar.gz
</pre>
* La seconda è quella di spostarsi nella directory che si è venuta a creare e dare inizio alla compilazione:
<pre>
$ cd nome_programma
$ ./configure
$ make
# make install
</pre>
Per disinstallare il programma bisogna portarsi nella directory dei sorgenti e digitare:
<pre>
# make uninstall
</pre>
=== Metodo alternativo I ===
Un metodo alternativo consiste nel compilare il programma creando un pacchetto <code>.deb</code> da installare successivamente. Il primo passo è di installare il programma:
<pre>
# apt-get install checkinstall
</pre>
Ora seguite i normali passi per la compilazione dei sorgenti, variando solo l'ultimo comando:
<pre>
$ ./configure
$ make
# checkinstall
</pre>
Se tutto è andato per il verso giusto, verrà creato ed installato un pacchetto debian.
=== Metodo alternativo II ===
A volte <code>checkinstall</code> può dare problemi, non rispettando le politiche Debian di gestione e creazione dei pacchetti. E' possibile per fortuna sostituire <code>checkinstall</code> con un modo più professionale. Dovete innanzitutto scaricare dei tool di sviluppo:
<pre>
# apt-get install devscripts dh-make make build-essential dpkg apt
</pre>
Adesso posizionatevi dentro la cartella estratta dei sorgenti e lanciate:
<pre>
$ dh_make
$ debuild binary
</pre>
A questo punto, dopo la compilazione, verrà creato un pacchetto <code>.deb</code>, che sarà collocato nella directory padre. Installatelo così:
<pre>
# dpkg -i ../pacchetto.deb
</pre>
e il gioco è fatto.
== Esecuzione di uno script ==
Spesso i programmi scaricati e scompattati contengono al loro interno uno script, da lanciare per effettuare l'installazione vera e propria del programma. Per lanciare questo tipo di installer si eseguano i comandi:
<pre>
chmod +x installer.sh
</pre>
e successivamente:
<pre>
./installer.sh
</pre>
== Installazione di un file .bin ==
Se abbiamo scaricato un installer in .bin, per avviare la sua installazione da terminale non si deve fare altro che dirigersi nella directory in cui il .bin è stato salvato e lanciarlo scrivendo il nome del file. L’unico problema può nascere quando l'installer non da nativamente i permessi di esecuzione all’utente normale, la cosa si risolve con il comando <code>chmod</code>.<br>
Se, per esempio, abbiamo scaricato il programma <code>mio_programma.bin</code> dobbiamo compiere le seguenti operazioni.<br>
L'installer avrà bisogno prima di tutto di una rettifica sui permessi. Entriamo nella cartella in cui si trova il file e lanciamo questi comandi:
<pre>
chmod +x mio_programma.bin
</pre>
e successivamente:
<pre>
./mio_programma.bin
</pre>
== Installazione di un file .rpm ==
Se abbiamo scaricato un installer con estensione .rpm (RedHat Package Manager, sistema di gestione dei pacchetti originario di Red Hat Linux), per installarlo dalla nostra distro dovremo per forza convertirlo in .deb . Il programma che ci consente di farlo è <code>alien</code>. Quindi installiamolo digitando:
<pre>
apt-get install alien
</pre>
Successivamente, dopo esserci diretti da terminale nella cartella in cui è presente il file .rpm scaricato, lanciamo:
<pre>
alien -k nomefile.rpm
</pre>
Avrete ottenuto un file .deb, che potrete utilizzare seguendo le istruzioni del paragrafo successivo.
== Installazione di un file .deb ==
Se abbiamo scaricato o creato un installer con estensione .deb (che, come il nome suggerisce, è stato creato per Debian e sistemi derivati come Ubuntu), per installarlo basterà dirigerci nella directory dove risiede il file e digitare:
<pre>
dpkg -i nomefile.deb
</pre>
Per disinstallarlo possiamo normalmente seguire una delle strade per la disinstallazione viste in precedenza, utilizzando <code>apt</code>.
== Scompattare un file .tar ==
Se abbiamo un archivio in formato compresso .tar, per decomprimerlo dovremo usare lo strumento <code>tar</code>. Se non lo abbiamo, digitiamo da terminale:
<pre>
apt-get install tar
</pre>
Adesso che abbiamo lo strumento, per decomprimere un pacchetto in formato .tar dobbiamo prima dirigerci, sempre da terminale, nella cartella in cui l’archivio è presente, e poi dobbiamo lanciare:
<pre>
tar xvf nomearchivio.tar
</pre>
dove
* <code>tar</code> è il nome del programma decompressore
* <code>x</code> significa “estrazione”
* <code>v</code> sta per "verbose", e serve per ottenere informazioni dettagliate durante il processo di estrazione
* <code>f</code> infine salva i file nella stessa posizione dell’archivio.
Lanciando il comando:
<pre>
tar --help
</pre>
avrete una lista completa delle opzioni che potete usare col programma.<br>
Attenzione ai permessi: se lanciate il comando tar da sudoer o da root, i permessi dei file decompressi saranno attribuiti a quell’utenza.
== Scompattare un file .tar.bz2 ==
Se abbiamo un archivio in formato compresso .tar.bz2, per decomprimerlo dovremo usare lo strumento <code>tar</code>. Se non lo abbiamo, digitiamo da terminale:
<pre>
apt-get install tar
</pre>
Adesso che abbiamo lo strumento, per decomprimere un pacchetto in formato .tar.bz2 dobbiamo prima dirigerci, sempre da terminale, nella cartella in cui l’archivio è presente, e poi dobbiamo lanciare:
<pre>
tar jxvf nomearchivio.tar.bz2
</pre>
dove
* <code>tar</code> è il nome del programma decompressore
* <code>j</code> indica che il file da decomprimere è in formato compresso .bz2
* <code>x</code> significa “estrazione”
* <code>v</code> sta per "verbose", e serve per ottenere informazioni dettagliate durante il processo di estrazione
* <code>f</code> infine salva i file nella stessa posizione dell’archivio.
Lanciando il comando
<pre>
tar --help
</pre>
avrete una lista completa delle sintassi che potete usare col programma.<br>
Attenzione ai permessi: se lanciate il comando tar da sudoer o da root, i permessi dei file decompressi saranno attribuiti a quell’utenza.
== Scompattare un file .tar.gz ==
Se abbiamo un archivio in formato compresso .tar.gz, per decomprimerlo dovremo usare lo strumento <code>tar</code>. Se non lo abbiamo, digitiamo da terminale:
<pre>
apt-get install tar
</pre>
Adesso che abbiamo lo strumento, per decomprimere un pacchetto in formato .tar.bz2 dobbiamo prima dirigerci, sempre da terminale, nella cartella in cui l’archivio è presente, e poi dobbiamo lanciare:
<pre>
tar zxvf nomearchivio.tar.gz
</pre>
dove
* <code>tar</code> è il nome del programma decompressore
* <code>z</code> indica che il file da decomprimere è in formato compresso .gz
* <code>x</code> significa “estrazione”
* <code>v</code> sta per "verbose", e serve per ottenere informazioni dettagliate durante il processo di estrazione
* <code>f</code> infine salva i file nella stessa posizione dell’archivio.
Lanciando il comando
<pre>
tar --help
</pre>
avrete una lista completa delle sintassi che potete usare col programma.<br>
Attenzione ai permessi: se lanciate il comando tar da sudoer o da root, i permessi dei file decompressi saranno attribuiti a quell’utenza.
== Scompattare un file .rar ==
Se siamo in possesso di un archivio .rar , per decomprimerlo avremo bisogno dello strumento <code>unrar</code>. Se non lo abbiamo, digitiamo da terminale:
<pre>
apt-get install unrar
</pre>
La differenza tra <code>tar</code> e <code>unrar</code> è che il pacchetto <code>tar</code> è tuttofare, e consente sia l’archiviazione che la decompressione dei file su cui è in grado di lavorare. <code>unrar</code> invece è in grado soltanto di decomprimere, e se volessimo creare un archivio .rar avremmo bisogno di un altro pacchetto, chiamato <code>rar</code>.<br>
Per decomprimere il file .rar digitiamo ora semplicemente:
<pre>
unrar nomearchivio.rar
</pre>
Attenzione ai permessi: se lanciate il comando unrar da sudoer o da root, i permessi dei file decompressi saranno attribuiti a quell’utenza.
== Scompattare un file .zip ==
Se siamo in possesso di un file .zip, possiamo decomprimerlo con lo strumento “<code>unzip</code>. Se non abbiamo dovremo installarlo con:
<pre>
apt-get install unzip
</pre>
Come per gli archivi .rar, <code>unzip</code> è in grado soltanto di decomprimere, e la compressione può avvenire grazie a <code>zip</code> che si installa allo stesso modo.<br>
Per decomprimere un file .zip, digitiamo semplicemente:
<pre>
unzip nomearchivio.zip
</pre>
Attenzione ai permessi: se lanciate il comando unrar da sudoer o da root, i permessi dei file decompressi saranno attribuiti a quell’utenza.
= Gestione di file e directory =
== Muoversi tra le directory ==
Accedere da terminale ad una directory è semplicissimo, perché il comando è uguale a quello del DOS.<br>
Per entrare nella directory “cartella” digitiamo:
<pre>
cd cartella
</pre>
se ci troviamo nella directory "genitore" della directory "cartella". Oppure digitiamo:
<pre>
cd /percorso/assoluto/per/arrivare/a/cartella
</pre>
Si noti che per utilizzare il percorso assoluto dobbiamo per prima cosa inserire il <code>/</code> che sta ad indicare la radice del filesystem.
Per entrare nella directory “sottocartella” presente in “cartella” con un solo comando, digitiamo:
<pre>
cd cartella/sottocartella
</pre>
Se siamo in “sottocartella” e vogliamo tornare in “cartella” digitiamo:
<pre>
cd ..
</pre>
Se siamo in “sottocartella” e vogliamo uscire sia da lì che da “cartella”, digitiamo:
<pre>
cd ../..
</pre>
== Visualizzare il contenuto di una directory ==
Se avete bisogno di vedere cosa è presente in una cartella, tutto quello che dovrete fare sarà entrare nella cartella che volete esaminare e lanciare:
<pre>
ls
</pre>
Esistono una serie di opzioni da aggiungere per perfezionare la ricerca. Avrete una guida completa di quello che potete aggiungere digitando:
<pre>
ls --help
</pre>
Le opzioni più utili sono secondo me:
<pre>
ls -a
</pre>
con cui si potranno visualizzare anche gli eventuali file nascosti, compresi <code>.</code> e <code>..</code> (directory corrente e directory superiore)
<pre>
ls -A
</pre>
con cui si potranno visualizzare anche gli eventuali file nascosti
<pre>
ls -la
</pre>
con cui si potranno visualizzare i file nascosti (<code>a</code>) e produrre un listato (<code>l</code>) con diversi dettagli utili (permessi di lettura/scrittura/esecuzione, utente e gruppo proprietari, dimensione, data di ultima modifica, ecc... )
== Creare una directory ==
Per creare una directory da terminale, dobbiamo spostarci dentro la directory nella quale desideriamo creare la nuova directory, e digitare:
<pre>
mkdir nuovacartella
</pre>
Se volessimo creare in un colpo solo la directory “cartella” e subito al suo interno la directory “sottocartella” scriviamo:
<pre>
mkdir cartella/sottocartella
</pre>
== Rinominare una directory ==
Rinominare una cartella da terminale è semplice. Se ad esempio dobbiamo assegnare alla directory “cartella” il nuovo nome “directory”, dobbiamo portarci nella directory genitore e scrivere:
<pre>
mv cartella/ directory/
</pre>
== Spostare (tagliare ed incollare) una directory ==
Spostare (tagliare ed incollare) una directory da terminale richiede un solo semplice comando. Supponiamo di avere la seguente struttura:
<pre>
/home
|
|__ ferdy
      |
      |__ cartella
      |      |__ sottocartella
      |
      |__ directory
</pre>
e di voler spostare la directory <code>sottocartella</code>  dalla directory <code>cartella</code> alla directory <code>directory</code>:
<pre>
cd /home/ferdy/cartella
mv sottocartella /home/ferdy/directory
</pre>
oppure, con un solo comando:
<pre>
mv /home/ferdy/cartella/sottocartella /home/ferdy/directory
</pre>
== Copiare una directory ==
Copiare ed incollare una directory da terminale richiede un solo semplice comando. Supponiamo di avere la seguente struttura:
<pre>
/home
|
|__ ferdy
      |
      |__ cartella
      |      |__ sottocartella
      |
      |__ directory
</pre>
e di voler copiare la directory <code>sottocartella</code> dalla directory <code>cartella</code> alla directory <code>directory</code>:
<pre>
cd /home/ferdy/cartella
cp -r sottocartella /home/ferdy/directory
</pre>
oppure, con un solo comando:
<pre>
cp -r /home/ferdy/cartella/sottocartella /home/ferdy/directory
</pre>
L'opzione <code>-r</code> permette di estendere ricorsivamente l'opzione di copia alle eventuali sottodirectory contenute della directory "sottocartella".
== Cancellare una directory vuota ==
Volendo cancellare la directory “cartella”, dobbiamo scrivere:
<pre>
rmdir cartella
</pre>
Questo comando presuppone che la directory sia vuota. In caso contrario verrà restituito l’errore:
<pre>
rmdir: failed to remove `cartella’: La directory non è vuota
</pre>
== Cancellare una directory non vuota ==
Volendo cancellare la directory non vuota “cartella” dovremo digitare:
<pre>
rm -r cartella
</pre>
L'opzione <code>-r</code> è in grado di cancellare ricorsivamente ogni file o sottodirectory di "cartella". Prestate attenzione a come utilizzate il comando perché '''non viene chiesta alcuna conferma''' e rischiate di eliminare file o directory di sistema.<br/>
Il comando precedente funziona correttamente anche se si vogliono cancellare directory vuote.
== Visualizzare la struttura di una directory ==
<code>tree</code> è un comando shell che ha il compito di listare ad albero una data directory. La sintassi del comando è:
<pre>
tree [-adfgilnopqrstuxACDFNS][-L level [-R]][-H baseHREF][-T title][-o filename][--nolinks][-P pattern]
    [-I pattern][--inodes][--device][--nore-port][--dirsfirst][--version][--help][directory ...]
</pre>
Alcune delle numerose opzioni che possiamo passare al comando tree sono:
* <code>-a</code>: Stampa a video tutti i file, compresi quelli nascosti
* <code>-d</code>: Lista soltanto le directory
* <code>-f</code>: Stampa tutto il percorso di ogni file
* <code>-i</code>: Non stampa un output ad 'albero'
* <code>-s</code>: Stampa affianco al nome del file la sua dimensione
* <code>-r</code>: Riordina alfabeticamente l'output
Se vogliamo ad esempio listare la cartella <code>/home/user/tmp</code>, basta dare il comando:
<pre>
tree /home/user/tmp
</pre>
== Rinominare un file ==
Per rinominare un file da terminale deve essere usato il comando <code>mv</code>. Volendo rinominare il file “testo.txt” in “text.txt” dovremo dirigerci prima nella directory in cui il file è presente, e poi digitare:
<pre>
mv testo.txt text.txt
</pre>
== Spostare (tagliare ed incollare) un file ==
Anche per questa operazione deve essere usato il comando <code>mv</code>. Supponiamo di avere il file "testo.txt" in una specifica directory e di volerlo spostare nella nostra directory Home. Dirigiamoci da terminale nella directory in cui il file è presente, e lanciamo:
<pre>
mv testo.txt /home/vostronomeutente/
</pre>
== Copiare un file ==
Se intendiamo duplicare un file, dobbiamo usare il comando <code>cp</code>. Con questo comando si possono fare più cose:
* copiare un file da una directory ad un'altra:
<pre>
cp testo.txt /home/vostronomeutente/testo.txt
</pre>
* creare un duplicato del file nella stessa direcctory, cambiandogli solo il nome:
<pre>
cp testo.txt text.txt
</pre>
* creare un duplicato e cambiare anche l’estensione:
<pre>
cp testo.txt testo.bak
</pre>
== Cancellare un file ==
La cancellazione di un file da terminale è semplice, basterà digitare il comando <code>rm</code> seguito dal nome del file che si vuole cancellare.
Ad esempio:
<pre>
rm testo.txt
</pre>
== Cancellare definitivamente un file ==
<code>shred</code> è un comando shell che sovrascrive ripetutamente i FILE specificati in modo da rendere più difficile recuperare i dati, e opzionalmente li cancella. La sintassi del comando è:
<pre>
shred [OPZIONI] FILE [...]
</pre>
Le opzioni che possiamo passare al comando sono:
* <code>-f, --force</code>: change permissions to allow writing if necessary
* <code>-n, --iterations=N</code>: Overwrite N times instead of the default (25)
* <code>--random-source=FILE</code>: get random bytes from FILE (default /dev/urandom)
* <code>-s, --size=N</code>: shred this many bytes (suffixes like K, M, G accepted)
* <code>-u, --remove</code>: truncate and remove file after overwriting
* <code>-v, --verbose</code>: show progress
* <code>-x, --exact</code>: do not round file sizes up to the next full block; this is the default for non-regular files
* <code>-z, --zero</code>: add a final overwrite with zeros to hide shredding
== Visualizzare il contenuto di un file ==
Il comando <code>cat</code> (che analizzeremo nel dettaglio tra pochi paragrafi) visualizza i contenuti di un intero file sullo schermo. Ad esempio, digitate:
<pre>
cat filename.txt
</pre>
per vedere il contenuto del file. Se il file è piuttosto lungo, il suo contenuto scorrerà velocemente sullo schermo. Per evitare ciò, usate un pager come less o most (more scorre solo in avanti):
<pre>
less filename.txt
</pre>
== Confrontare due file ==
<code>diff</code> è un comando shell che trova la differenza tra due file. La sintassi del comando è:
<pre>
diff [opzioni] da-file verso-file
</pre>
Alcune delle opzioni che possiamo passare al comando sono:
* <code>-righe</code>: Mostra "righe" (un intero) righe di contesto. Questa opzione non specifica da sola un formato di output; non ha nessun effetto a meno che venga combinata con <code>-c</code> o <code>-u</code>. Questa opzione è obsoleta. Per operare correttamente, diff ha, di solito, bisogno di almeno due righe di contesto.
* <code>-a</code>: Tratta tutti i file come testo confrontandoli riga per riga, anche se non sembrano essere testo.
* <code>-b</code>: Ignora differenza nella quantità di spazi bianchi.
* <code>-B</code>: Ignora differenze che consistono solo in righe vuote (eccedenti o mancanti).
* <code>--brief</code>: Riferisce solo se i file sono diversi, e non i particolari della differenza.
* <code>-c</code>: Usa il formato «a contesto» (context output, in inglese).
* <code>-d</code>: Usa un algoritmo diverso per trovare un, probabilmente, minore insieme di modifiche da fare. Questo rende diff più lento (a volte molto più lento).
== Comprimere file e directory ==
La creazione di un nuovo file con il comando <code>tar</code> viene fatta mediante l'opzione <code>-c</code> indicando il nome del file da creare e il file o la directory originali:
<code>
$ tar cf nuovo.tar dir/
</code>
Il file creato contiene l'intera directory <code>dir/</code>. Per estrarre la directory dall'archivio utilizziamo l'opzione <code>-x</code>:
<code>
$ tar xf nuovo.tar
</code>
l'archivio verrà estratto interamente nella directory corrente.<br/>
L'opzione <code>-f</code> utilizzata fino ad ora serve ad indicare che il campo direttamente successivo sarà il nome dell'archivio.
<br/>
Tuttavia in questo esempio non abbiamo utilizzato alcun software di compressione per ridurre la dimensione dei dati nell'archivio. Per farlo possiamo scegliere se utilizzare il software di compressione ''gzip'' (opzione -z) o con ''bzip2'' (opzione -j):<br/>
<code>
$ tar czf nuovo.tar.gz dir/      # utilizza gzip
</code><br/>
<code>
$ tar cjf nuovo.tar.bz2 dir/      # utilizza bzip2
</code><br/>
Analogamente per decomprimere:<br/>
<code>
$ tar xzf archive.tar.gz<br/>
$ tar xjf archive.tar.bz2
</code><br/>
L'estensione dei due file è stata cambiata da ''.tar'' a ''.tar.gz'' e ''.tar.bz2'' per indicare chiaramente con quale tipo di algoritmo sono stati compressi i dati. Esistono versioni compatte delle stesse estensioni: ''.tgz'' equivale a ''.tar.gz'' e ''.tbz'' equivale a ''.tar.bz2''.
<br/>
Nota: l'estensione corretta in realtà non è assolutamente necessaria. Possiamo chiamare tutti gli archivi .tar indipendentemente dalla compressione e questi funzioneranno perfettamente. Tuttavia in questo modo l'utente non ha modo di conoscere a colpo d'occhio l'algoritmo utilizzato.
<br/>
Una opzione basilare interessante è <code>-t</code> con la quale possiamo stampare il contenuto di un file compresso. Ad esempio:<br/>
<code>
$ tar tzf archive.tar.gz
</code><br/>
Nel caso in cui l'archivio non sia stato compresso utilizzando ''gzip'' o ''bzip2'' è possibile aggiungervi singoli file o intere directory utilizzando la modalità append attivata dall'opzione <code>-r</code>:<br/>
<code>
$ tar rf archive.tar file dir/
</code><br/>
Nota: è importante che l'archivio non sia compresso. Nel caso lo sia è possibile prima eliminare la compressione dall'archivio e poi aggiungere dei file. Alla fine verrà ricompresso il tutto.
=== Esempi ===
* Comprimere tutte le immagini jpg dentro una directory:
<code>
$ tar cvzf photo.tar.gz photo/*.jpg
</code>
* Come sopra ma il file viene inserito nella directory dove le foto risiedono:
<code>
$ tar cvzf photo/photo.tar.gz photo/*.jpg
</code>
* Comprimere la directory corrente (1):
<code>
$ tar cvjf current.tar.bz2 .
</code>
* Comprimere la directory corrente (2):
<code>
$ tar cvjf current.tar.bz2 *
</code><br/>
''Nota: La differenza tra i due comandi precedenti è abbastanza semplice. Nel primo caso ad essere compressa è la reale direcotry corrente. Scompattando l'archivio ci troveremo con una directory che contiene tutti i file. Nel secondo caso invece ad essere compressa non è la directory bensì tutti i file che essa contiene. Scompattando non troveremo una cartella contenente ma tutti i file contenuti nell'archivio saranno copiati nella directory di scompattazione senza che sia creata la subdirectory.''
* Copiare una directory:
<code>
$ tar cf - /some/directory | (cd /another/directory && tar  xf -)
</code>
* Estrarre tutti i file .h da un archivio:
<code>
$ tar xvzf source.tar.gz *.h
</code>
* Cerca tutti i file .jpeg nella home e crea un archivio:
<code>
$ find ~ -type f -name "*.jpg" | xargs tar cvzf photo.tar.gz
</code>
* Se stiamo cercando di creare un archivio molto grande è più conveniente il seguente metodo:
<code>
$ find ~ -type f -name "*.jpg" | xargs tar rvzf photo.tar.gz
</code><br/>
''nel quale abbiamo usato l'opzione append (-r) invece della create (-c). Questo perchè nel caso di archivi molto grandi xargs passa tutti gli argomenti a blocchi e tar ricrea ogni volta l'archivio con solamente i file elencati in quel blocco all'interno. La modalità append risolve il problema.''
* Estrarre singoli file da un archivio:
<code>
$ tar xvjf archive.tar.bz2 file1.cpp file2.cpp file3.cpp
</code>
* Estrarre file dalle subdirectory di un archivio: o subdirectory intere:
<code>
$ tar xvjf archive.tar.bz2 subdir1/file1.cpp subdir2/file2.cpp
</code>
* Estrarre una intera subdirectory da un archivio:
<code>
$ tar xvjf archive.tar.bz2 subdir1/
</code><br/>
''Nota: Per poter estrarre singoli file o subdirectory occorre conoscerne con esattezza i nomi. Tuttavia è possibile utilizzare altri comandi come find, grep, awk per ottenere un elenco dei file che vogliamo estrarre.''
* Estrarre da un archivio solo i file elencati in un file di testo:
<code>
$ tar xvf archive.tar -T list.txt
</code>
* Importare in un file di testo tutti gli elementi di un archivio:
<code>
$ tar tzf archive.tar.gz > list.txt
</code>
* Eliminare da una directory contenente molti file solo quelli contenuti anche nell'archivio:
<code>
$ tar tzf archive.tar.gz | xargs rm -r
</code>
* Stimare la dimensione di un archivio prima di crearlo:
<code>
$ tar czf - directory/ | wc -c
</code>
<br/><br/>
''(Grazie a [http://nerotux.tuxfamily.org Nerotux] per gli esempi sull'utilizzo di tar)''
== Modificare l'ora di accesso a un file ==
<code>touch</code> è un comando shell che modifica l'orario di accesso o/e modifica di un file (il cosiddetto '''timestamp'''). I file vengono modificati con l'orario corrente. La sintassi del comando è:
<pre>
touch    [-acfm] [-r    file][-t orario_decimale] [-d    orario]
          [--time={atime,access,use,mtime,modify}][--date=orario][--reference=file]
          [--no-create] [--help] [--version] [--] file...
</pre>
Le opzioni che possiamo passare al comando sono:
* <code>-a</code>: Cambia l'ora di accesso di file.
* <code>-c</code>: Non crea file.
* <code>-m</code>: Cambia l'ora di modifica di file.
* <code>-r ref_file</code>: Usa  i  corrispondenti  orari di ref_file come i nuovi valori per gli orari da cambiare.
* <code>-t orario</code>: Usa l'orario specificato come nuovo valore per gli orari cambiati. L'argomento è un numero decimale nella forma [[SS]AA]MMGGoomm[.ss]
* <code>-d, --date=orario</code>: Usa orario al posto dell'ora corrente. Può contenere il nomi di mese, fusi orari, «am» e «pm», ecc.
== Manipolazione di file ==
Un modo veloce (soprattutto negli script) per modificare il contenuto di un file o per accodare altro testo alla sua fine è utilizzare il comando <code>cat</code>.<br>
<code>cat</code> è un comando shell che legge file in sequenza e può scrivere i loro contenuti sullo standard output nella stessa sequenza. Lo scopo di cat è infatti concatenare file (generalmente di testo o che abbiano particolari intestazioni, ad esempio il formato MPEG2 usato dai VOB nei DVD video). Dimenticatevi follie quali "cat file.txt | less" o "cat file.txt | grep foo" perché è definito
[http://en.wikipedia.org/wiki/Cat_%28Unix%29#Useless_use_of_cat UUOC: Useless Use Of Cat] :-)
La sintassi del comando è:
<pre>
cat [opzioni][file ...]
</pre>
Note:
* <code>'''>''' file.estensione</code>: Se nomefile.estensione non esiste, viene creato e viene scritto il valore al suo interno. Nel caso esistesse già, il suo valore '''verrebbe sovrascritto'''.
* <code>'''>>''' nomefile.estensione</code>: Aggiunge alla fine del file il valore che gli date a riga di comando.<br>
Altri comandi utili per la manipolazione veloce di file sono:
* <code>head</code>, che mostra le prime dieci linee di un file. Utile quando si vuole avere un'idea del contenuto di un file senza doverlo aprire con un editor
* <code>tail</code>, che mostra al contrario le ultime dieci linee di un file
=== Esempi ===
Se vogliamo mostrare il contenuto del file di testo <code>/home/ferdy/prova.txt</code>, dobbiamo dare il comando:
<pre>
cat /home/ferdy/prova.txt
</pre>
Se vogliamo aggiungere il contenuto del file <code>/home/ferdy/aggiunte.txt</code> alla fine del file, diamo il seguente comando:
<pre>
cat /home/ferdy/aggiunte.txt >> /home/ferdy/prova.txt
</pre>
Se vogliamo unire i due file e crearne un terzo, diamo il comando:
<pre>
cat /home/ferdy/prova.txt /home/ferdy/aggiunte.txt > /home/ferdy/file_finale.txt
</pre>
Per visualizzare le prime dieci o le ultime dieci linee di un file:
<pre>
head /home/ferdy/prova.txt
tail /home/ferdy/prova.txt
</pre>
Un comando preziosissimo per gli amministratori di sistema è il seguente, che permette di vedere in modo interattivo la variazione di un file di log:
<pre>
tail -f /var/log/syslog | ccze
</pre>
Nell'ultimo comando sono stati usati:
* <code>'''-f</code>''' che permette a <code>tail</code> di seguire (follow) il file e i suoi cambiamenti
* <code>'''| ccze'''</code> che dirige l'output di tail verso il programma <code>ccze</code>, che colorerà l'output del log rendendolo facilmente leggibile
In quest'ultimo esempio, per rilasciare il terminale e riottenerne il pieno utilizzo bisogna stoppare <code>tail</code> con la combinazione di tasti <code>CTRL</code>+<code>C</code>.
Un altro uso interessante di cat è creare file di testo sfruttando lo stdin della shell.
Lanciamo questo comando:
<pre>
cat - > file.txt
</pre>
e possiamo scrivere il nostro testo sfruttando lo standard input come editor, si può correggere solo se non si è andati a capo e si termina con ''Ctrl-d''. <br>
== Creare un collegamento ==
Un collegamento è un particolare tipo di file che non è altro che un rimando ad un altro file o directory. Per creare un collegamento tra file o directory si deve usare il comando <code>ln</code>.
<pre>
ln -s <file da collegare> <nome del link>
</pre>
Supponiamo di avere il file testo.txt nella nostra home e di voler creare un collegamento in <code>usr/bin</code> chiamato "mylink.txt". Scriverò:
<pre>
ln -s /home/ferdy/testo.txt /usr/bin/mylink.txt
</pre>
per prevenire ogni tipo di problema è bene sempre specificare i percorsi assoluti del collegamento e del file (o directory) verso cui creare un collegamento.
Su Linux esistono due tipi di collegamenti: Hard link e Symbolic link.
=== Hard Link ===
Sono di fatto una copia di una voce di directory, hanno nomi diversi ma puntano allo stesso inode e quindi condividono esattamente lo stesso dato (oltre agli stessi permessi, data di modifica, owner ecc.).
=== SymLink ===
Sono dei piccoli file che contengono un puntamento ad altri file o directory. Questi file hanno i-node autonomo e possono puntare a file di altri file system (sia locali, che di rete). Si possono facilmente visualizzare con un normale ls -l e se viene cancellato o spostato il file a cui puntano rimangono "stale": continuano ad esistere ma puntano a qualcosa che non esiste.
<br/>
Un symlink appare come avente tutti i permessi aperti a tutti gli utenti, di fatto è trasparente rispetto a permessi e ownership e riflette quelli del file o directory a cui punta.
== Cambiare i permessi di lettura, scrittura ed esecuzione ==
Può succedere di aver bisogno di dover cambiare i permessi ad un file, per consentire la lettura, la scrittura o l’esecuzione ad ogni utente, oppure al contrario per proteggerlo da utilizzi indesiderati e restringerlo ad un particolare utente o gruppo.<br/>
Il comando da utilizzare per queste operazioni è <code>chmod</code>.<br/>
I permessi <code>chmod</code> sono tipicamente utilizzati dai sistemi operativi UNIX e Linux. Non sono altro che le linee guida che vengono impartite al sistema sugli accessi o non accessi ad una data directory e/o file. Questi sistemi operativi offrono la possibilita di operare con un file facendo la distinzione fra 3 tipi di operatori: Proprietario (User), Gruppo (Group), Pubblici (Others). Per ciascuno di questi utenti é necessario specificare i diversi permessi riguardanti la directory e/o il file in questione. I permessi sono generalmente indicati da alcuni numeri, ovvero:
* Lettura : permetti l'acceso al file ( 4 )
* Scrittura : permetti le modifiche del file da parte di un utente ( 2 )
* Esecuzione : permetti di eseguire lo script ( 1 )
Questi 3 permessi devono essere indicati per ognuno dei 3 tipi di utenti. Ad esempio <code>chmod 755</code>, non é altro che il tipo di permesso che si imposta ad un file, rendendolo:
* leggibile-scrivibile-eseguibile al proprietario
* leggibile-eseguibile al gruppo
* leggibile-eseguibile agli altri utenti
Il permesso <code>chmod 755</code> si calcola in questo modo:
<pre>
Permessi proprietario:
Lettura         sì = 4
Scrittura sì = 2
Esecuzione sì = 1
Totale         = 7
Permessi gruppo:
Lettura         sì = 4
Scrittura no = 0
Esecuzione sì = 1
Totale         = 5
Permessi utenti:
Lettura         sì = 4
Scrittura no = 0
Esecuzione sì = 1
Totale         = 5
</pre>
Affiancando i tre totali si ottiene il permesso 755.
<br/>
Per cambiare i permessi al file "testo.txt" dovremo quindi agire da autori del file e digitare:
<pre>
chmod xxx testo.txt
</pre>
Al posto delle lettere <code>xxx</code> devono essere indicati i numeri ottali visti in precedenza. Ad esempio:
* 755 – Lettura, scrittura, esecuzione per il proprietario, lettura, esecuzione per il gruppo ed altri utenti.
* 644 – Lettura, scrittura per il proprietario, lettura per il gruppo ed altri utenti.
* 666 – Lettura e scrittura per tutti.
* 700 – Lettura, scrittura, esecuzione per il proprietario, nessun permesso per il gruppo ed altri.
In generale valori che vanno da "0" a "7" rappresentano in forma numerica i permessi come di seguito riportato:
<pre>
4 è uguale a lettura(r),
2 è uguale a scrittura(w),
1 è uguale a esecuzione(x),
0 rimuove i permessi.
</pre>
Il valore numerico risultante è pari alla somma di tali valori.<br>
Partendo sempre da sinistra, la prima cifra si riferisce ai permessi per l'utente proprietario.<br>
La seconda cifra fa riferimento ai permessi per il gruppo proprietario.<br>
La terza e ultima cifra si riferisce ai permessi per gli altri utenti non appartenenti al gruppo proprietario.<br>
Un'altra sintassi utilizzabile è:
<pre>
chmod u|g|o|a|+rwx  file1/directory1
</pre>
Significato delle opzioni disponibili del precedente comando:
  u = user - applica i permessi all'utente proprietario del file,
  g = group - applica i permessi al gruppo proprietario del file,
  o = other - applica i permessi ad altri utenti,
  a = all - applica i permessi a tutti gli utenti,
  + = questo operatore logico aggiunge i permessi specificati,
  - = questo operatore logico rimuove i permessi specificati,
  r = indica il permesso di lettura,
  w = indica il permesso di scrittura,
  x = indica il permesso di esecuzione.
== Cambiare l'utente proprietario di un file ==
Per cambiare l'utente e il gruppo proprietari di ciascun file dato (specificato dal primo argomento che non sia un'opzione) si utilizza il comando <code>chown</code> nel seguente modo: se viene dato solo un nome utente (o una user ID numerica), quell'utente diventa proprietario di ciascun file dato, il cui gruppo non viene modificato. Se il nome utente è seguito da <code>:</code> e un nome di gruppo (o una group ID numerica), senza spazi frapposti, allora anche il gruppo proprietario del file viene cambiato.<br>
La sintassi del comando è:
<pre>
chown [opzioni] utente[:gruppo] file...
</pre>
=== Esempi ===
* Cambiare il proprietario del file <code>prova.txt</code>
<pre>
chown ferdy prova.txt
</pre>
* Cambiare proprietario e gruppo proprietario del file <code>prova.txt</code>
<pre>
chown ferdy:gruppo_desiderato prova.txt
</pre>
* Cambiare ricorsivamente il proprietario di tutti i file della directory <code>prova</code>
<pre>
chown -R ferdy prova/
</pre>
== Cambiare il gruppo proprietario di un file ==
Per cambiare il gruppo proprietario di un file si utilizza il comando <code>chgrp</code>. Il gruppo può essere identificato col nome o con l'ID. La sintassi del comando è:
<pre>
chgrp [opzioni] gruppo file...
</pre>
Ad esempio, per cambiare il gruppo proprietario di tutti i file contenuti nella directory <code>prova</code> si digiti:
<pre>
chgrp -R gruppo_voluto prova/
</pre>
== Ricerca di file nel sistema ==
Se siamo alla ricerca di un determinato file all’interno del nostro computer, il mio consiglio è andare su Risorse e selezionare Cerca file. In questo modo il processo sarà più rapido e meno macchinoso, ma in questa guida siamo qui per vedere come è possibile farlo anche da terminale.<br>
Il motore di ricerca da terminale si chiama <code>locate</code> e possiamo installarlo normalmente digitando:
<pre>
apt-get install locate
</pre>
Esso fa uso di un database ad aggiornamenti costanti, ma non frequenti, pertanto se volessimo ricercare un file di recente creazione, spostamento o immissione nel sistema dovremo prima lanciare il comando di update per questo database. Da root o con permessi sudoer aggiungendo “sudo” prima della sintassi digitiamo:
<pre>
/usr/bin/updatedb
</pre>
Attendiamo che l’aggiornamento sia terminato, e poi lanciamo:
<pre>
locate testo.txt
</pre>
== Scaricare un file da Internet ==
Da terminale è possibile anche scaricare file da Internet, utilizzando il comando <code>wget</code> con i protocolli HTTP o FTP. Ad esempio se volessimo scaricare il file http://www.sito.it/file.rar, ci basterà digitare:
<pre>
wget http://www.sito.it/file.rar
</pre>
Il file sarà messo in download e, una volta scaricato, piazzato nella directory in cui ci trovavamo al momento del lancio del comando.
== Sincronizzare il contenuto di due directory ==
<code>Rsync</code> e' un comando (ed un protocollo) che permette la copia di file via rete, ottimizzando i tempi di backup e ripristino dei dati. Non è presente in un'installazione minimale di Debian; occorre pertanto installarlo col comando:
<pre>
# apt-get install rsync
</pre>
La sintassi del comando è la seguente:
<pre>
# rsync -av --delete /Directory/Sorgente /Directory/Destinazione
</pre>
Le opzioni usate hanno il seguente significato:
* <code>-avr</code>: specifica di copiare i file mantenendo ownership, permessi e in modalità ''directory recursive''
* <code>--delete</code>: elimina dalla directory di destinazione i file non più presenti nella directory sorgente
Maggiori informazioni [[Rsync e Grsync | qui]].
= Gestione Utenti =
== Definizione di root e differenze con il normale utente ==
Cos’è '''root'''?<br>
Nei sistemi operativi di tipo Unix si indica con root l’utente dotato di massimi privilegi, cioè l’amministratore di sistema, detto anche super utente o superuser.<br>
L’account root su sistemi Unix è paragonabile a quello di Administrator su sistemi Windows NT/XP.<br>
L’utente root può fare tutto ciò che si desidera sul sistema: questo può essere sia un vantaggio sia uno svantaggio nello stesso momento. Viene infatti universalmente ritenuto pericoloso compiere le normali sessioni di lavoro in qualità di root: agire come utente normale e come utente root solo per amministrazione del sistema permette di minimizzare il rischio di effettuare operazioni pericolose come cancellare file essenziali per il sistema operativo.<br>
Fonte: Wikipedia
== Accesso come root ==
Per poter accedere come utente root nel sistema, ed avere quindi la possibilità di svolgere ogni operazione nel sistema, basterà digitare da terminale:
<pre>
su -
</pre>
Verrà richiesta la password di root e sarà eseguito l’accesso.<br>
Noterete che il prompt del terminale è cambiato, passando da:
<pre>
$
</pre>
''(che identifica un utente normale)''<br>
a:
<pre>
#
</pre>
''(che identifica l'utente root)''
== Disconnessione da root ==
''(per tornare utente con permessi normali sulla stessa finestra di terminale)''<br>
Se siete diventati root in una finestra di terminale, e volete tornare user senza chiudere la finestra o aprirne un’altra, basterà digitare:
<pre>
exit
</pre>
Il comando exit può servire anche per chiudere la finestra del terminale.
== Creazione di un nuovo utente ==
Per creare un nuovo utente da terminale, è sufficiente diventare root, e digitare il comando:
<pre>
adduser nomeutente
</pre>
Al posto di “nomeutente”, naturalmente, va scritto il nome dell’utente che volete creare. Saranno richieste la password che si vuole assegnare all’utente, e in più altre piccole informazioni facoltative , come Nome Completo, Stanza N° (?!), Numeri telefonici.
== Cancellazione di un utente ==
Per cancellare un utente registrato nel sistema, aperto il terminale e fatto accesso come utenti root, si digiti:
<pre>
userdel nomeutente
</pre>
Dove “nomeutente” deve essere sostituito con il nome dell’utente che si vuole cancellare. Non sono richiesti altri comandi o informazioni e l’operazione avverrà in meno di un secondo.
== Modifica della password di un utente ==
Per la modifica da terminale della password di un utente si utilizza il comando <code>passwd</code>. Facciamo login come utente root e diamo il comando:
<pre>
passwd nomeutente
</pre>
mettendo il nome dell’utente a cui vogliamo settare la password al posto di “nomeutente”. Con questo metodo è possibile cambiare non solo le password degli utenti, ma anche quella di root.
= Compiere operazioni con sudo =
== Definizione di sudo ==
Il comando <code>sudo</code> (super user do) è una stringa di comando usata su sistemi operativi Unix-like per eseguire operazioni ottenendo temporanei privilegi di root (ovvero di amministratore).<br>
A differenza del comando <code>su</code> (substitute user), <code>sudo</code> richiede all’utente solo la propria password, e non quella dell’amministratore; perciò non occorre conoscere password altrui, con ovvi vantaggi sulla sicurezza, ma è sufficiente essere stati precedentemente abilitati. Il file di configurazione <code>/etc/sudoers</code> stabilisce chi può sostituire chi, su quali macchine, e relativamente a quali operazioni.<br>
Fonte: Wikipedia
== Installazione di sudo ==
In una installazione di default di Debian <code>sudo</code> non è compreso. Per installarlo basta digitare:
<pre>
apt-get install sudo
</pre>
== Configurazione di sudo ==
Per aggiungere un utente al gruppo di sudoers, è sufficiente loggarsi da root e lanciare il comando:
<pre>
visudo
</pre>
Potremo così modificare il file <code>/etc/sudoers</code> ed aggiungere i permessi di sudoer ad un utente specifico.<br>
Un esempio di file <code>/etc/sudoers</code>:
<pre>
# /etc/sudoers
#
# This file MUST be edited with the 'visudo' command as root.
#
# See the man page for details on how to write a sudoers file.
#
Defaults  env_reset
# Host alias specification
# User alias specification
# Cmnd alias specification
# User privilege specification
root  ALL=(ALL) ALL
ferdy  ALL=(ALL) ALL
# Uncomment to allow members of group sudo to not need a password
# (Note that later entries override this, so you might need to move
# it further down)
# %sudo ALL=NOPASSWD: ALL
# Members of the admin group may gain root privileges
%admin ALL=(ALL) ALL
</pre>
Una volta che il nostro utente sarà abilitato all'utilizzo di sudo, potremo lanciare qualsiasi operazione di sistema che richieda permessi speciali, aggiungendo <code>sudo</code> all’inizio di ogni sintassi. Per esempio, per l’installazione di VLC:
<pre>
sudo apt-get install vlc
</pre>
e così via. Il comando <code>sudo</code> è molto comodo, ma ovviamente comporta più rischi per la sicurezza, specialmente nel caso in cui il sistema è utilizzato da più utenti. Usatelo con discrezione.
= Gestione del sistema =
== Visualizzare i processi di sistema in uso e le loro dipendenze ==
Da terminale abbiamo anche la possibilità di avere la panoramica sui processi in uso dal sistema. Il comando che ci occorre è:
<pre>
ps -e
</pre>
Potete anche chiedere uno schema strutturato ad albero se volete avere le idee più chiare sui processi aperti; il sistema avrà cura di raggrupparvi in una bella struttura i processi principali in esecuzione, e poi le loro rispettive dipendenze. Il comando da utilizzare è:
<pre>
pstree
</pre>
== Forzare la chiusura di un processo ==
Nel caso in cui vi trovaste con un programma andato in crash, che vi consuma RAM e che non accenna a chiudersi con una normale chiusura, potrete forzarne l’uscita. Il comando che serve per farlo da terminale è:
<pre>
kill processo
</pre>
Sostituendo naturalmente la voce “processo” con il nome del responsabile del blocco che volete killare.
== Visualizzare in ordine cronologico tutti i comandi digitati ==
Avete notato che sul terminale, premendo il tasto direzionale in su sulla tastiera vedrete il comando lanciato in precedenza? E che più volte cliccate, più comandi precedenti vengono mostrati?<br>
C’è un metodo più comodo che sfrutta questo sistema di ricordo cronologico dei comandi lanciati:
<pre>
history
</pre>
== Visualizzare le pagine di manuale ==
Le man page sono documenti che descrivono il funzionamento e la sintassi di programmi, funzioni e particolari file che compongono il sistema operativo. La quasi totalità dei comandi a disposizione hanno la propria man page che può essere visualizzata mediante il comando man, utilizzando la seguente sintassi:
<pre>
man comando_di_cui_vogliamo_visualizzare_il_manuale
</pre>
ad esempio per visualizzare la pagina di manuale del comando ls dobbiamo digitare:
<pre>
man ls
</pre>
il quale visualizzerà la pagina di manuale che può essere scorsa e letta tranquillamente e comodamente a video. Per uscire dalla visualizzazione della pagina di manuale dobbiamo premere il tasto <code>q</code>.
=== Sezioni delle man pages ===
Come abbiamo detto in precedenza, le pagine di manuale sono una vasta moltitudine (praticamente ogni comando possiede la propria pagina di manuale) e proprio per questo motivo si è scelto di dividere le varie man page in diverse sezioni numerate. Questo sistema è utilizzato in sostanza dalla nascita del sistema operativo GNU/Linux e spesso vi capiterà di incontrare riferimenti a comandi, programmi e anche a funzioni di librerie software assieme al relativo numero di sezione della pagina del manuale come ad esempio man(1). Questa indicazione significa che la documentazione relativa al comando man è inserita all'interno della sezione 1 (comandi utente). Possiamo visualizzare la sezione 1 del manuale per "man" attraverso il comando
<pre>
man 1 man
</pre>
Specificare la sezione è utile quando ci troviamo di fronte a casi di argomenti multipli con lo stesso nome. Vediamo qui di seguito quali sono e come sono suddivise le varie sezioni di man:
* Sezione 1 comandi utente (soltanto l'introduzione)
* Sezione 2 chiamate di sistema
* Sezione 3 chiamate delle librerie C
* Sezione 4 dispositivi (es.: hd, sd,)
* Sezione 5 formati dei file e protocolli (es.: wtmp, /etc/passwd, nfs)
* Sezione 6 giochi (introduzione)
* Sezione 7 convenzioni, pacchetti macro, etc. (es.: nroff, ascii)
* Sezione 8 amministrazione di sistema (soltanto l'introduzione)
== Modificare la priorità di un processo ==
<code>'''nice'''</code> è un comando dei sistemi operativi Unix e Unix-like, e più in generale dei sistemi POSIX[1], che esegue un altro comando modificando il suo valore di ''nice''.<br/>
Il valore di ''nice'' è un attributo numerico di ciascun processo dei sistemi Unix e Unix-like che è usato dallo scheduler per stabilire quanto tempo di CPU dedicare all'esecuzione del processo. A parità di priorità e di politica di schedulazione, i processi che hanno valori di ''nice'' maggiori ottengono in proporzione meno tempo di CPU rispetto a processi che hanno valori di ''nice'' minori, e quindi la loro esecuzione procede più lentamente, favorendo gli altri processi. L'idea generale è che un utente si comporti in maniera cortese (la traduzione dalla lingua inglese del termine nice è appunto cortese, simpatico) nei confronti degli altri utenti quando avvia elaborazioni particolarmente lunghe ed intense, avviandole con un valore di nice elevato in modo da non rallentare eccessivamente l'esecuzione dei processi degli altri utenti.<br>/
<code>nice</code> è anche il nome di una chiamata di sistema definita dallo standard POSIX che modifica il valore di ''nice'' del processo che la invoca. Di fatto il comando <code>nice</code> opera invocando l'omonima chiamata di sistema. Per diminuire il valore di ''nice'' è necessario disporre dei privilegi dell'amministratore (root), mentre ciò non è necessario per aumentarlo. Tipicamente è possibile diminuire il valore di ''nice'' fino a 20 unità rispetto al valore predefinito, o aumentarlo fino a 19 unità: è possibile specificare scostamenti più ampi, ma essi sono automaticamente ricondotti entro i limiti sopra citati.
=== Uso ===
La sintassi generale di nice è la seguente:
<pre>
nice [opzioni] [--] comando [arg1 [arg2 …] ]
</pre>
Il parametro <code>''comando''</code> indica il comando da eseguire, ed i parametri facoltativi <code>''arg''</code> i suoi parametri.<br/>
Il doppio trattino <code>--</code> (facoltativo) indica che i parametri successivi non sono da considerarsi opzioni.<br/>
Tra le opzioni significative vi sono:
* <code>-n delta</code>: somma algebricamente il valore ''delta'' al valore di ''nice'', in modo da aumentarlo o diminuirlo; ''delta'' può essere negativo, in modo da privilegiare il programma rispetto agli altri, ma in tal caso occorre disporre dei privilegi dell'amministratore (root). Se l'opzione <code>-n</code> non è specificata, il comportamento predefinito prevede di aggiungere 10 al valore di ''nice'';
=== Esempi ===
Avvia parallelamente due copie del programma <code>factor</code>, ciascuna delle quali calcola i fattori primi del numero 4611686018427387903, misurando il tempo di esecuzione tramite il comando <code>time</code>: la prima copia viene eseguita con un valore di ''nice'' elevato (aumentato di 20 unità rispetto al normale), mentre la seconda usa il valore di ''nice'' predefinito. Entrambe le copie impiegano lo stesso tempo di CPU per effettuare il calcolo, ma la prima copia è svantaggiata e (su un sistema con una sola CPU) completa il suo calcolo ben dopo la seconda:
<pre>
time nice -n 20 factor 4611686018427387903 &
time factor 4611686018427387903 &
</pre>
= Gestione del File System =
Se non si ha chiaro cosa sia un file system si veda prima [[File System | questa pagina]] introduttiva.
== Lista dei File System montati ==
Se  si avesse l’esigenza  di conoscere i File System montati nel sistema,  utile per sapere come  sono allocati in /dev, che tipo di permessi di  lettura e scrittura si  hanno in essi, e così via, si può semplicemente  lanciare da qualunque  utente il comando:
<pre>
mount
</pre>
Per ottenere in output la lista che cerchiamo.<br>
Il  file che dice a Linux quali dispositivi vanno montati all'avvio del  sistema e dove vanno montati è <code>/etc/fstab</code>.
== Connessione di nuove risorse ==
{{Box|Nota| Dischi ottici, dischi rigidi, memorie usb e partizioni remote sono tutti esempi di risorse, ovvero di filesystem esterni che un utente può agganciare a quello locale della macchina in uso.  }}
L'operazione di '''montaggio''' (in inglese '''mount''') di una risorsa permette di "agganciare" un dispositivo tra quelli elencati in <code>/dev</code> a una directory del file system, per renderlo utilizzabile all'interno del sistema.<br>
Collegato ad esempio un nuovo disco fisso al PC ed ipotizzato che questo sia identificato da Linux come <code>/dev/hdd1</code> è possibile renderlo raggiungibile sotto una certa directory arbitraria, per esempio <code>/mnt</code>, tramite la seguente procedura:
# creare all'interno di <code>/mnt</code> una directory a cui "agganciare" il disco:<pre># mkdir /mnt/disco_dati</pre>
# eseguire il mount del disco:<pre># mount -t auto /dev/hdd1 /mnt/disco_dati</pre>
L'opzione <code>-t auto</code> dice a Linux di riconoscere automaticamente il filesystem con cui il nostro disco è stato formattato.<br>
Da questo momento i dati contenuti nel nostro hard disk saranno raggiungibili andando nella directory <code>/mnt/disco_dati</code>.<br>
Il principale pregio di '''<code>mount</code>''' risiede nell'elevato numero di filesystem supportati, nativamente o ottraverso appositi pacchetti che ne estendono le capacità. Esistono quattro tipi di sintassi generica (si veda il manuale), qui di seguito si descrive solo l'ultima:
<pre># mount [-fnrsvw] -t tipo_fs -o fsopzione1,fsopzione2,ecc. /origine/risorsa /punto/montaggio</pre>
* '''[-fnrsvw]''', sono opzioni specifiche e facoltative dell'eseguibile mount, si veda il manuale per il significato di ciascuna lettera.
* '''-t''', specifica il tipo di filesystem che verrà montato, ad esempio auto,ext3,fat, ecc. Come già scritto auto incarica mount di capire autonomamente che filesystem si andrà a montare.
* '''-o''', specifica una o più opzioni relative al filesystem. Esistono sia opzioni valide per tutti i filesystem, altre specifiche dei singoli filesystem e infine altre utili solo se dichiarate nel file <code>/etc/fstab</code>
* '''/origine/risorsa''', indica semplicemente dove andare a prendere il filesystem della risorsa, per esempio <code>/dev/sdc</code> nel caso del disco rigido o chiavetta usb identificata dalla lettera "c".
* '''/punto/montaggio''', in quale directory (che deve già esistere) sarà visibile il contenuto della risorsa montata.
Di seguito alcuni esempi specifici.
=== Montaggio di una pendrive USB ===
Se dovesse capitare di dover montare un dispositivo USB senza poter usufruire del montaggio automatico fornito da molti Desktop Environment, è possibile farlo facilmente da terminale.
# Innanzitutto bisogna verificare a quale device è associato il dispositivo. Eseguire, <u>prima</u> di inserire la pendrive, il comando:<pre># fdisk -l</pre>
# Inserire la pendrive e rieseguire lo stesso comando; la differenza tra i due output fornirà il device.
# A questo punto si può montare la pendrive creando prima un punto di mount:<pre># mkdir /mnt/lamiapendrive</pre> per poi passare al montaggio vero e proprio: <pre># mount -t auto /dev/sdb1 /mnt/miapendrive</pre> In questo esempio si è supposto che la pendrive sia associata al device ''sdb'' e che ''sdb1'' sia la partizione da montare.<br/>
Ora è possibile utilizzare la directory <code>/mnt/miapendrive</code> per tutte le operazioni che dobbiamo svolgere. Ad esempio si possono visualizzare i file contenuti sulla pendrive:
<pre># ls -l /mnt/miapendrive</pre>
Copiare file sulla pendrive:
<pre># cp /etc/network/interfaces /mnt/miapendrive</pre>
Cancellare file dalla pendrive:
<pre># rm /mnt/miapendrive/filedacancellare.txt</pre>
Alla fine, per smontare il dispositivo:
<pre># umount /mnt/miapendrive</pre>
=== Montaggio di un immagine ISO ===
Il comando <code>mount</code> viene molto utile quando abbiamo un'immagine ISO di un CD-Rom e vogliamo vederne il contenuto senza masterizzarla:
<pre>mount -t iso9660 -o loop /cartella/immagine.iso /cartella/di/montaggio</pre>
===  Montaggio di una partizione NTFS ===
Per montare una partizione formattata NTFS occorre che sia installato il pacchetto:
<pre>
# apt-get install ntfs-3g
</pre>
Quindi si proceda come visto in precedenza:
<pre>
# mkdir /mnt/disco_ntfs
# mount -t ntfs-3g /dev/sdb1 /mnt/disco_ntfs
</pre>
E' possibile eseguire automaticamente all'avvio di Debian il montaggio di una partizione NTFS aggiungendo al file <code>/etc/fstab</code> la seguente riga:
<pre>
/dev/sdb1      /mnt/disco_ntfs      ntfs-3g rw,users,suid,umask=000 0      0
</pre>
===Montaggio di una partizione NFS===
Si veda [[Nfs-kernel-server: condividere risorse tra macchine GNU/Linux|questa pagina]] .
===Montaggio di una cartella SAMBA===
Il montaggio di una condivisione Windows di rete può essere eseguito con il comando:
[code]
#mount -t cifs -o username=Nome_utente,password=Password_utente,gid=1000,uid=1000,sec=ntlm //Indirizzo.IP.del.Server/Nome_condivisione /media/punto_di_mount
[/code]
Per approfondimenti si veda [[Samba: guida estesa|questa pagina]] .
== Disconnessione di una risorsa già presente ==
Se volessimo al contrario "sganciare" un disco dal nostro sistema, ci servirà il comando:
<pre>
umount /cartella/da/smontare/
</pre>
Ad esempio:
<pre>
umount /mnt/disco_dati
</pre>
Da questo momento il nostro disco non sarà più raggiungibile.
{{ Warningbox | State attenti a '''non''' eseguire lo smontaggio di dischi di sistema o potreste rendere inutilizzabile il vostro PC }}
== Cercare le directory che occupano più spazio ==
Il seguente comando permette di ricercare le directory di dimensioni più grosse all'interno del nostro filesystem. Il comando ricerca le sottodirectory a partire dalla directory corrente.
<pre>
# du -sk * | sort -rn
</pre>
= Gestione dell'Hardware =
== Ricavare informazioni sul sistema ==
Il comando <code>uname</code> restituisce in output diverse informazioni sul sistema. La sintassi del comando è:
<pre>
uname [OPZIONE]...
</pre>
Le opzioni che possiamo passare al comando sono:
* <code>-s</code>: Mostra il nome del kernel
* <code>-n</code>: Mostra il nome dell'host nel nodo di rete
* <code>-r</code>: Release del kernel
* <code>-v</code>: Versione del kernel
* <code>-m</code>: Nome hardware della macchina
* <code>-p</code>: Tipo di processore
* <code>-i</code>: Piattaforma hardware
* <code>-o</code>: Sistema Operativo
* <code>-a</code>: Mostra tutte le opzioni precedenti
== Lista delle periferiche USB montate ==
Quando abbiamo bisogno di venire a conoscenza delle periferiche USB collegate al sistema (utile, spesso, per sapere se in qualche modo il nostro sistema ha riconosciuto una determinata periferica), possiamo lanciare, da root o con “sudo”, il seguente comando:
<pre>
lsusb
</pre>
Avremo la lista delle porte USB nel nostro PC, e in caso di loro occupazione avremo nella riga della porta USB occupata il nome della periferica connessa, solitamente composto da marca e modello della stessa.
== Lista delle schede PCI montate ==
Quando abbiamo bisogno di venire a conoscenza delle periferiche PCI collegate al sistema (utile, spesso, per sapere se in qualche modo il nostro sistema ha riconosciuto una determinata periferica), possiamo lanciare, da qualsiasi posizione, il seguente comando:
<pre>
lspci
</pre>
Avremo la lista delle schede PCI collegate, inclusa la scheda video.
== Visualizzare lo spazio libero sui dischi ==
Se vogliamo avere una veloce panoramica dello spazio libero di tutti i File System montati ci basta utilizzare il comando:
<pre>
df -h
</pre>
L'opzione <code>-h</code> dice al comando di fornire l'output in un formato facilmente comprensibile.
== Visualizzare lo stato della memoria RAM e della cache ==
Per visualizzare lo stato di utilizzo della RAM e della cache si digiti:
<pre>
free
</pre>
== Visualizzare l'utilizzo delle risorse del sistema ==
Il programma <code>top</code> fornisce una visualizzazione in tempo reale della situazione sull'utilizzo delle risorse di sistema attraverso una tabella dell'attività principale della CPU. <code>top</code> mostra la lista dei task del sistema che fanno un utilizzo più intenso della CPU e mette a disposizione un'interfaccia interattiva per la manipolazione dei processi. I task possono essere ordinati in base all'utilizzo della CPU, all'utilizzo della memoria e al tempo di esecuzione. L'utilizzo più semplice di top prevede la seguente sintassi:
<pre>
top [opzioni]
</pre>
Mentre top è in esecuzione sono riconosciuti diversi comandi ‘‘single-key’’ che sono di seguito descritti:
* <code>'''h'''</code> Mostra un schermata d’aiuto che da una breve sommario dei comandi e lo stato dei secure e cumulative mode.
* <code>'''k'''</code> Killa un processo. Sarà chiesto il PID del task, e il signal da inviare.
* <code>'''q'''</code> Esce da top
* <code>'''s'''</code> Cambia l’intervallo di aggiornamento. Sarà richiesto di specificare il nuovo intervallo da utilizzare (da esprimere in secondi).
* <code>'''m'''</code> Disabilita (riabilita) la visualizzazione delle informazioni sulla memoria.
* <code>'''t'''</code> Disabilita (riabilita) la visualizzazione delle informazioni sui processi e sullo stato della CPU.
* <code>'''M'''</code> Ordina i task in base all’uso di memoria residente.
* <code>'''P'''</code> Ordina i task in base all’uso della CPU (default).
* <code>'''T'''</code> Ordina i task in base al tempo (o al tempo cumulativo).
* <code>'''W'''</code> Salva la configurazione corrente all'interno del file <code>~/.toprc</code>
Il comando <code>top</code> inoltre può essere lanciato specificando alcune opzioni in base alle nostre esigenze. Qui di seguito riportiamo quelle più importanti:
<pre>
top -d secondi
</pre>
Consente di specificare l'intervallo di aggiornamento utilizzato da top espresso in secondi
<pre>
top -s
</pre>
Disabilita alcuni comandi in modo interattivo. Questa opzione torna utile quando si vuole lasciare funzionare top in un terminale separato evitando incidenti.
<pre>
top -i
</pre>
Consente la visualizzazione dei processi inattivi o defunti (chiamati anche zombie)
<pre>
top -c
</pre>
Permette di visualizzare la riga di comando, invece del solo nome del programma.<br>
In alternativa a top possiamo utilizzare il programma <code>htop</code> che è modo simile a top, ma offre la possibilità di scorrere l'elenco di tutti i processi e mette a disposizione comandi interattivi più intuitivi e comodi.
= Varie =
== Arresto del sistema ==
Per spegnere il PC direttamente da terminale, si può lanciare uno dei comandi seguenti:
<pre>
halt
</pre>
oppure
<pre>
shutdown -h now
</pre>
dove
* <code>-h</code> indica che vogliamo arrestare il sistema.
* <code>now</code> indica che non deve trascorrere del tempo prima che il sistema inizi la procedura di spegnimento.
Serve essere root o avere i permessi di sudoer (aggiungere sudo all’inizio della sintassi) affinché il comando vada a buon fine.
== Riavvio del sistema ==
Per riavviare il PC direttamente da terminale, si può lanciare uno dei comandi seguenti:
<pre>
reboot
</pre>
oppure
<pre>
shutdown -r now
</pre>
dove
* <code>-r</code> indica che vogliamo riavviare il sistema.
* <code>now</code> indica che non deve trascorrere del tempo prima che il sistema inizi la procedura di riavvio.
Serve essere root o avere i permessi di sudoer (aggiungere sudo all’inizio della sintassi) affinché il comando vada a buon fine.
== Visualizzare data e ora del sistema ==
È una cosa un po' inutile, ma alle volte può far comodo. Potete vedere data e ora del sistema semplicemente digitando:
<pre>
date
</pre>
== Lanciare applicazioni e programmi da terminale ==
Ora che abbiamo preso dimestichezza con i comandi principali di un terminale Linux possiamo utilizzare la seguente guida per provare a svolgere da terminale anche il nostro lavoro quotidiano. I limiti di utilizzo del terminale Linux sono dati solo dalla nostra fantasia.<br>
Elenco programmi da terminale: [[Elenco_programmi_senza_interfaccia_grafica]]
= Approfondimenti =
=== Sitografia ===
http://vicsteele.wordpress.com/comandi/<br>
http://linuxpedia.netsons.org<br>
http://www.wikipedia.org
{{Autori
{{Autori
|Autore=[[Utente:Ferdybassi|Ferdybassi]] 15:14, 22 dic 2009 (CET)
|Autore=[[Utente:Ferdybassi|Ferdybassi]] 15:14, 22 dic 2009 (CET)
S3v
6 999

contributi

Estratto da "https://guide.debianizzati.org/index.php/Speciale:DiffMobile/33989"

Menu di navigazione