# Debian La distribution de la sagesse et des gens stables. # [Debian] Nala ## Introduction Nala est une surcouche au gestionnaire de paquet **apt** de Debian. Il permet d'avoir plus de couleurs et d'avoir un rendu beaucoup plus propre avec une interface ressemblant plus ou moins au gestionnaire de paquet *dnf*. Il permet aussi des vitesses de téléchargement des paquets plus rapides grâce à ses tâches lancées en parallèle. Source : [Article d'Adrien Linuxtricks](https://www.linuxtricks.fr/wiki/nala-un-frontend-a-apt-colore-et-lisible) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/scaled-1680-/r5zimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/r5zimage.png) ## Installation Tout d'abord, assurez vous d'être connecté en root puis lancez cette commande : ```bash wget -qO- https://deb.volian.org/volian/scar.key | gpg --dearmor | dd of=/usr/share/keyrings/volian-archive-scar.gpg && echo "deb [signed-by=/usr/share/keyrings/volian-archive-scar.gpg arch=amd64] https://deb.volian.org/volian/ scar main" > /etc/apt/sources.list.d/volian-archive-scar.list && apt update && apt install -y nala ``` #### Sélection des miroirs Maintenant, on peut scanner les meilleurs miroirs et sélectionner les plus rapides grâce à la commande suivante : ```bash nala fetch ``` ## Manuel Voici une liste des options proposées par nala (l'utilisation est assez intuitive) : ```markdown Commands: autopurge Autopurge packages that are no longer needed. autoremove Autoremove packages that are no longer needed. clean Clear out the local archive of downloaded package... fetch Fetch fast mirrors to speed up downloads. history Show transaction history. install Install packages. list List packages based on package names. purge Purge packages. remove Remove packages. search Search package names and descriptions. show Show package details. update Update package list. upgrade Update package list and upgrade the system. ``` # [Debian] Raid mdadm ## Introduction Le raid logiciel est disponible sur les distributions Linux grâce à l'outil **mdadm** qui supporte les plus grands types de raid (RAID0, RAID1, RAID5, RAID10 etc). Le tutoriel suivant sera réalisé sur une **Debian 12** équipée d'un disque accueillant le système de 15Go ainsi que 2 disques de 1Go utilisées d'abord pour faire du raid0 puis pour faire du raid1 dans la seconde partie du tutoriel. Sources : - [Documentation Ubuntu](https://doc.ubuntu-fr.org/raid_logiciel) - [Article Adrien Linuxtricks](https://www.linuxtricks.fr/wiki/mdadm-raid-logiciel-sous-linux) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/scaled-1680-/qyfimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/qyfimage.png) ## Installation #### Raid0 Dans l'exemple ci-dessous nous aurons 2 disques de 1Go en **raid0**. Tout d'abord, partitionnez les disques avec **fdisk** en type **fd** (Linux raid) : ```bash fdisk /dev/sda ``` Tapez l'enchaînement de touches suivant : **N / P / ENTER / ENTER / ENTER / T / FD / W** Faire la même opération avec le deuxième disque (**/dev/sdb**) Créer le **raid0** : ```bash mdadm --create /dev/md0 --level=0 --raid-devices=2 /dev/sda1 /dev/sdb1 ``` Vérifier l'état du raid : ```bash mdadm --detail /dev/md0 ``` #### Renommer le raid Pour sauvegarder le nom du raid en **md0**, lancez cette commande : ```bash mdadm --detail --scan > /etc/mdadm/mdadm.conf ``` Et pour prendre en compte les changements : ```bash update-initramfs -u && reboot ``` #### Formater le système de fichiers du Raid ```bash mkfs.ext4 /dev/md0 ``` #### Monter le raid Pour monter le raid manuellement et tester son bon fonctionnement on peut créer son point de montage et utiliser la commande **mount** : ```bash mkdir /media/myRaid && mount /dev/md0 /media/myRaid ``` Si vous souhaitez conserver ce point de montage lors du redémarrage de la machine, il faut indiquer le raid dans le **/etc/fstab** : ```bash /dev/md0 /media/myRaid ext4 defaults 0 0 ``` On peut vérifier la configuration du fstab grâce à la commande suivante qui ne doit rien renvoyer si la configuration est bonne : ```bash mount -a ``` #### Raid1 Une fois les partitions configurées, créez le **raid1** : ```bash mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sda1 /dev/sdb1 ``` #### Raid5 Dans cette configuration, nous avons un raid5 configuré avec 4 disques. Une fois les partitions configurées, créez le **raid5** : ```bash mdadm --create /dev/md0 --level=5 --raid-devices=4 /dev/sda1 /dev/sdb1 /dev/sdc1 /dev/sdd1 ``` #### Tester le raid Afin de vérifier le bon fonctionnement du raid nous allons simuler la panne d'un des deux disques physiques. Pour cela, nous allons supprimer un des deux disques dans VMware. [![Image collée 2.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/scaled-1680-/image-collee-2.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/image-collee-2.png) Une fois la machine redémarrée, le raid passe en état inactif comme on peut le voir : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/scaled-1680-/zZbimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/zZbimage.png) On peut éteindre la machine pour ajouter un disque sur la VM afin de reconstruire le raid. La première étape consiste à éteindre le raid actuel : ```bash mdadm --stop /dev/md0 ``` Une fois la machine redémarrée, nous devons créer la partition de type **Linux Raid** sur notre nouveau disque (se référer à la partie installation du raid). Ensuite, il faut recréer le raid en indiquant le nouveau disque et l'ancien sans oublier l'option **--assume-clean** : ```bash mdadm --create /dev/md0 --level=1 --assume-clean --raid-devices=2 /dev/sda1 /dev/sdb1 ```

Le raid devrait se reconstruire sans perte de données !

#### Supprimer un raid Tout d'abord, il faut penser à démonter le raid (s'il est monté) : ```bash umount /dev/md0 ``` Ensuite on peut éteindre le raid : ```bash mdadm --stop /dev/md0 ``` Et on supprime l'entrée (la ligne) du raid dans le **/etc/fstab** : ```bash nano /etc/fstab ``` # [Debian] Serveur DNS ## Introduction Un serveur DNS permet la résolution de noms de domaine en adresse IP et inversement sur un réseau. Dans ce tutoriel nous utiliserons la solution **Bind9** sur une Debian 11 ayant comme adresse IP 10.100.0.86. Le domaine configuré sera **elie.local**. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/scaled-1680-/01Eimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/01Eimage.png) ## Installation - Installez le paquet bind : ```bash apt update && apt install -y bind9 ``` - Au cas où un fichier vous souhaiteriez restaurer les fichiers de configuration par défaut, je vous recommande de faire une sauvegarde de ces différents fichiers : ```bash cp /etc/bind/named.conf /etc/bind/named.conf.bak ``` ```bash cp /etc/bind/named.conf.options /etc/bind/named.conf.options.bak ``` ```bash cp /etc/bind/named.conf.local /etc/bind/named.conf.local.bak ``` ## Configuration de forwarding - Éditez le fichier **/etc/bind/named.conf.options** de sorte à obtenir cette configuration (à adapter) : ```bash options{ directory "/var/cache/bind"; recursion yes; allow-query { 10.100.0.0/24; 127.0.0.1; }; forwarders { 1.1.1.1; 8.8.8.8; }; forward only; dnssec-validation auto; auth-nxdomain no; listen-on-v6 { any; }; }; ```

