---
title: "Installer et configurer Firefox sous Docker avec LinuxServer.io"
description: "Tu veux installer Firefox sous forme de conteneur Docker pour avoir une version ultra-légère et centralisée, mais tu te dis que c’est réservé aux experts ? Détrompe-toi. Même si tu as juste cliqué sur \"Installer\" sans comprendre comment ça marche jusqu’ici, ce tutoriel est fait pour toi. On va configurer Firefox en conteneur avec des fonctionnalités avancées comme le support GPU (Wayland) et une gestion sécurisée de tes données. Prêt·e à jouer avec Docker sans te prendre la tête ? C’est parti ! À la fin de ce tuto, tu auras :\n\nUn conteneur Docker exécutant Firefox avec une interface web (port 3000 pour HTTP et 3001 pour HTTPS).\n\nTes configurations sauvegardées dans un dossier persistant.\n\nLa"
canonical_url: "https://www.internetcreatif.fr/actualite/installer-et-configurer-firefox-sous-docker-avec-linuxserver-io-2/"
markdown_url: "https://www.internetcreatif.fr/actualite/installer-et-configurer-firefox-sous-docker-avec-linuxserver-io-2.md"
language: "fr-FR"
author: "internet"
date_published: "2026-07-03T05:05:00+00:00"
date_modified: "2026-08-03T05:07:03+00:00"
content_type: "article"
---

# Installer et configurer Firefox sous Docker avec LinuxServer.io

> Comment réussir « Installer et configurer Firefox sous Docker avec LinuxServer.io » sans erreur ?

Tu veux installer Firefox sous forme de conteneur Docker pour avoir une version ultra-légère et centralisée, mais tu te dis que c’est réservé aux experts ? Détrompe-toi. Même si tu as juste cliqué sur "Installer" sans comprendre comment ça marche jusqu’ici, ce tutoriel est fait pour toi. On va configurer Firefox en conteneur avec des fonctionnalités avancées comme le support GPU (Wayland) et une gestion sécurisée de tes données. Prêt·e à jouer avec Docker sans te prendre la tête ? C’est parti !
## 🎯 Résultat attendu : un Firefox ultra-rapide, accessible depuis ton navigateur préféré

