Home Server

Self hosted home server with multimedia, IoT, firewalls, among other applications

8 Aug 2025
⌘
14 min read

Table Contents

1. Preparation
2. Hardware
2.1 My PC
2.2 Drive
3. OS
3.1 Installing Proxmox
3.2 After installation
3.3 Set up SMART
3.4 Setup IOMMU, SMPT, Security
3.5 Disk Partition
4. Security
4.0 Recommendations
4.1 Using Caddy
4.2 Cloudflare tunnel
4.3 Set Up a VPN
5. Applications
5.1 Immich and Audiobookshelf
5.2 Home Assistant
5.3 Adguard Home
5.4 Jellyfin
For NAS/Samba
Change DNS back
Paths
Enable Hardware acceleration
Jellyfin Settings
Jellyfin Setups (for linux server)
More Settings
File Path (media)
Send movies to server
Plugins
Theme
5.5 Navidrome
Add metadata to your music files
5.6 Glance
Update
Create
Conclusion

This is not really a tutorial as I will not explain all the details from toe to head, but can give you ideas if you will want to set up, what to avoid, which are my personal recommendations. This also serves as a way to organize my notes and rethink my ideas and make the decisions on my homelab project. I am not an expert in this area, so if you think something is not correct, please feel free to contact me.

My aim to do my homelab is not only to do a challenge and learn a lot, but also a necessity because of the nature to have really customized software and not depend on external servers and the will of the companies doing whatever they want with my information or deciding for me the UI and how their services should work.

1. Preparation

Questions I should ask myself before getting my hands dirty:

What’s on my server?
What applications do I run on my home server?
What OS am I using?
How do I automate deploying and provisioning?
How do I secure my services from unauthorized access?

Here is a video found intesting about homelab:

2. Hardware

2.1 My PC

I got a 6W low TDP mini PC with Proxmox. For the applications I will use it, I prepared for it with 8GB of RAM. For storage, I went minimal, with an SSD with 240GB for the OS and apps and 1TB old HDD for media files.

2.2 Drive

When choosing a drive, consider the following factors:

3.5” vs 2.5”: 3.5” is more reliable in general, can have more capacity, but consumes more power, more heat, and may be more noisy.
CMR drives are better (no matter whether they are 2.5 or 3.5 ones)
Warranty: May check for drives that have a 5-year warranty or more
Prefer drives with TLC or better NAND for endurance.
Check for support of TRIM, garbage collection, and ECC features.
Brands: It seems that people on the internet recommend these brands quite often –Seagate IronWolf, WD Red, Hitachi HGST
External Bay: In a mini PC, you may need an external bay because there is not space inside the case. Affordable external bays usually may have one or two slots. I got the Sabrent 2 bay
RAID: You may take into account setting up a redundant array of independent disks (RAID), for example, there are RAID 0, RAID 1, or unRAID.

Then you may think which filesystem to use for your server. Zfs is much more complicated for beginners. You need to do a lot of reading and while the out of box solution is fine, you need to modify some things for performance (such as a time). I would recommend using LVMs as they’re a lot easier to grasp and seem to work great out of the box.

Xpenology (synology clone) and Truenas (formerly Freenas), are 2 good options and both run on Proxmox.

3. OS

For the OS in my homelab computer, I choose Proxmox as it is a tailored version of Debian specifically doing server stuff. It is like Docker virtualization really efficient, is free. Also, it is easier to do backups.

There is also a website with some scripts for Proxmox, called ProxmoxVE (GitHub) that will make installing and setting up Proxmox and the applications you want much smoother.

The fundamental OS in many homelabs is a hypervisor. They allow budding sysadmins to set up nested, throwaway environments starting on just one piece of hardware (it doesn’t even need to be an enterprise-grade server). - Docker - ESXi - unRAID - Hyper-V - Proxmox - Linux KVM

3.1 Installing Proxmox

Before installing Proxmox, please go to the BIOS and check if the virtualization is enabled.

3.2 After installation

By default, the username and password are:
```
username: root
password: `password`
```
But you should change them after installation.
On the sidebar, click Updates on the second sidebar
Click refresh on the topleft of the updates windows
Disable enterprise version
1. go to Repositories under Updates
2. click add button
3. chose from Enterprise to no-subscription
5. Go back to the update and click refresh again.
6. Click Upgrade
After finishing the upgrade, click your machine and then click the reboot button.

