diff --git a/docs/books/admin_guide/05-vi.it.md b/docs/books/admin_guide/05-vi.it.md index b31f8ce7eb..f9d6ad7051 100644 --- a/docs/books/admin_guide/05-vi.it.md +++ b/docs/books/admin_guide/05-vi.it.md @@ -84,6 +84,8 @@ Per uscire da VI, dalla modalità Comando, premi : quindi digita: Per forzare l'uscita senza conferma, devi aggiungere *!* ai precedenti comandi. +Per forzare l'uscita senza conferma, devi aggiungere *!* ai precedenti comandi. + !!! Warning "Attenzione" Non c'è alcun backup periodico, quindi è necessario ricordarsi di salvare il lavoro regolarmente. @@ -96,7 +98,7 @@ In VI, ci sono 3 modalità di lavoro: * La modalità *inserimento*; * La modalità *ex*. -La filosofia di VI è quella di alternare tra la modalità *commando* e la modalità *inserimento*. +La filosofia di VI è quella di alternare tra la modalità *comando* e la modalità *inserimento*. La terza modalità, *ex*, è una modalità di comando del piè di pagina modello vecchio editor di testo. @@ -104,7 +106,7 @@ La terza modalità, *ex*, è una modalità di comando del piè di pagina modello Questa è la modalità predefinita quando si avvia VI. Per accedervi da una qualsiasi delle altre modalità, basta premere il tasto ESC. -Tutte le voci sono interpretate come comandi e le azioni corrispondenti sono eseguite. Questi sono essenzialmente comandi per la modifica del testo (copia, incolla, annulla, ...). +In questo momento, tutta la digitazione della tastiera viene interpretata come comandi e le azioni corrispondenti vengono eseguite. Questi sono essenzialmente comandi per la modifica del testo (copia, incolla, annulla, ...). I comandi non vengono visualizzati sullo schermo. @@ -142,11 +144,11 @@ Il cursore è posizionato sotto il carattere desiderato. * Sposta uno o `n` caratteri su: -↑, n↑, k or nk +↑, n↑, k o nk * Sposta uno o `n` caratteri giù: -↓, n↓, j or nj +↓, n↓, j o nj * Passare alla fine della linea: @@ -198,7 +200,7 @@ Se la linea è finita, VI va automaticamente alla riga successiva. In modalità *comando*, ci sono diversi modi per inserire il testo. -VI passa alla modalità *inserimento* dopo l'inserimento di uno di questi chiavi. +VI passa alla modalità *inserimento* dopo l'inserimento di una di queste chiavi. !!! Note "Nota" @@ -256,15 +258,15 @@ Queste operazioni sono fatte in modalità *comando*. * Elimina uno o `n` caratteri: -x or nx +x o nx * Sostituisce un carattere con un altro: -rcarattere +rcharacter * Sostituisce più di un carattere con altri: -RcaratteriESC +RcharactersESC !!! Note "Nota" @@ -305,11 +307,11 @@ Queste operazioni sono fatte in modalità *comando*. * Copia una o `n` linee: -yy o nyy +p o np * Incolla ciò che è stato copiato o cancellato una volta o `n` volte dopo la linea corrente: -p o np +P o nP * Incolla ciò che è stato copiato o cancellato una volta o `n` volte prima della linea corrente: @@ -473,7 +475,7 @@ Sfoglia un intero file per sostituire la stringa cercata con la stringa specific * Esci dal file e salva: -`:wq` or `:x` +`:wq` o `:x` ## Altre funzioni @@ -483,7 +485,7 @@ Sfoglia un intero file per sostituire la stringa cercata con la stringa specific $ vi -c "set nu" /home/rockstar/file ``` -È anche possibile inserire ilcomando *Ex* in un file chiamato `.exrc` inserito nella directory di accesso dell'utente. Ad ogni avvio di VI o VIM, i comandi saranno letti e applicati. +È anche possibile inserire il comando *Ex* in un file chiamato `.exrc` inserito nella directory di accesso dell'utente. Ad ogni avvio di VI o VIM, i comandi saranno letti e applicati. ### comando `vimtutor` diff --git a/docs/guides/installation.it.md b/docs/guides/8.6_installation.it.md similarity index 99% rename from docs/guides/installation.it.md rename to docs/guides/8.6_installation.it.md index ab2f2ab837..daa2abdf99 100644 --- a/docs/guides/installation.it.md +++ b/docs/guides/8.6_installation.it.md @@ -151,7 +151,7 @@ La sezione Sistema della schermata _Riepilogo Installazione_ viene utilizzata pe #### Destinazione Installazione -Dalla schermata _Riepilogo Installazione_, clicca sull'opzione Destinazione Installazione. Questo ti porta all'area di attività corrispondente. +Dalla schermata _Riepilogo Installazione_, clicca sull'opzione Destinazione Installazione. Questo ti porta alla corrispondente area di attività. Verrà visualizzata una schermata che mostra tutte le unità disco candidate disponibili sul sistema di destinazione. Se avete un solo disco sul sistema, come sul nostro sistema di esempio, vedrai l'unità elencata sotto _Dischi locali standard_ con un segno di spunta accanto ad essa. Facendo clic sull'icona del disco si attiverà o disattiverà il segno di spunta per la selezione del disco. Vogliamo che sia selezionato/spuntato qui. diff --git a/docs/guides/8.6_installation.zh.md b/docs/guides/8.6_installation.zh.md new file mode 100644 index 0000000000..539de6309e --- /dev/null +++ b/docs/guides/8.6_installation.zh.md @@ -0,0 +1,266 @@ +--- +Title: 安装 Rocky Linux +author: wale soyinka +contributors: tianci li, Steven Spencer +updated: 11-23-2021 +--- + +# 安装 Rocky Linux + +本指南介绍了在独立系统上安装 64 位 Rocky Linux 发行版的详细步骤。 我们将使用从Rocky Linux项目网站下载的ISO镜像文件执行服务器类安装。 我们将在以下部分逐步完成安装和自定义步骤。 + + +## 操作系统安装前提 + +首先，您需要下载ISO镜像文件以用于安装Rocky Linux。 + +用于此安装的Rocky Linux版本的最新ISO镜像可从以下位置下载： + +``` +https://www.rockylinux.org/download/ +``` + +要直接从命令行下载 ISO，请使用 `wget` 命令： + +``` +wget https://download.rockylinux.org/pub/rocky/8.5/isos/x86_64/Rocky-8.5-x86_64-minimal.iso +``` + +Rocky Linux ISO 的命名遵循以下约定： + +``` +Rocky-<主版本号#>.<次版本号#>-<架构>-<变体>.iso +``` + +例如 `Rocky-8.5-x86_64-minimal.iso` + +!!! Note "说明" + + Rocky Linux项目网页列出了世界各地的几个镜像网站。 只要有可能，您应该选择地理位置上离您最近的镜像。 官方镜像列表可在 [这里](https://mirrors.rockylinux.org/mirrormanager/mirrors) 找到。 + +## 验证安装的 ISO 文件 + +如果您已经在现有的 GNU/Linux 发行版上下载了 Rocky Linux ISO，那么可以使用 sha256sum 程序验证下载的文件没有损坏。 接下来通过一个示例，演示如何验证 `Rocky-8.5-x86_64-minimal.iso`。 + +首先下载包含可用于 ISO 的官方校验和的文件。 在包含已下载的Rocky Linux ISO的文件夹中下载ISO的校验和文件时，键入： + +``` +wget https://download.rockylinux.org/pub/rocky/8.5/isos/x86_64/CHECKSUM +``` + +使用 `sha256sum` 工具来验证ISO文件的完整性，防止损坏或者被篡改。 + +``` +sha256sum -c CHECKSUM --ignore-missing +``` + +这将检查先前下载的ISO文件的完整性，前提是该文件位于同一目录中。 输出应显示： + +``` +Rocky-8.5-x86_64-minimal.iso: OK +``` + +## 安装 + +!!! tip "提示" + + 在开始正确安装之前，系统的统一可扩展固件接口（UEFI）或基本输入/输出系统（BIOS）应配置为从正确的介质引导。 + +如果将计算机设置为从包含ISO文件的介质启动，则可以开始安装过程。 + +插入并从安装介质（光盘、USB闪存驱动器等）引导。 + +启动后，您将看到Rocky Linux的初始安装界面。 + +![Rocky Linux installation splash screen](images/installation_8.5_F01.png) + +如果您不按任何键，提示将开始倒计时，之后安装过程将自动执行默认的突出显示选项： + +`Test this media & install Rocky Linux 8` + +您还可以随时按 Enter 键立即启动该过程。 + +将执行快速介质验证步骤。 此介质验证步骤，可以避免您在中途安装发现安装程序因安装介质损坏导致中止安装的情况出现。 + +介质检查运行完成，并且介质被成功验证为可用后，安装程序将自动跳到下一个界面。 + +在界面中选择要用于执行安装的语言。 在本指南中，我们选择_English (United States)_。 然后单击Continue按钮。 + +## 安装信息摘要 + +_Installation Summary_ 是一个集合多种设置的区域，您可以在其中对要安装的操作系统做出重要决定。 + +界面大致分为以下几部分： + +- _Localization_：(键盘、语言支持以及时间和日期) +- _Software_：(安装源和软件选择) +- _System_：(安装目的地以及网络和主机名) + +接下来将深入研究其中的每一个部分，并在必要时进行更改。 + +### Localization部分 + +此部分用于自定义与系统区域设置相关的项目。 包括 — 键盘、语言支持、时间和日期。 + +#### Keyboard + +在本指南的演示系统上，我们选择默认值 (_English US_) ，不做其他更改。 + +但是，如果需要在此处进行任何更改，请从 _Installation Summary_ 界面中单击 Keyboard 选项指定系统的键盘布局。 如果需要，可以在后续界面中添加其他键盘布局并指定其顺序。 + +完成后，单击 Done 。 + +#### Language Support + +Language Support选项，可以指定对其他语言的支持。 + +此处接受默认值 (__English – United States__) ，不做任何更改。 单击 Done 。 + +#### Time & Date + +点击 Time & Date ，调出另一个界面，您可以通过该界面选择机器所在的时区。 滚动区域和城市列表，选择离您最近的区域。 + +根据您的安装源，默认情况下可以将 _Network Time_ 选项设置为 _ON_ 或 _OFF_。 接受默认 _ON_ 设置；这允许系统使用网络时间协议 (NTP) 自动设置正确的时间。 进行任何更改后，请单击Done。 + +### Software部分 + +在 _Installation Summary_ 界面的 _Software_ 部分，您可以选择安装源以及要安装的其他软件包(应用程序)。 + +#### Installation Source + +由于我们使用完整的 Rocky 8 镜像进行安装，您会注意到，_安装源_ 部分下会自动指定本地介质。 我们将接受预设的默认设置。 + +!!! Tip "提示" + + 安装源区域是您可以选择执行基于网络安装的区域。 对于基于网络的安装，首先需要确保目标系统上的网络适配器配置正确，并且能够访问internet。 要执行基于网络的安装，请单击`Installation Source`，然后选择`On the network`单选按钮。 选择后，选择`https`作为协议，并在文本字段中键入以下URL `download.rockylinux.org/pub/rocky/8/BaseOS/x86_64/os`， 单击`Done`。 + +#### Software部分 + +单击Software Selection选项，将显示安装部分，从中您可以选择系统上要确定安装的软件包。 软件选择区域被划分为： + +- _Base Environment_ : 服务器、最小安装、自定义操作系统 +- _Additional software for Selected Environment area_ : 在左边选择一个基本环境，在右边呈现出可以为给定环境安装的各种相关附加软件。 + +我们这里选择 _最小安装_(基本功能)。 + +单击界面顶部的Done。 + +### System部分 + +_Installation Summary_界面用于自定义和更改目标系统的底层硬件。 在此处可以创建硬盘分区或LVM、指定要使用的文件系统，以及指定网络配置。 + +#### 安装目的地 + +在 _Installation Summary_ 界面上，点击 Installation Destination 选项。 这会将您带到相应的任务区域。 + +您将看到一个界面，显示目标系统上可用的所有候选磁盘驱动器。 如果系统上只有一个磁盘驱动器，如示例所示，您将看到在 _Local Standard Disks_ 下列出的驱动器，在它旁边有一个复选标记。 单击磁盘图标将打开或关闭磁盘选择复选标记。 我们在这里选择/勾选它。 + +在 _Storage Configuration_ 选项部分下，选择Automatic单选按钮。 + +然后单击界面顶部的 Done 。 + +安装程序确定有可用的磁盘后，将返回到 _Installation Summary_ 界面。 + +### Network & Hostname + +安装过程的最后一项任务是网络配置，您可以在其中配置或调整系统的网络相关设置。 + +!!! Note "说明" + + 单击 Network & Hostname 选项后，所有正确检测到的网络接口硬件(如以太网、无线网卡等)都将列在网络配置界面的左窗格中。 Linux 中以太网设备的名称类似于`eth0`、`eth1`、`ens3`、`ens4`、`em1`、`em2`、`p1p1`、`enp0s3`等，具体取决于 Linux 发行版和特定的硬件设置。 + +对于每个接口，您可以使用 DHCP 或手动配置 IP 地址。 如果您选择手动配置，请确保已准备好所有相关信息，如 IP 地址、子网掩码等。 + +单击 _Installation Summary_下的 Network & Hostname 按钮，将打开相应的配置界面。 此外，您还可以选择配置系统的主机名（默认为 `localhost.localdomain` ）。 + +!!! Note "说明" + + 在安装操作系统之后，您可以很容易地更改此名称。 现在此处主机名为默认值。 + +下一个重要的配置任务与系统上的网络接口相关。 首先，验证左窗格中是否列出了以太网卡（或任何网卡）。 单击左窗格中检测到的任何网络设备，将其选中， 所选网络适配器的可配置属性将出现在界面的右窗格中。 + +!!! Note "说明" + + 在我们的示例系统中，我们有两个以太网设备（`ens3`和`ens4`），它们都处于连接状态。 您系统上的网络设备的类型、名称、数量和状态可能与示例系统上的不同。 + +确保要配置设备的开关在右窗格中处于 `ON` 位置。 我们将接受这一部分的所有默认值。 + +单击Done返回 _Installation Summary_ 主界面。 + +!!! warning "警告" + + 注意此安装程序此部分服务器的 IP 地址。 如果您无法对系统进行物理或轻松的控制台访问，当您需要连接到服务器以继续使用它时，这些信息将在以后派上用场。 + +## 安装阶段 + +一旦您对各种安装任务的选择感到满意，安装过程的下一阶段将开始正确的安装。 + +### User Settings部分 + +此部分可用于为 `root` 用户帐户创建密码，也可用于创建新的管理员或非管理员帐户。 + +### 设置root密码 + +单击 _User Settings_ 下面的_Root Password_ ，启动_Root Password_任务界面。 在 _Root Password_ 文本框中，为 root 用户设置了一个强大的密码。 + +!!! warning "警告" + + root超级用户是系统中具有最高特权的帐户。 因此，如果您选择使用或启用它，使用强密码保护此帐户就显得非常重要。 + +在 _Confirm_ 文本框中再次输入相同的密码。 + +单击Done。 + + +### 创建用户账户 + +接下来点击 _User Settings_ 下面的 _User Creation_ ，以启动 _Create User_任务界面。 此界面允许您在系统上创建特权或非特权（非管理）用户帐户。 + +!!! info "信息" + + !!! Info "资料" + 在系统上创建和使用非特权帐户执行日常任务是一种很好的系统管理习惯。 + +我们将创建一个常规的普通用户，在需要时可以调用超级用户（管理员）权限。 + +用以下信息填写 _Create User_ 屏幕中的字段，然后单击Done： + +_Full name_: `rockstar` + +_Username_: `rockstar` + +_Make this user administrator_: 选中 + +_Require a password to use this account_: 选中 + +_Password_: `04302021` + +_Confirm password_: `04302021` + +### 开始安装 + +一旦您对各种安装任务的选择感到满意，请单击主界面_Installation Summary_上的"开始安装"按钮。 安装将开始，安装程序将显示安装进度。 安装开始时，各种任务将开始在后台运行，例如对磁盘进行分区、格式化分区或LVM卷、检查并解决软件依赖关系、将操作系统写入磁盘等。 + +!!! Note "说明" + + 如果您不想在单击"开始安装"按钮后继续， 您仍然可以在不丢失数据的情况下安全地返回安装。 要退出安装程序，只需单击"Quit"按钮，按键盘上的ctrl-alt-del组合键，或者按下重置或电源开关，即可重置系统。 + +### 完成安装 + +完成所有必需的子任务且安装程序运行完毕后，您将看到带有安装进度完毕的屏幕信息。 + +最后，单击Reboot System按钮来完成整个过程， 系统将重启。 + +### 登录 + +该系统现在已经设置好且可以使用了。 您将看到Rocky Linux控制台。 + +![Rocky Linux 欢迎界面](images/installation_8.5_F02.png) + +要登录到系统，请在登录提示处键入 `rockstar`，然后按 Enter 键。 + +在密码提示处，键入 `04302021`(rockstar 的密码)，然后按 Enter 键(密码将 ***不会*** 显示在屏幕上，这是正常的）。 + +登录后运行`whoami`命令，该命令显示当前登录用户的名称。 + +![Login Screen](images/installation-F06.png) diff --git a/docs/guides/containers/lxd_web_servers.it.md b/docs/guides/containers/lxd_web_servers.it.md new file mode 100644 index 0000000000..b620b602f4 --- /dev/null +++ b/docs/guides/containers/lxd_web_servers.it.md @@ -0,0 +1,926 @@ +--- +title: Guida Per Principianti Lxd-Server Multipli +author: Ezequiel Bruni +contributors: Steven Spencer, Franco Colussi +update: 28-Feb-2022 +--- + +# Costruire una Rete di Siti web/Server web con LXD, per Principianti + +## Introduzione + +Okay, così abbiamo già [una guida per l'installazione di LXD/LXC su Rocky Linux](lxd_server.md), ma questo è stato scritto da qualcuno che sa cosa sta facendo, e voleva costruire una rete containerizzata di server e/o applicazioni su una macchina fisica sulla sua rete locale. È fantastico, e ne ruberò subito dei pezzi per non dover scrivere tanto. + +Ma se avete appena sentito parlare di Linux Containers e non avete ancora capito bene come funzionano, ma volete ospitare qualche sito web, questa è la guida che fa per voi. *Questo tutorial vi insegnerà come ospitare siti web di base con LXD e LXC su qualsiasi sistema, compresi i server privati virtuali e il cloud hosting.* + +Quindi, in primo luogo, che cos'è un Container Linux? Per i principianti, si tratta di un modo per far sì che un computer finga di essere in realtà molti altri computer. Questi " container " ospitano ciascuno una versione di base, solitamente ridotta, di un sistema operativo scelto dall'utente. È possibile usare ogni contenitore come un server individuale; mettere *nginx* su uno, *Apache* su un altro e persino usare un terzo come server di database. + +Il vantaggio fondamentale è che se un'applicazione o un sito web all'interno del proprio contenitore presenta gravi bug, un hack o altri problemi, è improbabile che si ripercuotano sul resto del server o sulle altre applicazioni e siti web. Inoltre, i container sono facilissimi da visualizzare in snapshot, eseguire il backup e ripristinare. + +In questo caso, eseguiremo Rocky Linux nei nostri container, sopra il nostro sistema "host", che è anch'esso Rocky Linux. + +Concettualmente, è qualcosa di simile: + +![Un grafico che mostra come un computer possa fingere di essere più di un altro](../images/lxd-web-server-01.png) + +Se avete mai giocato con VirtualBox per eseguire alcune applicazioni Windows, è come questo, ma non è così. A differenza delle macchine virtuali, i container Linux non emulano un intero ambiente hardware per ogni container. Piuttosto, tutti condividono alcuni dispositivi virtuali per impostazione predefinita per la rete e lo storage, anche se è possibile aggiungere altri dispositivi virtuali. Di conseguenza, richiedono molto meno overhead (potenza di elaborazione e RAM) di una macchina virtuale. + +Per gli amici di Docker (Docker è un altro sistema basato su container, *non* un sistema di macchine virtuali), i container Linux sono meno effimeri di quelli a cui siete abituati. Tutti i dati in ogni istanza del container sono persistenti e qualsiasi modifica apportata è permanente, a meno che non si ripristini un backup. In breve, chiudere il contenitore non cancellerà i vostri peccati. + +Heh. + +LXD, in particolare, è un'applicazione a riga di comando che aiuta a configurare e gestire i Container Linux. Questo è ciò che installeremo oggi sul nostro server host Rocky Linux. Scriverò spesso di LXC/LXD, perché c'è molta documentazione vecchia che si riferisce solo a LXC e sto cercando di rendere più facile per le persone trovare guide aggiornate come questa. + +!!! Note "Nota" + + C'era un'applicazione precursore per LXD che veniva chiamata "LXC". Per come stanno le cose oggi: LXC è la tecnologia, LXD è l'applicazione. + +Li useremo entrambi per creare un ambiente che funzioni in questo modo: + +![Un diagramma della struttura del Container Linux previsto](../images/lxd-web-server-02.png) + +In particolare, vi mostrerò come configurare semplici server web Nginx e Apache all'interno dei vostri container server e come utilizzare un altro container con Nginx come reverse proxy. Anche in questo caso, questa configurazione dovrebbe funzionare in qualsiasi ambiente: dalle reti locali ai server privati virtuali. + +!!! Note "Nota" + + Un reverse proxy è un programma che prende le connessioni in entrata da Internet (o dalla rete locale) e le indirizza al server, al container o all'applicazione giusta. Esistono anche strumenti dedicati a questo lavoro, come HaProxy... ma, stranamente, trovo che Nginx sia molto più facile da usare. + +## Prerequisiti E Presupposti + +* Conoscenza di base dell'interfaccia a riga di comando Linux. Dovresti sapere come usare SSH se stai installando LXC/LXD su un server remoto. +* Un server connesso a Internet, fisico o virtuale, su cui è già in esecuzione Rocky Linux. +* Due nomi di dominio puntati correttamente sul vostro server con un record A. + * Anche due sottodomini andrebbero bene. Un dominio con un record di sottodominio wildcard anche, o un dominio LAN personalizzato... il disegno è chiaro. +* Un editor di testo a riga di comando. *nano* va bene, *micro* è il mio preferito, ma si può usare quello che si preferisce. +* *Potete* seguire l'intero tutorial come utente root, ma probabilmente non dovreste farlo. Dopo l'installazione iniziale di LXC/LXD, vi guideremo nella creazione di un utente non privilegiato specifico per i comandi LXD. +* Ora abbiamo immagini di Rocky Linux su cui basare i vostri container, e sono fantastiche. +* Se non avete molta dimestichezza con Nginx o Apache, **dovrete** consultare alcune delle nostre altre guide se volete ottenere un server di produzione completo e funzionante. Non preoccupatevi, li linkerò qui sotto. + +## Impostazione dell'Ambiente del Server Host + +Quindi qui copierò e incollerò dei pezzi dall'altra guida di LXD, per comodità vostra e mia. Il merito della maggior parte di questa parte va a Steven Spencer. + +### Installa il repository EPEL + +LXD richiede il repository EPEL (Extra Packages for Enterprise Linux), che è facile da installare: + +```bash +dnf install epel-release +``` + +Una volta installato, controllate gli aggiornamenti: + +```bash +dnf update +``` + +Se ci sono stati aggiornamenti del kernel durante il processo di aggiornamento di cui sopra, riavviare il server + +### Installazione di snapd + +LXD deve essere installato da un pacchetto snap\* per Rocky Linux. Per questo motivo, abbiamo bisogno di installare snapd con: + +```bash +dnf install snapd +``` + +Ora abilitate il servizio snapd per l'avvio automatico al riavvio del server e avviatelo subito: + +```bash +systemctl enable snapd +``` + +E poi eseguire: + +```bash +systemctl start snapd +``` + +Riavviare il server prima di continuare. È possibile farlo con il comando `reboot` o dal pannello di amministrazione del VPS/cloud hosting. + +\* *snap* è un metodo per impacchettare le applicazioni in modo che siano dotate di tutte le dipendenze necessarie e possano essere eseguite su quasi tutti i sistemi Linux. + +### Installare LXD + +L'installazione di LXD richiede l'uso del comando snap. A questo punto, stiamo solo installando, non stiamo facendo alcuna configurazione: + +```bash +snap install lxd +``` + +Se state eseguendo LXD su un server fisico (AKA "bare metal"), probabilmente dovreste tornare all'altra guida e leggere la sezione "Impostazione dell'Ambiente". Ci sono molte cose interessanti sui kernel, sui file system e molto altro ancora. + +Se state eseguendo LXD in un ambiente virtuale, riavviate e continuate a leggere. + +### Inizializzazione LXD + +Ora che l'ambiente è stato configurato, siamo pronti a inizializzare LXD. Si tratta di uno script automatico che pone una serie di domande per rendere operativa l'istanza LXD: + +```bash +lxd init +``` + +Ecco le domande e le nostre risposte per lo script, con una piccola spiegazione dove necessario: + +``` +Would you like to use LXD clustering? (yes/no) [default=no]: +``` + +Se siete interessati al clustering, fate ulteriori ricerche al riguardo [qui](https://lxd.readthedocs.io/en/latest/clustering/). Altrimenti, basta premere "Invio" per accettare l'opzione predefinita. + +``` +Do you want to configure a new storage pool? (yes/no) [default=yes]: +``` + + Accetta il predefinito. + +``` +Name of the new storage pool [default=default]: server-storage +``` + +Scegli un nome per il tuo pool di archiviazione. Mi piace chiamarlo come il server su cui gira LXD. (Un pool di archiviazione è in pratica una quantità prestabilita di spazio su disco rigido messa da parte per i vostri container.) + +``` +Name of the storage backend to use (btrfs, dir, lvm, zfs, ceph) [default=zfs]: lvm +``` + +La domanda precedente riguarda il tipo di file system che si desidera utilizzare per l'archiviazione e l'impostazione predefinita può variare a seconda di ciò che è disponibile sul sistema. Se siete su un server bare metal e volete usare ZFS, fate riferimento alla guida di cui sopra. + +In un ambiente virtuale, ho scoperto che "LVM" funziona bene e di solito è quello che uso. È possibile accettare l'impostazione predefinita alla domanda successiva. + +``` +Create a new LVM pool? (yes/no) [default=yes]: +``` + +Se si dispone di un disco rigido o di una partizione specifica che si desidera utilizzare per l'intero pool di archiviazione, scrivere "yes". Se state facendo tutto questo su un VPS, probabilmente *dovrete* scegliere "no". + +``` +`Would you like to use an existing empty block device (e.g. a disk or partition)? (yes/no) [default=no]:` +``` + +Metal As A Service (MAAS) non rientra nel campo di applicazione del presente documento. Accettare le impostazioni predefinite per il prossimo punto. + +``` +Would you like to connect to a MAAS server? (yes/no) [default=no]: +``` + +E più default. Va tutto bene. + +``` +Would you like to create a new local network bridge? (yes/no) [default=yes]: + +What should the new bridge be called? [default=lxdbr0]: ` + +What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: +``` + +Se si desidera utilizzare IPv6 sui propri contenitori LXD, è possibile attivare la prossima opzione. Questo dipende da voi, ma per lo più non dovrebbe essere necessario. Penso. Io tendo a lasciarlo fuori dalla pigrizia. + +``` +What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: +``` + +Questo è necessario per eseguire facilmente il backup del server e può consentire di gestire l'installazione di LXD da altri computer. Se tutto questo vi convince, rispondete "sì" qui/ + +``` +Would you like the LXD server to be available over the network? (yes/no) [default=no]: yes +``` + +Se avete risposto sì alle ultime domande, accettate i valori predefiniti: + +``` +Address to bind LXD to (not including port) [default=all]: + +Port to bind LXD to [default=8443]: +``` + +Ora vi verrà chiesta una password di fiducia. È il modo in cui ci si connette al server host LXC da altri computer e server, quindi è necessario impostare qualcosa che abbia senso nel proprio ambiente. Salvare la password in un luogo sicuro, ad esempio in un gestore di password. + +``` +Trust password for new clients: + +Again: +``` + +E poi proseguire con i valori predefiniti da qui in avanti: + +``` +Would you like stale cached images to be updated automatically? (yes/no) [default=yes] + +Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]: +``` + +#### Impostazione dei Privilegi degli Utenti + +Prima di continuare, dobbiamo creare l'utente "lxdadmin" e assicurarci che abbia i privilegi necessari. L'utente "lxdadmin" deve poter usare _sudo_ per accedere ai comandi di root e deve essere membro del gruppo "lxd". Per aggiungere l'utente e assicurarsi che sia membro di entrambi i gruppi, eseguire: + +```bash +useradd -G wheel,lxd lxdadmin +``` + +Quindi impostare la password: + +```bash +passwd lxdadmin +``` + +Come per le altre password, salvatela in un luogo sicuro. + +## Impostare Il Tuo Firewall + +Prima di fare qualsiasi altra cosa con i contenitori, è necessario essere in grado di accedere al server proxy dall'esterno. Se il firewall blocca la porta 80 (la porta predefinita utilizzata per il traffico HTTP/web) o la porta 443 (utilizzata per il traffico web HTTPS/*sicuro*), non si potrà fare molto a livello di server. + +L'altra guida di LXD mostra come farlo con il firewall *iptables*, se è questo che si vuole fare. Tendo a utilizzare il firewall predefinito di CentOS: *firewalld*. Ecco cosa faremo questa volta. + +`firewalld` è configurato tramite il comando `firewall-cmd`. **La prima cosa da fare**, prima di aprire qualsiasi porta, è assicurarsi che ai container possano essere assegnati automaticamente gli indirizzi IP: + +```bash +firewall-cmd --zone=trusted --permanent --change-interface=lxdbr0 +``` + +!!! Warning "Attenzione" + + Se non si esegue quest'ultimo passaggio, i contenitori non saranno in grado di accedere correttamente a Internet o tra loro. Si tratta di un elemento pazzescamente essenziale, e conoscerlo vi risparmierà *anni* di frustrazione. + +Ora, per aggiungere una nuova porta, basta eseguire questa operazione: + +```bash +firewall-cmd --permanent --zone=public --add-port=80/tcp +``` + +Scomponiamo il tutto: + +* La flag `--permanent` dice al firewall di assicurarsi che questa configurazione sia usata ogni volta che il firewall viene riavviato, e quando il server stesso viene riavviato. +* `--zone=public` dice al firewall di accettare connessioni in entrata a questa porta da chiunque. +* Infine, `–-add-port=80/tcp` dice al firewall di accettare connessioni in entrata sulla porta 80, fintanto che stanno utilizzando il Transmission Control Protocol, che è quello che si desidera in questo caso. + +Per ripetere il processo per il traffico HTTPS, basta eseguire nuovamente il comando e cambiare il numero. + +```bash +firewall-cmd --permanent --zone=public --add-port=443/tcp +``` + +Queste configurazioni non avranno effetto finché non si forzerà il processo. Per farlo, dite a *firewalld* di ricaricare le sue configurazioni, in questo modo: + +```bash +firewall-cmd --reload +``` + +Ora, c'è una piccolissima possibilità che questo non funzioni. In questi rari casi, fate in modo che *firewalld* esegua i vostri ordini con il vecchio "spegni e riaccendi". + +```bash +systemctl restart firewalld +``` + +Per verificare che le porte siano state aggiunte correttamente, eseguire `firewall-cmd --list-all`. Un firewall correttamente configurato avrà un aspetto simile a questo (ho alcune porte extra aperte sul mio server locale, ignoratele): + +```bash +public (active) + target: default + icmp-block-inversion: no + interfaces: enp9s0 + sources: + services: cockpit dhcpv6-client ssh + ports: 81/tcp 444/tcp 15151/tcp 80/tcp 443/tcp + protocols: + forward: no + masquerade: no + forward-ports: + source-ports: + icmp-blocks: + rich rules: +``` + +E questo dovrebbe essere tutto ciò di cui avete bisogno, a livello di firewall. + +## Impostazione Dei Container + +In realtà la gestione dei container è piuttosto semplice. Pensate che è come poter richiamare un intero computer a comando e avviarlo o fermarlo a piacimento. È inoltre possibile accedere a tale "computer" ed eseguire qualsiasi comando, proprio come si farebbe con il server host. + +!!! Note "Nota" + + Da questo momento in poi, ogni comando deve essere eseguito come utente `lxdadmin`, o come avete deciso di chiamarlo, anche se alcuni richiederanno l'uso di *sudo* per ottenere temporaneamente i privilegi di root. + +Per questa esercitazione sono necessari tre container: il server reverse proxy, un server Nginx di prova e un server Apache di prova, tutti eseguiti su container basati su Rocky. + +Se per qualche motivo si ha bisogno di un container completamente privilegiato (e per lo più non lo si dovrebbe), si possono eseguire tutti questi comandi come root. + +Per questa esercitazione sono necessari tre container: + +Li chiameremo "proxy-server" (per il contenitore che dirigerà il traffico web agli altri due contenitori), "nginx-server" e "apache-server". Sì, vi mostrerò come effettuare il reverse proxy su entrambi i server *nginx* e *apache*. Cose come *docker* o le applicazioni NodeJS possono aspettare fino a quando non lo capirò da me. + +Cominciamo a capire su quale immagine vogliamo basare i nostri container. Per questa esercitazione, utilizzeremo solo Rocky Linux. L'uso di Alpine Linux, ad esempio, può portare a container molto più piccoli (se l'archiviazione è un problema), ma questo esula dallo scopo di questo documento. + +### Trovare l'Immagine Desiderata + +Ecco il metodo breve per avviare un container con Rocky Linux: + +```bash +lxc launch images:rockylinux/8/amd64 my-container +``` + +Naturalmente, quel "my-container" alla fine deve essere rinominato con il nome del contenitore che si desidera, ad es. “proxy-server”. La parte "/amd64" dovrebbe essere cambiata in "arm64" se si sta facendo tutto questo su qualcosa come un Raspberry Pi. + +Ecco la versione lunga: per trovare le immagini desiderate, si può usare questo comando per elencare tutte le immagini disponibili nei repository LXC principali: + +```bash +lxc image list images: | more +``` + +Poi basta premere "Invio" per scorrere un enorme elenco di immagini e premere "Control-C" per uscire dalla modalità di visualizzazione dell'elenco. + +Oppure, ci si può semplificare la vita e specificare il tipo di Linux che si desidera, in questo modo: + +```bash +lxc image list images: | grep rockylinux +``` + +Dovrebbe venire stampato un elenco molto più breve, simile a questo: + +```bash +| rockylinux/8 (3 more) | 4e6beda70200 | yes | Rockylinux 8 amd64 (20220129_03:44) | x86_64 | VIRTUAL-MACHINE | 612.19MB | Jan 29, 2022 at 12:00am (UTC) | +| rockylinux/8 (3 more) | c04dd2bcf20b | yes | Rockylinux 8 amd64 (20220129_03:44) | x86_64 | CONTAINER | 127.34MB | Jan 29, 2022 at 12:00am (UTC) | +| rockylinux/8/arm64 (1 more) | adc0561d6330 | yes | Rockylinux 8 arm64 (20220129_03:44) | aarch64 | CONTAINER | 124.03MB | Jan 29, 2022 at 12:00am (UTC) | +| rockylinux/8/cloud (1 more) | 2591d9716b04 | yes | Rockylinux 8 amd64 (20220129_03:43) | x86_64 | CONTAINER | 147.04MB | Jan 29, 2022 at 12:00am (UTC) | +| rockylinux/8/cloud (1 more) | c963253fcea9 | yes | Rockylinux 8 amd64 (20220129_03:43) | x86_64 | VIRTUAL-MACHINE | 630.56MB | Jan 29, 2022 at 12:00am (UTC) | +| rockylinux/8/cloud/arm64 | 9f49e80afa5b | yes | Rockylinux 8 arm64 (20220129_03:44) | aarch64 | CONTAINER | 143.15MB | Jan 29, 2022 at 12:00am (UTC) | +``` + +### Creazione Dei Container + +!!! Note "Nota" + + Di seguito viene illustrato un modo rapido per creare tutti questi contenitori. Si consiglia di aspettare prima di creare il container proxy-server. C'è un trucco che vi mostrerò di seguito e che potrebbe farvi risparmiare tempo. + +Una volta trovata l'immagine desiderata, utilizzate il comando `lxc launch` come mostrato sopra. Per creare i container desiderati per questa esercitazione, eseguire questi comandi (modificandoli se necessario) in successione: + +```bash +lxc launch images:rockylinux/8/amd64 proxy-server +lxc launch images:rockylinux/8/amd64 nginx-server +lxc launch images:rockylinux/8/amd64 apache-server +``` + +Dopo aver eseguito ogni comando, si dovrebbe ricevere una notifica che indica che i container sono stati creati e persino avviati. Quindi, è necessario controllarli tutti. + +Eseguite questo comando per verificare che siano tutti attivi e funzionanti: + +```bash +lxc list +``` + +Il risultato dovrebbe essere simile a questo (anche se, se si è scelto di usare IPv6, ci sarà molto più testo): + +```bash ++---------------+---------+-----------------------+------+-----------+-----------+ +| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS | ++---------------+---------+-----------------------+------+-----------+-----------+ +| proxy-server | RUNNING | 10.199.182.231 (eth0) | | CONTAINER | 0 | ++---------------+---------+-----------------------+------+-----------+-----------+ +| nginx-server | RUNNING | 10.199.182.232 (eth0) | | CONTAINER | 0 | ++---------------+---------+-----------------------+------+-----------+-----------+ +| apache-server | RUNNING | 10.199.182.233 (eth0) | | CONTAINER | 0 | ++---------------+---------+-----------------------+------+-----------+-----------+ +``` + +#### Una Parola sulla Rete di Container + +Nella guida collegata all'inizio di questa c'è un intero tutorial su come impostare LXC/LXD per lavorare con Macvlan. Questo è particolarmente utile se si gestisce un server locale e si vuole che ogni contenitore abbia un indirizzo IP visibile sulla rete locale. + +Quando si lavora su un VPS, spesso non si ha questa possibilità. In effetti, potreste avere un solo indirizzo IP con cui siete autorizzati a lavorare. Non è un problema. La configurazione di rete predefinita è progettata per soddisfare questo tipo di limitazioni; rispondendo alle domande di `lxd init` come ho specificato sopra *si dovrebbe* occupare di tutto. + +Fondamentalmente, LXD crea un dispositivo di rete virtuale chiamato bridge (di solito chiamato "lxdbr0") e tutti i contenitori vengono connessi a quel bridge per impostazione predefinita. Attraverso di esso, possono connettersi a Internet tramite il dispositivo di rete predefinito dell'host (Ethernet, wi-fi o un dispositivo di rete virtuale fornito dal VPS). Inoltre, cosa ancora più importante, tutti i container possono connettersi tra loro. + +Per garantire questa connessione tra i container, *ogni contenitore ottiene un nome di dominio interno*. Per impostazione predefinita, è solo il nome del contenitore più ".lxd". Quindi il container "proxy-server" è disponibile per tutti gli altri container in "proxy-server.lxd". Ma ecco la cosa *davvero* importante da sapere: per **default i domini ".lxd" sono disponibili solo all'interno dei container stessi.** + +Se si esegue `ping proxy-server.lxd` sul sistema operativo host (o altrove), non si ottiene nulla. Questi domini interni, però, ci torneranno molto utili in seguito. + +Tecnicamente si può cambiare e rendere disponibili i domini interni del container sull'host... ma non l'ho mai capito. Probabilmente è meglio mettere il server reverse proxy in un container, in modo da poter eseguire snapshot e backup con facilità. + +### Gestire I Container + +Alcune cose da sapere prima di procedere: + +#### Avviamento & Arresto + +Tutti i container possono essere avviati, fermati e riavviati a seconda delle necessità con i seguenti comandi: + +```bash +lxc start mycontainer +lxc stop mycontainer +lxc restart mycontainer +``` + +Ehi, anche Linux ha bisogno di riavviarsi ogni tanto. E poi, in realtà, è possibile avviare, arrestare e riavviare tutti i container in una volta sola con i seguenti comandi. + +```bash +lxc start --all +lxc stop --all +lxc restart --all +``` + +L'opzione `restart --all` è molto utile per alcuni dei bug temporanei più oscuri. + +#### Fare Operazione all'Interno dei Container + +È possibile controllare il sistema operativo all'interno del container in due modi: si possono semplicemente eseguire comandi al suo interno dal sistema operativo host, oppure si può aprire una shell. + +Ecco cosa intendo. Per eseguire un comando all'interno di un container, magari per installare *Apache*, basta usare `lxc exec`, in questo modo: + +```bash +lxc exec my-container dnf install httpd -y +``` + +Questo farà sì che *Apache* si installi da solo e si vedrà l'output del comando sul terminale dell'host. + +Per aprire una shell (in cui è possibile eseguire tutti i comandi desiderati come root), utilizzare questa procedura: + +```bash +lxc exec my-container bash +``` + +Se, come me, preferite la comodità allo spazio di archiviazione e avete installato una shell alternativa come *fish* in tutti i vostri container, cambiate semplicemente il comando in questo modo: + +```bash +lxc exec my-container fish +``` + +In quasi tutti i casi, verrete automaticamente posizionati sull'account di root e nella directory `/root`. + +Infine, se si è aperta una shell in un container, la si lascia nello stesso modo in cui si lascia qualsiasi shell: con un semplice comando `exit`. + +#### Copia dei Container + +Ora, se si dispone di un container che si desidera replicare con il minimo sforzo, non è necessario avviarne uno nuovo e installare nuovamente tutte le applicazioni di base. Sarebbe sciocco. Esegui semplicemente: + +```bash +lxc copy my-container my-other-container +``` + +Verrà creata una copia esatta di "my-container" con il nome "my-other-container". Tuttavia, potrebbe non avviarsi automaticamente, quindi è necessario apportare eventuali modifiche alla configurazione del nuovo container ed eseguirlo: + +```bash +lxc start my-other-container +``` + +A questo punto, si potrebbero apportare alcune modifiche, come cambiare l'hostname interno del container o altro. + +#### Configurazione dello Storage & Limiti della CPU + +LXC/LXD di solito definisce la quantità di spazio di archiviazione di un container e in generale gestisce le risorse, ma è probabile che si voglia avere il controllo su questo aspetto. Se ci si preoccupa di mantenere i container piccoli, si può usare il comando `lxc config` per rimpicciolirli ed estenderli secondo le necessità. + +Il comando seguente imposta un limite "soft" di 2GB su un container. Un limite soft è in realtà più che altro una "memoria minima" e il container utilizzerà più memoria se è disponibile. Come sempre, cambiare "my-container" con il nome del container effettivo. + +```bash +lxc config set my-container limits.memory 2GB +``` + +È possibile impostare un limite hard in questo modo: + +```bash +lxc config set my-container limits.memory.enforce 2GB +``` + +Se si vuole essere sicuri che un determinato container non possa occupare tutta la potenza di elaborazione disponibile sul server, è possibile limitare i core della CPU a cui ha accesso con questo comando. Basta modificare il numero di core della CPU alla fine, come si ritiene opportuno. + +```bash +lxc config set my-container limits.cpu 2 +``` + +#### Eliminare i Container (e Come Evitare Che Ciò Accada) + +Infine, è possibile eliminare i container eseguendo questo comando: + +```bash +lxc delete my-container +``` + +Non sarà possibile cancellare il container se è in esecuzione, quindi è necessario fermarlo prima o usare la flag `--force` per saltare questa parte. + +```bash +lxc delete my-container --force +``` + +Ora, grazie al completamento del comando Tab, all'errore dell'utente e al fatto che la "d" si trova accanto alla "s" sulla maggior parte delle tastiere, è possibile cancellare accidentalmente i container. Questo è noto, nel settore, come il BIG OOPS. (O almeno sarà conosciuto come THE BIG OOPS quando avrò finito qui.) + +Per proteggersi da ciò, è possibile impostare qualsiasi container come "protetto" (facendo sì che il processo di cancellazione richieda un passo in più) con questo comando: + +```bash +lxc config set my-container security.protection.delete true +``` + +Per togliere la protezione al container, basta eseguire di nuovo il comando, cambiando però "true" con "false". + +## Impostazione dei Server + +Ok, ora che i container sono attivi e funzionanti, è il momento di installare ciò che serve. Per prima cosa, assicurarsi che tutti siano aggiornati con i seguenti comandi (saltare il container "proxy-server" se non è stato ancora creato): + +```bash +lxc exec proxy-server dnf update -y +lxc exec nginx-server dnf update -y +lxc exec apache-server dnf update -y +``` + +Poi, entrate in ogni container e datevi da fare. + +È inoltre necessario un editor di testo per ogni container. Per impostazione predefinita, Rocky Linux viene fornito con *vi*, ma se volete semplificarvi la vita, *nano* andrà bene. È possibile installarlo in ogni container prima di aprirli. + +```bash +lxc exec proxy-server dnf install nano -y +lxc exec nginx-server dnf install nano -y +lxc exec apache-server dnf install nano -y +``` + +In futuro userò *nano* in tutti i comandi relativi all'editor di testo, a vostra scelta. + +### Il Server del Sito Web Apache + +La faremo breve, a scopo di apprendimento e di verifica. Di seguito trovate il link alle guide Apache complete. + +Per prima cosa, aprite una shell nel vostro container. Si noti che, per impostazione predefinita, i container vi porteranno nell'account di root. Per i nostri scopi, questo va bene, anche se si potrebbe voler creare un utente del server web specifico per la produzione effettiva. + +```bash +lxc exec apache-server bash +``` + +Una volta effettuato l'accesso, è sufficiente installare *Apache* in modo semplice: + +```bash +dnf install httpd +``` + +Ora, si potrebbe seguire la nostra guida [Impostazione Apache Multi-Sito](.../web/apache-sites-enabled.md) da qui in avanti, ma in realtà è un po' eccessivo per i nostri scopi. Di solito non si vuole configurare Apache per più siti web in un ambiente containerizzato come questo. Il punto centrale dei container è la separazione delle operazioni, dopotutto. + +Inoltre, i certificati SSL andranno sul server proxy, quindi manterremo le cose semplici. + +Una volta installato *Apache*, assicurarsi che sia in funzione e che possa continuare a funzionare al riavvio: + +```bash +systemctl enable --now httpd +``` + +La flag `--now` consente di saltare il comando di avvio del server vero e proprio. Come riferimento, si tratta di: + +```bash +systemctl start httpd +``` + +Se avete installato `curl` sul vostro host server, potete assicurarvi che la pagina web predefinita sia attiva e funzionante con: + +```bash +curl [container-ip-address] +``` + +Ricordate che potete vedere tutti gli IP dei container con `lxc list`. E se si installa curl su tutti i container, si *potrebbe* eseguire semplicemente: + +```bash +curl localhost +``` + +#### Ottenere gli IP degli utenti reali dal server proxy + +Ora c'è un passo da fare per preparare Apache all'uso del reverse proxy. Per impostazione predefinita, gli indirizzi IP effettivi degli utenti non vengono registrati dai server nei container del server web. Si vuole che questi indirizzi IP passino perché alcune applicazioni web hanno bisogno degli IP degli utenti per operazioni come la moderazione, il divieto e la risoluzione dei problemi. + +Per far sì che gli indirizzi IP dei visitatori superino il server proxy, sono necessari due elementi: le giuste impostazioni del server proxy (di cui parleremo più avanti) e un semplice file di configurazione per il server Apache. + +Un grande ringraziamento va a Linode e [alla loro guida LXD](https://www.linode.com/docs/guides/beginners-guide-to-lxd-reverse-proxy) per i modelli di questi file di configurazione. + +Crea un nuovo file di configurazione: + +```bash +nano /etc/httpd/conf.d/real-ip.conf +``` + +E aggiungete questo testo: + +``` +RemoteIPHeader X-Real-IP +RemoteIPTrustedProxy proxy-server.lxd +``` + +Ricordarsi di cambiare `proxy-server.lxd` con il nome del container proxy effettivo, se necessario. Ora **non riavviate ancora il server Apache.** Il file di configurazione che abbiamo aggiunto potrebbe causare problemi *fino a quando* non avremo il server proxy attivo e funzionante. + +Usciamo dalla shell per ora e iniziamo con il server Nginx. + +!!! Note "Nota" + + Anche se questa tecnica *funziona* (le applicazioni web e i siti web otterranno gli IP reali degli utenti), i log di accesso di Apache *non mostreranno gli IP giusti* e di solito mostreranno l'IP del container in cui si trova il reverse proxy. A quanto pare si tratta di un problema nel modo in cui Apache registra i log. + + Ho trovato un sacco di soluzioni su Google, ma nessuna di esse ha effettivamente funzionato per me. Guardate questo spazio per vedere se qualcuno, molto più intelligente di me, riuscirà a capirlo. Nel frattempo, potete controllare i registri di accesso del server proxy se avete bisogno di vedere gli indirizzi IP, oppure controllare i registri di qualsiasi applicazione web che state installando. + +### Il server web Nginx + +Anche in questo caso, la faremo breve. Se volete usare la versione più recente (e consigliata) di Nginx in produzione, consultate la nostra [guida per principianti all'installazione di Nginx](../web/nginx-mainline.md). Questo contiene la guida completa all'installazione e alcune buone pratiche per la configurazione del server. + +Per i test e l'apprendimento, *potreste* installare Nginx normalmente, ma vi consiglio di installare l'ultima versione, che è chiamata ramo "mainline". + +Per prima cosa, accedere alla shell del container: + +```bash +lxc exec nginx-server bash +``` + +Quindi, installare il repository `epel-release` in modo da poter installare l'ultima versione di Nginx: + +```bash +dnf install epel-release +``` + +Una volta fatto questo, cercare l'ultima versione di Nginx con: + +```bash +dnf module list nginx +``` + +Si dovrebbe ottenere un elenco simile a questo: + +```bash +Rocky Linux 8 - AppStream +Name Stream Profiles Summary +nginx 1.14 [d] common [d] nginx webserver +nginx 1.16 common [d] nginx webserver +nginx 1.18 common [d] nginx webserver +nginx 1.20 common [d] nginx webserver +nginx mainline common [d] nginx webserver +``` + +Quella desiderata è, avete indovinato, il ramo mainline. Abilitare il modulo con questo comando: + +```bash +dnf enable module nginx:mainline +``` + +Vi verrà chiesto se siete sicuri di volerlo fare, quindi scegliete `Y` come al solito. Quindi, utilizzare il comando predefinito per installare Nginx: + +```bash +dnf install nginx +``` + +Quindi, abilitare e avviare Nginx: + +```bash +dnf enable --now nginx +``` + +!!! Note "Nota" + + Ricordate quando vi ho detto di aspettare prima di creare il contenitore proxy? Ecco perché: a questo punto, si può risparmiare tempo lasciando il container "nginx-server" e copiandolo per creare il container "proxy-server": + + ```bash + lxc copy nginx-server proxy-server + ``` + + + Assicurarsi di avviare il container proxy con `lxc start proxy-server` e di aggiungere le porte proxy al container come descritto di seguito. + +Anche in questo caso, si può verificare che il container funzioni dall'host con: + +```bash +curl [your-container-ip] +``` + +#### Ottenere gli IP utente reali dal server proxy (nuovamente) + +I log *dovrebbero* funzionare questa volta. Dovrebbero. Per farlo, inseriamo un file molto simile in `/etc/nginx/conf.d`: + +```bash +nano /etc/nginx/conf.d/real-ip.conf +``` + +Poi inserite questo testo: + +```bash +real_ip_header X-Real-IP; +set_real_ip_from proxy-server.lxd; +``` + +Infine, **non riavviare ancora il server**. Anche in questo caso, il file di configurazione potrebbe causare problemi finché non viene impostato il server proxy. + +### Il Server Reverse Proxy + +Ricordate quando vi ho detto che vi servono due domini o sottodomini? È qui che servono. I sottodomini che sto utilizzando per questo tutorial sono: + +* apache.server.test +* nginx.server.test + +Modificateli in tutti i file e le istruzioni, se necessario. + +Se si è copiato il container "proxy-server" dal container "nginx-server" e vi si sono aggiunti i dispositivi proxy, basta entrare nella shell. Se il container è stato creato in precedenza, è necessario ripetere tutti i passaggi per l'installazione di Nginx nel container "proxy-server". + +Una volta installato e accertato che funziona bene, è sufficiente impostare un paio di file di configurazione per indirizzare il traffico dai domini scelti ai server del sito web vero e proprio. + +Prima di farlo, assicuratevi di poter accedere a entrambi i server tramite i loro domini interni: + +```bash +curl apache-server.lxd +curl nginx-server.lxd +``` + +Se questi due comandi caricano nel terminale l'HTML delle pagine di benvenuto del server predefinito, allora tutto è stato configurato correttamente. + +#### *Passo essenziale:* Configurare il Container "proxy-server" per Accettare Tutto il Traffico Server in Entrata + +Anche in questo caso, si consiglia di farlo in un secondo momento, quando si creerà effettivamente il server proxy, ma ecco le istruzioni necessarie: + +Ricordate quando abbiamo aperto le porte 80 e 443 nel firewall? Qui si fa in modo che il container "proxy-server" ascolti queste porte e riceva tutto il traffico diretto verso di esse. + +Basta eseguire questi due comandi in successione: + +```bash +lxc config device add proxy-server myproxy80 proxy listen=tcp:0.0.0.0:80 connect=tcp:127.0.0.1:80 +lxc config device add proxy-server myproxy443 proxy listen=tcp:0.0.0.0:443 connect=tcp:127.0.0.1:443 +``` + +Vediamo di analizzare la situazione. Ogni comando aggiunge un "dispositivo" virtuale al container proxy-server. Questi dispositivi sono impostati per ascoltare la porta 80 e la porta 443 del sistema operativo host e sono collegati alla porta 80 e alla porta 443 del container. Ogni dispositivo ha bisogno di un nome, quindi ho scelto "myproxy80" e "myproxy443". + +L'opzione "listen" è la porta del sistema operativo host e, se non sbaglio, 0.0.0.0 è l'indirizzo IP dell'host sul bridge "lxdbr0". L'opzione "connect" indica l'indirizzo IP locale e le porte a cui ci si connette. + +!!! Note "Nota" + + Una volta impostati questi dispositivi, è necessario riavviare tutti i container, per sicurezza. + +Questi dispositivi virtuali dovrebbero essere idealmente univoci. Di solito è meglio non aggiungere un dispositivo "myport80" a un altro container in esecuzione; dovrà essere chiamato in un altro modo. + +*Allo stesso modo, solo un container alla volta può ascoltare su una specifica porta del sistema operativo host.* + +#### Direzione del traffico al server Apache + +Nel container "proxy-server", creare un file di configurazione chiamato `apache-server.conf` in `/etc/nginx/conf.d/`: + +```bash +nano /etc/nginx/conf.d/apache-server.conf +``` + +Quindi incollate questo testo, modificate il nome del dominio come necessario e salvatelo: + +``` +upstream apache-server { + server apache-server.lxd:80; +} + +server { + listen 80 proxy_protocol; + listen [::]:80 proxy_protocol; + server_name apache.server.test; #< Your domain goes here + + location / { + proxy_pass http://apache-server; + + proxy_redirect off; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + } +} +``` + +Vediamo di scomporlo un po': + +* La sezione `upstream` definisce esattamente dove il reverse proxy invierà tutto il suo traffico. In particolare, invia il traffico al nome di dominio interno del container "apache-server": `apache-server.lxd`. +* Le due righe che iniziano con `listen` indicano al server di ascoltare il traffico in arrivo sulla porta 80 con il protocollo proxy. La prima via IPv4 e la seconda via IPv6. +* La funzione `server_name` prende tutto il traffico che arriva specificamente da "apache.server.test" e lo instrada attraverso il reverse proxy. +* La funzione `proxy-pass` è la parte che dirige effettivamente tutto il traffico catturato dalla variabile `server_name` e lo invia al server definito nella sezione `upstream`. +* La funzione `proxy_redirect` può apparentemente interferire con i reverse proxy, quindi ci assicuriamo che sia disattivata. +* Tutte le opzioni `proxy-set-header` inviano al server web informazioni come l'IP dell'utente e altro. + +!!! warning "Attenzione" + + Il valore `proxy_protocol` nelle variabili `listen` è *essenziale* per il funzionamento del server proxy. Non lasciarlo mai fuori. + +Per ogni file di configurazione di LXD/sito web, è necessario modificare le impostazioni di `upstream`, `server`, `server_name` e `proxy_pass`. Il testo dopo "http://" in `proxy-pass` deve corrispondere al testo che viene dopo il testo `upstream`. + +Ricaricare il server con `systemctl restart nginx`, quindi puntare il browser sul dominio utilizzato invece che su `apache.server.test`. Se vedete una pagina che assomiglia a questa, siete a posto: + +![Schermata della pagina di benvenuto predefinita di Rocky Linux Apache](../images/lxd-web-server-03.png) + +!!! Note "Nota" + + È possibile assegnare ai file di configurazione il nome che si preferisce. Per le esercitazioni sto usando nomi semplificati, ma alcuni sysadmin raccomandano nomi basati sul dominio attuale, ma al contrario. È un'organizzazione basata sull'ordine alfabetico. + + es. "apache.server.test" otterrebbe un file di configurazione chiamato `test.server.apache.conf`. +#### Direzione del traffico al server Nginx + +Ripetere il procedimento. Creare un file come in precedenza: + +```bash +nano /etc/nginx/conf.d/nginx-server.conf +``` + +Aggiungere il testo appropriato: + +``` +upstream nginx-server { + server rocky-nginx.lxd:80; +} + +server { + listen 80 proxy_protocol; + listen [::]:80 proxy_protocol; + server_name nginx.server.test; #< Your domain goes here + + location / { + proxy_pass http://nginx-server; + + proxy_redirect off; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + } +} +``` + +Ancora una volta, ricaricate il server proxy, puntate il browser all'indirizzo appropriato e sperate che la divinità che preferite veda questo: + +![Una schermata della pagina di benvenuto predefinita di Rocky Linux Nginx](../images/lxd-web-server-04.png) + +#### Riavviare i server nei container che ospitano il server web + +Uscire dal container "proxy-server" e riavviare i server negli altri due container con un semplice comando: + +```bash +lxc exec apache-server systemctl restart httpd && lxc exec nginx-server restart nginx +``` + +Questo applicherà i file "real-ip.conf" che abbiamo creato nelle rispettive configurazioni dei server. + +#### Ottenere i certificati SSL per i tuoi siti web +Ottenere certificati SSL ufficiali e corretti è più facile con Let's Encrypt e una piccola applicazione chiamata certbot. certbot rileverà automaticamente i vostri siti web, otterrà i certificati SSL per essi e configurerà i siti stessi. Rinnova anche i certificati per voi ogni 30 giorni circa, senza alcun intervento da parte vostra o cron job. + +Tutto questo deve essere fatto dal container "proxy-server", quindi si deve accedere a quella shell. Una volta lì, installare i repository EPEL, proprio come si è fatto sull'host. Assicurarsi che il container sia stato prima aggiornato: + +```bash +dnf update +``` + +Quindi, aggiungere il repository EPEL: + +```bash +dnf install epel-release +``` + +Quindi è sufficiente installare certbot e il suo modulo Nginx: + +```bash +dnf install certbot python3-certbot-nginx +``` + +Una volta installato, se si dispone già di un paio di siti web configurati, è sufficiente eseguirlo: + +```bash +certbot --nginx +``` + +Certbot leggerà la configurazione di Nginx e capirà quanti siti web avete e se hanno bisogno di certificati SSL. A questo punto, vi saranno poste alcune domande. Accettate i termini di servizio, volete ricevere e-mail, ecc? + +Le domande più importanti sono le seguenti. Inserite il vostro indirizzo e-mail quando vedete questo: + +``` +Saving debug log to /var/log/letsencrypt/letsencrypt.log +Enter email address (used for urgent renewal and security notices) + (Enter 'c' to cancel): +``` + +Qui è possibile scegliere per quali siti web ottenere i certificati. Basta premere invio per ottenere i certificati per tutti quanti. + +``` +Which names would you like to activate HTTPS for? +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +1: apache.server.test +2: nginx.server.test +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +Select the appropriate numbers separated by commas and/or spaces, or leave input +blank to select all options shown (Enter 'c' to cancel): +``` + +Verrà visualizzato un testo di conferma e il gioco è fatto. Ma se andate sui vostri siti web, potreste scoprire che non funzionano. Questo perché quando certbot crea la configurazione aggiornata, dimentica una cosa molto importante. + +Andate nei file `apache-server.conf` e `nginx-server.conf` e trovate le due righe seguenti: + +``` +listen [::]:443 ssl ipv6only=on; # managed by Certbot +listen 443 ssl; # managed by Certbot +``` + +Sì, manca l'impostazione `proxy_protocol` e questo è un male. Aggiungetelo voi stessi. + +``` +listen proxy_protocol [::]:443 ssl ipv6only=on; # managed by Certbot +listen proxy_protocol 443 ssl; # managed by Certbot +``` + +Salvate il file, riavviate il server e i vostri siti web si caricheranno senza problemi. + +## Note + +1. In questa guida non ho parlato molto della configurazione dei server web. Il minimo che si dovrebbe fare, in produzione, è cambiare i nomi dei domini nei file di configurazione del server nei container del server web vero e proprio, e non solo nel container proxy. E magari impostare un utente del server web in ciascuno di essi. +2. Se volete saperne di più sulla gestione manuale dei certificati SSL e delle configurazioni dei server SSL, consultate [la nostra guida all'installazione di certbot e alla generazione dei certificati SSL](../security/generating_ssl_keys_lets_encrypt.md). +3. Applicazioni come Nextcloud richiedono una configurazione aggiuntiva (per motivi di sicurezza) se vengono inserite in un contenitore LXD dietro un proxy. + +## Conclusione + +C'è molto altro da imparare su LXC/LXD, sulla containerizzazione, sui server web e sull'esecuzione dei siti web, ma questo dovrebbe essere un buon inizio. Una volta appreso come deve essere impostato tutto e come configurare le cose nel modo desiderato, si può anche iniziare ad automatizzare il processo. + +Potreste usare Ansible, oppure essere come me e avere una serie di script scritti su misura da eseguire per rendere tutto più veloce. È anche possibile creare piccoli "container modello" con tutti i software preferiti preinstallati, per poi copiarli ed espanderne la capacità di archiviazione in base alle esigenze. + +Va Bene. Questo è fatto. Io sono fuori per giocare a videogiochi. Buon divertimento! diff --git a/docs/guides/contribute/README.es.md b/docs/guides/contribute/README.es.md new file mode 100644 index 0000000000..27dc19b3ae --- /dev/null +++ b/docs/guides/contribute/README.es.md @@ -0,0 +1 @@ +./../../README.md \ No newline at end of file diff --git a/docs/guides/contribute/mkdocs_lsyncd.it.md b/docs/guides/contribute/mkdocs_lsyncd.it.md index af29312cbc..01d0a3f869 100644 --- a/docs/guides/contribute/mkdocs_lsyncd.it.md +++ b/docs/guides/contribute/mkdocs_lsyncd.it.md @@ -2,7 +2,10 @@ title: Documentazione Locale - LXD author: Steven Spencer contributors: Ezequiel Bruni, Franco Colussi -update: 09-Mar-2022 +tested with: 8.5, 8.6 +tags: + - contribute + - local envirmonent lxd --- # Introduzione @@ -58,6 +61,18 @@ In primo luogo, entrare nel container con: lxc exec mkdocs bash ``` +!!! importante "Cambiamenti nel requirements.txt per 8.x" + + L'attuale `requirements.txt' richiederà una versione di Python più recente di quella installata di default in Rocky Linux 8.5 o 8.6. Per poter installare tutte le altre dipendenze, procedere come segue: + + ``` + sudo dnf module enable python38 + sudo dnf install python38 + ``` + + + Si può quindi saltare l'installazione di `python3-pip` nei pacchetti che si trovano di seguito. + Avremo bisogno di alcuni pacchetti per realizzare ciò che dobbiamo fare: ``` @@ -183,7 +198,7 @@ Poi abbiamo bisogno di impostare `mkdocs` con una directory aggiuntiva. Al momen ``` mkdir docs cd docs -ln -s ../documentation/docs +ln -s ../../documentation/docs ``` ### Testare mkdocs diff --git a/docs/guides/database/database_mariadb-server.es.md b/docs/guides/database/database_mariadb-server.es.md index d2443bad3f..91c2cab4f1 100644 --- a/docs/guides/database/database_mariadb-server.es.md +++ b/docs/guides/database/database_mariadb-server.es.md @@ -1,44 +1,63 @@ -# Base de datos mariadb-server +--- +title: Servidor de base de datos MariaDB +author: Steven Spencer +contributors: Ezequiel Bruni, William Perron +tested with: 8.5, 8.6, 9.0 +tags: + - base de datos + - mariadb +--- -## Pre-requisitos +# Servidor de base de datos MariaDB + +## Requisitos previos * Un servidor con Rocky Linux. -* Estaremos usando _"vi"_ como editor de linea de comandos, por lo que es necesario saber usarlo -* Una gran facilidad para el uso de líneas de comando en la terminal, revisar los logs (registros de errores), y otros aspectos generales de un administrador de sistema -* Será útil algún conocimiento sobre _mariadb-server_ -* Toma en consideración que todos los comandos deben ser ejecutados con super usuario o con _sudo_ +* Dominio de un editor de línea de comandos (en este ejemplo, utilizaremos _vi_) +* Un alto nivel de comodidad en la ejecución de comandos desde el terminal, la visualización de registros y otras tareas de caracter genérico dentro de la administración de sistemas +* Sería de gran utilidad poseer algún conocimiento sobre de bases de datos _mariadb-server_ +* Todos los comandos se deben ejecutar como el usuario root o _sudo_ ## Introducción -La combinación de _mariadb-server_ y su cliente _mariadb_ son una buena alternativa open source para _mysql-server_ y _mysql_, ya que los mismos comparten las mismas estructuras de comando. - -_mariadb-server_ es bastante popular y es usado en muchos servidores, debido a que es requerido por el CMS de [Wordpress](https://es.wordpress.org/). Aunque el mismo también se puede usar para otras cosas. +El servidor _mariadb-server_ y su cliente _mariadb_ son las alternativas de código abierto a _mysql-server_ y _mysql_, y comparten la misma estructura de comandos. _mariadb-server_ es muy popular y se utiliza en muchos servidores, debido a que es un requisito del CMS [Wordpress](https://es.wordpress.org/). Sin embargo, esta base de datos tiene muchos otros usos. -Si buscas aumentar aún más la seguridad por medio de otras herramientas, te aconsejo que leas la siguiente guía, [Apache Hardened Web Server guide](../web/apache_hardened_webserver/index.md). +Si quieres aumentar aún más la seguridad por medio de otras herramientas, te aconsejo que leas la siguiente guía, [Apache Hardened Web Server guide](../web/apache_hardened_webserver/index.md). -### Instalando mariadb-server +## Instalar el servidor de MariaDB -Necesitamos primero instalar _mariadb-server_: +Es necesario instalar _mariadb-server_: `dnf install mariadb-server` -### Asegurando mariadb-server +## Proteger el servidor de MariaDB -Para fortalecer la seguridad en _mariadb-server_ necesitamos primero habilitar el servicio: +Para reforzar la seguridad de _mariadb-server_ necesitamos ejecutar un script, pero antes de hacerlo, necesitamos habilitar e iniciar mariadb: `systemctl enable mariadb` -Y luego inicializarlo: +Y después: `systemctl start mariadb` -Para finalmente ingresar este comando: +A continuación, ejecuta el siguiente comando: `mysql_secure_installation` -Del cual saldrá este dialogo: +!!! Sugerencia + + La versión de mariadb-server que viene habilitada por defecto en Rocky Linux 8.5 es 10.3.32. Puede instalar la versión 10.5.13 activando el módulo: + + ``` + dnf module enable mariadb:10.5 + ``` + -```bash + Y a continuación instalando `mariadb`. A partir de la versión 10.4.6 de MariaDB, hay comandos específicos de MariaDB disponibles que puedes utilizar en lugar de los antiguos comandos prefijados de `mysql`. Entre ellos se incluye también la anteriormente mencionada `mysql_secure_installation` que ahora se puede llamar con la versión de MariaDB `mariadb-secure-installation`. + +Esto hace aparecer el siguiente cuadro de diálogo: + +``` NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB SERVERS IN PRODUCTION USE! PLEASE READ EACH STEP CAREFULLY! @@ -47,53 +66,54 @@ password for the root user. If you've just installed MariaDB, and you haven't set the root password yet, the password will be blank, so you should just press enter here. -Enter current password for root (enter for none): +Enter current password for root (enter for none): ``` -Al ser una instalación limpia, no hay una contraseña establecida: Por lo que tenés que presionar "Enter". Y te va a salir este dialogo: +Puesto que se trata de una instalación totalmente nueva, no existe una contraseñas de root establecida. Así que aquí basta con pulsar la tecla 'Enter'. + +La siguiente parte del diálogo continúa: -```bash +``` OK, successfully used password, moving on... Setting the root password ensures that nobody can log into the MariaDB root user without the proper authorisation. -Set root password? [Y/n] +Set root password? [Y/n] ``` -Lo que sí, siempre _deberías_ tener un gestor de contraseñas. Donde podés guardarla y pedirla cuando sea necesario. -Teclea "Y" y luego presiona "Enter", después de eso ingresa la contraseña y verifícala. +Absolutamente _ necesitas tener_ una contraseña de root establecida. Deberás averiguar cuál quieres utilizar y guardarla en un gestor de contraseñas en algún sitio para que puedas recurrir a él si es necesario. Presiona la tecla 'Enter' para aceptar el valor predeterminado "Y". Esto mostrará el cuadro de diálogo de contraseñas: -```bash -New password: +``` +New password: Re-enter new password: ``` -Si todo está bien, te aparecerá este mensaje: +Teclea la contraseña que has elegido y confirmala la contraseña tecleando nuevamente. Si todo va bien, verá el siguiente diálogo: -```bash +``` Password updated successfully! Reloading privilege tables.. ... Success! ``` -El siguiente mensaje trata sobre los usuarios anónimos, del cual seleccionamos "Y" y tecleamos "Enter": +A continuación el diálogo trata sobre el usuario anónimo: -```bash +``` By default, a MariaDB installation has an anonymous user, allowing anyone to log into MariaDB without having to have a user account created for them. This is intended only for testing, and to make the installation go a bit smoother. You should remove them before moving into a production environment. -Remove anonymous users? [Y/n] +Remove anonymous users? [Y/n] ``` -El siguiente dialogo básicamente te está preguntando si querés que el usuario "root" pueda loguearse remotamente. +La respuesta aquí es "Y", por lo que simplemente pulse la tecla 'Enter' para aceptar el valor por defecto. -El usuario "root" solo debe ser usado de manera local. Así que presiona "Y" y luego "Enter". +El diálogo continúa a la sección que trata sobre permitir o no al usuario root iniciar sesión de forma remota: -```bash +``` ... Success! Normally, root should only be allowed to connect from 'localhost'. This @@ -102,9 +122,11 @@ ensures that someone cannot guess at the root password from the network. Disallow root login remotely? [Y/n] ``` -El dialogo siguiente indica que _mariadb-server_ inicia con la base de datos "test" automáticamente para usos de prueba, del cual seleccionamos "Y" y presionamos "Enter". +El usuario "root" solo se debe utilizar de manera local. Por lo tanto, puedes aceptar también este valor por defecto pulsando la tecla 'Enter'. + +El diálogo se mueve a la base de datos 'test' que se instala automáticamente con _mariadb-server_: -```bash +``` ... Success! @@ -112,12 +134,14 @@ By default, MariaDB comes with a database named 'test' that anyone can access. This is also intended only for testing, and should be removed before moving into a production environment. -Remove test database and access to it? [Y/n] +Remove test database and access to it? [Y/n] ``` -Finalmente, el último dialogo va pedirte si querés recargar los privilegios: +Una vez más, la respuesta aquí es el valor por defecto, así que pulse la tecla 'Enter' para eliminarlo. + +Finalmente, el diálogo le preguntará si quieres recargar los privilegios: -```bash +``` - Dropping test database... ... Success! - Removing privileges on test database... @@ -126,12 +150,12 @@ Finalmente, el último dialogo va pedirte si querés recargar los privilegios: Reloading the privilege tables will ensure that all changes made so far will take effect immediately. -Reload privilege tables now? [Y/n] +Reload privilege tables now? [Y/n] [Y/n] ``` -De nuevo, tecleamos "Y" y presionamos "Enter" y si todo va bien, deberías recibir este mensaje: +Una vez más, basta con pulsar "Enter" para hacerlo. Si todo va bien, deberías recibir este mensaje: -```bash +``` ... Success! Cleaning up... @@ -142,10 +166,35 @@ installation should now be secure. Thanks for using MariaDB! ``` -Con esto, MariaDB debería estar listo para su uso. +MariaDB debería estar listo para su uso. + +### Cambios en Rocky Linux 9.0 + +Rocky Linux 9.0 utiliza `mariadb-server-10.5.13-2` como versión predeterminada del servidor mariadb. A partir de la versión 10.4.3, se activa automáticamente un nuevo plugin en el servidor que cambia el cuadro de diálogo `mariadb-secure-installation`. Este plugin permite la autenticación mediante `unix-socket`. En [este artículo](https://mariadb.com/kb/en/authentication-plugin-unix-socket/) se explica detalladamente esta nueva característica. Esencialmente, mediante la autenticación con `unix-socket` se utilizan las credenciales del usuario conectado para acceder a la base de datos. Esto lo que hace es que si el usuario root, por ejemplo, inicia sesión y luego utiliza `mysqladmin` para crear o eliminar una base de datos (o cualquier otra función) no se necesite una contraseña para acceder a ella. Esto tambien sirve para `mysql`. Lo que también significa que no hay contraseña que se pueda comprometer de manera remota. Esto depende de la seguridad de los usuarios configurados en el servidor para toda la protección de la base de datos. + +El segundo diálogo que se muestra durante la instalación de `mariadb-secure-installation` después de configurar la contraseña para el usuario administrador es: + +``` +Switch to unix_socket authentication Y/n +``` + +Obviamente, el valor por defecto aquí es "Y", pero incluso si usted responde "n", con el plugin habilitado, no se solicitará la contraseña para el usuario, al menos no desde la interfaz de línea de comandos. Puede especificar o no la contraseña y ambas opciones funcionan: + +``` +mysql + +MariaDB [(none)]> +``` + +``` +mysql -p +Enter password: + +MariaDB [(none)]> +``` -## Conclusiones +Para obtener más información sobre esta función, consulte el enlace anterior. Hay una forma de desactivar este plugin y volver a tener la contraseña como un campo requerido, que también se detalla en ese enlace. -Antes que arranquemos la base de datos en la etapa de producción, es una buena idea blindar la seguridad de la misma. +## Conclusión -Un servidor de base de datos, como _mariadb-server_, puede ser usado para muchos propósitos. Más allá del uso que tiene debido al CMS de Wordpress. Antes de pasar a la etapa de producción, una buena práctica es fortalecer la seguridad de la base de datos. \ No newline at end of file +Un servidor de base de datos, como _mariadb-server_, puede ser utilizado para muchos propósitos. Debido a la popularidad de Wordpress CMS, se encuentra a menudo en los servidores web. Sin embargo, antes de ejecutar la base de datos en producción, es una buena idea reforzar su seguridad. diff --git a/docs/guides/editors/micro.es.md b/docs/guides/editors/micro.es.md new file mode 100644 index 0000000000..8f1fb66e69 --- /dev/null +++ b/docs/guides/editors/micro.es.md @@ -0,0 +1,85 @@ +--- +title: micro +author: Ezequiel Bruni +contributors: Steven Spencer +tested version: 8.5 +tags: + - editor + - editores + - micro +--- + +# Instalar micro en Rocky Linux + +## Introducción + +*[micro](https://micro-editor.github.io)* es un fantástico editor de texto basado en terminal que se encuentra entre *nano* y *vim* en términos de complejidad. Posee un flujo de trabajo sencillo y fácil de reconocer con características increibles: + +* Todos los comandos habituales como “Control-C”, ”Control-V” y “Control-F” funcionan tal y como lo harían en un editor de texto basado en el escritorio. Por supuesto, todas las combinacions de teclado se pueden volver a definir. +* Soporte para el ratón — haga clic y arrastre para seleccionar el texto, haga doble clic para seleccionar laspalabras o haga incluso triple-clic para seleccionar líneas. +* Más de 75 lenguajes soportados con resaltado de sintaxis por defecto. +* Cuando necesite editar múltiples líneas a la vez dispone de múltiples cursores. +* Incluye un sistema de complementos. +* Varios paneles. + +Y así es como se ve en mi propio terminal: + +![Una captura de pantalla del editor de micro texto](images/micro-text-editor.png) + +!!! Aviso + + *Puede* instalar micro a través de una aplicación Snap. Si ya está utilizando snap en su máquina... Quiero decir... ¿por qué no? Pero yo prefiero hacerlo directamente desde su origen. + +## Requisitos previos + +* Una máquina o contenedor ejecutando Rocky Linux y conectado a Internet. +* Conocimiento básico de la línea de comandos, y el deseo de editar su texto allí. +* Algunos comandos tienen que ejecutarse como root, o con `sudo`. + +### Cómo instalar micro + +Este es quizás el tutorial más fácil que he escrito hasta ahora, con exactamente tres comandos. Primero, asegúrese de que los programas *tar* y *curl* estén instalados. Esto sólo debería ser relevante si está ejecutando una instalación mínima de Rocky, o ejecutándolo dentro de un contenedor. + +```bash +sudo dnf install tar curl +``` + +A continuación, necesitará el instalador que puede descargar desde la página web de *micro*. El siguiente comando descargará el instalador y lo ejecutará en el directorio en el que se encuentre en el momento de ejecutarlo. Normalmente no aconsejamos copiar y pegar comandos desde sitios web, pero éste nunca me ha dado ningún problema. + +```bash +curl https://getmic.ro | bash +``` + +Para instalar la aplicación en todo el sistema (y así puedes simplemente escribir "micro" para abrir la aplicación), puede ejecutar el script como el usuario root dentro de la carpeta `/usr/bin/`. Sin embargo, si quiere probarlo y revisarlo primero, puedes instalar el *micro* en cualquier carpeta que quieras, y luego mover la aplicación más adelante ejecutando el comando que se muestra a continuación: + +```bash +sudo mv micro /usr/bin/ +``` + +¡Y eso es todo! Feliz edición de texto. + +### La forma realmente fácil + +He creado un sencillo script que básicamente ejecuta todos los comandos anteriores. Puede encontrarlo en mi gist de[ Github](https://gist.github.com/EzequielBruni/0e29f2c0a63500baf6fe9e8c51c7b02f). Copie y pegue el texto a un archivo en su máquina, o descargalo mediante la aplicación `wget`. + +## Desinstalar micro + +Vaya a la carpeta en la que instaló *micro* y (usando sus poderes de root divinamente según sea necesario) ejecute: + +```bash +rm micro +``` + +Probablemente *micro* dejará algunos archivos de configuración en su directorio principal (y en los directorios de inicio de cada usuario que lo haya ejecutado). Puedes deshacerse de ellos ejecutando: + +```bash +rm -rf /home/[username]/.config/micro +``` + +## Conclusión + +Si quiere una guía completa para utilizar *micro*, eche un vistazo a su [sitio web principal](https://micro-editor.github.io), y a la documentación que se encuentra en el repositorio disponible en [Github](https://github.com/zyedidia/micro/tree/master/runtime/help). También puede presionar “Control-G” para abrir el archivo de ayuda principal dentro de la aplicación. + +Probablemente *micro* no satisfaga las necesidades de aquellos disfruten la experiencia de utilizar *vim* o *emacs* pero es perfecto para personas como yo. Siempre he querido disfrutar de esa antigua experiencia de Sublime Text en el terminal, y ahora tengo algo <0>realmente parecido. + +Pruébelo, y compruebe si funciona para usted. diff --git a/docs/guides/file_sharing/glusterfs.es.md b/docs/guides/file_sharing/glusterfs.es.md new file mode 100644 index 0000000000..a7e2200b52 --- /dev/null +++ b/docs/guides/file_sharing/glusterfs.es.md @@ -0,0 +1,341 @@ +--- +title: Cluster de almacenamiento con GlusterFS +author: Antoine Le Morvan +contributors: Steven Spencer +update: 11-Feb-2022 +--- + +# Clúster de alta disponibilidad con GlusterFS + +## Requisitos previos + +* Dominio de un editor de línea de comandos (en este ejemplo utilizamos _vi_) +* Un alto nivel de comodidad en la ejecución de comandos desde el terminal, la visualización de registros y otras tareas de caracter genérico dentro de la administración de sistemas +* Todos los comandos se ejecutan como el usuario root o sudo + +## Introduction + +GlusterFS es un sistema de archivos distribuido. + +Permite almacenar gran cantidad de datos distribuidos entre clústeres de servidores con una disponibilidad muy alta. + +Se compone de una parte del servidor que se instalará en todos los nodos de los clústeres del servidor. + +Los clientes pueden acceder a los datos mediante el comando `glusterfs` o `mount`. + +GlusterFS puede trabajar en dos modos diferentes: + + * Modo replicado: Cada nodo del cluster tiene todos los datos. + * modo distribuido: no hay redundancia de datos. Si un nodo de almacenamiento falla, se perderán los datos almacenados en ese nodo. + +Los dos modos pueden utilizarse conjuntamente para proporcionar un sistema de archivos replicado así como un sistema de archivos distribuido, siempre y cuando se disopnga del número correcto de servidores. + +Los datos se almacenan dentro de los bloques. + +> Un bloque es la unidad básica de almacenamiento en GlusterFS, representada por un directorio de exportación en un servidor dentro del grupo de almacenamiento de confianza. + +## Plataforma de prueba + +Nuestra plataforma ficticia está compuesta por dos servidores y un cliente, todos son servidores Rocky Linux. + +* Primer nodo: node1.cluster.local - 192.168.1.10 +* Segundo nodo: node2.cluster.local - 192.168.1.11 +* Client1: client1.clients.local - 192.168.1.12 + +!!! Note + + Asegúrese de tener el ancho de banda necesario entre los servidores del clúster. + +Cada servidor en el clúster tiene un segundo disco para el almacenamiento de datos. + +## Preparación de los discos + +Crearemos un nuevo volumen lógico LVM que será montado en `/data/glusterfs/vol0` en los dos servidores que forman parte del cluster: + +``` +$ sudo pvcreate /dev/sdb +$ sudo vgcreate vg_data /dev/sdb +$ sudo lvcreate -l 100%F-n lv_data vg_data +$ sudo mkfs. fs /dev/vg_data/lv_data +$ sudo mkdir -p /data/glusterfs/volume1 +``` + +!!! Note + + Si LVM no está disponible en sus servidores, simplemente instalelo mediante el siguiente comando: + + ``` + $ sudo dnf install lvm2 + ``` + +Ahora podemos añadir ese volumen lógico al archivo `/etc/fstab`: + +``` +/dev/mapper/vg_data-lv_data /data/glusterfs/volume1 xfs defaults 1 2 +``` + +Y montarlo: + +``` +$ sudo mount -a +``` + +Como los datos se almacenan en un subvolumen llamado brick, podemos crear un directorio en este nuevo espacio de datos dedicado a él: + +``` +$ sudo mkdir /data/glusterfs/volume1/brick0 +``` + +## Instalacion + +En el momento de escribir esta documentación, el repositorio original de almacenamiento SIG de CentOS ya no está disponible y el repositorio de RockyLinux aún no está disponible. + +Sin embargo, usaremos (por el momento) la versión archivada. + +En primer lugar, es necesario añadir el repositorio dedicado a gluster (en versión 9) en ambos servidores: + +``` +sudo dnf install centos-release-gluster9 +``` + +!!! Note + + Posteriormente, cuando esté preparado en el lado de Rocky, podemos cambiar el nombre de este paquete. + +Puesto que la lista de repos y la url ya no están disponibles, cambiremos el contenido del archivo `/etc/yum.repos.d/CentOS-Gluster-9.repo`: + +``` +[centos-gluster9] +name=CentOS-$releasever - Gluster 9 +#mirrorlist=http://mirrorlist.centos.org?arch=$basearch&release=$releasever&repo=storage-gluster-9 +baseurl=https://dl.rockylinux.org/vault/centos/8.5.2111/storage/x86_64/gluster-9/ +gpgcheck=1 +enabled=1 +gpgkey=file:///pki/rpm-gpg/RPM-GPG-KEY-CentOS-SIG-Storage +``` + +Ahora estamos listos para instalar el servidor de glusterfs: + +``` +$ sudo dnf install glusterfs glusterfs-libs glusterfs-server +``` + +## Reglas del firewall + +Se necesitan algunas reglas para que el servicio funcione: + +``` +$ sudo firewall-cmd --zone=public --add-service=glusterfs --permanent +$ sudo firewall-cmd --reload +``` + +o: + +``` +$ sudo firewall-cmd --zone=public --add-port=24007-24008/tcp --permanent +$ sudo firewall-cmd --zone=public --add-port=49152/tcp --permanent +$ sudo firewall-cmd --reload +``` + +## Resolución de nombres + +Puede dejar que el DNS se encargue de la resolución de nombres de los servidores de su cluster, o puede optar por liberar a los servidores de esta tarea insertando registros para cada uno de ellos en sus archivos `/etc/hosts`. Esto mantendrá las cosas funcionando incluso en el caso de un fallo de DNS. + +``` +192.168.10.10 node1.cluster.local +192.168.10.11 node2.cluster.local +``` + +## Iniciando el servicio + +Sin más retrasos, vamos a iniciar el servicio: + +``` +$ sudo systemctl enable glusterfsd.service glusterd.service +$ sudo systemctl start glusterfsd.service glusterd.service +``` + +Estamos listos para unir los dos nodos al mismo grupo. + +Este comando se debe realizar una única vez en un solo nodo (en el nodo 1): + +``` +sudo gluster peer probe node2.cluster.local +peer probe: success +``` + +Verificación: + +``` +node1 $ sudo gluster peer status +Number of Peers: 1 + +Hostname: node2.cluster.local +Uuid: c4ff108d-0682-43b2-bc0c-311a0417fae2 +State: Peer in Cluster (Connected) +Other names: +192.168.10.11 + +``` + +``` +node2 $ sudo gluster peer status +Number of Peers: 1 + +Hostname: node1.cluster.local +Uuid: 6375e3c2-4f25-42de-bbb6-ab6a859bf55f +State: Peer in Cluster (Connected) +Other names: +192.168.10.10 +``` + +Ahora podemos crear un volumen con 2 réplicas: + +``` +$ sudo gluster volume create volume1 replica 2 node1.cluster.local:/data/glusterfs/volume1/brick0/ node2.cluster.local:/data/glusterfs/volume1/brick0/ +Replica 2 volúmenes son propensos a dividir cero. Use Arbiter or Replica 3 to avoid this. See: http://docs.gluster.org/en/latest/Administrator%20Guide/Split%20brain%20and%20ways%20to%20deal%20with%20it/. +Do you still want to continue? + (y/n) y +volume create: volume1: success: please start the volume to access data +``` + +!!! Note + + Como se indica en la salida del comando, un clúster de 2 nodos no es la mejor idea del mundo para evitar un escenario Split Brain. Pero será suficiente para el propósito de nuestra plataforma de pruebas. + +Ahora podemos iniciar el volumen para acceder a los datos: + +``` +$ sudo gluster volume start volume1 + +volume start: volume1: success +``` + +Compruebe el estado del volumen: + +``` +$ sudo gluster volume status +Status of volume: volume1 +Gluster process TCP Port RDMA Port Online Pid +------------------------------------------------------------------------------ +Brick node1.cluster.local:/data/glusterfs/v +olume1/brick0 49152 0 Y 1210 +Brick node2.cluster.local:/data/glusterfs/v +olume1/brick0 49152 0 Y 1135 +Self-heal Daemon on localhost N/A N/A Y 1227 +Self-heal Daemon on node2.cluster.local N/A N/A Y 1152 + +Task Status of Volume volume1 +------------------------------------------------------------------------------ +There are no active volume tasks +``` + +``` +$ sudo gluster volume info + +Volume Name: volume1 +Type: Replicate +Volume ID: f51ca783-e815-4474-b256-3444af2c40c4 +Status: Started +Snapshot Count: 0 +Number of Bricks: 1 x 2 = 2 +Transport-type: tcp +Bricks: +Brick1: node1.cluster.local:/data/glusterfs/volume1/brick0 +Brick2: node2.cluster.local:/data/glusterfs/volume1/brick0 +Options Reconfigured: +cluster.granular-entry-heal: on +storage.fips-mode-rchecksum: on +transport.address-family: inet +nfs.disable: on +performance.client-io-threads: off +``` + +El estado debe ser "Started". + +Ahora podemos restringir un poco el acceso al volumen: + +``` +$ sudo gluster volume set volume1 auth.allow 192.168.10.* +``` + +Así de fácil + +## Acceso desde los clientes + +Hay varias formas de acceder a nuestros datos desde un cliente. + +El método preferido: + +``` +$ sudo dnf install glusterfs-client +$ sudo mkdir /data +$ sudo mount.glusterfs node1.cluster.local:/volume1 /data +``` + +No hay repositorios adicionales para configurar. El cliente ya está presente en los repositorios base. + +Cree un archivo y compruebe que esté presente en todos los nodos del cluster: + +En el cliente: + +``` +sudo touch /data/test +``` + +En ambos servidores: + +``` +$ ll /data/glusterfs/volume1/brick0/ +total 0 +-rw-r--r--. 2 root root 0 Feb 3 19:21 test +``` + +¡Suena bien! Pero, ¿qué pasa si el nodo 1 falla? Es el nodo que se especificó al montar el acceso remoto. + +Vamos a detener el nodo 1: + +``` +$ sudo shutdown -h now +``` + +Comprobar el estado en el nodo 2: + +``` +$ sudo gluster peer status +Number of Peers: 1 + +Hostname: node1.cluster.local +Uuid: 6375e3c2-4f25-42de-bbb6-ab6a859bf55f +State: Peer in Cluster (Disconnected) +Other names: +192.168.10.10 +[antoine@node2 ~]$ sudo gluster volume status +Status of volume: volume1 +Gluster process TCP Port RDMA Port Online Pid +------------------------------------------------------------------------------ +Brick node2.cluster.local:/data/glusterfs/v +olume1/brick0 49152 0 Y 1135 +Self-heal Daemon on localhost N/A N/A Y 1152 + +Task Status of Volume volume1 +------------------------------------------------------------------------------ +There are no active volume tasks +``` + +El node1 está ausente. + +Y en el cliente: + +``` +$ ll /data/test +-rw-r--r--. 1 root root 0 Feb 4 16:41 /data/test +``` + +El archivo ya está ahí. + +Tras la conexión, el cliente de glusterfs recibe una lista con los nodos a los que se puede dirigir, lo que explica el cambio transparente que acabamos de ver. + +## Conclusión + +Aunque no hay repositorios actuales, el uso de los repositorios archivados de tenía para GlusterFS seguirá funcionando. Como se describe, GlusterFS es bastante fácil de instalar y mantener. Utilizar las herramientas de línea de comandos es un proceso bastante sencillo. GlusterFS le ayudará a crear y mantener clústeres de alta disponibilidad para almacenamiento de datos y redundancia. Puede obtener más información sobre GlusterFS y el uso de herramientas en las [páginas oficiales de documentación.](https://docs.gluster.org/en/latest/) diff --git a/docs/guides/interoperability/import_rocky_to_wsl_howto.it.md b/docs/guides/interoperability/import_rocky_to_wsl_howto.it.md new file mode 100644 index 0000000000..8adb78b7a1 --- /dev/null +++ b/docs/guides/interoperability/import_rocky_to_wsl_howto.it.md @@ -0,0 +1,122 @@ +--- +title: Importare in WSL2 con Docker +--- + +# Importare Rocky Linux in WSL2 con Docker + +## Prerequisiti + +O + +* PC Linux con VirtualBox - VirtualBox non funzionerà sotto Windows 10 con WSL2, che è necessario per i passaggi successivi. È anche possibile utilizzare un PC dual boot o una distribuzione live, ma assicurarsi di avere a disposizione VirtualBox. + +Oppure + + +* Docker Desktop per Windows 10 (o qualsiasi installazione di docker) + +Richiesto +* PC Windows 10 con **WSL2** +* Accesso ad Internet + +## Introduzione + +Questa guida mostra i passaggi per creare un'immagine tar per un contenitore Docker e come importare tale immagine in Windows Subsystem for Linux (WSL). I passaggi descritti di seguito sono in gran parte tratti da [Importare qualsiasi distribuzione Linux da usare con WSL](https://docs.microsoft.com/en-us/windows/wsl/use-custom-distro) di Microsoft e da [Creare un'immagine di base](https://docs.docker.com/develop/develop-images/baseimages/) di Docker, e adattati alla nuova distribuzione. + +Si noti che è necessario Virtual Box (per creare il container) **o** Docker per prelevare l'immagine esistente da Docker Hub. Questa guida presuppone che l'utente abbia familiarità con VirtualBox o Docker e sappia come eseguire operazioni come l'installazione delle VirtualBoxAdditions e il montaggio delle unità condivise. + +È inoltre importante conoscere le limitazioni di WSL, che causano l'interruzione di alcune funzionalità, il loro funzionamento lento o in modi inaspettati. A seconda di ciò che si vuole ottenere, la distribuzione risultante può fare o meno ciò che si desidera. Non ci sono garanzie. + +---- + +## Fasi di installazione + +### Ottenere l'Immagine del Container Rocky + +#### Estrarre da Docker Hub (sullo stesso PC in cui è installato WSL2) +1. Da powershell o da un'altra distro WSL2 creare un contenitore rocky usando la versione con cui si vuole iniziare. Sostituire l'etichetta con quella desiderata +```powershell +docker run --name rocky-container rockylinux/rockylinux:8.5 +``` +2. Confermare l'esistenza del container +```powershell +docker container list --all | Select-String rocky-container +``` +3. Esportazione del container come tar +```powershell +docker export rocky-container -o rocky-container.tar +``` + +Nota: non è necessario essere sullo stesso sistema dell'installazione di WSL2, ma è sufficiente essere in grado di portare il file tar nel sistema. + +#### Create il Vostro PC Linux con VirtualBox +1. Scaricare l'immagine minimale da [Rocky Linux](https://rockylinux.org/download). +2. Avviare e installare Rocky Linux su una nuova macchina virtuale VirtualBox. Le impostazioni predefinite vanno bene. +3. Installare VirtualBoxAdditions sulla macchina virtuale. Ciò richiederà l'installazione di pacchetti aggiuntivi (come mostrato nel comando suggerito):
+```bash +$ sudo yum install gcc make kernel-devel bzip2 binutils patch libgomp glibc-headers glibc-devel kernel-headers elfutils-libelf-devel tar + +``` +4. Creare una directory di lavoro e copiare i file da utilizzare per l'immagine tar.
+```bash +$ mkdir wsl_tar +$ cd wsl_tar +$ cp -p /etc/yum.conf . +$ cp -p /etc/yum.repos.d/Rocky-BaseOS.repo . +``` +5. Modificare la *copia* di `yum.conf` e aggiungere questa riga (modificare il percorso come necessario):
+```bash +reposdir=/home//wsl_tar/ +``` +6. Scaricare lo script per creare un'immagine di base da Docker GitHub.
Lo script si chiama [mkimage-yum.sh](https://github.com/moby/moby/blob/master/contrib/mkimage-yum.sh). +7. Modificare lo script per creare un file tar alla fine, invece di avviare Docker. Ecco le modifiche suggerite al file: +```bash +## Change line 143 to simply create the tar file, without invoking Docker +tar --numeric-owner -c -C "$target" . -f + +## Comment out line 145 +``` +8. Eseguire lo script con questo comando (modificare il percorso se necessario):
+```bash +$ sudo ./mkimage-yum.sh -y /home//wsl_tar/yum.conf baseos +``` +9. Al termine dello script, il nuovo file tar si troverà nel percorso inserito nello script precedente. Montare un'unità condivisa con l'host e spostare lì il file tar. + È anche possibile spostare il file in un'unità USB o in una cartella accessibile al PC Windows 10.
Dopo aver spostato il file su un'unità o una cartella esterna, la macchina virtuale non sarà più necessaria. È possibile eliminarla o modificarla per altri scopi. + + +### Importazione in WSL2 +1. Creare una directory per contenere il filesystem Rocky Linux. +2. In un prompt di PowerShell, importate Rocky Linux (qui si chiama `rocky_rc`, ma potete chiamarlo come volete).
+```PowerShell +wsl --import rocky_rc +``` +3. Verificare che Rocky Linux sia installato con:
+```PowerShell +wsl -l -v +``` +4. Avviare Rocky Linux con
+```PowerShell +wsl -d rocky_rc +``` +5. Configurate Rocky Linux con i seguenti comandi bash (dovrete essere in esecuzione come root).
+```bash +yum update +yum install glibc-langpack-en -y +yum install passwd sudo -y +yum reinstall cracklib-dicts -y +newUsername= +adduser -G wheel $newUsername +echo -e "[user]\ndefault=$newUsername" >> /etc/wsl.conf +passwd $newUsername +``` +6. Uscire dal prompt di bash (Ctrl+D o exit). +7. In un prompt di PowerShell, spegnere tutte le istanze WSL in esecuzione e avviare Rocky.
+```PowerShell +wsl --shutdown +wsl -d rocky_rc +``` +8. Provate e divertitevi! + +Se avete installato Windows Terminal, il nome della nuova distro WSL apparirà come opzione nel menu a discesa, il che è molto utile per lanciarla in futuro. È quindi possibile personalizzarlo con colori, caratteri, ecc. + +Anche se è necessario WSL2 per eseguire i passaggi sopra descritti, è possibile utilizzare la distro come WSL 1 o 2, convertendola con i comandi di PowerShell. diff --git a/docs/guides/interoperability/rocky_to_wsl_howto.it.md b/docs/guides/interoperability/rocky_to_wsl_howto.it.md new file mode 100644 index 0000000000..b7129aa5a2 --- /dev/null +++ b/docs/guides/interoperability/rocky_to_wsl_howto.it.md @@ -0,0 +1,108 @@ +--- +title: Importare in WSL con WSL e rinse +--- + +# Importazione di Rocky Linux in WSL con WSL e rinse + +## Prerequisiti +* Un PC Windows 10 con WSL 2 abilitato. (*vedi nota sotto). +* Ubuntu, o qualsiasi distribuzione basata su Debian, installata e funzionante su WSL. Questa guida è stata testata utilizzando Ubuntu 20.04 LTS dal negozio Microsoft. + +## Introduzione +Questa guida è destinata agli utenti Windows che desiderano eseguire Rocky Linux (RL) nel sottosistema Windows per Linux (WSL). Si presuppone che il lettore abbia familiarità con la riga di comando e che WSL sia abilitato e in esecuzione nel proprio PC Windows 10. + +Il processo utilizza `rinse`, uno script perl per creare immagini di distribuzioni che utilizzano il gestore di pacchetti YUM. + +Tenete presente che WSL ha limitazioni e stranezze significative e che la distribuzione risultante può o non può funzionare come ci si aspetta. Potrebbe essere troppo lento o imprevedibile per alcune applicazioni. Con i computer, come nella vita, non ci sono garanzie. + +## Passi + +1. Avviate la vostra distribuzione Ubuntu in WSL, aggiornate il gestore dei pacchetti e installate `rinse`
+```bash +$ sudo apt-get update +$ sudo apt-get install rinse +``` +`rinse` non è a conoscenza di RL, quindi dobbiamo modificare la sua configurazione per aggiungere i repository dei pacchetti e così via. + +2. Copiare il file dei pacchetti di CentOS 8 e prepararlo per RL +```bash +$ sudo cp -p /etc/rinse/centos-8.packages /etc/rinse/rocky-8.packages +``` +3. Modificare il nuovo file e cambiare tutte le voci di 'centos' in 'rocky'. Quindi, aggiungere le seguenti righe. L'ordine nel file non è importante, le voci possono essere aggiunte ovunque. Qui è possibile aggiungere qualsiasi altro pacchetto che si voglia avere nell'immagine (server, utility come `which`, ecc.) +```bash +glibc-langpack-en +libmodulemd +libzstd +passwd +sudo +cracklib-dicts +openssh-clients +python3-dbus +dbus-glib +``` +4. Modificare il file di configurazione di `rinse` in `/etc/rinse/rinse.conf` e aggiungere le seguenti righe, che sono la voce per i mirror RL. Al momento abbiamo un download diretto, ma sarà sostituito da un mirror non appena disponibile. +```bash +# Rocky Linux 8 +[rocky-8] +mirror.amd64 = http://dl.rockylinux.org/pub/rocky/8/BaseOS/x86_64/os/Packages/ +``` +5. Copiare lo script post-installazione per CentOS in modo da poterlo modificare per RL +```bash +$ sudo cp -pR /usr/lib/rinse/centos-8 /usr/lib/rinse/rocky-8 +``` +6. Modificare `/usr/lib/rinse/rocky-8/post-install.sh` e aggiungere le seguenti linee alla riga 14. È necessario assicurarsi che TLS/SSL funzioni come previsto per *YUM* e *dnf*. +```bash +echo " Extracting CA certs..." +$CH /usr/bin/update-ca-trust +``` +7. Modificare lo script `rinse` in `/usr/sbin/rinse` e alla riga 1248 rimuovere il testo `--extract-over-symlinks`. Questa opzione è stata deprecata nel programma chiamato e interrompe lo script. Non chiudere ancora il file. +8. Nello stesso file, andare alla riga 1249 e sostituire "centos" con "rocky". Salvare e chiudere il file. +9. Creare una directory per il nuovo filesystem RL (qualsiasi nome va bene). +```bash +$ mkdir rocky_rc +``` +10. Eseguire `rinse` con il seguente comando +```bash +$ sudo rinse --arch amd64 --directory ./rocky_rc --distribution rocky-8 +``` +11. Dopo che lo script ha completato il download e l'estrazione di tutti i pacchetti, si avrà un file system Rocky Linux completo nella directory creata. Ora è il momento di impacchettarlo per passarlo a Windows e importarlo in una nuova distro WSL. Usare questo comando, creando il file tar in una cartella di Windows (iniziando con `/mnt/c/` o simile per averlo a disposizione per il passaggio successivo). +```bash +$ sudo tar --numeric-owner -c -C ./rocky_rc . -f +``` +12. Chiudere la sessione WSL con Ctrl+D o digitando `exit`. +13. Aprire un prompt di PowerShell (non è necessario essere amministratori) e creare una cartella per contenere la nuova distro RL. +14. Importare il file tar con questo comando: +```PowerShell +wsl --import rocky_rc +``` +Nota: il percorso predefinito di WSL è `%LOCALAPPDATA%`\Packages\`ad esempio per Ubuntu - C:\Users\tahder\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhks2fndhsd\LocalState\rootfs\home\txunil\rocky_rc`` + +15. Nel prompt di PowerShell, avviare la nuova distro con: +```PowerShell +wsl -d rocky_rc +``` +16. Ora siete root nella vostra nuova distro RL. Eseguite questi comandi per completare la configurazione: +```bash +yum update +yum reinstall passwd sudo cracklib-dicts -y +newUsername= +adduser -G wheel $newUsername +echo -e "[user]\ndefault=$newUsername" >> /etc/wsl.conf +passwd $newUsername +``` +17. Uscire dal prompt di bash (Ctrl+D o digitare `exit`). +18. Tornando a PowerShell, spegnete WSL e rilanciate la nuova distro. +```PowerShell +wsl --shutdown +wsl -d rocky_rc +``` +19. Provate e divertitevi! + +## Pulizia +Tutti i pacchetti scaricati sono ancora memorizzati nella distro debian utilizzata all'inizio del processo. È possibile rimuovere i file da `/var/cache/rinse` e cancellare tutti i file dalla cartella `rocky_rc`. La prossima volta che si vuole creare un'immagine nuova, aggiornata o modificata, è sufficiente apportare le modifiche ed eseguire i comandi dal punto 10 in poi. + +## Problemi noti +Ci sono alcune stranezze che derivano dall'estrazione dei pacchetti, anziché dalla loro installazione. L'esecuzione di `yum reinstall` in alcuni pacchetti risolve i problemi, come nel caso di `passwd`. Lo script `rinse` si limita a estrarre i pacchetti e non esegue comandi post-installazione (anche se è in grado di farlo). Se incontrate dei problemi e sapete come risolverli, lasciate dei commenti per gli altri utenti, in modo che altri possano trarre vantaggio dalla vostra esperienza. + +## Note +La maggior parte dello script `rinse` funziona sotto WSL 1, ma l'ultima parte, quella in cui viene invocato `dnf`, ha problemi di memoria e corrompe il database `rpm`. Questo rovina la distro e i tentativi di riparazione falliscono, anche con WSL. Se sapete come far funzionare `dnf` sotto WSL 1, fatecelo sapere, ma ci sono molti problemi di BDB relativi a WSL 1 su diversi forum sul web. WSL 2 ha risolto questi problemi con il kernel Linux nativo. diff --git a/docs/guides/security/enabling_iptables_firewall.it.md b/docs/guides/security/enabling_iptables_firewall.it.md index 08d897076b..5537bbf220 100644 --- a/docs/guides/security/enabling_iptables_firewall.it.md +++ b/docs/guides/security/enabling_iptables_firewall.it.md @@ -1,30 +1,45 @@ -# Abilitazione Firewall iptables +--- +title: Abilitazione del Firewall `iptables` +author: Steven Spencer +contributors: Ezequiel Bruni, Franco Colussi +tested with: 8.5, 8.6, 9.0 +tags: + - security + - iptables + - deprecated +--- + +# Abilitazione del Firewall iptables ## Prerequisiti * Un ardente, inestinguibile desiderio di disabilitare l'applicazione di default _firewalld_ e abilitare _iptables_. +!!! warning "Questo Processo È Deprecato" + + A partire da Rocky Linux 9.0, `iptables` e tutte le utilità ad esso associate sono deprecate. Ciò significa che le future versioni del sistema operativo rimuoveranno `iptables`. Per questo motivo, si consiglia vivamente di non utilizzare questo processo. Se hai familiarità con iptables, ti consigliamo di utilizzare [`iptables` Guida A `firewalld`](firewalld.md). Se sei nuovo ai concetti del firewall, ti consigliamo [`firewalld` per Principianti](firewalld-beginners.md). + ## Introduzione -_firewalld_ è ora il firewall predefinito su Rocky Linux. _firewalld_ **era** nient'altro che un'applicazione dinamica di _iptables_ che utilizzando i file xml caricava le modifiche senza il flushing delle regole in CentOS 7/RHEL 7. Con CentOS 8/RHEL 8/Rocky 8, _firewalld_ è ora un wrapper intorno a _nftables_. È ancora possibile, tuttavia, installare e utilizzare direttamente _iptables_ se questa è la tua preferenza. Per installare ed eseguire direttamente _iptables_ senza _firewalld_ puoi farlo seguendo questa guida. Ciò che questa guida **non ti dirà** è come scrivere le regole per _iptables_. Si presume che se vuoi sbarazzarti di _firewalld_, devi già sapere come scrivere regole per _iptables_. +_firewalld_ è ora il firewall predefinito su Rocky Linux. _firewalld_ **era** nient'altro che un'applicazione dinamica di _iptables_ che utilizzando i file xml caricava le modifiche senza il flushing delle regole in CentOS 7/RHEL 7. Con CentOS 8/RHEL 8/Rocky 8, _firewalld_ è ora un wrapper intorno a _nftables_. È ancora possibile, tuttavia, installare e utilizzare direttamente _iptables_ se questa è la tua preferenza. Per installare ed eseguire direttamente _iptables_ senza _firewalld_ puoi farlo seguendo questa guida. Ciò che questa guida **non** ti dirà è come scrivere le regole per _iptables_. Si presume che se vuoi sbarazzarti di _firewalld_, devi già sapere come scrivere regole per _iptables_. -## Disabilita firewalld +## Disabilitare firewalld Non è possibile eseguire la vecchia utility _iptables_ accanto a _firewalld_. Semplicemente non sono compatibili. Il modo migliore per aggirare questo è disabilitare _firewalld_ interamente (non c'è bisogno di rimuoverlo a meno che tu non lo voglia), e reinstallare le utilità _iptables_. Disabilitare _firewalld_ può essere fatto utilizzando questi comandi: -Stop _firewalld_: +Arrestare _firewalld_: `systemctl stop firewalld` -Disabilita _firewalld_ in modo che non si parta all'avvio: +Disabilitare _firewalld_ in modo che non parta all'avvio: `systemctl disable firewalld` -Maschera il servizio in modo che non possa essere trovato: +Mascherare il servizio in modo che non possa essere trovato: `systemctl mask firewalld` -## Installazione e abilitazione dei servizi iptables +## Installazione e Abilitazione dei Servizi iptables Successivamente abbiamo bisogno di installare i vecchi servizi e le vecchie utility _iptables_. Ciò è fatto con quanto segue: @@ -38,4 +53,4 @@ Ora abbiamo bisogno di abilitare il servizio _iptables_ per assicurarsi che part ## Conclusione -È possibile tornare a utilizzare di seguito _iptables_ se si preferisce al posto di _firewalld_. Puoi tornare a usare il _firewalld_ predefinito semplicemente invertendo queste modifiche. +È possibile ritornare a utilizzare _iptables_ se lo si preferisce al posto di _firewalld_. Puoi tornare a usare il _firewalld_ predefinito semplicemente invertendo queste modifiche. diff --git a/docs/labs/security/index.es.md b/docs/labs/security/index.es.md new file mode 100644 index 0000000000..7598bb4346 --- /dev/null +++ b/docs/labs/security/index.es.md @@ -0,0 +1,70 @@ +--- +title: Listado de laboratorios de seguridad +--- + +# Listado de laboratorios de seguridad + +## [Introducción](introduction.md) + +### Lab 1: Instalación de Rocky Linux + +1. Instalación del sistema operativo + +### Laboratorio 2: Aplicación de parches al sistema + +1. Actualizando y parcheando +1. Configurar y utilizar dnf +1. Soluciones de terceros + +### Laboratorio 3: Comprobar el sistema +1. Un sencillo comprobador de integridad de fabricación casera +1. Tripwire +1. Comprobación de integridad y visualización de informes +1. Afinando Tripwire + +### Laboratorio 4: Recopilar información +1. netstat +1. lsof +1. nmap +1. rpcinfo +1. tcpdump +1. telnet + +### Laboratorio 5: Seguridad local +1. Crackeando el sistema a través del cargador de arranque +1. Proteger con contraseña el cargador de arranque +1. Desactivar TTYs innecesarias +1. Deshabilitar el reinicio mediante CTRL+ALT+DEL +1. Forzar la solicitud de contraseña en modo único de usuario +1. Programas Set-UID +1. John the ripper + +### Laboratorio 6: Un Hack escenificado +1. El PATH + +### Laboratorio 7: TCP wrappers +1. Tcp_wrappers + +### Laboratorio 8: Iptables +1. Fundamentos de Iptables +1. Filtrado básico de paquetes +1. Reenvío básico de paquetes + +### Laboratorio 9: Criptografía +1. GnuPG +1. Administración de claves +1. Revocación de certificados +1. Firmas digitales +1. Encriptar y desencriptar archivos +1. sshd +1. ssh +1. scp +1. Autenticación vía clave pública +1. ssh-agent + +### Laboratorio 10: Seguridad a nivel de Kernel +1. Instalar GRsecurity +1. gradm +1. ACLs +1. Modo de aprendizaje de GRSecurity +1. SELinux diff --git a/docs/labs/security/index.it.md b/docs/labs/security/index.it.md index 9e1329f751..a6b532a979 100644 --- a/docs/labs/security/index.it.md +++ b/docs/labs/security/index.it.md @@ -1,8 +1,8 @@ --- -title: Elenco di Laboratori di Sicurezza +title: Elenco dei Laboratori di Sicurezza --- -# Elenco di Laboratori di Sicurezza +# Elenco dei Laboratori di Sicurezza ## [Introduzione](introduction.md) @@ -12,7 +12,7 @@ title: Elenco di Laboratori di Sicurezza ### Laboratorio 2: Patch del Sistema -1. Aggiornamento e Patch +1. Aggiornamento e Patching 1. Configurare e usare dnf 1. Soluzioni di terze parti @@ -20,7 +20,7 @@ title: Elenco di Laboratori di Sicurezza 1. Un semplice controllo dell'integrità fatto in casa 1. Tripwire 1. Controllo d'integrità e visualizzazione dei rapporti -1. Messa a punto del tripwire +1. Messa a punto di tripwire ### Laboratorio 4: Raccolta delle informazioni 1. netstat @@ -35,20 +35,20 @@ title: Elenco di Laboratori di Sicurezza 1. Proteggere il boot loader con password 1. Disabilitare il tty non necessario 1. Disabilitare il riavvio tramite CTRL+ALT+DEL -1. Imporre la richiesta della password in modalità utente singolo +1. Imporre la richiesta della password in modalità user-mode 1. Programmi Set-UID 1. John the ripper -### Laboratorio 6: Un Hack inscenata -1. Il PERCORSO +### Laboratorio 6: Un Hack in scena +1. Il PATH ### Laboratorio 8: Wrapper TCP 1. Tcp_wrapper ### Laboratorio 8: Iptables -1. Fondamenti delle Iptable -1. Filtraggio di Base del Pacchetto -1. Inoltro di Base del Pacchetto +1. Fondamenti di Iptables +1. Basi sul Filtraggio del Pacchetto +1. Basi sull'Inoltro del Pacchetto ### Laboratorio 9: Criptografia 1. GnuPG @@ -59,10 +59,10 @@ title: Elenco di Laboratori di Sicurezza 1. sshd 1. ssh 1. scp -1. Autenticare tramite Chiave Pubblica +1. Autenticazione tramite chiave pubblica 1. ssh-agent -### Laboratorio 10: Sicurezza del Livello del Kernel +### Laboratorio 10: Sicurezza a livello di kernel 1. Installare GRsecurity 1. gradm 1. ACL diff --git a/docs/labs/security/introduction.es.md b/docs/labs/security/introduction.es.md new file mode 100644 index 0000000000..de729ecdc5 --- /dev/null +++ b/docs/labs/security/introduction.es.md @@ -0,0 +1,19 @@ +--- +title: Introducción +--- + +# Introducción + +Una empresa ficticia (llamada Example Incorporated) es el argumento principal para el diseño de los laboratorios. Example Incorporated tiene oficinas en todo el mundo. Example Incorporated fabrica dispositivos. La empresa cuenta con todos los elementos habituales que una empresa moderna necesita para llevar a cabo su actividad. + +La organización de Example Incorporated posee una red de sucursales, con ordenadores que desempeñan diferentes roles. Algunos ordenadores son estaciones de trabajo, otros son cortafuegos y otros son servidores (servidores de archivos, servidores web, servidores de correo, servidores de bases de datos, servidores de aplicaciones, servidores de marcación, etcetera). + +Y lo más importante para nosotros en este manual: la empresa tiene administradores que administran/gestionan los ordenadores. Tú, el lector, serás el administrador de una de las sucursales. + +Trabajará con un compañero (también administrador) para asegurarse de que los sistemas de la empresa estén en funcionamiento todo el tiempo. Example Incorporated despliega Rocky Linux en sus sistemas porque tiene altos estándares y requisitos para el hardware y el software que utiliza. + +El usuario puede realizar tareas desde la línea de comandos (shell) del sistema operativo Linux. El usuario también puede realizar estas tareas desde la interfaz gráfica de usuario del sistema operativo (GUI). Sin embargo, la mayor parte de nuestro trabajo con este manual, se realizará desde la línea de comandos. + +La idea es que te sientas cómodo trabajando con la línea de comandos, después de lo cual no habrá tarea que no puedas realizar desde la línea de comandos. + +La línea de comandos es una forma rápida de hacer las cosas y también es una de las características de Linux (además del Kernel) que encontrará consistente en su aspecto, y funcionalidad entre las distintas versiones de Linux. diff --git a/docs/labs/security/introduction.it.md b/docs/labs/security/introduction.it.md new file mode 100644 index 0000000000..26b7eaba98 --- /dev/null +++ b/docs/labs/security/introduction.it.md @@ -0,0 +1,19 @@ +--- +title: Introduzione +--- + +# Introduzione + +Una società fittizia (chiamata Example Incorporated) è il soggetto per la progettazione dei laboratori. Example Incorporated ha uffici in tutto il mondo. Example Incorporated crea widget. L'azienda ha tutti i soliti frizzi e lazzi che un'agenzia moderna richiede per condurre il proprio business. + +L'Organizzazione di Esempio ha filiali collegate in rete, con computer che svolgono ruoli diversi. Alcuni computer sono stazioni di lavoro, alcuni firewall, e altri sono server (server di file, web, mail, database, applicazione, dialup, etc.). + +E di maggior importanza significativa per noi in questo manuale, l'azienda fa amministrare/gestire i computer agli amministratori. Tu, il Lettore, sarai l'amministratore di una delle filiali. + +Lavorerai con un partner (anch'egli amministratore) per assicurarti che i sistemi Aziendali funzionino sempre. Example Incorporated distribuisce Rocky Linux sui suoi sistemi perché ha Standard e Requisiti Elevati per Hardware e il Software che usa. + +L'utente può svolgere le mansioni da una riga di comando (shell) del Sistema Operativo di Linux. L'utente può anche svolgerle dall'Interfaccia Utente Grafica (GUI) del Sistema Operativo. Gran parte del nostro lavoro, sarà svolto dalla riga di comando in questo manuale. + +L'idea è farti lavorare comodamente con la riga di comando, dopodiché non potrai eseguire alcun'attività dalla riga di comando. + +La riga di comando è un modo veloce per fare le cose ed è anche una delle funzionalità di Linux (oltre al Kernel) che troverai rimanere coerente nel suo aspetto e nelle funzionalità tra le varie versioni di Linux. diff --git a/docs/release_notes/8-changelog.zh.md b/docs/release_notes/8-changelog.zh.md index 42b1a80f5e..a55da2b9cd 100644 --- a/docs/release_notes/8-changelog.zh.md +++ b/docs/release_notes/8-changelog.zh.md @@ -1,5 +1,5 @@ --- -title: 变更日志 +title: 8的变更日志 author: Louis Abel contributors: tianci li, Steven Spencer tags: diff --git a/docs/release_notes/9_0.it.md b/docs/release_notes/9_0.it.md new file mode 100644 index 0000000000..a73f10b6e3 --- /dev/null +++ b/docs/release_notes/9_0.it.md @@ -0,0 +1,177 @@ +--- +title: Versione corrente 9.0 +tags: + - 9.0 + - 9.0 release + - Rocky 9.0 +--- + +# Note Di Rilascio Per Rocky Linux 9.0 + +## Modifiche Principali + +Per un elenco completo delle principali modifiche, consulta l'elenco a monte [qui](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/9.0_release_notes/overview#overview-major-changes). + +!!! warning "Verificare la Compatibilità della CPU" + + Con Rocky Linux 9.0, alcune vecchie CPU non funzioneranno bene, o forse non funzioneranno affatto. Le seguenti architetture sono considerate i requisiti minimi per la buona riuscita dell'installazione: + + * Architetture AMD e Intel a 64 bit (x86-64-v2) + * L'architettura ARM a 64 bit (ARMv8.0-A) + * IBM Power Systems, Little Endian (POWER9) + * IBM Z a 64 bit (z14) + + Per ulteriori informazioni sulle architetture supportate e sui rischi legati all'uso di quelle non supportate, consultare la nota di rilascio upstream sull'argomento [qui](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/9.0_release_notes/architectures). + +Alcuni punti salienti di questa release sono dettagliati successivamente. + +### Nuovo Sistema di Compilazione (Peridot) + +Rocky Linux 9 è stato costruito con amore con il nostro sistema di build in-house sviluppato e open-source Cloud Native chiamato Peridot. Peridot è stato utilizzato per costruire Rocky Linux 9 per le architetture - x86_64, aarch64, s390x e ppc64le. + +Tra le altre cose, questa versione rappresenta la nostra promessa e l'impegno per la comunità per garantire la longevità del progetto Rocky Linux consentendo agli utenti di costruire, migliorare o riprodurre Rocky Linux da zero indipendentemente. Il codice sorgente per il sistema di compilazione è disponibile [qui](https://github.com/rocky-linux/peridot) + +### Sicurezza + +* L'utilizzo del digest dei messaggi **SHA-1** per scopi crittografici è stato deprecato. Le funzioni di hash crittografico prodotte da SHA-1 non sono più considerate sicure. Ci sono alcune eccezioni, che sono dettagliate nel link dell'upstream sopra. +* **OpenSSL** è arrivato alla versione 3.0.1 con molti miglioramenti, tra cui il concetto di provider, un nuovo schema di versioning, un client HTTP(S) migliorato, il supporto per nuovi protocolli, formati e algoritmi e altro ancora. +* **OpenSSH** è ora la versione 8.7p1 con molti miglioramenti, in particolare la sostituzione del protocollo SCP/RCP con il protocollo SFTP che offre una gestione dei nomi dei file più prevedibile. +* **SELinux** prestazioni, memoria overhead, tempo di caricamento, e molto altro sono stati sostanzialmente migliorati. Ci sono tutta una serie di modifiche con maggiori dettagli nelle note di rilascio nell'upstream. +* Rocky Linux 9 supporta la configurazione automatica delle impostazioni di conformità alla sicurezza per PCI-DSS, HIPAA, DISA e molti altri direttamente tramite l'installatore Anaconda, permettendo di risparmiare tempo e sforzi per soddisfare le complesse esigenze nel panorama di sicurezza in rapida evoluzione. + +### Networking + +Le principali modifiche legate alla rete sono elencate di seguito. Per una copertura dettagliata di queste modifiche e di altre modifiche relative alla rete, visita il link a monte [qui](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/9.0_release_notes/new-features#enhancement_networking). + +* **mptcpd** o MultiPath TCP Daemon, può essere utilizzato al posto di `iproute2` per configurare gli endpoint MultiPath TCP. +* NetworkManager ora utilizza i file chiave per memorizzare i nuovi profili di connessione come predefinito, ma supporta comunque l'uso di `ifcfg`. +* **iptables-nft** e **ipset** sono ora deprecati che includevano le utilities, `iptables`, `ip6tables`, `ebtables`e `arptables`. Questi sono tutti sostituiti dal framework `nftables`. +* il pacchetto **network-scripts** è stato rimosso. Usa NetworkManager per configurare le connessioni di rete. + +### Web e Programmazione + +Diverse suite di programmazione dinamica, controllo di versione e applicazioni web elencate di seguito sono state aggiornate a versioni più recenti in Rocky Linux 9.0. Per un elenco completo delle modifiche e delle descrizioni, consultare [questo link a monte](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/9.0_release_notes/New-features#enhancement_dynamic-programming-languages-web-and-database-servers). + + +#### Programmazione Dinamica + +* **Node.js 16** +* **Perl 5.32** +* **PHP 8.0** +* **Python 3.9** +* **Ruby 3.0** + +#### Controllo di versione + +* **Git 2.31** +* **Subversion 1.14** + +#### Server Web + +* **Server Apache HTTP 2.4.51** +* **nginx 1.20** + +#### Server Di Caching Proxy + +* **Varnish Cache 6.6** +* **Squid 5.2** + +#### Server Database + +* **MariaDB 10.5** +* **MySQL 8.0** +* **PostgreSQL 13** +* **Redis 6.2** + +### Compilatori e Strumenti di Sviluppo + +Per un elenco completo e dettagliato delle modifiche, consultare [questo link a monte](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/9.0_release_notes/New-features#enhancement_compilers-and-development-tools). I punti salienti sono riportati di seguito. + +#### Toolchain Di Sistema + +* **GCC 11.2.1** +* **glibc 2.34** +* **binutils 2.35.2** + +#### Strumenti di Performance e Debug + +* **GDB 10.2** +* **Valgrind 3.18.1** +* **SystemTap 4.6** +* **Dyninst 11.0.0** +* **elfutils 0.186** + +#### Strumenti Di Monitoraggio Delle Prestazioni + +* **PCP 5.3.5** +* **Grafana 7.5.11** + +#### Strumenti Del Compilatore + +* **LLVM Toolset 13.0.1** +* **Rust Toolset 1.58.1** +* **Go Toolset 1.17.7** + +#### Implementazione Java + +Vengono forniti i seguenti ambienti di runtime Java e kit di sviluppo Java: + +* `java-17-openjdk` +* `java-11-openjdk` +* `java-1.8.0-openjdk` + +Vengono forniti i seguenti strumenti Java: + +* **Maven 3.6** +* **Ant 1.10** + +### Virtualizzazione + +Per un elenco completo delle modifiche e dei miglioramenti apportati alla Virtualizzazione, consultate [questo link a monte](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/9.0_release_notes/New-features#enhancement_virtualization). + +I punti salienti sono: + +* QEMU è ora costruito utilizzando il compilatore CLANG, che consente all'Hypervisor KVM di utilizzare una serie di funzioni avanzate di sicurezza e debug. +* vTPM (Virtual Trusted Platform Module) è ora pienamente supportato. +* è stata implementata la funzione `virtiofs`, che può essere utilizzata per condividere in modo più efficiente i file tra un host Rocky Linux e le sue macchine virtuali. +* `cgroup-v2`, che implementa un modello a gerarchia singola, è ora il gruppo di controllo predefinito di Linux nella versione 9.0. Ciò avrà alcune ramificazioni per coloro che utilizzano sistemi basati su container (Docker, Kubernetes, ecc.) Ulteriori informazioni sono disponibili al link sopra indicato. + +## Aggiornamento + +Il team di Rocky Linux non raccomanda l'aggiornamento da una versione principale alla successiva (in questo caso dalla 8.6 alla 9.0). Sebbene sia tecnicamente possibile eseguire l'aggiornamento tra le versioni principali, si consiglia di eseguire una nuova installazione dell'ultima versione principale desiderata. + +## Installazione + +Per installare Rocky Linux 9.0, visitate la [pagina di download](https://rockylinux.org/download/) e scaricate la versione necessaria per la vostra architettura. Una guida completa all'installazione di Rocky Linux 9.0 è disponibile sul [sito web della documentazione di Rocky Linux, qui](https://docs.rockylinux.org/guides/installation/). + +Anche se questo aspetto è trattato nella guida all'installazione (sopra), è importante verificare il download con il CHECKSUM di quel file per assicurarsi che non ci siano corruzioni o manomissioni. È possibile farlo con i seguenti passaggi, supponendo di aver scaricato il file su un'altra macchina che utilizza Linux: + + * Nella directory in cui è stata scaricata l'immagine ISO per l'architettura di destinazione, scaricare anche il file CHECKSUM. Esempio: + + ``` + curl https://download.rockylinux.org/pub/rocky/9/isos/x86_64/CHECKSUM -o CHECKSUM + ``` + + * Quindi, impartite il comando: + + ``` + sha256sum -c CHECKSUM --ignore-missing + ``` + + * Se si ottiene il seguente risultato alla riga di comando, il file è stato verificato. Si noti che stiamo ipotizzando la ISO minimale qui sotto, ma potrebbe essere anche la ISO del DVD: + + ``` + Rocky-8.5-x86_64-minimal.iso: OK + ``` + +In alternativa, è possibile ottenere l'accesso a qualsiasi checksum della versione di Rocky Linux, accedendo al repository [github qui](https://github.com/rocky-linux/checksums). + +## Problemi noti + +Come per ogni release, ci sono problemi già noti. È possibile consultare l'elenco attuale dei problemi nell'upstream [qui](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/9/html/9.0_release_notes/known-issues). + +* **Limitazione all'uso dell'installazione ISO minima**: la maggior parte (se non tutti) i pacchetti relativi alla sicurezza non funzioneranno. Se avete bisogno di profili e pacchetti di sicurezza/SCAP al momento dell'installazione, utilizzate il DVD ISO. + +## Segnala gli errori + +Si prega di segnalare qualsiasi bug riscontrato al [Rocky Linux Bug Tracker](https://bugs.rockylinux.org/). Vi invitiamo inoltre a unirvi alla nostra comunità in qualsiasi modo vogliate, che sia sul nostro [Forum](https://forums.rockylinux.org), su [Mattermost](https://chat.rockylinux.org), su [IRC su Libera.Chat](irc://irc.liberachat/rockylinux), su [Reddit](https://reddit.com/r/rockylinux), sulle [Mailing List](https://lists.resf.org) o in qualsiasi altro modo vogliate partecipare! diff --git a/docs/release_notes/index.it.md b/docs/release_notes/index.it.md new file mode 100644 index 0000000000..75799d75ef --- /dev/null +++ b/docs/release_notes/index.it.md @@ -0,0 +1,12 @@ +--- +title: Note Di Rilascio Rocky +tags: + - release + - release notes +--- + +# Note di rilascio di Rocky Linux + +Benvenuti nel nostro elenco delle note di rilascio e dei changelog di Rocky Linux 8 e Rocky Linux 9. Le note di rilascio delle versioni più recenti sono riportate per prime. + +Se avete domande o commenti, partecipate alla discussione [qui](https://chat.rockylinux.org/rocky-linux/channels/documentation). diff --git a/docs/release_notes/index.zh.md b/docs/release_notes/index.zh.md new file mode 100644 index 0000000000..387b1a0445 --- /dev/null +++ b/docs/release_notes/index.zh.md @@ -0,0 +1,12 @@ +--- +title: Rocky发布说明 +tags: + - release + - release notes +--- + +# Rocky Linux发布说明 + +欢迎来到 Rocky Linux 8 与 Rocky Linux 9 的发布说明和变更日志列表。 您可以找到最新发布版本的发布说明。 + +如果您有任何问题或意见，请加入[这里的](https://chat.rockylinux.org/rocky-linux/channels/documentation)讨论。