Hébergement Mutualisé LWS Linux et formule domaine 15 Juil. 2024 Créé par Aurélien 0mn de lecture

Come posso gestire il mio hosting con Web Terminal?

Lien de l'article

Sommaire

Procédure

Il Terminale Web disponibile sul vostro account del pannello LWS vi permette di eseguire diverse azioni sulla riga di comando. Queste linee di comando consentono di interagire con l'hosting e possono, in alcuni casi, aiutare a gestire l'hosting.

Questa documentazione spiega come utilizzare il terminale web per interagire con il vostro hosting.

Prima di questa documentazione, vi invitiamo ad accedere al terminale web del vostro hosting.

Spostarsi tra le cartelle con il comando cd

Il comando cd (acronimo di "change directory") serve a cambiare la directory corrente in cui si trova l'utente nel terminale.

Uso di base

Per spostarsi in una directory specifica, si usa cd seguito dal percorso della directory. Ad esempio, per spostarsi in una directory chiamata Documenti, digitate :
```
cd Documenti
```
Questa operazione cambierà la directory corrente in Documenti, a condizione che questa directory esista nella directory corrente.
Per tornare alla directory principale, è sufficiente digitare :
```
cd
```
oppure
```
cd ~
```
Per salire di un livello nella gerarchia delle directory (alla directory madre), usare :
```
cd .
```

Percorsi relativi e assoluti

Percorso relativo: è un percorso relativo alla directory corrente. Ad esempio, se ci si trova in /home/username e si vuole andare in /home/username/Documents, si può semplicemente digitare
```
cd Documenti
```

Percorso assoluto: è un percorso che inizia dalla radice del file system (indicata da una / iniziale). Ad esempio, indipendentemente dalla posizione nel file system, è possibile andare direttamente a /etc digitando :
```
cd /etc
```

Usi avanzati

È possibile combinare i percorsi per andare direttamente a una sottocartella di un'altra directory senza dover cambiare directory più volte. Ad esempio: cd /var/www/html
```
cd /var/www/html
```
Il comando cd - riporta all'ultima directory in cui ci si trovava prima dell'ultimo cd. È utile per passare rapidamente da una directory all'altra.

Suggerimenti

Utilizzate il tasto Tab per il completamento automatico dei nomi delle directory, che vi aiuterà a evitare errori di battitura e a velocizzare la navigazione.
Le virgole possono essere usate per gestire i nomi di directory contenenti spazi:
```
cd "Foto delle vacanze"
```

Il comando cd è fondamentale per navigare nel file system quando si utilizza un'interfaccia a riga di comando.

Esempi:

test2215341@webdbXX:~/htdocs$ cd app test2215341@webdbXX:~/htdocs/app$ cd .. test2215341@webdbXX:~/htdocs$ cd images bash: cd: images: No such file or directory test2215341@webdbXX:~/htdocs$ cd var/cache/prod test2215341@webdbXX:~/htdocs/var/cache/prod$

Nel nostro esempio, nella prima riga ci troviamo nella cartella "htdocs" e ci viene chiesto di spostarci nella cartella "app", situata nella cartella "htdocs", usando il comando"cd app".
Nella seconda riga, ci troviamo nella cartella "app" e vogliamo tornare alla cartella madre "htdocs"; per farlo dobbiamo eseguire il comando"cd ..".
Nella terza riga, siamo di nuovo nella cartella "htdocs" e vogliamo spostarci nella cartella "images".
La quarta riga mostra che non esiste una cartella "images" nella cartella "htdocs".
Infine, nella quinta riga, ci spostiamo direttamente alla cartella "prod" contenuta nella cartella "cache" contenuta nella cartella "var", a sua volta contenuta nella cartella "htdocs" in cui ci troviamo. È quindi possibile andare direttamente a una sottocartella in profondità nella gerarchia senza passare per ogni livello applicando il comando"cd var/cache/prod".

Visualizzazione del contenuto di una cartella con ls

Il comando ls è uno dei comandi più utilizzati. Viene utilizzato per elencare i file e le cartelle contenuti in una directory. Ecco una spiegazione dettagliata del suo funzionamento e delle sue varie opzioni:

Funzione di base

Senza argomenti, ls visualizza i file e le cartelle della directory corrente, senza i file nascosti (quelli il cui nome inizia con un punto).

test2215341@webdbXX:~/htdocs$ ls INSTALL.txt bin default_index.html index.php override themes webservice LICENSES cache docs init.php pdf tools Makefile classes download js phpinfolws.php translations admin908smaiui composer.lock error500.html localization phpstan.neon.dist upload app config images.inc.php mails robots.txt var autoload.php controllers img modules src vendor