3.3 Set up SMART

sudo smartctl --scan — list drives

# replace `sdX` with the sisk show in the scan.
# show SMART data for a disk
sudo smartctl --all /dev/sdX

# enable SMART if disabled
sudo smartctl -s on /dev/sdX

3.4 Setup IOMMU, SMPT, Security

Setup IOMMU — Used for passing the pcie interfaces to the VMs, for example to use a graphic card
1. In the shell nano /etc/default/grub
  1. change to GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on"
  2. save and exit
2. run sudo update-grub
3. run update-initramfs -u
4. reboot
set up SMPT to send email notifications
secure your server, partly following cj’s tutorial, like setting up two factor Auth, create a non-root user, disable password authentication for SSH…

3.5 Disk Partition

make partition on a second disk (not the one where is proxmox located) for easy backup, as the the main disk will be where the docker and the OS is.
List your disks:
```
fdisk -l
```
[note] that the name of the disk like sda may change after a reboot

wipe data on the second drive:

wipefs /dev/sda # check if the second drive is is called sda

erase the partitions inside the second disk

wipefs /dev/sda1    # Lists the filesystem, RAID, or partition-table signatures
wipefs -a /dev/sda1 # erase all signatures found
wipefs -a /dev/sda2
wipefs -a /dev/sda3

create partition with gdisk

start

gdisk /dev/sda

Partition table scan:
MBR: MBR only
BSD: not present
APM: not present
GPT: present

Found valid MBR and GPT. Which do you want to use?
1 - MBR
2 - GPT
3 - Create blank GPT

Your answer: 2 - GPT

Then type o, then y:

...
Your answer: 2 - GPT
Using GPT and creating fresh protective MBR.

Command (? for help): o

This option deletes all partitions and creates a new protective MBR.
Proceed? (Y/N): y

type n to add and press enter several times for add first sector and last sector:

Command (? for help): n
Partition number (1-128, default 1):
First sector (34-1465149134, default = 2048) or {+-}size{KMGTP}:
Last sector (2048-1465149134, default = 1465147391) or {+-}size{KMGTP}:
Current type is 8300 (Linux filesystem)
Hex code or GUID (L to show codes, Enter = 8300):

type w to write, then y:

Command (? for help): w

Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING
PARTITIONS!!

Do you want to proceed? (Y/N): y
OK; writing new GUID partition table (GPT) to /dev/sda.
The operation has completed successfully.

list all the disks, the best way to refer to disks:
```
ls -la /dev/disk/by-id/
```
copy the partition that is related to sda1, for example ata-XXXXXXXXX_XXXXXX-part1
add a file called fstab:
```
nano /etc/fstab
```

add this line on the last line, the mnt/ssd cand be also mnt/hdd

/dev/disk/by-id/ata-XXXXXXXXX_XXXXXX-part1 /mnt/ssd1 ext4 defaults,noatime,discard 0

check if it has been modified:
```
cat /etc/fstab
```

creat the ext4 partition:

mkfs.ext4 /dev/disk/by-id/ata-WD_MXXXXXXXXX_32UFF00ZS-part1

mount

mkdir /mnt/ssd
systemctl daemon-reload
mount -a

check if it is mounted

mount
...
...
/dev/sda1 on /mnt/ssd type ext4 (rw,noatime,discard) # it should be a line showing it is mounted

Install duf

apt install duf
duf   # it will print a really easy to read partition

4. Security

Something really crucial about home labbing is security. By default, the services from Google, Microsoft, and other big companies should do it for you, but here you should set up your own security measures. Fortunately, Proxmox and many apps have some security applied by default.

[!info] for more info about each of the software refer to 4.3 Networking and Security

4.0 Recommendations

Do NOT Expose Proxmox Web GUI Directly: Never forward port 8006 (Proxmox web interface) directly to the internet. This port should only be accessible from within your secure VPN connection.
Use SSH with Strong Authentication (Optional): If you need CLI access, use SSH over the VPN. Enable key-based authentication and disable password logins for extra security.
Dynamic DNS (DDNS): If your home IP address changes, set up a DDNS service. This gives you a consistent hostname to connect to your VPN endpoint.
Firewall Rules: Restrict access to the Proxmox management ports to VPN clients only. Block all other external access attempts.
Change the subnet: Alter default network subnets to reduce predictability.
Block countries you don’t live in: Geo-blocking to limit access from high-risk regions. But not really useful.
DNS protection: Use a 3rd party service like Cloudflare for DNS and DDoS protection. It provides DNS management, free SSL certificates, and firewall rules to block malicious traffic.