Vous pouvez choisir les DNS primaires et secondaires vers lesquels la redirection va se produire dans les **forwarders**, ici j'utilise celui de Cloudflare en primaire et celui de Google en secondaire.

#### Vérifier les configurations Vous pouvez vérifier la configuration à l'aide de la commande suivante : ```bash named-checkconf ``` #### Redémarrer le service DNS Une fois que vous avez vérifié que votre configuration DNS est bonne, vous pouvez redémarrer le service named pour prendre en compte les changements : ```bash systemctl restart named ``` ## Configuration de zone (classique) - Éditez le fichier **/etc/bind/named.conf.local** pour configurer la zone DNS et ajoutez-y ce contenu (à adapter) : ```bash // Configuration DNS zone "elie.local" IN { type master; file "db.elie.local"; allow-update { none; }; }; // Configuration Reverse DNS sur un réseau 10.100.0.X zone "0.100.10.in-addr.arpa" IN { type master; file "rev.elie.local"; allow-update { none; }; }; ``` #### Ajout des entrées DNS À chaque fois que vous voudrez ajouter une entrée DNS, il faudra écrire l'entrée le fichier de configuration DNS et dans le fichier de configuration du reverse DNS. - Pour commencer, déplacez-vous dans le répertoire **/var/cache/bind/** et créez votre fichier de configuration des enrtées DNS, ici c'est le fichier **db.elie.local** et ajoutez le contenu suivant (à adapter) : ```bash $TTL 86400 @ IN SOA debian-dns.elie.local. root.elie.local. ( 2022111401 1w 1d 4w 1w ) @ IN NS debian-dns.elie.local. debian-dns IN A 10.100.0.86 ; SET DNS RECORDS mail IN A 10.100.0.200 debian-client-1 IN A 10.100.0.201 ``` Ici, le serveur DNS ayant pour adresse IP **10.100.0.86** aura le nom **debian-dns.elie.local** qui est enregistré comme entrée de type A. On peut voir en dessous qu'un serveur de messagerie et un poste client sont aussi enregistrés dans la base sous leurs noms respectifs (à vous de mettre vos propres entrées). - Ensuite, toujours dans le répertoire **/var/cache/bind/** il faut créer le fichier de configuration du reverse DNS, ici **rev.elie.local** : ```bash $TTL 86400 @ IN SOA debian-dns.elie.local. root.elie.local. ( 2022111401 1w 1d 4w 1w ) @ IN NS debian-dns.elie.local. 86 IN PTR debian-dns.elie.local ; SET DNS RECORDS 200 IN PTR mail.elie.local 201 IN PTR debian-client-1.elie.local ``` On s'aperçoit que le contenu est similaire à la configuration du DNS avec un différence majeure au niveau des entrées DNS qui sont de type PTR et où on indique la valeur du dernier octet de l'adresse IP pointant vers le nom correspondant. Par exemple on reconnait l'entrée du serveur de messagerie "***200 IN PTR mail.elie.local***" où **200** correspond au dernier octet de son adresse c'est à dire 10.100.0.**200**. #### Modification des droits des fichiers Afin que Bind puisse exploiter vos fichiers de configuration, les bons droits doivent être mis dessus : ```bash chgrp bind /var/cache/bind/* ``` ```bash chmod 664 /var/cache/bind/* ``` #### Modification de /etc/resolv.conf Il faut indiquer au serveur que le serveur DNS correspond désormais à lui-même dans le fichier **/etc/resolv.conf** : ```bash echo "nameserver 10.100.0.86" > /etc/resolv.conf ``` #### Vérifier les configurations Voici les deux commandes "magiques" qui permettent de vérifier que les configurations sont correctes : ```bash named-checkconf ``` L'option -z permet d'être beaucoup plus verbeux quant aux erreurs que vous pouvez rencontrer : ```bash named-checkconf -z ``` #### Redémarrer le service DNS Une fois que vous avez vérifié que votre configuration DNS est bonne, vous pouvez redémarrer le service named pour prendre en compte les changements : ```bash systemctl restart named ``` ## Configuration de vues (avancé) Cette approche est particulière puisque contrairement à la configuration en mode zone, nous pourrons définir des entrées et des traitements différents selon **l'interface** par laquelle la requête DNS va entrer. Le domaine sera toujours **elie.local** . Pour cet exemple nous aurons un lab avec 2 réseaux :
**Réseaux****Adresse réseau**
LAN192.168.0.0/24
DMZ10.0.0.0/24
Ainsi que 3 machines :
**Machine****Adresse interface LAN****Adresse interface DMZ****Rôle**
vm-deb01192.168.0.25310.0.0.253Serveur DNS
vm-deb02192.168.0.1/Client LAN
vm-deb03/10.0.0.1Serveur web
- L'ensemble des configurations se fera dans le dossier **/etc/bind** cette fois : ```bash cd /etc/bind/ ``` - Voici à quoi doit ressembler le fichier **named.conf.options** : ``` acl myclients { 127.0.0.0/8; 192.168.0.0/24; 10.0.0.0/24; }; options { directory "/var/cache/bind"; forwarders { 1.1.1.1; }; dnssec-validation auto; forward only; listen-on { 127.0.0.1; 192.168.0.253; 10.0.0.253; }; allow-transfer { none; }; allow-query { myclients; }; }; ``` - Le fichier **named.conf.zones** : ``` zone "elie.local" { type master; file "/etc/bind/localzones/db.elie.local"; }; zone "elie.local" { type master; file "/etc/bind/localzones/db.elie.local.external"; }; ``` - Le fichier **common-zones.conf** : ``` zone "elie.local" { type master; file "/etc/bind/localzones/db.elie.local"; }; zone "elie.local" { type master; file "/etc/bind/localzones/db.elie.local.external"; }; ``` - Le fichier **named.conf** : ``` // This is the primary configuration file for the BIND DNS server named. // // Please read /usr/share/doc/bind9/README.Debian for information on the // structure of BIND configuration files in Debian, *BEFORE* you customize // this configuration file. // // If you are just adding zones, please do that in /etc/bind/named.conf.local include "/etc/bind/named.conf.options"; include "/etc/bind/named.conf.local"; #include "/etc/bind/named.conf.default-zones"; view "local" { match-clients { 192.168.0.0/24; }; allow-query { any; }; recursion no; zone "elie.local" { type master; file "/etc/bind/localzones/db.elie.local"; }; include "/etc/bind/named.conf.default-zones"; }; view "external" { match-clients { 10.0.0.0/24; }; allow-query { any; }; recursion no; zone "elie.local" { type master; file "/etc/bind/localzones/db.elie.local.external"; }; include "/etc/bind/named.conf.default-zones"; }; ``` - Le fichier **named.conf.internal-zones** : ``` view "internal" { # match all except targets defined on [match-clients] on internal section match-clients { 127.0.0.0/8; 192.168.0.0/24 }; # allow all queries allow-query { any; }; # not allow recursive queries recursion no; zone "elie.local" { type master; file "/etc/bind/localzones/db.elie.local"; }; include "/etc/bind/named.conf.default-zones"; }; ``` - Le fichier **named.conf.external-zones** : ``` view "external" { # match all except targets defined on [match-clients] on internal section match-clients { 10.0.0.0/24; }; # allow all queries allow-query { any; }; # not allow recursive queries recursion no; zone "elie.local" { type master; file "/etc/bind/localzones/db.elie.local.external"; }; include "/etc/bind/named.conf.default-zones"; }; ``` - Créer un dossier **localzones** et se déplacer dedans : ``` mkdir localzone && cd localzone ``` - Créer le fichier de la zone interne soit **db.elie.local** : ``` $TTL 86400 @ IN SOA vm-deb01.elie.local. root.elie.local. ( 2022111401 1w 1d 4w 1w ) @ IN NS vm-deb01.elie.local. vm-deb01 IN A 192.168.0.253 ; SET DNS RECORDS vm-deb02 IN A 192.168.0.1 ``` - Créer le fichier de la vue externe soit **db.elie.local.externa**l : ``` $TTL 86400 @ IN SOA vm-deb01.elie.local. root.elie.local. ( 2022111402 1w 1d 4w 1w ) @ IN NS vm-deb01.elie.local. vm-deb01 IN A 10.0.0.253 ; SET DNS RECORDS web-srv IN A 10.0.0.1 ``` - Créer le fichier du reverse DNS de la vue interne **rev.elie.local** : ``` $TTL 86400 @ IN SOA vm-deb01.elie.local. root.elie.local. ( 2022111401 1w 1d 4w 1w ) @ IN NS vm-deb01.elie.local. 253 IN PTR vm-deb01.elie.local ; SET DNS RECORDS 1 IN PTR vm-deb02.elie.local ``` - Créer le fichier du reverse DNS de la vue externe **rev.elie.local** : ``` $TTL 86400 @ IN SOA vm-deb01.elie.local. root.elie.local. ( 2022111401 1w 1d 4w 1w ) @ IN NS vm-deb01.elie.local. 253 IN PTR vm-deb01.elie.local ; SET DNS RECORDS 1 IN PTR web-srv.elie.local ``` # [Debian] Serveur DHCP ## Introduction Un serveur **DHCP** permet d'attribuer automatiquement des adresses IP aux hôtes se connectant sur le réseau. Dans ce guide, nous allons utiliser une Debian 12 avec l'outil **dhcpcd** qui va nous permettre de configurer le service DHCP. Source : - [Article d'Adrien Linuxtricks](https://www.linuxtricks.fr/wiki/debian-installer-un-serveur-dhcp) ## Prérequis - Définir une adresse IP statique sur votre futur serveur DHCP. ## ![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/scaled-1680-/J93image.png)Installation Tout d'abord, installez le paquet le paquet approprié : ```bash apt update && apt install -y isc-dhcp-server ``` Indiquer dans le fichier **/etc/default/isc-dhcp-server** l'interface d'écoute du serveur DHCP et décommenter cette ligne : ```bash DHCPDv4_CONF=/etc/dhcp/dhcpd.conf ``` Et en ajoutant le nom des interfaces : ``` INTERFACESv4="ens33" INTERFACESv6="ens33" ``` ## Configuration La configuration se trouve dans le fichier **/etc/dhcp/dhcpd.conf** . Voici un template de configuration : ``` default-lease-time 86400; # Bail de 24H max-lease-time 172800; # Bail maxi de 48H # Déclaration d'un réseau subnet 192.168.0.0 netmask 255.255.255.0 { range 192.168.0.100 192.168.0.199; # Plage IP option domain-name-servers 192.168.0.253; # DNS option routers 192.168.0.254; # Passerelle } ``` On peut aussi ajouter des entrées d'hôtes où l'adresse IP doit être fixe en faisant une réservation d'adresse : ``` host work-l-arch { hardware ethernet 10:bf:48:13:f6:cc; fixed-address 192.168.0.120; } ``` On peut aussi si on le souhaite, refuser le service DHCP à un hôte en spécifiant son adresse MAC de la même façon : ``` host work-l-arch { hardware ethernet 10:bf:48:13:f6:cc; deny booting; } ``` ## Démarrage et activation du service ```bash systemctl enable --now isc-dhcp-server ``` # [Debian] Serveur Samba ## Introduction Le service **samba** est disponible sur les différentes distributions Linux et permet de partager des fichiers comme le ferait un serveur FTP par exemple mais permet la compatibilité native avec Windows ce qui est intéressant. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/scaled-1680-/6UBimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/6UBimage.png) ## Source - [Tutoriel IT-Connect](https://www.it-connect.fr/serveur-de-fichiers-debian-installer-et-configurer-samba-4/) ## Installation Commencez par installer le paquet **samba** : ```bash sudo apt install -y samba ``` Puis configurez un partage : ```bash nano /etc/samba/smb.conf ``` ``` [] comment = Partage de données path = valid users = admin @LECTEURS guest ok = no read only = no browseable = yes create mask = 0664 directory mask = 0775 force group = LECTEURS ```

Cette configuration autorise un utilisateur **admin** (qui a les droits d'écriture) ainsi que les utilisateurs du groupe **LECTEURS** qui ont seulement les droits de lecture sur le partage). Vous pouvez bien sûr modifier cette configuration à souhait.

D'ailleurs, pensez à vérifier que l'utilisateur est bien propriétaire du dossier du partage. Définissez un mot de passe samba à votre utilisateur : ```bash smbpasswd -a ``` Vous pouvez tester votre fichier de configuration grâce à la commande **testparm** : ```bash testparm ``` Enfin, activez et démarrez le service samba : ```bash systemctl enable --now smbd ``` ## Monter un partage Ensuite ce qui est intéressant c'est de monter le partage que l'on vient de créer sur le client qui va l'utiliser. Tout d'abord, installez le paquet **cifs-utils** : ``` sudo apt update && sudo apt install -y cifs-utils ``` Créez le fichier contenant les identifiants du partage et enlevez lui les droits de lecture : ```bash sudo nano /root/.creds ``` ``` username=myUser password=myPass domain=WORKGROUP ``` ```bash sudo chmod 600 /root/.creds ``` Créez le dossier qui va accueillir le point de montage : ```bash sudo mkdir /media/share ``` Testez le montage de votre partage : ```bash sudo mount -t cifs -o credentials=/root/.creds /// /media/share ``` Afin de rendre persistent votre point de montage, éditez le fichier **/etc/fstab** : ```bash sudo nano /etc/fstab ``` Et ajoutez une entrée de la sorte : ```bash /// cifs uid=0,credentials=/root/.creds-nas,iocharset=utf8,vers=3.0 0 0 ``` # [Debian] Cockpit ## Introduction Un peu de la même manière que Webmin, **Cockpit** est une solution de gestion de votre serveur directement par l'interface web. Cette solution a été développée par RedHat mais est disponible sur la plupart des distributions Linux dont Debian. Il fonctionne par défaut sur le port **9090**. ## Source - [Article d'Adrien Linuxtricks](https://www.linuxtricks.fr/wiki/administrer-son-serveur-en-web-avec-cockpit-debian) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/scaled-1680-/391image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/391image.png) ## Installation ```bash sudo apt update && sudo apt install -y cockpit && sudo systemctl enable --now cockpit.socket ``` ## Activer le compte root Par défaut, le compte root est désactivé et nécessite de commenter son entrée dans le fichier **/etc/cockpit/disallowed-users** : ``` # List of users which are not allowed to login to Cockpit #root ``` # [Debian] Serveur NFS ## Introduction Le service **NFS** pour *Network File System* est généralement le protocole de partage de fichier à privilégier sur **Linux** pour sa performance. Contrairement à la plupart des autres protocoles, il n'est pas basé sur un système d'authentification mais autorise un hôte ou un sous-réseau à se connecter au partage. ## Source - [Article d'Adrien Linuxtricks](https://www.linuxtricks.fr/wiki/debian-installer-un-serveur-nfs) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/9qqimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/9qqimage.png) ## Installation du serveur Tout d'abord, installez le paquet **nfs-kernel-server** : ```bash sudo apt install nfs-kernel-server ``` Dans le cas où votre partage sera utilisé via votre nom de domaine, modifiez le fichier idmapd.conf : ``` Domain = ``` Démarrez et activez le service NFS : ```bash sudo systemctl enable --now nfs-server.service ``` Configurez vos partages NFS dans le fichier **/etc/exports** en respectant ce format : ``` / /(rw,sync,no_root_squash) ``` Pour prendre en compte les modifications : ```bash sudo exportfs -a ```
## Montage sur le client Maintenant que votre partage NFS est configuré côté serveur, il faut monter le partage côté client. Pour cela, commencez par installer le paquet **nfs-common** : ```bash sudo apt install nfs-common ``` Créez le dossier qui va contenir le point de montage pour le partage NFS : ``` mkdir -p ``` Puis montez le partage : ``` mount -t nfs : ``` Vous pouvez afficher les partages actifs montés sur le client : ```bash showmount -e ``` On peut ajouter le partage dans le **/etc/fstab** pour qu'il soit persistent après le démarrage : ``` : nfs auto,_netdev,nofail 0 0 ```
# [Debian] Installation avec RAID ## Introduction Ce TP est réalisé dans le cadre d'un cours à l'ESGI, et a pour but de mettre en place un serveur Debian fonctionnel avec **2 disques de 20Go** où on retrouve la configuration suivante : - Pas de raid pour la partition de démarrage. - Raid0 pour le swap de 1G sur chaque disque. - Raid1 en ext4 pour la partition racine. L'installation sera réalisée dans mon cas sur une machine virtuelle sous **Proxmox** mais peut très bien fonctionner dans d'autres configurations. ## Installation Je ne détaillerai pas la création de la VM ni le début de l'installation de Debian car elle est tout à fait traditionnelle. Arrêtons-nous sur le partitionnement des disques et sélectionnons le disque **sda** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/sMTimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/sMTimage.png) Il nous est demandé si on souhaite créer une nouvelle table des partitions, faites **Oui** : ![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/fWkimage.png) On réitère pour le disque **sdb** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/Wf8image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/Wf8image.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/A9bimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/A9bimage.png) Il faut ensuite créer la partition de démarrage ainsi que les partitions pour accueillir les raids. On commence par créer une partition **primaire** de **512MB** sur le disque **sda** qui sera formatée en **FAT32,** qui aura comme point de montage **/boot/efi** et qui accueillera l'indicateur d'amorçage : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/GUrimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/GUrimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/ztHimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/ztHimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/Njiimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/Njiimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/AVFimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/AVFimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/SNAimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/SNAimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/wekimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/wekimage.png) On peut maintenant créer les partitions qui seront utilisés comme **volume physique pour RAID** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/RIsimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/RIsimage.png) Je rappelle qu'on vient créer une partition de 1GB pour le SWAP et une partition de 20GB pour le système s**ur chaque disque**. On obtient donc la configuration suivante : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/xBBimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/xBBimage.png)

On notera qu'il reste un peu d'espace sur le deuxième disque qui représente l'espace qui a été utilisé sur le premier disque par la partition de démarrage.

On peut maintenant **Configurer le RAID avec gestion logicielle** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/rmsimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/rmsimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/R2dimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/R2dimage.png) On commence par le **RAID0** de la SWAP : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/7r1image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/7r1image.png) On sélectionnes les deux partitions de 1Go : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/BDmimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/BDmimage.png) On réitère l'opération pour le RAID du système: [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/PGUimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/PGUimage.png) Cette fois on configure un **RAID1** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/Iioimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/Iioimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/mHlimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/mHlimage.png) Dans notre configuration, nous n'aurons pas de disque de réserve (spare), laissez 0 : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/7Pfimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/7Pfimage.png) On sélectionnes les deux partitions de 20Go : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/8xIimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/8xIimage.png) Et on peut **Terminer** la configuration des périphériques RAID : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/ir5image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/ir5image.png) Désormais, on sélectionne le **Périphérique RAID0** pour configurer la SWAP : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/uRnimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/uRnimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/fHaimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/fHaimage.png) Puis on sélectionne le **périphérique RAID1** pour configurer la racine du système : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/RU2image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/RU2image.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/6ubimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/6ubimage.png) On peut enfin **Terminer le partitionnement et appliquer les changements** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/7TFimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/7TFimage.png) [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/YYsimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/YYsimage.png) Vous pouvez poursuivre l'installation du système de manière standard sauf pour l'installation de GRUB où vous allez devoir sélectionner le disque **/dev/sda** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/90iimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/90iimage.png) ## Vérification de la configuration Une fois le système redémarré, on peut s'assurer de la configuration des partitions grâce à la commande **lsblk** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/0C1image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/0C1image.png) Puis on peut vérifier l'état du RAID0 grâce à la commande **mdadm --detail /dev/md0** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/4Rzimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/4Rzimage.png) Et enfin, l'état du RAID1 grâce à la commande **mdadm --detail /dev/md1** : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/fcZimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/fcZimage.png) # [Debian] Serveur NTP ## Introduction Il peut être utile d'installer un serveur de temps sur un réseau lorsque vous faites des opérations qui nécessitent que les horloges de vos différents systèmes soient synchronisées. ## Installation serveur Commencez par installer le paquet **ntp** sur le serveur : ```bash apt update && apt install -y ntp ``` Puis passez à la configuration de votre serveur en éditant le fichier **/etc/ntpsec/ntp.conf**. Commencez par commenter (avec le #) les pools de Debian définis par défaut : ``` #pool 0.debian.pool.ntp.org iburst #pool 1.debian.pool.ntp.org iburst #pool 2.debian.pool.ntp.org iburst #pool 3.debian.pool.ntp.org iburst ``` Vous pouvez configurer un serveur de temps de strate supérieur (qui servira de référence) en ajoutant cette ligne : ``` server ``` Dans notre cas, nous utiliserons un serveur de temps public qui est **0.fr.pool.ntp.org** : ``` server 0.fr.pool.ntp.org ``` On peut ensuite configurer les restrictions qui permettent de définir qui aura le droit d'utiliser notre serveur de temps. Dans notre cas, ce sera l'ensemble du réseau local **192.168.5.0/24** : ``` restrict 0.fr.pool.ntp.org restrict 192.168.5.0 netmask 255.255.255.0 restrict default none ```