Opzioni comuni

-a o --all: Visualizza tutti i file, compresi quelli nascosti.

test2215341@webdbXX:~/htdocs$ ls -a . admin908smaiui composer.lock error500.html localization phpstan.neon.dist upload .. app config images.inc.php mails robots.txt var .htaccess autoload.php controllers img modules src vendor INSTALL.txt bin default_index.html index.php override themes webservice LICENSES cache docs init.php pdf tools Makefile classes download js phpinfolws.php translations

-l: Utilizza un formato lungo per la visualizzazione, che include informazioni dettagliate come i permessi, il numero di link, il proprietario, il gruppo, la dimensione e la data di ultima modifica.
```
test2215341@webdbXX:~/htdocs$ ls -l total 465 -rw-r--r-- 1 test2215341 test2215341 5127 Dec 13 2023 INSTALL.txt -rw-r--r-- 1 test2215341 test2215341 186018 Dic 13 2023 LICENSES -rw-r--r-- 1 test2215341 test2215341 88 Dic 13 2023 Makefile drwxr-xr-x 8 test2215341 test2215341 28 Jul 11 09:04 admin908smaiui drwxr-xr-x 5 test2215341 test2215341 8 Jul 11 09:04 app
```
Questo elenco mostra per ogni riga in ordine :
- Permessi: questo campo mostra i permessi del file o della cartella. Inizia con un carattere che indica il tipo (ad esempio, - per un file e d per una cartella), seguito da tre gruppi di tre caratteri che rappresentano rispettivamente le autorizzazioni del proprietario, del gruppo e degli altri utenti (lettura (r), scrittura (w), esecuzione (x)).
- Numero di link: Questo numero indica quanti collegamenti puntano all'elemento. Per le cartelle, questo numero include le sottocartelle e la cartella stessa.
- Proprietario: il nome dell'utente che possiede il file o la cartella.
- Gruppo: il nome del gruppo associato al file o alla cartella.
- Dimensione: la dimensione del file in byte. Per le cartelle, questa può essere la dimensione della cartella stessa, che può variare a seconda del file system.
- Data di modifica: la data e l'ora dell'ultima modifica del file o della cartella. Il formato può variare, ma generalmente include il giorno, il mese, l'ora e talvolta l'anno.
- Nome: il nome del file o della cartella. I file nascosti sono indicati da un punto . all'inizio del loro nome.

-h o --human-readable (spesso usato con -l)**: Visualizza la dimensione dei file in formato human-readable (K, M, G).

test2215341@webdbXX:~/htdocs$ ls -lh total 465K -rw-r--r-- 1 test2215341 test2215341 5.1K Dec 13 2023 INSTALL.txt -rw-r--r-- 1 test2215341 test2215341 182K Dic 13 2023 LICENSES -rw-r--r-- 1 test2215341 test2215341 88 Dic 13 2023 Makefile drwxr-xr-x 8 test2215341 test2215341 28 Jul 11 09:04 admin908smaiui drwxr-xr-x 5 test2215341 test2215341 8 Jul 11 09:04 app

-t: ordina i file per data di modifica, dal più recente al più vecchio.

test2215341@webdbXX:~/htdocs$ ls -lt total 465 -rwxr-xr-x 1 test2215341 test2215341 19 Jul 12 11:12 phpinfolws.php drwxr-xr-x 6 test2215341 test2215341 8 Jul 11 09:10 var drwxr-xr-x 68 test2215341 test2215341 70 Jul 11 09:10 modules -rw-r--r-- 1 test2215341 test2215341 3148 Jul 11 09:10 robots.txt

Combinazione di opzioni

Le opzioni possono essere combinate per affinare la visualizzazione come richiesto. Ad esempio:

ls -la: Combinazione di -l e -a, per una visualizzazione dettagliata che include i file nascosti.

ls -lh: visualizza i dettagli dei file con le dimensioni in formato leggibile.

test2215341@webdbXX:~/htdocs$ ls -lha total 496K drwxr-xr-x 26 test2215341 test2215341 40 Jul 12 11:16 .
drwxr-xr-x 13 root 23 Jul 12 07:42 . -rw-r--r-- 1 test2215341 test2215341 3,4K Jul 12 11:16 .htaccess -rw-r--r-- 1 test2215341 test2215341 5.1K Dic 13 2023 INSTALL.txt -rw-r--r-- 1 test2215341 test2215341 182K Dic 13 2023 LICENSES -rw-r--r-- 1 test2215341 test2215341 88 Dic 13 2023 Makefile drwxr-xr-x 8 test2215341 test2215341 28 Jul 11 09:04 admin908smaiui drwxr-xr-x 5 test2215341 test2215341 8 Jul 11 09:04 app

