Djeex/docudjeex
Djeex/docudjeex
1
1
Fork 0
Code Issues Pull Requests Projects Wiki Activity

First commit -clean

Browse Source
This commit is contained in:
Djeex 2025-06-04 14:19:33 +00:00
commit 3e6bb5aa92
124 changed files with 23489 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
.eslintrc.cjs Normal file
View File

@ -0,0 +1,14 @@
module.exports = {
root: true,
extends: ['@nuxt/eslint-config'],
ignorePatterns: [
'dist',
'node_modules',
'.output',
'.nuxt'
],
rules: {
'vue/max-attributes-per-line': 'off',
'vue/multi-word-component-names': 'off'
}
}

12
.gitignore vendored Executable file
View File

@ -0,0 +1,12 @@
node_modules
*.iml
.idea
*.log*
.nuxt
.vscode
.DS_Store
coverage
dist
sw.*
.env
.output

1
.npmrc Normal file
View File

@ -0,0 +1 @@
strict-peer-dependencies=false

43
README.md Executable file
View File

@ -0,0 +1,43 @@
<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/) [![](https://dcbadge.limes.pink/api/server/jvhardware)](https://discord.gg/jvhardware) [![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
**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/)
Ce repo contient de quoi modifier les pages, ajouter vos changements, et redéployer le site.
## Setup
Installer les dépendances
```bash
npm install
```
## Environnement de dévelopment (port 3000)
```bash
npm run dev
```
## Génération des pages statiques
```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.
## 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 :
```bash
npm run preview
```

76
app.config.ts Normal file
View File

@ -0,0 +1,76 @@
// https://github.com/nuxt-themes/docus/blob/main/nuxt.schema.ts
export default defineAppConfig({
css: ['~/assets/css/extra.css'],
colorMode: {
preference: 'dark',
fallback:'dark',
},
content: {
highlight: {
langs: [
'console',
'nginx',
]
}
},
mdc: {
highlight: {
theme: 'github-dark',
langs: ['ts','console','nginx'],
wrapperStyle: true
}
},
docus: {
title: 'Docudjeex',
description: 'La doc de mes expériences',
url: 'http://docus.dev',
image: '/img/social.png',
socials: {
github:'',
Gitea: {
label: 'Gitea',
icon: 'cib:gitea',
href: 'https://git.djeex.fr/Djeex/docudjeex',
},
Discord: {
label: 'Discord',
icon: 'cbi:discord',
href: 'https://discord.gg/jvhardware',
},
},
github: {
baseUrl:'https://git.djeex.fr',
dir: 'content',
branch: 'src/branch/master',
repo: 'docudjeex',
owner: 'Djeex',
edit: false
},
aside: {
level: 0,
collapsed: false,
exclude: []
},
main: {
padded: true,
fluid: true
},
header: {
logo: true,
showLinkIcon: true,
exclude: [],
fluid: false
},
footer: {
credits: {
icon: '',
text: '',
href: '',
}
}
},
})

59
assets/css/extra.css Normal file
View File

@ -0,0 +1,59 @@
@media (min-width: 1024px) {
.card-grid .layout {
grid-template-columns: repeat(2, minmax(0, 1fr)) !important;
}
}
.alert .shiki {
--shiki-dark: #00000000 !important;
--shiki-default: #00000000 !important;
--shiki-dark-bg: #00000000 !important;
--shiki-default-bg: #00000000 !important;
}
.dark .shiki {
background-color: #00000000 !important;
}
*html .dark .shiki span, html.dark .shiki span {
background-color: var(--prose-code-block-backgroundColor) !important;
}
/*html .dark .shiki span, html.dark .shiki span {
background-color: #00000000 !important;
}*/
.alert.success .prose-code, .alert.success .shiki span {
background-color: var(--elements-state-success-backgroundColor-secondary) !important;
border-color: #00361f !important;
}
.alert.info .prose-code, .alert.info .shiki span {
background-color: var(--elements-state-info-backgroundColor-secondary) !important;
border-color: #00304a !important;
}
.alert.warning .prose-code, .alert.warning .shiki span {
background-color: var(--elements-state-warning-backgroundColor-secondary) !important;
border-color: #382d00 !important;
}
.alert.danger .prose-code, .alert.danger .shiki span {
background-color: var(--elements-danger-info-backgroundColor-secondary) !important;
border-color: #00304a !important;
}
.section.right > :nth-child(2) {
display:none;
}
.container {
max-width: var(--elements-container-maxWidth);
}
p img {
border-radius:7px;
}
@media (min-width: 1024px) {
.card-grid {
padding-bottom: 80px !important;
}
}

21
assets/djeex/logo-short.svg Normal file
View File

@ -0,0 +1,21 @@
<?xml version="1.0" encoding="UTF-8"?>
<svg id="Calque_1" data-name="Calque 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 561.54">
<defs>
<style>
.cls-1 {
fill: #55c3ec;
}
.cls-1, .cls-2 {
stroke-width: 0px;
}
.cls-2 {
fill: #fff;
}
</style>
</defs>
<path class="cls-2" d="M167.5,561.54c-34.5,0-64.27-8.56-89.31-25.68-25.05-17.12-44.34-41.65-57.88-73.59C6.77,430.32,0,392.12,0,347.66v-.38c0-44.71,6.77-82.98,20.32-114.8,13.54-31.81,32.83-56.21,57.88-73.21,25.04-16.99,54.68-25.49,88.93-25.49,19.67,0,37.69,3.2,54.05,9.58,16.35,6.39,30.72,15.52,43.12,27.41,12.39,11.88,22.29,26.13,29.71,42.74h2.3V0h111.92v553.11h-111.92v-70.15h-2.3c-7.41,16.36-17.25,30.41-29.51,42.16-12.27,11.76-26.58,20.76-42.93,27.02-16.36,6.26-34.37,9.39-54.05,9.39ZM205.07,468.78c18.14,0,34.11-4.92,47.91-14.76,13.8-9.83,24.47-23.82,32.01-41.97,7.53-18.14,11.31-39.61,11.31-64.39v-.38c0-24.53-3.83-45.86-11.5-64.01-7.67-18.14-18.34-32.13-32.01-41.97-13.67-9.83-29.58-14.76-47.72-14.76s-34.76,4.86-48.3,14.57c-13.55,9.71-24.02,23.57-31.43,41.59-7.41,18.02-11.12,39.55-11.12,64.59v.38c0,24.79,3.64,46.25,10.92,64.39,7.28,18.15,17.76,32.14,31.43,41.97,13.67,9.84,29.83,14.76,48.49,14.76Z"/>
<path class="cls-1" d="M520.82,390.59c-17.38,0-32.14-6-44.27-18.01-12.14-12.01-18.21-26.83-18.21-44.46s6.07-32.07,18.21-44.08c12.13-12.01,26.89-18.02,44.27-18.02s32.07,6.01,44.08,18.02c12.01,12.01,18.02,26.71,18.02,44.08s-6.01,32.45-18.02,44.46c-12.01,12.01-26.71,18.01-44.08,18.01Z"/>
<path class="cls-2" d="M783.28,561.54c-34.5,0-64.27-8.56-89.31-25.68-25.05-17.12-44.34-41.65-57.88-73.59-13.55-31.94-20.32-70.14-20.32-114.61v-.38c0-44.71,6.77-82.98,20.32-114.8,13.54-31.81,32.83-56.21,57.88-73.21,25.04-16.99,54.68-25.49,88.93-25.49,19.67,0,37.69,3.2,54.05,9.58,16.35,6.39,30.72,15.52,43.12,27.41,12.39,11.88,22.29,26.13,29.71,42.74h2.3V0h111.92v553.11h-111.92v-70.15h-2.3c-7.41,16.36-17.25,30.41-29.51,42.16-12.27,11.76-26.58,20.76-42.93,27.02-16.36,6.26-34.37,9.39-54.05,9.39ZM820.85,468.78c18.14,0,34.11-4.92,47.91-14.76,13.8-9.83,24.47-23.82,32.01-41.97,7.54-18.14,11.31-39.61,11.31-64.39v-.38c0-24.53-3.83-45.86-11.5-64.01-7.67-18.14-18.34-32.13-32.01-41.97-13.67-9.83-29.58-14.76-47.72-14.76s-34.76,4.86-48.3,14.57c-13.55,9.71-24.02,23.57-31.43,41.59-7.41,18.02-11.12,39.55-11.12,64.59v.38c0,24.79,3.64,46.25,10.92,64.39,7.28,18.15,17.76,32.14,31.43,41.97,13.67,9.84,29.83,14.76,48.49,14.76Z"/>
</svg>
Side by Side

After

Width:  |  Height:  |  Size: 2.4 KiB

3
components/Logo.vue Normal file
View File

@ -0,0 +1,3 @@
<template>
<img width="120" src="/img/logo.svg"/>
</template>

51
content/0.index.md Normal file
View File

@ -0,0 +1,51 @@
---
title: Accueil
navigation: false
layout: page
main:
fluid: false
---
:ellipsis{right=0px width=75% blur=150px}
::block-hero
---
cta:
- Accéder à la doc
- /apropos/bienvenue
secondary:
- Discord →
- https://discord.gg/jvhardware
---
#title
Bienvenue sur docu[·]{style="color: #1ad6ff"}djeex
#description
De la doc, encore de la doc. Des astuces et des expériences. Vous y trouverez entre autre :
#extra
::list
- **Installation de Debian** pour votre serveur
- **Docker** pour déployer vos services
- **VPN** pour accéder à votre réseau privé
- **Reverse proxy** et **Zero Trust** pour exposer vos services
- **SSO** et **Multi-facteur** pour protéger vos services exposés
- **Cloud** et **media** pour accéder et synchroniser vos fichiers et media
- _(à venir)_ **Créer votre NAS** de A à Z pour stocker vos données
- _(à venir)_ **Backup 3-2-1**
::
#support
::terminal
---
content:
- ssh user@serveex -p 22
- cd /docker
- sudo docker compose up -d
- sudo rm -rf * /
- Sud.. shit shiiit shiiiiit !!!
---
::
::

40
content/1.apropos/1.bienvenue.md Normal file
View File

@ -0,0 +1,40 @@
---
title: A propos
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 principale __Nipah__ et __Xenio__ (et d'autres) pour leur patience et écoute. La majeur partie de ce contenu vient de leurs têtes. Rejoins nous sur [Discord](https://discord.gg/jvhardware) !
## 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
::
::

3
content/1.apropos/_dir.yml Normal file
View File

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

66
content/2.generalites/1.nat.md Normal file
View File

@ -0,0 +1,66 @@
---
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.

67
content/2.generalites/2.dns.md Normal file
View File

@ -0,0 +1,67 @@
---
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/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.

228
content/2.generalites/3.samba.md Normal file
View File

@ -0,0 +1,228 @@
---
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
```

3
content/2.generalites/_dir.yml Normal file
View File

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

277
content/3.serveex/1.introduction.md Normal file
View File

@ -0,0 +1,277 @@
---
navigation: true
title: Introduction
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
## Un home lab par un débutant pour les débutants
<p align="center">
<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.
Un grand merci à **Nipah**, pour le partage de ses connaissances infinies, et surtout pour sa patience.
::alert{type="info"}
**Pré-requis :**
:::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/nat)
- Savoir configurer la [zone DNS d'un nom de domaine](/generalites/dns)
:::
::
L'objectif etant d'etre facilement déployable et facile à migrer, voici sa structure :
::card-grid{grid-template-columns="repeat(2, minmax(0, 1fr));"}
#title
Le coeur du serveur
#root
:ellipsis{left=0px width=40rem top=10rem blur=140px}
#default
::card{icon=logos:debian}
#title
__Système d'exploitation__
#description
[Installer et configurer Debian 12](/serveex/coeur/installation)
::
::card{icon=logos:docker-icon}
#title
__Moteur de conteneur__
#description
[Installer Docker](/serveex/coeur/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)
::
::card{icon=noto:globe-showing-americas}
#title
__Reverse Proxy__
#description
[Exposez vos services avec SWAG](/serveex/coeur/swag)
::
::
::card-grid
#title
La sécurité
#root
:ellipsis{left=0px width=40rem top=10rem blur=140px}
#default
::card{icon=simple-icons:wireguard style="color: #88171a;"}
#title
__VPN__
#description
[Installer et déployer Wireguard](/serveex/securite/wireguard)
::
::card{icon=noto:key}
#title
__SSO & MFA__
#description
[Installer et déployer Authentik](/serveex/securite/authentik)
::
::card{icon=logos:cloudflare-icon}
#title
__Zero Trust__
#description
[Installer et déployer Cloudflared](/serveex/securite/cloudflare)
::
::
::card-grid
#title
Monitoring
#root
:ellipsis{left=0px width=40rem top=10rem blur=140px}
#default
::card{icon=solar:pulse-linear style="color: rgb(99, 222, 144);"}
#title
__Etat des services__
#description
[Installer et déployer Uptime-Kuma](/serveex/monitoring/uptime-kuma)
::
::card{icon=lucide:logs style="color: #1AD6FF;"}
#title
__Gestion des logs__
#description
[Installer et déployer Dozzle](/serveex/monitoring/dozzle)
::
::card{icon=noto:rabbit style="color: #1AD6FF;"}
#title
__Gestion de la connexion__
#description
[Installer et déployer Speedtest Tracker](/serveex/monitoring/speedtest-tracker)
::
::card{icon=lucide:chart-column-decreasing style="color:rgb(26, 255, 213);"}
#title
__Etat des ressources__
#description
[Installer et déployer 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)
::
::
::card-grid
#title
Media
#root
:ellipsis{left=0px width=40rem top=10rem blur=140px}
#default
::card{icon=cbi:plex-alt style="color: rgb(229, 160, 13);"}
#title
__Media__
#description
[Installer et déployer Plex](/serveex/media/plex)
::
::card{icon=cbi:qbittorrent style="color: rgb(#2f67ba);"}
#title
__Seedbox__
#description
[Installer et déployer Qbittorrent](/serveex/media/qbittorrent)
::
::
::card-grid
#title
Cloud Drive & Photos
#root
:ellipsis{left=0px width=40rem top=10rem blur=140px}
#default
::card{icon=cib:nextcloud style="color: rgb(0, 104, 161);"}
#title
__Drive__
#description
[Installer et déployer Nextcloud](/serveex/cloud/nextcloud)
::
::card{icon=simple-icons:immich style="color: #ed79b5;"}
#title
__Photos__
#description
[Installer et déployer Immich](/serveex/cloud/immich)
::
::
::card-grid
#title
Fichiers & partage
#root
:ellipsis{left=0px width=40rem top=10rem blur=140px}
#default
::card{icon=noto:open-file-folder }
#title
__Explorateur de fichier__
#description
[Installer et déployer file-browser](/serveex/files/file-browser)
::
::card{icon=carbon:share style="color: #47428e;" }
#title
__Partage__
#description
[Installer et déployer Pingvin](/serveex/files/pingvin)
::
::
::card-grid
#title
Outils de développement
#root
:ellipsis{left=0px width=40rem top=10rem blur=140px}
#default
::card{icon=logos:visual-studio-code}
#title
__Visual Studio Code__
#description
[Installer et déployer 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)
::
::card{icon=noto:hammer-and-wrench }
#title
__Outils__
#description
[Installer et déployer IT Tools](/serveex/development/it-tools)
::
::
::card-grid
#title
Applications utiles
#root
:ellipsis{left=0px width=40rem top=10rem blur=140px}
#default
::card{icon=cbi:adguard style="color: #67b279;"}
#title
__DNS anti-pub et filtres__
#description
[Installer et déployer Adguard Home](/serveex/apps/adguard)
::
::card{icon=cbi:bitwarden style="color: rgb(25 128 255);"}
#title
__Gestionnaire de mots de passe__
#description
[Installer et déployer Vaultwarden](/serveex/apps/vaultwarden)
::
::
## A venir
---
- Homepage, pour avoir tout vos services en un coup d'oeil et y accéder facilement
- Mkdocs pour votre documentation
- Docus, alternative à Mkdocs
- Speedtest-tracker pour vérifier la connexion de votre serveur
- UpSnap pour réveiller vos machines à distance

76
content/3.serveex/2.coeur/1.installation.md Normal file
View File

@ -0,0 +1,76 @@
---
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/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
:::
::

176
content/3.serveex/2.coeur/2.docker.md Normal file
View File

@ -0,0 +1,176 @@
---
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 !

398
content/3.serveex/2.coeur/3.swag.md Normal file
View File

@ -0,0 +1,398 @@
---
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 ce [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/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/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`.

1
content/3.serveex/2.coeur/_dir.yml Normal file
View File

@ -0,0 +1 @@
navigation.title: Le coeur du serveur

252
content/3.serveex/3.securite/1.wireguard.md Normal file
View File

@ -0,0 +1,252 @@
---
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
---
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: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 :__ 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`
::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)

588
content/3.serveex/3.securite/2.authentik.md Normal file
View File

@ -0,0 +1,588 @@
---
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:-2024.2.3}`{lang=properties} par [la dernière version de Authentik](https://version-2024-6.goauthentik.io/docs/releases).
```yaml
---
services:
postgresql:
image: docker.io/library/postgres:12-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:-2024.2.3}
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
- ./auth.css:/web/dist/custom.css
- ./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:-2024.2.3}
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
- ./auth.css:/web/dist/custom.css
- ./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/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/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
```

268
content/3.serveex/3.securite/3.cloudflare.md Normal file
View File

@ -0,0 +1,268 @@
---
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/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/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/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` |

