Add section summary pages and make single-link admonitions clickable

This commit is contained in:
Djeex
2026-09-04 18:51:42 +02:00
parent f2cfa49150
commit 9c5a693281
60 changed files with 451 additions and 174 deletions
@@ -0,0 +1,2 @@
title: Alternatives
icon: i-lucide-arrow-left-right
@@ -0,0 +1,324 @@
---
title: Plex
description: Install Plex Media Server with Tautulli on your homelab to stream movies and TV shows from anywhere on all your devices.
---
:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}
::note{to="/serveex/media/jellyfin"}
This is an alternative to **Jellyfin**, kept here for reference. Plex isn't fully self-hosted: local playback still goes through Plex's own relay and requires a Plex account, and several features sit behind a Plex Pass paywall.
::
[Plex](https://www.plex.tv/fr/) is a self-hosted video streaming platform for managing your movie or TV show library and playing them locally or remotely. Plex has apps for TV, Android, iOS, Windows, and macOS, allowing you to stream your library just like Netflix.
With *Plex Pass*, you can also organize and play your music content similar to Spotify, the difference being that its your content, hosted and streamed from your server.
![picture](/img/serveex/plex.png)
We'll also install [Tautulli](https://docs.linuxserver.io/images/docker-tautulli/), a tool that provides detailed stats about Plex. As always, we'll use linuxserver.io images where possible.
- [More info on the Plex container](https://docs.linuxserver.io/images/docker-plex)
- [More info on the Tautulli container](https://docs.linuxserver.io/images/docker-tautulli/)
::note
Youll need to create a *Plex.tv* account. You dont need to expose your Plex service; it will be accessible through the platform. Your Plex server will be manageable directly from your account.
::
## Install Plex
::file-tree
---
tree:
/:
- docker:
- plex:
- compose.yml
- .env
- config/
- transcode/
- tautulli:
- config/
- media:
- tvseries/
- movies/
- library/
---
::
::steps{level="3"}
### Create the media folders
Create the `movies`, `tvseries`, and `library` folders in `/media`:
```bash [Terminal]
mkdir -p /media/movies /media/library /media/tvseries
```
### Deploy the stack
Open Dockge in your browser and click `compose`.
Name the stack `plex` and add the following config:
```yaml [compose.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
```
::tip{icon=""}
✨ Add the Watchtower label to each container to automate updates:
```yaml [compose.yaml]
---
services:
plex:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
tautulli:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
```
::
### Set your environment variables
Find your PUID and GUID by running:
```bash [Terminal]
id username
```
Fill in your `.env` file with the retrieved values, for example:
```properties [.env]
PUID=1000
GUID=1000
```
Deploy the stack.
The local interface is available at `http://yourserverip:32400/web/index.html`.
Tautulli is accessible at `http://yourserverip:8181`.
::warning{to="https://support.plex.tv/articles/200288586-installation/#toc-2"}
You must be on your local network during Plex's initial setup. Otherwise, the URL will redirect to your Plex account without detecting your server. A VPN won't help. If you have no choice, **you can handle the setup remotely via SSH tunnel**.
::
### Done !
::
## Configure Plex
Plex offers a range of free movies/shows. After creating your account, I recommend disabling everything in the _Online Services_ section to keep your library clean.
Then go to the _Remote Access_ section and manually select a port (well use `1234`). It's best not to use the default port.
![picture](/img/serveex/plex-port.png)
- On your router, forward TCP port `1234` to port `32400` for your servers IP using [NAT rules](/general/networking/nat).
- Once done, return to Plex to verify that remote access is functional.
::caution
**If it fails:** check your firewall rules and allow port `32400` on your server.
::
- If you have PlexPass and a GPU or iGPU, enable *hardware acceleration* in the _Transcoder_ section.
- In _Settings > Library_, enable _Update my library automatically_.
- In _Manage > Library_, add or edit libraries and point to `/media/movies` for movies and `/media/tvseries` for series.
And thats it! You now have a working Plex server!
Simply add your media to `/media/movies` and `/media/tvseries` on your server. You can then install the Plex app on your devices and watch your favorite content locally or remotely.
::note{to="/general/networking/samba"}
If your media is stored on a network disk (e.g. NAS or external hard drive over the network), refer to the **Samba mount guide** so Plex can access it.
::
## Expose Tautulli with Swag
You dont need to expose Plex, as it's accessible via your Plex account on plex.tv.
However, you may want to expose Tautulli so you can view stats from a simple URL when you're not home.
::note
We assume you have the subdomain `tautulli.mydomain.com` with a `CNAME` pointing to `mydomain.com` in your [DNS zone](/general/networking/dns). And of course, [unless you use Cloudflare Zero Trust](/serveex/security/cloudflare), your box's port `443` must be forwarded to your server's port `443` in [NAT rules](/general/networking/nat).
::
::steps{level="3"}
### Add Tautulli's network to SWAG
Go to Dockge and edit SWAGs compose file by adding Tautullis network:
```yaml [compose.yaml]
---
services:
swag:
container_name: # ...
# ...
networks: # Attach container to custom network
# ...
- tautulli # Name of the declared network
networks: # Define the custom network
# ...
tautulli: # Declared network name
name: tautulli_default # Actual external network name
external: true # Marks it as externally defined
```
Redeploy the stack and wait for SWAG to be fully operational.
::note
Here we assume the Tautulli network name is `tautulli_default`. You can check the connection by visiting SWAGs dashboard at `http://yourserverip:81`.
::
### Create the subdomain.conf file
Copy and rename the file `tautulli.subdomain.conf.sample` to `tautulli.subdomain.conf`, then edit it:
::tip{icon="" to="/serveex/files/file-browser-quantum"}
✨ **Tip:** Use **File Browser** to navigate and edit files instead of using terminal commands.
::
```bash [Terminal]
sudo cp /docker/swag/config/nginx/proxy-confs/tautulli.subdomain.conf.sample /docker/swag/config/nginx/proxy-confs/tautulli.subdomain.conf
sudo nano /docker/swag/config/nginx/proxy-confs/tautulli.subdomain.conf
```
Ensure the configuration matches the following, and edit it if needed:
```nginx [tautulli.subdomain.conf]
## 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;
}
}
```
::tip{icon="" to="/serveex/advanced/authentik#protecting-an-app-via-reverse-proxy"}
✨ You can protect this app with Authentik by removing the `#` before `include /config/nginx/authentik-server.conf;` and `include /config/nginx/authentik-location.conf;`. Dont forget to **create an application and provider in Authentik**.
::
Press :kbd{value="Ctrl+O"}, then :kbd{value="Enter"} to save, and :kbd{value="Ctrl+X"} to exit.
### Done !
::
Wait a few minutes, then open `http://tautulli.mydomain.com` in your browser.
::caution
**If it fails:** check your firewall rules.
::
And you're done!
@@ -0,0 +1,345 @@
---
title: Qbittorrent for Plex
description: Install qBittorrent with Gluetun and ProtonVPN to download torrents securely behind a VPN on your self-hosted server.
---
:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}
::note{to="/serveex/media/qbittorrent"}
This is the seedbox setup paired with Plex rather than Jellyfin, kept here for reference. See **Qbittorrent** for the same setup paired with Jellyfin, the recommended alternative since Plex isn't fully self-hosted (its own relay, a required account) and gates features behind a Plex Pass paywall.
::
![Picture](/img/serveex/qbit-vue.jpeg)
To safely download your favorite media, we'll build a system using:
- [Qbittorrent](https://github.com/linuxserver/docker-qbittorrent) as the BitTorrent client
- [Proton VPN Plus](https://protonvpn.com/torrenting), a VPN to secure your traffic. You need a subscription (promos available) to access the BitTorrent protocol. You can also use another VPN as long as it supports BitTorrent.
- [Gluetun](https://github.com/qdm12/gluetun)
- [Qbittorrent port update](https://codeberg.org/TechnoSam/qbittorrent-gluetun-port-update) to automatically update the VPN port (which changes regularly).
- The [VueTorrent](https://github.com/gabe565/linuxserver-mod-vuetorrent) mod for a modern and intuitive UI.
Heres the system well set up:
![Picture](/img/serveex/qbit.svg)
## Configuration
::file-tree
---
tree:
/:
- docker:
- seedbox:
- qbittorrent:
- config/
- gluetun/
- compose.yaml
- .env
- "media # linked to Plex and Qbittorrent":
- "downloads/ # generic downloads, selected in settings"
- "movies/ # used for downloading movies"
- "tvseries/ # used for downloading TV shows"
---
::
::steps{level="3"}
### Create the downloads folder
If not already done, create the `downloads` folder under `/media`:
```bash [Terminal]
mkdir -P /media/downloads
```
### Deploy the stack
Open Dockge, click on `compose`, and name the stack `seedbox`. Paste the following config:
```yaml [compose.yaml]
---
services:
qbit:
image: ghcr.io/linuxserver/qbittorrent:libtorrentv1
container_name: qbittorrent
restart: unless-stopped
network_mode: service:gluetun
mem_limit: 4g
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.41.3
container_name: gluetun
restart: unless-stopped
mem_limit: 4g
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
```
::tip{icon=""}
✨ __Tip:__ Add the Watchtower label in each container to automate updates
```yaml [compose.yaml]
---
services:
qbittorrent:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
gluetun:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
```
::
### Configure the port-forwarding sync
Before editing the `.env` in Dockge, let's configure the download port update. Proton and most VPNs rotate the forwarding port, which must be communicated to Qbittorrent.
Weve added the mod `ghcr.io/t-anc/gsp-qbittorent-gluetun-sync-port-mod` to the container.
We now need to allow the mod to fetch info from Gluetun, which only allows encrypted communication via its API.
Open a terminal to generate the authentication key:
```bash [Terminal]
sudo docker run --rm qmcgaw/gluetun genkey
```
Note the key, then create the `/docker/gluetun` folder:
```bash [Terminal]
sudo mkdir /docker/gluetun
```
Create the `config.toml` file:
```bash [Terminal]
sudo nano /docker/gluetun/config.toml
```
Enter:
```toml [config.toml]
[[roles]]
name = "t-anc/GSP-Qbittorent-Gluetun-sync-port-mod"
routes = ["GET /v1/portforward"]
auth = "apikey"
apikey = "your_key_here" # key you just generated
```
Press :kbd{value="Ctrl+O"}, then :kbd{value="Enter"} to save, and :kbd{value="Ctrl+X"} to exit.
### Set your environment variables
In Dockge, fill in the variables in `.env`:
```properties [.env]
PUID=
GUID=
UI_PORT=
PR_KEY=
GSP_KEY= # the key you generated and entered in config.toml
ID=
PW=
```
Detailed info:
| Variable | Description | Example |
|------------|-------------|---------|
| `PUID` | User ID (`id yourusername`) | `1000` |
| `GUID` | Group ID (`id yourusername`) | `1000` |
| `UI_PORT` | Port for accessing the web UI | `5695` |
| `PR_KEY` | Private key from Proton | `buKsjNHLyzKMM1qYnzOy4s7SHfly` |
| `GSP_KEY` | Key you generated for port update | `MnBa47MeVmk7xiv` |
| `ID` | Qbittorrent UI login username | `user` |
| `PW` | Qbittorrent UI password | `password` |
### Done !
::
## Deployment
::steps{level="3"}
### Deploy the container
Once done, deploy the container.
::warning
**Startup logs will show a temporary password for `admin` user**
::
### Log in and secure your account
Login at `http://server-ip:5695` (or the port you set).
::caution
__If login fails:__ check your firewall rules.
::
Change your username and password in the "webui" settings.
### Done !
::
You're done! In Qbittorrent settings, under "Downloads", set `/media/downloads` as the default folder.
When adding a download, remember to select the proper directory so Plex can sync correctly (`/media/movies` or `/media/tvseries`). You can also automate this with categories and folders.
## Exposing the Web UI
::warning
Qbittorrent does not support multi-factor authentication. Exposing it to the internet may put your system at risk. Only do this if you use MFA via [Authentik](/serveex/advanced/authentik/). Otherwise, dont expose it with SWAG. Use a VPN like [Wireguard](/serveex/core/wireguard) instead.
::
To start downloads from outside your home, without a VPN, you can expose the Qbittorrent web UI.
::note
We assume you have the subdomain `seedbox.mydomain.com` with a `CNAME` pointing to `mydomain.com` in [DNS zone](/general/networking/dns). And that port `443` on your router is forwarded to your server in [NAT rules](/general/networking/nat), unless youre using Cloudflare Zero Trust.
::
::steps{level="3"}
### Add the seedbox network to SWAG
In Dockge, edit the SWAG compose file and add Gluetuns network:
```yaml [compose.yaml]
---
services:
swag:
container_name: # ...
# ...
networks:
# ...
- seedbox
networks:
# ...
seedbox:
name: seedbox_default
external: true
```
Click "Deploy" and wait for SWAG to fully initialize.
::note
We assume the network name is `seedbox_default`. You can confirm by checking the SWAG dashboard at http://server-ip:81.
::
### Create the subdomain.conf file
Now create/edit `seedbox.subdomain.conf`.
::tip{icon="" to="/serveex/files/file-browser-quantum"}
✨ __Terminal-free tip:__ use **File Browser** to edit files instead of using the terminal.
::
```bash [Terminal]
sudo nano /docker/swag/config/nginx/proxy-confs/seedbox.subdomain.conf
```
Paste the following config (check the port):
```nginx [seedbox.subdomain.conf]
## 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;
}
}
```
::tip{icon="" to="/serveex/advanced/authentik#protecting-an-app-via-reverse-proxy"}
✨ You can secure this app with Authentik by uncommenting the `authentik-server.conf` and `authentik-location.conf` lines. Dont forget to **create an app and provider in Authentik**.
::
Press :kbd{value="Ctrl+O"}, then :kbd{value="Enter"} to save, and :kbd{value="Ctrl+X"} to exit.
### Done !
::
Wait a few minutes, then go to `https://seedbox.mydomain.com`. You should land on the Qbittorrent interface.
And thats it! You now have a ready-to-use media center.
![Picture](/img/serveex/seed.svg)
@@ -0,0 +1,534 @@
---
title: Servarr for Plex
description: Automate media downloads with the Servarr stack, Radarr, Sonarr, Bazarr, Prowlarr, and Overseerr for movies and TV shows.
---
:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}
::note{to="/serveex/media/servarr"}
This is the Servarr stack wired up for Plex rather than Jellyfin, kept here for reference. See **Automation** for the same stack paired with Jellyfin, the recommended alternative since Plex isn't fully self-hosted (its own relay, a required account) and gates features behind a Plex Pass paywall.
::
[Servarr](https://wiki.servarr.com/) is a suite of applications developed to automate the downloading, updating, and management of media. Here, we'll focus on movies and TV shows with the goal of:
- Selecting a movie from a catalog through a web interface.
- Sitting back and enjoying it on Plex a few minutes later.
Simple.
![arr](/img/serveex/arr.svg)
Well start by deploying the stack and then proceed to configure each app and understand how they work.
## Install the Apps
::file-tree
---
tree:
/:
- docker:
- plex:
- compose.yml
- config/
- transcode/
- tautulli:
- config/
- sonarr:
- config/
- radarr:
- config/
- bazarr:
- config/
- prowlarr:
- config/
- overseerr:
- config/
- media:
- downloads/
- tvseries/
- movies/
- library/
---
::
::warning
__Warning:__ Make sure to follow this file structure carefully, especially the `media` folder. This folder must be mounted **exactly the same way** in both the _Qbittorrent_ compose file (`/your/path/media:/media`) and the _arr_ applications.
If not, the _arr_ apps may not recognize the path provided by Qbittorrent and will fail to create _hardlinks_.
Without hardlinks, the _arr_ apps will copy the files instead, **doubling the space used** on your storage.
::
::steps{level="3"}
### Deploy the stack
Open Docker and your `plex` stack. Modify the compose file as follows:
```yaml [compose.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
restart: unless-stopped
environment:
- PUID=1000
- PGID=1000
- TZ=Europe/Paris
volumes:
- /docker/bazarr/config:/config
- ${MEDIA_PATH}:/media
ports:
- 6767:6767
```
::tip{icon=""}
✨ Add the Watchtower label to each container to automate updates
```yaml [compose.yaml]
---
services:
plex:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
tautulli:
#...
labels:
- com.centurylinklabs.watchtower.enable=true
```
::
### Set your environment variables
Set your `.env` file with the variables below:
```properties [.env]
PUID=
GUID=
MEDIA_PATH=
```
| Variable | Description | Example |
|----------------|-------------------------------------------------------------------------------------------------|-------------|
| `PUID` | Set using your user info (check with `id yourusername`) | `1000` |
| `GUID` | Same as above | `1000` |
| `MEDIA_PATH` | Path to your media folder, here: `/media`. It must match the one used by Qbittorrent. | `/media` |
Deploy the stack.
### Done !
::
### Configure Radarr
Radarr queries your torrent sources and lets you define the type of releases to prioritize. It can also upgrade your movies if a better version is available.
Once deployed, visit `http://yourserverip:7878`.
::caution
__If it fails:__ check your firewall rules.
::
Create an account and choose *forms login*.
::steps{level="4"}
#### Add a *root folder*
- Go to *Settings > Media Management*.
- Add a root folder and select `/media/movies`.
::warning
__Warning:__ If you already have movies in `movies` from Qbittorrent, do not let Radarr add them. Radarr might modify them, which could stop seeding in Qbittorrent.
::
#### Configure Profiles
Go to *Settings > Profiles*. These are your default quality profiles. When you make a request, you're selecting one of these. For example, configure the “any” profile by unchecking everything except what is shown in the image and ordering them accordingly. This makes Radarr search for 4K REMUX first, then go down the list if unavailable.
![profiles_radarr](/img/serveex/radarr1.png)
#### Add Qbittorrent
In *Settings > Download Clients*, add Qbittorrent.
- Use your server IP as *Host* and port `5695` if following this guide.
- Provide your Qbittorrent *Username* and *Password*.
- Click *Test*.
- If successful, click *Save*.
#### Connect to Plex
Go to *Settings > Connect*, add a new connection and choose *Plex Media Server*.
- Use `plex` or your server IP for *Host*.
- Port: `32400`
- Click the blue "authenticate with Plex.tv" button and log into Plex.
- Press *Test*, then *Save* if successful.
#### Get API Key for Prowlarr and Overseerr
- Go to *Settings > General* and copy your *API Key* for later use.
#### Done !
::
### Configure Sonarr
Sonarr queries torrent sources and defines what kind of TV series releases to prioritize. It also upgrades series when better versions are available.
- Visit `http://yourserverip:8989`.
- Follow the same steps as for Radarr, but use `/media/tvseries` as the root folder.
::caution
__If it fails:__ check your firewall rules.
::
### Configure Prowlarr
Prowlarr acts as a proxy to manage your torrent indexers and link them to Radarr and Sonarr.
Go to `http://yourserverip:9696` and create an account, using *forms login*.
::caution
__If it fails:__ check your firewall rules.
::
::steps{level="4"}
#### Add an Indexer
- Go to the *Indexers* section and add your torrent indexer.
#### Add Radarr and Sonarr
In *Settings > Apps*, add Radarr and Sonarr with the following details:
- Prowlarr Server: `http://prowlarr:9696` (or use server IP)
- Sonarr / Radarr Server: `http://sonarr:8989` or `http://radarr:7878`
- API Key: use the one copied from Radarr and Sonarr.
- Click *Test*, then *Save* if all goes well.
#### Done !
::
### Configuring Bazarr
Bazarr is an app that automatically searches for the correct subtitles in your preferred languages for all the movies and TV shows added by Radarr and Sonarr.
Go to `http://yourserverip:6767`.
::caution
__If it fails:__ check your firewall rules.
::
Go to *Settings > General* and create a username and password using *forms login*.
::steps{level="4"}
#### Add a Language Profile
- In *Settings > Languages*, click the pink *Add new profile* button and name it.
- Click the pink *Add Languages* button and add your preferred languages, e.g., *French* and *English*.
- Save and exit.
- At the bottom of the screen under *Default Language For Newly Added Show*, check both boxes and select the profile you just created.
![Bazarr](/img/serveex/bazarr2.png)
- Save using the button at the top of the screen.
#### Add Subtitle Providers
- In *Settings > Providers*, add your preferred providers, for example:
![Bazarr](/img/serveex/bazarr.png)
- Save using the button at the top of the screen.
#### Add Radarr and Sonarr
- Go to *Settings > Sonarr*
- In *Address*, enter `sonarr` or your server's IP address.
- In *Port*, enter `8989`.
- In *API Key*, enter Sonarrs API key.
- Click *Test*.
- Save using the button at the top of the screen.
Repeat the same steps for Radarr.
#### Done !
::
### Configuring Overseerr
[Overseerr](https://overseerr.dev/) is an app that lets you browse a movie catalog and send requests to Sonarr and Radarr. Just browse movies or series, click *Request*, and the media will automatically be downloaded according to your Radarr or Sonarr settings. If the title hasnt been released yet, it will be downloaded automatically when available. This way, episodes of a series appear in Plex without any manual intervention.
![Overseerr](/img/serveex/overseerr.webp)
Go to `http://yourserverip:5055` and log in with your Plex account.
::caution
__If it fails:__ check your firewall rules.
::
::steps{level="4"}
#### Add Radarr
When prompted, add a Radarr server:
- Check *Default server*.
- __Server name:__ Radarr
- __Hostname or IP address:__ `radarr` or your server's IP
- __Port:__ `7878`
- __API Key:__ Radarrs API key
- Click *Test* at the bottom.
If the test succeeds, continue filling in the fields:
- __Quality Profile:__ the one you configured (e.g., `any`)
- __Root Folder:__ the Plex folder. In our examples: `/media/movies`
- __Minimum Availability:__ `Announced`. This allows requesting unreleased content and downloads it upon release.
- Check all 3 boxes at the bottom.
- Save and continue.
#### Add Sonarr
Now do the same for Sonarr:
- Check *Default server*.
- __Server name:__ Sonarr
- __Hostname or IP address:__ `sonarr` or your server's IP
- __Port:__ `8989`
- __API Key:__ Sonarrs API key
- Click *Test* at the bottom.
If the test succeeds, continue filling in the fields:
- __Quality Profile:__ the one you configured (e.g., `any`)
- __Root Folder:__ the Plex folder. In our examples: `/media/tvseries`
- __Language Profile:__ `Deprecated`
- Check all 4 boxes at the bottom.
- Save and continue.
#### Done !
::
And thats it! Just request a movie or series, then check in qBittorrent or Radarr/Sonarr. Within a few minutes, your media will be available on Plex!
## Exposing Overseerr with SWAG
It can be useful to expose Overseerr if you want to send requests from outside your network without a VPN, or if you've shared your Plex library with others and want them to have Overseerr access.
::note
We assume you have the subdomain `films.mydomain.com` with a `CNAME` pointing to `films.fr` in your [DNS zone](/general/networking/dns). And that [unless youre using Cloudflare Zero Trust](/serveex/security/cloudflare), port `443` on your router is forwarded to port `443` on your server via [NAT rules](/general/networking/nat).
::
::steps{level="3"}
### Add Overseerr's network to SWAG
Go to Dockge, edit the SWAG compose file, and add the Overseerr network, which is the same as Plex (since its in the Plex stack):
```yaml [compose.yaml]
---
services:
swag:
container_name: # ...
# ...
networks: # Connects the container to a custom network
# ...
- plex # Name of the network declared in the stack
networks: # Defines the custom network
# ...
plex: # Name of the declared network
name: plex_default # Actual name of the external network
external: true # Indicates its an external network
```
Restart the stack by clicking “Deploy” and wait until SWAG is fully operational.
::note
Here we assume the Tautulli network is named `plex_default`. You can verify the connection works by visiting the SWAG dashboard at `http://yourserverip:81`.
::
### Create the subdomain.conf file
Create and edit the file `films.subdomain.conf`:
::tip{icon="" to="/serveex/files/file-browser-quantum"}
✨ __Tip:__ you can use **File Browser** to browse and edit files instead of using terminal commands.
::
```bash [Terminal]
sudo nano /docker/swag/config/nginx/proxy-confs/films.subdomain.conf
```
Paste the following:
```nginx [films.subdomain.conf]
## 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;
}
}
```
Press :kbd{value="Ctrl+O"}, then :kbd{value="Enter"} to save, and :kbd{value="Ctrl+X"} to exit.
### Done !
::
Wait a few minutes, then visit `http://films.mydomain.com` in your browser.
::caution
__If it fails:__ check your firewall rules.
::
And there you go, Overseerr is now publicly accessible!
@@ -0,0 +1,212 @@
---
title: Gitea
description: Install Gitea, a lightweight self-hosted Git service to manage your code repositories privately on your own server.
---
:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}
::note{to="/serveex/development/forgejo"}
This is an alternative to **Forgejo**, the community-run fork created after Gitea's governance moved to a for-profit company, a concern for a project people expect to stay FOSS.
::
[Gitea](https://about.gitea.com/) is a self-hosted DevOps platform that allows you to manage repositories much like GitHub, but on your own infrastructure.
![gitea](https://about.gitea.com/img/home-screenshot.png)
## Installation
::file-tree
---
tree:
/:
- docker:
- gitea:
- data/
---
::
::steps{level="3"}
### Deploy the stack
Open Dockge, click on `compose`, name the stack `gitea`, and paste the following content:
```yaml [compose.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
```
### Set your environment variables
Fill out the `.env` file with the required information, for example:
```properties [.env]
UID=1000
GID=1000
```
Deploy the container and go to `http://yourserverip:3333`. Your Gitea instance is now up and running!
### Done !
::
::caution
__If it fails:__ check your firewall rules.
::
## Exposing Gitea with Swag
The benefit of this setup is being able to access it remotely from any of your devices. To do so, well expose Gitea through Swag.
::note
__Prerequisite:__ We assume you have created a subdomain such as `gitea.yourdomain.com` in your [DNS zone](/general/networking/dns) with `CNAME` pointing to `yourdomain.com`, and [unless you're using Cloudflare Zero Trust](/serveex/security/cloudflare), you have already forwarded port `443` from your router to your servers port `443` in the [NAT rules](/general/networking/nat).
::
::steps{level="3"}
### Add Gitea's network to SWAG
In Dockge, go to the SWAG stack and edit the compose file by adding Gitea's network:
```yaml [compose.yaml]
---
services:
swag:
container_name: # ...
# ...
networks: # Connect the container to the custom network
# ...
- gitea # Name of the declared network
networks: # Define the custom network
# ...
gitea: # Name of the declared network
name: gitea_default # Actual external network name
external: true # Indicates it's an external network
```
::note
We assume the Gitea network name is `gitea_default`. You can verify connectivity by visiting the SWAG dashboard at http://yourserverip:81.
::
Redeploy the stack by clicking "Deploy" and wait until SWAG is fully operational.
### Create the subdomain.conf file
Inside the Swag folders, create the file `gitea.subdomain.conf`.
::tip{icon="" to="/serveex/files/file-browser-quantum"}
✨ __Tip:__ You can use **File Browser** to navigate and edit your files instead of using terminal commands.
::
```bash [Terminal]
sudo nano /docker/swag/config/nginx/proxy-confs/gitea.subdomain.conf
```
Paste the configuration below:
```nginx [gitea.subdomain.conf]
## 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;
}
}
```
Press :kbd{value="Ctrl+O"}, then :kbd{value="Enter"} to save, and :kbd{value="Ctrl+X"} to exit.
### Configure Gitea's domain
Now open the `app.ini` file from the container's file system:
```bash [Terminal]
sudo nano /docker/gitea/data/gitea/conf/app.ini
```
Then modify the server section with your domain information:
```properties [app.ini]
[server]
DOMAIN = gitea.yourdomain.com
SSH_DOMAIN = gitea.yourdomain.com
ROOT_URL = https://gitea.yourdomain.com/
```
Press :kbd{value="Ctrl+O"}, then :kbd{value="Enter"} to save, and :kbd{value="Ctrl+X"} to exit, then restart the container.
### Done !
::
And thats it! Gitea is now exposed to the web.
::tip{icon=""}
__Tip:__ You can protect this app natively via OIDC with [Pocket ID](/serveex/security/pocket-id) (register it as an OIDC client), or with Authentik by [following these instructions](https://docs.goauthentik.io/integrations/services/gitea/).
::