Altre opzioni utili

-S: ordina i file per dimensione.
-d: elenca le directory stesse, non il loro contenuto.

Il comando ls è estremamente flessibile e può essere adattato a una moltitudine di situazioni per aiutare gli utenti a navigare e gestire i propri file in modo efficiente.

Visualizzazione della cartella in cui ci si trova con pwd

Il comando pwd sta per "print working directory". Viene utilizzato per visualizzare il percorso completo della cartella in cui si trova l'utente.

Come funziona

Quando si digita pwd nel terminale, il sistema restituisce il percorso assoluto della directory in cui ci si trova. Questo percorso inizia sempre con la radice / e mostra il percorso completo dalla radice alla directory corrente.

test2215341@webdbXX:~/htdocs/var/cache/prod$ pwd /home/htdocs/var/cache/prod

Utilità

Orientamento: pwd è utile per assicurarsi di trovarsi nella directory giusta prima di eseguire comandi che potrebbero influenzare file o cartelle, soprattutto se questi comandi utilizzano percorsi relativi.
Script: negli script di shell, pwd può essere utilizzato per ottenere il percorso della directory in cui lo script è in esecuzione, utile per manipolare i file relativi a tale directory.

pwd è un comando semplice ma fondamentale per la navigazione e la gestione dei file.

Permette di vedere in ogni momento dove ci si trova.

Copiare i file con il comando cp

Il comando cp viene utilizzato per copiare file e cartelle da una posizione all'altra. Questo comando è molto potente e flessibile e offre diverse opzioni per controllare con precisione il modo in cui i file vengono copiati. Ecco una spiegazione dettagliata del suo utilizzo e delle opzioni più comuni.

Funzione di base

Sintassi di base: la forma più semplice del comando cp è cp [sorgente] [destinazione], dove [sorgente] è il percorso del file da copiare e [destinazione] è il percorso in cui il file deve essere copiato.
Copia di più file: È possibile copiare più file in una cartella specificando più sorgenti e una cartella di destinazione, ad esempio, cp file1.txt file2.txt /percorso/destinazione/.

Opzioni comuni

-r: Richiesto per la copia di directory. Consente di copiare in modo ricorsivo tutte le sottocartelle e i file della cartella di origine.
-i: Richiede una conferma prima di sovrascrivere un file esistente. Se un file nella destinazione ha lo stesso nome del file da copiare, cp chiederà se si vuole sovrascrivere il file.
-u: Copia solo quando l'origine è più recente della destinazione o quando la destinazione non esiste.
-v: Visualizza una descrizione di ciò che viene copiato. Questo può aiutare a tenere traccia di ciò che il comando sta facendo.

Esempi di utilizzo

Copia di un singolo file:
```
cp originale.txt copia.txt
```
Copia il file originale.txt nella stessa directory con il nome copy.txt.
Copiare una cartella in modo ricorsivo:
```
cp -r cartella1/ nuova cartella/
```
Copia tutto il contenuto della cartella1 nella nuova cartella, creando la nuova cartella se non esiste già.
Copiare con conferma per evitare la sovrascrittura:
```
test2215341@webdbXX:~/htdocs$ cp -i index.php themes/ cp: sovrascrivere 'themes/index.php'?
```
Se index.php esiste già in themes, cp chiederà se si vuole sovrascrivere il file. Verrà chiesto di rispondere sì o no, a seconda della scelta.
Copia durante la visualizzazione dei dettagli (modalità verbosa):
```
test2215341@webdbXX:~/htdocs$ cp -v index.php themes/ 'index.php' -> 'themes/index.php'
```
Verrà visualizzato un messaggio con i dettagli del file copiato.

Punti da considerare

Per impostazione predefinita, il comando cp non copia i collegamenti simbolici in modo ricorsivo; copia i file a cui puntano. Per copiare i collegamenti stessi, utilizzare l'opzione -d.
Fare attenzione all'opzione -r quando si copiano le cartelle per assicurarsi di non includere file o sottocartelle indesiderate.
I permessi dei file copiati possono essere modificati a seconda dei permessi dell'utente che esegue il comando cp e delle impostazioni umask del sistema.

Il comando cp è essenziale per la gestione dei file in un ambiente a riga di comando e offre una notevole flessibilità nella manipolazione di file e directory.

Spostamento di file con il comando mv

