# Linux # 🔗 Les alias Linux : créer des raccourcis dans le terminal Les alias permettent de créer des raccourcis personnalisés pour des commandes Linux. Ils sont très utiles pour simplifier des commandes longues ou ajouter des options par défaut. --- ## 📑 Sommaire - [Définition d’un alias](#bkmrk-%F0%9F%94%A7-qu%E2%80%99est-ce-qu%E2%80%99un-al) - [Exemple classique : ll et ls](#bkmrk-%F0%9F%93%82-exemple-classique-) - [Créer un alias](#bkmrk-%E2%9E%95-cr%C3%A9er-un-alias) - [Lister les alias](#bkmrk-%F0%9F%93%8B-lister-les-alias-e) - [Supprimer un alias](#remove) - [Contourner un alias](#bkmrk-%F0%9F%9A%AB-ex%C3%A9cuter-la-comman) - [Exemples pratiques](#bkmrk-%E2%9A%99%EF%B8%8F-exemples-pratique) - [Persistance (.bashrc)](#bkmrk-%F0%9F%92%BE-rendre-les-alias-p) --- ## 🔧 Qu’est-ce qu’un alias ?

**Information** Un alias est un raccourci qui remplace une commande par une autre.

Exemple : ``` ll = ls -l ``` Lorsque vous tapez `ll`, Linux exécute en réalité `ls -l`. --- ## 📂 Exemple classique : ll, la et l Sur certaines distributions, ces alias ne sont pas activés par défaut. ``` ll ``` Peut donner : ``` ll : commande introuvable ```

**Attention** Les alias peuvent varier selon les distributions (Ubuntu, Debian, CentOS, Fedora...).

Les commandes équivalentes sans alias sont : ``` ls -l ls -la ls -CF ``` \--- ## ➕ Créer un alias ### Syntaxe ``` alias nom='commande' ``` ### Exemple simple ``` alias ll='ls -l' ``` ### Exemple avec options ``` alias la='ls -la' alias l='ls -CF' ``` \---

**Astuce** Les alias sont actifs uniquement dans le shell courant (temporaire).

\--- ## 📋 Lister les alias existants ``` alias ``` Exemple de sortie : ``` alias ll='ls --color=auto -l' alias la='ls --color=auto -la' ``` \--- ## 🗑️ Supprimer un alias ### Syntaxe ``` unalias nom ``` ### Exemple ``` unalias ll ``` Cela supprime l’alias uniquement dans la session actuelle. \--- ### Supprimer tous les alias ``` unalias -a ``` \--- ## 🚫 Exécuter la commande sans alias Si un alias existe mais que vous voulez exécuter la commande originale : ``` \ls ``` Le backslash ignore les alias. \---

**Important** Un alias peut masquer une commande système. Toujours vérifier avec `type`.

\--- ### Vérifier si une commande est un alias ``` type ls ``` Exemple : ``` ls is aliased to `ls --color=auto' ``` \--- ## ⚙️ Exemples pratiques réels ### 🧩 1. Alias pour cp sécurisé Ajout du mode interactif pour éviter les écrasements accidentels : ``` alias cp='cp -i' ``` \--- ### 🧩 2. Alias de sauvegarde automatique ``` alias safecp='cp --backup=numbered' ``` \--- ### 🧩 3. Alias utile pour logs ``` alias log='journalctl -xe' ``` \--- ### 🧩 4. Alias dangereux à éviter ``` alias rm='rm -i' ``` Utile pour éviter les suppressions accidentelles, mais peut gêner les scripts. \--- ## 🔁 Exemple complet : cp + alias + suppression ``` alias cp='cp -i' cp fichier1 fichier2 ``` Résultat : confirmation avant écrasement. Supprimer l’alias : ``` unalias cp ``` \--- ## 💾 Rendre les alias permanents (.bashrc)

**Information** Les alias créés avec la commande `alias` disparaissent à la fermeture du terminal.

Pour les conserver : ``` nano ~/.bashrc ``` Ajouter : ``` alias ll='ls -l' alias la='ls -la' alias l='ls -CF' ``` Puis appliquer : ``` source ~/.bashrc ``` \--- ### Alternative : sans modifier .bashrc Vous pouvez aussi créer des alias uniquement pour la session actuelle : ``` alias ll='ls -l' ``` Ils seront supprimés à la déconnexion. \---

**Bonnes pratiques**- Éviter de surcharger les commandes critiques (rm, cp, mv) dans les scripts - Documenter ses alias personnalisés - Utiliser type pour diagnostiquer un comportement étrange

\--- ## 📌 Résumé

Commande	Action
`alias ll='ls -l'`	Créer un alias
`alias`	Afficher les alias
`unalias ll`	Supprimer un alias
`unalias -a`	Supprimer tous les alias
`\ls`	Ignorer les alias
`type ls`	Vérifier alias/commande

\---

**À retenir** Les alias sont des raccourcis temporaires puissants pour améliorer la productivité dans le terminal Linux.

# Ajouter un utilisateur sudo [![sudo.jpg](https://kb.numericare.fr/uploads/images/gallery/2019-09/scaled-1680-/YTXLOhaUYn0FUT3p-sudo.jpg)](https://kb.numericare.fr/uploads/images/gallery/2019-09/YTXLOhaUYn0FUT3p-sudo.jpg) La commande sudo est un programme conçu pour permettre aux utilisateurs d'exécuter des commandes avec les privilèges de sécurité d'un autre utilisateur. Par défaut, l'utilisateur root Dans ce guide, nous allons vous montrer comment créer un nouvel utilisateur sur un système Debian et lui donner un accès sudo Vous pouvez utiliser ce compte utilisateur pour exécuter des commandes admins sans vous connecter à votre serveur Debian en tant qu'utilisateur root. ## Créer un utilisateur Sudo Suivez les étapes ci-dessous pour créer un nouveau compte utilisateur et lui donner un accès sudo. Si vous souhaitez configurer sudo pour un utilisateur existant, passez à l'étape 3. ### 1. Se connecter à la machine Linux Se connecter en premier lieu avec le compte root de la machine ### 2. Création d'un compte utilisateur Créer un utilsateur en utilisant la commande `adduser`. Ne pas oublier de remplacer `username` par le nom d'utilisateur à créer : ```console-bash adduser username ```

Le terminal vous demande de taper le mot de passe pour le nouvel utilisateur et de confirmer. Pensez à créer un mot de passe suffisamment sécurisé (combinaison de lettres, chiffres et caractères spéciaux).

```output Adding user `username' ... Adding new group `username' (1001) ... Adding new user `username' (1001) with group `username' ... Creating home directory `/home/username' ... Copying files from `/etc/skel' ... New password: Retype new password: passwd: password updated successfully ``` Une fois que vous avez défini le mot de passe pour l'utilisateur, la commande créée un répertoire de base pour l'utilisateur, copie plusieurs fichiers de configuration dans le répertoire de base et vous invite à définir les informations du nouvel utilisateur. Si vous souhaitez laisser toutes ces informations vides, appuyez simplement sur `ENTER` pour tout accepter sans rien remplir. ```chroma Changing the user information for username Enter the new value, or press ENTER for the default Full Name []: Room Number []: Work Phone []: Home Phone []: Other []: Is the information correct? [Y/n] ``` ### 3. Ajouter l'utilisateur au groupe sudo Par défaut, sur les systèmes Debian, les membres du groupe sudo ont un accès sudo. Pour ajouter un utilisateur au groupe sudo, utilisez la commande `usermod` . Remplacer username par le nom d'utilisateur créé plus haut : ```chroma usermod -aG sudo username ``` ### Tester l'accès sudo Basculer sur le compte utilisateur créé : ```console-bash su - username ```

Utiliser la commande sudo `whoami` pour savoir si vous êtes connecté avec le bon compte :

```console-bash sudo whoami ```

Si l'utilisateur a un accès sudo, le résultat de la commande `whoami` sera `root`:

```chroma root ``` ## Le cas où sudo n'est pas installé. Dans cette partie nous allons voir le cas ou sudo n'est pas installé par défaut. C'est le cas par exemple sur la version cd de Debian. ### I L'installation de sudo en fonction de l'OS. Dans le cas d'un debian ou ubuntu : ``` apt-get install sudo ``` Dans le cas d'un red hat ou CentOS : ``` yum install sudo ``` ### II Ajout de droits sur un utilisateur : Dans ce cas, la création d'un utilisateur est nécessaire. Il faut donc faire en sorte d'avoir les droits root. ``` adduser su #se mettre en root ``` On va donc ensuite modifier le fichier qui modifie les droits sudo via cette commande : ``` visudo ``` ## Conclusion Vous avez appris à créer un utilisateur avec les privilèges sudo. Vous pouvez maintenant vous connecter à votre serveur Debian avec ce compte utilisateur et utiliser sudo pour exécuter des commandes admins # DDClient - DynDns Client # Automatiser la gestion des adresses IP dynamiques **ddclient** permet d'automatiser la mise à jour d'une [adresse IP dynamique](https://doc.ubuntu-fr.org/dns_dynamique "dns_dynamique") reliée à un nom de domaine (de 213.95.41.11 à www.ubuntu-fr.org par exemple). Ce système est extrêmement pratique quand il s'agit de créer un serveur web personnel accessible rapidement *via* un nom de domaine, alors que votre adresse IP change régulièrement.

## Pré-requis

