<

>

Article

Top 4 des astuces WSL

7

min

Outils

03

/

06

/

2025

Introduction

Connaissez-vous le WSL ou Windows Subsystem for Linux, cette fonction très pratique permettant d'exécuter un système Linux au sein de Windows, mais sans passer par une virtualisation lourde comme VirtualBox ?

En tant que développeur, sous Windows, c'est l'outil idéal au quotidien. Il permet de travailler facilement et simultanément avec les environnements Windows et Linux pour différents besoins.

La techno du WSL s'améliorant chaque année, il nous paraissait logique aujourd'hui de partager avec vous nos meilleures trouvailles, de la petite ligne de commande astucieuse jusqu'à la fonctionnalité cachée 🙂 (oui, il y en a !).

Astuce n°1 : Manager ses WSL en CLI

Gérer de multiples instances

Le programme WSL2 nous permet de gérer non pas une, mais plusieurs instances Linux, et ce, directement depuis l'invité de commande (ou PowerShell).

Avant d'installer une distribution de Linux, nous pouvons commencer par afficher les distributions disponibles au téléchargement :

wsl --list --online

Voici une liste des distributions valides qui peuvent être installées.
Installer en utilisant 'wsl.exe --install <Distro>'.

NAME                            FRIENDLY NAME
Ubuntu                          Ubuntu
Debian                          Debian GNU/Linux
kali-linux                      Kali Linux Rolling
Ubuntu-18.04                    Ubuntu 18.04 LTS
Ubuntu-20.04                    Ubuntu 20.04 LTS
Ubuntu-22.04                    Ubuntu 22.04 LTS
Ubuntu-24.04                    Ubuntu 24.04 LTS
OracleLinux_7_9                 Oracle Linux 7.9
OracleLinux_8_7                 Oracle Linux 8.7
OracleLinux_9_1                 Oracle Linux 9.1
openSUSE-Leap-15.6              openSUSE Leap 15.6
SUSE-Linux-Enterprise-15-SP5    SUSE Linux Enterprise 15 SP5
SUSE-Linux-Enterprise-15-SP6    SUSE Linux Enterprise 15 SP6
openSUSE-Tumbleweed             openSUSE Tumbleweed

Avec la commande wsl --install, la distribution installée par défaut sera normalement la dernière version LTS d'Ubuntu.

Mais il est possible d'installer également une 2e distribution spécifique qui nous intéresse. Par exemple, la 22.04 LTS, plus ancienne :

wsl --install -d Ubuntu-22.04

On peut alors lister toutes nos versions installées avec un wsl -l :

Ubuntu-22.04 (par défaut)
Ubuntu-24.04

Note : il faut bien se rappeler que chaque distribution est une instance bien différente avec un espace de stockage différent :
- toutes les instances Linux peuvent accéder aux fichiers du lecteur C:\ avec un cd /mnt/c/,
- mais depuis le PowerShell, on accède aux fichiers Linux via cd \\wsl$\Ubuntu-24.04 (ou cd \\wsl$\Ubuntu-22.04, etc.)

Maintenant que plusieurs instances WSL sont présentes sur Windows, il faudra penser à désigner la bonne à chaque commande wsl, histoire de ne rien laisser au hasard.

Pour cela, deux options s'offrent à nous :

soit sélectionner l'instance par défaut avec un wsl --set-default Ubuntu-24.04, qui sera implicitement choisie pour toutes les futures commandes wsl
soit indiquer l'instance utilisée uniquement pour la commande actuelle : wsl -d Ubuntu-22.04

Exécuter des commandes dans WSL depuis Windows

Avec l'argument --exec, on peut exécuter une commande simple directement dans la machine Linux, mais sans quitter son PowerShell ! 😯

Par exemple, avec cette commande qui nous permet d'obtenir la version du système :

wsl --exec cat /etc/os-release

Ce qui nous affiche :

PRETTY_NAME="Ubuntu 22.04.3 LTS"
NAME="Ubuntu"
VERSION_ID="22.04"
VERSION="22.04.3 LTS (Jammy Jellyfish)"
VERSION_CODENAME=jammy
ID=ubuntu
ID_LIKE=debian
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
UBUNTU_CODENAME=jammy

Et pour des commandes plus complexes, on peut exécuter un script bash présent sur le système de fichiers Linux :

wsl --exec ~/my_script.sh

D'expérience, lancer des commandes avec --exec permet de réduire les intermédiaires en agissant directement dans l'environnement voulu, ce qui est très pratique pour lancer des commandes dans une double virtualisation avec Docker Linux par exemple (voir section "Docker dans WSL").