Pensez à supprimer les restrictions par défaut.

Puis il faut en dernier lieu utiliser **fudge** afin de rafraîchir automatiquement l'horloge et définir le niveau de strate : ``` fudge 127.127.0.1 9 ``` On peut ensuite redémarrer et activer le serveur de temps pour prendre en compte notre configuration : ```bash systemctl enable --now ntp ``` ## Configuration client #### Debian Installez les paquets **ntp** et **ntpdate** : ```bash apt update && apt install -y ntp ntpdate ``` Puis configurez le serveur à utiliser en éditant le fichier **/etc/ntpsec/ntp.conf** : ``` server ``` On peut ensuite définir la fréquence de rafraîchissement de la récupération du temps sur le serveur : ``` minpoll maxpoll ```

La valeur doit être égale à la racine carré du nombre de seconde que vous souhaitez (ex: pour un rafraîchissement toutes les 16 secondes la valeur sera égale à 4 car 2^**4** = 16).

On peut ensuite redémarrer le service ntp et interroger le serveur avec ntpdate : ```bash systemctl restart ntp ``` ```bash ntpdate ``` #### Windows Rendez vous dans le **Panneau de configuration** puis dans **Horloge et région** : [![Image collée.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/image-collee.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/image-collee.png) Cliquez sur **Ajouter des horloges pour des fuseaux horaires variés** : [![Image collée 1.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/image-collee-1.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/image-collee-1.png) Accédez à l'onglet **Temps Internet** et cliquez sur **Modifier les paramètres** : [![Image collée 2.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/image-collee-2.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/image-collee-2.png) Et enfin vous pouvez saisir l'adresse **IP** ou le **FQDN** de votre serveur de temps et cliquer sur **Mettre à jour** puis **OK** : [![Image collée 3.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/scaled-1680-/image-collee-3.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-11/image-collee-3.png) # [Debian] Serveur Apache ## Introduction Le serveur Apache permet d'héberger des sites web sur votre machine Linux de manière très simple en effectuant un minimum de commandes. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/scaled-1680-/yE4image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/yE4image.png) ## Installation #### Apache2 Tout d'abord, installez le paquet **apache2** : ```bash sudo apt update && sudo apt install -y apache2 ``` Ensuite, vérifiez que le serveur web est fonctionnel en vous saisissant l'**adresse IP** de la machine Debian dans l'URL de votre navigateur en utilisant le protocole **http** :
http://<IP>
[![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/scaled-1680-/s6Limage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/s6Limage.png) #### PHP Tout d'abord, installez les paquets nécessaires au fonctionnement de PHP : ```bash sudo apt install -y php libapache2-mod-php ``` Puis redémarrez le service apache : ```bash sudo systemctl restart apache2 ``` #### MariaDB Commencez par installer le paquet **mariadb-server** : ```bash sudo apt install -y mariadb-server ``` Vous pouvez ensuite lancer la configuration de votre SGBD avec la commande suivante : ```bash sudo mysql_secure_installation ``` Puis vous pouvez vous connecter à MariaDB grâce à cette commande : ```bash sudo mysql -u root -p ``` # [Debian] Serveur Nginx ## Introduction Les serveurs **Nginx** permettent d'héberger des serveurs web tout comme Apache mais tolèrent davantage de configuration et apporte de meilleures performances. Nginx est considéré plus professionnel. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/scaled-1680-/QMkimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/QMkimage.png) ## Installation #### Nginx Tout d'abord, installez le paquet **nginx** : ```bash sudo apt install -y nginx ```

Les fichiers html et css de votre site web sont stockées dans **/var/www/html** .

Vous pouvez accéder à votre site web en saisissant l'adresse IP de votre machine Debian dans l'URL de votre navigateur en utilisant le protocole http : ``` http:// ``` [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/scaled-1680-/iAbimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/iAbimage.png) #### PHP Tout d'abord installez le paquet php-fpm : ```bash sudo apt install -y php-fpm ``` Ensuite éditez le fichier de configuration **/etc/nginx/sites-enabled/default** pour décommenter la section qui ressemble à ceci : ``` location ~ \.php$ { include snippets/fastcgi-php.conf; fastcgi_pass unix:/run/php/php8.2-fpm.sock; # Le chemin peut varier selon votre version PHP } ```

Pensez à vérifier la version de php en utilisant la commande **"ls /run/php"**.

Enfin, n'oubliez pas de redémarrer les services pour appliquer les changements : ```bash sudo systemctl restart php8.2-fpm nginx ``` # [Debian] ELK ## Introduction La suite **ELK** pour **Elastic Logstash et Kibana** est un ensemble d'outil de sécurité qui permettent de collecter, indexer, parser et afficher les logs. Ces outils sont complémentaires et primordiaux pour la **blue team**. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/scaled-1680-/lwcimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/lwcimage.png) ## Sources - [Documentation officielle - Installation Elasticsearch](https://www.elastic.co/guide/en/elasticsearch/reference/current/deb.html) - [Documentation officielle - Installation Logstash](https://www.elastic.co/guide/en/logstash/current/installing-logstash.html) - [Documentation officielle - Installation Kibana](https://www.elastic.co/guide/en/kibana/current/deb.html) ## Installation #### Prérequis Tout d'abord, il faut importer la **clé GPG** pour être en mesure d'installer les outils de la suite ELK : ```bash wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg && apt-get install apt-transport-https && echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main" | tee /etc/apt/sources.list.d/elastic-7.x.list && apt-get update ``` #### Elasticsearch Voici la commande pour installer **Elasticsearch** : ```bash apt install -y elasticsearch ``` Démarrez et activez le service elasticsearch : ```bash systemctl enable --now elasticsearch ```