![Un bureau Linux épuré avec un écran courbe affichant une session terminale en cours de clonage du dépôt Docker Firefox. L’éclairage doux met en valeur les touches tapées et le café à portée de main, symbolisant la préparation méthodique avant l’installation. ---](https://www.internetcreatif.fr/wp-content/uploads/2026/08/0ee1cdb2-c4b3-5f1e-bbf9-ac48ffe89b23_image1_0005.jpg)

À la fin de ce tuto, tu auras : - Un conteneur Docker exécutant Firefox avec une interface web (port 3000 pour HTTP et 3001 pour HTTPS).
- Tes configurations sauvegardées dans un dossier persistant.
- La possibilité d’utiliser des fonctionnalités avancées comme le support GPU si tu as une carte NVIDIA.
- Un accès sécurisé via un reverse proxy (optionnel mais recommandé).

 **⚠️ Prérequis : vérifie que ton système est prêt à rouler** Avant de commencer, assure-toi que : 1. **Tu utilises un système Linux compatible** (Ubuntu ou une dérivée). Si tu es sur Windows ou macOS, Docker Desktop devrait suffire, mais ce tuto se concentre sur la version serveur.
2. **Docker et Docker Compose sont installés**. Ouvre un terminal et tape : ```
docker --version
docker-compose --version
```

 Si tu vois des versions (ex: Docker 20.10+), c’est bon ! Sinon, installe-les depuis [le site officiel de Docker](https://docs.docker.com/get-docker/).
3. **Tu as les droits admin**. Certaines étapes nécessitent `sudo`. Si tu es en mode utilisateur standard, prévois de taper ton mot de passe à quelques reprises.
4. **Ton UID et GID sont connus**. Pour savoir si tu fais partie du groupe des admins locaux, tape : ```
id your_user
```

 Tu devrais voir quelque chose comme `uid=1000(your_user) gid=1000(your_user)`. Si ce n’est pas le cas, note ces valeurs (par exemple 1000), car on en aura besoin plus tard.

 **🛠️ Installation pas à pas : clone, configure, lance** **Étape 1 : Clone le dépôt du conteneur Firefox** On va récupérer les fichiers de configuration depuis GitHub. Ouvre ton terminal et tape : ```
git clone https://github.com/linuxserver/docker-firefox.git
cd docker-firefox
```

 Pas d’inquiétude si tu ne comprends pas tout : c’est juste une façon de télécharger les instructions pour créer le conteneur. **Étape 2 : Installe les dépendances système (libfuse2, git, gdb)** Pour que Firefox tourne sans problème, il faut installer quelques paquets. Ajoute-les via Docker Mods : ```
-e DOCKER_MODS=linuxserver/mods:universal-package-install
-e INSTALL_PACKAGES=libfuse2|git|gdb
```

 Ces paquets sont essentiels pour les fonctionnalités avancées comme le support Wayland ou la débogage.
## Étape 3 : Lance le conteneur avec Docker

![Un rack serveur Linux avec un conteneur Docker Firefox en cours d’exécution, affichant les ports 3000 et 3001 actifs. Un terminal vérifie le statut du conteneur : "Firefox écoute sur :3000 (HTTP) et :3001 (HTTPS)." L’éclairage des serveurs crée une ambiance technique professionnelle. ---](https://www.internetcreatif.fr/wp-content/uploads/2026/08/0ee1cdb2-c4b3-5f1e-bbf9-ac48ffe89b23_image2_0004.jpg)

Maintenant, c’est l’heure de lancer Firefox ! Copie-colle cette commande dans ton terminal (attention aux espaces et tirets) : ```
docker run -d 
          --name=firefox 
          -e PUID=1000 
          -e PGID=1000 
          -p 3000:3000 
          -p 3001:3001 
          -v /path/to/firefox/config:/config 
          --shm-size="1gb" 
          lscr.io/linuxserver/firefox:latest
```

 **Explications des options :** - `-e PUID=1000 -e PGID=1000` : Remplace 1000 par ton UID/GID si tu as vérifié autre chose à l’étape précédente.
- `-v /path/to/firefox/config:/config` : Crée un dossier (ex: `mkdir ~/firefox_config`) et remplace `/path/to/firefox/config` par son chemin. C’est là que seront stockées tes données Firefox.
- `--shm-size="1gb"` : Alloue 1 Go de mémoire partagée pour éviter les bugs liés aux performances.

 **🎨 Configuration et premier démarrage : personnalise ton Firefox** **Optionnel : Définis une résolution manuelle** Si tu veux forcer une résolution spécifique (ex: 1920x1080), ajoute ces variables : ```
-e SELKIES_MANUAL_WIDTH=1920
-e SELKIES_MANUAL_HEIGHT=1080
-e MAX_RES=1920x1080
```

 Parfait si tu utilises Firefox pour du streaming ou des jeux en ligne. **Activer le support GPU (Wayland) avec NVIDIA** Si tu as une carte graphique NVIDIA et que tu veux profiter du rendu Wayland, il faut : 1. **Configurer GRUB pour activer les pilotes NVIDIA**. Ouvre un éditeur de texte avec `sudo` : ```
sudo nano /etc/default/grub
```

 Ajoute ces options à la ligne `GRUB_CMDLINE_LINUX_DEFAULT` (sans supprimer ce qui existe déjà) : ```
nvidia-drm.modeset=1 nvidia_drm.fbdev=1
```

 Enregistre avec Ctrl+O, puis quitte avec Ctrl+X. Mise à jour de GRUB : ```
sudo update-grub
```
2. **Active le runtime NVIDIA pour Docker** : ```
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```
3. **Lance le conteneur avec les options GPU**. Ajoute ces variables à ta commande `docker run` : ```
-e PIXELFLUX_WAYLAND=true
-v /dev/dri:/dev/dri
-e DRINODE=/dev/dri/renderD128
-e DRI_NODE=/dev/dri/renderD128
```

 **Accède à Firefox via ton navigateur** Ouvre un navigateur (Chrome, Firefox local, etc.) et tape : <a href="https://:3001" target="_blank">https://:3001 Remplace `` par l’adresse IP de ta machine. Tu devrais voir l’interface web de Firefox ! **Optionnel : Ajoute une authentification basique** Pour sécuriser un peu plus ton accès local, ajoute ces variables à ta commande `docker run` : ```
-e CUSTOM_USER=utilisateur
-e PASSWORD=motsdepasse
```

 Remplace `utilisateur` et `motsdepasse` par tes propres identifiants. Maintenant, tu devras te connecter pour accéder à Firefox.
## 🔍 Vérifications : tout fonctionne comme un charme ?

![Un double écran dans un bureau à domicile : l’un montre Firefox accessible via une interface web avec des onglets ouverts, l’autre affiche les logs du conteneur sans erreurs. La lumière naturelle éclaire le poste de travail, soulignant la fluidité du fonctionnement. ---](https://www.internetcreatif.fr/wp-content/uploads/2026/08/0ee1cdb2-c4b3-5f1e-bbf9-ac48ffe89b23_image3_0004.jpg)

**Vérifie les logs du conteneur** Si Firefox ne répond pas ou plante, consulte ses logs : ```
docker logs firefox
```

 Ou en temps réel pour suivre les erreurs : ```
docker logs -f firefox
```

 **Teste les ports et la résolution** Vérifie que les ports sont bien ouverts avec : ```
curl -v http://localhost:3000
curl -v https://localhost:3001
```

 Si tu vois des réponses HTTP/HTTPS, c’est bon ! Pour tester la résolution, ouvre Firefox dans le conteneur et vérifie que l’affichage correspond à ce que tu as configuré. **Vérifie la version du conteneur** Pour savoir quelle version de Firefox tourne : ```
docker inspect -f '{{ index .Config.Labels "build_version" }}' firefox
```

 **🛡️ Sécurisation : protège ton conteneur comme un·e pro** **Utilise un reverse proxy (HTTPS obligatoire)** Exposer Firefox directement sur Internet est risqué. Au lieu de ça, utilise un reverse proxy comme SWAG ou Nginx pour chiffrer le trafic. Voici comment : 1. Installe SWAG (ou ton choix) et configure-le pour rediriger les ports 3000/3001 vers HTTPS.
2. Désactive l’authentification basique si tu utilises un proxy, car celui-ci gérera déjà la sécurité.

 **Désactive les ports inutiles** Si tu ne veux pas exposer Firefox sur le réseau local non plus, retire les options `-p 3000:3000` et `-p 3001:3001` de ta commande `docker run`. Accède alors uniquement via `localhost`. **❌ Problèmes fréquents : que faire si ça coince ?** 1. **Erreur "Permission denied" sur `/dev/dri`** : Ajoute ton utilisateur au groupe `video` avec : ```
sudo usermod -aG video $USER
```

 Redémarre ta session ou tape `newgrp video`.
2. **Firefox ne se lance pas après une mise à jour** : Vérifie les logs avec `docker logs firefox` et relance le conteneur avec `--restart unless-stopped`.
3. **Problème de résolution ou d’affichage** : Redéfini les variables `SELKIES_MANUAL_WIDTH`, `SELKIES_MANUAL_HEIGHT` et `MAX_RES` dans ta commande `docker run`.

 **🔄 Mise à jour et désinstallation : quand tu veux tout nettoyer** **Mettre à jour le conteneur** Pour mettre à jour Firefox vers la dernière version : ```
docker-compose pull firefox
docker-compose up -d firefox
```

 Ou si tu utilises `docker run` directement : ```
docker stop firefox
docker rm firefox
docker pull lscr.io/linuxserver/firefox:latest
docker run [tes options] lscr.io/linuxserver/firefox:latest
```

 **Désinstaller proprement** Pour arrêter et supprimer le conteneur : ```
docker stop firefox
docker rm firefox
```

 Supprime aussi ton dossier de configuration (`/path/to/firefox/config`) si tu ne veux plus garder tes données.
## Conclusion

![Une personne assise devant un bureau épuré ouvrant Firefox dans le conteneur depuis son navigateur local. L’écran montre une connexion sécurisée avec vérification HTTPS, et un carnet note des prochaines personnalisations. La lumière chaleureuse souligne la satisfaction du travail accompli. ---](https://www.internetcreatif.fr/wp-content/uploads/2026/08/0ee1cdb2-c4b3-5f1e-bbf9-ac48ffe89b23_image4_0004.jpg)

Tu as réussi à installer et configurer Firefox en conteneur avec des fonctionnalités avancées comme le support GPU Wayland ou une résolution personnalisée. Même si au début ça peut sembler compliqué, une fois que tu as tout en place, c’est ultra-rapide pour lancer un navigateur sécurisé et centralisé. > *"Et voilà ! Plus besoin de s’inquiéter des mises à jour ou des conflits logiciels : ton Firefox tourne dans un conteneur, comme par magie. Maintenant, va tester tes sites préférés depuis ton navigateur web préféré… et dis-toi que tu as fait ça tout seul·e."*

 Si tu veux aller plus loin, explore les options de Docker Compose pour automatiser encore plus ton setup ou ajoute des extensions via le dossier `/config`. Et n’oublie pas : la technologie est là pour rendre ta vie plus simple… alors profite-en ! 🚀 Source : https://github.com/linuxserver/docker-firefox
