guides/docs/selfhosting/template.mdx

---
title: Template
description: A guide on using my template Docker Compose file.
keywords: [viren070, guides, viren070's guides]
---

# Template

This guide will show you how to use my template Docker Compose file to quickly deploy services.

Having followed my previous guides, you should have a basic understanding of how to deploy services with Docker Compose.
This section will focus on using [my template `compose.yaml`](https://github.com/Viren070/docker-compose-vps-template).

## What is it for?

The "template" makes use of a Docker Compose project and its [include](https://docs.docker.com/reference/compose-file/include/) feature to
allow you to easily use and maintain a large number of services.

Each individual app has its own `compose.yaml` file, which will usually have its own `.env` file for configuration,
and then the main `compose.yaml` file **includes** all of them. Each individual app will also have its own [`profile`](https://docs.docker.com/compose/how-tos/profiles/).

The `.env` files handle most of the configuration for the services, which means you usually don't have to ever edit the `compose.yaml` file itself,
just the documented `.env` files.

This means that when using the compose project, it counts as one single file with all the services in it. This makes it easy
to reference other containers, and not having to deal with multiple networks, etc.

This `compose.yaml` uses [Traefik](https://traefik.io) as a reverse proxy to route traffic to the correct service.
All our services are put behind Traefik, which allows us to access all services on the same port (80/443) and Traefik will route the traffic to the correct service.
This means that port 80 and 443 are the only ports that need to be open on your server.

We use Authelia as an authentication service, which allows us to protect our services. Authelia is not applied
to every single service, but only to the ones that require authentication. This is done through Traefik labels.
I will discuss how to add Authelia to a service later on.

A quick summary of what is included in this template is:

- Default server management services
- Stremio related services
- Debrid media server services
- Seanime
- Minecraft server
- Plausible analytics
- Vaultwarden
- SearXNG
- Zipline

<details>
<summary>What is the full list of services that are available in the template?</summary>
  <div>

    [Traefik](https://github.com/traefik/traefik) is included as our reverse proxy. It is used to route traffic to the correct service. It means that you can access all services on the same port (80/443) and Traefik will route the traffic to the correct service.
    It also allows for automatic SSL certificate generation using Let's Encrypt, which is required for Stremio addons as Stremio requires HTTPS to install addons.

    Authelia is included for authentication.

    To help with managing the server, the following services are included:

    - [Dozzle](https://github.com/amir20/dozzle) - A simple real time log viewer for docker containers with a web based UI.
    - [Watchtower](https://github.com/containrrr/watchtower) - Automatically update your Docker containers to the latest version.
    - [Uptime Kuma](https://github.com/louislam/uptime-kuma) - A self-hosted monitoring tool for your services.
      - This is useful for monitoring the status of your services and receiving alerts. You do have to set up your services manually, but this can be done through the web interface.
    - [Dash.](https://github.com/MauriceNino/dashdot) - A simple dashboard to monitor your server.
    - [Honey](https://github.com/dani3l0/honey) - Beautiful, customisable, startpage for your server to access all your services.

    <details>
    <summary>Stremio Addons and Utilities</summary>
    <div>

        - [AIOStreams](https://github.com/Viren070/AIOStreams)
        - [AIOStremio](https://github.com/Viren070/AIOStremio)
        - [Comet](https://github.com/g0ldyy/comet)
        - [MediaFusion](https://github.com/mhdzumair/MediaFusion)
        - [StremThru](https://github.com/MunifTanjim/stremthru)
        - [Stremio-Jackett](https://github.com/aymene69/stremio-jackett)
        - [Jackettio](https://github.com/arvida42/jackettio)
        - [EasyNews+](https://github.com/sleeyax/stremio-easynews-addon)
        - [MediaFlow Proxy](https://github.com/mhdzumair/mediaflow-proxy)
        - [Catalog Providers](https://github.com/redd-ravenn/stremio-catalog-providers)
        - [TMDB Addon](https://github.com/mrcanelas/tmdb-addon)
        - [Stremio Trakt Addon](https://github.com/redd-ravenn/stremio-trakt-addon)
        - [Stremio Catalog Addon](https://github.com/redd-ravenn/stremio-catalog-providers)
        - [OMG TV Stremio Addon](https://github.com/mccoy88f/OMG-Premium-TV/blob/main/README-EN.md)
        - [Stremio Server](https://github.com/Stremio/server-docker)
          - This is the official Stremio server docker image. This handles the downloading and transcoding of streams. This is useful if you use Stremio on devices
            that don't have a server bundled with it, like on iOS on Stremio Web. It will allow you to stream torrents on those devices. Debrid streams may not be transcoded on all clients, however.
        - [Addon Manager](https://github.com/redd-ravenn/stremio-addon-manager)

    </div>
    </details>

    <details>
    <summary>Debrid Media Server</summary>
    <div>
        :::danger
        These services require a lot of work to set up, and documentation for it is not finished yet, I suggest only using
        this template as a reference
        :::

        - [Wests Scripts](https://github.com/westsurname/scripts)
          - Includes blackhole, repair, plex requests, plex watchlist.
        - [Radarr](https://github.com/Radarr/Radarr)
        - [Sonarr](https://github.com/Sonarr/Sonarr)
        - [AutoSync](https://github.com/Pukabyte/AutoSync)
        - [Recyclarr](https://github.com/Recyclarr/Recyclarr)
        - [Plex](https://github.com/plexinc/pms-docker)
        - [Zurg](https://github.com/yowmamasita/zurg)
        - [RClone](https://github.com/rclone/rclone)
        - [Jellyfin](https://github.com/jellyfin/jellyfin)
        - [JellySeer](https://github.com/fallenbagel/jellyseerr)
        - Plex
        - Overseerr
        - Tautulli
        - Kometa

    </div>
    </details>

    <details>
    <summary>Indexers and Utilities</summary>
    <div>

      - [Prowlarr](https://github.com/Prowlarr/Prowlarr)
      - [Jackett](https://github.com/Jackett/Jackett)
      - [NZBHydra2](https://github.com/theotherp/nzbhydra2)
        - This is an indexer for NZB indexers. Which is mostly useful for Torbox users with the BYOI feature.
      - [Zilean](https://github.com/iPromKnight/zilean)
        - This is a [DMM](https://debridmediamanager.com) scraper.
      - [FlareSovlerr](https://github.com/FlareSolverr/FlareSolverr) / [Byparr](https://github.com/ThePhaseless/Byparr)
        - Useful for bypassing Cloudflare's anti-bot protection for scraping purposes.
      - [Cloudflare Warp](https://github.com/cmj2002/warp-docker)
        - This is a Cloudflare Warp client. It allows you to bypass blocks. For example, Torrentio blocks requests from some VPS providers (like Oracle Cloud).
          In this case, you can use Cloudflare Warp to proxy your requests through it which can be used for AIOStreams, Prowlarr, etc.
      - Gluetun
      - Tweakio
        - A torrentio indexer built to work with the *arrs.
      - Torbox Manager
    </div>
    </details>

    This template also includes other applications:

    - [Seanime](https://github.com/5rahim/seanime) - Beautiful open-source media server with a web interface and desktop app for anime and manga.
    - [SearXNG](https://github.com/searxng/searxng) - Privacy-respecting metasearch engine.
    - [Plausible Analytics](https://github.com/plausible/analytics/) - Simple, privacy-friendly and open-source web analytics. (Used on this site)
    - Minecraft server
    - [Vaultwarden](https://github.com/dani-garcia/vaultwarden) - An unofficial Bitwarden compatible server written in Rust.

  </div>
</details>

## Customising the template

The template is designed to be easily customisable. You can add your own services, remove services, and modify the configuration of the services.

My compose.yaml makes use of profiles to make it easier to deploy only specific services.
Each individual service has its own profile, so seanime has a profile called `seanime`, and so on.

The individual profiles are simply the names of the folder names in the `apps` directory.

As every single service has a profile, you must define a profile, either in the `COMPOSE_PROFILES` environment variable or through the `--profile` flag when running the `docker compose` command.
Otherwise, no services will be started.

However, there is a 'required' profile which includes Traefik and Authelia, which is required for external access to the services.

After you have chosen which profiles you are going to use, keep them in mind, as you will now need to fill in
the .env file with the necessary environment variables.

Other than manually adding profiles one by one, you could just use `all` as your profile and modify the root `compose.yaml` file and remove the compose.yaml from the include list for the services you don't want to use.

## Setup

### Requirements

- A server with Docker installed per https://get.docker.com/. (Other methods like snap are not recommended).
- A domain with name servers preferably changed to Cloudflares.
  - You may use free subdomains from services like [DuckDNS](https://www.duckdns.org/), [Afraid.org](https://freedns.afraid.org/) or [No-IP](https://www.noip.com/), but I recommend using a domain you own.
    :::note
    Should you choose to use these free services, you most likely will not be able to change name servers. This means
    you will have to manually create DNS records for each subdomain you want to use.
    :::
- Ports 80 and 443 open on your server. This is required for Traefik to work correctly.
  :::tip
  If you are using Oracle Cloud, you can follow [these steps](/selfhosting/oracle#opening-ports) to open the ports.
  :::

### Steps

1. Connect to your server, typically done using the following command, replacing `your-server-ip` with your server's IP address:

   ```bash
   ssh ubuntu@your-server-ip
   ```

   :::tip
   If you are using a different user, you should change the `ubuntu` part of the command to your username.
   :::

2. The first step is to download the template, preferably to `/opt/docker`, using the following commands:

   ```bash
   cd /opt
   ```

   ```bash
   git clone https://github.com/Viren070/docker-compose-vps-template.git docker
   ```

   ```bash
   cd docker
   ```

   :::tip
   You can change the permissions of the `/opt/docker` directory to your user using the following command:

   ```bash
   sudo chown $(id -u):$(id -g) -R /opt/docker
   ```

   This will allow you to edit files in the directory without needing to use `sudo`.

   :::

3. You can now confirm that the files have been downloaded by running the following command:

   ```bash
   ls -a
   ```

   You should see the the apps and data directories as well as the "root" `compose.yaml` file and the `.env` file.

4. Next, you should edit the `.env` files to fill in the necessary environment variables. I'd recommend that you start with the root `.env` file only.

   There are many ways to fill these values in, you could:

   - use a CLI text editor like `nano` or `vim` to edit the file directly through the terminal.
     ```
     nano .env
     ```
   - Use VS Code to edit the file directly on the server using the `Remote - SSH` extension. (**recommended**)

     1. Install the `Remote - SSH` extension in VS Code.
     2. Open the command palette (Ctrl + Shift + P) and type `Remote-SSH: Connect to Host...`.
     3. Enter the SSH connection string for your server (e.g. `ubuntu@your-server-ip`).
     4. Once connected, navigate to the `/opt/docker/apps` directory (`Ctrl + K` + `Ctrl + O` / `File` > `Open Folder...`).
     5. You will be able to see all the files and folders in the sidebar. Edit the `.env` files for each service from here
        by simply clicking on them and then editing them. You can also use the terminal in VS Code to run commands on the server.
        Make sure to save the files after editing them. (`Ctrl + S` / `File` > `Save`).

   - Use XPipe as a remote file explorer and then use your preferred text editor to edit the files. (**also recommended**)

     1. Download and install XPipe from [here](https://xpipe.io/download).
     2. Open XPipe and click on the `+` button to add a new connection.
     3. You can either let XPipe search automaticallly using the SSH config files or manually add a Remote Host connection.
     4. After adding the connection, you can go to the file browser tab on the right (or `Ctrl + 2`) and navigate to the `/opt/docker/apps` directory.
     5. You can then right click on the `.env` file and select `Open with...` and select your preferred text editor.
     6. After editing the file, make sure to save it.

   - Edit all the files locally (so clone the repository to your local machine first) using your preferred method
     and then upload them to your server using `scp`.

   :::info
   You should only fill in the environment variables for the services you are going to deploy.
   If you add a profile, the full set of environment variables for each app under that profile will be required.
   :::

5. After filling in the root .env, you should start the 'required' profile, this allows you to check that Traefik and Authelia are working correctly.

   ```bash
   docker compose --profile required up -d
   ```

   This will start the Traefik and Authelia services. You can check the logs for any errors by running:

   ```bash
   docker compose --profile required logs -f
   ```

6. You can then start adding and configuring more services, either by adding more profiles or using the 'all' profile and manually removing the compose files you don't want to use from the
   `include:` section of the root `compose.yaml` file. Make sure to fill in any `.env` files for the other services if they exist within the folder for that app.

7. If you are not using cloudflare-ddns (which automatically creates the DNS records), you should ensure that for every hostname in the root `.env` files, you have a DNS `A record` handling it pointing it to your servers **public IP**.
   :::warning
   If you are using Cloudflare, you should disable the proxy (orange cloud) for the DNS record. This is because Traefik needs to connect directly to your server.
   :::
   :::tip
   You can create a wildcard DNS by using an A record with `*` as the subdomain. e.g. `*.yourdomain.com`. This will allow you to use any subdomain while only
   needing to create one DNS record.

   However, this can cause issues and will cause any subdomain to be routed to your server.
   For example, if you're running a minecraft server, it will mean that any subdomain will be routed to your server.
   :::

8. After you have filled in the environment variables, you can now deploy the services. You should make sure you defined the `COMPOSE_PROFILES` environment variables
   as this will determine which profiles are started. If you did not set it, no services will be started.

   Then, you can run the following command:

   ```bash
   docker compose up -d
   ```

- You can also specify the profiles through the `--profile` flag, e.g.
  ```bash
  docker compose --profile required --profile aiostreams up -d --force-recreate
  ```

9. After running the command, it may take some time for the services to start up. Once it is done, you should be able to access them at the hostnames that are defined in
   the root `.env` file.