Vargo Myaló

Config files and other READMEs for my server, Vargo. Instructions and other stuff are also included to document my experience.

Trivia: Myaló is a common way of saying "Brain" in Greek. Due to my fascination towards Greek mythology, everything related to the server has a Greek essence to it.

Contents

→ The Story
→ Pi Pictures
→ The Configuration
→ Services
→ Item Links

The Story

I always wanted to tinker with Raspberry Pis and other Single Board Computers (SBCs). Got an idea to make a server out of it cause why not. After going through various Pi models, I decided to get the Raspberry Pi 5 16GB version. Alibaba gave the cheapest option however the delivery date was too late, around 2-3 months 🥲 I couldn't wait that long, hence, bought it off a third-party website. Other components for the Pi were available in Amazon and were delivered within 2-3 days. I'll attach links at the end if someone wants to have a look at them.

P.S. - The Blog site for Vargo is up and can be viewed at Vargo Blog.

Some Pictures Of The Pi

The Configuration

## The Configuration After getting the Pi, I decided on what services to self-host. I didn't want to host any mediaserver because I have lots of subscriptions for watching movies, tv, anime, etc. (don't judge). Eventually, zeroed down to: - NextCloud (for files, images, etc.) - LinkWarden (bookmark manager) - VaultWarden (password manager) - Glance Dashboard (for viewing certain server & self-hosted services metrics) - Stirling PDF (pdf utils) - Mazanoke (image utils) - Portainer (for easier docker container management) - Speedtest Tracker (internet speed test)

Note - I'm exposing all my services to the internet via cloudflare tunnel. That enables me to access these services from anywhere in the world.

Services

NextCloud

I would say, setting up nextcloud was the most challenging considering it was my first time doing something like that. Eventually after slogging through the docs, reddit posts and some ChatGPT help, I was able to configure it to my taste. The docker-compose.yml file that I'm using for the service:

services:
  nextcloud:
    image: linuxserver/nextcloud:latest
    container_name: nextcloud
    environment:
      - PUID=${PUID}
      - PGID=${PGID}
      - TZ=${TIMEZONE}
    volumes:
      - /portainer/Files/AppData/Config/Nextcloud/Config:/config
      - /portainer/Files/AppData/Config/Nextcloud/Data:/data
    ports:
      - 5443:443
      - 8080:80
    restart: unless-stopped
    depends_on:
      - nextcloud_db
  nextcloud_db:
    image: linuxserver/mariadb:latest
    container_name: nextcloud_db
    environment:
      - PUID=${PUID}
      - PGID=${PGID}
      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
      - TZ=${TZ}
      - MYSQL_DATABASE=nextcloud_db
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=${DATABASE_PASSWORD}
    volumes:
      - /portainer/Files/AppData/Config/Nextcloud/DB:/config
    restart: unless-stopped

Rest of the configurations were done from the interface itself so I cannot include them here. The process is quite straightforward, so setting it up according to one’s preferences should not be a problem.

LinkWarden

After combing through the internet for a clean, simple yet elegant looking bookmark/article manager, I eventually found LinkWarden. I didn't configure LinkWarden much, just used the compose.yml from their docs. That seemed to work right out of the box. I just had to setup AUTH by myself. The docker-compose.yml file that I"m using for the service:

services:
  linkwarden:
    container_name: linkwarden
    image: ghcr.io/linkwarden/linkwarden:latest
    restart: unless-stopped
    volumes:
      - /app/linkwarden/data:/data/data
    environment:
      - DATABASE_URL=<postgres-database-url>
      - NEXTAUTH_SECRET=<sus-password>
      - NEXTAUTH_URL=http://localhost/api/v1/auth
    ports:
      - "port"
    networks:
      - linkwarden_net

  linkwarden-db:
    container_name: linkwarden-db
    image: postgres:17-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_USER=<user>
      - POSTGRES_PASSWORD=<password>
      - POSTGRES_DB=<db>
    volumes:
      - /app/linkwarden/pgdata:/var/lib/postgresql/data
    networks:
      - linkwarden_net

networks:
  linkwarden_net:
    driver: bridge

VaultWarden

Well, I always knew I wanted to host my own password manager because I am super forgetful. While searching the internet for a decent self-hosted password manager, I immediately stumbled upon VaultWarden and BitWarden. After searching around for other options, I figured vaultwarden was the best option. I just used the unmodified compose.yml from their github page which was by far the easiest to setup. The docker-compose.yml file that I'm using for the service:

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    ports:
      - "8280:80"
    environment:
      DOMAIN: "https://your.domain.com"
      SIGNUPS_ALLOWED: "true" # Change it to "false" after first sign up.
      WEBSOCKET_ENABLED: "true"
      ADMIN_TOKEN: "token"
    volumes:
      - ./data:/data