1
content/3.serveex/3.securite/_dir.yml Normal file
View File

@ -0,0 +1 @@
navigation.title: La sécurité

198
content/3.serveex/4.monitoring/1.uptime-kuma.md Normal file
View File

@ -0,0 +1,198 @@
---
navigation: true
title: Uptime-Kuma
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Uptime-Kuma
::alert{type="info"}
🎯 __Objectifs :__
- Installer et déployer Uptime-Kuma
- Exposer Uptime Kuma
- (Optionnel) Protéger Uptime-Kuma avec 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.
![picture](https://user-images.githubusercontent.com/1336778/212262296-e6205815-ad62-488c-83ec-a5b0d0689f7c.jpg)
## Installation
---
Structure des dossiers
```console
root
└── docker
└── uptime-kuma
├── date
└── compose.yaml
```
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `uptime-kuma` puis copiez collez ceci :
```yaml
---
services:
uptime-kuma:
image: louislam/uptime-kuma:1
container_name: uptime-kuma
volumes:
- /docker/uptime-kuma/uptime-kuma-data:/app/data
ports:
- 3200:3001 # <Host Port>:<Container Port>
restart: always
```
::alert{type="success"}
✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
uptime-kuma:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Vous n'avez plus qu'à accéder à l'outil via `http://ipdevotreserveur:3200`.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer avec Swag
---
::alert{type="info"}
📋 __Au préalable :__
<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/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/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).
:::
::
Dans les dossiers de Swag, créez le fichier `stats.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.
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name stats.*;
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; }
# 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 uptime-kuma;
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`.
Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau d'Uptime-Kuma :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- uptime-kuma # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
Relancez la stack et patientez le temps que SWAG soit complètement opérationnel.
::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`.
:::
::
Et voilà, vous avez exposé Uptime-Kuma, vous pouvez y accéder en tapant `https://stats.mondomaine.fr`
::alert{type="success"}
✨ __Astuce :__
<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:
- Editez le fournisseur d'Uptime-Kuma
- Dans *paramètres avancés du protocole > chemins authentifiés*, saisissez :
```properties
^/$
^/status
^/assets/
^/assets
^/icon.svg
^/api/.*
^/upload/.*
^/metrics
::
Déployez à nouveau la stack.
Uptime-Kuma sera ainsi joignable directement depuis internet en tapant `https://stats.mondomaine.fr`.
::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.
::

182
content/3.serveex/4.monitoring/2.dozzle.md Normal file
View File