La configuration globale d'elasticsearch se trouve dans le fichier **/etc/elasticsearch/elasticsearch.yml** .

Ensuite, configurez le mot de passe de l'utilisateur **elastic** grâce à cette commande : ```bash /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic -i ```

Le service est désormais disponible depuis le navigateur en vous rendant sur **https://<IP>:9200** .

#### Logstash Voici la commande pour installer **Logstash** : ```bash apt install -y logstash ```

Logstash peut être configuré à travers le fichier **/etc/logstash/conf.d/beats.conf** .

Démarrez et activez le service logstash : ```bash systemctl enable --now logstash ```

Le service est désormais disponible sur le port **5044** .

#### Filebeat Voici la commande pour installer **Filebeat** : ```bash apt install -y filebeat ```

Logstash peut être configuré à travers le fichier **/etc/filebeat/filebeat.yml** .

Démarrez et activez le service filebeat : ```bash systemctl enable --now filebeat ``` #### Kibana Voici la commande pour installer **Kibana** : ```bash apt install -y kibana ```

Kibana peut être configuré à travers le fichier **/etc/kibana/kibana.yml** .

Démarrez et activez le service kibana : ```bash systemctl enable --now kibana ```

Le service est désormais disponible sur l'url **http://<IP>:5601** .

Pour activer Kibana, il vous sera demandé un token d'enrollement qui peut être généré grâce à la commande suivante : ```bash /usr/share/kibana/bin/kibana-verification-code ``` Ensuite, un code de vérification vous sera demandé, tapez cette commande pour l'obtenir : ```bash /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana ``` # [Debian] Mauvais écran connexion ## Introduction Il se peut qu'après une nouvelle installation vous ayez le mauvais écran pour l'écran de verrouillage. Dans ce cas vous pouvez essayer la technique ci-dessous. ## Résolution Copier la configuration locale dans le dossier de configuration de GDM : ``` sudo cp .config/monitors.xml /var/lib/gdm3/.config/ ```