Il comando mv viene utilizzato per spostare o rinominare file e cartelle. Questo comando è essenziale per gestire l'organizzazione dei file nel file system senza la necessità di creare una copia aggiuntiva.

Funzione di base

Spostamento di file: mv [origine] [destinazione] sposta il file o la cartella da [origine] a [destinazione]. Se [destinazione] è un nome di cartella esistente, [sorgente] viene spostato in questa cartella. Se [destinazione] non esiste, il file o la cartella [sorgente] viene rinominato in [destinazione].
Rinominare i file: se si usa mv per spostare un file nella stessa directory e dargli un nuovo nome, ciò equivale a rinominarlo.

Opzioni comuni

-i: Richiede una conferma prima di sovrascrivere un file esistente nella destinazione. Se un file nella destinazione ha lo stesso nome del file di origine, mv chiederà se si vuole sovrascrivere il file.
-u: sposta i file solo se l'origine è più recente della destinazione o se la destinazione non esiste.
-v: Visualizza i dettagli delle operazioni in corso, utili per controllare cosa viene spostato o rinominato.

Esempi di utilizzo

Spostare un file in un'altra directory:
```
mv file.txt /percorso/di/destinazione/
```
Questa operazione sposta file.txt dalla directory corrente a /percorso/di/destinazione/. Se la destinazione è una cartella, file.txt viene spostato all'interno di questa cartella.
Rinominare un file:
```
mv nome_vecchio.txt nome_nuovo.txt
```
Cambia il nome del file nome_vecchio.txt in nome_nuovo.txt nella stessa directory.
Spostare più file in una cartella:
```
mv file1.txt file2.txt /percorso/destinazione/
```
Sposta i file1.txt e file2.txt nella cartella specificata.

Punti da considerare

A differenza del comando cp, mv non crea una copia del file, ma riposiziona il file o la cartella, il che è generalmente più veloce, soprattutto per i file di grandi dimensioni, poiché non vi è alcuna duplicazione dei dati.
Utilizzate l'opzione -i per evitare di sovrascrivere accidentalmente file importanti.
Se si usa mv su file situati su volumi o partizioni diversi, il comando può richiedere più tempo perché deve copiare i dati e poi cancellare l'originale.

Il comando mv è uno strumento importante per la gestione di file e cartelle, che consente di modificare l'organizzazione dei file in modo efficiente e razionale.

Eliminazione di elementi con il comando rm

Il comando rm è utilizzato per eliminare file e directory. È un comando potente e va usato con attenzione perché, a differenza di molti ambienti grafici, in genere non esiste un cestino o un modo semplice per recuperare i file una volta eliminati.

Funzione di base

Eliminare i file: la sintassi di base è rm [opzioni] file..., dove file... rappresenta uno o più file da eliminare. Senza opzioni, rm elimina semplicemente i file specificati.

Opzioni comuni

-r: Elimina le directory e il loro contenuto in modo ricorsivo. Questa opzione è necessaria per eliminare cartelle che contengono a loro volta file o altre cartelle.
-f: forza l'eliminazione dei file, ignorando quelli inesistenti ed eliminandoli senza chiedere conferma. Spesso viene usata insieme a -r per eliminare intere directory senza interruzioni.
-i: richiede una conferma prima di cancellare ogni file. Questo può aiutare a prevenire l'eliminazione accidentale di file.

Esempi di utilizzo

Eliminazione di un singolo file:
```
rm file.txt
```
Questo elimina il file file .txt dal file system, senza chiedere conferma.
Eliminazione di più file:
```
rm file1.txt file2.txt file3.txt
```
Elimina i file file1.txt, file2. txt e file3.txt.
Cancellare una cartella e il suo contenuto:
```
rm -r cartella/
```
Elimina la cartella denominata cartella e tutto il suo contenuto, comprese le altre sottocartelle e i file in essa contenuti.

Eliminazione di file in modo interattivo:

test2215341@webdbXX:~/htdocs$ rm -i error500.html autoload.php rm: rimuovere il file regolare 'error500.html'? sì rm: rimuovere il file regolare 'autoload.php'? no

Chiede conferma prima di cancellare ogni file, il che è utile se non si è sicuri di voler cancellare certi file.

Punti da considerare

Fate molta attenzione con rm, specialmente quando utilizzate le opzioni -r e -f. Un comando sbagliato può portare alla perdita irreversibile di dati importanti.
Sicurezza: spesso è consigliabile usare l'opzione -i per accertarsi di cosa si sta cancellando, oppure elencare i file con ls prima di passarli a rm.
Non è facile da recuperare: a differenza dei sistemi operativi con interfacce grafiche, i file cancellati da rm generalmente non passano attraverso il cestino e sono difficili da recuperare senza strumenti di recupero dati specializzati.