@ -0,0 +1,182 @@
---
navigation: true
title: Dozzle
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Dozzle
::alert{type="info"}
🎯 __Objectifs :__
- Installer Dozzle
- Exposer Dozzle avec 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://blog.unixhost.pro/wp-content/uploads/2023/03/image-5.png)
## Installation
---
Structure des dossiers
```console
root
└── docker
└── dozzle
└── data
```
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `dozzle` puis copiez collez ceci :
```yaml
---
services:
dozzle:
container_name: dozzle
image: amir20/dozzle:latest
ports:
- 9135:8080
env_file:
- .env
environment:
- DOZZLE_AUTH_PROVIDER=simple
- DOZZLE_HOSTNAME=${DOMAIN}
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- /docker/dozzle/data:/data
```
::alert{type="success"}
✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
dozzle:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Renseignez le `.env` votre nom de domaine, par exemple
```properties
DOMAIN=dozzle.mondomaine.fr
```
Déployez le conteneur et rendez-vous sur `http://ipduserveur:9135`. Et voilà, votre instance Dozzle en webui est disponible !
## Exposer Dozzle avec 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).
:::
::
Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer Dozzle via Swag.
::alert{type="info"}
📋 __Au préalable :__
<br/><br/>
Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat).
::
Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Dozzle :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- dozzle # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
::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`.
:::
::
Dans les dossiers de Swag, créez le fichier `dozzle.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.
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name dozzle.*;
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; }
# 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 dozzle;
set $upstream_port 8080;
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`.
Et voilà, vous avez exposé Dozzle !
::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).
::

206
content/3.serveex/4.monitoring/3.speedtest-tracker.md Normal file
View File

@ -0,0 +1,206 @@
---
navigation: true
title: Speedtest Tracker
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Speedtest Tracker
::alert{type="info"}
🎯 __Objectifs :__
- Installer Speedtest Tracker
- Exposer Speedtest Tracker avec 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](/img/serveex/speedtest-tracker.avif)
## Installation
---
::alert{type="info"}
:::list{type="info"}
- Nous utiliserons l'image docker maintenue par [LinuxServer.io](https://docs.linuxserver.io/images/docker-speedtest-tracker/)
:::
::
Structure des fichiers
```console
root
└── docker
└── speedtest-tracker
└── data
└── config
```
Dans un terminal, générez une clé avec la commande suivante :
```shell
echo -n 'base64:'; openssl rand -base64 32;
```
Notez la clé.
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `speedtest-tracker` puis copiez collez ceci :
```yaml
---
services:
speedtest-tracker:
image: lscr.io/linuxserver/speedtest-tracker:latest
restart: unless-stopped
container_name: speedtest-tracker
ports:
- ${PORT}$:80
environment:
- PUID=${PUID}
- PGID=${GUID}
- TZ=Europe/Paris
- APP_KEY=${API_KEY}
- DB_CONNECTION=sqlite
- SPEEDTEST_SCHEDULE=${SCHEDULE}
volumes:
- /docker/speedtest-tracker/data/config:/config
```
Trouvez votre `PUID` et votre `GUID` en tapant la commande suivante :
```shell
id nomdutilisateur
```
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 :
```properties
SCHEDULE=15 */6 * * * # toutes les 6h
KEY=base64:zihejehkj8_nzhY/OjeieR= # votre clé
PUID=1000
GUID=1000
PORT=3225 # port d'accès à la webui
```
::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).
::
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é !
## Exposer Speedtest Tracker
---
::alert{type="info"}
📋 __Prérequis :__ <br/></br>
Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/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`.
::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).
:::
::
Ouvrez le fichier speedtest.subdomain.conf :
```shell
sudo vi /docker/swag/config/nginx/proxy-confs/speedtest.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 speedtest.*;
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 speedtest-tracker; # Nom du conteneur
set $upstream_port 3225; # 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 "speedtest-tracker". Pour qu'il puisse y accéder, vous devez rajouter le réseau de Speedtest Tracker dans le `compose.yml` de SWAG.
:::
::
Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Speedtest Tracker :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- speedtest-tracker # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
::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`.
:::
::
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).
::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).
::

255
content/3.serveex/4.monitoring/4.beszel.md Normal file
View File