Glance Dashboard

One thing I noticed maximum server owners had was a really beautiful looking dashboard that contained various info for the services they are hosting. I wanted one too but couldn't find anything nice off the internet. After searching for a long time, I found this YouTube video and was instantly hooked on Glance. After spending a whole day in customizing the widgets and other stuff to my liking, I was finally satisfied with the setup shown in the image.

I am not going to include the docker-compose.yml file for this service in this README.md but will give a link to it: docker-compose.yml

Stirling PDF

I have to deal with PDFs more or less everyday due to university and my own work. Decided to self-host a PDF utility service that was feature-rich. Their 50+ PDF tools are more than enough for what I need daily. I used their docs to modify the compose file as needed and added AUTH to it so only verified users could use the service. The docker-compose.yml file for the service:

services:
  stirling-pdf:
    image: frooodle/s-pdf:latest
    container_name: stirling-pdf
    restart: unless-stopped
    ports:
      - "8088:8080"
    environment:
      - DISABLE_ADDITIONAL_FEATURES=false
      - SECURITY_ENABLELOGIN=true
      - SECURITY_LOGINMETHOD=normal
      - SECURITY_INITIALLOGIN_USERNAME=<initial_username>
      - SECURITY_INITIALLOGIN_PASSWORD=<initial_password> # Do change this afterwards!
      - LANGS=en_GB
    volumes:
      - ./data:/usr/share/stirling-pdf/config
      - ./pdfs:/usr/share/stirling-pdf/pdfs

Mazanoke

I wanted a simple yet useful self-hosted image compression service. Found Mazanoke from a reddit post and was instantly impressed by it's simplicity and beautiful interface. Used the basic compose.yml file from their github page and added AUTH to it so only verified users could use the service. The docker-compose.yml file for the service:

services:
  mazanoke:
    container_name: mazanoke
    image: ghcr.io/civilblur/mazanoke:latest
    ports:
      - "3474:80"

Speedtest Tracker

I didn't really need to host an internet speedtest tracker but I found this interesting hence I did. It is pretty lightweight too. The tracker seems to work properly and it has a few features that I found really nice. The customization process was tedious but it worked out well in the end. The docker-compose.yml file for this service:

version: "3.8"

services:
  db:
    image: postgres:17
    container_name: speedtest-tracker-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: <db>
      POSTGRES_USER: <user>
      POSTGRES_PASSWORD: <password>
    volumes:
      - speedtest-db:/var/lib/postgresql/data
    # healthcheck:
    #   test: ["CMD-SHELL", "pg_isready -U speedtest_tracker -d speedtest_tracker || exit 1"]
    #   interval: 5s
    #   timeout: 5s
    #   retries: 10

  speedtest-tracker:
    image: lscr.io/linuxserver/speedtest-tracker:latest
    container_name: speedtest-tracker
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
    ports:
      - "8080:80"     # Change
      - "8280:80"     # Them
    environment:
      PUID: 1000
      PGID: 1000
      TZ: ${TIMEZONE}
      APP_KEY: ${SUPER SECRET APP KEY}
      DB_CONNECTION: pgsql
      DB_HOST: db
      DB_PORT: 5432
      DB_DATABASE: <database>
      DB_USERNAME: <username>
      DB_PASSWORD: <db_password>
      SPEEDTEST_SCHEDULE: "0 */2 * * *" # (Cron job) Run a speedtest every 2 hours.
      SPEEDTEST_ON_START: "true" # Run a test when the container is started.
      APP_URL: <url>
      ASSET_URL: <could_be_same_url>
      DISPLAY_TIMEZONE: ${TIMEZONE}
    volumes:
      - /srv/speedtest/config:/config

volumes:
  speedtest-db:

Portainer

Managing docker containers via the command line is honestly a pain, hence, portainer.

Installed portainer by following the instructions in their docs - Portainer Installation Instructions

Paperless

Amongst document management system, paperless ngx shines bright. It was a no-brainer to self-host this too! With it's OCR capabilities and it's search on steroids, it is one of the most feature-rich service in my self-hosted services drawer. The docker-compose.yml for paperless is:

services:
  paperless:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    container_name: paperless
    restart: unless-stopped
    depends_on:
      - db
      - redis
    ports:
      - "8080:80"
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=TIMEZONE
      - PAPERLESS_TIME_ZONE=TIMEZONE
      - PAPERLESS_DBHOST=DB_HOST
      - PAPERLESS_DBPORT=DB_PORT
      - PAPERLESS_DBNAME=DB
      - PAPERLESS_DBUSER=USER
      - PAPERLESS_DBPASS=PASSWORD
      - PAPERLESS_REDIS=redis://redis:5330/0
      - PAPERLESS_CONSUMPTION_DIR=PATH # Give the path of the directory you want paperless to watch for files
      - PAPERLESS_CONSUMPTION_DIR_MONITOR=0 # Paperless polls instead of inotify monitoring
      - PAPERLESS_CONSUMPTION_DIR_RECURSIVE=1 # Read through nested folders
      - PAPERLESS_CONSUMER_RECURSIVE=true
      - PAPERLESS_OCR_MODE=skip # Skip if unable to OCR any document
      - PAPERLESS_OCR_SKIP_IF_OCR_FAILS=false
      - PAPERLESS_OCR_RETRY_ON_FAIL=false
      - PAPERLESS_CONSUMER_ENABLE_IMAGE_CONVERSION=true # Enables image pre-processing
      - PAPERLESS_CONSUMER_GS_OPTIONS=--continue-on-soft-render-error
      - PAPERLESS_CONSUME_COPY=true # If set to true, it copies files in the watch dir instead of moving them.
      - PAPERLESS_ALLOWED_HOSTS=PAPERLESS_URL
      - PAPERLESS_CSRF_TRUSTED_ORIGINS=PAPERLESS_URL_WITH_HTTPS
      - PAPERLESS_URL=PAPERLESS_URL
      - PAPERLESS_CONSUMER_POLLING=1
      - PAPERLESS_CONSUMER_POLLING_SECONDS=15 # Check every 15 seconds for new file addition in watch dir
      - PAPERLESS_WORKER_TIMEOUT=3600  # 1 hour
      - PAPERLESS_WORKER_SOFT_TIME_LIMIT=3500 # 58 minutes 20 seconds

    volumes:
      - /opt/paperless/data:/usr/src/paperless/data
      - /opt/paperless/media:/usr/src/paperless/media

  db:
    image: postgres:16-alpine
    container_name: paperless-db
    restart: unless-stopped
    environment:
      - POSTGRES_DB=DB
      - POSTGRES_USER=USER
      - POSTGRES_PASSWORD=PASSWORD
      - TZ=TIMEZONE
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U paperless -d paperless || exit 1"]
      interval: 5s
      timeout: 5s
      retries: 20
    volumes:
      - paperless-pg:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    container_name: paperless-redis
    restart: unless-stopped
    command: ["redis-server","--appendonly","yes"]
    healthcheck:
      test: ["CMD","redis-cli","ping"]
      interval: 5s
      timeout: 3s
      retries: 20
    volumes:
      - paperless-redis:/data

volumes:
  paperless-pg:
  paperless-redis:

One thing to be noted is, I've set paperless to watch a specific folder in nextcloud for consumption. Hence, whenever I upload a document in that particular folder, paperless consumes the file and archives it.

ConvertX

With the frequent need for a secure, easy to use file conversion service, I wanted to host mine. With over 1000+ file type conversion support, ConvertX was my choice. It is light-weight, simple and secure. The docker-compose.yml for this service:

# docker-compose.yml
services:
  convertx:
    image: ghcr.io/c4illin/convertx
    container_name: convertx
    restart: unless-stopped
    ports:
      - "53400:3000"
    environment:
      - TZ=TIMEZONE
      - ALLOW_UNAUTHENTICATED=false
      - ACCOUNT_REGISTRATION=false
      - AUTO_DELETE_EVERY_N_HOURS=24
      - HIDE_HISTORY=false
      - JWT_SECRET=generate_your_own_token # will use randomUUID() if unset
      # - HTTP_ALLOWED=true # uncomment this if accessing it over a non-https connection
    volumes:
      - ./data:/app/data
      - ./bin/soffice:/usr/local/bin/soffice:ro
      - ./bin/libreoffice:/usr/local/bin/libreoffice:ro
      - ./bin/loffice:/usr/local/bin/loffice:ro

Item Links

→ Rasberry Pi 5 (16GB) - Amazon
→ Rasberry Pi M.2 Hat - Amazon
→ Rasberry Pi 27W Power Supply - raspberrypi.com
→ Rasberry Pi 5 Active Cooler - Amazon
→ Crucial P310 1TB M.2 2230 SSD - Amazon