S'être inscrit sur l'un des services pris en charge. Pour les connaître, saisissez dans un [terminal](https://doc.ubuntu-fr.org/terminal "terminal") la [commande](https://doc.ubuntu-fr.org/commande_shell "commande_shell") suivante :

``` ddclient --help | grep "o '" ``` -

Disposer des [droits d'administration](https://doc.ubuntu-fr.org/sudo "sudo").

Disposer d'une connexion à Internet configurée et activée.

Avoir activé l'accès aux [dépôts Universe et Multiverse](https://doc.ubuntu-fr.org/depots#universe_et_multiverse "depots").

## Installation [Installez le paquet](https://doc.ubuntu-fr.org/tutoriel/comment_installer_un_paquet "tutoriel:comment_installer_un_paquet") **ddclient**. ``` sudo apt install -y ddclient ``` La touche espace sert à sélectionner la redirection "\[\] Nomduhost.dyndns.com"

## Configuration Commencez par générer le fichier de configuration en tapant : ``` sudo dpkg-reconfigure ddclient ``` Tout d'abord, vous devrez spécifier le service à utiliser. Le ou les noms de domaines qui pointeront vers l'adresse IP dynamique. L'identifiant et le mot de passe avec lesquels vous vous êtes inscrit au service. ddclient peut prendre connaissance de l'adresse IP dynamique de diverses manières :

Paramètre	Signification
web	à partir d'une page web
if	par une interface réseau (ex : ppp0, eth0…)
fw	en interrogeant le routeur
cmd	en exécutant une commande

Si vous avez choisi une autre option que « web », il sera nécessaire de [modifier le fichier](https://doc.ubuntu-fr.org/tutoriel/comment_modifier_un_fichier "tutoriel:comment_modifier_un_fichier") « /etc/ddclient.conf » par la suite afin de spécifier l'interface, l'adresse IP du routeur ou la commande à employer.

Si vous êtes derrière un routeur, ce n'est pas l'ordinateur qui initiera la connexion. Par conséquent, répondez « Non » à la question « Faut-il lancer ddclient lors de la connexion PPP ? ». L'avant-dernière question vous propose de faire tourner ddclient en tâche de fond (daemon). Puisque le but est d'automatiser la mise à jour de l'adresse IP, répondez « Oui ». Enfin, vous pouvez définir un délai entre les vérifications. Par défaut, celles-ci s'effectueront toutes les 300 secondes (5 minutes).

### ddclient.conf Maintenant que vous avez répondu aux questions, nous pouvons [modifier le fichier](https://doc.ubuntu-fr.org/tutoriel/comment_modifier_un_fichier "tutoriel:comment_modifier_un_fichier") « /etc/ddclient.conf » afin d'affiner les réglages. Celui-ci se présente sous cette forme : ``` pid=/var/run/ddclient.pid ssl=yes protocol=dyndns2 #ou zoneedit1 si vous utilisez zoneedit use=web server=members.dyndns.org #ou dynamic.zoneedit.com si vous utilisez zoneedit login=identifiant password='motdepasse' nom.de.domaine #si plusieurs nom de domaine, separez par ',' ``` Exemple de configuration DynDns OVH : ``` protocol=dyndns2

use=web

server=www.ovh.com

login=my-domain.com-user

password='passworddemy-domain.com-user'

subdomain.my-domain.com

use=web

server=www.ovh.com

login=my-domain.com-user1

password='passworddemy-domain.com-user1'

subdomain1.my-domain.com

# ... ```

Si vous utilisez l'option « `ssl=yes` », veillez à ce que le paquet libio-socket-ssl-perl soit installé. Votre version de ddclient doit être supérieure à 3.7.0 (cf. [le site de DynDNS](http://www.dyndns.com/support/kb/using_ddclient_with_dyndns_services.html#secure "http://www.dyndns.com/support/kb/using_ddclient_with_dyndns_services.html#secure")).

Option	Signification
ssl	connexion sécurisé lors de l'échange avec DynDNS
protocol	service utilisé pour effectuer la liaison
use	comment identifier l'adresse IP
server	serveur utilisé pour effectuer la mise à jour
login	l'identifiant pour le service
password	le mot de passe pour le service
wildcard	Définit si les adresses du type \*.nom.de.domaine fonctionnerons

Intéressons nous à l'option **use**. Celle-ci accepte plusieurs paramètres :

Paramètre	Signification
web	donne l'adresse IP à partir d'une page web (par défaut)
cmd	donne l'adresse IP en exécutant une commande
fw	donne l'adresse IP en interrogeant un routeur
if	donne l'adresse IP à partir d'une interface réseau (ex. : ppp0, eth0, etc.)
ip	donne l'adresse IP à partir d'une adresse IP

Pour utiliser la plupart de ces paramètres, il vous faudra rajouter quelques lignes au fichier de configuration. Exemple d'obtention à partir d'une interface réseau : ``` use=if if=ppp0 ``` Exemple d'interrogation d'un routeur : ``` use=fw fw=ip_du_routeur fw-login=identifiant_du_routeur fw-password=motdepasse_du_routeur ```

Par défaut, ddclient récupère la première adresse IP qu'il trouve. Lorsque l'option **fw** est utilisée, il est possible que votre routeur ne fournisse pas la bonne. Pour palier ce problème, vous avez la possibilité de spécifier directement le modèle du routeur. Pour obtenir la liste des routeurs pris en charge par la version de ddclient installée, saisissez la commande suivante :

``` ddclient --help | grep use= ``` Pour vérifier que la configuration fonctionne: ``` sudo ddclient -daemon=0 -debug -verbose -noquiet ```

ddclient utilise un fichier cache en local afin d'éviter de trop solliciter le serveur (certains serveurs limitent la périodicité des mises à jour). On peut alors voir apparaître le message **skipped: IP address was already set to xxx.xxx.xxx.xxx**

Il est alors nécessaire de supprimer le cache local, afin de forcer ddclient à mettre à jour le serveur : ``` sudo rm /var/cache/ddclient/ddclient.cache ``` Exemple de configuration pour le service noip (fichier ddclient.conf) : ``` ssl=yes protocol=noip use=web, web=checkip.dyndns.com/, web-skip='Current IP Address' server=dynupdate.no-ip.com login=votrelogin password='motdepasse' votreserveur.no-ip.biz ```

### Ajout d'un enregistrement MX à votredomaine.dyndns.org → Voir l'[article Wikipédia](https://fr.wikipedia.org/wiki/Domain_Name_System#MX_record "https://fr.wikipedia.org/wiki/Domain_Name_System#MX_record") pour la définition et son utilité. L'astuce ici est de créer un second enregistrement sur votre compte *dyndns.org* du style **mxvotredomaine.dyndns.org** et qui sera également mis à jour par le démon. Après avoir créé **mxvotredomaine.dyndns.org**, il vous faut [modifier le fichier](https://doc.ubuntu-fr.org/tutoriel/comment_modifier_un_fichier "tutoriel:comment_modifier_un_fichier") **/etc/ddclient.conf** de la sorte : ``` pid=/var/run/ddclient.pid protocol=dyndns2 use=web #use=if; if=web server=members.dyndns.org login=votre_login password='votre_password' mx=mxvotredomaine.dyndns.org ← Adresse de l'enregistrement MX backupmx=no ← Votre enregistrement MX est prioritaire votredomaine.dyndns.org,mxvotredomaine.dyndns.org ← Mise à jour de l'adresse MX ``` Rechargez ensuite **ddclient** : ``` sudo /etc/init.d/ddclient force-reload ```

### Réglage complémentaire avec FreeDNS Si vous utilisez un sous-domaine fourni par FreeDNS, il se peut que vous soyez confronté à ce message d'erreur : >

FATAL: Error loading the Perl module Digest::SHA1 needed for freedns update. > FATAL: On Debian, the package libdigest-sha1-perl must be installed.

En attendant que le problème soit corrigé, il est possible de [modifier le fichier](https://doc.ubuntu-fr.org/tutoriel/comment_modifier_un_fichier "tutoriel:comment_modifier_un_fichier") **/usr/sbin/ddclient** et de remplacer « `require Digest::SHA1` » par « `require Digest::SHA` » et « `import Digest::SHA1` » par « `import Digest::SHA` ». Source : *[Ask Ubuntu : How can I get ddclient to work with FreeDNS?](http://askubuntu.com/questions/211173/how-can-i-get-ddclient-to-work-with-freedns "http://askubuntu.com/questions/211173/how-can-i-get-ddclient-to-work-with-freedns")*

## Désinstallation Pour supprimer cette application, il suffit de [supprimer son paquet](https://doc.ubuntu-fr.org/tutoriel/comment_supprimer_un_paquet "tutoriel:comment_supprimer_un_paquet"). La configuration de l'application sera conservée ou supprimée selon la méthode de désinstallation que vous choisirez. # Grub ## Apprenez à maitriser Grub ! Déjà, qu'est ce que Grub ? Derrière ce nom barbare se cache un programme très utile aux utilisateurs de Linux. En vérité Grub est ce qu'on appelle un chargeur d'amorçage, ou (pour les anglophones *bootloader*). L'acronyme signifie **the GRand Unified Bootloader** ou littéralement **le Grand Chargeur Unifié**. Je sais, ça ne veux rien dire ^^ mais ne vous inquiétez pas, nous allons clarifier ça tout au long de ce tutoriel.

- Note : le tuto était au départ destiné à la première version de Grub, mais une nouvelle version étant apparue entre temps, j'ai dû adapter le tuto pour les faire cohabiter. Ce tutoriel va donc vous proposer de configurer aussi bien Grub que Grub2 (Grub-pc). Ainsi, si vous voyez une mauvaise référence à l'ancienne version ou une manipulation qui n'est plus à jour (malgré le soin de mes petites mains et de celles de toute l'équipe), merci de me le signaler ! ;)

## Histoire et fonctionnement de Grub

Parlons tout d'abords du bien connu projet GNU. ## Sa création

Le projet GNU a été créé par Richard Stallman en 1984 alors qu'il travaillait au MIT (au laboratoire d'intelligence artificielle). Il souhaitait selon ses dires créer un système d'exploitation libre et complet pour "ramener l'esprit de coopération qui prévalait dans la communauté informatique dans les jours anciens". La mascotte de GNU est un gnou (en raison de sa prononciation anglophone).

![Image utilisateur](https://pub.phyks.me/sdz/sdz/medias/uploads.siteduzero.com_files_61001_62000_61641.png)

Le terme GNU est un acronyme récursif pour Gnu's Not Unix (Gnu N'est pas Unix). Il faut savoir qu'au moment de la création du projet GNU, le système UNIX était déjà bien lancé et reconnu par les informaticiens. GNU fut donc créé dans le but d'être compatible avec ce système. En 1985, Stallman fonde la Free Software Foundation, structure logistique, légale et financière du projet GNU. La FSF finance le développement du projet GNU et ce sont pour la plupart des communautés étudiantes américaines qui ont rendu ce projet viable. Le projet GNU se développe rapidement si bien que plusieurs sociétés contribuent au projet GNU en revendant ses logiciels, ou en offrant un support technique. En 1990, GNU dispose de son propre éditeur de texte (Emacs), de son compilateur (GCC) et de la plupart des bibliothèques dont dispose Unix. Mais il manque encore un noyau. Les systèmes 100% GNU sont des utopies mais il existe certains systèmes s'en approchant (comme [Debian](http://www.debian.org/index.fr.html)). La totalité des distributions de Linux sont plus ou moins apparentées au projet GNU au point que Richard Stallman défendait l'appellation *distribution GNU/Linux*. A ce stade, il manquait encore une pièce du puzzle : le noyau, et c'est ici que Linux fait son apparition.

---

## L'arrivée de Grub

Grub est un programme de [multiboot](http://fr.wikipedia.org/wiki/Multiboot) libre et gratuit. Ce genre de programme se nomme **bootloader***ou***chargeur d'amorçage**. Il permet de choisir entre plusieurs systèmes d'exploitation (*OS*) sur une seul machine. Grub a été créé en 1995 par Erich Boleyn à l'université de l'Utah. Avec l'aide de Brian FORD, il a créé un lanceur de multiboot. Erich a compris qu'il aurait plus vite fait d'écrire son propre chargeur plutôt que d'en modifier un autre.

Erich a ajouté de nombreuses fonctions à GRUB, mais d'autres priorités l'ont empêché de suivre les demandes du nombre croissant d'utilisateurs. En 1999, Gordon Matzigkeit et Yoshinori K. Okuji ont adopté GRUB comme un projet GNU officiel. Sa principale fonction est de pouvoir supporter la spécification multiboot. Ses concepteurs voulait qu'il soit en même temps :

- Simple d'utilisation ; - Fonctionnel pour les experts et les concepteurs de noyau ; - Qu'il soit compatible avec les systèmes du moment.

Grub possède une interface de commande. Elle s'affiche automatiquement si il manque un fichier de configuration ou si il y a une erreur. Contrairement à [LILO](http://fr.wikipedia.org/wiki/Linux_loader), GRUB n'a pas besoin d'être réinstallé pour mettre à jour sa configuration. Une simple commande permet sa mise à jour `sudo update-grub` GRUB est par ailleurs très flexible : il permet de charger aussi bien des systèmes compatibles avec le multiboot que des systèmes non-compatibles avec cette fonction (comme Microsoft Windows). Il supporte en outre beaucoup de [systèmes de fichiers](http://www.siteduzero.com/tuto-3-16701-1-partitionner-son-disque.html#ss_part_2) comme ext3, VFAT ou NTFS. GRUB est également compatible avec le mode [Logical Block Address](http://en.wikipedia.org/wiki/Logical_block_addressing) (anglais et pas très utile ici ^^ ).

---

## Le boot

Venons en au boot. What ? Héhé :p

Citation : Wikipédia > En informatique, le mot boot (apocope du mot anglais bootstrap, nom qui désigne la languette des chaussures pour pouvoir les enfiler plus facilement, voir la partie Historique de l'article pour plus de précisions) désigne la procédure de démarrage d'un ordinateur. En français son usage est un anglicisme, il peut être employé de façon synonyme avec le mot amorçage (du verbe amorcer) de même que le mot bootable est synonyme d'amorçable. Initialement lorsque les ordinateurs n'avaient pas encore de disque dur, cette procédure nécessitait l'usage d'une disquette souple de 5"1/4 ; toutefois actuellement ce terme est également employé lorsqu'il s'agit d'un autre médium comme un CD, un DVD une clef USB, ou encore un accès réseau. > > On distingue : > > \* le « boot à froid » (cold boot), obtenu en allumant la machine, ou en l'éteignant puis en la rallumant ; > \* du « boot à chaud » (warm boot), ou «re-boot», obtenu en redémarrant. L'option est présente au niveau du système d'exploitation.

Derrière ce pavé se cache une notion fondamentale de l'informatique. Tout d'abord, en anglais, TO BOOT signifie INITIALISER. En informatique, la procédure de boot est le démarrage de l'ordinateur en "passant la main" à un système d'exploitation.

\-------------------------------------------------------------------------------------------------------------------------------------------- Que se passe-t-il entre le moment où vous appuyez sur le bouton de mise sous tension de votre ordinateur et le moment où vous voyez le logo de votre OS avec sa barre de chargement ?

![Image utilisateur](https://pub.phyks.me/sdz/sdz/medias/uploads.siteduzero.com_files_61001_62000_61669.png)

Pendant le moment ou vous voyez les écrans publicitaires avec les marques et logos de votre PC, un programme se charge : le BIOS. Le BIOS (ou Basic Input Output System) va lire le MBR (Master Boot Record), premier secteur d'un disque dur ou se trouve la table des partitions et un programme : le bootloader. Ce superbe programme, stocké sur la ROM (mémoire morte) ou sur la mémoire vive, va extraire le noyau du système d'exploitation (kernel en anglais) qui fera le lien entre logiciel et matériel et donne sa dernière instruction : l'exécuter. Et ce bootloader cela peut être Grub. Voila pour le début, la partie la plus ennuyeuse est passée. :p

---

## Installation de Grub

Vous allez ici apprendre à installer Grub2 sur votre machine. Depuis la version 2, c'est devenu très facile ! ;) **ATTENTION !** La partie qui suit comporte certains risques, minimes certes mais pas inexistants. Les opération décrites ici ont été effectuées par des millions de gens mais je ne saurais être tenu responsable des éventuels dommages rencontrés si vous vous écartez hors des sentiers battus. ## Installation

Installer Grub2 n'est pas difficile, il vous suffit d'installer le paquet *grub-pc*, puis de lancer la configuration automatique : ``` $ sudo apt-get install grub-pc $ sudo grub-install /dev/sdX // Remplacez le X par la lettre de votre disque-dur dans /dev/ (Exemple: /dev/sda) $ sudo update-grub ``` Grub-install copiera tous les fichiers dont grub-pc a besoin dans le dossier /boot et la commande update-grub génèrera un nouveau fichier grub.cfg (voir plus loin).

---

## Upgrade depuis la version précédente

La première version de Grub est peut-être déjà installée sur votre machine. Il est alors possible que Grub2 soit automatiquement mis à jour si la version de votre système est récente, mais pour les versions antérieures, vous serez probablement amenés à effectuer les manipulations suivantes : ``` $ sudo apt-get install grub-pc $ sudo upgrade-from-grub-legacy ``` Durant l'installation, vous devrez configurer le disque sur lequel se trouve la partition /boot.

![Image utilisateur](https://pub.phyks.me/sdz/sdz/medias/uploads.siteduzero.com_files_205001_206000_205944.png)

Voila, GRUB est enfin installé. Si tout s'est bien passé, félicitations à vous. Si ce n'est pas le cas, reportez-vous à la partie "Réparation et Restauration" (en cours de rédaction :-° ) ou en attendant, aux forums ou bien envoyez moi un [MP](http://www.siteduzero.com/mp-273-33351.html) ;)

---

## Configurez Grub2

Ce chapitre va vous permettre de vous faire la main avec Grub2 et de le configurer à vos envies. A vos claviers !

## Mise au point

Voici d'abord ce que la plupart d'entre vous ont (je dis la plupart car cela peut varier selon vos OS installés) :

![Image utilisateur](https://pub.phyks.me/sdz/sdz/medias/uploads.siteduzero.com_files_86001_87000_86529.png)

*Un Menu classique de GRUB* Ce n'est pas très accueillant, je vous l'accorde...

---

## Les fichiers à modifier

##### Le fichier /etc/default/grub (debian) On commence par ouvrir le fameux fichier (en root bien sur) : ``` # gedit /etc/default/grub // Pour Gnome # kate /etc/default/grub // Pour KDE ``` Citation > \# If you change this file, run 'update-grub' afterwards to update > \# /boot/grub/grub.cfg. > > GRUB\_DEFAULT=0 > GRUB\_HIDDEN\_TIMEOUT=0 > GRUB\_HIDDEN\_TIMEOUT\_QUIET=true > GRUB\_TIMEOUT="3" > GRUB\_DISTRIBUTOR=`lsb\_release -i -s 2> /dev/null || echo Debian` > GRUB\_CMDLINE\_LINUX\_DEFAULT="quiet splash" > GRUB\_CMDLINE\_LINUX="" > > \# Uncomment to disable graphical terminal (grub-pc only) > \#GRUB\_TERMINAL=console > > \# The resolution used on graphical terminal > \# note that you can use only modes which your graphic card supports via VBE > \# you can see them in real GRUB with the command `vbeinfo' > \#GRUB\_GFXMODE=640x480 > > \# Uncomment if you don't want GRUB to pass "root=UUID=xxx" parameter to Linux > \#GRUB\_DISABLE\_LINUX\_UUID=true > > \# Uncomment to disable generation of recovery mode menu entrys > \#GRUB\_DISABLE\_LINUX\_RECOVERY="true" Dans cette couleur bleue, ce sont les commentaires. Dans cette couleur rouge, ce sont les parties actives qui seront traitées. ##### Le répertoire /etc/grub.d/ (debian) La commande `ls -al` nous renvoie : ``` total 52 drwxr-xr-x 2 root root 4096 2009-11-09 23:45 . drwxr-xr-x 169 root root 12288 2009-12-07 17:40 .. -rwxr-xr-x 1 root root 3296 2009-10-24 02:44 00_header -rwxr-xr-x 1 root root 1154 2009-10-24 02:31 05_debian_theme -rwxr-xr-x 1 root root 783 2008-03-04 19:20 06_dell_theme -rwxr-xr-x 1 root root 3778 2009-10-24 02:44 10_linux -rwxr-xr-x 1 root root 772 2009-10-23 18:11 20_memtest86+ -rwxr-xr-x 1 root root 5467 2009-10-29 17:21 30_os-prober -rwxr-xr-x 1 root root 214 2009-10-24 02:44 40_custom -rw-r--r-- 1 root root 483 2009-10-24 02:44 README ``` A l'exception du README, les autres sont des script bash. La génération du fichier grub.cfg va se passer tout simplement en exécutant l'ensemble de ces scripts dans un ordre croissant, l'ordre étant appliqué sur les numéros XX précédent le caractère \_ dans le nom de ces scripts.

- **00\_header :** script permettant la génération de l'en-tête du fichier grub.cfg. Cet en-tête est généré principalement à l'aide des informations que vous avez paramétrées dans le fichier /etc/default/grub. - **05\_debian\_theme :** script permettant la génération des informations sur le thème graphique du menu de démarrage. À l'heure où j'écris ces lignes, sur Ubuntu 9.10, le thème est minimal : du texte blanc sur un fond noir. - **10\_linux :** script permettant de générer les entrées correspondant à votre système GNU/Linux hôte. - **20\_memtest86+ :** script permettant de générer les entrées memtest. - **30\_os-prober :** script permettant de détecter des nouveaux systèmes lors de la génération du fichier grub.cfg et de générer les entrées correspondantes. Il est normalement capable de détecter les systèmes avec un noyaux Linux, un noyau Hurd, les systèmes Windows et les systèmes Mac OS X. - **40\_custom :** script permettant de générer des entrées introduites manuellement dans ce fichier.

##### Le fichier /boot/grub/grub.cfg **Alors là, pas touche !** Si vous êtes sur Debian (Ubuntu par exemple), ce fichier est généré automatiquement par Grub après chaque mise à jour de votre part (n'oubliez pas de le faire après les modifications) : `sudo update-grub` Sinon, vous pouvez le modifier ; le principe reste le même que plus haut (la syntaxe est un peu différente):

- **(hdn,m)** est la partition m du disque n, le numéro du disque commence par zéro (0), les partitions par un (1). - **set default=n** est l'entrée par défaut, qui démarrera automatiquement après le time-out. - **set timeout=m** le temps m m est le temps d'attente avant que le choix par défaut ne démarre. - **menuentry "str"{options} title string 'str'** pour préciser manuellement une entrée du menu et la façon donc elle sera affichée. - s**et root=(hdn,m)** définit la partition root (/), là où est installé le noyau. - **linux /path ro root=/dev/device initrd /initrd.img** options pour la partition root, si le noyau n'est pas installé sur la partition / . - **chainloader +1** permet de passer le relai à un autre bootloader (exemple celui de Windows, nécessaire à son démarrage)

---

## Modification des entrées

Ici, ça ce complique un peu (non, ne partez pas, j'ai dit un peu ! :p ) ###### La ligne de base Nous allons éditer la ou les lignes commençant par **GRUB\_DISTRIBUTOR** (je n'en ai qu'une, mais je n'exclus pas la possibilité de systèmes un peu plus exotiques ^^ ) Ces lignes vont définir ce qui sera affiché à l'écran suivant les options choisies. Choisissez parmi les options suivantes : Citation : Doc > GRUB\_DISTRIBUTOR=`lsb\_release -i -s 2> /dev/null || echo Debian` # donne : **Ubuntu, Linux 2.6...** > \#GRUB\_DISTRIBUTOR=`lsb\_release -d -s 2> /dev/null || echo Debian` # donne : **Ubuntu 9.10, Linux 2.6...** > \#GRUB\_DISTRIBUTOR=`echo -n $(lsb\_release -cds 2> /dev/null || echo Debian)` # donne : **Ubuntu 9.10 karmic, Linux 2.6....** ###### Les autres Il est aussi possible d'ajouter des entrées "manuellement". Pour cela, éditez le fichier **/ect/grub.d/40\_custom** et ajoutez vos entrées. En effet, tout ce qui est présent dans ce fichier sera recopié tel quel dans le fichier **grub.cfg**. Exemple: Citation : 40\_custom > \### BEGIN /etc/grub.d/40\_custom ### > \# This file provides an easy way to add custom menu entries. Simply type the > \# menu entries you want to add after this comment. Be careful not to change > \# the 'exec tail' line above. > > menuentry "Windows 7" { > set root=(hd0,1) > chainloader +1 > }

---

## Protégez Grub2 avec un mot de passe

###### Protéger automatiquement tous les recovery modes Le recovery mode est un mode de Linux vous permettant de réparer votre OS en cas de problème et vous offre notamment un shell normal ainsi que plusieurs autres options intéressantes. Pour le protéger, il vous suffit de dé-commenter cette ligne du fichier **/ect/default/grub** : Citation : menu.lst > \#GRUB\_DISABLE\_LINUX\_RECOVERY="true" // Enlevez le # On n'oublie pas de mettre à jour : ``` $ sudo update-grub ``` Ainsi Grub ne génèrera plus d'entrée recovery dans son menu. Notez cependant que le jour où vous avez un problème, vous risquez fort de devoir booter sur un Live CD pour la re-commenter. ###### Protéger entièrement le menu Vous pouvez également protéger avec un mot de passe tout le menu. Ce [How To](http://ubuntuforums.org/showthread.php?t=1369019) m'a été proposé dans les commentaires. Je ne traiterai pas cette partie plus en détail car :

- je n'aime pas vraiment le concept (devoir sans arrêt taper son mot de passe à chaque démarrage...) ; - ces explications, bien qu'en anglais, sont très bien rédigées.

---

## Le démarrage

Citation > GRUB\_DEFAULT=0 Surement la plus intéressante : elle vous permet de modifier l'entrée de votre menu sur laquelle vous allez booter automatiquement. La valeur peut être un nombre naturel (définissant la position) ou *saved*. Ce dernier indique que l'entrée choisie au dernier démarrage sera la prochaine entrée par défaut. Lorsque cette ligne est commentée, la valeur par défaut est 0. Citation > GRUB\_TIMEOUT="5" Cette ligne précise le nombre de **secondes** à attendre avant de booter sur le *default*. La valeur est soit un nombre naturel (secondes), soit -1. Ce dernier indiquera que le menu doit attendre indéfiniment. Précisons que si la valeur est 0, l'entrée par défaut sera bootée instantanément. Lorsque cette ligne est commentée, la valeur par défaut est 5. Citation > \#GRUB\_HIDDEN\_TIMEOUT=0 Permet de définir si le menu de démarrage doit être affiché ou non. Si ce paramètre est commenté, il sera affiché, sinon, sa valeur est un nombre naturel (secondes). Lequel définit le nombre de secondes à attendre avant de lancer le boot de l'entrée par défaut. Si cette valeur est supérieure à 0, pendant le nombre de secondes définies, vous aurez la possibilité de faire afficher le menu manuellement en appuyant sur Esc par exemple. Notez bien la différence avec le précédent : ici, vous ne verrez pas le menu. Citation > \#GRUB\_HIDDEN\_TIMEOUT\_QUIET=true Permet de définir si un chronomètre doit être affiché durant les GRUB\_HIDDEN\_TIMEOUT secondes définies dans le paramètre précédent. Sa valeur est true ou false. Lorsque cette ligne est commentée, la valeur par défaut est false.

---

## Fond d'écran

Plutôt que de faire un vieux plagia, je préfère vous rediriger vers la doc, bien plus complète sur le sujet. Le lien est le suivant : [http://doc.ubuntu-fr.org/grub-pc#exemple\_fond\_d\_ecran](http://doc.ubuntu-fr.org/grub-pc#exemple_fond_d_ecran) Notez cependant que ce n'est pas quelque chose d'essentiel, et que la plupart d'entre vous choisiront sûrement de ne pas afficher leur menu du tout. Pas vraiment de conclusion, les choses vues dans ce chapitres sont assez diverses et variées. Encore une fois, si vous avez rencontré un problème, vous pourrez vous reporter au chapitre sur les erreurs fréquentes (en cours de rédaction) ou bien poster un message sur les forums (pensez à faire une recherche avant, les forums grouillent de sujets sur les erreurs de Grub) ou encore m'envoyez un MP, je me ferai un plaisir de vous aider ! ;)

---

## Configurez Grub-legacy

Dans ce chapitre, vous allez apprendre à configurer Grub (ou encore "Grub legacy", l'ancienne version) pour le rendre plus convivial et à terme plus sécurisé ! ## Déterminer l'ordre de boot

Prenez votre menu et définissez le **numéro** auquel va correspondre le système qui vous intéresse de cette façon : ``` Ubuntu, kernel 2.6.17-10-generic Ubuntu, kernel 2.6.17-10-generic (recovery mod) Ubuntu, memtest86+ Other operating systems: Windows XP Media Center Edition Windows NT/2000/XP Microsoft Windows XP Embedded ``` Sur mon code :

- **Ubuntu, kernel 2.6.17-10-generic = 0** - Ubuntu, kernel 2.6.17-10-generic (recovery mode) = 1 - Ubuntu, memtest86+ = 2 - **Other operating systems = 3** - Windows XP Media Center Edition = 4 - Windows NT/2000/XP = 5 - Microsoft Windows XP Embedded = 6

Notez bien le nombre qui vous intéresse : celui sur lequel vous désirez booter par défaut.

---

## Méthode 1 : Le default

Une fois revenu sur votre bureau, ouvrez un terminal et entrez-y :

- pour KDE : ``` kdesu kate /boot/grub/menu.lst ``` - pour Gnome : ``` gksudo gedit /boot/grub/menu.lst ``` - pour XFCE : ``` sudo mousepad /boot/grub/menu.lst ```

Si vous n'avez pas compris, on va ouvrir le fichier cible de l'adresse **/boot/grub/menu.lst**. Effectivement, ce n'est pas très digeste... :'( Le mien est résumé ainsi : ``` default 0 timeout 15 hiddenmenu title Ubuntu, kernel 2.6.17-10-generic root (hd0,4) kernel /boot/vmlinuz-2.6.17-10-generic root=/dev/sda5 ro quiet splash initrd /boot/initrd.img-2.6.17-10-generic quiet savedefault boot title Ubuntu, kernel 2.6.17-10-generic (recovery mode) root (hd0,4) kernel /boot/vmlinuz-2.6.17-10-generic root=/dev/sda5 ro single initrd /boot/initrd.img-2.6.17-10-generic boot title Ubuntu, memtest86+ root (hd0,4) kernel /boot/memtest86+.bin quiet boot title Other operating systems: root title Windows XP Media Center Edition root (hd0,0) savedefault makeactive chainloader +1 ``` Remplacez tout simplement le chiffre suivant *default* par celui qui vous intéresse. ``` default X ``` Où X est le chiffre que vous avez choisi en première partie. Enregistrez votre fichier, fermez et redémarrez. Magique :magicien: , le curseur est déjà placé sur le choix que vous vouliez. Laissez passer le temps et Grub bootera sur votre choix par défaut. C'est tout.

---

## Méthode 2 : savedefault

Il existe une autre méthode afin de déterminer le système par défaut. Grub vous propose de déterminer lui-même le système sur lequel vous allez booter, en ne choisissant pas n'importe lequel, mais le dernier état sauvegardé. Question logique : comment sauvegarde-t-on ? Regardez vos entrées, avec un peu de chance, vous devriez y voir au moins un *savedefault*. Cela signifie que vous allez automatiquement enregistrer ce choix comme choix par défaut pour le boot. Placez donc *savedefault* après votre choix le plus important et prenez soin de le retirer aux autres. Ensuite, remontez en haut du fichier et éditez encore une fois la ligne *default X* et changez le X par *saved*. Grub sélectionnera automatiquement le système qu'il aura sauvegardé au préalable ;)

---

## Annexes

###### Le timeout Une chose qui peut être intéressante est de pouvoir modifier la ligne : ``` timeout 15 ``` Cette ligne permet de régler le temps limite pour faire votre choix.

**ATTENTION !**, Ne mettez SURTOUT PAS ``` timeout 0 ``` Vous n'auriez plus aucun temps de battement avant le démarrage. C'est une erreur très fréquente et qui peut être particulièrement désagréable à réparer. Imaginons que vous choisissez de faire booter votre système sur Windows. Vous n'auriez alors plus accès à Linux, et sachant que vous ne pouvez modifier votre menu.lst que depuis ce système, cela vous pose donc un gros problème. Trop tard ? Ne vous inquiétez pas, ce n'est pas dramatique du tout ;) Faites une recherche sur les forums où envoyez moi un petit MP, ou reportez-vous à la partie concernant les erreurs fréquentes (en cours de rédaction actuellement). Un chapitre fera en effet bientôt la liste des erreurs les plus courantes et expliquera comment les rattraper ;)

###### Les noms des systèmes Autre chose : il est possible et facile de modifier les noms des systèmes. Une partie de mon menu.lst : ``` title Ubuntu, kernel 2.6.17-10-generic root (hd0,4) kernel /boot/vmlinuz-2.6.17-10-generic root=/dev/sda5 ro quiet splash initrd /boot/initrd.img-2.6.17-10-generic quiet savedefault boot ``` Il suffit de modifier cette ligne : **title Ubuntu, kernel 2.6.17-10-generic** En : **title Ubuntu** Pour changer le nom et avoir un menu de boot plus simple. ###### La protection des entrées Et oui ! C'est possible ! Grub vous permet de protéger votre système avec un mot de passe supplémentaire. Et alors ? J'ai déjà un Mdp pour me connecter sur ma machine, moi ! C'est vrai. Néanmoins, ce que vous ne savez peut être pas, c'est qu'en mode recovery, vous avez accès à beaucoup d'éléments et notamment une console en root sans mot de passe ! C'est plutôt risqué ! Pour protéger Grub par un mot de passe, il vous faut déjà ... un mot de passe. Grub vous propose par ailleurs de le crypter lui-même en md5 : ``` grub> md5crypt md5crypt Password: votre mot de passe Encrypted: $1$gLhU0/$aW78kHK1QfV3P2b2znUoe/ grub> quit ``` Décommentez ensuite la ligne correspondant dans le menu.lst (**en n'oubliant pas de changer le mot de passe encrypté par le vôtre !!!**) Citation > \## password \['--md5'\] passwd > \# If used in the first section of a menu file, disable all interactive editing > \# control (menu entry editor and command-line) and entries protected by the > \# command 'lock' > \# e.g. password topsecret > password --md5 $1$gLhU0/$aW78kHK1QfV3P2b2znUoe/ > \# password topsecret

Maintenant vous avez deux possibilités : ###### Protéger une seule entrée C'est assez facile, ajoutez simplement lock à la suite de vos options sur le système voulu : Citation > title Ubuntu 9.04, kernel 2.6.28-14-generic (recovery mode) > lock > uuid e77d8ae8-36d8-42d1-891d-2cf89dbf0b0c > kernel /boot/vmlinuz-2.6.28-14-generic root=UUID=e77d8ae8-36d8-42d1-891d-2cf89dbf0b0c ro single > initrd /boot/initrd.img-2.6.28-14-generic Pour être sûr de ne pas vous planter, testez sur un ancien noyau ou un vieux truc histoire de ne pas rester coincé au menu. ###### Protéger tous les recovery mode Encore une fois, cela va être assez rapide. Remplacez : Citation > \# lockalternative=false Par : Citation > \# lockalternative=true Ainsi, tous vos recovery modes seront protégés et cela même après mise à jour du noyau ;) Il est vrai que la première version est plus facile à configurer que la dernière, tout tient en un seul fichier (un peu "mastoc" certes :p ). # La structure des répertoires Contrairement à MS-DOS, Unix voit ses disques comme une unique arborescence. Une partition contient la racine du système de fichier, qu'on note `/` (et non `c:\` comme sous MS-DOS). D'autres partitions, des disquettes, des CD-ROM, etc., peuvent être "montés" dans des répertoires. Par exemple, sur la machine que j'utilise en ce moment, le contenu du CD-ROM est accessible dans le répertoire `/mnt/cdrom`. Une fois les différents systèmes de fichiers montés, leur utilisation est transparente, sauf dans quelques cas particuliers: impossibilité d'écrire sur un CD-ROM... Bien souvent, sur les systèmes importants, les utilisateurs ne savent même pas dans quelle machine se trouve le disque dur qu'ils utilisent. La structure "standard" des répertoires est décrite par le FHS (Filesystem Hierarchy Standard) auquel la plupart des distributions Linux essaient de se conformer. Les principaux répertoires sont:

**/bin :**

contient les commandes de base (sous Unix, presque toutes les commandes sont "externes", et non intégrées au shell comme sous DOS).

**/boot :**

contient les informations nécessaires au démarrage de la machine.

**/dev :**

contient les fichiers spéciaux correspondant aux périphériques.

**/etc :**

la plupart des fichiers de configuration.

**/home :**

contient les répertoires personnels des utilisateurs. Par exemple, l'utilisateur toto a généralement pour répertoire `/home/toto`.

**/lib :**

contient les principales bibliothèques partagées (équivalent des DLL de Windows).

**/lost+found :**

quand un disque crashe pour une raison ou pour une autre, on utilise le programme fsck pour réparer (équivalent de scandisk); c'est là qu'il dépose les fragments de fichiers perdus.

**/mnt :**

les répertoires utilisés pour monter temporairement un système de fichiers (disquette, CD-ROM...).

**/opt :**

c'est la qu'on installe les logiciels commerciaux.

**/proc :**

un répertoire factice, dont les fichiers contiennent des infos sur l'état du système et des processus en cours d'exécution.

**/root :**

le répertoire de l'administrateur système. Il n'est pas sous `/home` pour des raisons que je détaillerai plus loin.

**/sbin :**

les commandes de base nécessaires a l'administration système (vérification et réparation des disques, mise en place du réseau...).

**/tmp :**

les fichiers temporaires.

**/usr :**

les logiciels installés avec le système.

**/usr/X11R6 :**: X-Window.
**/usr/bin :**: les exécutables.
**/usr/dict :**: les dictionnaires (pour les correcteurs d'orthographe et les craqueurs de mots de passe).
**/usr/doc :**: la doc.
**/usr/etc :**: des fichiers de config.
**/usr/games :**: les jeux.
**/usr/include :**: les fichiers d'en-tête pour la programmation.
**/usr/info :**: la doc au format GNU info.
**/usr/lib :**: les DLL non vitales.
**/usr/local :**: une sous-hiérarchie qui contient des logiciels compilés sur place à partir des sources. Organisation similaire à `/usr`.
**/usr/man :**: le manuel en ligne. Les fichiers sont compressés.
**/usr/sbin :**: principalement les serveurs réseau.
**/usr/share :**: des fichiers de données.
**/usr/spool :**: généralement un lien symbolique vers `/var/spool`.
**/usr/src :**: les sources de certains logiciels, principalement le noyau de Linux.

**/var :**

des données fréquemment réécrites.

**/var/catman :**: les pages du manuel décompressées (ça se fait à la demande).
**/var/lib :**: des bases de données, des fichiers de config...
**/var/local :**: complète `/usr/local` de la même façon que `/var` complète `/usr`.
**/var/lock :**: des fichiers qui servent à marquer l'utilisation de certaines ressources. Par exemple, quand un logiciel se sert du modem, il crée un fichier ici pour le signaler.
**/var/log :**: le journal du système.
**/var/run :**: principalement des infos sur les serveurs en fonctionnement.
**/var/spool :**: les spools: tout ce qui est "de passage" en attendant d'être utilisé par un logiciel. Ca inclut entre autres le mail, les news, les files d'attente des imprimantes...
**/var/tmp :**: des fichiers temporaires.

Une petite explication des structures assez similaires de `/`, `/usr` et `/usr/local`. Il est assez fréquent que `/usr` soit stocké sur un disque distinct de `/`, voire sur une autre machine. Donc `/` contient de quoi monter `/usr`, y compris à travers le réseau, et de quoi réparer si quelque chose foire. La même remarque s'applique a `/home`; c'est pourquoi le répertoire de l'administrateur est `/root` et non `/home/root`. De plus, comme `/usr` peut être monté en réseau, il peut être partagé entre plusieurs machines; c'est pourquoi les fichiers de config et de données sont dans `/var`. Quant à `/usr/local`, il est séparé de `/usr` car si `/usr` est facilement récupérable en cas de pépin (au pire, on réinstalle tout), `/usr/local` est beaucoup plus difficile à reconstruire: il faut récupérer les sources des logiciels et les recompiler. Enfin, `/opt` a une structure totalement différente: chaque logiciel y a son propre répertoire. On pourra par exemple avoir une hiérarchie du style: > ``` > /opt ---+ > +- /opt/Office40 > +- /opt/netscape > +- /opt/kde > +- /opt/gnome > | > ``` Généralement, chaque répertoire de `/opt` possède au moins les sous-répertoires `bin` et `etc`, qui contiennent respectivement les exécutables et les fichiers de config: > ``` > /opt ---+- /opt/gnome --+- /opt/gnome/bin > | +- /opt/gnome/etc > | | > | > ``` # Étendre la partition et le système de fichiers (Côté Linux) Une fois l'espace alloué par Proxmox, le système Linux à l'intérieur du LXC doit être informé qu'il peut utiliser ce nouvel espace. ## Étape 1 : Vérification de l'état actuel Connectez-vous en console ou SSH **à l'intérieur** de votre LXC et vérifiez l'espace disponible : ``` df -h ``` Si la taille affichée pour `/` est déjà la nouvelle taille, Proxmox a fait le travail automatiquement (courant en LXC). Sinon, passez à l'étape suivante. ## Étape 2 : Redimensionner le système de fichiers (ext4) La majorité des LXC utilisent le système de fichiers **ext4**. Pour l'étendre sans redémarrer : ``` # On demande à resize2fs d'occuper tout l'espace libre sur le disque racine resize2fs /dev/sda1 ``` *Note : Si `/dev/sda1` ne fonctionne pas, utilisez la commande `lsblk` pour identifier le nom exact de votre partition racine.* ## Étape 3 : Cas particulier - Gestion par LVM Si votre LXC utilise LVM (très rare à l'intérieur d'un conteneur, mais possible), suivez ces étapes : ``` # 1. Étendre le volume physique pvresize /dev/sda # 2. Étendre le volume logique (remplacez par votre chemin) lvextend -l +100%FREE /dev/mapper/ubuntu--vg-ubuntu--lv # 3. Étendre le système de fichiers resize2fs /dev/mapper/ubuntu--vg-ubuntu--lv ```

**Astuce :** Si après ces commandes `df -h` ne montre toujours pas de changement, essayez simplement de redémarrer le conteneur depuis l'interface Proxmox (Stop puis Start).

# 🔑 Guide Complet : Authentification SSH par Clés L'authentification par clés SSH remplace avantageusement les mots de passe. Elle est plus sécurisée, insensible aux attaques par force brute, et indispensable pour l'automatisation avec des outils comme Ansible (AWX). --- ## 1. 🧠 Le Concept : Clé Publique vs Clé Privée L'authentification SSH repose sur la cryptographie asymétrique. Au lieu d'avoir un mot de passe unique, on utilise un couple de fichiers indissociables :

🔒 La Clé Publique (Le Cadenas)	🗝️ La Clé Privée (La Clé physique)
- Extension : Finit toujours par `.pub` (ex: `id_ed25519.pub`). - Rôle : C'est le cadenas que vous installez sur toutes les portes (serveurs) où vous souhaitez entrer. - Sécurité : Elle n'est pas secrète. Vous pouvez la distribuer partout, l'envoyer par mail, la mettre sur GitHub. Sans la clé privée associée, elle ne sert à rien.	- Extension : Pas d'extension (ex: `id_ed25519`). - Rôle : C'est la clé unique que vous gardez sur vous (votre PC ou votre gestionnaire de mots de passe / AWX). Elle ouvre les cadenas. - Sécurité : ULTRA SECRÈTE. Elle ne doit jamais quitter votre machine ou votre coffre-fort. Si quelqu'un la vole, il a accès à tous vos serveurs.

--- ## 2. 🛠️ Générer sa paire de clés On utilise aujourd'hui l'algorithme **ED25519**, qui est plus moderne, plus rapide et plus sécurisé que l'ancien RSA. Ouvrez un terminal sur votre machine locale et tapez : ```bash ssh-keygen -t ed25519 -C "cle-admin-cluster" ``` - `-t ed25519` : Spécifie l'algorithme cryptographique. - `-C "..."` : Un commentaire pour vous rappeler à quoi sert cette clé (très utile quand on en a plusieurs). *Note : L'outil vous demandera où sauvegarder (laissez par défaut) et si vous voulez une "passphrase" et dans le cas d'une passphrase, afin d'éviter de la renseigner à chaque fois, vous pouvez taper la commande ssh-add. Pour l'automatisation (Ansible/AWX), laissez la passphrase vide en appuyant deux fois sur Entrée.* --- ## 3. 🚀 Déployer la clé (Méthode classique) Pour autoriser votre clé sur un serveur distant, il faut copier le contenu de la clé publique (le cadenas) dans le fichier `~/.ssh/authorized_keys` du serveur. La commande `ssh-copy-id` fait cela automatiquement : ```bash # Remplacer 'utilisateur' et 'ip_du_serveur' ssh-copy-id -i ~/.ssh/id_ed25519.pub utilisateur@10.151.x.x ``` Il vous demandera le mot de passe du serveur une dernière fois pour installer le cadenas. Ensuite, vous pourrez vous connecter sans mot de passe ! --- ## 4. 🤖 Déploiement Massif (La boucle du Sysadmin) Si vous avez 15 serveurs ou LXC à configurer d'un coup, faire la commande précédente manuellement est fastidieux (taper "yes" pour l'empreinte, taper 15 fois le mot de passe...). Voici comment automatiser le déploiement de la clé publique avec une boucle Bash et l'outil `sshpass`. ### Prérequis : Installez l'utilitaire `sshpass` sur votre machine d'administration : ```bash sudo apt update && sudo apt install sshpass -y ``` ### Le Script de boucle : Modifiez ce bloc avec vos IPs, votre utilisateur cible, et votre mot de passe, puis collez-le dans le terminal. ```bash # 1. On stocke le mot de passe dans une variable d'environnement export SSHPASS='MonMotDePasseSuperSecret' # 2. On lance la boucle sur notre liste d'IPs for ip in 10.151.151.230 10.151.151.244 10.151.151.100; do echo -e "\n=== Copie de la clé sur root@$ip ===" # sshpass : injecte le mot de passe automatiquement # StrictHostKeyChecking=no : accepte automatiquement la nouvelle empreinte (le fameux 'yes') sshpass -e ssh-copy-id -o StrictHostKeyChecking=no -i ~/.ssh/id_ed25519.pub root@$ip done # 3. On détruit la variable pour des raisons de sécurité unset SSHPASS ```

**🎉 Résultat :** En 5 secondes, votre clé SSH est poussée sur l'ensemble de votre parc. Vous êtes prêt pour Ansible !

# Environnement Python pour Ansible & Molecule (venv)

**Objectif :** Standardiser un environnement Python isolé pour Ansible et Molecule afin de garantir stabilité, reproductibilité et compatibilité en environnement LXC / serveur / homelab.

--- ## 1. Architecture recommandée

**Principe :** Un environnement Python isolé (venv) par stack.

- `/opt/ansible-venv` → Ansible + Molecule - Pas d’installation pip globale - Pas de mélange apt + pip pour Ansible --- ## 2. Pré-requis système ``` sudo apt update sudo apt install -y python3 python3-venv python3-pip \ gcc git build-essential ```

**ATTENTION :** Ne jamais utiliser `sudo pip install` sur le système hôte.

--- ## 3. Création du venv Ansible ``` python3 -m venv /opt/ansible-venv ``` ### Correction des permissions (important en LXC) ``` sudo chown -R $USER:$USER /opt/ansible-venv ``` --- ## 4. Activation du venv ``` source /opt/ansible-venv/bin/activate ``` ### Alias recommandé ``` echo 'alias avenv="source /opt/ansible-venv/bin/activate"' >> ~/.bashrc echo 'alias dvenv="deactivate"' >> ~/.bashrc source ~/.bashrc ```

**Usage :** `avenv` pour activer l’environnement.

--- ## 5. Installation Ansible (core) ``` pip install --upgrade pip setuptools wheel pip install ansible ``` ### Validation ``` ansible --version ansible-config --version ``` --- ## 6. Installation Molecule ### Installation standard ``` pip install molecule ``` ### Drivers recommandés ``` # Docker pip install molecule molecule-docker # Podman pip install molecule molecule-podman ``` --- ## 7. Vérification globale ``` which ansible-config which molecule ansible --version molecule --version ```

**Résultat attendu :** Tous les binaires doivent pointer vers `/opt/ansible-venv/bin/`

--- ## 8. Maintenance et mises à jour ### Voir les paquets obsolètes ``` pip list --outdated ``` ### Mettre à jour pip ``` pip install --upgrade pip ``` ### Mise à jour globale du venv ``` pip install pip-review pip-review --auto ```

**ATTENTION :** Les mises à jour automatiques peuvent casser la compatibilité Ansible/Molecule. À utiliser uniquement en environnement non production.

--- ## 9. Sauvegarde / reproductibilité ### Exporter l’environnement ``` pip freeze > requirements.txt ``` ### Restaurer ``` pip install -r requirements.txt ``` --- ## 10. Dépannage (RUNBOOK) ### ❌ ansible-config introuvable ``` pip install ansible ``` ### ❌ Permission denied dans /opt/ansible-venv ``` sudo chown -R $USER:$USER /opt/ansible-venv ``` ### ❌ Molecule ne trouve pas Ansible ``` pip install ansible molecule ``` ### ❌ Mauvais PATH (pipx / system conflict) ``` which ansible which molecule echo $PATH ``` --- ## 11. Commandes opérationnelles ``` avenv # activer venv dvenv # désactiver venv ansible-playbook # exécuter playbooks molecule test # tests infra pip list # paquets installés pip list --outdated # audit ``` --- ## 12. Recommandations d’architecture - 1 venv = 1 stack (Ansible / CI / dev) - éviter pip global système - préférer /opt pour environnements partagés serveur - préférer ~/venvs pour dev utilisateur ---

**Conclusion :** Un environnement venv propre garantit stabilité, reproductibilité et compatibilité avec Ansible & Molecule en environnement LXC / homelab.

# Extraire le contenu d'un coup d'un contexte Voici comment extraire tout le contenu de plusieurs fichiers dans une sous-arborescence : ```bash .venv) [nancmdzk@TOLX302130067 ~/workspace/techdata-ansible-collection] (docs/roles_documentation)$ tree techdata/monitoring/roles/kibana/ techdata/monitoring/roles/kibana/ ├── defaults │ └── main.yml ├── files │ └── node.options ├── handlers │ └── main.yml ├── meta │ ├── argument_specs.yml │ └── main.yml ├── README.md ├── tasks │ ├── cleanup_old_facts.yml │ ├── configure.yml │ └── main.yml ├── templates │ └── kibana.yml.j2 ├── tests │ └── main.yml └── vars └── main.yml 8 directories, 12 files ``` La commande magique : ```bash find techdata/monitoring/roles/kibana/ -type f -exec echo -e "\n=== {} ===" \; -exec cat {} \; ``` La même commande magique extraite dans un fichier : ```bash find techdata/monitoring/roles/kibana/ -type f -exec echo -e "\n=== {} ===" \; -exec cat {} \; > kibana_full_export.txt ``` ### Notice explicative des options de la commande : - **`find techdata/monitoring/roles/kibana/`** : Outil de recherche et chemin du dossier de départ où fouiller. - **`-type f`** : Restreint la recherche aux fichiers uniquement (*f* pour *file*). Cela permet d'ignorer les dossiers et d'éviter les erreurs de lecture. - **`-exec ... \;`** : Indique à la commande `find` d'exécuter une action spécifique sur chaque élément trouvé. Le `\;` sert à marquer la fin de l'instruction à exécuter. - **`echo -e "\n=== {} ==="`** : La première action exécutée. Elle affiche le nom du fichier comme un titre. - **`-e`** : Active l'interprétation des caractères spéciaux, comme le `\n` qui crée un saut de ligne pour aérer la lecture. - **`{}`** : C'est la variable de `find`. Elle est remplacée dynamiquement par le chemin du fichier actuellement traité. - **`-exec cat {} \;`** : La deuxième action exécutée immédiatement après. La commande `cat` lit et affiche l'intégralité du contenu du fichier (représenté par `{}`). - **`> kibana_full_export.txt`** : Redirige la sortie standard (tout ce qui se serait affiché dans le terminal) pour l'écrire directement dans un fichier texte. # 📦 Vagrant + VirtualBox + LFCS Lab (Fedora) ## 1. Objectif Environnement LFCS avec 2 VM Ubuntu gérées par Vagrant + VirtualBox. --- ## 2. Installation ### Vagrant ``` sudo dnf install -y vagrant ``` ### VirtualBox ``` sudo dnf install -y VirtualBox ``` --- ## 3. Vagrantfile (2 VM) ``` config.vm.define "ubuntu1" do |vm| vm.vm.box = "ubuntu/focal64" vm.vm.network "private_network", ip: "192.168.56.101" end config.vm.define "ubuntu2" do |vm| vm.vm.box = "ubuntu/focal64" vm.vm.network "private_network", ip: "192.168.56.102" end ``` --- ## 4. Commandes Vagrant essentielles ``` vagrant up vagrant halt vagrant ssh ubuntu1 vagrant destroy -f vagrant status ``` --- ## 5. Commandes réseau / debug Vagrant ``` vagrant status vagrant ssh ubuntu1 ip a ``` \--- ## 6. DEBUG — VirtualBox & Kernel (IMPORTANT) ### 6.1 Vérifier module kernel VirtualBox ``` lsmod | grep vbox ``` Si rien n’apparaît : ``` sudo modprobe vboxdrv ``` \--- ### 6.2 Vérifier VirtualBox ``` VBoxManage --version which VBoxManage rpm -qa | grep -i virtualbox ``` \--- ### 6.3 Problème kernel modules (akmods) Sur Fedora, VirtualBox dépend des modules kernel : ``` sudo akmods --rebuild --force sudo modprobe vboxdrv ``` Si problème persiste : ``` sudo reboot ``` \--- ## 7. DEBUG — Installation / réinstallation VirtualBox ### Réinstallation complète ``` sudo dnf reinstall -y VirtualBox-server akmod-VirtualBox VirtualBox-kmodsrc ``` Ou nettoyage total : ``` sudo dnf remove -y VirtualBox-server akmod-VirtualBox VirtualBox-kmodsrc ``` Puis : ``` sudo dnf install -y VirtualBox ``` \--- ## 8. DEBUG — Vagrant + provider VirtualBox ### Plugins Vagrant ``` vagrant plugin list vagrant plugin install vagrant-virtualbox2 ``` ### Réparation plugins ``` vagrant plugin repair vagrant plugin expunge --reinstall vagrant plugin update ``` \--- ## 9. DEBUG — libvirt (ancien essai Fedora) ### Problèmes rencontrés - No URI provided (Vagrant libvirt) - virtqemud / virtstoraged sockets manquants - SELinux bloque ports VNC (5701) ### Commandes de diagnostic utilisées ``` virsh net-list --all virsh domifaddr all-courses_ubuntu1 virsh domiflist all-courses_ubuntu1 virsh dumpxml all-courses_ubuntu1 systemctl status libvirtd ``` ### Conclusion Libvirt fonctionne mais est trop complexe sur Fedora 44 pour ce lab. VirtualBox est plus stable pour LFCS. \--- ## 10. Secure Boot / MOK (Fedora) ### Problème Modules kernel VirtualBox bloqués par Secure Boot ### Solution - Enrôler MOK key - Redémarrer machine - Valider dans interface Secure Boot ``` sudo mokutil --list-enrolled ``` \--- ## 11. Cycle de travail recommandé ``` vagrant up vagrant ssh ubuntu1 vagrant halt vagrant up ``` \--- ## 12. Résumé troubleshooting - vboxdrv absent → modprobe ou akmods - VBoxManage cassé → reinstall VirtualBox - Vagrant incompatible → update Vagrant - libvirt complexe → abandon dans ce lab - MOK obligatoire sur Fedora Secure Boot # Raccourcis clavier pour le Terminal Cette documentation regroupe les raccourcis clavier les plus utilisés dans les terminaux Linux (Bash, Zsh, Shell POSIX compatibles GNU Readline). --- ## ⌨️ Déplacement du curseur

Raccourci	Action
Ctrl + A	Aller au début de la ligne
Ctrl + E	Aller à la fin de la ligne
Alt + B	Reculer d'un mot
Alt + F	Avancer d'un mot
Ctrl + XX	Basculer entre la position actuelle et le début de ligne

--- ## ✂️ Édition et suppression

Raccourci	Action
Ctrl + D	Supprimer le caractère sous le curseur
Backspace	Supprimer le caractère précédent
Ctrl + H	Equivalent à Backspace
Ctrl + W	Supprimer le mot précédent
Alt + D	Supprimer le mot suivant
Ctrl + U	Supprimer du curseur jusqu'au début de ligne
Ctrl + K	Supprimer du curseur jusqu'à la fin de ligne
Ctrl + Y	Coller le dernier texte supprimé
Alt + Backspace	Supprimer le mot précédent
Ctrl + T	Inverser deux caractères
Alt + T	Inverser deux mots

--- ## 📜 Historique des commandes

Raccourci	Action
Flèche Haut	Commande précédente
Flèche Bas	Commande suivante
Ctrl + P	Commande précédente
Ctrl + N	Commande suivante
Ctrl + R	Recherche dans l'historique
Ctrl + G	Quitter la recherche d'historique
!!	Exécuter la dernière commande
!n	Exécuter la commande numéro n
!texte	Dernière commande commençant par "texte"
history	Afficher l'historique

--- ## 🔄 Contrôle des processus

Raccourci	Action
Ctrl + C	Interrompre le processus courant
Ctrl + Z	Suspendre le processus
Ctrl + D	Fermer la session ou envoyer EOF
fg	Remettre un processus suspendu au premier plan
bg	Reprendre un processus en arrière-plan
jobs	Afficher les tâches en cours

--- ## 📂 Autocomplétion

Raccourci	Action
Tab	Autocompléter commande ou fichier
Tab + Tab	Afficher les possibilités
Alt + ?	Afficher les complétions possibles
Alt + \*	Insérer toutes les complétions

--- ## 🖥️ Gestion de l'écran

Raccourci	Action
Ctrl + L	Effacer l'écran
clear	Effacer l'écran
reset	Réinitialiser le terminal

--- ## 📋 Copier / Coller (Terminal graphique)

Raccourci	Action
Ctrl + Shift + C	Copier
Ctrl + Shift + V	Coller
Shift + Insert	Coller
Sélection molette	Coller la sélection primaire

--- ## 🔍 Recherche et navigation avancée

Raccourci	Action
Ctrl + R	Recherche arrière dans l'historique
Ctrl + S	Recherche avant (si activée)
Alt + .	Récupérer le dernier argument de la commande précédente
Esc puis .	Equivalent à Alt + .

--- ## 🐧 Raccourcis spécifiques Bash

Raccourci	Action
Ctrl + O	Exécuter la commande trouvée puis passer à la suivante
Alt + C	Mettre en majuscule le caractère courant et avancer
Alt + U	Mettre le mot suivant en majuscules
Alt + L	Mettre le mot suivant en minuscules
Ctrl + \_	Annuler la dernière modification
cd	Revient au home directory
cd -	Revient au dossier précédent

--- ## 🧵 Multiplexeurs de terminal ### tmux

Raccourci	Action
Ctrl + B puis C	Nouvelle fenêtre
Ctrl + B puis N	Fenêtre suivante
Ctrl + B puis P	Fenêtre précédente
Ctrl + B puis %	Division verticale
Ctrl + B puis "	Division horizontale

### screen

Raccourci	Action
Ctrl + A puis C	Créer une fenêtre
Ctrl + A puis N	Fenêtre suivante
Ctrl + A puis P	Fenêtre précédente
Ctrl + A puis D	Détacher la session

--- ## ⭐ Les 15 raccourcis indispensables 1. Ctrl + C 2. Ctrl + Z 3. Ctrl + D 4. Ctrl + L 5. Ctrl + A 6. Ctrl + E 7. Ctrl + U 8. Ctrl + K 9. Ctrl + W 10. Ctrl + Y 11. Ctrl + R 12. Tab 13. Alt + . 14. Ctrl + P 15. Ctrl + N --- Version : Linux / Bash / Zsh Dernière mise à jour : Juin 2026 # 🔀 Comprendre les redirections : stdout, stderr, 2>&1, /dev/null et tee Les redirections sont l'un des concepts les plus importants à maîtriser sous Linux. Elles permettent de contrôler où sont envoyés les résultats d'une commande et les messages d'erreur. --- ## 📑 Sommaire - [Les flux standards](#bkmrk-%F0%9F%93%A1-les-flux-standards) - [Redirection de stdout](#bkmrk-%F0%9F%93%A4-redirection-de-std) - [Redirection de stderr](#bkmrk-%E2%9A%A0%EF%B8%8F-redirection-de-st) - [Comprendre 2>&1](#bkmrk-%F0%9F%A7%A0-comprendre-2%3E%261) - [Le fichier /dev/null](#bkmrk-%F0%9F%97%91%EF%B8%8F-comprendre-%2Fdev%2Fn) - [La commande tee](#bkmrk-%F0%9F%AB%96-comprendre-la-comm) - [Résumé des redirections](#bkmrk-%F0%9F%93%8B-r%C3%A9sum%C3%A9-rapide) --- ## 📡 Les flux standards Linux

**Information** Chaque programme Linux utilise trois flux standards.

Flux	Numéro	Description
stdin	0	Entrée standard (clavier)
stdout	1	Sortie standard
stderr	2	Sortie d'erreur

### Schéma général ``` Clavier | v stdin (0) COMMANDE stdout (1) -------------> Écran stderr (2) -------------> Écran ``` Par défaut, les résultats et les erreurs sont affichés sur le terminal. --- ## 📤 Redirection de stdout (1) Le symbole `>` redirige la sortie standard. ``` ls /etc > resultat.txt ``` ### Ce qui se passe ``` stdout (1) | v resultat.txt ``` Le contenu n'est plus affiché à l'écran mais enregistré dans le fichier. ### Écrasement vs Ajout

Syntaxe	Effet
`>`	Écrase le fichier
`>>`	Ajoute à la fin du fichier

#### Exemple ``` echo "Bonjour" > test.txt echo "Monde" > test.txt ``` Résultat : ``` Monde ``` Le premier contenu a été remplacé. --- ## ⚠️ Redirection de stderr (2) Les erreurs utilisent un flux différent : stderr. ``` ls fichier_inexistant ``` Affiche : ``` ls: impossible d'accéder à 'fichier_inexistant' ``` Pour rediriger les erreurs : ``` ls fichier_inexistant 2> erreurs.log ``` ### Schéma ``` stderr (2) | v erreurs.log ``` --- ## 📁 Séparer stdout et stderr ``` ls /etc fichier_inexistant > sortie.log 2> erreur.log ```

Fichier	Contenu
sortie.log	Résultat normal
erreur.log	Messages d'erreur

--- ## 🧠 Comprendre 2>&1

**Astuce importante** C'est probablement la syntaxe la plus utilisée dans les scripts Linux.

### Commande ``` commande > fichier.log 2>&1 ``` ### Décomposition Cette partie : ``` > fichier.log ``` équivaut à : ``` 1> fichier.log ``` Donc : ``` stdout --> fichier.log ``` Puis : ``` 2>&1 ``` signifie : ``` rediriger stderr vers le même emplacement que stdout ``` ### Schéma ``` stdout (1) -----\ \ ---> fichier.log / stderr (2) -----/ ``` ### Résultat ``` commande > fichier.log 2>&1 ``` Les sorties normales et les erreurs sont regroupées dans le même fichier. --- ## ⚠️ Pourquoi l'ordre est important ? **Correct :** ``` commande > fichier.log 2>&1 ``` **Incorrect :** ``` commande 2>&1 > fichier.log ```

**Attention** Linux traite les redirections de gauche à droite.

Dans le second cas, stderr continue d'utiliser le terminal. --- ## 🚀 Syntaxe simplifiée : &> Bash fournit un raccourci : ``` commande &> fichier.log ``` Équivalent à : ``` commande > fichier.log 2>&1 ``` ### Ajout dans le fichier ``` commande &>> fichier.log ``` --- ## 🗑️ Comprendre /dev/null

**Information** /dev/null est la poubelle de Linux.

Tout ce qui est envoyé dans ce fichier disparaît immédiatement. ``` echo "test" > /dev/null ``` Aucun résultat. ### Ignorer les erreurs ``` commande 2>/dev/null ``` ### Ignorer la sortie normale ``` commande >/dev/null ``` ### Tout ignorer ``` commande >/dev/null 2>&1 ``` ### Schéma ``` stdout --------> /dev/null stderr --------> stdout | v /dev/null ``` Rien ne s'affiche. --- ## 🫖 Comprendre la commande tee La commande `tee` permet d'écrire à la fois : - dans un fichier - sur l'écran ### Exemple ``` ls | tee resultat.log ``` ### Schéma ``` stdout | +------> écran | +------> resultat.log ``` L'utilisateur voit le résultat tout en conservant une trace dans un fichier. --- ## 🔐 Tee avec sudo Cette commande échoue : ``` sudo echo "8.8.8.8 google" > /etc/hosts ``` Car la redirection est exécutée par le shell utilisateur avant sudo. ### Solution ``` echo "8.8.8.8 google" | sudo tee -a /etc/hosts ``` ### Schéma ``` echo | v sudo tee -a | +------> écran | +------> /etc/hosts ``` Ici, c'est bien tee qui écrit dans le fichier avec les privilèges root. --- ## 📋 Résumé rapide

Syntaxe	Action
`commande > fichier`	stdout vers fichier
`commande >> fichier`	Ajouter stdout
`commande 2> fichier`	stderr vers fichier
`commande > fichier 2>&1`	stdout + stderr vers fichier
`commande &> fichier`	Version courte Bash
`commande >/dev/null`	Ignorer stdout
`commande 2>/dev/null`	Ignorer stderr
`commande >/dev/null 2>&1`	Tout ignorer
`commande \| tee fichier`	Afficher + enregistrer
`commande \| sudo tee -a fichier`	Afficher + enregistrer avec sudo

**À retenir** Les 4 syntaxes les plus utilisées en administration Linux sont : - `commande > fichier.log 2>&1` - `commande >> fichier.log 2>&1` - `commande >/dev/null 2>&1` - `commande | tee fichier.log`

# Bootstrap automatique d'un poste Fedora d'administration Cette page décrit la mise en place d'un poste Fedora destiné à l'administration de l'infrastructure. L'objectif est de pouvoir : - installer les outils nécessaires ; - générer une clé SSH ; - créer automatiquement le fichier `~/.ssh/config` ; - déployer la clé publique sur les hôtes utilisant `root` ; - déployer la clé publique sur les hôtes utilisant `nancre` ; - valider rapidement que tout fonctionne. --- ## Prérequis - Un poste Fedora avec accès administrateur local. - Accès réseau aux serveurs du LAN `10.151.151.0/24`. - Le mot de passe du compte `root` sur les hôtes concernés. - Le mot de passe du compte `nancre` sur les hôtes concernés. --- ## Script de bootstrap Créer un fichier, par exemple `bootstrap-fedora.sh`, puis coller le script ci-dessous. ``` #!/usr/bin/env bash set -euo pipefail echo "=== Bootstrap Fedora Administration ===" SSH_DIR="$HOME/.ssh" KEY_FILE="$SSH_DIR/id_ed25519" CONFIG_FILE="$SSH_DIR/config" ROOT_HOSTS=( 10.151.151.230 10.151.151.100 10.151.151.220 10.151.151.231 10.151.151.40 10.151.151.239 10.151.151.249 ) NANCRE_HOSTS=( 10.151.151.244 10.151.151.245 10.151.151.246 10.151.151.247 10.151.151.240 ) echo echo "[1/6] Installation des paquets nécessaires" sudo dnf install -y openssh-clients sshpass echo echo "[2/6] Préparation du dossier ~/.ssh" mkdir -p "$SSH_DIR" chmod 700 "$SSH_DIR" echo echo "[3/6] Génération de la clé SSH si absente" if [[ ! -f "$KEY_FILE" ]]; then ssh-keygen -t ed25519 -a 100 -f "$KEY_FILE" -N "" else echo "Clé déjà existante : $KEY_FILE" fi echo echo "[4/6] Création de ~/.ssh/config" cat > "$CONFIG_FILE" <<'EOF' Host nas HostName 10.151.151.201 User n.ancre Port 22022 IdentityFile ~/.ssh/id_ed25519 Host 10.151.151.* !10.151.151.201 User root IdentityFile ~/.ssh/id_ed25519 StrictHostKeyChecking no UserKnownHostsFile /dev/null Host proxmox HostName 10.151.151.249 User root IdentityFile ~/.ssh/id_ed25519 Host proxmox-ms HostName 10.151.151.239 User root IdentityFile ~/.ssh/id_ed25519 Host squall HostName 10.151.151.245 User nancre IdentityFile ~/.ssh/id_ed25519 Host linoa HostName 10.151.151.246 User nancre IdentityFile ~/.ssh/id_ed25519 Host quistis HostName 10.151.151.247 User nancre IdentityFile ~/.ssh/id_ed25519 Host selphie HostName 10.151.151.240 User nancre IdentityFile ~/.ssh/id_ed25519 Host network HostName 10.151.151.40 User root IdentityFile ~/.ssh/id_ed25519 StrictHostKeyChecking no Host webserver HostName 10.151.151.100 User root IdentityFile ~/.ssh/id_ed25519 StrictHostKeyChecking no Host bitwarden HostName 10.151.151.231 User root IdentityFile ~/.ssh/id_ed25519 StrictHostKeyChecking no Host bookstack HostName 10.151.151.220 User root IdentityFile ~/.ssh/id_ed25519 StrictHostKeyChecking no Host bastion HostName 10.151.151.244 User nancre IdentityFile ~/.ssh/id_ed25519 StrictHostKeyChecking no UserKnownHostsFile /dev/null Host plex HostName 10.151.151.105 User nancre IdentityFile ~/.ssh/awx_ansible_key EOF chmod 600 "$CONFIG_FILE" echo echo "[5/6] Déploiement de la clé sur les hôtes root" read -s -p "Mot de passe root : " ROOTPASS echo export SSHPASS="$ROOTPASS" for host in "${ROOT_HOSTS[@]}"; do echo " - root@$host" sshpass -e ssh-copy-id \ -o StrictHostKeyChecking=no \ -i "$KEY_FILE.pub" \ root@"$host" done unset SSHPASS unset ROOTPASS echo echo "[6/6] Déploiement de la clé sur les hôtes nancre" read -s -p "Mot de passe nancre : " NANCREPASS echo export SSHPASS="$NANCREPASS" for host in "${NANCRE_HOSTS[@]}"; do echo " - nancre@$host" sshpass -e ssh-copy-id \ -o StrictHostKeyChecking=no \ -i "$KEY_FILE.pub" \ nancre@"$host" done unset SSHPASS unset NANCREPASS echo echo "=== Vérification ===" ssh -G proxmox > /dev/null ssh -G squall > /dev/null ssh -G bastion > /dev/null echo echo "Bootstrap terminé avec succès." ``` --- ## Installation du script ``` nano bootstrap-fedora.sh chmod +x bootstrap-fedora.sh ``` --- ## Exécution ``` ./bootstrap-fedora.sh ``` Le script va demander deux mots de passe distincts : - le mot de passe de `root` pour les machines administrées en root ; - le mot de passe de `nancre` pour les machines administrées avec ce compte. --- ## Structure des accès ### Accès en root - `10.151.151.230` - `10.151.151.100` - `10.151.151.220` - `10.151.151.231` - `10.151.151.40` - `10.151.151.239` - `10.151.151.249` ### Accès avec nancre - `10.151.151.244` - `10.151.151.245` - `10.151.151.246` - `10.151.151.247` - `10.151.151.240` --- ## Tests manuels Après exécution, vérifier les alias SSH : ``` ssh proxmox ssh proxmox-ms ssh squall ssh linoa ssh quistis ssh selphie ssh network ssh webserver ssh bitwarden ssh bookstack ssh bastion ssh nas ``` Si tout est correct, aucune demande de mot de passe ne doit apparaître pour les hôtes déjà provisionnés. --- ## Notes - Le compte `plex` utilise ici une clé dédiée `~/.ssh/awx_ansible_key`. - Si tu veux uniformiser complètement le poste, tu peux aussi basculer Plex sur la clé `id_ed25519`. - La configuration est pensée pour être reproductible sur un nouveau portable Fedora. # 🔒Ajout d'un sous-domaine sur le reverse proxy Nginx génération Let's Encrypt Cette procédure décrit l'ajout d'un nouveau sous-domaine sur le reverse proxy Nginx, avec : - création de la configuration Nginx dans `/etc/nginx/conf.d/` ; - redirection HTTP vers HTTPS ; - certificat Let's Encrypt ; - authentification HTTP Basic via `.htpasswd` ; - accès sans authentification depuis le LAN ; - proxy vers un serveur interne ; - prise en charge des WebSockets ; - tests DNS, Nginx, TLS et backend. --- ## 1. Architecture Le principe est le suivant : ``` Internet │ │ https://SOUS-DOMAINE.numericare.fr ▼ Routeur / équipement amont │ │ PROXY protocol ▼ Reverse Proxy Nginx │ │ HTTPS / HTTP ▼ Serveur interne 10.151.151.xxx:PORT ``` Dans cette infrastructure, les configurations Nginx sont stockées directement dans : ``` /etc/nginx/conf.d/ ``` Un fichier est créé par sous-domaine. Exemple : ``` /etc/nginx/conf.d/browser.numericare.fr.conf ``` ## 2. Informations nécessaires avant de commencer Déterminer les éléments suivants :

Élément	Exemple
Sous-domaine	`browser.numericare.fr`
Serveur backend	`10.151.151.229`
Port backend	`3001`
Protocole backend	`HTTPS`
Fichier Nginx	`/etc/nginx/conf.d/browser.numericare.fr.conf`
Authentification	`/etc/nginx/.htpasswd`

Avant de commencer, confirmer également que le serveur backend est accessible depuis le reverse proxy. ## 3. Vérifier le DNS Créer ou modifier l'enregistrement DNS du sous-domaine. Le sous-domaine doit pointer vers l'adresse IP publique qui arrive sur le reverse proxy. Exemple : ``` browser.numericare.fr → IP publique du reverse proxy ``` Ne pas faire pointer directement le DNS vers l'adresse privée du backend : ``` ❌ browser.numericare.fr → 10.151.151.229 ``` Depuis le reverse proxy, vérifier la résolution : ``` dig +short browser.numericare.fr ``` ou : ``` nslookup browser.numericare.fr ``` Le résultat doit correspondre à l'adresse IP publique du reverse proxy. ## 4. Vérifier le backend Depuis le reverse proxy, tester la connectivité vers le serveur interne. Pour un backend HTTPS : ``` curl -vk https://10.151.151.229:3001/ ``` Pour un backend HTTP : ``` curl -v http://10.151.151.229:3001/ ``` Tester également le port : ``` nc -vz 10.151.151.229 3001 ``` Le résultat attendu est similaire à : ``` Connection to 10.151.151.229 3001 port [tcp/*] succeeded! ``` **Si le backend n'est pas accessible, ne pas poursuivre la configuration du reverse proxy.** ## 5. Vérifier le répertoire Let's Encrypt Le répertoire utilisé pour les challenges ACME doit exister : ``` sudo ls -ld /var/www/certbot ``` S'il n'existe pas : ``` sudo mkdir -p /var/www/certbot sudo chown -R www-data:www-data /var/www/certbot ``` ## 6. Créer le fichier Nginx Créer le fichier correspondant au sous-domaine : ``` sudo nano /etc/nginx/conf.d/SOUS-DOMAINE.numericare.fr.conf ``` Exemple pour `browser.numericare.fr` : ``` sudo nano /etc/nginx/conf.d/browser.numericare.fr.conf ``` ## 7. Configuration HTTP / HTTPS Utiliser la structure suivante : ``` map $http_upgrade $connection_upgrade { default upgrade; '' close; } server { listen 80; server_name SOUS-DOMAINE.numericare.fr; # Let's Encrypt ACME HTTP-01 location ^~ /.well-known/acme-challenge/ { root /var/www/certbot; try_files $uri =404; } # Tout le reste → HTTPS location / { return 301 https://$host$request_uri; } } server { listen 443 ssl proxy_protocol; server_name SOUS-DOMAINE.numericare.fr; # ============================================================ # SSL # ============================================================ ssl_certificate /etc/letsencrypt/live/SOUS-DOMAINE.numericare.fr/fullchain.pem; ssl_certificate_key /etc/letsencrypt/live/SOUS-DOMAINE.numericare.fr/privkey.pem; ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; include /etc/letsencrypt/options-ssl-nginx.conf; keepalive_timeout 70; # ============================================================ # REAL IP # ============================================================ real_ip_header proxy_protocol; set_real_ip_from 10.151.151.230; set_real_ip_from 10.151.151.228; set_real_ip_from 10.151.151.102; # ============================================================ # AUTHENTIFICATION # ============================================================ satisfy any; # Pas de mot de passe depuis le LAN allow 10.151.151.0/24; # Authentification obligatoire depuis l'extérieur deny all; auth_basic "Restricted Access"; auth_basic_user_file /etc/nginx/.htpasswd; # ============================================================ # PROXY # ============================================================ location / { proxy_pass https://10.151.151.xxx:PORT; proxy_buffering off; proxy_set_header Host $http_host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; # WebSockets proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection $connection_upgrade; proxy_http_version 1.1; } } ``` **Important :** si plusieurs fichiers Nginx utilisent le bloc : ``` map $http_upgrade $connection_upgrade { default upgrade; '' close; } ``` le `map` ne doit être déclaré **qu'une seule fois** dans toute la configuration Nginx. Vérifier avant d'en ajouter un nouveau : ``` sudo grep -R "map \$http_upgrade" /etc/nginx/ ``` Si le `map` existe déjà, ne pas le recopier dans le nouveau fichier. ## 8. Ne pas recharger Nginx immédiatement Si le certificat n'existe pas encore, la configuration HTTPS référence des fichiers inexistants : ``` /etc/letsencrypt/live/SOUS-DOMAINE.numericare.fr/fullchain.pem /etc/letsencrypt/live/SOUS-DOMAINE.numericare.fr/privkey.pem ``` Il est donc préférable de générer le certificat avant le premier reload de cette nouvelle configuration. ## 9. Générer le certificat Let's Encrypt Utiliser Certbot avec le webroot : ``` sudo certbot certonly \ --webroot \ -w /var/www/certbot \ -d SOUS-DOMAINE.numericare.fr ``` Exemple : ``` sudo certbot certonly \ --webroot \ -w /var/www/certbot \ -d browser.numericare.fr ``` Certbot doit terminer avec un message indiquant que le certificat a été obtenu. ## 10. Vérifier le certificat ``` sudo ls -l /etc/letsencrypt/live/SOUS-DOMAINE.numericare.fr/ ``` Les fichiers suivants doivent notamment exister : ``` cert.pem chain.pem fullchain.pem privkey.pem ``` ## 11. Tester la configuration Nginx Avant tout reload : ``` sudo nginx -t ``` Le résultat attendu : ``` syntax is ok test is successful ``` En cas d'erreur, **ne pas recharger Nginx**. ## 12. Recharger Nginx Si le test est correct : ``` sudo systemctl reload nginx ``` Vérifier que Nginx fonctionne toujours : ``` sudo systemctl status nginx --no-pager ``` Le service doit être : ``` Active: active (running) ``` ## 13. Tester le HTTPS Depuis le reverse proxy : ``` curl -vk https://SOUS-DOMAINE.numericare.fr/ ``` Exemple : ``` curl -vk https://browser.numericare.fr/ ``` La connexion TLS doit être établie et le certificat doit correspondre au sous-domaine. ## 14. Vérifier le certificat avec OpenSSL ``` openssl s_client \ -connect SOUS-DOMAINE.numericare.fr:443 \ -servername SOUS-DOMAINE.numericare.fr ``` Vérifier que le certificat présenté correspond au sous-domaine. ## 15. Tester l'accès depuis le LAN Depuis une machine située dans le réseau `10.151.151.0/24`, ouvrir : ``` https://SOUS-DOMAINE.numericare.fr ``` Grâce à : ``` satisfy any; allow 10.151.151.0/24; deny all; auth_basic "Restricted Access"; auth_basic_user_file /etc/nginx/.htpasswd; ``` l'accès depuis le LAN doit être autorisé **sans demande de mot de passe**. ## 16. Tester l'accès depuis Internet Utiliser un réseau extérieur au LAN, par exemple une connexion mobile 4G/5G. Ouvrir : ``` https://SOUS-DOMAINE.numericare.fr ``` Le navigateur doit demander les identifiants HTTP Basic. Les identifiants sont ceux présents dans : ``` /etc/nginx/.htpasswd ``` ## 17. Tester les WebSockets Si l'application utilise les WebSockets, vérifier son fonctionnement directement dans l'application. La configuration suivante doit être présente : ``` proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection $connection_upgrade; proxy_http_version 1.1; ``` Elle permet notamment aux applications interactives utilisant WebSocket de fonctionner correctement derrière Nginx. ## 18. Vérifier les logs En cas de problème : ``` sudo tail -f /var/log/nginx/access.log ``` Dans un autre terminal : ``` sudo tail -f /var/log/nginx/error.log ``` Puis refaire une connexion au sous-domaine. ## 19. Diagnostic rapide

Symptôme	Vérification
DNS incorrect	`dig +short SOUS-DOMAINE.numericare.fr`
Backend inaccessible	`nc -vz IP PORT`
Backend HTTPS	`curl -vk https://IP:PORT/`
Erreur Nginx	`sudo nginx -t`
Erreur TLS	`openssl s_client ...`
Erreur proxy	`sudo tail -f /var/log/nginx/error.log`
Erreur HTTP Basic	Vérifier `/etc/nginx/.htpasswd`
WebSocket	Vérifier `Upgrade` et `Connection`

## 20. Vérification finale Exécuter : ``` echo "=== DNS ===" dig +short SOUS-DOMAINE.numericare.fr echo "=== NGINX ===" sudo nginx -t echo "=== CERTIFICAT ===" sudo ls -l /etc/letsencrypt/live/SOUS-DOMAINE.numericare.fr/ echo "=== SERVICE NGINX ===" sudo systemctl is-active nginx echo "=== BACKEND ===" nc -vz IP_BACKEND PORT_BACKEND echo "=== HTTPS ===" curl -Ik https://SOUS-DOMAINE.numericare.fr/ ``` Le nouveau sous-domaine est considéré comme opérationnel lorsque : - le DNS pointe vers l'IP publique du reverse proxy ; - le backend est accessible depuis Nginx ; - le certificat Let's Encrypt est valide ; - `nginx -t` est OK ; - Nginx est actif ; - le HTTPS fonctionn # Wireguard # 01 - Présentation Cette documentation décrit la mise en place du serveur VPN **WireGuard** utilisé sur l'infrastructure personnelle **Numericare**. L'objectif est de disposer d'un accès distant sécurisé au réseau domestique tout en conservant une navigation Internet performante depuis les appareils mobiles et les ordinateurs portables. --- ## Objectifs - Accéder au réseau domestique depuis Internet. - Accéder aux serveurs Linux en SSH. - Accéder aux machines Windows en RDP. - Administrer Proxmox. - Administrer Kubernetes. - Accéder au NAS Synology. - Accéder à Home Assistant. - Accéder aux applications hébergées derrière le reverse proxy. - Bénéficier du filtrage DNS d'AdGuard Home même en déplacement. --- ## Architecture logique ``` Client VPN (iPhone, Windows, Linux, macOS) │ ▼ WireGuard │ ├────────────► Réseau local │ │ │ ├── Proxmox │ ├── Kubernetes │ ├── Synology │ ├── Home Assistant │ └── Serveurs Linux │ ▼ AdGuard Home │ ▼ Cloudflare / Quad9 ``` --- ## Choix d'architecture Deux modes de fonctionnement sont possibles avec WireGuard.

Mode	Description	Choix
Full Tunnel	L'intégralité du trafic Internet passe par la maison.	❌ Non retenu
Split Tunnel	Seul le trafic destiné au réseau domestique passe dans le VPN.	✅ Retenu

Le mode **Split Tunnel** permet de conserver les performances de la connexion Internet locale (5G, Fibre, Wi-Fi public...) tout en ayant accès à l'ensemble de l'infrastructure personnelle. --- ## Fonctionnement DNS Tous les clients VPN utilisent **AdGuard Home** comme serveur DNS. ``` Client VPN │ ▼ WireGuard 10.152.152.1 │ ▼ AdGuard Home │ ▼ Cloudflare / Quad9 ``` Cette architecture permet de bénéficier du blocage des publicités, des domaines malveillants et des trackers même lorsque l'appareil est connecté en 5G ou sur un réseau Wi-Fi externe. --- ## Plan d'adressage

Équipement	Adresse
Serveur WireGuard	10.152.152.1/24
Clients VPN	10.152.152.0/24
LXC NETWORK	10.151.151.40
DNS VPN	10.152.152.1

--- ## Principe de fonctionnement ``` Navigation Internet ─────────────────── Téléphone │ ├────────► DNS │ ▼ WireGuard │ ▼ AdGuard Home │ ▼ Cloudflare / Quad9 Trafic Web ────────── Téléphone │ ▼ 5G / Fibre / Wi-Fi (Le trafic Internet ne transite pas par le VPN) ``` --- ## Avantages de cette architecture - Très faibles latences. - Excellentes performances. - Consommation de bande passante minimale à domicile. - Accès sécurisé à l'ensemble du réseau personnel. - Filtrage DNS AdGuard Home disponible partout. - Configuration simple des nouveaux clients VPN. --- > Cette documentation décrit l'architecture actuellement utilisée sur l'infrastructure Numericare. Les exemples de configuration, les adresses IP et les commandes sont directement issus de l'environnement de production personnel. # 02 - Architecture réseau Cette page présente l'architecture réseau utilisée pour le serveur VPN WireGuard ainsi que les différents flux réseau entre les clients distants, le serveur VPN et l'infrastructure domestique. --- ## Vue d'ensemble ``` Internet │ │ ▼ adguard.numericare.fr │ │ Routeur ASUS RT-AC88U Redirection UDP 51820 │ ▼ LXC NETWORK (Debian 12) 10.151.151.40 │ ┌────────────────────────────┼────────────────────────────┐ │ │ │ │ │ │ WireGuard AdGuard Home DDNS Updater 10.152.152.1 Docker Docker │ ▼ Réseau VPN 10.152.152.0/24 │ ▼ Réseau domestique 192.168.150.0/24 ``` --- ## Plan d'adressage IP

Équipement	Adresse IP	Description
Routeur ASUS	192.168.150.254	Passerelle Internet
LXC NETWORK	10.151.151.40	Serveur Debian hébergeant les services réseau
WireGuard	10.152.152.1/24	Serveur VPN
Clients VPN	10.152.152.0/24	Téléphones et ordinateurs
AdGuard Home	10.152.152.1:53	Serveur DNS utilisé par les clients VPN

--- ## Services hébergés dans le LXC NETWORK

Service	Mode	Description
WireGuard	Installation native	Serveur VPN
AdGuard Home	Docker (network\_mode: host)	Serveur DNS avec filtrage
ISC DHCP	Docker (network\_mode: host)	Serveur DHCP
DDNS Updater	Docker (network\_mode: host)	Mise à jour automatique du DNS OVH

--- ## Flux réseau ### Connexion VPN ``` Client VPN │ │ UDP 51820 ▼ Routeur ASUS │ ▼ LXC NETWORK │ ▼ WireGuard ``` ### Accès aux serveurs internes # WireGuard ### Résolution DNS ``` Client VPN │ ▼ 10.152.152.1 (WireGuard) │ ▼ AdGuard Home │ ▼ Cloudflare Google Quad9 ``` --- ## Mode Split Tunnel L'infrastructure utilise un fonctionnement **Split Tunnel**. Seuls les flux destinés aux réseaux internes transitent par le VPN. Le reste du trafic Internet continue d'utiliser la connexion locale (5G, Fibre ou Wi-Fi).

Destination	Passe dans le VPN
192.168.150.0/24	✅ Oui
10.151.151.0/24	✅ Oui
10.152.152.0/24	✅ Oui
Internet	❌ Non

--- ## Résolution DNS Tous les clients WireGuard utilisent le serveur DNS interne de WireGuard. ``` DNS = 10.152.152.1 ``` Cette configuration permet : - le filtrage des publicités ; - le blocage des trackers ; - le blocage des domaines malveillants ; - l'utilisation d'AdGuard Home quel que soit le réseau utilisé. --- ## Pourquoi utiliser l'adresse 10.152.152.1 comme DNS ? Bien que le conteneur AdGuard Home soit installé sur le LXC **10.151.151.40**, les clients VPN utilisent l'adresse **10.152.152.1**. Cette adresse correspond à l'interface WireGuard du serveur et présente plusieurs avantages : - elle est toujours accessible dès que le tunnel VPN est établi ; - elle reste identique même si l'adresse LAN du serveur change ; - elle simplifie la configuration des clients ; - elle évite les problèmes de routage observés avec certains systèmes d'exploitation mobiles. --- > **Bonnes pratiques** > > - Installer WireGuard directement sur Debian et non dans Docker. > - Installer AdGuard Home en Docker avec `network_mode: host`. > - Utiliser le mode Split Tunnel. > - Utiliser `10.152.152.1` comme serveur DNS des clients VPN. > - Conserver un plan d'adressage dédié au réseau VPN. # 03 - Installation des prérequis Cette page décrit l'installation des composants nécessaires au fonctionnement du serveur **WireGuard** sur le LXC **NETWORK**. À l'issue de cette étape, le serveur disposera de tous les outils nécessaires pour créer le VPN, générer les clés cryptographiques et assurer le routage des paquets. --- ## Prérequis

Élément	Valeur
Système d'exploitation	Debian 12 (Bookworm)
Serveur	LXC NETWORK
Adresse IP	10.151.151.40
Accès	Compte sudo ou root
Connexion Internet	Requise

--- ## Architecture concernée ``` Internet │ ▼ Freebox 192.168.150.0/24 │ ▼ Routeur ASUS 10.151.151.0/24 │ ▼ LXC NETWORK (Debian 12) 10.151.151.40 │ Installation de WireGuard ``` --- ## Installation des paquets Mettre à jour les dépôts puis installer les différents composants nécessaires. ``` sudo apt update sudo apt install wireguard qrencode iptables-persistent -y ``` --- ## Description des paquets

Paquet	Description
wireguard	Serveur VPN WireGuard et outils de gestion.
qrencode	Permet de générer des QR Codes pour les clients mobiles.
iptables-persistent	Sauvegarde automatiquement les règles NAT après un redémarrage.

--- ## Vérification de l'installation Contrôler que WireGuard est correctement installé. ``` wg --version ``` **Résultat attendu** ``` wireguard-tools v1.x.x ``` La version peut varier selon les mises à jour de Debian. --- ## Vérification du module WireGuard Contrôler que le noyau Linux dispose bien du support WireGuard. ``` sudo modprobe wireguard lsmod | grep wireguard ``` **Résultat attendu** ``` wireguard XXXXX X ``` --- ## Vérification des outils installés ``` which wg which wg-quick which qrencode ``` **Résultat attendu** ``` /usr/bin/wg /usr/bin/wg-quick /usr/bin/qrencode ``` --- ## Versions installées Il peut être utile de conserver les versions des composants installés afin de faciliter un futur dépannage. ``` dpkg -l | grep wireguard dpkg -l | grep qrencode ``` --- ## Bonnes pratiques > **Recommandations** > > - Installer WireGuard directement sur Debian plutôt que dans un conteneur Docker. > - Conserver AdGuard Home dans Docker avec `network_mode: host`. > - Toujours mettre à jour les dépôts avant l'installation. > - Éviter de mélanger plusieurs méthodes d'installation (APT, Snap, compilation). --- ## Dépannage ### Commande "wg" introuvable Vérifier que le paquet est bien installé. ``` dpkg -l | grep wireguard ``` --- ### Le module WireGuard ne se charge pas Vérifier la version du noyau Linux. ``` uname -r ``` Debian 12 intègre nativement le support WireGuard dans son noyau. --- ## Résumé de cette étape

Élément	Statut
Paquets installés	✅
WireGuard disponible	✅
Module noyau chargé	✅
QR Code disponible	✅
iptables-persistent installé	✅

--- > À l'issue de cette étape, le serveur possède tous les outils nécessaires pour mettre en place le VPN WireGuard. La prochaine page sera consacrée à la préparation de l'environnement, à la création de l'arborescence de travail et à la génération des clés cryptographiques du serveur. # 04 - Préparation de l'environnement Cette étape consiste à préparer l'environnement de travail du serveur WireGuard. Les clés cryptographiques du serveur seront générées puis stockées dans un répertoire dédié afin de faciliter la maintenance et les sauvegardes. --- ## Pourquoi stocker les clés dans `/opt/network` ? Par défaut, WireGuard ne fournit aucune arborescence permettant d'organiser les clés des différents clients. L'infrastructure Numericare utilise donc un répertoire dédié afin de centraliser toutes les informations liées au VPN. > **Avantages** > > - Organisation claire des fichiers. > - Sauvegarde facilitée. > - Séparation entre la configuration système et les données. > - Stockage des QR Codes des clients. > - Gestion simplifiée des futurs clients VPN. --- ## Arborescence retenue ``` /opt/network/ └── wireguard ├── server │ ├── server.key │ └── server.pub │ ├── clients │ ├── iphone/ │ ├── windows/ │ ├── ubuntu/ │ └── ... │ └── qr ├── iphone.png ├── windows.png └── ... ``` --- ## Création de l'arborescence ``` sudo mkdir -p /opt/network/wireguard/server sudo mkdir -p /opt/network/wireguard/clients sudo mkdir -p /opt/network/wireguard/qr ``` --- ## Vérification ``` tree /opt/network ``` **Résultat attendu** ``` /opt/network └── wireguard ├── clients ├── qr └── server ``` --- ## Création des clés du serveur Les clés WireGuard utilisent la cryptographie à clé publique. - Une clé privée reste exclusivement sur le serveur. - Une clé publique sera communiquée à tous les clients. --- ## Se placer dans le répertoire du serveur ``` cd /opt/network/wireguard/server ``` --- ## Sécuriser les permissions par défaut Avant de générer les clés, il est recommandé de limiter automatiquement les droits des nouveaux fichiers. ``` umask 077 ``` Les fichiers créés seront uniquement accessibles au propriétaire. --- ## Génération des clés ``` wg genkey | tee server.key | wg pubkey > server.pub ``` --- ## Contenu du répertoire ``` ls -lh ``` **Résultat attendu** ``` server.key server.pub ``` --- ## Afficher les clés ``` cat server.key cat server.pub ``` > **Important** > > - La clé privée (`server.key`) ne doit jamais être transmise. > - La clé publique (`server.pub`) pourra être utilisée dans la configuration des clients VPN. --- ## Vérification des permissions ``` ls -l ``` **Résultat attendu** ``` -rw------- server.key -rw------- server.pub ``` --- ## Sauvegarde recommandée Les clés du serveur sont les éléments les plus importants de l'infrastructure WireGuard. Une copie hors du serveur est fortement recommandée. > **Bonnes pratiques** > > - Copie sur le NAS Synology. > - Sauvegarde chiffrée. > - Ne jamais envoyer la clé privée par e-mail ou messagerie. > - Conserver une copie hors site. --- ## Vérifications complémentaires Calculer l'empreinte SHA256 des clés permet de vérifier ultérieurement leur intégrité. ``` sha256sum server.key sha256sum server.pub ``` --- ## Résumé de cette étape

Élément	Statut
Arborescence créée	✅
Répertoire serveur	✅
Répertoire clients	✅
Répertoire QR Codes	✅
Clé privée générée	✅
Clé publique générée	✅
Permissions vérifiées	✅

--- > À l'issue de cette étape, le serveur possède désormais son identité cryptographique. La page suivante sera consacrée à l'activation du routage IP et à la création de l'interface WireGuard (`wg0`). # 05 - Configuration du serveur WireGuard Cette étape consiste à configurer le serveur WireGuard afin qu'il puisse accepter les connexions des futurs clients VPN. À l'issue de cette page, l'interface **wg0** sera entièrement configurée. --- ## Architecture ``` Clients VPN 10.152.152.0/24 │ │ Interface wg0 10.152.152.1 │ LXC NETWORK 10.151.151.40 │ ▼ Réseau ASUS 10.151.151.0/24 ``` --- ## Activation du routage IPv4 Le serveur doit être capable de transférer les paquets entre le réseau VPN et le réseau local. Éditer le fichier : ``` sudo nano /etc/sysctl.conf ``` Décommenter ou ajouter la ligne suivante : ``` net.ipv4.ip_forward=1 ``` Appliquer immédiatement la configuration : ``` sudo sysctl -p ``` Vérifier : ``` cat /proc/sys/net/ipv4/ip_forward ``` **Résultat attendu** ``` 1 ``` --- ## Pourquoi activer le routage ? Sans cette option, Linux reçoit les paquets provenant du VPN mais refuse de les transmettre vers le réseau local. > Le serveur WireGuard joue le rôle de routeur entre : > > - le réseau VPN (**10.152.152.0/24**) > - le réseau ASUS (**10.151.151.0/24**) --- ## Création du fichier de configuration ``` sudo nano /etc/wireguard/wg0.conf ``` --- ## Configuration complète ``` [Interface] Address = 10.152.152.1/24 ListenPort = 51820 PrivateKey = PostUp = iptables -A FORWARD -i wg0 -j ACCEPT PostUp = iptables -A FORWARD -o wg0 -j ACCEPT PostUp = iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE PostDown = iptables -D FORWARD -i wg0 -j ACCEPT PostDown = iptables -D FORWARD -o wg0 -j ACCEPT PostDown = iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE ``` --- ## Comprendre chaque paramètre

Paramètre	Description
Address	Adresse IP du serveur sur le réseau VPN.
ListenPort	Port UDP utilisé par WireGuard.
PrivateKey	Clé privée du serveur générée à l'étape précédente.
PostUp	Commandes exécutées automatiquement au démarrage de l'interface.
PostDown	Suppression automatique des règles lors de l'arrêt.

--- ## Pourquoi utiliser MASQUERADE ? Les équipements du réseau ASUS ne connaissent pas le réseau VPN **10.152.152.0/24**. Le NAT permet donc de masquer les clients VPN derrière l'adresse IP du serveur **10.151.151.40**. ``` Client VPN 10.152.152.2 │ ▼ WireGuard 10.152.152.1 │ NAT (MASQUERADE) │ ▼ 10.151.151.40 │ ▼ Serveur NAS Serveur Linux Home Assistant Kubernetes ``` --- ## Pourquoi utiliser l'interface eth0 ? Le LXC NETWORK possède une seule interface réseau reliée au LAN ASUS. Les paquets quittent donc naturellement le serveur via **eth0**. Vérification : ``` ip addr ``` --- ## Sécurisation du fichier Le fichier contient la clé privée du serveur. ``` sudo chmod 600 /etc/wireguard/wg0.conf ``` Vérifier : ``` ls -l /etc/wireguard/wg0.conf ``` **Résultat attendu** ``` -rw------- root root ``` --- ## Contrôle de la configuration Avant de démarrer WireGuard, vérifier que le fichier est correctement rempli. ``` sudo cat /etc/wireguard/wg0.conf ``` Les éléments suivants doivent être présents : - Adresse 10.152.152.1/24 - Port 51820 - Clé privée - Règles PostUp - Règles PostDown --- ## Résumé de cette étape

Élément	Statut
Routage IPv4 activé	✅
Configuration WireGuard créée	✅
Interface wg0 configurée	✅
NAT configuré	✅
Permissions sécurisées	✅

--- > À ce stade, le serveur WireGuard est entièrement configuré mais n'est pas encore démarré. La prochaine page décrira le démarrage du service, l'ouverture du port UDP 51820 sur le routeur ASUS ainsi que les vérifications permettant de s'assurer que le serveur est opérationnel. # 06 - Démarrage et validation du serveur Après avoir installé WireGuard, généré les clés cryptographiques et créé le fichier de configuration, il est temps de démarrer le service et de vérifier son bon fonctionnement. À la fin de cette étape, le serveur WireGuard sera opérationnel et en attente de connexions VPN. --- ## Architecture ``` Internet │ ▼ Routeur ASUS │ ▼ LXC NETWORK (10.151.151.40) │ WireGuard (wg0) 10.152.152.1/24 │ ▼ En attente des clients VPN ``` --- ## Activer le démarrage automatique Configurer WireGuard afin que le service démarre automatiquement à chaque redémarrage du serveur. ``` sudo systemctl enable wg-quick@wg0 ``` **Résultat attendu** ``` Created symlink ... ``` --- ## Démarrer le service ``` sudo systemctl start wg-quick@wg0 ``` --- ## Vérifier l'état du service ``` sudo systemctl status wg-quick@wg0 ``` **Résultat attendu** ``` Active: active (exited) ``` Le service **wg-quick** configure l'interface réseau puis termine son exécution. L'état **active (exited)** est donc parfaitement normal. --- ## Afficher la configuration WireGuard ``` sudo wg ``` **Résultat attendu** ``` interface: wg0 public key: xxxxxxxxxxxxxxxxxxxxxxxxx listening port: 51820 ``` À ce stade, aucun client n'est encore configuré. Il est donc normal que la commande n'affiche aucun **peer**. --- ## Afficher l'adresse IP de l'interface ``` ip addr show wg0 ``` **Résultat attendu** ``` inet 10.152.152.1/24 ``` --- ## Contrôler le port d'écoute Vérifier que WireGuard écoute bien sur le port UDP **51820**. ``` sudo ss -lunp | grep 51820 ``` **Résultat attendu** ``` udp UNCONN 0 0 0.0.0.0:51820 ``` --- ## Contrôler les règles NAT Les règles `PostUp` doivent avoir été ajoutées automatiquement au démarrage de l'interface. ``` sudo iptables -L FORWARD sudo iptables -t nat -L POSTROUTING ``` Les règles autorisant le transfert entre **wg0** et **eth0** ainsi que la règle **MASQUERADE** doivent être présentes. --- ## Vérifier le routage IPv4 ``` cat /proc/sys/net/ipv4/ip_forward ``` **Résultat attendu** ``` 1 ``` --- ## Consulter les journaux système En cas de problème lors du démarrage, consulter les journaux de **systemd**. ``` sudo journalctl -u wg-quick@wg0 ``` Pour afficher uniquement les derniers événements : ``` sudo journalctl -u wg-quick@wg0 -n 50 ``` --- ## Redémarrer le service Après toute modification du fichier `/etc/wireguard/wg0.conf`, redémarrer WireGuard. ``` sudo systemctl restart wg-quick@wg0 ``` --- ## Arrêter le service ``` sudo systemctl stop wg-quick@wg0 ``` Les règles `PostDown` supprimeront automatiquement les règles iptables ajoutées au démarrage. --- ## Commandes utiles

Commande	Description
`sudo wg`	Afficher l'état du serveur WireGuard.
`ip addr show wg0`	Afficher l'adresse IP de l'interface VPN.
`sudo wg show`	Afficher les statistiques détaillées.
`sudo systemctl restart wg-quick@wg0`	Redémarrer le service.
`sudo systemctl status wg-quick@wg0`	Afficher l'état du service.
`sudo journalctl -u wg-quick@wg0`	Afficher les journaux système.

--- ## Dépannage ### L'interface wg0 n'existe pas ``` ip link show wg0 ``` Si l'interface n'apparaît pas, vérifier le contenu du fichier `/etc/wireguard/wg0.conf` ainsi que les journaux systemd. --- ### Le port 51820 n'est pas ouvert Contrôler que le service est bien démarré : ``` sudo systemctl status wg-quick@wg0 ``` Puis vérifier la présence de l'interface : ``` sudo wg ``` --- ### Erreur de syntaxe dans le fichier wg0.conf Une erreur dans le fichier de configuration empêche le démarrage de WireGuard. Les journaux systemd indiquent généralement la ligne concernée. ``` sudo journalctl -u wg-quick@wg0 ``` --- ## Résumé de cette étape

Élément	Statut
Service activé au démarrage	✅
Interface wg0 créée	✅
Serveur à l'écoute sur UDP 51820	✅
Règles NAT chargées	✅
Routage IPv4 opérationnel	✅
Serveur prêt à recevoir des clients	✅

--- > Le serveur WireGuard est désormais pleinement opérationnel. La prochaine partie de cette documentation sera consacrée à la configuration du routeur ASUS (redirection du port UDP 51820, DNS dynamique et validation de l'accès depuis Internet), avant de passer à la création du premier client VPN. # 07 - Création d'un client WireGuard Cette page décrit la procédure permettant d'ajouter un nouveau client au serveur WireGuard. Chaque client possède sa propre paire de clés cryptographiques ainsi qu'une adresse IP dédiée sur le réseau VPN. --- ## Architecture ``` Serveur WireGuard 10.152.152.1 │ ──────────────┼────────────── │ Réseau VPN 10.152.152.0/24 │ ┌─────────────┼─────────────┐ │ │ │ Windows iPhone Ubuntu 10.152.152.2 10.152.152.3 10.152.152.4 ``` --- ## 1. Créer le dossier du client Chaque client possède son propre répertoire contenant ses clés, sa configuration et, si nécessaire, son QR Code. ``` cd /opt/network/wireguard/clients mkdir -p windows cd windows ``` --- ## 2. Générer les clés cryptographiques Limiter les permissions des fichiers générés. ``` umask 077 ``` Créer ensuite la paire de clés. ``` wg genkey | tee windows.key | wg pubkey > windows.pub ``` --- ## 3. Vérifier les fichiers générés ``` ls -l ``` **Résultat attendu** ``` windows.key windows.pub ``` --- ## 4. Afficher les clés ``` cat windows.key cat windows.pub ``` > **Important** > > - La clé privée reste exclusivement sur le client. > - La clé publique sera ajoutée au serveur WireGuard. --- ## 5. Déclarer le client sur le serveur Éditer le fichier de configuration du serveur. ``` sudo nano /etc/wireguard/wg0.conf ``` Ajouter à la fin du fichier : ``` [Peer] PublicKey = AllowedIPs = 10.152.152.2/32 ``` Chaque client doit disposer d'une adresse IP unique.

Client	Adresse VPN
Windows	10.152.152.2
iPhone	10.152.152.3
Ubuntu	10.152.152.4
Android	10.152.152.5

--- ## 6. Créer le fichier de configuration du client ``` nano windows.conf ``` --- ## Configuration du client ``` [Interface] PrivateKey = Address = 10.152.152.2/32 DNS = 10.152.152.1 [Peer] PublicKey = bdo5MJaEb+NSEk9x5I2yStIDUjvgvgAoZkeQDksSMT4= Endpoint = adguard.numericare.fr:51820 AllowedIPs = 10.151.151.0/24,10.152.152.0/24 PersistentKeepalive = 25 ``` --- ## Comprendre les paramètres

Paramètre	Description
PrivateKey	Clé privée du client.
Address	Adresse IP du client sur le VPN.
DNS	Serveur AdGuard Home accessible via le VPN.
Endpoint	Nom DNS public du serveur WireGuard.
AllowedIPs	Détermine les réseaux qui transitent dans le VPN.
PersistentKeepalive	Maintient la connexion active derrière un NAT.

--- ## Pourquoi utiliser ces AllowedIPs ? ``` AllowedIPs = 10.151.151.0/24,10.152.152.0/24 ``` Cette configuration met en œuvre un **Split Tunnel**. - Le réseau domestique (10.151.151.0/24) passe dans le VPN. - Le réseau VPN (10.152.152.0/24) passe également dans le tunnel. - La navigation Internet continue d'utiliser la connexion locale du client. --- ## Pourquoi utiliser DNS = 10.152.152.1 ? Le serveur WireGuard héberge également AdGuard Home. Les requêtes DNS transitent donc dans le VPN vers l'adresse du serveur WireGuard. ``` DNS = 10.152.152.1 ``` Cette configuration permet de bénéficier du filtrage AdGuard même lorsque le client est connecté depuis Internet. --- ## 7. Recharger WireGuard ``` sudo systemctl restart wg-quick@wg0 ``` --- ## 8. Vérifier que le client est enregistré ``` sudo wg ``` Le nouveau **Peer** doit apparaître. --- ## 9. Générer un QR Code (Android / iPhone) ``` qrencode -o /opt/network/wireguard/qr/windows.png < windows.conf ``` Ou directement dans le terminal : ``` qrencode -t ansiutf8 < windows.conf ``` --- ## 10. Importer la configuration

Plateforme	Méthode
Windows	Importer le fichier windows.conf dans le client WireGuard.
Linux	Copier le fichier dans /etc/wireguard/wg0.conf puis démarrer wg-quick.
Android	Scanner le QR Code.
iPhone / iPad	Scanner le QR Code.

--- ## 11. Vérifications Une fois connecté : ``` ping 10.151.151.40 ``` Puis : ``` nslookup google.fr ``` Le serveur DNS utilisé doit être : ``` 10.152.152.1 ``` Enfin, sur le serveur : ``` sudo wg ``` Le client doit apparaître avec : - Latest Handshake - Transfer RX - Transfer TX --- ## Bonnes pratiques - Une paire de clés par client. - Ne jamais réutiliser une clé privée. - Attribuer une adresse VPN unique à chaque client. - Conserver le fichier **.conf** avec les clés dans le dossier du client. - Redémarrer WireGuard après l'ajout d'un nouveau Peer. - Supprimer un Peer inutilisé afin de limiter la surface d'exposition. --- ## Résumé

Élément	Statut
Clés générées	✅
Peer ajouté au serveur	✅
Configuration client créée	✅
QR Code généré	✅
Connexion prête	✅

> Le client WireGuard est maintenant prêt à être utilisé. Les chapitres suivants détaillent la configuration spécifique de chaque plateforme (Windows, Ubuntu, Fedora, Android, iPhone et macOS). # 08.1 - Configuration d'un client Windows 11 Cette page explique comment installer et configurer le client WireGuard sous Windows 11 afin d'accéder au réseau privé via le serveur VPN. À l'issue de cette procédure, l'ordinateur pourra se connecter au réseau domestique en toute sécurité et utiliser AdGuard Home comme serveur DNS. --- ## Prérequis - Le serveur WireGuard est opérationnel. - Le client Windows a été créé sur le serveur (voir chapitre 07). - Le fichier **windows.conf** est disponible. - Une connexion Internet est disponible. --- ## Architecture ``` Internet │ ▼ adguard.numericare.fr │ UDP 51820 │ ▼ Serveur WireGuard 10.152.152.1 │ ─────────────── │ Réseau ASUS 10.151.151.0/24 ``` --- ## 1. Installer WireGuard Télécharger puis installer le client officiel WireGuard pour Windows. Conserver les options d'installation par défaut. --- ## 2. Lancer WireGuard Au premier lancement, la liste des tunnels est vide. ``` No tunnels configured. ``` --- ## 3. Importer la configuration Cliquer sur : ``` Import tunnel(s) from file... ``` Sélectionner le fichier : ``` windows.conf ``` Le tunnel apparaît immédiatement dans la liste. --- ## 4. Vérifier la configuration Le contenu doit être similaire à celui-ci : ``` [Interface] PrivateKey = xxxxxxxxxxxxxxxxxxxxxxxxx Address = 10.152.152.2/32 DNS = 10.152.152.1 [Peer] PublicKey = xxxxxxxxxxxxxxxxxxxxxxxxx Endpoint = adguard.numericare.fr:51820 AllowedIPs = 10.151.151.0/24,10.152.152.0/24 PersistentKeepalive = 25 ``` --- ## Comprendre les paramètres

Paramètre	Description
Address	Adresse VPN attribuée au poste Windows.
DNS	Utilisation d'AdGuard Home via le VPN.
Endpoint	Adresse publique du serveur WireGuard.
AllowedIPs	Réseaux accessibles via le VPN (Split Tunnel).
PersistentKeepalive	Maintient la connexion ouverte derrière un NAT.

--- ## 5. Établir la connexion Cliquer sur : ``` Activate ``` L'état du tunnel devient : ``` Active ``` --- ## 6. Vérifier l'adresse IP VPN Ouvrir PowerShell : ``` ipconfig ``` Une nouvelle interface WireGuard doit apparaître. **Résultat attendu** ``` Adresse IPv4 : 10.152.152.2 ``` --- ## 7. Tester la connectivité Tester le serveur WireGuard : ``` ping 10.152.152.1 ``` Tester ensuite le serveur Docker / AdGuard : ``` ping 10.151.151.40 ``` Les deux réponses doivent être positives. --- ## 8. Vérifier le DNS Exécuter : ``` nslookup google.fr ``` Le serveur DNS utilisé doit être : ``` 10.152.152.1 ``` Cela confirme que toutes les requêtes DNS transitent par AdGuard Home. --- ## 9. Vérifier le serveur Depuis le serveur Debian : ``` sudo wg ``` Le client Windows doit apparaître. **Exemple** ``` peer: xxxxxxxxxxxxxxxxx latest handshake: 25 seconds ago transfer: 48 KiB received transfer: 120 KiB sent ``` --- ## 10. Déconnecter le VPN Dans WireGuard, cliquer sur : ``` Deactivate ``` La connexion VPN est immédiatement interrompue. --- ## Dépannage ### Le tunnel reste inactif - Vérifier la connexion Internet. - Vérifier le port UDP 51820 sur le routeur. - Contrôler l'adresse Endpoint. - Vérifier la clé publique du serveur. --- ### Aucun Handshake Sur le serveur : ``` sudo wg ``` Si aucun **Latest Handshake** n'apparaît : - vérifier la redirection UDP 51820 ; - contrôler le pare-feu Windows ; - vérifier que le domaine DNS pointe vers l'adresse IP publique correcte ; - contrôler les clés publiques et privées. --- ### Impossible d'accéder au réseau domestique - Vérifier les **AllowedIPs**. - Vérifier que le routage IPv4 est activé sur le serveur. - Contrôler les règles NAT (iptables). --- ### Les publicités ne sont pas bloquées - Contrôler que le DNS est bien **10.152.152.1**. - Tester avec : ``` nslookup google.fr ``` Le serveur interrogé doit être WireGuard / AdGuard Home. --- ## Bonnes pratiques - Conserver le fichier **windows.conf** dans un emplacement sécurisé. - Ne jamais partager la clé privée. - Installer les mises à jour du client WireGuard. - Désactiver le tunnel lorsqu'il n'est plus nécessaire. - Contrôler régulièrement le nombre de Peers autorisés sur le serveur. --- ## Résumé

Élément	Statut
Client WireGuard installé	✅
Configuration importée	✅
Tunnel établi	✅
Connexion au réseau domestique	✅
DNS AdGuard fonctionnel	✅

--- > Le client Windows est désormais entièrement configuré. Les chapitres suivants présentent la configuration des autres plateformes (Ubuntu, Fedora, Android, iPhone/iPad et macOS), dont la logique est similaire mais avec des méthodes d'installation propres à chaque système. # 08.2 - Configuration d'un client Ubuntu Cette page explique comment installer et configurer un client WireGuard sous Ubuntu afin d'accéder au réseau privé via le serveur VPN. La configuration s'appuie sur le fichier **ubuntu.conf** généré lors de la création du client (voir chapitre 07). --- ## Prérequis - Le serveur WireGuard est opérationnel. - Le client Ubuntu a été créé sur le serveur. - Le fichier **ubuntu.conf** est disponible. - Une connexion Internet est disponible. --- ## Architecture ``` Ubuntu 10.152.152.4 │ │ Tunnel WireGuard │ ▼ adguard.numericare.fr │ ▼ Serveur WireGuard 10.152.152.1 │ ▼ Réseau ASUS 10.151.151.0/24 ``` --- ## 1. Installer WireGuard ``` sudo apt update sudo apt install wireguard -y ``` --- ## 2. Vérifier l'installation ``` wg --version ``` **Résultat attendu** ``` wireguard-tools v1.x.x ``` --- ## 3. Copier le fichier de configuration Copier le fichier généré sur le serveur dans le répertoire système : ``` sudo cp ubuntu.conf /etc/wireguard/wg0.conf ``` --- ## 4. Sécuriser les permissions Le fichier contient la clé privée du client. ``` sudo chmod 600 /etc/wireguard/wg0.conf ``` Vérification : ``` ls -l /etc/wireguard/wg0.conf ``` **Résultat attendu** ``` -rw------- root root ``` --- ## 5. Vérifier la configuration ``` sudo cat /etc/wireguard/wg0.conf ``` Le fichier doit contenir notamment : ``` [Interface] Address = 10.152.152.4/32 DNS = 10.152.152.1 [Peer] Endpoint = adguard.numericare.fr:51820 AllowedIPs = 10.151.151.0/24,10.152.152.0/24 ``` --- ## 6. Démarrer le tunnel ``` sudo wg-quick up wg0 ``` Résultat attendu : ``` [#] ip link add wg0 type wireguard [#] wg setconf wg0 ... [#] ip address add ... [#] ip link set up dev wg0 ``` --- ## 7. Vérifier l'interface VPN ``` ip addr show wg0 ``` **Résultat attendu** ``` inet 10.152.152.4/32 ``` --- ## 8. Vérifier le tunnel ``` sudo wg ``` La sortie doit afficher : - la clé publique du serveur ; - un **Latest Handshake** récent ; - les compteurs RX/TX. --- ## 9. Tester la connectivité Tester le serveur VPN : ``` ping 10.152.152.1 ``` Tester ensuite le réseau local : ``` ping 10.151.151.40 ``` --- ## 10. Vérifier le DNS ``` nslookup google.fr ``` Le serveur interrogé doit être : ``` 10.152.152.1 ``` --- ## 11. Arrêter le tunnel ``` sudo wg-quick down wg0 ``` --- ## 12. Démarrage automatique (optionnel) Pour établir automatiquement le VPN au démarrage : ``` sudo systemctl enable wg-quick@wg0 ``` Pour le désactiver : ``` sudo systemctl disable wg-quick@wg0 ``` --- ## Commandes utiles

Commande	Description
`sudo wg`	Afficher l'état du tunnel.
`ip addr show wg0`	Afficher l'interface VPN.
`sudo wg-quick up wg0`	Démarrer le tunnel.
`sudo wg-quick down wg0`	Arrêter le tunnel.
`systemctl status wg-quick@wg0`	Afficher l'état du service.

--- ## Dépannage ### L'interface wg0 n'existe pas ``` ip link show wg0 ``` Vérifier que le fichier **/etc/wireguard/wg0.conf** est présent et correctement nommé. --- ### Aucun Handshake - Vérifier l'accès Internet. - Contrôler le domaine **adguard.numericare.fr**. - Vérifier le port UDP 51820. - Contrôler les clés publiques. --- ### Impossible d'accéder au LAN - Contrôler les **AllowedIPs**. - Vérifier que le serveur WireGuard est actif. - Contrôler le routage IPv4 sur le serveur. --- ### Le DNS ne fonctionne pas ``` resolvectl status ``` Le serveur DNS doit être : ``` 10.152.152.1 ``` --- ## Bonnes pratiques - Conserver le fichier **ubuntu.conf** dans un emplacement sécurisé. - Limiter les permissions du fichier de configuration. - Utiliser une paire de clés unique par machine. - Mettre régulièrement WireGuard à jour. - Désactiver le tunnel lorsqu'il n'est plus utilisé. --- ## Résumé

Élément	Statut
WireGuard installé	✅
Configuration copiée	✅
Tunnel opérationnel	✅
Connexion au réseau domestique	✅
DNS AdGuard fonctionnel	✅

--- > Le client Ubuntu est maintenant entièrement configuré et peut accéder de manière sécurisée au réseau domestique via WireGuard. La procédure pour Fedora est très proche, avec quelques différences liées au gestionnaire de paquets et aux outils d'administration. # 08.3 - Configuration d'un client Fedora Cette page explique comment installer et configurer un client WireGuard sous Fedora afin d'accéder au réseau privé via le serveur VPN. Le client utilisera la configuration générée lors du chapitre 07 (**fedora.conf**). --- ## Prérequis - Le serveur WireGuard est opérationnel. - Le client Fedora a été créé sur le serveur. - Le fichier **fedora.conf** est disponible. - Une connexion Internet est disponible. --- ## Architecture ``` Fedora 10.152.152.5 │ ▼ Tunnel WireGuard │ ▼ adguard.numericare.fr │ ▼ Serveur WireGuard 10.152.152.1 │ ▼ Réseau ASUS 10.151.151.0/24 ``` --- ## 1. Installer WireGuard ``` sudo dnf install wireguard-tools -y ``` --- ## 2. Vérifier l'installation ``` wg --version ``` **Résultat attendu** ``` wireguard-tools v1.x.x ``` --- ## 3. Copier le fichier de configuration ``` sudo cp fedora.conf /etc/wireguard/wg0.conf ``` --- ## 4. Sécuriser le fichier ``` sudo chmod 600 /etc/wireguard/wg0.conf ``` Vérifier : ``` ls -l /etc/wireguard/wg0.conf ``` **Résultat attendu** ``` -rw------- root root ``` --- ## 5. Vérifier la configuration ``` sudo cat /etc/wireguard/wg0.conf ``` Le fichier doit notamment contenir : ``` [Interface] Address = 10.152.152.5/32 DNS = 10.152.152.1 [Peer] Endpoint = adguard.numericare.fr:51820 AllowedIPs = 10.151.151.0/24,10.152.152.0/24 ``` --- ## 6. Démarrer le tunnel ``` sudo wg-quick up wg0 ``` **Résultat attendu** ``` [#] ip link add wg0 type wireguard [#] wg setconf wg0 [#] ip address add [#] ip link set up dev wg0 ``` --- ## 7. Vérifier l'état du tunnel ``` sudo wg ``` La sortie doit afficher : - le Peer du serveur ; - un **Latest Handshake** récent ; - les compteurs RX/TX. --- ## 8. Vérifier l'adresse IP ``` ip addr show wg0 ``` **Résultat attendu** ``` inet 10.152.152.5/32 ``` --- ## 9. Tester la connectivité ``` ping 10.152.152.1 ``` Puis : ``` ping 10.151.151.40 ``` Les deux commandes doivent répondre. --- ## 10. Vérifier le DNS ``` nslookup google.fr ``` Le serveur DNS doit être : ``` 10.152.152.1 ``` Pour afficher la configuration DNS complète : ``` resolvectl status ``` --- ## 11. Activer le démarrage automatique (optionnel) ``` sudo systemctl enable wg-quick@wg0 ``` Démarrer immédiatement : ``` sudo systemctl start wg-quick@wg0 ``` Vérifier : ``` systemctl status wg-quick@wg0 ``` --- ## 12. Arrêter le tunnel ``` sudo wg-quick down wg0 ``` --- ## Utilisation quotidienne

Commande	Description
`sudo wg-quick up wg0`	Démarrer le VPN.
`sudo wg-quick down wg0`	Arrêter le VPN.
`sudo wg`	Afficher l'état du tunnel.
`sudo wg show`	Afficher les statistiques détaillées.
`systemctl status wg-quick@wg0`	Afficher l'état du service.
`journalctl -u wg-quick@wg0`	Consulter les journaux.

--- ## Dépannage ### Le tunnel ne démarre pas ``` journalctl -u wg-quick@wg0 ``` Consulter les derniers messages d'erreur. --- ### Aucun Handshake - Vérifier l'accès Internet. - Contrôler le domaine **adguard.numericare.fr**. - Vérifier la redirection UDP 51820. - Contrôler les clés publiques. --- ### Impossible d'accéder au réseau local - Vérifier les **AllowedIPs**. - Contrôler que le serveur WireGuard fonctionne. - Vérifier le routage IPv4. --- ### Le DNS n'utilise pas AdGuard Home ``` resolvectl status ``` Le serveur DNS actif doit être : ``` 10.152.152.1 ``` --- ## Bonnes pratiques - Conserver le fichier **fedora.conf** dans un emplacement sécurisé. - Limiter les permissions du fichier de configuration. - Mettre régulièrement Fedora et WireGuard à jour. - Utiliser une paire de clés unique par poste. - Désactiver le VPN lorsqu'il n'est plus utilisé. --- ## Résumé

Élément	Statut
WireGuard installé	✅
Configuration importée	✅
Tunnel établi	✅
Connexion au réseau domestique	✅
DNS AdGuard opérationnel	✅

--- > Le client Fedora est maintenant entièrement configuré et peut accéder au réseau domestique de manière sécurisée. Les chapitres suivants présentent la configuration des clients Android, iPhone/iPad et macOS. # 08.4 - Configuration d'un client Android Cette page explique comment installer et configurer WireGuard sur un smartphone ou une tablette Android afin d'accéder au réseau domestique de manière sécurisée. Deux méthodes d'import sont possibles : - Import via un QR Code (méthode recommandée). - Import du fichier **android.conf**. --- ## Prérequis - Le serveur WireGuard est opérationnel. - Le client Android a été créé (voir chapitre 07). - Le QR Code ou le fichier **android.conf** est disponible. - Une connexion Internet est disponible. --- ## Architecture ``` Android 10.152.152.5 │ Tunnel WireGuard │ ▼ adguard.numericare.fr │ ▼ Serveur WireGuard 10.152.152.1 │ ▼ Réseau ASUS 10.151.151.0/24 ``` --- ## 1. Installer WireGuard Installer l'application officielle **WireGuard** depuis le Google Play Store. --- ## 2. Ouvrir l'application Au premier lancement, aucun tunnel n'est configuré. --- ## 3. Ajouter un tunnel Appuyer sur le bouton : ``` + ``` Deux méthodes sont proposées : - Scanner un QR Code. - Importer depuis un fichier. --- ## 4. Import via QR Code (recommandé) Sélectionner : ``` Scanner depuis un QR Code ``` Scanner le QR Code généré sur le serveur. Le tunnel est automatiquement créé. --- ## 5. Import via un fichier Si le QR Code n'est pas disponible : ``` Importer depuis un fichier ``` Sélectionner : ``` android.conf ``` --- ## 6. Vérifier la configuration Le tunnel doit contenir une configuration similaire à celle-ci : ``` [Interface] Address = 10.152.152.5/32 DNS = 10.152.152.1 [Peer] Endpoint = adguard.numericare.fr:51820 AllowedIPs = 10.151.151.0/24,10.152.152.0/24 PersistentKeepalive = 25 ``` --- ## 7. Activer le tunnel Appuyer sur l'interrupteur situé à droite du tunnel. Android demande l'autorisation de créer un VPN. Accepter la demande. --- ## 8. Vérifier la connexion Une icône VPN apparaît dans la barre d'état Android. Le tunnel est maintenant actif. --- ## 9. Vérifier le serveur Depuis le serveur Debian : ``` sudo wg ``` Le client Android doit apparaître avec : - Latest Handshake - Transfer RX - Transfer TX --- ## 10. Tester la connectivité Depuis un navigateur Android, accéder à une application hébergée sur le réseau domestique. Par exemple : - Home Assistant - BookStack - Grafana - NAS Synology Si les applications sont accessibles, le tunnel fonctionne correctement. --- ## 11. Vérifier le DNS Ouvrir un navigateur puis visiter un site de test DNS ou utiliser une application de diagnostic réseau. Les requêtes DNS doivent être résolues par : ``` 10.152.152.1 ``` Le filtrage AdGuard Home est alors actif même en dehors du domicile. --- ## 12. Désactiver le VPN Dans WireGuard, désactiver simplement l'interrupteur du tunnel. --- ## Dépannage ### Le tunnel ne se connecte pas - Vérifier l'accès Internet. - Contrôler le domaine **adguard.numericare.fr**. - Vérifier le port UDP 51820. - Contrôler les clés du client. --- ### Aucun Handshake Sur le serveur : ``` sudo wg ``` Si aucun **Latest Handshake** n'apparaît, vérifier la configuration du client et la redirection du port UDP 51820. --- ### Impossible d'accéder au réseau domestique - Vérifier les **AllowedIPs**. - Contrôler le routage IPv4 du serveur. - Vérifier les règles NAT. --- ### Les publicités ne sont pas bloquées - Vérifier que le champ **DNS** est configuré avec **10.152.152.1**. - Contrôler qu'aucun DNS privé Android n'est activé. --- ## Bonnes pratiques - Utiliser un tunnel différent pour chaque appareil Android. - Ne jamais partager le QR Code avec une autre personne. - Supprimer le tunnel si le téléphone est remplacé. - Protéger le smartphone avec un code ou une authentification biométrique. - Maintenir l'application WireGuard à jour. --- ## Résumé

Élément	Statut
Application WireGuard installée	✅
Tunnel importé	✅
Connexion VPN établie	✅
Accès au réseau domestique	✅
DNS AdGuard opérationnel	✅

--- > Le client Android est maintenant entièrement configuré. Le chapitre suivant présente la procédure équivalente pour un iPhone ou un iPad. # 08.5 - Configuration d'un client iPhone / iPad Cette page explique comment installer et configurer WireGuard sur un iPhone ou un iPad afin d'accéder au réseau domestique de manière sécurisée. Deux méthodes d'import sont possibles : - Scanner un QR Code (méthode recommandée). - Importer un fichier de configuration. --- ## Prérequis - Le serveur WireGuard est opérationnel. - Le client iPhone / iPad a été créé (voir chapitre 07). - Le QR Code ou le fichier **iphone.conf** est disponible. - Une connexion Internet est disponible. --- ## Architecture ``` iPhone / iPad 10.152.152.3 │ Tunnel WireGuard │ ▼ adguard.numericare.fr │ ▼ Serveur WireGuard 10.152.152.1 │ ▼ Réseau ASUS 10.151.151.0/24 ``` --- ## 1. Installer WireGuard Installer l'application officielle **WireGuard** depuis l'App Store. --- ## 2. Ouvrir l'application Au premier lancement, aucun tunnel n'est encore configuré. --- ## 3. Ajouter un tunnel Appuyer sur : ``` Ajouter un tunnel ``` Deux méthodes sont disponibles : - Scanner un QR Code. - Créer ou importer depuis un fichier. --- ## 4. Import via QR Code (recommandé) Choisir : ``` Scanner un QR Code ``` Scanner ensuite le QR Code généré sur le serveur. Le tunnel est créé automatiquement. --- ## 5. Import via un fichier Si le QR Code n'est pas disponible : - Transférer le fichier **iphone.conf** sur l'iPhone (AirDrop, Mail, iCloud Drive, etc.). - Ouvrir le fichier et choisir **WireGuard** comme application d'import. --- ## 6. Vérifier la configuration Le tunnel doit contenir une configuration similaire à : ``` [Interface] Address = 10.152.152.3/32 DNS = 10.152.152.1 [Peer] Endpoint = adguard.numericare.fr:51820 AllowedIPs = 10.151.151.0/24,10.152.152.0/24 PersistentKeepalive = 25 ``` --- ## 7. Activer le tunnel Basculer l'interrupteur du tunnel sur **Activé**. iOS demande l'autorisation d'ajouter une configuration VPN. Valider la demande puis s'authentifier avec Face ID, Touch ID ou le code de l'appareil. --- ## 8. Vérifier la connexion Une icône **VPN** apparaît dans la barre d'état (ou dans le Centre de contrôle selon le modèle d'iPhone/iPad). Le tunnel est maintenant actif. --- ## 9. Vérifier le serveur Depuis le serveur Debian : ``` sudo wg ``` Le client iPhone/iPad doit apparaître avec : - Latest Handshake - Transfer RX - Transfer TX --- ## 10. Tester l'accès au réseau domestique Ouvrir Safari puis accéder à un service hébergé sur le réseau domestique, par exemple : - Home Assistant - BookStack - Grafana - NAS Synology Si les services sont accessibles, le tunnel fonctionne correctement. --- ## 11. Vérifier le DNS Les requêtes DNS doivent être résolues par : ``` 10.152.152.1 ``` Le filtrage AdGuard Home est alors appliqué, même lorsque l'appareil est connecté à un réseau Wi-Fi public ou au réseau mobile. --- ## 12. Désactiver le VPN Ouvrir WireGuard puis désactiver simplement l'interrupteur du tunnel. --- ## VPN à la demande (optionnel) WireGuard permet d'activer automatiquement le VPN dans certaines situations, par exemple lors de la connexion à un réseau Wi-Fi public. Cette fonctionnalité peut être configurée dans les paramètres du tunnel afin d'améliorer la sécurité sans intervention manuelle. --- ## Dépannage ### Le tunnel ne se connecte pas - Vérifier la connexion Internet. - Contrôler que **adguard.numericare.fr** est joignable. - Vérifier la redirection du port UDP 51820. - Contrôler les clés publiques et privées. --- ### Aucun Handshake Depuis le serveur : ``` sudo wg ``` Si aucun **Latest Handshake** n'apparaît, vérifier la configuration du client et l'ouverture du port UDP 51820. --- ### Impossible d'accéder au réseau domestique - Vérifier les **AllowedIPs**. - Contrôler le routage IPv4 sur le serveur. - Vérifier les règles NAT. --- ### Les publicités ne sont pas bloquées - Vérifier que le DNS configuré est **10.152.152.1**. - Contrôler qu'aucun profil DNS ou VPN tiers n'est actif sur l'appareil. --- ## Bonnes pratiques - Utiliser un tunnel distinct pour chaque appareil Apple. - Ne jamais partager le QR Code. - Supprimer le tunnel si l'appareil est remplacé ou perdu. - Maintenir iOS/iPadOS et l'application WireGuard à jour. - Activer le VPN à la demande si l'appareil est fréquemment utilisé sur des réseaux publics. --- ## Résumé

Élément	Statut
Application WireGuard installée	✅
Tunnel importé	✅
Connexion VPN établie	✅
Accès au réseau domestique	✅
DNS AdGuard opérationnel	✅

--- > Le client iPhone / iPad est maintenant entièrement configuré et peut accéder au réseau domestique de manière sécurisée. Le dernier chapitre présente la configuration du client macOS. # 08.6 - Configuration d'un client macOS Cette page explique comment installer et configurer WireGuard sur macOS afin d'accéder au réseau domestique via le serveur VPN. La méthode recommandée consiste à utiliser l'application officielle WireGuard disponible sur l'App Store. --- ## Prérequis - Le serveur WireGuard est opérationnel. - Le client macOS a été créé sur le serveur (voir chapitre 07). - Le fichier **macos.conf** ou son QR Code est disponible. - Une connexion Internet est disponible. --- ## Architecture ``` macOS 10.152.152.6 │ Tunnel WireGuard │ ▼ adguard.numericare.fr │ ▼ Serveur WireGuard 10.152.152.1 │ ▼ Réseau ASUS 10.151.151.0/24 ``` --- ## 1. Installer WireGuard Installer l'application officielle **WireGuard** depuis l'App Store. --- ## 2. Ouvrir l'application Au premier lancement, aucune configuration VPN n'est présente. --- ## 3. Importer un tunnel Cliquer sur : ``` Import tunnel(s) from file... ``` Puis sélectionner le fichier : ``` macos.conf ``` Le tunnel est automatiquement ajouté. --- ## 4. Vérifier la configuration La configuration doit être similaire à : ``` [Interface] PrivateKey = xxxxxxxxxxxxxxxxxxxxxxxxx Address = 10.152.152.6/32 DNS = 10.152.152.1 [Peer] PublicKey = xxxxxxxxxxxxxxxxxxxxxxxxx Endpoint = adguard.numericare.fr:51820 AllowedIPs = 10.151.151.0/24,10.152.152.0/24 PersistentKeepalive = 25 ``` --- ## Comprendre les paramètres

Paramètre	Description
Address	Adresse VPN attribuée au Mac.
DNS	Utilisation d'AdGuard Home via le tunnel VPN.
Endpoint	Nom DNS public du serveur WireGuard.
AllowedIPs	Réseaux accessibles via le VPN (Split Tunnel).
PersistentKeepalive	Maintient la connexion active derrière un routeur NAT.

--- ## 5. Activer le tunnel Cliquer sur : ``` Activate ``` Lors de la première connexion, macOS demande l'autorisation d'ajouter une configuration VPN. Valider la demande puis s'authentifier avec Touch ID ou le mot de passe de la session. --- ## 6. Vérifier la connexion Une icône VPN apparaît dans la barre de menus de macOS. Le tunnel est maintenant actif. --- ## 7. Vérifier le serveur Depuis le serveur Debian : ``` sudo wg ``` Le client macOS doit apparaître avec : - Latest Handshake - Transfer RX - Transfer TX --- ## 8. Tester la connectivité Ouvrir le Terminal puis exécuter : ``` ping 10.152.152.1 ``` Puis : ``` ping 10.151.151.40 ``` Les deux commandes doivent répondre. --- ## 9. Vérifier le DNS Afficher la configuration DNS active : ``` scutil --dns ``` Le serveur DNS utilisé par le tunnel doit être : ``` 10.152.152.1 ``` Le filtrage AdGuard Home est alors appliqué aux requêtes DNS transitant par le VPN. --- ## 10. Désactiver le VPN Dans WireGuard, cliquer sur : ``` Deactivate ``` Le tunnel est immédiatement fermé. --- ## Utilisation avancée (Terminal) Les utilisateurs avancés peuvent également gérer le tunnel en ligne de commande à l'aide de **wg-quick** (si les outils WireGuard sont installés). ``` sudo wg-quick up wg0 sudo wg sudo wg-quick down wg0 ``` --- ## Dépannage ### Le tunnel ne se connecte pas - Vérifier la connexion Internet. - Contrôler que **adguard.numericare.fr** est résolu correctement. - Vérifier l'ouverture du port UDP 51820. - Contrôler les clés publiques et privées. --- ### Aucun Handshake Depuis le serveur : ``` sudo wg ``` Si aucun **Latest Handshake** n'apparaît, vérifier la configuration du client et la redirection du port UDP 51820. --- ### Impossible d'accéder au réseau domestique - Vérifier les **AllowedIPs**. - Contrôler le routage IPv4 sur le serveur. - Vérifier les règles NAT. --- ### Les publicités ne sont pas bloquées - Vérifier que le DNS du tunnel est bien **10.152.152.1**. - Contrôler qu'aucun autre logiciel VPN ou DNS n'est actif. --- ## Bonnes pratiques - Conserver le fichier **macos.conf** dans un emplacement sécurisé. - Ne jamais partager la clé privée. - Mettre régulièrement macOS et WireGuard à jour. - Utiliser un tunnel distinct pour chaque Mac. - Désactiver le VPN lorsqu'il n'est plus nécessaire. --- ## Résumé

Élément	Statut
Application WireGuard installée	✅
Configuration importée	✅
Tunnel établi	✅
Accès au réseau domestique	✅
DNS AdGuard opérationnel	✅

--- > Le client macOS est désormais entièrement configuré et peut accéder au réseau domestique de manière sécurisée via WireGuard. Vous disposez maintenant d'une procédure complète pour les principales plateformes : Windows, Ubuntu, Fedora, Android, iPhone/iPad et macOS. # 09 - Mise à jour de WireGuard Cette page décrit la procédure recommandée pour mettre à jour WireGuard et ses composants sur le serveur Debian hébergeant le service VPN. L'objectif est de bénéficier des dernières corrections de sécurité, des améliorations de stabilité et des nouvelles fonctionnalités tout en garantissant la continuité du service. --- ## Prérequis - Disposer d'un accès SSH au serveur. - Être connecté avec un compte disposant des privilèges **sudo**. - Vérifier qu'aucune opération de maintenance n'est en cours. --- ## 1. Vérifier la version installée Afficher la version des outils WireGuard : ``` wg --version ``` Exemple : ``` wireguard-tools v1.0.20210914 ``` --- ## 2. Vérifier les mises à jour disponibles ``` sudo apt update ``` Puis afficher les paquets pouvant être mis à jour : ``` apt list --upgradable ``` Si une nouvelle version de **wireguard** ou **wireguard-tools** apparaît dans la liste, une mise à jour est disponible. --- ## 3. Mettre à jour le système ``` sudo apt upgrade -y ``` Cette commande met à jour l'ensemble des paquets installés, y compris WireGuard si une nouvelle version est disponible. --- ## 4. Vérifier que le service est toujours actif ``` sudo systemctl status wg-quick@wg0 ``` Le résultat attendu est similaire à : ``` Active: active (exited) ``` --- ## 5. Vérifier le fonctionnement du tunnel ``` sudo wg ``` Contrôler notamment les informations suivantes : - Présence de l'interface **wg0**. - Liste des clients configurés. - Derniers **Handshake**. - Compteurs RX/TX. --- ## 6. Vérifier l'écoute du port UDP ``` sudo ss -lunp | grep 51820 ``` Le serveur doit toujours être à l'écoute sur le port UDP **51820**. --- ## 7. Tester la connectivité Depuis un client WireGuard : - Établir le tunnel VPN. - Accéder au réseau **10.151.151.0/24**. - Vérifier la résolution DNS via AdGuard Home. --- ## 8. Redémarrer le service (si nécessaire) Dans la majorité des cas, aucun redémarrage n'est nécessaire. Si toutefois la mise à jour le requiert, exécuter : ``` sudo systemctl restart wg-quick@wg0 ``` Vérifier ensuite le statut du service : ``` sudo systemctl status wg-quick@wg0 ``` --- ## 9. Consulter les journaux En cas d'anomalie après la mise à jour : ``` journalctl -u wg-quick@wg0 ``` Ou uniquement les derniers événements : ``` journalctl -u wg-quick@wg0 -n 50 ``` --- ## Bonnes pratiques - Mettre régulièrement le système Debian à jour. - Effectuer les mises à jour durant une période de faible utilisation. - Vérifier le bon fonctionnement des clients après chaque mise à jour. - Contrôler les journaux système en cas d'anomalie. - Maintenir le système d'exploitation également à jour afin de bénéficier des derniers correctifs de sécurité. --- ## Résumé

Étape	Validation
Version vérifiée	✅
Paquets mis à jour	✅
Service WireGuard opérationnel	✅
Port UDP 51820 à l'écoute	✅
Tests de connexion validés	✅

--- > La mise à jour de WireGuard est terminée. Le serveur bénéficie des dernières corrections tout en conservant sa configuration existante. Il est recommandé de vérifier le bon fonctionnement des clients après chaque mise à jour afin de garantir la disponibilité du service VPN. # 10 - Dépannage Cette page regroupe les principaux problèmes pouvant être rencontrés lors de l'utilisation de WireGuard ainsi que les procédures de diagnostic permettant d'identifier rapidement leur origine. Les vérifications sont présentées du cas le plus fréquent au plus spécifique. --- ## Vérifier l'état général du serveur Avant toute investigation, contrôler que le serveur WireGuard fonctionne correctement. ``` sudo systemctl status wg-quick@wg0 ``` Le résultat attendu est : ``` Active: active (exited) ``` Puis vérifier l'interface WireGuard : ``` sudo wg ``` --- ## Le client ne parvient pas à se connecter ### Cause possible - Le serveur n'est pas démarré. - Le port UDP 51820 n'est pas accessible. - Le domaine DNS est incorrect. - Une erreur est présente dans la configuration du client. ### Vérifications ``` sudo systemctl status wg-quick@wg0 ``` ``` sudo ss -lunp | grep 51820 ``` ``` sudo wg ``` Vérifier également : - Le nom DNS **adguard.numericare.fr**. - La redirection UDP 51820 sur le routeur. - La configuration du client. --- ## Aucun Handshake ### Symptômes ``` sudo wg ``` Le champ **Latest Handshake** est absent ou indique **Never**. ### Causes possibles - Clés publiques incorrectes. - Port UDP fermé. - Nom DNS incorrect. - Connexion Internet indisponible. ### Vérifications - Contrôler les clés publique et privée. - Tester le domaine **adguard.numericare.fr**. - Vérifier la redirection UDP 51820. - Contrôler le pare-feu. --- ## Le tunnel est établi mais le réseau domestique est inaccessible ### Symptômes - Le Handshake est présent. - Impossible de joindre les équipements du réseau **10.151.151.0/24**. ### Vérifications Contrôler les réseaux autorisés : ``` AllowedIPs = 10.151.151.0/24,10.152.152.0/24 ``` Puis vérifier le routage IPv4 : ``` cat /proc/sys/net/ipv4/ip_forward ``` Le résultat attendu est : ``` 1 ``` --- ## Le DNS ne fonctionne pas ### Symptômes - Les noms de domaine ne sont pas résolus. - Les publicités ne sont plus filtrées. ### Vérifications Contrôler la configuration du client : ``` DNS = 10.152.152.1 ``` Puis vérifier qu'AdGuard Home est actif : ``` docker ps ``` Le conteneur AdGuard Home doit être en état **Up**. --- ## Impossible d'accéder à Internet ### Cause possible Ce problème apparaît généralement lorsque le client est configuré en **Full Tunnel** et que le routage ou le NAT du serveur est incorrect. ### Vérifications ``` sudo iptables -t nat -L ``` Contrôler la présence de la règle MASQUERADE. --- ## Le client se connecte puis se déconnecte régulièrement ### Cause possible - Connexion mobile instable. - NAT du routeur. - Absence du paramètre PersistentKeepalive. ### Vérification Le client doit contenir : ``` PersistentKeepalive = 25 ``` --- ## Le serveur écoute sur un mauvais port Vérifier la configuration : ``` sudo cat /etc/wireguard/wg0.conf ``` Le paramètre attendu est : ``` ListenPort = 51820 ``` --- ## Vérifier les journaux Afficher les derniers événements : ``` journalctl -u wg-quick@wg0 -n 50 ``` Afficher les journaux en temps réel : ``` journalctl -fu wg-quick@wg0 ``` --- ## Commandes de diagnostic

Commande	Description
`sudo wg`	Afficher les tunnels et les Handshakes.
`ip addr show wg0`	Afficher l'interface WireGuard.
`systemctl status wg-quick@wg0`	Vérifier le service.
`ss -lunp \| grep 51820`	Vérifier l'écoute du port UDP.
`journalctl -u wg-quick@wg0`	Consulter les journaux.
`docker ps`	Vérifier qu'AdGuard Home est démarré.
`iptables -t nat -L`	Contrôler les règles NAT.
`cat /proc/sys/net/ipv4/ip_forward`	Vérifier l'activation du routage IPv4.

--- ## Résumé

Problème	Premier contrôle à effectuer
Aucune connexion	Vérifier le service WireGuard.
Aucun Handshake	Contrôler les clés, le DNS et le port UDP 51820.
Réseau domestique inaccessible	Vérifier les AllowedIPs et le routage IPv4.
DNS inopérant	Vérifier AdGuard Home et le paramètre DNS.
Pas d'accès Internet	Contrôler les règles NAT et la configuration Full Tunnel.
Déconnexions fréquentes	Vérifier le paramètre PersistentKeepalive.

--- > La majorité des incidents WireGuard proviennent d'une configuration incorrecte des clés, des paramètres **AllowedIPs**, de la résolution DNS ou de la redirection du port UDP **51820**. En suivant les vérifications de cette page dans l'ordre, il est généralement possible d'identifier rapidement l'origine du problème. # 11 - Annexe : Utilisation du Full Tunnel Cette documentation est basée sur une architecture **Split Tunnel**, dans laquelle seul le trafic destiné au réseau domestique transite par le VPN. Dans certains cas, il peut être souhaitable de faire transiter l'ensemble du trafic Internet par le serveur WireGuard. Ce mode de fonctionnement est appelé **Full Tunnel**. --- ## Split Tunnel (configuration actuelle) Dans cette documentation, les clients utilisent la configuration suivante : ``` AllowedIPs = 10.151.151.0/24,10.152.152.0/24 ``` Cela signifie que seuls les réseaux suivants sont envoyés dans le tunnel VPN : - Le réseau domestique : **10.151.151.0/24**. - Le réseau WireGuard : **10.152.152.0/24**. Tout le reste du trafic Internet continue de sortir directement par la connexion réseau du client. ``` Internet ▲ │ Connexion locale ▲ │ Client │ ──────────────┼────────────── ▼ Tunnel WireGuard ▼ Réseau domestique 10.151.151.0/24 ``` --- ## Passer en Full Tunnel Pour faire transiter l'intégralité du trafic réseau dans le tunnel VPN, remplacer la directive **AllowedIPs** du client par : ``` AllowedIPs = 0.0.0.0/0 ``` Pour une prise en charge complète d'IPv4 et d'IPv6 : ``` AllowedIPs = 0.0.0.0/0,::/0 ``` --- ## Fonctionnement Lorsque le Full Tunnel est activé, l'ensemble des communications du client passe par le serveur WireGuard avant d'accéder à Internet. ``` Client │ ▼ Tunnel WireGuard │ ▼ Serveur WireGuard │ ▼ AdGuard Home │ ▼ Routeur ASUS │ ▼ Internet ``` --- ## Avantages - L'ensemble du trafic est chiffré entre le client et le domicile. - Les requêtes DNS sont systématiquement filtrées par AdGuard Home. - Les services Internet voient l'adresse IP publique du domicile. - Les réseaux Wi-Fi publics deviennent beaucoup plus sûrs. - Les règles de filtrage AdGuard sont appliquées quel que soit le réseau utilisé. --- ## Inconvénients - Toute la navigation Internet dépend de la connexion du domicile. - Le débit Internet est limité par le débit montant de la connexion domestique. - Une coupure du serveur WireGuard interrompt également l'accès à Internet. - Le serveur traite davantage de trafic réseau. --- ## Configuration DNS Aucune modification supplémentaire n'est nécessaire concernant le DNS si le client utilise déjà la configuration recommandée : ``` DNS = 10.152.152.1 ``` Les requêtes DNS continueront d'être résolues par AdGuard Home via le tunnel VPN. --- ## Quand utiliser le Full Tunnel ?

Situation	Recommandation
Accès au réseau domestique uniquement	Conserver le Split Tunnel.
Utilisation sur un Wi-Fi public	Utiliser le Full Tunnel.
Bénéficier du filtrage AdGuard partout	Utiliser le Full Tunnel.
Masquer son adresse IP publique	Utiliser le Full Tunnel.
Optimiser les performances réseau	Conserver le Split Tunnel.

--- ## Revenir au Split Tunnel Pour retrouver le comportement décrit dans cette documentation, rétablir la configuration d'origine : ``` AllowedIPs = 10.151.151.0/24,10.152.152.0/24 ``` Le client utilisera alors le VPN uniquement pour accéder au réseau domestique, tandis que le trafic Internet continuera d'emprunter la connexion locale. --- ## Résumé

Mode	Trafic VPN	Utilisation recommandée
Split Tunnel	Uniquement le réseau domestique	Usage quotidien
Full Tunnel	Tout le trafic Internet	Réseaux publics, confidentialité renforcée

--- > Le **Split Tunnel** constitue le mode de fonctionnement recommandé pour cette infrastructure, car il offre un excellent compromis entre performances et accès sécurisé au réseau domestique. Le **Full Tunnel** reste une option intéressante lorsque l'on souhaite protéger l'ensemble de son trafic Internet ou bénéficier du filtrage AdGuard Home sur tous les réseaux. # Nmap - Les commandes indispensables ## Installation Debian / Ubuntu sudo apt update sudo apt install nmap RHEL / Rocky / AlmaLinux sudo dnf install nmap Vérifier la version nmap --version 1. Découvrir les machines d'un réseau Scanner uniquement les hôtes actifs. nmap -sn 192.168.1.0/24 Résultat : Host is up Nmap scan report for 192.168.1.10 Nmap scan report for 192.168.1.15 Très pratique pour : inventaire retrouver une machine détecter un nouvel équipement 2. Scanner les ports ouverts Ports par défaut nmap 192.168.1.10 Tous les ports nmap -p- 192.168.1.10 Ports spécifiques nmap -p 22,80,443 192.168.1.10 Plage nmap -p 20-1000 192.168.1.10 3. Identifier les services nmap -sV 192.168.1.10 Exemple 22/tcp open ssh OpenSSH 9.8 80/tcp open nginx 1.26 443/tcp open https Très utile pour vérifier la version d'un service. � Nmap 4. Détection du système d'exploitation sudo nmap -O 192.168.1.10 Exemple Linux 6.x 5. Scan avancé sudo nmap -A 192.168.1.10 Le mode -A active : détection OS versions scripts NSE traceroute C'est souvent le premier scan complet utilisé pour un audit autorisé. � Nmap +1 6. Scripts NSE Lister les scripts ls /usr/share/nmap/scripts/ Scanner les vulnérabilités connues sudo nmap --script vuln 192.168.1.10 Détecter des informations HTTP nmap --script http-title 192.168.1.10 Informations SSL nmap --script ssl-cert -p443 192.168.1.10 7. Scan UDP sudo nmap -sU 192.168.1.10 Exemple 53 DNS 123 NTP 161 SNMP 8. Traceroute sudo nmap --traceroute 192.168.1.10 9. Scan rapide Ports les plus courants nmap -F 192.168.1.10 Timing plus rapide nmap -T4 192.168.1.10 10. Scanner plusieurs machines Une plage nmap 192.168.1.1-100 Un réseau nmap 192.168.1.0/24 Depuis un fichier hosts.txt 192.168.1.10 192.168.1.20 192.168.1.30 Puis nmap -iL hosts.txt 11. Sauvegarder les résultats Texte nmap -oN scan.txt 192.168.1.10 XML nmap -oX scan.xml 192.168.1.10 Tous les formats nmap -oA scan 192.168.1.10 Très pratique pour conserver un historique ou importer les résultats dans d'autres outils. � Reddit 12. Quelques exemples utiles Découvrir toutes les machines nmap -sn 192.168.1.0/24 Scanner un serveur Web nmap -sV -p80,443 webserver.local Scanner un serveur SSH nmap -sV -p22 serveur Scanner un NAS nmap -A 192.168.1.20 Scanner tout un VLAN nmap -T4 192.168.10.0/24 Tableau récapitulatif Commande Description -sn Découverte des hôtes -p- Tous les ports -p 80,443 Ports spécifiques -sV Détection des versions -O Détection de l'OS -A Scan avancé -sU Scan UDP -F Scan rapide -T4 Plus rapide --script vuln Scripts NSE de vérification --traceroute Chemin réseau -oA Sauvegarde complète Bonnes pratiques Commencer par -sn pour identifier les hôtes actifs. Utiliser -sV pour connaître les services exposés. Réserver -A aux audits complets, car il est plus intrusif et plus lent. Sauvegarder les résultats avec -oA pour pouvoir comparer les scans dans le temps. Utiliser Nmap uniquement sur des systèmes dont tu es propriétaire ou pour lesquels tu as une autorisation explicite. # Mise à jour manuelle de code-server – LXC BASTION Cette procédure permet de mettre à jour **code-server** installé sous forme de paquet Debian (`.deb`) sur le LXC **BASTION**. ## 1. Informations de l'installation

Élément	Valeur
Utilisateur	`nancre`
Architecture	`amd64`
Installation	Paquet Debian officiel
Binaire	`/usr/bin/code-server`
Installation	`/usr/lib/code-server`
Configuration	`/home/nancre/.config/code-server/config.yaml`
Données utilisateur	`/home/nancre/.local/share/code-server`
Service systemd	`code-server@nancre.service`
Port	`8080/TCP`

## 2. Vérifier la version actuelle Avant toute modification, vérifier la version installée : ``` dpkg -l | grep code-server /usr/bin/code-server --version ``` Exemple : ``` ii code-server 4.130.0 amd64 Run VS Code in the browser. 4.130.0 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx with Code 1.130.0 ``` ## 3. Vérifier que le service fonctionne ``` sudo systemctl status code-server@nancre.service --no-pager ``` Le service doit être : ``` Active: active (running) ``` Vérifier également que le port 8080 est à l'écoute : ``` sudo ss -ltnp | grep ':8080' ``` On doit retrouver une écoute sur : ``` 0.0.0.0:8080 ``` ## 4. Sauvegarder la configuration Avant la mise à jour, sauvegarder la configuration et les données utilisateur. ``` cp -a ~/.config/code-server \ ~/.config/code-server.backup-$(date +%Y%m%d-%H%M%S) cp -a ~/.local/share/code-server \ ~/.local/share/code-server.backup-$(date +%Y%m%d-%H%M%S) ``` Vérifier que les sauvegardes existent : ``` ls -ld ~/.config/code-server.backup-* ls -ld ~/.local/share/code-server.backup-* ``` ## 5. Définir la version cible Remplacer `4.137.0` par la version souhaitée. ``` export CODE_SERVER_VERSION="4.137.0" ``` Pour vérifier : ``` echo "$CODE_SERVER_VERSION" ``` ## 6. Télécharger le paquet officiel Se placer dans le répertoire temporaire : ``` cd /tmp ``` Télécharger le paquet Debian correspondant à l'architecture AMD64 : ``` wget "https://github.com/coder/code-server/releases/download/v${CODE_SERVER_VERSION}/code-server_${CODE_SERVER_VERSION}_amd64.deb" ``` Vérifier que le fichier existe : ``` ls -lh "/tmp/code-server_${CODE_SERVER_VERSION}_amd64.deb" ``` ## 7. Vérifier le paquet avant installation Afficher les informations du paquet : ``` dpkg-deb -I "/tmp/code-server_${CODE_SERVER_VERSION}_amd64.deb" | grep -E 'Package:|Version:|Architecture:' ``` Le résultat doit indiquer : ``` Package: code-server Version: 4.137.0 Architecture: amd64 ``` ## 8. Installer la nouvelle version ``` sudo dpkg -i "/tmp/code-server_${CODE_SERVER_VERSION}_amd64.deb" ``` Si des dépendances sont signalées comme manquantes, exécuter : ``` sudo apt-get install -f ``` Puis vérifier de nouveau le paquet : ``` dpkg -l | grep code-server ``` ## 9. Vérifier la nouvelle version ``` /usr/bin/code-server --version ``` Le résultat doit correspondre à la version cible. Exemple pour la version 4.137.0 : ``` 4.137.0 b11dabdaca0d3369986975be285db92c8795cea5 with Code 1.137.0 ``` ## 10. Recharger la configuration systemd L'installation d'un nouveau paquet peut modifier les fichiers systemd. Recharger le gestionnaire systemd : ``` sudo systemctl daemon-reload ``` Cette étape est importante si systemd affiche le message : ``` Warning: The unit file, source configuration file or drop-ins of code-server@nancre.service changed on disk. Run 'systemctl daemon-reload' to reload units. ``` ## 11. Redémarrer code-server ``` sudo systemctl restart code-server@nancre.service ``` Vérifier immédiatement le service : ``` sudo systemctl status code-server@nancre.service --no-pager ``` Le service doit être : ``` Active: active (running) ``` ## 12. Vérifier les logs Afficher les dernières lignes du journal : ``` sudo journalctl -u code-server@nancre.service -n 50 --no-pager ``` En cas de problème, rechercher les erreurs : ``` sudo journalctl -u code-server@nancre.service --no-pager | grep -Ei 'error|failed|fatal' ``` ## 13. Vérifier le port d'écoute ``` sudo ss -ltnp | grep ':8080' ``` Le port doit être ouvert sur : ``` 0.0.0.0:8080 ``` ## 14. Tester localement Tester la réponse HTTP de code-server : ``` curl -I http://127.0.0.1:8080 ``` Une réponse : ``` HTTP/1.1 401 Unauthorized ``` est normale puisque l'authentification par mot de passe est activée dans `config.yaml`. ## 15. Vérifier la configuration ``` cat ~/.config/code-server/config.yaml ``` Configuration actuelle attendue : ``` bind-addr: 0.0.0.0:8080 auth: password password: 'MON_MOT_DE_PASSE' cert: false ``` **Ne pas modifier le mot de passe pendant une simple mise à jour.** ## 16. Test fonctionnel dans le navigateur Ouvrir l'URL habituelle de code-server et vérifier : - connexion à code-server ; - ouverture du workspace ; - terminal intégré ; - Git ; - extensions ; - extension Codex/OpenAI ; - accès aux fichiers du workspace. ## 17. Vérification finale Exécuter : ``` echo "=== VERSION ===" /usr/bin/code-server --version echo "=== PAQUET ===" dpkg -l | grep code-server echo "=== SERVICE ===" sudo systemctl is-active code-server@nancre.service echo "=== PORT ===" sudo ss -ltnp | grep ':8080' ``` La mise à jour est considérée comme réussie si : - la version correspond à la version cible ; - le paquet est en état `ii` ; - le service retourne `active` ; - le port 8080 est à l'écoute ; - l'interface web fonctionne. --- ## 18. Procédure de rollback En cas de problème après la mise à jour, il est possible de revenir à la version précédente. ### 18.1 Identifier la version précédente ``` grep code-server /var/log/dpkg.log | tail -20 ``` On peut également consulter : ``` ls -lh /tmp/code-server_*.deb ``` Si le paquet précédent a été conservé dans `/tmp`, il peut être réinstallé directement. ### 18.2 Télécharger l'ancienne version Définir la version précédente : ``` export OLD_VERSION="4.130.0" ``` Télécharger le paquet : ``` cd /tmp wget "https://github.com/coder/code-server/releases/download/v${OLD_VERSION}/code-server_${OLD_VERSION}_amd64.deb" ``` ### 18.3 Réinstaller l'ancienne version ``` sudo dpkg -i "/tmp/code-server_${OLD_VERSION}_amd64.deb" ``` ### 18.4 Recharger systemd ``` sudo systemctl daemon-reload ``` ### 18.5 Redémarrer code-server ``` sudo systemctl restart code-server@nancre.service ``` ### 18.6 Vérifier le rollback ``` /usr/bin/code-server --version sudo systemctl status code-server@nancre.service --no-pager sudo ss -ltnp | grep ':8080' ``` La version précédente doit être affichée et le service doit être `active (running)`. ## 19. Rollback de la configuration utilisateur Si la mise à jour a également provoqué un problème avec la configuration ou les extensions, arrêter code-server : ``` sudo systemctl stop code-server@nancre.service ``` Identifier la sauvegarde créée avant la mise à jour : ``` ls -ld ~/.config/code-server.backup-* ls -ld ~/.local/share/code-server.backup-* ``` Restaurer la configuration : ``` rm -rf ~/.config/code-server cp -a ~/.config/code-server.backup-YYYYMMDD-HHMMSS ~/.config/code-server ``` Restaurer les données utilisateur uniquement si nécessaire : ``` rm -rf ~/.local/share/code-server cp -a ~/.local/share/code-server.backup-YYYYMMDD-HHMMSS ~/.local/share/code-server ``` Redémarrer : ``` sudo systemctl start code-server@nancre.service ```

**⚠️ Attention :** remplacer `YYYYMMDD-HHMMSS` par le nom exact de la sauvegarde. Ne pas supprimer les sauvegardes avant d'avoir validé le fonctionnement de la nouvelle version.

## 20. Commandes rapides – mise à jour Pour une mise à jour ultérieure déjà validée, la séquence minimale est : ``` export CODE_SERVER_VERSION="X.Y.Z" cd /tmp wget "https://github.com/coder/code-server/releases/download/v${CODE_SERVER_VERSION}/code-server_${CODE_SERVER_VERSION}_amd64.deb" sudo dpkg -i "/tmp/code-server_${CODE_SERVER_VERSION}_amd64.deb" sudo systemctl daemon-reload sudo systemctl restart code-server@nancre.service /usr/bin/code-server --version sudo systemctl status code-server@nancre.service --no-pager sudo ss -ltnp | grep ':8080' ``` ## 21. Résumé de l'architecture ``` Utilisateur : nancre │ ▼ code-server@nancre.service │ ▼ /usr/bin/code-server │ ▼ /usr/lib/code-server │ ▼ 0.0.0.0:8080 │ ▼ Reverse proxy / accès web ``` **Important :** le service à utiliser est `code-server@nancre.service`. Le service utilisateur `code-server.service` n'est pas celui qui exécute l'instance actuelle.