Changer l'emplacement du disque virtuel WSL

Il n'y a pas de magie : s'il y a un système de fichiers persistant dans les WSL, c'est qu'il y a un emplacement de stockage réservé quelque part !

Les fichiers des environnements Linux sont en réalité stockés dans C:\Users\<UserName>\AppData\Local\Packages\CanonicalGroupLimited.<Distrib>_<ID>\LocalState\ sous forme de fichier *.vhdx.

Pour rappel, un fichier vhdx ou "Virtual Hard Disk V2" est un disque dur virtuel. Créé initialement par Connectix puis repris par Microsoft, il peut être utilisé avec les émulateurs VirtualBox, Parallels Desktop, ou Hyper-V. Il peut s'étendre jusqu'à 64 To (contre 2 To avec l'ancien format vhd).

Pour en revenir à notre espace de stockage WSL : si on voulait stocker nos instances sur un autre disque physique situé sur le lecteur D: ? (Au hasard, un bon SSD 🙃)

Eh bien, c'est possible. Pour déplacer ce fameux fichier VHDX :

wsl --shutdown
wsl --manage Ubuntu-24.04 --move D:\My-WSLs

Astuce n°2 : Une IHM avec WSLg

Nous avons appris comment installer et accéder à WSL en ligne de commande. Mais depuis le build 19044 de Windows 10 (et depuis le début de Windows 11), il est également possible d'exécuter des applications possédant une interface graphique. Ces applications sont alors intégrées dans notre environnement Windows (raccourci dans le menu démarrer, icône dans la barre des tâches durant l'exécution, accès au presse-papier, etc.)

Sur une machine Windows 10 sur laquelle WSL était déjà installé, il est nécessaire de réaliser quelques vérifications avant de lancer des applications :

1. Vérifier que la distribution se lance bien en mode WSL version 2

wsl --list --verbose

  NAME      STATE           VERSION
  * Ubuntu    Running         2

Si ce n'est pas le cas, la commande suivante y remédiera : wsl --set-version Ubuntu 2.

2. S'assurer que le noyau WSL soit à jour :

wsl --update
wsl --shutdown # Attention: cela équivaut a éteindre WSL, toute application éxécutée sera terminée"

Une fois cela fait, ou si la machine était suffisamment à jour, la manipulation est transparente :

On commence par installer une application possédant une interface graphique (ex : GIMP) : sudo apt install gimp

Il ne nous reste plus qu'à lancer l'application :

Soit par l'icône qui est apparue dans le menu démarrer (sous le dossier qui porte le nom de votre distribution)
Soit lancer l'application via une CLI ouverte dans la distribution WSL

L'application devrait maintenant s'afficher sur votre bureau.

Astuce n°3 : Docker dans WSL

Docker Desktop est le moyen le plus courant pour installer Docker sous Windows. Cependant l'application Docker Desktop (pas le moteur d'exécution de conteneur docker lui-même) requiert maintenant une licence dans un cadre professionnel pour toute entreprise d'une certaine taille.

Comment faire pour utiliser docker si nous n'avons pas besoin de Docker Desktop ?

Utilisons WSL !

Nous allons principalement suivre les instructions pour la distribution que nous avons installée, ici, Ubuntu : https://docs.docker.com/engine/install/ubuntu/.

Toute commande fournie ci-dessous devra être exécutée dans le contexte de votre distribution WSL, sauf mention contraire.

Commençons par nous assurer de commencer sur une base propre et de désinstaller tout paquet existant pouvant avoir un lien avec docker :

for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do sudo apt-get remove $pkg; done

Il est possible qu'aucun de ces paquets ne soient installés et qu'apt vous en notifie.

Configurons le dépôt apt de docker (pour avoir des versions à jour) :

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Maintenant, installons docker et ses utilitaires :

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Nous pouvons maintenant utiliser docker, mais nous avons besoin de le faire en utilisant sudo :

sudo docker run hello-world

Pour pouvoir l'utiliser de manière plus fluide, il nous faut ajouter notre utilisateur au groupe docker.

Commençons par le créer : sudo groupadd docker.

Puis, ajoutons ce groupe à notre utilisateur : sudo usermod -aG docker $USER.

Forçons la déconnexion en lançant depuis un terminal windows (non WSL) : wsl --shutdown.

Et nous pouvons maintenant utiliser : docker run hello-world.

Astuce bonus : un alias pour utiliser docker directement depuis windows

