diff --git a/docs/guides/backup/rsnapshot_backup.it.md b/docs/guides/backup/rsnapshot_backup.it.md index b55293f1e0..a2e872b7e9 100644 --- a/docs/guides/backup/rsnapshot_backup.it.md +++ b/docs/guides/backup/rsnapshot_backup.it.md @@ -1,8 +1,8 @@ --- -title: Backup Solution - Rsnapshot -author: Steven Spencer -contributors: Ezequiel Bruni -tested with: 8.5, 8.6 +title: Soluzione di Backup - Rsnapshot +author: Steven Spencer, Franco Colussi +contributors: Ezequiel Bruni, Franco Colussi +tested with: 8.5, 8.6 tags: - backup - rsnapshot @@ -21,11 +21,11 @@ tags: ## Introduzione -_rsnapshot_ è un'utilità di backup molto potente che può essere installata su qualsiasi macchina basata su Linux. È possibile eseguire il backup di una macchina in locale o di più macchine, ad esempio i server, da un'unica macchina. +Per installare _rsnapshot_ abbiamo bisogno del repository del software EPEL di Fedora. È possibile eseguire il backup di una macchina in locale o di più macchine, ad esempio i server, da un'unica macchina. -_rsnapshot_ utilizza `rsync` ed è scritto interamente in perl senza dipendenze da librerie, quindi non ci sono requisiti strani per installarlo. Nel caso di Rocky Linux, dovreste essere in grado di installare _rsnapshot_ semplicemente installando il repository del software EPEL. +_rsnapshot_ utilizza `rsync` ed è scritto interamente in perl senza dipendenze della libreria, quindi non ci sono requisiti strani per installarlo. Nel caso di Rocky Linux, dovresti essere in grado di installare _rsnapshot_ semplicemente installando il repository software EPEL. -Questa documentazione riguarda l'installazione di _rsnapshot_ solo su Rocky Linux. +Il repository dovrebbe ora essere attivo. ## Installazione di Rsnapshot @@ -33,7 +33,7 @@ Tutti i comandi qui mostrati si riferiscono alla riga di comando del server o de ### Installazione del repository EPEL -Per installare _rsnapshot_ abbiamo bisogno del repository del software EPEL di Fedora. Per installare il repository, basta usare questo comando: +Abbiamo bisogno del repository software EPEL di Fedora per installare _rsnapshot_. Per installare il repository, basta usare questo comando: `sudo dnf install epel-release` @@ -45,7 +45,7 @@ Successivamente, installare _rsnapshot_ stesso: `sudo dnf install rsnapshot` -Se mancano delle dipendenze, queste verranno visualizzate e sarà sufficiente rispondere alla richiesta per continuare. Per esempio: +Questo è il passo più importante. Per esempio: ``` dnf install rsnapshot @@ -70,7 +70,7 @@ Is this ok [y/N]: y ``` ## Montaggio di un'unità o di un file system per il backup -In questa fase viene mostrato come montare un disco rigido, ad esempio un disco rigido USB esterno, che verrà utilizzato per il backup del sistema. Questo passaggio è necessario solo se si esegue il backup di un singolo computer o server, come nel primo esempio riportato di seguito. +Un carattere di spazio fa fallire l'intera configurazione e il backup. Per esempio, all'inizio del file di configurazione c'è una sezione per la `# SNAPSHOT ROOT DIRECTORY #`. 1. Collegare l'unità USB. 2. Digitare `dmesg | grep sd` che dovrebbe mostrare l'unità che si desidera utilizzare. In questo caso, si chiamerà _sda1_. @@ -83,47 +83,39 @@ In questa fase viene mostrato come montare un disco rigido, ad esempio un disco 7. Ora digitate nuovamente `mount | grep sda1` e dovreste vedere qualcosa di simile: `/dev/sda1 on /mnt/backup type ext2 (rw,relatime)` 8. Quindi creare una directory che deve esistere affinché il backup continui sull'unità montata. Per questo esempio utilizzeremo una cartella chiamata "storage": `sudo mkdir /mnt/backup/storage` -Si noti che per una singola macchina, sarà necessario ripetere le operazioni di umount e mount ogni volta che l'unità viene ricollegata o ogni volta che il sistema si riavvia, oppure automatizzare questi comandi con uno script. +Si noti che per una singola macchina è necessario ripetere i passi umount e montare ogni volta che l'unità è collegato di nuovo, o ogni volta che il sistema riavvia o automatizza questi comandi con uno script. -Raccomandiamo l'automazione. L'automazione è la via del sysadmin. +Si consiglia l'automazione. L'automazione è il modo sysadmin. ## Configurazione di rsnapshot -Questo è il passo più importante. È facile commettere un errore quando si apportano modifiche al file di configurazione. La configurazione di _rsnapshot_ richiede l'uso di tabulazioni per la separazione tra gli elementi e un'avvertenza in tal senso si trova all'inizio del file di configurazione. +In questo caso, _rsnapshot_ verrà eseguito localmente per eseguire il backup di un particolare computer. In questo esempio, scomporremo il file di configurazione e mostreremo esattamente le modifiche da apportare. La configurazione _rsnapshot_ richiede schede per ogni separazione tra elementi, e un avviso a questo effetto è nella parte superiore del file di configurazione. -Un carattere di spazio fa fallire l'intera configurazione e il backup. Per esempio, all'inizio del file di configurazione c'è una sezione per la `# SNAPSHOT ROOT DIRECTORY #`. Se lo si aggiungesse da zero, si dovrebbe digitare `snapshot_root`, poi TAB e quindi digitare `/qualunque_percorso_per_la_root_di_snapshot/` +Un personaggio spazio farà fallire l'intera configurazione e il backup. Per esempio, vicino alla parte superiore del file di configurazione è una sezione per il `# SNAPSHOT ROOT DIRECTORY #`. Se lo si aggiungesse da zero, si digita `snapshot_root` poi TAB e quindi digita `/whatever_the_path_to_snapshot_root_will_be/` -La cosa migliore è che la configurazione predefinita fornita con _rsnapshot_ richiede solo piccole modifiche per far funzionare il backup di una macchina locale. È sempre una buona idea, però, fare una copia di backup del file di configurazione prima di iniziare a modificarlo: +La cosa migliore è che la configurazione predefinita che viene fornita con _rsnapshot_ necessita solo di modifiche minori per farlo funzionare per un backup di una macchina locale. È sempre una buona idea, però, fare una copia di backup del file di configurazione prima di iniziare a modificare: -`cp /etc/rsnapshot.conf /etc/rsnapshot.conf.bak` +`snapshot_root /.snapshots/` ## Backup di base della macchina o del singolo server -In questo caso, _rsnapshot_ verrà eseguito localmente per eseguire il backup di un particolare computer. In questo esempio, scomporremo il file di configurazione e mostreremo esattamente le modifiche da apportare. - -Per aprire il file _/etc/rsnapshot.conf_ è necessario utilizzare `vi` (o modificare con il proprio editor preferito). - -La prima cosa da modificare è l'impostazione _snapshot_root_, che per impostazione predefinita ha questo valore: - -`snapshot_root /.snapshots/` - -Dobbiamo cambiare questo punto con il nostro punto di montaggio creato in precedenza, con l'aggiunta di "storage". +In questo caso, _rsnapshot_ sta per essere eseguito localmente per eseguire il backup di una particolare macchina. In questo esempio, spezzeremo il file di configurazione e ti mostreremo esattamente quello che devi cambiare. -`snapshot_root /mnt/backup/storage/` +Dovrai usare `vi` (o modificare con il tuo editor preferito) per aprire il file _/etc/rsnapshot.conf_. -Vogliamo anche dire al backup di NON essere eseguito se l'unità non è montata. Per fare ciò, rimuovete il segno "#" (chiamato anche commento, segno di cancelletto, segno di numero, simbolo di hash, ecc.) accanto a no_create_root, in modo che appaia come questo: +La prima cosa da cambiare è l'impostazione _snapshot_root_ che per impostazione predefinita ha questo valore: `no_create_root 1` -Quindi scendete alla sezione intitolata `# EXTERNAL PROGRAM DEPENDENCIES #` e rimuovete il commento (di nuovo, il segno "#") da questa riga: +Dobbiamo cambiare questo punto con il nostro punto di montaggio creato in precedenza, con l'aggiunta di "storage". `#cmd_cp /usr/bin/cp` -Così che ora si legge: +Vogliamo anche dire al backup di NON eseguire se l'unità non è montata. Per fare questo, rimuovere il segno "#" (chiamato anche una osservazione, segno libbre, segno numerico, simbolo hash, ecc. accanto a no_create_root in modo che assomigli a questo: `cmd_cp /usr/bin/cp` -Anche se non abbiamo bisogno di cmd_ssh per questa particolare configurazione, ne avremo bisogno per l'altra opzione che segue e non fa male averla abilitata. Trovate quindi la riga che dice: +Passa poi alla sezione intitolata `# PROGRAM ESTERNA DEPENDENZE #` e rimuovi il commento (ancora, il segno "#") da questa riga: `#cmd_ssh /usr/bin/ssh` @@ -131,12 +123,20 @@ E rimuovete il segno "#" in modo che appaia come questo: `cmd_ssh /usr/bin/ssh` -Poi dobbiamo passare alla sezione intitolata `# BACKUP LEVELS / INTERVALS #` +Anche se non abbiamo bisogno di cmd_ssh per questa particolare configurazione, ne avremo bisogno per la nostra altra opzione qui sotto e non fa male per averla abilitata. Quindi trovare la linea che dice: -Rispetto alle versioni precedenti di _rsnapshot_ è stato cambiato da `hourly, daily, monthly, yearly` in `alfa, beta, gamma, delta`. Il che è un po' confuso. È necessario aggiungere un'annotazione a tutti gli intervalli che non verranno utilizzati. Nella configurazione, il delta è già stato commentato. +`#cmd_ssh /usr/bin/ssh` Per questo esempio, non verranno eseguiti altri incrementi oltre al backup notturno, quindi è sufficiente aggiungere un'annotazione ad alfa e gamma in modo che la configurazione appaia come questa una volta terminata: +`cmd_ssh /usr/bin/ssh` + +Successivamente dobbiamo passare alla sezione intitolata `# LIVELLI BACKUP / INTERVALS #` + +Questo è stato cambiato dalle versioni precedenti di _rsnapshot_ da `orario, giornaliero, mensile, annuale` a `alfa, beta, gamma, delta`. Che è un po' confusa. Quello che devi fare è aggiungere un'osservazione a qualsiasi intervallo che non utilizzerai. Nella configurazione, il delta è già stato evidenziato. + +Per questo esempio, non saranno in esecuzione altri incrementi diversi da un backup notturno, quindi basta aggiungere un'osservazione all'alfa e alla gamma in modo che la configurazione assomigli a questa quando hai finito: + ``` #retain alpha 6 retain beta 7 @@ -146,37 +146,37 @@ retain beta 7 Ora passate alla riga del file di log, che per impostazione predefinita dovrebbe essere la seguente: -`#logfile /var/log/rsnapshot` +`#logfile /var/log/rsnapshot` -E rimuovete il commento in modo che sia abilitato: +E rimuovere l'osservazione in modo che sia abilitato: -`logfile /var/log/rsnapshot` +`logfile /var/log/rsnapshot` -Infine, passate alla sezione `### BACKUP POINTS / SCRIPTS ###` e aggiungete tutte le directory che volete aggiungere nella sezione `# LOCALHOST`, ricordando di usare TAB anziché SPAZIO tra gli elementi! +Infine, salta alla sezione `### BACKUP POINTS / SCRIPTS ###` e aggiungi tutte le directory che vuoi aggiungere nella sezione `# LOCALHOST` , ricordatevi di usare TAB piuttosto che SPACE tra gli elementi! -Per ora scrivete le vostre modifiche`(SHIFT :wq!` per `vi`) e uscite dal file di configurazione. +Per ora scrivete le vostre modifiche (`SHIFT :wq!` per `vi`) e uscite dal file di configurazione. ### Controllo della Configurazione -Vogliamo assicurarci di non aver aggiunto spazi o altri errori evidenti al nostro file di configurazione mentre lo stavamo modificando. Per fare ciò, si esegue _rsnapshot_ con la nostra configurazione con l'opzione configtest: +Vogliamo assicurarci di non aggiungere spazi o altri errori lampeggianti al nostro file di configurazione durante la modifica. Per fare questo, eseguiamo _rsnapshot_ contro la nostra configurazione con l'opzione configtest: -`rsnapshot configtest` mostrerà `Syntax OK` se non ci sono errori nella configurazione. +`rsnapshot configtest` mostrerà `Sintassi OK` se non ci sono errori nella configurazione. -Si dovrebbe prendere l'abitudine di eseguire configtest quando si modifica una particolare configurazione. Il motivo sarà più evidente quando entreremo nella sezione **Backup di più Macchine o più Server**. +Si dovrebbe avere l'abitudine di eseguire configtest contro una particolare configurazione. Il motivo di ciò sarà più evidente quando entreremo nella sezione **Multiple Machine o Multiple Server Backup**. -Per eseguire configtest con un particolare file di configurazione, è necessario eseguirlo con l'opzione -c per specificare la configurazione: +Per eseguire configtest su un particolare file di configurazione, eseguirlo con l'opzione -c per specificare la configurazione: `rsnapshot -c /etc/rsnapshot.conf configtest` ## Eseguire il Backup la Prima Volta -Tutto è stato verificato, quindi è il momento di eseguire il backup per la prima volta. Se si vuole, si può eseguire prima in modalità di prova, in modo da vedere cosa farà lo script di backup. +Tutto ha fatto il check out, quindi è il momento di andare avanti ed eseguire il backup per la prima volta. È possibile eseguire questo in modalità di prova prima se ti piace, in modo da poter vedere cosa lo script di backup sta per fare. -Anche in questo caso non è necessario specificare la configurazione, ma si dovrebbe prendere l'abitudine di farlo: +Ancora una volta, per fare questo non è necessario specificare la configurazione in questo caso, ma si dovrebbe avere l'abitudine di farlo: `rsnapshot -c /etc/rsnapshot.conf -t beta` -Il risultato dovrebbe essere simile a questo, mostrando cosa accadrà quando il backup verrà effettivamente eseguito: +Che dovrebbe restituire qualcosa di simile, mostrando cosa accadrà quando il backup è effettivamente eseguito: ``` echo 1441 > /var/run/rsnapshot.pid @@ -192,21 +192,21 @@ mkdir -m 0755 -p /mnt/backup/storage/beta.0/ touch /mnt/backup/storage/beta.0/ ``` -Una volta soddisfatti del test, procedere all'esecuzione manuale della prima volta senza il test: +Una volta soddisfatto del test, procedere e eseguirlo manualmente la prima volta senza il test: `rsnapshot -c /etc/rsnapshot.conf beta` -Al termine del backup, navigare in /mnt/backup e dare un'occhiata alla struttura di directory che è stata creata. Ci sarà una directory `storage/beta.0/localhost`, seguita dalle directory specificate per il backup. +Per ripristinare i file, non è necessario scegliere la directory o l'incremento da cui ripristinarli, ma solo la data e l'ora in cui il backup deve essere ripristinato. È un ottimo sistema e utilizza molto meno spazio su disco rispetto a molte altre soluzioni di backup. ### Ulteriori spiegazioni -Ogni volta che viene eseguito il backup, viene creato un nuovo incremento beta, 0-6 o 7 giorni di backup. Il backup più recente sarà sempre beta.0, mentre il backup di ieri sarà sempre beta.1. +Ogni volta che il backup viene eseguito, creerà un nuovo incremento beta, 0-6, o 7 giorni di backup. Il backup più recente sarà sempre beta.0 mentre il backup di ieri sarà sempre beta.1. -Le dimensioni di ciascuno di questi backup sembreranno occupare la stessa quantità (o più) di spazio su disco, ma ciò è dovuto all'uso di hard link _da parte di rsnapshot_. Per ripristinare i file dal backup di ieri, è sufficiente copiarli di nuovo dalla struttura di directory della beta.1. +La dimensione di ciascuno di questi backup apparirà occupare la stessa quantità (o più) di spazio su disco, ma questo è dovuto all'uso di _rsnapshot_ dei collegamenti rigidi. Per ripristinare i file dal backup di ieri, si sarebbe semplicemente copiarli di nuovo dalla struttura directory di beta.1. -Ogni backup è solo un backup incrementale rispetto all'esecuzione precedente, MA, grazie all'uso dei collegamenti diretti, ogni directory di backup contiene il file o il collegamento diretto al file nella directory in cui è stato effettivamente eseguito il backup. +Se non avete mai eseguito questa operazione, scegliete vim.basic come editor o l'editor che preferite quando viene visualizzata la riga `Select an editor`. -Per ripristinare i file, non è necessario scegliere la directory o l'incremento da cui ripristinarli, ma solo la data e l'ora in cui il backup deve essere ripristinato. È un ottimo sistema e utilizza molto meno spazio su disco rispetto a molte altre soluzioni di backup. +Quindi, per ripristinare i file, non è necessario scegliere e scegliere quale directory o incremento per ripristinarli da, a che ora timbro il backup dovrebbe avere che si sta ripristinando. È un grande sistema e utilizza molto meno spazio su disco rispetto a molte altre soluzioni di backup. ## Impostazione dell'esecuzione automatica del backup @@ -214,9 +214,9 @@ Una volta che tutto è stato testato e sappiamo che le cose funzioneranno senza `sudo crontab -e` -Se non avete mai eseguito questa operazione, scegliete vim.basic come editor o l'editor che preferite quando viene visualizzata la riga `Select an editor`. +Se non hai eseguito questo prima, scegli vim. asic come il tuo editor o la tua preferenza di editor quando viene visualizzata la linea `Seleziona un editor`. -Vogliamo impostare il nostro backup in modo che venga eseguito automaticamente alle 23:00, quindi lo aggiungeremo al crontab: +Stiamo per impostare il nostro backup per eseguire automaticamente a 11 PM, quindi aggiungeremo questo al crontab: ``` ## Running the backup at 11 PM @@ -225,15 +225,15 @@ Vogliamo impostare il nostro backup in modo che venga eseguito automaticamente a ## Backup di Più Macchine o Più Server -L'esecuzione di backup di più macchine da una macchina con un array RAID o una grande capacità di archiviazione, in sede o da Internet, funziona molto bene. +Facendo backup di più macchine da una macchina con un array RAID o una grande capacità di archiviazione, in loco o da tutta Internet funziona molto bene. -Se si eseguono questi backup da Internet, è necessario assicurarsi che entrambe le sedi dispongano di una larghezza di banda adeguata per l'esecuzione dei backup. È possibile utilizzare _rsnapshot_ per sincronizzare un server in sede con un array di backup o un server di backup fuori sede per migliorare la ridondanza dei dati. +Se si è già generato un set di chiavi, si può saltare questo passaggio. È possibile scoprirlo eseguendo `ls -al .ssh` e cercando una coppia di chiavi id_rsa e id_rsa.pub. ## Presupposto -Si presume che si stia eseguendo _rsnapshot_ da un computer remoto, in sede. Questa esatta configurazione può essere duplicata, come indicato sopra, anche in remoto fuori sede. +Supponiamo che tu stia eseguendo _rsnapshot_ da una macchina da remoto, on-premise. Questa esatta configurazione può essere duplicata, come indicato sopra, anche fuori sede remota. -In questo caso, è necessario installare _rsnapshot_ sul computer che esegue tutti i backup. Stiamo anche ipotizzando: +In questo caso, si desidera installare _rsnapshot_ sulla macchina che sta facendo tutti i backup. Supponiamo anche: * Che i server su cui si eseguirà il backup abbiano una regola del firewall che consenta alla macchina remota di accedere al server SSH * Che ogni server di cui si intende eseguire il backup abbia installato una versione recente di `rsync`. Per i server Rocky Linux, eseguire `dnf install rsync` per aggiornare la versione di `rsync` del sistema. @@ -241,43 +241,43 @@ In questo caso, è necessario installare _rsnapshot_ sul computer che esegue tut ## Chiavi Pubbliche e Private SSH -Per il server che eseguirà i backup, è necessario generare una coppia di chiavi SSH da utilizzare durante i backup. Per il nostro esempio, creeremo chiavi RSA. +Per il server che eseguirà i backup, abbiamo bisogno di generare una coppia di tasti SSH da utilizzare durante i backup. Per il nostro esempio, creeremo chiavi RSA. -Se si è già generato un set di chiavi, si può saltare questo passaggio. È possibile scoprirlo eseguendo `ls -al .ssh` e cercando una coppia di chiavi id_rsa e id_rsa.pub. Se non esiste, utilizzate il seguente link per impostare le chiavi per il vostro computer e per i server a cui volete accedere: +Se si dispone già di un insieme di chiavi generate, è possibile saltare questo passaggio. Puoi scoprire facendo un `ls -al .ssh` e cercando una coppia di chiavi id_rsa e id_rsa.pub. Se non esiste, utilizzare il seguente link per impostare le chiavi per la macchina e il server a cui si desidera accedere: -[Coppie di Chiavi Private Pubbliche SSH](../security/ssh_public_private_keys.md) +[Ssh Portachiavi Private Pairs](../security/ssh_public_private_keys.md) ## Configurazione di Rsnapshot -Il file di configurazione deve essere identico a quello creato per la **Macchina di Base o per il Backup di un Singolo Server**, tranne che per la modifica di alcune opzioni. +Il file di configurazione deve essere simile a quello che abbiamo creato per il **Basic Machine o il Single Server Backup** di cui sopra, tranne che vogliamo cambiare alcune delle opzioni. -La radice dell'istantanea può essere riportata al valore predefinito in questo modo: +... può essere nuovamente commentata: -`snapshot_root /.snapshots/` +`no_create_root 1` -E questa riga: +E questa linea: -`no_create_root 1` +`cmd_cp /usr/bin/cp` -... può essere nuovamente commentata: +... può essere commentato di nuovo: `#no_create_root 1` -L'altra differenza è che ogni macchina avrà una propria configurazione. Una volta che ci si è abituati, è sufficiente copiare uno dei file di configurazione esistenti con un nuovo nome e modificarlo per adattarlo alle macchine aggiuntive di cui si desidera eseguire il backup. +L'altra differenza è che ogni macchina avrà la propria configurazione. Una volta che ci si abitua, semplicemente copiare uno dei file di configurazione esistenti su un nuovo nome e quindi modificarlo per adattarsi a qualsiasi macchina aggiuntiva che si desidera eseguire il backup. -Per ora, vogliamo modificare il file di configurazione come abbiamo fatto sopra e poi salvarlo. Quindi copiare il file come modello per il nostro primo server: +Per ora, vogliamo modificare il file di configurazione proprio come abbiamo fatto sopra, e poi salvarlo. Quindi copiare quel file come modello per il nostro primo server: `cp /etc/rsnapshot.conf /etc/rsnapshot_web.conf` -Si vuole modificare il nuovo file di configurazione e creare il log e il lockfile con il nome della macchina: +Ecco un esempio di configurazione di web.ourdomain.com: `logfile /var/log/rsnapshot_web.log` -`lockfile /var/run/rsnapshot_web.pid` +`rsnapshot -c /etc/rsnapshot_web.conf configtest` -Successivamente, si vuole modificare rsnapshot_web.conf in modo che includa le directory di cui si vuole fare il backup. L'unica cosa diversa è l'obiettivo. +Come in precedenza, cerchiamo il messaggio `Syntax OK`. L'unica cosa diversa è l'obiettivo. -Ecco un esempio di configurazione di web.ourdomain.com: +Ecco un esempio della configurazione di web.ourdomain.com: ``` ### BACKUP POINTS / SCRIPTS ### @@ -294,7 +294,7 @@ Come in precedenza, ora possiamo verificare la configurazione per assicurarci ch `rsnapshot -c /etc/rsnapshot_web.conf configtest` -Come in precedenza, cerchiamo il messaggio `Syntax OK`. Se tutto è a posto, possiamo eseguire il backup manualmente: +E proprio come prima, stiamo cercando il messaggio `Sintassi OK`. Se tutto va bene, possiamo eseguire il backup manualmente: `/usr/bin/rsnapshot -c /etc/rsnapshot_web.conf beta` @@ -302,7 +302,7 @@ Supponendo che tutto funzioni bene, possiamo creare i file di configurazione per ## Automatizzare il backup -L'automazione dei backup per la versione con più macchine/server è leggermente diversa. Vogliamo creare uno script bash per richiamare i backup in ordine. Quando uno finisce, inizia il successivo. Questo script avrà un aspetto simile a questo e sarà memorizzato in /usr/local/sbin: +L'automazione dei backup per la versione multipla di macchina/server è leggermente diversa. Vogliamo creare uno script bash per chiamare i backup in ordine. Quando uno finirà il prossimo inizierà. Questo script assomiglia a questo e sarà memorizzato in /usr/local/sbin: `vi /usr/local/sbin/backup_all` @@ -315,11 +315,11 @@ Con il contenuto: /usr/bin/rsnapshot -c /etc/rsnapshot_mail.conf beta /usr/bin/rsnapshot -c /etc/rsnapshot_portal.conf beta ``` -Poi rendiamo lo script eseguibile: +E aggiungere questa riga: `chmod +x /usr/local/sbin/backup_all` -Quindi creaiamo il crontab per root per eseguire lo script di backup: +Quindi creare il crontab per eseguire lo script di backup: `crontab -e` @@ -332,14 +332,14 @@ E aggiungere questa riga: ## Segnalazione dello Stato del Backup -Per assicurarsi che il backup avvenga secondo i piani, si consiglia di inviare i file di registro del backup all'indirizzo e-mail. Se si stanno eseguendo backup di più macchine utilizzando _rsnapshot_, ogni file di registro avrà il proprio nome, che potrà essere inviato all'indirizzo e-mail per la revisione utilizzando la procedura [Utilizzo di postfix per la Segnalazione dei Processi del Server](../email/postfix_reporting.md). +Per assicurarsi che tutto è il backup in base alla pianificazione, si potrebbe voler inviare i file di registro di backup alla vostra e-mail. Se stai eseguendo più backup di macchine usando _rsnapshot_, ogni file di log avrà il proprio nome, che puoi quindi inviare alla tua email per la revisione [Utilizzando la procedura postfix For Server Process Reporting](../email/postfix_reporting.md). ## Ripristinare un Backup -Il ripristino di un backup, di alcuni file o di un ripristino completo, comporta la copia dei file desiderati dalla directory con la data di ripristino al computer. Semplice! +Ripristino di un backup, alcuni file o un ripristino completo, comporta la copia dei file che si desidera dalla directory con la data che si desidera ripristinare da indietro alla macchina. Semplice! ## Conclusioni e Altre Risorse -La configurazione corretta di _rsnapshot_ è un po' scoraggiante all'inizio, ma può far risparmiare molto tempo per il backup delle macchine o dei server. +Ottenere la configurazione giusta con _rsnapshot_ è un po 'scoraggiante in un primo momento, ma può risparmiare un sacco di tempo di backup delle macchine o server. -_rsnapshot_ è molto potente, molto veloce e molto economico per quanto riguarda l'utilizzo dello spazio su disco. Per ulteriori informazioni su Rsnapshot, visitare il sito [rsnapshot.org](https://rsnapshot.org/download.html) +_rsnapshot_ è molto potente, molto veloce e molto economico nell'utilizzo dello spazio su disco. Puoi trovare maggiori informazioni su Rsnapshot, visitando [rsnapshot.org](https://rsnapshot.org/download.html) diff --git a/docs/guides/cms/cloud_server_using_nextcloud.it.md b/docs/guides/cms/cloud_server_using_nextcloud.it.md index 5372fc0595..d7097b4402 100644 --- a/docs/guides/cms/cloud_server_using_nextcloud.it.md +++ b/docs/guides/cms/cloud_server_using_nextcloud.it.md @@ -1,8 +1,8 @@ --- -title: Cloud Server Using Nextcloud -author: Steven Spencer -contributors: Ezequiel Bruni -tested with: 8.5, 8.6 +title: Server Cloud con Nextcloud +author: Steven Spencer, Franco Colussi +contributors: Ezequiel Bruni, Franco Colussi +tested with: 8.5, 8.6 tags: - cloud - nextcloud @@ -10,7 +10,7 @@ tags: # Server Cloud con Nextcloud -## Prerequisiti e Presupposti +## Prerequisiti E Presupposti * Server con Rocky Linux (è possibile installare Nextcloud su qualsiasi distribuzione Linux, ma questa procedura presuppone l'utilizzo di Rocky). * Un elevato grado di comfort nell'operare dalla riga di comando per l'installazione e la configurazione. @@ -387,5 +387,5 @@ Il file "Nextcloud Manual.pdf" è il manuale d'uso, in modo che gli utenti possa A questo punto, non dimenticate che si tratta di un server su cui memorizzerete i dati aziendali. È importante mettere in sicurezza il sito con un firewall, [configurare i backup](../backup/rsnapshot_backup.md), proteggere il sito con un [SSL](../security/generating_ssl_keys_lets_encrypt.md) e qualsiasi altra operazione necessaria per mantenere i dati al sicuro. -## Conclusioni e altre risorse +## Conclusioni La decisione di portare il cloud aziendale all'interno dell'azienda deve essere valutata con attenzione. Per coloro che decidono che mantenere i dati aziendali in locale è preferibile rispetto a un host cloud esterno, Nextcloud è una buona alternativa. diff --git a/docs/guides/cms/dokuwiki_server.it.md b/docs/guides/cms/dokuwiki_server.it.md index ec0e60d08e..11b1aeb0cf 100644 --- a/docs/guides/cms/dokuwiki_server.it.md +++ b/docs/guides/cms/dokuwiki_server.it.md @@ -1,8 +1,8 @@ --- -title: DokuWiki -author: Steven Spencer -contributors: Ezequiel Bruni -tested with: 8.5, 8.6 +title: DokuWiki +author: Steven Spencer, Franco Colussi +contributors: Ezequiel Bruni, Franco Colussi +tested with: 8.5, 8.6 tags: - wiki - documentation @@ -10,7 +10,7 @@ tags: # Server DokuWiki -## Prerequisiti e Presupposti +## Prerequisiti E Presupposti * Un'istanza di Rocky Linux installata su un server, un container o una macchina virtuale. * Abilità nel modificare i file di configurazione dalla riga di comando con un editor (gli esempi qui riportati utilizzano _vi_, ma è possibile sostituire l'editor preferito) @@ -103,7 +103,7 @@ Nel server, passare alla root directory. Ora che il nostro ambiente è pronto, prendiamo l'ultima versione stabile di DokuWiki. Potete trovarlo andando alla [pagina di download](https://download.dokuwiki.org/) e sul lato sinistro della pagina, alla voce "Version", vedrete "Stable (Recommended) (direct link)." -Fare clic con il tasto destro del mouse sulla parte "(link diretto)" e copiare l'indirizzo del link. Nella console del vostro server DokuWiki, digitate "wget" e uno spazio e poi incollate il link copiato nel terminale. Si dovrebbe ottenere qualcosa di simile a questo: +Fare clic con il tasto destro del mouse sulla parte "(link diretto)" e copiare l'indirizzo del link. Nella console del vostro server DokuWiki, digitate "wget" e uno spazio e poi incollate il link copiato nel terminale. Dovresti ottenere qualcosa di simile: `wget https://download.dokuwiki.org/src/dokuwiki/dokuwiki-stable.tgz` diff --git a/docs/guides/containers/podman-nextcloud.it.md b/docs/guides/containers/podman-nextcloud.it.md new file mode 100644 index 0000000000..5638f92215 --- /dev/null +++ b/docs/guides/containers/podman-nextcloud.it.md @@ -0,0 +1,459 @@ +--- +title: Nextcloud su Podman +author: Ananda Kammampati +contributors: Ezequiel Bruni, Steven Spencer, Franco Colussi +tested with: 8.5 +tags: + - podman + - containers + - nextcloud +--- + +# Esecuzione di Nextcloud come container Podman su Rocky Linux + +## Introduzione + +Questo documento spiega tutti i passi necessari per costruire ed eseguire un'istanza di [Nextcloud](https://nextcloud.com) come container Podman su Rocky Linux. Inoltre, l'intera guida è stata testata su un Raspberry Pi, quindi dovrebbe essere compatibile con ogni architettura di processore supportata da Rocky. + +La procedura è suddivisa in più fasi, ognuna con i propri script di shell per l'automazione: + +1. Installare i pacchetti `podman` e `buildah` per gestire e costruire i nostri container, rispettivamente +2. Creare un'immagine di base che sarà riutilizzata per tutti i container di cui avremo bisogno +3. Creare un'immagine container `db-tools` con gli script di shell necessari per costruire ed eseguire il database MariaDB +4. Creare ed eseguire MariaDB come container Podman +5. Creazione ed esecuzione di Nextcloud come container Podman, utilizzando il container Podman MariaDB come backend + +La maggior parte dei comandi della guida può essere eseguita manualmente, ma la creazione di alcuni script bash renderà la vita molto più facile, soprattutto quando si desidera ripetere questi passaggi con impostazioni, variabili o nomi di container diversi. + +!!! Note "Nota per i principianti" + + Podman è uno strumento per la gestione dei container, in particolare dei container OCI (Open Containers Initiative). È stato progettato per essere praticamente compatibile con Docker, nel senso che la maggior parte, se non tutti, gli stessi comandi funzioneranno per entrambi gli strumenti. Se "Docker" non significa nulla per voi - o anche se siete solo curiosi - potete leggere di più su Podman e su come funziona su [il sito web di Podman](https://podman.io). + + `buildah` è uno strumento che costruisce immagini di container Podman basate su "DockerFiles". + + Questa guida è stata progettata come esercizio per aiutare le persone a familiarizzare con l'esecuzione dei container Podman in generale e su Rocky Linux in particolare. + +## Prerequisiti e Presupposti + +Ecco tutto ciò di cui avrete bisogno, o che dovrete sapere, per far funzionare questa guida: + +* Familiarità con la riga di comando, gli script bash e la modifica dei file di configurazione di Linux. +* Accesso SSH se si lavora su un computer remoto. +* Un editor di testo a riga di comando di vostra scelta. Per questa guida utilizzeremo `vi`. +* Una macchina Rocky Linux connessa a Internet (anche in questo caso, un Raspberry Pi può andare bene). +* Molti di questi comandi devono essere eseguiti come root, quindi è necessario avere un utente root o con capacità sudo sulla macchina. +* La familiarità con i server web e MariaDB sarebbe sicuramente utile. +* La familiarità con i container e magari con Docker sarebbe *indubbiamente* un vantaggio ma non è strettamente essenziale. + +## Passo 01: Installare `podman` e `buildah` + +Innanzitutto, assicuratevi che il vostro sistema sia aggiornato: + +```bash +dnf update +``` + +Poi si dovrà installare il repository `epel-release` per tutti i pacchetti extra che verranno utilizzati. + +```bash +dnf -y install epel-release +``` + +Una volta fatto questo, si può aggiornare di nuovo (cosa che a volte è utile) o semplicemente andare avanti e installare i pacchetti necessari: + +```bash +dnf -y install podman buildah +``` + +Una volta installati, eseguire `podman --version` e `buildah --version` per verificare che tutto funzioni correttamente. + +Per accedere al registro di Red Hat per scaricare le immagini dei container, è necessario eseguire: + +```bash +vi /etc/containers/registries.conf +``` + +Trovate la sezione che assomiglia a quella che vedete qui sotto. Se è commentato, decommentarlo. + +``` +[registries.insecure] +registries = ['registry.access.redhat.com', 'registry.redhat.io', 'docker.io'] +insecure = true +``` + +## Passo 02: Creare l'immagine del container `di base` + +In questa guida lavoriamo come utente root, ma è possibile eseguire questa operazione in qualsiasi home directory. Passare alla directory principale, se non c'è già: + +```bash +cd /root +``` + +Ora create tutte le directory necessarie per le varie build del container: + +```bash +mkdir base db-tools mariadb nextcloud +``` + +Ora cambiate la vostra directory di lavoro nella cartella dell'immagine di base: + +```bash +cd /root/base +``` + +E creare un file chiamato DockerFile. Sì, anche Podman li usa. + +```bash +vi Dockerfile +``` + +Copiare e incollare il seguente testo nel nuovo file Docker. + +``` +FROM rockylinux/rockylinux:latest +ENV container docker +RUN yum -y install epel-release ; yum -y update +RUN dnf module enable -y php:7.4 +RUN dnf install -y php +RUN yum install -y bzip2 unzip lsof wget traceroute nmap tcpdump bridge-utils ; yum -y update +RUN (cd /lib/systemd/system/sysinit.target.wants/; for i in *; do [ $i == \ +systemd-tmpfiles-setup.service ] || rm -f $i; done); \ +rm -f /lib/systemd/system/multi-user.target.wants/*;\ +rm -f /etc/systemd/system/*.wants/*;\ +rm -f /lib/systemd/system/local-fs.target.wants/*; \ +rm -f /lib/systemd/system/sockets.target.wants/*udev*; \ +rm -f /lib/systemd/system/sockets.target.wants/*initctl*; \ +rm -f /lib/systemd/system/basic.target.wants/*;\ +rm -f /lib/systemd/system/anaconda.target.wants/*; +VOLUME [ "/sys/fs/cgroup" ] +CMD ["/usr/sbin/init"] +``` + +Salvare e chiudere il file precedente e creare un nuovo file di script bash: + +```bash +vi build.sh +``` + +Quindi incollare questo contenuto: + +``` +#!/bin/bash +clear +buildah rmi `buildah images -q base` ; +buildah bud --no-cache -t base . ; +buildah images -a +``` + +Ora rendete eseguibile lo script di compilazione con: + +```bash +chmod +x build.sh +``` + +E poi eseguire: + +```bash +./build.sh +``` + +Aspettate che sia finito e passate alla fase successiva. + +## Passo 03: Creare l'immagine del container `db-tools` + +Per gli scopi di questa guida, manteniamo la configurazione del database il più semplice possibile. È opportuno tenere sotto controllo i seguenti elementi e modificarli se necessario: + +* Nome del database: ncdb +* Utente del database: nc-user +* Pass per il database: nc-pass +* L'indirizzo IP del vostro server (di seguito utilizzeremo un IP di esempio) + +Per prima cosa, spostarsi nella cartella in cui si costruirà l'immagine di db-tools: + +```bash +cd /root/db-tools +``` + +Ora impostiamo alcuni script bash che saranno usati all'interno dell'immagine del container Podman. Per prima cosa, create lo script che costruirà automaticamente il database per voi: + +```bash +vi db-create.sh +``` + +Ora copiate e incollate il seguente codice nel file, utilizzando il vostro editor di testo preferito: + +``` +#!/bin/bash +mysql -h 10.1.1.160 -u root -p rockylinux << eof +create database ncdb; +grant all on ncdb.* to 'nc-user'@'10.1.1.160' identified by 'nc-pass'; +flush privileges; +eof +``` + +Salvare e chiudere, quindi ripetere i passaggi con lo script per l'eliminazione dei database, se necessario: + +```bash +vi db-delete.sh +``` + +Copiate e incollate questo codice nel nuovo file: + +``` +#!/bin/bash +mysql -h 10.1.1.160 -u root -p rockylinux << eof +drop database ncdb; +flush privileges; +eof +``` + +Infine, configuriamo il file Docker per l'immagine di `db-tools`: + +```bash +vi Dockerfile +``` + +Copia e incolla: + +``` +FROM localhost/base +RUN yum -y install mysql +WORKDIR /root +COPY db-drop.sh db-drop.sh +COPY db-create.sh db-create.sh +``` + +Infine, ma non meno importante, creare lo script bash per costruire l'immagine a comando: + +```bash +vi build.sh +``` + +Il codice desiderato: + +``` +#!/bin/bash +clear +buildah rmi `buildah images -q db-tools` ; +buildah bud --no-cache -t db-tools . ; +buildah images -a +``` + +Salvare e chiudere, quindi rendere il file eseguibile: + +```bash +chmod +x build.sh +``` + +E poi eseguire: + +```bash +./build.sh +``` + +## Passo 04: Creare l'immagine del container MariaDB + +State prendendo confidenza con il processo, vero? È il momento di costruire il container di database vero e proprio. Cambiare la directory di lavoro in `/root/mariadb`: + +```bash +cd /root/mariadb +``` + +Creare uno script per (ri)costruire il container ogni volta che si vuole: + +```bash +vi db-init.sh +``` + +Ecco il codice necessario: + +!!! warning "Attenzione" + + Ai fini di questa guida, il seguente script cancellerà tutti i volumi Podman. Se ci sono altre applicazioni in esecuzione con i propri volumi, modificare/commentare la riga "podman volume rm --all"; + +``` +#!/bin/bash +clear +echo " " +echo "Deleting existing volumes if any...." +podman volume rm --all ; +echo " " +echo "Starting mariadb container....." +podman run --name mariadb --label mariadb -d --net host -e MYSQL_ROOT_PASSWORD=rockylinux -v /sys/fs/cgroup:/sys/fs/cgroup:ro -v mariadb-data:/var/lib/mysql/data:Z mariadb ; + +echo " " +echo "Initializing mariadb (takes 2 minutes)....." +sleep 120 ; + +echo " " +echo "Creating ncdb Database for nextcloud ....." +podman run --rm --net host db-tools /root/db-create.sh ; + +echo " " +echo "Listing podman volumes...." +podman volume ls +``` + +È qui che si crea uno script per resettare il database ogni volta che si vuole: + +```bash +vi db-reset.sh +``` + +Ed ecco il codice: + +``` +#!/bin/bash +clear +echo " " +echo "Deleting ncdb Database for nextcloud ....." +podman run --rm --net host db-tools /root/db-drop.sh ; + +echo " " +echo "Creating ncdb Database for nextcloud ....." +podman run --rm --net host db-tools /root/db-create.sh ; +``` + +Infine, ecco lo script di compilazione che metterà insieme l'intero container mariadb: + +```bash +vi build.sh +``` + +With its code: + +``` +#!/bin/bash +clear +buildah rmi `buildah images -q mariadb` ; +buildah bud --no-cache -t mariadb . ; +buildah images -a +``` + +Ora create il vostro DockferFile (`vi Dockerfile`) e incollate la seguente singola riga: + +``` +FROM arm64v8/mariadb +``` + +Ora rendete eseguibile il vostro script di compilazione ed eseguitelo: + +```bash +chmod +x *.sh + +./build.sh +``` + +## Passo 05: Creare ed Eseguire il Container Nextcloud + +Siamo alla fase finale e il processo si ripete praticamente da solo. Passare alla directory dell'immagine di Nextcloud: + +```bash +cd /root/nextcloud +``` + +Questa volta impostate il vostro file Docker per primo, per una questione di varietà: + +```bash +vi Dockerfile +``` + +!!! note "Nota" + + Il prossimo punto presuppone l'architettura ARM (per il Raspberry Pi), quindi se si utilizza un'altra architettura, ricordarsi di cambiarla. + +E incollare questo pezzo: + +``` +FROM arm64v8/nextcloud +``` + +Creare lo script di compilazione: + +```bash +vi build.sh +``` + +E incollare questo codice: + +``` +#!/bin/bash +clear +buildah rmi `buildah images -q nextcloud` ; +buildah bud --no-cache -t nextcloud . ; +buildah images -a +``` + +Ora, imposteremo una serie di cartelle locali sul server host (*no* in nessun container Podman), in modo da poter ricostruire i nostri container e database senza temere di perdere tutti i nostri file: + +```bash +mkdir -p /usr/local/nc/nextcloud /usr/local/nc/apps /usr/local/nc/config /usr/local/nc/data +``` + +Infine, creeremo lo script che costruirà il container Nextcloud per noi: + +```bash +vi run.sh +``` + +Ecco tutto il codice necessario per farlo. Assicurarsi di cambiare l'indirizzo IP di `MYSQL_HOST` con il container docker che sta eseguendo l'istanza di MariaDB. + +``` +#!/bin/bash +clear +echo " " +echo "Starting nextloud container....." +podman run --name nextcloud --net host --privileged -d -p 80:80 \ +-e MYSQL_HOST=10.1.1.160 \ +-e MYSQL_DATABASE=ncdb \ +-e MYSQL_USER=nc-user \ +-e MYSQL_PASSWORD=nc-pass \ +-e NEXTCLOUD_ADMIN_USER=admin \ +-e NEXTCLOUD_ADMIN_PASSWORD=rockylinux \ +-e NEXTCLOUD_DATA_DIR=/var/www/html/data \ +-e NEXTCLOUD_TRUSTED_DOMAINS=10.1.1.160 \ +-v /sys/fs/cgroup:/sys/fs/cgroup:ro \ +-v /usr/local/nc/nextcloud:/var/www/html \ +-v /usr/local/nc/apps:/var/www/html/custom_apps \ +-v /usr/local/nc/config:/var/www/html/config \ +-v /usr/local/nc/data:/var/www/html/data \ +nextcloud ; +``` + +Salvare e chiudere il file, rendere eseguibili tutti gli script, quindi eseguire prima lo script di creazione dell'immagine: + +```bash +chmod +x *.sh + +./build.sh +``` + +Per verificare che tutte le immagini siano state costruite correttamente, eseguire `podman images`. Dovrebbe apparire un elenco simile a questo: + +``` +REPOSITORY TAG IMAGE ID CREATED SIZE +localhost/db-tools latest 8f7ccb04ecab 6 days ago 557 MB +localhost/base latest 03ae68ad2271 6 days ago 465 MB +docker.io/arm64v8/mariadb latest 89a126188478 11 days ago 405 MB +docker.io/arm64v8/nextcloud latest 579a44c1dc98 3 weeks ago 945 MB +``` + +Se tutto sembra corretto, eseguite lo script finale per avviare Nextcloud: + +```bash +./run.sh +``` + +Quando si esegue `podman ps -a`, si dovrebbe vedere un elenco di container in esecuzione che assomiglia a questo: + +``` +CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES +9518756a259a docker.io/arm64v8/mariadb:latest mariadbd 3 minutes ago Up 3 minutes ago mariadb +32534e5a5890 docker.io/arm64v8/nextcloud:latest apache2-foregroun... 12 seconds ago Up 12 seconds ago nextcloud +``` + +Da qui, dovreste essere in grado di puntare il vostro browser all'indirizzo IP del vostro server (ad esempio http://10.1.1.160) e vedere Nextcloud in funzione. + +## Conclusione + +Ovviamente, questa guida dovrà essere modificata in qualche modo su un server di produzione, soprattutto se l'istanza Nextcloud è destinata a essere pubblica. Comunque, questo dovrebbe darvi un'idea di base di come funziona Podman e di come potete configurarlo con script e immagini di base multiple per facilitare le ricostruzioni. diff --git a/docs/guides/custom-linux-kernel.it.md b/docs/guides/custom-linux-kernel.it.md new file mode 100644 index 0000000000..b691c5d51d --- /dev/null +++ b/docs/guides/custom-linux-kernel.it.md @@ -0,0 +1,459 @@ +--- +title: Costruire e installare kernel Linux personalizzati +author: wale soyinka +contributors: Steven Spencer, Franco Colussi +update: 07-Feb-2022 +--- + +# Sommario +In questa guida, passeremo attraverso il processo di acquisizione di un albero sorgente del kernel, configurandolo, compilandolo, e, infine, installando e avviando il kernel. + + +## Il Kernel + +Molto spesso, quando le persone dicono _Linux_, di solito si riferiscono a una "_distribuzione Linux_" —per esempio, Rocky Linux e Debian sono tipi di distribuzione Linux. Una distribuzione comprende tutto il necessario per far sì che Linux esista come sistema operativo funzionale. Le distribuzioni fanno uso di codice da vari progetti open source che sono indipendenti da Linux. + +Linux è il kernel. Il kernel si trova letteralmente al centro della questione [del sistema operativo]. + +L'unica cosa più fondamentale del kernel è l'hardware del sistema stesso. Anche se il kernel è una piccola parte di una distribuzione Linux completa, è di gran lunga l'elemento più critico. Se il kernel fallisce o si blocca, il resto del sistema si blocca con esso. + + +## Il Codice Sorgente Del Kernel + +La distribuzione Rocky Linux ha a disposizione, in una forma o nell'altra, il codice sorgente per la versione specifica del kernel che supporta. Questi possono essere sotto forma di un binario compilato *(.src.rpm), un RPM sorgente (.srpm)* o simili. + +Se hai bisogno di scaricare una versione diversa (forse più recente) rispetto a quella fornita dalla tua specifica distribuzione Rocky Linux, il primo posto per cercare il codice sorgente è nel sito web ufficiale del kernel: + +[www.kernel.org](https://www.kernel.org) + +Questo sito mantiene un elenco di siti web con i mirror dei sorgenti del kernel, oltre a tonnellate di altro software open source, distribuzioni e utilità generiche. + +L'elenco dei mirrors è mantenuto su: + +[mirrors.kernel.org](http://mirrors.kernel.org) + + +!!! TIP "Suggerimento" + + La maggior parte delle operazioni di download, configurazione e compilazione del kernel Linux descritte nelle sezioni seguenti possono/devono essere eseguite da utenti non privilegiati, ma le fasi finali che richiedono l'installazione o la modifica dei file di sistema e dei file binari devono essere eseguite con privilegi elevati. + + Saremo in grado di svolgere la maggior parte del lavoro come utente non privilegiato perché useremo una speciale opzione di compilazione del kernel, che ci permette di specificare una directory di lavoro o di output personalizzata. In particolare, useremo l'opzione `O=~/build/kernel` per tutte le invocazioni di make. + + Dove `~/build/kernel` è equivalente a `/home/$USER/build/kernel` o `$HOME/build/kernel` + +## Versioni del kernel e convenzioni di denominazione + +L'elenco del sito web dei kernel disponibili conterrà cartelle per v1.0, v2.5, v2.6, v3.0, v3.x, v4.x, v5.x, v6.x e così via. Prima di seguire la vostra naturale inclinazione a prendere l'ultima versione, assicuratevi di aver capito come funziona il sistema di versioni del kernel Linux. + +La convenzione attuale è quella di chiamare e numerare le nuove versioni principali del kernel come "Linux 5.x" (chiamate anche kernel vanilla o mainline). Pertanto, la prima di questa serie sarà la versione 5.0 di Linux (uguale alla 5.0.0), la successiva sarà la versione 5.1 di Linux (uguale alla 5.1.0), seguita dalla versione 5.2 e così via. + +Eventuali modifiche o aggiornamenti minori all'interno di ciascuna versione della major release si rifletteranno con incrementi alla terza cifra. Questi vengono comunemente chiamati rilasci di punti stabili. Pertanto, la prossima release stabile per il kernel della serie 5.0.0 sarà la versione 5.0.1 di Linux, seguita dalla versione 5.0.2 e così via. Un altro modo per affermare ciò è dire, ad esempio, che la versione 5.0.4 di Linux è la quarta release stabile basata sulla serie 5.0.0 di Linux. + +## Installare gli strumenti e le librerie richieste + +Una fonte comune di fallimento riscontrata durante il processo di creazione del kernel può essere causata dalla mancanza di tutto il software necessario per la compilazione e la creazione del kernel Linux mainline. Gli strumenti e le librerie mancanti possono essere installate utilizzando il gestore di pacchetti DNF su una distro Rocky Linux. Ci occuperemo di questo in questa sezione. + +1. Su una distribuzione Rocky Linux, è possibile ottenere rapidamente la maggior parte degli strumenti di sviluppo necessari installati eseguendo questo comando: + + ``` + > sudo dnf -y groupinstall 'C Development Tools and Libraries' + ``` + +2. Alcune altre librerie, file di intestazione e applicazioni di cui si potrebbe aver bisogno possono essere ottenute installando i seguenti pacchetti. Digita: + + ``` + > sudo dnf -y install \ + ncurses-devel openssl-devel elfutils-libelf-devel python3 + ``` + +3. Successivamente, abbiamo bisogno di altre utilità che sono disponibili solo in alcuni archivi di terze parti supportati. Uno di queste repository è il repo di Powertools. Abilitiamo questo repo sul nostro sistema Rocky. Digita: + + ``` + > sudo dnf config-manager --set-enabled powertools + ``` + +4. Infine, installiamo uno dei pacchetti necessari dal repo Powertool. Digita: + + ``` + > sudo dnf -y install dwarves + ``` + +Questo è tutto per quanto riguarda i pacchetti richiesti necessari per la costruzione del Kernel! + +## Scaricare e decomprimere il kernel Linux + +La versione del kernel che stiamo per costruire nella sezione seguente è la versione 5.16.9, disponibile all'indirizzo: + +[www.kernel.org/pub/linux/kernel/v5.x/linux-5.16.9.tar.xz](https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.16.9.tar.xz) + +Iniziamo il processo. + +1. Innanzitutto, utilizzare il seguente comando curl per scaricare il sorgente del kernel necessario nella directory di lavoro corrente. Digita: + + ``` + curl -L -o linux-5.16.9.tar.xz \ + https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.16.9.tar.xz + ``` + +2. Il sorgente del kernel che scaricherai da Internet è un file che è stato compresso con tar. Pertanto, per utilizzare i sorgenti, è necessario decomprimere e fare l'untar del file sorgente. + + Assicurarsi di essere nella directory in cui si è scaricato il tarball del Kernel. Utilizzare il comando tar per scompattare e decomprimere il file, eseguendo: + + ``` + tar xvJf linux-5.*.tar.xz + ``` + +## Costruire il Kernel + +In questa sezione, esamineremo il processo di configurazione e costruzione di un kernel. Questo è in contrasto con macOS o sistemi operativi basati su Windows, che vengono preconfigurati e quindi contengono supporto per molte funzioni che potresti non volere. + +La filosofia di progettazione di Linux consente all'individuo di decidere le parti importanti del kernel. Questa progettazione personalizzata ha l'importante vantaggio di consentire di ridurre l'elenco delle funzionalità in modo che Linux possa funzionare nel modo più efficiente possibile. + +Questo è anche uno dei motivi per cui è possibile personalizzare Linux per farlo funzionare in diverse configurazioni hardware, dai sistemi di fascia bassa, ai sistemi embedded, ai sistemi di fascia alta. + +Due passi principali sono necessari per costruire un kernel: + +- configurazione +- compilazione + +Il primo passo nella costruzione del kernel è la configurazione delle sue funzionalità. Di solito, la lista di funzionalità desiderata sarà basata su qualsiasi hardware è necessario supportare. Questo, naturalmente, significa che avrete bisogno di un elenco di quell'hardware. + +Su un sistema che esegue già Linux, è possibile eseguire comandi come lspci, lshw e così via per visualizzare informazioni dettagliate sull'esatta configurazione hardware del sistema. Nelle distro basate su RPM queste utilità sono fornite dai pacchetti *pciutils.rpm e lshw.rpm*. + +Una migliore comprensione di ciò che costituisce l'hardware sottostante può aiutare a determinare meglio ciò di cui si ha bisogno nel kernel personalizzato. Sei pronto per iniziare a configurare il kernel. + +### Sanificazione dell'ambiente di compilazione + +Con un'idea approssimativa dei tipi di hardware e delle caratteristiche che il nostro nuovo kernel ha bisogno di supportare, possiamo iniziare la configurazione reale. Ma prima, alcune informazioni di base. + +L'albero dei sorgenti del kernel Linux contiene diversi file denominati Makefile (un makefile è semplicemente un file di testo con delle direttive e descrive anche le relazioni tra i file di un programma). + +Questi makefile aiutano a incollare insieme le migliaia di altri file che compongono il sorgente del kernel. Ciò che è più importante per noi è che i makefile contengono anche obiettivi. Gli obiettivi sono i comandi, o direttive, che vengono eseguiti dal programma make. + + +!!! Caution "Attenzione: Evitare Inutili Aggiornamenti Kernel" + + Tenete presente che se avete un sistema funzionante, stabile e ben funzionante, non c'è motivo di aggiornare il kernel, a meno che non si verifichi una di queste condizioni: + + - Un bug fix o di sicurezza influisce sul sistema e deve essere applicato + - Hai bisogno di una nuova funzione specifica in un rilascio stabile + + Nel caso di una correzione di sicurezza, decidete se il rischio vi riguarda davvero: ad esempio, se il problema di sicurezza è stato riscontrato in un driver di periferica che non utilizzate, potrebbe non esserci motivo di aggiornare. Nel caso di un rilascio con correzione di bug, leggete attentamente le note di rilascio e decidete se i bug vi riguardano davvero: se avete un sistema stabile, aggiornare il kernel con patch che non usate mai potrebbe essere inutile. + + Sui sistemi di produzione, il kernel non dovrebbe essere semplicemente aggiornato solo per avere “il kernel più recente”; si dovrebbe avere una ragione davvero convincente per aggiornarlo. + +Il Makefile nella radice dell'albero dei sorgenti del kernel contiene obiettivi specifici che possono essere usati per preparare l'ambiente di compilazione del kernel, configurare il kernel, compilare il kernel, installare il kernel e così via. Alcuni degli obiettivi sono discussi in dettaglio qui: + +- **make mrproper** Questo obiettivo ripulisce l'ambiente di compilazione da tutti i file e le dipendenze obsolete che potrebbero essere rimaste da una precedente compilazione del kernel. Tutte le configurazioni del kernel precedenti verranno pulite (eliminate) dall'ambiente di compilazione. +- **make clean** Questo obiettivo non svolge un lavoro così approfondito come l'obiettivo mrproper. Elimina solo la maggior parte dei file generati. Non elimina il file di configurazione del kernel (.config). +- **make menuconfig** Questo obiettivo richiama un'interfaccia di editor basata sul testo con menu, elenchi di opzioni e finestre di dialogo basate sul testo per la configurazione del kernel. +- **make xconfig** Si tratta di uno strumento/obiettivo di configurazione del kernel basato su interfaccia grafica che si basa sulle librerie di sviluppo grafico Qt. Queste librerie sono usate da applicazioni basate su KDE/Plasma. +- **make gconfig** Anche questo è uno strumento/obiettivo di configurazione del kernel basato su GUI, ma si basa sul toolkit GTK+. Questo toolkit GTK è usato pesantemente nel mondo del desktop GNOME. +- **make olddefconfig** Questo obiettivo utilizza il file .config esistente nella directory di lavoro corrente, aggiorna le dipendenze e imposta automaticamente i nuovi simboli ai valori predefiniti. +- **make help** Questo obiettivo mostra tutti gli altri possibili obiettivi di creazione e funge anche da rapido sistema di guida in linea. + +Per configurare il kernel in questa sezione, utilizzeremo solo uno degli obiettivi. In particolare, useremo il comando make menuconfig. L'editor di configurazione del kernel menuconfig è una semplice e popolare utilità di configurazione basata sul testo che consiste di menu, elenchi di pulsanti radio e dialoghi. + +Ha un'interfaccia semplice e pulita che può essere facilmente navigata con la tastiera ed è abbastanza intuitivo da usare. + +Dobbiamo cambiare (cd) nella directory dei sorgenti del kernel, dopodiché possiamo iniziare la configurazione del kernel. Ma prima di iniziare la configurazione reale del kernel, è necessario pulire (preparare) l'ambiente di generazione del kernel utilizzando il comando make mrproper: + +``` +> cd linux-5.* +> make O=~/build/kernel mrproper +``` + +### Configurazione del Kernel + +Successivamente, verrà illustrato il processo di configurazione di un kernel Linux serie 5.*. Per esplorare alcuni dei meccanismi interni di questo processo, abiliteremo il supporto di una funzione specifica che fingeremo essere una caratteristica indispensabile del sistema. Una volta capito come funziona, si può applicare la stessa procedura per aggiungere il supporto a qualsiasi altra nuova funzione del kernel che si desidera. In particolare, attiveremo il supporto per il file system NTFS nel nostro kernel personalizzato. + +La maggior parte delle moderne distro Linux viene fornita con un file di configurazione del kernel in esecuzione, disponibile sul file system locale come file compresso o normale. Nel nostro sistema Rocky di esempio, questo file risiede nella directory /boot e di solito ha un nome come config-4.*. + +Il file di configurazione contiene un elenco delle opzioni e delle caratteristiche abilitate per il particolare kernel che rappresenta. Un file di configurazione simile a questo è quello che si vuole creare durante il processo di configurazione del kernel. L'unica differenza tra il file che creeremo e quello già pronto è che al nostro aggiungeremo ulteriori piccole personalizzazioni. + + +!!! TIP "Suggerimento" + + L'utilizzo di un file di configurazione noto e preesistente come quadro di riferimento per la creazione del nostro file personalizzato ci permette di non perdere troppo tempo a duplicare gli sforzi che altre persone hanno già fatto per trovare ciò che funziona e ciò che non funziona! + +I passi seguenti spiegano come configurare il kernel. Utilizzeremo un'utilità di configurazione del kernel basata sul testo, che vi consentirà di seguire la procedura nel vostro terminale, indipendentemente dal fatto che utilizziate o meno un ambiente desktop con interfaccia grafica. + +1. Per iniziare, copiamo e rinominiamo il file di configurazione preesistente dalla directory /boot nel nostro ambiente di creazione del kernel: + ``` + > cp /boot/config-`uname -r` ~/build/kernel/.config + ``` + Qui si usa `uname -r` per ottenere il file di configurazione del kernel in esecuzione. Il comando uname -r stampa la release del kernel in esecuzione. L'utilizzo di questa funzione ci consente di assicurarci di ottenere la versione esatta che desideriamo, nel caso in cui siano presenti altre versioni. + + !!! NOTE "Nota" + + L'editor di configurazione del kernel Linux inizia a cercare, e finisce per generare, un file chiamato .config (pronunciato "dot config") nella radice dell'albero dei sorgenti del kernel. Questo file è nascosto. + +2. Avviare l'utilità di configurazione del kernel grafico: + + ``` + > make O=~/build/kernel menuconfig + ``` + + Apparirà una schermata simile a questa: + +![Schermata Principale di Configurazione del Kernel](images/Il01-kernel.png) + + La schermata di configurazione del kernel che appare è divisa approssimativamente in tre aree. + La parte superiore mostra varie informazioni utili, scorciatoie da tastiera e legende che possono aiutare a navigare nell'applicazione. + Il corpo principale della schermata mostra un elenco espandibile a struttura ad albero delle opzioni del kernel complessivamente configurabili. È possibile approfondire le voci con le frecce di controllo per visualizzare e/o configurare le voci dei sottomenu (o figli). Infine, nella parte inferiore dello schermo vengono visualizzate le azioni/opzioni che l'utente può scegliere. + +3. Successivamente, a scopo dimostrativo, aggiungeremo il supporto per NTFS nel nostro kernel personalizzato. + + Nella schermata della configurazione principale, utilizzare i tasti freccia per spostarsi ed evidenziare la voce File systems. Una volta selezionato File systems, premere invio per visualizzare il menu secondario o le voci secondarie di File systems. + + Nella sezione File Systems utilizzare i tasti freccia per spostarsi su DOS/FAT/NT Filesystems. Premete invio per visualizzare le voci secondarie per i file system DOS/FAT/NT. + +4. Nella sezione Filesystem DOS/FAT/NT, passare al supporto del file system NTFS. + + Digitare M (maiuscolo) per abilitare il supporto del file system NTFS tramite moduli. + + Utilizzare i tasti freccia per spostarsi verso il basso fino a NTFS debugging support NTFS (NEW) e premere y per includerlo. + + Utilizzare i tasti freccia per spostarsi verso il basso fino a NTFS write support e premere y per includerlo. Al termine, accanto a ogni opzione dovrebbe comparire la lettera M o il simbolo dell'asterisco (*), come quelli mostrati qui: + + ![Schermata Configurazione File Systems del Kernel](images/Il02-kernel.png) + + !!! TIP "Suggerimento" + + Per ciascuna delle opzioni configurabili, nell'utilità di configurazione del kernel, le parentesi angolari vuote, <>, indicano che la funzione in questione è disabilitata. La lettera M tra parentesi angolari, , indica che la funzione deve essere compilata come modulo. + + Il simbolo dell'asterisco tra parentesi angolari, <*>, indica che il supporto per la funzione sarà integrato direttamente nel kernel. Di solito è possibile scorrere tutte le opzioni possibili utilizzando la barra spaziatrice della tastiera. + +5. Tornare alla schermata principale dei File Systems premendo due volte il tasto esc sulla tastiera nella schermata DOS/FAT/NT Filesystems. Tornare alla schermata principale di configurazione del kernel premendo nuovamente due volte esc sulla tastiera. + +6. Infine, salvare le modifiche nel file .config nella radice dell'albero dei sorgenti del kernel e uscire dall'applicazione di configurazione del kernel dopo aver salvato il file premendo di nuovo esc due volte sulla tastiera. + +7. Apparirà una finestra di dialogo che ti chiederà di salvare la tua nuova configurazione. Assicurarsi che Yes sia selezionato e quindi premere Invio. + +8. Dopo l'uscita dall'utilità di configurazione del kernel, si tornerà alla shell all'interno dell'albero dei sorgenti del kernel! + +9. Dobbiamo completare alcune personalizzazioni sulla nostra distro Rocky. Digita: + + ``` + sed -ri '/CONFIG_SYSTEM_TRUSTED_KEYS/s/=.+/=""/g' ~/build/kernel/.config + ``` + + !!! TIP "Suggerimento" + + Per visualizzare i risultati di alcune delle modifiche apportate con lo strumento menuconfig, usare l'utilità grep per visualizzare direttamente il file .config salvato. Ad esempio, per visualizzare l'effetto del supporto del file system NTFS attivato in precedenza, digitate quanto segue: + ``` + > grep NTFS ~/build/kernel/.config + CONFIG_NTFS_FS=m + CONFIG_NTFS_DEBUG=y + CONFIG_NTFS_RW=y + ``` + !!! NOTE "Una Breve Nota sui Moduli del Kernel" + + Il supporto per i moduli caricabili è una caratteristica del kernel Linux che consente il caricamento (o la rimozione) dinamica dei moduli del kernel. + + I moduli del kernel sono pezzi di codice compilato che possono essere inseriti dinamicamente nel kernel in esecuzione, anziché essere integrati in modo permanente nel kernel. Le funzioni non utilizzate di frequente possono quindi essere abilitate, ma non occuperanno spazio nella memoria quando non vengono utilizzate. + + Fortunatamente, il kernel Linux è in grado di determinare automaticamente cosa caricare e quando. Naturalmente, non tutte le funzioni possono essere compilate come moduli. Il kernel deve sapere alcune cose prima di poter caricare e scaricare i moduli, ad esempio come accedere al disco rigido e analizzare il file system in cui sono memorizzati i moduli caricabili. Alcuni moduli del kernel vengono comunemente chiamati anche driver. + +### Compilazione del Kernel + +Nella sezione precedente abbiamo illustrato il processo di creazione di un file di configurazione per il kernel personalizzato che vogliamo costruire. In questa sezione, eseguiremo la costruzione effettiva del kernel. Ma prima di fare questo, aggiungeremo una semplice personalizzazione all'intero processo. + +La personalizzazione finale consisterà nell'aggiungere un'informazione supplementare utilizzata nel nome finale del nostro kernel. Questo ci aiuterà a distinguere questo kernel da qualsiasi altro kernel con lo stesso numero di versione. Aggiungeremo il tag "custom" alle informazioni sulla versione del kernel. Questo può essere fatto modificando il Makefile principale e aggiungendo il tag desiderato alla variabile EXTRAVERSION. + +La fase di compilazione del processo di creazione del kernel è di gran lunga la più semplice, ma richiede anche più tempo. A questo punto è sufficiente eseguire il comando make, che genererà automaticamente e si occuperà di eventuali problemi di dipendenza, compilerà il kernel stesso e compilerà tutte le funzionalità (o i driver) che sono state abilitate come moduli caricabili. + +A causa della quantità di codice che deve essere compilato, preparatevi ad aspettare almeno qualche minuto, a seconda della potenza di elaborazione del vostro sistema. Analizziamo i passi specifici necessari per compilare il nuovo kernel. + +1. Per prima cosa aggiungeremo un pezzo in più alla stringa di identificazione del kernel che stiamo per costruire. Mentre siamo ancora nella radice dell'albero dei sorgenti del kernel, useremo l'utilità sed per modificare il Makefile. La variabile che vogliamo cambiare è vicina alla parte superiore del file. Vogliamo cambiare la riga nel file che assomiglia a questa: + + ``` + EXTRAVERSION = + ``` + + In questa: + + ``` + EXTRAVERSION = -custom + ``` + + Usa il seguente comando `sed` per effettuare la modifica. Digita: + + ``` + sed -i 's/^EXTRAVERSION.*/EXTRAVERSION = -custom/' Makefile + ``` + + Naturalmente è possibile utilizzare qualsiasi editor di testo con cui si ha dimestichezza per apportare le modifiche. Basta ricordarsi di salvare le modifiche al file! + +2. Passare il target kernelversion al comando make per visualizzare la versione completa del kernel appena personalizzato: + + ``` + > make O=~/build/kernel kernelversion + ``` + + !!! Tip "Suggerimento" + + È possibile sfruttare tutta la potenza di elaborazione extra (CPU, core e così via) sulla maggior parte dei sistemi moderni e accelerare notevolmente le operazioni ad alta intensità di CPU come la compilazione del kernel. A tale scopo, è possibile passare un parametro al comando make che specifichi il numero di lavori da eseguire simultaneamente. Il numero di lavori specificato viene quindi distribuito ed eseguito simultaneamente su ciascun core della CPU. La sintassi del comando è: + + ``` + > make -j N + ``` + dove N è il numero di lavori da eseguire contemporaneamente. Ad esempio, se si dispone di una CPU con capacità octa (8) core, è possibile digitare: + + ``` + > make -j 8 + ``` + +3. L'unico comando necessario per compilare il kernel è il comando make: + + ``` + > make O=~/build/kernel** + make[1]: Entering directory '/home/super/build/kernel' + SYNC include/config/auto.conf.cmd + GEN Makefile + HOSTCC scripts/kconfig/conf.o + HOSTLD scripts/kconfig/conf + GEN Makefile + ...… + LD [M] sound/usb/usx2y/snd-usb-usx2y.ko + LD [M] sound/x86/snd-hdmi-lpe-audio.ko + LD [M] sound/xen/snd_xen_front.ko + LD [M] virt/lib/irqbypass.ko + make[1]: Leaving directory '/home/super/build/kernel' + ``` + +4. Il prodotto finale di questo comando (cioè il kernel) è in attesa nel percorso: + + ``` + ~/build/kernel/arch/x86/boot/bzImage + ``` + +5. Poiché abbiamo compilato parti del kernel come moduli (ad esempio, il modulo NTFS), dobbiamo installare i moduli. Digitare quanto segue: + + ``` + > sudo make O=~/build/kernel modules_install + ``` + + Sul nostro sistema Rocky, questo comando installerà tutti i moduli compilati del kernel nella cartella /lib/modules/ . In questo esempio, il percorso si tradurrà in /lib/modules/5.16.9-custom/. È il percorso dal quale il kernel caricherà tutti i moduli caricabili, se necessario. + + !!! TIP "Suggerimento" + + Il footprint (dimensione) dei moduli del kernel installati tramite "make modules_install" può diventare piuttosto grande perché i moduli includono simboli di debug. Di conseguenza, si potrebbe facilmente ritrovarsi con una cartella `/lib/modules/5.16.9-custom/` di dimensioni prossime ai 5 Gb! + + Per questa guida evitiamo queste dimensioni elevate includendo l'opzione INSTALL_MOD_STRIP=1 nell'invocazione di make modules_install. È possibile ridurre la dimensione totale in ordini di grandezza (ad esempio, meno di 200 MB!) eliminando questi simboli di debug. + + Questo può essere fatto includendo l'opzione `INSTALL_MOD_STRIP=1` al comando `make modules_install`. + +## Installazione del Kernel + +Supponendo che tu abbia un PC e stia lavorando fuori dalla directory `~/build/kernel/`, il kernel compilato creato nell'esercizio precedente si troverà in questo percorso - `/arch/x86/boot/bzImage` oppure, per essere precisi, nel nostro esempio `~/build/kernel/arch/x86/boot/bzImage`. + +Il file di mappa corrispondente per questo si trova in ~/build/kernel/System.map. Avrete bisogno di entrambi i file per la fase di installazione. + +Il file System.map è utile quando il kernel si comporta erroneamente e genera messaggi “Oops”. Un "Oops" viene generato su alcuni errori del kernel a causa di bug del kernel o di hardware difettoso. + +Questo errore è simile al Blue Screen of Death (BSOD) di Microsoft Windows. Questi messaggi includono molti dettagli sullo stato attuale del sistema, compresi diversi numeri esadecimali. + +System.map dà a Linux la possibilità di trasformare i numeri esadecimali in nomi leggibili, facilitando il debug. Sebbene sia principalmente a beneficio degli sviluppatori, può essere utile quando si segnala un problema. + +Esaminiamo i passaggi necessari per installare la nuova immagine del kernel. + +1. Nella radice della directory di creazione del kernel, copiare e rinominare il file bzImage nella directory /boot: + + ``` + > **sudo cp ~/build/kernel/arch/x86/boot/bzImage \ + /boot/vmlinuz-** + ``` + + Qui, kernel-version è il numero di versione del kernel. Per il kernel di esempio che stiamo usando in questa guida, il nome del file sarà vmlinuz-5.16.9-custom. Ecco il comando esatto per questo esempio: + + ``` + > sudo cp ~/build/kernel/arch/x86/boot/bzImage \ + /boot/vmlinuz-5.16.9-custom + ``` + + !!! Note "Nota" + + La decisione di chiamare l'immagine del kernel vmlinuz-5.16.9-custom è in qualche modo arbitraria. È comodo, perché le immagini del kernel sono comunemente chiamate vmlinuz e il suffisso del numero di versione è utile quando si hanno a disposizione più kernel o kernel che forniscono funzionalità specifiche (per esempio vmlinuz-6.50.0-ws). + +2. Ora che l'immagine del kernel è pronta, copiare e rinominare il file System.map corrispondente nella directory /boot utilizzando la stessa convenzione di denominazione: + + ``` + > sudo cp -v ~/build/kernel/System.map \ + /boot/System.map-5.16.9-custom + ``` + +3. Con il kernel a posto, il file System.map a posto e i moduli a posto, siamo pronti per il passo finale. La sintassi del comando necessario è: + + ``` + > kernel-install add + ``` + + Qui, è il numero di versione (e il nome) del kernel. E è il percorso all'immagine del kernel appena compilata. + + Per il nostro esempio, digitare: + + ``` + > sudo kernel-install \ + add 5.16.9-custom /boot/vmlinuz-5.16.9-custom + ``` + +Il comando kernel-install utilizzato qui è un piccolo script di shell. Forse non è disponibile in tutte le distribuzioni Linux, ma lo è nelle più recenti Fedora, RHEL e CentOS. Questo strumento automatizza molte delle ultime operazioni manuali che normalmente dovremmo fare per configurare il sistema per l'avvio del nuovo kernel appena creato. + +In particolare, lo strumento fa quanto segue: + +- Crea l'immagine iniziale del file system RAM (l'immagine initramfs, cioè l'/boot/initramfs-.img file). Per eseguire questa operazione manualmente sui sistemi in cui kernel-install non è disponibile, utilizzare il comando mkinitramfs. +- Esegue il comando depmod (che crea un elenco delle dipendenze dei moduli). +- Aggiorna la configurazione del boot loader. + +Per i sistemi che eseguono le versioni più recenti di GRUB2, il file sarà `/boot/grub2/grub.cfg`. Per i sistemi EFI /boot/efi//fedora/grub.cfg viene anche aggiornato. + +E per i sistemi che eseguono le versioni legacy di GRUB, questo sarà il file /boot/grub/grub.conf o /boot/grub/menu.lst. Per le nuove distro che hanno implementato le nuove Boot Loader Specification (BLS), verrà aggiunta una nuova voce del boot loader alla directory /boot/loader/entries/ o a qualsiasi directory indicata dalla variabile "blsdir". + +Sul nostro server demo Rocky basato su EFI che esegue GRUB 2 utilizzando BLS, viene creata una nuova voce di avvio nel file del boot loader che si trova qui: `/boot/loader/entries/6fa25ca775f64accb0d3e53f0e4e6e92-5.16.9-custom.conf` + +``` +> sudo cat /boot/loader/entries/6fa25ca775f64accb0d3e53f0e4e6e92-5.16.9-custom.conf +title Rocky Linux (5.16.9-custom) 8.5 (Green Obsidian) +version 5.16.9-custom +linux /vmlinuz-5.16.9-custom +initrd /initramfs-5.16.9-custom.img $tuned_initrd +options $kernelopts $tuned_params +id rocky-20220212013135-5.16.9-custom +grub_users $grub_users +grub_arg --unrestricted +grub_class kernel +``` + +!!! Note "Nota" + + La maggior parte delle distro ha a disposizione diverse utility grub2-* che possono essere utilizzate per eseguire varie operazioni di manutenzione di GRUB2 e del boot loader. Ad esempio, si può usare il comando grub2-set-default per modificare o impostare il kernel predefinito da avviare all'avvio del sistema. + +## Avviare il Kernel personalizzato +La fase successiva è quella di testare il nuovo kernel per assicurarsi che il sistema possa effettivamente avviarsi con esso. + +1. Supponendo di aver eseguito tutto nel modo esatto prescritto dal medico e che tutto abbia funzionato esattamente come indicato dal medico, si può tranquillamente riavviare il sistema e selezionare il nuovo kernel dal menu del boot loader durante l'avvio del sistema: + + ``` + > sudo reboot + ``` + +2. Dopo l'avvio del sistema, è possibile utilizzare il comando uname per scoprire il nome del kernel corrente: + + ``` + > uname -r + 5.16.9-custom + ``` + +3. Si ricorderà che una delle caratteristiche aggiunte al nuovo kernel è la capacità di supportare il file system NTFS. Assicurarsi che il nuovo kernel abbia effettivamente il supporto per NTFS visualizzando le informazioni sul modulo NTFS: + + ``` + [rockstar ~]$ modinfo ntfs + filename: /lib/modules/5.16.9-custom/kernel/fs/ntfs/ntfs.ko + license: GPL + version: 2.1.32 + description: NTFS 1.2/3.x driver - Copyright ….. + ...... + ``` + +E questo è tutto! diff --git a/docs/guides/installation.it.md b/docs/guides/installation.it.md index e663d1ec6c..ab2f2ab837 100644 --- a/docs/guides/installation.it.md +++ b/docs/guides/installation.it.md @@ -1,7 +1,7 @@ --- Title: Installazione di Rocky Linux -author: tianci li, Steven Spencer, Colussi Franco -contributors: 01-15-2022 +author: wale soyinka +contributors: tianci li, Steven Spencer, Colussi Franco updated: 12-22-2021 --- @@ -51,10 +51,10 @@ wget https://download.rockylinux.org/pub/rocky/8.5/isos/x86_64/CHECKSUM Utilizzare l'utilità `sha256sum` per verificare l'integrità del file ISO contro la corruzione e/o la manomissione. ``` -sha256sum -c CHECKSUM --ignore-missing Rocky-8.5-x86_64-minimal.iso +sha256sum -c CHECKSUM --ignore-missing ``` -L'output dovrebbe mostrare: +Questo controllerà l'integrità del file ISO scaricato in precedenza, a condizione che sia nella stessa directory. L'output dovrebbe mostrare: ``` Rocky-8.5-x86_64-minimal.iso: OK diff --git a/docs/guides/migrate2rocky.it.md b/docs/guides/migrate2rocky.it.md index 2bfe65df4c..f4a929dd5f 100644 --- a/docs/guides/migrate2rocky.it.md +++ b/docs/guides/migrate2rocky.it.md @@ -1,8 +1,8 @@ --- title: Migrazione A Rocky Linux author: Ezequiel Bruni -contributors: 01-15-2022 -update: 01-15-2022 +contributors: tianci li, Steven Spencer, Colussi Franco +update: 11-23-2021 --- # Come migrare a Rocky Linux da CentOS Stream, CentOS, Alma Linux, RHEL, o Oracle Linux diff --git a/docs/guides/mirror_management/add_mirror_manager.it.md b/docs/guides/mirror_management/add_mirror_manager.it.md new file mode 100644 index 0000000000..1246b38e96 --- /dev/null +++ b/docs/guides/mirror_management/add_mirror_manager.it.md @@ -0,0 +1,135 @@ +--- +title: Aggiungere un Mirror Rocky +contributors: Amin Vakil, Steven Spencer, Franco Colussi +--- + +# Aggiunta di un mirror pubblico al gestore di mirror di Rocky + +## Requisiti minimi per un mirror pubblico + +Accogliamo sempre con favore nuovi mirrors pubblici. Ma dovrebbero essere ben mantenuti e ospitati in un centro dati 24/7 come ambiente. La larghezza di banda disponibile deve essere di almeno 1 GBit/s. Preferiamo i mirrors che offrono il doppio stack (IPv4 & IPv6). Si prega di non inserire mirror configurati utilizzando il DNS dinamico. Se stai offrendo un mirror in una regione che ha solo pochi mirrors, accetteremo anche velocità più lente. + +Si prega di non inviare mirror che sono ospitati in un Anycast-CDN come Cloudflare, ecc. perché questo può portare a prestazioni non ottimali con la selezione del mirror più veloce in `dnf`. + +Si prega di notare che non siamo autorizzati ad accettare mirror pubblici in paesi soggetti alle norme di esportazione degli Stati Uniti. L'elenco di questi Paesi è disponibile qui: [https://www.bis.doc.gov/index.php/policy-guidance/country-guidance/sanctioned-destinations](https://www.bis.doc.gov/index.php/policy-guidance/country-guidance/sanctioned-destinations) + +Lo spazio su disco rigido richiesto è attualmente di circa 500 GB, ma si prevede una crescita nel tempo. 600 GB di spazio dovrebbero essere sufficienti per i prossimi anni. + +Il nostro master mirror è `rsync://msync.rockylinux.org/rocky/mirror/pub/rocky/` Per la prima sincronizzazione utilizzare un mirror vicino a voi. Puoi trovare tutti i mirror ufficiali qui: https://mirrors.rockylinux.org + +Si noti che in futuro potremmo limitare l'accesso al master mirror ufficiale ai mirror pubblici ufficiali. Per questo motivo, se gestite un mirror privato, prendete in considerazione l'opzione `rsyncing` da un mirror pubblico vicino a voi. Inoltre i mirror locali potrebbero essere più veloci da sincronizzare. + +## Configurare il tuo mirror + +Si prega di impostare un cron job per sincronizzare periodicamente il mirror e eseguirlo circa 6 volte al giorno. Ma assicurati di sincronizzare l'ora per aiutare a distribuire il carico nel tempo. Se si controlla solo le modifiche di `fullfiletimelist-rocky` e si esegue una sincronizzazione completa solo se questo file è cambiato, è possibile sincronizzare ogni ora. + +Ecco alcuni esempi di crontab per voi: + +``` +#This will synchronize your mirror at 0:50, 4:50, 8:50, 12:50, 16:50, 20:50 +50 */6 * * * /path/to/your/rocky-rsync-mirror.sh > /dev/null 2>&1 + +#This will synchronize your mirror at 2:25, 6:25, 10:25, 14:25, 18:25, 22:25 +25 2,6,10,14,18,22 * * * /path/to/your/rocky-rsync-mirror.sh > /dev/null 2>&1 + +#This will synchronize your mirror every hour at 15 minutes past the hour. +#Only use if you are using our example script +15 * * * * /path/to/your/rocky-rsync-mirror.sh > /dev/null 2>&1 +``` + +Per una semplice sincronizzazione si può usare il seguente comando `rsync`: + +``` +rsync -aqH --delete source-mirror destination-dir +``` +Considerare l'uso di un meccanismo di blocco per evitare di eseguire più di un lavoro `rsync` simultaneamente quando rilasciamo una nuova release. + +È inoltre possibile utilizzare e modificare il nostro esempio di implementazione dello script di blocco e sincronizzazione completa, se necessario. Può essere trovato su [https://github.com/rocky-linux/rocky-tools/blob/main/mirror/mirrorsync.sh](https://github.com/rocky-linux/rocky-tools/blob/main/mirror/mirrorsync.sh). + +Dopo la prima sincronizzazione completa controllare che tutto vada bene con il tuo mirror. La cosa più importante è verificare che tutti i file e le directory siano stati sincronizzati, che il cron job funzioni correttamente e che il mirror sia raggiungibile da Internet. Doppio controllo delle regole del tuo firewall! Per evitare problemi, non applicare il reindirizzamento da http a https. + +Per qualsiasi domanda riguardante la configurazione del tuo mirror unisciti a https://chat.rockylinux.org/rocky-linux/channels/infrastructure + +Quando avete finito, passate alla sezione successiva e proponete il vostro mirror per renderlo pubblico! + +## Cosa Ti Serve +* Un account su https://accounts.rockylinux.org/ + +## Creare un sito + +Rocky utilizza il Mirror Manager di Fedora per organizzare i mirror della comunità. + +Accedi a Rocky's Mirror Manager qui: https://mirrors.rockylinux.org/mirrormanager/ + +Dopo un accesso riuscito, il tuo profilo sarà in alto a destra. Selezionare il menu a tendina quindi fare clic su "My sites". + +Verrà visualizzata una nuova pagina con l'elenco di tutti i siti dell'account. La prima volta sarà vuota. Clicca su "Register a new site". + +Verrà caricata una nuova pagina con un'importante dichiarazione di Conformità alle Esportazioni da leggere. Quindi compilare le seguenti informazioni: + +* "Site Name" +* "Site Password" - utilizzato dallo script `report_mirrors`, si può utilizzare ciò che si preferisce +* "Organization URL" - URL dell'Azienda/Scuola/Organizzazione +* "Private" - Selezionando questa casella si nasconde il proprio mirror all'uso pubblico. +* "User active" - Deselezionare questa casella per disabilitare temporaneamente questo sito, che verrà rimosso dagli elenchi pubblici. +* "All sites can pull from me?" - Consentire a tutti i siti mirror di attingere da me senza aggiungerli esplicitamente al mio elenco. +* "Comments for downstream siteadmins. Includere qui la fonte di sincronizzazione per evitare cicli di dipendenze." + +Facendo clic su "Submit" si torna alla pagina principale dei mirror. + +## Configurazione del sito + +Dalla pagina principale del mirror, selezionare l'elenco a discesa e fare clic su "My sites". + +Verrà caricata la pagina dell'account e il sito dovrebbe essere elencato. Fare clic su di esso per accedere alle Information Site. + +Tutte le opzioni dell'ultima sezione sono elencate di nuovo. In fondo alla pagina ci sono tre nuove opzioni: Admin, Hosts e Delete site. Clicca su "Hosts [add]". + +## Creare un nuovo host + +Compila le seguenti opzioni appropriate per il sito: + +* "Host name" - richiesto: FQDN del server visto da un utente finale pubblico +* "User active" - Deselezionare questa casella per disabilitare temporaneamente questo host, che verrà rimosso dagli elenchi pubblici. +* "Country" - richiesto: Codice paese ISO a 2 lettere +* "Bandwidth" - richiesto: numero intero di megabit/sec, la quantità di larghezza di banda che questo host può servire +* "Private" - ad esempio, non disponibile al pubblico, un mirror privato interno +* "Internet2" - su Internet2 +* "Internet2 clients" - serve i client di Internet2, anche se privati +* "ASN - Autonomous System Number, utilizzato nelle tabelle di routing BGP. Solo se siete un ISP. +* "ASN Clients? - Serve tutti i client dallo stesso ASN. Utilizzato per ISP, aziende o scuole, non per reti personali. +* "Robot email" - indirizzo di posta elettronica, riceverà una notifica degli aggiornamenti dei contenuti upstream +* "Comment" - testo, qualsiasi altra cosa vogliate che un utente finale pubblico sappia sul vostro mirror +* "Max connections" - Connessioni massime di download parallelo per client, suggerite tramite metalinks. + +Fare clic su "Create" e si verrà reindirizzati al sito informativo dell'host. + +## Aggiornamento host + +Nella parte inferiore di Information site, l'opzione "Hosts" dovrebbe ora visualizzare il titolo dell'host accanto ad essa. Fare clic sul nome per caricare la pagina dell'host. Vengono riproposte tutte le stesse opzioni del passo precedente. Ci sono nuove opzioni in basso. + +* "Site-local Netblocks": I Netblocks sono utilizzati per cercare di guidare l'utente finale verso un mirror specifico del sito. Ad esempio, un'università potrebbe elencare i propri netblocks e il CGI mirrorlist restituirà il mirror locale dell'università piuttosto che quello del paese. Il formato è uno dei seguenti: 18.0.0.0/255.0.0.0, 18.0.0.0/8, un prefisso/lunghezza IPv6 o un nome host DNS. I valori devono essere indirizzi IP pubblici (non indirizzi di spazio privati RFC1918). Da utilizzare solo se si è un ISP e/o si possiede un netblock instradabile pubblicamente! + +* "Peer ASN": I peer ASN sono utilizzati per guidare un utente finale su reti vicine verso il nostro mirror. Ad esempio, un'università potrebbe elencare i propri peer ASN e il CGI mirrorlist restituirà il mirror locale dell'università piuttosto che quello del paese. Per creare nuove voci in questa sezione è necessario far parte del gruppo di amministratori di MirrorManager. + +* "Countries Allowed": Alcuni mirror devono limitarsi a servire solo gli utenti finali del proprio paese. Se siete tra questi, elencate il codice ISO di 2 lettere per i paesi da cui consentite agli utenti finali di provenire. La mirrorlist CGI lo rispetterà. + +* "Categories Carried": Gli host trasportano categorie di software. Le categorie di Fedora includono Fedora e Fedora Archive. + +Fare clic sul link "[add]" sotto "Categories Carried". + +### Categories Carried + +Per la Categoria, selezionare "Rocky Linux" e poi "Create" per caricare la pagina dell'URL. Quindi fare clic su "[add]" per caricare la pagina "Add host category URL". C'è una opzione. Ripetere l'operazione per ciascuno dei protocolli supportati dai mirrors. + +* "URL" - URL (rsync, https, http) che punta alla directory superiore + +Esempi: +* `http://rocky.example.com` +* `https://rocky.example.com` +* `rsync://rocky.example.com` + + +## Conclusione + +Una volta compilate le informazioni, il sito dovrebbe apparire nell'elenco dei mirror non appena si verifica il successivo aggiornamento dei mirror.