@ -0,0 +1,255 @@
---
navigation: true
title: Beszel
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Beszel
::alert{type="info"}
🎯 __Objectifs :__
- Installer Beszel
- Monitorer le serveur local
- Monitorer un serveur distant
- Exposer Beszel avec 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 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](/img/serveex/beszel.png)
## Installation
---
Structure des dossiers
```console
root
└── docker
└── beszel
├── data
└── socket
```
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `beszel` puis copiez collez ceci :
```yaml
---
services:
beszel:
image: henrygd/beszel:latest
container_name: beszel
restart: unless-stopped
ports:
- ${PORT}$:8090
volumes:
- ./data:/beszel_data
- ./socket:/beszel_socket
beszel-agent:
image: henrygd/beszel-agent:latest
container_name: beszel-agent
restart: unless-stopped
network_mode: host
volumes:
- ./socket:/beszel_socket
- /var/run/docker.sock:/var/run/docker.sock:ro
environment:
LISTEN: /beszel_socket/beszel.sock
# Do not remove quotes around the key
KEY: ${KEY}
```
::alert{type="success"}
✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
beszel:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Renseignez le `.env`, par exemple :
```properties
PORT=8090 # port de la webui
KEY= # clé privée à récupérer dans Beszel lors que vous ajoutez un système
```
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 !
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
### Ajouter les informations du serveur local
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 :
![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 :
![Beszel add system](/img/serveex/beszel-system.png)
### Ajouter les informations d'un serveur distant
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 :
- 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 :
```yaml
---
services:
beszel-agent:
image: henrygd/beszel-agent
container_name: beszel-agent
restart: unless-stopped
network_mode: host
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
environment:
LISTEN: ${PORT}
KEY: ${KEY}
```
Et dans le `.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
```
Déployez la stack sur votre serveur distant. Les informations du serveur distant remontront au bout de quelques secondes dans votre webui.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer Beszel avec 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).
:::
::
Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer Beszel via Swag.
::alert{type="info"}
📋 __Au préalable :__
<br/><br/>
Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat).
::
Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Beszel :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- beszel # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
::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`.
:::
::
Dans les dossiers de Swag, créez le fichier `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.
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name beszel.*;
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; }
# 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 beszel;
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`.
Et voilà, vous avez exposé Beszel !
::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).
::

194
content/3.serveex/4.monitoring/5.upsnap.md Normal file
View File

@ -0,0 +1,194 @@
---
navigation: true
title: UpSnap
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# UpSnap
::alert{type="info"}
🎯 __Objectifs :__
- Installer UpSnap
- Exposer UpSnap avec 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.
![Beszel](/img/serveex/upsnap.webp)
## Installation
---
Structure des dossiers
```console
root
└── docker
└── upsnap
└── data
```
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `upsnap` puis copiez collez ceci :
```yaml
---
services:
upsnap:
container_name: upsnap
image: ghcr.io/seriousm4x/upsnap:5
network_mode: host
restart: unless-stopped
volumes:
- /docker/upsnap/data:/app/pb_data
environment:
- TZ=Europe/Paris
- UPSNAP_SCAN_RANGE=${SCAN_RANGE}
- UPSNAP_SCAN_TIMEOUT=500ms
- UPSNAP_PING_PRIVILEGED=true
dns:
- ${DNS}
entrypoint: /bin/sh -c "./upsnap serve --http 0.0.0.0:8095"
healthcheck:
test: curl -fs "http://localhost:8095/api/health" || exit 1
interval: 10s
```
::alert{type="success"}
✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
upsnap:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Renseignez le `.env`, par exemple :
```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
```
Déployez le conteneur et rendez-vous sur `http://ipduserveur:8095`. Vous n'avez plus qu'à suivre les instructions pour créer votre compte !
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer UpSnap avec 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).
:::
::
Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer UpSnap via Swag.
::alert{type="info"}
📋 __Au préalable :__
<br/><br/>
Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat).
::
Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de UpSnap :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- upsnap # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
::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`.
:::
::
Dans les dossiers de Swag, créez le fichier `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.
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name upsnap.*;
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; }
# 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 upsnap;
set $upstream_port 8095;
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`.
Et voilà, vous avez exposé 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).
::

1
content/3.serveex/4.monitoring/_dir.yml Normal file
View File

@ -0,0 +1 @@
navigation.title: Monitoring

310
content/3.serveex/5.media/1.plex.md Normal file
View File

@ -0,0 +1,310 @@
---
navigation: true
title: Plex
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Plex
::alert{type="info"}
🎯 __Objectifs :__
- Installer Plex
- Installer Tautulli
- Accéder aux media depuis l'exterieur
::
[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.
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.
![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.
- [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/)
::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.
:::
::
## Installer Plex
---
Structure des dossiers :
```console
root
├── docker
│ ├── plex
│ │ ├── compose.yml
│ │ ├── .env
│ │ ├── config
│ │ └── transcode
│ └── tautulli
│ └── config
└── media
├── tvseries
├── movies
└── library
```
Créez les dossiers `movies`, `tvseries` et `library` dans /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 :
```yaml
---
services:
linuxserver_plex:
image: ghcr.io/linuxserver/plex:amd64-latest
container_name: plex
network_mode: host
environment:
- PUID=${PUID}
- PGID=${GUID}
- TZ=Europe/Paris
- VERSION=docker
volumes:
- /docker/plex/config:/config
- /docker/plex/transcode:/transcode
- /media:/media
restart: unless-stopped
mem_limit: 4096m
mem_reservation: 2048m
devices:
- /dev/dri:/dev/dri
tautulli:
image: lscr.io/linuxserver/tautulli:latest
container_name: tautulli
environment:
- PUID=${PUID}
- PGID=${GUID}
- TZ=Europe/Paris
volumes:
- /docker/tautulli/config:/config
ports:
- 8181:8181
restart: unless-stopped
```
::alert{type="success"}
✨ Ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
plex:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
tautulli:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Trouvez votre PUID et votre GUID en tapant la commande suivante :
```shell
id nomdutilisateur
```
Et renseignez le `.env` avec les infos que vous avez trouvées, par exemple :
```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`.
::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).
:::
::
## Paramétrer 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_.
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.
![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/nat).
- Une fois fait, retournez dans Plex afin de vérifier que la connexion est bien opérationnelle
::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.
:::
::
- 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.
Et voilà, vous avez un Plex fonctionnel !
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 !
::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/samba) afin que Plex puisse y accéder.
:::
::
## Exposer Tautulli avec Swag
---
Plex n'a pas besoin d'etre exposé, étant joignable directement depuis votre compte Plex sur plex.tv.
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/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/nat).
:::
::
Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Tautulli :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- tautulli # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
::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`.
:::
::
Copiez en renommant le fichier `tautulli.subdomain.conf.sample` en `tautulli.subdomain.conf` et éditez le :
::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 cp /docker/swag/config/nginx/proxy-confs/tautulli.subdomain.conf.sample /docker/swag/config/nginx/proxy-confs/tautulli.subdomain.conf
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`:
```nginx
## Version 2023/05/31
# make sure that your tautulli container is named tautulli
# make sure that your dns has a cname set for tautulli
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name tautulli.*;
include /config/nginx/ssl.conf;
client_max_body_size 0;
# 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 tautulli;
set $upstream_port 8181;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ (/tautulli)?/api {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app tautulli;
set $upstream_port 8181;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ (/tautulli)?/newsletter {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app tautulli;
set $upstream_port 8181;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ (/tautulli)?/image {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app tautulli;
set $upstream_port 8181;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
}
```
::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).
::
Appuyez sur `Echap` puis sauvegardez et quittez en tappant `:x`
Patientez quelques minutes puis tapez dans votre navigateur `http://tautulli.mondomaine.fr`.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
Et voilà !

324
content/3.serveex/5.media/2.qbittorrent.md Normal file
View File

@ -0,0 +1,324 @@
---
navigation: true
title: Qbittorrent
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Qbittorrent
::alert{type="info"}
🎯 __Objectifs :__
- Installer et configurer Qbittorrent
- Etre relié au réseau bittorent en toute sécurité avec Gluetun et Proton VPN
::
![Picture](https://github.com/VueTorrent/VueTorrent/blob/master/public/screenshots/screenshot-desktop-dark-mode.jpeg?raw=true)
Afin de téléchargez vos media favoris en toute sécurité, nous allons monter un système à base de :
- [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.
- [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.
Nous monterons ici le système ci-dessous :
![Picture](/img/serveex/qbit.svg)
## Configuration
---
Structure des dossiers
```console
root
├── docker
│ └── seedbox
│ ├── qbittorrent
│ │ └── config
│ ├── gluetun
│ ├── 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
```
Si ce n'est pas déjà fait, créez le dossier `downloads` dans `/media` :
```sh
mkdir -P /media/downloads
```
Ouvrez Dockge, cliquez sur `compose` et nommez la stack `seedbox`. Collez la config ci-dessous :
```yaml
---
services:
qbit:
image: ghcr.io/linuxserver/qbittorrent:latest
container_name: qbittorrent
restart: unless-stopped
network_mode: service:gluetun
mem_limit: 1g
environment:
- DOCKER_MODS=ghcr.io/gabe565/linuxserver-mod-vuetorrent|ghcr.io/t-anc/gsp-qbittorent-gluetun-sync-port-mod:main
- TZ=Europe/Paris
- PUID=${PUID}
- PGID=${GUID}
- WEBUI_PORT=${UI_PORT}
- GSP_GTN_API_KEY=${GSP_KEY}
- GSP_QBT_USERNAME=${ID}
- GSP_QBT_PASSWORD=${PW}
volumes:
- /docker/seedbox/qbittorrent/config:/config
- /media:/media
depends_on:
- gluetun
gluetun:
image: qmcgaw/gluetun:v3.40
container_name: gluetun
restart: unless-stopped
mem_limit: 1g
volumes:
- /docker/gluetun/config.toml:/gluetun/auth/config.toml:ro
devices:
- /dev/net/tun:/dev/net/tun
ports:
- ${UI_PORT}:5695 # Port de la web-ui
- 8000:8000 # Port de controle de Gluetun
cap_add:
- NET_ADMIN
environment:
- TZ=Europe/Paris
- VPN_SERVICE_PROVIDER=protonvpn
- VPN_PORT_FORWARDING=on
- VPN_PORT_FORWARDING_PROVIDER=protonvpn
- VPN_TYPE=wireguard
- 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
```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.
Pour ce faire, nous avons ajouté le mod `ghcr.io/t-anc/gsp-qbittorent-gluetun-sync-port-mod` dans le conteneur.
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.
A cet effet, ouvrez un terminal. Nous allons à présent générer une clé d'authentification :
```shell
sudo docker run --rm qmcgaw/gluetun genkey
```
Notez la clé. Puis créez le dossier `/docker/gluetun`
```shell
sudo mkdir /docker/gluetun
```
Et créez le fichier `config.toml`
```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 :
```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
```
Appuyez sur `échap` et quittez en sauvegardant en tapant `:x`. Rendez-vous dans Dockge, et renseignez les variables dans `.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
ID=
PW=
```
En détails :
| 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` |
## Déploiement
---
Une fois fait, déployez le conteneur.
::alert{type="warning"}
:::list{type="warning"}
- **Dans les logs de lancement, vous trouverez un mot de passe temporaire pour l'utilisateur `admin`**
:::
::
Loggez vous sur `http://ipduserveur:5695` (ou le port que vous avez configuré).
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
Changez votre nom d'utilisateur et votre mot de passe dans les paramètres "webui".
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.
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é.
## Exposer la webui
---
::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).
:::
::
Afin de lancer des téléchargement hors de chez vous, sans VPN, vous pouvez exposer la webui de Qbittorrent.
::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/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/nat).
:::
::
Rendez-vous dans dockge, et éditez le compose de SWAG en ajoutant le réseau de Gluetun :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- seedbox # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
::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.
:::
::
Puis nous allons créer et éditer le fichier `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.
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name seedbox.*;
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; }
# 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 gluetun;
set $upstream_port 5555;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
}
```
::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).
::
Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x`.
Patientez quelques minutes puis tapez dans votre navigateur `https://seedbox.mondomaine.fr`, vous arriverez sur l'interface de Qbittorrent.
Et voilà, vous avez un mediacenter pret à l'emploi !
![Picture](/img/serveex/seed.svg)

503
content/3.serveex/5.media/3.servarr.md Normal file
View File

@ -0,0 +1,503 @@
---
navigation: true
title: Automatisation
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Servarr
::alert{type="info"}
🎯 __Objectifs :__
- Automatiser les téléchargements de films et de séries avec Radarr, Sonarr, Bazarr, Prowlarr et 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
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.
## Installer les apps
---
### Docker compose
Structure des dossiers :
```console
root
├── docker
│ ├── plex
│ │ ├── compose.yml
│ │ ├── config
│ │ └── transcode
│ ├── tautulli
│ │ └── config
│ ├── sonarr
│ │ └── config
│ ├── radarr
│ │ └── config
│ ├── bazarr
│ │ └── config
│ ├── prowlarr
│ │ └── config
│ └── overseerr
│ └── config
└── media
├── tvseries
├── movies
└── library
```
Ouvrez dockge et votre stack `plex`. Modifiez le compose comme ceci :
```yaml
---
services:
linuxserver_plex:
image: ghcr.io/linuxserver/plex:latest
container_name: plex
network_mode: host
environment:
- PUID=${PUID}
- PGID=${PGID}
- TZ=Europe/Paris
- VERSION=docker
- PLEX_CLAIM= #optional
volumes:
- /docker/plex/config:/config
- /docker/plex/transcode:/transcode #optional
- ${MEDIA_PATH}:/media
labels:
- com.centurylinklabs.watchtower.enable=true
restart: unless-stopped
mem_limit: 4096m
mem_reservation: 2048m
devices:
- /dev/dri:/dev/dri
tautulli:
image: lscr.io/linuxserver/tautulli:latest
container_name: tautulli
environment:
- TZ=Europe/Paris
volumes:
- /docker/tautulli/config:/config
ports:
- 8181:8181
restart: unless-stopped
sonarr:
image: lscr.io/linuxserver/sonarr:latest
container_name: sonarr
environment:
- PUID=${PUID}
- PGID=${PGID}
- TZ=Europe/Paris
volumes:
- /docker/sonarr/config:/config
- ${MEDIA_PATH}:/media
ports:
- 8989:8989
restart: unless-stopped
radarr:
image: lscr.io/linuxserver/radarr:latest
container_name: radarr
environment:
- PUID=${PUID}
- PGID=${PGID}
- TZ=Europe/Paris
volumes:
- /docker/radarr/config:/config
- ${MEDIA_PATH}:/media
ports:
- 7878:7878
restart: unless-stopped
prowlarr:
image: lscr.io/linuxserver/prowlarr:latest
container_name: prowlarr
environment:
- PUID=${PUID}
- PGID=${PGID}
- TZ=Europe/Paris
volumes:
- /docker/prowlarr/data:/config
ports:
- 9696:9696
restart: unless-stopped
overseerr:
image: lscr.io/linuxserver/overseerr:latest
container_name: overseerr
dns:
- 1.1.1.1
- 8.8.8.8
environment:
- PUID=${PUID}
- PGID=${PGID}
- TZ=Europe/Paris
volumes:
- /docker/overseerr/config:/config
ports:
- 5055:5055
restart: unless-stopped
bazarr:
image: lscr.io/linuxserver/bazarr:latest
container_name: bazarr
environment: null
restart: unless-stopped - PUID=1000 - PGID=1000 - TZ=Europe/Paris
volumes:
- /docker/bazarr/config:/config
- ${MEDIA_PATH}:/media
ports:
- 6767:6767
```
::alert{type="success"}
✨ Ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
plex:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
tautulli:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Renseignez le `.env` avec les variables ci-dessous
```properties
PUID=
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` |
Déployez la stack.
### Paramétrer 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`.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
Créez vous un compte, choisissez bien *forms login*.
##### Ajouter un *root folder*
- Dans le menu à gauche, cliquez sur *Settings > Media Management*.
- Ajoutez un *root folder*, choisisez `/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.
:::
::
##### Configurer les profils
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.
![profiles_radarr](/img/serveex/radarr1.png)
##### Ajouter Qbittorrent
Dans *Settings > Downloads Clients* vous allez ajouter 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*.
##### Connecter à Plex
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*.
##### 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
---
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`.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
### Paramétrer 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*.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
##### Ajouter une source
- Dans la section *Indexers*, ajoutez l'indexer de votre source de torrent.
##### Ajouter Radarr et Sonarr
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*.
### Paramétrer 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.
Rendez-vous sur `http://ipduserveur:9696`.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
Rendez-vous dans *Settings > General* et créez un identifiant et un mot de passe en utilisant le *forms login*.
#### Ajouter un profil de langage
- 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.
![Bazarr](/img/serveex/bazarr2.png)
- Enregistrez avec le bouton tout en haut de l'écran.
#### Ajouter des fournisseurs de sous-titre
- Dans *Settings > Providers*, ajoutez vos fournisseurs favoris, comme par exemple :
![Bazarr](/img/serveex/bazarr.png)
- Enregistrez avec le bouton tout en haut de l'écran.
#### Ajouter Radarr et 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.
Faites de même avec Radarr.
### Paramétrer 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](/img/serveex/overseerr.webp)
Rendez-vous sur `http://ipduserveur:5055` et authentifiez vous avec votre compte Plex.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
#### Ajouter Radarr et 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.
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.
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.
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.
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 !
## Exposer Overseerr avec 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.
::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/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/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 :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- plex # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
::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`.
:::
::
Créez le fichier `films.subdomain.conf` et éditez le :
::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/nginx/proxy-confs/films.subdomain.conf
```
Rentrez en édition en appuyant sur `i`:
```nginx
## Version 2024/07/16
# make sure that your overseerr container is named overseerr
# make sure that your dns has a cname set for overseerr
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name films.*;
include /config/nginx/ssl.conf;
client_max_body_size 0;
# 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 overseerr;
set $upstream_port 5055;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ (/overseerr)?/api {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app overseerr;
set $upstream_port 5055;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
}
```
Appuyez sur `Echap` puis sauvegardez et quittez en tappant `:x`
Patientez quelques minutes puis tapez dans votre navigateur `http://films.mondomaine.fr`.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
Et voilà, vous avez exposé Overseerr !

1
content/3.serveex/5.media/_dir.yml Normal file
View File

@ -0,0 +1 @@
navigation.title: Media & Seedbox

174
content/3.serveex/6.cloud/1.immich.md Normal file
View File

@ -0,0 +1,174 @@
---
navigation: true
title: Immich
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Immich
::alert{type="info"}
🎯 __Objectifs :__ installer [Immich](https://immich.app/docs/overview/introduction) pour gérer vos photos sur tout vos appareils.
::
[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.
![Picture](/img/serveex/immich.png)
## Installation
---
Structure des dossiers
```console
root
└── docker
└── immich
├── library
├── compose.yaml
└── .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).
::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.
:::
::
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.
::alert{type="info"}
:::list{type="info"}
- Si vous avez un NAS ou un disque réseau partagé via [samba](/generalites/samba/) pour stocker vos données, remplacez la valeur de `UPLOAD_LOCATION`{lang=properties} par le chemin d'accès de votre dossier partagé.
:::
::
::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).
::
Déployez le conteneur.
Et voilà, vous pouvez vous connecter et suivre les instructions sur `http://ipduserveur:2283`
## Exposer Immich avec 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.
::alert{type="info"}
📋 __Au préalable :__
<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/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/nat).
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de immich :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- immich # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
::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.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Dans les dossiers de Swag, créez le fichier `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.
:::
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name immich.*;
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; }
# 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 immich_server;
set $upstream_port 3001;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ (/immich)?/api {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app immich_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`.
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.
::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/).
::

194
content/3.serveex/6.cloud/2.nextcloud.md Normal file
View File

@ -0,0 +1,194 @@
---
navigation: true
title: Nextcloud
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Nextcloud
::alert{type="info"}
🎯 __Objectifs :__ installer [Nextcloud](https://nextcloud.com/) pour gérer vos photos sur tout vos appareils.
::
[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.
![Picture](/img/serveex/nextcloud.png)
## Installation
---
::alert{type="info"}
:::list{type="info"}
- Nous utiliserons l'image docker maintenue par [LinuxServer.io](https://docs.linuxserver.io/images/docker-nextcloud/)
:::
::
Structure des fichiers
```console
root
└── docker
└── nextcloud
├── config
├── data
├── compose.yaml
└── .env
```
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `nextcloud` puis copiez collez ceci :
```yaml
---
services:
nextcloud:
image: lscr.io/linuxserver/nextcloud:latest
container_name: nextcloud
environment:
- PUID=${PUID}
- PGID=${GUID}
- TZ=Etc/UTC
volumes:
- /docker/nextcloud/config:/config
- /docker/nextcloud/data:/data
ports:
- ${PORT}:443
restart: unless-stopped
```
::alert{type="info"}
:::list{type="info"}
- Si vous avez un NAS ou un disque réseau partagé via [samba](/generalites/samba) pour stocker vos données, remplacez `/docker/nextcloud/data` par le chemin d'accès de votre dossier partagé.
:::
::
Trouvez votre `PUID` et votre `GUID` en tapant la commande suivante :
```shell
id nomdutilisateur
```
Et renseignez le `.env` avec le port souhaité, et les infos que vous avez trouvées, par exemple :
```properties
PUID=1000
GUID=1000
PORT=4545
```
Déployez la stack et rendez-vous sur `http://ipduserveur:4545` et suivez les instructions.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer Nextcloud avec 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.
::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/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/nat).
:::
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de nextcloud :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- nextcloud # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
::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.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Dans les fichiers de nextcloud, éditez le fichier `config.php`.
::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/nextcloud/config/www/nextcloud/config/config.php
```
Entrez en modification avec la touche `i` et copiez les informations suivantes __avant__ `);`.
```js
'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`.
Dans les dossiers de Swag, créez le fichier `nextcloud.subdomain.conf`.
```shell
sudo vi /docker/swag/config/nginx/proxy-confs/nexctloud.subdomain.conf
```
Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
```nginx
## Version 2024/04/25
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name nextcloud.*;
include /config/nginx/ssl.conf;
client_max_body_size 0;
location / {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app nextcloud;
set $upstream_port 443;
set $upstream_proto https;
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;
proxy_hide_header X-XSS-Protection;
# Disable proxy buffering
proxy_buffering off;
}
}
```
Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
Et voilà, vous avez exposé Nextcloud ! Et n'oubliez pas d'installer [les applications pour ordinateurs et mobiles](https://nextcloud.com/fr/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/).
::

1
content/3.serveex/6.cloud/_dir.yml Normal file
View File

@ -0,0 +1 @@
navigation.title: Cloud Drive & Photos

164
content/3.serveex/7.files/1.file-browser.md Normal file
View File

@ -0,0 +1,164 @@
---
navigation: true
title: File Browser
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# File Browser
::alert{type="info"}
🎯 __Objectifs :__
- Installer File Browser
- Exposer File Browser avec 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](/img/serveex/filebrowser.png)
## Installation
---
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `filebrowser` puis copiez collez ceci :
```yaml
---
services:
filebrowser:
container_name: filebrowser
volumes:
- /:/srv
- /docker/filebrowser/config:/config/
# - /chemin/vers/vos/dossiers:/vosdossiers
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
```yaml
services:
filebrowser:
#...
labels:
- 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 !
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer File Browser avec 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).
:::
::
Vous aurez peut-etre envie d'y accéder à distance et sur tout vos appareils. Pour cela, nous allons exposer IT Tools via Swag.
::alert{type="info"}
:::list{type="info"}
- __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat).
:::
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de filebrowser :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- filebrowser # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
::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.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Dans les dossiers de Swag, créez le fichier `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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name files.*;
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; }
# 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 filebrowser;
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`.
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).
::