Il comando rm è uno strumento essenziale ma potenzialmente pericoloso nell'arsenale dei comandi e deve essere usato con cautela per evitare perdite accidentali di dati.

Eliminazione di una cartella vuota con il comando rmdir

Il comando rmdir viene utilizzato per eliminare le cartelle vuote. È stato progettato per essere un comando sicuro, in quanto consente di eliminare solo le directory già vuote, evitando così la cancellazione accidentale di file o sottodirectory.

Funzione di base

Eliminazione di directory vuote: la sintassi di base di rmdir è rmdir [opzioni] directory..., dove directory... rappresenta una o più directory che si desidera eliminare.

Opzioni comuni

--ignore-fail-on-non-empty: questa opzione fa sì che rmdir non visualizzi un messaggio di errore se una directory non è vuota. Il comando fallisce comunque, ma in modo silenzioso.
-p: elimina ogni directory nella catena specificata, ma solo se è vuota. Ad esempio, rmdir -p a/b/c tenterà di eliminare successivamente c, b e a, a condizione che siano vuote.

Esempi di utilizzo

Eliminare una semplice cartella vuota:
```
rmdir cartella_vuota
```
Elimina la directory cartella cartella_vuota se è vuota. Se la directory contiene file o sottodirectory, il comando fallisce con un messaggio di errore.
Eliminare più directory vuote:
```
rmdir dir1 dir2 dir3
```
Elimina le directory dir1, dir2 e dir3, purché siano tutte vuote.
Eliminare una catena di directory vuote:
```
rmdir -p a/b/c
```
Se c, b e a sono directory vuote annidate, questo comando le eliminerà tutte, iniziando da c, poi da b e infine da a se tutte sono successivamente vuote.

Punti da considerare

Controllo preliminare: prima di usare rmdir, è spesso una buona idea controllare il contenuto delle directory con il comando ls per assicurarsi che siano davvero vuote.
Uso limitato: rmdir è utile solo per eliminare le directory vuote. Per le directory contenenti file o altre directory, è necessario svuotarle prima manualmente o usare rm -r per eliminarle ricorsivamente, ma con attenzione.

Il comando rmdir è stato progettato specificamente per prevenire la cancellazione accidentale dei dati, il che lo rende meno rischioso di rm -r per le directory, ma anche meno flessibile se si devono gestire directory contenenti file.

Concatenare più file in un unico file con il comando cat

Il comando cat (abbreviazione di concatenate) è usato per visualizzare il contenuto dei file, concatenarlo e reindirizzarlo ad altri output o file. È semplice ma incredibilmente potente e versatile per l'elaborazione di testo e dati.

Funzioni di base

Visualizzare il contenuto di un file: per visualizzare il contenuto di un file direttamente nel terminale, si può usare cat seguito dal nome del file.

test2215341@webdbXX:~/htdocs$ cat robots.txt User-agent: * # Direttive di ammissione Consenti: */moduli/*.css Consenti: */modules/*.js Allow: /js/jquery/* # Pagine private Disallow: /*?order= Disallow: /*?tag=

Questo visualizzerà il contenuto di robot.txt nel terminale.

Concatenare diversi file: cat può essere usato per visualizzare il contenuto di diversi file in successione.
```
cat file1.txt file2.txt file3.txt
```
Visualizza il contenuto di file1.txt, seguito da file2.txt e da file3.txt nel terminale.

Opzioni comuni

-n: numera tutte le righe di output, il che può essere utile quando si esamina il codice o si modificano i file di configurazione.
-b: Numera solo le righe non vuote.
-s: Riduce diverse righe vuote consecutive a una singola riga vuota.
-E: Visualizza un $ alla fine di ogni riga, utile per visualizzare le terminazioni di riga nei file di testo.
-T: Visualizza le tabulazioni come ^I, utile per visualizzare le tabulazioni nei file di testo.

Esempio di concatenazione e reindirizzamento

Per combinare diversi file in uno solo e visualizzare il risultato:

cat file1.txt file2.txt > combinato.txt

Questo concatena file1. txt e file2.txt e reindirizza il risultato a combined.txt.

cat è uno strumento di base ma estremamente utile nell'arsenale dei comandi Unix/Linux, utilizzato sia per semplici operazioni di manipolazione dei file sia come componente di processi di elaborazione dei dati più complessi.

Creare una cartella con il comando mkdir

