diff --git a/docs/guides/virtualization/cloud-init/04_advanced_provisioning.it.md b/docs/guides/virtualization/cloud-init/04_advanced_provisioning.it.md new file mode 100644 index 0000000000..600bd4a3f6 --- /dev/null +++ b/docs/guides/virtualization/cloud-init/04_advanced_provisioning.it.md @@ -0,0 +1,237 @@ +--- +title: 4. Provisioning avanzato +author: Wale Soyinka +contributors: Steven Spencer +tags: + - cloud-init + - rocky linux + - cloud + - automation + - networking +--- + +## Networking e multi-part payload + +Nel capitolo precedente si è imparato a utilizzare i moduli principali di `cloud-init` per la gestione di utenti, pacchetti e file. Ora è possibile creare un server ben configurato in modo dichiarativo. Ora è il momento di esplorare tecniche più avanzate che ci consentano un controllo ancora maggiore sulla configurazione della vostra istanza. + +Questo capitolo tratta due argomenti avanzati e molto importanti: + +1. Configurazione di rete dichiarativa: come andare oltre il DHCP e definire configurazioni di rete statiche per le tue istanze. +2. Payload MIME multiparte: come combinare diversi tipi di dati utente, come script di shell e file `#cloud-config`, in un unico potente payload. + +## 1) Configurazione per rete dichiarativa + +Per impostazione predefinita, la configurazione della maggior parte delle immagini cloud prevede l'acquisizione di un indirizzo IP tramite DHCP. Sebbene sia comodo, molti ambienti di produzione richiedono che i server abbiano indirizzi IP statici. Il sistema di configurazione di rete `cloud-init` offre un modo dichiarativo e indipendente dalla piattaforma per gestire tutto questo. + +Le specifiche delle configurazioni di rete sono contenute in un documento YAML separato dal `#cloud-config` principale. I processi `cloud-init` provengono entrambi dallo stesso file e utilizzano il separatore standard dei documenti YAML (`---`) per distinguerli. + +!!! note "Come `cloud-init` applica lo stato della rete" + + Su Rocky Linux, `cloud-init` non configura direttamente le interfacce di rete. Agisce invece come un traduttore, convertendo la sua configurazione di rete in file che **NetworkManager** (il servizio di rete predefinito) è in grado di comprendere. Quindi passa il controllo a NetworkManager per applicare la configurazione. È possibile ispezionare i profili di connessione risultanti in `/etc/NetworkManager/system-connections/`. + +### Esempio 1: Configurazione di un singolo IP statico + +In questo esercizio configureremo la macchina virtuale con un indirizzo IP statico, un gateway predefinito e server DNS personalizzati. + +1. **Creare `user-data.yml`:** + + Questo file contiene due documenti YAML distinti, separati da `---`. Il primo è il `#cloud-config` standard. Il secondo definisce lo stato della rete. + + ```bash + cat < user-data.yml + #cloud-config + # Possiamo comunque includere i moduli standard. + # Installiamo uno strumento per la risoluzione dei problemi di rete. + packages: + - traceroute + + --- + + # Questo secondo documento definisce la configurazione di rete. + network: + version: 2 + ethernets: + eth0: + dhcp4: no + addresses: + - 192.168.122.100/24 + gateway4: 192.168.122.1 + nameservers: + addresses: [8.8.8.8, 8.8.4.4] + EOF + ``` + +2. **Spiegazione delle Key directives:** + + - `network:`: Chiave di primo livello per la configurazione di rete. + - `versione: 2`: specifica che stiamo utilizzando la sintassi moderna, simile a Netplan. + - `ethernets:`: un dizionario delle interfacce di rete fisiche da configurare, ordinate in base al nome dell'interfaccia (ad esempio, `eth0`). + - `dhcp4: no`: Disabilita il DHCP per IPv4 su questa interfaccia. + - `indirizzi`: un elenco di indirizzi IP statici da assegnare, specificati in notazione CIDR. + - `gateway4`: Il gateway predefinito per il traffico IPv4. + - `nameservers`: un dizionario contenente un elenco di indirizzi IP per la risoluzione DNS. + +3. _Boot e verifica._\* + + La verifica è diversa questa volta, poiché la VM non otterrà un indirizzo IP dinamico. È necessario connettersi direttamente alla console della VM. + + ```bash + # Utilizzare un nuovo disco per questo esercizio + qemu-img create -f qcow2 -F qcow2 -b Rocky-10-GenericCloud.qcow2 static-ip-vm.qcow2 + + virt-install --name rocky10-static-ip \ + --memory 2048 --vcpus 2 \ + --disk path=static-ip-vm.qcow2,format=qcow2 \ + --cloud-init user-data=user-data.yml,hostname=network-server \ + --os-variant rockylinux10 \ + --import --noautoconsole + + # Connettere la virtual console + virsh console rocky10-static-ip + + # Loggarsi dentro e controlloare l'IP + [rocky@network-server ~]$ ip a show eth0 + ``` + + L'output dovrebbe mostrare che `eth0` ha l'indirizzo IP statico `192.168.122.100/24`. + +### Esempio 2: Configurazione multi-interfaccia + +Uno scenario comune nel mondo reale è un server con più interfacce di rete. Qui creeremo una VM con due interfacce: `eth0` utilizzerà DHCP, mentre `eth1` avrà un IP statico. + +1. **Create `user-data.yml` per due interfacce:** + + ```bash + cat < user-data.yml + #cloud-config + packages: [iperf3] + + --- + + network: + version: 2 + ethernets: + eth0: + dhcp4: yes + eth1: + dhcp4: no + addresses: [192.168.200.10/24] + EOF + ``` + +2. **Boot di una VM con due schede di rete:** aggiungiamo un secondo flag `--network` al comando `virt-install`. + + ```bash + virt-install --name rocky10-multi-nic \ + --memory 2048 --vcpus 2 \ + --disk path=... \ + --network network=default,model=virtio \ + --network network=default,model=virtio \ + --cloud-init user-data=user-data.yml,hostname=multi-nic-server \ + --os-variant rockylinux10 --import --noautoconsole + ``` + +3. **Verifica:** esegure SSH all'indirizzo assegnato dal DHCP su `eth0`, quindi controlla l'IP statico su `eth1` con `ip a show eth1`. + +## 2) Unificazione dei payload con MIME multi-part + +A volte è necessario eseguire uno script di configurazione _prima_ dell'esecuzione dei moduli principali `#cloud-config`. I file multi-part MIME sono la soluzione ideale, poiché consentono di raggruppare diversi tipi di contenuti in un unico payload ordinato. + +È possibile visualizzare la struttura di un file MIME come segue: + +``` ++-----------------------------------------+ +| Main Header (multipart/mixed; boundary) | ++-----------------------------------------+ +| +| --boundary | +| +-------------------------------------+ +| | Part 1 Header (e.g., text/x-shellscript) | +| +-------------------------------------+ +| | Part 1 Content (#/bin/sh...) | +| +-------------------------------------+ +| +| --boundary | +| +-------------------------------------+ +| | Part 2 Header (e.g., text/cloud-config) | +| +-------------------------------------+ +| | Part 2 Content (#cloud-config...) | +| +-------------------------------------+ +| +| --boundary-- (closing) | ++-----------------------------------------+ +``` + +### Hands-on: uno script per il controllo preventivo + +Creeremo un file composto da più parti che prima esegue uno script shell e poi procede al `#cloud-config` principale. + +1. **Creare il file multiparte `user-data.mime`:** + + Si tratta di un file di testo con un formato speciale che utilizza una stringa “di delimitazione” per separare le parti. + + ```bash + cat < user-data.mime + Content-Type: multipart/mixed; boundary="//" + MIME-Version: 1.0 + + --// + Content-Type: text/x-shellscript; charset="us-ascii" + + #!/bin/sh + echo "Running pre-flight checks..." + # In a real script, you might check disk space or memory. + # If checks failed, you could 'exit 1' to halt cloud-init. + echo "Pre-flight checks passed." > /tmp/pre-flight-status.txt + + --// + Content-Type: text/cloud-config; charset="us-ascii" + + #cloud-config + packages: + - htop + runcmd: + - [ sh, -c, "echo 'Main cloud-config ran successfully' > /tmp/main-config-status.txt" ] + + --//-- + EOF + ``` + + !!! note "Informazioni sul delimitatore MIME" + + ``` + La stringa di delimitazione (in questo caso `//`) è una stringa arbitraria che non deve comparire nel contenuto di nessuna parte. Viene utilizzata per separare le diverse sezioni del file. + ``` + +2. _Boot e verifica._\* + + Questo file viene passato a `virt-install` allo stesso modo di un file `user-data.yml` standard. + + ```bash + # Use a new disk image + qemu-img create -f qcow2 -F qcow2 -b Rocky-10-GenericCloud.qcow2 mime-vm.qcow2 + + virt-install --name rocky10-mime-test \ + --memory 2048 --vcpus 2 \ + --disk path=mime-vm.qcow2,format=qcow2 \ + --cloud-init user-data=user-data.mime,hostname=mime-server \ + --os-variant rockylinux10 \ + --import --noautoconsole + ``` + + Dopo il boot, accedere alla VM tramite SSH e verificare che entrambe le parti siano state eseguite cercando i file che hanno creato: + + ```bash + cat /tmp/pre-flight-status.txt + cat /tmp/main-config-status.txt + ``` + +!!! tip "Altri tipi di contenuti Multi-part" + + `cloud-init` supporta altri tipi di contenuto per casi d'uso avanzati, come `text/cloud-boothook` per script iniziali di boot o `text/part-handler` per l'esecuzione di codice Python personalizzato. Per ulteriori dettagli, consultare la documentazione ufficiale. + +## Prossimo passo + +Ora avete imparato due potenti tecniche avanzate di `cloud-init`. Ora è possibile definire reti statiche e orchestrare flussi di lavoro di provisioning complessi con dati utente multi-part. + +Nel prossimo capitolo, sposteremo la nostra prospettiva dal _consumo_ di `cloud-init` su base individuale alla _personalizzazione del suo comportamento predefinito_ per creare le vostre “immagini golden” preconfigurate. diff --git a/docs/guides/virtualization/cloud-init/05_image_builders_perspective.it.md b/docs/guides/virtualization/cloud-init/05_image_builders_perspective.it.md new file mode 100644 index 0000000000..fd9619c90c --- /dev/null +++ b/docs/guides/virtualization/cloud-init/05_image_builders_perspective.it.md @@ -0,0 +1,141 @@ +--- +title: 5. La prospettiva del image builder +author: Wale Soyinka +contributors: Steven Spencer +tags: + - cloud-init + - rocky linux + - cloud + - automation + - image-building +--- + +## Impostazioni predefinite e generalizzazione + +Finora, il nostro percorso si è concentrato sulla configurazione delle singole istanze all'avvio utilizzando `user-data`. In questo capitolo, cambieremo prospettiva e assumeremo quella di un **image builder**. Cioè qualcuno che crea e gestisce le “golden images” che fungono da modelli per altre macchine virtuali. + +Il nostro obiettivo è quello di creare una nuova immagine personalizzata con le nostre policies ed impostazioni predefinite integrate. Ciò comporta due passaggi fondamentali: + +1. **Personalizzazione delle impostazioni predefinite a livello di sistema:** Modifica della configurazione `cloud-init` _all'interno dell'immagine stessa_. +2. **Generalizzazione dell'immagine:** utilizzo di strumenti quali `cloud-init clean` e `virt-sysprep` per rimuovere tutti i dati specifici della macchina, preparando l'immagine per la clonazione. + +## 1) Configurazione del laboratorio di personalizzazione + +Per iniziare, abbiamo bisogno di un'istanza funzionante dell'immagine cloud di base da poter modificare. Avvieremo questa VM _senza_ fornire alcun `dato utente` per ottenere un sistema pulito. + +```bash +# Create un'immagine disco per il nostro nuovo modello +qemu-img create -f qcow2 -o size=10G golden-image-template.qcow2 + +# Avviate l'immagine di base utilizzando virt-install +virt-install --name golden-image-builder \ +--memory 2048 --vcpus 2 \ +--disk path=golden-image-template.qcow2,format=qcow2 \ +--cloud-init none --os-variant rockylinux10 --import + +# Connettersi alla console ed effettuare il login come utente predefinito “rocky”. +virsh console golden-image-builder +``` + +## 2. Configurazione a livello di sistema con `cloud.cfg.d` + +All'interno della nostra VM in esecuzione, ora possiamo personalizzare la configurazione `cloud-init` a livello di sistema. Non modificare mai direttamente il file master, `/etc/cloud/cloud.cfg`. La posizione corretta e sicura per gli aggiornamenti delle personalizzazioni è la directory `/etc/cloud/cloud.cfg.d/`. `cloud-init` legge tutti i file `.cfg` qui presenti in ordine alfabetico dopo il file principale `cloud.cfg`, consentendo di sovrascrivere le impostazioni predefinite. + +### Hands-on: impostazione dei valori predefiniti della golden image + +Applichiamo una policy sul nostro golden image: disabiliteremo l'autenticazione tramite password, imposteremo un nuovo utente predefinito e garantiremo che sia sempre installato un set di pacchetti di base. + +1. **Creare un file di configurazione personalizzato:** dall'interno della VM, creare `/etc/cloud/cloud.cfg.d/99-custom-defaults.cfg`. Il prefisso “99-” assicura che venga letto per ultimo. + + ```bash + sudo cat < /etc/cloud/cloud.cfg.d/99-custom-defaults.cfg + # Golden Image Customizations + + # Define a new default user named 'admin' + system_info: + default_user: + name: admin + sudo: ["ALL=(ALL) NOPASSWD:ALL"] + shell: /bin/bash + + # Enforce key-based SSH authentication + ssh_pwauth: false + + # Ensure a baseline of packages is always installed + packages: + - htop + - vim-enhanced + EOF + ``` + +!!! tip "Disabilitazione di moduli specifici" + + Una tecnica per una sicurezza efficace consiste nel disabilitare completamente determinati moduli `cloud-init`. Ad esempio, per impedire a qualsiasi utente di utilizzare `runcmd`, è possibile aggiungere quanto segue al file `.cfg` personalizzato. In questo modo si indica a `cloud-init` di eseguire un elenco vuoto di moduli durante la fase finale. + + `yaml cloud_final_modules: [] ` + +## 3. Generalizzare l'immagine + +La nostra VM ora contiene la nostra configurazione personalizzata, ma contiene anche identificatori univoci della macchina (come `/etc/machine-id`) e chiavi host SSH. Prima di poterlo clonare, dobbiamo rimuovere questi dati attraverso un processo chiamato **generalizzazione**. + +### Metodo 1: `cloud-init clean` (all'interno della VM) + +`cloud-init` fornisce un comando integrato per questo scopo. + +1. **Eseguire `cloud-init clean`:** dall'interno della VM, eseguire il seguente comando per rimuovere i dati specifici dell'istanza. + + ```bash + sudo cloud-init clean --logs --seed + ``` + + !!! note "Riguardo a `cloud-init clean --seed`" + + ``` + Questo comando rimuove il seed univoco utilizzato da `cloud-init` per identificare l'istanza, costringendola a eseguire il processo da zero al successivo avvio. **Non** rimuove le configurazioni personalizzate in `/etc/cloud/cloud.cfg.d/`. Questo passaggio è essenziale per creare un modello veramente generico. + ``` + +2. **Spegnimento immediato:** dopo la pulizia, spegnere immediatamente la VM. + + ```bash + sudo poweroff + ``` + +### Metodo 2: `virt-sysprep` (dall'host) + +Uno strumento ancora più completo e conforme agli standard del settore è `virt-sysprep`. È possibile eseguire questa operazione dal computer host sul disco della macchina virtuale spenta. Esegue tutte le azioni di `cloud-init clean` e molto altro ancora, come cancellare la cronologia dei comandi, rimuovere i file temporanei e reimpostare i file di log. + +1. **Assicurarsi che la VM sia spenta.** + +2. **Eseguire `virt-sysprep` dal vostro host:** + + ```bash + sudo virt-sysprep -a golden-image-template.qcow2 + ``` + +Una volta completato il processo di generalizzazione, il file su disco (`golden-image-template.qcow2`) diveterà la vostra nuova nuova golden image. + +!!! note "Convenzioni di denominazione delle golden image" + + È buona norma assegnare alle golden image nomi descrittivi che includano il sistema operativo e il numero di versione, ad esempio `rocky10-base-v1.0.qcow2`. Ciò facilita il controllo delle versioni e la gestione dell'infrastruttura. + +## 4. Verificare la golden image + +Proviamo la nostra nuova immagine avviando una nuova istanza _da_ essa senza alcun `user-data`. + +1. **Creare un nuovo VM disk dalla nostra golden image:** + + ```bash + qemu-img create -f qcow2 -F qcow2 -b golden-image-template.qcow2 test-instance.qcow2 + ``` + +2. **Avviare l'istanza di prova:** + + ```bash + virt-install --name golden-image-test --cloud-init none ... + ``` + +3. **Verifica:** Connettersi alla console (`virsh console golden-image-test`). La richiesta di accesso dovrebbe essere per l'utente `admin`, non per `rocky`. Una volta effettuato l'accesso, è anche possibile verificare l'installazione di `htop` con (`rpm -q htop`). Questo conferma che le impostazioni predefinite integrate funzionano correttamente. + +## Il passo successivo + +Ora avete imparato come creare modelli standardizzati integrando le impostazioni predefinite nella configurazione di sistema di `cloud-init` e generalizzandoli correttamente per la clonazione. Nel prossimo capitolo tratteremo le competenze essenziali per la risoluzione dei problemi quando `cloud-init` non funziona come previsto. diff --git a/docs/guides/virtualization/cloud-init/06_troubleshooting.it.md b/docs/guides/virtualization/cloud-init/06_troubleshooting.it.md new file mode 100644 index 0000000000..70177fc88d --- /dev/null +++ b/docs/guides/virtualization/cloud-init/06_troubleshooting.it.md @@ -0,0 +1,115 @@ +--- +title: 6. Troubleshooting cloud-init +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - cloud-init + - rocky linux + - cloud + - automation + - troubleshooting +--- + +## Troubleshooting cloud-init + +In qualsiasi sistema complesso e automatizzato, prima o poi qualcosa andrà storto. Quando una configurazione `cloud-init` fallisce, sapere come diagnosticare sistematicamente il problema è una competenza essenziale. Questo capitolo è una guida all'analisi forense di `cloud-init` e tratta sia le tecniche di risoluzione dei problemi in guest che quelle in host. + +## 1. Toolkit per il troubleshooting in-guest + +Quando è possibile accedere a un'istanza in esecuzione, `cloud-init` fornisce diversi comandi e registri per mostrare cosa è successo. + +### Punto 1: Il comando status (`cloud-init status`) + +Questo è il tuo primo punto di riferimento. Fornisce un riepilogo di alto livello dello stato di `cloud-init`. + +- **Verifica il completamento di `cloud-init`:** `cloud-init status` + (Se l'esecuzione ha avuto esito positivo, verrà visualizzato `status: done`) + +- _Attendere il completamento di `cloud-init`:_\* `cloud-init status --wait` + (Questo è utile negli script per mettere in pausa l'esecuzione fino al completamento di `cloud-init`) + +### Punto 2: Il log principale (`/var/log/cloud-init.log`) + +Questo file è la principale fonte di verità: una registrazione dettagliata e cronologica di ogni fase e modulo. Quando si ha bisogno di sapere _esattamente_ cosa è successo, guardare qui. Cercando in questo file `ERROR` o `WARNING` spesso si arriva direttamente al problema. + +### Pilastro 3: Il log di output (`/var/log/cloud-init-output.log`) + +Questo log registra l'intero `stdout` e `stderr` di tutti gli script eseguiti da `cloud-init` (ad esempio, da `runcmd`). Se un modulo è stato eseguito ma lo script al suo interno non ha funzionato, il messaggio di errore sarà presente in questo file. + +**Hands-on: debug di un comando `runcmd` non funzionante** + +1. Creare un file `user-data.yml` con un comando `runcmd` che contiene un errore nascosto: + + ```bash + cat < user-data.yml + #cloud-config + runcmd: + - [ ls, /non-existent-dir ] + EOF + ``` + +2. Avviare una VM con questi dati. `cloud-init status` riporterà `status: done` perché il modulo `runcmd` stesso è stato eseguito correttamente. + +3. Tuttavia, `/var/log/cloud-init-output.log` conterrà l'errore effettivo del comando `ls`, mostrando cosa non ha funzionato: + + ``` + ls: cannot access '/non-existent-dir': No such file or directory + ``` + +## 2) Troubleshooting lato host con `libguestfs-tools` + +A volte, una VM non riesce ad avviarsi completamente, rendendo inutili gli strumenti in-guest. In questi casi, è possibile diagnosticare i problemi ispezionando l'immagine del disco della VM direttamente dall'host utilizzando la potente suite `libguestfs-tools` (installabile con `sudo dnf install libguestfs-tools`). + +### `virt-cat`: Lettura dei file da un disco guest + +`virt-cat` consente la lettura dei file dall'interno dell'immagine disco di una VM senza montarla. Questo è perfetto per recuperare i file di log da un'istanza che non si avvia. + +```bash +# Dal host, leggere il file cloud-init.log dal disco della VM. +sudo virt-cat -a /path/to/your-vm-disk.qcow2 /var/log/cloud-init.log +``` + +### `virt-inspector`: Ispezione approfondita del sistema + +`virt-inspector` genera un report XML dettagliato del sistema operativo, delle applicazioni e della configurazione di una macchina virtuale. Questo è incredibilmente potente per l'analisi automatizzata. + +- **Ottienere un rapporto completo:** + + ```bash + sudo virt-inspector -a your-vm-disk.qcow2 > report.xml + ``` + +- **Eseguire una query mirata:** È possibile convogliare il file XML a `xmllint` per estrarre informazioni specifiche. Questo esempio verifica la versione installata di `cloud-init` all'interno dell'immagine: + + ```bash + sudo virt-inspector -a your-vm-disk.qcow2 | xmllint --xpath "//application[name='cloud-init']/version/text()" - + ``` + +## 3. Errori comuni e come evitarli + +### Errore 1: Errori YAML e di schema + +I YAML non validi sono la causa più comune di errori. Un problema più complesso è rappresentato da un file YAML sintatticamente valido che viola la struttura prevista da `cloud-init` (ad esempio, un errore di battitura nel nome di un modulo). + +- **Soluzione:** Utilizza il comando `cloud-init schema` per convalidare la configurazione _prima_ dell'avvio. Rileverà sia gli errori YAML che quelli strutturali. + + ```bash + # Convalidate il vostro file di user-data rispetto allo schema ufficiale + cloud-init schema --config-file user-data.yml + ``` + + Se il file è valido, verrà visualizzato il messaggio “Valid cloud-config: user-data.yml”. In caso contrario, fornirà errori dettagliati. + +### Errore 2: moduli dipendenti dalla rete non funzionanti + +Se non si riesce a connettere alla rete, moduli come `packages` non funzioneranno. Controllare la configurazione di rete e la fase `Network` in `/var/log/cloud-init.log`. + +## 4. Controllo dell'esecuzione di `cloud-init` + +- **Forzare una riesecuzione:** per testare le modifiche su una VM in esecuzione, eseguire `sudo cloud-init clean --logs` seguito da `sudo reboot`. +- **Disabilitazione di `cloud-init`:** per impedire l'esecuzione di `cloud-init` agli avvii successivi, creare un file sentinella: `sudo touch /etc/cloud/cloud-init.disabled`. +- **Eseguire ad ogni avvio (`bootcmd`):** Utilizzare il modulo `bootcmd` per gli script che devono essere eseguiti ad ogni singolo avvio. Questo è raro ma utile per alcune diagnosi. + +## Il passo successivo + +Ora si dispone di una potente serie di strumenti per la risoluzione dei problemi sia sul lato ospite che sul lato host. Nel capitolo finale esamineremo il progetto `cloud-init` stesso, preparandovi ad esplorarne il codice sorgente e a contribuire alla comunity. diff --git a/docs/guides/virtualization/cloud-init/07_contributing.it.md b/docs/guides/virtualization/cloud-init/07_contributing.it.md new file mode 100644 index 0000000000..14d7fb3d3d --- /dev/null +++ b/docs/guides/virtualization/cloud-init/07_contributing.it.md @@ -0,0 +1,135 @@ +--- +title: 7. Contribuire +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - cloud-init + - open source + - development + - python +--- + +## Contribuire al progetto cloud-init + +Congratulazioni! Abbiamo affrontato i concetti fondamentali di `cloud-init` fino alle tecniche avanzate di provisioning e risoluzione dei problemi. Ora siete un utente esperto di `cloud-init`. Questo capitolo finale apre le porte alla fase successiva del tuo percorso: passare dall'essere un utente di `cloud-init` a un potenziale collaboratore. + +`cloud-init` è un progetto open source fondamentale che prospera grazie ai contributi della comunità. Che si tratti di correggere un errore tipografico nella documentazione, segnalare un bug o scrivere un modulo completamente nuovo, ogni contributo è utile. Questo capitolo fornisce una panoramica di alto livello per comprendere il codice sorgente, creare un modulo personalizzato e interagire con la comunità upstream. Non è una guida completa per sviluppatori, ma piuttosto un'introduzione amichevole per iniziare a partecipare. + +## 1. Il panorama del codice sorgente di `cloud-init` + +Prima di poter contribuire, devi conoscere bene il progetto. Esploriamo il codice sorgente e configuriamo un ambiente di sviluppo di base. + +### Il linguaggio e la repository + +Scritto quasi interamente in **Python**, Canonical ospita il repository del codice sorgente `cloud-init` su **Launchpad**, ma per facilitare la collaborazione e offrire un'interfaccia più familiare, la maggior parte dei contributori interagisce con il suo mirror ufficiale su **GitHub**. + +- **Canonical repository (Launchpad):** [https://git.launchpad.net/cloud-init](https://git.launchpad.net/cloud-init) + +- **GitHub mirror:** [https://github.com/canonical/cloud-init](https://github.com/canonical/cloud-init) + +Per ottenere il codice sorgente, è possibile clonare il repository GitHub: + +```bash +# Clonare il codice sorgente sulla macchina locale +git clone https://github.com/canonical/cloud-init.git +cd cloud-init +``` + +### Configurare di un ambiente di sviluppo + +Per lavorare sul codice senza influire sui pacchetti Python del sistema, è consigliabile utilizzare sempre un ambiente virtuale. + +```bash +# Creare un ambiente virtuale Python +python3 -m venv .venv + +# Attivare l'ambiente virtuale +source .venv/bin/activate + +# Installare le dipendenze di sviluppo richieste +pip install -r requirements-dev.txt +``` + +### Una panoramica di alto livello sul codice sorgente + +Navigare nel codice sorgente per la prima volta può essere scoraggiante. Ecco le directory più importanti: + +- `cloudinit/`: questa è la directory principale dei sorgenti Python. +- `cloudinit/sources/`: questa directory contiene il codice per le **fonti dati** (ad esempio, `DataSourceNoCloud.py`). Ecco come `cloud-init` rileva e legge la configurazione da diverse piattaforme cloud. +- `cloudinit/config/`: qui risiedono i **moduli** (ad esempio, `cc_packages.py`, `cc_users_groups.py`). Il prefisso `cc_` è una convenzione per i moduli abilitati da `#cloud-config`. Questo è il percorso più comune per i contributi relativi alle nuove funzionalità. +- `doc/`: La documentazione ufficiale del progetto. Migliorare la documentazione è uno dei modi migliori per dare il tuo primo contributo. +- `tests/`: La suite di test completa per il progetto. + +## 2. Scrivere un modulo personalizzato di base + +Sebbene `runcmd` sia utile, scrivere un modulo personalizzato è il modo migliore per creare configurazioni riutilizzabili, portabili e idempotenti. + +Creiamo il modulo più semplice possibile: uno che legga una chiave di configurazione da `user-data` e scriva un messaggio nel log `cloud-init`. + +1. **Creare il file del modulo:** Creare un nuovo file denominato `cloudinit/config/cc_hello_world.py`. + + ```python + # Nome file: cloudinit/config/cc_hello_world.py + + # Elenco delle frequenze e delle fasi di esecuzione di questo modulo + frequency = “once-per-instance” + distros = [“all”] + + def handle(name, cfg, cloud, log, args): + # Ottieni una chiave “message” dalla configurazione dei dati utente. + # Se non esiste, utilizzare un valore predefinito. + message = cfg.get(“message”, “Ciao da un modulo personalizzato!”) + + # Scrivere il messaggio nel log principale di cloud-init. + log.info(f“Il modulo Hello World dice: {message}”) + ``` + +2. **Abilitare il modulo:** Creare il file non è sufficiente. È necessario indicare a `cloud-init` di eseguirlo. Creare un file in `/etc/cloud/cloud.cfg.d/99-my-modules.cfg` e aggiungere il nuovo modulo a uno degli elenchi di moduli: + + ```yaml + # Aggiungere il nostro modulo personalizzato all'elenco dei moduli eseguiti durante la fase di configurazione + cloud_config_modules: + - hello_world + ``` + +3. **Utilizzare il modulo:** Ora si può utilizzare il modulo personalizzato nel vostro `user-data`. La chiave di primo livello (`hello_world`) deve corrispondere al nome del modulo senza il prefisso `cc_`. + + ```yaml + #cloud-config + hello_world: + message: "My first custom module is working!" + ``` + +Dopo aver avviato una VM con questa configurazione, puoi controllare `/var/log/cloud-init.log` e troverai il tuo messaggio personalizzato, a dimostrazione che il tuo modulo ha funzionato. + +## 3. Il workflow per contribuire + +Il contributo a un progetto open source segue un workflow standard. Ecco una panoramica semplificata: + +1. **Trova qualcosa su cui lavorare:** il punto di partenza migliore è l'issue tracker del progetto su Launchpad. Cerca bug o richieste di funzionalità. I nuovi arrivati sono incoraggiati a iniziare con correzioni alla documentazione o problemi contrassegnati come “low-hanging-fruit” (facili da risolvere) o “good first issue” (buoni primi problemi). + +2. **Fork e branch:** creare una vostra copia (un “fork”) del repository `cloud-init` su GitHub. Quindi, creare un nuovo ramo per le vostre modifiche. + + ```bash + git checkout -b my-documentation-fix + ``` + +3. **Apportare le modifiche e conferma:** Apportare le modifiche al codice o alla documentazione. Quando si esegue il commit, si scriva un messaggio chiaro che descriva ciò che si è fatto. Il flag `-s` aggiunge una riga `Signed-off-by`, che certifica che si è scritto la patch o che si ha il diritto di contribuire ad essa. + + ```bash + git commit -s -m “Doc: correzione di un errore tipografico nella documentazione del modulo utenti” + ``` + +4. **Includere i test:** tutti i contributi significativi, in particolare le nuove funzionalità, devono includere i test. Esplorare la directory `tests/` per vedere come vengono testati i moduli esistenti. + +5. **Invia una richiesta pull (PR):** invia il tuo ramo al tuo fork su GitHub e apri una richiesta pull al ramo `main` del repository `canonical/cloud-init`. Questa è la vostra richiesta formale per includere il vostro lavoro nel progetto. + +6. **Partecipare alla revisione del codice:** i responsabili del progetto esamineranno la vostra richiesta di pull. Potrebbero porre domande o richiedere modifiche. Si tratta di un processo collaborativo. Interagire con il feedback è una parte fondamentale del contributo all'open source. + +### Coinvolgimento della comunità + +Per saperne di più, porre domande e interagire con la comunità, è possibile partecipare al canale `#cloud-init` sulla rete IRC OFTC o alla mailing list ufficiale. + +## Un'ultima cosa + +Congratulazioni per aver completato questa guida. Si è passati da utente principiante a utente esperto di `cloud-init` e ora avete una mappa che vi guiderà nel mondo del open source per contribuirvi. La comunità `cloud-init` è accogliente e apprezza i tuoi contributi, anche se piccoli. Happy building! diff --git a/docs/guides/virtualization/cloud-init/index.it.md b/docs/guides/virtualization/cloud-init/index.it.md new file mode 100644 index 0000000000..e6e9db230d --- /dev/null +++ b/docs/guides/virtualization/cloud-init/index.it.md @@ -0,0 +1,45 @@ +--- +title: 0. cloud-init +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - cloud-init +--- + +## Guida a cloud-init su Rocky Linux + +Benvenuti nella guida completa a `cloud-init` su Rocky Linux. Questa serie vi guiderà dai concetti fondamentali dell'inizializzazione delle istanze cloud alle tecniche avanzate di provisioning e risoluzione dei problemi nel mondo reale. Che voi siate un nuovo utente che sta configurando il suo primo server cloud o un amministratore esperto che crea immagini personalizzate, questa guida fa al caso vostro. + +I capitoli sono strutturati in modo da poter essere letti in ordine sequenziale, basandosi sulle conoscenze acquisite nelle sezioni precedenti. + +--- + +## Capitoli in questa guida + +**[1. Fondamentali](./01_fundamentals.md)** + +> Scoprirete cos'è `cloud-init`, perché è essenziale per il cloud computing e quali sono le fasi del suo ciclo di vita esecutivo. + +**[2. Primo contatto](./02_first_contact.md)** + +> Il vostro primo esercizio pratico. Avviare un'immagine cloud ed eseguire una semplice personalizzazione utilizzando un file `user-data` di base. + +**[3. Il motore di configurazione](./03_configuration_engine.md)** + +> Approfondire il sistema del modulo `cloud-init`. Imparare a utilizzare i moduli più importanti per la gestione di utenti, pacchetti e file. + +**[4. Provisioning avanzato](./04_advanced_provisioning.md)** + +> Affrontare scenari complessi, tra cui come definire configurazioni di rete statiche e come combinare script e configurazioni cloud in un unico payload. + +**[5. La prospettiva del image builder](./05_image_builders_perspective.md)** + +> Cambiare la vostra prospettiva e assumere quella di un image builder. Scoprire come creare “golden images” con impostazioni predefinite integrate e come generalizzarle correttamente per la clonazione. + +**[6. Troubleshooting](./06_troubleshooting.md)** + +> Imparare l'arte essenziale della analisi forense di `cloud-init`. Comprendere i log, i comandi di stato e le insidie comuni per diagnosticare e risolvere i problemi in modo efficace. + +**[7. Contribuire a cloud-init](./07_contributing.md)** + +> Non limitartevi a essere un semplice utente. Questo capitolo fornisce una mappa per comprendere il codice sorgente di `cloud-init` e dare il vostro primo contributo al progetto open source. diff --git a/docs/guides/web/php.it.md b/docs/guides/web/php.it.md index 27dd1afc67..e111ee2d64 100644 --- a/docs/guides/web/php.it.md +++ b/docs/guides/web/php.it.md @@ -2,7 +2,7 @@ title: PHP e PHP-FPM author: Antoine Le Morvan contributors: Steven Spencer, Ganna Zhyrnova, Joseph Brinkman -tested_with: 9.3, 8.9 +tested_with: 10.0 tags: - web - php @@ -35,160 +35,49 @@ PHP-FPM, **oltre a prestazioni migliori**, porta con sé: ## Scegliere una versione PHP -Rocky Linux, come il suo upstream, offre molte versioni del linguaggio. Alcuni di essi hanno raggiunto la fine del loro ciclo di vita, ma vengono mantenuti per continuare a ospitare applicazioni storiche che non sono ancora compatibili con le nuove versioni di PHP. Per scegliere una versione, consultare la pagina delle [versioni supportate](https://www.php.net/supported-versions.php) del sito web php.net. +Rocky Linux 10, come il suo upstream, non ha più moduli. La versione di PHP è quella disponibile nel repository Appstream. Per verificare la versione disponibile di PHP, utilizzare: -Per ottenere un elenco delle versioni disponibili, basta inserire il seguente comando: - -=== "Elenco dei moduli PHP 9.3" - - ```bash - $ sudo dnf module list php - - Rocky Linux 9 - AppStream - Name Stream Profiles Summary - php 8.1 [d] common [d], devel, minimal - - Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled - ``` - - - Il repository Remi offre versioni più recenti di PHP rispetto al repository Appstream, incluse le versioni 8.3 e 8.4. - - Per installare il repository Remi, eseguire il seguente comando (nota: se si utilizza Rocky Linux 8.x o 10.x, sostituire 8 o 10 dopo “release-” nel comando riportato di seguito): - - ```bash - sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm - ``` - - - Una volta installato il repository Remi, abilitarlo eseguendo il seguente comando. - - ```bash - sudo dnf config-manager --set-enabled remi - ``` - - - È ora possibile attivare un modulo più recente (PHP 8.4) immettendo il seguente comando: - - ```bash - sudo dnf module enable php:remi-8.4 - ``` - -=== "Elenco dei moduli PHP 8.9" - - ```bash - $ sudo dnf module list php - - Rocky Linux 8 - AppStream - Name Stream Profiles Summary - php 7.2 [d] common [d], devel, minimal PHP scripting language - php 7.3 common [d], devel, minimal PHP scripting language - php 7.4 common [d], devel, minimal PHP scripting language - php 8.0 common [d], devel, minimal PHP scripting language - - Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled - ``` - - - Rocky fornisce diversi moduli PHP dal suo repository AppStream. - - Noterai che la versione predefinita di un Rocky 8.9 è la 7.2, che ha già raggiunto il termine del proprio ciclo vitale, al momento della scrittura. - - Puoi attivare un modulo più recente inserendo il seguente comando: - - ```bash - sudo dnf module enable php:8.0 - ============================================================================================== - Package Architecture Version Repository Size - ============================================================================================== - Enabling module streams: - httpd 2.4 - nginx 1.14 - php 8.0 - - Transaction Summary - ============================================================================================== +```bash +dnf whatprovides php - Is this ok [y/N]: +Last metadata expiration check: 0:00:03 ago on Wed 22 Oct 2025 03:58:30 PM UTC. - Transaction Summary - ============================================================================================== +php-8.3.19-1.el10_0.x86_64 : PHP scripting language for creating dynamic web sites +Repo : @System +Matched from: +Provide : php = 8.3.19-1.el10_0 - Is this ok [y/N]: y - Complete! - ``` +php-8.3.19-1.el10_0.x86_64 : PHP scripting language for creating dynamic web sites +Repo : appstream +Matched from: +Provide : php = 8.3.19-1.el10_0 +``` Ora si può procedere all'installazione del motore PHP. ## Modalità PHP cgi -Prima di tutto, vediamo come installare e utilizzare PHP in modalità CGI. Possiamo farlo funzionare soltanto con il server web di Apache e il suo modulo `mod_php`. Vedremo, più avanti in questo documento, nella parte FastCGI (php-fpm) come integrare PHP in Nginx (ma anche in Apache). +Per prima cosa, instalare PHP. È possibile farlo funzionare solo con il server web Apache e il suo modulo `mod_php`. Più avanti in questo documento, nella parte dedicata a FastCGI (`php-fpm`), si vedrà come integrare PHP in Nginx e Apache. ### Installazione L'installazione di PHP è relativamente semplice, poiché consiste nell'installare il pacchetto principale e i pochi moduli necessari. -Il seguente esempio installa PHP con i moduli solitamente installati con esso. - -=== "9.3 installare PHP" - - ```bash - sudo dnf install php php-cli php-gd php-curl php-zip php-mbstring - ``` - - - Durante l'installazione verrà richiesto di importare le chiavi GPG per i repository epel9 (Extra Packages for Enterprise Linux 9) e Remi. Immettere y per importare le chiavi: - - ```bash - Extra Packages for Enterprise Linux 9 - x86_64 - Importing GPG key 0x3228467C: - Userid : "Fedora (epel9) " - Fingerprint: FF8A D134 4597 106E CE81 3B91 8A38 72BF 3228 467C - From : /etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-9 - Is this ok [y/N]: y - Key imported successfully - Remi's RPM repository for Enterprise Linux 9 - x86_64 - Importing GPG key 0x478F8947: - Userid : "Remi's RPM repository (https://rpms.remirepo.net/) " - Fingerprint: B1AB F71E 14C9 D748 97E1 98A8 B195 27F1 478F 8947 - From : /etc/pki/rpm-gpg/RPM-GPG-KEY-remi.el9 - Is this ok [y/N]: y - Key imported successfully - Running transaction check - Transaction check succeeded. - Running transaction test - Transaction test succeeded. - - Complete! - ``` - -=== "8.9 installare PHP" +Questo esempio installa PHP con i moduli comunemente installati con esso: - ```bash - sudo dnf install php php-cli php-gd php-curl php-zip php-mbstring - ``` +```bash +sudo dnf install php php-cli php-gd php-curl php-zip php-mbstring +``` È possibile verificare che la versione installata corrisponda a quella prevista: -=== "9.3 controllare la versione di PHP" - - ```bash - $ php -v - PHP 8.3.2 (cli) (built: Jan 16 2024 13:46:41) (NTS gcc x86_64) - Copyright (c) The PHP Group - Zend Engine v4.3.2, Copyright (c) Zend Technologies - with Zend OPcache v8.3.2, Copyright (c), by Zend Technologies - ``` - -=== "8.9 controllare la versione di PHP" - - ```bash - $ php -v - PHP 7.4.19 (cli) (built: May 4 2021 11:06:37) ( NTS ) - Copyright (c) The PHP Group - Zend Engine v3.4.0, Copyright (c) Zend Technologies - with Zend OPcache v7.4.19, Copyright (c), by Zend Technologies - ``` +```bash +php -v +PHP 8.3.19 (cli) (built: Mar 12 2025 13:10:27) (NTS gcc x86_64) +Copyright (c) The PHP Group +Zend Engine v4.3.19, Copyright (c) Zend Technologies + with Zend OPcache v8.3.19, Copyright (c), by Zend Technologies +``` ### Configurazione @@ -198,27 +87,27 @@ Per servire pagine PHP in modalità CGI, è necessario installare il server Apac * Installazione: - ```bash - sudo dnf install httpd - ``` + ```bash + sudo dnf install httpd + ``` * Attivazione: - ```bash - sudo systemctl enable --now httpd - sudo systemctl status httpd - ``` + ```bash + sudo systemctl enable --now httpd + sudo systemctl status httpd + ``` -* Non dimenticate di configurare il firewall: +* Non dimenticare di configurare il firewall: - ```bash - sudo firewall-cmd --add-service=http --permanent - sudo firewall-cmd --reload - ``` + ```bash + sudo firewall-cmd --add-service=http --permanent + sudo firewall-cmd --reload + ``` -Il vhost predefinito dovrebbe funzionare subito. PHP fornisce una funzione `phpinfo()` che genera una tabella riassuntiva della sua configurazione. È molto utile per verificare il buon funzionamento di PHP. Tuttavia, fate attenzione a non lasciare tali file di prova sui vostri server. Rappresentano un enorme rischio per la sicurezza della vostra infrastruttura. +Il vhost predefinito dovrebbe funzionare immediatamente. PHP fornisce una funzione `phpinfo()` che genera una tabella riassuntiva della sua configurazione. It is very useful to test the good working of PHP. Tuttavia, fate attenzione a non lasciare tali file di prova sui vostri server. Rappresentano un enorme rischio per la sicurezza della vostra infrastruttura. -Creare il file `/var/www/html/info.php` (`/var/www/html` è la cartella vhost della configurazione predefinita di Apache): +Create il file `/var/www/html/info.php` (`/var/www/html` è la cartella vhost della configurazione predefinita di Apache): ```bash > avg_php_proc; sleep 60; done ``` -Dopo un po' di tempo, questo dovrebbe darci un'idea abbastanza precisa dell'ingombro medio della memoria di un processo PHP su questo server. +Dopo un po' di tempo, questo dovrebbe darci un'idea abbastanza precisa dell'uso medio della memoria di un processo PHP su questo server. -Il risultato riportato nel resto del documento è un ingombro di memoria pari a 120 Mb per processo a pieno carico. +Il risultato del resto di questo documento è un uso di memoria di 120 megabyte per ogni processo a pieno carico. -Su un server con 8 Gb di RAM, mantenendo 1 Gb per il sistema e 1 Gb per la OPCache (si veda il resto di questo documento), rimangono 6 Gb per elaborare le richieste PHP dei client. +On a server with 8 gigabytes of RAM, keeping 1 gigabyte for the system and 1 gigabyte for the OPCache (see the rest of this document), 6 gigabytes is left to process PHP requests from clients. -Possiamo facilmente concludere che questo server può accettare al massimo **50 thread** ( `(6*1024) / 120)`. +Si può concludere che questo server può accettare al massimo **50 thread** `((6*1024) / 120)`. Una buona configurazione di `php-fpm` specifica per questo caso d'uso sarebbe: @@ -515,8 +404,8 @@ Mantiene gli script PHP compilati in memoria, il che ha un forte impatto sull'es Per configurarlo, dobbiamo lavorare su: -* La dimensione della memoria dedicata alla opcache in base all'hit ratio, configurandola correttamente -* il numero di script PHP da memorizzare nella cache (numero di chiavi + numero massimo di script) +* La dimensione della memoria dedicata all'`opcache` in base al rapporto di hit, configurandola correttamente +* Il numero di script PHP da mettere in cache (numero di chiavi + numero massimo di script) * il numero di stringhe da mettere in cache Per installarla: @@ -535,16 +424,16 @@ opcache.max_accelerated_files=4000 dove: -* `opcache.memory_consumption` corrisponde alla quantità di memoria necessaria per l'opcache (da aumentare fino a ottenere un rapporto di hit corretto). +* `opcache.memory_consumption` corrisponde alla quantità di memoria necessaria per `opcache` (aumentarla fino a ottenere un rapporto di successo corretto). * `opcache.interned_strings_buffer` la quantità di stringhe da mettere in cache. -* `opcache.max_accelerated_files` è prossimo al risultato del comando `find ./ -iname "*.php"|wc -l`. +* `opcache.max_accelerated_files` è simile al risultato del comando `find ./ -iname "*.php"|wc -l`. -Si può fare riferimento a una pagina `info.php` (compresa la `phpinfo();`) per configurare l'opcache (si vedano ad esempio i valori di `Cached scripts` e `Cached strings`). +È possibile fare riferimento alla pagina `info.php` (incluso il comando `phpinfo();`) per configurare `opcache` (vedere ad esempio i valori di `Cached scripts` e `Cached strings`). !!! Note - A ogni nuova distribuzione di nuovo codice, sarà necessario svuotare la opcache (ad esempio riavviando il processo php-fpm). + Ad ogni nuova implementazione di codice, sarà necessario svuotare l'opcache (ad esempio riavviando il processo php-fpm). !!! Note - Non sottovalutate il guadagno di velocità che si può ottenere impostando e configurando correttamente l'opcache. + Do not underestimate the speed gain that can be achieved by setting up and configuring the `opcache` correctly. diff --git a/docs/guides/web/tor_onion_service.de.md b/docs/guides/web/tor_onion_service.de.md new file mode 100644 index 0000000000..8d0ad7b372 --- /dev/null +++ b/docs/guides/web/tor_onion_service.de.md @@ -0,0 +1,105 @@ +--- +title: Tor Onion Dienst +author: Neel Chauhan +contributors: Ganna Zhrynova +tested_with: 9.3 +tags: + - web + - proxy + - proxies +--- + +## Einleitung + +[Tor](https://www.torproject.org/) ist ein Anonymisierungsdienst und eine Software, die den Datenverkehr über drei von Freiwilligen betriebene Server, sogenannte Relays, leitet. Das Three-Hop-Design soll die Privatsphäre gewährleisten, indem es Überwachungsversuchen widersteht. + +Eine Besonderheit von Tor ist, dass man versteckte, Tor-exklusive Websites betreiben kann, die als [Onion-Dienste](https://community.torproject.org/onion-services/) bezeichnet werden. Der gesamte Datenverkehr zu einem Onion-Dienst ist daher privat und verschlüsselt. + +## Voraussetzungen + +Folgende Mindestvoraussetzungen gelten für die Anwendung dieses Verfahrens: + +- Die Möglichkeit, Befehle als Root-Benutzer auszuführen oder mit `sudo` die Berechtigungen zu erhöhen +- Erfahrung im Umgang mit einem Kommandozeilen-Editor. Der Autor verwendet hier `vi` oder `vim`, Sie können aber Ihren bevorzugten Editor verwenden +- Ein Webserver, der auf localhost oder einem anderen TCP/IP-Port läuft + +## Tor-Installation + +Zur Installation von Tor müssen Sie zuerst EPEL (Extra Packages for Enterprise Linux) installieren und Updates ausführen: + +```bash +dnf -y install epel-release && dnf -y update +``` + +Dann Tor installieren: + +```bash +dnf -y install tor +``` + +## Tor-Konfiguration + +Nach der Installation der Pakete müssen Sie Tor konfigurieren. Der Autor verwendet dafür `vim`, aber wenn Sie `nano` oder etwas anderes bevorzugen, können Sie das gerne entsprechend anpassen: + +```bash +vi /etc/tor/torrc +``` + +Die standardmäßige `torrc`-Datei ist recht aussagekräftig, kann aber sehr lang werden, wenn man nur einen Onion-Dienst benötigt. Eine minimale Onion-Service-Konfiguration sieht in etwa so aus: + +```bash +HiddenServiceDir /var/lib/tor/onion-site/ +HiddenServicePort 80 127.0.0.1:80 +``` + +### Genauere Betrachtung + +- Das Verzeichnis `HiddenServiceDir` enthält den Hostnamen und die kryptografischen Schlüssel Ihres Onion-Dienstes. Sie speichern diese Schlüssel unter `/var/lib/tor/onion-site/` +- Der `HiddenServicePort` ist die Portweiterleitung von Ihrem lokalen Server zum Onion-Dienst. Sie leiten 127.0.0.1:80 an Port 80 unseres Tor-basierten Dienstes weiter + +!!! warning "Warnhinweis" + +``` +Wenn Sie ein Verzeichnis außerhalb von `/var/lib/tor/` für Ihre Onion-Service-Signaturschlüssel verwenden möchten, müssen Sie sicherstellen, dass die Berechtigungen `0700` lauten und der Eigentümer `toranon:toranon` ist. +``` + +## Web-Server — Konfiguration + +Sie benötigen außerdem einen Webserver auf Ihrem Rechner, um Clients für Ihren Onion-Dienst zu bedienen. Jeder Webserver (Caddy, Apache oder Nginx) ist verwendbar. Der Autor bevorzugt Caddy. Der Einfachheit halber installieren wir Caddy: + +```bash +dnf -y install caddy +``` + +Als Nächstes fügen Sie Folgendes in die Datei `/etc/caddy/Caddyfile` ein: + +```bash +http:// { + root * /usr/share/caddy + file_server +} +``` + +## Testen und Hochfahren + +Sobald Sie Ihre Tor-Relay-Konfiguration eingerichtet haben, besteht der nächste Schritt darin, die Tor- und Caddy-Daemons zu aktivieren: + +```bash +systemctl enable --now tor caddy +``` + +Den Hostnamen Ihres Onion-Dienstes erhalten Sie mit diesem Befehl: + +```bash +cat /var/lib/tor/onion-site/hostname +``` + +Innerhalb weniger Minuten wird Ihr Onion-Dienst über das Tor-Netzwerk verbreitet und Sie können Ihren neuen Onion-Dienst im Tor-Browser anzeigen: + +![Tor Browser showing our Onion Service](../images/onion_service.png) + +## Zusammenfassung + +Onion-Dienste sind ein unschätzbares Werkzeug, wenn Sie eine Website privat hosten oder die Carrier-Grade-NAT-Sperre Ihres Internetanbieters ausschließlich mit Open-Source-Software umgehen müssen. + +Auch wenn Onion-Dienste nicht so schnell sind wie das direkte Hosten einer Website (was aufgrund des datenschutzorientierten Designs von Tor verständlich ist), sind sie wesentlich sicherer und privater als das öffentliche Internet. diff --git a/docs/guides/web/tor_onion_service.it.md b/docs/guides/web/tor_onion_service.it.md index 887a556177..dbcec4e930 100644 --- a/docs/guides/web/tor_onion_service.it.md +++ b/docs/guides/web/tor_onion_service.it.md @@ -9,12 +9,6 @@ tags: - proxies --- -!!! warning “Temporaneamente in Sospeso” - -``` -`tor` è attualmente assente dall'EPEL. Probabilmente verrà compilato. Il team Docs continuerà a testarne la disponibilità nell'EPEL non appena possibile. Per ora, l'unica opzione è compilare `tor` dal sorgente, ma le istruzioni per farlo non sono attualmente disponibili qui. -``` - ## Introduzione [Tor](https://www.torproject.org/) è un servizio e un software di anonimato che instrada il traffico attraverso tre server gestiti da volontari e chiamati relay. Il design a tre hop serve a garantire la privacy resistendo ai tentativi di sorveglianza. diff --git a/docs/guides/web/tor_onion_service.uk.md b/docs/guides/web/tor_onion_service.uk.md index 28075651fd..6251d2c987 100644 --- a/docs/guides/web/tor_onion_service.uk.md +++ b/docs/guides/web/tor_onion_service.uk.md @@ -9,12 +9,6 @@ tags: - proxies --- -!!! note "Альтернативний спосіб установки Caddy" - -``` -Ці інструкції стосуються створення веб-сервісу за допомогою Caddy. Наразі Caddy недоступний в EPEL. Дотримуйтесь [документації Caddy](caddy.md) для отримання альтернативних інструкцій з інсталяції. -``` - ## Вступ [Tor](https://www.torproject.org/) — це служба анонімності та програмне забезпечення, яке направляє трафік через три сервери, що працюють на волонтерах і називаються ретрансляторами. Конструкція з трьома стрибками забезпечує конфіденційність шляхом протидії спробам стеження. diff --git a/docs/labs/systems_administration_I/lab3-system_utilities.it.md b/docs/labs/systems_administration_I/lab3-system_utilities.it.md index a7d2456d94..ed572aca02 100644 --- a/docs/labs/systems_administration_I/lab3-system_utilities.it.md +++ b/docs/labs/systems_administration_I/lab3-system_utilities.it.md @@ -1,12 +1,10 @@ - - - -author: Wale Soyinka contributors: Steven Spencer, Ganna Zhyrnova tested on: All Versions tags: +title: Lab 3 - Utility di Sistema comuni author: Wale Soyinka contributors: Steven Spencer, Ganna Zhyrnova, Franco Colussi tested on: Tutte le versioni tags: - lab exercise - system utilities - cli - - - -# Laboratorio 3: Utilità di sistema comuni - ## Obiettivi Dopo aver completato questo laboratorio, sarete in grado di @@ -17,17 +15,24 @@ Tempo stimato per completare questo laboratorio: 70 minuti ## Utilità di sistema comuni presenti nei sistemi Linux +### Cos'è una Utility di Sistema? + +In un ambiente Linux, le *utility di sistema* sono programmi e comandi che consentono di gestire, monitorare e ottimizzare il funzionamento del sistema operativo. Questi strumenti sono essenziali per amministratori di sistema, sviluppatori e utenti avanzati, poiché semplificano attività quali la gestione dei file, il controllo dei processi, la configurazione di rete e molto altro ancora. + +Al posto d'interfacce grafiche, molte utilità sono accessibili tramite la riga di comando, offrendo maggiore flessibilità, automazione e controllo sul sistema. + Gli esercizi di questo laboratorio riguardano l'utilizzo di alcune utilità di sistema di base che sia gli utenti che gli amministratori devono conoscere bene. La maggior parte dei comandi viene utilizzata per navigare e manipolare il file system. Il file system è costituito da file e directory. Gli esercizi tratteranno l'utilizzo delle utilità –`pwd`, `cd`, `ls`, `rm`, `mv`, `ftp`, `cp`, `touch`, `mkdir`, `file`, `cat`, `find`, e `locate`. -## Esercizio 1 +## Esercizi -### `cd` +### 1. Navigare nel file system con `cd` -Il comando `cd` sta per cambia directory. Inizierete questi laboratori passando ad altre directory sul file system. +Il comando `cd` (abbreviazione di ==Change Directory==) è uno dei comandi più comunemente utilizzati nei sistemi Linux e Unix-like. Consente di spostarsi tra le directory del file system, permettendo agli utenti di navigare tra le cartelle e accedere ai file in esse contenuti. +Il comando `cd` è essenziale per lavorare nella shell Linux, poiché consente di esplorare e organizzare il file system in modo efficiente. -#### Per utilizzare `cd` +#### Come si usa `cd` 1. Accedere al computer come root @@ -57,37 +62,34 @@ Il comando `cd` sta per cambia directory. Inizierete questi laboratori passando [root@localhost local]# cd /root ``` -6. Passare nuovamente alla directory /usr/local/. Digitare: +6. Passare nuovamente alla directory `/usr/local/ `. Digitare: ```bash [root@localhost root]# cd /usr/local ``` -7. Per passare alla directory principale della directory locale, digitare "cd ..". +7. Per passare alla directory superiore della directory locale, digitare `cd ..`. ```bash [root@localhost local]# cd .. ``` - !!! question "Domanda" + !!! Question "Domanda" - Qual è la directory principale della directory /usr/local/? + Qual è la directory a monte della directory `/usr/local/`? 8. Per tornare rapidamente alla directory home di root, digitare "cd" senza alcun argomento. ```bash [root@localhost usr]# cd - [root@localhost root]# ``` -## Esercizio 2 +### 2. Visualizzare il path con `pwd` -### `pwd` +Il comando `pwd` (==Present Working Directory==) mostra all'utente il percorso (path) assoluto della directory corrente all'interno del file system. Viene utilizzato per identificare la posizione corrente quando si lavora col terminale e si desidera sapere esattamente dove ci si trova. Questo comando è essenziale per navigare nel file system, specialmente quando si lavora con percorsi complessi o script automatizzati. -Il comando `pwd` sta per "directory di lavoro corrente". Mostra la posizione in cui ti trovi nel file system. - -#### Per utilizzare `pwd` +#### Come utilizzare `pwd` 1. Per scoprire la vostra directory di lavoro attuale, digitare: @@ -96,7 +98,7 @@ Il comando `pwd` sta per "directory di lavoro corrente". Mostra la posizione in /root ``` -2. Passare alla directory /usr/local/ utilizzando il comando "cd": +2. Passare alla directory `/usr/local/` utilizzando il comando `cd`: ```bash [root@localhost root]# cd /usr/local @@ -115,27 +117,25 @@ Il comando `pwd` sta per "directory di lavoro corrente". Mostra la posizione in [root@localhost root]# cd ``` -## Esercizio 3 - -### `mkdir` +### 3. Creare cartelle con `mkdir` -Il comando `mkdir` viene utilizzato per creare directory. Si creeranno due directory chiamate "folder1" e "folder2". +Il comando `mkdir` (==Make Directory==) consente di creare nuove directory (cartelle) all'interno del file system. In questo esercizio si creeranno due cartelle denominate `cartella1` e `cartella2`. -#### Per utilizzare `mkdir` +#### Come usare `mkdir` -1. Digitare: +1. Creare la prima directory denominata `folder1` ```bash [root@localhost root]# mkdir folder1 ``` -2. Crea una seconda directory chiamata folder2 +2. Creare la seconda directory denominata `folder2` ```bash [root@localhost root]# mkdir folder2 ``` -3. Ora cambiate la vostra directory di lavoro nella directory “folder1” che avete creato sopra. +3. Ora spostatevi dalla vostra directory di lavoro nella directory “folder1” che avete creato sopra. ```bash [root@localhost root]# cd folder1 @@ -154,21 +154,20 @@ Il comando `mkdir` viene utilizzato per creare directory. Si creeranno due direc 5. Tornare alla directory home di root. -## Esercizio 4 - -### `touch` +### 4. Modificare i metadata dei file con `touch` -Il comando `touch` può essere utilizzato per creare file ordinari. Verranno creati i file “file11, file12, file21 e file22” nelle cartelle create sopra. +Il comando `touch` è uno strumento che consente di creare nuovi file vuoti o modificare le date di accesso/modifica dei file esistenti, oltre a consentire usi avanzati nella creazione di script e nell'automazione. Il nome ==touch== deriva dall'idea di “*toccare*” i metadati del file senza necessariamente modificarne il contenuto. +I file *file11*, *file12*, *file21* e *file22* verranno creati nelle cartelle create sopra. -#### Per utilizzare `touch` +#### Come utilizzare `touch` -1. Cambiare directory, ovvero `cd` alla folder1 e creare il "file11:" +1. Cambiare directory, ovvero `cd` alla `folder1` e craere il file *file11*: ```bash [root@localhost folder1]# touch file11 ``` -2. Mentre si è ancora nella folder1, creare “file12:” +2. Mentre si è ancora nella `folder1` creare *file12*: ```bash [root@localhost folder1]# touch file12 @@ -184,13 +183,11 @@ Il comando `touch` può essere utilizzato per creare file ordinari. Verranno cre 5. Tornare alla directory home di root. -## Esercizio 5 +### 5. Elencare le directory con `ls` -### `ls` +Il comando ls (==List==) è uno dei comandi più basilari e ampiamente utilizzati nei sistemi Linux e Unix-like. Consente di visualizzare il contenuto di una directory, mostrando file e sottodirectory con varie opzioni di formattazione e ordinamento. -Il comando `ls` sta per lista. Elenca il contenuto di una directory. - -#### Per utilizzare `ls` +#### Come usare `ls` 1. Digitare `ls` nella directory home di root: @@ -198,22 +195,22 @@ Il comando `ls` sta per lista. Elenca il contenuto di una directory. [root@localhost root]# ls ``` - !!! question "Domanda" + !!! Question "Domanda" Elenca il contenuto della directory 2. Passare alla directory "folder1" -3. Elencare il contenuto della directory "folder1". Digitare `ls` +3. Elencare il contenuto della directory `folder1`. Digitare `ls` ```bash [root@localhost folder1]# ls file11 file12 ``` -4. Passare alla directory "folder2" ed elencare il suo contenuto: +4. Passare alla directory `folder2` ed elencare il suo contenuto: -5. Tornare alla directory home ed elencare "tutti" i file e le cartelle nascosti: +5. Tornare alla directory home ed elencare **tutti** i file e le cartelle nascosti: ```bash [root@localhost folder2]# cd @@ -227,33 +224,22 @@ Il comando `ls` sta per lista. Elenca il contenuto di una directory. ```bash [root@localhost root]# ls –al total 44 - drwx------ 5 root root 4096 May 8 10:15 . - drwxr-xr-x 8 root root 4096 May 8 09:44 .. - -rw------- 1 root root 43 May 8 09:48 .bash_history - -rw-r--r-- 1 root root 24 May 8 09:44 .bash_logout - -rw-r--r-- 1 root root 191 May 8 09:44 .bash_profile - -rw-r--r-- 1 root root 124 May 8 09:44 .bashrc - drwxrwxr-x 2 root root 4096 May 8 10:17 folder1 - drwxrwxr-x 2 root root 4096 May 8 10:18 folder2 - ……………………….. ``` -## Esercizio 6 - -### `mv` +### 6. Spostare i file con `mv` -Il comando `mv` sta per muovere. Rinomina file o directory. Può anche spostare i file. +Il comando `mv` (==Move==) fornisce uno strumento per la gestione dei file nel sistema. La sua funzione principale è quella di spostare o rinominare file e directory all'interno del file system. Questo comando è particolarmente utile per riorganizzare la struttura delle directory, eseguire operazioni batch su gruppi di file e gestire i backup in modo efficiente. -#### Per utilizzare `mv` +#### Come usare `mv` 1. Passare alla directory "folder1" ed elencare il suo contenuto: @@ -264,7 +250,7 @@ Il comando `mv` sta per muovere. Rinomina file o directory. Può anche spostare file11 file12 ``` -2. Si rinomineranno i file file11 e file12 nella directory “folder1” rispettivamente in temp_file11 e temp_file12: +2. Si rinominino i file file11 e file12 nella directory “folder1” rispettivamente in temp_file11 e temp_file12: ```bash [root@localhost folder1]# mv file11 temp_file11 @@ -276,7 +262,7 @@ Il comando `mv` sta per muovere. Rinomina file o directory. Può anche spostare [root@localhost folder1]# ls ``` - !!! question "Domanda" + !!! Question "Domanda" Annotare i contenuti: @@ -300,69 +286,67 @@ Il comando `mv` sta per muovere. Rinomina file o directory. Può anche spostare Qual è il comando per farlo? Elencare anche l'output del comando? -## Esercizio 7 +### 7. Copiare file con `cp` -### `cp` +Il comando `cp` (==Copia==) consente di duplicare file e directory da una posizione all'altra nel file system, mantenendo intatto il file originale. La sua facilità d'uso e versatilità lo rendono indispensabile sia per le operazioni quotidiane che per le attività di amministrazione di sistema più complesse. Tra le caratteristiche più utili del comando `cp` vi è la capacità di preservare gli attributi originali dei file durante la copia, inclusi *permessi*, *timestamp* e *informazioni sul proprietario*. Questa funzione è particolarmente importante quando si lavora con file di configurazione o quando è necessario mantenere intatte determinate proprietà dei documenti. -Il comando `cp` sta per copia. Crea copie di file o cartelle. +#### Come usare `cp` -1. Cambiare la vostra directory nella directory "folder2". +1. Passa alla directory `folder2`. -2. Copiare il contenuto della "folder2" (temp_file21 e temp_file22) nella "folder1:" +2. Copiare il contenuto della cartella `folder2` (*temp_file21* e *temp_file22*) nella cartella `folder1`: ```bash - [root@localhost folder2]# cp temp_file21 temp_file22 ../folder1 + [root@localhost folder2]# cp temp_file21 temp_file22 ../folder1 ``` -3. Elencare il contenuto della folder1. +3. Elencare il contenuto della `folder1`. ```bash [root@localhost folder2]# ls ../folder1 temp_file11 temp_file12 temp_file21 temp_file22 ``` -4. Elencare il contenuto della folder2. Si noti che le copie originali di temp_file21 e temp_file22 rimangono nella folder2. +4. Elencare il contenuto della `folder2`. Si noti che le copie originali di *temp_file21* e *temp_file22* rimangono nella `folder2`. ```bash [root@localhost folder2]# ls temp_file21 temp_file22 ``` -## Esercizio 8 - -### `file` +### 8. Determinare il tipo di file con `file` -L'utilità `file` viene utilizzata per determinare i tipi di file o directory. +Il comando `file` è uno strumento diagnostico che consente di determinare la tipologia di un file analizzandone il contenuto. A differenza delle estensioni dei file, che possono essere modificate o fuorvianti, questo comando esamina la struttura effettiva dei dati per identificarne con precisione la natura. Una delle caratteristiche più importanti del comando `file` è la sua capacità di distinguere tra diversi tipi di file di testo, identificando, ad esempio, script di shell, codice sorgente in vari linguaggi di programmazione, file XML o JSON. Per i file binari, è in grado di riconoscere eseguibili, librerie condivise, immagini in vari formati e molti altri tipi di dati strutturati. -#### Per utilizzare `file` +#### Come utilizzare `file` 1. Tornare alla directory home. -2. Per vedere se "folder1" è un file o una directory, digitare: +2. Per verificare se `cartella1` è un file o una directory, digitare: ```bash [root@localhost root]# file folder1 folder1: directory ``` -3. Passare alla folder1 +3. Passare alla cartella `folder1` -4. Utilizzare l'utilità `file` per determinare il tipo di file per temp_file11: +4. Utilizzare l'utilità `file` per determinare il tipo di file per *temp_file11*: ```bash [root@localhost folder1]# file temp_file11 temp_file11: empty ``` -5. Utilizzare l'utilità `file` per scoprire il tipo di file di tutti i file presenti nella folder1. Elenco qui: +5. Utilizzare l'utilità `file` per scoprire il tipo di file di tutti i file presenti nella `folder1` . Elencare qui: -6. Passare alla cartella /etc: +6. Passate alla directory `/etc`: ```bash [root@localhost folder1]# cd /etc ``` -7. Utilizzare l'utilità `file` per scoprire il tipo di file del file "passwd". +7. Utilizzare l'utilità `file` per scoprire il tipo di file del file *passwd*. ```bash [root@localhost etc]# file passwd @@ -372,17 +356,15 @@ L'utilità `file` viene utilizzata per determinare i tipi di file o directory. Di che tipo di file si tratta? -## Esercizio 9 - -### `cat` +### 9. Elenca e concatena i file con `cat` -Il comando `cat` è l'abbreviazione di concatenate, cioè mettere insieme i file. Il comando `cat` visualizza anche il contenuto di un intero file sullo schermo. Si utilizzerà `cat` insieme al simbolo di reindirizzamento ">" per creare un file. +Il comando `cat` (abbreviazione di ==Concatenate==) è uno strumento essenziale per la gestione dei file di testo in Linux. La sua funzione principale è quella di visualizzare il contenuto di uno o più file direttamente a terminale, ma può anche essere utilizzato per creare, unire o copiare file. Il comando cat è particolarmente utile in combinazione con altri strumenti (come grep o more) per elaborare o filtrare testi direttamente dal terminale. Nonostante la sua semplicità, è uno dei comandi più utilizzati per la rapida manipolazione dei file. Si utilizza `cat` insieme al simbolo di reindirizzamento “>” per creare un file. -#### Per usare `cat` per creare un file +#### Usare `cat` per creare un file 1. Passare alla directory /root/folder1 -2. Creare un nuovo file di testo chiamato "first.txt" +2. Creare un nuovo file di testo chiamato *first.txt* ```bash [root@localhost folder1]# cat > first.txt @@ -396,10 +378,10 @@ Il comando `cat` è l'abbreviazione di concatenate, cioè mettere insieme i file 4. Premere contemporaneamente i tasti ++ctrl+c++. -5. Digitare "cat first.txt" per leggere il testo appena digitato: +5. Digitare `cat first.txt` per leggere il testo appena digitato: ```bash - [root@localhost folder1]# cat first.txt + [root@localhost folder1]# cat first.txt Questa è una riga di first.txt !! ``` @@ -409,49 +391,48 @@ Il comando `cat` è l'abbreviazione di concatenate, cioè mettere insieme i file Qual è il comando per farlo? -#### Per usare `cat` per concatenare insieme i file +#### Usare `cat` per concatenare insieme i file -1. Si concatenaneranno i file "first.txt" e "second.txt". Digitare: +1. Se si vuole concatenare i file *first.txt* e *second.txt*. Digitare: ```bash - [root@localhost folder1]# cat first.txt second.txt + [root@localhost folder1]# cat first.txt second.txt ``` !!! question "Domanda" - Qual è il vostro risultato? + Qual è il risultato? -## Esercizio 10 +### 10. Trasferire file con `ftp` -### `ftp` - -`ftp` è un programma client per l'utilizzo e la connessione ai servizi FTP tramite il File Transfer Protocol. Il programma consente agli utenti di trasferire file da e verso un sito di rete remoto. Si tratta di un'utility che potrebbe essere utilizzata spesso. - -In questo esercizio imparerete ad accedere in modo anonimo a un server FTP e a scaricare un file dal server utilizzando un programma client `ftp`. +Il comando `ftp` (File Transfer Protocol) è uno strumento a riga di comando che consente di trasferire file tra sistemi remoti e locali. Sebbene sia stato parzialmente sostituito da protocolli più moderni e sicuri come *SFTP* e *SCP*, rimane utile in contesti legacy o con server che supportano solo FTP. +L'FTP trasmette i dati in **testo chiaro**, comprese le credenziali e i contenuti, quindi non è consigliato per i trasferimenti sensibili. +Sebbene l'FTP sia ancora utilizzato in alcuni ambienti, per operazioni sicure sono preferibili i protocolli crittografati. +In questo esercizio imparerai come accedere in modo anonimo a un server FTP e scaricare un file dal server utilizzando un programma *client FTP*. !!! note "Nota" Per poter seguire questo esercizio specifico, che richiede un server FTP disponibile e raggiungibile, è necessario aver completato gli esercizi del laboratorio precedente. -#### Per utilizzare `ftp` +#### Come usare `ftp` 1. Accedere al computer come root -2. Passare alla directory "/usr/local/src/" +2. Passare alla directory `/usr/local/src/` -3. Creare una nuova directory chiamata "downloads" nella directory "/usr/local/src/". +3. Creare una nuova directory chiamata `downloads` all'interno della directory `/usr/local/src/`. !!! question "Domanda" Qual è il comando per farlo? -4. Passa alla directory "downloads" appena creata +4. Andate nella directory `downloads` appena creata ```bash [root@localhost src]# cd downloads ``` -5. Digitare "ftp" per avviare il client `ftp`: +5. Digitare `ftp` per avviare il *client ftp*: ```bash [root@localhost downloads]# ftp @@ -462,13 +443,12 @@ In questo esercizio imparerete ad accedere in modo anonimo a un server FTP e a s ```bash ftp> open < server-address> (Obtain the from your instructor) - ……… - + ……… 220 localhost.localdomain FTP server (Version wu-2.6.2-5) ready. ……….. ``` -7. Accedere come utente anonimo. Digitare "anonymous" al prompt: +7. Accedere come utente anonimo. Digitare “*anonymous*” nel prompt: ```bash Name (10.4.51.29:root): anonymous @@ -480,11 +460,8 @@ In questo esercizio imparerete ad accedere in modo anonimo a un server FTP e a s Password: *************** 230 Guest login ok, access restrictions apply. - Remote system type is UNIX. - Using binary mode to transfer files. - ftp> ``` @@ -496,9 +473,9 @@ In questo esercizio imparerete ad accedere in modo anonimo a un server FTP e a s !!! question "Domanda" - Qual è l'output del comando binario e cos'è la modalità binaria “modalità binaria”? + Qual è l'output del comando binario e cos'è la “modalità binaria”? -10. Elencare le directory correnti sul server ftp. Digitare "ls" al prompt ftp. (ftp>): +10. Elencare le directory correnti sul server ftp. Digitare `ls` nel *prompt ftp*: ```bash ftp> ls @@ -509,76 +486,71 @@ In questo esercizio imparerete ad accedere in modo anonimo a un server FTP e a s 226 Transfer complete. ``` -11. Passare alla directory "pub". Digitare: +11. Passare alla directory `pub` . Digitare: ```bash ftp> cd pub ``` -12. Utilizzare il comando "ls" per elencare i file e le directory presenti nella directory "pub" +12. Utilizzare il comando `ls` per elencare i file e le directory presenti nella directory `pub` !!! question "Domanda" Quanti file e directory ci sono adesso? -13. Scaricare il file denominato "hello-2.1.1.tar.gz" nella directory locale. Digitare "yes" quando richiesto. +13. Scaricare il file denominato “*hello-2.1.1.tar.gz*” in locale. Digitare “*yes*” quando richiesto. ```bash ftp> mget hello-2.1.1.tar.gz - mget hello-2.1.1.tar.gz? yes + mget hello-2.1.1.tar.gz? yes 227 Entering Passive Mode (10,0,4,5,16,252). - 125 Data connection already open; Transfer starting. - 226 Transfer complete. - 389363 bytes received in 0.0745 secs (5.1e+03 Kbytes/sec) ``` -14. Disconnettersi dal server FTP e chiudere il client `ftp`. Digitare: +14. Disconnettersi dal server FTP e chiudere il *client ftp*. Digitare: ```bash ftp> bye ``` -15. Verrai reindirizzato alla tua shell locale. +15. Si verrà reindirizzati alla shell locale. -16. Assicurati di trovarti ancora nella directory "download" del tuo computer locale. +16. Assicuratevi di trovarvi ancora nella directory `downloads` della vostra macchina in locale. !!! question "Domanda" - Elencare i file nella cartella dei downloads. - -## Esercizio 11 + Elencare i file nella cartella downloads. -### Utilizzo del reindirizzamento +### 11. Utilizzo del reindirizzamento -La maggior parte delle utility e dei comandi utilizzati in Linux inviano il loro output allo schermo. Lo schermo è chiamato output standard (stdout). Il reindirizzamento consente di inviare l'output altrove – ad esempio in un file. +La maggior parte delle utility e dei comandi utilizzati in Linux inviano il loro output allo schermo. Lo schermo è chiamato standard output (*stdout*). Il reindirizzamento consente di inviare l'output altrove – ad esempio in un file. -Ogni programma avviato su un sistema Linux ha tre descrittori di file aperti: stdin (0), stdout (1) e stderr (2). È possibile reindirizzarli o convogliarli individualmente tramite "pipe". I simboli di reindirizzamento sono ">, < " +Ogni programma avviato su un sistema Linux ha tre descrittori di file aperti, *stdin* **(0)**, *stdout* **(1)** e *stderr* **(2)**. È possibile reindirizzarli o “*pipe*” (ricondurli) singolarmente. I simboli di reindirizzamento sono ++maggiore++ e ++minore++. -#### Per utilizzare il reindirizzamento +#### Come usare il reindirizzamento -1. Assicurarsi di essere ancora nella directory folder1. +1. Assicurarsi di essere ancora nella directory `folder1`. -2. Si utilizzerà il reindirizzamento dell'output per reindirizzare l'output del comando ls (elenco) a un file di testo denominato myredirects: +2. Si utilizzerà il reindirizzamento dell'output per reindirizzare l'output del comando `ls` (*lista*) a un file di testo denominato myredirects: ```bash [root@localhost folder1]# ls > myredirects ``` -3. Esaminare il contenuto del nuovo file (myredirects) creato nella directory folder1. +3. Esaminare il contenuto del nuovo file (*myredirects*) creato nella directory `folder1`. ```bash [root@localhost folder1] # cat myredirects temp_file11 temp_file12 temp_file21 temp_file22 myredirects ``` -4. Ora il risultato del comando file verrà reindirizzato nello stesso file. Si vuole scoprire il tipo di file per temp_file11 nella directory folder1 e inviare l'output al file myredirects: +4. Ora il risultato del comando file verrà reindirizzato nello stesso file. Si vuole scoprire il tipo di file per *temp_file11* nella directory `folder1` e inviare l'output al file *myredirects*: ```bash - [root@localhost folder1]# file temp_file11 > myredirects + [root@localhost folder1]# file temp_file11 > myredirects ``` 5. Esaminare il contenuto del file myredirects. @@ -587,48 +559,45 @@ Ogni programma avviato su un sistema Linux ha tre descrittori di file aperti: st È cambiato. Cos'è successo? -6. Se si vuole evitare che si verifichi quanto sopra, si utilizzerà il doppio simbolo di reindirizzamento “>>”. Questo aggiungerà (appenderà) il nuovo output al file invece di sostituirlo. Fate una prova: +6. Se si vuole evitare che si verifichi quanto sopra, si utilizzerà il doppio simbolo di reindirizzamento ++">>"++. Questo accoderà (*aggiungerà*) il nuovo output al file invece di sostituirlo. Fate una prova: ```bash - [root@localhost folder1]# ls >> myredirects + [root@localhost folder1]# ls >> myredirects ``` -7. Ora esaminare nuovamente il contenuto del file myredirects utilizzando `cat`. +7. Ora si esamini nuovamente il contenuto del file *myredirects* utilizzando `cat`. !!! question "Domanda" - Scrivi qui il suo contenuto: + Scrivere qui il suo contenuto: -### Utilizzo del reindirizzamento per sopprimere l'output di un comando +#### Utilizzare il reindirizzamento per sopprimere l'output di un comando -I concetti trattati in questa sezione saranno molto utili in Linux, quindi ti invitiamo a prestare particolare attenzione. Può essere un po' complicato. +I concetti trattati in questa sezione saranno molto utili in Linux, quindi vi invitiamo a prestare particolare attenzione. Potrebbe apparire un po' complicato. -Ci saranno momenti in cui non vorrai che l'utente veda l'output di un comando, ad esempio un messaggio di errore. Questo accade solitamente perché i messaggi di errore strani spesso spaventano gli utenti abituali. In questo esercizio si invierà l'output tuoi comandi al dispositivo nullo ( /dev/null/ ). Il dispositivo nullo è come un "bit bucket". Tutto ciò che metti dentro scompare per sempre. È anche possibile inviare (o reindirizzare) l'output regolare dei comandi al dispositivo nullo "null device". +Ci saranno casi in cui non si vuole che l'utente veda l'output di un comando, ad esempio un messaggio di errore. Accade spesso infatti che i messaggi di errore strani spaventino gli utenti comuni. In questo esercizio si dirotterà l'output dei comandi al *dispositivo null* ( `/dev/null/` ). Il *dispositivo null* è simile a un “*bit bucket*”. Tutto ciò che metti dentro scompare per sempre. È anche possibile inviare (o reindirizzare) l'output regolare dei comandi al *dispositivo null*. Utilizzare le linee guida riportate di seguito: -```bash -|Redirector|