213
content/3.serveex/7.files/2.pingvin.md Normal file
View File

@ -0,0 +1,213 @@
---
navigation: true
title: Pingvin
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Pingvin
::alert{type="info"}
🎯 __Objectifs :__
- Installer Pingvin
- Exposer Pingvin
::
[Pingvin](https://github.com/stonith404/pingvin-share) est un outil permettant de partager rapidement des fichiers, à la manière de WeTransfer. Ses nombreuses options de partage (mot de passe, durée d'expiration, personnalisation du lien...) en font l'outil idéal pour partager rapidement des fichiers. Pingvin permet également de créer des _demandes de dépot_, c'est à dire un lien partageable à envoyer à quelqu'un de votre choix pour qu'il puisse téléverser ses fichiers afin que vous puissiez les récupérer.
![File Browser](/img/serveex/pingvin.png)
## Installation
---
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `pingvin` puis copiez collez ceci :
```yaml
---
services:
pingvin-share:
container_name: pingvin
image: stonith404/pingvin-share
restart: unless-stopped
ports:
- 3600:3000
volumes:
- /docker/pingvin/data:/opt/app/backend/data
- /docker/pingvin/data/img:/opt/app/frontend/public/img
- /docker/pingvin/uploads:/opt/app/backend/uploads # chemin du dossier dans lequel vous souhaitez stocker les fichiers uploadés dans pingvin. A changer selon vos préférences.
depends_on:
clamav:
condition: service_healthy
networks:
- swag
clamav: #antivirus pour les fichiers
restart: unless-stopped
image: clamav/clamav
```
::alert{type="info"}
:::list{type="info"}
- Ici nous partons du principe que le nom du réseau de Swag est `swag_default`.
:::
::
::alert{type="success"}
✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
filebrowser:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
clamav:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Déployez le conteneur et rendez-vous sur `http://ipduserveur:3600`. Et voilà, votre instance File Browser en webui est disponible !
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer Immich avec 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 Pingvin via Swag.
::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/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/nat).
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de pingvin :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- pingvin # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
pingvin: # Nom du réseau déclaré dans la stack
name: pingvin_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 pingvin est `pingvin_default`. Vous pouvez vérifier que la connexion est opérationnelle en visitant le dashboard de SWAG en tapant http://ipduserveur:81.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Dans les dossiers de Swag, créez le fichier `pingvin.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.
:::
::
```shell
sudo vi /docker/swag/config/nginx/proxy-confs/pingvin.subdomain.conf
```
Entrez en modification avec la touche `i` et collez la configuration ci-dessous :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name pingvin.*;
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; }
# 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 pingvin;
set $upstream_port 3000;
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`.
Et voilà, vous avez exposé Pingvin !
## Sécuriser Pingvin avec Authentik
Vous pouvez protéger cette app avec Authentik de façon native en suivant les instructions ci-dessous.
1. Dans votre espace admin authentik, créez un fournisseur OAuth2/OpenID.
2. Remplissez chaque section comme suit en remplaçant `mondomaine.fr` par votre domaine. Copiez quelque part le contenu des champs `ID du client` et `Secret du client`.
![Picture](/img/serveex/pingvin-auth1.png)
![Picture](/img/serveex/pingvin-auth2.png)
![Picture](/img/serveex/pingvin-auth3.png)
3. Enregistrez et créez une application `pingvin` comme suit.
![Picture](/img/serveex/pingvin-auth4.png)
4. Enregistrez et aller dans la liste de vos avant-postes. Ajoutez le fournisseur pingvin` à votre avant-poste.
5. Quittez authentik, et allez dans l'interface d'administration de Pingvin.
6. Dans la section _« Identifiant social »_ renseignez les champs suivant :
- `URI de découverte OpenID` avec `https://pingvin.mondomaine.fr/application/o/pingvin/.well-known/openid-configuration` (n'oubliez pas de remplacer `mondomaine.fr` par votre domaine)
- `Revendication du nom d’utilisateur OpenID` avec `preferred_username`
- `ID du client OpenID` avec l'ID que vous avez copié en étape 2.
- `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.

1
content/3.serveex/7.files/_dir.yml Normal file
View File

@ -0,0 +1 @@
navigation.title: Fichiers & partage

223
content/3.serveex/8.development/1.code-server.md Normal file
View File

@ -0,0 +1,223 @@
---
navigation: true
title: Code-Serveur
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Code-Server
::alert{type="info"}
🎯 __Objectifs :__
- Installer code-server
- Monter des dossiers dans vscode
- Exposer code-server avec 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/coder/code-server/raw/main/docs/assets/screenshot-2.png)
## Installation
---
::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/).
:::
::
Structure des dossiers
```console
root
├── docker
│ └── code-server
│ └── config
└── #n'importe quel dossier à monter dans vscode
```
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `code-server` puis copiez collez ceci :
```yaml
---
services:
code-server:
image: lscr.io/linuxserver/code-server:latest
container_name: code-server
environment:
- PUID=${PUID}
- PGID=${GUID}
- TZ=Etc/UTC
- HASHED_PASSWORD=${PW}
volumes:
- /docker/code-server/config:/config
# ajoutez vos dossier à monter dans vscode
# - /chemin/vers/dossier:/dossier
ports:
- 8443:8443
restart: unless-stopped
```
::alert{type="success"}
✨ Ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
code-server:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Choisissez un mot de passe et générez un hash
```shell
echo -n "votremotdepasse" | npx argon2-cli -e
```
Notez précieusement le résultat. Trouvez votre PUID et votre GUID en tapant la commande suivante :
```shell
id nomdutilisateur
```
Et renseignez le `.env` avec les infos que vous avez trouvées, par exemple :
```properties
PW='$argon2i$v=19$m=4096,t=3,p=1$wST5QhBgk2lu1ih4DMuxvg$LS1alrVdIWtvZHwnzCM1DUGg+5DTO3Dt1d5v9XtLws4'
PUID=1000
GUID=1000
```
::alert{type="warning"}
:::list{type="warning"}
- __Attention :__ Pensez à mettre un guillemet simple `'`au debut et à la fin du hash
:::
::
Déployez le conteneur et rendez-vous sur `http://ipduserveur:8443`. Et voilà, votre instance code-server en webui est disponible !
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Monter des dossiers
---
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.
```yaml
services:
code-server:
#...
volumes:
- /chemin/vers/dossier:/dossier
```
Une fois dans vscode, vous pourrez accéder au dossier.
## Exposer code-server avec 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.
::alert{type="info"}
:::list{type="info"}
- __Au préalable :__ Nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat).
:::
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de code-server :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- code-server # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
::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.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Dans les dossiers de Swag, créez le fichier `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.
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name code.*;
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; }
# 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 code-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`.
Et voilà, vous avez exposé code-server !
::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).
::

