Hi all and welcome to this mini tutorial!

If you are following my [*Programming on Windows without the hassle* series' articles](https://aalonso.dev/blog?tags=wsl2), you are probably also using WSL2 in your day-to-day work. Today, I'll tell you about something very important in every system (and every system configuration): backup and restore.

When you have tuned your WSL2 distro for the work you made, installing the required packages, configure the shell interpreter, aliases, environment, networking, solved windows related issues, etc. etc. you don't want them to be lost. Even better, if you mess up and break something, you want to revert to a fully working copy of your work environment asap.

Thought this tutorial, you'll learn how to back up and restore WSL2 distro full file system (virtual drives, system image) in a `.tar` compressed file, using native WSL PowerShell commands.

## Backing up your WSL2 distro
We need to stop the WSL2 distro and the WSL2 hypervisor to the backup to be completed without issues, so first, ensure the WSL2 distro you want to back up is not running. You can check that with the following command:

```powershell
wsl --list -v
```

![All my WSL2 distros](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5sn9o1uywwl4mevja6oc.png)

If the distro is running, like in my case, you can stop it with:

```powershell
wsl --shutdown
```

Then, to back up the distro:

```powershell
wsl --export Distro_Name \Windows\destination\path\name.tar
```

Ensure you have writing permissions in the destination path to the new backup file to be created. This can take a few minutes, depending on your WSL2 distro image size. The `Distro_Name` is the one you got from `wsl --list`.

![Backing up my Ubuntu WSL2 distro](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dp1dnhg2xg84ktum00tp.png)

## Restoring or migrating your WSL2 distro

Once you have a backup of your distro, you can import it into WSL2 in any Windows machine with WSL2 enabled. As you have probably realized, every WSL2 distro installation has a name that we use to identify it in the commands. You cannot import it with a name that already exist, you must either remove the old distro and then import, or import it with a new name.

To remove the old distro installation:

```powershell
wsl --unregister Distro_Name
```

To import the WSL2 backup (Note: the first argument is the path where the new WSL2 distro will be installed, i.e. where the virtual disk and all related files will be created):

```powershell
wsl --import Distro_Name \New\Installation\Path \Windows\backup\path\name.tar
```

![Importing the WSL2 backup](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mvtj57zaga8k8zzuis51.png) 

You can test your new imported distro with:

```powershell
wsl --distribution Distro_Name
``` 

**NOTE:** after the import, it's probably that the new imported WSL2 distro boots up logging with the root user, instead of your regular user. That's because we have in fact installed manually the distro, so Windows doesn't know what is the default distro user (the one you configure when you install it from the Windows store) and therefore it falls back to root. The [Microsoft recommended way](https://docs.microsoft.com/en-us/windows/wsl/wsl-config#user) to fix it is by adding a file in `/etc/wsl.conf` inside the WSL2 distro with the following content:

```ini
[user]
default=your_username
```

**IMPORTANT**: after these steps, it's probably that you need to re-enable docker support for the new imported distros, if you want to use docker inside them. Check the docker section [in a previous post](https://aalonso.dev/blog/how-to-be-a-productive-programmer-in-windows-with-wsl2-5185) to know how to do it, if you don't know how.

## Bonus: setting the new imported distro as WSL2 default distro

You can set any installed WSL2 distro as default. The default distro is the one that will boot up and open when you execute `bash.exe` or something related to WSL in Windows. You can easily do that with:

```powershell
wsl --set-default Distro_Name
```

Voilà! I hope that was helping for you. Have a nice day!

Hi all and welcome to this mini tutorial!  If you are following my Programming on Windows without the...

How to back up and restore (or migrate to a new computer) a WSL2 distro

Aitor Alonso

Hi guys!

Today, I come here with another mini-tutorial to make programming on Windows a little easier with the help of the [WSL 2](https://docs.microsoft.com/en-us/windows/wsl/about).

Imagine you are developing an API,  web app, website, etc. on your Windows machine under WSL2. For example, in my case, [my own website](https://aalonso.dev/). I use the React framework [Next.js](https://nextjs.org/), and yarn as package manager, so if I want to start the development server to check my site I just do:

```bash
yarn dev
```

With the above command, the development server will start and listen on port `3000`. It will serve the page to every device that can reach it, as it's serving the site on the `0.0.0.0` address by default. 

![Starting the dev server of my website](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4uzme7peiaxhkbvykuuk.png) 

Then, if I visit `localhost:3000` on my Windows machine, everything works. The server returns my live website. However, what happens when I try to open my live site from my mobile phone? I navigate to `<my_windows_local_ip>:3000` and then

![The site can't be reached](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lppaoyo9copyqc1x1cki.jpg)

## The solution: forwarding ports in WSL 2 NAT

WSL 2 creates a [virtualized Ethernet adapter with its own unique IP address](https://docs.microsoft.com/en-us/windows/wsl/compare-versions#accessing-a-wsl-2-distribution-from-your-local-area-network-lan), so in fact it creates a NAT between your WSL instance and your Windows host computer. So to be able to access to applications running in your WSL from within your Local Area Network (LAN), you must port forward the desired ports.

The solution is to add a port proxy in the Windows Firewall, so we open a PowerShell terminal with administrator rights and execute the following command:

```powershell
netsh interface portproxy add v4tov4 listenport=3000 listenaddress=0.0.0.0 connectport=3000 connectaddress=<the_wsl_ip>
```

You can get the WSL virtual machine IP right from PowerShell, by executing bash:

```powershell
bash.exe -c "ip -4 addr show eth0 | grep -oP '(?<=inet\s)\d+(\.\d+){3}'"
```

Or the same from within the WSL instance:

```bash
ip -4 addr show eth0 | grep -oP '(?<=inet\s)\d+(\.\d+){3}'
```

After executing the `netsh interface` command in an administrator PowerShell, the server can now be reached without further configuration needed, nor restarting the server.

![Now it works!](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qg9fd6gj3v9xo1hv1nzo.jpg)

## Bonus: a PowerShell script to simplify this task

The IP address of the WSL VM changes every time it reboots (like when you power off your Windows), so if you have already added a port proxy for an IP address, it might not work if you restart your computer.

I have created a PowerShell script to simplify this task when you need it to be done. You could also configure a Windows task to execute this PowerShell script on every reboot, if you also start WSL on boot (because WSL needs to be launched to get its IP address). Or could be a way to executing it from WSL once it starts. I'm not explaining here how to achieve this, as I don't have configured it that way. I don't usually access apps running inside WSL from my LAN, so when I need to do this, I just execute the following script in an administrator PowerShell terminal **(explanation below)**:

```powershell
$remoteport = bash.exe -c "ip -4 addr show eth0 | grep -oP '(?<=inet\s)\d+(\.\d+){3}'"
$found = $remoteport -match '\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}';

if( $found ){
  $remoteport = $matches[0];
} else{
  echo "The Script Exited, the ip address of WSL 2 cannot be found";
  exit;
}

#[Ports]

#All the ports you want to forward separated by coma
$ports=@(80,443,3000,3001,3002,3333,5000,5432,6000,8080,8081,19000,19001);


#[Static ip]
#You can change the addr to your ip config to listen to a specific address
$addr='0.0.0.0';
$ports_a = $ports -join ",";


#Remove Firewall Exception Rules
iex "Remove-NetFireWallRule -DisplayName 'WSL 2 Firewall Unlock' ";

#adding Exception Rules for inbound and outbound Rules
iex "New-NetFireWallRule -DisplayName 'WSL 2 Firewall Unlock' -Direction Outbound -LocalPort $ports_a -Action Allow -Protocol TCP";
iex "New-NetFireWallRule -DisplayName 'WSL 2 Firewall Unlock' -Direction Inbound -LocalPort $ports_a -Action Allow -Protocol TCP";

for( $i = 0; $i -lt $ports.length; $i++ ){
  $port = $ports[$i];
  iex "netsh interface portproxy delete v4tov4 listenport=$port listenaddress=$addr";
  iex "netsh interface portproxy add v4tov4 listenport=$port listenaddress=$addr connectport=$port connectaddress=$remoteport";
}
```

What this script does is:
- Gets the IP address of the WSL VM.
- Defines the ports you want to proxy/forward. You can therefore edit the `$ports` array as you wish. Here I have written all the ports I could potentially use, so the script will be valid for multiple apps/technologies.
- Adds Windows Firewall rules to allow all inbound/outbound traffic to the WSL. Also removes old rules from previous script executions (with different IP addresses).
- Adds the required port proxies, at the same times that removes old ones from old script executions (with different IP addresses).

If there is the first time that you execute this script, or you have added a new port, you can get a lot of *not found* messages. These are normal warnings that you can safely ignore, as these occur because the script is trying to delete non-existent firewall rules (first time execution) or port proxies (when you add a new port).

I hope this serves you to improve your developer experience in WSL and make you more productive. See you soon!

Hi guys!  Today, I come here with another mini-tutorial to make programming on Windows a little...

Accessing network apps running inside WSL2 from other devices in your LAN

Hi guys!

Today, I will teach how to run Linux GUI (Graphical User Interface) apps from within the WSL2. Nowadays, a third-party app is required to run GUI apps, but Microsoft announced on Build 2020 that [adding Linux GUI app native support to WSL is on their roadmap](https://devblogs.microsoft.com/commandline/the-windows-subsystem-for-linux-build-2020-summary/#wsl-gui).

I currently use *VcXsrv Windows X Server* for that purpose, and that's the tool I will explain on this post. It's an old open-source software that updates quite frequently. [You can check it on Sourceforge](https://sourceforge.net/projects/vcxsrv/).

## Installing and configuring VcXsrv
The first step is to download and install the `.exe` [installer from Sourceforge](https://sourceforge.net/projects/vcxsrv/). Execute it and on the installation process, be sure to check the *Disable access control* option. This will save us time, avoiding some *permission denied* errors.

![Be sure to disable access control](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c9fsd1f4vlhkcqroffl4.png)

To be sure that this option is always checked, save the configuration to later launch VcXsrv using that config file.

![How to save VcXsrv configuration](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x370kq1k7asyda7zq8op.png)

## Setting permissions in Windows Firewall
Once VcXsrv is installed, we need to set the proper permissions on our firewall. Here, I assume you use the default Windows Firewall, but if you use a custom firewall (like a firewall provided by an antivirus), you may need extra steps.

When executing VcXsrv for the first time, a Windows Firewall pop-up should appear. Just be sure to give it permissions on both private and public networks.

![Setting permissions in Windows Firewall](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fumy6n0d8f3c1vowd3rg.png)

If the pop-up doesn't appear, or if you gave it the wrong permissions by mistake, you can just change the permissions manually. To do so, go to `Windows Security -> Firewall & network protection -> Allow an app through firewall` and ensure *VcXsrv windows x server* has both permissions.

## Setting the `DISPLAY` env var
The last step is to set the `DISPLAY` environment variable on our WSL2 Linux instance. We need to configure the Windows host's IP address as `DISPLAY` (where the VcXsrv X server is running). Also, as WSL2 network changes on every restart, so the Windows host's IP does too, it's needed to dynamically set this value on WSL2 launch.

We can use one of the following statements to dynamically set the `DISPLAY` env var to the correct value.

```bash
export DISPLAY="`grep nameserver /etc/resolv.conf | sed 's/nameserver //'`:0"
export DISPLAY="`sed -n 's/nameserver //p' /etc/resolv.conf`:0"
export DISPLAY=$(ip route|awk '/^default/{print $3}'):0.0
```

If you run one of the above commands on your Linux terminal, then, you should see and local IP address when reading the var value. Just use whatever of the above that works correctly on your machine.

```bash
export DISPLAY=....
echo $DISPLAY # Example working output: 192.168.128.1:0.0
```

Lastly, to ensure the DISPLAY env var is updated on every restart, we should add the chosen `export` statement to our `~/.bashrc` file (if you are using bash as your command interpreter) or in `~/.zshrc` (if using zsh instead).

## Testing it out

Let's test it! First, ensure the VcXsrv is running. You can check it by looking at the icons on your task bar. You should be able to see the VcXsrv icon if the server is up and running.

![VcXsrv running on the task bar](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/b44988fz25hfs0j6ktq6.png)

If you can't see any icon, just start the server by double-clicking on the config file you saved when installing. It will launch VcXsrv server with the configuration on that file. You can open the file with a text editor, if you want, to check the configuration inside.

If you have followed all the above steps, you should be able to execute GUI apps within WSL2 already. Let's try with the `x11-apps`, some very low resources and low dependencies apps made for testing X server configurations.

```bash
sudo apt install x11-apps
xeyes
xcalc
```

![x11 apps running on WSL2 Ubuntu](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/g9xjdjgs2v7mjd4ljzjh.png)

If, after executing the above commands, you see two eyes following your mouse... Congratulations! You have successfully configured your WSL2 instance to run GUI apps.

## Troubleshooting

I particularly had an issue trying to use the default `0.0` display as my X server. Indeed, trying to use `0.0` will make the X server to crash on my Windows machine. It took me a few hours to realize, after searching on Google for a while and trying multiple different fixing options.

If you have the same problem, may you can fix it by using the `1.0` display instead. Here is how I set the `DISPLAY` value and my VcXsrv `config.xlaunch` config file.

```bash
export DISPLAY=$(ip route | awk '/default/ { print $3 }'):1.0
```

```xml
<?xml version="1.0" encoding="UTF-8"?>
<XLaunch WindowMode="MultiWindow" ClientMode="NoClient" LocalClient="False" Display="1" LocalProgram="xcalc" RemoteProgram="xterm" RemotePassword="" PrivateKey="" RemoteHost="" RemoteUser="" XDMCPHost="" XDMCPBroadcast="False" XDMCPIndirect="False" Clipboard="True" ClipboardPrimary="True" ExtraParams="" Wgl="True" DisableAC="True" XDMCPTerminate="False"/>
```

Hi guys!  Today, I will teach how to run Linux GUI (Graphical User Interface) apps from within the...

How to use GUI apps in WSL2 (forwarding X server)

Hi folks!

Today, I will explain to you how to configure WSL 2 on Windows to have a fully programming environment with productivity in mind. In this post, I will show you how to configure WSL 2 to fully integrate it with VS Code and Docker Desktop.

In case you missed it, in a [previous post](https://aalonso.dev/blog/how-to-install-wsl2-on-windows-10-5e82) I explained how to install WSL2 on your Windows 10 machine. 

## Wait, can you really be a productive programmer in Windows?

Yes, or at least, WSL 2 will provide you with a Linux environment with all the fancy stuff such as a UNIX terminal (bash, zsh, ...), unix tools like curl, wget, ssh, ..., and everything you would need in a normal development environment, while still having a Windows OS where you can install some proprietary Windows-only apps.

**This is how I configured my PC for my daily remote work as a professional programmer.** Before that, I had a dual boot windows + Linux setup, which I encourage you to do if you want to enjoy the fully Linux experience. However, currently I prefer and easier approach, as I use a lot of apps that can only be installed on Windows along with some games with only Windows support, and I don't want to maintain two different OSes, nor having my disk space divided or a boot manager asking me what to boot.

## First step: installing docker

To install docker on both Windows and WSL 2 you only need to install Docker Desktop with its .exe installer. That's it. Here is the official download URL:

https://www.docker.com/products/docker-desktop

Install it like any other Windows app. If it asks about enabling WSL2 support, just select it like in the picture below:

![Installing Docker Desktop with WSL 2 support](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j2xirsv0tn2z3ln8mi36.png)

Once installed, open the Docker Desktop app and go to settings by clicking on the gear icon on the upper bar (1). Then, check if effectively WSL 2 support is enabled (2). Also, there you can disable Docker Desktop to automatically start when you log in to Windows, or to send usage statistics if you want.

![Checking WSL 2 support on Docker](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gdpwb3be129futrhucvp.png)

If you have more than one Linux distribution installed on WSL 2, you may want to enable Docker for them as well. To do so, just go `Resources > WSL integration` as you see in the picture below.
 
![Enabling WSL for individual distros](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qejtne1sdj9x33cyjxd7.png)

After that, maybe restarting Docker and WSL is required. You can just reboot your Windows PC, or manually:

1. Right-clicking on the docker icon on task bar --> Restart Docker
2. Open a PowerShell terminal and type `wsl --shutdown`

### Testing and troubleshooting

You can test your Docker integration with WSL by running the following commands from WSL 2:

```bash
docker --version
docker-compose --version
```

If everything is correctly configured, those commands will show your docker installed version. 

However, if it prints an error message saying that the `docker` or `docker-compose` command couldn't be found, check that the Docker Desktop app is up and running by looking for the Docker icon on the Windows task bar. If Docker is running and the error persists, you should double-check that you enable WSL2 integration on Docker Desktop settings, like in the pictures above. Try enabling it on all your Linux distros by activating the toggle button on `Resources > WSL integration` settings page or restarting your PC if you didn't do it already.

## Next: installing VS Code Remote WSL extension

I suppose you already have installed the good knowing VS Code editor on your Windows. If you haven't done it yet, just [download it from the official page](https://code.visualstudio.com/download) and install it like any other Windows program. There is nothing especial with its installation process.

Then, open VS Code and install the [Remote WSL extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl). On the extension's page, you can read about what this extension does and how to use it.

Once the extension is installed and enabled, on VS Code press `Ctrl + Shift + P` and search for `wsl` commands. You should be able to see commands for opening a folder inside your WSL distro or just opening a new VS Code instance on your home directory, like in the next picture.

![WSL commands from VS Code](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1dbik1uyauagebbemw7s.png)

If executing one of the above commands, you should be now using VS Code over a WSL folder. If you try to open the VS Code integrate terminal, you will load bash (or zhs or whatever your default distro shell is it) instead of PowerShell or CMD. You are, effectively, working inside your WSL environment.

Pro-tip: you can open a VS Code instance from/in a WSL directory by just typing on the WSL terminal:
```bash
code . 
```

## Conclusions

Congratulations! Now you have a fully working dev environment with VS Code, fully integrated with Docker and with your favorite Linux shell and tools available. In fact, you are working on a near-to-full Linux distribution without leaving Windows, so Linux specific tools, configurations and project setups will work out of the box inside WSL.

With this setup, it is easy to feel productive programming on Windows!

Hi folks!  Today, I will explain to you how to configure WSL 2 on Windows to have a fully programming...

How to be a productive programmer in Windows with WSL2

Hi guys!

This is the first post of a series that aims to explain how to get a fully productive and integrated Linux development environment within Windows 10. Today, I will explain what is WSL 2 and how to install it on Windows.

## What is WSL 2?

But first what it's first. What is WSL 2? The Windows Subsystem for Linux (WSL) lets developers run a GNU/Linux environment -- including most command-line tools, utilities, and applications such as bash, ssh, sudo, apt, curl, etc. -- directly on Windows, unmodified, without the overhead of a traditional virtual machine or the extra disk space needed for a dual boot setup.

WSL 2 is a new version of the Windows Subsystem which primary goals are to increase file system performance, as well as adding full system call compatibility. The Linux kernel is executing in parallel to the Windows one, in a very light hypervisor (a low resource consuming virtual machine).

If you are interested in learning more about what is WSL and what does, along with the differences between version 1 and 2, you can check the [official Microsoft docs](https://docs.microsoft.com/en-us/windows/wsl/compare-versions).

## Enabling WSL on your Windows

First, your Windows 10 build version should be 1903 (also known as 19H1) or above. This is a version from May 2019, so if you have auto updates enables, it is highly probable that you are using a compatible Windows 10 build.

If you want to check what your current Windows 10 build version is, just run `winver` and a window will open with the basic version info.

![How to know what is your Windows 10 build version](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kxq6fb4s3032x7bh2b2t.png)

Next, we will enable the WSL feature on our Windows. For doing that, open a new PowerShell instance as administrator. Just search for `powersell` and `right click -> execute as administrator`. There, we will execute the following command:

```powershell
dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
```

Now, we must enable the Virtual Machine Platform feature to WSL for proper working, by executing:

```powershell
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
```

At this point we should restart our Windows to apply changes. Once we are back in our user, we need to set WSL version 2 as our default WSL version. For doing that, open a new PowerShell terminal (doesn't need to be an administrator privileged terminal) and execute the following command:

```powershell
wsl --set-default-version 2
```

## Installing your Linux distribution

Congratulations!`You have already installed WSL 2 in your machine. It wasn't so difficult, wasn't it? Just a few terminal commands.

The next step is to install your Linux distribution of choice. To do so, just open the Microsoft Store app on your Windows and search for `linux`.

![Linux's distributions available for WSL](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p8ra7kehwzsi8b8z16ow.png)

Personally, I installed Ubuntu for the following **subjective** reasons:
- Canonical (the developers of Ubuntu) and Microsoft have a partnership to ensure maximum stability and compatibility of the Ubuntu WSL images.
- Most of Linux user out there use Ubuntu, so it is easy to find resolution to the majority of problems, because chances are that someone had the same problem before you.
- As a developer (my Linux geek times went away years ago) I want to expend the less time possible solving problems with my environment, so the above two points are important to me.

However, you can use, as I said, the distro of your choice. I will use Ubuntu for the rest of the series, but the steps should be equal or very similar to all the WSL available Linux distributions. Just chose one and select "Get" on the Store.

![Ubuntu for WSL on Microsoft Store](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zdneeb36hdzbnyf7z8xd.png)

The first time you launch a newly installed Linux distribution, a console window will open, and you'll be asked to wait for a minute or two for files to decompress and be stored on your PC. All future launches should take less than a second.

You will then need to create a user account and password for your new Linux distribution. This will be a user with sudo privileges. The onboarding script will guide you through this process, but if you have some doubts or want to know more, here is the [official Microsoft docs](https://docs.microsoft.com/en-us/windows/wsl/user-support) that explain it very well.

Hope you have found this post useful. Cheers!

Hi guys!  This is the first post of a series that aims to explain how to get a fully productive and...

How to install WSL2 on Windows 10

Hello Dev community!

Years ago I started my first personal side project as a new and funny way of learning new technologies and methodologies. I remember that choosing an idea, a programming language and a framework was easy as there were some that got my attention and wanted to dive deeper into them.

However, when I had my project ready for production, and I started to read about how to deploy it, I got overwhelmed with all the existing ways of doing that. From PaaS to IaaS (terms that were unknown to me) to the different vendors and free products that suits each classification.

So that is why now, as a more experienced developer, I wrote an article telling about **what are IaaS and PaaS** where I tell **how to deploy an app to the web** by comparing five of the most known PaaS providers and their free products: **Netlify, Vercel, Heroku, GitHub Pages** and **Firebase**.

It's something I'd like to have found when I was starting: a good basis for novice developers and a good memory refresh for most experienced ones.

I hope you find it useful!

https://acidtango.com/thelemoncrunch/how-to-deploy-a-full-stack-app-to-the-web/

Hello Dev community!  Years ago I started my first personal side project as a new and funny way of le...

Blog

How to back up and restore (or migrate to a new computer) a WSL2 distro

Accessing network apps running inside WSL2 from other devices in your LAN

How to use GUI apps in WSL2 (forwarding X server)

How to be a productive programmer in Windows with WSL2

How to install WSL2 on Windows 10

How to Deploy a Full-Stack App to the Web