Si **/var/lib/gdm3** n'existe pas, essayez avec **/var/lib/gdm** !

Puis redémarrez GDM pour vérifier que la manipulation a fonctionnée : ``` sudo systemctl restart gdm ``` # [Debian] Flatpak ## Introduction Les dépôts **Flatpak** permettent d'étendre votre logithèque et d'installer des logiciels non disponibles normalement. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-01/scaled-1680-/sRKimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2024-01/sRKimage.png) ## Installation Tout d'abord, installez le paquet **flatpak** : ``` apt install -y flatpak ``` Puis ajoutez le dépôts **flathub** : ``` flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo ``` ## Manuel Pour installer un paquet flatpak : ``` flatpak install ``` # [Debian] Serveur OpenVPN ## Introduction Ce tutoriel décrit la procédure d'installation d'un serveur **OpenVPN** sous Debian. OpenVPN est une bonne solution lorsque vous travaillez avec du matériel assez ancien, sinon je recommande d'utiliser **Wireguard** qui est plus performant et qui réduira grandement le ping. Pour l'installation, un script sera utilisé pour gagner du temps et générer automatiquement les certificats. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/scaled-1680-/NBbimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/NBbimage.png) ## Installation du serveur - **Téléchargez** et **lancez** le script d'installation rapide : ``` wget https://git.io/vpn -O openvpn-install.sh && bash openvpn-install.sh ``` L'adresse **IP du serveur publique** (adresse utilisée par les clients pour se connecter) vous est demandé : ![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/scaled-1680-/Cwuimage.png)Ensuite, vous devez choisir le **protocole** qu'OpenVPN utilisera : ![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/scaled-1680-/l2mimage.png)Puis saisissez le numéro de **port** que le service OpenVPN devra utiliser : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/scaled-1680-/mdtimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/mdtimage.png) Vient après la configuration du **serveur DNS** : ![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/scaled-1680-/2hlimage.png)Saisissez le nom d'un **premier client** : ![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/scaled-1680-/6iHimage.png)