Il comando mkdir (abbreviazione di make directory) viene utilizzato per creare nuove directory. È uno strumento essenziale per organizzare e gestire i file nel file system.

Funzione di base

Creare una directory semplice: per creare una nuova directory, usare mkdir seguito dal nome della directory che si desidera creare.
```
mkdir new_folder
```
```
Crea una directory chiamata new_folder nella directory corrente
```
.

Opzioni comuni

-p: Questa opzione viene utilizzata per creare più directory padre che non esistono già. Ad esempio, se si desidera creare un percorso di directory come a/b/c e a e b non esistono, mkdir -p a/b/c creerà tutte le directory necessarie.
-m: Permette di impostare i permessi della directory quando viene creata. Ad esempio, per creare una directory con permessi specifici, si può usare mkdir -m 755 folder.

Esempi di utilizzo

Creare diverse directory con un solo comando:
```
mkdir cartella1 cartella2 cartella3
```
In questo modo vengono create tre directory nella directory corrente.
Utilizzate l'opzione -p per creare una struttura di directory:
```
mkdir -p progetti/2023/luglio
```
Questo crea la directory projects, con una sottodirectory 2023 e una sottodirectory July, anche se nessuna di queste directory esiste.

Consigli d'uso

Controllo prima della creazione: per impostazione predefinita, mkdir non controlla se una directory esiste già. Se si tenta di creare una directory già esistente senza utilizzare opzioni aggiuntive, si riceverà un messaggio di errore.
Uso con gli script: mkdir viene spesso utilizzato negli script per garantire l'esistenza della struttura di directory necessaria prima di scrivere file o eseguire altre operazioni.

In sintesi, mkdir è un semplice comando per la creazione di directory, che consente agli utenti di strutturare e organizzare in modo efficiente i propri spazi di lavoro e i propri dati.

Gestione dei permessi di file/cartelle con chmod

Il comando chmod (abbreviazione di change mode) è utilizzato per modificare i permessi di accesso a file e directory. Questo comando controlla chi può leggere, scrivere o eseguire un determinato file o directory.

Concetti chiave

Utenti: i permessi possono essere impostati per tre tipi di utenti:
- u - Proprietario (utente)
- g - Gruppo
- o - Altri
- a - Tutti, cioè proprietario, gruppo e altri.
Autorizzazioni: Esistono tre tipi di autorizzazioni:
- r - Lettura
- w - Scrittura
- x - Esecuzione

Sintassi di base

chmod può essere utilizzato in due modi principali: utilizzando la notazione simbolica o numerica (ottale).

Notazione simbolica

Aggiungere permessi
```
chmod u+w file
```
aggiunge il permesso di scrittura al proprietario del file.

Rimuovere i permessi
```
chmod g-r file
```
rimuove il permesso di lettura dal gruppo.
Imposta permessi specifici
```
chmod o=rx file
```
imposta i permessi di sola lettura ed esecuzione per gli altri.

Notazione numerica (ottale)

Ogni numero rappresenta un insieme di permessi:

0: nessun permesso
1: esecuzione
2: scrivere
3: lettura e scrittura
4: leggere
5: lettura ed esecuzione
6: Lettura e scrittura
7: Lettura, scrittura ed esecuzione

Le autorizzazioni vengono aggiunte per formare un numero per ogni tipo di utente (proprietario, gruppo, altro). Ad esempio :

chmod 755 file

Proprietario: 7 (lettura, scrittura, esecuzione)
Gruppo: 5 (lettura, esecuzione)
Altro: 5 (lettura, esecuzione)

Esempi di utilizzo

Dare a tutti gli utenti il diritto di eseguire uno script:
```
chmod +x script.sh
```
Questo aggiunge il permesso di esecuzione per il proprietario, il gruppo e gli altri.
Impostare permessi specifici per un file:
```
chmod 644 file.txt
```
- Proprietario: lettura e scrittura
- Gruppo e altri: solo lettura
Utilizzare le opzioni per modificare ricorsivamente i permessi di una cartella e del suo contenuto:
```
chmod -R 755 cartella/
```
Questo applica il permesso 755 a tutti i file e le sottodirectory della cartella/.

Consigli d'uso

Attenzione con chmod -R: la modifica dei permessi in modo ricorsivo può avere effetti significativi, soprattutto se applicata in modo non corretto.
Permessi di sicurezza: i file eseguibili e gli script, soprattutto negli ambienti condivisi, devono essere gestiti con cura per evitare problemi di sicurezza.