Here are some ways from accessing from outside, there isn’t the definite way to do it.

4.1 Using Caddy

Optionally combine with VPN or additional authentication for safer external access. Caddy can create CA certificates for us, by default will use let’s encrypt and zero SSL. It will challenge DNS/HTTPS to prove you are the owner, after it knows you are the true owner, caddy will send a cert sign request (CSR). All this is used automatically using the ACME protocol, it uses two Certificate authorities, if one of these doesn’t respond it will fall back to the second CA.

Configuration is both dynamic and exportable with Caddy’s API. Although no config files required, you can still use them; most people’s favorite way of configuring Caddy is using the Caddyfile. The format of the config document takes many forms with config adapters, but Caddy’s native config language is JSON. More info on caddy dir. There are three ways to configure caddy, the API, caddyfile, json config file. Is recommended to use API or json for dynamic services, like endpoints that need to programmatically change or modified.

4.2 Cloudflare tunnel

I found this short video from NetworkChuck quite informative:

There is another video from Lawrence Systems called Using Cloudflare Tunnels For Hosting & Certificates Without Exposing Ports On Your Firewall:

4.3 Set Up a VPN

There are many options for setting up a VPN for accessing your home server. One of the most popular is WireGuard, OpenVPN, or Tailscale.

WireGuard: Secure, fast, and lightweight. Run it on a dedicated VM, container, or router. Only the VPN port is exposed, and all Proxmox management traffic is encrypted.
OpenVPN: Robust, widely supported, and secure, but slightly more complex to set up than WireGuard.
Tailscale: Easy for beginners, uses WireGuard under the hood, and securely accesses your home network from anywhere without complex port forwarding. Many recommend running it in a container or on a separate device for stability and easier recovery.

5. Applications

For fast and easy installation, you can use Proxmox scripts to install it. After running the script, you can also make changes to customize your installation and allocate how many resources you want for it.

You can install an application like an VM (a complete OS inside Proxmox), as a Docker container, or as an LXC (Linux Container). Containers usually require much less RAM and CPU as they share resources, but some applications work better or need to be in their own OS, like Home Assistant. Most of the apps can easily be in containers.

Check what is running

pct list    # List All LXC Containers (CTs)
qm list     # List All Virtual Machines (VMs)

# Check for Running Services that aent on CTs or VMs
systemctl status tailscaled
ps aux | grep gimmich

5.1 Immich and Audiobookshelf

Immich is a open selfhost version of Google Photos and Audiobookshelf is a Audiobooks and Ebooks selfhost service. Here is a simplified way how I installed it. The following is for Immich, but I also installed Audiobookshelf in the same way.

create dirs

cd /mnt/ssd/
mkdir -p /mnt/ssd/data/photos/upload
apt install tree

list with tree

tree
.
├── appdata
│  └── immich
├── data
│  └── photos
│      └── upload
└── lost+found

make some changes on the compose.yaml
1. change to the desire disk name

run docker compose

docker compose pull

check if everything was setup correct:

docker compose up -d
docker compose logs -f

5.2 Home Assistant

It is the defacto selfhost smart home that people usually install, and personally it is so configurable and have so many plugins, ways of tune it tha seems decades ahead of the comercial version from Google, Apple and Amazon. It even have bridging systems that let you add Apple Homekit devices from and to Home Assistant, making it possible to use IoT deiveces that will be impossible to use in the Apple ecosystem.

Install Home Assistant OS
1. Using the script from Proxmox VE Helper-Scripts
```
bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/vm/haos-vm.sh)"
```
2. Recommended hardware for HA OS is 2vCPU 4GB 32GB
3. prompt select
  1. <Yes>
  2. <Advanced>
  3. <Stable>
  4. Set ID: xxx
  5. (*) i440fx
  6. 32GB
  7. (*) 1 Write Through
  8. homeassistant
  9. (*) Host
  10. CPU Cores: 4
  11. RAM: 4096
  12. Bridge: (the one already filled)
  13. click ok on the next stuffs