Le serveur VPN est prêt à être utilisé !

Vous pouvez créer de nouveaux clients en exécutant de nouveau le script.

## Installation des clients #### Windows - [OpenVPN - Windows download](https://openvpn.net/client/client-connect-vpn-for-windows/) ##### Debian ```bash apt install -y openvpn ``` ```bash openvpn .ovpn ``` # [Debian] Serveur Wireguard ## Introduction **Wireguard** est un service VPN récent, sécurisé et performant. Il peut fonctionner dans plusieurs configurations différentes mais utilise exclusivement le protocole **UDP**. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/scaled-1680-/5FVimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2024-02/5FVimage.png) ## Source - [Tutoriel IT-Connect - Wireguard](https://www.it-connect.fr/mise-en-place-de-wireguard-vpn-sur-debian-11/) ## Installation du serveur #### Réseau privé Wireguard peut fonctionner en mode réseau simple, c'est à dire qu'il va vous permettre d'établir un réseau avec les hôtes que vous connecterez en mode **P2P**. Il n'y aura pas de serveur VPN à proprement parler ni une nouvelle passerelle par défaut pour les hôtes. - Tout d'abord, installez le paquet **wireguard** : ```bash apt install -y wireguard ``` Ensuite, éditez la configuration de votre premier noeud à travers le fichier **/etc/wireguard/wg0.conf** : ``` [Interface] PrivateKey = Address = / ListenPort = 51820 ``` - Dans un deuxième terminal, lancez la génération de : 1. La clé **privée** du serveur : ``` wg genkey | sudo tee /etc/wireguard/wg-private.key ``` 2. La clé **publique** du serveur : ``` cat /etc/wireguard/wg-private.key | wg pubkey | sudo tee /etc/wireguard/wg-public.key ```

Vous pouvez réitérer les deux commandes ci-dessus pour générer une paire clé privée/publique pour chaque hôte du réseau VPN.

Ensuite, pour chaque hôte, ajoutez cela dans la configuration du serveur : ``` [Peer] PublicKey = AllowedIPs = / Endpoint = :51820 ``` Une fois que vous avez configurer le serveur et les hôtes, vous pouvez démarrer le serveur wireguard : ```bash wg-quick up wg0 ``` Vous devinerez que pour l'éteindre il s'agit de cette commande : ```bash wg-quick down wg0 ``` Pour activer le service à chaque démarrage, exécutez la commande suivante : ``` systemctl enable wg-quick@wg0.service ``` ## Installation des hôtes Tout d'abord, installez le paquet **wireguard** : ```bash apt install -y wireguard ``` Ensuite, créez le fichier de configuration du client **/etc/wireguard/wg0.conf** : ``` [Interface] PrivateKey = Address = / [Peer] PublicKey = AllowedIPs = / Endpoint = :51820 ``` Et démarrez wireguard : ```bash wg-quick up wg0 ``` ## Générateur de configuration Si vous êtes habituez à la configuration de Wireguard, vous verrez que vous pouvez gagner du temps grâce à ce générateur de fichier de config : - [https://www.wireguardconfig.com/](https://www.wireguardconfig.com/) ## Script d'installation automatique - [https://github.com/angristan/wireguard-install](https://github.com/angristan/wireguard-install) Pour lancer le script : ```bash curl -O https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh && chmod +x wireguard-install.sh && ./wireguard-install.sh ``` # [Debian] SSHS ## Introduction Ce gestionnaire de connexions SSH permet d'avoir une interface graphique pour ne plus avoir à retenir vos identifiants et les IP des connexions. Cet outil fonctionne en ligne de commande pour le bonheur de tous. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-04/scaled-1680-/image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2024-04/image.png) ## Installation Vous devez récupérer le binaire depuis le [Github](https://github.com/quantumsheep/sshs) du projet et le rendre exécutable : ```bash wget -O /usr/local/bin/sshs https://github.com/quantumsheep/sshs/releases/download/4.3.0/sshs-linux-amd64 && chmod +x /usr/local/bin/sshs ``` ## Configuration Le fichier de configuration se trouve dans ~/.ssh/config et prend ce format : ``` Host "" Hostname User root Port 2222 IdentityFile "~/.ssh/id_rsa" ```