chmod è uno strumento essenziale per la gestione dei permessi, che garantisce la sicurezza e il buon funzionamento dei file system.

Ricerca di una stringa di caratteri in un file specificato con grep

Il comando grep (Global Regular Expression Print) è un comando potente e versatile utilizzato per cercare testo nei file in base a espressioni regolari o semplici stringhe di caratteri. Viene comunemente utilizzato per filtrare il contenuto di file o flussi in base a modelli specifici.

Funzioni di base

Ricerca di testo: grep cerca le righe contenenti uno schema specifico in uno o più file e visualizza i risultati sullo schermo.
Uso delle espressioni regolari: grep può utilizzare espressioni regolari complesse per ricerche avanzate, consentendo una grande flessibilità nella definizione dei modelli di ricerca.

Sintassi di base

grep [opzioni] pattern [file...]

pattern: il testo o l'espressione regolare che si sta cercando.
file... uno o più file in cui effettuare la ricerca. Se non viene specificato alcun file, grep legge lo standard input.

Opzioni comuni

-i: Ignora le maiuscole e le minuscole durante la ricerca.
-v: Inverte il modello di ricerca, visualizzando le righe che non lo contengono.
-n: Visualizza il numero di riga di ogni riga corrispondente nel file.
-r: Esegue una ricerca ricorsiva in tutte le cartelle e sottocartelle.
-l: Visualizza solo i nomi dei file che contengono lo schema, senza mostrare le righe corrispondenti.
-c: Conta il numero di righe che corrispondono allo schema.
-E: Interpreta il pattern come un'espressione regolare estesa (ERE), consentendo l'uso di una sintassi di espressione regolare più ricca.

Esempi di utilizzo

Trova una semplice stringa in un file:
```
grep "esempio" file.txt
```
visualizza tutte le righe di file.txt contenenti la parola "esempio".
Ricerca ricorsiva di una stringa in tutti i file di una directory:
```
grep -r "esempio" /percorso/di/cartella/
```
Cerca"esempio" in tutti i file della cartella specificata e nelle sue sottocartelle.
Cerca una stringa, ignorando le maiuscole e le minuscole:
```
grep -i "example" file.txt
```
Cerca"example","Example","EXAMPLE", ecc. in file.txt.
Visualizza i file contenenti uno schema senza visualizzare le righe corrispondenti:
```
grep -l "esempio" *.txt
```
Elenca tutti i file .txt contenenti la parola"esempio".
Conta il numero di righe contenenti lo schema:
```
grep -c "esempio" fichier.txt
```
Visualizza il numero di righe contenenti "esempio" in fichier.txt.

In sintesi, grep è uno strumento essenziale per la ricerca di testo e il filtraggio dei dati, utilizzato sia per semplici attività di scripting che per analisi complesse.

Trovare un file con find

Il comando find è uno strumento utilizzato per cercare file e directory in un albero di file in base a vari criteri come il nome del file, la dimensione, il tipo, la data di modifica, i permessi e molti altri criteri.

Funzioni di base

Trova file e directory: find individua file e directory in base a un insieme di condizioni specificate, rendendolo estremamente utile per la gestione dei file e gli script automatici.

Sintassi di base

find [percorso...] [opzioni] [espressione]

percorso... Specifica la directory di partenza per la ricerca. Se non viene fornito alcun percorso, find utilizza la directory corrente.
opzioni: modifica il comportamento del comando find.
espressione: definisce test (come il confronto dei nomi dei file), azioni (come la stampa dei nomi dei file) e operatori logici (come AND, OR e NOT) che determinano il modo in cui find cerca i file.

Opzioni ed espressioni comuni

-nome: Trova i file il cui nome corrisponde allo schema specificato. Gli schemi possono includere caratteri jolly come * e ?.
```
find /path/ -nome "*.txt"
```
-type: Cerca elementi di un tipo specifico, come f per i file o d per le directory.
```
find /path/ -type d
```
-size: ricerca i file in base alla loro dimensione. Ad esempio, +50M per i file più grandi di 50 megabyte, -10k per i file più piccoli di 10 kilobyte.
```
find /chemin/ -size +50M
```
-mtime, -atime, -ctime: Cerca i file modificati (mtime), acceduti (atime) o i cui metadati sono cambiati (ctime) n giorni fa.
```
find /chemin/ -mtime -7
```
-perm: Cerca i file in base ai loro permessi.
```
find /chemin/ -perm 644
```
-exec: Esegue un comando su ogni file trovato.
```
find /chemin/ -type f -exec chmod 644 {}
```
\
```
;
```
-delete: Cancella i file che corrispondono ai criteri specificati.
```
find /path/ -name "*.tmp" -delete
```

