Wireguard + images

app.config.ts

@@ -41,8 +41,8 @@ export default defineAppConfig({
     },
     github: {
       baseUrl:'https://git.djeex.fr',
-      dir: '.starters/default/content',
-      branch: 'master',
+      dir: 'content',
+      branch: 'src/master',
       repo: 'docudjeex',
       owner: 'Djeex',
       edit: true

assets/css/extra.css

@@ -10,3 +10,13 @@
     --shiki-dark-bg: #00000000 !important;
     --shiki-default-bg: #00000000 !important;
 }
+
+.alert.success[data-v-756a9723] .alert-content code {
+    color: var(--elements-state-success-color-primary) !important;
+    background-color: #00000000 !important;
+}
+
+.alert.info[data-v-756a9723] .alert-content code {
+    color: var(--elements-state-success-color-primary) !important;
+    background-color: #00000000 !important;
+}

content/1.serveex/1.introduction.md

@@ -7,7 +7,7 @@ main:
 ## Un home lab par un débutant pour les débutants
 
 <p align="center">
-<img src="/img/schema/serveex.svg" align="center" width="700">
+<img src="/img/serveex/serveex.svg" align="center" width="700">
 
 **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.
 

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

@@ -12,7 +12,7 @@ main:
 - Installer Debian 12 et les dépendances principales pour avoir un OS pret à l'emploi, joignable en SSH.
 ::
 
-![picture](/img/schema/server.svg)
+![picture](/img/serveex/server.svg)
 
 ## Installation
 ---

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

@@ -0,0 +1,175 @@
+---
+navigation: true
+title: Docker
+main:
+  fluid: false
+---
+# 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
+version: "4"
+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
+version: "2.3"
+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/1.serveex/2.coeur/3.swag.md

@@ -11,9 +11,7 @@ main:
 Ci-dessous, vous trouverez un exemple, exposant Dockge.
 
 ::alert{type="info"}
-:::list{type="primary"}
-- __Objectifs :__
-:::
+__Objectifs :__
 - Installer Swag
 - Activer le SSL
 - Accéder au tableau de bord
@@ -31,7 +29,7 @@ Nous installerons SWAG, ainsi que le mod dbip servant à bloquer les connexions
 
 **Principe d'un reverse proxy et application dans notre cas :**
 
-![Picture](/img/schema/reverse-proxy.svg)
+![Picture](/img/serveex/reverse-proxy.svg)
 
 ## Installation
 ---
@@ -94,16 +92,15 @@ networks:
 ::alert{type="success"}
 :::list{type="success"}
 - __Astuce :__
+ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
 :::
-
-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` :
@@ -130,12 +127,12 @@ En CLI, allez dans le dossier dns-conf et éditez le fichier `ovh.ini` :
 
 ::alert{type="success"}
 :::list{type="success"}
-- __Astuce pour les allergiques au terminal__
+- __Astuce pour les allergiques au terminal :__
+vous pouvez utiliser [File Browser](/serveex/filebrowser) pour naviguer dans vos fichier et éditer vos documents au lieu d'utiliser les commandes du terminal.
 :::
-
-Vous pouvez utiliser [File Browser](/serveex/filebrowser) 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
 ```
@@ -270,7 +267,7 @@ Dans les fichiers de conf des domaines (section suivante), vous pourrez activer
 ---
 ::alert{type="info"}
 __Prérequis :__
-Nous partons du principe que vous avez créé dans votre [zone DNS](../../dns) un sous domaine du type `dockge.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/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](../../nat).
+- Nous partons du principe que vous avez créé dans votre [zone DNS](../../dns) un sous domaine du type `dockge.mondomaine.fr` avec pour `CNAME` `mondomaine.fr` et [à moins que vous utilisiez Cloudflare Zero Trust](/serveex/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](../../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`.

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

@@ -0,0 +1,251 @@
+---
+navigation: true
+title: Wireguard
+main:
+  fluid: false
+---
+# 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 permettre de pouvoir se connecter à son réseau où que l'on soit, de maniere sécuriser, 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 etre 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" icon="exclamation-circle"}
+:::list{type="info"}
+- A vérifier au préalable"
+:::
+- Vérifiez si le port `51820 UDP` est libre 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="danger"}
+:::list{type="danger"}
+- En cas d'échec, vérifiez les règles du pare-feu.
+:::
+::
+
+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
+version: "3.8"
+volumes:
+  etc_wireguard:
+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
+    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"}
+:::list{type="success"}
+- __Astuce :__ 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}    | Domaine de l'host                                                                                                                                                                                                                                                                                                                                                                                                                         | `mondomaine.fr` |
+| `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`
+
+## Sur le serveur client
+---
+::alert{type="info" icon="exclamation-circle"}
+:::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"}
+:::list{type="success"}
+- __Astuce pour les allergiques au terminal :__
+vous pouvez utiliser [File Browser](/serveex/filebrowser) 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"}
+:::list{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)