diff --git a/docs/guides/interoperability/import_rocky_to_wsl.md b/docs/guides/interoperability/import_rocky_to_wsl.md new file mode 100644 index 0000000000..bb8203233f --- /dev/null +++ b/docs/guides/interoperability/import_rocky_to_wsl.md @@ -0,0 +1,44 @@ +--- +title: Import Rocky Linux to WSL or WSL2 +author: Lukas Magauer +tested with: 8.6, 9.0 +tags: + - wsl + - wsl2 + - windows + - interoperability +--- + +# Import Rocky Linux to WSL + +## Prerequisites + +The Windows-Subsystem for Linux feature has to be enable. This is possible with either of these options: + +- Open an administrative Terminal (either PowerShell or Command-Prompt) and run `wsl --install` ([ref.](https://docs.microsoft.com/en-us/windows/wsl/install)) +- Go to the graphical Windows Settings and enable the optional feature `Windows-Subsystem for Linux` + +This feature should be available on every supported Windows 10 and 11 version right now. + +## Steps + +1. Get the container rootfs. This is possible in multiple ways: + + - Download the image from the [CDN images folder](https://dl.rockylinux.org/pub/rocky/9/images/) (if it is available) + - Download the image from the latest [Github Action build](https://github.com/rocky-linux/sig-cloud-instance-images/actions/workflows/build.yml) + - Extract the image from either Docker Hub or Quay.io ([ref.](https://docs.microsoft.com/en-us/windows/wsl/use-custom-distro#export-the-tar-from-a-container))
` export rockylinux:9 > rocky-9-image.tar` + +2. (optional) You might have to extract the docker rootfs layer from the image you got +3. Create the directory where the WSL will store its files (mostly somewhere in the userprofile) +4. Finally, import the image into WSL ([ref.](https://docs.microsoft.com/en-us/windows/wsl/use-custom-distro#import-the-tar-file-into-wsl)): + + - WSL: `wsl --import ` + - WSL 2: `wsl --import --version 2` + +!!! hint "WSL vs. WSL 2" + + Generally speaking WSL 2 should be faster than WSL, but that might differ from use-case to use-case. + +!!! hint "Windows Terminal" + + If you have Windows Terminal installed, the new WSL distro name will appear as an option on the pull-down menu, which is quite handy for launching in the future. You can then customize it with colors, fonts, etc. diff --git a/docs/guides/interoperability/import_rocky_to_wsl_howto.it.md b/docs/guides/interoperability/import_rocky_to_wsl_howto.it.md deleted file mode 100644 index 8adb78b7a1..0000000000 --- a/docs/guides/interoperability/import_rocky_to_wsl_howto.it.md +++ /dev/null @@ -1,122 +0,0 @@ ---- -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/import_rocky_to_wsl_howto.md b/docs/guides/interoperability/import_rocky_to_wsl_howto.md deleted file mode 100644 index eedd6855c4..0000000000 --- a/docs/guides/interoperability/import_rocky_to_wsl_howto.md +++ /dev/null @@ -1,123 +0,0 @@ ---- -title: Import to WSL2 with Docker ---- - -# Import Rocky Linux to WSL2 with Docker - -## Prerequisites - -Either - -* Linux PC running VirtualBox - VirtualBox will not run under windows 10 with WSL2, which is needed for later steps. You can also use a dual boot PC, or a live distribution, but make sure you have VirtualBox available. - -Or - - -* Docker Desktop for Windows 10 (or any docker installation) - -Required -* Windows 10 PC running **WSL2** -* Internet access - -## Introduction - -This guide shows the steps to create a tar image for a Docker container, and how to import that image into the Windows Subsystem for Linux (WSL). The steps outlined below are largely taken from Microsoft's [Import any Linux distribution to use with WSL](https://docs.microsoft.com/en-us/windows/wsl/use-custom-distro) and from Docker's [Create a base image](https://docs.docker.com/develop/develop-images/baseimages/), and adapted to the new distribution. - -Please note that you need Virtual Box (to create the container for yourself) **OR** Docker to just pull the existing image from Docker Hub. This guide assumes the user is familiar with VirtualBox or Docker, and knows how to perform tasks like installing the VirtualBoxAdditions, and mounting shared drives. - -It is also important to be familiar with the limitations of WSL, which will cause some functionality to break, work slowly, or work in unexpected ways. Depending on what you want to accomplish, the resulting distribution may or may not do what you want it to do. There are no guarantees. - ----- - -## Install Steps - -### Get Rocky Container Image - -#### Pull From Docker Hub (on the same PC as your WSL2 install) -1. From powershell or another WSL2 distro create a rocky container using the version you wish to start with. Replace the tag with your desired tag -```powershell -docker run --name rocky-container rockylinux/rockylinux:8.5 -``` -2. Confirm the container exists -```powershell -docker container list --all | Select-String rocky-container -``` -3. Export container as tar -```powershell -docker export rocky-container -o rocky-container.tar -``` - -Note: You don't have to be on the same system as your WSL2 install, you just need to be able to get that tar file to the system. - -#### Create Your Own On Linux PC with VirtualBox -1. Download the minimal image from [Rocky Linux](https://rockylinux.org/download). -2. Boot and install Rocky Linux on a new VirtualBox VM. The default settings are fine. -3. Install VirtualBoxAdditions on your VM. This will require installing additional packages (as shown in the suggested command):
-```bash -$ sudo yum install gcc make kernel-devel bzip2 binutils patch libgomp glibc-headers glibc-devel kernel-headers elfutils-libelf-devel tar - -``` -4. Make a working directory, and copy files to be used for the tar image.
-```bash -$ mkdir wsl_tar -$ cd wsl_tar -$ cp -p /etc/yum.conf . -$ cp -p /etc/yum.repos.d/Rocky-BaseOS.repo . -``` -5. Edit *your copy* of `yum.conf` and add this line to it (modify the path as needed):
-```bash -reposdir=/home//wsl_tar/ -``` -6. Download the script to create a base image from Docker GitHub.
- The script is called [mkimage-yum.sh](https://github.com/moby/moby/blob/master/contrib/mkimage-yum.sh). -7. Modify the script to create a tar file at the end, instead of starting Docker. Here are the suggested changes to the 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. Execute the script using this command (modify the path as needed):
-```bash -$ sudo ./mkimage-yum.sh -y /home//wsl_tar/yum.conf baseos -``` -9. After the script finishes, your new tar file will be in the path you entered in the script above. Mount a shared drive with the host and move the tar file there. - You could also move the file to a USB drive or folder accessible to the Windows 10 PC. After moving the file to an external drive or folder, you won't need the VM anymore. You can delete it or modify it for other purposes. - - -### Import into WSL2 -1. Create a directory to hold the Rocky Linux filesystem. -2. In a PowerShell prompt, import Rocky Linux (it's named `rocky_rc` here, but you can name it anything you like).
-```PowerShell -wsl --import rocky_rc -``` -3. Verify Rocky Linux is installed with:
-```PowerShell -wsl -l -v -``` -4. Launch Rocky Linux with
-```PowerShell -wsl -d rocky_rc -``` -5. Set up Rocky Linux with the following bash commands (you'll need to be running as 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. Exit the bash prompt (Ctrl+D or exit). -7. Back in a PowerShell prompt, shutdown all WSL running instances and start Rocky.
-```PowerShell -wsl --shutdown -wsl -d rocky_rc -``` -8. Test and enjoy! - -If you have Windows Terminal installed, the new WSL distro name will appear as an option on the pull-down menu, which is quite handy to launch it in the future. You can then customize it with colors, fonts, etc. - -Even though you need WSL2 in order to perform the steps above, you can use the distro as WSL 1 or 2, by converting it with PowerShell commands. diff --git a/docs/guides/interoperability/rocky_to_wsl_howto.it.md b/docs/guides/interoperability/rocky_to_wsl_howto.it.md deleted file mode 100644 index b7129aa5a2..0000000000 --- a/docs/guides/interoperability/rocky_to_wsl_howto.it.md +++ /dev/null @@ -1,108 +0,0 @@ ---- -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/interoperability/rocky_to_wsl_howto.md b/docs/guides/interoperability/rocky_to_wsl_howto.md deleted file mode 100644 index fc485103cc..0000000000 --- a/docs/guides/interoperability/rocky_to_wsl_howto.md +++ /dev/null @@ -1,109 +0,0 @@ ---- -title: Import To WSL with WSL and rinse ---- - -# Import Rocky Linux to WSL with WSL and rinse - -## Prerequisites -* A Windows 10 PC with WSL 2 enabled. (*see note below). -* Ubuntu, or any debian-based distribution, installed and running on WSL. This guide was tested using Ubuntu 20.04 LTS from the Microsoft store. - -## Introduction -This guide is for Windows users who would like to run Rocky Linux (RL) in the Windows Subsystem for Linux (WSL). It assumes the reader is familiar with the command line and has WSL enabled and running in their Windows 10 PC. - -The process uses `rinse`, a perl script for creating images of distributions that use the package manager YUM. - -Please keep in mind that WSL has significant limitations and quirks, and the resulting distribution may or may not work as you expect it. It may be too slow, or be unpredictable for some applications. With computers, as with life, there are no guarantees. - -## Steps - -1. Launch your Ubuntu distribution in WSL, update the package manager and install `rinse`
-```bash -$ sudo apt-get update -$ sudo apt-get install rinse -``` -`rinse` is not aware of RL, so we need to modify its configuration to add the package repositories and so on. - -2. Copy the CentOS 8 packages file and prepare it for RL -```bash -$ sudo cp -p /etc/rinse/centos-8.packages /etc/rinse/rocky-8.packages -``` -3. Edit the new file and change all the entries for 'centos' to 'rocky'. Next, add the following lines to it. The order in the file is not important, the entries can be added anywhere. Here you can also add any other packages that you may want to have in your image (servers, utilities like `which`, etc) -```bash -glibc-langpack-en -libmodulemd -libzstd -passwd -sudo -cracklib-dicts -openssh-clients -python3-dbus -dbus-glib -``` -4. Edit the `rinse` config file at `/etc/rinse/rinse.conf` and add the following lines, which are the entry for RL mirrors. As of this writing, we have a direct download, but this will be changed to a mirror as soon as available. -```bash -# Rocky Linux 8 -[rocky-8] -mirror.amd64 = http://dl.rockylinux.org/pub/rocky/8/BaseOS/x86_64/os/Packages/ -``` -5. Copy the post-install script for CentOS so it can be modified for RL -```bash -$ sudo cp -pR /usr/lib/rinse/centos-8 /usr/lib/rinse/rocky-8 -``` -6. Edit `/usr/lib/rinse/rocky-8/post-install.sh` and add the following lines at line 14. This is needed to make sure TLS/SSL works as expected for *YUM* and *dnf*. -```bash -echo " Extracting CA certs..." -$CH /usr/bin/update-ca-trust -``` -7. Edit the `rinse` script at `/usr/sbin/rinse`, and at line 1248 remove the text `--extract-over-symlinks`. This option was deprecated in the program called and breaks the script. Don't close the file yet. -8. On the same file, go to line 1249 and replace 'centos' for 'rocky'. Save and close the file. -9. Make a directory to hold the new RL filesystem (any name is fine). -```bash -$ mkdir rocky_rc -``` -10. Execute `rinse` with the following command -```bash -$ sudo rinse --arch amd64 --directory ./rocky_rc --distribution rocky-8 -``` -11. After the script completes downloading and extracting all the packages, you will have a full Rocky Linux file system in the directory you created. Now it's time to package it to pass it to Windows for importing into a new WSL distro. Use this command, creating the tar file in a Windows folder (starting with `/mnt/c/` or similar to have it readily available for the next step). -```bash -$ sudo tar --numeric-owner -c -C ./rocky_rc . -f -``` -12. Close your WSL session with Ctrl+D or by typing `exit`. -13. Open a PowerShell prompt (does not need to be admin), and create a folder to hold your new RL distro. -14. Import the tar file with this command: -```PowerShell -wsl --import rocky_rc -``` -Note: Default location of WSL is `%LOCALAPPDATA%\Packages\` -`e.g. for Ubuntu - C:\Users\tahder\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhks2fndhsd\LocalState\rootfs\home\txunil\rocky_rc` - -15. In the PowerShell prompt, launch your new distro with: -```PowerShell -wsl -d rocky_rc -``` -16. You are now root in your new RL distro. Run these commands to finish setting everything up: -```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. Exit the bash prompt (Ctrl+D or type `exit`). -18. Back in PowerShell, shutdown WSL and relaunch your new distro. -```PowerShell -wsl --shutdown -wsl -d rocky_rc -``` -19. Test and enjoy! - -## Cleanup -All the downloaded packages are still stored in the debian distro you used at the beginning of the process. You can remove the files from `/var/cache/rinse`, and you can also delete all the files from the `rocky_rc` directory. Next time you want to create a new, updated or modified image, simply make your changes and run the commands from step 10 on. - -## Known issues -There are some quirky things that result from extracting packages, rather than installing them. Running `yum reinstall` in some packages fixes the issues, as is the case for `passwd`. The `rinse` script simply extracts the packages and does not execute post-install commands (although it is capable of doing so). Please leave comments for other users if you run into problems and know how to fix them, so that others can benefit from your experience. - -## Notes -Most of the `rinse` script runs under WSL 1, but the very last part, where `dnf` is invoked, runs into memory issues and corrupts the `rpm` database. This ruins the distro, and repair attempts fail, even under WSL. If you know how to get `dnf` to work under WSL 1, please let us know, but there are lots of BDB issues related to WSL 1 on different forums on the web. WSL 2 solved those issues with the native Linux kernel.