Remplacez les champs appropriés par vos valeurs.

## Utilisation ```bash sshs ``` # [Debian] GlusterFS ## Introduction **GlusterFS** permet de créer des espaces de données partagées ce qui peut servir pour faire répliquer deux partitions identiques entre deux serveurs distants. ## Source - [Tutoriel - Installer GlusterFS sur Debian 11](https://shape.host/resources/optimize-filesystem-scalability-install-glusterfs-debian-11) ## Installation du cluster Pour la haute disponibilité il est recommandé d'utiliser au moins trois instances sur lesquels nous aurons notre partitions partagée. Pour le tutoriel nous utiliserons trois machines sur **Debian 11**. - Tout d'abord, toutes les machines du cluster doivent posséder un hostname, pour cela on définit le hostname avec la commande suivante : ```bash hostnamectl set-hostname ``` Puis ajoutez les entrées dans le fichier **/etc/hosts** dans le format suivant : ``` ```

Vérifiez que le ping fonctionne en utilisant les noms d'hôtes.

Ensuite, nous devons préparer la partition qui va accueillir les données sur les trois machines (notre disque sera **/dev/sdb**) : ```bash apt install -y parted ``` ```bash parted /dev/sdb mklabel gpt mkpart SHARE ext4 1MiB 100% ``` Maintenant, nous devons préparer le dossier qui va accueillir le point de montage (ici **/share**) : ```bash mkdir /share ``` Puis ajoutez cela dans le **/etc/fstab** pour être persistant après redémarrage : ``` /dev/sdb1 /share ext4 defaults 0 1 ``` Pour appliquer les changements et détecter les erreurs : ```bash mount -a ```

Ne laissez pas d'erreur, sinon vous risquez de ne pas pouvoir démarrer au prochain redémarrage du système !

Créer le dossier **/share/brick0** qui va accueillir les fichiers partagés : ```bash mkdir -p /share/brick0 ``` Désormais, nous pouvons installer le **serveur GlusterFS** sur nos trois machines : ```bash apt install -y gnupg2 apt-transport-https software-properties-common curl && curl https://download.gluster.org/pub/gluster/glusterfs/10/rsa.pub | gpg --dearmor > /usr/share/keyrings/glusterfs-archive-keyring.gpg && DEBID=$(grep 'VERSION_ID=' /etc/os-release | cut -d '=' -f 2 | tr -d '"') && DEBVER=$(grep 'VERSION=' /etc/os-release | grep -Eo '[a-z]+') && DEBARCH=$(dpkg --print-architecture) && echo "deb [signed-by=/usr/share/keyrings/glusterfs-archive-keyring.gpg] https://download.gluster.org/pub/gluster/glusterfs/LATEST/Debian/${DEBID}/${DEBARCH}/apt ${DEBVER} main" | sudo tee /etc/apt/sources.list.d/gluster.list && apt update && apt install -y glusterfs-server ``` Activer le service et démarrez le : ```bash systemctl enable --now glusterd ``` ``` systemctl enable glusterd ``` On peut initialiser le cluster depuis le premier noeud (Node 1) du cluster avec la commande suivante : ```bash gluster peer probe && gluster peer probe ```

On peut vérifier que les noeuds ont bien rejoins le cluster avec la commande **gluster pool list** .

On peut vérifier l'état du cluster avec la commande **gluster peer status** .

On peut maintenant créer un premier volume partagé ```bash gluster volume create replica 3 :/share/brick0 :/share/brick0 :/share/brick0 ``` On démarrer le volume : ```bash gluster volume start ```

On peut afficher les informations du volume avec la commande **gluster volume info** .

## Montage côté client Comme on le ferait avec un partage réseau type NFS ou Samba par exemple, nous allons monter notre volume glusterfs sur notre ou nos clients. Pour cela, on installe d'abord le paquet **glusterfs-client** : ```bash apt install -y glusterfs-client ``` On peut créer le point de montage : ```bash mkdir -p /mnt/share ``` Et on monte le volume : ```bash mount.glusterfs :/ /mnt/share ``` Pour un partage persistant, on ajoute une entrée dans le **/etc/fstab** : ```bash : /mnt/share glusterfs defaults,_netdev 0 0 ``` Puis : ```bash mount -a ```

Le volume distribué est prêt et tolère la panne pour supporter la **HA** !