Esempi di utilizzo

Trova tutti i file .jpg nella directory /home/user/images e nelle sue sottodirectory:
```
find /home/user/images -type f -name "*.jpg"
```
-delete : Cancella tutti i file .jpg nella directory /home/user/images e nelle suesottodirectory.
Trova ed elimina tutti i file .tmp in /tmp:
```
find /tmp -type f -name "*.tmp" -delete
```
Trovare i file modificati negli ultimi 7 giorni ed elencarli:
```
find /path/ -mtime -7 -ls
```

Consigli d'uso

Fate attenzione a comandi come -delete e -exec, perché possono modificare o eliminare i file in modo irreversibile.
Usare -print, -ls o -exec ls -ld {} + per visualizzare i risultati in modo da comprendere i file trovati.

Il comando find è utile per gestire grandi quantità di file e per automatizzare le attività di manutenzione o di gestione dei file su file system complessi.

Gestione delle scorciatoie con gli alias

Il comando alias viene utilizzato per creare scorciatoie per i comandi del terminale. Un alias sostituisce un comando lungo o complesso con una versione più breve e facile da ricordare. È uno strumento utile per personalizzare l'ambiente della riga di comando, ridurre la digitazione e velocizzare il flusso di lavoro.

Funzioni di base

Creare un alias: è possibile creare un alias utilizzando la seguente sintassi:
```
alias name='comando'
```
Dove name è il nome dell'alias che si desidera utilizzare e command è il comando completo che questo alias deve eseguire.

Esempi di utilizzo

Alias per la navigazione: se si accede spesso a una particolare directory, è possibile creare un alias per semplificare il comando.
```
alias docs='cd /home/user/Documents'.
```
Quindi, digitando semplicemente docs, si verrà spostati in /home/user/Documents.
Alias per l'aggiornamento del sistema: su un sistema Linux che utilizza apt, è possibile creare un alias per i comandi di aggiornamento.
```
alias update='sudo apt update && sudo apt upgrade'".
```
Digitare update per eseguire i comandi di aggiornamento.
Alias per comandi complessi: Per un comando che coinvolge diversi strumenti e opzioni, un alias può semplificare l'immissione.
```
alias findsrc='find . -name "*.c" -print'
```
Consente di cercare tutti i file sorgente C nella directory corrente semplicemente utilizzando findsrc.

Opzioni comuni

Elenco di tutti gli alias esistenti: Per vedere tutti gli alias definiti nella sessione corrente, basta digitare alias senza argomenti.
Cancellare un alias: Per cancellare un alias, usare unalias seguito dal nome dell'alias.
```
unalias nome
```

Suggerimenti per l'uso

Persistenza: gli alias definiti in una sessione del terminale sono temporanei e scompaiono alla chiusura del terminale. Per rendere permanenti gli alias, è necessario aggiungerli al file di configurazione della shell (come .bashrc, .zshrc, ecc.).
```
echo "alias docs='cd /home/user/Documents'" >> ~/.bashrc
```
Quindi ricaricate il file di configurazione con l'origine ~/.bashrc.
Evitare i conflitti: fate attenzione a non assegnare a un alias lo stesso nome di un comando esistente, a meno che non sia fatto intenzionalmente per annullare il comportamento predefinito di quel comando.

Il comando alias è un modo efficace per semplificare e personalizzare l'uso della riga di comando, rendendo più facile ricordare ed eseguire i comandi usati più di frequente.

Editor di testo visivo con nano

Il comando nano lancia Nano, un editor di testo in modalità console per sistemi Unix, Linux e macOS. È stato progettato per essere semplice e facile da usare, il che lo rende una popolare alternativa a editor più complessi come Vim o Emacs. Nano è spesso consigliato ai principianti per la sua semplicità e l'interfaccia intuitiva.

Funzioni di base

Apertura e modifica dei file: per aprire un file in Nano, è sufficiente digitare nano seguito dal nome del file.
```
 
```
Se il file non esiste, Nano ne creerà uno nuovo con quel nome al momento del salvataggio.
```
nano file.txt
```

Interfaccia utente

L'interfaccia di Nano visualizza il contenuto del file nella parte superiore della finestra del terminale. In basso, una barra di stato mostra le informazioni sul file (come i numeri di riga) e una barra di menu con le scorciatoie da tastiera per i comandi più utilizzati. Queste scorciatoie sono visualizzate come ^G (Ctrl+G), il che significa che è necessario premere contemporaneamente Ctrl e G per accedere alla guida.