198
content/3.serveex/8.development/2.gitea.md Normal file
View File

@ -0,0 +1,198 @@
---
navigation: true
title: Gitea
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Gitea
::alert{type="info"}
🎯 __Objectifs :__
- Installer Gitea
- Exposer Gitea avec 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/img/home-screenshot.png)
## Installation
---
Structure des dossiers
```console
root
└── docker
└── gitea
└── data
```
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `gitea` puis copiez collez ceci :
```yaml
---
networks:
gitea:
external: false
services:
server:
image: gitea/gitea:1.22.0
container_name: gitea
environment:
- USER_UID=${UID}
- USER_GID=${GID}
- TZ=Europe/Paris
restart: unless-stopped
networks:
- gitea
volumes:
- ./data:/data
ports:
- 3333:3000
- 222:22
```
Et renseignez le `.env` avec les infos que vous avez trouvées, par exemple :
```properties
UID=1000
GID=1000
```
Déployez le conteneur et rendez-vous sur `http://ipduserveur:3333`. Et voilà, votre instance Gitea est disponible !
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer Gitea avec 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.
::alert{type="info"}
:::list{type="info"}
- __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat).
:::
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de gitea :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- gitea # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
::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.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Dans les dossiers de Swag, créez le fichier `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.
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name gitea.*;
include /config/nginx/ssl.conf;
client_max_body_size 0;
# 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 gitea;
set $upstream_port 3000;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ (/gitea)?/info/lfs {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app gitea;
set $upstream_port 3000;
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`.
Ouvrez le fichier `app.ini` dans les fichiers du conteneur
```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
```properties
[server]
DOMAIN = gitea.mondomaine.fr
SSH_DOMAIN = gitea.mondomaine.fr
ROOT_URL = https://gitea.mondomaine.fr/
```
Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x` puis en appuyant sur `Entrée`.
Relancez le conteneur.
Et voilà, vous avez exposé Gitea !
::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/).
::

167
content/3.serveex/8.development/3.it-tools.md Normal file
View File

@ -0,0 +1,167 @@
---
navigation: true
title: IT-Tools
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# IT Tools
::alert{type="info"}
🎯 __Objectifs :__
- Installer IT-Tools
- Exposer IT Tools avec 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](/img/serveex/it-tools.png)
## Installation
---
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `it-tools` puis copiez collez ceci :
```yaml
---
services:
it-tools:
container_name: it-tools
restart: unless-stopped
image: corentinth/it-tools:latest
ports:
- 3222:80
```
::alert{type="success"}
✨ __Astuce :__ ajoutez le label de watchtower dans chaque conteneur afin d'automatiser les mises à jour
```yaml
services:
it-tools:
#...
labels:
- 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 !
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer IT Tools avec 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.
::alert{type="info"}
:::list{type="info"}
- __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat).
:::
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de it-tools :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- it-tools # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
::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.
:::
::
::alert{type="info"}
:::list{type="info"}
- Ici nous partons du principe que le nom du réseau de Swag est `swag_default`.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Dans les dossiers de Swag, créez le fichier `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.
::
```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 :
```nginx
## Version 2023/12/19
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name tools.*;
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; }
# 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 it-tools;
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`.
Et voilà, vous avez exposé it-tools !
::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).
::

1
content/3.serveex/8.development/_dir.yml Normal file
View File

@ -0,0 +1 @@
navigation.title: Développement

308
content/3.serveex/9.apps/1.adguard.md Normal file
View File

@ -0,0 +1,308 @@
---
navigation: true
title: Adguard Home
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# 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
::
[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.
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.
En pratique, une fois en place, il vous faudra juste configurer les serveurs DNS de vos appareils, pour que ces derniers l'utilisent.
**Rappel sur le fonctionnement d'un DNS :**
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.
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.
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 :
- 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.
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.
![Picture](/img/serveex/adguard.svg)
## Installation
---
Structure des dossiers :
```console
root
└── docker
└── adguard
├── confdir
├── workdir
├── compose.yaml
└── .env
```
::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.
:::
::
Ouvrez Dockge, et cliquez sur `compose`
Nommez la stack `adguard` et copiez la configuration ci-dessous
```yaml
---
services:
adguardhome:
container_name: adguard
image: adguard/adguardhome
restart: unless-stopped
ports:
- 53:53/udp
- 8080:80/tcp
- 4443:443/tcp
- 853:853/tcp
- 3000:3000/tcp
volumes:
- /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
```yaml
services:
adguardhome:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
::
Déployez la stack.
Rendez-vous sur `http//ipduserveur:3000` et suivez les instructions
Et voilà, vous avez déployé Adguard !
## Exposer Adguard avec Swag
---
Pour être utilisable hors de chez vous, vous devez exposer Adguard
::alert{type="info"}
:::list{type="info"}
- __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat). Redirigez également le port `53` et le port `853` vers votre serveur. Ces ports serviront à router les requêtes DNS.
:::
::
::alert{type="warning"}
:::list{type="warning"}
- N'utilisez pas les tunnels cloudflare pour exposer Adguard, et désactivez tout proxy.
:::
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau d'adguard :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- adguard # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
::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.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Créez et ouvrez le fichier `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.
::
```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 :
```nginx
## Version 2023/05/31
# make sure that your adguard container is named adguard
# make sure that your dns has a cname set for adguard
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name adguard.*;
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; }
# 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 adguard;
set $upstream_port 3000;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location /control {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app adguard;
set $upstream_port 3000;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location /dns-query {
# to properly use this please set `allow_unencrypted_doh: true` and `force_https: false` in adguard
# see https://github.com/AdguardTeam/AdGuardHome/wiki/Configuration#configuration-file
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app adguard;
set $upstream_port 3000;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
}
```
::alert{type="success"}
✨ __Astuce :__
<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 :
- Editez le fournisseur d'Adguard
- Dans *paramètres avancés du protocole > chemins authentifiés*, saisissez `^/dns-query`
::
Appuyez sur `Echap` puis sauvegardez et quittez en tapant `:x`
Et voilà, vous exposez Adguard à présent !
## Configurer le chiffrement SSL/TLS
---
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.
Afin de configurer le chiffrement :
- Allez dans _paramètre_ puis dans _chiffrement_.
- Parametrez comme suit
![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
Et voilà ! Vous avez protégé vos futures requêtes DNS !
## Configurer les appareils
---
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).
Généralement cette option est dans les paramètres _DHCP_ de votre box. Pensez bien à ajouter un serveur secondaire tel que :
- Cloudlare : `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.
::alert{type="info"}
:::list{type="info"}
- Des appareils peuvent avoir un autre DNS paramétré et ne pas utiliser ceux de la box.
:::
::
### Forcer un navigateur à utiliser 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`
### Windows, paramétrer Adguard au niveau système
Dans windows, vous devez paramétrer Adguard pour chaque carte réseau que vous souhaitez utiliser.
- 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
Tous les programmes de votre machine utilisant cette carte réseau seront filtrés par Adguard.
## Ajouter des filtres
---
- Allez dans les paramètres et changez les filtres.

