diff --git a/docs/guides/cms/mediawiki.it.md b/docs/guides/cms/mediawiki.it.md
new file mode 100644
index 0000000000..73dc7e82a9
--- /dev/null
+++ b/docs/guides/cms/mediawiki.it.md
@@ -0,0 +1,253 @@
+---
+title: MediaWiki
+author: Neel Chauhan
+contributors: Steven Spencer
+tested_with: 10.0
+tags:
+  - cms
+---
+
+## Introduzione
+
+[MediaWiki](https://www.mediawiki.org/wiki/MediaWiki) è un popolare motore software open source per wiki che alimenta siti come Wikipedia, Fandom e wikiHow, tra gli altri.
+
+## Prerequisiti e presupposti
+
+A seguire i requisiti minimi per seguire questa procedura:
+
+- La possibilità di eseguire comandi come utente root o di utilizzare `sudo` per elevare i privilegi
+- Familiarità con un editor a riga di comando. L'autore utilizza `vi` o `vim`, ma è possibile sostituirli con il proprio editor preferito
+
+## Installazione di Apache
+
+Apache è il server web da utilizzare. Installarlo con:
+
+```bash
+dnf -y install httpd
+```
+
+Quindi, aprire le porte del firewall corrispondenti:
+
+```bash
+sudo firewall-cmd --permanent --zone=public --add-service=http
+sudo firewall-cmd --permanent --zone=public --add-service=https
+sudo firewall-cmd --reload
+```
+
+## Installazione di PHP
+
+!!! note
+
+    Se state utilizzando Rocky Linux 8.x o 9.x, sostituite "8" o "9" accanto alla release nella riga di installazione del pacchetto Remi
+
+Per installare PHP, è necessario prima installare EPEL (Extra Packages for Enterprise Linux):
+
+```bash
+dnf -y install epel-release && dnf -y update
+```
+
+È necessario anche il repository Remi. Installarlo con quanto segue:
+
+```bash
+dnf install https://rpms.remirepo.net/enterprise/remi-release-10.rpm
+```
+
+Quindi installare PHP e i moduli necessari:
+
+```bash
+dnf install -y dnf install php84-php-fpm php84-php-intl php84-php-mbstring php84-php-apcu php84-php-curl php84-php-mysql php84-php-xml
+```
+
+Abilitare PHP con:
+
+```bash
+systemctl enable --now php84-php-fpm.service
+```
+
+## Installazione di MariaDB
+
+Per il database è necessario MariaDB. Installarlo con:
+
+```bash
+dnf install mariadb-server
+```
+
+Quindi abilitate il servizio `systemd` ed eseguite la configurazione guidata:
+
+```bash
+systemctl enable --now mariadb
+mysql_secure_installation
+```
+
+Quando viene richiesta la password di root, premere ++enter++ :
+
+```bash
+Enter current password for root (++enter++ for none):
+```
+
+Rispondere ++"n"++ all'autenticazione `unix_socket`:
+
+```bash
+Switch to unix_socket authentication [Y/n] n
+```
+
+Rispondere ++"Y"++ per cambiare la password di root e inserire la password di root necessaria:
+
+```bash
+Change the root password? [Y/n] Y
+New password: 
+Re-enter new password: 
+```
+
+Rimuovere gli utenti anonimi e disabilitare i login remoti di `root`:
+
+```bash
+Remove anonymous users? [Y/n] Y
+...
+Disallow root login remotely? [Y/n] Y
+```
+
+Rimuovere l'accesso al database di prova e ricaricare le tabelle dei privilegi:
+
+```bash
+Remove test database and access to it? [Y/n] Y
+...
+Reload privilege tables now? [Y/n] Y
+```
+
+Accedere a MariaDB con:
+
+```bash
+mysql -u root -p
+```
+
+Inserire la password di root creata in precedenza.
+
+Nella console di MariaDB, creare il database per MediaWiki:
+
+```bash
+MariaDB [(none)]> create database mediawiki;
+```
+
+Quindi, creare l'utente MediaWiki:
+
+```bash
+MariaDB [(none)]> create user 'mediawiki'@'localhost' identified by 'nchauhan11';
+```
+
+Concedere i privilegi sul database MediaWiki:
+
+```bash
+grant all privileges on mediawiki.* to 'mediawiki'@'localhost';
+```
+
+Infine, svuotare i privilegi con:
+
+```bash
+MariaDB [(none)]> flush privileges;
+```
+
+## Installazione di MediaWiki
+
+Andare nella directory `/var/www/` e scaricare MediaWiki:
+
+```bash
+cd /var/www/
+wget https://releases.wikimedia.org/mediawiki/1.44/mediawiki-1.44.0.zip
+```
+
+Decomprimere e spostare MediaWiki:
+
+```bash
+unzip mediawiki-1.44.0.zip
+mv mediawiki-1.44.0/* html/
+```
+
+Impostare i permessi SELinux corretti:
+
+```bash
+chown -R apache:apache /var/www/html
+semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html(/.*)?"
+restorecon -Rv /var/www/html
+```
+
+Abilitare Apache:
+
+```bash
+systemctl enable --now httpd
+```
+
+Quindi, aprire un browser su `http://your_ip` (sostituire `il your_ip` con il vostro indirizzo IP):
+
+![MediaWiki Initial Setup](../images/mediawiki_1.png)
+
+Selezionare la lingua e fare clic su **Continua**:
+
+![MediaWiki Language Page](../images/mediawiki_2.png)
+
+Verificare che la configurazione di PHP sia corretta, scorrere verso il basso e fare clic su **Continua**:
+
+![MediaWiki PHP Checks](../images/mediawiki_3.png)
+
+A questo punto, inserite le informazioni del database come segue:
+
+- **Database host**: `localhost`
+
+- **Database name (senza trattini)**: `mediawiki` (o il database creato nel passo **MariaDB**)
+
+- **Database username:**: `mediawiki` (o l'utente creato nella fase **MariaDB**)
+
+- **Database password**: La password creata nella fase **MariaDB**
+
+![MediaWiki Database Information](../images/mediawiki_4.png)
+
+Fare clic su **Continua**:
+
+![MediaWiki Database Access Settings](../images/mediawiki_5.png)
+
+Nella pagina **Installazione della versione MediaWiki**, inserisci quanto segue:
+
+- **URL host name**: L'URL desiderato
+
+- **Name of wiki**: Il nome del Wiki desiderato
+
+- **Administrator account**/**Your username**: Il nome utente dell'amministratore che si desidera utilizzare
+
+- **Administrator account**/**Password (di nuovo)**: La password di amministrazione che si desidera utilizzare
+
+- **Administrator account**/**Email address**: L'indirizzo e-mail dell'utente amministratore
+
+Facoltativamente, è possibile selezionare **Fammi altre domande** per perfezionare il Wiki. Per semplicità, selezionare **Sono già annoiato, basta installare il wiki** e fare clic su **Continua**:
+
+![MediaWiki Wiki Information](../images/mediawiki_6.png)
+
+Fare clic su **Continua** per installare il Wiki:
+
+![MediaWiki Install Step Part 1](../images/mediawiki_7.png)
+
+MediaWiki imposterà i database. Al termine, fare clic su **Continua**:
+
+![MediaWiki Install Step Part 2](../images/mediawiki_8.png)
+
+Il browser scaricherà un file `LocalSettings.php`. Si caricherà il file sul server con `sftp`.
+
+A titolo di esempio, l'autore utilizzerà il proprio portatile Fedora 42 per caricare questo file. Per farlo:
+
+```bash
+sftp root@your_ip
+(Enter password)
+cd /var/www/html
+put LocalSettings.php 
+```
+
+![MediaWiki LocalSettings.php Step](../images/mediawiki_9.png)
+
+Infine, fare clic su **inserisci il tuo wiki**:
+
+![Fresh MediaWiki Wiki](../images/mediawiki_10.png)
+
+Ora avete una nuova installazione di MediaWiki.
+
+## Conclusione
+
+Sebbene MediaWiki sia noto soprattutto per aver alimentato Wikipedia, è utile come sistema di gestione dei contenuti quando gli utenti devono poter modificare le pagine. MediaWiki è una buona alternativa open source a SharePoint di Microsoft.
diff --git a/docs/labs/kubernetes-the-hard-way/lab1-prerequisites.it.md b/docs/labs/kubernetes-the-hard-way/lab1-prerequisites.it.md
new file mode 100644
index 0000000000..4458562988
--- /dev/null
+++ b/docs/labs/kubernetes-the-hard-way/lab1-prerequisites.it.md
@@ -0,0 +1,43 @@
+---
+author: Wale Soyinka
+contributors: Steven Spencer, Ganna Zhyrnova
+tags:
+  - kubernetes
+  - k8s
+  - lab exercise
+---
+
+# Laboratorio 1: Prerequisiti
+
+!!! info
+
+    Si tratta di un fork dell'originale ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way) scritto originariamente da Kelsey Hightower (GitHub: kelseyhightower). A differenza dell'originale, che si basa su distribuzioni simili a Debian per l'architettura ARM64, questo fork si rivolge a distribuzioni Enterprise Linux come Rocky Linux, che gira su architettura x86_64.
+
+In questo laboratorio verranno esaminati i requisiti della macchina necessari per seguire questa esercitazione.
+
+## Macchine virtuali o fisiche
+
+Questa esercitazione richiede quattro (4) macchine virtuali o fisiche x86_64 con Rocky Linux 9.5 (anche i container Incus o LXD dovrebbero funzionare). La tabella seguente elenca le quattro macchine e i relativi requisiti di CPU, memoria e storage.
+
+| Nome    | Descrizione            | CPU | RAM   | Storage |
+| ------- | ---------------------- | --- | ----- | ------- |
+| jumpbox | Host amministrativo    | 1   | 512MB | 10GB    |
+| server  | Kubernetes server      | 1   | 2GB   | 20GB    |
+| node-0  | Nodo worker Kubernetes | 1   | 2GB   | 20GB    |
+| node-1  | Nodo worker Kubernetes | 1   | 2GB   | 20GB    |
+
+La modalità di provisioning delle macchine è a vostra discrezione; l'unico requisito è che ogni macchina soddisfi i requisiti di sistema sopra indicati, comprese le specifiche della macchina e la versione del sistema operativo. Una volta che tutte e quattro le macchine sono state messe a disposizione, verificare i requisiti di sistema eseguendo il comando `uname` su ogni macchina:
+
+```bash
+uname -mov
+```
+
+Dopo aver eseguito il comando `uname`, si dovrebbe vedere il seguente risultato:
+
+```text
+#1 SMP PREEMPT_DYNAMIC Wed Feb 19 16:28:19 UTC 2025 x86_64 GNU/Linux
+```
+
+L'indicazione `x86_64` nell'output conferma che il sistema è un'architettura x86_64. Questo dovrebbe essere il caso di vari sistemi basati su AMD e Intel.
+
+Successivo: [setting-up-the-jumpbox](lab2-jumpbox.md)
diff --git a/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.de.md b/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.de.md
new file mode 100644
index 0000000000..91af0fe898
--- /dev/null
+++ b/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.de.md
@@ -0,0 +1,126 @@
+---
+author: Wale Soyinka
+contributors: Steven Spencer, Ganna Zhyrnova
+tags:
+  - kubernetes
+  - k8s
+  - Laborübung
+---
+
+# Übung 2: Einrichten der Jumpbox
+
+!!! info
+
+    Dies ist ein Fork des ursprünglichen ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way), das ursprünglich von Kelsey Hightower geschrieben wurde (GitHub: kelseyhightower). Im Gegensatz zum Original, das auf Debian-ähnlichen Distributionen für die ARM64-Architektur basiert, zielt dieser Fork auf Enterprise-Linux-Distributionen wie Rocky Linux ab, das auf der x86_64-Architektur läuft.
+
+In diesem Labor richten Sie eine der vier Maschinen als „Jumpbox“ ein. Sie werden diese Maschine verwenden, um in diesem Tutorial Befehle auszuführen. Obwohl zur Gewährleistung der Konsistenz eine dedizierte Maschine verwendet wird, können Sie diese Befehle von nahezu jeder Maschine aus ausführen, einschließlich Ihrer persönlichen Workstation mit macOS oder Linux.
+
+Stellen Sie sich die `jumpbox` als die Verwaltungsmaschine vor, die Sie als Basis verwenden, wenn Sie Ihren Kubernetes-Cluster von Grund auf einrichten. Bevor Sie beginnen, müssen Sie einige Befehlszeilenprogramme installieren und das Git-Repository `Kubernetes The Hard Way` klonen. Dieses enthält einige zusätzliche Konfigurationsdateien, die Sie im Verlauf dieses Lernprogramms zum Konfigurieren verschiedener Kubernetes-Komponenten verwenden werden.
+
+Melden Sie sich bei der `jumpbox` an:
+
+```bash
+ssh root@jumpbox
+```
+
+Der Einfachheit halber führen Sie alle Befehle als `root`-Benutzer aus, wodurch die Anzahl der zum Einrichten erforderlichen Befehle reduziert wird.
+
+## Installation der Command Line Utilities
+
+Sobald Sie sich als `root`-Benutzer bei der `jumpbox`-Maschine angemeldet haben, installieren Sie die Befehlszeilenprogramme, die Sie im Verlauf des Lernprogramms zum Ausführen verschiedener Aufgaben verwenden werden:
+
+```bash
+sudo dnf -y install wget curl vim openssl git
+```
+
+## Synchronisation der GitHub-Repository
+
+Jetzt ist es an der Zeit, eine Kopie dieses Tutorials herunterzuladen, das die Konfigurationsdateien und Vorlagen enthält, die Sie zum Erstellen Ihres Kubernetes-Clusters von Grund auf verwenden werden. Klonen Sie das `Kubernetes The Hard Way`-Git-Repository mit dem Befehl `git`:
+
+```bash
+git clone --depth 1 \
+  https://github.com/wsoyinka/kubernetes-the-hard-way.git
+```
+
+Wechseln Sie in das Verzeichnis `kubernetes-the-hard-way`:
+
+```bash
+cd kubernetes-the-hard-way
+```
+
+Dies wird das Arbeitsverzeichnis für den Rest des Tutorials sein. Wenn Sie einmal nicht weiterkommen, führen Sie den Befehl `pwd` aus, um zu überprüfen, ob Sie sich im richtigen Verzeichnis befinden, wenn Sie Befehle auf der `jumpbox` ausführen:
+
+```bash
+pwd
+```
+
+```text
+/root/kubernetes-the-hard-way
+```
+
+## Herunterladen der Binaries
+
+Hier laden Sie die Binärdateien für die verschiedenen Kubernetes-Komponenten herunter. Speichern Sie diese Binärdateien im Verzeichnis `Downloads` auf der `jumpbox`. Dadurch wird die zum Abschließen dieses Lernprogramms erforderliche Internetbandbreite reduziert, da Sie die Binärdateien nicht für jede Maschine in unserem Kubernetes-Cluster mehrmals herunterladen müssen.
+
+Die Datei `download.txt` listet die Binärdateien auf, die Sie herunterladen werden. Sie können diese mit dem Befehl `cat` überprüfen:
+
+```bash
+cat downloads.txt
+```
+
+Laden Sie die in der Datei `downloads.txt` aufgeführten Binärdateien mit dem Befehl `wget` in ein Verzeichnis namens `downloads` herunter:
+
+```bash
+wget -q --show-progress \
+  --https-only \
+  --timestamping \
+  -P downloads \
+  -i downloads.txt
+```
+
+Abhängig von der Geschwindigkeit Ihrer Internetverbindung kann das Herunterladen der `584` Megabyte Binärdateien eine Weile dauern. Sobald der Download abgeschlossen ist, können Sie sie mit dem Befehl `ls` auflisten:
+
+```bash
+ls -loh downloads
+```
+
+```text
+total 557M
+-rw-r--r--. 1 root 51M Jan  6 11:13 cni-plugins-linux-amd64-v1.6.2.tgz
+-rw-r--r--. 1 root 36M Feb 28 14:09 containerd-2.0.3-linux-amd64.tar.gz
+-rw-r--r--. 1 root 19M Dec  9 04:16 crictl-v1.32.0-linux-amd64.tar.gz
+-rw-r--r--. 1 root 17M Feb 25 14:19 etcd-v3.4.36-linux-amd64.tar.gz
+-rw-r--r--. 1 root 89M Dec 11 16:12 kube-apiserver
+-rw-r--r--. 1 root 82M Dec 11 16:12 kube-controller-manager
+-rw-r--r--. 1 root 55M Dec 11 16:12 kubectl
+-rw-r--r--. 1 root 74M Dec 11 16:12 kubelet
+-rw-r--r--. 1 root 64M Dec 11 16:12 kube-proxy
+-rw-r--r--. 1 root 63M Dec 11 16:12 kube-scheduler
+-rw-r--r--. 1 root 11M Feb 13 20:19 runc.amd64
+```
+
+## Installation von `kubectl`
+
+In diesem Abschnitt installieren Sie `kubectl`, das offizielle Befehlszeilentool des Kubernetes-Clients, auf der `jumpbox`-Maschine. Sie werden `kubectl` verwenden, um mit der Kubernetes-Steuerebene zu interagieren, nachdem die Bereitstellung Ihres Clusters später in diesem Tutorial abgeschlossen ist.
+
+Verwenden Sie den Befehl `chmod`, um die Binärdatei `kubectl` ausführbar zu machen und sie in das Verzeichnis `/usr/local/bin/` zu verschieben:
+
+```bash
+  chmod +x downloads/kubectl
+  cp downloads/kubectl /usr/local/bin/
+```
+
+Da Ihre Installation von `kubectl` abgeschlossen ist, können Sie dies überprüfen, indem Sie den Befehl `kubectl` ausführen:
+
+```bash
+kubectl version --client
+```
+
+```text
+Client Version: v1.32.0
+Kustomize Version: v5.5.0
+```
+
+An diesem Punkt haben Sie eine `jumpbox` mit allen Befehlszeilentools und Dienstprogrammen eingerichtet, die zum Abschließen der Übungen in diesem Lernprogramm erforderlich sind.
+
+Fortsetzung folgt: [Provisionierung der Computer-Ressourcen](lab3-compute-resources.md)
diff --git a/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.it.md b/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.it.md
new file mode 100644
index 0000000000..f8bd733d52
--- /dev/null
+++ b/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.it.md
@@ -0,0 +1,126 @@
+---
+author: Wale Soyinka
+contributors: Steven Spencer, Ganna Zhyrnova
+tags:
+  - kubernetes
+  - k8s
+  - lab exercise
+---
+
+# Laboratorio 2: Configurazione della Jumpbox
+
+!!! info
+
+    Si tratta di un fork dell'originale ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way) scritto originariamente da Kelsey Hightower (GitHub: kelseyhightower). A differenza dell'originale, che si basa su distribuzioni simili a Debian per l'architettura ARM64, questo fork si rivolge a distribuzioni Enterprise Linux come Rocky Linux, che gira su architettura x86_64.
+
+In questo laboratorio, si imposterà una delle quattro macchine come `jumpbox`. Questa macchina verrà utilizzata per eseguire i comandi di questa esercitazione. Sebbene venga utilizzato un computer dedicato per garantire la coerenza, è possibile eseguire questi comandi da qualsiasi computer, compresa la propria workstation personale con macOS o Linux.
+
+Considerate la `jumpbox` come la macchina di amministrazione che userete come base per impostare il vostro cluster Kubernetes da zero. Una cosa da fare prima di iniziare è installare alcune utility da riga di comando e clonare il repository git Kubernetes The Hard Way, che contiene alcuni file di configurazione aggiuntivi che verranno utilizzati per configurare vari componenti di Kubernetes nel corso di questo tutorial.
+
+Accedere alla `jumpbox`:
+
+```bash
+ssh root@jumpbox
+```
+
+Per comodità, si eseguiranno tutti i comandi come utente `root`, in modo da ridurre il numero di comandi necessari per la configurazione.
+
+## Installare le utilità della riga di comando
+
+Una volta effettuato l'accesso alla macchina `jumpbox` come utente `root`, si installeranno le utility da riga di comando che verranno utilizzate per eseguire vari compiti nel corso dell'esercitazione:
+
+```bash
+sudo dnf -y install wget curl vim openssl git
+```
+
+## Sincronizzazione del repository GitHub
+
+Ora è il momento di scaricare una copia di questo tutorial, che contiene i file di configurazione e i modelli da utilizzare per costruire il cluster Kubernetes da zero. Clonare il repository git Kubernetes The Hard Way usando il comando `git`:
+
+```bash
+git clone --depth 1 \
+  https://github.com/wsoyinka/kubernetes-the-hard-way.git
+```
+
+Passare alla cartella `kubernetes-the-hard-way`:
+
+```bash
+cd kubernetes-the-hard-way
+```
+
+Questa sarà la directory di lavoro per il resto dell'esercitazione. Se vi perdete, eseguite il comando `pwd` per verificare di essere nella directory corretta quando eseguite i comandi su `jumpbox`:
+
+```bash
+pwd
+```
+
+```text
+/root/kubernetes-the-hard-way
+```
+
+## Scaricare i binari
+
+Qui si scaricano i binari dei vari componenti di Kubernetes. Memorizzare questi file binari nella directory `Downloads` della `jumpbox`. Questo ridurrà la quantità di banda internet necessaria per completare questa esercitazione, in quanto si eviterà di scaricare i binari più volte per ogni macchina del cluster Kubernetes.
+
+Il file `download.txt` elenca i file binari che verranno scaricati, che possono essere esaminati con il comando `cat`:
+
+```bash
+cat downloads.txt
+```
+
+Scaricare i file binari elencati nel file `downloads.txt` in una directory chiamata `downloads` usando il comando `wget`:
+
+```bash
+wget -q --show-progress \
+  --https-only \
+  --timestamping \
+  -P downloads \
+  -i downloads.txt
+```
+
+A seconda della velocità di connessione a Internet, potrebbe essere necessario un po' di tempo per scaricare i `584` megabyte di file binari. Una volta completato il download, è possibile elencarli con il comando `ls`:
+
+```bash
+ls -loh downloads
+```
+
+```text
+total 557M
+-rw-r--r--. 1 root 51M Jan  6 11:13 cni-plugins-linux-amd64-v1.6.2.tgz
+-rw-r--r--. 1 root 36M Feb 28 14:09 containerd-2.0.3-linux-amd64.tar.gz
+-rw-r--r--. 1 root 19M Dec  9 04:16 crictl-v1.32.0-linux-amd64.tar.gz
+-rw-r--r--. 1 root 17M Feb 25 14:19 etcd-v3.4.36-linux-amd64.tar.gz
+-rw-r--r--. 1 root 89M Dec 11 16:12 kube-apiserver
+-rw-r--r--. 1 root 82M Dec 11 16:12 kube-controller-manager
+-rw-r--r--. 1 root 55M Dec 11 16:12 kubectl
+-rw-r--r--. 1 root 74M Dec 11 16:12 kubelet
+-rw-r--r--. 1 root 64M Dec 11 16:12 kube-proxy
+-rw-r--r--. 1 root 63M Dec 11 16:12 kube-scheduler
+-rw-r--r--. 1 root 11M Feb 13 20:19 runc.amd64
+```
+
+## Installare `kubectl`
+
+In questa sezione si installerà `kubectl`, lo strumento a riga di comando ufficiale del client Kubernetes, sulla macchina `jumpbox`. Si userà `kubectl` per interagire con il piano di controllo di Kubernetes dopo il completamento del provisioning del cluster, più avanti in questo tutorial.
+
+Usare il comando `chmod` per rendere eseguibile il binario `kubectl` e spostarlo nella directory `/usr/local/bin/`:
+
+```bash
+  chmod +x downloads/kubectl
+  cp downloads/kubectl /usr/local/bin/
+```
+
+Poiché l'installazione di `kubectl` è completa, è possibile verificarla eseguendo il comando `kubectl`:
+
+```bash
+kubectl version --client
+```
+
+```text
+Client Version: v1.32.0
+Kustomize Version: v5.5.0
+```
+
+A questo punto, avete configurato una `jumpbox` con tutti gli strumenti e le utilità a riga di comando necessari per completare i laboratori di questa esercitazione.
+
+Successivo: [Provisioning delle risorse di calcolo](lab3-compute-resources.md)
diff --git a/docs/labs/kubernetes-the-hard-way/lab3-compute-resources.it.md b/docs/labs/kubernetes-the-hard-way/lab3-compute-resources.it.md
new file mode 100644
index 0000000000..ce399a0e2b
--- /dev/null
+++ b/docs/labs/kubernetes-the-hard-way/lab3-compute-resources.it.md
@@ -0,0 +1,236 @@
+---
+author: Wale Soyinka
+contributors: Steven Spencer
+tags:
+  - kubernetes
+  - k8s
+  - lab exercise
+---
+
+# Laboratorio 3: Provisioning delle risorse di calcolo
+
+!!! info
+
+    Si tratta di un fork dell'originale ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way) scritto originariamente da Kelsey Hightower (GitHub: kelseyhightower). A differenza dell'originale, che si basa su distribuzioni simili a Debian per l'architettura ARM64, questo fork si rivolge a distribuzioni Enterprise Linux come Rocky Linux, che gira su architettura x86_64.
+
+Kubernetes richiede un insieme di macchine per ospitare il piano di controllo di Kubernetes e i nodi worker dove vengono eseguiti i container. In questo laboratorio, si forniranno le macchine necessarie per configurare un cluster Kubernetes.
+
+## Database macchine
+
+Questa esercitazione sfrutterà un file di testo, che servirà come database delle macchine, per memorizzare i vari attributi delle macchine che verranno utilizzati durante la configurazione del piano di controllo e dei nodi worker di Kubernetes. Il seguente schema rappresenta le voci del database delle macchine, una voce per riga:
+
+```text
+IPV4_ADDRESS FQDN HOSTNAME POD_SUBNET
+```
+
+Ogni colonna corrisponde a un indirizzo IP della macchina `IPV4_ADDRESS`, a un nome di dominio completamente qualificato `FQDN`, a un nome host `HOSTNAME` e alla sottorete IP `POD_SUBNET`. Kubernetes assegna un indirizzo IP per `pod` e il `POD_SUBNET` rappresenta l'intervallo di indirizzi IP unico assegnato a ciascuna macchina del cluster.
+
+Ecco un esempio di database macchina simile a quello utilizzato per creare questa esercitazione. Date un'occhiata agli indirizzi IP nascosti. È possibile assegnare qualsiasi indirizzo IP alle macchine, purché siano raggiungibili tra loro e dalla `jumpbox`.
+
+```bash
+cat machines.txt
+```
+
+```text
+XXX.XXX.XXX.XXX server.kubernetes.local server  
+XXX.XXX.XXX.XXX node-0.kubernetes.local node-0 10.200.0.0/24
+XXX.XXX.XXX.XXX node-1.kubernetes.local node-1 10.200.1.0/24
+```
+
+Ora tocca a voi creare un file `machines.txt` con i dettagli delle tre macchine che userete per creare il cluster Kubernetes. È possibile utilizzare l'esempio di database delle macchine di cui sopra per aggiungere i dettagli delle proprie macchine.
+
+## Configurazione dell'accesso SSH
+
+Si utilizzerà SSH per configurare le macchine del cluster. Verificare di avere accesso SSH `root` a ogni macchina elencata nel database. Potrebbe essere necessario abilitare l'accesso SSH root su ogni nodo aggiornando il file `sshd_config` e riavviando il server SSH.
+
+### Abilitare l'accesso SSH di root
+
+È possibile saltare questa sezione se si dispone di un accesso SSH `root` per ogni macchina.
+
+Una nuova installazione di `Rocky Linux` disabilita l'accesso SSH per l'utente `root` per impostazione predefinita. Questo per ragioni di sicurezza, dato che l'utente `root' ha il controllo amministrativo totale dei sistemi Unix-like. Le password deboli sono terribili per le macchine connesse a Internet. Come accennato in precedenza, si abiliterà l'accesso `root\` su SSH per semplificare i passaggi di questa esercitazione. La sicurezza è un compromesso; in questo caso, si sta ottimizzando la convenienza.
+
+Accedere a ogni macchina utilizzando SSH e il proprio account utente, quindi passare all'utente `root` con il comando `su`:
+
+```bash
+su - root
+```
+
+Modificare il file di configurazione del demone SSH `/etc/ssh/sshd_config` e impostare l'opzione `PermitRootLogin` su `yes`:
+
+```bash
+sed -i \
+  's/^#PermitRootLogin.*/PermitRootLogin yes/' \
+  /etc/ssh/sshd_config
+```
+
+Riavviare il server SSH `sshd` per caricare il file di configurazione aggiornato:
+
+```bash
+systemctl restart sshd
+```
+
+### Generare e distribuire le chiavi SSH
+
+Qui si genererà e distribuirà una coppia di chiavi SSH alle macchine `server`, `node-0` e `node-1`, che verranno utilizzate per eseguire comandi su tali macchine nel corso di questa esercitazione. Eseguite i seguenti comandi dalla macchina `jumpbox`.
+
+Generare una nuova chiave SSH:
+
+```bash
+ssh-keygen
+```
+
+Premete ++enter++ per accettare tutti i valori predefiniti delle richieste:
+
+```text
+Generating public/private rsa key pair.
+Enter file in which to save the key (/root/.ssh/id_rsa): 
+Enter passphrase (empty for no passphrase): 
+Enter same passphrase again: 
+Your identification has been saved in /root/.ssh/id_rsa
+Your public key has been saved in /root/.ssh/id_rsa.pub
+```
+
+Copiare la chiave pubblica SSH su ogni macchina:
+
+```bash
+while read IP FQDN HOST SUBNET; do 
+  ssh-copy-id root@${IP}
+done < machines.txt
+```
+
+Una volta aggiunta ogni chiave, verificare che l'accesso alla chiave pubblica SSH funzioni:
+
+```bash
+while read IP FQDN HOST SUBNET; do 
+  ssh -n root@${IP} uname -o -m
+done < machines.txt
+```
+
+```text
+x86_64 GNU/Linux
+x86_64 GNU/Linux
+x86_64 GNU/Linux
+```
+
+## Hostnames
+
+In questa sezione, si assegneranno i nomi host alle macchine `server`, `node-0` e `node-1`. Si utilizzerà il nome dell'host quando si eseguiranno i comandi dalla `jumpbox` a ogni macchina. Anche il nome dell'host svolge un ruolo importante all'interno del cluster. Invece di utilizzare un indirizzo IP per inviare comandi al server API Kubernetes, i client Kubernetes utilizzeranno il nome host `server`. I nomi di host sono utilizzati anche da ogni macchina worker, `node-0` e `node-1`, quando si registra con un determinato cluster Kubernetes.
+
+Per configurare l'hostname di ogni macchina, eseguire i seguenti comandi su `jumpbox`.
+
+Impostare il nome host di ogni macchina elencata nel file `machines.txt`:
+
+```bash
+while read IP FQDN HOST SUBNET; do
+    ssh -n root@${IP} cp /etc/hosts /etc/hosts.bak 
+    CMD="sed -i 's/^127.0.0.1.*/127.0.0.1\t${FQDN} ${HOST}/' /etc/hosts"
+    ssh -n root@${IP} "$CMD"
+    ssh -n root@${IP} hostnamectl hostname ${HOST}
+done < machines.txt
+```
+
+Verificare l'hostname impostato su ogni macchina:
+
+```bash
+while read IP FQDN HOST SUBNET; do
+  ssh -n root@${IP} hostname --fqdn
+done < machines.txt
+```
+
+```text
+server.kubernetes.local
+node-0.kubernetes.local
+node-1.kubernetes.local
+```
+
+## Tabella di ricerca host
+
+In questa sezione, si genererà un file `hosts` e lo si aggiungerà al file `/etc/hosts` su `jumpbox` e ai file `/etc/hosts` su tutti e tre i membri del cluster utilizzati per questa esercitazione. In questo modo ogni macchina sarà raggiungibile con un nome di host come `server`, `node-0` o `node-1`.
+
+Creare un nuovo file `hosts` e aggiungere un'intestazione per identificare le macchine da aggiungere:
+
+```bash
+echo "" > hosts
+echo "# Kubernetes The Hard Way" >> hosts
+```
+
+Generare una voce di host per ogni macchina nel file `machines.txt` e aggiungerla al file `hosts`:
+
+```bash
+while read IP FQDN HOST SUBNET; do 
+    ENTRY="${IP} ${FQDN} ${HOST}"
+    echo $ENTRY >> hosts
+done < machines.txt
+```
+
+Esaminare le voci degli host nel file `hosts`:
+
+```bash
+cat hosts
+```
+
+```text
+
+# Kubernetes The Hard Way
+XXX.XXX.XXX.XXX server.kubernetes.local server
+XXX.XXX.XXX.XXX node-0.kubernetes.local node-0
+XXX.XXX.XXX.XXX node-1.kubernetes.local node-1
+```
+
+## Aggiunta di voci `/etc/hosts` a una macchina locale
+
+In questa sezione, si aggiungeranno le voci DNS dal file `hosts` al file locale `/etc/hosts` sulla macchina `jumpbox`.
+
+Aggiungere le voci DNS da `hosts` a `/etc/hosts`:
+
+```bash
+cat hosts >> /etc/hosts
+```
+
+Verificare l'aggiornamento del file `/etc/hosts`:
+
+```bash
+cat /etc/hosts
+```
+
+```text
+127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
+::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
+
+# Kubernetes The Hard Way
+XXX.XXX.XXX.XXX server.kubernetes.local server
+XXX.XXX.XXX.XXX node-0.kubernetes.local node-0
+XXX.XXX.XXX.XXX node-1.kubernetes.local node-1
+```
+
+Dovresti essere in grado di collegarti tramite SSH a ciascuna macchina elencata nel file `machines.txt` utilizzando un nome host.
+
+```bash
+for host in server node-0 node-1
+   do ssh root@${host} uname -o -m -n
+done
+```
+
+```text
+server x86_64 GNU/Linux
+node-0 x86_64 GNU/Linux
+node-1 x86_64 GNU/Linux
+```
+
+## Aggiunta di voci `/etc/hosts` alle macchine remote
+
+In questa sezione, si aggiungeranno le voci di host da `hosts` a `/etc/hosts` su ogni macchina elencata nel file di testo `machines.txt`.
+
+Copiare il file `hosts` su ogni macchina e aggiungerne il contenuto a `/etc/hosts`:
+
+```bash
+while read IP FQDN HOST SUBNET; do
+  scp hosts root@${HOST}:~/
+  ssh -n \
+    root@${HOST} "cat hosts >> /etc/hosts"
+done < machines.txt
+```
+
+È possibile utilizzare i nomi host quando ci si connette alle macchine dalla propria macchina `jumpbox` o da una qualsiasi delle tre macchine del cluster Kubernetes. Invece di usare gli indirizzi IP, è ora possibile connettersi alle macchine usando un nome di host come `server`, `node-0` o `node-1`.
+
+Successivo: [Provisioning di una CA e generazione di certificati TLS](lab4-certificate-authority.md)