Open HA
1. go to the VM home assistant and open the Console
2. In a new tab in your browser go to the address shown in the console under UPv4 adresses: http://<your-IPv4-ip>:8123 (be careful you should type http to work)
Create the Smart Home
1. Click Create My Smart Home
2. Put your details
3. location doesn’t really matter
Add TLS certificate
1. Install Studio Code Server from add-ons
2. Enter in Studio Code Server add-on and start it
3. Go to Studio Code Server
4. Add this to the configuration.yaml
```
http:
  use_x_forwarded_for: true
  trusted_proxies:
    - 127.0.0.1
```
5. Save the file
6. Restart HA
Connect the Zigbee dongle
1. Allow USB Passthrough in the Hardware panel in Proxmox
2. Reboot Home assistant.
3. Go to [Settings] > [Devices and Services]
  1. in the discovered section:
  2. Click on the Zigbee Home Automation integration and follow the instructions to complete the setup.
  3. (if it is the first time) Network Formation: [Create a network]

5.3 Adguard Home

Here are one of the tutorials I followed: NetworkCuck

Install with the script from VE Helper-scripts

bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/adguard.sh)"

go to the link shown on the terminal after installed
1. Next > Next
2. Sign up
3. Configure your devices
4. Tutorial Page
  1. To start using AdGuard Home, you need to configure your devices to use it. AdGuard Home DNS server is listening on the following addresses:
```
- 127.0.0.1
- 192.168.0.87
...
```
Log In
1. Go to Settings > DNS settings
  1. Change the Upstream DNS servers to 1.1.1.1 or better go to the Adguard DNS list and choose for example https://dns.quad9.net/dns-query that is a DNS-over-HTTPS, also there is https://dns.cloudflare.com/dns-query
  2. Below on the Fallback DNS servers section add 1.1.1.1 and 8.8.8.8
  3. Go below and click [Test upstream] and if it is working click [Apply]
  4. Enable DNSSEC
Add custom list for blocking

5.4 Jellyfin

It is a less centralized and free version of Plex and many users have been transitioned from Plex, some helper docs from TechHutTV Github

Install with Proxmox VE Helper Scripts
privileged, For hardware acceleration need to have
set a root pass
DNS server IP: 8.8.8.8 (as it didnt work for me without)
Update it
```
apt update && apt upgrade -y
```

For NAS/Samba

You need cifs-utils if you want Jellyfin to access media stored on a network share using the SMB/CIFS protocol (such as Windows shares, Samba shares, or NAS devices).

Install
```
sudo apt install cifs-utils
```
Mount the network share. Use the mount command (with -t cifs) or add an entry to /etc/fstab.
```
sudo mount -t cifs //server/share /mnt/media -o username=youruser,password=yourpass
```
Point Jellyfin to the mounted folder:
- In the Jellyfin dashboard, add the mounted directory as a library.

Change DNS back

change the DNS back to the the default, under the DNS panel sets on the LXC CT
reboot the LXC

Paths

Add location config file. On the pve shell:
```
mkdir /etc/jellyfin/
```
ffmpeg path
```
/usr/lib/jellyfin-ffmpeg/ffmpeg
```

Enable Hardware acceleration

source from Jelyfin official hardware acceleration site

Selecting Appropriate Hardware
1. Internet Connection: At least 20mbps upload bandwidth for remote access
2. The following is a quick comparison on the quality between vendors on modern products.
  - Apple ≥ Intel ≥ Nvidia >>> AMD*
3. Not having a GPU is NOT recommended for Jellyfin, as video transcoding on the CPU is very performance demanding. HDR to SDR tone-mapping can make the situation even worse.
4. Server with Integrated Graphics
  - CPU:
    - Apple M series or newer
    - Intel Core i5-11400, Intel Pentium Gold G7400, Intel N100 (excluding Intel J/M/N/Y series up to 11th gen). Intel 7-10th gen CPUs with integrated graphics has been deprecated by Intel. Although they are working well nowadays, they may have problems in the future.
  - RAM: 8GB System RAM (Consider adding more on Windows 11)
  - Graphics: Intel UHD 710, Apple M series or newer. AMD is NOT recommended if you plan to use integrated graphics for Jellyfin.