# [Debian] Corosync ## Introduction **Corosync** permet de faire de la haute disponiblité sur vos services systemd ce qui peut être utile pour un serveur web ou une base de données par exemple. À noter que corosync est utilisé par Proxmox pour sa HA. ## Installation # [Debian] OpenSSL ## Introduction Openssl est une bibliothèque standard de chiffrement disponible sur les systèmes Unix. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-10/scaled-1680-/image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2024-10/image.png) ## Chiffrement de fichier Vous pouvez chiffrer un fichier en AES-256-CBC avec un mot de passe grâce à la commande suivante : ```bash openssl enc -aes-256-cbc -salt -pbkdf2 -in -out -base64 -k ``` Et pour déchiffrer : ```bash openssl enc -d -aes-256-cbc -pbkdf2 -in -out -base64 -k ``` Pour créer une paire de clés publique/privée RSA puis chiffrer un fichier avec, on peut utiliser openssl. Tout d'abord, générez la paire de clés : - Clé privée : ```bash openssl genpkey -algorithm RSA -out priv.pem -aes-256-cbc -pass pass:mypass ``` - Clé publique : ```bash openssl rsa -pubout -in key.pem -out pub.pem -passin pass:mypass ``` Puis chiffrez un fichier avec la clé publique : ```bash openssl pkeyutl -encrypt -inkey pub.pem -pubin -in plain.txt -out cypher.enc && openssl base64 -in cypher.enc -out cypher.enc.base64 ``` Puis pour déchiffrer avec la clé privée : ```bash openssl base64 -d -in cypher.enc.base64 -out cypher.enc && openssl pkeyutl -decrypt -inkey priv.pem -in cypher.enc -out plain_decrypted.txt ``` ## Échange de clé On peut utiliser **Diffie Hellman** pour échanger des clés. Pour cela, commencez par créer un paramètre DH : ```bash openssl genpkey -genparam -algorithm DH -out dhp.prem ``` Puis on peut générer une première clé : ```bash openssl genpkey -paramfile dhp.pem -out dhkey1.pem ``` On peut afficher les informations de cette clé : ```bash openssl pkey -in dhkey1.pem -text -noout ``` Et on peut créer une deuxième clé : ```bash openssl pkey -in dhkey1.pem -pubout -out dhpub1.pem ``` On peut afficher les informations de cette clé : ```bash openssl pkey -pubin -in dhpub1.pem -text ``` On peut ensuite créer une dérivation de ces clés : ```bash openssl pkeyutil -derive -inkey dhkey1.pem -peerkey dhpub1.pem -out secret1.bin ``` ```bash openssl pkeyutil -derive -inkey dhkey2.pem -peerkey dhpub2.pem -out secret2.bin ``` On peut ensuite comparer les deux secrets et s'apercevoir qu'ils sont identiques : ```bash cmp secret1.bin secret2.bin ``` ## Génération de clés ECC Les clés ECC suivent les courbes elliptiques ce qui permet une taille de clé réduite en conservant un bon niveau de sécurité. #### Création d'une clé ECC ```bash openssl ecparam -genkey -name prime256v1 -out ecc.key ``` #### Demande de certificat ```bash openssl req -new -sha256 -key ecc.key -nodes -out ecc.csr ``` #### Signer le certificat Ici nous allons auto-signer le certificat, si vous utilisez une autorité de certification (CA), utilisez la clé privée du CA : ```bash openssl req -x509 -sha256 -days 365 -key ecc.key -in ecc.csr -out ecc.crt ``` #### Extraire la clé publique ```bash openssl ec -in net-sec.key -pubout ``` # [Debian] LVM ## Introduction LVM (Logical Volume Manager) permet de créer des volumes logiques, ce qui permet une grande flexibilité. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2025-01/scaled-1680-/Xmwimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2025-01/Xmwimage.png) ## Manuel #### Installation Installez le paquet **lvm2** : ```bash apt install -y lvm2 ``` Admettons que nous voulons créer un volume logique pour accueillir nos musiques et des films (des médias). Pour cela nous allons utiliser deux disques (volumes) physiques de 50Go chacun. Tout d'abord, initialisez les volumes physiques (**PV**) : ```bash wipefs -a /dev/sdX && wipefs -a /dev/sdY && pvcreate /dev/sdX /dev/sdY ``` Créez votre groupe de volume (**VG**) : ```bash vgcreate vg_medias /dev/sdX /dev/sdY ``` Vous pouvez maintenant créer deux volumes logiques, **LV**, (un pour les musiques et un pour les films) : ```bash lvcreate -L 10G -n lv_musics vg_medias ``` ```bash lvcreate -L 90G -n lv_movies vg_medias ``` Désormais, il ne vous reste plus qu'à formater les volumes logiques : - lv\_musics en ext4 : ```bash mkfs.ext4 /dev/vg_medias/lv_musics ``` - lv\_movies en xfs : ```bash mkfs.xfs /dev/vg_medias/lv_movies ``` Et enfin, montez vos volumes logiques : ```bash mount /dev/vg_medias/lv_musics /mnt/musics && mount /dev/vg_medias/lv_movies /mnt/movies ```

Vous pouvez créer les entrées correspondantes dans le **/etc/fstab** .

#### Ajout d'un disque Admettons que je manque d'espace sur mon volume logiques correspondant à mes musiques (lv\_musics), je vais ajouter un disque dans mon serveur, puis je vais l'initialiser : ```bash wipefs -a /dev/sdZ && pvcreate /dev/sdZ ``` Ajoutez le volume physique à votre groupe de volumes : ```bash vgextend vg_medias /dev/sdZ ``` Puis agrandissez votre volume logique : ```bash lvextend -L +500G /dev/vg_medias/lv_musics && resize2fs /dev/vg_medias/lv_musics ```

Si vous souhaitez redimensionner un volume logique formaté en XFS, utilisez **xfs\_growfs** <MOUNT\_POINT>. Cela paraît contre intuitif mais le volume doit être monté pour être redimensionné. Mettez bien le point de montage et pas l'identifiant du disque !

#### Supprimer un volume logique ```bash umount /mnt/musics && lvremove /dev/vg_medias/lv_musics ``` #### Debug Affichez les volumes physiques : ```bash pvs ``` Affichez les groupes de volumes : ```bash vgs ``` Ou : ```bash vgdisplay ``` Affichez les volumes logiques : ```bash lvs ``` # [Debian] LUKS ## Introduction LUKS permet le chiffrement de partition sur les systèmes Linux. ## ![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2025-01/scaled-1680-/BCHimage.png)Installation #### Debian ```bash apt install -y cryptsetup ``` ## Manuel #### Création partition ```bash fdisk /dev/sdX ``` Puis N > P > ENTER > ENTER > ENTER. #### Chiffrement partition ```bash cryptsetup luksFormat --cipher aes-xts-plain64 --key-size 256 --hash sha256 --verify-passphrase /dev/sdhX1 ``` #### Déchiffrement partition ```bash cryptsetup luksOpen /dev/sdX1 sdX1_crypt ```

Par défaut, le nom du volume chiffré s'appelle **sdX\_crypt**.

#### Formatage partition ```bash mkfs.ext4 /dev/mapper/sdX_crypt ``` #### Montage partition mount /dev/mapper/sdX\_crypt ```bash mount /dev/mapper/sdX_crypt /mnt/crypt_part ``` # [Debian] Raid ZFS ## Introduction Le raid avec ZFS est considéré comme plus performant et plus moderne donc recommandable. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2026-02/scaled-1680-/image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2026-02/image.png) ## Raid1 #### Identification des disques ```bash lsblk -o NAME,SIZE,MODEL,SERIAL ``` ```bash ls -l /dev/disk/by-id/ | grep -E 'sda|sdb' ```

Notez les identifiants (ata-XXXXX).

#### Construction du raid Ici le pool s'appellera **data** : ```bash zpool create -f -o ashift=12 data mirror /dev/disk/by-id/ /dev/disk/by-id/ ``` On active quelques options cool : ```bash zfs set compression=lz4 data ``` ```bash zfs set atime=off data ``` ```bash zfs set checksum=on data ``` ```bash zfs set xattr=sa data ``` ```bash zfs set acltype=posixacl data ``` #### Afficher le status du pool ```bash zpool status data ``` #### Création d'un dataset Ici le dataset sera dédié à stocker des séries : ```bash zfs create data/series ```

Les datasets sont un peu comme les sous-volumes BTRFS, on peut y appliquer des *quotas* etc.

#### Suppression d'un dataset ```bash zfs destroy data/series ```