Sous PowerShell éditez votre fichier de profil :

notepad $profile.CurrentUserAllHosts

et ajoutez-y ce contenu :

function docker {
    wsl -- docker $args
}

Vous pourrez maintenant, pour vos prochaines sessions PowerShell appeler les commandes docker directement (ex : docker ps).

Pour CMD, la mise en place d'alias est bien plus complexe et sort du cadre de cet article.

Astuce n°4 : Passerelle USB avec Usbipd

D'accord, il est possible d'échanger des fichiers entre l'hôte Windows et l'environnement Linux. Mais qu'en est-il des périphériques USB ?

En vérité cette passerelle existe depuis un certain nombre d'années, mais aujourd'hui elle est grandement simplifiée avec l'outil en CLI usbipd.

Comme son nom l'indique, c'est un programme qui va ouvrir un canal d'échange TCP/IP sur un réseau local à la machine, et rediriger les flux d'un périphérique USB vers et depuis ce canal.

Notez qu'il existe une version IHM de l'outil (capture d'écran ci-dessus), mais en tant que développeurs, nous allons nous concentrer sur la version CLI qui nous offre une interopérabilité plus intéressante, par exemple avec des scripts.

Après avoir installé l'outil depuis le setup ou le package manager de Windows : winget install usbipd, nous allons être capables de lister les devices disponibles :

usbipd list

Connected:
BUSID  VID:PID    DEVICE                                                        STATE
2-6    0c45:6a17  Integrated Webcam, Integrated IR Webcam                       Not shared
2-10   8087:0033  Intel(R) Wireless Bluetooth(R)                                Not shared
13-6   0424:284c  Hub Feature Controller, Périphérique d’entrée USB             Not shared
14-3   0bda:8153  Realtek USB GbE Family Controller #2                          Not shared

Sur cette liste, on notera le BUSID qui nous permettra de désigner un périphérique spécifique à partager, ainsi que le STATE qui nous indique l'état de partage à proprement parler.

En ouvrant un PowerShell administrateur, on saisit la commande bind pour ouvrir un canal de partage, par exemple sur la webcam :

usbipd bind -b 2-6

À ce stade, si on liste à nouveaux les périphériques, on doit voir apparaître le statut Shared :

Connected:
BUSID  VID:PID    DEVICE                                                        STATE
2-6    0c45:6a17  Integrated Webcam, Integrated IR Webcam                       Shared

Il ne nous reste plus qu'à assigner le périphérique à une instance WSL :

usbipd attach --wsl --busid 2-6

usbipd: info: Using WSL distribution 'Ubuntu-22.04' to attach; the device will be available in all WSL 2 distributions.
usbipd: info: Using IP address 172.25.224.1 to reach the host.

Le device passe alors dans l'état Attached côté Windows, et apparaît dans le contexte Linux :

lsusb

Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 002: ID 0c45:6a17 Microdia Integrated_Webcam_FHD
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Le tour est joué ! 🙂

Le mot de la fin

Nous avons pu vous montrer plusieurs astuces assez étonnantes autour du WSL qui, en parallèle, continue d'évoluer, permettant ainsi de se passer d'outils de virtualisation lourde comme VirtualBox.

Si, comme nous, vous aimez en apprendre toujours plus, il reste encore d'autres sujets très intéressants à explorer du côté des IHM de configuration, de la nouvelle distribution Red Hat RHEL, ou encore de l'import/export des WSL sous forme de fichier, etc.

Cet article a été coécrit avec Antoine-Ali. N'hésitez pas à aller voir également ses publications !

‍

No items found.

ça t’a plu ?
Partage ce contenu

Jean-Noël

Jean-Noël aime sa guitare, sa PS4 (quoi de mieux que de réaliser un super combo sur sa manette) et coder... mais de préférence en Typescript !

Et oui, le Typescript, c’est son dada ! Il y a une très forte interopérabilité, le typage apporte de la rigueur au JS, et tout fonctionne très bien, très vite ! En revanche, quand il s’agit d’algorithmes, il préfère le Rust ! C’est le seul langage pour lequel, lorsqu’il a réussi à compiler, il peut respirer en criant : « MON CODE EST SUUUUR !!! ».

On ne sait pas si c’est pour pouvoir rédiger des tas d’articles pour le blog YOUNUP mais il nous a confié rêver de pouvoir regénérer ses cellules pour une jeunesse et un savoir sans limite. Un mix entre le film « Bienvenue à Gattaca » et les écrits de « Laurent Alexandre » ?

Retrouvez le sur Linkedin