5. Server with Dedicated Graphics
  - Intel Drivers are much easier to install on Linux, with many distributions including them by default.
  - If you are planning to use a dedicated graphics card (including upgrading an old system with a dedicated GPU), the following specs are recommended:
    - CPU:
      - = Intel Core i5-2300
      - = AMD FX-8100 (Geekbench 6 Multicore >=1500)
    - RAM: 8GB (4GB should be enough for a server running Linux without a GUI) Graphics: Intel Arc A series or newer, Nvidia GTX16/RTX20 series or newer (Excluding GTX1650), AMD is NOT recommended.
6. The CPU will be responsible for many tasks, notably Transcoding Audio and Decoding video in unsupported codecs
Using jellyfin-ffmpeg with Jellyfin is highly recommended, which has a -Jellyfin suffix in the version string.
```
/usr/lib/jellyfin-ffmpeg/ffmpeg
```
Configure & Verify Hardware Acceleration
1. There are some preparations that need to be done before enabling hardware acceleration. The specific configuration steps may vary between GPU vendors, installation methods, and operating systems.
2. On Linux you can check available GPU
  1. using the lspci command:
```
lspci -nn | grep -Ei "3d|display|vga"
```
  2. Or using lshw:
```
lshw -C display
```
Setting up on Intel GPU
1. On Linux there are two methods:
  1. QSV - Preferred on mainstream GPUs, better performance
  2. VA-API - Required by pre-Broadwell legacy GPUs, for compatibility

Jellyfin Settings

Playback
1. Transcoding
  1. Hardware acceleration: [intel]
    1. H264 for Intel GPU that supports QSV
    2. HEVC 10bit for 7th Gen Core, Apollo Lake, Gemini Lake (Pentium and Celeron) and newer
    3. VP9
    4. AV1
    5. HEVC 10bit
    6. VP9 10bit
    7. HEVC RExt 8/10bit
  2. Prefer OS native DXVA or VA-API hardware decoders
  3. Hardware encoding options
    1. Enable hardware encoding
      - allow Jellyfin to use Intel Quick Sync for encoding/transcoding)
    2. Enable Intel Low-Power H.264 hardware encoder
      - recommended for efficient H.264 transcoding
    3. [?] Enable Intel Low-Power HEVC hardware encoder
      - recommended for HEVC transcoding, but if you experience stuttering, try disabling it
  4. Encoding format options
    1. Decoding AV1 8/10-bit >= 11th Gen Core
    2. Encode AV1 8/10-bit
  5. [?] Enable VPP Tone mapping
    - Optional, Enable if you want Jellyfin to handle HDR to SDR tone mapping during transcoding. This can improve compatibility with non-HDR clients but may increase transcoding load.
  6. Tone-mapping Methods
    1. Hardware accelerated HDR/DV to SDR tone-mapping is supported on all Intel GPUs that have HEVC 10-bit decoding.

Jellyfin Setups (for linux server)

A 64-bit Linux distribution is required. Root permission is required.

Install the jellyfin-ffmpeg7 package. Remove the deprecated jellyfin meta package if it breaks the dependencies:
```
sudo apt update && sudo apt install -y jellyfin-ffmpeg7
```

Make sure at least one renderD* device exists in /dev/dri. Otherwise upgrade your kernel or enable the iGPU in the BIOS.

ls -l /dev/dri

# A correct Output will be something like:
total 0
crw-rw---- 1 root video 226, 0 Jul 5 09:06 card0
crw-rw---- 1 root _ssh 226, 128 Jul 5 09:06 renderD128

Add the jellyfin user to the render group, then restart jellyfin service:

sudo usermod -aG render jellyfin
sudo systemctl restart jellyfin

check if it correctly added

groups jellyfin

jellyfin : jellyfin video render # ouptut

Check the version of intel-opencl-icd thats the Linux distro provides:
```
apt policy intel-opencl-icd

# output
intel-opencl-icd:
  Installed: (none)
  Candidate: 22.xx.xxxxx-x
...
```
- If the version is newer than 22.xx.xxxxx just install it. Otherwise install from Intel compute-runtime repository:
```
sudo apt install -y intel-opencl-icd
```

Verify VA-API support inside the container (?)

sudo apt update
sudo apt install intel-media-va-driver-non-free