Function

| -| :- | :- | -|> file|Indirizza l'output standard su un file| -|< file|Prende l'input standard dal file| -|Cmd1 | cmd2|Pipe; prende lo standard out da cmd1 come input standard per cmd2| -|n> file|Descritore di file n a file| -|N< file|Imposta il file come descrittore di file n| -|>&n|Duplica l'output standard nel descrittore di file n| -|<&n|Duplica l'input standard dal descrittore di file n| -|&>file|Indirizza l'output standard e l'errore standard al file| - -``` +| Reindirizzatore | Funzione | +| --------------- | --------------------------------------------------------------------------- | +| > file | Indirizza lo standard output al file | +| < file | Riceve come standard input dal file | +| Cmd1 \ | cmd2 | Pipe; prende lo standard output di cmd1 come standard input per cmd2 | +| n> file | Indirizza il descrittore del file n al file | +| N< file | Imposta il file come descrittore del file N | +| >&n | Duplica lo standard output nel descrittore di file n | +| <&n | Duplica lo standard input dal descrittore del file n | +| &>file | Indirizza lo standard output e lo standard error nel file | -1. Assicurarsi di essere ancora nella directory folder1. Utilizzare l'opzione di elenco esteso del comando ls su temp_file11: +1. Assicurarsi di essere ancora nella directory `folder1`. Utilizzare l'opzione di elenco esteso del comando `ls` su *temp_file11*: ```bash [root@localhost folder1]# ls –l temp_file11 -rw-r--r-- 1 root root 0 Jul 26 18:26 temp_file11 ``` -2. Reindirizzare l'output dello stesso comando sopra riportato (ls –l temp_file11) al dispositivo nullo. +2. Reindirizzare l'output dello stesso comando sopra riportato (0>ls –l temp_file11) al dispositivo null. ```bash [root@localhost folder1]# ls –l temp_file11 > /dev/null @@ -645,7 +614,7 @@ Utilizzare le linee guida riportate di seguito: Quanto sopra è il risultato del tipo di errore che il comando `ls` ha programmato di restituire. -4. Eseguire lo stesso comando di cui sopra con un nome file scritto in modo errato e reindirizzarlo a /dev/null +4. Esegure lo stesso comando di cui sopra con un nome file scritto in modo errato e reindirizzalo a `/dev/null`. ```bash [root@localhost folder1]# ls -l te_file1 > /dev/null @@ -655,7 +624,7 @@ Utilizzare le linee guida riportate di seguito: !!! question "Domanda" - Cosa è successo qui? Perché l'output continuava a essere visualizzato sullo schermo (stdout)? + Cosa è successo qui? Perché l'output continua a essere visualizzato sullo schermo (stdout)? 5. Per vari motivi potresti voler sopprimere messaggi di errore come quello sopra riportato. Per farlo, digitare: @@ -663,32 +632,28 @@ Utilizzare le linee guida riportate di seguito: [root@localhost folder1]# ls –l te_file1 > /dev/null 2>&1 ``` - Non otterrete alcun risultato. - - Questa volta vengono soppressi sia l'output standard che l'errore standard. + Non otterrete alcun risultato. Questa volta vengono soppressi sia l'output standard che l'errore standard. L'ordine di reindirizzamento è IMPORTANTE!! - Il reindirizzamento viene letto da sinistra a destra sulla riga di comando. + Il reindirizzamento viene letto da sinistra a destra sulla riga di comando. La parte più a sinistra del simbolo di reindirizzamento - ++greater++ invierà lo standard output (*stdout*) a `/dev/null`. Quindi la parte più a destra del reindirizzamento - `2>&1` duplicherà lo standard error **(2)** nello standard output **(1)**. - La parte più a sinistra del simbolo di reindirizzamento - “>”: invierà l'output standard (stdout) a /dev/null. Quindi la parte più a destra del reindirizzamento - “2>&1 ”: duplicherà l'errore standard (2) nell'output standard (1). - - Quindi il comando sopra riportato può essere letto come: reindirizza stdout(1) a “/dev/null” e poi copia stderr (2) su stdout + Pertanto, il comando sopra riportato può essere letto come: *reindirizza stdout(1) a “/dev/null” e poi copia stderr (2) a stdout* 6. Per dimostrare ulteriormente l'importanza dell'ordine di reindirizzamento, prova: ```bash - [root@localhost folder1]# ls –l tem_file 2>&1 > order.txt + [root@localhost folder1]# ls –l tem_file 2>&1 > order.txt ``` - Utilizzare il comando `cat` per esaminare il contenuto del file "order.txt" + Utilizzate il comando `cat` per esaminare il contenuto del file “*order.txt*” La parte più a sinistra – “2>&1” copierà l'errore standard nell'output standard. Quindi, la parte più a destra di quanto sopra – “ > order.txt” reindirizza stdout al file order.txt. 7. Provare questa variante del passaggio precedente: ```bash - [root@localhost folder1]# ls –l hgh_ghz 2> order2.txt > order2.txt + [root@localhost folder1]# ls –l hgh_ghz 2> order2.txt > order2.txt ``` !!! question "Domanda" @@ -698,69 +663,62 @@ Utilizzare le linee guida riportate di seguito: 8. Per inviare l'output standard e l'errore standard a file separati; Digitare: ```bash - [root@localhost folder1]# ls –l tep_f > standard_out 2> standard_err + [root@localhost folder1]# ls –l tep_f > standard_out 2> standard_err ``` !!! question "Domanda" Sono stati creati due nuovi file. Quali sono i nomi dei file e qual è il loro contenuto? -9. È possibile reindirizzare sia stdout che stderr allo stesso file utilizzando: +9. È possibile reindirizzare sia lo *stdout* che lo *stderr* allo stesso file utilizzando: ```bash - [root@localhost folder1]# ls –l te_fil &> standard_both + [root@localhost folder1]# ls –l te_fil &> standard_both ``` -## Esercizio 12 - -### `rm` +### 12. Cancellare file con `rm` -Il comando `rm` viene utilizzato per eliminare file o directory. Si utilizzerà il comando `rm` per eliminare alcuni dei file creati negli esercizi precedenti. +Il comando `rm` (Rimuovi) consente di eliminare definitivamente uno o più file, directory e relativi contenuti, senza possibilità di recupero se non tramite soluzioni di recupero esterne. È un comando potente, ma potenzialmente pericoloso se usato in modo improprio, poiché opera in modo irreversibile. Per questo motivo è importante utilizzarlo con cautela, controllando sempre i percorsi e i nomi dei file prima di eseguire l'operazione. +Utilizzerete `rm` per eliminare alcuni dei file creati negli esercizi precedenti. -#### Per utilizzare `rm` +#### Come si usa `rm` -1. Mentre si è ancora nella directory "folder1", eliminare il file standard_err. Digitare "y" alla richiesta di conferma: +1. Mentre si è ancora nella directory `folder1`, eliminare il file *standard_err*. Digitare ++“y”++ alla richiesta di conferma: ```bash [root@localhost folder1]# rm standard_err rm: remove `standard_err'? y ``` -2. Eliminare il file "standard_out". Per evitare che venga richiesta la conferma prima di eliminare un file, utilizzare l'opzione "–f " con il comando `rm`: +2. Eliminare il file *standard_out*. Per evitare che venga richiesta la conferma prima di eliminare un file, utilizzare l'opzione `–f` con il comando `rm`: ```bash - [root@localhost folder1]# rm -f standard_out + [root@localhost folder1]# rm -f standard_out ``` -3. Ritornare alla directory home (/root) ed eliminare la directory "folder2". Se si vuole usare `rm` per eliminare una cartella, bisogna usare l'opzione “–r”: +3. Tornare alla directory home (`/root`) ed eliminare la directory `folder2`. Utilizzare `rm` per eliminare una cartella è necessario utilizzare l'opzione `–r`: ```bash - [root@localhost root]# rm -r folder2 - - rm: descend into directory `folder2'? y - - rm: remove `folder2/temp_file21'? y - - rm: remove `folder2/temp_file22'? y - - rm: remove directory `folder2'? y + [root@localhost root]# rm -r folder2 + rm: descend into directory 'folder2'? y + rm: remove 'folder2/temp_file21'? y + rm: remove 'folder2/temp_file22'? y + rm: remove directory 'folder2'? y ``` !!! question "Domanda" Vi è stato nuovamente chiesto di confermare la rimozione di ogni singolo file nella directory e della directory stessa. Quale opzione si utilizzerà con il comando `rm –r` per evitare che ciò accada? -## Esercizio 13 +### 13. Imparare `vi` -### Imparare `vi` +L'editor `vi` è uno degli editor di testo più potenti e diffusi disponibili su sistemi Linux e Unix-like. È uno strumento essenziale per amministratori di sistema e sviluppatori grazie alla sua efficienza e versatilità. A differenza di molti editor moderni, `vi` funziona principalmente in modalità testo, offrendo comandi rapidi e combinazioni di tasti che consentono di modificare i file con estrema precisione e velocità. -`vi` è un editor di testo. Può essere utilizzato per modificare tutti i tipi di testo semplice. È particolarmente utile per i programmi di editing. +All'inizio la curva di apprendimento può essere ripida, ma una volta acquisita padronanza delle funzionalità di base, diventa uno strumento indispensabile per modificare file di configurazione, script e codice sorgente direttamente dal terminale. `vi` è un mostro enorme che può fare praticamente tutto, compreso prepararti il caffè o la cioccolata calda!! -Invece di cercare di insegnarvi `vi`, questo esercizio vi indicherà uno strumento che vi consentirà di familiarizzare meglio con `vi`. - -Vi invitiamo a dedicare un po' di tempo alla lettura del tutorial online su `vi` (più precisamente su `vim`). Basta seguire le istruzioni. +Invece di cercare di insegnarvi `vi`, questo esercizio vi indicherà uno strumento che vi consentirà di familiarizzare meglio con `vi`. Vi invitiamo a dedicare un po' di tempo alla lettura del tutorial online su `vi` (più precisamente su `vim`). Basta seguire le istruzioni. #### Per imparare `vi` @@ -768,15 +726,13 @@ Vi invitiamo a dedicare un po' di tempo alla lettura del tutorial online su `vi` [root@localhost root]# vimtutor -## Esercizio 14 - -### Ricerca di file: (`find` e `locate`) +### 14. Ricerca di file con `find` e `locate` Questo esercizio tratterà due delle utility più diffuse utilizzate per la ricerca di file e directory nel file system. Si tratta dei comandi `find` e `locate`. #### `find` -L'utilità `find` esiste da molto tempo. Esegue una scansione ricorsiva delle directory per trovare i file che corrispondono a un determinato criterio. +Il comando `find` consente di cercare file e directory all'interno del filesystem in base a una vasta gamma di criteri, quali nome, tipo, dimensione, data di modifica, autorizzazioni e molto altro ancora. La sua capacità di eseguire azioni sui risultati trovati, come eliminare, spostare o elaborare file, lo rende uno strumento indispensabile per gli amministratori di sistema e gli utenti avanzati. La sintassi generale per `find` è: @@ -784,61 +740,35 @@ La sintassi generale per `find` è: find [path] [options] [criterion] [action] ``` -Se non si specifica alcuna directory o percorso, find cercherà nella directory corrente. Se non si specifica alcun criterio, ciò equivale a "vero", quindi verranno trovati tutti i file. L'utilità `find` offre numerose opzioni per eseguire praticamente qualsiasi tipo di ricerca di un file. Di seguito sono elencate solo alcune delle opzioni, dei criteri e delle azioni disponibili. - -```bash -OPZIONI: - --xdev: non effettuare ricerche nelle directory situate su altri file system.; - --mindepth scendere di almeno livelli al di sotto della directory specificata prima della - -ricerca di file; - --maxdepth : cerca i file che si trovano al massimo a n livelli sotto la directory specificata; - --follow: segui i collegamenti simbolici se puntano a directory. - --daystart: quando si utilizzano test relativi al tempo (vedi sotto), prendere l'inizio del giorno corrente come timestamp invece del valore predefinito (24 ore prima dell'ora corrente). -``` - -```bash -CRITERIO - --type : cerca un determinato tipo di file; può essere uno dei seguenti: f (file regolare), d (directory), - -l (collegamento simbolico), s (socket), b (file in modalità blocco), c (file in modalità carattere) o - -p (pipe con nome); - --name : trova i file i cui nomi corrispondono al modello specificato ; - --iname : like -name, but ignore case; - --atime , -amin : trova i file a cui è stato effettuato l'ultimo accesso giorni fa (-atime) o minuti fa (-amin). È anche possibile specificare + o -, nel qual caso la ricerca verrà effettuata rispettivamente sui file a cui è stato effettuato l'accesso al massimo o al minimo giorni/minuti fa; - --anewer : trova i file che sono stati aperti più di recente rispetto al file ; - --ctime , -cmin , -cnewer : come per -atime, -amin e -anewer, ma si applica all'ultima volta in cui il contenuto del file è stato modificato; - --regex : come per -name, ma il pattern viene trattato come un'espressione regolare; - --iregex : come per -regex, ma ignora le maiuscole/minuscole. -``` - -```bash -AZIONE: - --print: stampa semplicemente il nome di ogni file sullo standard output. Questa è l'azione predefinita; - --ls: stampa sullo standard output l'equivalente di ls -ilds per ogni file trovato; - --exec : execute command su ogni file trovato. La riga di comando deve terminare con un ;, che deve essere preceduto dal carattere di escape in modo che la shell non lo interpreti; la posizione del file è contrassegnata da {}. - --ok : come per -exec, ma richiede una conferma per ogni comando. -``` - -#### Per utilizzare `find` +Se non si specifica alcuna directory o percorso, `find` cercherà nella directory corrente. Se non si specifica alcun criterio, ciò equivale a “*true*”, quindi verranno trovati tutti i file. L'utilità `find` offre numerose opzioni per eseguire praticamente qualsiasi tipo di ricerca di un file. Di seguito sono elencate solo alcune delle opzioni, dei criteri e delle azioni disponibili. + +| OPZIONI | DESCRIZIONE | +| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| -xdev | non effettua ricerche nelle directory situate su altri file system | +| -mindepth `` | scende di almeno `` livelli al di sotto della directory specificata prima di cercare i file | +| -maxdepth `` | cerca i file che si trovano al massimo a `` livelli sotto la directory specificata | +| -follow | segue i collegamenti simbolici se questi rimandano una directory | +| -daystart | quando si utilizzano test relativi al tempo (vedi sotto), prende come timestamp l'inizio del giorno corrente invece del valore predefinito (24 ore prima dell'ora corrente) | + +| CRITERIO | DESCRIZIONE | +| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| -type `` | cerca un determinato tipo di file; `` può essere uno dei seguenti: **f** (*file regolare*), **d** (*directory*) **l** (*collegamento simbolico*), **s** (*socket*), **b** (*file in modalità blocco*), **c** (*file in modalità carattere*) o **p** (*pipe con nome*) | +| -name `` | trova i file i cui nomi corrispondono a quelli specificati `` | +| -iname `` | come *-nome*, ma ignora le maiuscole e le minuscole | +| -atime ``, -amin `` | trova i file a cui è stato effettuato l'ultimo accesso `` giorni fa (*-atime*) o `` minuti fa (*-amin*). È anche possibile specificare `+` o `-`, nel qual caso la ricerca verrà effettuata rispettivamente sui file a cui si è avuto accesso *al massimo* o *al minimo* `` giorni/minuti fa. | +| -anewer `` | trova i file che sono stati aperti più recentemente rispetto al file `` | +| -ctime ``, -cmin ``, -cnewer `` | come per *-atime*, *-amin* e *-anewer*, ma si applica all'ultima volta in cui il contenuto del file è stato modificato | +| -regex `` | uguale a *-name*, ma il pattern viene trattato come un'espressione regolare | +| -iregex `` | uguale a *-regex*, ma ignora le maiuscole/minuscole | + +| AZIONE | DESCRIZIONE | +| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| -print | stampa semplicemente il nome di ciascun file sullo standard output. Questa è una azione di default | +| -ls | stampa sullo standard output l'equivalente di `ls -ilds` per ogni file trovato | +| -exec `` | esegue il comando `` su ogni file trovato. La riga di comando `` deve terminare con un `;`, che deve essere preceduto da un carattere di escape affinché la shell non lo interpreti; la posizione del file è contrassegnata con `{}`. | +| -ok `` | uguale a *-exec* ma richiede una conferma per ogni comando | + +#### Come usare `locate` 1. Assicurarsi di trovarsi nella directory home. @@ -849,33 +779,23 @@ AZIONE: ……….. - ./.bash_profile - ./.bashrc - ./.cshrc - ./.tcshrc - ./.viminfo - ./folder1 - ./folder1/first.txt - ………… ``` - Il risultato mostra il comportamento predefinito di find quando viene utilizzato senza alcuna opzione. - - Visualizza tutti i file e le directory (compresi i file nascosti) nella directory di lavoro in modo ricorsivo. + Il risultato mostra il comportamento predefinito di find quando viene utilizzato senza alcuna opzione. +Visualizza tutti i file e le directory (*compresi i file nascosti*) nella directory di lavoro in modo ricorsivo. -3. Ora utilizzare `find` per trovare solo le directory nella tua pwd. Digitare: +3. Ora utilizzate `find` per trovare solo le directory nella vostra *pwd*. Digitare: ```bash - [root@localhost root]# find -type d - . + [root@localhost root]# find -type d ./folder1 ./folder2 ……… @@ -899,51 +819,43 @@ AZIONE: Sempre dal comando sopra riportato, cosa sono l'"opzione", il "percorso", il "criterio" e infine l'"azione"? (SUGGERIMENTO: L'azione = “- print”) - La ricerca verrà eseguita solo su 3 directory in basso dalla directory “/”. - - L'asterisco utilizzato nel comando sopra riportato è uno dei caratteri "jolly" in Linux. - - L'uso dei caratteri jolly in Linux è chiamato "globbing". + La ricerca verrà eseguita solo su 3 directory di profondità dalla directory `/`. L'asterisco utilizzato nel comando sopra riportato è uno dei caratteri “*jolly*” presenti in Linux. +L'uso dei caratteri jolly in Linux è chiamato “*globbing*”. 5. Utilizzare il comando `find` per trovare tutti i file nella "pwd" che hanno una dimensione "inferiore" a 200 kilobyte. Digitare: ```bash - [root@localhost root]# find . –size -200k + [root@localhost root]# find . –size -200k ``` 6. Utilizzare il comando `find` per trovare tutti i file nella directory corrente che sono "più grandi" di 10 kilobyte e visualizzare anche il loro "tipo di file". Digitare: ```bash - [root@localhost root]# find . –size +10k –exec file "{ }" ";" + [root@localhost root]# find . –size +10k –exec file "{ }" ";" ``` #### `locate` -La sintassi del comando `find` può essere piuttosto difficile da usare in alcuni casi e, a causa della sua ricerca estesa, può essere lenta. Un comando alternativo è `locate`. - -`locate` effettua una ricerca in un database creato in precedenza contenente tutti i file presenti nel file system. - -Si basa sul programma `updatedb`. +Il comando `locate` consente di cercare file e directory all'interno del sistema. A differenza di altri comandi come `find`, che eseguono una ricerca in tempo reale, `locate` si basa su un database precompilato contenente i percorsi di tutti i file presenti nel sistema, garantendo risultati quasi istantanei. Questo database viene solitamente aggiornato periodicamente utilizzando il comando `updatedb`, gestito da un *cron job*. Grazie alla sua efficienza, `locate` è particolarmente utile per trovare rapidamente file o cartelle senza dover eseguire manualmente la scansione dell'intero file system. +Tuttavia, è importante ricordare che i risultati potrebbero non essere sempre aggiornati se il database non è stato sincronizzato di recente con lo stato attuale del sistema. -```bash -utilizzo della ricerca: - -locate [-qi] [-d ] [--database=] ... - -locate [-r ] [--regexp=] +| Utilizzo della ricerca: | +| --------------------------------------------------------------------------------------- | +| locate [-qi] [-d ``] [--database=``] ``... | +| locate [-r ``] [--regexp=``] | -database usage: locate [-qv] [-o ] [--output=] +| Uso del database: | +| --------------------------------------------------------------------------------------------------------------------------------- | +| locate [-qv] [-o ``] [--output=``] | +| locate [-e ``] [-f ``] [-l ``] [-c] [-U ``] [-u] [`pattern...`] | -locate [-e ] [-f ] [-l ] - -[-c] <[-U ] [-u]> - -general usage: locate [-Vh] [--version] [--help] -``` +| Uso generale: | +| ------------------------------------- | +| locate \[-Vh\] \[--version\] [--help] | -#### Per utilizzare `locate` +#### Come si usa `locate` -1. Passare alla directory folder1 e creare i file vuoti temp1, temp2 e temp3: +1. Passa alla directory `folder1` e crea i file vuoti *temp1*, *temp2* e *temp3*: ```bash [root@localhost root]# cd folder1; touch temp1 temp2 temp3 @@ -973,7 +885,7 @@ general usage: locate [-Vh] [--version] [--help] 4. Ora riprovare la ricerca. Digitare: ```bash - [root@localhost folder1]# locate temp + [root@localhost folder1]# locate temp ``` !!! question "Domanda" diff --git a/docs/release_notes/10_0.it.md b/docs/release_notes/10_0.it.md index bf1c47b79b..7c0756ad3b 100644 --- a/docs/release_notes/10_0.it.md +++ b/docs/release_notes/10_0.it.md @@ -1,5 +1,5 @@ --- -title: Versione corrente 10 +title: Release 10 tags: - 10 - 10.0 release diff --git a/docs/release_notes/10_1.de.md b/docs/release_notes/10_1.de.md new file mode 100644 index 0000000000..cb5ed678c4 --- /dev/null +++ b/docs/release_notes/10_1.de.md @@ -0,0 +1,224 @@ +--- +title: Aktuelle Version 10.1 +tags: + - 10.1 + - 10.1 release + - Rocky Linux 10.1 +--- + +!!! info "Einige Inhalte aus den Versionshinweisen zu 10.0 wurden absichtlich beibehalten." + + Da es sich hier um die erste kleinere Versionsnummer von 10 handelt und viele Benutzer mit einem Upgrade oder dem Wechsel auf eine neuere Version bis nach der ersten kleineren Versionsnummer warten, enthalten die Versionshinweise für 10.1 hier einige Inhalte aus der ursprünglichen 10-Version, die für diejenigen von Interesse sein könnten, die einen Wechsel auf 10.1 planen. + +## Rocky Linux 10.1 + +Rocky Linux 10.1 (RL 10.1) ist die neueste Nebenversion des Enterprise-Betriebssystems Rocky Linux. + +### Upgrade auf Rocky Linux 10.1 + +Um von Version 10.0 auf 10.1 zu aktualisieren, führen Sie einfach den Befehl `dnf -y upgrade` aus. + +Rocky Linux unterstützt keine Upgrades auf Hauptversionen. Um von Version 8.x oder 9.x auf Rocky Linux 10.x zu wechseln, führen Sie eine Neuinstallation des Betriebssystems durch und stellen Sie die Daten aus einer Sicherung wieder her. + +### Neue Funktionen und Änderungen + +In den folgenden Abschnitten werden ausgewählte Funktionen von RL 10.1 beschrieben. + +Wie bei allen Rocky Linux-Releases umfasst diese Versionsbeschreibung zahlreiche Verbesserungen, Änderungen und neue Funktionen. + +Die nachfolgende Übersicht hebt Änderungen in den folgenden Kategorien hervor: Architektur, Kernel, Installationsprogramm, Netzwerk, Sicherheit, Virtualisierung, Container, Speicher und Paketverwaltung. Hier werden die Funktionen ausgewählt, die für einen allgemeinen Anwenderkreis am ehesten relevant sind. + +Eine vollständige Liste der wichtigsten Änderungen finden Sie in der Upstream-Liste [hier](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/10/html/10.1_release_notes/overview#overview-major-changes). + +### Unterstützte Architekturen + +!!! warning "Bitte prüfen Sie die CPU-Kompatibilität" + + Auf der x86_64-Prozessorarchitektur unterstützt RL 10 keine Hardware der Mikroarchitekturebene x86-64-v2 und älter mehr. Die Mikroarchitekturebene x86-64-v3 dient als Basis für die Distribution. + + Weitere Informationen finden Sie im Abschnitt („Unterstützte Mikroarchitekturebenen“), insbesondere im Abschnitt zum Testen der CPU-Kompatibilität. + +!!! info "Einstellung der 32-Bit-Pakete" + + Rocky Linux 10 hat die 32-Bit-Kompatibilität für x86_64 entfernt. Verwenden Sie stattdessen 64-Bit-Bibliotheken oder Container mit 32-Bit-Abhängigkeiten. + +Rocky Linux 10.1 wird auf den folgenden Prozessorarchitekturen unterstützt: + +- 64-Bit AMD/Intel x86-64-v3 und höher (x86_64) +- 64-bit RISC-V (riscv64) +- 64-bit ARMv8.0-A (aarch64) +- IBM POWER10 und höher, little endian (ppc64le) +- IBM z15 und höher (s390x) + +#### Unterstützung für die RISC-V-Architektur + +Das Entwicklungsteam von Rocky Linux hat lange und hart daran gearbeitet, Rocky Linux 10 für bestimmte „RISC-V-Implementierungen“ bereitzustellen. +Zu den am Veröffentlichungstag unterstützten Plattformen/Subsystemen gehören - StarFive VisionFive 2 (VF2), **QEMU** und SiFive HiFive Premier P550. + +Weitere Details zu diesem Meilenstein, einschließlich der RISC-V-Unterstützung von RL10, finden Sie auf [dieser Seite](https://rockylinux.org/news/rockylinux-support-for-riscv). + +#### Unterstützte Mikroarchitekturebenen + +Die x86-64-v3-Mikroarchitektur basiert auf dem Funktionsumfang der Intel Haswell-Prozessorgeneration. Eine Handvoll Intel Atom-Prozessoren (wie zum Beispiel die Prozessoren der Gracemont-Familie) unterstützen x86-64-v3. Andere Prozessoren, darunter die Intel Atom Parker Ridge-Familie und der Intel Atom x6416RE Elkhart Lake-Familie, bieten hingegen keine x86-64-v3-Funktionen und werden daher in RL 10 nicht unterstützt. Wenn Sie Zweifel an der Kompatibilität Ihres Prozessors haben, [verwenden Sie dieses Verfahren](https://docs.rockylinux.org/gemstones/test_cpu_compat/), um dies zu überprüfen. + +Die Implementierung der x86-64-v3-Mikroarchitekturebene durch AMD, die als Grundlage für Rocky Linux 10 auf x86_64 dient, wurde mit der Excavator-Mikroarchitektur eingeführt. Dies bedeutet, dass Prozessoren, die älter sind als solche, die auf der Excavator-Architektur basieren, von Rocky Linux 10 möglicherweise nicht vollständig unterstützt werden. + +!!! note "Raspberry Pi Image-Unterschiede" + + Der Hauptunterschied zwischen den Rocky Linux Pi-Images für Version 10 besteht darin, dass RL10 Pi 4 und Pi 5 unterstützt, während RL9 Pi 3, Pi 4, Pi 5 und Pi Zero 2W unterstützt. + +### Installationsprogramm und Image-Erstellung + +Anaconda, die interaktive grafische Benutzeroberfläche für das Rocky Linux-Installationsprogramm, weist in Version 10 eine Reihe von Änderungen auf. + +Zu den wichtigsten Änderungen zählen: + +- Die standardmäßige Deaktivierung des Root-Kontos. Für die Systemverwaltung ist die Erstellung eines Administratorbenutzers mit vollen sudo-Berechtigungen erforderlich. Wenn Sie sich dafür entscheiden, das Root-Konto durch Festlegen eines Passworts zu aktivieren, können Sie Standardbenutzer ohne Administratorrechte erstellen. +- Das Remote Desktop Protocol (RDP) ersetzt VNC für den grafischen Fernzugriff während des Installationsprozesses. Diese Änderung betrifft die zugehörigen Kernel-Bootoptionen. + +!!! note "RDP und `xrdp`" + + Da X11 im Betriebssystem nicht mehr unterstützt wird, existieren keine Pakete mehr, die von X11 abhängen (z. B. `xrdp`). Anweisungen, die die Installation von `xrdp` oder `x11vnc` erfordern, funktionieren daher nicht mehr. + +- Die grafische Benutzeroberfläche unterstützt das Hinzufügen von Drittanbieter-Repositories während der Erstinstallation nicht mehr. Verwenden Sie stattdessen die Boot-Option `inst.addrepo` oder Kickstart. + +#### Image-Builder + +Image Builder kann jetzt WSL2- und Vagrant-Images (libvirt) erstellen. + +### Kernel + +Der standardmäßig out-of-box Kernel für RL 10.1 bleibt Version 6.12.0. + +Einige Kernel-Funktionen sind nun deaktiviert, da sie nicht mehr gewartet werden, unsicher sind oder als veraltet gelten. + +Das Kernel-Befehlszeilenargument `rh_waived` kann diese Funktionen bei Bedarf aktivieren. Der CFS-Scheduler wird durch Earliest Eligible Virtual Deadline First (EEVDF) ersetzt, bei dem latenzempfindliche Aufgaben mit kürzeren Zeitschlitzen priorisiert werden, um die Reaktionsfähigkeit zu verbessern. + +### Netzwerke + +Zu den Verbesserungen der Netzwerkfunktionen in RL 10 gehören Änderungen an der Netzwerkkonfiguration, der Aggregation von Netzwerkschnittstellen, DHCP-Clients und -Servern sowie Hinzufügungen und Entfernungen von Gerätetreibern. + +#### NetworkManager und Netzwerk-Scripte + +Die alten ifcfg-rh-Netzwerkskripte wurden in früheren Versionen von Rocky Linux (9.x) als veraltet markiert. Unter Rocky Linux 10 sind diese Skripte nicht mehr verfügbar. + +Sie müssen nun den NetworkManager verwenden. Zu diesen Tools gehören `nmcli`, `nmtui` und `nmstate`. Dies bedeutet, dass einige ältere Dateien und Befehle nicht mehr funktionieren und sich auch der Speicherort Ihrer Netzwerkkonfigurationsdateien geändert hat. + +- Dateien mit dem Präfix ifcfg- im Verzeichnis /etc/sysconfig/network-scripts/ werden nicht unterstützt. +- Die Befehle ifup und ifdown sind nicht mehr verfügbar. +- Ältere Netzwerk-Skripte wie ifup-local werden nicht mehr unterstützt. +- Netzwerkkonfigurationsdateien werden im Ordner /etc/NetworkManager/system-connections/ gespeichert. + +#### DHCP Client und Server + +Die Implementierung des DHCP-Clients in RL 10 erfolgt über ein internes Subsystem von NetworkManager. Das ältere dhcp-client-Paket wurde entfernt und wird vom Upstream-Projekt nicht mehr unterstützt. + +Kea DHCP ersetzt den veralteten ISC DHCP-Server in RL 10. + +#### Netzwerk-Bonding und Teaming + +In früheren Versionen von Rocky Linux wurde das NIC-Teaming-Feature obsolet. In RL 10 wurde dies nun vollständig entfernt. Konfigurieren Sie als Ersatz eine Bond-Verbindung anstelle eines Netzwerkteams. + +### Speicher + +In RL 10 wurden mehrere Speicher-bezogene Gerätetreiber hinzugefügt, aktualisiert oder entfernt. + +### Sicherheit-Features + +Mit RL 10 werden zahlreiche neue sicherheitsrelevante Funktionen eingeführt. + +Zu den Updates gehören unter anderem: + +- Systemweite kryptografische Richtlinien (Krypto-Richtlinien): PQC-Algorithmen sind jetzt standardmäßig in allen Richtlinien aktiviert. +- Sequoia PGP: Kann jetzt zum Signieren von RPMs verwendet werden. +- OpenSSH: Die Wiederherstellung strengerer SSH-Hostschlüsselberechtigungen. (Neue Berechtigungen = 0600 vs. alte Berechtigungen = 0640). +- yescrypt-Algorithmus: Der Passwort-Algorithmus für den Standardbenutzer wird geändert. + +### Virtualisierung + +Bei der Virtualisierung kommt es zu wichtigen Änderungen: + +- Der monolithische libvirtd-Daemon ist veraltet. Verwenden Sie als Ersatz die modularen Daemons und Sockets. Eine ausführliche Dokumentation zu den Unterschieden finden Sie in der [Upstream-Dokumentation](https://libvirt.org/daemons.html#monolithic-vs-modular-daemons) +- Der virtuelle Maschinentyp `i440fx` ist nun obsolet +- Virtual Machine Manager ist nun obsolet, Cockpit ist der vorgesehene Ersatz + +### Kontainer + +Podman 5 in RL 10 führt mehrere Verbesserungen ein, darunter die neue Standard-Container-Laufzeitumgebung `crun`, die `runc` ersetzt. Control Groups v2 ist jetzt die Standard-cgroup-Version. + +Zu den wichtigsten Updates gehören die Abschaffung des Netzwerkmodus slirp4netns, die Möglichkeit, Wiederholungsversuche und Verzögerungen für Push- und Pull-Vorgänge von Images zu konfigurieren, sowie umfassende Unterstützung für Container-Images mit mehreren Architekturen. + +Darüber hinaus unterstützt Podman 5 weiterhin Quadlets, eine in Podman 4.4 eingeführte Funktion, die die Verwaltung von Podman-Containern mit `systemd` unter Verwendung deklarativer Unit-Dateien ermöglicht. + +### Softwareverwaltung + +Die DNF-Module sind nun veraltet und werden in einer zukünftigen Hauptversion von Rocky Linux entfernt. + +### Desktop-Umgebung + +In RL 10 ersetzt Wayland den X.Org-Server. Xwayland wird die meisten X11-Clients unterstützen, die noch nicht auf Wayland portiert wurden. In RL 10 werden auch einige Desktop-Anwendungen und -Komponenten ersetzt. + +Weitere Informationen zu den Änderungen an Desktop-Anwendungen finden Sie in den [10.0 Versionshinweisen](https://docs.rockylinux.org/release_notes/10_0/). + +### Dynamische Programmiersprachen + +Folgende Aktualisierungen gängiger Programmiersprachen: + +- Node.js 24 + +### Web-Servers und Datenbank-Servers + +Für die folgenden Webserver stehen Updates auf eine neuere Version zur Verfügung: + +- Apache HTTP Server 2.4.63 + +### Compiler und Entwicklungstools + +#### System-Toolchain + +Rocky Linux 10.1 enthält die folgenden System-Toolchain-Komponenten: + +- GCC 14.3 +- glibc 2.39 +- Annobin 12.99 +- binutils 2.41 + +#### Compiler-Toolsets + +- GCC Toolset 15, einschließlich: + + - GCC 15.1 + - Binutils 2.44 + +- LLVM Toolset 20.1.8 + +- Rust Toolset 1.88.0 + +- Go Toolset 1.24 + +- .NET 10.0 + +- OpenJDK 25 + +#### Performance-Tools und Debugger + +- GDB 16.3 +- Valgrind 3.25.1 +- SystemTap 5.3 +- Dyninst 13.0.0 +- elfutils 0.193 +- libabigail 2.8 + +### RL Web-Konsole (Cockpit) + +Cockpit ist eine webbasierte Benutzeroberfläche zur Verwaltung und Überwachung Ihres lokalen Systems. + +Diese neue Version bietet einen verbesserten UI-Stil basierend auf PatternFly 6. + +## Bekannte Issues + +Das Rocky-Testteam meldete keine nennenswerten Probleme mit Version 10.1. Wie immer gibt es jedoch [bekannte Probleme, die hier im Upstream gemeldet wurden.](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/10/html/10.1_release_notes/known-issues) + +## Mitmachen und Fehler melden + +Bitte melden Sie alle Fehler, auf die Sie gestoßen sind, dem [Rocky Linux Bug Tracker](https://bugs.rockylinux.org/). Wir laden Sie herzlich ein, sich unserer Community auf jede gewünschte Weise anzuschließen, sei es in unseren [Foren](https://forums.rockylinux.org), [Mattermost](https://chat.rockylinux.org), [IRC auf Libera.Chat](irc://irc.liberachat/rockylinux), [Reddit](https://reddit.com/r/rockylinux), [Mailinglisten](https://lists.resf.org) oder auf jede andere Art und Weise, die Ihnen am Herzen liegt! diff --git a/docs/release_notes/10_1.it.md b/docs/release_notes/10_1.it.md new file mode 100644 index 0000000000..f75d63feb5 --- /dev/null +++ b/docs/release_notes/10_1.it.md @@ -0,0 +1,225 @@ +--- +title: Versione Corrente 10.1 +tags: + - 10.1 + - 10.1 release + - Rocky Linux 10.1 +--- + +!!! info "Alcuni contenuti delle note di rilascio della versione 10.0 sono stati volutamente conservati." + + Poiché questa è la prima versione minore della 10 e poiché molte persone aspettano di aggiornare o passare a una versione più recente fino a dopo la prima versione minore, le note di rilascio della 10.1 qui riportate includono alcuni dei contenuti della versione originale 10 che potrebbero essere di interesse per coloro che intendono passare alla 10.1. + +## Rocky Linux 10.1 + +Rocky Linux 10.1 (RL 10.1) è l'ultima versione minore del sistema operativo Rocky Linux Enterprise. + +### Aggiornare a Rocky Linux 10.1 + +Per eseguire l'aggiornamento dalla versione 10.0 alla 10.1, è sufficiente eseguire il comando `dnf -y upgrade`. + +Rocky Linux non supporta gli aggiornamenti tra versioni principali. Per passare dalla versione 8.x o 9.x a Rocky Linux 10.x, eseguire una nuova installazione del sistema operativo e ripristinare i dati da un backup. + +### Nuove funzionalità e modifiche + +Le sezioni seguenti descrivono alcune caratteristiche di RL 10.1. + +Come per tutte le versioni di Rocky Linux, questa nota di rilascio descrive numerosi miglioramenti, modifiche e nuove funzionalità. + +La panoramica che segue evidenzia le modifiche apportate alle seguenti categorie: architettura, kernel, programma di installazione, rete, sicurezza, virtualizzazione, container, archiviazione e gestione dei pacchetti. Qui sono state selezionate le caratteristiche che potrebbero essere più rilevanti per un pubblico generico. + +Per un elenco completo delle modifiche principali, consultare l'elenco upstream [qui](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/10/html/10.1_release_notes/overview#overview-major-changes). + +### Architetture supportate + +!!! warning "Verificare la compatibilità della CPU" + + In merito all'architettura x86_64 della CPU, RL 10 non supporta più l'hardware a livello di microarchitettura x86-64-v2 e precedenti, e rende la microarchitettura x86-64-v3 il punto di riferimento per la distribuzione. + Per ulteriori informazioni, consultare la sezione [Livelli di microarchitettura supportati](#supported-microarchitecture-levels), in particolare la sezione relativa al test di compatibilità della CPU. + +!!! info "Interruzione della distribuzione con package a 32 bit" + + Rocky Linux 10 ha rimosso la compatibilità a 32 bit per x86_64. Utilizzare invece librerie a 64 bit o container con dipendenze a 32 bit. + +Rocky Linux 10.1 è supportato sulle seguenti architetture di processori: + +- 64-bit AMD/Intel x86-64-v3 e successive (x86_64) +- 64-bit RISC-V (riscv64) +- 64-bit ARMv8.0-A (aarch64) +- IBM POWER10 and later, little endian (ppc64le) +- IBM z15 and later (s390x) + +#### Supporto dell'architettura RISC-V + +Il team di ingegneri di Rocky Linux ha lavorato a lungo e duramente per portare Rocky Linux 10 su alcune “implementazioni RISC-V”. +Le piattaforme/sottosistemi supportati al momento del rilascio includono: StarFive VisionFive 2 (VF2), **QEMU** e SiFive HiFive Premier P550. + +Per ulteriori dettagli su questo risultato, incluso il supporto RISC-V di RL10, visitare [questo sito](https://rockylinux.org/news/rockylinux-support-for-riscv). + +#### Livelli di Microarchitettura supportati + +La microarchitettura x86-64-v3 si basa sul set di funzionalità della generazione di processori Intel Haswell. Una manciata di processori Intel Atom (come quelli della famiglia Gracemont) supportano x86-64-v3. Al contrario, altri processori, tra cui quelli della famiglia Intel Atom Parker Ridge e il processore Intel Atom x6416RE della famiglia Elkhart Lake, non offrono le funzionalità x86-64-v3 e pertanto non sono supportati in RL 10. Se si avesse dubbi sulla compatibilità del vostro processore, [seguire questa procedura](https://docs.rockylinux.org/gemstones/test_cpu_compat/) per verificarla. + +L'implementazione da parte di AMD del livello di microarchitettura x86-64-v3, che funge da base per Rocky Linux 10 su x86_64, è stata introdotta con la microarchitettura Excavator. Ciò significa che i processori più vecchi di quelli basati sull'architettura Excavator potrebbero non essere completamente supportati da Rocky Linux 10. + +!!! Note Nota “Differenze nell'immagine Raspberry Pi” + + ``` + La differenza principale tra le immagini Rocky Linux Pi per la versione 10 è che la versione 10 supporta Pi 4 e Pi 5, mentre la versione 9 supporta Pi 3, Pi 4, Pi 5 e Pi Zero 2W. + ``` + +### Installatore e creazione di immagini + +Anaconda, l'interfaccia grafica interattiva per il programma di installazione di Rocky Linux, presenta una serie di modifiche nella versione 10. + +Le modifiche principali includono: + +- La disabilitazione, per impostazione predefinita, dell'account root. La gestione del sistema richiede la creazione di un utente amministrativo con privilegi sudo completi. Se si sceglie di abilitare l'account root impostandone la password, è possibile creare utenti standard senza privilegi amministrativi. +- Il protocollo RDP (Remote Desktop Protocol) sostituisce VNC per l'accesso remoto grafico durante il processo di installazione. Questa modifica influisce sulle relative opzioni di avvio del kernel. + +!!! note "RDP e `xrdp`" + + Poiché X11 non è più supportato nel sistema operativo, i pacchetti che dipendono da X11 non esistono più (ad esempio `xrdp`). Le istruzioni che richiedono l'installazione di `xrdp` o `x11vnc` semplicemente non funzioneranno così come sono. + +- L'interfaccia grafica non supporta più l'aggiunta di repository di terze parti durante l'installazione iniziale. Utilizza invece l'opzione di avvio `inst.addrepo` o Kickstart. + +#### Image Builder + +Image Builder è ora in grado di creare immagini WSL2 e Vagrant (libvirt). + +### Kernel + +Il kernel predefinito per RL 10.1 rimane 6.12.0. + +Alcune funzionalità del kernel sono ora disabilitate perché non più supportate, non sicure o obsolete. + +L'argomento della riga di comando del kernel `rh_waived` può abilitare queste funzionalità, se necessario. Il Earliest Eligible Virtual Deadline First (EEVDF), che dà la priorità alle attività sensibili alla latenza con intervalli di tempo più brevi per migliorare la reattività, sostituisce lo scheduler CFS. + +### Networking + +I miglioramenti alle funzionalità di rete in RL 10 includono modifiche alla configurazione di rete, all'aggregazione delle interfacce di rete, ai client e server DHCP, nonché aggiunte e rimozioni ai driver dei dispositivi. + +#### NetworkManager e Network Scripts + +La rimozione dei vecchi script di rete ifcfg-rh è avvenuta nelle versioni precedenti di Rocky Linux (9.x). Con Rocky Linux 10, questi script non sono più disponibili. + +Ora si deve usare NetworkManager. Questi strumenti includono `nmcli`, `nmtui` e `nmstate`. Ciò significa che alcuni file e comandi meno recenti non funzioneranno più e che anche la posizione in cui sono conservati i file di configurazione di rete è cambiata. + +- I file con il prefisso ifcfg- nella directory /etc/sysconfig/network-scripts/ non sono supportati. +- I comandi ifup e ifdown non sono più disponibili. +- Gli script di rete legacy, come ifup-local, non sono più supportati. +- I file di configurazione di rete sono memorizzati nella cartella /etc/NetworkManager/system-connections/. + +#### DHCP Client e Server + +L'implementazione del client DHCP in RL 10 avviene tramite un sottosistema interno di NetworkManager. Il pacchetto legacy dhcp-client è stato rimosso e non è più supportato a monte. + +Kea DHCP sostituisce il server ISC DHCP giunto al termine del ciclo di vita in RL 10. + +#### Network Bonding e Teaming + +Le versioni precedenti di Rocky Linux hanno eliminato la funzionalità di teaming NIC. In RL 10, questa funzione è stata completamente rimossa. Come sostituto, configurare un bond invece di un network team. + +### Storage + +Diversi driver di periferica relativi allo storage sono stati aggiunti, aggiornati o rimossi da RL 10. + +### Funzionalità per la sicurezza + +Con RL 10 vengono introdotte numerose nuove funzionalità relative alla sicurezza. + +Alcuni degli aggiornamenti includono: + +- Politiche crittografiche a livello di sistema (crypto-policies): gli algoritmi PQC sono ora abilitati di default in tutte le politiche. +- Sequoia PGP: ora può essere utilizzato per firmare gli RPM. +- OpenSSH: ripristino di permessi più rigorosi per le chiavi host SSH. (Nuove autorizzazioni = 0600 rispetto alle vecchie autorizzazioni = 0640). +- Algoritmo yescrypt: l'algoritmo della password per l'utente predefinito è stato modificato. + +### Virtualizzazione + +La virtualizzazione ha subito cambiamenti fondamentali: + +- Il deamon monolitico libvirtd è stato abbandonato. Si utilizzano dei deamon modulari e i socket come sostituti. Per ulteriori dettagli sulle differenze, consultare la documentazione dettagliata nella [documentazione upstream](https://libvirt.org/daemons.html#monolithic-vs-modular-daemons). +- Rimozione della tipologia i440fx di macchina virtuale +- Deprecazione di Virtual Machine Manager, Cockpit è il sostituto previsto + +### Container + +Podman 5 in RL 10 introduce diversi miglioramenti, tra cui il nuovo runtime predefinito per i container, `crun`, che sostituisce `runc`. Control Groups v2 è ora la versione predefinita di cgroup. + +Gli aggiornamenti principali includono la dismissione della modalità di rete slirp4netns, la possibilità di configurare i tentativi di riprova e i ritardi per le operazioni di push e pull delle immagini e il supporto completo per le immagini dei container multi-architettura. + +Inoltre, Podman 5 continua a supportare Quadlets, una funzionalità introdotta in Podman 4.4 che consente di gestire i container Podman con `systemd` utilizzando file unit dichiarativi. + +### Software Management + +La modularità DNF è abbandonata e verrà rimossa in una futura versione principale di Rocky Linux. + +### Ambiente Desktop + +In RL 10, Wayland sostituisce il server X.Org. Xwayland supporterà la maggior parte dei client X11 che non sono ancora stati portati su Wayland. Anche alcune applicazioni desktop e alcuni componenti sono stati sostituiti in RL 10. + +Per ulteriori informazioni sulle modifiche apportate all'applicazione Desktop, consultare le [note di rilascio della versione 10.0](https://docs.rockylinux.org/release_notes/10_0/) + +### Linguaggi di programmazione dinamica + +A seguire gli aggiornamenti ai linguaggi di programmazione più diffusi: + +- Node.js 24 + +### Web e Database Servers + +Sono disponibili gli aggiornamenti per i seguenti server web alla versione più recente: + +- Apache HTTP Server 2.4.63 + +### Compilatori e strumenti di sviluppo + +#### Toolchain di sistema + +Rocky Linux 10.1 include i seguenti componenti di toolchain di sistema: + +- GCC 14.3 +- glibc 2.39 +- Annobin 12.99 +- binutils 2.41 + +#### Toolset del compilatore + +- Toolset GCC 15, che include: + + - GCC 15.1 + - Binutils 2.44 + +- LLVM Toolset 20.1.8 + +- Rust Toolset 1.88.0 + +- Go Toolset 1.24 + +- .NET 10.0 + +- OpenJDK 25 + +#### Tools di performance e debugger + +- GDB 16.3 +- Valgrind 3.25.1 +- SystemTap 5.3 +- Dyninst 13.0.0 +- elfutils 0.193 +- libabigail 2.8 + +### RL Web Console (Cockpit) + +Cockpit è un'interfaccia web per la gestione e il monitoraggio del sistema locale. + +Questa nuova versione presenta uno stile dell'interfaccia utente migliorato basato su PatternFly 6. + +## Problemi noti + +Il team di test Rocky non ha segnalato problemi significativi con la versione 10.1. Come sempre, però, ci sono [problemi noti segnalati nell'upstream qui.](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/10/html/10.1_release_notes/known-issues) + +## Partecipazione e segnalazione di bug + +Si prega di segnalare eventuali bug riscontrati al [Rocky Linux Bug Tracker](https://bugs.rockylinux.org/). Vi invitiamo inoltre a unirvi alla nostra community nel modo che preferite, sia sui nostri [forum](https://forums.rockylinux.org), [Mattermost](https://chat.rockylinux.org), [IRC su Libera.Chat](irc://irc.liberachat/rockylinux), [Reddit](https://reddit.com/r/rockylinux), [Mailing List](https://lists.resf.org) o in qualsiasi altro modo desideriate partecipare! diff --git a/docs/release_notes/8_10.it.md b/docs/release_notes/8_10.it.md index 2ab286a5ea..5d5aea8b3c 100644 --- a/docs/release_notes/8_10.it.md +++ b/docs/release_notes/8_10.it.md @@ -1,5 +1,5 @@ --- -title: Versione corrente 8.10 +title: Release corrente 8.10 tags: - "8.10" - 8.10 release diff --git a/docs/release_notes/8_5.it.md b/docs/release_notes/8_5.it.md index 3ac96f6eb9..29f1c5af3c 100644 --- a/docs/release_notes/8_5.it.md +++ b/docs/release_notes/8_5.it.md @@ -1,5 +1,5 @@ --- -title: Rilascio 8.5 +title: Release 8.5 --- # Note di rilascio per Rocky Linux 8.5 diff --git a/docs/release_notes/8_7.it.md b/docs/release_notes/8_7.it.md index 86e009ef25..77ac0d2791 100644 --- a/docs/release_notes/8_7.it.md +++ b/docs/release_notes/8_7.it.md @@ -1,5 +1,5 @@ --- -title: Rilascio 8.7 +title: Release 8.7 tags: - 8.7 - 8.7 release diff --git a/docs/release_notes/8_9.it.md b/docs/release_notes/8_9.it.md index 5a299f5943..a5b7d6e65d 100644 --- a/docs/release_notes/8_9.it.md +++ b/docs/release_notes/8_9.it.md @@ -1,5 +1,5 @@ --- -title: Rilascio 8.9 +title: Release 8.9 tags: - 8.9 - 8.9 release diff --git a/docs/release_notes/9_0.it.md b/docs/release_notes/9_0.it.md index dc63919c42..f5374a4d58 100644 --- a/docs/release_notes/9_0.it.md +++ b/docs/release_notes/9_0.it.md @@ -1,5 +1,5 @@ --- -title: Rilascio 9.0 +title: Release 9.0 tags: - 9.0 - 9.0 release diff --git a/docs/release_notes/9_1.it.md b/docs/release_notes/9_1.it.md index 90eda7549f..79539b8609 100644 --- a/docs/release_notes/9_1.it.md +++ b/docs/release_notes/9_1.it.md @@ -1,5 +1,5 @@ --- -title: Rilascio 9.1 +title: Release 9.1 tags: - 9.1 - 9.1 release diff --git a/docs/release_notes/9_4.it.md b/docs/release_notes/9_4.it.md index 080439a3ea..25e5393056 100644 --- a/docs/release_notes/9_4.it.md +++ b/docs/release_notes/9_4.it.md @@ -1,5 +1,5 @@ --- -title: Versione attuale 9.4 +title: Release 9.4 tags: - 9.4 - 9.4 release diff --git a/docs/release_notes/9_5.it.md b/docs/release_notes/9_5.it.md index 6aa5c74c51..335a837013 100644 --- a/docs/release_notes/9_5.it.md +++ b/docs/release_notes/9_5.it.md @@ -1,5 +1,5 @@ --- -title: Versione 9.5 +title: Release 9.5 tags: - 9.5 - 9.5 release diff --git a/docs/release_notes/9_6.it.md b/docs/release_notes/9_6.it.md index b991afb27e..533bdfac8d 100644 --- a/docs/release_notes/9_6.it.md +++ b/docs/release_notes/9_6.it.md @@ -1,5 +1,5 @@ --- -title: Versione attuale 9.6 +title: Release corrente 9.6 tags: - 9.6 - 9.6 release diff --git a/docs/release_notes/index.it.md b/docs/release_notes/index.it.md index cd7506ee09..d51ff3b1df 100644 --- a/docs/release_notes/index.it.md +++ b/docs/release_notes/index.it.md @@ -1,5 +1,5 @@ --- -title: Note Di Rilascio Rocky +title: Note delle Release di Rocky tags: - release - release notes