248
content/3.serveex/9.apps/2.vaultwarden.md Normal file
View File

@ -0,0 +1,248 @@
---
navigation: true
title: Vaultwarden
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# 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).
::
![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 est un fork de la solution [Bitwarden](https://bitwarden.com/fr-fr/help/).
## Installation
---
Structure des dossiers
```console
root
└── docker
└── vaultwarden
├── data
├── compose.yaml
└── .env
```
Ouvrez Dockge, cliquez sur `compose`, appelez la stack `vaultwarden` puis copiez collez ceci :
```yaml
---
services:
vaultwarden:
container_name: vaultwarden
image: vaultwarden/server:latest
restart: unless-stopped
env_file:
- .env
volumes:
- ./data/:/data/
ports:
- 3050:80
environment:
- DOMAIN=${URL}
- LOGIN_RATELIMIT_MAX_BURST=10
- LOGIN_RATELIMIT_SECONDS=60
- ADMIN_RATELIMIT_MAX_BURST=10
- ADMIN_RATELIMIT_SECONDS=60
- ADMIN_TOKEN=${TOKEN}
- SENDS_ALLOWED=true
- EMERGENCY_ACCESS_ALLOWED=true
- WEB_VAULT_ENABLED=true
- SIGNUPS_ALLOWED=false
- 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
```yaml
services:
vauktwarden:
#...
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`
```shell
echo -n "votremotdepasse" | argon2 "$(openssl rand -base64 32)" -e -id -k 65540 -t 3 -p 4
```
Copiez le résultat précieusement.
Dans le `.env`, renseignez les variables suivantes :
```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` |
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.
::alert{type="danger"}
:::list{type="danger"}
- __En cas d'échec :__ vérifiez les règles de votre pare-feu.
:::
::
## Exposer Vaultwarden avec 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).
::alert{type="info"}
✨ __Au préalable :__ nous partons du principe que vous avez créé dans votre [zone DNS](/generalites/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/nat).
::
Dans Dockge, rendez-vous dans la stack de SWAG et éditez le compose en ajoutant le réseau de vaultwarden :
```yaml
services:
swag:
container_name: # ...
# ...
networks: # Relie le conteneur au réseau custom
# ...
- vaultwarden # Nom du réseau déclaré dans la stack
networks: # Définit le réseau custom
# ...
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
```
::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.
:::
::
Relancez la stack en cliquant sur "déployer" et patientez le temps que SWAG soit complètement opérationnel.
Dans les dossiers de Swag, créez le fichier `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.
::
```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 :
```nginx
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name vault.*;
include /config/nginx/ssl.conf;
client_max_body_size 128M;
# 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 vaultwarden;
set $upstream_port 80;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ ^(/vaultwarden)?/admin {
# 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 vaultwarden;
set $upstream_port 80;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ (/vaultwarden)?/api {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app vaultwarden;
set $upstream_port 80;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
location ~ (/vaultwarden)?/notifications/hub {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;
set $upstream_app vaultwarden;
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`.
Et voilà, vous avez exposé Vaultwarden ! Accédez au panneau d'administration via `vault.mondomaine.fr` et créez votre compte. Plus d'info sur les fonctionnalités de [Bitwarden](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.
::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).
::

1
content/3.serveex/9.apps/_dir.yml Normal file
View File

@ -0,0 +1 @@
navigation.title: Applications utiles

2
content/3.serveex/_dir.yml Normal file
View File

@ -0,0 +1,2 @@
icon: noto:microscope
navigation.redirect: /serveex/introduction

17
content/4.Stockeex/1.introduction.md Normal file
View File

@ -0,0 +1,17 @@
---
navigation: true
title: Introduction
layout: page
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
::terminal{style="margin-top:80px;"}
---
content:
- sudo systemctl status stockeex
- server is busy, come back later...
---
::

2
content/4.Stockeex/_dir.yml Normal file
View File

@ -0,0 +1,2 @@
icon: noto:computer-disk
navigation.redirect: /stockeex/introduction

146
content/5.betises/1.bash.md Normal file
View File

@ -0,0 +1,146 @@
---
navigation: true
title: Scripts bash
main:
fluid: false
---
:ellipsis{left=0px width=40rem top=10rem blur=140px}
# Scripts bash
Quelques scripts en vracs qui m'ont sauvé la vie.
## 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.
A plus tard pour de nouvelles aventures passionnantes.

69
content/5.betises/2.python.md Normal file
View File

@ -0,0 +1,69 @@
---
navigation: true
title: Scripts python
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](https://git.djeex.fr/Djeex/nvidia-stock-bot/raw/commit/88c09ff4cffd96cbf0852ec785f9fbf2130c23b2/assets/img/nvbot.png)
à cela :
![Nvidia Stock bot](https://git.djeex.fr/Djeex/nvidia-stock-bot/raw/branch/main/assets/img/nvbot_schematics.png)
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)
::
## 🤖 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)
::

2
content/5.betises/_dir.yml Normal file
View File

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

47
nuxt.config.ts Executable file
View File

@ -0,0 +1,47 @@
export default defineNuxtConfig({
// https://github.com/nuxt-themes/docus
css: ['~/assets/css/extra.css'],
extends: ['@nuxt-themes/docus'],
devtools: { enabled: false },
colorMode: {
preference: 'dark',
fallback:'dark',
},
content: {
highlight: {
langs: [
'console',
'nginx',
]
}
},
mdc: {
highlight: {
theme: 'github-dark',
langs: ['ts','html','console','nginx'],
wrapperStyle: true
}
},
app: {
head: {
link: [
{ rel: 'icon', type: 'image/x-icon', href: '/img/favicon/favicon.ico' },
{ rel: 'apple-touch-icon', sizes: '180x180', href: '/img/favicon/apple-touch-icon.png' },
{ rel: 'icon', sizes: '192x192', href: '/img/favicon/android-chrome-192x192.png' },
{ rel: 'icon', sizes: '512x512', href: '/img/favicon/android-chrome-512x512.png' },
{ rel: 'icon', type: 'image/png', sizes: '32x32', href: '/img/favicon/favicon-32x32.png' },
{ rel: 'icon', type: 'image/png', sizes: '16x16', href: '/img/favicon/favicon-16x16.png' },
{ rel: 'manifest', href: '/img/favicon/site.webmanifest' }
],
meta: [
{ name: 'darkreader-lock' },
]
}
},
compatibilityDate: '2024-10-24'
})

16057
package-lock.json generated Normal file
View File

File diff suppressed because it is too large Load Diff

22
package.json Executable file
View File

@ -0,0 +1,22 @@
{
"name": "docus-starter",
"version": "0.1.0",
"private": true,
"scripts": {
"dev": "nuxi dev",
"build": "nuxi build",
"generate": "nuxi generate",
"preview": "nuxi preview",
"lint": "eslint ."
},
"devDependencies": {
"@nuxt-themes/docus": "latest",
"@nuxt/devtools": "^1.6.0",
"@nuxt/eslint-config": "^0.6.1",
"@nuxt/icon": "^1.7.5",
"@nuxtjs/plausible": "^1.0.3",
"@types/node": "^22.9.0",
"eslint": "^9.14.0",
"nuxt": "^3.14.159"
}
}

BIN
public/cover.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 214 KiB

BIN
public/favicon.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 15 KiB

BIN
public/img/favicon/android-chrome-192x192.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.9 KiB

BIN
public/img/favicon/android-chrome-512x512.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
public/img/favicon/apple-touch-icon.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.7 KiB

BIN
public/img/favicon/favicon-16x16.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 402 B

BIN
public/img/favicon/favicon-32x32.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 796 B

BIN
public/img/favicon/favicon.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 15 KiB

1
public/img/favicon/site.webmanifest Normal file
View File

@ -0,0 +1 @@
{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}

13
public/img/global/dns.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 97 KiB

13
public/img/global/lab.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 142 KiB

13
public/img/global/nat.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 106 KiB

13
public/img/global/smb.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 101 KiB

13
public/img/global/ssh.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 115 KiB

25
public/img/logo.svg Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0" encoding="UTF-8"?>
<svg id="Calque_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 2911.15 609.88">
<!-- Generator: Adobe Illustrator 29.5.0, SVG Export Plug-In . SVG Version: 2.1.0 Build 137) -->
<defs>
<style>
.st0 {
fill: #fff;
}
.st1 {
fill: #55c3ec;
}
</style>
</defs>
<path class="st0" d="M173.02,463.62c-38.53,0-69.1-14.28-91.72-42.84-22.62-28.56-33.93-67.47-33.93-116.73s11.36-87.5,34.07-115.87c22.71-28.37,53.43-42.55,92.15-42.55,21.85,0,41.06,5.27,57.65,15.81,16.58,10.54,28.7,24.54,36.37,41.98h1.73V43.85h83.95v414.88h-82.8v-52.9h-1.44c-7.67,17.44-20.03,31.44-37.09,41.98-17.06,10.54-36.71,15.81-58.94,15.81ZM201.49,212.91c-21.09,0-37.71,8.24-49.88,24.73-12.17,16.49-18.26,38.81-18.26,66.99s6.08,50.7,18.26,66.99c12.17,16.29,28.8,24.44,49.88,24.44s37.52-8.19,49.88-24.58c12.36-16.39,18.54-38.67,18.54-66.85s-6.18-50.27-18.54-66.85c-12.36-16.58-28.99-24.87-49.88-24.87Z"/>
<path class="st0" d="M647.06,422.65c-27.41,28.46-64.6,42.7-111.55,42.7s-84.15-14.28-111.55-42.84c-27.41-28.56-41.11-67.95-41.11-118.17s13.85-88.79,41.55-117.45c27.7-28.65,64.74-42.98,111.12-42.98s83.67,14.33,111.27,42.98c27.6,28.66,41.4,67.81,41.4,117.45s-13.71,89.85-41.11,118.31ZM535.51,401.23c20.7,0,37.09-8.43,49.17-25.3,12.08-16.86,18.11-40.63,18.11-71.3s-6.04-53.95-18.11-71.02c-12.08-17.06-28.46-25.59-49.17-25.59s-37.14,8.53-49.31,25.59c-12.17,17.06-18.26,40.73-18.26,71.02s6.04,54.44,18.11,71.3c12.08,16.87,28.56,25.3,49.45,25.3Z"/>
<path class="st0" d="M996.03,265.24h-77.92c-2.49-16.68-9.06-30.09-19.69-40.25-10.64-10.16-24.39-15.24-41.26-15.24-20.89,0-37.33,8.39-49.31,25.16-11.98,16.77-17.97,39.92-17.97,69.43s5.99,53.48,17.97,70.15c11.98,16.68,28.51,25.01,49.6,25.01,16.68,0,30.28-4.74,40.83-14.23,10.54-9.49,17.15-22.66,19.84-39.53h78.2c-2.11,36.42-15.81,65.46-41.11,87.12-25.3,21.66-58.18,32.49-98.62,32.49-46.77,0-83.76-14.33-110.98-42.98-27.22-28.65-40.83-68-40.83-118.02s13.66-88.31,40.97-117.16c27.31-28.85,64.07-43.27,110.26-43.27,41.02,0,74.13,11.31,99.34,33.93,25.2,22.62,38.76,51.75,40.68,87.4Z"/>
<path class="st0" d="M1306.18,150.52v308.21h-81.08v-55.49h-1.72c-16.1,40.83-46.86,61.24-92.29,61.24-33.74,0-60.67-10.3-80.79-30.91-20.12-20.6-30.19-48.73-30.19-84.38v-198.67h83.95v181.13c0,20.51,4.93,36.13,14.81,46.86,9.87,10.74,24.1,16.1,42.7,16.1s33.35-6.13,44.28-18.4c10.92-12.26,16.39-28.65,16.39-49.17v-176.53h83.95Z"/>
<path class="st1" d="M1442.39,311.24c-9.2,9.2-20.32,13.8-33.35,13.8s-24.15-4.6-33.35-13.8c-9.2-9.2-13.8-20.31-13.8-33.35s4.6-24.39,13.8-33.49c9.2-9.1,20.31-13.66,33.35-13.66s24.15,4.56,33.35,13.66c9.2,9.11,13.8,20.27,13.8,33.49s-4.6,24.15-13.8,33.35Z"/>
<path class="st0" d="M1626.33,463.62c-38.53,0-69.1-14.28-91.72-42.84-22.62-28.56-33.93-67.47-33.93-116.73s11.36-87.5,34.07-115.87c22.71-28.37,53.43-42.55,92.15-42.55,21.85,0,41.07,5.27,57.65,15.81,16.58,10.54,28.7,24.54,36.37,41.98h1.73V43.85h83.95v414.88h-82.8v-52.9h-1.44c-7.67,17.44-20.03,31.44-37.09,41.98-17.06,10.54-36.71,15.81-58.94,15.81ZM1654.79,212.91c-21.09,0-37.71,8.24-49.88,24.73-12.17,16.49-18.26,38.81-18.26,66.99s6.08,50.7,18.26,66.99c12.17,16.29,28.8,24.44,49.88,24.44s37.52-8.19,49.88-24.58c12.36-16.39,18.54-38.67,18.54-66.85s-6.18-50.27-18.54-66.85c-12.36-16.58-28.99-24.87-49.88-24.87Z"/>
<path class="st0" d="M1932.75,150.52v322.59c0,31.24-9.39,54.91-28.18,71.02-18.79,16.1-46.2,24.15-82.23,24.15-10.35,0-18.01-.39-23-1.15v-61.82c2.69.38,6.23.58,10.64.58,13.99,0,23.96-2.73,29.9-8.19,5.94-5.46,8.91-14.42,8.91-26.88V150.52h83.95ZM1922.68,103.94c-8.62,8.44-19.26,12.65-31.91,12.65s-23.29-4.21-31.91-12.65c-8.63-8.43-12.94-18.69-12.94-30.76s4.31-22.57,12.94-30.91c8.62-8.34,19.26-12.51,31.91-12.51s23.29,4.17,31.91,12.51c8.63,8.34,12.94,18.64,12.94,30.91s-4.31,22.33-12.94,30.76Z"/>
<path class="st0" d="M2177.35,364.43h77.05c-4.6,30.29-19.7,54.68-45.28,73.17-25.59,18.5-57.36,27.74-95.31,27.74-47.35,0-84.48-14.18-111.41-42.55-26.93-28.36-40.4-67.28-40.4-116.73s13.41-88.6,40.25-118.02c26.83-29.42,62.96-44.13,108.39-44.13s80.22,13.99,106.67,41.98c26.45,27.99,39.68,65.46,39.68,112.42v25.59h-212.47v5.18c0,22.04,6.47,39.92,19.41,53.62,12.94,13.71,30.04,20.56,51.32,20.56,15.33,0,28.56-3.5,39.68-10.49,11.11-6.99,18.59-16.43,22.43-28.32ZM2111.51,206.01c-18.21,0-33.4,6.23-45.57,18.69-12.17,12.46-19.03,28.37-20.56,47.73h130.82c-.96-19.74-7.33-35.75-19.12-48.01-11.79-12.26-26.98-18.4-45.57-18.4Z"/>
<path class="st0" d="M2488.94,364.43h77.05c-4.6,30.29-19.7,54.68-45.28,73.17-25.59,18.5-57.36,27.74-95.31,27.74-47.35,0-84.48-14.18-111.41-42.55-26.93-28.36-40.4-67.28-40.4-116.73s13.41-88.6,40.25-118.02c26.83-29.42,62.96-44.13,108.39-44.13s80.22,13.99,106.67,41.98c26.45,27.99,39.68,65.46,39.68,112.42v25.59h-212.47v5.18c0,22.04,6.47,39.92,19.41,53.62,12.94,13.71,30.04,20.56,51.32,20.56,15.33,0,28.56-3.5,39.68-10.49,11.11-6.99,18.59-16.43,22.43-28.32ZM2423.1,206.01c-18.21,0-33.4,6.23-45.57,18.69-12.17,12.46-19.03,28.37-20.56,47.73h130.82c-.96-19.74-7.33-35.75-19.12-48.01-11.79-12.26-26.98-18.4-45.57-18.4Z"/>
<path class="st0" d="M2718.88,351.78h-1.72l-57.79,106.95h-88.27l96.6-153.53-96.03-154.68h94.59l55.49,104.08h1.73l54.63-104.08h91.43l-96.32,152.38,95.45,155.83h-91.14l-58.65-106.95Z"/>
</svg>
Side by Side

After

Width:  |  Height:  |  Size: 5.1 KiB

BIN
public/img/serveex/adguard-chiffrement.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 83 KiB

13
public/img/serveex/adguard.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 146 KiB

4
public/img/serveex/arr.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 80 KiB

13
public/img/serveex/auth-native.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 100 KiB

13
public/img/serveex/auth-outpost.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 112 KiB

13
public/img/serveex/auth-proxy.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 100 KiB

BIN
public/img/serveex/auth1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 76 KiB

BIN
public/img/serveex/auth2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 118 KiB

BIN
public/img/serveex/auth3.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 13 KiB

13
public/img/serveex/authentik.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 119 KiB

BIN
public/img/serveex/bazarr.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 85 KiB

BIN
public/img/serveex/bazarr2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 64 KiB

BIN
public/img/serveex/beszel-add.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB

BIN
public/img/serveex/beszel-system.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.0 KiB

BIN
public/img/serveex/beszel.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 33 KiB

BIN
public/img/serveex/cf-dns.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

BIN
public/img/serveex/cf-id.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 13 KiB

BIN
public/img/serveex/cf-token.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 74 KiB

BIN
public/img/serveex/cf-tunnels-id.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 19 KiB

13
public/img/serveex/cloudflared.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 121 KiB

13
public/img/serveex/docker.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 114 KiB

BIN
public/img/serveex/dockge.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 112 KiB

BIN
public/img/serveex/filebrowser.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 122 KiB

BIN
public/img/serveex/immich.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.8 MiB

BIN
public/img/serveex/it-tools.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 155 KiB

13
public/img/serveex/lab.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 142 KiB

10
public/img/serveex/lab2.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 64 KiB

BIN
public/img/serveex/nextcloud.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 77 KiB

BIN
public/img/serveex/overseerr.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 356 KiB

Some files were not shown because too many files have changed in this diff Show More