Direct link to LXC On Proxmox
1. Make sure your GPU is available as a DRI render device on the Proxmox host, e.g. /dev/dri/renderD128. If not, install the necessary drivers on the host.
2. On the Web Interface
  - (logged as root, run in a privileged LXC CT, Proxmox VE >= 8)
  1. [Resources Panel] (If you dont have device (dev0) and Device (dev1) then:
    1. [Add] > [Device Passthrough]
      - Be sure to set the correct GID via the advanced options of the dialog, e.g. 989 for the render group. GIDs can be looked up in /etc/group inside the LXC.
Check the group ID on the host for /dev/dri/renderD128:
```
ls -l /dev/dri
```
- If on the host it’s owned by video, you need to fix this inside the container. Inside the container, fix the group ownership:
```
sudo chown root:video /dev/dri/renderD128
sudo chmod 660 /dev/dri/renderD128
```
Monitor GPU Usage with intel_gpu_top (Linux Host)
```
sudo apt update
sudo apt install intel-gpu-tools
sudo intel_gpu_top
```
- Look for activity in the Video or VideoEnhance engines. Increased usage during playback means the iGPU is actively transcoding.

More Settings

After installing the Jellyfin, it’s important to configure it according to your specific needs and preferences. This includes setting up user accounts, organizing your media library, and adjusting streaming quality settings.

Users
1. Failed login tries before user is locked out: 5
2. Maximum number of simultaneous user sessions: 5

File Path (media)

Bind mount the media directory into the Jellyfin container or VM, Jellyfin needs access to the media files inside its container/VM filesystem.
1. Stop the Jellyfin container
```
pct stop <vmid>
```
2. create the directory /media inside the container:
```
cd /mnt/ssd/media
sudo mkdir movies
sudo mkdir
```
3. Change ownership of the whole media folder to jellyfin user and group
```
sudo chown -R jellyfin:jellyfin /media/movies
```
4. For LXC container, edit the container config file on the Proxmox host,
```
nano /etc/pve/lxc/<vmid>.conf
```
  1. add this line on the end of the .conf file
```
mp0: /mnt/ssd/media,mp=/media
```
    - This mounts /mnt/ssd/media from the host into /media inside the container.
5. Start, enter the container and check the mount
```
pct start <vmid>
pct enter <vmid>
ls /media
```

Send movies to server

using rsync
- note: by default macOS ship with an old version, update with
```
 brew install rsync
```
1. Test run to preview what will be transferred:
```
rsync -avh --progress --ignore-existing --dry-run /path/to/local/movies/ user@server:/media/movies/
```
  - Explanation of options:
    - -a : archive mode (recursive, preserves permissions, timestamps, symbolic links, etc.), it includes recursion -r
    - -v : verbose output (shows what is being transferred)
    - -h : human-readable numbers
    - --progress : shows progress during transfer
    - --ignore-existing : skip files that already exist on the server (won’t overwrite)
    - --dry-run : simulate the operation without making any changes (to check what would be copied)
2. Perform the transfer
  - Remove —dry-run to actually perform the transfer
```
rsync -avh --progress --ignore-existing /path/to/local/movies/ user@server:/media/movies/
```

through SCP

# for single files
scp /path/to/local/movie.mp4 <username>@<proxmox-ip>:/mnt/ssd/media/movies/

# for multiple files
scp -r ~/Movies/Series root@<ip>:/mnt/ssd/media/series/

SFTP (SSH File Transfer Protocol)
- using Filezilla
- Additional notes:
  - If your Proxmox server is behind a gateway or firewall, you might need to set up an SSH tunnel or port forwarding on your Mac using the ssh command to connect through the gateway first, then connect FileZilla to localhost on a forwarded port.
  - Ensure SSH/SFTP is enabled on your Proxmox server and that your user has permissions to write files.
1. Open FileZilla and set up a new connection:
  1. Go to File > Site Manager.
  2. Click New Site and name it (e.g., Proxmox).
  3. Click For Protocol, select SFTP - SSH File Transfer Protocol.
  4. In the Host field, enter the IP address or hostname of your Proxmox server.
  5. Set the Port to 22 (default for SSH/SFTP).
  6. Enter your username and password for the Proxmox server.
  7. Click Connect.
2. Transfer files:
  1. Once connected, your Computer’s local files appear on the left pane, and the Proxmox server files on the right.
  2. Drag and drop files from the left (local) to the right (Proxmox) pane to upload.
  3. The transfer progress will show, and files will appear on the Proxmox server once done.
Thought USB or Ethernet Cable

Plugins

Add repos:
1. Intro Skipper https://intro-skipper.org/manifest.json
2. Media Cleaner https://raw.githubusercontent.com/shemanaev/jellyfin-plugin-repo/master/manifest.json
3. Skin Manager https://raw.githubusercontent.com/danieladov/JellyfinPluginManifest/master/manifest.json
4. tmdb-trailers https://raw.githubusercontent.com/crobibero/jellyfin-plugin-tmdb-trailers/master/manifest.json
JellyScrub (not need anymore as it is now included in Jellyfin)
Intro Skipper
LDAP Auth
TheTVDB
Playback Reporting – Collect and show user play statistics
Trakt – Syncs watched episodes and movies
Fanart – Scrape poster images for movies, shows, and artists in your library.
Media Cleaner – Automatically delete played media files after specified amount of time.
Skin Manager
Merge Versions
OpenSubtitles
tmdb railers – Watch trailers from TMDb

Theme

General > Custom CSS code:

@import url("https://cdn.jsdelivr.net/gh/lscambo13/ElegantFin@main/Theme/ElegantFin-jellyfin-theme-build-latest-minified.css");

Click [Save]

for client-side implementation
1. Open Display tab in Settings.
2. Scroll down to find Custom CSS code box.
3. Paste the custom css in Custom CSS code box.
4. Click save.
Restart after installed the plugins

5.5 Navidrome

It is the selfhost version of Spotify, although you may find it less smart if you have been used Spotify or pther modern music apps, as it lacks those daily tailored copilation albums you are used, which you may discover new music. Navidrome is what music apps where 10 or 20 year ago, only having your music, it is static and you will need to actively add music on it, in contrast of modern modern music which you will passively discover and add music with one click in your phone. One of Navidrone pros is that you can choose any app that you like and is support it, so you dont stuck on the Navidrome webui, but can use the Submariner app on the laptop and Amperfy app on the phone.

Install with the community script

bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/navidrome.sh)"

