Typo

README.md

@@ -1,42 +1,42 @@
 <p align="center">
 <img src="https://git.djeex.fr/Djeex/DjeexLab/raw/branch/main/docs/files/img/global/lab.svg" align="center" width="700">
 
-
-[![docu.djeex.fr](https://img.shields.io/badge/Docu·djeex-00b0f0?style=for-the-badge&logoColor=white&logo=materialformkdocs)](https://docu.djeex.fr/) [![Uptime-Kuma](https://stats.djeex.fr/api/badge/23/status?style=for-the-badge)](https://docu.djeex.fr/) 
-
+[![docu.djeex.fr](https://img.shields.io/badge/Docu·djeex-00b0f0?style=for-the-badge&logoColor=white&logo=materialformkdocs)](https://docu.djeex.fr/) 
+[![Uptime-Kuma](https://stats.djeex.fr/api/badge/23/status?style=for-the-badge)](https://docu.djeex.fr/) 
 </p>
 
-# 🔧 De la doc, encore de la doc
+# 🔧 Docs, More Docs
 
-**Docu·djeex** c'est avant tout un projet personnel visant à héberger chez soi le plus de services possibles du quotidien sans passer par des plateformes propriétaires (Google, Apple, Netflix...). Cette doc utilise [Nuxt.js](https://nuxt.com/)
+**Docu·djeex** is first and foremost a personal project aimed at self-hosting as many everyday services as possible — without relying on proprietary platforms (Google, Apple, Netflix, etc.).  
+This documentation site is built using [Nuxt.js](https://nuxt.com/).
 
-Ce repo contient de quoi modifier les pages, ajouter vos changements, et redéployer le site.
+This repository contains everything you need to edit pages, apply your changes, and redeploy the site.
 
 ## Setup
 
-Installer les dépendances
+Install dependencies:
 
 ```bash
 npm install
 ```
 
-## Environnement de dévelopment (port 3000)
+## Development Environment (port 3000)
 
 ```bash
 npm run dev
 ```
 
-## Génération des pages statiques
+## Generate Static Pages
 
 ```bash
 npm run generate
 ```
 
-Les fichiers HTML seront générés dans le dossier .output/public et prêts à être déployés sur n'importe quel hébergement compatible avec un site statique.
+The HTML files will be generated in the `.output/public` folder and are ready to be deployed on any static-compatible hosting.
 
-## Preview build
+## Preview Build
 
-Si vous voulez voir immédiatement le résultat de la génération du site vous pouvez lancer un serveur de preview :
+If you'd like to immediately see the result of your static site build, you can launch a preview server:
 
 ```bash
 npm run preview

app.config.ts

@@ -30,9 +30,9 @@ export default defineAppConfig({
     socials: {
       github:'',
       Language: {
-        label: 'En',
-        icon: 'ri:english-input',
-        href: 'https://docu.djeex.fr'
+        label: '🇫🇷',
+        icon:'material-symbols:language-french', 
+        href: 'https://docu.djeex.fr/fr/',
       },
       Gitea: {
         label: 'Gitea',

content/0.index.md

@@ -1,5 +1,5 @@
 ---
-title: Accueil
+title: Home
 navigation: false
 layout: page
 main:
@@ -11,18 +11,18 @@ main:
 ::block-hero
 ---
 cta:
-  - Accéder à la doc
-  - /apropos/bienvenue
+  - Access the Docs
+  - /about/welcome
 secondary:
-  - En →
-  - https://docu.djeex.fr
+  - 🇫🇷 →
+  - https://docu.djeex.fr/fr/
 ---
 
 #title
-Bienvenue sur docu[·]{style="color: #1ad6ff"}djeex
+Welcome to docu[·]{style="color: #1ad6ff"}djeex
 
 #description
-De la doc, encore de la doc. Des astuces et des expériences. Construisez votre homelab et votre propre NAS.
+Docs, more docs. Tips and experiments. Build your homelab and your own NAS.
 
 #extra
 ![](/img/global/docudjeex-home.svg)  
@@ -31,5 +31,5 @@ De la doc, encore de la doc. Des astuces et des expériences. Construisez votre
 #title
 __git.djeex.fr__
 #description
-[Consultez mes bêtises](https://git.djeex.fr)
+[Check my nonsense projects](https://git.djeex.fr)
 ::

content/1.about/1.welcome.md

@@ -0,0 +1,44 @@
+---
+icon: lucide:home
+title: Welcome
+main:
+  fluid: false
+---
+:ellipsis{right=0px width=75% blur=150px}
+
+# docu[·]{style="color: #1ad6ff"}what?
+
+__Docu[·]{style="color: #1ad6ff"}djeex__ is a site containing the documentation of my personal servers, originally created to easily keep track of my configurations and commands.  
+My infrastructure is built around the Debian 12 + Docker combo, making exporting and deployment simpler.  
+Special thanks to __Nipah__, __Xenio__, and others for their patience and support. Most of this content comes directly from them.  
+
+## About the documentation
+
+The documentation provided here is experimental and shared in a spirit of open knowledge and experience.  
+It is not intended to build production-grade or industrialized infrastructure.  
+It may contain mistakes and/or approximations.
+
+Naturally, this documentation should only be used within a strictly legal framework.
+
+::card-grid
+#title
+Available or Upcoming Documentation
+
+#root
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+
+#default
+  ::card{icon=noto:microscope}
+  #title
+  Serveex
+  #description
+  [Step-by-step Homelab Deployment Guide](/serveex/introduction)
+  ::
+
+  ::card{icon=noto:computer-disk}
+  #title
+  Stockeex
+  #description
+  *(coming soon)* Build your own home NAS to store your data and media
+  ::
+::

content/1.about/_dir.yml

@@ -0,0 +1,3 @@
+icon: noto:star
+navigation.title: About
+navigation.redirect: /about/welcome

content/1.apropos/1.bienvenue.md

@@ -1,41 +0,0 @@
----
-icon: lucide:home
-title: Bienvenue
-main:
-  fluid: false
----
-:ellipsis{right=0px width=75% blur=150px}
-
-# docu[·]{style="color: #1ad6ff"}quoi ?
-
-__Docu[·]{style="color: #1ad6ff"}djeex__ est le site regroupant la documentation de mes serveurs, pensé à l'origine pour retrouver facilement mes configurations et commandes. Mon infrastructure est construite autour du duo Debian 12 et docker, pour plus de simplicité à l'export et au déploiement. On remerciera principalement __Nipah__ et __Xenio__ (et d'autres) pour leur patience et écoute. La majeur partie de ce contenu vient de leurs têtes.
-
-## A propos de la documentation
-
-La documentation fournie ici est distribuée à titre expérimentale, dans un esprit de partage d'expérience. Elle n'est en aucun cas faite pour construire une architecture de production ou pour de l'industrialisation. Il est possible qu'elle contienne des erreurs et/ou des approximations.
-
-Evidemment l'usage de cette documentation doit strictement se limiter au cadre légal.
-
-::card-grid
-#title
-Documentation disponible ou en cours
-
-#root
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-
-#default
-  ::card{icon=noto:microscope}
-  #title
-  Serveex
-  #description
-  [Votre homelab à déployer pas à pas](/serveex/introduction)
-  ::
-
-  ::card{icon=noto:computer-disk}
-  #title
-  Stockeex
-  #description
-  *(à venir)* Votre NAS maison à créer chez vous pour stocker vos données et media
-  ::
-::
-

content/1.apropos/_dir.yml

@@ -1,3 +0,0 @@
-icon: noto:star
-navigation.title: Bienvenue
-navigation.redirect: /apropos/bienvenue

content/2.general/1.networking/1.nat.md

@@ -0,0 +1,79 @@
+---
+navigation: true
+title: NAT & DHCP
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+
+# Router and NAT
+
+::alert{type="info"}
+🎯  __Goals:__
+- Understand how port forwarding works
+- Learn how to configure router NAT
+- Learn how to issue DHCP leases (fixed IPs)
+::
+
+![picture](/img/global/nat.svg)
+
+## What is a "port"?
+---
+Ports are different channels through which your router sends and receives data. This allows multiple services to run simultaneously.  
+When it receives data through a port, your router forwards that data to the machine that:
+- either initiated the request,
+- or is configured to receive data on a specific port.
+
+Your router has over 65,000 ports available.
+
+Some programs and applications are designed to use specific ports. For example, when your network sends data from an HTML page, the router receives it through port 80 (non-secure) or port `443` (secure via SSL).  
+
+So, your router acts as a data dispatcher between the internet and your local machines.
+
+## Port Forwarding
+---
+Forwarding a `port` means setting a rule that specifies which `source` can send data to which `port` on your router, which will then forward it to a specific `port` on a specific `machine`. The `sources` and `destination machine` are identified by their IP addresses.
+
+| Variable               | Description                                             | Example                 |
+|------------------------|---------------------------------------------------------|-------------------------|
+| `source machine`       | IP of the source machine (from the internet)            | `All`<br>`123.45.67.89` |
+| `source port`          | Incoming port on the router                             | `443`                   |
+| `destination port`     | Port on the destination machine                         | `3000`                  |
+| `destination machine`  | IP of the target machine (on your local network)        | `192.168.1.50`          |
+
+According to the table:  
+If we remove `All` and keep the IP `123.45.67.89`, all traffic from this IP sent to port `443` on your router will be forwarded to port `3000` on the local IP `192.168.1.50`.
+
+If we remove the IP and keep `All`, then all traffic from the internet on port `443` will be redirected to port `3000` on `192.168.1.50`.
+
+This is useful when you have a server that must be accessible from the internet. For instance, a website uses port `80` (non-secure) or `443` (SSL-secured).  
+To make the website accessible, you'll configure your router to redirect the domain request to your local server.  
+Assume your service runs on port `3000` locally (`http://192.168.1.50:3000`), you would redirect all traffic from port `443` on the router to port `3000` on the local server.
+
+::alert{type="warning"}
+:::list{type="warning"}
+- __Warning:__ If you have multiple services to expose like `subdomain1.mydomain.com` and `subdomain2.mydomain.com`, your router cannot differentiate requests and forward to different ports.  
+  You must use a [Reverse Proxy](../../serveex/core/swag) to route traffic based on the request.
+:::
+::
+
+## DHCP
+---
+Every time a device connects to your local network, your router assigns it an IP address using DHCP rules.  
+This IP is randomly selected from a predefined pool.  
+At every device reboot, the IP may change — which is problematic if you're forwarding ports, as the target IP may no longer be valid.  
+
+To avoid this, use your router's DHCP server to assign a static IP address.
+
+Each device has a physical "MAC address".  
+To assign a fixed IP, you must know your device's MAC address (visible in your router when it's connected), and assign it a static IP.  
+This is called a "static DHCP lease."
+
+That way, your machine's IP never changes and your port forwarding rules remain effective.
+
+| Variable      | Description                     | Example             |
+|---------------|----------------------------------|---------------------|
+| `IP`          | Fixed local IP to assign         | `192.168.1.50`      |
+| `MAC Address` | Physical address of the device   | `5E:FF:56:A2:AF:15` |
+
+For more information, refer to your router's documentation.

content/2.general/1.networking/2.dns.md

@@ -0,0 +1,69 @@
+---
+navigation: true
+title: DNS Zone
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Domain Names and DNS Zones
+
+::alert{type="info"}
+🎯  __Objectives:__
+- Understand how a DNS server works
+- Learn how to edit a DNS zone
+::
+
+## Introduction
+---
+When you browse a website or use an app, requests are made to one or more domains to fetch content for the page. Your device doesn't know the IP addresses of these servers, so it contacts a _name server_ (Domain Name Server), which responds with the most up-to-date IP address for the domain being requested.
+
+The DNS zone is like a registry with signposts that direct your requests to the correct destination.
+
+![Picture](/img/global/dns.svg)
+
+## The DNS Zone
+---
+When you purchase a domain from a registrar (Cloudflare, OVH, etc.), the registrar assigns you a DNS zone that you can customize.
+
+You can enter _records_ into this DNS zone to direct requests properly. You can find [more information here](https://help.ovhcloud.com/csm/fr-dns-servers-general-information?id=kb_article_view&sysparm_article=KB0051661).
+
+Example of a DNS zone for the domain `mydomain.com`:
+
+
+```
+@ IN SOA ns1.dns.me. dns.net. (2024051800 86400 3600 3600000 60)
+                 IN NS     ns1.dns.me.
+                 IN NS     ns2.dns.me.
+                 IN A      203.0.113.0
+www              IN CNAME  mydomain.com
+sousdomaine      IN CNAME  mydomain.com
+```
+
+
+In this example:
+
+- `$TTL 3600` tells global name servers that the records are valid for 1 hour (after which they need to re-check).
+- `IN SOA ns1.dns.me. dns.net. (...)` indicates `ns1.dns.me` as the primary DNS server, with refresh intervals.
+- `IN NS` records define the authoritative name servers for the domain.
+- `IN A 203.0.113.0` means `mydomain.com` points to IP `203.0.113.0`.
+- `subdomain IN CNAME mydomain.com` means `subdomain.mydomain.com` points to the same destination as `mydomain.com`.
+
+So, if you want to point `mydomain.com` to your server, you can do it by adding an `A` record pointing to your server's public IP address.
+
+::alert{type="warning"}
+:::list{type="warning"}
+- __Warning:__ If your server is hosted at home:
+:::
+- Your public IP is the one assigned to your home router. Make sure it's static, or configure [DDNS](https://aws.amazon.com/fr/what-is/dynamic-dns/).
+- Make sure you've [set up port 443 forwarding to your server's listening port](/general/networking/nat).
+::
+
+If you're adding a subdomain that should also point to your server, use a `CNAME` record pointing to `mydomain.com`.
+
+::alert{type="info"}
+:::list{type="info"}
+- __Why not use an `A` record for the subdomain?__ If your subdomain points to the same server as `mydomain.com`, it's better to use a `CNAME` record because if the server's IP changes, you won’t need to update the subdomain record.
+:::
+::
+
+Most registrars offer user-friendly interfaces to manage DNS records. Refer to your registrar’s documentation for specific instructions.

content/2.general/1.networking/3.samba.md

@@ -0,0 +1,227 @@
+---
+navigation: true
+title: Samba
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Samba
+
+Samba is a protocol that allows access to a folder located on a network drive. It can be configured on macOS, Windows, or Linux.
+
+There are many tutorials for setting up Samba on Windows or on NAS systems like Synology, but here we focus on Debian.
+
+::alert{type="info"}
+🎯 __Objectives:__
+- Create a network folder on a remote machine
+- Access the network folder from our server
+::
+
+![samba](/img/global/smb.svg)
+
+## Sharing a Network Folder
+---
+::alert{type="info"}
+:::list{type="info"}
+- In this example, we will share the `/video` folder from a remote machine called `remote-machine`. We will access this folder from a machine called `local-machine`. The user connecting to the network drive will be `sambauser`.
+:::
+::
+
+### Install Samba Server
+
+```shell
+sudo apt update && sudo apt upgrade
+sudo apt install samba smbclient cifs-utils
+```
+
+### Create the `/video` Folder
+
+```shell
+sudo mkdir /video
+```
+
+### Configure the Share
+
+Now, edit the file `/etc/samba/smb.conf`.
+
+✨ **Tip:** You can use [File Browser](/serveex/files/file-browser) to navigate and edit your files instead of using terminal commands.
+\::
+
+```shell
+sudo vim /etc/samba/smb.conf
+```
+
+Find the `workgroup` variable, press `i` to enter insert mode, and name your workgroup (e.g., `workgroup = WORKGROUP`).
+
+Then scroll to the end of the file and add the following configuration:
+
+```properties
+[video]
+   comment = Video folder
+   path = /video
+   writable = yes
+   guest ok = no
+   valid users = @smbshare
+   force create mode = 770
+   force directory mode = 770
+   inherit permissions = yes
+```
+
+Press `Esc` to exit insert mode, then type `:x` and press `Enter` to save and exit.
+
+### Create a Samba User and Group
+
+Since we're using a secured share, we need to create a user and group to access it remotely.
+
+Create the group:
+
+```shell
+sudo groupadd smbshare
+```
+
+Give the group control over the `/video` folder:
+
+```shell
+sudo chgrp -R smbshare /video
+```
+
+Set inherited permissions:
+
+```shell
+sudo chmod 2775 /video
+```
+
+Now add a no-login user — this user cannot log into the server but can access Samba.
+
+```shell
+sudo useradd -M -s /sbin/nologin sambauser
+```
+
+Add the user to the `smbshare` group:
+
+```shell
+sudo usermod -aG smbshare sambauser
+```
+
+Set a Samba password:
+
+```shell
+sudo smbpasswd -a sambauser
+```
+
+Enable the Samba account:
+
+```shell
+sudo smbpasswd -e sambauser
+```
+
+```shell
+sudo ufw allow from remote-ip to any app Samba
+::
+```
+
+## Accessing a Shared Folder
+
+---
+
+\::
+
+### Install Required Packages
+
+```shell
+sudo apt update && sudo apt upgrade
+sudo apt install cifs-utils
+```
+
+### Create the Mount Destination
+
+We will create a folder on our local machine where the remote `/video` folder will be mounted — e.g., `/mnt/video`.
+
+```shell
+sudo mkdir /mnt/video
+```
+
+### Prepare the .credentials File
+
+To avoid typing our username and password every time, create a `.credentials` file storing the login info.
+
+Create it in the `/smb` folder:
+
+```shell
+sudo mkdir /smb
+sudo vi /smb/.credentials
+```
+
+Enter insert mode (`i`) and write:
+
+```properties
+username=smbuser
+password=password
+```
+
+* `smbuser`: the user we created on the `remote-machine`
+* `password`: the password set earlier
+
+Press `Esc`, then `:x` and `Enter` to save and exit.
+
+Set proper file permissions:
+
+```shell
+sudo chmod 600 /smb/.credentials
+```
+
+### Mount the Shared Folder
+
+Now mount the folder:
+
+```shell
+sudo mount -t cifs -o credentials=/smb/.credentials //remote-ip/video /mnt/video
+```
+
+Replace `remote-ip` with your `remote-machine`'s IP address.
+
+Verify the mount:
+
+```shell
+sudo mount -t cifs
+```
+
+You’ll see details confirming the mount is successful.
+
+Now you can access the `/video` folder of the `remote-machine` from your `local-machine`!
+
+### Auto-mount on Boot
+
+By default, shares aren't auto-mounted after reboot. To automate this, edit the `/etc/fstab` file.
+
+First, back it up:
+
+```shell
+sudo cp /etc/fstab /etc/fstab.bak
+```
+
+Then add the mount configuration line:
+
+```shell
+sudo echo //remote-ip/video    /mnt/video  cifs   _netdev,nofail,credentials=/smb/.credentials,x-systemd.automount,x-systemd.device-timeout=15 0 0 >> /etc/fstab
+```
+
+Reboot the machine:
+
+```shell
+sudo reboot
+```
+
+After rebooting, verify the mount:
+
+```shell
+sudo mount -t cifs
+```
+
+And done!
+
+### Unmount the Shared Folder
+
+```shell
+sudo umount -t cifs /mnt/video
+```

content/2.general/1.networking/_dir.yml

@@ -0,0 +1,2 @@
+navigation.title: Networking
+icon: lucide:network

content/2.general/2.storage/1.raid.md

@@ -0,0 +1,113 @@
+---
+navigation: true
+title: RAID
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# RAID
+
+_Redundant Array of Independent Disks_
+
+In computing, RAID (Redundant Array of Independent Disks) is a system that allows multiple hard drives to be combined to improve performance and/or reliability. It works by restructuring and distributing data blocks across the drives.
+
+Originally, RAID systems were hardware-based, meaning a dedicated controller (a specific chip) managed data distribution and RAID operations. Today, most RAID systems (or their equivalents) are software-based. In fact, many software technologies can create RAID-like systems with features not available in hardware RAID, such as automatic repair (data scrubbing), snapshots, and more.
+
+## Different Types of RAID
+
+There are several types of RAID, each offering its own pros and cons. In general, RAID impacts the following five factors:
+
+- Number of drives
+- Total storage capacity
+- Read speed
+- Write speed
+- Fault tolerance (resistance to hardware failure)
+
+::alert{type="warning"}
+:::list{type="warning"}
+  - RAID is not a backup system but a service continuity system! It only allows hot-swapping of drives without interrupting your server or restoring from backup. You still need an external backup system.
+::
+
+### No RAID
+---
+
+<div style="display: flex; align-items: center;">
+  <img src="/img/global/no-raid.svg" alt="Image" style="max-width: 30%; max-height:230px; margin-right: 20px;">
+  <ul>
+    <li>Just your disks, without RAID. Data is stored disk by disk.</li>
+    <li>If you lose a disk, only its data is lost.</li>
+    <li>Total capacity is the sum of all disks.</li>
+</div>
+
+Use your disks without RAID when you're not afraid of data loss and can tolerate service interruptions between failure and backup restoration.
+
+### RAID 0
+---
+
+<div style="display: flex; align-items: center;">
+  <img src="/img/global/raid0.svg" alt="Image" style="max-width: 30%; max-height:230px; margin-right: 20px;">
+  <ul>
+    <li>OS sees 1 drive.</li>
+    <li>Data is striped across all disks.</li>
+    <li>If you lose one disk, you lose all data.</li>
+    <li>High read and write performance (multiplied by number of disks).</li>
+    <li>Total capacity is the sum of all disks.</li>
+    <li>Minimum of 2 disks required.</li>
+</div>
+
+Use RAID 0 when you prioritize performance and are not concerned about data loss. Ideal for temporary, high-speed storage (video editing, AI workloads, etc). Not suitable for long-term storage, as one failure means total data loss.
+
+### RAID 1
+---
+
+<div style="display: flex; align-items: center;">
+  <img src="/img/global/raid1.svg" alt="Image" style="max-width: 30%; max-height:230px; margin-right: 20px;">
+  <ul>
+    <li>OS sees 1 drive.</li>
+    <li>All disks contain identical data.</li>
+    <li>You can lose all but one disk.</li>
+    <li>Improved read speed (scales with number of disks).</li>
+    <li>Total capacity is equal to one disk (e.g., 2×10TB = 10TB).</li>
+    <li>Minimum of 2 disks required.</li>
+</div>
+
+Use RAID 1 for strong redundancy. Each disk contains all data, so performance remains unaffected during a failure. Once failed disks are replaced, data is quickly restored. However, usable storage is limited to one disk’s capacity, making it an expensive solution.
+
+::alert{type="success"}
+:::list{type="success"}
+- __Tip:__ You can combine RAID 1 with other RAID types to create mirrored arrays.
+:::
+::
+
+### RAID 5
+---
+<p align="center">
+  <img src="/img/global/raid5.svg" alt="Image" style="max-width: 40%; margin-right: 20px;">
+</p>
+
+- OS sees 1 drive.
+- Data is striped with parity blocks for redundancy.
+- You can lose 1 disk and recover data.
+- Improved read speed (scales with number of disks).
+- Total capacity is the sum of all disks minus one (e.g., 3×10TB = 20TB).
+- Minimum of 3 disks (4 recommended to reduce capacity loss).
+
+Use RAID 5 when you want reliable storage with 3 to 5 disks and minimal space loss. It tolerates one disk failure but may have degraded performance during recovery, which can take days.
+
+### RAID 6
+---
+<p align="center">
+  <img src="/img/global/raid6.svg" alt="Image" style="max-width: 50%; margin-right: 20px;">
+</p>
+
+- OS sees 1 drive.
+- Data is striped with dual parity blocks.
+- You can lose 2 disks and still recover data.
+- Improved read speed (scales with number of disks).
+- Total capacity is the sum of all disks minus two (e.g., 4×10TB = 20TB).
+- Minimum of 4 disks (6 recommended to minimize space loss).
+
+Use RAID 6 in similar situations as RAID 5, especially with 6 or more disks. More disks mean higher failure risk. RAID 6 offers peace of mind by tolerating two simultaneous failures.
+
+## Software RAID
+(coming soon)

content/2.general/2.storage/2.zfs.md

@@ -0,0 +1,76 @@
+---
+navigation: true
+title: ZFS
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# ZFS
+
+::alert{type="info"}
+🎯 __Objectives:__
+- Understand what ZFS is and why it's useful
+::
+
+ZFS is widely used in the world of servers, NAS systems (like FreeNAS / TrueNAS), virtualization, and even by tech-savvy individuals who want reliable storage. It is both a _file system_ (like NTFS for Windows, EXT4, FAT32, etc.) and a _volume manager_ (similar to LVM).
+
+To put it simply:  
+- A **volume manager** organizes physical storage (like one or more hard drives).  
+- A **file system** organizes how data blocks are written, read, and deleted within those volumes.
+
+ZFS goes far beyond traditional file systems in terms of performance and features.  
+Here’s what we’re most interested in:
+- Its __snapshot management__ features, allowing you to quickly roll back in case of issues.
+- Its support for disk groupings and [__RAID-like structures__](/general/storage/raid) (Z-Mirror, RAIDZ1, RAIDZ2, RAIDZ3).
+- Its __automatic recovery of corrupted data__ (through scrubbing).
+- Its performance, enhanced by RAM caching (ZFS ARC).
+- Its robust error notifications and monitoring.
+
+## Structure
+---
+![](/img/global/zfs.svg)
+
+ZFS has a unique structure:
+
+- **vdev** (virtual device): a group of physical or virtual disks.
+- **zpool**: a collection of vdevs configured as a single storage pool. A zpool can contain multiple vdevs, but a vdev belongs to only one zpool.
+- **dataset**: a logical data container within a zpool. Each dataset can have its own settings (compression, quotas, permissions, etc.).
+
+There are several dataset types:
+- **file system**: a standard ZFS filesystem, mounted without storage quotas.
+- **zvol**: a "virtual disk" with a defined size, which you can format and partition as if it were a physical disk.
+- **snapshot**: a frozen-in-time version of another dataset. Snapshots can be created manually or through backup tools. They can be mounted to browse data as it was at the snapshot time.
+
+## Why ZFS over others?
+---
+### Data Integrity
+
+ZFS continuously checks that your stored data hasn't become corrupted. Every block of data is associated with a checksum, allowing ZFS to detect even the smallest alteration. If corruption is found and a healthy copy exists elsewhere, ZFS can repair the data automatically.
+
+### Built-in RAID
+
+ZFS includes its own volume management system (vdevs). You can build a zpool using multiple disks—similar to traditional [RAID](/general/storage/raid) setups—but with more flexibility. For example:
+- **Z-mirror** → equivalent to RAID 1
+- **RAIDZ1** → equivalent to RAID 5 (tolerates 1 disk failure)
+- **RAIDZ2** → equivalent to RAID 6 (tolerates 2 disk failures)
+- **RAIDZ3** → tolerates up to 3 disk failures
+
+ZFS handles all this natively—no external RAID software needed.
+
+::alert{type="info"}
+:::list{type="info"}
+- Check out the [article on RAID](/general/storage/raid) to find the right solution for your needs.
+:::
+::
+
+### Snapshots and Clones
+
+ZFS allows you to create snapshots—instantaneous images of a dataset's state. Snapshots take up minimal space and can be scheduled frequently. You can also create clones: writable copies of snapshots.
+
+### Compression and Deduplication
+
+ZFS can compress data on the fly (transparently to the user), saving disk space. It also supports deduplication (removing duplicate data), though this feature requires a lot of memory and is not recommended for all use cases.
+
+---
+
+Now you know why ZFS is *the* file system to deploy on your NAS.

content/2.general/2.storage/_dir.yml

@@ -0,0 +1,2 @@
+navigation.title: Storage
+icon: lucide:hard-drive

content/2.general/3.hardware/basics.md

@@ -0,0 +1,171 @@
+---
+navigation: true
+title: The Basics
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Server Basics
+
+::alert{type="info"}
+🎯 __Objectives:__
+- Understand the fundamentals of server hardware
+::
+
+![hardware](/img/global/hardware.svg)
+
+
+A __server__ is essentially a computer dedicated to specific tasks, designed to remain accessible at all times. Structurally, it's not much different from a regular computer. Depending on its intended use, some components may vary. This article serves as a reference to help you understand the essential components of a server and how their roles adapt based on your needs.
+
+## Motherboard
+---
+The __motherboard__ is the foundation of your machine. It's the component that connects all others together. It enables communication between components and interaction with peripherals (keyboard, mouse, etc.). Choose it based on your I/O (Input/Output) needs like USB ports, network ports, speed, etc., and ensure compatibility with the components you plan to install.
+
+Key components connected to the motherboard:
+- CPU
+- RAM
+- Storage (HDD and/or SSD)
+- Optional dedicated GPU
+
+Common consumer motherboard formats:
+- E-ATX: largest
+- ATX: standard
+- Micro-ATX: smaller
+- Mini-ITX: smallest
+
+Larger boards generally offer more ports and features. Pre-built systems might use proprietary formats.
+
+## CPU
+---
+<div style="display: flex; align-items: center;">
+  <img src="/img/global/cpu.svg" alt="Image" style="max-width: 25%; max-height:230px; margin-right: 20px;">
+  <p>The <strong>CPU</strong> (Central Processing Unit) is the computer's calculator. It processes most software tasks. Modern CPUs have multiple cores, often with virtual threads, to better handle workloads. They need to be cooled using either an active cooler (with a fan) or a passive one (fanless), depending on power consumption (watts). Choose your CPU based on how you plan to use the server.</p>
+</div>
+
+::alert{type="warning"}
+:::list{type="warning"}
+- __Caution:__ Ensure third-party coolers are compatible with the CPU socket and always apply thermal paste before installing the cooler.
+:::
+::
+
+Consider:
+- Number of cores (more cores = better multitasking)
+- Clock speed in GHz
+- Power consumption in Watts
+
+For low-power home servers or NAS (non-intensive computing), consider Intel N100/150 (4 cores) or N305/N355 (8 cores)—efficient and low power (ideal for 24/7 uptime).
+
+## RAM
+---
+
+<p align="center">
+  <img src="/img/global/ram.svg" alt="Image" style="max-width: 65%;">
+</p>
+
+__RAM__ (Random Access Memory) is fast, temporary memory used by the CPU (and iGPU if applicable) for quick access during execution. It clears periodically and when the machine powers down. Better RAM = better CPU performance.
+
+Comes as sticks installed on the motherboard. Varies by format and generation (currently DDR5).
+
+## GPU
+---
+
+The __GPU__ (Graphics Processing Unit) handles graphical, video, and sometimes AI-related processing. Its main theoretical use is to display the image on your screen. In servers, it's useful for media centers (e.g. [Plex](/serveex/media/plex)) and for accelerating AI tasks like facial recognition or photo indexing (e.g. [Immich](/serveex/cloud/immich)).
+
+Depending on the required performance, one can choose between a dedicated GPU with its own VRAM (a graphics card connected to a PCIe slot on the motherboard), or an iGPU—an integrated GPU built into the CPU (such as the N100/N150 or N305/N355), which uses the system’s shared RAM.
+
+### HDD(s)
+---
+
+<p align="center">
+  <img src="/img/global/hdd.svg" alt="Image" style="max-width: 50%; margin-right: 20px;">
+</p>
+
+An __HDD__ (Hard Disk Drive), or hard drive, is a component used to store data. It was once the standard storage device in computers. HDDs consist of one or more stacked platters and read/write heads—somewhat like a vinyl record player.
+
+Today, HDDs can store enormous amounts of data (up to 30TB, or 30,000 gigabytes, for consumer models), but their read and write speeds are limited due to their mechanical nature. They are also bulky and heavy.
+
+Generally, HDDs are best suited for storing data that doesn’t require frequent access or fast write speeds, such as media files (videos, photos), cloud drives, or archived data. They perform well in these scenarios and, most importantly, are significantly cheaper than SSDs for the same amount of storage.
+
+::alert{type="success"}
+:::list{type="success"}
+- __Tip:__ Use multiple HDDs in [RAID](/general/storage/raid) to enhance performance and redundancy.
+:::
+::
+
+Comes in 3.5" and 2.5" formats; servers usually favor the more reliable 3.5".
+
+### SSD(s)
+---
+
+<p align="center">
+  <img src="/img/global/nvme.svg" alt="Image" style="max-width: 50%; margin-right: 20px;">
+</p>
+
+An __SSD__ (Solid State Drive) is a small circuit board with memory chips soldered onto it, used to store information. Unlike RAM, these chips retain data even when not powered, meaning the information is preserved after a reboot. SSDs are generally used as the main storage medium for your server.
+
+Unlike HDDs, SSDs have no moving parts, are highly compact, and most importantly, are extremely fast—offering speeds of several gigabytes per second for high-performance models.
+
+SSDs come in various formats, but today the preferred choice is the M.2 NVMe version, as it is the smallest, fastest, and has become the standard on modern motherboards.
+
+However, SSDs are significantly more expensive than hard drives for the same storage capacity. Typically, the operating system (OS) is installed on the SSD to ensure fast performance. In a server environment, it's also ideal to store [Docker containers](/serveex/core/docker) and databases on the SSD. More broadly, any data that needs to be accessed frequently and quickly—such as websites, applications, or processing workloads—should be stored on an SSD.
+
+### Network Card
+---
+
+A __network card__ allows your machine to communicate with your network (including the internet). It consists of a controller chip and one or more network ports. These ports—often Ethernet ports—can come in different physical formats and support various data transfer standards:
+
+- __RJ45 Gigabit Ethernet (10/100/1000):__ The standard RJ45 connector, supporting speeds from 10 Mbps (0.125 MB/s) up to 1000 Mbps (125 MB/s).
+- __RJ45 2.5G:__ Same connector type, supporting up to 2.5 Gbps (2,500 Mbps or 312.5 MB/s).
+- __RJ45 5G:__ Same connector, supporting up to 5 Gbps (625 MB/s).
+- __RJ45 10G Base-T:__ Same RJ45 format, supporting up to 10 Gbps (1.25 GB/s).
+- __SFP 1G:__ SFP port, commonly used for fiber optic connections, supporting speeds up to 1 Gbps.
+- __SFP+ 10G:__ An enhanced version of the SFP port, also used for fiber optics, supporting up to 10 Gbps.
+
+::alert{type="warning"}
+:::list{type="warning"}
+- __Caution:__ Match network gear (router, switch, cables) to your desired speed. For most uses, CAT5E cables are enough; use CAT6A beyond 10 Gbps. Fiber requires additional care (simplex, duplex, transceivers...).
+:::
+::
+
+The network card is usually built directly into the motherboard, but you can also use dedicated network cards, for example via USB or a PCIe expansion slot.
+
+In general, for a server setup, it's recommended to have at least two Ethernet ports to ensure redundancy in case one connection fails.
+
+### Input/Output Ports
+---
+
+__I/O__ ports allow communication with external devices (displays, keyboard, mouse, network...). Motherboards typically offer:
+- Ethernet ports
+- USB ports (varied types/speeds)
+- Video ports
+- Audio jacks
+
+Choose a motherboard and expansions based on your I/O needs.
+
+### Power Supply
+---
+
+The __power supply unit__ (PSU) is the component that provides electrical power to your machine’s components. It connects to the wall via a power cord and has several output cables that plug into the motherboard and various peripherals, such as hard drives or dedicated graphics cards.
+
+A power supply is defined by several key characteristics:
+
+- Wattage (its total power output),
+- Modularity (whether the cables are fixed or detachable),
+- Efficiency (measured as a percentage). For example, a 500W PSU with 80% efficiency will actually draw 625W from the wall to deliver 500W to the system.
+
+Another important factor is the form factor. There are several standard sizes, from ATX L (for larger cases) to SFX (for compact builds). There are also specialized models for rack-mounted servers, which are typically flat and space-efficient.
+
+To choose the right PSU, a common rule of thumb is to estimate your system’s power needs based on usage, and then double that value. This is because most power supplies operate at optimal efficiency around 50% of their maximum load.
+
+### Case
+---
+
+<div style="display: flex; align-items: center;">
+  <img src="/img/global/case.svg" alt="Image" style="max-width: 25%; max-height:230px; margin-right: 20px;">
+  <p>The <strong>case</strong> is also an essential component of your machine. It plays a key role in cooling, through its fans and airflow design, and it determines the form factor compatibility for your motherboard, power supply, and any dedicated GPU you may install.
+</p>
+</div>
+
+Additionally, the case dictates how many HDDs you can install and what formats they support. Some cases are rack-mountable, meaning they can be installed in server racks (server cabinets).
+
+Choose your case carefully based on your specific needs and the hardware you plan to use.

content/2.general/_dir.yml

@@ -0,0 +1,3 @@
+icon: noto:open-book
+navigation.title: General
+navigation.redirect: /general/networking/nat

content/2.generalites/1.reseau/1.nat.md

@@ -1,66 +0,0 @@
----
-navigation: true
-title: NAT & DHCP
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Routeur et NAT
-::alert{type="info"}
-🎯  __Objectifs :__
-- Comprendre le principe de la redirection de port
-- Savoir configurer le NAT de son routeur
-- Savoir émettre des baux DHCP (IP fixes)
-::
-
-![picture](/img/global/nat.svg)
-
-## Qu'est-ce qu'un "port" ?
----
-Les ports sont différents canaux par lesquels votre routeur envoie et reçoit des données, ce qui permet d'utiliser plusieurs services en meme temps. Lorsqu'il reçoit une donnée via un port, otre routeur transmet ensuite les données à la machine qui :
-- soit a émis la requête de départ
-- soit est configurée pour recevoir les données reçues par un port spécifique du routeur
-
-Votre routeur dispose de plus de 65 000 ports à utiliser.
-
-Certains programmes et applications sont conçus pour utiliser des ports spécifiques. Par exemple, lorsque votre réseau envoie des données à partir d'une page HTML, le routeur les recevra via le port numéro 80 (non sécurisé) ou `443` (sécurisé via SSL). 
-
-Le routeur sert donc de plateforme d'aiguillage des données entre internet et votre machine.
-
-## La redirection de port
----
-Rediriger un `port`, c'est émettre une règle qui spécifie que telle `source` peut envoyer des données à tel `port` de votre routeur, qui redirigera les données sur tel `port` de telle `machine`. Les `sources` et la `machine de destination` sont identifiées par leur `adresse IP`.
-
-| Variable                 | Description                                              | exemple                 |
-|--------------------------|----------------------------------------------------------|-------------------------|
-|         `machine source` |                   IP de la machine source (sur internet) | `All`<br>`123.45.67.89` |
-|            `port source` |                            Port d'arrivée sur le routeur |                   `443` |
-|    `port de destination` |             Port d'arrivée sur la machine de destination |                  `3000` |
-| `machine de destination` | IP de la machine de destination (sur votre réseau local) |          `192.168.1.50` |
-
-Selon ce tableau, si on enlève le `All` et que l'on garde l'ip `123.45.67.89` en provenance d'internet, tout le traffic envoyé depuis cette IP sur le port `443` du routeur sera redirigé vers le port `3000` de l'IP locale `192.168.1.50`.
-
-Si on enlève l'IP de l'exemple et qu'on laisse le `All`, tout le traffic d'internet envoyé au port `443` du routeur sera redirigé vers le port `3000` de l'IP locale `192.168.1.50`.
-
-C'est utile si par exemple vous avez un serveur qui a un service qui nécessite d'etre accessible par internet. Par exemple, un site web. Le web utilise le port `80` (non sécurisé) et le port 443 (sécurisé par certificat SSL) pour communiquer. Ainsi, si je veux que mon site internet soit accessible, je vais faire en sorte que lorsqu'on tape le nom de domaine de mon site, le routeur redirige bien vers mon serveur local (avec l'exemple de l'IP locale du tableau). Par exemple, imaginons que mon service est sur le port `3000` de mon routeur (accessible en local via `http://192.168.1.50:3000`), je vais donc rediriger comme dans l'exemple toutes les sources (All) qui passent par le port `443` du routeur vers le port `3000` de mon serveur local.
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ Si vous avez plusieurs services à rendre accessible, avec par exemple `sousdomaine1.mondomaine.fr` et `sousdomaine2.mondomaine.fr`, votre routeur ne peut pas rediriger vers plusieurs port selon la requête. Vous devrez utiliser un [Reverse Proxy](../../serveex/coeur/swag) qui selon la requete redirigera vers le bon service de votre serveur.
-:::
-::
-
-## Le DHCP
----
-A chaque fois que vous connectez un appareil sur votre réseau local, votre routeur lui attribue une adresse IP via les règles DHCP. Celle-ci est aléatoire selon des règles prédéfinies. A chaque redémarrage de l'appareil, l'IP peut changer. C'est embetant si vous exposez un service et que vous avez une redirection de port dans votre routeur car si l'IP change, la redirection enverra les données dans le vide. Le serveur DHCP de votre box permet d'attribuer une IP fixe à un appareil.
-
-Chaque appareil a une adresse physique dite "adressse MAC". Pour fixer l'IP, vous devez connaitre l'adresse physique de votre appareil (visible dans votre routeur si votre machine est connectée au réseau), et lui attribuer une adresse IP fixe, ce qu'on appel un "bail DHCP fixe".
-
-Ainsi, l'IP de votre machine ne changera jamais et la redirection de port sera toujours effective.
-
-| Variable      | Description                    | Exemple             |
-|---------------|--------------------------------|---------------------|
-| `IP`          | IP locale fixe à attribuer     | `192.168.1.50`      |
-| `Adresse Mac` | Adresse physique de la machine | `5E:FF:56:A2:AF:15` |
-
-Pour plus d'information sur ces sujets, consultez la documentation de votre routeur.

content/2.generalites/1.reseau/2.dns.md

@@ -1,67 +0,0 @@
----
-navigation: true
-title: Zone DNS
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Noms de domaines et zone DNS
-
-::alert{type="info"}
-🎯  __Objectifs :__
-- Comprendre le fonctionnement d'un serveur DNS
-- Comprendre comment modifier une zone DNS
-::
-
-## Introduction
----
-Lorsque vous naviguez sur un site, ou une application, des requêtes sont émises vers un ou des domaines afin d'afficher le contenu de votre page. Votre appareil ne connait pas les adresses IP de ces serveurs à joindre. Pour les connaitre, il va contacter un _serveur de nom_ (Domain Name Server) qui lui va lui répondre avec l'adresse IP la plus à jour pour le domaine de la requête. 
-
-La zone DNS, c'est une sorte de registre avec des panneaux qui redirige vos requêtes vers la bonne destination.
-
-![Picture](/img/global/dns.svg)
-
-## La zone DNS
----
-Lorsque vous réservez un domaine chez votre registrar (cloudflare, ovh...), ce registrar vous attribue une zone DNS que vous pouvez personnaliser.
-
-Vous pouvez rentrer des _enregistrements_ dans cette zone DNS qui permettront d'orienter les requêtes au bon endroit. Vous trouverez [plus d'information ici](https://help.ovhcloud.com/csm/fr-dns-servers-general-information?id=kb_article_view&sysparm_article=KB0051661).
-
-Exemple d'une zone DNS du domaine mondomaine.fr:
-
-```
-@   IN SOA ns1.dns.me. dns.net. (2024051800 86400 3600 3600000 60)
-                 IN NS     ns1.dns.me.
-                 IN NS     ns2.dns.me.
-                 IN A      203.0.113.0
-www              IN CNAME  mondomaine.fr
-sousdomaine      IN CNAME  mondomaine.fr
-```
-
-Dans cet exemple :
-
-- `$TTL 3600` indique aux différents serveurs de noms de la planète que les enregistrement sont valides 1h (et qu'au-delà il faudra rev"rifier).
-- `IN SOA ns1.dns.me. dns.net. (2024051800 86400 3600 3600000 60)` indique que `ns1.dns.me` est le serveur dns principal, et les nombres sont des indications de rafraichissement.
-- `IN NS ns1.dns.me.` et `IN NS ns2.dns.me.` indique que `ns1.dns.me` et `ns2.dns.me` sont des serveurs de noms pour ce domaine.
-- `IN A 203.0.113.0` signifie que `mondomaine.fr` pointe vers l'IP `203.0.113.0`
-- `sousdomaine IN CNAME mondomaine.fr` signifie que `sousdomaine.mondomaine.fr` pointe vers `mondomaine.fr` et donc vers l'IP `203.0.113.0`.
-
-Ainsi, si vous choisissez de pointer le domaine `mondomaine.fr` vers votre serveur, vous pouvez le faire en ajoutant un enregistrement `A` pointant vers l'IP publique de votre serveur.
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention,__ Si votre serveur est chez vous :
-:::
-- l'IP publique est celle de votre box internet. Assurez-vous auprès de votre opérateur que cette IP est fixe ou configurez un [DDNS](https://aws.amazon.com/fr/what-is/dynamic-dns/).
-- assurez-vous d'avoir [redirigé le port 443 vers le port d'écoute de votre serveur](/generalites/reseau/nat).
-::
-
-Et si vous ajoutez un sous-domaine qui doit pointer vers votre serveur, vous pouvez utiliser un enregistrement `CNAME` vers `mondomaine.fr`.
-
-::alert{type="info"}
-:::list{type="info"}
-- __Pourquoi ne pas utiliser un enregistrement `A` pour le sous-domaine ?__ Si votre sous domaine pointe sur le meme serveur que `mondomaine.fr`, il vaut mieux utiliser un enregistrement `CNAME` car en cas de changement d'IP du serveur, il n'y aura aucune autre manipulation à faire.
-:::
-::
-
-La plupart des registrar proposent des interfaces plus lisbles pour modifier ces informations. Renseignez-vous auprès de la documentation de votre registrar.

content/2.generalites/1.reseau/3.samba.md

@@ -1,228 +0,0 @@
----
-navigation: true
-title: Samba
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Samba
-
-Samba est un protocole permettant d'accèder à un dossier situé sur un disque réseau. Il peut être configuré sous Mac, Windows ou Linux.
-
-De nombreux tutorials existent pour configurer Samba sous windows ou sur un NAS type Synology, ici nous nous concentrons sur Debian.
-
-::alert{type="info"}
-🎯 __Objectifs :__
-- Créer un dossier réseau sur une machine distante
-- Accéder au dossier réseau sur notre serveur
-::
-
-![samba](/img/global/smb.svg)
-
-## Partager un dossier réseau
----
-::alert{type="info"}
-:::list{type="info"}
-- Ici, nous allons partager le dossier `/video` d'une machine distant que nous appelerons `machine-distante`. Nous accéderons à ce dossier par la machine nommée `machine-locale`. L'utilisateur de connexion au disque réseau sera `sambauser`.
-:::
-::
-
-
-### Installer le serveur samba
-
-```shell
-sudo apt update && sudo apt upgrade
-sudo apt install samba smbclient cifs-utils
-```
-
-### Créer le dossier `/video`
-
-```shell
-sudo mkdir /video
-```
-
-### Configuration du partage
-
-Ensuite nous allons éditer le fichier `/etc/samba/smb.conf`
-
-::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
-::
-
-```shell
-sudo vim /etc/samba/smb.conf
-```
-
-Localisez la variable `workgroup` puis passez en mode modification en appuyant sur `i` et nommez votre worgroup, par exemple `::::properties workgroup = WORKGROUP`
-
-Puis allez à la fin du fichier et collez la configuration suivante
-
-```properties
-[video]
-   comment = Dossier video
-   path = /video
-   writable = yes
-   guest ok = no
-   valid users = @smbshare
-   force create mode = 770
-   force directory mode = 770
-   inherit permissions = yes
-```
-Appuyez sur `Echap` pour quitter le mode notification puis tapez `:x` et appuyez sur `Entrée` pour sauvegarder et quitter.
-
-### Créer un utilisateur et un groupe pour Samba
-
-Comme nous avons configfuré un partage sécurisé, nous allons devoir créer un utilisateur et un groupe pour pouvoir y accéder à distance.
-
-Creez le groupe.
-```shell
-sudo groupadd smbshare
-```
-
-Nous allons maintenant permettre au groupe d'avoir le controle sur le dossier `/video`.
-
-```shell
-sudo chgrp -R smbshare /video
-```
-
-Et maintenant nous allons donner les permissions nécessaires aux dossiers et fichier hérités.
-
-```shell
-sudo chmod 2775 /video
-```
-
-A présent nous allons ajouter un utilisateur nologin c'est à dire que cet utilisateur ne pourra pas se connecter sur le serveur pour faire des opérations, mais pourra tout de meme se connecter au service samba.
-
-```shell
-sudo useradd -M -s /sbin/nologin sambauser
-```
-
-Puis nous ajoutons l'utilisateur au groupe `sambashare` que nous avons créé précédemment.
-
-
-```shell
-sudo usermod -aG smbshare sambauser
-```
-Et nous allons configurer un mot de passe.
-
-```shell
-sudo smbpasswd -a sambauser
-```
-Et enfin nous allons activer le compte que nous venons de créer.
-
-```shell
-sudo smbpasswd -e sambauser
-```
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ Si vous utilisez un pare-feu, comme ufw, n'oubliez pas d'autoriser les IP des machines qui accéderont à votre dossier partagé :
-:::
-    ```shell
-    sudo ufw allow from ipdelamachine to any app Samba
-::
-
-
-## Accéder à un dossier partagé
----
-::alert{type="info"}
-:::list{type="info"}
-- A présent, nous sommes sur votre `machine-locale` qui nécessite d'accéder au dossier partagé `/video` présent sur la `machine-distante`.
-:::
-::
-
-### Installer les package nécessaires
-
-```shell
-sudo apt update && sudo apt upgrade
-sudo apt install cifs-utils
-```
-### Créer le dossier de destination
-
-Nous allons créer un dossier sur notre serveur sur lequel sera monté le dossier partagé de notre `machine-distante. C'est à dire que dans ce dossier nous retrouverons le contenu du dossier partagé de notre `machine-distante`. Ici nous appellerons ce dossier `/mnt/video`.
-
-```shell
-sudo mkdir /mnt/video
-```
-
-### Préparer le fichier .credentials
-
-Afin de ne pas avoir systématiquement à rentrer notre utilisateur et mot de passe, nous allons créer un fichier .credentials` stockant ces informations.
-
-Nous allons le créer dans le dossier `/smb`.
-
-```shell
-sudo mkdir /smb
-sudo vi /smb/.credentials
-```
-Passez en mode modification en appuyant sur `i` et configurez comme suit :
-
-```properties
-username=smbuser
-password=motdepasse
-```
-
-- `smbuser` : L'utilisateur que nous avons configuré sur la `machine-distante`
-- `motdepasse` : Le mot de passe que nous avons configuré sur la `machine-distante`
-
-Appuyez sur `Echap` afin de quitter le mode modification, puis tapez `:x` et appuyez sur `Entrée` pour sauvegarder et quitter.
-
-Nous allons modifier les permissions du dossier afin que seul le propriétaire puis lire et écrire dans ce fichier.
-
-```shell
-sudo chmod 600 /smb/.credentials
-```
-
-### Monter le dossier partager
-
-A présent nous allons monter le dossier.
-
-```shell
-sudo mount -t cifs -o credentials=/smb/.credentials //ip-machine-distante/video /mnt/video
-```
-
-Remplacez `ip-machine-distante` par l'adresse IP de votre `machine-distante`
-
-Vérifiez que cela a fonctionné en tapant :
-
-```shell
-sudo mount -t cifs
-```
-Vous verrez différentes informations qui confirmerons le succès du montage.
-
-Et voilà, à présent vous accédez au dossier /video de `votre machine-distante`, depuis votre `machine-locale` !
-
-### Automatiser le montage au boot
-
-Par défaut, les dossiers pattagés ne sont pas connectés automatiquement au redémarrage. Pour autoamtiser cet aspect, nous allons modifier le fichier `/etc/fstab`.
-
-D'abord, sauvegardons notre fichier `fstab`.
-
-```shell
-sudo cp /etc/fstab /etc/fstab.bak
-```
-
-Puis nous allons ajouter une ligne à la fin du fichier comportant les informations de montages dans le fichier `fstab`.
-
-```shell
-sudo echo //ip-machine-distante/video    /mnt/video  cifs   _netdev,nofail,credentials=/smb/.credentials,x-systemd.automount,x-systemd.device-timeout=15 0 0 >> /etc/fstab
-```
-
-Redémarrez.
-
-```shell
-sudo reboot
-```
-
-Une fois redémarré, vérifiez que le montage est correct
-
-```shell
-sudo mount -t cifs
-```
-
-Et voilà !
-
-### Démonter le dossier partagé
-
-```shell
-sudo umount -t cifs /mnt/video
-```

content/2.generalites/1.reseau/_dir.yml

@@ -1,2 +0,0 @@
-navigation.title: Réseau
-icon: lucide:network

content/2.generalites/2.stockage/1.raid.md

@@ -1,117 +0,0 @@
----
-navigation: true
-title: RAID
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# RAID
-
-_Redundant Array of Independent Disks_
-
-::alert{type="info"}
-🎯 __Objectifs :__
-- Comprendre ce qu'est un système RAID
-- Comprendre quel type de RAID est adapté aux différents usages
-::
-
-En informatique, le RAID (Redundant Array of Independent Disks) est un système permettant de combiner plusieurs disques durs pour améliorer les performances et/ou la fiabilité. Il fonctionne en restructurant et en répartissant les blocs de données entre les disques.
-
-À l’origine, les systèmes RAID étaient matériels, ce qui signifiait qu’un contrôleur dédié (une puce spécifique) gérait la distribution des données et les opérations RAID. Aujourd’hui, la plupart des systèmes RAID (ou équivalents) sont logiciels. En fait, de nombreuses technologies logicielles peuvent créer des systèmes de type RAID avec des fonctionnalités indisponibles dans les RAID matériels, comme la réparation automatique (data scrubbing), les instantanés (snapshots), etc.
-
-## Différents types de RAID
-
-Il existe plusieurs types de RAID, chacun ayant ses avantages et inconvénients. Les facteurs qui les influencent sont les suivants :
-
-- Nombre de disques
-- Capacité totale de stockage
-- Vitesse de lecture
-- Vitesse d’écriture
-- Tolérance aux pannes (résistance aux défaillances matérielles)
-
-::alert{type="warning"}
-:::list{type="warning"}
-  - Le RAID n’est pas un système de sauvegarde mais un système de continuité de service ! Il permet seulement le remplacement à chaud des disques sans interruption du serveur ou restauration depuis une sauvegarde. Vous avez toujours besoin d’un système de sauvegarde externe.
-:::
-::
-
-### Sans RAID
----
-
-<div style="display: flex; align-items: center;">
-  <img src="/fr/img/global/no-raid.svg" alt="Image" style="max-width: 30%; max-height:230px; margin-right: 20px;">
-  <ul>
-    <li>Vos disques sans RAID. Les données sont stockées disque par disque.</li>
-    <li>Si vous perdez un disque, seules ses données sont perdues.</li>
-    <li>La capacité totale est la somme de tous les disques.</li>
-</div>
-
-Utilisez vos disques sans RAID si vous n’avez pas peur de perdre des données et pouvez tolérer une interruption de service entre la panne et la restauration.
-
-### RAID 0
----
-
-<div style="display: flex; align-items: center;">
-  <img src="/fr/img/global/raid0.svg" alt="Image" style="max-width: 30%; max-height:230px; margin-right: 20px;">
-  <ul>
-    <li>Le système voit un seul disque.</li>
-    <li>Les données sont entrelacées entre tous les disques.</li>
-    <li>Si un disque est perdu, toutes les données le sont.</li>
-    <li>Excellentes performances en lecture et écriture (multipliées par le nombre de disques).</li>
-    <li>La capacité totale est la somme de tous les disques.</li>
-    <li>Minimum de 2 disques requis.</li>
-</div>
-
-Utilisez RAID 0 si vous souhaitez privilégier la performance et que la perte de données n’est pas un problème. Idéal pour le stockage temporaire à haute vitesse (montage vidéo, IA, etc). Pas adapté au stockage à long terme.
-
-### RAID 1
----
-
-<div style="display: flex; align-items: center;">
-  <img src="/fr/img/global/raid1.svg" alt="Image" style="max-width: 30%; max-height:230px; margin-right: 20px;">
-  <ul>
-    <li>Le système voit un seul disque.</li>
-    <li>Tous les disques contiennent les mêmes données.</li>
-    <li>Vous pouvez perdre tous les disques tant qu'un seul est en bonne santé.</li>
-    <li>Vitesse de lecture améliorée (selon le nombre de disques).</li>
-    <li>Capacité totale égale à un seul disque (ex. : 2×10 To = 10 To).</li>
-    <li>Minimum de 2 disques requis.</li>
-</div>
-
-Utilisez RAID 1 pour une redondance maximale. Chaque disque contient toutes les données, donc les performances ne sont pas affectées en cas de panne. Une fois les disques remplacés, les données sont rapidement restaurées. Mais la capacité utilisable est limitée à un seul disque, ce qui en fait une solution coûteuse.
-
-::alert{type="success"}
-:::list{type="success"}
-- __Astuce :__ Vous pouvez combiner le RAID 1 avec d’autres types de RAID pour créer des grappes miroir.
-:::
-::
-
-### RAID 5
----
-<p align="center">
-  <img src="/fr/img/global/raid5.svg" alt="Image" style="max-width: 40%; margin-right: 20px;">
-</p>
-
-- Le système voit un seul disque.
-- Les données sont entrelacées avec des blocs de parité.
-- Vous pouvez perdre un disque et récupérer les données.
-- Vitesse de lecture améliorée (selon le nombre de disques).
-- Capacité totale = somme des disques – 1 (ex. : 3×10 To = 20 To).
-- Minimum de 3 disques (4 recommandés pour limiter la perte de capacité).
-
-Utilisez RAID 5 pour un stockage fiable avec 3 à 5 disques et une perte minimale d’espace. Il tolère une panne, mais la reconstruction peut durer plusieurs jours avec des performances dégradées.
-
-### RAID 6
----
-<p align="center">
-  <img src="/fr/img/global/raid6.svg" alt="Image" style="max-width: 50%; margin-right: 20px;">
-</p>
-
-- Le système voit un seul disque.
-- Les données sont entrelacées avec deux blocs de parité.
-- Vous pouvez perdre 2 disques et récupérer les données.
-- Vitesse de lecture améliorée (selon le nombre de disques).
-- Capacité totale = somme des disques – 2 (ex. : 4×10 To = 20 To).
-- Minimum de 4 disques (6 recommandés pour minimiser la perte d’espace).
-
-Utilisez RAID 6 dans les mêmes cas que RAID 5, surtout avec 6 disques ou plus. Plus de disques = plus de risque de panne. RAID 6 vous apportera plus de fiabilité en cas de panne simultanée de deux disques. Il n'y a rien de plus frustrant que de perdre un second disque en pleine reconstruction du remplacement du premier.

content/2.generalites/2.stockage/2.zfs.md

@@ -1,71 +0,0 @@
----
-navigation: true
-title: ZFS
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# ZFS
-
-::alert{type="info"}
-🎯 __Objectifs :__
-- Comprendre ce qu'est ZFS et son utilité
-::
-
-ZFS est populaire dans le monde des serveurs, des NAS (comme FreeNAS / TrueNAS), de la virtualisation, et même chez les particuliers qui veulent un stockage résilient. C'est est un _système de fichier_ (à l'instar de NTFS pour windows, EXT4, FAT32 etc...) mais également un __gestionnaire de volume__ (comme LVM par exemple). Pour le dire (très) rapidement, un gestionnaire de volume arrange l'espace sur des espaces physiques comme un ou plusieurs disques durs, et un gestionnaire de fichier arrange la maniere dont sont organisés les blocs de données dans ces volumes pour écrire, lire et supprimer les données.
-
-
-ZFS dépasse largement les limites des autres systèmes de fichiers, que cela soit en terme de performance ou de fonctionnalité.
-Ce qui nous intéresse le plus :
-- ses fonctionnalités de __gestion des instantanés__ (snaphsot), permettant de rapidement revenir en arrière en cas de problème
-- sa gestion des grappes de disques et [__ses équivalent au RAID__](/generalites/stockage/raid) (Z-Mirror, RAIDZ1, RAIDZ2, RAIDZ3)
-- sa __reconstruction automatique des données corrumpues__ (via le scrubbing)
-- ses performance avec son cache RAM (ZFS ARC)
-- ses notifications en cas d'erreur
-
-## Structure
-
-![](/img/global/zfs.svg)
-
-ZFS dispose d'une structure particulière :
-
-- __vdev__ (virtual device) : une grappe de disques (physiques ou virtuel)
-- __zpool__ : un ensemble de disques physiques ou virtuels en volume simple, Z-mirror ou RAIDZ. Un _zpool_ peut englober plusieurs _vdev_ mais pas l'inverse.
-- __dataset__ : un système de de donnée dans un _zpool_. Chaque dataset peut avoir ses propres options (compression, quotas, permissions, etc.).
-
-Il existe plusieurs types de dataset :
-- __file system__ : un système de fichier, ZFS par défaut, monté comme un volume sans quota de stockage.
-- __zvol__ : un "disque virtuel" avec un quota d'espace, que vous pouvez formater/partitionner comme vous le souhaitez. Il sera utilisable comme un disque physique.
-- __snapshot__ : un état figé d’un autre dataset à un instant donné. Ils peuvent etre créés manuellement ou via des outils de sauvegarde. Ils peuvent etre montés pour parcourir les données dans leur état au moment du snapshot.
-
-## Pourquoi ZFS vs les autres ?
-
-### Intégrité des données
-
-ZFS vérifie automatiquement que les données stockées ne sont pas corrompues. Chaque bloc de données est accompagné d’une empreinte (checksum) qui permet à ZFS de détecter toute altération, même minime. Et s’il y a un problème, il peut souvent le réparer automatiquement, si une copie saine existe ailleurs dans le système.
-
-### RAID intégré
-
-ZFS propose son propre système de gestion de volumes (vdev). Vous pouvez créer un pool de stockage (zpool) en combinant plusieurs disques, un peu comme avec le [RAID](/generalites/stockage/raid) classique, mais de façon plus souple. Par exemple :
-- __Z-mirror__ => equivalent du RAID 1
-- __RAIDZ1__ => équivalent du RAID 5 (tolérance à 1 panne disque)
-- __RAIDZ2__ => équivalent du RAID 6 (tolérance à 2 pannes disque)
-- __RAIDZ3__ => (tolérance à 3 pannes disque)
-
-ZFS gère cela directement, pas besoin de logiciel RAID externe.
-
-::alert{type="info"}
-:::list{type="info"}
-- Consultez [l'article sur le RAID](/generalites/stockage/raid) pour en savoir plus sur la solution qui vous convient.
-:::
-::
-
-### Snapshots et clones
-
-ZFS permet de créer des snapshots, c’est-à-dire des captures instantanées de l’état d’un système de fichiers à un moment donné. Ces snapshots prennent très peu d’espace et peuvent être créés automatiquement et fréquemment. Vous pouvez aussi faire des clones : des copies modifiables d’un snapshot.
-
-### Compression et déduplication
-
-ZFS peut compresser les données à la volée (transparente pour l’utilisateur), ce qui permet d’économiser de l’espace disque. Il propose aussi la déduplication (éliminer les doublons), mais cette fonctionnalité consomme beaucoup de mémoire et n’est pas recommandée pour tous les usages.
-
-Voilà, à présent vous savez pourquoi ZFS est Ze systeme de fichier à déployer sur votre NAS.

content/2.generalites/2.stockage/_dir.yml

@@ -1,2 +0,0 @@
-navigation.title: Stockage
-icon: lucide:hard-drive

content/2.generalites/3.hardware/1.bases.md

@@ -1,153 +0,0 @@
----
-navigation: true
-title: Les bases
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Les bases d'un serveur
-
-::alert{type="info"}
-🎯 __Objectifs :__
-- Comprendre les bases du hardware d'un serveur
-::
-
-![hardware](/img/global/hardware.svg)
-
-Un __serveur__ n'est rien d'autre qu'un ordinateur dédié à des taches particulières, ayant vocation à rester accessible en permanence. En soi, sa structure ne diffère pas d'un ordinateur classique, si ce n'est que selon l'usage cible, on fera évoluer certains composants dans un sens ou dans un autre. Dans cet article, vous trouverez un aide mémoire pour comprendre quels sont les composants essentiels d'un serveur et comprendre leur fonction selon vos usages.
-
-## La carte mère
----
-La __carte mère__ est le socle de votre machine. C'est le composant qui relie tous les autres composants. Elle sert à les faire communiquer et à interagir avec vos périphériques (clavier, souris, etc...). Il faut donc la choisir en fonction de vos besoins en terme d'entrées/sorties (I/O) comme le nombre de ports USB, de ports réseau, leur vitesse, etc... Mais il faut également veiller à sa compatibilité avec les autres composants que vous allez brancher dessus.
-
-Les composants importants à brancher dessus sont :
-- le CPU
-- la RAM
-- le stockage (HDD et/ou SSD)
-- l'eventuel GPU dédié
-
-Il existe plusieurs formats de carte mère grand public :
-- E-ATX : les plus grosses
-- ATX : le standard
-- Micro-ATX : plus petit
-- Mini-ITX : le plus petit
-
-Bien sûr, selon la taille, le nombre de ports et de fonctionnalité diffère. D'autre part, les constructeurs de machines déjà assemblées peuvent aussi profiter de formats plus personnalisés.
-
-## Le CPU
----
-
-<div style="display: flex; align-items: center;">
-  <img src="/img/global/cpu.svg" alt="Image" style="max-width: 25%; max-height:230px; margin-right: 20px;">
-  <p>
-Le <strong>CPU</strong> (Central processor Unit) est la supercalculette de l’ordinateur. Il traite la plupart des tâches logicielles. Aujourd’hui les processeurs comportent plusieurs cœurs, parfois eux même divisé en deux de façon logicielle, afin de mieux répartir la charge de travail et optimiser son fonctionnement. Il nécessite d'etre refroidit avec un dissipateur actif (avec ventilateur) ou passif (sans ventilateur) selon la chaleur qu'iil dégage, et donc selon la puissance en Watt qu'il requiert. Dans le cadre d'un serveur, on veillera donc à le choisir selon les usages que l'on aura. </p>
-</div>
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ N'oubliez pas que pour installer un dissipateur tiers, vous devez vous assurer qu'il soit compatible avec le socket de votre processeur, c'est à dire le socle sur lequel il est installé sur la carte mère, et que vous devez également appliquer de la pate thermique sur le CPU avant d'installer le dissipateur. 
-:::
-::
-
-
-Il faut les juger selon :
-- Leur nombre de coeurs (plus ils en ont, plus il peuvent paralléliser les tâches)
-- La fréquence de ces coeurs en Giga Hertz _Ghz_
-- Leur consommation en Watt _W_
-
-Dans le cadre d'un homelab/NAS sans calcul intensif, aujourd'hui on se dirigera facilement vers les Intel N100/150 (4 coeurs) et N305/N355 (8 coeurs) qui sont des processeurs performants à très faible consommation (rappelez vous que ces machines sont censées tourner H24).
-
-## La RAM
----
-
-<p align="center">
-  <img src="/img/global/ram.svg" alt="Image" style="max-width: 65%; margin-right: 20px;">
-</p>
-
-La __RAM__ (Random Access Memory), est une zone de stockage éphémère ultra rapide utilisée par le CPU (et l'iGPU le cas échéant) pour stocker des informations et calculs le temps de les éxecuter. Elle se vide régulièrement selon les sollicitation et se vide également à chaque extinction de la machine. Plus elle est performante, plus les calculs du processeur sont efficaces.
-
-Elle prend généralement la forme de barettes, à brancher sur la carte mère. Il en existe plusieurs format selon le type de carte mère, et de plusieurs générations (DDR5 de nos jours).
-
-## Le GPU 
----
-
-Le __GPU__ (Graphical Processor Unit) est un processeur dédié aux calculs graphiques, vidéo, et parfois d'intelligence artificielle. Dans le cadre d'un serveur, il aura son utilité pour tout ce qui touche au media center (Streaming de video comme [Plex](/serveex/media/plex) par exemple), mais aussi en terme d'accélération matérielle pour les calculs d'IA comme la reconnaissance faciale ou la recherche sur des photos (comme via [Immich](/serveex/cloud/immich) par exemple).
-
-Selon la puissance requise, on choisira un GPU dédié avec sa propre VRAM (une carte graphique à brancher sur un port PCIe de la carte mère), ou un iGPU, c'est à dire un GPU compris dans le CPU (comme les N100/N150 et N305/N355), qui utilisera la RAM globale de la machine
-
-
-### Le ou les HDD
----
-
-<p align="center">
-  <img src="/img/global/hdd.svg" alt="Image" style="max-width: 50%; margin-right: 20px;">
-</p>
-
-Un __HDD__ (Hard Disk Drive) ou disque dur, est un composant servant à stocker des données. Autrefois, c'etait le stockage standard des machines informatiques. Ils sont constitués d'un ou plusieurs disques superposés en plateau, et de têtes de lecture, presque comme une platine vinyle. Si aujourd'hui on arrive à stocker des quantités extraordinaire de données dans un HDD (jusqu'à 30To soit 30 000 Giga-octet de nos jours pour le grand public), ils sont limités dans leur vitesse de lecture et d'écriture par leur caractère mécaniques. Ils sont également volumineux et très lourds. 
-
-De manière générale, on les privilégiera pour stocker des données qui ne servent pas à des calculs et ne nécessitent pas d'ecriture rapide, comme les media (videos, photos...) ou les cloud drive, stockage d'archives, etc. Ils sont performants dans ces scenario et surtout coutent beaucoup moins cher que des SSD à espace de stockage égal.
-
-::alert{type="success"}
-:::list{type="success"}
-- __Astuce :__ Vous pouvez combiner plusieurs HDD ensemble en [RAID](/generalites/stockage/raid) afin d'accroitre les performances de votre machine.
-:::
-::
-
-Il existe plusieurs formats de HDD : 3.5" et 2.5". De manière générale dans un serveur on privilégiera les 3.5, plus fiables.
-
-
-### Le ou les SSD
----
-
-<p align="center">
-  <img src="/img/global/nvme.svg" alt="Image" style="max-width: 50%; margin-right: 20px;">
-</p>
-
-Un __SSD__ (Solid State Drive) est une petite carte sur laquelle sont soudées des puces de mémoires servant à stocker de l'information. Contrairement à la RAM, ces puces conservent les informations même lorsqu'elles ne sont pas alimentées et donc les conservent après un redémarrage. C'est ce qui sert globalement de stockage pour votre serveur. Contrairement aux HDD, ils ne disposent pas de parties mécaniques, sont très miniaturisés et surtout sont extrêmement rapides, de l'ordre de plusieurs Giga-octets par seconde pour les plus performants. 
-
-On les trouve dans plusieurs formats, aujourd'hui on priviligiera les versions M.2 NVMe, car ce sont les plus petits et plus rapides, et sont devenu un standard sur les cartes mères.
-
-Ils sont en revanche beaucoup plus chers que les disque durs à capacité de stockage égale. Généralement, on y stockera au moins le système d'exploitation de la machine (Operating System ou OS) pour garantir une certaine rapidité d'execution. Dans le cadre d'un serveur, on y stockera aussi si possible les conteneurs type [docker](/serveex/coeur/docker) et les bases de données. De manière générale, toute données dont un a besoin régulièrement et rapidement pour des calculs (site web, applications, etc...).
-
-### La carte réseau
----
-
-Une __carte réseau__ sert à faire communiquer votre machine avec votre réseau (dont internet). Elle est composée d'une puce de controle et d'un ou plusieurs port réseau. Ces ports peuvent dits _ports ethernet_ peuvent être dans plusieurs formats physique et dans plusieurs normes de débit :
-- RJ45 Gigabit ethernet 10/100/1000 : le format standard de prise RJ45 permettant de dialoguer à des débit allant de 10Mbps (soit 0,125Mo/s) à 1000Mbps (soit 125Mo/s)
-- RJ45 2.5G : Même prise, pouvant dialoguer jusqu'à 2,5Gpbs soit 2 500Mbps (donc 312,5Mo/s)
-- RJ45 5G : Même prise, pouvant dialoguer jusqu'à 5Gpbs (donc 625Mo/s)
-- RJ45 10G Base T : Même prise pouvant dialoguer jusqu'à 10Gbs (soit 1,25Go/s)
-- SFP 1G : Prise SFP, généralement utilisée pour la fibre optique, pouvant dialoguer jusqu'à 1Gpbs
-- SFP+ 10G : Prise SFP amélioriée, aussi utilisée pour la fibre optique, pouvant dialoguer jusqu'à 10Gbps.
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ Pensez bien à dimensionner vos appareils réseaux (routeurs, switch, cables...) en fonction du débit que vous souhaitez entre vos appareils. D'autre part, il existe plusieurs normes de cables RJ45 selon la vitesse permise. On privilegiera dans la plupart des cas des cables RJ45 CAT5E, et au delà de 10Gbps, on privilégiera du CAT6A, bien que le CAT5E soit utilisable à ces vitesses à courte distance. Quant à la fibre, c'est tout un sujet (simplex, duplex, transceiver...).
-:::
-::
-
-La carte réseau est généralement directement intégrée à la carte mère, mais vous pouvez utiliser des cartes réseau dédiées comme par USB par exemple ou via un port d'extension PCIe. De manière générale, sur un serveur, on appréciera d'avoir au moins deux ports ethernet afin d'avoir de la redondance en cas de panne.
-
-### Entrées et sorties
----
-
-Les __ports d'entrées et sorties__ (Input/Outpout) sont l'ensemble des ports de la machine permettant d'échanger de l'information avec des appareils externes (écrans, clavier, souris, réseau...). Généralement, sur une carte mère on retrouve le ou les ports réseaux, des ports USB de plusieurs formats et vitesse différentes, un ou plusieurs port vidéo, et des ports audio.
-
-Selon vos usages, vous devrez choisir votre carte mere et ses éventuelles cartes d'extension en fonction de vos besoin à ce niveau.
-
-### L'alimentation
----
-
-__L'alimentation__ est le composant qui permet d'alimenter électriquement les composants de votre machine. Elle se compose d'un cable secteur en entrée, et de plusieurs types de cables en sorties. Ces cables se branchent sur la carte mère et différents périphériques le nécessitant, comme les disques dur, ou certaines cartes graphiques dédiées. L'alimentation se caractérise par sa puissance, en Watt, sa modularité (cables attachés ou détachables), et son rendement, en pourcentage. Comprendre qu'une alimentation de 500W avec un rendement de 80% consommera en fait 625W pour fournir ces 500W.
-
-Une autre caractéristiques des alimentations sont leur format. Il en existe plusieurs standard, comme ATX L pour les plus grandes jusqu'à SFX pour les plus petites. Il en existe aussi des spécifiques aux serveurs rackables, par définition assez plats.
-
-Pour choisir votre alimentation, la convention est d'estimer la puissance electrique demandée par votre machine à usage et de multiplier par deux cette puissance. En effet, le rendement des alimentations se situe environ à 50% de sa charge totale.
-
-### Le boitier
----
-
-<div style="display: flex; align-items: center;">
-  <img src="/img/global/case.svg" alt="Image" style="max-width: 25%; max-height:230px; margin-right: 20px;">
-  <p>Le <strong>boitier</strong> est également un composant essentiel pour votre machine. Il conditionne le refroidissement de cette dernière, avec ses ventilateurs et sa conception gérant les flux d'air, mais aussi le format de votre carte mere, de votre alimentation et de votre éventuel GPU dédié. D'autre part, il conditionne également le nombre de HDD et leur format. Certains boitiers sont dit rackables, c'est à dire qu'ils peuvent etre fixés dans des racks pour des armoires informatiques (baies serveurs). Choisissez consciencieusement votre boitier en fonction de vos besoins.</p>
-</div>

content/2.generalites/3.hardware/2.reseau.md

@@ -1,115 +0,0 @@
----
-navigation: true
-title: Réseau
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Réseau
-
-::alert{type="info"}
-🎯 __Objectifs :__
-- Comprendre les bases du matériel réseau
-::
-
-![hardware](/img/global/hardware-networking.svg)
-
-Un réseau informatique est indissociable du matériel nécessaire à le mettre en place. Le matériel va conditionner les dimension du réseau, les vitesses de communication et les performances du réseau. Dans cet article, nous nous limiterons au réseau les plus simples, composant généralement ceux que l'on peut retrouver chez soi.
-
-## Le routeur
----
-Le __routeur__ est le point central de votre réseau. C'est lui qui dirige les __paquets__, c'est à dire les blocs d'informations qui transitent sur votre réseau, de l'émetteur vers le bon destinataire. Il permet à la fois de conditionner le routage de l'information au sein de votre réseau mais aussi vers ou depuis l'exterieur. Globalement, il fait communiquer les appareils entre eux et avec internet.
-
-Vous avez tous un routeur chez vous, c'est la __box__ de votre _FAI_ (Fournisseur d'Accès à Internet).
-
-Plus généralement, un routeur est composé :
-- d'un port WAN (Wide Area Network) recevant les informations depuis l'internet (ou un réseau de hiérarchie supérieure). Par exemple un port recevant la fibre optique de votre opérateur, ou un port SFP+/RJ45 pour un routeur tiers.
-- d'un switch, c'est à dire d'un hub composé de plusieurs ports __LAN__ (Local Area Network) permettant de connecter plusieurs lignes et appareils à votre routeur. Ils peuvent etre RJ45 ou SFP/SFP+.
-- parfois d'un emetteur/recepteur WiFi
-
-Le routeur peut posséder des capacité de _firewall_, c'est à dire de limiter le traffic d'appareils en particulier, et de _[NAT (Network Adress Translation)](/generalites/reseau/nat)_, c'est à dire de redirection de port. Il possède aussi généralement un _[DHCP (Dynamic Host Configuration Protocol)](/generalites/reseau/nat#le-dhcp)_, servant à attribuer dynamiquement des _adresses IP_ à votre matériel branché au réseau.
-
-Le routeur conditionne directement la vitesse de communication entre vos appareils. En effet, le port WAN conditionne le débit qu'il peut recevoir de la part de votre FAI. Si vous avez un abonnement de 5 Gb/s, il vous faudra un port WAN d'au moins 5 Gb/s. Mais il conditionne également la vitesse de communication entre vos équipements. Si vous avez des appareils qui communiquent à 5 Gb/s, il faudra que la partie _switch_ du routeur disposent de ports 5 Gb/s. Enfin, si vous avez du matériel WiFi 7 et que vous souhaitez profiter de ces débits, il faudra également que votre routeur le supporte. Et dans le cas d'une borne Wifi tierce, n'oubliez pas que son port réseau doit disposer d'un débit au moins égale au WiFi qu'il diffuse, et le routeur également.
-
-Débit internet, nombre d'équipements à brancher, débit WiFi, débit réseau, ce sont quatre points à regarder avec attention lorsque vous souscrivez à une offre avec une box internet ou lorsque vous achetez votre propre routeur.
-
-
-::alert{type="success"}
-✨ __Astuce :__
-Vous pouvez utiliser sans difficulté un routeur tiers pour votre réseau qui remplacera la gestion de votre box internet si celle-ci surpporte le mode _Bridge_. En France seul l'opérateur Free le permet. C'est également possible avec les opérateurs ne disposant pas de ce mode, mais avec de grandes difficultés et sans toutes les fonctionnalités qu'un routeur tiers pourrait vous apporter.
-::
-
-## Le Switch
----
-
-Le __switch__ ou commutateur, est un appareil qui permet de brancher plusieurs appareils au réseau. C'est littéralement un hub, qui se connecte directement au routeur ou à un autre switch, jusqu'au routeur. Il permet d'éviter de saturer toutes les prises switch du routeur, ou de délocaliser le matériel dans une autre pièce, sans tirer un cable par appareil vers le routeur. Un autre cas d'usage est de pouvoir séparer plusieurs réseaux gérés par un meme routeur.
-
-Il en existe globalement de deux types :
-- Les switch non managés, les plus courants. Ils sont plug-n-play, c'est à dire que vous les branchez et tout est réglé tout seul.
-- Les switchs managés. Ils disposent d'une interface de configuration (en ligne de commande ou via une interface web), servant à affiner les règles de routages asservies au routeur. C'est très efficace pour séparer des réseaux virtuels entre vos appareils, mais généralement nécessite beaucoup de temps de configuration et sont moins pratiques à utiliser qu'un simple switch non managé.
-
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ Veillez à bien utiliser un switch avec des ports disposant des débits cohérents avec le matériel de votre réseau 
-:::
-::
-
-## Les cables
----
-
-Les cables sont des composants essentiels de votre réseau. Selon leur type et catégorie, ils limiteront le débit entre vos appareils et nécessitent donc d'etre dimensionnés de manière cohérente avec votre réseau. Ils doivent être compatibles avec les ports de vos apapreils. Pour rappel, voici les normes de ports les plus utilisées:
-- RJ45 Gigabit ethernet 10/100/1000 : le format standard de prise RJ45 permettant de dialoguer à des débit allant de 10Mbps (soit 0,125Mo/s) à 1000Mbps (soit 125Mo/s)
-- RJ45 2.5G : Même prise, pouvant dialoguer jusqu'à 2,5Gpbs soit 2 500Mbps (donc 312,5Mo/s)
-- RJ45 5G : Même prise, pouvant dialoguer jusqu'à 5Gpbs (donc 625Mo/s)
-- RJ45 10G Base T : Même prise pouvant dialoguer jusqu'à 10Gb/s (soit 1,25Go/s)
-- SFP 1G : Prise SFP, généralement utilisée pour la fibre optique, pouvant dialoguer jusqu'à 1Gpbs
-- SFP+ 10G : Prise SFP amélioriée, aussi utilisée pour la fibre optique, pouvant dialoguer jusqu'à 10Gb/s.
-
-
-### Les cables Ethernet
-
-Ces cables en cuivre disposent généralement d'une prise dite `RJ45`. C'est la prise la plus standard du matériel réseau, que vous retrouvez sur vos routeurs et vos switch.
-
-Ils sont définis en plusieurs catégorie, définissant le débit maximal selon la distance :
-
-| Débit    | Type de câble  | Distance max |
-|----------|----------------|--------------|
-| 10 Gb/s   | CAT 6A         | 100 m        |
-|          | CAT 6          | 55 m         |
-|          | CAT 5e         | 30 m         |
-| 5 Gb/s    | CAT 6          | 100 m        |
-|          | CAT 5e         | 30 m         |
-| 2.5 Gb/s  | CAT 5e         | 100 m        |
-| 1 Gb/s    | CAT 5e         | 100 m        |
-| 100 Mbs  | CAT 5          | 100 m        |
-
-Certains de ces cables sont plats, ronds, blindés (à relier à la terre), etc. Choisissez en fonction de votre installation. ce qu'il faut comprendre, c'est que pour relier un appareil qui dispose d'une prise RJ45 ethernet 2.5 Gb/s sur un routeur 2.5G b/s, il faut au moins un cable `CAT 5e`.
-En revanche, si votre appareil est limité à 100 Mb/s, vous n'avez besoin que d'un cable `CAT 5`.
-
-Aujourd'hui, dans les nouvelles construction, la norme est d'installer des cables `CAT 6A` dans les murs. Ainsi, les prises murales sont prêtes à accepter du 10 Gb/s sur 100 m
-
-### Les cables optiques
-Très fins mais très fragile, on commence à les voir de plus en plus dans les installations chez soi. A commencer par le cable opérateur qui est relié entre votre prise fibre et votre box/routeur. Ils ont l'avantage de prendre peu de place, de ne rien consommer comparé à un cable en cuivre qui subit des déperdition d'energie liée à la chauffe, de n'emettre aucun rayonnement (pas besoin de blindage, pas de perturbation du signal) et d'accepter des débits très élevés sur de longue distance.
-
-Pour du réseau local, il faut comprendre qu'il existe plusieurs types de cables fibres, conditionnant le débit selon la distance, et conditionnant le type de `transceiver` à utiliser. En effet, les cables fibres se branchent sur les ports SFP+ de vos appareils, via un petit objet qui traduit le signal lumineux en information électrique, et qui, dans le sens inverse, traduit les informations électrique en signal lumineux.
-
-Globalement, pour du réseau local, on évitera de choisir autre chose qu'un cable multimode OM3 avec prise LC, avec un transceiver LC SFP+ 10G. Cela permet de relier des appareils en 10 Gb/s et est compatible avec la plupart des appareils disposant d'un port SFP+.
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ Veillez à bien utiliser des `transceiver` compatibles avec vos materiels (routeur, switch ou appareil). Il n'existe pas encore de standard absolu, les constructeurs précisent généralement les marques compatibles.
-:::
-::
-
-### Les cables DAC
-Ce sont des cables en cuivre fichés dans des `transceiver`. Ils permettent à deux ports SFP/SFP+ de dialoguer, à courte distance, sans utiliser une fibre plus fragile ou d'adapteteur RJ45. Cependant, ils demandent plus d'énergie, la deperdition dans le cuivre etant non négligeable.
-
-### Les transceiver SFP+
-Il permettent de connecter différents typle de cable à vos ports SFP/SFP+. Il en existe pour fibre optique, pour DAC et pour RJ45.
-
-::alert{type="warning"}
-:::list{type="warning"}
-- Un transceiver RJ45 consommera beaucoup d'energie due à la deperdition naturelle dans le cuivre, et donc génerera beaucoup de chaleur. Il existe des transceiver basse consommation, consommant moins de 2W. De manière peu intuitive, ils sont généralement indiqués pour des cables plus long (80m au lieu de 30m). Ils sont conseillés plutot que ceux indiqués pour les cables plus court car ces derniers dégagent plus de chaleur et demandent plus d'energie, ce qui peut poser des problemes de compatibilité avec votre matériel, et dégrader votre réseau, voir le couper.
-:::
-::

content/2.generalites/_dir.yml

@@ -1,3 +0,0 @@
-icon: noto:open-book
-navigation.title: Généralités
-navigation.redirect: /generalites/reseau/nat

content/3.serveex/1.introduction.md

@@ -6,31 +6,31 @@ main:
   fluid: false
 ---
 :ellipsis{left=0px width=40rem top=10rem blur=140px}
-## Un home lab par un débutant pour les débutants
+## A Home Lab by a Beginner, for Beginners
 
 ![](/img/serveex/serveex-server.svg)  
 
-**Serveex** c'est avant tout un projet personnel visant à héberger chez soi le plus de services possibles du quotidien sans passer par des plateformes propriétaires (Google, Apple, Netflix...). L'idée était d'expérimenter, d'apprendre, et de documenter chaque étape. C'est un projet purement pour la science, et n'a pas vocation à être utilisé en production.
+**Serveex** is primarily a personal project aimed at hosting as many everyday services as possible at home, without relying on proprietary platforms (Google, Apple, Netflix, etc.). The goal was to experiment, learn, and document every step along the way. This is purely a scientific project and is not intended for production use.
 
-Un grand merci à **Nipah**, pour le partage de ses connaissances infinies, et surtout pour sa patience.
+A big thanks to **Nipah** for sharing his infinite knowledge and, above all, for his patience.
 
 ::alert{type="info"}
-**Pré-requis :**
+**Prerequisites:**
 :::list{type="primary"}
-- Posséder [un VPS en ligne](https://www.it-connect.fr/les-serveurs-prives-virtuels-vps-pour-les-debutants/) ou une machine locale : idéalement un mini PC (on trouve des N100 pour 100€), mais fonctionne aussi sur laptop ou [une machine virtuelle](https://openclassrooms.com/fr/courses/2035806-virtualisez-votre-architecture-et-vos-environnements-de-travail/6313946-installez-virtualbox). Les [Freebox Delta/Ultra proposent des machines virtuelles](https://next.ink/3493/machines-virtuelles-et-freebox-delta-comment-heberger-votre-premiere-page-web/).
-- Savoir configurer les [règles NAT d'un routeur et attribuer des baux DHCP](/generalites/reseau/nat)
-- Savoir configurer la [zone DNS d'un nom de domaine](/generalites/reseau/dns)
+- Have [an online VPS](https://www.it-connect.fr/les-serveurs-prives-virtuels-vps-pour-les-debutants/) or a local machine: ideally a mini PC (you can find N100 models for around €100), but it also works on a laptop or [a virtual machine](https://openclassrooms.com/fr/courses/2035806-virtualisez-votre-architecture-et-vos-environnements-de-travail/6313946-installez-virtualbox). The [Freebox Delta/Ultra offer virtual machines](https://next.ink/3493/machines-virtuelles-et-freebox-delta-comment-heberger-votre-premiere-page-web/).
+- Know how to configure [NAT rules on a router and assign DHCP leases](/general/networking/nat)
+- Know how to configure the [DNS zone of a domain name](/general/networking/dns)
 :::
 ::
 
 <p align="center">
 <img src="/img/serveex/serveex.svg" align="center" width="700">
 
-L'objectif étant d'etre facilement déployable et facile à migrer, voici sa structure :
+The goal is to be easily deployable and easy to migrate, so here is its structure:
 
 ::card-grid{grid-template-columns="repeat(2, minmax(0, 1fr));"}
 #title
-Le coeur du serveur
+The Core of the Server
 
 #root
 :ellipsis{left=0px width=40rem top=10rem blur=140px}
@@ -39,36 +39,36 @@ Le coeur du serveur
  
   ::card{icon=logos:debian}
   #title
-  __Système d'exploitation__
+  __Operating System__
   #description
-  [Installer et configurer Debian 12](/serveex/coeur/installation)
+  [Install and configure Debian 12](/serveex/core/installation)
   ::
  
   ::card{icon=logos:docker-icon}
   #title
-  __Moteur de conteneur__
+  __Container Engine__
   #description
-  [Installer Docker](/serveex/coeur/docker)
+  [Install Docker](/serveex/core/docker)
   ::
 
   ::card{icon=carbon:container-registry style="color: rgb(41, 194, 243);" }
   #title
   __Docker GUI__
   #description
-  [Installer et déployer Dockge](/serveex/coeur/docker#installer-dockge-pour-gérer-et-déployer-les-conteneurs)
+  [Install and deploy Dockge](/serveex/core/docker#installer-dockge-pour-gérer-et-déployer-les-conteneurs)
   ::
   
   ::card{icon=noto:globe-showing-americas}
   #title
   __Reverse Proxy__
   #description
-  [Exposez vos services avec SWAG](/serveex/coeur/swag)
+  [Expose your services with SWAG](/serveex/core/swag)
   ::
 ::
 
 ::card-grid
 #title
-La sécurité
+Security
 
 #root
 :ellipsis{left=0px width=40rem top=10rem blur=140px}
@@ -79,21 +79,21 @@ La sécurité
   #title
   __VPN__
   #description
-  [Installer et déployer Wireguard](/serveex/securite/wireguard)
+  [Install and deploy Wireguard](/serveex/security/wireguard)
   ::
  
   ::card{icon=noto:key}
   #title
   __SSO & MFA__
   #description
-  [Installer et déployer Authentik](/serveex/securite/authentik)
+  [Install and deploy Authentik](/serveex/security/authentik)
   ::
 
   ::card{icon=logos:cloudflare-icon}
   #title
   __Zero Trust__
   #description
-  [Installer et déployer Cloudflared](/serveex/securite/cloudflare)
+  [Install and deploy Cloudflared](/serveex/security/cloudflare)
   ::
 ::
 
@@ -108,37 +108,37 @@ Monitoring
  
   ::card{icon=solar:pulse-linear style="color: rgb(99, 222, 144);"}
   #title
-  __Etat des services__
+  __Service Status__
   #description
-  [Installer et déployer Uptime-Kuma](/serveex/monitoring/uptime-kuma)
+  [Install and deploy Uptime-Kuma](/serveex/monitoring/uptime-kuma)
   ::
  
   ::card{icon=lucide:logs style="color: #1AD6FF;"}
   #title
-  __Gestion des logs__
+  __Log Management__
   #description
-  [Installer et déployer Dozzle](/serveex/monitoring/dozzle)
+  [Install and deploy Dozzle](/serveex/monitoring/dozzle)
   ::
 
   ::card{icon=noto:rabbit style="color: #1AD6FF;"}
   #title
-  __Gestion de la connexion__
+  __Connection Management__
   #description
-  [Installer et déployer Speedtest Tracker](/serveex/monitoring/speedtest-tracker)
+  [Install and deploy Speedtest Tracker](/serveex/monitoring/speedtest-tracker)
   ::
 
   ::card{icon=lucide:chart-column-decreasing style="color:rgb(26, 255, 213);"}
   #title
-  __Etat des ressources__
+  __Resource Status__
   #description
-  [Installer et déployer Beszel](/serveex/monitoring/beszel)
+  [Install and deploy Beszel](/serveex/monitoring/beszel)
   ::
 
   ::card{icon=lucide:circle-power style="color:rgb(228, 117, 117);"}
   #title
   __Wake on Lan__
   #description
-  [Installer et déployer UpSnap](/serveex/monitoring/upsnap)
+  [Install and deploy UpSnap](/serveex/monitoring/upsnap)
   ::
 ::
 
@@ -155,14 +155,14 @@ Media
   #title
   __Media__
   #description
-  [Installer et déployer Plex](/serveex/media/plex)
+  [Install and deploy Plex](/serveex/media/plex)
   ::
  
   ::card{icon=cbi:qbittorrent style="color: rgb(#2f67ba);"}
   #title
   __Seedbox__
   #description
-  [Installer et déployer Qbittorrent](/serveex/media/qbittorrent)
+  [Install and deploy Qbittorrent](/serveex/media/qbittorrent)
   ::
 ::
 
@@ -179,20 +179,20 @@ Cloud Drive & Photos
   #title
   __Drive__
   #description
-  [Installer et déployer Nextcloud](/serveex/cloud/nextcloud)
+  [Install and deploy Nextcloud](/serveex/cloud/nextcloud)
   ::
  
   ::card{icon=simple-icons:immich style="color: #ed79b5;"}
   #title
   __Photos__
   #description
-  [Installer et déployer Immich](/serveex/cloud/immich)
+  [Install and deploy Immich](/serveex/cloud/immich)
   ::
 ::
 
 ::card-grid
 #title
-Fichiers & partage
+Files & Sharing
 
 #root
 :ellipsis{left=0px width=40rem top=10rem blur=140px}
@@ -201,24 +201,23 @@ Fichiers & partage
  
   ::card{icon=noto:open-file-folder }
   #title
-  __Explorateur de fichier__
+  __File Explorer__
   #description
-  [Installer et déployer file-browser](/serveex/files/file-browser)
+  [Install and deploy file-browser](/serveex/files/file-browser)
   ::
 
   ::card{icon=carbon:share style="color: #47428e;" }
   #title
-  __Partage__
+  __Sharing__
   #description
-  [Installer et déployer Pingvin](/serveex/files/pingvin)
+  [Install and deploy Pingvin](/serveex/files/pingvin)
   ::
 
 ::
 
-
 ::card-grid
 #title
-Outils de développement
+Development Tools
 
 #root
 :ellipsis{left=0px width=40rem top=10rem blur=140px}
@@ -229,27 +228,27 @@ Outils de développement
   #title
   __Visual Studio Code__
   #description
-  [Installer et déployer code-server](/serveex/development/code-server)
+  [Install and deploy code-server](/serveex/development/code-server)
   ::
  
   ::card{icon=simple-icons:gitea style="color: #9ee773;"}
   #title
   __Git Repository__
   #description
-  [Installer et déployer Gitea](/serveex/development/gitea)
+  [Install and deploy Gitea](/serveex/development/gitea)
   ::
 
   ::card{icon=noto:hammer-and-wrench }
   #title
-  __Outils__
+  __Tools__
   #description
-  [Installer et déployer IT Tools](/serveex/development/it-tools)
+  [Install and deploy IT Tools](/serveex/development/it-tools)
   ::
 ::
 
 ::card-grid
 #title
-Applications utiles
+Useful Applications
 
 #root
 :ellipsis{left=0px width=40rem top=10rem blur=140px}
@@ -258,22 +257,22 @@ Applications utiles
  
   ::card{icon=cbi:adguard style="color: #67b279;"}
   #title
-  __DNS anti-pub et filtres__
+  __Ad-blocking DNS and Filters__
   #description
-  [Installer et déployer Adguard Home](/serveex/apps/adguard)
+  [Install and deploy Adguard Home](/serveex/apps/adguard)
   ::
  
-  ::card{icon=cbi:bitwarden style="color: rgb(25 128 255);"}
+  ::card{icon=cbi:bitwarden style="color: rgb(25 128 255);" }
   #title
-  __Gestionnaire de mots de passe__
+  __Password Manager__
   #description
-  [Installer et déployer Vaultwarden](/serveex/apps/vaultwarden)
+  [Install and deploy Vaultwarden](/serveex/apps/vaultwarden)
   ::
 ::
 
-## A venir
+## Coming Soon
 ---
-- Homepage, pour avoir tout vos services en un coup d'oeil et y accéder facilement
-- Mkdocs pour votre documentation
-- Docus, alternative à Mkdocs
-- UpSnap pour réveiller vos machines à distance
+- Homepage, to have all your services at a glance and access them easily
+- Mkdocs for your documentation
+- Docus, an alternative to Mkdocs
+- UpSnap to remotely wake your machines

content/3.serveex/2.coeur/1.installation.md

@@ -1,76 +0,0 @@
----
-navigation: true
-title: Debian 12
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Debian 12
-::alert{type="info"}
-🎯 __Objectif :__ Installer Debian 12 et les dépendances principales pour avoir un OS pret à l'emploi, joignable en SSH.
-::
-
-![picture](/img/serveex/server.svg)
-
-## Installation
----
-1. [Paramètrage BIOS](https://www.debian.org/releases/stable/i386/ch03s06.fr.html#bios-setup)
-2. [Téléchargement de l'image Debian](https://www.debian.org/download.fr.html)
-3. [USB bootable (Rufus)](https://dev.to/devops2808/how-to-create-bootable-usb-installer-for-debian-12-4f66)
-4. [Installer Debian et configurer SSH](https://www.howtoforge.com/tutorial/debian-minimal-server/)
-5. Installer sudo et ajouter un utilisateur au groupe sudo, pour les privilèges administrateurs
-    Se connecter en root : 
-    ```shell
-    su -
-    ```
-    mettre son mot de passe puis taper :
-    ```shell
-     apt install sudo
-    ```
-    Ajouter l'utilisateur au groupe sudo : 
-    ```shell
-    adduser <nomdutilisateur> sudo
-    ```
-
-    La prochaine fois que l'utilisateur se connectera, il pourra utiliser la commande `sudo` et ainsi executer des commandes avec les privilèges administrateurs.
-
-
-6. [Tout savoir sur la connexion à distance à la console (SSH)](https://www.digitalocean.com/community/tutorials/ssh-essentials-working-with-ssh-servers-clients-and-keys)
-7. Optionnel - [UPS client en cas de coupure](https://www.sindastra.de/p/2078/how-to-connect-linux-server-to-synology-ups-server) / [et aussi](https://www.reddit.com/r/synology/comments/gtkjam/use_synology_nas_as_ups_server_to_safely_power/)
-8. Optionnel - Réveil en cas de coupure de courant -> régler le BIOS S0 state
-9. Optionnel - [Réveiller le serveur à distance (WoW - WoL)](https://dev.to/zakery1369/enable-wake-on-lan-on-debian-4ljd)
-
-## CLI apps à avoir près de soi
----
-Quelques app que vous utiliserez forcément à un moment donné, autant les installer dès le départ
-```shell
- sudo apt update
- sudo apt upgrade
- sudo apt install vim btop ranger git duf neofetch samba cifs-utils tree unzip ufw
-```
-
-En plus :
-
-- [gping](https://www.linode.com/docs/guides/how-to-use-gping-on-linux/) - Outil graphique de ping
-- [lazydocker](https://github.com/jesseduffield/lazydocker) - Gestion de conteneurs docker en CLI
-
-## Fonctions utiles
----
-### Pare-feu
-- [ufw](https://www.zenarmor.com/docs/network-security-tutorials/how-to-set-up-a-firewall-with-ufw-on-debian)
-- [Firewalld](https://linuxcapable.com/how-to-install-firewalld-on-debian-linux/)
-
-### Partage Samba (accès à un disque réseau distant)
-- [Créer et accéder à un partage Samba](/generalites/reseau/samba)
-
-
-### Transfert de fichier via rsync
-
-```shell
-sudo rsync -avhHSP  /source /destination
-```
-::alert{type="info" icon="exclamation-circle"}
-:::list{type="info"}
-- Ajoutez ` --exclude @eaDir`{lang=shell} si la source est un NAS Synology
-:::
-::

content/3.serveex/2.coeur/2.docker.md

@@ -1,176 +0,0 @@
----
-navigation: true
-title: Docker
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Docker
-
-Docker, pour installer des services déployables en quelques secondes, et les manager en quelques commandes/clics.
-
-::alert{type="info"}
-🎯  __Objectifs :__
-- Installer [Docker](https://www.docker.com/)
-- Installer [Dockge](https://github.com/louislam/dockge) pour manager les stacks
-- Installer [Watchtower](https://github.com/containrrr/watchtower) pour mettre à jour les conteneurs
-::
-
-![picture](/img/serveex/docker.svg)
-
-## Installer docker
----
-Installez les repo Docker et la clé GPG
-
-```shell
-# Add Docker's official GPG key:
-sudo apt-get update
-sudo apt-get install ca-certificates curl
-sudo install -m 0755 -d /etc/apt/keyrings
-sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
-sudo chmod a+r /etc/apt/keyrings/docker.asc
-
-# Add the repository to Apt sources:
-echo \
-  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
-  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
-  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
-sudo apt-get update
-```
-Installez les package
-
-```shell
-sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
-```
-Et voilà !
-
-**Plus d'options** [Installer docker pour Debian 12](https://docs.docker.com/engine/install/debian/)
-
-::alert{type="info" icon="exclamation-circle"}
-:::list{type="info"}
-- Dans toute la suite, on part du principe que les stacks sont installées dans le dossier `/docker`, créé grace à la commande :
-:::
-    ```shell
-    sudo mkdir /docker
-::   
-
-## Installer [dockge](https://github.com/louislam/dockge) pour gérer et déployer les conteneurs
----
-[Dockge](https://github.com/louislam/dockge) est un outil web permettant de créer, configurer, lancer et gérer des conteneurs pour Docker. C'est une interface simple, intuitive, qui est plus légère et plus facile pour les débutants que d'utiliser docker en CLI ou Portainer.
-
-![picture](/img/serveex/dockge.png)
-
-### Configuration
-
-Plan des fichiers que nous allons modifier :
-
-```console
-root
-└── docker
-    └── dockge    
-        └── compose.yml
-```
-
-Créez le dossier de la stack :
-
-```shell
-cd /docker
-sudo mkdir dockge
-```
-
-Puis créez le fichier `compose.yml` dans ce dossier avec l'outil vim que vous avez installé préalablement (dans les outils CLI)
-
-```shell
-cd /docker/dockge
-sudo vi compose.yml
-```
-Appuyer sur `i` pour rentrer en modif et copiez-collez ceci.
-
-```yaml
----
-services:
-  dockge:
-    image: louislam/dockge:1
-    restart: unless-stopped
-    container_name: dockge
-    ports:
-      - 3555:5001 # Le port joignable depuis le LAN sera 3555
-
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
-      - /docker/dockge/data:/app/data
-      - /docker:/docker
-    environment:
-      - DOCKGE_STACKS_DIR=/docker
-```
-
-Appuyez sur `Echap` pour quitter le mode modif et tapez `:x` pour enregistrer et quitter
-
-
-Pour lancer le conteneur, tapez :
-
-```shell
-cd /docker/dockge
-sudo docker compose up -d
-```
-Une fois lancé, tapez dans votre navigateur `http://ipduserveur:3555` et vous tomberez sur la page de login.
-
-Plus d'info sur [dockge et comment l'utiliser](https://github.com/louislam/dockge)
-
-Et voilà, vous avez installé docker et un outil facile pour manager vos conteneurs !
-
-## [Watchtower](https://github.com/containrrr/watchtower?tab=readme-ov-file), pour mettre à jour automatiquement les conteneurs
----
-Watchtower est un conteneur qui permet de vérifier les mise à jour et d'installer les nouvelles images sans effort, en ajoutant un simple label dans les fichiers `compose.yml` de vos conteneurs.
-
-### Configuration
-
-- Ouvrez Dockge dans votre navigateur
-- Cliquez sur `compose`
-- Nommez la stack `watchtower`
-- Copiez collez la configuration ci-dessous à la place de la configuration par défaut dans Dockge
-
-```yaml
----
-services:
-  watchtower:
-    container_name: watchtower
-    image: containrrr/watchtower:latest
-    restart: unless-stopped
-    env_file:
-      - .env
-    environment:
-      - TZ=Europe/Paris
-      - WATCHTOWER_SCHEDULE=${SCHEDULE}
-      - WATCHTOWER_LABEL_ENABLE=true # watchtower scan tous les conteneurs qui ont le label com.centurylinklabs.watchtower.enable=true
-      - WATCHTOWER_CLEANUP=true
-      - WATCHTOWER_REMOVE_VOLUMES=true
-      #Notifications Discord - décommenter si utilisé
-      #- WATCHTOWER_NOTIFICATIONS=slack
-      #- WATCHTOWER_NOTIFICATION_SLACK_IDENTIFIER=Watchtower
-      #- WATCHTOWER_NOTIFICATION_SLACK_HOOK_URL=${WH_URL}
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
-```
-
-Puis remplissez les données ci-dessous dans l'encart ".env" de Dockge
-
-```properties
-SCHEDULE=
-WH_URL=
-```
-
-| Propriété               | Valeur                                                              | Exemples                                     |
-|-------------------------|---------------------------------------------------------------------|----------------------------------------------|
-| `SCHEDULE`{lang=properties} | Format cron                                                         | `0 0 6 * * *` (tous les jours à 6h du matin) |
-| `WH_URL`{lang=properties} | URL du webhook de votre serveur Discord - ajouter `/slack` à la fin | `https://serveurdiscord/valeur/slack`        |
-
-
-Pour que Watchtower surveille vos autres conteneurs, ajoutez ceci à vos conteneurs dans leur compose.yml :
-
-```yaml
-labels:
-      - com.centurylinklabs.watchtower.enable=true
-```
-
-Puis relancez les stacks modifiés. Et voilà, vous avez une bonne carcasse pour commencer à installer les services qui vous plaisent !

content/3.serveex/2.coeur/3.swag.md

@@ -1,398 +0,0 @@
----
-navigation: true
-title: SWAG
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# SWAG
-
-::alert{type="info"}
-🎯  __Objectifs :__
-- Installer Swag
-- Activer le SSL
-- Accéder au tableau de bord
-- Configurer le blocage régional
-- Exposer Dockge
-::
-
-[Swag](https://docs.linuxserver.io/general/swag/) est le noyau de ce homelab. C'est un reverse proxy puissant qui permet d'exposer des services sur le net via un ou des noms de domaines, en se chargeant de l'émission des certificats SSL (pour garder des connexions chiffrées), du routage des requêtes et de la sécurisation des accès (par authent HTTP ou par SSO comme Authelia ou Authentik). Toute la doc nécessaire se [situe ici](https://docs.linuxserver.io/general/swag).
-
-::alert{type="warning"}
-:::list{type="warning"}
-- SWAG n'a pour utilité que l'exposition de vos services sur internet. C'est à dire, y accéder via une url publique du type `https://service.mondomaine.fr`. Si vous ne souhaitez pas exposer vos services et plutôt utiliser systématiquement un VPN pour vous connecter à vos services à distance, vous pouvez directement aller [par ici](/serveex/securite/wireguard). 
-:::
-::
-
-Ci-dessous, vous trouverez un exemple, exposant Dockge. Nous installerons SWAG, ainsi que le mod dbip servant à bloquer les connexions en fonction de la géoloc, ainsi que le mod dashboard qui permet de piloter le fonctionnement de swag, fail2ban et la géoloc.
-
-**Principe d'un reverse proxy et application dans notre cas :**
-
-![Picture](/img/serveex/reverse-proxy.svg)
-
-## Installation
----
-
-::alert{type="info" icon="exclamation-circle"}
-:::list{type="info"}
-- Ce tutoriel part du principe que vous avez un nom de domaine qui pointe vers votre serveur, et que votre box a une règle NAT qui redirige le port `443` vers l'adresse IP et le port `443` de votre serveur. Le nom de domaine d'exemple sera `mondomaine.fr`.
-:::
-::
-
-Plan des fichiers que nous allons modifier :
-
-```console
-root
-└── docker
-    └── swag
-        ├── config
-        │   ├── dns-conf
-        │   │   └── ovh.ini
-        │   └── nginx
-        │       ├── dbip.conf
-        │       ├── nginx.conf
-        │       └── proxy-confs
-        │           └── dockge.subdomain.conf      
-        ├── compose.yml
-        └── .env
-```
-
-Ouvrez Dockge dans votre navigateur, cliquez sur `compose`, nommez la stack `swag` et copiez la conf ci-dessous
-
-``` yaml
----
-services:
-  swag:
-    image: lscr.io/linuxserver/swag:latest
-    container_name: swag
-    cap_add:
-      - NET_ADMIN
-    env_file:
-      - .env
-    environment:
-      - TZ=Europe/Paris
-      - URL=${DOMAIN}
-      - EXTRA_DOMAINS=${DOMAINS}
-      - SUBDOMAINS=wildcard # couvre les sous-domaines
-      - VALIDATION=dns
-      - DNSPLUGIN=${PLUGIN}
-      - EMAIL=${EMAIL}
-      - DOCKER_MODS=linuxserver/mods:swag-dbip|linuxserver/mods:swag-dashboard|linuxserver/mods:swag-auto-reload
-    volumes:
-      - /docker/swag/config:/config
-    ports:
-      - 80:80
-      - 443:443
-      - 81:81 # Nécessaire pour le dashboard
-    restart: unless-stopped
-    networks:
-      - swag
-
-networks:
-  swag:
-    name: swag_default
-
-```
-
-::alert{type="success"}
-✨ __Astuce :__
-ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
-    
-    ```yaml
-    services:
-      swag:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
-::
-
-Puis dans le `.env` :
-
-```properties
-DOMAIN=
-DOMAINS=
-EMAIL=
-PLUGIN=
-```
-
-Remplissez comme suit 
-
-| Propriété                | Valeur                                                                    | Exemples              |
-|--------------------------|---------------------------------------------------------------------------|-----------------------|
-| ` DOMAIN`{lang=properties}  | Votre domaine (cela couvre aussi tous les sous-domaines)                  | `mondomaine.fr`       |
-| ` DOMAINS`{lang=properties} | Vos éventuels autres domaines                                             | `monsecondomaine.fr`  |
-| ` EMAIL`{lang=properties}   | Votre email, pour générer le certificat                                   | `votre@email.fr`      |
-| ` PLUGIN`{lang=properties}  | Le plugin pour générer le certificat, lié à votre [fournisseur de zone DNS](https://docs.linuxserver.io/general/swag/) | `ovh`<br>`cloudflare` |
-
-Ici nous partons du principe que votre zone DNS est chez OVH. Déployez la stack une premiere fois. Dans les logs vous verrez qu'il n'arrivera pas à créer de certificat SSL car le fichier ovh.ini renvoi une erreur. Arretez la stack.
-
-En CLI, allez dans le dossier dns-conf et éditez le fichier `ovh.ini` :
-
-::alert{type="success"}
-✨ __Astuce pour les allergiques au terminal :__
-vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
-::
-
-
-```shell
-sudo vi /docker/swag/config/dns-conf/ovh.ini
-```
-
-Voici ce qui s'affiche :
-
-```properties
-# Instructions: https://github.com/certbot/certbot/blob/master/certbot-dns-ovh/certbot_dns_ovh/__init__.py#L20
-# Replace with your values
-dns_ovh_endpoint = ovh-eu
-dns_ovh_application_key = 
-dns_ovh_application_secret = 
-dns_ovh_consumer_key = 
-```
-Authentifiez vous et créez [votre token ici](https://www.ovh.com/auth/?onsuccess=https%3A%2F%2Fwww.ovh.com%2Fauth%2Fapi%2FcreateToken). 
-
-Les permissions à configurer sont les suivantes :
-
-* ``GET /domain/zone/*``
-* ``PUT /domain/zone/*``
-* ``POST /domain/zone/*``
-* ``DELETE /domain/zone/*``
-
-Notez les 3 clés temporairement et renseignez le fichier `ovh.ini`. (avec vim, `i` pour passer en modif, `Echap` quand c'est fini, `:x` pour sauvegarder et quitter)
-
-Sauvegardez et quittez le fichier. 
-
-Configurez aussi swag pour qu'il accède à DBIP, le module de gestion des accès par géolocalisation /Ouvrez le fichier nginx.conf
-
-```shell
-sudo vi /docker/swag/config/nginx/nginx.conf
-```
-
-Et ajoutez la ligne suivante en dessous de la section `http` :
-
-```nginx
-include /config/nginx/dbip.conf
-```
-
-Relancez la stack dans Dockge, cette fois le certificat SSL est bien émis ! Vérifiez dans les logs que le serveur est bien ready.
-
-## Dashboard
----
-Accedez au dashboard via votre réseau local en tapant `http//ipdevotreserveur:81`
-A gauche, vous trouverez la liste des services actuellement "proxied" (aucun pour le moment). A droite, les IP bannies. En-dessous, une liste d'indicateurs. pour le détail, [c'est par ici](https://www.linuxserver.io/blog/introducing-swag-dashboard).
-
-![picture](https://www.linuxserver.io/user/pages/03.blog/introducing-swag-dashboard/example.png)
-
-## DBIP
----
-DBIP permet de bloquer les connexions en fonction des pays. Il s'appuie sur le fichier de config nommé `dbip.conf` dans `/docker/swag/config/nginx`. [Plus d'info ici](https://virtualize.link/secure/).
-
-Dans cet exemple, nous allons le configurer pour bloquer une liste de pays connus pour etre à l'origine de la plupart des connexions malveillantes. Nous allons également configurer une variable au cas où nous souhaiterions permettre au réseau interne du serveur, au réseau local de votre box ainsi qu'à un éventuel vpn en 10.x.x.x de pouvoir accéder à vos services, mais pas directement à internet.
-
-La configuration est activable ou désactivable pour chaque service qui sera proxied (voir exemple de Dockge plus bas).
-
-Ouvrez `dbip.conf` :
-
-```shell
-sudo vi /docker/swag/config/nginx/dbip.conf
-```
-
-Faites vos modifications ([voir documentation](https://github.com/linuxserver/docker-mods/tree/swag-dbip)), ou prenez l'exemple suivant: 
-
-```nginx
-geoip2 /config/geoip2db/dbip-country-lite.mmdb {
-    auto_reload 1w;
-    $geoip2_data_continent_code   continent code;
-    $geoip2_data_country_iso_code country iso_code;
-}
-
-# Country Codes: https://en.wikipedia.org/wiki/ISO_3166-2
-
-map $geoip2_data_country_iso_code $geo-whitelist {
-    # default yes;
-    # Example for whitelisting a country, comment out 'default yes;' above and uncomment 'default no;' and the whitelisted country below
-    default no;
-    FR yes;
-}
-
-map $geoip2_data_country_iso_code $geo-blacklist {
-    default yes;
-    # Example for blacklisting a country, uncomment the blacklisted country below
-    CN no; #China
-    RU no; #Russia
-    HK no; #Hong Kong
-    IN no; #India
-    IR no; #Iran
-    VN no; #Vietnam
-    TR no; #Turkey
-    EG no; #Egypt
-    MX no; #Mexico
-    JP no; #Japan
-    KR no; #South Korea
-    KP no; #North Korea
-    PE no; #Peru
-    BR no; #Brazil
-    UA no; #Ukraine
-    ID no; #Indonesia
-    TH no; #Thailand
- }
-
-geo $lan-ip {
-    default no;
-    10.0.0.0/8 yes;
-    172.16.0.0/12 yes;
-    192.168.0.0/16 yes;
-    127.0.0.1 yes;
-}
-```
-
-Sauvegardez et quittez. Redémarrez la stack.
-
-Dans les fichiers de conf des domaines (section suivante), vous pourrez activer ou désactiver la whitelist ou la blacklist ([voir documentation ici](https://www.forum-nas.fr/threads/tuto-installer-swag-en-docker-reverse-proxy.15057/)). Dans notre cas, la whitelist laisse uniquement passer les requêtes françaises. La blacklist laisse passer tout le monde sauf la liste de pays mentionnée. On utilisera donc la blacklist, sur ce modèle :
-
-```nginx
- server {
-     listen 443 ssl;
-     listen [::]:443 ssl;
-
-     server_name some-app.*;
-     include /config/nginx/ssl.conf;
-     client_max_body_size 0;
-
-     if ($geo-blacklist = no) { return 404; }
-
-     location / {
-```
-
-
-## Exposer Dockge
----
-::alert{type="info"}
-📋 __Prérequis :__ <br/></br>
-Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `dockge.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
-::
-
-Il s'agit maintenant d'exposer Dockge sur internet, afin de pouvoir y accéder et gérer vos conteneurs sans que vous soyez chez vous. Pour cela, nous partons du principe que vous avez configuré un sous domaine `dockge.mondomaine.fr` dans votre zone DNS dont le `CNAME` pointe sur `mondomaine.fr`.
-
-::alert{type="warning"}
-:::list{type="warning"}
-- Dockge n'utilise pas d'authentification multifacteur. Exposer Dockge sur internet pourrait compromettre les machines auxquelles il est relié. Ne le faite que si vous utilisez un systeme d'authentification multifacteur comme [Authentik](/serveex/securite/authentik/). Sinon, n'exposez pas avec SWAG et utilisez plutôt un VPN comme [Wireguard](/serveex/securite/wireguard).
-:::
-::
-
-Ouvrez le fichier dockge.subdomain.conf :
-
-```shell
-sudo vi /docker/swag/config/nginx/proxy-confs/dockge.subdomain.conf
-```
-
-Paramétrez le comme tel :
-
-```nginx
-## Version 2023/12/19
-
-server {
-    listen 443 ssl;
-    listen [::]:443 ssl;
-    
-    # indique que le sous-domaine doit être dirigé
-    server_name dockge.*;  
-
-    include /config/nginx/ssl.conf;
-
-    client_max_body_size 0;
-
-    #if ($lan-ip = yes) { set $geo-whitelist yes; }
-    #if ($geo-whitelist = no) { return 404; }
-    # indique que les pays dans la blacklist sont intedits
-    if ($geo-blacklist = no) { return 404; } 
-
-    # enable for ldap auth (requires ldap-location.conf in the location block)
-    #include /config/nginx/ldap-server.conf;
-
-    # enable for Authelia (requires authelia-location.conf in the location block)
-    #include /config/nginx/authelia-server.conf;
-
-    # enable for Authentik (requires authentik-location.conf in the location block)
-    #include /config/nginx/authentik-server.conf;
-
-    location / {
-        # enable the next two lines for http auth
-        #auth_basic "Restricted";
-        #auth_basic_user_file /config/nginx/.htpasswd;
-
-        # enable for ldap auth (requires ldap-server.conf in the server block)
-        #include /config/nginx/ldap-location.conf;
-
-        # enable for Authelia (requires authelia-server.conf in the server block)
-        #include /config/nginx/authelia-location.conf;
-
-        # enable for Authentik (requires authentik-server.conf in the server block)
-        #include /config/nginx/authentik-location.conf;
-
-        include /config/nginx/proxy.conf;
-        include /config/nginx/resolver.conf;
-        
-        set $upstream_app dockge; # Nom du conteneur
-        set $upstream_port 5001; # Port interne conteneur
-        set $upstream_proto http;
-        proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
-    }
-}
-```
-
-
-Sauvegardez et quittez. La configuration va se mettre à jour en quelques secondes. 
-::alert{type="info"}
-:::list{type="info"}
-- Par défaut, SWAG ne connait pas le nom "dockge". Pour qu'il puisse y accéder, vous devez rajouter le réseau de dockge dans le `compose.yml` de SWAG.
-:::
-::
-
-Rendez-vous sur la stack de SWAG, puis cliquez sur `éditer`, et ajouter le réseau de dockge dans le fichier de conf sur ce modele (les champs `networks`) :
-
-
-```yaml
-services:
-  swag:
-     container_name: #...
-      # ... 
-     networks:           # Relie le conteneur au réseau custom 
-      - dockge           # Nom du réseau déclaré dans la stack
-    
-networks:                # Définit le réseau custom
-  #...
-  dockge:                # Nom du réseau déclaré dans la stack
-    name: dockge_default # Nom véritable du réseau externe
-    external: true       # Précise que c'est un réseau à rechercher en externe
-```
-
-::alert{type="info"}
-:::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de dockge est `dockge_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant `http://ipduserveur:81`.
-:::
-::
-
-Déployez à nouveau la stack de SWAG.
-
-Patientez puis tapez `https://dockge.mondomaine.fr` dans votre navigateur, vous devriez être redirigé vers dockge. Vous pouvez vérifier le statut du service via le dashboard (depuis votre réseau local, http://ipdevotreserveur:81)
-
-
-## Exposer un autre service avec SWAG
----
-Swag dispose de modeles pour la plupart des services connus, nommés `nomduservice.subdomain.conf.sample`. Il vous suffit de créer le sous-domaine dans votre zone DNS chez votre registrar (comme OVH par exemple), de le faire pointer sur votre domaine principale (via un enregistrement CNAME) et de copier en renommant `nomduservice.subdomain.conf.sample` en `nomduservice.subdomain.conf`. 
-
-```shell
-cd /docker/swag/config/proxy-confs
-sudo cp nomduservice.subdomain.conf.sample nomduservice.subdomain.conf
-```
-::alert{type="danger"}
-:::list{type="danger"}
-- __Si le sous domaine n'est pas redirigé correctement__
-:::
-- éditez le fichier et vérifiez notamment le nom du conteneur dans `set $upstream_app nomduconteneur;`{lang=nginx}
-
-- vérifiez que vous avez bien ajouté le réseau du conteneur dans le `compose.yml` de SWAG.
-::
-
-Vous pouvez aussi choisir le sous-domaine en changeant la variable `server_name votresousdomaine.*;`{lang=nginx} et en renommant le fichier `votresousdomaine.subdomain.conf`.

content/3.serveex/2.coeur/_dir.yml

@@ -1,2 +0,0 @@
-navigation.title: Le coeur du serveur
-icon: lucide:server-cog

content/3.serveex/2.core/1.installation.md

@@ -0,0 +1,75 @@
+---
+navigation: true
+title: Debian 12
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Debian 12
+::alert{type="info"}
+🎯 __Goal:__ Install Debian 12 and the main dependencies to have a ready-to-use OS, accessible via SSH.
+::
+
+![picture](/img/serveex/server.svg)
+
+## Installation
+---
+1. [BIOS Setup](https://www.debian.org/releases/stable/i386/ch03s06.fr.html#bios-setup)
+2. [Download Debian Image](https://www.debian.org/download.fr.html)
+3. [Create Bootable USB (Rufus)](https://dev.to/devops2808/how-to-create-bootable-usb-installer-for-debian-12-4f66)
+4. [Install Debian and Set Up SSH](https://www.howtoforge.com/tutorial/debian-minimal-server/)
+5. Install sudo and add a user to the sudo group for administrative privileges.
+    Log in as root:
+    ```shell
+    su -
+    ```
+    Enter your password, then type:
+    ```shell
+    apt install sudo
+    ```
+    Add the user to the sudo group:
+    ```shell
+    adduser <username> sudo
+    ```
+
+    Next time the user logs in, they will be able to use the `sudo` command to execute commands with administrative privileges.
+
+6. [Everything About Remote Console Access (SSH)](https://www.digitalocean.com/community/tutorials/ssh-essentials-working-with-ssh-servers-clients-and-keys)
+7. Optional - [UPS Client in Case of Power Outage](https://www.sindastra.de/p/2078/how-to-connect-linux-server-to-synology-ups-server) / [also here](https://www.reddit.com/r/synology/comments/gtkjam/use_synology_nas_as_ups_server_to_safely_power/)
+8. Optional - Wake up after power outage → configure BIOS S0 state
+9. Optional - [Wake Server Remotely (WoW - WoL)](https://dev.to/zakery1369/enable-wake-on-lan-on-debian-4ljd)
+
+## Must-Have CLI Apps
+---
+Some essential apps you’ll likely need at some point, so might as well install them early:
+```shell
+sudo apt update
+sudo apt upgrade
+sudo apt install vim btop ranger git duf neofetch samba cifs-utils tree unzip ufw
+```
+
+Additionally:
+
+- [gping](https://www.linode.com/docs/guides/how-to-use-gping-on-linux/) - Graphical ping tool
+- [lazydocker](https://github.com/jesseduffield/lazydocker) - CLI Docker container manager
+
+## Useful Features
+---
+### Firewall
+- [ufw](https://www.zenarmor.com/docs/network-security-tutorials/how-to-set-up-a-firewall-with-ufw-on-debian)
+- [Firewalld](https://linuxcapable.com/how-to-install-firewalld-on-debian-linux/)
+
+### Samba Sharing (Access a Remote Network Disk)
+- [Create and Access a Samba Share](/general/networking/samba)
+
+
+### File Transfer via rsync
+
+```shell
+sudo rsync -avhHSP /source /destination
+```
+::alert{type="info" icon="exclamation-circle"}
+:::list{type="info"}
+- Add ` --exclude @eaDir`{lang=shell} if the source is a Synology NAS
+:::
+::

content/3.serveex/2.core/2.docker.md

@@ -0,0 +1,174 @@
+---
+navigation: true
+title: Docker
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Docker
+
+Docker, to install deployable services in seconds and manage them with just a few commands or clicks.
+
+::alert{type="info"}
+🎯  __Goals:__
+- Install [Docker](https://www.docker.com/)
+- Install [Dockge](https://github.com/louislam/dockge) to manage stacks
+- Install [Watchtower](https://github.com/containrrr/watchtower) to update containers
+::
+
+![picture](/img/serveex/docker.svg)
+
+## Install Docker
+---
+Add the Docker repositories and GPG key:
+
+```shell
+# Add Docker's official GPG key:
+sudo apt-get update
+sudo apt-get install ca-certificates curl
+sudo install -m 0755 -d /etc/apt/keyrings
+sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
+sudo chmod a+r /etc/apt/keyrings/docker.asc
+
+# Add the repository to Apt sources:
+echo   "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian   $(. /etc/os-release && echo "$VERSION_CODENAME") stable" |   sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+sudo apt-get update
+```
+
+Install the packages:
+
+```shell
+sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+```
+
+That's it!
+
+**More options:** [Install Docker for Debian 12](https://docs.docker.com/engine/install/debian/)
+
+::alert{type="info" icon="exclamation-circle"}
+:::list{type="info"}
+- From here on, we assume the stacks are installed in the `/docker` folder, created using the command:
+:::
+    ```shell
+    sudo mkdir /docker
+::
+
+## Install [Dockge](https://github.com/louislam/dockge) to manage and deploy containers
+---
+[Dockge](https://github.com/louislam/dockge) is a web tool to create, configure, launch, and manage Docker containers. It's a simple, intuitive interface that’s lighter and easier for beginners than using the CLI or Portainer.
+
+![picture](/img/serveex/dockge.png)
+
+### Configuration
+
+File structure we will create:
+
+```console
+root
+└── docker
+    └── dockge    
+        └── compose.yml
+```
+
+Create the stack folder:
+
+```shell
+cd /docker
+sudo mkdir dockge
+```
+
+Then create the `compose.yml` file in this folder using `vim`:
+
+```shell
+cd /docker/dockge
+sudo vi compose.yml
+```
+Press `i` to enter insert mode and paste the following:
+
+```yaml
+---
+services:
+  dockge:
+    image: louislam/dockge:1
+    restart: unless-stopped
+    container_name: dockge
+    ports:
+      - 3555:5001 # LAN-accessible port will be 3555
+
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - /docker/dockge/data:/app/data
+      - /docker:/docker
+    environment:
+      - DOCKGE_STACKS_DIR=/docker
+```
+
+Press `Esc` and type `:x` to save and exit.
+
+To launch the container:
+
+```shell
+cd /docker/dockge
+sudo docker compose up -d
+```
+
+Then go to `http://yourserverip:3555` in your browser to access the login page.
+
+More info on [Dockge and how to use it](https://github.com/louislam/dockge)
+
+And there you go — Docker and a tool to easily manage your containers are ready!
+
+## [Watchtower](https://github.com/containrrr/watchtower?tab=readme-ov-file), to auto-update containers
+---
+Watchtower is a container that checks for updates and pulls new images automatically, just by adding a label in your containers’ `compose.yml` files.
+
+### Configuration
+
+- Open Dockge in your browser
+- Click `compose`
+- Name the stack `watchtower`
+- Paste the config below into the default config area in Dockge
+
+```yaml
+---
+services:
+  watchtower:
+    container_name: watchtower
+    image: containrrr/watchtower:latest
+    restart: unless-stopped
+    env_file:
+      - .env
+    environment:
+      - TZ=Europe/Paris
+      - WATCHTOWER_SCHEDULE=${SCHEDULE}
+      - WATCHTOWER_LABEL_ENABLE=true
+      - WATCHTOWER_CLEANUP=true
+      - WATCHTOWER_REMOVE_VOLUMES=true
+      # Discord notifications - uncomment if used
+      #- WATCHTOWER_NOTIFICATIONS=slack
+      #- WATCHTOWER_NOTIFICATION_SLACK_IDENTIFIER=Watchtower
+      #- WATCHTOWER_NOTIFICATION_SLACK_HOOK_URL=${WH_URL}
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+```
+
+Then fill in the `.env` section in Dockge with the following:
+
+```properties
+SCHEDULE=
+WH_URL=
+```
+
+| Property       | Value                                                              | Examples                                     |
+|----------------|--------------------------------------------------------------------|----------------------------------------------|
+| `SCHEDULE`     | Cron format                                                        | `0 0 6 * * *` (every day at 6 AM)            |
+| `WH_URL`       | Your Discord webhook URL - append `/slack` at the end              | `https://yourdiscordserver/webhook/slack`   |
+
+To have Watchtower monitor your other containers, add this to their `compose.yml`:
+
+```yaml
+labels:
+  - com.centurylinklabs.watchtower.enable=true
+```
+
+Then restart the modified stacks. And that's it — you now have a solid base to start deploying the services you want!

content/3.serveex/2.core/3.swag.md

@@ -0,0 +1,379 @@
+---
+navigation: true
+title: SWAG
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# SWAG
+
+::alert{type="info"}
+🎯  __Objectives:__
+- Install Swag
+- Enable SSL
+- Access the dashboard
+- Configure regional blocking
+- Expose Dockge
+::
+
+[Swag](https://docs.linuxserver.io/general/swag/) is the core of this homelab. It’s a powerful reverse proxy that allows you to expose services on the internet using domain names, handling SSL certificate issuance (for encrypted connections), request routing, and access security (via HTTP auth or SSO like Authelia or Authentik). All the necessary documentation is [available here](https://docs.linuxserver.io/general/swag).
+
+::alert{type="warning"}
+:::list{type="warning"}
+- SWAG is only useful for exposing your services to the internet—i.e., accessing them via a public URL like `https://service.mydomain.com`. If you don’t want to expose your services and prefer to always use a VPN to connect remotely, you can go [here instead](/serveex/security/wireguard).
+:::
+::
+
+Below is an example exposing Dockge. We will install SWAG along with the dbip mod for geolocation-based blocking, and the dashboard mod for managing swag, fail2ban, and geolocation.
+
+**Reverse proxy principle and its application in our case:**
+
+![Picture](/img/serveex/reverse-proxy.svg)
+
+## Installation
+---
+
+::alert{type="info" icon="exclamation-circle"}
+:::list{type="info"}
+- This tutorial assumes you have a domain name pointing to your server, and that your router has a NAT rule forwarding port `443` to your server's IP and port `443`. The example domain will be `mydomain.com`.
+:::
+::
+
+File structure to be modified:
+
+```console
+root
+└── docker
+    └── swag
+        ├── config
+        │   ├── dns-conf
+        │   │   └── ovh.ini
+        │   └── nginx
+        │       ├── dbip.conf
+        │       ├── nginx.conf
+        │       └── proxy-confs
+        │           └── dockge.subdomain.conf      
+        ├── compose.yml
+        └── .env
+```
+
+Open Dockge in your browser, click on `compose`, name the stack `swag`, and copy the following config:
+
+```yaml
+---
+services:
+  swag:
+    image: lscr.io/linuxserver/swag:latest
+    container_name: swag
+    cap_add:
+      - NET_ADMIN
+    env_file:
+      - .env
+    environment:
+      - TZ=Europe/Paris
+      - URL=${DOMAIN}
+      - EXTRA_DOMAINS=${DOMAINS}
+      - SUBDOMAINS=wildcard
+      - VALIDATION=dns
+      - DNSPLUGIN=${PLUGIN}
+      - EMAIL=${EMAIL}
+      - DOCKER_MODS=linuxserver/mods:swag-dbip|linuxserver/mods:swag-dashboard|linuxserver/mods:swag-auto-reload
+    volumes:
+      - /docker/swag/config:/config
+    ports:
+      - 80:80
+      - 443:443
+      - 81:81
+    restart: unless-stopped
+    networks:
+      - swag
+
+networks:
+  swag:
+    name: swag_default
+```
+
+::alert{type="success"}
+✨ __Tip:__
+Add the watchtower label to each container to enable automatic updates
+
+```yaml
+services:
+  swag:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+```
+::
+
+Then in the `.env` file:
+
+```properties
+DOMAIN=
+DOMAINS=
+EMAIL=
+PLUGIN=
+```
+
+Fill out the variables as follows:
+
+| Property                | Value                                                                     | Examples              |
+|-------------------------|---------------------------------------------------------------------------|-----------------------|
+| `DOMAIN`                | Your domain (covers all subdomains too)                                   | `mydomain.com`        |
+| `DOMAINS`               | Any additional domains                                                     | `myseconddomain.com`  |
+| `EMAIL`                 | Your email for generating the certificate                                 | `your@email.com`      |
+| `PLUGIN`                | Plugin for certificate generation—depends on your [DNS provider](https://docs.linuxserver.io/general/swag/) | `ovh`<br>`cloudflare` |
+
+Assuming your DNS zone is managed by OVH, deploy the stack once. The logs will show a failure in creating the SSL certificate due to a missing `ovh.ini` configuration. Stop the stack.
+
+In CLI, go to the dns-conf folder and edit the `ovh.ini` file:
+
+::alert{type="success"}
+✨ __Tip for terminal-shy users:__
+You can use [File Browser](/serveex/files/file-browser) to browse and edit files instead of using terminal commands.
+::
+
+```shell
+sudo vi /docker/swag/config/dns-conf/ovh.ini
+```
+
+You should see:
+
+```properties
+# Instructions: https://github.com/certbot/certbot/blob/master/certbot-dns-ovh/certbot_dns_ovh/__init__.py#L20
+# Replace with your values
+dns_ovh_endpoint = ovh-eu
+dns_ovh_application_key = 
+dns_ovh_application_secret = 
+dns_ovh_consumer_key = 
+```
+
+Authenticate and create [your token here](https://www.ovh.com/auth/?onsuccess=https%3A%2F%2Fwww.ovh.com%2Fauth%2Fapi%2FcreateToken).
+
+Set the following permissions:
+
+* `GET /domain/zone/*`
+* `PUT /domain/zone/*`
+* `POST /domain/zone/*`
+* `DELETE /domain/zone/*`
+
+Note the 3 keys temporarily and enter them in `ovh.ini`. (In vim, press `i` to edit, `Esc` when done, `:x` to save and exit)
+
+Save and exit the file.
+
+Now configure swag to access DBIP, the geolocation-based access control module. Open the `nginx.conf` file:
+
+```shell
+sudo vi /docker/swag/config/nginx/nginx.conf
+```
+
+Add the following line below the `http` section:
+
+```nginx
+include /config/nginx/dbip.conf;
+```
+
+Restart the stack in Dockge. This time, the SSL certificate should be successfully generated! Check the logs to confirm the server is ready.
+
+## Dashboard
+---
+Access the dashboard locally by going to `http://yourserverip:81`
+On the left, you'll see a list of currently "proxied" services (none yet). On the right, the list of banned IPs. Below, various indicators. For more details, [click here](https://www.linuxserver.io/blog/introducing-swag-dashboard).
+
+![picture](https://www.linuxserver.io/user/pages/03.blog/introducing-swag-dashboard/example.png)
+
+
+## DBIP
+---
+DBIP allows you to block connections based on countries. It relies on the configuration file named `dbip.conf` located in `/docker/swag/config/nginx`. [More info here](https://virtualize.link/secure/).
+
+In this example, we’ll configure it to block a list of countries known to be the source of most malicious traffic. We’ll also configure a variable to allow internal server traffic, your box’s local network, and a potential VPN in the 10.x.x.x range to access your services — but not the open internet.
+
+This configuration can be enabled or disabled per service (see the Dockge example below).
+
+Open `dbip.conf`:
+
+```shell
+sudo vi /docker/swag/config/nginx/dbip.conf
+```
+
+Make your changes ([see documentation](https://github.com/linuxserver/docker-mods/tree/swag-dbip)), or use the following example:
+
+```nginx
+geoip2 /config/geoip2db/dbip-country-lite.mmdb {
+    auto_reload 1w;
+    $geoip2_data_continent_code   continent code;
+    $geoip2_data_country_iso_code country iso_code;
+}
+
+# Country Codes: https://en.wikipedia.org/wiki/ISO_3166-2
+
+map $geoip2_data_country_iso_code $geo-whitelist {
+    default no;
+    FR yes;
+}
+
+map $geoip2_data_country_iso_code $geo-blacklist {
+    default yes;
+    CN no; #China
+    RU no; #Russia
+    HK no; #Hong Kong
+    IN no; #India
+    IR no; #Iran
+    VN no; #Vietnam
+    TR no; #Turkey
+    EG no; #Egypt
+    MX no; #Mexico
+    JP no; #Japan
+    KR no; #South Korea
+    KP no; #North Korea
+    PE no; #Peru
+    BR no; #Brazil
+    UA no; #Ukraine
+    ID no; #Indonesia
+    TH no; #Thailand
+}
+
+geo $lan-ip {
+    default no;
+    10.0.0.0/8 yes;
+    172.16.0.0/12 yes;
+    192.168.0.0/16 yes;
+    127.0.0.1 yes;
+}
+```
+
+Save and close the file. Restart the stack.
+
+In the domain config files (see next section), you can enable or disable the whitelist or blacklist ([see documentation here](https://www.forum-nas.fr/threads/tuto-installer-swag-en-docker-reverse-proxy.15057/)). In our case, the whitelist allows only French requests. The blacklist blocks only the listed countries. We'll use the blacklist, like so:
+
+```nginx
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;
+
+    server_name some-app.*;
+    include /config/nginx/ssl.conf;
+    client_max_body_size 0;
+
+    if ($geo-blacklist = no) { return 404; }
+
+    location / {
+```
+
+## Exposing Dockge
+---
+::alert{type="info"}
+📋 __Prerequisite:__ <br/><br/>
+We assume that you have created a subdomain like `dockge.mydomain.com` in your [DNS zone](/general/networking/dns), with a `CNAME` pointing to `mydomain.com` and — unless you're using [Cloudflare Zero Trust](/serveex/security/cloudflare) — that you've forwarded port `443` from your router to the server's `443` in [your NAT rules](/general/networking/nat).
+::
+
+Now it's time to expose Dockge on the internet so you can access and manage your containers remotely. We assume you've set up the subdomain `dockge.mydomain.com` with a `CNAME` pointing to `mydomain.com`.
+
+::alert{type="warning"}
+:::list{type="warning"}
+- Dockge does not support multi-factor authentication. Exposing it online could compromise all connected machines. Only do this if you're using an MFA solution like [Authentik](/serveex/security/authentik/). Otherwise, don’t expose it with SWAG — use a VPN like [Wireguard](/serveex/security/wireguard) instead.
+:::
+::
+
+Open the `dockge.subdomain.conf` file:
+
+```shell
+sudo vi /docker/swag/config/nginx/proxy-confs/dockge.subdomain.conf
+```
+
+Configure it like this:
+
+```nginx
+## Version 2023/12/19
+
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;
+    
+    server_name dockge.*;  # define the subdomain to redirect
+
+    include /config/nginx/ssl.conf;
+
+    client_max_body_size 0;
+
+    #if ($lan-ip = yes) { set $geo-whitelist yes; }
+    #if ($geo-whitelist = no) { return 404; }
+    if ($geo-blacklist = no) { return 404; } # all countries un blacklist are forbidden
+
+    #include /config/nginx/ldap-server.conf;
+    #include /config/nginx/authelia-server.conf;
+    #include /config/nginx/authentik-server.conf;
+
+    location / {
+        #auth_basic "Restricted";
+        #auth_basic_user_file /config/nginx/.htpasswd;
+
+        #include /config/nginx/ldap-location.conf;
+        #include /config/nginx/authelia-location.conf;
+        #include /config/nginx/authentik-location.conf;
+
+        include /config/nginx/proxy.conf;
+        include /config/nginx/resolver.conf;
+        
+        set $upstream_app dockge; # container name
+        set $upstream_port 5001; # internal container port (not exposed port)
+        set $upstream_proto http;
+        proxy_pass $upstream_proto://$upstream_app:$upstream_port;
+    }
+}
+```
+
+Save and exit. The configuration will update within a few seconds.
+
+::alert{type="info"}
+:::list{type="info"}
+- By default, SWAG doesn’t recognize the name "dockge". You’ll need to add Dockge’s network to SWAG’s `compose.yml`.
+:::
+::
+
+Go to the SWAG stack, click `edit`, and modify the config file like this (note the `networks` section):
+
+```yaml
+services:
+  swag:
+    container_name: #...
+    # ...
+    networks:            # Link the container to the custom network
+      - dockge           # Network name as defined in the stack
+
+networks:                # Define the custom network
+  # ...
+  dockge:                # Network name as defined in the stack
+    name: dockge_default # True external network name
+    external: true
+```
+
+::alert{type="info"}
+:::list{type="info"}
+- We assume the Dockge network is named `dockge_default`. You can verify the setup works by checking the SWAG dashboard at `http://yourserverip:81`.
+:::
+::
+
+Redeploy the SWAG stack.
+
+Wait a moment, then visit `https://dockge.mydomain.com` in your browser — you should be redirected to Dockge. You can also check the service status from the dashboard (`http://yourserverip:81` on your local network).
+
+## Exposing Another Service with SWAG
+---
+SWAG includes templates for most known services, named `servicename.subdomain.conf.sample`. Just create the subdomain in your registrar's DNS zone (like OVH), point it to your main domain via a CNAME, then copy and rename the sample file:
+
+```shell
+cd /docker/swag/config/proxy-confs
+sudo cp servicename.subdomain.conf.sample servicename.subdomain.conf
+```
+
+::alert{type="danger"}
+:::list{type="danger"}
+- __If the subdomain is not redirected properly__
+:::
+- Open the file and verify the container name in `set $upstream_app containername;`{lang=nginx}
+- Make sure you added the container's network in SWAG’s `compose.yml`
+::
+
+You can also customize the subdomain by editing `server_name yoursubdomain.*;`{lang=nginx} and renaming the file to `yoursubdomain.subdomain.conf`.

content/3.serveex/2.core/_dir.yml

@@ -0,0 +1,2 @@
+navigation.title: Server core
+icon: lucide:server-cog

content/3.serveex/3.securite/1.wireguard.md

@@ -1,252 +0,0 @@
----
-navigation: true
-title: Wireguard
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Wireguard
-
-::alert{type="info"}
-🎯 __Objectifs :__
-  - Installer Wireguard
-  - Configurer les clients
-  - Accéder au réseau sécurisé
-::
-
-## Introduction
----
-L'utilisation d'un VPN permet d'accéder à distance aux ressources locales du serveur sans les exposer sur internet. C'est notamment une manière propre de sécuriser l'accès à la console SSH, plutot que d'exposer le port sur internet. C'est pouvoir se connecter à son réseau où que l'on soit, de maniere sécurisée, et de faire dialoguer des machines qui sont sur des réseaux différents.
-
-Ici nous utiliserons [Wireguard](https://www.wireguard.com/), un serveur VPN sécurisé et très performant, à l'aide des conteneurs :
-
-- [wg-easy](https://github.com/wg-easy/wg-easy) pour le serveur, qui propose une interface web très simple pour controler les connexions et télécharger les fichiers de conf (notamment par QR code pour les téléphones)
-- [Wireguard](https://docs.linuxserver.io/images/docker-wireguard/?h=wireguard) pour les clients linux
-
-Il existe aussi des clients Windows, MacOS, iOS et Android.
-
-Le principe est le suivant :
-
-- Sur internet, n'importe qui peut contacter n'importe quel box internet et donc essayer de contacter n'importe quel serveur exposé.
-- Votre serveur est sur votre réseau local. Il est accessible depuis le réseau local mais pas depuis internet, mis à part les services exposés (comme nous l'avons fait avec Dockge). Pour accéder aux ressources non exposées, vous devez être connecté sur le meme réseau que votre serveur et donc etre chez vous. De plus, vous devez laisser ouvert les ports utilisés par vos services à travers le pare feu de votre serveur.
-- Nous souhaitons ici au contraire, depuis n'importe où, pouvoir accéder de maniere securisée aux services non exposés sur internet du serveur, comme la console SSH qui permet de se connecter à la machine par exemple.
-- Nous souhaitons aussi accéder aux services d'autres serveurs, et par exemple relier de maniere sécurisée deux instances de Dockge pour tout controler depuis la meme interface.
-
-Pour cela nous allons créer un **réseau privé virtuel**, ou VPN, c'est à dire un tunnel sécurisé auquel personne n'a accès à part les machines que vous relierez entre elles. Elles feront partie d'un nouveau réseau et pourront dialoguer entre elle comme dans un réseau local. 
-
-D'autre part, vous pourrez ajouter votre téléphone, un ordinateur portable ou n'importe quel appareil au réseau pour pouvoir utiliser vos ressources depuis vos appareils quotidiens, où que vous soyiez.
-
-![picture](/img/serveex/vpn.svg)
-
-Dans cette illustration, la machine 1 est sur deux réseaux :
-
-- son réseau local (tous les appareils liés à la box, avec une adresse IP du type `192.168.x.x ` donc ici la machine 1 et la machine 2)
-- le réseau du VPN (tous les appareils reliés au VPN, avec une seconde adresse IP du type `10.8.x.x` donc ici la machine 1 et 4)
-
-On peut aussi faire en sorte que les machines reliées au réseau virtuel partagent les acces à leur réseau local. Ici nous ne le ferons pas, pour des raisons de sécurité, et de complexité en terme de sous-réseau (si les deux machines distantes ont des machines locales qui utilisent la meme adresse IP locale, par exemple `192.168.1.1`, cela posera des conflits). 
-
-Ainsi, sur le réseau virtuel, seules les machines directement reliées pourront dialoguer entre elle depuis ce réseau. Elles ne pourront pas dialoguer avec une machine situées sur un autre réseau local et non reliée au VPN.
-
-## Côté serveur
----
-::alert{type="info"}
-📋 __A vérifier au préalable :__
-- Vérifiez si le port `51820 UDP` estlibre sur votre serveur, et bien routé dans le NAT de la box `Source 51820 UDP -> Destination 51820 UDP -> Serveur`. En effet, votre serveur étant derrière votre box, le port de votre box doit etre joignable et rediriger vers le port de votre serveur connecté à votre VPN.
-- Vérifiez aussi que le port `51821 TCP` est libre sur le serveur pour accéder à la web ui.
-:: 
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ Cette documentation utilise la version `14` de [wg-easy](https://wg-easy.github.io/wg-easy/latest/). La version `15`comporte des breaking changes qui ne sont pas compatibles avec les configurations proposées ici.
-:::
-::
-
-Structure des dossiers
-
-```console
-root
-└── docker
-    └── wg-easy
-        ├── config
-        │   └── etc_wireguard
-        ├── compose.yaml
-        └── .env
-```
-
-Le conteneur sera en mode `HOST`, c'est à dire qu'il occupera les ports de votre host comme s'il n'etait pas dans un conteneur mais directement installé sur la machine, sans passer par un sous-réseau.
-
-Ouvrez Dockge, cliquez sur `compose` et nommez la stack `wg_easy`.
-
-Copiez la configuration suivante :
-
-```yaml
----
-services:
-  wg-easy:
-    network_mode: host
-    env_file:
-      - .env
-    environment:
-      - LANG=en
-      - WG_HOST=${HOST}
-      - PASSWORD_HASH=${PW}
-      - WG_DEFAULT_ADDRESS=${ADDRESS}
-      - WG_HIDE_KEYS=never
-      - WG_ALLOWED_IPS=${IPS}
-      - WG_DEFAULT_DNS=
-      - UI_TRAFFIC_STATS=true
-      - UI_CHART_TYPE=1
-    image: ghcr.io/wg-easy/wg-easy:14
-    container_name: wg-easy
-    volumes:
-      - /docker/wg_easy/config/etc_wireguard:/etc/wireguard
-    restart: unless-stopped
-    cap_add:
-      - NET_ADMIN
-      - SYS_MODULE
-```
-::alert{type="success"}
-✨ __Astuce :__ 
-- Vous pouvez personnaliser le port de wireguard avec `WG_PORT` au lieu du port par defaut `51820`
-- Ajoutez le label de watchtower afin d'automatiser les mises à jour
-
-    ```yaml
-    services
-      wg-easy:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
-::
-
-Dans  `.env` :
-
-```properties
-HOST=
-PW=
-ADDRESS=
-IPS=
-```
-
-| Variable                  | Valeur                                                                                                                                                                                                                                                                                                                                                                                                                                    | Exemples      |
-|---------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------|
-| `HOST`{lang=properties}    | IP publique de votre box internet (elle doit etre fixe)                                                                                                                                                                                                                                                                                                                                                                                                                        | `80.72.136.27` |
-| `PW`{lang=properties}      | Hash du mot de passe, [à générer ici](https://bcrypt-generator.com/). **ATTENTION:** doubler les `$`                                                                                                                                                                                                                                                                                                                                                                      | `$$2a$$12$$FF6T4QqSP9Ho`|
-| `ADDRESS`{lang=properties} | Plage d'adresse que le DHCP du VPN peut attribuer, le `x` doit etre présent, on peut changer les autres chiffres ou les remplacer par `x` aussi                                                                                                                                                                                                                                                                                           | `10.8.0.x`      |
-| `IPS`{lang=properties}     | les IPs qui doivent etre routées par les clients vers le VPN. Dans notre cas, on veut que seul le traffic vers le serveur et clients du VPN soit routé, on veut pas de leurs réseau local et on veut conserver l'accès à internet direct sans passer par le VPN.Si vous voulez tout de meme ajouter toutes les machines connectées aux appareils en local, ajoutez la plage `192.168.0.0/16` en séparant les deux plages par une virgule. | `10.8.0.0/24`   |
-
-
-Puis déployez la stack.
-
-### Activation du forwarding depuis l'host
-
-Pour que l'host autorise les clients à communiquer entre eux, vous devez activer les paramèttres suivants :
-
-```shell
-sudo sysctl net.ipv4.ip_forward=1
-sudo sysctl net.ipv4.conf.all.src_valid_mark=1
-```
-
-### Recuperation des fichiers de conf
-
-Afin de configurer les clients, vous devez télécharger les fichiers de conf générés par l'host :
-
-- Connectez vous via le web en local sur `http://ipduserveur:51821`
-- Créez un client
-- Téléchargez le fichier de conf
-- Renommez le en `wg0.conf`
-
-::alert{type="danger"}
-:::list{type="danger"}
-- En cas d'échec, vérifiez les règles du pare-feu.
-:::
-::
-
-## Sur le serveur client
----
-::alert{type="info"}
-:::list{type="info"}
-- Nous partons du principe que le serveur client est un serveur linux avec Docker installé
-:::
-::
-
-Structure des dossiers
-
-```console
-root
-└── docker
-    └── wireguard
-        └── config
-        │   └── wg_confs
-        └── compose.yaml
-```
-
-Creez le dossier `/docker/wireguard/config/wg_confs`.
-
-::alert{type="success"}
-✨ __Astuce pour les allergiques au terminal :__
-vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
-::
-
-```shell
-sudo mkdir -p /docker/wireguard/config/wg_confs
-```
-
-Copiez le fichier` wg0.conf` téléchargé précédemment. 
-
-::alert{type="success"}
-✨ __Astuce :__ Le moyen le plus simple est de transférer le fichier par sftp dans le dossier `/home/nomdutilisateur` puis de le copier dans le bon dossier :
-
-    ```shell
-    sudo cp ~/wg0.conf /docker/wireguard/config/wg_confs
-
-::
-
-Creez le `compose.yaml` dans `/docker/wireguard `:
-```shell
-sudo vi /docker/wireguard/compose.yaml
-```
-Appuyez sur `i` pour rentrer en modification et copiez la configuration ci-dessous
-```yaml
-services:
-  wireguard:
-    image: lscr.io/linuxserver/wireguard:latest
-    container_name: wireguard
-    network_mode: host
-    cap_add:
-      - NET_ADMIN
-      - SYS_MODULE #optional
-    environment:
-      - TZ=Europe/Paris
-    volumes:
-      - /docker/wireguard/config:/config
-      - /lib/modules:/lib/modules #optional
-    restart: unless-stopped
-```
-
-Appuyez sur `Echap` puis tapez `:x` pour quitter et sauvegarder.
-
-Lancez le conteneur :
-```shell
-cd /docker/wireguard
-sudo docker compose up -d
-```
-::alert{type="info" icon="exclamation-circle"}
-:::list{type="info"}
-- A répéter pour chaque client
-:::
-::
-
-## Autres appareils
----
-- **Téléphone :** installer wireguard et scanner le QR code via le webui (http://ipduserveur:51821)
-- **PC :** Installer wireguard client et mettre directement le fichier de conf téléchargé via le webui
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ Si des machines clientes sont sur le meme réseau local que le serveur (derriere la box), éditez le fichier `wg0.conf` uploadé sur cette machine en changeant avec l'adresse locale du serveur : `Endpoint = ipduserveur:51820`{lang=properties}
-:::
-::
-
-Et voilà ce que cela peut donner !
-
-![picture](/img/serveex/wireguard.svg)

content/3.serveex/3.securite/2.authentik.md

@@ -1,586 +0,0 @@
----
-navigation: true
-title: Authentik
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Authentik
-
-::alert{type="info"}
-🎯 __Objectifs :__
-- Installer et exposer Authentik
-- Paramétrer le Multi-Facteur
-- Protéger une app native ou via reverse proxy
-::
-
-[Authentik](https://goauthentik.io) est un outil d'authentification unique permettant de vous logger une seule fois sur les plateformes compatibles OpenID. Il permet également de sécuriser l'accès aux services que vous exposez, en s'injectant via SWAG aux requetes vers vos services. 
-
-Ainsi, si vous exposez Dockge sur internet via `dockge.mondomaine.fr`, au moment de l'accès à cette page, vous tomberez sur une page de login d'authentik. Si vous avez déjà été identifié sur un autre service sécurisé par authentik auparavant, alors vous serez déjà identifié. cela permet d'avoir à vous identifiez qu'une seule fois par jour sur l'ensemble des services protégés par authentik.
-
-Authentik permet aussi d'utiliser le multi-facteur, notamment par TOTP (code généré par une application d'authentification de votre choix. Enfin, authentik permet aussi de se connecter directement via un compte Microsoft ou Google, si vous avez configuré une application d'un de ces services.
-
-C'est une bonne manière de se passer de VPN pour exposer vos services, et d'exposer des services qui ne sont pas protégés par du MFA voir pas protégés par des login (comme le dashboard de swag). 
-
-Authentik dipose d'[une doc très fournie](https://docs.goauthentik.io/docs/installation/docker-compose) et des [fabuleux tuto de Cooptonian](https://www.youtube.com/@cooptonian). Ici, nous montrerons juste les bases, avec l'exemple de l'exposition de Dockge.
-
-Deux modes principaux sont à connaitre: 
-
-- Le premier permet à une application qui dispose nativement d'une intégration avec du SSO compatible OpenID de se connecter directement à Authentik. C'est la solution à privilégier car elle permet de laisser l'application décider de ce qui est public et de ce qui est protégé.
-
-![Picture](/img/serveex/auth-native.svg)
-
-- Le second permet d'injecter une authentification via authentik grace à SWAG avant d'arriver sur le service désiré.
-
-![Picture](/img/serveex/auth-proxy.svg)
-
-Les deux modes son configurables application par application.
-
-
-
-## Installation
----
-Structure des dossiers :
-```console
-root
-└── docker
-    └── authentik
-        ├── .env
-        ├── compose.yml
-        ├── media
-        ├── certs
-        ├── custom-template
-        └── ssh
-```
-
-Créez les dossiers : 
-
-```shell
-sudo mkdir -p /docker/authentik/media /docker/authentik/certs /docker/authentik/custom-template /docker/authentik/ssh
-```
-
-Positionnez vous dans le dossier `authentik` et générez un mot de passe et une clé secrete que l'on va intégrer dans le .env :
-
-```shell
-sudo echo "PG_PASS=$(openssl rand 36 | base64)" >> .env
-sudo echo "AUTHENTIK_SECRET_KEY=$(openssl rand 60 | base64)" >> .env
-```
-::alert{type="info"}
-:::list{type="info"}
-- Afin de générer la clé, nous avons créé les dossiers en amont du déploiement via Dockge. Dockge vous empechera de créer une stack du meme nom dans ces dossiers s'il n'existe pas de `compose.yml`. Il faut donc créer un `compose.yml` vide afin que ce dernier la reconnaisse comme existante dans les stacks inactives :
-:::
-    ```shell
-    sudo vi /docker/authentik/compose.yml
-::
-
-Ouvrez dockge, et cherchez "authentik" dans les stack inactives.
-Nommez la stack authentik et collez la configuration suivante, en changeant les chiffres de `{AUTHENTIK_TAG:-2025.6.3}`{lang=properties} par [la dernière version de Authentik](https://goauthentik.io/docs/releases). 
-
-```yaml
----
-services:
-
-  postgresql:
-    image: docker.io/library/postgres:16-alpine
-    container_name: authentik-postgresql
-    restart: unless-stopped
-    healthcheck:
-      test:
-        - CMD-SHELL
-        - pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}
-      start_period: 20s
-      interval: 30s
-      retries: 5
-      timeout: 5s
-    volumes:
-      - database:/var/lib/postgresql/data
-    environment:
-      POSTGRES_PASSWORD: ${PG_PASS:?database password required}
-      POSTGRES_USER: ${PG_USER:-authentik}
-      POSTGRES_DB: ${PG_DB:-authentik}
-    env_file:
-      - .env
-
-  redis:
-    image: docker.io/library/redis:alpine
-    container_name: authentik-redis
-    command: --save 60 1 --loglevel warning
-    restart: unless-stopped
-    healthcheck:
-      test:
-        - CMD-SHELL
-        - redis-cli ping | grep PONG
-      start_period: 20s
-      interval: 30s
-      retries: 5
-      timeout: 3s
-    volumes:
-      - redis:/data
-  
-  server:
-    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.2.1}
-    container_name: authentik-server
-    restart: unless-stopped
-    command: server
-    environment:
-      AUTHENTIK_REDIS__HOST: redis
-      AUTHENTIK_POSTGRESQL__HOST: postgresql
-      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
-      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
-      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
-    volumes:
-      - ./media:/media
-      - ./custom-templates:/templates
-      - ./ssh:/authentik/.ssh
-    env_file:
-      - .env
-    ports:
-      - ${COMPOSE_PORT_HTTP:-9000}:9000
-      - ${COMPOSE_PORT_HTTPS:-9443}:9443
-    depends_on:
-      - postgresql
-      - redis
-
-  worker:
-    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.2.1}
-    container_name: authentik-worker
-    restart: unless-stopped
-    command: worker
-    environment:
-      AUTHENTIK_REDIS__HOST: redis
-      AUTHENTIK_POSTGRESQL__HOST: postgresql
-      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
-      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
-      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
-    # `user: root` and the docker socket volume are optional.
-    # See more for the docker socket integration here:
-    # https://goauthentik.io/docs/outposts/integrations/docker
-    # Removing `user: root` also prevents the worker from fixing the permissions
-    # on the mounted folders, so when removing this make sure the folders have the correct UID/GID
-    # (1000:1000 by default)
-    user: root
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
-      - ./media:/media
-      - ./certs:/certs
-      - ./custom-templates:/templates
-      - ./ssh:/authentik/.ssh
-    env_file:
-      - .env
-    depends_on:
-      - postgresql
-      - redis
-
-volumes:
-  database:
-    driver: local
-  redis:
-    driver: local
-```
-
-Dans le point `.env`, les variables `PG_PASS` et `AUTHENTIK_SECRET_KEY` sont déjà remplies.
-Déployez la stack.
-
-Vous pouvez alors commencer le set-up d'authentik en tappant `http://ipduserveur:9000/if/flow/initial-setup/`.
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__ il est conseillé de créer un nouveau compte admin, et de **désactiver** le compte admin de base `akadmin`.
-:::
-::
-
-## Exposer authentik
----
-Pour être utilisable hors de chez vous, vous devez exposer authentik.
-
-::alert{type="info"}
-📋 __Au préalable :__  <br/><br/>
-Nous partons du principe quer vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `auth.mondomaine.fr` avec pour CNAME `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
-::
-
-Ouvrez le fichier `authentik-server.conf`.
-
-::alert{type="success"}
-✨ __Astuce pour les allergiques au terminal :__
-vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
-::
-
-```shell
-sudo vi /docker/swag/config/nginx/authentik-server.conf
-```
-
-Vérifiez que dans chaque cas les variables ci-dessous sont correctes :
-
-```nginx
-set $upstream_authentik authentik-server;
-proxy_pass http://$upstream_authentik:9000;
-```
-
-Si ce n'est pas le cas, passez en mode modification en tapant `i` et éditez les. Sauvegardez et quittez en tapant sur `Echap` puis `:x`.
-
-Créez le fichier `auth.subdomain.conf`
-
-```shell
-sudo vi /docker/swag/config/nginx/proxy-confs/auth.subdomain.conf
-
-```
-
-Appuyez sur `i` pour rentrer en mode modification puis collez la configuration suivante :
-
-```nginx
-## Version 2023/05/31
-# make sure that your authentik container is named authentik-server
-# make sure that your dns has a cname set for authentik
-
-server {
-    listen 443 ssl;
-    listen [::]:443 ssl;
-
-    server_name auth.*;
-
-    include /config/nginx/ssl.conf;
-
-    client_max_body_size 0;
-
-    location / {
-
-        include /config/nginx/proxy.conf;
-        include /config/nginx/resolver.conf;
-        set $upstream_app authentik-server;
-        set $upstream_port 9000;
-        set $upstream_proto http;
-        proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
-    }
-
-    location ~ (/authentik)?/api {
-        include /config/nginx/proxy.conf;
-        include /config/nginx/resolver.conf;
-        set $upstream_app authentik-server;
-        set $upstream_port 9000;
-        set $upstream_proto http;
-        proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
-    }
-}
-```
-
-Sauvegardez et quittez en appuyant sur `Echap` puis en tapant `:x`.
-
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau d'Authentik :
-
-```yaml
-services:
-  swag:
-     container_name: # ...
-      # ... 
-     networks:               # Relie le conteneur au réseau custom 
-      # ...           
-      - authentik            # Nom du réseau déclaré dans la stack
-    
-networks:                    # Définit le réseau custom
-  # ...
-  authentik:                 # Nom du réseau déclaré dans la stack
-    name: authentik_default  # Nom véritable du réseau externe
-    external: true           # Précise que c'est un réseau à rechercher en externe
-```
-
-Relancez la stack et patientez le temps que SWAG soit complètement opérationnel.
-
-Et voilà ! Vous pouvez accéder à authentik via `https://auth.mondomaine.fr`
-
-## Activer le multifacteur
----
-Tout l'intérêt de authentik c'est de disposer du multifacteur pour toutes les apps que l'on protègera.
- 
-- Rendez vous sur `https://auth.mondomaine.fr`
-- Identifiez-vous
-- Rendez-vous dans _paramètres_
-- Cliquez sur la section _MFA_
-- Cliquez sur _s'inscrire_
-- Choisissez une méthode comme _TOTP device_ ( dans ce cas vous devrez utilisez une app d'authentification telle que Google Authenticator par exemple)
-- Suivez les étapes
-
-Et voilà, vous serez invité à saisir un code à usage unique à chaque connexion.
-
-## Protéger une app native
----
-Authentik est compatible nativement avec un certain nombre d'application, vous retrouverez la liste et [le support ici](https://docs.goauthentik.io/integrations/services/)
-
-## Protéger une app par reverse proxy
----
-Swag permet d'intercaler la page d'authentik entre la requête et l'accès à votre service. Pour cela il va falloir :
-
-- Configurer le service d'authentification dans authentik.
-- Configurer le fichier proxy du domaine pour que swag puisse intercaler la page.
-
-Pourquoi le faire alors que Dockge a déjà une page d'authentification ? Tout simplement parce que l'authentification HTTP utilisée par Dockge est faible. Avec Authentik, vous aurez directement une authentification forte par MFA, et vous serez loggé automatiquement à toutes vos apps déjà protégées par authentik. Cela permet de sécuriser l'accès à Dockge et aux autres apps que vous protégerez, sans avoir à passer par un VPN.
-
-### Configuration de Authentik
-
-- Rendez vous dans Authentik
-- Allez dans le panneau d'administration
-- Sélectionnez _application_ puis _créer avec l'assistant_
-- Renseignez les champs comme suit :
-
-![Picture](/img/serveex/auth1.png)
-
-- Puis à l'étape suivante choisissez "Transférer l'authentification (application unique)" et éditez comme suit (attention aux flow, c'est important) :
-
-![Picture](/img/serveex/auth2.png)
-
-- Ensuite, allez dans le menu à gauche dans _Avant-poste_ et éditez _authentik Embedded Outpost_
-
-![Picture](/img/serveex/auth3.png)
-
-- Ajoutez l'application `dockge` en la faisant passer à droite et validez.
-
-### Configuration de SWAG
-
-Ensuite rendez-vous dans le fichier `dockge.mondomaine.fr`.
-
-```shell
-sudo vi /docker/swag/config/nginx/proxy-confs/dockge.subdomain.conf
-```
-
-Puis entrez en modification en appuyant sur `i` et enlevez les `#` des deux lignes `#include /config/nginx/authentik-server.conf;`{lang=nginx}.
-
-Appuyez sur `Echap` puis tapez `:x` et appuyez sur `Entrée` pour sauvegarder et quitter.
-
-Et voilà ! En tapant `https://dockge.mondomaine.fr`, vous tomberez à présent sur la mire d'authentification de authentik. 
-
-::alert{type="success"}
-✨ __Astuce :__ dans Dockge, dans les paramètres, vous pouvez désactiver l'authentification de Dockge afin de ne pas avoir à vous identifier deux fois. **Attention**, cela voudra dire que si vous avez exposé un port sur votre réseau local, il n'y aura plus aucune authentification.
-::
-
-::alert{type="info"}
-:::list{type="info"}
-- Vous pouvez répétez l'opération pour chaque application que vous souhaitez protéger (si elle ne dipose pas d'intégration directe avec Authentik).
-:::
-::
-
-Voilà votre nouvelle architecture :
-
-![Picture](/img/serveex/authentik.svg)
-
-## Protéger un service sur un serveur distant
----
-Dans le cas d'une application [native](/serveex/securite/authentik#protéger-une-app-native) (via OAuth 2.0 ou autre), rien ne change.
-
-Dans le cas d'une application non native à protéger derrière un reverse proxy, vous devrez déployer un __avant-poste__. Un avant-poste est un conteneur qui jouera le rôle de proxy local, c'est à dire que c'est vers ce conteneur que les requêtes d'authentification de vos applications seront redirigées. C'est le seul qui est autorisé à dialoguer avec l'API de votre instance authentik.
-
-
-::alert{type="info"}
-Pré-requis :
-- Avoir installé [docker](/serveex/coeur/docker) sur votre machine distante hébergeant le service à protéger.
-- Si l'application n'a pas d'intégration native, avoir un reverse proxy compatible. Comme partout ici, nous utiliserons [SWAG](/serveex/coeur/swag).
-:: 
-
-Ce conteneur redirigera ensuite les requetes vers votre instance [Authentik](/serveex/securite/authentik#authentik) principale, à travers le web (ou votre réseau local). Le serveur executera les controle et renverra la réponse à l'_avant-poste_, qui bloquera ou non la connexion à l'app protégée.
-
-![auth-outpost](/img/serveex/auth-outpost.svg)
-
-### Configuration d'Authentik
-
-Créez vos [fournisseurs et applications](/serveex/securite/authentik#protéger-une-app-native) comme nous l'avons vu plus haut.
-
-Puis, dans votre panneau admin, allez dans la rubrique _Applications > Avant-postes_, puis créez un nouvel avant-poste.
-
-Remplissez comme suit :
-
-
-| Champs         | Valeur                                                                |
-|----------------|-----------------------------------------------------------------------|
-| `Nom`          | Le nom que vous souhaitez                                             |
-| `Type`         | `Proxy`                                                               |
-| `Intégration`  | Laissez vide                                                          |
-| `Applications` | Sélectionnez le ou les applications que vous avez créées précédemment |
-
-Dans la section `Paramètres avancés`, supprimez l'existant, et complétez comme suit :
-
-```yaml
-log_level: info
-docker_labels: null
-authentik_host: https://domaine_de_votre_serveur_authentik/
-object_naming_template: ak-outpost-%(name)s
-authentik_host_insecure: false
-container_image:
-docker_network: null
-docker_map_ports: true
-docker_labels: null
-```
-
-Enrtegistrez et quittez.
-
-Sur l'écran affichant les avant-postes créés, vous verrez le nouvel avant-poste que vous venez de créer. A la fin de la ligne, cliquez sur _afficher les informations_, et copiez précieusement le jeton d'accès.
-
-### Configuration de la machine distante
-
-Nous partons du principe que vous avez déjà installé [Docker](/serveex/coeur/docker) et [SWAG](/serveex/coeur/swag) sur cette machine distante.
-
-Sur votre machine distante, à l'aide de [Dockge](/serveex/coeur/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs), créez une stack `authentik-outpost`.
-
-Si vous n'avez pas installé [Dockge](/serveex/coeur/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs), créez un dossier `/docker/authentik-outpost`, ou directement en ligne de commande :
-
-```shell
-sudo mkdir -P /docker/authentik-outpost
-```
-
-::alert{type="success"}
-✨ __Astuce pour les allergiques au terminal :__
-vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
-::
-
-Créez le fichier `compose.yaml` ou copiez la configuration directement dans le champs si vous avez [Dockge](/serveex/coeur/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs)
-
-En ligne de commande :
-
-```shell
-sudo vi /docker/authentik-outpost/compose.yaml
-```
-Entrez en mode modification avec `i` et collez la configuration suivante, en changeant les chiffres de `{AUTHENTIK_TAG:proxy:2024.2.3}`{lang=properties} par la meme version que celle de votre serveur Authentik. 
-
-```yaml
-version: "3.5"
-services:
-  authentik_proxy:
-    container_name: authentik-outpost
-    image: ghcr.io/goauthentik/proxy:2024.2.3
-    # Optionally specify which networks the container should be
-    # might be needed to reach the core authentik server
-    restart: unless-stopped
-    env_file:
-      - .env
-    #   - foo
-    ports:
-      - 9000:9000
-      - 9443:9443
-    environment:
-      AUTHENTIK_HOST: ${HOST}
-      AUTHENTIK_INSECURE: "false"
-      AUTHENTIK_TOKEN: ${TOKEN}
-      # Starting with 2021.9, you can optionally set this too
-      # when authentik_host for internal communication doesn't match the public URL
-      # AUTHENTIK_HOST_BROWSER: https://external-domain.tld
-```
-
-Rendez-vous sur la stack de SWAG de la machine distante (ou remplissez directement si vous avez [Dockge](/serveex/coeur/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs)) et ajoutez le réseau de authentik-outpost dans le fichier de conf sur ce modele (les champs `networks`) :
-
-
-```shell
-sudo vi /docker/swag/compose.yaml
-```
-
-```yaml
-services:
-  swag:
-     container_name: #...
-      # ... 
-     networks:                      # Relie le conteneur au réseau custom 
-      - authentik-outpost           # Nom du réseau déclaré dans la stack
-    
-networks:                           # Définit le réseau custom
-  #...
-  authentik-outpost:                # Nom du réseau déclaré dans la stack
-    name: authentik-outpost_default # Nom véritable du réseau externe
-    external: true                  # Précise que c'est un réseau à rechercher en externe
-```
-
-Appuyez sur `Echap` puis tapez `:x` et appuyez sur `Entrée` pour sauvegarder et quitter.
-
-::alert{type="info"}
-:::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de dockge est `authentik-outpost_default`.
-:::
-::
-
-Si vous avez [Dockge](/serveex/coeur/docker/#installer-dockge-pour-g"rer-et-d"ployer-les-conteneurs), relancez SWAG.
-
-Sinon, via le terminal :
-
-```shell
-cd /docker/swag/
-sudo docker compose up -d
-```
-
-Creez (ou remplissez directement si vous avez [Dockge](/serveex/coeur/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs)) le fichier `.env` dans le dossier de l'avant poste authentik :
-
-En ligne de commande :
-
-```shell
-sudo vi /docker/authentik-outpost/.env
-```
-
-Entrez en mode modification avec `i` et collez la configuration suivante
-
-```properties
-HOST=
-TOKEN=
-```
-Remplissez comme suit
-
-| Variable                | Valeur                                                  | Exemple                    |
-|-------------------------|---------------------------------------------------------|----------------------------|
-| `HOST`{lang=properties}  | L'url de votre serveur authentik                        | `https://auth.domaine.fr`  |
-| `TOKEN`{lang=properties} | Le token que vous avez précédemment copié précieusement | `Q2pVEqsTNRkJSO9SkJzU3KZ2` |
-
-Appuyez sur `Echap` puis tapez `:x` et appuyez sur `Entrée` pour sauvegarder et quitter.
-
-Si vous avez [Dockge](/serveex/coeur/docker/#installer-dockge-pour-g"rer-et-d"ployer-les-conteneurs), déployez la stack.
-
-Sinon, via le terminal :
-
-```shell
-cd /docker/authentik-outpost/
-sudo docker compose up -d
-```
-
-Le conteneur est en route, vous pouvez vérifier son état dans votre panneau admin de votre instance Authentik, section _Applications > Avant-postes_. 
-
-
-Nous allons a présent configurer SWAG.
-
-Ouvrez le fichier `authentik-server.conf`.
-
-```shell
-sudo vi /docker/swag/config/nginx/authentik-server.conf
-```
-
-Dans le fichier, passez en mode modification en tapant `i` et changez `authentik-server` par `authentik-outpost` comme suit :
-
-```nginx
-set $upstream_authentik authentik-outpost;
-proxy_pass http://$upstream_authentik:9000;
-```
-
-Sauvegardez et quittez en tapant sur `Echap` puis `:x` et sur `Entrée`.
-
-Ensuite, configurez les applications à protéger selon si elles sont [natives](/serveex/securite/authentik#protéger-une-app-native) ou par [proxy](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy) comme vous l'avez fait sur votre serveur principal.
-
-## Migrer une base authentik
----
-Sur la machine d'origine, dumper la bdd :
-
-```shell
-sudo docker exec authentik-postgres pg_dump -U authentik -F t authentik > /path/to/mydb.tar
-```
-
-Puis l'envoyer sur la machine cible. Sur la machine cible, copier le fichier dans le container docker
-
-```shell
-cp /path/to/mydb.tar authentik-postgres:/path/to/wherever
-```
-
-(Optionnel) Purgez les tables existantes :
-
-```shell
-sudo docker exec -i authentik-postgres psql -U authentik -c "SELECT pg_terminate_backend(pg_stat_activity.pid) FROM pg_stat_activity WHERE pg_stat_activity.datname = 'authentik' AND pid <> pg_backend_pid();" && \
-sudo docker exec -i authentik-postgres psql -U authentik -d postgres -c "DROP DATABASE IF EXISTS authentik;" && \
-sudo docker exec -i authentik-postgres psql -U authentik -d postgres -c "CREATE DATABASE authentik;" && \
-```
-
-Restaurez la bdd
-
-```shell
-sudo docker exec authentik-postgresql pg_restore -U authentik -d authentik /path/to/wherever/mydb.tar
-```

content/3.serveex/3.securite/3.cloudflare.md

@@ -1,268 +0,0 @@
----
-navigation: true
-title: Cloudflare Zero Trust
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Cloudflare Zero Trust
-
-::alert{type="info"}
-🎯 __Objectifs :__
-  - Comprendre le principe des Tunnels Cloudflare
-  - Paramétrer son compte cloudflare
-  - Paramétrer SWAG
-  - Gérer plusieurs tunnels
-::
-
-![cloudfare_tunnels](/img/serveex/cloudflared.svg)
-
-## Introduction
----
-L'architecture _Zero Trust_ est la pratique consistant à concevoir des systèmes fondés sur le principe de __« ne jamais faire confiance__, __toujours vérifier »__, par opposition au principe traditionnel de __« confiance, mais vérifier »__. Ce concept est devenu très populaires récemment, à la suite des attaques toujours plus nombreuses concernant les données des utilisateurs. C'est un concept très large, nous nous concentrerons sur l’application du _Zero Trust_ aux services Web que nous hébergeons.
-
-Les _tunnels Cloudflare_ offrent un moyen simple d'arriver au _Zero Trust_, en s'appuyant sur [SWAG](/serveex/coeur/swag) et [Authentik](/serveex/securite/authentik).
-
-Pour le dire simplement, les Tunnels Cloudflare permettent notamment de :
-
-- Masquer l'IP de votre serveur (et donc de votre box s'il est hébergé chez vous).
-- D'authentifier le traffic.
-- De bénéficier des protection de Cloudflare (attaques DDOS, etc, blacklist, requêtes malveillantes, etc...).
-- De bénéficier du CDN, c'est à dire du serveur de cache de Cloudlfare, qui permet d'augmenter les performances de vos sites web.
-- De ne plus avoir besoin de l'ouverture de ports de votre routeur pour les services exposés par SWAG.
-
-Ici, nous expliquerons comment associer SWAG aux tunnels Cloudflare.
-
-::alert{type="warning"}
-:::list{type="warning"}
-- __Attention :__
-:::
-- N'utilisez pas les tunnels Cloudflare pour exposer un serveur mail
-- N'utilisez pas les tunnels Cloudflare pour exposer un service vidéo, comme Plex (si vous avez [suivi ce guide](/serveex/media/plex), Plex n'est pas exposé, c'est donc valide)
-- N'utilisez pas les tunnels Cloudflare pour utiliser le protocole bittorrent (si vous avez [suivi ce guide](/serveex/media/qbittorrent), tout est bon)
-::
-
-## Configuration Cloudflare
----
-### Zone DNS
-
-Avant toute chose, vous devez définir Cloudflare comme gestionnaire de votre [zone DNS](/generalites/reseau/dns). Si vous avez réservé votre nom de domaine chez Cloudflare, c'est déjà le cas. Sinon, renseignez vous auprès de votre registrar sur comment ajouter des DNS externes. Cloudflare dispose d'[une documentation expliquant pas à pas comment paramétrer une Zone DNS](https://developers.cloudflare.com/dns/zone-setups/full-setup/setup/), que vous ayez un domaine externe ou reservé chez Cloudflare.
-
-Si vous avez qu'un seul serveur à protéger derrière Cloudflare, vous pouvez supprimer l'ensemble des enregistrement DNS existant, par défaut le domaine et tout ses sous-domaines seront directement redirigés vers le tunnel.
-
-Si vous avez des sous-domaines à rediriger vers d'autres serveurs, vous pourrez toujours les déclarer dans la zone DNS à l'aide d'un enregistrement A.
-
-Si vous avez plusieurs serveurs et donc plusieurs tunnels pour un meme domaine principal, [voyez ici](http://192.168.7.80:8005/serveex/cloudflare/#gerer-plusieurs-tunnels-pour-plusieurs-serveurs).
-
-### Clé API
-
-Pour commencer, nous devons créer un nouveau jeton API pour Cloudflare et récupérer nos identifiants de zone et de compte. 
-
-Sur le tableau de bord de Cloudflare, dans la page de présentation de votre domaine, vous pouvez voir les identifiants de `zone` et de `compte` en bas à droite de l'écran. Copiez précieusement ces deux identifiants.
-
-![id and account](/img/serveex/cf-id.png)
-
-Juste en dessous d'eux, il y a un lien intitulé _Obtenez votre jeton API_. Cliquez dessus. Le périmètre dont nous avons besoin pour le jeton doit inclure `Zone:DNS:Edit` et `Account:Cloudflare Tunnel:Edit`. Assurez-vous que votre page de création de token ressemble à celle illustrée dans la capture d'écran ci-dessous. 
-
-![API token](/img/serveex/cf-token.png)
-
-Une fois que nous aurons enregistré, notre jeton sera affiché une fois. copiez le précieusement, car vous ne pourrez plus le revoir après la fermeture.
-
-### Cloudflare Zero Trust
-
-Vous devez vous inscrire à _Cloudflare Teams_ pour pouvoir accéder au tableau de bord _Zero Trust_ qui gère les tunnels et les politiques d'accès. Il s'agit d'un service premium, mais ils proposent un forfait gratuit pour un maximum de 50 utilisateurs, ce qui devrait suffire pour votre Home Lab. Gardez à l’esprit que puisqu’il s’agit d’une fonctionnalité premium, ils demandent une carte de crédit valide lors de l’inscription, mais avec le forfait gratuit, il n'y aura aucun frais. 
-
-Inscrivez-vous [via ce lien](https://dash.teams.cloudflare.com/).
-
-
-## Configuration de Swag
----
-::alert{type="info"}
-:::list{type="info"}
-- Nous partons du principe que vous avez le domaine `mondomaine.fr` avec les DNS qui pointent bien vers ceux de Cloudflare, comme vu précédemment.
-:::
-::
-
-SWAG dispose de deux `Docker Mods` permettant d'y intégrer :
-
-- __Cloudflared__, le conteneur qui permet de créer et de gérer les tunnels
-- __Cloudflared Real IP__, un conteneur qui permet à SWAG d'obtenir la vraie source IP des requêtes depuis internet plutot que celle de Docker (ce qui pourrait entrer en conflit avec le mod de géolocalisatioN DBIP).
-
-Ces deux mods, fusionnés dans le conteneur de SWAG, nécessitent un peu de configuration.
-
-### Configuration du tunnel
-
-Pour configurer les tunnels, nous aurons besoin de créer un fichier `tunnelconfig.yml` auquel nous ferons appel dans le `compose.yaml` de SWAG.
-
-::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
-::
-
-```shell
-sudo vi /docker/swag/config/tunnelconfig.yml
-```
-
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous
-
-```yaml
-ingress:
-  - hostname: mondomaine.fr
-    service: https://mondomaine.fr
-  - hostname: "*.mondomaine.fr"
-    service: https://mondomaine.fr
-  - service: http_status:404
-```
-
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
-
-### Configuration de Cloudflare Real IP
-
-A présent, nous allons configurer le bon fonctionnement du mode _Cloudflare Real IP_
-
-Ouvrez le fichier `nginx.conf`
-
-```shell
-sudo vi /docker/swag/config/nginx/nginx.conf
-```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous à la fin de la section `http`
-
-```nginx
-real_ip_header X-Forwarded-For;
-real_ip_recursive on;
-include /config/nginx/cf_real-ip.conf;
-set_real_ip_from 127.0.0.1;
-```
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
-
-### Docker compose
-
-Ouvrez Dockge, éditez la stack SWAG avec cette configuration
-
-```yaml
----
-services:
-  swag:
-    image: lscr.io/linuxserver/swag:latest
-    container_name: swag
-    cap_add:
-      - NET_ADMIN
-    env_file:
-      - .env
-    environment:
-      - DOCKER_MODS=linuxserver/mods:swag-dbip|linuxserver/mods:swag-dashboard|linuxserver/mods:swag-auto-reload|linuxserver/mods:universal-cloudflared|linuxserver/mods:swag-cloudflare-real-ip
-      - PUID=${PUID}
-      - PGID=${PGID}
-      - TZ=Europe/Paris
-      - URL=${DOMAIN}
-      - SUBDOMAINS=wildcard
-      - VALIDATION=dns
-      - DNSPLUGIN=${PLUGIN}
-      - EMAIL=${EMAIL}
-      - CF_ZONE_ID=${ZONE_ID}
-      - CF_ACCOUNT_ID=${ACCOUNT_ID}
-      - CF_API_TOKEN=${API_TOKEN}
-      - CF_TUNNEL_NAME=${TUNNEL_NAME}
-      - CF_TUNNEL_PASSWORD=${TUNNEL_PW}
-      - FILE__CF_TUNNEL_CONFIG=/config/tunnelconfig.yml
-    extra_hosts:
-      - ${DOMAIN}:127.0.0.1
-    ports:
-      - 81:81
-    volumes:
-      - /docker/swag/config:/config
-      - /docker/swag/config/fail2ban/fail2ban.sqlite3:/dashboard/fail2ban.sqlite3:ro
-    restart: unless-stopped
-```
-
-::alert{type="success"}
-✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
-
-    ```yaml
-    services:
-      swag:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
-::
-
-
-Et renseignez le `.env` les infos que vous avez trouvées et notées tout au long de ce guide
-
-```properties
-PUID=
-PGID=
-DOMAIN=
-PLUGIN=
-EMAIL=
-ZONE_ID=
-ACCOUNT_ID=
-API_TOKEN=
-TUNNEL_NAME=
-TUNNEL_PW=
-```
-
-| Variable                          | Valeur                                                                                                    | Exemples                       |
-|-----------------------------------|-----------------------------------------------------------------------------------------------------------|--------------------------------|
-| `PUID`{lang=properties}            | A renseigner avec les infos de votre user (trouvables via la commande `id nomdutilisateur`{lang=shell}) | `1000`                           |
-| `GUID`{lang=properties}              | A renseigner avec les infos de votre user (trouvables via la commande `id nomdutilisateur`{lang=shell}) | `1000 `                          |
-| `DOMAIN`{lang=properties}            | Le domaine que vous avez réservé                                                                          | `mondomaine.fr`                  |
-| `PLUGIN`{lang=properties}            | Le fournisseur de zone DNS, ici Cloudflare. Pensez à renseigner `cloudflare.ini` (voir [guide de swag](https://docs.linuxserver.io/general/swag/#create-container-via-dns-validation-with-a-wildcard-cert))                                                                | `cloudflare`                     |
-| `EMAIL`{lang=properties}             | Votre email pour le certificat                                                                            | `votre@email.fr`                 |
-| `ZONE_ID`{lang=properties}           | L'ID de Zone que vous avez noté précédemment                                                              | `aNhcz1l3JfWbFZo2XMpzQlP2iOqk`   |
-| `ACCOUNT_ID`{lang=properties}        | L'ID de Compte que vous avez noté précédemment                                                            | `buKsjNHLyzKMM1qYnzOy4s7SHfly`   |
-| `API_TOKEN`{lang=properties}         | Le jeton d'API que vous avez noté précédemment                                                            | `53ydYus9TFFk1DOXNdP87iIcJtQjoW` |
-| `TUNNEL_NAME`{lang=properties}       | Le nom de votre tunnel                                                                                    | `mon_tunnel`                     |
-| `TUNNEL_PW`{lang=properties}   | Un mot de passe fort généré aléatoirement                                                                 | `iSzKRmP4VbnlsMvdSdgBEJiJi`      |
-
-Une fois fait, déployez la stack. Cela prendra un peu de temps, vérifiez les logs, vous devriez arriver à `serveur ready`
-
-Une fois le conteneur en ligne, vérifiez dans cloudflare que votre tunnel est bien présent dans la section _Networks > Tunnels_ de [Cloudflare Zero Trust](https://one.dash.cloudflare.com/). Par défaut, l'ensemble des sous domaine sont redirigés vers le tunnel, sans avoir besoin de les déclarer [dans votre zone DNS](/generalites/reseau/dns).
-
-::alert{type="success"}
-✨ __Astuce:__ si vous voulez exposer un service sans tunnel, vous pouvez toujours déclarer un enregistrement A [dans votre zone DNS](/generalites/reseau/dns). En cas de problème de résolution, désactivez la fonction _proxy_ pour cet enregistrement. Par exemple pour `sous.mondomaine.fr`
-![dns](/img/serveex/cf-dns.png)
-::
-
-
-## Gérer plusieurs tunnels pour plusieurs serveurs
----
-Par défaut, l'ensemble des sous domaine de votre nom de domaine pointent vers le tunnel que vous avez créé. Mais si vous avez un second serveur, vous pouvez avoir un second tunnel en changeant seulement le nom de tunnel dans la configuration de l'instance swag de votre serveur.
-
-Vous devrez ensuite dans votre zone DNS rediriger les sous domaine souhaité vers le bon tunnel. Pour cela, faites comme suit.
-
-Rendez-vous dans dans la section _Networks > Tunnels_ de [Cloudflare Zero Trust](https://one.dash.cloudflare.com/).
-
-Notez les deux ID des tunnels
-
-![tunnels_id](/img/serveex/cf-tunnels-id.png)
-
-Rendez-vous à présent dans la section DNS de [cloudflare](https://dash.cloudflare.com/), après avoir cliqué sur le nom de domaine concerné. 
-
-Cliquez sur `ajouter un enregistrement` et ajoutez deux enregistrements comme suit en ajoutant bien `.cfargotunnel.com` après vos id de tunnels.
-
-| Type    | Nom            | Cible                               |
-|---------|----------------|-------------------------------------|
-| `CNAME` | `sousdomaine1` | `votreiddetunnel1.cfargotunnel.com` |
-| `CNAME` | `sousdomaine2` | `votreiddetunnel2.cfargotunnel.com` |
-
-
-
-Si vous avez de nombreux sous-domaines, vous pouvez déclarer un seul sous domaine par tunnel comme ci-dessus, puis déclarer vos autres sous domaine en les faisant pointer vers ces sous domaines de référence.
-
-Ainsi, en cas de changement d'id de tunnel, vous n'aurez qu'à le changer que pour un seul sous-domaine.
-Par exemple :
-    
-- Le serveur de `sousdomaine1` doit egalement etre la cible de sub1, et sub2 :
-
-    | Type    | Nom            | Cible                               |
-    |---------|----------------|-------------------------------------|
-    | `CNAME` | `sub1` | `sousdomaine1` |
-    | `CNAME` | `sub2` | `sousdomaine1` |
-    
-- Le serveur de `sousdomaine2` doit egalement etre la cible de sub3, et sub4 :
-
-    | Type    | Nom            | Cible                               |
-    |---------|----------------|-------------------------------------|
-    | `CNAME` | `sub3` | `sousdomaine2` |
-    | `CNAME` | `sub4` | `sousdomaine2` |
-

content/3.serveex/3.securite/_dir.yml

@@ -1,2 +0,0 @@
-navigation.title: La sécurité
-icon: lucide:shield

content/3.serveex/3.security/1.wireguard.md

@@ -0,0 +1,258 @@
+---
+navigation: true
+title: Wireguard
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Wireguard
+
+::alert{type="info"}
+🎯 __Goals:__
+  - Install Wireguard
+  - Configure clients
+  - Access the secure network
+::
+
+## Introduction
+---
+Using a VPN allows remote access to a server’s local resources without exposing them to the internet. It’s a clean and secure way to access services like SSH without exposing the port publicly. With a VPN, you can securely connect to your network from anywhere and make devices on different networks communicate.
+
+Here we will use [Wireguard](https://www.wireguard.com/), a secure and high-performance VPN server, using containers:
+
+- [wg-easy](https://github.com/wg-easy/wg-easy) as the server, providing a very simple web UI to manage connections and download config files (including QR codes for phones)
+- [Wireguard](https://docs.linuxserver.io/images/docker-wireguard/?h=wireguard) as the client for Linux systems
+
+Clients are also available for Windows, macOS, iOS, and Android.
+
+The concept:
+
+- On the internet, anyone can reach any internet box and thus any exposed server.
+- Your server is on your local network. It is accessible only locally unless services are explicitly exposed (as we did with Dockge). To access non-exposed resources, you must be on the same local network.
+- We want to securely access these unexposed services (like SSH) from anywhere.
+- We also want to connect services between servers, like linking two Dockge instances securely.
+
+To achieve this, we’ll create a **Virtual Private Network** (VPN), i.e., a secure tunnel that only connected machines can use. They’ll appear to be on the same private network.
+
+Additionally, you can add your phone, laptop, or other devices to the VPN and securely access your server resources wherever you are.
+
+![picture](/img/serveex/vpn.svg)
+
+In this diagram, machine 1 is part of two networks:
+
+- Its local network (devices behind the same router, e.g. `192.168.x.x` – machines 1 and 2)
+- The VPN network (VPN devices with a second IP, e.g. `10.8.x.x` – machines 1 and 4)
+
+You *can* allow VPN clients to share access to their local networks, but we won’t do that here for security and subnet conflict reasons (e.g., if two remote machines use the same local IP like `192.168.1.1`).
+
+So only VPN-connected devices can communicate with each other on the VPN, not with other local devices outside the VPN.
+
+## Server Side
+---
+::alert{type="info"}
+📋 __Checklist:__
+- Ensure port `51820 UDP` is available and properly forwarded through your router to the server (`Source 51820 UDP -> Destination 51820 UDP -> Server`).
+- Ensure port `51821 TCP` is available for the web UI.
+::
+
+::alert{type="warning"}
+:::list{type="warning"}
+- __Warning:__ This guide uses version `14` of [wg-easy](https://wg-easy.github.io/wg-easy/latest/). Version `15` introduces breaking changes incompatible with this configuration.
+:::
+::
+
+Folder structure:
+
+```console
+root
+└── docker
+    └── wg-easy
+        ├── config
+        │   └── etc_wireguard
+        ├── compose.yaml
+        └── .env
+```
+
+The container runs in `HOST` mode, meaning it uses the host’s network stack directly.
+
+Open Dockge, click `compose`, and name the stack `wg_easy`.
+
+Paste the following configuration:
+
+```yaml
+---
+services:
+  wg-easy:
+    network_mode: host
+    env_file:
+      - .env
+    environment:
+      - LANG=en
+      - WG_HOST=${HOST}
+      - PASSWORD_HASH=${PW}
+      - WG_DEFAULT_ADDRESS=${ADDRESS}
+      - WG_HIDE_KEYS=never
+      - WG_ALLOWED_IPS=${IPS}
+      - WG_DEFAULT_DNS=
+      - UI_TRAFFIC_STATS=true
+      - UI_CHART_TYPE=1
+    image: ghcr.io/wg-easy/wg-easy:14
+    container_name: wg-easy
+    volumes:
+      - /docker/wg_easy/config/etc_wireguard:/etc/wireguard
+    restart: unless-stopped
+    cap_add:
+      - NET_ADMIN
+      - SYS_MODULE
+```
+
+::alert{type="success"}
+✨ __Tip:__
+- You can also specify your own wireguard port with `WG_PORT`
+- Add the Watchtower label to enable automatic updates
+
+```yaml
+services
+  wg-easy:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+```
+::
+
+In `.env`:
+
+```properties
+HOST=
+PW=
+ADDRESS=
+IPS=
+```
+
+| Variable     | Description | Example |
+|--------------|-------------|---------|
+| `HOST`       | IP of public access of your host (router ISP's IP if it's at home) | `80.75.137.27` |
+| `PW`         | Bcrypt password hash, [generate here](https://bcrypt-generator.com/). **NOTE:** Double the `$` characters | `$$2a$$12$$FF6T4QqSP9Ho` |
+| `ADDRESS`    | VPN DHCP address range, the `x` must remain, others can vary | `10.8.0.x` |
+| `IPS`        | IPs routed by clients through the VPN. Use `10.8.0.0/24` to only route VPN traffic. To include local LAN, add `192.168.0.0/16` separated by commas. | `10.8.0.0/24` |
+
+Deploy the stack.
+
+### Enable Forwarding on Host
+
+To allow communication between VPN clients, enable:
+
+```shell
+sudo sysctl net.ipv4.ip_forward=1
+sudo sysctl net.ipv4.conf.all.src_valid_mark=1
+```
+
+### Retrieve Configuration Files
+
+To configure clients, download the config files from the server:
+
+- Visit `http://your-server-ip:51821`
+- Create a client
+- Download the config file
+- Rename it to `wg0.conf`
+
+::alert{type="danger"}
+:::list{type="danger"}
+- If it fails, check firewall rules.
+:::
+::
+
+## On the Client Server
+---
+::alert{type="info"}
+:::list{type="info"}
+- Assumes the client is a Linux server with Docker installed
+:::
+::
+
+Folder structure:
+
+```console
+root
+└── docker
+    └── wireguard
+        └── config
+        │   └── wg_confs
+        └── compose.yaml
+```
+
+Create the folder `/docker/wireguard/config/wg_confs`:
+
+::alert{type="success"}
+✨ __Tip:__ Use [File Browser](/serveex/files/file-browser) to browse and edit files without terminal
+::
+
+```shell
+sudo mkdir -p /docker/wireguard/config/wg_confs
+```
+
+Copy the `wg0.conf` file downloaded earlier:
+
+::alert{type="success"}
+✨ __Tip:__ Easiest way is to transfer the file via SFTP to `/home/youruser`, then move it:
+
+```shell
+sudo cp ~/wg0.conf /docker/wireguard/config/wg_confs
+```
+::
+
+Create `compose.yaml` in `/docker/wireguard`:
+
+```shell
+sudo vi /docker/wireguard/compose.yaml
+```
+
+Press `i` to enter insert mode and paste:
+
+```yaml
+services:
+  wireguard:
+    image: lscr.io/linuxserver/wireguard:latest
+    container_name: wireguard
+    network_mode: host
+    cap_add:
+      - NET_ADMIN
+      - SYS_MODULE #optional
+    environment:
+      - TZ=Europe/Paris
+    volumes:
+      - /docker/wireguard/config:/config
+      - /lib/modules:/lib/modules #optional
+    restart: unless-stopped
+```
+
+Press `Esc` then type `:x` to save and exit.
+
+Start the container:
+
+```shell
+cd /docker/wireguard
+sudo docker compose up -d
+```
+
+::alert{type="info" icon="exclamation-circle"}
+:::list{type="info"}
+- Repeat for each client
+:::
+::
+
+## Other Devices
+---
+- **Phone:** Install Wireguard and scan the QR code from the web UI (`http://your-server-ip:51821`)
+- **PC:** Install the Wireguard client and import the config file
+
+::alert{type="warning"}
+:::list{type="warning"}
+- __Warning:__ If a client device is on the same LAN as the server, edit `wg0.conf` and change the endpoint to the local server IP:
+`Endpoint = your-server-ip:51820`
+:::
+::
+
+And this is the result:
+
+![picture](/img/serveex/wireguard.svg)

content/3.serveex/3.security/2.authentik.md

@@ -0,0 +1,574 @@
+---
+navigation: true
+title: Authentik
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Authentik
+
+::alert{type="info"}
+🎯 __Objectives:__
+- Install and expose Authentik
+- Configure Multi-Factor Authentication (MFA)
+- Protect a native app or an app behind a reverse proxy
+::
+
+[Authentik](https://goauthentik.io) is a single sign-on (SSO) tool that allows you to log in once to all platforms compatible with OpenID. It can also secure access to your exposed services by injecting itself via SWAG into requests to those services.
+
+For example, if you're exposing Dockge online at `dockge.mydomain.com`, you’ll first land on an Authentik login page when accessing it. If you've already authenticated with another Authentik-protected service, you won’t need to log in again. This allows you to authenticate only once per day for all protected services.
+
+Authentik also supports multi-factor authentication, including TOTP (a code generated by the authentication app of your choice). Additionally, it allows login through Microsoft or Google accounts, provided you've configured one of those applications.
+
+It's a great alternative to VPNs for securely exposing services, especially ones that lack MFA or login protection (e.g., the SWAG dashboard).
+
+Authentik has [extensive documentation](https://docs.goauthentik.io/docs/installation/docker-compose) and [great tutorials from Cooptonian](https://www.youtube.com/@cooptonian). Here, we’ll cover the basics using Dockge as an example.
+
+There are two main modes you should know:
+
+- The first allows apps with native support for OpenID-compatible SSO to connect directly to Authentik. This is the preferred method, as the app itself decides what’s public and what’s protected.
+
+![Picture](/img/serveex/auth-native.svg)
+
+- The second method injects Authentik authentication through SWAG before reaching the target service.
+
+![Picture](/img/serveex/auth-proxy.svg)
+
+Both modes can be configured on a per-application basis.
+
+## Installation
+---
+Folder structure:
+```console
+root
+└── docker
+    └── authentik
+        ├── .env
+        ├── compose.yml
+        ├── media
+        ├── certs
+        ├── custom-template
+        └── ssh
+```
+
+Create the folders:
+
+```shell
+sudo mkdir -p /docker/authentik/media /docker/authentik/certs /docker/authentik/custom-template /docker/authentik/ssh
+```
+
+Navigate to the `authentik` folder and generate a password and secret key to include in the `.env` file:
+
+```shell
+sudo echo "PG_PASS=$(openssl rand 36 | base64)" >> .env
+sudo echo "AUTHENTIK_SECRET_KEY=$(openssl rand 60 | base64)" >> .env
+```
+
+::alert{type="info"}
+:::list{type="info"}
+- To generate the keys, we created the folders ahead of deployment using Dockge. Dockge will prevent you from creating a stack with the same name in these folders unless a `compose.yml` file exists. So, create an empty `compose.yml` so it appears as an inactive stack:
+:::
+    ```shell
+    sudo vi /docker/authentik/compose.yml
+::
+
+Open Dockge and search for "authentik" in the inactive stacks.
+Name the stack `authentik` and paste the following configuration, replacing `{AUTHENTIK_TAG:-2025.6.3}`{lang=properties} with [the latest version of Authentik](https://goauthentik.io/docs/releases). 
+
+```yaml
+---
+services:
+
+  postgresql:
+    image: docker.io/library/postgres:16-alpine
+    container_name: authentik-postgresql
+    restart: unless-stopped
+    healthcheck:
+      test:
+        - CMD-SHELL
+        - pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}
+      start_period: 20s
+      interval: 30s
+      retries: 5
+      timeout: 5s
+    volumes:
+      - database:/var/lib/postgresql/data
+    environment:
+      POSTGRES_PASSWORD: ${PG_PASS:?database password required}
+      POSTGRES_USER: ${PG_USER:-authentik}
+      POSTGRES_DB: ${PG_DB:-authentik}
+    env_file:
+      - .env
+
+  redis:
+    image: docker.io/library/redis:alpine
+    container_name: authentik-redis
+    command: --save 60 1 --loglevel warning
+    restart: unless-stopped
+    healthcheck:
+      test:
+        - CMD-SHELL
+        - redis-cli ping | grep PONG
+      start_period: 20s
+      interval: 30s
+      retries: 5
+      timeout: 3s
+    volumes:
+      - redis:/data
+  
+  server:
+    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.2.1}
+    container_name: authentik-server
+    restart: unless-stopped
+    command: server
+    environment:
+      AUTHENTIK_REDIS__HOST: redis
+      AUTHENTIK_POSTGRESQL__HOST: postgresql
+      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
+      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
+      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
+    volumes:
+      - ./media:/media
+      - ./custom-templates:/templates
+      - ./ssh:/authentik/.ssh
+    env_file:
+      - .env
+    ports:
+      - ${COMPOSE_PORT_HTTP:-9000}:9000
+      - ${COMPOSE_PORT_HTTPS:-9443}:9443
+    depends_on:
+      - postgresql
+      - redis
+
+  worker:
+    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.2.1}
+    container_name: authentik-worker
+    restart: unless-stopped
+    command: worker
+    environment:
+      AUTHENTIK_REDIS__HOST: redis
+      AUTHENTIK_POSTGRESQL__HOST: postgresql
+      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
+      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
+      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
+    # `user: root` and the docker socket volume are optional.
+    # See more for the docker socket integration here:
+    # https://goauthentik.io/docs/outposts/integrations/docker
+    # Removing `user: root` also prevents the worker from fixing the permissions
+    # on the mounted folders, so when removing this make sure the folders have the correct UID/GID
+    # (1000:1000 by default)
+    user: root
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ./media:/media
+      - ./certs:/certs
+      - ./custom-templates:/templates
+      - ./ssh:/authentik/.ssh
+    env_file:
+      - .env
+    depends_on:
+      - postgresql
+      - redis
+
+volumes:
+  database:
+    driver: local
+  redis:
+    driver: local
+```
+
+In the `.env` file, the `PG_PASS` and `AUTHENTIK_SECRET_KEY` variables are already set.
+Deploy the stack.
+
+You can then begin the initial setup by visiting:  
+`http://yourserverip:9000/if/flow/initial-setup/`
+
+::alert{type="warning"}
+:::list{type="warning"}
+- __Warning:__ It’s recommended to create a new admin account and **disable** the default `akadmin` account.
+:::
+::
+
+## Exposing Authentik
+---
+To use Authentik outside your local network, you must expose it.
+
+::alert{type="info"}
+📋 __Prerequisites:__  <br/><br/>
+We assume you have already created a subdomain like `auth.mydomain.com` in your [DNS zone](/general/networking/dns), with a CNAME pointing to `mydomain.com`. Also, unless you're using [Cloudflare Zero Trust](/serveex/security/cloudflare), you must have already forwarded port `443` from your router to port `443` of your server in your [NAT rules](/general/networking/nat).
+::
+
+Open the `authentik-server.conf` file:
+
+::alert{type="success"}
+✨ __Tip for those who dislike terminals:__
+You can use [File Browser](/serveex/files/file-browser) to navigate and edit files instead of using terminal commands.
+::
+
+```shell
+sudo vi /docker/swag/config/nginx/authentik-server.conf
+```
+
+Verify that the following variables are set correctly:
+
+```nginx
+set $upstream_authentik authentik-server;
+proxy_pass http://$upstream_authentik:9000;
+```
+
+If not, press `i` to enter edit mode, make the necessary changes, then save and exit by pressing `Esc` followed by `:x`.
+
+Create the `auth.subdomain.conf` file:
+
+```shell
+sudo vi /docker/swag/config/nginx/proxy-confs/auth.subdomain.conf
+```
+
+Press `i` to enter edit mode and paste the following configuration:
+
+```nginx
+## Version 2023/05/31
+# Ensure your authentik container is named authentik-server
+# Ensure your DNS has a CNAME for authentik
+
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;
+
+    server_name auth.*;
+
+    include /config/nginx/ssl.conf;
+
+    client_max_body_size 0;
+
+    location / {
+        include /config/nginx/proxy.conf;
+        include /config/nginx/resolver.conf;
+        set $upstream_app authentik-server;
+        set $upstream_port 9000;
+        set $upstream_proto http;
+        proxy_pass $upstream_proto://$upstream_app:$upstream_port;
+    }
+
+    location ~ (/authentik)?/api {
+        include /config/nginx/proxy.conf;
+        include /config/nginx/resolver.conf;
+        set $upstream_app authentik-server;
+        set $upstream_port 9000;
+        set $upstream_proto http;
+        proxy_pass $upstream_proto://$upstream_app:$upstream_port;
+    }
+}
+```
+
+Save and exit by pressing `Esc` then `:x`.
+
+Go to Dockge, and edit the SWAG compose file to add the Authentik network:
+
+```yaml
+services:
+  swag:
+     container_name: # ...
+      # ...
+     networks:               # Attach the container to the custom network
+      # ...           
+      - authentik            # Name of the network declared in the stack
+
+networks:                    # Define the custom network
+  # ...
+  authentik:                 # Name of the network declared in the stack
+    name: authentik_default  # Actual name of the external network
+    external: true           # Indicates it's an external network
+```
+
+Restart the stack and wait for SWAG to be fully operational.
+
+Done! You can now access Authentik via `https://auth.mydomain.com`
+
+## Enable Multifactor Authentication
+---
+The main value of Authentik is using multifactor authentication for all protected apps.
+
+- Go to `https://auth.mydomain.com`
+- Log in
+- Go to _Settings_
+- Click the _MFA_ section
+- Click _Register_
+- Choose a method like _TOTP device_ (you'll need an authenticator app like Google Authenticator)
+- Follow the steps
+
+You’ll now be prompted to enter a one-time code at every login.
+
+## Protecting a Native App
+---
+Authentik is natively compatible with several applications. You can find the list and [support here](https://docs.goauthentik.io/integrations/services/).
+
+## Protecting an App via Reverse Proxy
+---
+SWAG lets you insert Authentik’s login page between a request and access to your service. To do this:
+
+- Configure the authentication provider in Authentik.
+- Edit the domain proxy file so SWAG can intercept the request.
+
+Why do this when Dockge already has authentication? Because Dockge uses weak HTTP authentication. With Authentik, you get strong MFA authentication and automatic login to all apps protected by Authentik. This secures access to Dockge and other apps without needing a VPN.
+
+### Configuring Authentik
+
+- Go to Authentik
+- Open the admin panel
+- Select _Applications_ then _Create with wizard_
+- Fill in the fields as shown:
+
+![Picture](/img/serveex/auth1.png)
+
+- At the next step, choose "Forward authentication (single application)" and configure it as shown (flows are important):
+
+![Picture](/img/serveex/auth2.png)
+
+- Next, go to the _Outposts_ menu on the left and edit _authentik Embedded Outpost_:
+
+![Picture](/img/serveex/auth3.png)
+
+- Add the `dockge` application by moving it to the right column and save.
+
+### Configuring SWAG
+
+Edit the file `dockge.mydomain.com`:
+
+```shell
+sudo vi /docker/swag/config/nginx/proxy-confs/dockge.subdomain.conf
+```
+
+Press `i` to enter edit mode and uncomment the two lines `#include /config/nginx/authentik-server.conf;`
+
+Press `Esc`, type `:x`, and press `Enter` to save and exit.
+
+Done! Now when accessing `https://dockge.mydomain.com`, you’ll be redirected to the Authentik login screen.
+
+::alert{type="success"}
+✨ __Tip:__ In Dockge's settings, you can disable Dockge's authentication to avoid double login. **Warning**: this means if the port is open on your local network, there will be no authentication at all.
+::
+
+::alert{type="info"}
+:::list{type="info"}
+- Repeat this process for each app you want to protect (unless it has native integration with Authentik).
+:::
+::
+
+Your new architecture looks like this:
+
+![Picture](/img/serveex/authentik.svg)
+
+## Protecting a Remote Server Service
+---
+For a [native application](/serveex/security/authentik/#protecting-a-native-app) (via OAuth 2.0 or other), nothing changes.
+
+For a non-native app behind a reverse proxy, you must deploy an __Outpost__. An Outpost is a container acting as a local proxy — it's the target of your app's auth requests and the only one authorized to communicate with your Authentik API.
+
+::alert{type="info"}
+Prerequisites:
+- Install [Docker](/serveex/core/docker) on the remote server hosting the service.
+- If the app has no native integration, use a compatible reverse proxy. We will use [SWAG](/serveex/core/swag) here.
+::
+
+This container will forward requests to your main [Authentik](/serveex/security/authentik#authentik) instance over the internet (or your local network). The server will perform checks and respond to the Outpost, which will allow or block access accordingly.
+
+![auth-outpost](/img/serveex/auth-outpost.svg)
+
+### Configuring Authentik
+
+Create your [providers and applications](/serveex/security/authentik/#protecting-a-native-app) as shown earlier.
+
+Then, in the admin panel, go to _Applications > Outposts_, and create a new outpost.
+
+Fill in as follows:
+
+| Field           | Value                                                                 |
+|----------------|------------------------------------------------------------------------|
+| `Name`         | Your preferred name                                                    |
+| `Type`         | `Proxy`                                                                |
+| `Integration`  | Leave empty                                                            |
+| `Applications` | Select the applications you previously created                         |
+
+In the `Advanced settings` section, clear the existing content and enter:
+
+```yaml
+log_level: info
+docker_labels: null
+authentik_host: https://your_authentik_server_domain/
+object_naming_template: ak-outpost-%(name)s
+authentik_host_insecure: false
+container_image:
+docker_network: null
+docker_map_ports: true
+docker_labels: null
+```
+
+Save and exit.
+
+On the list of created outposts, locate the new one and click _Show details_ at the end of the line. Carefully copy the access token.
+
+
+### Configuring the Remote Machine
+
+We assume you’ve already installed [Docker](/serveex/core/docker) and [SWAG](/serveex/core/swag) on this remote machine.
+
+On your remote machine, use [Dockge](/serveex/core/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs) to create a stack named `authentik-outpost`.
+
+If you haven’t installed [Dockge](/serveex/core/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs), create a folder `/docker/authentik-outpost`, or directly via command line:
+
+```shell
+sudo mkdir -P /docker/authentik-outpost
+```
+
+::alert{type="success"}
+✨ __Tip for terminal-averse users:__
+You can use [File Browser](/serveex/files/file-browser) to navigate and edit your files instead of using terminal commands.
+::
+
+Create the `compose.yaml` file or paste the configuration directly into Dockge if installed.
+
+Via command line:
+
+```shell
+sudo vi /docker/authentik-outpost/compose.yaml
+```
+Enter edit mode by pressing `i` and paste the following configuration, updating the version in `{AUTHENTIK_TAG:proxy:2024.2.3}`{lang=properties} to match your Authentik server version.
+
+```yaml
+version: "3.5"
+services:
+  authentik_proxy:
+    container_name: authentik-outpost
+    image: ghcr.io/goauthentik/proxy:2024.2.3
+    # Optionally specify which networks the container should be
+    # might be needed to reach the core authentik server
+    restart: unless-stopped
+    env_file:
+      - .env
+    ports:
+      - 9000:9000
+      - 9443:9443
+    environment:
+      AUTHENTIK_HOST: ${HOST}
+      AUTHENTIK_INSECURE: "false"
+      AUTHENTIK_TOKEN: ${TOKEN}
+```
+
+Go to the SWAG stack on the remote machine (or edit directly using Dockge) and add the authentik-outpost network in the configuration file like this (see `networks` section):
+
+```shell
+sudo vi /docker/swag/compose.yaml
+```
+
+```yaml
+services:
+  swag:
+     container_name: #...
+      # ... 
+     networks:                      # Attach the container to the custom network
+      - authentik-outpost           # Network name as declared in the stack
+
+networks:                           # Define the custom network
+  #...
+  authentik-outpost:                # Name of the network declared in the stack
+    name: authentik-outpost_default # Actual name of the external network
+    external: true                  # Marks it as an external network
+```
+
+Press `Esc`, then type `:x` and press `Enter` to save and exit.
+
+::alert{type="info"}
+:::list{type="info"}
+- We assume the Dockge network name is `authentik-outpost_default`.
+:::
+::
+
+If using [Dockge](/serveex/core/docker/#installer-dockge-pour-gérer-et-déployer-les-conteneurs), restart SWAG.
+
+Otherwise, via terminal:
+
+```shell
+cd /docker/swag/
+sudo docker compose up -d
+```
+
+Create (or fill using Dockge) the `.env` file in the `authentik-outpost` directory:
+
+Via command line:
+
+```shell
+sudo vi /docker/authentik-outpost/.env
+```
+
+Enter edit mode with `i` and paste the following configuration:
+
+```properties
+HOST=
+TOKEN=
+```
+
+Fill in the values:
+
+| Variable | Value | Example |
+|----------|-------|---------|
+| `HOST`{lang=properties} | The URL of your Authentik server | `https://auth.domain.com` |
+| `TOKEN`{lang=properties} | The previously copied access token | `Q2pVEqsTNRkJSO9SkJzU3KZ2` |
+
+Press `Esc`, then type `:x` and press `Enter` to save and exit.
+
+If using Dockge, deploy the stack.
+
+Otherwise, via terminal:
+
+```shell
+cd /docker/authentik-outpost/
+sudo docker compose up -d
+```
+
+The container is now running. You can verify its status from your Authentik instance admin panel under _Applications > Outposts_.
+
+Now, let’s configure SWAG.
+
+Open the `authentik-server.conf` file:
+
+```shell
+sudo vi /docker/swag/config/nginx/authentik-server.conf
+```
+
+In the file, press `i` to enter edit mode and change `authentik-server` to `authentik-outpost` as shown:
+
+```nginx
+set $upstream_authentik authentik-outpost;
+proxy_pass http://$upstream_authentik:9000;
+```
+
+Save and exit with `Esc`, then `:x` and `Enter`.
+
+Then configure the applications to protect as you did on your main server, whether they are [native](/serveex/security/authentik/#protecting-a-native-app) or protected via [reverse proxy](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
+
+## Migrating an Authentik Database
+---
+On the source machine, dump the database:
+
+```shell
+sudo docker exec authentik-postgres pg_dump -U authentik -F t authentik > /path/to/mydb.tar
+```
+
+Then transfer it to the target machine. On the target machine, copy the file into the Docker container:
+
+```shell
+cp /path/to/mydb.tar authentik-postgres:/path/to/wherever
+```
+
+(Optional) Purge existing tables:
+
+```shell
+sudo docker exec -i authentik-postgres psql -U authentik -c "SELECT pg_terminate_backend(pg_stat_activity.pid) FROM pg_stat_activity WHERE pg_stat_activity.datname = 'authentik' AND pid <> pg_backend_pid();" && sudo docker exec -i authentik-postgres psql -U authentik -d postgres -c "DROP DATABASE IF EXISTS authentik;" && sudo docker exec -i authentik-postgres psql -U authentik -d postgres -c "CREATE DATABASE authentik;"
+```
+
+Restore the database:
+
+```shell
+sudo docker exec authentik-postgresql pg_restore -U authentik -d authentik /path/to/wherever/mydb.tar
+```

content/3.serveex/3.security/3.cloudflare.md

@@ -0,0 +1,263 @@
+---
+navigation: true
+title: Cloudflare Zero Trust
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Cloudflare Zero Trust
+
+::alert{type="info"}
+🎯 __Goals:__
+  - Understand the concept of Cloudflare Tunnels
+  - Configure your Cloudflare account
+  - Configure SWAG
+  - Manage multiple tunnels
+::
+
+![cloudfare_tunnels](/img/serveex/cloudflared.svg)
+
+## Introduction
+---
+The _Zero Trust_ architecture is the practice of designing systems based on the principle of __"never trust, always verify"__, as opposed to the traditional principle of __"trust, but verify"__. This concept has become increasingly popular recently due to the growing number of attacks targeting user data. It’s a broad concept, but we’ll focus on how to apply _Zero Trust_ to the web services we host.
+
+_Cloudflare tunnels_ offer a simple way to implement _Zero Trust_, using [SWAG](/serveex/core/swag) and [Authentik](/serveex/security/authentik).
+
+Simply put, Cloudflare Tunnels allow you to:
+
+- Hide your server’s IP (and your home IP if it's self-hosted)
+- Authenticate traffic
+- Benefit from Cloudflare protections (DDoS attacks, blacklists, malicious requests, etc.)
+- Use Cloudflare's CDN to cache and speed up your websites
+- Avoid opening router ports for services exposed by SWAG
+
+Here we’ll explain how to integrate SWAG with Cloudflare tunnels.
+
+::alert{type="warning"}
+:::list{type="warning"}
+- __Warning:__
+:::
+- Do not use Cloudflare tunnels to expose a mail server
+- Do not use Cloudflare tunnels to expose a video service like Plex (if you followed [this guide](/serveex/media/plex), Plex is not exposed, so it’s fine)
+- Do not use Cloudflare tunnels for the BitTorrent protocol (if you followed [this guide](/serveex/media/qbittorrent), everything is fine)
+::
+
+## Cloudflare Configuration
+---
+### DNS Zone
+
+First, you need to set Cloudflare as your [DNS zone](/general/networking/dns) manager. If you bought your domain from Cloudflare, that’s already done. Otherwise, check with your registrar how to add external DNS servers. Cloudflare provides [step-by-step documentation](https://developers.cloudflare.com/dns/zone-setups/full-setup/setup/) on how to configure a DNS Zone, whether your domain is external or registered with Cloudflare.
+
+If you only have one server to protect behind Cloudflare, you can delete all existing DNS records. By default, your domain and all its subdomains will be redirected to the tunnel.
+
+If you have subdomains pointing to other servers, you can still define them in the DNS zone using A records.
+
+If you have several servers and tunnels under one domain, [see here](http://192.168.7.80:8005/serveex/cloudflare/#gerer-plusieurs-tunnels-pour-plusieurs-serveurs).
+
+### API Key
+
+Start by creating a new Cloudflare API token and retrieving your zone and account IDs.
+
+On your Cloudflare dashboard, on your domain overview page, you’ll see the `zone` and `account` IDs at the bottom right. Save both securely.
+
+![id and account](/img/serveex/cf-id.png)
+
+Just below that is a link titled _Get your API token_. Click it. The token scope must include `Zone:DNS:Edit` and `Account:Cloudflare Tunnel:Edit`. Your page should look like the screenshot below.
+
+![API token](/img/serveex/cf-token.png)
+
+Once created, your token will only be shown once. Save it securely, as it cannot be viewed again later.
+
+### Cloudflare Zero Trust
+
+You must register for _Cloudflare Teams_ to access the _Zero Trust_ dashboard that manages tunnels and access policies. This is a premium service, but there’s a free plan for up to 50 users—perfect for a home lab. Keep in mind that a valid credit card is required to register, but the free plan incurs no charges.
+
+Register [via this link](https://dash.teams.cloudflare.com/).
+
+## SWAG Configuration
+---
+::alert{type="info"}
+:::list{type="info"}
+- This guide assumes you own `mondomaine.fr` and that its DNS is correctly pointing to Cloudflare, as described above.
+:::
+::
+
+SWAG supports two Docker Mods:
+
+- __Cloudflared__, the container used to create and manage tunnels
+- __Cloudflared Real IP__, which allows SWAG to receive the true source IP of incoming requests instead of Docker’s internal IP (important for IP geolocation mods like DBIP).
+
+These two mods, merged into the SWAG container, require some configuration.
+
+### Tunnel Configuration
+
+Create a file `tunnelconfig.yml` to reference in your SWAG `compose.yaml`.
+
+::alert{type="success"}
+✨ __Tip:__ Use [File Browser](/serveex/files/file-browser) to navigate and edit files instead of using the terminal.
+::
+
+```shell
+sudo vi /docker/swag/config/tunnelconfig.yml
+```
+
+Press `i` to enter insert mode and paste:
+
+```yaml
+ingress:
+  - hostname: mondomaine.fr
+    service: https://mondomaine.fr
+  - hostname: "*.mondomaine.fr"
+    service: https://mondomaine.fr
+  - service: http_status:404
+```
+
+Press `Esc`, then save and exit with `:x` and `Enter`.
+
+### Cloudflare Real IP Configuration
+
+Now configure _Cloudflare Real IP_.
+
+Open the `nginx.conf` file:
+
+```shell
+sudo vi /docker/swag/config/nginx/nginx.conf
+```
+
+Press `i` and add the following at the end of the `http` section:
+
+```nginx
+real_ip_header X-Forwarded-For;
+real_ip_recursive on;
+include /config/nginx/cf_real-ip.conf;
+set_real_ip_from 127.0.0.1;
+```
+
+Save and exit with `:x`.
+
+### Docker Compose
+
+In Dockge, edit your SWAG stack with this:
+
+```yaml
+---
+services:
+  swag:
+    image: lscr.io/linuxserver/swag:latest
+    container_name: swag
+    cap_add:
+      - NET_ADMIN
+    env_file:
+      - .env
+    environment:
+      - DOCKER_MODS=linuxserver/mods:swag-dbip|linuxserver/mods:swag-dashboard|linuxserver/mods:swag-auto-reload|linuxserver/mods:universal-cloudflared|linuxserver/mods:swag-cloudflare-real-ip
+      - PUID=${PUID}
+      - PGID=${PGID}
+      - TZ=Europe/Paris
+      - URL=${DOMAIN}
+      - SUBDOMAINS=wildcard
+      - VALIDATION=dns
+      - DNSPLUGIN=${PLUGIN}
+      - EMAIL=${EMAIL}
+      - CF_ZONE_ID=${ZONE_ID}
+      - CF_ACCOUNT_ID=${ACCOUNT_ID}
+      - CF_API_TOKEN=${API_TOKEN}
+      - CF_TUNNEL_NAME=${TUNNEL_NAME}
+      - CF_TUNNEL_PASSWORD=${TUNNEL_PW}
+      - FILE__CF_TUNNEL_CONFIG=/config/tunnelconfig.yml
+    extra_hosts:
+      - ${DOMAIN}:127.0.0.1
+    ports:
+      - 81:81
+    volumes:
+      - /docker/swag/config:/config
+      - /docker/swag/config/fail2ban/fail2ban.sqlite3:/dashboard/fail2ban.sqlite3:ro
+    restart: unless-stopped
+```
+
+::alert{type="success"}
+✨ __Tip:__ Add a Watchtower label to automate updates:
+
+```yaml
+labels:
+  - com.centurylinklabs.watchtower.enable=true
+```
+::
+
+Fill in your `.env` file:
+
+```properties
+PUID=
+PGID=
+DOMAIN=
+PLUGIN=
+EMAIL=
+ZONE_ID=
+ACCOUNT_ID=
+API_TOKEN=
+TUNNEL_NAME=
+TUNNEL_PW=
+```
+
+| Variable       | Value                                                       | Example                        |
+|----------------|-------------------------------------------------------------|--------------------------------|
+| `PUID`         | User ID (`id username`)                                     | `1000`                         |
+| `GUID`         | Group ID (`id username`)                                    | `1000`                         |
+| `DOMAIN`       | Your reserved domain                                         | `mondomaine.fr`                |
+| `PLUGIN`       | DNS provider (also configure `cloudflare.ini`)              | `cloudflare`                   |
+| `EMAIL`        | Email for the certificate                                   | `you@email.com`                |
+| `ZONE_ID`      | Cloudflare Zone ID                                          | `aNhcz1l3JfWbFZo2XMpzQlP2iOqk` |
+| `ACCOUNT_ID`   | Cloudflare Account ID                                       | `buKsjNHLyzKMM1qYnzOy4s7SHfly` |
+| `API_TOKEN`    | API token                                                   | `53ydYus9TFFk1DOXNdP87iIcJtQjoW` |
+| `TUNNEL_NAME`  | Tunnel name                                                 | `my_tunnel`                    |
+| `TUNNEL_PW`    | Strong, random password                                     | `iSzKRmP4VbnlsMvdSdgBEJiJi`    |
+
+Once done, deploy the stack. Check the logs—you should reach `server ready`.
+
+Then confirm your tunnel appears under _Networks > Tunnels_ in [Cloudflare Zero Trust](https://one.dash.cloudflare.com/). By default, all subdomains will be routed through the tunnel—no need to define them [in your DNS zone](/general/networking/dns).
+
+::alert{type="success"}
+✨ __Tip:__ If you want to expose a service without a tunnel, just define an A record [in your DNS zone](/general/networking/dns). If resolution fails, disable the proxy function for that record—e.g., for `sub.mondomaine.fr`.
+![dns](/img/serveex/cf-dns.png)
+::
+
+## Managing Multiple Tunnels for Multiple Servers
+---
+By default, all subdomains of your domain are routed through the single tunnel. But if you have a second server, just change the tunnel name in that SWAG instance.
+
+In your DNS zone, redirect subdomains to the correct tunnel.
+
+Go to _Networks > Tunnels_ in [Cloudflare Zero Trust](https://one.dash.cloudflare.com/).
+
+Note the tunnel IDs:
+
+![tunnels_id](/img/serveex/cf-tunnels-id.png)
+
+Then in the [Cloudflare DNS dashboard](https://dash.cloudflare.com/), click your domain name.
+
+Click `Add Record` and add these two CNAME records (include `.cfargotunnel.com`):
+
+| Type    | Name         | Target                                |
+|---------|--------------|----------------------------------------|
+| `CNAME` | `subdomain1` | `yourtunnelid1.cfargotunnel.com`       |
+| `CNAME` | `subdomain2` | `yourtunnelid2.cfargotunnel.com`       |
+
+If you have many subdomains, point them to the above reference subdomains.
+
+This way, if a tunnel ID changes, you only update one DNS record.
+
+Example:
+
+- `sub1` and `sub2` also point to the server behind `subdomain1`:
+
+| Type    | Name  | Target        |
+|---------|--------|---------------|
+| `CNAME` | `sub1` | `subdomain1`  |
+| `CNAME` | `sub2` | `subdomain1`  |
+
+- `sub3` and `sub4` point to the server behind `subdomain2`:
+
+| Type    | Name  | Target        |
+|---------|--------|---------------|
+| `CNAME` | `sub3` | `subdomain2`  |
+| `CNAME` | `sub4` | `subdomain2`  |

content/3.serveex/3.security/_dir.yml

@@ -0,0 +1,2 @@
+navigation.title: Security
+icon: lucide:shield

content/3.serveex/4.monitoring/1.uptime-kuma.md

@@ -8,19 +8,19 @@ main:
 # Uptime-Kuma
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer et déployer Uptime-Kuma
-- Exposer Uptime Kuma
-- (Optionnel) Protéger Uptime-Kuma avec Authentik
+🎯 __Goals:__
+- Install and deploy Uptime-Kuma
+- Expose Uptime-Kuma
+- (Optional) Protect Uptime-Kuma with Authentik
 ::
 
-[Uptime-Kuma ](https://github.com/louislam/uptime-kuma)est un conteneur dédié au monitoring de services. Le principe est d'envoyer des requêtes régulières à vos services afin de déterminer s'ils sont en lignes ou non, et de vous alerter le cas échéant. Uptime-Kuma est développé par le meme développeur que Dockge. 
+[Uptime-Kuma](https://github.com/louislam/uptime-kuma) is a container dedicated to service monitoring. The principle is to regularly send requests to your services to determine if they are online, and alert you if not. Uptime-Kuma is developed by the same developer as Dockge.
 
 ![picture](https://user-images.githubusercontent.com/1336778/212262296-e6205815-ad62-488c-83ec-a5b0d0689f7c.jpg)
 
 ## Installation
 ---
-Structure des dossiers
+Folder structure
 
 ```console
 root
@@ -30,7 +30,7 @@ root
         └── compose.yaml
 ```
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `uptime-kuma` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `uptime-kuma`, then copy and paste the following:
 
 ```yaml
 ---
@@ -45,7 +45,7 @@ services:
     restart: always
 ```
 ::alert{type="success"}
-✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the Watchtower label to each container to automate updates
 
     ```yaml
     services:
@@ -55,39 +55,39 @@ services:
           - com.centurylinklabs.watchtower.enable=true
 ::
 
-Vous n'avez plus qu'à accéder à l'outil via `http://ipdevotreserveur:3200`.
+You can now access the tool via `http://yourserverip:3200`.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-## Exposer avec Swag
+## Expose with Swag
 ---
 ::alert{type="info"}
-📋 __Au préalable :__ 
+📋 __Before you begin:__ 
 <br/><br/>
-Nous partons du principe que vous avez le sous-domaine `stats.mondomaine.fr` avec un `CNAME` qui pointe vers `mondomaine.fr` dans votre [zone DNS](/generalites/reseau/dns). Et que bien sûr, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), le port `443` de votre box pointe bien sur le port `443` de votre serveur via [les règles NAT](/generalites/reseau/nat).
+We assume you have the subdomain `stats.mydomain.com` with a `CNAME` pointing to `mydomain.com` in your [DNS zone](/general/networking/dns). And of course, [unless you're using Cloudflare Zero Trust](/serveex/security/cloudflare), port `443` of your router should point to port `443` of your server via [NAT rules](/general/networking/nat).
 ::
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- Uptime-Kuma n'utilise pas d'authentification multifacteur. Exposer Uptime-Kuma sur internet pourrait compromettre les machines auxquelles il est relié. Ne le faite que si vous utilisez un systeme d'authentification multifacteur comme [Authentik](/serveex/securite/authentik/). Sinon, n'exposez pas avec SWAG et utilisez plutôt un VPN comme [Wireguard](/serveex/securite/wireguard).
+- Uptime-Kuma does not use multi-factor authentication. Exposing Uptime-Kuma on the internet could compromise the machines it monitors. Only do this if you're using an MFA system like [Authentik](/serveex/security/authentik/). Otherwise, don’t expose it with SWAG; use a VPN like [Wireguard](/serveex/security/wireguard) instead.
 :::
 ::
 
-Dans les dossiers de Swag, créez le fichier `stats.subdomain.conf`.
+In the Swag folders, create the `stats.subdomain.conf` file.
 
 ::alert{type="success"}
-✨ __Astuce pour les allergiques au terminal :__
-vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip for those who dislike the terminal:__
+you can use [File Browser](/serveex/files/file-browser) to browse and edit your files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/stats.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+Enter insert mode with `i` and paste the following config:
 
 ```nginx
 ## Version 2023/12/19
@@ -139,43 +139,48 @@ server {
     }
 }
 ```
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
 
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau d'Uptime-Kuma :
+Press `Esc`, then save and exit with `:x` and `Enter`.
+
+In Dockge, edit the SWAG compose and add the Uptime-Kuma network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:                 # Relie le conteneur au réseau custom 
+     networks:                 # Link container to custom network 
       # ...           
-      - uptime-kuma            # Nom du réseau déclaré dans la stack
+      - uptime-kuma            # Name of the declared network
 
-networks:                      # Définit le réseau custom
+networks:                      # Define custom network
   # ...
-  uptime-kuma:                 # Nom du réseau déclaré dans la stack
-    name: uptime-kuma_default  # Nom véritable du réseau externe
-    external: true             # Précise que c'est un réseau à rechercher en externe
+  uptime-kuma:                 # Name of the declared network
+    name: uptime-kuma_default  # Actual name of the external network
+    external: true             # Specifies it's an external network
 ```
 
-Relancez la stack et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack and wait until SWAG is fully operational.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de Uptime-Kuma est `uptime-kuma_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant `http://ipduserveur:81`.
+- Here we assume that the network name of Uptime-Kuma is `uptime-kuma_default`. You can verify the connection by visiting SWAG's dashboard at `http://yourserverip:81`.
 :::
 ::
 
-Et voilà, vous avez exposé Uptime-Kuma, vous pouvez y accéder en tapant `https://stats.mondomaine.fr`
+That's it! Uptime-Kuma is now exposed, and you can access it via `https://stats.mydomain.com`.
 
 ::alert{type="success"}
-✨ __Astuce :__ 
+✨ __Tip:__ 
 <br/><br>
-Vous pouvez protéger cette app avec Authentik en ouvrant `stats.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy). Si vous souhaitez que la page publique de stats soit joignable par tout le monde sans authentification:
+You can protect this app with Authentik by opening `stats.subdomain.conf` and uncommenting the lines:  
+`include /config/nginx/authentik-server.conf;`  
+and  
+`include /config/nginx/authentik-location.conf;`.  
+Don’t forget to [create an application and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy). If you want the public stats page to be accessible without authentication:
 
-- Editez le fournisseur d'Uptime-Kuma
-- Dans *paramètres avancés du protocole > chemins authentifiés*, saisissez :
+- Edit the Uptime-Kuma provider
+- In *Advanced Protocol Settings > Authenticated Paths*, enter:
 
     ```properties
     ^/$
@@ -188,11 +193,10 @@ Vous pouvez protéger cette app avec Authentik en ouvrant `stats.subodmain.conf`
     ^/metrics    
 ::
 
-Déployez à nouveau la stack.
-
-Uptime-Kuma sera ainsi joignable directement depuis internet en tapant `https://stats.mondomaine.fr`.
+Redeploy the stack.
 
+Uptime-Kuma will then be publicly reachable via `https://stats.mydomain.com`.
 
 ::alert{type="success"}
-✨ __Astuce :__ Si vous utilisez Authentik et que vous ne craignez pas d'exposer votre panneau admin à votre réseau local, vous pouvez désactiver l'authentification d'Uptime-Kuma via les paramètres, afin de ne garder que celle d'Authentik.
+✨ __Tip:__ If you're using Authentik and don't mind exposing the admin panel to your local network, you can disable Uptime-Kuma's native authentication in its settings and rely solely on Authentik.
 ::

content/3.serveex/4.monitoring/2.dozzle.md

@@ -8,18 +8,18 @@ main:
 # Dozzle
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer Dozzle
-- Exposer Dozzle avec Swag
+🎯 __Goals:__
+- Install Dozzle
+- Expose Dozzle with Swag
 ::
 
-[Dozzle](https://dozzle.dev/) est un conteneur permettant d'accéder au logs de vos conteneurs et de les afficher en temps réel de via une interface user-friendly. C'est une manière simple de naviguer entre les logs et de retrouver des informations dans l'historique.
+[Dozzle](https://dozzle.dev/) is a container that lets you access logs from your other containers and display them in real time through a user-friendly interface. It's a simple way to browse logs and retrieve information from the history.
 
 ![Dozzle](https://blog.unixhost.pro/wp-content/uploads/2023/03/image-5.png)
 
 ## Installation
 ---
-Structure des dossiers
+Folder structure
 
 ```console
 root
@@ -28,7 +28,7 @@ root
         └── data
 ```
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `dozzle` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `dozzle`, then copy and paste the following:
 
 ```yaml
 ---
@@ -47,7 +47,7 @@ services:
 ```
 
 ::alert{type="success"}
-✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the watchtower label to each container to automate updates
 
     ```yaml
     services:
@@ -57,68 +57,67 @@ services:
           - com.centurylinklabs.watchtower.enable=true
 ::
 
-Renseignez le `.env` votre nom de domaine, par exemple
+Fill in your domain name in the `.env` file, for example:
 
 ```properties
-DOMAIN=dozzle.mondomaine.fr
+DOMAIN=dozzle.mydomain.com
 ```
 
-Déployez le conteneur et rendez-vous sur `http://ipduserveur:9135`. Et voilà, votre instance Dozzle en webui est disponible !
+Deploy the container. Go to `http://yourserverip:9135`. Voilà, your Dozzle web UI is up and running!
 
-## Exposer Dozzle avec Swag
+## Exposing Dozzle with Swag
 ---
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- Dozzle n'utilise pas d'authentification multifacteur. Exposer Dozzle sur internet pourrait compromettre les machines auxquelles il est relié. Ne le faite que si vous utilisez un systeme d'authentification multifacteur comme [Authentik](/serveex/securite/authentik/). Sinon, n'exposez pas avec SWAG et utilisez plutôt un VPN comme [Wireguard](/serveex/securite/wireguard).
+- Dozzle does not use multi-factor authentication. Exposing Dozzle to the internet could compromise the connected machines. Only do this if you use a multi-factor authentication system like [Authentik](/serveex/security/authentik/). Otherwise, do not expose it with SWAG and instead use a VPN like [Wireguard](/serveex/security/wireguard).
 :::
 ::
 
-Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer Dozzle via Swag.
+You may want to access Dozzle remotely and on all your devices. To do so, we’ll expose Dozzle via Swag.
 
 ::alert{type="info"}
-📋 __Au préalable :__
+📋 __Before you begin:__
 <br/><br/>
-Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `dozzle.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+We assume you have created a subdomain like `dozzle.mydomain.com` in your [DNS zone](/general/networking/dns) with a `CNAME` pointing to `mydomain.com` and that, [unless you're using Cloudflare Zero Trust](/serveex/security/cloudflare), you’ve redirected port `443` from your router to port `443` on your server in your [NAT rules](/general/networking/nat).
 ::
 
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Dozzle :
+Go to Dockge and edit the SWAG compose file to add Dozzle’s network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:                 # Relie le conteneur au réseau custom 
+     networks:                 # Connects the container to a custom network
       # ...           
-      - dozzle           # Nom du réseau déclaré dans la stack
+      - dozzle                 # Network name declared in the stack
     
-networks:                      # Définit le réseau custom
+networks:                      # Defines the custom network
   # ...
-  dozzle:                 # Nom du réseau déclaré dans la stack
-    name: dozzle_default  # Nom véritable du réseau externe
-    external: true             # Précise que c'est un réseau à rechercher en externe
+  dozzle:                      # Network name declared in the stack
+    name: dozzle_default       # Actual name of the external network
+    external: true             # Indicates it's an externally defined network
 ```
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Redeploy the stack by clicking “Deploy” and wait for SWAG to be fully operational.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de Dozzle est `dozzle_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant `http://ipduserveur:81`.
+- We assume the Dozzle network name is `dozzle_default`. You can verify the connection is working by visiting the SWAG dashboard at `http://yourserverip:81`.
 :::
 ::
 
-
-Dans les dossiers de Swag, créez le fichier `dozzle.subdomain.conf`.
+In the Swag folder, create the `dozzle.subdomain.conf` file.
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ You can use [File Browser](/serveex/files/file-browser) to browse and edit files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/dozzle.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+Enter edit mode by pressing `i` and paste the configuration below:
 
 ```nginx
 ## Version 2023/12/19
@@ -171,10 +170,10 @@ server {
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, then save and exit by typing `:x` and pressing `Enter`.
 
-Et voilà, vous avez exposé Dozzle !
+And there you go, Dozzle is now exposed!
 
 ::alert{type="success"}
-✨ Vous pouvez protéger cette app avec Authentik en ouvrant `dozzle.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ You can protect this app with Authentik by opening `dozzle.subdomain.conf` and removing the `#` in front of `include /config/nginx/authentik-server.conf;`{lang=nginx} and `include /config/nginx/authentik-location.conf;`{lang=nginx}. Don’t forget to [create an application and a provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::

content/3.serveex/4.monitoring/3.speedtest-tracker.md

@@ -8,12 +8,12 @@ main:
 # Speedtest Tracker
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer Speedtest Tracker
-- Exposer Speedtest Tracker avec Swag
+🎯 **Objectives:**
+- Install Speedtest Tracker  
+- Expose Speedtest Tracker with SWAG  
 ::
 
-[Speedtest Tracker](https://docs.speedtest-tracker.dev/) est un conteneur permettant de programmer des speedtest régulier afin d'historiser l'état de la connexion internet de votre serveur.
+[Speedtest Tracker](https://docs.speedtest-tracker.dev/) is a container that allows you to schedule regular speed tests in order to log your server's internet connection status.
 
 ![speedtest-tracker](/img/serveex/speedtest-tracker.avif)
 
@@ -21,11 +21,11 @@ main:
 ---
 ::alert{type="info"}
 :::list{type="info"}
-- Nous utiliserons l'image docker maintenue par [LinuxServer.io](https://docs.linuxserver.io/images/docker-speedtest-tracker/)
+- We will use the Docker image maintained by [LinuxServer.io](https://docs.linuxserver.io/images/docker-speedtest-tracker/)
 :::
 ::
 
-Structure des fichiers
+File structure:
 
 ```console
 root
@@ -35,15 +35,15 @@ root
             └── config
 ```
 
-Dans un terminal, générez une clé avec la commande suivante :
+In a terminal, generate a key using the following command:
 
 ```shell
 echo -n 'base64:'; openssl rand -base64 32;
 ```
 
-Notez la clé.
+Take note of the key.
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `speedtest-tracker` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `speedtest-tracker`, then paste the following:
 
 ```yaml
 ---
@@ -65,51 +65,50 @@ services:
             - /docker/speedtest-tracker/data/config:/config
 ```
 
-Trouvez votre `PUID` et votre `GUID` en tapant la commande suivante :
+Find your `PUID` and `GUID` by running the following command:
 
 ```shell
-id nomdutilisateur
+id yourusername
 ```
 
-Dans `.env` renseignez la variable `API_KEY` avec la clé que vous avez générée et un planning de test au format cron, ainsi que vos `PUID` et `GUID`, par exemple :
+In the `.env` file, set the variable `API_KEY` with the key you generated and add a cron-style test schedule, as well as your `PUID` and `GUID`, for example:
 
 ```properties
-SCHEDULE=15 */6 * * * # toutes les 6h
-KEY=base64:zihejehkj8_nzhY/OjeieR= # votre clé
+SCHEDULE=15 */6 * * * # every 6 hours
+KEY=base64:zihejehkj8_nzhY/OjeieR= # your key
 PUID=1000
 GUID=1000
-PORT=3225 # port d'accès à la webui
+PORT=3225 # port to access the web UI
 ```
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez configurer d'autres variables d'environnements en consultant la [documentation officielle](https://docs.speedtest-tracker.dev/getting-started/environment-variables).
+✨ **Tip:** You can configure additional environment variables by referring to the [official documentation](https://docs.speedtest-tracker.dev/getting-started/environment-variables).
 ::
 
-Déployez le conteneur et rendez-vous sur http://ipduserveur:3225. Connectez vous avec le compte `admin@exemple.com` et le mot de passe `password`. N'oubliez pas de changer votre id et votre mot de apsse une fois connecté !
+Deploy the container and go to `http://yourserverip:3225`. Log in with the account `admin@exemple.com` and the password `password`. Don’t forget to change your ID and password once logged in!
 
-
-## Exposer Speedtest Tracker
+## Expose Speedtest Tracker
 ---
 ::alert{type="info"}
-📋 __Prérequis :__ <br/></br>
-Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `speedtest.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+📋 **Prerequisites:**  
+We assume that you've already created a subdomain like `speedtest.yourdomain.com` in your [DNS zone](/general/networking/dns) with a `CNAME` pointing to `yourdomain.com`, and [unless you’re using Cloudflare Zero Trust](/serveex/security/cloudflare), you've also forwarded port `443` from your router to port `443` of your server in your [NAT rules](/general/networking/nat).
 ::
 
-Il s'agit maintenant d'exposer Speedtest Tracker sur internet, afin de pouvoir y accéder sans que vous soyez chez vous. Pour cela, nous partons du principe que vous avez configuré un sous domaine `speedtest.mondomaine.fr` dans votre zone DNS dont le `CNAME` pointe sur `mondomaine.fr`.
+Now we want to expose Speedtest Tracker to the internet so you can access it remotely. We assume you've set up the DNS `CNAME` for `speedtest.yourdomain.com` pointing to `yourdomain.com`.
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- Speedtest Tracker n'utilise pas d'authentification multifacteur. Exposer Speedtest Tracker sur internet pourrait compromettre les machines auxquelles il est relié. Ne le faite que si vous utilisez un systeme d'authentification multifacteur comme [Authentik](/serveex/securite/authentik/). Sinon, n'exposez pas avec SWAG et utilisez plutôt un VPN comme [Wireguard](/serveex/securite/wireguard).
+- Speedtest Tracker does not use multi-factor authentication. Exposing it on the internet could compromise connected devices. Do so only if you use a multi-factor system like [Authentik](/serveex/security/authentik/). Otherwise, avoid using SWAG and prefer a VPN like [Wireguard](/serveex/security/wireguard).
 :::
 ::
 
-Ouvrez le fichier speedtest.subdomain.conf :
+Open the `speedtest.subdomain.conf` file:
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/speedtest.subdomain.conf
 ```
 
-Paramétrez le comme tel :
+Configure it like this:
 
 ```nginx
 ## Version 2023/12/19
@@ -118,7 +117,6 @@ server {
     listen 443 ssl;
     listen [::]:443 ssl;
     
-    # indique que le sous-domaine doit être dirigé
     server_name speedtest.*;  
 
     include /config/nginx/ssl.conf;
@@ -127,80 +125,72 @@ server {
 
     #if ($lan-ip = yes) { set $geo-whitelist yes; }
     #if ($geo-whitelist = no) { return 404; }
-    # indique que les pays dans la blacklist sont intedits
     if ($geo-blacklist = no) { return 404; } 
 
-    # enable for ldap auth (requires ldap-location.conf in the location block)
+    # Authentication options (uncomment as needed)
     #include /config/nginx/ldap-server.conf;
-
-    # enable for Authelia (requires authelia-location.conf in the location block)
     #include /config/nginx/authelia-server.conf;
-
-    # enable for Authentik (requires authentik-location.conf in the location block)
     #include /config/nginx/authentik-server.conf;
 
     location / {
-        # enable the next two lines for http auth
+        # Basic auth
         #auth_basic "Restricted";
         #auth_basic_user_file /config/nginx/.htpasswd;
 
-        # enable for ldap auth (requires ldap-server.conf in the server block)
+        # Per-location authentication
         #include /config/nginx/ldap-location.conf;
-
-        # enable for Authelia (requires authelia-server.conf in the server block)
         #include /config/nginx/authelia-location.conf;
-
-        # enable for Authentik (requires authentik-server.conf in the server block)
         #include /config/nginx/authentik-location.conf;
 
         include /config/nginx/proxy.conf;
         include /config/nginx/resolver.conf;
         
-        set $upstream_app speedtest-tracker; # Nom du conteneur
-        set $upstream_port 3225; # Port interne conteneur
+        set $upstream_app speedtest-tracker;
+        set $upstream_port 3225;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 }
 ```
 
-Sauvegardez et quittez. La configuration va se mettre à jour en quelques secondes. 
+Save and exit. The configuration will update in a few seconds.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Par défaut, swag ne connait pas le nom "speedtest-tracker". Pour qu'il puisse y accéder, vous devez rajouter le réseau de Speedtest Tracker dans le `compose.yml` de SWAG.
+- By default, SWAG doesn’t know the name "speedtest-tracker". To allow access, you need to add Speedtest Tracker’s network to SWAG’s `compose.yml`.
 :::
 ::
 
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Speedtest Tracker :
+Go to Dockge, and edit SWAG’s compose to include Speedtest Tracker’s network:
 
 ```yaml
 services:
   swag:
-     container_name: # ...
+    container_name: # ...
+    # ...
+    networks:
       # ...
-     networks:                       # Relie le conteneur au réseau custom 
-      # ...           
-      - speedtest-tracker            # Nom du réseau déclaré dans la stack
+      - speedtest-tracker
 
-networks:                            # Définit le réseau custom
+networks:
   # ...
-  speedtest-tracker:                 # Nom du réseau déclaré dans la stack
-    name: speedtest-tracker_default  # Nom véritable du réseau externe
-    external: true                   # Précise que c'est un réseau à rechercher en externe
+  speedtest-tracker:
+    name: speedtest-tracker_default
+    external: true
 ```
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack by clicking "Deploy" and wait for SWAG to be fully up.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de Speedtest Tracker est `speedtest-tracker_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant `http://ipduserveur:81`.
+- This assumes the Speedtest Tracker network is named `speedtest-tracker_default`. You can verify the connection by visiting SWAG’s dashboard at `http://yourserverip:81`.
 :::
 ::
 
-Patientez puis tapez `https://speedtest.mondomaine.fr` dans votre navigateur, vous devriez être redirigé vers speedtest-tracker. Vous pouvez vérifier le statut du service via le dashboard (depuis votre réseau local, http://ipdevotreserveur:81).
+Wait a moment, then visit `https://speedtest.yourdomain.com` in your browser — you should be redirected to Speedtest Tracker. You can check service status via the dashboard (`http://yourserverip:81` from the local network).
 
 ::alert{type="success"}
-✨ Vous pouvez protéger cette app avec Authentik en ouvrant `speedtest.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ You can protect this app with Authentik by opening `speedtest.subdomain.conf` and uncommenting  
+`include /config/nginx/authentik-server.conf;` and `include /config/nginx/authentik-location.conf;`.  
+Don’t forget to [create an application and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::

content/3.serveex/4.monitoring/4.beszel.md

@@ -8,23 +8,23 @@ main:
 # Beszel
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer Beszel
-- Monitorer le serveur local
-- Monitorer un serveur distant
-- Exposer Beszel avec Swag
+🎯 __Objectives:__
+- Install Beszel
+- Monitor the local server
+- Monitor a remote server
+- Expose Beszel with Swag
 ::
 
-[Beszel](https://beszel.dev/) est un conteneur permettant d'accéder aux informations du hardware de vos serveurs en temps réel et de les historiser. Activité CPU, usages des disques, températures, RAM, vous ne raterez rien de l'état de votre serveur. Beszel permet également de paramétrer des notifications et alertes en cas de dépassement de limites que vous avez choisies.
+[Beszel](https://beszel.dev/) is a container that gives you real-time access to hardware information from your servers and allows historical tracking. CPU activity, disk usage, temperatures, RAM—nothing escapes your monitoring. Beszel also lets you configure notifications and alerts when your predefined thresholds are exceeded.
 
-Beszel dispose d'un hub avec une webui et d'un agent qui permet de collecter les données depuis votre serveur ou sur un serveur distant.
+Beszel includes a hub with a web UI and an agent that collects data from your server or a remote server.
 
 ![Beszel](/img/serveex/beszel.png)
 
 ## Installation
 ---
 
-Structure des dossiers
+Folder structure
 
 ```console
 root
@@ -32,10 +32,9 @@ root
     └── beszel
         ├── data
         └── socket
-
 ```
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `beszel` puis copiez collez ceci :
+Open Dockge, click `compose`, name the stack `beszel`, and paste the following:
 
 ```yaml
 ---
@@ -65,52 +64,53 @@ services:
 ```
 
 ::alert{type="success"}
-✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the Watchtower label to each container to automate updates.
 
-    ```yaml
-    services:
-      beszel:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
+```yaml
+services:
+  beszel:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+```
 ::
 
-Renseignez le `.env`, par exemple :
+Fill out the `.env` file, for example:
 
 ```properties
-PORT=8090 # port de la webui
-KEY= # clé privée à récupérer dans Beszel lors que vous ajoutez un système
+PORT=8090 # web UI port
+KEY= # private key to retrieve from Beszel when adding a system
 ```
-Pour la valeur `KEY`, il faudra lancer Beszel une première fois pour la saisir.
 
-Déployez le conteneur et rendez-vous sur `http://ipduserveur:8090`. Et voilà, votre instance Beszel en webui est disponible !
+For the `KEY` value, you'll need to launch Beszel once to get it.
+
+Deploy the container and go to `http://yourserverip:8090`. Your Beszel web UI is now accessible!
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-### Ajouter les informations du serveur local
+### Add local server information
 
-Maintenant que la webui est accessible, vous devez faire remonter les informations du serveur dedans. Pour cela, il vous suffit d'ajouter une machine dans la webui et de paraméter comme ceci :
+Now that the web UI is accessible, you need to push local server information into it. Just add a machine via the web UI and configure it like this:
 
 ![Beszel add system](/img/serveex/beszel-add.png)
 
-Note la clé privée et validez. Renseignez la clé dans votre `.env` dans dockge, et redéployez la stack. Lorsque vous retournerez sur la webui, votre serveur apparaitra :
+Note the private key and confirm. Enter the key in your `.env` file in Dockge and redeploy the stack. Once done, your server will appear in the web UI:
 
-![Beszel add system](/img/serveex/beszel-system.png)
+![Beszel system](/img/serveex/beszel-system.png)
 
+### Add a remote server
 
-### Ajouter les informations d'un serveur distant
+You can also monitor a remote server. To do so, run the agent on the remote server. Add a new machine in Beszel and fill in:
 
-Vous pouvez également monitorer un serveur distant. Pour cela vous avez juste à faire tourner l'agent sur le serveur distant. Pour cela, ajoutez une nouvelle machine dans Beszel et renseignez :
+- The name displayed for your remote server
+- The IP address or domain name of the remote server
+- The listening port (e.g., `45876`)
 
-- Le nom qui s'affichera dans Beszel pour votre serveur distant
-- L'adresse IP ou le nom de domaine de votre serveur distant
-- Le port d'écoute de votre serveur distant (dans notre exemple cela sera `45876`)
-
-Beszel vous proposera de copier directement le `compose.yaml` à déployer sur votre serveur distant, ou vous pouvez le configurer comme suit :
+Beszel will suggest a `compose.yaml` to deploy on the remote server, or you can use:
 
 ```yaml
 ---
@@ -127,73 +127,75 @@ services:
       KEY: ${KEY}
 ```
 
-Et dans le `.env` :
+And in `.env`:
 
 ```properties
-PORT=45876 # port de communication entre votre hub et l'agent à distance
-KEY= # clé privée à récupérer dans Beszel lors que vous ajoutez un système
+PORT=45876 # communication port between hub and remote agent
+KEY= # private key from Beszel when adding the system
 ```
-Déployez la stack sur votre serveur distant. Les informations du serveur distant remontront au bout de quelques secondes dans votre webui.
+
+Deploy the stack on the remote server. Data will begin flowing into the web UI after a few seconds.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-## Exposer Beszel avec Swag
+## Expose Beszel with Swag
 ---
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- Beszel n'utilise pas d'authentification multifacteur. Exposer Beszel sur internet pourrait compromettre les machines auxquelles il est relié. Ne le faite que si vous utilisez un systeme d'authentification multifacteur comme [Authentik](/serveex/securite/authentik/). Sinon, n'exposez pas avec SWAG et utilisez plutôt un VPN comme [Wireguard](/serveex/securite/wireguard).
+- Beszel does not support multi-factor authentication. Exposing it on the internet could compromise connected machines. Only do this if you're using a system like [Authentik](/serveex/security/authentik/). Otherwise, do not expose with SWAG—use a VPN like [Wireguard](/serveex/security/wireguard) instead.
 :::
 ::
 
-Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer Beszel via Swag.
+If you want to access Beszel remotely from all your devices, expose it using Swag.
 
 ::alert{type="info"}
-📋 __Au préalable :__
+📋 __Prerequisite:__
 <br/><br/>
-Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `beszel.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+You must have created a DNS subdomain like `beszel.mydomain.com` with a `CNAME` pointing to `mydomain.com`, and—unless you're using Cloudflare Zero Trust—you must have forwarded port `443` on your router to your server’s `443` port via [NAT rules](/general/networking/nat).
 ::
 
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Beszel :
+In Dockge, edit Swag's compose file and add Beszel’s network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ...
-     networks:            # Relie le conteneur au réseau custom 
+     networks:
       # ...
-      - beszel            # Nom du réseau déclaré dans la stack
+      - beszel            # network declared in the stack
 
-networks:                 # Définit le réseau custom
+networks:
   # ...
-  beszel:                 # Nom du réseau déclaré dans la stack
-    name: beszel_default  # Nom véritable du réseau externe
-    external: true        # Précise que c'est un réseau à rechercher en externe
+  beszel:
+    name: beszel_default  # actual external network name
+    external: true
 ```
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Redeploy the stack and wait for Swag to become fully operational.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de beszel est `beszel_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant `http://ipduserveur:81`.
+- We assume the network name is `beszel_default`. You can check connectivity by visiting Swag's dashboard at `http://yourserverip:81`.
 :::
 ::
 
-Dans les dossiers de Swag, créez le fichier `beszel.subdomain.conf`.
+In Swag’s config folders, create `beszel.subdomain.conf`.
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ Use [File Browser](/serveex/files/file-browser) to browse and edit files instead of terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/beszel.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+
+Press `i` to enter insert mode and paste:
 
 ```nginx
 ## Version 2023/12/19
@@ -212,27 +214,21 @@ server {
     #if ($geo-whitelist = no) { return 404; }
     if ($geo-blacklist = no) { return 404; }
 
-    # enable for ldap auth (requires ldap-location.conf in the location block)
+    # enable for ldap auth
     #include /config/nginx/ldap-server.conf;
 
-    # enable for Authelia (requires authelia-location.conf in the location block)
+    # enable for Authelia
     #include /config/nginx/authelia-server.conf;
 
-    # enable for Authentik (requires authentik-location.conf in the location block)
+    # enable for Authentik
     #include /config/nginx/authentik-server.conf;
 
     location / {
-        # enable the next two lines for http auth
         #auth_basic "Restricted";
         #auth_basic_user_file /config/nginx/.htpasswd;
 
-        # enable for ldap auth (requires ldap-server.conf in the server block)
         #include /config/nginx/ldap-location.conf;
-
-        # enable for Authelia (requires authelia-server.conf in the server block)
         #include /config/nginx/authelia-location.conf;
-
-        # enable for Authentik (requires authentik-server.conf in the server block)
         #include /config/nginx/authentik-location.conf;
 
         include /config/nginx/proxy.conf;
@@ -241,15 +237,14 @@ server {
         set $upstream_port 8090;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, type `:x`, and hit `Enter` to save and exit.
 
-Et voilà, vous avez exposé Beszel !
+That’s it—Beszel is now exposed!
 
 ::alert{type="success"}
-✨ Vous pouvez protéger cette app avec Authentik en ouvrant `beszel.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ You can protect this app with Authentik by opening `beszel.subdomain.conf` and removing the `#` in front of `include /config/nginx/authentik-server.conf;` and `include /config/nginx/authentik-location.conf;`. Don’t forget to [create an application and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::

content/3.serveex/4.monitoring/5.upsnap.md

@@ -8,19 +8,19 @@ main:
 # UpSnap
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer UpSnap
-- Exposer UpSnap avec Swag
+🎯 __Goals:__
+- Install UpSnap
+- Expose UpSnap with Swag
 ::
 
-[UpSnap](https://github.com/seriousm4x/UpSnap) est un conteneur permettant d'allumer, éteindre, ou mettre en veille vos machines à distance. Il utilise essentiellement le systeme de Wake-On-Lan (WoL) par le réseau et dispose d'autres fonctions avancées.
+[UpSnap](https://github.com/seriousm4x/UpSnap) is a container that allows you to remotely power on, shut down, or put your machines to sleep. It mainly uses Wake-On-Lan (WoL) over the network and offers advanced features.
 
 ![Beszel](/img/serveex/upsnap.webp)
 
 ## Installation
 ---
 
-Structure des dossiers
+Folder structure
 
 ```console
 root
@@ -29,7 +29,7 @@ root
         └── data
 ```
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `upsnap` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `upsnap`, then copy and paste the following:
 
 ```yaml
 ---
@@ -55,7 +55,7 @@ services:
 ```
 
 ::alert{type="success"}
-✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the watchtower label to each container to automate updates
 
     ```yaml
     services:
@@ -65,74 +65,74 @@ services:
           - com.centurylinklabs.watchtower.enable=true
 ::
 
-Renseignez le `.env`, par exemple :
+Fill in the `.env`, for example:
 
 ```properties
-RANGE=192.168.1.0/24 # scan toutes les machines sur le réseau local ayant une adresse IP comprise entre 192.168.0.1 et 192.168.1.255
-DNS=192.168.1.1 # IP du dns à utiliser pour résoudre les noms de domaines, ici dans l'exemple c'est généralement l'IP du routeur
+RANGE=192.168.1.0/24 # scans all devices on the local network with an IP between 192.168.0.1 and 192.168.1.255
+DNS=192.168.1.1 # DNS IP to resolve domain names, typically your router’s IP
 ```
 
-Déployez le conteneur et rendez-vous sur `http://ipduserveur:8095`. Vous n'avez plus qu'à suivre les instructions pour créer votre compte !
+Deploy the container and go to `http://yourserverip:8095`. Just follow the steps to create your account!
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-## Exposer UpSnap avec Swag
+## Exposing UpSnap with Swag
 ---
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- UpSnap n'utilise pas d'authentification multifacteur. Exposer UpSnap sur internet pourrait compromettre les machines auxquel il est relié. Ne le faite que si vous utilisez un systeme d'authentification multifacteur comme [Authentik](/serveex/securite/authentik/). Sinon, n'exposez pas avec SWAG et utilisez plutôt un VPN comme [Wireguard](/serveex/securite/wireguard).
+- UpSnap does not support multi-factor authentication. Exposing it on the internet could compromise connected machines. Do this only if you're using a multi-factor authentication system like [Authentik](/serveex/security/authentik/). Otherwise, avoid exposing it with SWAG and use a VPN like [Wireguard](/serveex/security/wireguard) instead.
 :::
 ::
 
-Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer UpSnap via Swag.
+You may want to access it remotely from all your devices. To do so, we'll expose UpSnap via Swag.
 
 ::alert{type="info"}
-📋 __Au préalable :__
+📋 __Beforehand:__
 <br/><br/>
-Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `upsnap.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+We assume you've created a subdomain in your [DNS zone](/general/networking/dns), such as `upsnap.yourdomain.com` with a `CNAME` to `yourdomain.com`. Also, unless you're using Cloudflare Zero Trust, you should have already forwarded port `443` from your router to port `443` on your server in your [NAT rules](/general/networking/nat).
 ::
 
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de UpSnap :
+Go to Dockge, and edit the SWAG compose by adding the UpSnap network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:                       # Relie le conteneur au réseau custom 
+     networks:                       # Connects the container to the custom network 
       # ...           
-      - upsnap                       # Nom du réseau déclaré dans la stack
+      - upsnap                       # Network name declared in the stack
     
-networks:                            # Définit le réseau custom
+networks:                            # Defines the custom network
   # ...
-  upsnap:                 # Nom du réseau déclaré dans la stack
-    name: upsnap_default             # Nom véritable du réseau externe
-    external: true                   # Précise que c'est un réseau à rechercher en externe
+  upsnap:                 # Network name declared in the stack
+    name: upsnap_default             # Actual name of the external network
+    external: true                   # Indicates it's an external network
 ```
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack by clicking "deploy" and wait for SWAG to be fully operational.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de upsnap est `upsnap_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant `http://ipduserveur:81`.
+- Here we assume the network name for upsnap is `upsnap_default`. You can check the connection in the SWAG dashboard at `http://yourserverip:81`.
 :::
 ::
 
-Dans les dossiers de Swag, créez le fichier `upsnap.subdomain.conf`.
+In the Swag folders, create the file `upsnap.subdomain.conf`.
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ You can use [File Browser](/serveex/files/file-browser) to navigate your files and edit documents instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/upsnap.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+Enter edit mode by pressing `i`, and paste the following configuration:
 
 ```nginx
 ## Version 2023/12/19
@@ -185,10 +185,10 @@ server {
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Escape`, then save and exit by typing `:x` and pressing `Enter`.
 
-Et voilà, vous avez exposé UpSnap !
+And that’s it — you’ve exposed UpSnap!
 
 ::alert{type="success"}
-✨ Vous pouvez protéger cette app avec Authentik en ouvrant `upsnap.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ You can protect this app with Authentik by opening `upsnap.subdomain.conf` and removing the `#` in front of `include /config/nginx/authentik-server.conf;`{lang=nginx} and `include /config/nginx/authentik-location.conf;`{lang=nginx}. Don’t forget to [create an application and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::

content/3.serveex/5.media/1.plex.md

@@ -8,32 +8,32 @@ main:
 # Plex
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer Plex
-- Installer Tautulli
-- Accéder aux media depuis l'exterieur
+🎯 **Objectives:**
+- Install Plex
+- Install Tautulli
+- Access media from outside your network
 ::
 
-[Plex](https://www.plex.tv/fr/) est une plateforme de streaming vidéo déployable chez vous, pour manager votre bibliothèque de films ou de série, et les lire en locale ou à distance. Plex dispose d'applications TV, Android, iOS, Window et Mac OS, permettant la lecture de vos bibliothèques, à la Netflix. 
+[Plex](https://www.plex.tv/fr/) is a self-hosted video streaming platform for managing your movie or TV show library and playing them locally or remotely. Plex has apps for TV, Android, iOS, Windows, and macOS, allowing you to stream your library just like Netflix.
 
-Avec le *plexpass*, vous pouvez également organsier et lire vos contenus audio, à la spotify, la différence étant que c'est bien votre contenu qui est hébergé et lu depuis chez vous.
+With *Plex Pass*, you can also organize and play your music content similar to Spotify, the difference being that it’s your content, hosted and streamed from your server.
 
 ![picture](/img/serveex/plex.png)
 
-On installera également [Tautulli](https://docs.linuxserver.io/images/docker-tautulli/), un outil qui permet d'avoir des stats poussées sur Plex. On utilisera, comme dès qu'on le peut, les images de linuxserver.io.
+We'll also install [Tautulli](https://docs.linuxserver.io/images/docker-tautulli/), a tool that provides detailed stats about Plex. As always, we'll use linuxserver.io images where possible.
 
-- [Plus d'info sur le conteneur Plex](https://docs.linuxserver.io/images/docker-plex)
-- [Plus d'info sur le conteneur Tautulli](https://docs.linuxserver.io/images/docker-tautulli/)
+- [More info on the Plex container](https://docs.linuxserver.io/images/docker-plex)
+- [More info on the Tautulli container](https://docs.linuxserver.io/images/docker-tautulli/)
 
 ::alert{type="info"}
 :::list{type="info"}
-- Vous serez amenés à creer un compte *Plex.tv*. Vous n'avez pas besoin d'exposer votre service Plex, il sera accessible directement par la plateforme. Votre serveur Plex sera gérable directement depuis votre compte.
+- You’ll need to create a *Plex.tv* account. You don’t need to expose your Plex service; it will be accessible through the platform. Your Plex server will be manageable directly from your account.
 :::
 ::
 
-## Installer Plex
+## Install Plex
 ---
-Structure des dossiers :
+Folder structure:
 ```console
 root
 ├── docker
@@ -50,14 +50,14 @@ root
     └── library
 ```
 
-Créez les dossiers `movies`, `tvseries` et `library` dans /media :
+Create the `movies`, `tvseries`, and `library` folders in `/media`:
 
 ```sh
 mkdir -p /media/movies /media/library /media/tvseries
 ```
 
-Ouvrez Dockge dans votre navigeateur, et cliquez sur `compose`.
-Nommez la stack `plex` et ajoutez la config suivante :
+Open Dockge in your browser and click `compose`.  
+Name the stack `plex` and add the following config:
 
 ```yaml
 ---
@@ -96,115 +96,119 @@ services:
 ```
 
 ::alert{type="success"}
-✨ Ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ Add the Watchtower label to each container to automate updates:
 
-    ```yaml
-    services:
-      plex:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
+```yaml
+services:
+  plex:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
 
-      tautulli:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
+  tautulli:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+```
 ::
 
-Trouvez votre PUID et votre GUID en tapant la commande suivante :
+Find your PUID and GUID by running:
 
 ```shell
-id nomdutilisateur
+id username
 ```
-Et renseignez le `.env` avec les infos que vous avez trouvées, par exemple :
+
+Fill in your `.env` file with the retrieved values, for example:
 
 ```properties
 PUID=1000
 GUID=1000
 ```
-Déployez la stack.
 
-L'interface locale est disponible via `http://ipduserveur:32400/web/index.html`. L'interface de Tautulli est joignable via `http://ipduserveur:8181`.
+Deploy the stack.
+
+The local interface is available at `http://yourserverip:32400/web/index.html`.  
+Tautulli is accessible at `http://yourserverip:8181`.
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- Vous devez impérativement être sur votre réseau local au moment du premier setup de Plex, sans quoi l'url vous renverra sur votre compte Plex sans detecter votre serveur. Un VPN ne vous sauvera pas. Si vous ne pouvez pas faire autrement, [vous pouvez gérer l'installation à distance via un tunnel SSH](https://support.plex.tv/articles/200288586-installation/#toc-2).
+- You must be on your local network during Plex's initial setup. Otherwise, the URL will redirect to your Plex account without detecting your server. A VPN won't help. If you have no choice, [you can handle the setup remotely via SSH tunnel](https://support.plex.tv/articles/200288586-installation/#toc-2).
 :::
 ::
 
-## Paramétrer Plex
+## Configure Plex
 ---
-Plex propose tout une gamme de film/série gratuitement. Après avoir créé votre compte, et pour ne pas polluer votre bibliothèque, je vous conseille de tout désactiver dans la section _Services en ligne_.
+Plex offers a range of free movies/shows. After creating your account, I recommend disabling everything in the _Online Services_ section to keep your library clean.
 
-Ensuite rendez-vous dans la section _Accès à distance_ et choisissez un port manuellement (ici cela sera `1234`). Il est préférable de ne pas garder le port d'origine.
+Then go to the _Remote Access_ section and manually select a port (we’ll use `1234`). It's best not to use the default port.
 
 ![picture](/img/serveex/plex-port.png)
 
-- Sur votre routeur, redirigez le port `TCP` source `1234` vers le port `32400`, vers l'IP de votre serveur via [les règles NAT](/generalites/reseau/nat).
-- Une fois fait, retournez dans Plex afin de vérifier que la connexion est bien opérationnelle
+- On your router, forward TCP port `1234` to port `32400` for your server’s IP using [NAT rules](/general/networking/nat).
+- Once done, return to Plex to verify that remote access is functional.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu et autorisez le port `32400` de votre serveur.
+- **If it fails:** check your firewall rules and allow port `32400` on your server.
 :::
 ::
 
-- Si vous avez un abonnement PlexPass et un GPU ou iGPU, activez *l'accélération matérielle* dans la section _Transcodeur_.
-- Dans la section _Réglages/bibliothèque_, cochez _Analyser ma bibliothèque automatiquement_.
-- Dans la section _Gérer/bibliothèque_ modifiez ou ajouter les bibliothèque, et choisissez le répertoire `/media/movies` pour les films et `/media/tvseries` pour les séries.
+- If you have PlexPass and a GPU or iGPU, enable *hardware acceleration* in the _Transcoder_ section.
+- In _Settings > Library_, enable _Update my library automatically_.
+- In _Manage > Library_, add or edit libraries and point to `/media/movies` for movies and `/media/tvseries` for series.
 
-Et voilà, vous avez un Plex fonctionnel ! 
+And that’s it! You now have a working Plex server!
 
-Vous n'avez plus qu'a remplir les dossiers `/media/movies` et `/media/tvseries` sur votre serveur de vos média favoris. Vous pourrez alors télécharger l'application Plex sur vos appareils et lire vos média favoris, chez vous ou à distance !
+Simply add your media to `/media/movies` and `/media/tvseries` on your server. You can then install the Plex app on your devices and watch your favorite content locally or remotely.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Si pour stocker vos média vous utilisez un disque réseau (par exemple un stockage sur un NAS ou un disque dur externe branché ailleurs sur le réseau), veuillez consulter la section [montage samba](/generalites/reseau/samba) afin que Plex puisse y accéder.
+- If your media is stored on a network disk (e.g. NAS or external hard drive over the network), refer to the [Samba mount guide](/general/networking/samba) so Plex can access it.
 :::
 ::
 
-## Exposer Tautulli avec Swag
+## Expose Tautulli with Swag
 ---
-Plex n'a pas besoin d'etre exposé, étant joignable directement depuis votre compte Plex sur plex.tv. 
+You don’t need to expose Plex, as it's accessible via your Plex account on plex.tv.  
+
+However, you may want to expose Tautulli so you can view stats from a simple URL when you're not home.
 
-En  revanche, vous pouvez désirer exposer Tautulli, afin d'accéder aux stats même si vous n'est pas chez vous, depuis une simple url.
 ::alert{type="info"}
 :::list{type="info"}
-- Nous partons du principe que vous avez le sous-domaine `tautulli.mondomaine.fr` avec un `CNAME` qui pointe vers `mondomaine.fr` dans [zone DNS](/generalites/reseau/dns). Et que bien sûr, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), le port `443` de votre box pointe bien sur le port `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+- We assume you have the subdomain `tautulli.mydomain.com` with a `CNAME` pointing to `mydomain.com` in your [DNS zone](/general/networking/dns). And of course, [unless you use Cloudflare Zero Trust](/serveex/security/cloudflare), your box's port `443` must be forwarded to your server's port `443` in [NAT rules](/general/networking/nat).
 :::
 ::
 
-
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Tautulli :
+Go to Dockge and edit SWAG’s compose file by adding Tautulli’s network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:              # Relie le conteneur au réseau custom 
+     networks:              # Attach container to custom network 
       # ...           
-      - tautulli            # Nom du réseau déclaré dans la stack
+      - tautulli            # Name of the declared network
 
-networks:                   # Définit le réseau custom
+networks:                   # Define the custom network
   # ...
-  tautulli:                 # Nom du réseau déclaré dans la stack
-    name: tautulli_default  # Nom véritable du réseau externe
-    external: true          # Précise que c'est un réseau à rechercher en externe
+  tautulli:                 # Declared network name
+    name: tautulli_default  # Actual external network name
+    external: true          # Marks it as externally defined
 ```
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Redeploy the stack and wait for SWAG to be fully operational.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de Tautulli est `tautulli_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant `http://ipduserveur:81`.
+- Here we assume the Tautulli network name is `tautulli_default`. You can check the connection by visiting SWAG’s dashboard at `http://yourserverip:81`.
 :::
 ::
 
-Copiez en renommant le fichier `tautulli.subdomain.conf.sample` en `tautulli.subdomain.conf` et éditez le :
+Copy and rename the file `tautulli.subdomain.conf.sample` to `tautulli.subdomain.conf`, then edit it:
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ **Tip:** Use [File Browser](/serveex/files/file-browser) to navigate and edit files instead of using terminal commands.
 ::
 
 ```shell
@@ -212,7 +216,7 @@ sudo cp /docker/swag/config/nginx/proxy-confs/tautulli.subdomain.conf.sample /do
 sudo vi /docker/swag/config/nginx/proxy-confs/tautulli.subdomain.conf
 ```
 
-Et vérifiez que la configuration correspond bien à ceci, sinon éditez le fichier en appuyant sur `i`:
+Ensure the configuration matches the following. If needed, press `i` to edit:
 
 ```nginx
 ## Version 2023/05/31
@@ -294,17 +298,17 @@ server {
 ```
 
 ::alert{type="success"}
-✨ Vous pouvez protéger cette app avec Authentik en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ You can protect this app with Authentik by removing the `#` before `include /config/nginx/authentik-server.conf;` and `include /config/nginx/authentik-location.conf;`. Don’t forget to [create an application and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tappant `:x`
+Press `Esc` then save and quit by typing `:x`
 
-Patientez quelques minutes puis tapez dans votre navigateur `http://tautulli.mondomaine.fr`.
+Wait a few minutes, then open `http://tautulli.mydomain.com` in your browser.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- **If it fails:** check your firewall rules.
 :::
 ::
 
-Et voilà !
+And you're done!

content/3.serveex/5.media/2.qbittorrent.md

@@ -8,28 +8,28 @@ main:
 # Qbittorrent
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer et configurer Qbittorrent
-- Etre relié au réseau bittorent en toute sécurité avec Gluetun et Proton VPN
+🎯 __Goals:__
+- Install and configure Qbittorrent
+- Securely connect to the BitTorrent network using Gluetun and Proton VPN
 ::
 
 ![Picture](https://github.com/VueTorrent/VueTorrent/blob/master/public/screenshots/screenshot-desktop-dark-mode.jpeg?raw=true)
 
-Afin de télécharger vos media favoris en toute sécurité, nous allons monter un système à base de :
+To safely download your favorite media, we'll build a system using:
 
-- [Qbittorent](https://github.com/linuxserver/docker-qbittorrent) comme logiciel de téléchargement bittorent
-- [Proton VPN Plus](https://protonvpn.com/torrenting), VPN pour sécuriser vos échanges, auquel vous devez souscrire (il y a de nombreux codes promo) pour accéder au protocole Bittorent, mais vous pouvez également en choisir un autre, à condition qu'il propose le protocole bittorent.
+- [Qbittorrent](https://github.com/linuxserver/docker-qbittorrent) as the BitTorrent client
+- [Proton VPN Plus](https://protonvpn.com/torrenting), a VPN to secure your traffic. You need a subscription (promos available) to access the BitTorrent protocol. You can also use another VPN as long as it supports BitTorrent.
 - [Gluetun](https://github.com/qdm12/gluetun)
-- [Qbittorrent port update](https://codeberg.org/TechnoSam/qbittorrent-gluetun-port-update) pour mettre automatiquement à jour le port de votre VPN (qui change régulièrement).
-- Et le mode [vuetorrent](https://github.com/gabe565/linuxserver-mod-vuetorrent) pour une interface moderne et intuitive.
+- [Qbittorrent port update](https://codeberg.org/TechnoSam/qbittorrent-gluetun-port-update) to automatically update the VPN port (which changes regularly).
+- The [VueTorrent](https://github.com/gabe565/linuxserver-mod-vuetorrent) mod for a modern and intuitive UI.
 
-Nous monterons ici le système ci-dessous :
+Here’s the system we’ll set up:
 
 ![Picture](/img/serveex/qbit.svg)
 
 ## Configuration
 ---
-Structure des dossiers
+Folder structure
 
 ```console
 root
@@ -41,22 +41,22 @@ root
 │       ├── compose.yaml
 │       └── .env
 │       
-└── media #relié à plex et Qbittorrent
-    ├── downloads #vos téléchargements génériques, à selectionner dans les parametres
-    ├── movies #à selectionner dans l'interface pour télécharger vos films
-    └── tvseries #à selectionner dans l'interface pour télécharger vos séries
+└── media #linked to Plex and Qbittorrent
+    ├── downloads #generic downloads, selected in settings
+    ├── movies #used for downloading movies
+    └── tvseries #used for downloading TV shows
 ```
 
-Si ce n'est pas déjà fait, créez le dossier `downloads` dans `/media` :
+If not already done, create the `downloads` folder under `/media`:
 
 ```sh
 mkdir -P /media/downloads
 ```
 
-Ouvrez Dockge, cliquez sur `compose` et nommez la stack `seedbox`. Collez la config ci-dessous : 
+Open Dockge, click on `compose`, and name the stack `seedbox`. Paste the following config:
 
 ```yaml
----
+
 services:
   qbit:
     image: ghcr.io/linuxserver/qbittorrent:latest
@@ -102,164 +102,162 @@ services:
       - WIREGUARD_PRIVATE_KEY=${PR_KEY}
       - SERVER_COUNTRIES=France
       - PORT_FORWARD_ONLY=on
-      
 ```
 
-
 ::alert{type="success"}
-✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the Watchtower label in each container to automate updates
 
-    ```yaml
-    services:
-      qbittorrent:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
-      gluetun:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
+```yaml
+services:
+  qbittorrent:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+  gluetun:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+```
 ::
 
-Avant de renseigner le `.env` dans Dockge, nous allons configurer la mise à jour du port de téléchargement. En effet, Proton, et la plupart des VPN, changent régulièrement le port de téléchargement, et celui-ci doit etre communiqué à Qbitorrent. 
+Before editing the `.env` in Dockge, let's configure the download port update. Proton and most VPNs rotate the forwarding port, which must be communicated to Qbittorrent.
 
-Pour ce faire, nous avons ajouté le mod `ghcr.io/t-anc/gsp-qbittorent-gluetun-sync-port-mod` dans le conteneur. 
+We’ve added the mod `ghcr.io/t-anc/gsp-qbittorent-gluetun-sync-port-mod` to the container.
 
-Il faut à présent permettre au mod de récupérer l'information via Gluetun, qui n'accepte que les communications chiffrées via son API.
+We now need to allow the mod to fetch info from Gluetun, which only allows encrypted communication via its API.
 
-A cet effet, ouvrez un terminal. Nous allons à présent générer une clé d'authentification :
+Open a terminal to generate the authentication key:
 
 ```shell
 sudo docker run --rm qmcgaw/gluetun genkey
 ```
 
-Notez la clé. Puis créez le dossier `/docker/gluetun`
+Note the key, then create the `/docker/gluetun` folder:
 
 ```shell
 sudo mkdir /docker/gluetun
 ```
 
-Et créez le fichier `config.toml`
+Create the `config.toml` file:
 
 ```shell
 sudo vi /docker/gluetun/config.toml
 ```
 
-Entrez en modification en tapant `i` et éditez le comme suit en ajoutant la clée que vous avez générée :
+Press `i` to edit and enter:
 
 ```toml
 [[roles]]
 name = "t-anc/GSP-Qbittorent-Gluetun-sync-port-mod"
 routes = ["GET /v1/openvpn/portforwarded"]
 auth = "apikey"
-apikey = "votre_clée" # clée que vous avez générée précédemment
+apikey = "your_key_here" # key you just generated
 ```
 
-Appuyez sur `échap` et quittez en sauvegardant en tapant `:x`. Rendez-vous dans Dockge, et renseignez les variables dans `.env`:
+Press `Esc` then type `:x` to save and exit.
+
+In Dockge, fill in the variables in `.env`:
 
 ```properties
 PUID=
 GUID=
 UI_PORT=
 PR_KEY=
-GSP_KEY= # la clé que vous avez générée et renseignée dans config.toml
+GSP_KEY= # the key you generated and entered in config.toml
 ID=
 PW=
 ```
 
-En détails :
+Detailed info:
 
-| Variable                    | Valeur                                                                                                                                            | Exemples                     |
-|-----------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------|
-| `PUID`{lang=properties}      | A renseigner avec les infos de votre user (trouvables via la commande `id nomdutilisateur`{lang=shell})                                         | `1000`                         |
-| `GUID`{lang=properties}   | A renseigner avec les infos de votre user (trouvables via la commande `id nomdutilisateur`{lang=shell})                                         | `1000`                         |
-| `UI_PORT`{lang=properties}     | Le port d'accès à la web ui, elle sera joignable via `http//ipduserveur:port`                                                                     | `5695`                         |
-| `PR_KEY`{lang=properties}      | La clée privée fournie par Proton                                                                                                                 | `buKsjNHLyzKMM1qYnzOy4s7SHfly` |
-| `GSP_KEY`{lang=properties}     | Clé que vous avez générée pour la mise à jour du port         | `MnBa47MeVmk7xiv`                |
-| `ID`{lang=properties}     | username que vous utilisez pour vous logger dans l'interface de Qbittorrent         | `user`                |
-| `PW`{lang=properties}     | mot de passe que vous utilisez pour vous logger dans l'interface de Qbittorrent         | `password`                |
+| Variable   | Description | Example |
+|------------|-------------|---------|
+| `PUID`     | User ID (`id yourusername`) | `1000` |
+| `GUID`     | Group ID (`id yourusername`) | `1000` |
+| `UI_PORT`  | Port for accessing the web UI | `5695` |
+| `PR_KEY`   | Private key from Proton | `buKsjNHLyzKMM1qYnzOy4s7SHfly` |
+| `GSP_KEY`  | Key you generated for port update | `MnBa47MeVmk7xiv` |
+| `ID`       | Qbittorrent UI login username | `user` |
+| `PW`       | Qbittorrent UI password | `password` |
 
-## Déploiement
+## Deployment
 ---
-Une fois fait, déployez le conteneur.
-
+Once done, deploy the container.
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- **Dans les logs de lancement, vous trouverez un mot de passe temporaire pour l'utilisateur `admin`**
+- **Startup logs will show a temporary password for `admin` user**
 :::
 ::
 
-Loggez vous sur `http://ipduserveur:5695` (ou le port que vous avez configuré). 
+Login at `http://server-ip:5695` (or the port you set).
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If login fails:__ check your firewall rules.
 :::
 ::
 
-Changez votre nom d'utilisateur et votre mot de passe dans les paramètres "webui".
+Change your username and password in the "webui" settings.
 
-Et voilà ! Dans les paramètres de Qbittorrent, dans "téléchargements" selectionnez `/media/downloads` comme chemin par défaut pour télécharger vos media.
+You're done! In Qbittorrent settings, under "Downloads", set `/media/downloads` as the default folder.
 
-Lorsque vous lancez un téléchargement, n'oubliez pas de préciser le bon répertoire de téléchargement afin que Plex puisse synchroniser correctement sa bibliothèque (`/media/movies` et `/media/tvseries`). Vous pouvez aussi l'automatiser en créant une catégorie et un répertoire associé.
+When adding a download, remember to select the proper directory so Plex can sync correctly (`/media/movies` or `/media/tvseries`). You can also automate this with categories and folders.
 
-## Exposer la webui
+## Exposing the Web UI
 ---
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- Qbitorrent n'utilise pas d'authentification multifacteur. Exposer Qbitorrent sur internet pourrait compromettre les machines auxquelles il est relié. Ne le faite que si vous utilisez un systeme d'authentification multifacteur comme [Authentik](/serveex/securite/authentik/). Sinon, n'exposez pas avec SWAG et utilisez plutôt un VPN comme [Wireguard](/serveex/securite/wireguard).
+- Qbittorrent does not support multi-factor authentication. Exposing it to the internet may put your system at risk. Only do this if you use MFA via [Authentik](/serveex/security/authentik/). Otherwise, don’t expose it with SWAG—use a VPN like [Wireguard](/serveex/security/wireguard) instead.
 :::
 ::
 
-
-Afin de lancer des téléchargement hors de chez vous, sans VPN, vous pouvez exposer la webui de Qbittorrent. 
+To start downloads from outside your home, without a VPN, you can expose the Qbittorrent web UI.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Nous partons du principe que vous avez le sous-domaine `seedbox.mondomaine.fr` avec un `CNAME` qui pointe vers `mondomaine.fr` dans [zone DNS](/generalites/reseau/dns). Et que bien sûr, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), le port `443` de votre box pointe bien sur le port `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+- We assume you have the subdomain `seedbox.mydomain.com` with a `CNAME` pointing to `mydomain.com` in [DNS zone](/general/networking/dns). And that port `443` on your router is forwarded to your server in [NAT rules](/general/networking/nat), unless you’re using Cloudflare Zero Trust.
 :::
 ::
 
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Gluetun :
+In Dockge, edit the SWAG compose file and add Gluetun’s network:
 
 ```yaml
 services:
   swag:
-     container_name: # ...
+    container_name: # ...
+    # ...
+    networks:
       # ...
-     networks:             # Relie le conteneur au réseau custom 
-      # ...           
-      - seedbox            # Nom du réseau déclaré dans la stack
+      - seedbox
 
-networks:                  # Définit le réseau custom
+networks:
   # ...
-  seedbox:                 # Nom du réseau déclaré dans la stack
-    name: seedbox_default  # Nom véritable du réseau externe
-    external: true         # Précise que c'est un réseau à rechercher en externe
+  seedbox:
+    name: seedbox_default
+    external: true
 ```
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Click "Deploy" and wait for SWAG to fully initialize.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de la seedbox est `seedbox_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- We assume the network name is `seedbox_default`. You can confirm by checking the SWAG dashboard at http://server-ip:81.
 :::
 ::
 
-
-Puis nous allons créer et éditer le fichier `seedbox.subdomain.conf`.
+Now create/edit `seedbox.subdomain.conf`.
 
 ::alert{type="success"}
-✨__Astuce pour les allergiques au terminal :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Terminal-free tip:__ use [File Browser](/serveex/files/file-browser) to edit files instead of using the terminal.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/seedbox.subdomain.conf
 ```
 
-Entrez en modification en appuyant sur `i` et copiez la configuration ci-dessous, en prenant soin de vérifier le port : 
+Press `i` and paste the following config (check the port):
 
 ```nginx
 ## Version 2023/12/19
@@ -311,14 +309,15 @@ server {
     }
 }
 ```
+
 ::alert{type="success"}
-✨ Vous pouvez protéger cette app avec Authentik en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ You can secure this app with Authentik by uncommenting the `authentik-server.conf` and `authentik-location.conf` lines. Don’t forget to [create an app and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x`.
+Press `Esc`, type `:x` to save and quit.
 
-Patientez quelques minutes puis tapez dans votre navigateur `https://seedbox.mondomaine.fr`, vous arriverez sur l'interface de Qbittorrent.
+Wait a few minutes, then go to `https://seedbox.mydomain.com`—you should land on the Qbittorrent interface.
 
-Et voilà, vous avez un mediacenter pret à l'emploi !
+And that’s it! You now have a ready-to-use media center.
 
 ![Picture](/img/serveex/seed.svg)

content/3.serveex/5.media/3.servarr.md

@@ -1,6 +1,6 @@
 ---
 navigation: true
-title: Automatisation
+title: Automation
 main:
   fluid: false
 ---
@@ -8,26 +8,26 @@ main:
 # Servarr
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Automatiser les téléchargements de films et de séries avec Radarr, Sonarr, Bazarr, Prowlarr et Overseerr.
+🎯 __Goals:__
+- Automate movie and TV show downloads using Radarr, Sonarr, Bazarr, Prowlarr, and Overseerr.
 ::
 
-[Servarr](https://wiki.servarr.com/) est une collection d'applications développées dans le but d'automatiser le téléchargement, la mise à jour et la gestions des media. Ici nous allons porter notre attention sur les films et séries avec comme objectif :
-- Pouvoir choisir un film dans un catalogue via une interface web
-- N'avoir plus rien à faire à part en profiter quelques minutes plus tard sur Plex
+[Servarr](https://wiki.servarr.com/) is a suite of applications developed to automate the downloading, updating, and management of media. Here, we'll focus on movies and TV shows with the goal of:
+- Selecting a movie from a catalog through a web interface.
+- Sitting back and enjoying it on Plex a few minutes later.
 
 Simple.
 
 ![arr](/img/serveex/arr.svg)
 
-Je vous propose de déployer la stack puis nous verrons par la suite la configuration de chacune des apps et leur fonctionnement.
+We’ll start by deploying the stack and then proceed to configure each app and understand how they work.
 
-## Installer les apps
+## Install the Apps
 ---
 
-### Docker compose
+### Docker Compose
 
-Structure des dossiers :
+Folder structure:
 
 ```console
 root
@@ -57,12 +57,13 @@ root
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- __Attention :__ Respectez bien ce type de structure de fichier, notamment le dossier `media`. Ce dossier doit etre monté de la même manière dans les compose de _Qbittorrent_ (`/votre/chemin/media:/media`) et des _arr_. Sans cela, les _arr_ risquent de ne pas trouver le chemin fourni par Qbittorrent et de ne pas créer de _hardlinks_. Sans hardlink, les _arr_ copieront les films et cela doublera l'espace utilisé sur votre stockage.
+- __Warning:__ Make sure to follow this file structure carefully, especially the `media` folder. This folder must be mounted **exactly the same way** in both the _Qbittorrent_ compose file (`/your/path/media:/media`) and the _arr_ applications.  
+If not, the _arr_ apps may not recognize the path provided by Qbittorrent and will fail to create _hardlinks_.  
+Without hardlinks, the _arr_ apps will copy the files instead—**doubling the space used** on your storage.
 :::
 ::
 
-Ouvrez dockge et votre stack `plex`. Modifiez le compose comme ceci :
-
+Open Docker and your `plex` stack. Modify the compose file as follows:
 ```yaml
 ---
 services:
@@ -169,22 +170,23 @@ services:
 ```
 
 ::alert{type="success"}
-✨ Ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ Add the Watchtower label to each container to automate updates
 
-    ```yaml
-    services:
-      plex:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
+```yaml
+services:
+  plex:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
 
-      tautulli:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
+  tautulli:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+```
 ::
 
-Renseignez le `.env` avec les variables ci-dessous
+Set your `.env` file with the variables below:
 
 ```properties
 PUID=
@@ -192,251 +194,247 @@ GUID=
 MEDIA_PATH=
 ```
 
-| Variable                    | Valeur                                                                                                                                            | Exemples                     |
-|-----------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------|
-| `PUID`{lang=properties}      | A renseigner avec les infos de votre user (trouvables via la commande `id nomdutilisateur`{lang=shell})                                         | `1000`                         |
-| `GUID`{lang=properties}   | A renseigner avec les infos de votre user (trouvables via la commande `id nomdutilisateur`{lang=shell})                                         | `1000`                         |
-| `MEDIA_PATH`{lang=properties}     | le chemin vers votre dossier media, ici : `/media`. Attention, il doit correspondre aussi à celui qu'utilise Qbittorrent.                | `/media`                         |
+| Variable        | Description                                                                                     | Example     |
+|----------------|-------------------------------------------------------------------------------------------------|-------------|
+| `PUID`         | Set using your user info (check with `id yourusername`)                                         | `1000`      |
+| `GUID`         | Same as above                                                                                   | `1000`      |
+| `MEDIA_PATH`   | Path to your media folder, here: `/media`. It must match the one used by Qbittorrent.          | `/media`    |
 
-Déployez la stack.
+Deploy the stack.
 
-### Paramétrer Radarr
+### Configure Radarr
 ---
-Radarr est une app qui permet de requêter à votre place vos sources de torrent et de définir quel type de release vous souhaitez télécharger en priorité. Radarr permet aussi de mettre à jour vos films si une meilleure version est disponible.
 
-Maintenant que vous avez déployé la stack, vous pouvez vous rendre sur `http://ipduserveur:7878`.
+Radarr queries your torrent sources and lets you define the type of releases to prioritize. It can also upgrade your movies if a better version is available.
+
+Once deployed, visit `http://yourserverip:7878`.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-Créez vous un compte, choisissez bien *forms login*.
+Create an account and choose *forms login*.
 
-##### Ajouter un *root folder*
+##### Add a *root folder*
 
-- Dans le menu à gauche, cliquez sur *Settings > Media Management*.
-- Ajoutez un *root folder*, choisisez `/media/movies`
+- Go to *Settings > Media Management*.
+- Add a root folder and select `/media/movies`.
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- __Attention :__ Si vous avez déjà des films dans `movies` issus de Qbittorrent, ne les ajoutez pas dans Sonarr si ce dernier vous le propose. Radarr risque de les modifier ce qui entrainerait l'arrêt du seed par Qbittorrent.
+- __Warning:__ If you already have movies in `movies` from Qbittorrent, do not let Radarr add them. Radarr might modify them, which could stop seeding in Qbittorrent.
 :::
 ::
 
-##### Configurer les profils
+##### Configure Profiles
 
-Dans le menu *Settings > Profiles*, vous trouverez les profils par défaut de Radarr. Comprendre que lorsque vous faites une requete, vous demandez un de ces profils. Ainsi, radarr va chercher en priorité le parametre le plus élevé, puis s'il ne trouve pas, il va passer à celui d'en dessous etc. Vous pouvez par exemple régler comme ceci pour le profile "any", en décochant tout sauf ce qui est sur l'image, et en les mettant dans le même ordre. Avec ce profil "any", Radarr va chercher en priorité du 4K REMUX (meilleure qualité), puis s'il ne trouve pas, il va passer au critère du dessous.
+Go to *Settings > Profiles*. These are your default quality profiles. When you make a request, you're selecting one of these. For example, configure the “any” profile by unchecking everything except what is shown in the image and ordering them accordingly. This makes Radarr search for 4K REMUX first, then go down the list if unavailable.
 
 ![profiles_radarr](/img/serveex/radarr1.png)
 
-##### Ajouter Qbittorrent
+##### Add Qbittorrent
 
-Dans *Settings > Downloads Clients* vous allez ajouter Qbittorrent. 
+In *Settings > Download Clients*, add Qbittorrent.
 
-- Renseignez le *Host* avec l'IP de votre serveur et précisez le port de la webui, si vous avez suivi mon tuto c'est le `5695`. 
-- Renseignez le *Username* et le *Password* de votre interface Qbittorrent.
-- Cliquez sur *test*.
-- Si tout est ok, cliquez sur *save*.
+- Use your server IP as *Host* and port `5695` if following this guide.
+- Provide your Qbittorrent *Username* and *Password*.
+- Click *Test*.
+- If successful, click *Save*.
 
+##### Connect to Plex
 
-##### Connecter à Plex
+Go to *Settings > Connect*, add a new connection and choose *Plex Media Server*.
 
-Dans *Settings > Connect*, ajoutez une nouvelle connexion, choisissez *Plex Media Server*.
-- Dans *Host* mettez `plex` ou l'adresse IP de votre serveur.
-- Dans port mettez `32400`.
-- Cliquez sur le bouton bleu "authenticate with Plex.tv" et authentifiez vous avec votre compte Plex.
-- Appuyez sur le bouton *test*.
-- Si tout est ok, appuyez sur le bouton *save*.
+- Use `plex` or your server IP for *Host*.
+- Port: `32400`
+- Click the blue "authenticate with Plex.tv" button and log into Plex.
+- Press *Test*, then *Save* if successful.
 
+##### Get API Key for Prowlarr and Overseerr
 
+- Go to *Settings > General* and copy your *API Key* for later use.
 
-##### Récupérer la clé API pour Prowlarr et Overserr
-
-- Dans *Settings > General*, copiez la *API Key* et notez la précieusement.
-
-### Paramétrer Sonarr
+### Configure Sonarr
 ---
-Sonarr est une app qui permet de requêter à votre place vos sources de torrent et de définir quel type de release vous souhaitez télécharger en priorité. Radarr permet aussi de mettre à jour vos séries si une meilleure version est disponible.
 
-- Rendez-vous sur `http://ipduserveur:8989`.
-- Suivez exactement les mêmes étapes que pour Radarr, et en *root folder* mettez `/media/tvseries`.
+Sonarr queries torrent sources and defines what kind of TV series releases to prioritize. It also upgrades series when better versions are available.
+
+- Visit `http://yourserverip:8989`.
+- Follow the same steps as for Radarr, but use `/media/tvseries` as the root folder.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-### Paramétrer Prowlarr
+### Configure Prowlarr
 ---
-Prowlarr est un proxy qui permet de gérer vos sources de torrents et de les passer à Radarr et Sonarr.
 
-Rendez-vous sur `http://ipduserveur:9696` et créez vous un compte en choisissant bien *forms login*.
+Prowlarr acts as a proxy to manage your torrent indexers and link them to Radarr and Sonarr.
+
+Go to `http://yourserverip:9696` and create an account, using *forms login*.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
+##### Add an Indexer
 
-##### Ajouter une source
+- Go to the *Indexers* section and add your torrent indexer.
 
-- Dans la section *Indexers*, ajoutez l'indexer de votre source de torrent.
+##### Add Radarr and Sonarr
 
-##### Ajouter Radarr et Sonarr
+In *Settings > Apps*, add Radarr and Sonarr with the following details:
 
-Dans la section *Settings > Apps*, ajoutez Radarr et Sonarr avec les informations ci-dessous :
-- Prowlarr Server : `http://prowlarr:9696` (ou remplacez prowlarr par l'IP de votre serveur)
-- Sonarr / Radarr Server : `http://sonarr:8989` ou `http://radarr:7878`(ou remplacez sonarr/radarr par l'IP de votre serveur)
-- API Key, la clé que vous avez notée pour Radarr et celle de Sonarr.
-- Appuyez sur *Test*.
-- Si tout va bien, appuyez sur *Save*.
+- Prowlarr Server: `http://prowlarr:9696` (or use server IP)
+- Sonarr / Radarr Server: `http://sonarr:8989` or `http://radarr:7878`
+- API Key: use the one copied from Radarr and Sonarr.
+- Click *Test*, then *Save* if all goes well.
 
-
-### Paramétrer Bazarr
+### Configuring Bazarr
 ---
-Bazarr est une app qui permet de chercher automatiquement les bons sous-titre dans les langues souhaitez pour tout les films et séries que Radarr et Sonarr ajoutent pour vous.
+Bazarr is an app that automatically searches for the correct subtitles in your preferred languages for all the movies and TV shows added by Radarr and Sonarr.
 
-Rendez-vous sur `http://ipduserveur:9696`.
+Go to `http://yourserverip:9696`.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-Rendez-vous dans *Settings > General* et créez un identifiant et un mot de passe en utilisant le *forms login*.
+Go to *Settings > General* and create a username and password using *forms login*.
 
-#### Ajouter un profil de langage
+#### Add a Language Profile
 
-- Dans *Settings > Languages* cliquez sur le bouton rose *Add new profile* et nommez le.
-- Cliquez sur le bouton rose *Add Languages* et ajoutez les langues que vous souhaitez, par exemple *French* et *English*.
-- Sauvegardez et quittez.
-- En bas de l'ecran dans *Default Language For Newly Added Show*, cochez les deux cases et renseignez le profil que vous venez de créer.
+- In *Settings > Languages*, click the pink *Add new profile* button and name it.
+- Click the pink *Add Languages* button and add your preferred languages, e.g., *French* and *English*.
+- Save and exit.
+- At the bottom of the screen under *Default Language For Newly Added Show*, check both boxes and select the profile you just created.
 ![Bazarr](/img/serveex/bazarr2.png)
-- Enregistrez avec le bouton tout en haut de l'écran.
+- Save using the button at the top of the screen.
 
-#### Ajouter des fournisseurs de sous-titre
+#### Add Subtitle Providers
 
-- Dans *Settings > Providers*, ajoutez vos fournisseurs favoris, comme par exemple :
+- In *Settings > Providers*, add your preferred providers, for example:
 
 ![Bazarr](/img/serveex/bazarr.png)
 
-- Enregistrez avec le bouton tout en haut de l'écran.
+- Save using the button at the top of the screen.
 
-#### Ajouter Radarr et Sonarr
+#### Add Radarr and Sonarr
 
-- Rendez-vous dans *Settings > Sonarr*
-- Dans *Adress*, mettez `sonarr` ou l'adresse IP du serveur.
-- Dans *Port* mettez `8989`.
-- Dans *API Key* mettez la clé API de Sonarr.
-- Cliquez sur *Test*.
-- Enregistrez avec le bouton tout en haut de l'écran.
+- Go to *Settings > Sonarr*
+- In *Address*, enter `sonarr` or your server's IP address.
+- In *Port*, enter `8989`.
+- In *API Key*, enter Sonarr’s API key.
+- Click *Test*.
+- Save using the button at the top of the screen.
 
-Faites de même avec Radarr.
+Repeat the same steps for Radarr.
 
-
-### Paramétrer Overseerr
+### Configuring Overseerr
 ---
 
-[Overseerr](https://overseerr.dev/) est une application qui permet de naviguer dans un catalogue de film et de faire des requetes à Sonarr et à Radarr. Il suffit de naviguer dans les films ou séries, puis de cliquer sur *Demander*, et le film ou la série sera automatiquement téléchargée selon les paramètres de Radarr ou de Sonarr. Si le film ou la série n'est pas sortie, cela sera automatiquement téléchargé lorsque cela sera disponible. Ainsi, les épisodes d'une séerie arrivent automatiquement au fur et à mesure dans Plex sans aucune intervention manuelle.
+[Overseerr](https://overseerr.dev/) is an app that lets you browse a movie catalog and send requests to Sonarr and Radarr. Just browse movies or series, click *Request*, and the media will automatically be downloaded according to your Radarr or Sonarr settings. If the title hasn’t been released yet, it will be downloaded automatically when available. This way, episodes of a series appear in Plex without any manual intervention.
 
 ![Overseerr](/img/serveex/overseerr.webp)
 
-Rendez-vous sur `http://ipduserveur:5055` et authentifiez vous avec votre compte Plex.
+Go to `http://yourserverip:5055` and log in with your Plex account.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-#### Ajouter Radarr et Sonarr
+#### Add Radarr and Sonarr
 
-Lorsque cela vous est demandé, ajoutez un serveur radarr :
-- Cochez *serveur par défaut*.
-- __Nom du serveur :__ Radarr
-- __Nom d'hôte ou adresse IP :__ `radarr` ou l'adresse IP de votre serveur
-- __Port :__ `7878`.
-- __Clé d'API :__ la clé API de Radarr.
-- Cliquez sur *Tester* en bas.
+When prompted, add a Radarr server:
+- Check *Default server*.
+- __Server name:__ Radarr
+- __Hostname or IP address:__ `radarr` or your server's IP
+- __Port:__ `7878`
+- __API Key:__ Radarr’s API key
+- Click *Test* at the bottom.
 
-Si tout va bien, continuez à renseigner les champs.
-- __Profil de qualité :__ celui que vous avez configuré (par exemple, `any`).
-- __Dossier racine :__ le dossier de plex. Dans nos exemples : `/media/movies`.
-- __Disponibilité minimale :__ `Annoncé`. Ainsi, si un film n'est pas sorti, vous pouvez le demander et il sera automatiquement récupéré à sa sortie.
-- Cochez les 3 cases du bas.
-- Sauvegardez et continuez.
+If the test succeeds, continue filling in the fields:
+- __Quality Profile:__ the one you configured (e.g., `any`)
+- __Root Folder:__ the Plex folder. In our examples: `/media/movies`
+- __Minimum Availability:__ `Announced`. This allows requesting unreleased content and downloads it upon release.
+- Check all 3 boxes at the bottom.
+- Save and continue.
 
-Puis faites de même avec Sonarr :
-- Cochez *serveur par défaut*.
-- __Nom du serveur :__ Radarr
-- __Nom d'hôte ou adresse IP :__ `sonarr` ou l'adresse IP de votre serveur
-- __Port :__ `8989`.
-- __Clé d'API :__ la clé API de Sonarr.
-- Cliquez sur *Tester* en bas.
+Now do the same for Sonarr:
+- Check *Default server*.
+- __Server name:__ Sonarr
+- __Hostname or IP address:__ `sonarr` or your server's IP
+- __Port:__ `8989`
+- __API Key:__ Sonarr’s API key
+- Click *Test* at the bottom.
 
-Si tout va bien, continuez à renseigner les champs.
-- __Profil de qualité :__ celui que vous avez configuré (par exemple, `any`).
-- __Dossier racine :__ le dossier de plex. Dans nos exemples : `/media/tvseries`.
-- __Profil de langue :__ `Deprecated`.
-- Cochez les 4 cases du bas.
-- Sauvegardez et continuez.
+If the test succeeds, continue filling in the fields:
+- __Quality Profile:__ the one you configured (e.g., `any`)
+- __Root Folder:__ the Plex folder. In our examples: `/media/tvseries`
+- __Language Profile:__ `Deprecated`
+- Check all 4 boxes at the bottom.
+- Save and continue.
 
-Et voilà ! Vous n'avez plus qu'à faire une demande d'un film et d'une serie, puis de vérifier dans qbittorrent ou dans radarr/sonarr que tout va bien. Dans quelques minutes, votre media sera sur Plex !
+And that’s it! Just request a movie or series, then check in qBittorrent or Radarr/Sonarr. Within a few minutes, your media will be available on Plex!
 
-## Exposer Overseerr avec Swag
+## Exposing Overseerr with SWAG
 ---
 
-Il peut etre intéressant d'exposer Overseerr, si vous souhaitez pouvoir faire des requêtes depuis l'exterieur sans VPN, ou si vous avez partagé votre Bibliothèque Plex à des utilisateurs et que vous souhaitez qu'ils aient accès à Overseerr.
+It can be useful to expose Overseerr if you want to send requests from outside your network without a VPN, or if you've shared your Plex library with others and want them to have Overseerr access.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Nous partons du principe que vous avez le sous-domaine `films.mondomaine.fr` avec un `CNAME` qui pointe vers `films.fr` dans [zone DNS](/generalites/reseau/dns). Et que bien sûr, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), le port `443` de votre box pointe bien sur le port `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+- We assume you have the subdomain `films.mydomain.com` with a `CNAME` pointing to `films.fr` in your [DNS zone](/general/networking/dns). And that [unless you’re using Cloudflare Zero Trust](/serveex/security/cloudflare), port `443` on your router is forwarded to port `443` on your server via [NAT rules](/general/networking/nat).
 :::
 ::
 
-
-Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau d'overseer, qui est celui de Plex car dans la stack Plex :
+Go to Dockge, edit the SWAG compose file, and add the Overseerr network, which is the same as Plex (since it’s in the Plex stack):
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:              # Relie le conteneur au réseau custom 
+     networks:          # Connects the container to a custom network 
       # ...           
-      - plex            # Nom du réseau déclaré dans la stack
+      - plex            # Name of the network declared in the stack
     
-networks:                   # Définit le réseau custom
+networks:               # Defines the custom network
   # ...
-  plex:                 # Nom du réseau déclaré dans la stack
-    name: plex_default  # Nom véritable du réseau externe
-    external: true          # Précise que c'est un réseau à rechercher en externe
+  plex:                 # Name of the declared network
+    name: plex_default  # Actual name of the external network
+    external: true      # Indicates it’s an external network
 ```
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack by clicking “Deploy” and wait until SWAG is fully operational.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de Tautulli est `plex_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant `http://ipduserveur:81`.
+- Here we assume the Tautulli network is named `plex_default`. You can verify the connection works by visiting the SWAG dashboard at `http://yourserverip:81`.
 :::
 ::
 
-Créez le fichier `films.subdomain.conf` et éditez le :
+Create and edit the file `films.subdomain.conf`:
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ you can use [File Browser](/serveex/files/file-browser) to browse and edit files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/films.subdomain.conf
 ```
 
-Rentrez en édition en appuyant sur `i`:
+Enter insert mode by pressing `i`:
 
 ```nginx
 ## Version 2024/07/16
@@ -497,14 +495,14 @@ server {
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tappant `:x`
+Press `Escape`, then type `:x` and press `Enter` to save and exit.
 
-Patientez quelques minutes puis tapez dans votre navigateur `http://films.mondomaine.fr`.
+Wait a few minutes, then visit `http://films.mydomain.com` in your browser.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-Et voilà, vous avez exposé Overseerr !
+And there you go, Overseerr is now publicly accessible!

content/3.serveex/6.cloud/1.immich.md

@@ -8,16 +8,16 @@ main:
 # Immich
 
 ::alert{type="info"}
-🎯 __Objectifs :__ installer [Immich](https://immich.app/docs/overview/introduction) pour gérer vos photos sur tout vos appareils.
+🎯 __Goals:__ Install [Immich](https://immich.app/docs/overview/introduction) to manage your photos across all your devices.
 ::
 
-[Immich](https://immich.app/docs/overview/introduction) est une solution de gestion de photos et de vidéos que vous pouvez installer directement sur votre serveur. Cette solution remplace les clouds type Google Photo ou iCloud. Elle dispose de nombreuse fonctionnalités comme la reconnaissance de visage ou la géolocalisation.
+[Immich](https://immich.app/docs/overview/introduction) is a self-hosted photo and video management solution that replaces cloud services like Google Photos or iCloud. It offers powerful features like face recognition and geolocation.
 
 ![Picture](/img/serveex/immich.png)
 
 ## Installation
 ---
-Structure des dossiers
+Folder structure
 
 ```console
 root
@@ -28,81 +28,78 @@ root
         └── .env
 ```
 
-
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `immich` puis copiez collez le contenu du dernier `docker-compose.yml` [publié ici](https://github.com/immich-app/immich/blob/main/docker/docker-compose.yml). 
+Open Dockge, click on `compose`, name the stack `immich`, then copy and paste the latest `docker-compose.yml` [published here](https://github.com/immich-app/immich/blob/main/docker/docker-compose.yml).
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- __Attention__ : n'ajoutez pas le label de Watchtower à la stack d'Immich. Immich étant une solution en perpetuelle évolution, des mises à jour automatiques risqueraient de casser votre installation.
+- __Warning__: Do not add the Watchtower label to the Immich stack. Immich evolves rapidly, and automatic updates may break your installation.
 :::
 ::
 
-Configurer le `.env` en copiant collant le contenu de la dernière version [publiée ici](https://github.com/immich-app/immich/blob/main/docker/example.env) et suivez les commentaires indiqués dans le fichier.
-
+Configure the `.env` file by copying the latest version [from here](https://github.com/immich-app/immich/blob/main/docker/example.env) and follow the comments in the file.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Si vous avez un NAS ou un disque réseau partagé via [samba](/generalites/reseau/samba/) pour stocker vos données, remplacez la valeur de `UPLOAD_LOCATION`{lang=properties} par le chemin d'accès de votre dossier partagé.
+- If you're using a NAS or a network-shared drive via [Samba](/general/networking/samba/) to store your data, replace the value of `UPLOAD_LOCATION`{lang=properties} with the path to your shared folder.
 :::
 ::
 
 ::alert{type="success"}
-✨ __Astuce :__ si votre CPU/iGPU/GPU le supporte, Immich permet d'utiliser l'accélération matérielle pour lire les vidéos ou pour la reconnaissance d'images. Ces fonctionnalités peuvent tripler les performances d'Immich. Plus d'infos sur le [Transcoding](https://immich.app/docs/features/hardware-transcoding/) et sur le [Machine learning](https://immich.app/docs/features/ml-hardware-acceleration).
+✨ __Tip:__ If your CPU/iGPU/GPU supports it, Immich can use hardware acceleration for video playback and image recognition. This can triple performance. Learn more about [Transcoding](https://immich.app/docs/features/hardware-transcoding/) and [Machine Learning](https://immich.app/docs/features/ml-hardware-acceleration).
 ::
 
-Déployez le conteneur.
+Deploy the container.
 
-Et voilà, vous pouvez vous connecter et suivre les instructions sur `http://ipduserveur:2283`
+You're done! You can connect and follow the setup instructions at `http://yourserverip:2283`.
 
-## Exposer Immich avec Swag
+## Exposing Immich with SWAG
 ---
-Tout l'intérêt d'une telle solution, c'est de pouvoir y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer Immich via Swag.
+The main benefit of this setup is being able to access Immich remotely on all your devices. We'll expose Immich using SWAG.
 
 ::alert{type="info"}
-📋 __Au préalable :__ 
+📋 __Before you begin:__ 
 <br/><br/>
-Nous partons du principe que vous avez le sous-domaine `immich.mondomaine.fr` avec un `CNAME` qui pointe vers `mondomaine.fr` dans votre [zone DNS](/generalites/reseau/dns). Et que bien sûr, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), le port `443` de votre box pointe bien sur le port `443` de votre serveur via [les règles NAT](/generalites/reseau/nat).
+We assume that you have a subdomain `immich.yourdomain.com` with a `CNAME` pointing to `yourdomain.com` in your [DNS zone](/general/networking/dns). Also, unless you're using [Cloudflare Zero Trust](/serveex/security/cloudflare), make sure port `443` on your router is forwarded to port `443` on your server via [NAT rules](/general/networking/nat).
 ::
 
-Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de immich :
+In Dockge, open the SWAG stack and edit the compose file to add Immich's network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:            # Relie le conteneur au réseau custom 
+     networks:            # Connects the container to the custom network 
       # ...           
-      - immich            # Nom du réseau déclaré dans la stack
+      - immich            # Network name defined in the stack
     
-networks:                 # Définit le réseau custom
+networks:                 # Defines the custom network
   # ...
-  immich:                 # Nom du réseau déclaré dans la stack
-    name: immich_default  # Nom véritable du réseau externe
-    external: true        # Précise que c'est un réseau à rechercher en externe
+  immich:                 # Network name defined in the stack
+    name: immich_default  # Actual external network name
+    external: true        # Indicates it's an external network
 ```
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de immich est `immich_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- We're assuming Immich's network is named `immich_default`. You can check connectivity by visiting the SWAG dashboard at http://yourserverip:81.
 :::
 ::
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack by clicking "deploy" and wait for SWAG to fully initialize.
 
-
-Dans les dossiers de Swag, créez le fichier `immich.subdomain.conf`.
+In the SWAG folders, create a file named `immich.subdomain.conf`.
 
 ::alert{type="success"}
 :::list{type="success"}
-- __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+- __Tip:__ You can use [File Browser](/serveex/files/file-browser) to navigate and edit your files instead of using terminal commands.
 :::
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/immich.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+Press `i` to enter insert mode, then paste the following configuration:
 
 ```nginx
 ## Version 2023/12/19
@@ -150,7 +147,6 @@ server {
         set $upstream_port 3001;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 
     location ~ (/immich)?/api {
@@ -160,15 +156,14 @@ server {
         set $upstream_port 3001;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, type `:x`, then hit `Enter` to save and exit.
 
-Et voilà, vous avez exposé Immich ! N'oubliez pas d'installer les applications [iOS](https://apps.apple.com/us/app/immich/id1613945652)/[Android](https://play.google.com/store/apps/details?id=app.alextran.immich) afin de synchroniser vos appareils.
+That's it! Immich is now accessible from the internet. Don’t forget to install the [iOS](https://apps.apple.com/us/app/immich/id1613945652) / [Android](https://play.google.com/store/apps/details?id=app.alextran.immich) apps to sync your devices.
 
 ::alert{type="success"}
-✨ __Astuce :__ Vous pouvez protéger cette app avec Authentik de façon native en [suivant ces instructions](https://docs.goauthentik.io/integrations/services/immich/).
+✨ __Tip:__ You can protect this app with Authentik natively by [following these instructions](https://docs.goauthentik.io/integrations/services/immich/).
 ::

content/3.serveex/6.cloud/2.nextcloud.md

@@ -8,10 +8,10 @@ main:
 # Nextcloud
 
 ::alert{type="info"}
-🎯 __Objectifs :__ installer [Nextcloud](https://nextcloud.com/) pour gérer vos photos sur tout vos appareils.
+🎯 __Goals:__ Install [Nextcloud](https://nextcloud.com/) to manage your photos and files across all your devices.
 ::
 
-[Nextcloud](https://nextcloud.com/) est une solution qui vous permet d'accéder à vos données sur tout vos appareils, et de les synchroniser. Nexctloud dispose également de fonctionnalités de collaboration, de calendrier et bien d'autres. Cette solution remplace des solutions du type Google Drive, iCloud, ou encore OneDrive.
+[Nextcloud](https://nextcloud.com/) is a self-hosted solution that allows you to access and synchronize your data across all your devices. It also includes collaboration features, calendar, and more. It’s a great alternative to services like Google Drive, iCloud, or OneDrive.
 
 ![Picture](/img/serveex/nextcloud.png)
 
@@ -19,11 +19,11 @@ main:
 ---
 ::alert{type="info"}
 :::list{type="info"}
-- Nous utiliserons l'image docker maintenue par [LinuxServer.io](https://docs.linuxserver.io/images/docker-nextcloud/)
+- We'll be using the Docker image maintained by [LinuxServer.io](https://docs.linuxserver.io/images/docker-nextcloud/)
 :::
 ::
 
-Structure des fichiers
+File structure:
 
 ```console
 root
@@ -35,7 +35,7 @@ root
         └── .env
 ```
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `nextcloud` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `nextcloud` and paste the following:
 
 ```yaml
 ---
@@ -57,16 +57,17 @@ services:
 
 ::alert{type="info"}
 :::list{type="info"}
-- Si vous avez un NAS ou un disque réseau partagé via [samba](/generalites/reseau/samba) pour stocker vos données, remplacez `/docker/nextcloud/data` par le chemin d'accès de votre dossier partagé.
+- If you’re using a NAS or network-shared drive via [Samba](/general/networking/samba), replace `/docker/nextcloud/data` with the path to your shared folder.
 :::
 ::
 
-Trouvez votre `PUID` et votre `GUID` en tapant la commande suivante :
+Find your `PUID` and `GUID` by running the following command:
 
 ```shell
-id nomdutilisateur
+id username
 ```
-Et renseignez le `.env` avec le port souhaité, et les infos que vous avez trouvées, par exemple :
+
+Then fill out the `.env` file with your preferred port and the values found above, for example:
 
 ```properties
 PUID=1000
@@ -74,83 +75,87 @@ GUID=1000
 PORT=4545
 ```
 
-Déployez la stack et rendez-vous sur `http://ipduserveur:4545` et suivez les instructions.
+Deploy the stack and visit `http://yourserverip:4545` to complete the setup.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-## Exposer Nextcloud avec Swag
+## Exposing Nextcloud with Swag
 ---
-Tout l'intérêt d'une telle solution, c'est de pouvoir y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer Nextcloud via Swag.
+The goal of this setup is to access Nextcloud remotely from all your devices. We’ll use Swag to expose the app.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Nous partons du principe que vous avez le sous-domaine `nextcloud.mondomaine.fr` avec un `CNAME` qui pointe vers `mondomaine.fr` dans votre [zone DNS](/generalites/reseau/dns). Et que bien sûr, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), le port `443` de votre box pointe bien sur le port `443` de votre serveur via [les règles NAT](/generalites/reseau/nat).
+- We assume you have a subdomain `nextcloud.yourdomain.com` with a `CNAME` pointing to `yourdomain.com` in your [DNS zone](/general/networking/dns). And unless you’re using [Cloudflare Zero Trust](/serveex/security/cloudflare), port `443` on your router must be forwarded to port `443` on your server using [NAT rules](/general/networking/nat).
 :::
 ::
 
-Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de nextcloud :
+In Dockge, go to your SWAG stack and edit the compose to add Nextcloud's network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:               # Relie le conteneur au réseau custom 
+     networks:               
       # ...           
-      - nextcloud            # Nom du réseau déclaré dans la stack
+      - nextcloud            
     
-networks:                    # Définit le réseau custom
+networks:                    
   # ...
-  nextcloud:                    # Nom du réseau déclaré dans la stack
-    name: nextcloud_default  # Nom véritable du réseau externe
-    external: true           # Précise que c'est un réseau à rechercher en externe
+  nextcloud:                 
+    name: nextcloud_default  
+    external: true           
 ```
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de nextcloud est `nextcloud_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- We assume the Nextcloud network is named `nextcloud_default`. You can confirm connectivity by visiting the SWAG dashboard at http://yourserverip:81.
 :::
 ::
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Redeploy the stack and wait for SWAG to become fully operational.
 
-Dans les fichiers de nextcloud, éditez le fichier `config.php`.
+In Nextcloud’s files, edit the `config.php` file:
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ You can use [File Browser](/serveex/files/file-browser) to navigate and edit files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/nextcloud/config/www/nextcloud/config/config.php
 ```
 
-Entrez en modification avec la touche `i` et copiez les informations suivantes __avant__ `);`.
+Enter edit mode with `i` and paste the following before the final `);`:
 
-```js
-'trusted_proxies' => [gethostbyname('swag')],  'overwrite.cli.url' => 'https://nextcloud.example.com/',
+```php
+'trusted_proxies' => [gethostbyname('swag')],
+'overwrite.cli.url' => 'https://nextcloud.example.com/',
 'overwritehost' => 'nextcloud.example.com',
 'overwriteprotocol' => 'https',
 ```
 
-Ajoutez également votre nom de domaine dans la section `array` , cela devrait ressembler à ceci
-```js
- array (
-   0 => '192.168.0.1:444', # Cette ligne est surement différente chez vous, ne la modifiez pas !
-   1 => 'nextcloud.mondomaine.fr', # Renseignez votre domaine
-  ),
-```
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Also add your domain in the `array` section. It should look like this:
 
-Dans les dossiers de Swag, créez le fichier `nextcloud.subdomain.conf`.
+```php
+array (
+   0 => '192.168.0.1:444', # This line may differ—don’t change it!
+   1 => 'nextcloud.yourdomain.com', # Add your domain here
+),
+```
+
+Press `Esc`, then save and exit by typing `:x` and hitting Enter.
+
+In Swag’s folders, create the file `nextcloud.subdomain.conf`:
 
 ```shell
-sudo vi /docker/swag/config/nginx/proxy-confs/nexctloud.subdomain.conf
+sudo vi /docker/swag/config/nginx/proxy-confs/nextcloud.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+
+Enter edit mode with `i` and paste the following:
 
 ```nginx
 ## Version 2024/04/25
@@ -173,7 +178,6 @@ server {
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
 
         # Hide proxy response headers from Nextcloud that conflict with ssl.conf
-        # Uncomment the Optional additional headers in SWAG's ssl.conf to pass Nextcloud's security scan
         proxy_hide_header Referrer-Policy;
         proxy_hide_header X-Content-Type-Options;
         proxy_hide_header X-Frame-Options;
@@ -185,10 +189,10 @@ server {
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, save and exit with `:x` then Enter.
 
-Et voilà, vous avez exposé Nextcloud ! Et n'oubliez pas d'installer [les applications pour ordinateurs et mobiles](https://nextcloud.com/fr/install/).
+That’s it—you’ve exposed Nextcloud! Don’t forget to install [the desktop and mobile apps](https://nextcloud.com/install/).
 
 ::alert{type="success"}
-✨ __Astuce :__ Vous pouvez protéger cette app avec Authentik de façon native en [suivant ces instructions](https://docs.goauthentik.io/integrations/services/nextcloud/).
+✨ __Tip:__ You can natively protect this app with Authentik by [following these instructions](https://docs.goauthentik.io/integrations/services/nextcloud/).
 ::

content/3.serveex/7.files/1.file-browser.md

@@ -8,18 +8,18 @@ main:
 # File Browser
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer File Browser
-- Exposer File Browser avec Swag
+🎯 __Objectives:__
+- Install File Browser
+- Expose File Browser using Swag
 ::
 
-[File Browser](https://github.com/filebrowser/filebrowser) est une interface permettant d'accéder aux fichiers de votre serveur et de les éditer.
+[File Browser](https://github.com/filebrowser/filebrowser) is a web-based interface that lets you access and edit the files on your server.
 
 ![File Browser](/img/serveex/filebrowser.png)
 
 ## Installation
 ---
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `filebrowser` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `filebrowser`, then copy and paste the following:
 
 ```yaml
 ---
@@ -27,15 +27,15 @@ services:
   filebrowser:
     container_name: filebrowser
     volumes:
-     - /docker/filebrowser/config:/config/
-     - /chemin/vers/vos/dossiers:/vosdossiers #ajoutez ici les dossiers que vous voulez voir apparaitre dans filebrowser
+      - /docker/filebrowser/config:/config/
+      - /path/to/your/folders:/yourfolders #add your folders to browse as /docker:/docker for exemple
     ports:
       - 8010:80
     image: filebrowser/filebrowser:s6
 ```
 
 ::alert{type="success"}
-✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the watchtower label to each container to automate updates.
 
     ```yaml
     services:
@@ -45,64 +45,64 @@ services:
           - com.centurylinklabs.watchtower.enable=true
 ::
 
-
-Déployez le conteneur et rendez-vous sur `http://ipduserveur:8010`. Et voilà, votre instance File Browser en webui est disponible !
+Deploy the container and go to `http://yourserverip:8010`. That’s it—your File Browser web UI is up and running!
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it doesn’t work:__ check your firewall rules.
 :::
 ::
 
-## Exposer File Browser avec Swag
+## Exposing File Browser with Swag
 ---
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- File Browser n'utilise pas d'authentification multifacteur. Exposer File Browser sur internet pourrait compromettre les machines auxquelles il est relié. Ne le faite que si vous utilisez un systeme d'authentification multifacteur comme [Authentik](/serveex/securite/authentik/). Sinon, n'exposez pas avec SWAG et utilisez plutôt un VPN comme [Wireguard](/serveex/securite/wireguard).
+- File Browser does not support multi-factor authentication. Exposing it publicly could put your systems at risk. Only do this if you’re using a secure authentication solution like [Authentik](/serveex/security/authentik/). Otherwise, do not expose it with SWAG—use a VPN like [Wireguard](/serveex/security/wireguard) instead.
 :::
 ::
 
-Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer IT Tools via Swag.
+You may want to access File Browser remotely from all your devices. To do that, we’ll expose it through Swag.
 
 ::alert{type="info"}
 :::list{type="info"}
-- __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `files.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+- __Pre-requisite:__ We assume you've already created a subdomain like `files.yourdomain.com` in your [DNS zone](/general/networking/dns) pointing to `yourdomain.com` with a `CNAME`, and—unless you're using Cloudflare Zero Trust—have already forwarded port `443` on your router to port `443` on your server using [NAT rules](/general/networking/nat).
 :::
 ::
 
-Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de filebrowser :
+In Dockge, go to the SWAG stack and edit the compose file to add File Browser’s network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:                 # Relie le conteneur au réseau custom 
+     networks:                 # Connects the container to the custom network 
       # ...           
-      - filebrowser            # Nom du réseau déclaré dans la stack
+      - filebrowser            # Name of the network declared in the stack
     
-networks:                      # Définit le réseau custom
+networks:                      # Defines the custom network
   # ...
-  filebrowser:                 # Nom du réseau déclaré dans la stack
-    name: filebrowser_default  # Nom véritable du réseau externe
-    external: true             # Précise que c'est un réseau à rechercher en externe
+  filebrowser:                 # Name of the network declared in the stack
+    name: filebrowser_default  # Actual name of the external network
+    external: true             # Specifies it's an external network
 ```
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de filebrowser est `filebrowser_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- Here, we assume the network name for File Browser is `filebrowser_default`. You can confirm the connection is working by accessing the SWAG dashboard at http://yourserverip:81.
 :::
 ::
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack by clicking "deploy" and wait for SWAG to fully initialize.
 
-Dans les dossiers de Swag, créez le fichier `files.subdomain.conf`.
+In the Swag folders, create the file `files.subdomain.conf`.
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/files.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+
+Enter insert mode by pressing `i`, and paste the following configuration:
 
 ```nginx
 ## Version 2023/12/19
@@ -150,14 +150,14 @@ server {
         set $upstream_port 80;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, then save and exit with `:x` followed by `Enter`.
+
+That’s it—File Browser is now exposed!
 
-Et voilà, vous avez exposé File Browser !
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez protéger cette app avec Authentik en ouvrant `files.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ __Tip:__ You can protect this app with Authentik by opening `files.subdomain.conf` and uncommenting `include /config/nginx/authentik-server.conf;`{lang=nginx} and `include /config/nginx/authentik-location.conf;`{lang=nginx}. Don’t forget to [create an application and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::

content/3.serveex/7.files/2.pingvin.md

@@ -81,7 +81,7 @@ Tout l'intérêt d'une telle solution, c'est de pouvoir y accéder à distance e
 ::alert{type="info"}
 📋 __Au préalable :__ 
 <br/><br/>
-Nous partons du principe que vous avez le sous-domaine `pingvin.mondomaine.fr` avec un `CNAME` qui pointe vers `mondomaine.fr` dans votre [zone DNS](/generalites/reseau/dns). Et que bien sûr, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), le port `443` de votre box pointe bien sur le port `443` de votre serveur via [les règles NAT](/generalites/reseau/nat).
+Nous partons du principe que vous avez le sous-domaine `pingvin.mondomaine.fr` avec un `CNAME` qui pointe vers `mondomaine.fr` dans votre [zone DNS](/general/networking/dns). Et que bien sûr, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/security/cloudflare), le port `443` de votre box pointe bien sur le port `443` de votre serveur via [les règles NAT](/general/networking/nat).
 ::
 
 Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de pingvin :
@@ -206,8 +206,3 @@ Vous pouvez protéger cette app avec Authentik de façon native en suivant les i
 - `Secret du client OpenID` avec le token que vous avez copié en étape 2.
 
 Et voilà, désormais lorsque vous vous connectez à Pingvin, un bouton "Open ID" sera disponible en dessous de la mire de connexion.
-
-
-
-
-

content/3.serveex/7.files/_dir.yml

@@ -1,2 +1,2 @@
-navigation.title: Fichiers & partage
+navigation.title: File & share
 icon: lucide:folder-tree

content/3.serveex/8.development/1.code-server.md

@@ -1,6 +1,6 @@
 --- 
 navigation: true
-title: Code-Serveur
+title: Code-Server
 main:
   fluid: false
 ---
@@ -8,13 +8,13 @@ main:
 # Code-Server
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer code-server
-- Monter des dossiers dans vscode
-- Exposer code-server avec Swag
+🎯 __Goals:__
+- Install code-server
+- Mount folders into VS Code
+- Expose code-server with Swag
 ::
 
-[code-server](https://github.com/linuxserver/docker-code-server) est un conteneur permettant d'accéder à [vscode](https://code.visualstudio.com/) en web-ui dans un environnement linux. C'est littéralement vscode et vos projets directement dans votre poche, disponibles partout.
+[code-server](https://github.com/linuxserver/docker-code-server) is a container that lets you access [VS Code](https://code.visualstudio.com/) via a web UI in a Linux environment. It's literally VS Code and your projects in your pocket, available anywhere.
 
 ![code-server](https://github.com/coder/code-server/raw/main/docs/assets/screenshot-2.png)
 
@@ -22,21 +22,21 @@ main:
 ---
 ::alert{type="info"}
 :::list{type="info"}
-- Pour cette installation nous utiliserons [l'image maintenue par LinuxServer.io](https://docs.linuxserver.io/images/docker-code-server/).
+- For this setup, we’ll use the [image maintained by LinuxServer.io](https://docs.linuxserver.io/images/docker-code-server/).
 :::
 ::
 
-Structure des dossiers
+Folder structure
 
 ```console
 root
 ├── docker
 │   └── code-server
 │       └── config
-└── #n'importe quel dossier à monter dans vscode
+└── #any folder you want to mount in VS Code
 ```
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `code-server` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `code-server`, and paste the following:
 
 ```yaml
 ---
@@ -51,15 +51,15 @@ services:
       - HASHED_PASSWORD=${PW}
     volumes:
       - /docker/code-server/config:/config
-    # ajoutez vos dossier à monter dans vscode
-    # - /chemin/vers/dossier:/dossier
+    # add folders to mount in VS Code
+    # - /path/to/folder:/folder
     ports:
       - 8443:8443
     restart: unless-stopped
 ```
 
 ::alert{type="success"}
-✨ Ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ Add the Watchtower label to each container to automate updates
 
     ```yaml
     services:
@@ -69,19 +69,19 @@ services:
           - com.centurylinklabs.watchtower.enable=true
 ::
 
-Choisissez un mot de passe et générez un hash
+Choose a password and generate its hash:
 
 ```shell
-echo -n "votremotdepasse" | npx argon2-cli -e
+echo -n "yourpassword" | npx argon2-cli -e
 ```
 
-Notez précieusement le résultat. Trouvez votre PUID et votre GUID en tapant la commande suivante :
+Save the result carefully. Find your PUID and GUID with:
 
 ```shell
-id nomdutilisateur
+id yourusername
 ```
 
-Et renseignez le `.env` avec les infos que vous avez trouvées, par exemple :
+Fill in the `.env` file with the values you found, for example:
 
 ```properties
 PW='$argon2i$v=19$m=4096,t=3,p=1$wST5QhBgk2lu1ih4DMuxvg$LS1alrVdIWtvZHwnzCM1DUGg+5DTO3Dt1d5v9XtLws4'
@@ -91,77 +91,78 @@ GUID=1000
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- __Attention :__ Pensez à mettre un guillemet simple `'`au debut et à la fin du hash
+- __Note:__ Make sure to wrap the hash in single quotes `'`
 :::
 ::
 
-Déployez le conteneur et rendez-vous sur `http://ipduserveur:8443`. Et voilà, votre instance code-server en webui est disponible !
+Deploy the container and go to `http://yourserverip:8443`. Voilà, your code-server instance is up and running in the browser!
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-## Monter des dossiers
+## Mount Folders
 ---
-Vous pouvez monter les dossiers à partager dans vscode en ajoutant les volumes concernés dans le compose.yaml (ou via dockge), et en redéployant le conteneur.
+You can mount folders into VS Code by adding the relevant volumes in `compose.yaml` (or via Dockge), then redeploy the container.
 
 ```yaml
 services:
   code-server:
     #...
     volumes:
-      - /chemin/vers/dossier:/dossier
+      - /path/to/folder:/folder
 ```
-Une fois dans vscode, vous pourrez accéder au dossier.
+Once inside VS Code, you'll have access to the mounted folder.
 
-## Exposer code-server avec Swag
+## Expose code-server with Swag
 ---
-Tout l'intérêt d'une telle solution, c'est de pouvoir y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer coder-server via Swag.
+The whole point of such a solution is to access it remotely from any device. To do this, we’ll expose code-server via Swag.
 
 ::alert{type="info"}
 :::list{type="info"}
-- __Au préalable :__ Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `code.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+- __Preliminary:__ We assume you’ve created a subdomain like `code.yourdomain.com` with a `CNAME` pointing to `yourdomain.com` in your [DNS zone](/general/networking/dns), and—unless you're using [Cloudflare Zero Trust](/serveex/security/cloudflare)—that you’ve forwarded port `443` from your router to port `443` on your server using [NAT rules](/general/networking/nat).
 :::
 ::
 
-Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de code-server :
+In Dockge, go to the SWAG stack and edit the compose file to add code-server’s network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:           # Relie le conteneur au réseau custom 
+     networks:           # Connects the container to a custom network 
       # ...           
-      - code-server      # Nom du réseau déclaré dans la stack
+      - code-server      # Name of the network defined in the stack
     
-networks:                # Définit le réseau custom
+networks:                # Defines the custom network
   # ...
-  code-server:           # Nom du réseau déclaré dans la stack
-    name: code-serveur   # Nom véritable du réseau externe
-    external: true       # Précise que c'est un réseau à rechercher en externe
+  code-server:           # Name of the network defined in the stack
+    name: code-serveur   # Actual name of the external network
+    external: true       # Indicates it’s an external network
 ```
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de code-server est `code-server_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- We assume the network name is `code-server_default`. You can verify that the connection works by visiting the SWAG dashboard at http://yourserverip:81.
 :::
 ::
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Redeploy the stack by clicking “deploy” and wait until SWAG is fully operational.
 
-Dans les dossiers de Swag, créez le fichier `code.subdomain.conf`.
+Inside the Swag config folders, create the file `code.subdomain.conf`.
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ You can use [File Browser](/serveex/files/file-browser) to navigate and edit your files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/code.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+
+Enter insert mode with `i` and paste the following configuration:
 
 ```nginx
 ## Version 2023/12/19
@@ -209,15 +210,14 @@ server {
         set $upstream_port 8443;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, then save and exit by typing `:x` and pressing `Enter`.
 
-Et voilà, vous avez exposé code-server !
+That’s it — code-server is now exposed!
 
 ::alert{type="success"}
-✨ __Astuce :__ Vous pouvez protéger cette app avec Authentik en ouvrant `code.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}.N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ __Tip:__ You can protect this app with Authentik by opening `code.subdomain.conf` and uncommenting the lines `include /config/nginx/authentik-server.conf;` and `include /config/nginx/authentik-location.conf;`. Don’t forget to [create an application and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::

content/3.serveex/8.development/2.gitea.md

@@ -8,18 +8,18 @@ main:
 # Gitea
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer Gitea
-- Exposer Gitea avec Swag
+🎯 __Goals:__
+- Install Gitea
+- Expose Gitea using Swag
 ::
 
-[Gitea](https://https://about.gitea.com/) est une plateforme DevOps, permettant de gérer des dépots, à la manière de GitHub mais chez vous en selfhost.
+[Gitea](https://about.gitea.com/) is a self-hosted DevOps platform that allows you to manage repositories much like GitHub, but on your own infrastructure.
 
 ![gitea](https://about.gitea.com/img/home-screenshot.png)
 
 ## Installation
 ---
-Structure des dossiers
+Folder structure
 
 ```console
 root
@@ -28,7 +28,7 @@ root
         └── data
 ```
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `gitea` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `gitea`, and paste the following content:
 
 ```yaml
 ---
@@ -52,67 +52,68 @@ services:
       - 3333:3000
       - 222:22
 ```
-Et renseignez le `.env` avec les infos que vous avez trouvées, par exemple :
+
+Fill out the `.env` file with the required information, for example:
 
 ```properties
 UID=1000
 GID=1000
 ```
 
-Déployez le conteneur et rendez-vous sur `http://ipduserveur:3333`. Et voilà, votre instance Gitea est disponible !
+Deploy the container and go to `http://yourserverip:3333`. Your Gitea instance is now up and running!
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-## Exposer Gitea avec Swag
+## Exposing Gitea with Swag
 ---
-Tout l'intérêt d'une telle solution, c'est de pouvoir y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer Gitea via Swag.
+The benefit of this setup is being able to access it remotely from any of your devices. To do so, we’ll expose Gitea through Swag.
 
 ::alert{type="info"}
 :::list{type="info"}
-- __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `gitea.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+- __Prerequisite:__ We assume you have created a subdomain such as `gitea.yourdomain.com` in your [DNS zone](/general/networking/dns) with `CNAME` pointing to `yourdomain.com`, and [unless you're using Cloudflare Zero Trust](/serveex/security/cloudflare), you have already forwarded port `443` from your router to your server’s port `443` in the [NAT rules](/general/networking/nat).
 :::
 ::
 
-Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de gitea :
+In Dockge, go to the SWAG stack and edit the compose file by adding Gitea's network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:           # Relie le conteneur au réseau custom 
+     networks:           # Connect the container to the custom network
       # ...           
-      - gitea            # Nom du réseau déclaré dans la stack
+      - gitea            # Name of the declared network
     
-networks:                # Définit le réseau custom
+networks:                # Define the custom network
   # ...
-  gitea:                 # Nom du réseau déclaré dans la stack
-    name: gitea_default  # Nom véritable du réseau externe
-    external: true       # Précise que c'est un réseau à rechercher en externe
+  gitea:                 # Name of the declared network
+    name: gitea_default  # Actual external network name
+    external: true       # Indicates it's an external network
 ```
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de gitea est `gitea_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- We assume the Gitea network name is `gitea_default`. You can verify connectivity by visiting the SWAG dashboard at http://yourserverip:81.
 :::
 ::
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Redeploy the stack by clicking "Deploy" and wait until SWAG is fully operational.
 
-Dans les dossiers de Swag, créez le fichier `gitea.subdomain.conf`.
+Inside the Swag folders, create the file `gitea.subdomain.conf`.
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ You can use [File Browser](/serveex/files/file-browser) to navigate and edit your files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/gitea.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+Press `i` to enter edit mode and paste the configuration below:
 
 ```nginx
 ## Version 2023/12/19
@@ -148,7 +149,7 @@ server {
         #include /config/nginx/authelia-location.conf;
 
         # enable for Authentik (requires authentik-server.conf in the server block)
-	      #include /config/nginx/authentik-location.conf;
+        #include /config/nginx/authentik-location.conf;
 
         include /config/nginx/proxy.conf;
         include /config/nginx/resolver.conf;
@@ -171,28 +172,27 @@ server {
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, then save and exit by typing `:x` and hitting `Enter`.
 
-Ouvrez le fichier `app.ini` dans les fichiers du conteneur
+Now open the `app.ini` file from the container's file system:
 
 ```shell
 sudo vi /docker/gitea/data/gitea/conf/app.ini
 ```
 
-Entrez en modification avec la touche `i` et et modifiez la section serveur avec les infos de votre domaine
+Press `i` to edit, then modify the server section with your domain information:
 
 ```properties
 [server]
-DOMAIN = gitea.mondomaine.fr
-SSH_DOMAIN = gitea.mondomaine.fr
-ROOT_URL = https://gitea.mondomaine.fr/
+DOMAIN = gitea.yourdomain.com
+SSH_DOMAIN = gitea.yourdomain.com
+ROOT_URL = https://gitea.yourdomain.com/
 ```
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
 
-Relancez le conteneur.
+Press `Esc`, save and exit with `:x`, then restart the container.
 
-Et voilà, vous avez exposé Gitea !
+And that’s it! Gitea is now exposed to the web.
 
 ::alert{type="success"}
-✨ __Astuce :__ Vous pouvez protéger cette app avec Authentik de façon native en [suivant ces instructions](https://docs.goauthentik.io/integrations/services/gitea/).
+✨ __Tip:__ You can natively protect this app with Authentik by [following these instructions](https://docs.goauthentik.io/integrations/services/gitea/).
 ::

content/3.serveex/8.development/3.it-tools.md

@@ -1,6 +1,6 @@
 ---
 navigation: true
-title: IT-Tools
+title: IT Tools
 main:
   fluid: false
 ---
@@ -8,19 +8,19 @@ main:
 # IT Tools
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer IT-Tools
-- Exposer IT Tools avec Swag
+🎯 __Goals:__
+- Install IT Tools
+- Expose IT Tools with Swag
 ::
 
-[IT Tools](https://github.com/CorentinTh/it-tools) est un conteneur exposant une page web permettant d'accéder à un grand nombre d'outil de développement.
+[IT Tools](https://github.com/CorentinTh/it-tools) is a container exposing a web page that provides access to a wide range of development tools.
 
 ![IT Tools](/img/serveex/it-tools.png)
 
 ## Installation
 ---
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `it-tools` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `it-tools`, and paste the following:
 
 ```yaml
 ---
@@ -34,7 +34,7 @@ services:
 ```
 
 ::alert{type="success"}
-✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the Watchtower label to each container to enable automatic updates.
 
     ```yaml
     services:
@@ -44,68 +44,67 @@ services:
           - com.centurylinklabs.watchtower.enable=true
 ::
 
-
-Déployez le conteneur et rendez-vous sur `http://ipduserveur:3222`. Et voilà, votre instance IT Tools en webui est disponible !
+Deploy the container and visit `http://yourserverip:3222`. That’s it, your IT Tools web UI instance is up and running!
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-## Exposer IT Tools avec Swag
+## Expose IT Tools with Swag
 ---
-Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer IT Tools via Swag.
+You might want to access it remotely on all your devices. To do that, we'll expose IT Tools using Swag.
 
 ::alert{type="info"}
 :::list{type="info"}
-- __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `tools.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+- __Pre-requisite:__ We assume you’ve created a subdomain like `tools.yourdomain.com` in your [DNS zone](/general/networking/dns) with `CNAME` set to `yourdomain.com`. Also, unless you’re using [Cloudflare Zero Trust](/serveex/security/cloudflare), make sure you’ve already forwarded port `443` from your router to port `443` on your server in the [NAT rules](/general/networking/nat).
 :::
 ::
 
-Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de it-tools :
+In Dockge, go to the SWAG stack and edit the compose file to add the IT Tools network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ...
-     networks:              # Relie le conteneur au réseau custom 
+     networks:              # Connects the container to the custom network 
       # ...           
-      - it-tools            # Nom du réseau déclaré dans la stack
+      - it-tools            # Network name as defined in the IT Tools stack
     
-networks:                   # Définit le réseau custom
+networks:                   # Defines the custom network
   # ...
-  it-tools:                 # Nom du réseau déclaré dans la stack
-    name: it-tools_default  # Nom véritable du réseau externe
-    external: true          # Précise que c'est un réseau à rechercher en externe
+  it-tools:                 # Network name as defined in the IT Tools stack
+    name: it-tools_default  # Actual name of the external network
+    external: true          # Indicates it's an external network
 ```
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de it-tools est `it-tools_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- We assume the IT Tools network is named `it-tools_default`. You can check connectivity by visiting the SWAG dashboard at http://yourserverip:81.
 :::
 ::
 
-
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de Swag est `swag_default`.
+- We also assume the SWAG network is named `swag_default`.
 :::
 ::
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack by clicking "deploy" and wait for SWAG to be fully operational.
 
-Dans les dossiers de Swag, créez le fichier `tools.subdomain.conf`.
+Inside the Swag folders, create the file `tools.subdomain.conf`.
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ You can use [File Browser](/serveex/files/file-browser) to navigate and edit your files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/tools.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+
+Enter edit mode by pressing `i` and paste the configuration below:
 
 ```nginx
 ## Version 2023/12/19
@@ -158,10 +157,10 @@ server {
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, then save and exit by typing `:x` and pressing `Enter`.
 
-Et voilà, vous avez exposé it-tools !
+And that’s it — IT Tools is now exposed!
 
 ::alert{type="success"}
-✨ __Astuce :__ Vous pouvez protéger cette app avec Authentik en ouvrant `tools.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ __Tip:__ You can secure this app with Authentik by opening `tools.subdomain.conf` and uncommenting the lines `include /config/nginx/authentik-server.conf;` and `include /config/nginx/authentik-location.conf;`. Don’t forget to [create an application and a provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::

content/3.serveex/8.development/_dir.yml

@@ -1,2 +1,2 @@
-navigation.title: Développement
+navigation.title: Developpement
 icon: lucide:code-xml

content/3.serveex/9.apps/1.adguard.md

@@ -8,36 +8,37 @@ main:
 # Adguard Home
 
 ::alert{type="info"}
-🎯 __Objectifs :__
-- Installer et déployer Adguard
-- Exposer Adguard
-- Sécuriser les requêtes avec SSL/TLS
-- Configurer les appareils clients
+🎯 __Goals:__
+- Install and deploy Adguard
+- Expose Adguard
+- Secure DNS queries with SSL/TLS
+- Configure client devices
 ::
 
-[AdGuard Home](https://github.com/AdguardTeam/AdGuardHome) est un serveur DNS anti-pub et anti-traçage qui fonctionne au niveau du système. Une fois configuré, il couvrira TOUS vos appareils domestiques et vous n'aurezbesoin d'aucun logiciel côté client pour cela.
+[AdGuard Home](https://github.com/AdguardTeam/AdGuardHome) is a DNS server that blocks ads and tracking at the system level. Once configured, it will protect ALL your home devices without the need for any client-side software.
 
-Il fonctionne comme un serveur DNS qui redirige les domaines de suivi vers un «black hole», empêchant ainsi vos appareils de se connecter à ces serveurs. 
+It works as a DNS server that redirects tracking domains to a “black hole,” preventing your devices from connecting to them.
 
-En pratique, une fois en place, il vous faudra juste configurer les serveurs DNS de vos appareils, pour que ces derniers l'utilisent.
+In practice, once it's in place, all you need to do is set your devices to use Adguard as their DNS server.
 
-**Rappel sur le fonctionnement d'un DNS :**
+**Quick reminder of how DNS works:**
 
-Lorsque vous naviguez sur un site, ou une application, des requêtes sont émises vers un ou des domaines afin d'afficher le contenu de votre page. Les publicités notamment. Votre appareil ne connait pas les adresses IP de ces serveurs à joindre. Pour les connaitre, il va contacter un _serveur de nom_ (Domain Name Server) qui lui va lui répondre avec l'adresse IP la plus à jour pour le domaine de la requête. 
+When you visit a site or use an app, it makes requests to various domains to load content—ads in particular. Your device doesn’t know the IP addresses of these domains, so it contacts a _Domain Name Server_ (DNS), which returns the current IP address.
 
-Par défaut, votre appareil utilise le serveur votre fournisseur d'accès, paramétré dans votre box ou directement sur le CGNAT de votre opérateur si appareil mobile. Cela peut etre changé directement dans les réglages de votre navigateur, mais aussi dans le système de votre appareil, et parfois directement dans votre box si votre FAI le permet.
+By default, your device uses your ISP's DNS server, which is usually configured in your router or, for mobile devices, at the carrier’s CGNAT level. You can change this in your browser settings, your device’s system settings, or even directly in your router, depending on your ISP.
 
-Adguard lui, va s'intercaler entre le serveur de nom et votre appareil. Si vous paramétrez vos appareil, ils contacteront d'abord adguard qui filtrera les requetes, via des listes régulièrement mises à jour :
+Adguard will act as a middleman between your device and the upstream DNS servers. If you configure your devices to use Adguard:
 
-- Si le domaine n'est pas dans une blocklist, il contactera des serveurs de noms génériques (dit upstreams) et répondra vers vos appareils avec l'adresse IP recherchée.
-- Si le domaine est dans une blocklist, il ne contactera pas les DNS upstream et ne répondre pas à vos appareils. Le contenu affilié à cette requete ne s'affichera pas.
+- If the domain is not in a blocklist, Adguard queries the upstream DNS servers and returns the correct IP to your device.
+- If the domain *is* in a blocklist, Adguard will block the request and return nothing, so the associated content won’t load.
 
-C'est ainsi que les pubs et domaines malveillants sont bloqués : leurs domaines sont présents dans la blocklist, le reste de la page lui charge correctement.
+This is how ads and malicious domains are blocked—Adguard blocks only the bad domains, allowing the rest of the page to load normally.
 
 ![Picture](/img/serveex/adguard.svg)
+
 ## Installation
 ---
-Structure des dossiers : 
+Folder structure:
 
 ```console
 root
@@ -51,18 +52,17 @@ root
 
 ::alert{type="info"}
 :::list{type="info"}
-- Nous monterons aussi le dossier `/docker/swag/config/etc/letsencrypt` afin d'avoir accès au certificat SSL de Swag.
+- We will also mount the `/docker/swag/config/etc/letsencrypt` folder to access Swag's SSL certificate.
 :::
 ::
 
-Ouvrez Dockge, et cliquez sur `compose`
+Open Dockge and click `compose`
 
-Nommez la stack `adguardhome` et copiez la configuration ci-dessous
+Name the stack `adguardhome` and paste the configuration below:
 
 ```yaml
 ---
 services:
-  
   adguardhome:
     container_name: adguard
     image: adguard/adguardhome
@@ -77,82 +77,81 @@ services:
       - /docker/adguardhome/confdir:/opt/adguardhome/conf
       - /docker/adguardhome/workdir:/opt/adguardhome/work
       - /docker/swag/config/etc/letsencrypt:/swag-ssl:ro
-
 ```
 
-
-
 ::alert{type="success"}
-✨ __Astuce :__ Ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the watchtower label to each container to automate updates
 
-    ```yaml
-    services:
-      adguardhome:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
+```yaml
+services:
+  adguardhome:
+    # ...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+```
 ::
 
-Déployez la stack.
+Deploy the stack.
 
-Rendez-vous sur `http//ipduserveur:3000` et suivez les instructions
+Go to `http://yourserverip:3000` and follow the setup instructions.
 
-Et voilà, vous avez déployé Adguard !
+That’s it! Adguard is deployed.
 
-## Exposer Adguard avec Swag
+
+## Exposing AdGuard with SWAG
 ---
-Pour être utilisable hors de chez vous, vous devez exposer Adguard
+To make AdGuard usable from outside your home network, you need to expose it.
 
 ::alert{type="info"}
 :::list{type="info"}
-- __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `adguard.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat). Redirigez également le port `53` et le port `853` vers votre serveur. Ces ports serviront à router les requêtes DNS.
+- __Prerequisites:__ We assume you've created a subdomain like `adguard.mydomain.com` in your [DNS zone](/general/networking/dns) with a `CNAME` pointing to `mydomain.com`, and that you’ve already forwarded port `443` from your router to port `443` on your server in your [NAT rules](/general/networking/nat). Also forward port `53` and port `853` to your server. These ports are used to route DNS requests.
 :::
 ::
 
 ::alert{type="warning"}
 :::list{type="warning"}
-- N'utilisez pas les tunnels cloudflare pour exposer Adguard, et désactivez tout proxy.
+- Do not use Cloudflare tunnels to expose AdGuard, and make sure any proxying is disabled.
 :::
 ::
 
-Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau d'adguard :
+In Dockge, go to the SWAG stack and edit the compose file to add the AdGuard network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
       # ... 
-     networks:             # Relie le conteneur au réseau custom 
+     networks:             # Connect the container to the custom network 
       # ...           
-      - adguard            # Nom du réseau déclaré dans la stack
+      - adguard            # Name of the network declared in the stack
     
-networks:                  # Définit le réseau custom
+networks:                  # Define the custom network
   # ...
-  adguard:                 # Nom du réseau déclaré dans la stack
-    name: adguard_default  # Nom véritable du réseau externe
-    external: true         # Précise que c'est un réseau à rechercher en externe
+  adguard:                 # Name of the network declared in the stack
+    name: adguard_default  # Actual name of the external network
+    external: true         # Specifies that this is an external network
 ```
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau d'adguard est `adguard_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- We assume here that the AdGuard network is named `adguard_default`. You can verify the connection is working by visiting the SWAG dashboard at http://yourserverip:81.
 :::
 ::
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack by clicking "Deploy" and wait for SWAG to be fully operational.
 
-Créez et ouvrez le fichier `adguard.subdomain.conf`
+Create and open the file `adguard.subdomain.conf`
 
 ::alert{type="success"}
-✨ __Astuce pour les allergiques au terminal :__
-vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip for terminal haters:__
+You can use [File Browser](/serveex/files/file-browser) to browse and edit files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/adguard.subdomain.conf
 ```
 
-Editez le fichier en appuyant sur `i` puis copiez la configuration ci-dessous :
+Edit the file by pressing `i` and then pasting the configuration below:
 
 ```nginx
 ## Version 2023/05/31
@@ -227,82 +226,80 @@ server {
 
     }
 }
-
 ```
 
 ::alert{type="success"}
-✨ __Astuce :__ 
+✨ __Tip:__ 
 <br/><br/>
-Vous pouvez protéger cette app avec Authentik en ouvrant `adguard.subdomain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. n'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik/#protéger-une-app-par-reverse-proxy). Il vous faudra exclure l'url `https://adguard.mondomaine.fr/dns-query` de l'authentification :
+You can protect this app with Authentik by opening `adguard.subdomain.conf` and removing the `#` in front of `include /config/nginx/authentik-server.conf;`{lang=nginx} and `include /config/nginx/authentik-location.conf;`{lang=nginx}. Don’t forget to [create an application and a provider in Authentik](/serveex/security/authentik/#protéger-une-app-par-reverse-proxy). You’ll need to exclude the URL `https://adguard.mydomain.com/dns-query` from authentication:
 
-- Editez le fournisseur d'Adguard
-- Dans *paramètres avancés du protocole > chemins authentifiés*, saisissez `^/dns-query`
+- Edit the AdGuard provider
+- Under *Advanced Protocol Settings > Authenticated Paths*, enter `^/dns-query`
 ::
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x`
+Press `Esc`, then save and exit by typing `:x`
 
-Et voilà, vous exposez Adguard à présent !
+And that's it! AdGuard is now exposed!
 
-## Configurer le chiffrement SSL/TLS
+## Configure SSL/TLS Encryption
 ---
-Le chiffrement est essentiel si vous souhaitez garder privées les requêtes que vous faites vers adguard. Chiffrer ces requêtes c'est vous assurez que personne, meme votre FAI ne connaissent votre historique. C'est aussi vous assurer que personne d'autre que votre serveur vous répond.
+Encryption is essential if you want to keep your queries to AdGuard private. Encrypting your queries ensures that no one—not even your ISP—can see your history. It also ensures that only your server can respond to you.
 
-Afin de configurer le chiffrement :
+To configure encryption:
 
-- Allez dans _paramètre_ puis dans _chiffrement_.
-- Parametrez comme suit
+- Go to _Settings_ then _Encryption_.
+- Set the options as follows:
 
 ![Picture](/img/serveex/adguard-chiffrement.png)
 
-- Puis en dessous, dans la section _certificats_ cochez _Définir un emplacement de fichier du certificat_
-- Dans le champs de saisie, mettez `/swag-ssl/live/mondomaine.fr/fullchain.pem` en remplaçant `mondomaine.fr` par votre domaine principal.
-- Dans _clé privée_ cochez _Définir un fichier pour la clef privée_
-- Dans le champs de saisie, mettez `/swag-ssl/live/mondomaine.fr/privkey.pem` en remplaçant `mondomaine.fr` par votre domaine principal.
-- Validez
+- Below, in the _Certificates_ section, check _Use file path for certificate_
+- In the input field, enter `/swag-ssl/live/mydomain.com/fullchain.pem`, replacing `mydomain.com` with your actual domain.
+- For _Private Key_, check _Use file path for private key_
+- In the input field, enter `/swag-ssl/live/mydomain.com/privkey.pem`, replacing `mydomain.com` accordingly.
+- Save
 
-Et voilà ! Vous avez protégé vos futures requêtes DNS !
+Done! Your future DNS queries are now protected!
 
-## Configurer les appareils
+## Configure Devices
 ---
-Pour configurer vos appareils, vous avez plusieurs choix (que vous pouvez cumuler).
-### Sécuriser le réseau local
-Vous pouvez sécuriser votre réseau local avec adguard en configurant votre box pour que chaque requête DNS soit dirigée par défaut vers adguard plutot que les services de votre FAI. Attention, votre box doit pouvoir permettre le changement de DNS (Orange ne le permet pas). 
+You have several options (which you can combine) to configure your devices.
+### Secure the Local Network
+You can secure your local network with AdGuard by configuring your router to direct all DNS queries by default to AdGuard instead of your ISP’s DNS. Note: your router must allow DNS changes (Orange routers do not).
 
-Généralement cette option est dans les paramètres _DHCP_ de votre box. Pensez bien à ajouter un serveur secondaire tel que :
+This option is usually in the _DHCP_ settings. Make sure to add a fallback DNS server such as:
 
-- Cloudlare : `1.1.1.1`
-- Google : `8.8.8.8`
+- Cloudflare: `1.1.1.1`
+- Google: `8.8.8.8`
 
-En effet, sans cela, si votre serveur tombe, vos appareils n'arriveraient plus à se connecter à internet.
+Without this, if your server goes down, your devices will lose internet access.
 
 ::alert{type="info"}
 :::list{type="info"}
-- Des appareils peuvent avoir un autre DNS paramétré et ne pas utiliser ceux de la box.
+- Some devices may have a separate DNS configured and may not use the router’s DNS.
 :::
 ::
 
-### Forcer un navigateur à utiliser Adguard
+### Force a Browser to Use AdGuard
 
-Dans votre navigateur, vous pouvez configurer un DNS pour le forcer à utiliser adguard home.
-Dans les paramètres, il vous faudra renseigner l'adresse` https://adguard.mondomaine.fr/dns-query`
+In your browser, you can configure a DNS to force it to use AdGuard Home.
+In the settings, specify the address `https://adguard.mydomain.com/dns-query`
 
-### Windows, paramétrer Adguard au niveau système
+### Configure AdGuard at the System Level on Windows
 
-Dans windows, vous devez paramétrer Adguard pour chaque carte réseau que vous souhaitez utiliser. 
+In Windows, you need to configure AdGuard for each network adapter you want to use.
 
-- Rendez vous dans _accueil > Réseau et internet >_ et choisissez votre carte réseau à modifier
-- Cliquez sur _modifier les DNS_ (parfois dans _propriété du matériel_)
-- Choisissez `Manuel`
-- Activez IPv4
-- Renseignez l'IP publique de votre serveur (celle accessible depuis internet)
-- Activez _DNS sur HTTPS (modèle manuel)_
-- Désactivez _retour au texte en clair_
-- Enregistrez
+- Go to _Home > Network & Internet_, then select the network adapter to modify
+- Click _Edit DNS_ (sometimes under _Hardware Properties_)
+- Choose `Manual`
+- Enable IPv4
+- Enter your server’s public IP (the one accessible from the internet)
+- Enable _DNS over HTTPS (manual template)_
+- Disable _Fallback to plaintext_
+- Save
 
-Tous les programmes de votre machine utilisant cette carte réseau seront filtrés par Adguard.
+All programs using that network adapter will now be filtered by AdGuard.
 
-
-## Ajouter des filtres
+## Add Filters
 ---
 
-- Allez dans les paramètres et changez les filtres.
+- Go to the settings and change the filters.

content/3.serveex/9.apps/2.vaultwarden.md

@@ -8,18 +8,18 @@ main:
 # Vaultwarden
 
 ::alert{type="info"}
-🎯 __Objectifs :__ Installer [Vaultwarden](https://github.com/dani-garcia/vaultwarden) pour gérer vos mot de passe sur tout vos appareils (remplace la gestion de mot de passe Google ou Apple).
+🎯 __Goals:__ Install [Vaultwarden](https://github.com/dani-garcia/vaultwarden) to manage your passwords across all your devices (a replacement for Google or Apple password managers).
 ::
 
 ![Vaultwarden](/img/serveex/vaultwarden.png)
 
-[Vaultwarden](https://github.com/dani-garcia/vaultwarden) est une solution de gestion de vos mot de passe (génération, saisie semi-automatique...) que vous pouvez installer directement sur votre serveur. Cette solution remplace les gestionnaires comme Google, Apple ou Keepass. Cette solution permet de synchroniser tout vos mots de passe sur vos différentes machines, avec un chiffrement de bout en bout.
+[Vaultwarden](https://github.com/dani-garcia/vaultwarden) is a password management solution (generation, autofill...) that you can host directly on your server. This replaces managers like Google, Apple, or Keepass. Vaultwarden synchronizes your passwords across all your devices with end-to-end encryption.
 
-Vaultwarden est un fork de la solution [Bitwarden](https://bitwarden.com/fr-fr/help/).
+Vaultwarden is a fork of [Bitwarden](https://bitwarden.com/fr-fr/help/).
 
 ## Installation
 ---
-Structure des dossiers
+Folder structure:
 
 ```console
 root
@@ -30,7 +30,7 @@ root
         └── .env
 ```
 
-Ouvrez Dockge, cliquez sur `compose`, appelez la stack `vaultwarden` puis copiez collez ceci :
+Open Dockge, click on `compose`, name the stack `vaultwarden`, and paste the following:
 
 ```yaml
 ---
@@ -59,95 +59,95 @@ services:
       - SIGNUPS_VERIFY=true
       - SIGNUPS_VERIFY_RESEND_TIME=3600
       - SIGNUPS_VERIFY_RESEND_LIMIT=5
-
 ```
 
 ::alert{type="success"}
-✨ __Astuce :__ Ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
+✨ __Tip:__ Add the Watchtower label in each container to automate updates
 
-    ```yaml
-    services:
-      vaultwarden:
-        #...
-        labels:
-          - com.centurylinklabs.watchtower.enable=true
+```yaml
+services:
+  vaultwarden:
+    #...
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+```
 ::
 
-Nous allons maintenant générer un hash de mot de passe, qu'il faudra renseigner dans la variable `TOKEN` du `.env`
+Next, generate a password hash to put in the `TOKEN` variable in `.env`:
 
 ```shell
-echo -n 'votremotdepasse' | argon2 "$(openssl rand -base64 32)" -e -id -k 65540 -t 3 -p 4
+echo -n 'yourpassword' | argon2 "$(openssl rand -base64 32)" -e -id -k 65540 -t 3 -p 4
 ```
 
-Copiez le résultat précieusement et gardez en tête le mot de passe que vous avez choisi.
+Copy the result securely.
 
-Dans le `.env`, renseignez les variables suivantes :
+In the `.env` file, enter the following variables:
 
 ```properties
 URL=
 TOKEN=
 ```
 
-| Variable                | Valeur                                                  | Exemple                    |
-|-------------------------|---------------------------------------------------------|----------------------------|
-| `URL`{lang=properties}   | L'url de votre serveur vaultwarden                      | `https://vault.domaine.fr` |
-| `TOKEN`{lang=properties} | Le token que vous avez précédemment copié précieusement | `'$argon2id$v=19$m=65540,t=3,p=4$bXBGME` |
+| Variable | Value | Example |
+|----------|-------|---------|
+| `URL`    | The URL of your Vaultwarden server | `https://vault.yourdomain.com` |
+| `TOKEN`  | The token you previously copied | `'$argon2id$v=19$m=65540,t=3,p=4$bXBGME...` |
 
-Puis déployez le conteneur.
-
-Depuis quelques temps, Vaultwarden ne permet pas d'etre accéder sans certificat SSL, ce qui empeche d'y accéder via son IP local. Nous y accèderons donc après l'avoir exposé avec SWAG, qui ajoute lui même un certificat SSL.
+Then deploy the container.
 
+Recently, Vaultwarden requires SSL to be accessed, which prevents access via a local IP. We'll expose it with SWAG, which provides an SSL certificate.
 
 ::alert{type="danger"}
 :::list{type="danger"}
-- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
+- __If it fails:__ check your firewall rules.
 :::
 ::
 
-## Exposer Vaultwarden avec SWAG
+## Exposing Vaultwarden with SWAG
 ---
-Tout l'intérêt d'une telle solution, c'est de pouvoir y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer Vaultwarden via [SWAG](/serveex/coeur/swag).
+The main benefit of Vaultwarden is being able to access it remotely from any device. We'll expose it through [SWAG](/serveex/core/swag).
 
 ::alert{type="info"}
-✨ __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/reseau/dns) un sous domaine du type `vault.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et, [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/securite/cloudflare), que que vous avez déjà redirigé le port `443` de votre box vers le `443` de votre serveur dans [les règles NAT](/generalites/reseau/nat).
+✨ __Before you start:__ Make sure you've created a DNS subdomain like `vault.yourdomain.com` with `CNAME` pointing to `yourdomain.com` and (unless using Cloudflare Zero Trust) that you've forwarded port `443` from your router to your server's `443` via [NAT rules](/general/networking/nat).
 ::
 
-Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de vaultwarden :
+In Dockge, go to the SWAG stack and edit the compose file to add the Vaultwarden network:
 
 ```yaml
 services:
   swag:
      container_name: # ...
+     # ...
+     networks:             # Connects container to custom network
       # ...
-     networks:             # Relie le conteneur au réseau custom 
-      # ...           
-      - vaultwarden            # Nom du réseau déclaré dans la stack
+      - vaultwarden        # Name of the declared network
     
-networks:                  # Définit le réseau custom
+networks:                  # Defines the custom network
   # ...
-  vaultwarden:                 # Nom du réseau déclaré dans la stack
-    name: vaultwarden_default  # Nom véritable du réseau externe
-    external: true         # Précise que c'est un réseau à rechercher en externe
+  vaultwarden:             # Name of the declared network
+    name: vaultwarden_default  # Actual name of the external network
+    external: true
 ```
 
 ::alert{type="info"}
 :::list{type="info"}
-- Ici nous partons du principe que le nom du réseau de vaultwarden est `vaultwarden_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
+- We're assuming the network name is `vaultwarden_default`. You can check connectivity by visiting the SWAG dashboard at http://yourserverip:81.
 :::
 ::
 
-Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
+Restart the stack by clicking "Deploy" and wait for SWAG to be fully operational.
 
-Dans les dossiers de Swag, créez le fichier `vault.subdomain.conf`.
+In SWAG's config folder, create the file `vault.subdomain.conf`:
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez utiliser [File Browser](/serveex/files/file-browser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
+✨ __Tip:__ Use [File Browser](/serveex/files/file-browser) to navigate and edit files instead of using terminal commands.
 ::
 
 ```shell
 sudo vi /docker/swag/config/nginx/proxy-confs/vault.subdomain.conf
 ```
-Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
+
+Press `i` to edit, and paste the following configuration:
 
 ```nginx
 server {
@@ -174,13 +174,13 @@ server {
         #auth_basic "Restricted";
         #auth_basic_user_file /config/nginx/.htpasswd;
 
-        # enable for ldap auth (requires ldap-server.conf in the server block)
+        # enable for ldap auth
         #include /config/nginx/ldap-location.conf;
 
-        # enable for Authelia (requires authelia-server.conf in the server block)
+        # enable for Authelia
         #include /config/nginx/authelia-location.conf;
 
-        # enable for Authentik (requires authentik-server.conf in the server block)
+        # enable for Authentik
         #include /config/nginx/authentik-location.conf;
 
         include /config/nginx/proxy.conf;
@@ -189,7 +189,6 @@ server {
         set $upstream_port 80;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 
     location ~ ^(/vaultwarden)?/admin {
@@ -197,13 +196,13 @@ server {
         #auth_basic "Restricted";
         #auth_basic_user_file /config/nginx/.htpasswd;
 
-        # enable for ldap auth (requires ldap-server.conf in the server block)
+        # enable for ldap auth
         #include /config/nginx/ldap-location.conf;
 
-        # enable for Authelia (requires authelia-server.conf in the server block)
+        # enable for Authelia
         #include /config/nginx/authelia-location.conf;
 
-        # enable for Authentik (requires authentik-server.conf in the server block)
+        # enable for Authentik
         #include /config/nginx/authentik-location.conf;
 
         include /config/nginx/proxy.conf;
@@ -212,7 +211,6 @@ server {
         set $upstream_port 80;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 
     location ~ (/vaultwarden)?/api {
@@ -222,7 +220,6 @@ server {
         set $upstream_port 80;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 
     location ~ (/vaultwarden)?/notifications/hub {
@@ -232,17 +229,16 @@ server {
         set $upstream_port 80;
         set $upstream_proto http;
         proxy_pass $upstream_proto://$upstream_app:$upstream_port;
-
     }
 }
 ```
 
-Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
+Press `Esc`, then type `:x` and press `Enter` to save and exit.
 
-Et voilà, vous avez exposé Vaultwarden ! Accédez au panneau d'administration via `https://vault.mondomaine.fr/admin` et collez le mot de passe que vous avez choisi pour générer l'`ADMIN_TOKEN`. Plus d'info sur les fonctionnalités de [Bitwarden](https://bitwarden.com/help/).
+And there you go — Vaultwarden is now exposed! Visit `https://vault.yourdomain.com/admin` to access the admin panel and paste the password you specified when generatique the `ADMIN_TOKEN`. For more information, see the [Bitwarden documentation](https://bitwarden.com/help/).
 
-N'oubliez pas d'installer les extensions Bitwarden (elles sont compatibles avec Vaultwarden) pour [Chrome](https://chromewebstore.google.com/detail/gestionnaire-de-mots-de-p/nngceckbapebfimnlniiiahkandclblb) ou pour [Firefox](https://addons.mozilla.org/fr/firefox/addon/bitwarden-password-manager/) ainsi que les applications [iOS](https://apps.apple.com/fr/app/bitwarden/id1137397744) et [Android](https://play.google.com/store/apps/details?id=com.x8bit.bitwarden&hl=fr) afin de synchroniser vos mot de passe.
+Don't forget to install Bitwarden browser extensions (they work with Vaultwarden) for [Chrome](https://chromewebstore.google.com/detail/gestionnaire-de-mots-de-p/nngceckbapebfimnlniiiahkandclblb) and [Firefox](https://addons.mozilla.org/fr/firefox/addon/bitwarden-password-manager/), as well as [iOS](https://apps.apple.com/fr/app/bitwarden/id1137397744) and [Android](https://play.google.com/store/apps/details?id=com.x8bit.bitwarden&hl=fr) apps to sync your passwords.
 
 ::alert{type="success"}
-✨ __Astuce :__ vous pouvez protéger cette app avec Authentik en ouvrant `tools.subodmain.conf` et en retirant les `#` devant `include /config/nginx/authentik-server.conf;`{lang=nginx} et `include /config/nginx/authentik-location.conf;`{lang=nginx}. N'oubliez pas de [créer une application et un fournisseur dans Authentik](/serveex/securite/authentik#protéger-une-app-par-reverse-proxy).
+✨ __Tip:__ You can protect this app with Authentik by opening `tools.subdomain.conf` and removing the `#` in front of `include /config/nginx/authentik-server.conf;` and `include /config/nginx/authentik-location.conf;`. Don't forget to [create an application and provider in Authentik](/serveex/security/authentik#protecting-an-app-via-reverse-proxy).
 ::

content/3.serveex/9.apps/_dir.yml

@@ -1,2 +1,2 @@
-navigation.title: Applications utiles
+navigation.title: Useful Apps
 icon: lucide:award

content/5.betises/1.python/1.nvidia-stock-bot.md

@@ -1,43 +0,0 @@
----
-navigation: true
-title: Nvidia Stock Bot
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Scripts python
-
-Mes cochonneries en python
-
-## 🤖 Nvidia Stock Bot
----
-
-Depuis déjà 4 ans, la pénurie de materiel electronique fait rage. Et les cartes graphiques ne sont pas épargnées. En 2020, j'ai du attendre 2 mois pour obtenir mon exemplaire de RTX 3080, et pour cela j'ai du m'inscrire sur [JV Hardware](https://discord.gg/gxffg3GA96) où une poignée de geek avait mis en place un bot qui envoyait un ping lorsqu'elles étaient disponibles.
-
-4 ans après et 5000 abonnés plus tard, vient la sortie des RTX 5000. Et là aucun bot dispo sur le marché ne semble fonctionner correctement. Je ne parle même pas d'un certain "influenceur" qui se permet de faire payer l'accès à son bot qui ne fonctionne meme pas. Il copie à la main les alertes provenant d'autres serveurs, comme le notre qui ont résolu le problème.
-
-Quoiqu'il en soit, désireux d'obtenir une RTX 5090 pour ma machine dédiée à l'IA, je me suis dit qu'il était peut etre le temps de plonger dans le monde de python et de ChatGPT pour m'épauler. A l'aide d'un autre membre du serveur, KevOut, qui a principalement guidé sur le principe de départ et les sources des différentes API, j'ai réussi à obtenir un bot propre, fonctionnel, qui envoie différents types d'alertes via Discord. Avec un simple conteneur docker à déployer.
-
-Après moult déconvenues, je suis passé de ceci :
-
-![Nvidia Stock Bot Old](/img/betises/nvidia-stock-bot-old.svg)
-
-à cela :
-
-![Nvidia Stock bot](/img/betises/nvidia-stock-bot.svg)
-
-Et plus récemment :
-
-![Nvidia Stock bot](/img/betises/nvidia-stock-bot-en-v4.svg)
-
-J'ai également eu la chance d'être référencé dans la fameuse [newsletter selfhost](https://selfh.st/weekly/2025-07-11/) !
-
-Plus d'infos directement sur le repo :
-
- 
-  ::card
-  #title
-    🐋 __Nvidia Stock Bot__
-  #description
-  [Robot d'alerte de stock de GPU Nvidia](https://git.djeex.fr/Djeex/nvidia-stock-bot)
-  ::

content/5.betises/1.python/2.adguard-cidre.md

@@ -1,38 +0,0 @@
----
-navigation: true
-title: Adguard CIDRE
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-# 🤖 Adguard CIDRE Sync
----
-
-Adguard Home est une solution merveilleuse pour filter ses requêtes DNS et ainsi se débarasser de la publicité ou des DNS des fournisseurs d'accès, ou encore réécrire des requetes.
-
-Quand c'est en local, c'est très chouette. Mais quand on veut que tout ses appareils en profitent même à l'exterieur, on est obligé de l'exposer sur le net. Et n'importe qui peut s'en servir et saturer le petit remote à 1€ qu'on a pris pour l'heberger.
-
-Adguard permet d'avoir des listes de clients autorisés ou bloqués. Problème, pour autoriser un client il faut son IP, et dans le cas d'un téléphone sur le réseau mobile, beh elle change régulièrement. L'idée est donc plutot de bloquer des listes générales plutot que d'autoriser des IP qui de toute façon changent régulièrement.
-
-CIDRE est un outil qui permet de synchroniser des listes de plages IP géolocalisées mises à jour régulièrement avec un pare feu. Plutot que de faire tourner CIDRE sur le remote complet avec des règles de pare feu complexes, je me suis dit qu'il fallait simplement s'arranger pour ajouter les plages IP à jour que CIDRE propose au systeme de block list d'adguard, selon les pays que l'on souhaite bloquer.
-
-C'est ainsi qu'est né Adguard CIDRE Sync, un conteneur qui synchronise régulièrement la block list d'Adguard avec les plages IP recensées par CIDRE à la fréquence que vous voulez.
-
-L'idée etant de :
-- Backup le fichier de conf d'Adguard au premier lancement (le fichier jamais touché par le robot est ainsi conservé au cas où)
-- Télécharger la liste des pays selectionnés via une variable d'environnement
-- Permettre d'ajouter soi-meme des IP "à la main" dans un fichier
-- Concaténer le tout, backup le fichier de conf (dernière update), et injecter la liste dans la bonne section du fichier de conf d'Adguard
-- Recharger Adguard en relançant le container (accès au socket via docker socket proxy pour limiter les permissions)
-
-Tout ceci de manière complètement autonome, avec une fréquence choisie en variable d'environnement dans la conf du compose.
-
-Plus d'infos directement sur le repo :
-
- 
-  ::card
-  #title
-    🐋 __Adguard CIDRE Sync__
-  #description
-  [Robot de synchronisation de la blocklist d'Adguard](https://git.djeex.fr/Djeex/adguard-cidre)
-  ::

content/5.betises/2.bash/1.servarr-doublons.md

@@ -1,141 +0,0 @@
----
-navigation: true
-title: Doublons servarr
-main:
-  fluid: false
----
-:ellipsis{left=0px width=40rem top=10rem blur=140px}
-
-# Detection de doublons et remplacement par des hardlinks
----
-
-Six mois après avoir téléchargé des térabytes de media, je me suis rendu compte que Sonarr et Radarr les copaient dans ma biblio Plex au lieu de créer des hardlinks. C'est dû à un mécanisme contre intuitif qui est que si vous montez plusieurs dossiers dans Sonarr/Radarr, il les voit comme deux systemes de fichiers différents. Et ne peut donc pas créer de hardlinks. C'est pour cela qu'il ne faut monter qu'un seul dossier parent, qui contient tous les enfants (`downloads`, `movies`, `tvseries` dans le dossier parent `media` par exemple).
-
-J'ai donc restructuré mes dossiers, remis à la main chaque chemin dans Qbittorrent, Plex, et autres. Il restait à trouver un moyen de détecter les doublons existants et d'automatiquement les supprimer et de créer des hardlinks à la place, pour économiser de l'espace.
-
-Mes dossiers :
-
-```console
-.
-└── media
-    ├── seedbox
-    ├── radarr
-    │   └── tv-radarr
-    ├── movies
-    └── tvseries
-```
-
-Mes dossiers originaux sont dans `seedbox`, et il ne faut surtout pas les modifier pour qu'ils continuent d'etre "seed". Les copies, et donc doublons, sont dans `movies` et `tvseries`. Mais pour complexifier la chose, j'ai aussi des media uniques originaux déposés par ailleurs dans `movies` et `tvseries`, sinon cela serait trop facile. Et dans ces deux dossiers, il peut y avoir des sous dossiers, des sous-sous dossiers, etc. 
-
-L'idée est donc de : 
-
-- lister les originaux dans seedbox
-- lister les fichiers dans movies
-- comparer les deux listes et isoler les chemins des doublons
-- supprimer les doublons
-- hardlinker les originaux dans les dossiers des doublons supprimés
-
-Alors oui j'ai demandé à ChatGPT et à Qwen3 (que j'héberge sur une machine dédiée à l'IA). Et evidemment ils m'ont conseillé les rfind, rdfind, dupes, rdupes, rmlint... Mais comparer les hash de 30TB de media, faudrait plusieurs jours, j'ai vite abandonné.
-
-Au final, je n'ai que des `.mkv` à chercher et les doublons ont exactement les mêmes noms que les originaux, ce qui simplifie grandement la tâche. Un simple script bash devait donc être suffisant.
-
-Je vous passe les incessantes questions réponses avec ChatGPT, je suis assez déçu. Qwen3 a été bien plus propre. ChatGPT n'a pas cessé de mettre des solutions type awk, qui pètent la lecture des chemins au moindre espace. En faisant relire à Qwen, et en lui demandant de se passer de awk, le résultat a été immediatement plus qualitatif.
-
-Pour tester, j'ai d'abord demandé un script qui ne fait que lister et comparer :
-
-```bash
-#!/bin/bash
-
-# Créer un tableau associatif pour stocker les doublons
-declare -A seen
-
-# Trouver tous les fichiers .mkv uniquement (exclure les dossiers)
-find /media/seedbox /media/movies /media/tvseries -type f -name "*.mkv" -print0 | \
-while IFS= read -r -d '' file; do
-    # Obtenir l'inode du fichier et son chemin
-    inode=$(stat --format="%i" "$file")
-    filename=$(basename "$file")
-    
-    # Si ce nom de fichier a déjà été vu
-    if [[ -n "${seen[$filename]}" ]]; then
-        # Vérifier si l'inode est différent du précédent
-        if [[ "${seen[$filename]}" != "$inode" ]]; then
-            # Ajouter le doublon à la sortie en affichant les chemins complets
-            echo "Doublons pour \"$filename\" :"
-            echo "${seen["$filename"]} ${seen["$filename:full_path"]}"
-            echo "$inode $file"
-            echo
-        fi
-    else
-        # Si c'est la première fois qu'on rencontre ce nom de fichier
-        seen[$filename]="$inode"
-        seen["$filename:full_path"]="$file"
-    fi
-done
-```
-
-J'ai ainsi obtenu ce type de réponse :
-
-```
-Doublons pour "episode1.mkv" :
-1234567 /media/seedbox/sonarr/Serie 1/Season1/episode1.mkv
-2345678 /media/tvseries/Serie 1/Season1/episode1.mkv
-```
-
-Avec "awk", il se serait arrêté à  `/media/seedbox/sonarr/Serie`. Je ne suis absolument pas un pro, mais Qwen3 a été plus performant et m'a expliqué de A à Z pourquoi et comment faire.
-
-Une fois que j'ai vu que cela fonctionnait bien, j'ai demandé un script qui fait l'intégralité de la cinématique, de la comparaison aux hardlinks en passant par la suppression des doublons.
-Encore une fois ChatGPT a été décevant. Malgré mes demandes, il créait d'abord les hardlinks et ensuite il supprimait les doublons. Ce qui.. suprimme aussi le lien (meme si cela conserve l'originale). Idiot.
-Petit détour par Qwen3, et ma RTX 5090 en PLS, et paf un résultat bien plus propre. Bon il a gardé les emoji de ChatGPT qui peut pas s'empecher d'en mettre partout, mais voilà :
-
-```bash
-#!/bin/bash
-
-echo "🔍 Étape 1 : Indexation des fichiers originaux dans /media/seedbox..."
-declare -A seen
-
-# Indexe tous les .mkv dans seedbox
-while IFS= read -r -d '' file; do
-    filename=$(basename "$file")
-    seen["$filename"]="$file"
-done < <(find /media/seedbox -type f -name "*.mkv" -print0)
-
-echo "📦 Étape 2 : Remplacement automatique des doublons..."
-total_doublons=0
-total_ko_economises=0
-
-while IFS= read -r -d '' file; do
-    filename=$(basename "$file")
-    original="${seen[$filename]}"
-
-    if [[ -n "$original" && "$original" != "$file" ]]; then
-        inode_orig=$(stat -c %i "$original")
-        inode_dupe=$(stat -c %i "$file")
-
-        if [[ "$inode_orig" != "$inode_dupe" ]]; then
-            size_kb=$(du -k "$file" | cut -f1)
-            echo "🔁 Remplacement :"
-            echo "    Doublon   : $file"
-            echo "    Original  : $original"
-            echo "    Taille    : ${size_kb} Ko"
-
-            rm "$file" && ln "$original" "$file" && echo "✅ Hardlink créé."
-
-            total_doublons=$((total_doublons + 1))
-            total_ko_economises=$((total_ko_economises + size_kb))
-        fi
-    fi
-done < <(find /media/movies /media/tvseries -type f -name "*.mkv" -print0)
-
-echo ""
-echo "🧾 Résumé :"
-echo "    🔗 Doublons remplacés par hardlink : $total_doublons"
-echo "    💾 Espace disque économisé approximatif : ${total_ko_economises} Ko (~$((total_ko_economises / 1024)) Mo)"
-echo "✅ Terminé."
-```
-
-Bilan j'ai :
-- appris pas mal de subtilité bash
-- appris qu'il ne faut jamais copier coller un script généré ChatGPT sans le comprendre et sans le tester en dry-run
-- appris que Qwen sur une RTX 5090 est plus cohérent que ChatGPT 4o sur des fermes de serveurs (je vous passe les résultats de la version "normale").
-- appris que même quand on a 100TB d'espace, monitorer ce dernier m'aurait permis de voir beaucoup plus tot que j'avais 12TB de doublons qui trainent.

content/5.betises/_dir.yml

@@ -1,2 +0,0 @@
-icon: noto:test-tube
-navigation.title: Mes bêtises

content/5.nonsense/1.python/1.nvidia-stock-bot.md

@@ -0,0 +1,39 @@
+---
+navigation: true
+title: Nvidia Stock Bot
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+
+# 🤖 Nvidia Stock Bot
+---
+
+For the past four years, the electronics hardware shortage has been relentless. Graphics cards are no exception. In 2020, I had to wait two months to get my RTX 3080. To manage it, I joined [JV Hardware](https://discord.gg/gxffg3GA96), where a small group of geeks had set up a bot that pinged users when GPUs became available.
+
+Four years later and with 5,000 members on the server, the RTX 5000 series is being released. Yet, no working stock bot seems to exist. Not to mention a certain “influencer” who charges users for access to a bot that doesn’t even work. He manually copies alerts from other servers like ours, which have already solved the issue.
+
+Anyway, eager to get an RTX 5090 for my AI-dedicated machine, I decided it was time to dive into Python—with a little help from ChatGPT. Along with another member, KevOut, who helped guide me through the APIs and initial architecture, I ended up building a clean and functional bot that sends different kinds of Discord alerts—all deployable in a simple Docker container.
+
+After many setbacks, I went from this:
+
+![Nvidia Stock Bot Old](/img/nonsense/nvidia-stock-bot-old-en.svg)
+
+To this:
+
+![Nvidia Stock bot](/img/nonsense/nvidia-stock-bot-en.svg)
+
+And more recently :
+
+![Nvidia Stock bot](/img/nonsense/nvidia-stock-bot-en-v4.svg)
+
+And I was also lucky enough to be referenced in the famous [selfhost newsletter](https://selfh.st/weekly/2025-07-11/) !
+
+More info directly on the repo:
+
+::card
+#title
+  🐋 __Nvidia Stock Bot__
+#description
+  [Nvidia GPU stock alert bot](https://git.djeex.fr/Djeex/nvidia-stock-bot)
+::

content/5.nonsense/1.python/2. adguard-cidre.md

@@ -0,0 +1,38 @@
+---
+navigation: true
+title: Adguard CIDRE
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+
+# 🤖 Adguard CIDRE Sync
+---
+
+Adguard Home is a fantastic solution for DNS-level ad blocking and rewriting requests—perfect for removing ISP DNS trackers or intrusive ads.
+
+It works great locally, but if you want all your devices (even on the go) to benefit, you’ll need to expose Adguard to the internet. Unfortunately, that means anyone can use it, potentially overloading your €1/month remote VPS.
+
+Adguard allows whitelisting or blacklisting clients. The problem? To whitelist a client, you need their IP—but for mobile phones, that IP changes often. Instead of trying to whitelist ever-changing IPs, the better approach is to block broader IP ranges by region.
+
+CIDRE is a tool that syncs geo-targeted IP ranges with firewalls. Instead of running CIDRE with a full firewall stack on the remote server, I figured I could just import those regularly updated IP ranges into Adguard’s blocklist.
+
+Thus, Adguard CIDRE Sync was born: a container that syncs Adguard’s blocklist with CIDRE’s updated IP ranges on a schedule of your choosing.
+
+The idea is to:
+- Backup Adguard’s config file on first run (original untouched version saved)
+- Download selected country IP ranges via an environment variable
+- Let you manually add custom IPs via a file
+- Concatenate, backup the config again (as the updated version), and inject the list into the correct blocklist section
+- Reload Adguard by restarting the container (using Docker socket proxy for limited permissions)
+
+All fully autonomous, with frequency set via environment variable in the `docker-compose` config.
+
+More info directly on the repo:
+
+::card
+#title
+  🐋 __Adguard CIDRE Sync__
+#description
+  [Adguard blocklist sync bot](https://git.djeex.fr/Djeex/adguard-cidre)
+::

content/5.nonsense/1.python/_dir.yml

@@ -0,0 +1,2 @@
+navigation.title: Python
+icon: lucide:file-code-2

content/5.nonsense/2.bash/1.servarr-duplicates.md

@@ -0,0 +1,141 @@
+---
+navigation: true
+title: Servarr corrector
+main:
+  fluid: false
+---
+:ellipsis{left=0px width=40rem top=10rem blur=140px}
+# Servarr duplicates corrector
+---
+
+Six months after downloading terabytes of media, I realized that Sonarr and Radarr were copying them into my Plex library instead of creating hardlinks. This happens due to a counterintuitive mechanism: if you mount multiple folders in Sonarr/Radarr, it sees them as different filesystems and thus cannot create hardlinks. That’s why you should mount only one parent folder containing all child folders (like `downloads`, `movies`, `tvseries` inside a `media` parent folder).
+
+So I restructured my directories, manually updated every path in Qbittorrent, Plex, and others. The last challenge was finding a way to detect existing duplicates, delete them, and automatically create hardlinks instead—to save space.
+
+My directory structure:
+
+```console
+.
+└── media
+    ├── seedbox
+    ├── radarr
+    │   └── tv-radarr
+    ├── movies
+    └── tvseries
+```
+
+The originals are in `seedbox` and must not be modified to keep seeding. The copies (duplicates) are in `movies` and `tvseries`. To complicate things, there are also unique originals in `movies` and `tvseries`. And within those, there can be subfolders, sub-subfolders, etc.
+
+So the idea is to:
+
+- list the originals in seedbox
+- list files in movies and tvseries
+- compare both lists and isolate duplicates
+- delete the duplicates
+- hardlink the originals to the deleted duplicate paths
+
+Yes, I asked ChatGPT and Qwen3 (which I host on a dedicated AI machine). Naturally, they suggested tools like rfind, rdfind, dupes, rdupes, rmlint... But hashing 30TB of media would take days, so I gave up quickly.
+
+In the end, I only needed to find `.mkv` files, and duplicates have the exact same name as the originals, which simplifies things a lot. A simple Bash script would do the job.
+
+Spare you the endless Q&A with ChatGPT—I was disappointed. Qwen3 was much cleaner. ChatGPT kept pushing awk-based solutions, which fail on paths with spaces. With Qwen’s help and dropping awk, the results improved significantly.
+
+To test, I first asked for a script that only lists and compares:
+
+```bash
+#!/bin/bash
+
+# Create an associative array to store duplicates
+declare -A seen
+
+# Find all .mkv files only (exclude directories)
+find /media/seedbox /media/movies /media/tvseries -type f -name "*.mkv" -print0 | \
+while IFS= read -r -d '' file; do
+    # Get the file's inode and name
+    inode=$(stat --format="%i" "$file")
+    filename=$(basename "$file")
+    
+    # If the filename has been seen before
+    if [[ -n "${seen[$filename]}" ]]; then
+        # Check if the inode is different from the previous one
+        if [[ "${seen[$filename]}" != "$inode" ]]; then
+            # Output the duplicates with full paths
+            echo "Duplicates for \"$filename\":"
+            echo "${seen["$filename"]} ${seen["$filename:full_path"]}"
+            echo "$inode $file"
+            echo
+        fi
+    else
+        seen[$filename]="$inode"
+        seen["$filename:full_path"]="$file"
+    fi
+done
+```
+
+This gave me outputs like:
+
+```
+Duplicates for "episode1.mkv":
+1234567 /media/seedbox/sonarr/Serie 1/Season1/episode1.mkv
+2345678 /media/tvseries/Serie 1/Season1/episode1.mkv
+```
+
+With `awk`, it would’ve stopped at `/media/seedbox/sonarr/Serie`. I’m far from an expert, but Qwen3 performed better and explained everything clearly.
+
+Once I verified the output, I asked for a complete script: compare, delete duplicates, create hardlinks.
+
+Again, ChatGPT disappointed. Despite my requests, it created hardlinks *before* deleting the duplicates—effectively linking and then deleting the link (though the original is kept). Not helpful.
+
+Quick stopover to Qwen3, RTX 5090 in overdrive, and bam—much better result. Yes, it kept ChatGPT-style emojis, but here it is:
+
+```bash
+#!/bin/bash
+
+echo "🔍 Step 1: Indexing original files in /media/seedbox..."
+declare -A seen
+
+# Index all .mkv files in seedbox
+while IFS= read -r -d '' file; do
+    filename=$(basename "$file")
+    seen["$filename"]="$file"
+done < <(find /media/seedbox -type f -name "*.mkv" -print0)
+
+echo "📦 Step 2: Automatically replacing duplicates..."
+total_doublons=0
+total_ko_saved=0
+
+while IFS= read -r -d '' file; do
+    filename=$(basename "$file")
+    original="${seen[$filename]}"
+
+    if [[ -n "$original" && "$original" != "$file" ]]; then
+        inode_orig=$(stat -c %i "$original")
+        inode_dupe=$(stat -c %i "$file")
+
+        if [[ "$inode_orig" != "$inode_dupe" ]]; then
+            size_kb=$(du -k "$file" | cut -f1)
+            echo "🔁 Replacing:"
+            echo "    Duplicate : $file"
+            echo "    Original  : $original"
+            echo "    Size      : ${size_kb} KB"
+
+            rm "$file" && ln "$original" "$file" && echo "✅ Hardlink created."
+
+            total_doublons=$((total_doublons + 1))
+            total_ko_saved=$((total_ko_saved + size_kb))
+        fi
+    fi
+done < <(find /media/movies /media/tvseries -type f -name "*.mkv" -print0)
+
+echo ""
+echo "🧾 Summary:"
+echo "    🔗 Duplicates replaced by hardlink: $total_doublons"
+echo "    💾 Approx. disk space saved: ${total_ko_saved} KB (~$((total_ko_saved / 1024)) MB)"
+echo "✅ Done."
+```
+
+So, in conclusion, I:
+- Learned many Bash subtleties
+- Learned never to blindly copy-paste a ChatGPT script without understanding and dry-running it
+- Learned that Qwen on a RTX 5090 is more coherent than ChatGPT-4o on server farms (not even mentioning “normal” ChatGPT)
+- Learned that even with 100TB of storage, monitoring it would’ve alerted me much earlier to the 12TB of duplicates lying around

content/5.nonsense/2.bash/2.luks- backup.md

@@ -1,27 +1,28 @@
 ---
 navigation: true
-title: Luks backup
+title: LUKS Backup
 main:
   fluid: false
 ---
 :ellipsis{left=0px width=40rem top=10rem blur=140px}
-# Backup des headers luks pour disques/volumes chiffrés
+
+# Backup of LUKS Headers for Encrypted Disks/Volumes
 ---
 
-Je me suis rendu compte il y a peu qu'il ne suffisait pas d'avoir le mot de passe pour deverouiller un volume luks apres une panne ou une corruption. J'ai ainsi appris à dump les headers luks des disques/volumes et à utiliser les numéros de série + noms de partitions pour pouvoir bien identifier quel header correspond à quel disque/partition (j'en ai 10 !).
+I recently realized that having just the password is not enough to unlock a LUKS volume after a failure or corruption. I learned how to dump the LUKS headers from disks/volumes and to use the serial numbers along with partition names to accurately identify which header corresponds to which disk/partition (I have 10 of them!).
 
-Après avoir bien galéré à la main, j'avoue avoir demandé à Qwen3 (llm hebergé sur ma RTX 5090) de me faire un script qui automatise le listing et identification des disques, dump les headers et les stock dans une archive chiffrée prete à etre backupée sur mon serveur de sauvegarde.
+After struggling to do this manually, I asked Qwen3 (an LLM running on my RTX 5090) to create a script that automates the listing and identification of disks, dumps the headers, and stores them in an encrypted archive ready to be backed up on my backup server.
 
-Ainsi, ce script :
-* Liste et identifie les disques avec leur numéro de série
-* Liste les partition
-* Dump les headers dans un dossier dans `/root` (dossier sécurisé)
-* Cree une archive temporaire
-* Prompt pour saisir un mot de passe
-* Chiffre avec le mot de passe
-* Détruit l'archive non chiffrée
+This script:
+* Lists and identifies disks with their serial numbers
+* Lists partitions
+* Dumps headers into a secured folder under `/root`
+* Creates a temporary archive
+* Prompts for a password
+* Encrypts the archive with that password
+* Deletes the unencrypted archive
 
-```
+```bash
 #!/bin/bash
 
 # Directory where LUKS headers will be backed up
@@ -84,4 +85,4 @@ else
 fi
 ```
 
-Ne pas oublier de backup `/etc/fstab` et `/etc/crypttab` !
+**Don’t forget to back up `/etc/fstab` and `/etc/crypttab` as well!**

content/5.nonsense/2.bash/_dir.yml

@@ -0,0 +1,2 @@
+navigation.title: Bash
+icon: lucide:file-terminal

content/5.nonsense/_dir.yml

@@ -0,0 +1,2 @@
+icon: noto:test-tube
+navigation.title: My nonsense

nuxt.config.ts

@@ -8,7 +8,6 @@ export default defineNuxtConfig({
     fallback:'dark',
   },
   
-
   content: {
     highlight: {
       langs: [
@@ -27,7 +26,6 @@ export default defineNuxtConfig({
   },
 
   app: {
-    baseURL: '/fr/',
     head: {
       link: [
         { rel: 'icon', type: 'image/x-icon', href: '/img/favicon/favicon.ico' },