On the proxmox shell
1. mount the disk where the music is
```
nano /etc/pve/lxc/209.conf
```
2. edit the file by adding where the disk is located
```
mp0: /mnt/disk/music-dir/,mp=/music
```
  - mp=media means where the dir of music will be shown in the navidrome LXC container
To change Navidrome music folder path. inside the LXC:
```
nano /etc/navidrome/navidrome.toml
```
1. Change it to your desired music directory path.
```
DataFolder = "/var/lib/navidrome"
MusicFolder = "/music"
```
Verify Permissions
- Ensure that the Navidrome user (often navidrome or root in LXC) has read access to the entire music directory. If not, you may need to adjust permissions:
```
sudo chown -R navidrome:navidrome /mnt/music
sudo chmod -R 755 /mnt/music # all the music folders should be 755
```

Add metadata to your music files

Use the desktop app MusicBrainz
Then trow your music into sidebar of the app
Check if the album have been scanned succesfully and added metadata correctly
- Usually if the album is shown full (yellow cd) then it will be fine.
- If not sometimes it will split the songs in different albums, then you should drag the song files missed from your pc folders directly into the album in the musicbrainz app.

5.6 Glance

Glance a self-hosted dashboard that puts all your feeds in one place, from Stocks, weather, to news feed from Hacker News, Sub Reddits, RSS and your stats from the apps of your homelab.

github
vid tutorial
Create RSS feed from newletter

Update

update glance file

cd /root/docker/glance/
nano glance.yaml

after edit the file

docker compose down
docker compose up -d
docker logs glance --tail 50

Create

Create the directories

mkdir -p /root/docker/glance/
cd /root/docker/glance/

Create the files

nano docker-compose.yaml
nano glance.yaml
ls   # check the files

Pull docker
```
docker compose up -d
``
```
Check if there are any errors
```
docker logs glance --tail 50
```
Location of config file
1. config/home.yml to configure the widgets or layout of the home page
2. config/glance.yml if you want to change the theme or add more pages
3. Other files you may want to edit
  1. .env to configure environment variables that will be available inside configuration files
  2. assets/user.css to add custom CSS

Conclusion