My Humble Home Lab Self-Hosted Setup
My Humble Home Lab Self-Hosted Setup
Introduction
Building a home lab is more than just a hobby—it’s a journey into the heart of DevOps and infrastructure management that gives you complete control over your digital environment. When I started my self-hosted journey in September last year, I was looking for a way to consolidate my media consumption, experiment with infrastructure management, and create a learning environment that would challenge my technical skills.
The beauty of a humble home lab setup lies in its accessibility. You don’t need enterprise-grade hardware or a massive budget to create something powerful and educational. My setup, which cost around $500, demonstrates that with careful component selection and thoughtful architecture, you can build a versatile self-hosted environment that serves multiple purposes—from media streaming to DNS management and custom TV channel creation.
This comprehensive guide walks through my specific setup, explaining not just what I built, but why I made each choice and how you can replicate or adapt it for your own needs. Whether you’re a DevOps professional looking to experiment with infrastructure concepts, a media enthusiast wanting to take control of your content, or someone interested in learning about self-hosting, this setup provides a solid foundation that’s both practical and educational.
Understanding My Setup
My home lab centers around a Beelink mini PC as the primary workhorse, complemented by external storage for media, a Raspberry Pi for specialized tasks, and a carefully chosen software stack that maximizes the capabilities of this modest hardware. The Beelink N150 with 16GB RAM provides the processing power needed for media transcoding and multiple services, while the two 14TB WD Elements drives offer ample storage for my growing media library.
The software stack includes Ubuntu as the base operating system, Jellyfin for media management and streaming, Pi-hole for network-wide ad blocking and DNS management, and Tunarr for creating custom TV channels. This combination transforms a simple mini PC into a multifunctional server that handles entertainment, network security, and content creation.
The Raspberry Pi Zero 2W serves as a backup DNS server, adding redundancy to the network infrastructure and providing a platform for learning about ARM-based computing and lightweight services. The entire setup is designed with energy efficiency in mind—both devices consume minimal power while providing maximum utility.
What makes this setup particularly interesting is how it balances performance with practicality. The hardware choices were made with specific workloads in mind, and the software selection reflects a preference for open-source solutions that offer flexibility and control. This isn’t about having the most powerful setup possible; it’s about creating a functional, educational environment that demonstrates core DevOps principles like infrastructure as code, service orchestration, and network management.
Prerequisites
Before diving into the setup, it’s important to understand the prerequisites and considerations for a successful home lab deployment.
Hardware Requirements:
- Mini PC or small form factor computer with at least 8GB RAM (16GB recommended for media transcoding)
- Storage: Minimum 2TB for media library, expandable based on collection size
- Network: Gigabit Ethernet connection for reliable streaming and service communication
- Raspberry Pi (any model) for secondary services or backup functions
- External storage drives (USB 3.0 recommended for speed)
Software Requirements:
- Ubuntu 20.04 LTS or later (long-term support recommended for stability)
- Docker and Docker Compose for container management
- Basic understanding of Linux command line operations
- Network configuration knowledge (static IPs, port forwarding if needed)
Network Considerations:
- Static IP assignment for all servers to ensure consistent access
- Port forwarding configuration if accessing services externally
- VPN setup for secure remote access
- Quality of Service (QoS) settings to prioritize critical services
Security Prerequisites:
- Strong, unique passwords for all services
- SSH key-based authentication for server access
- Firewall configuration to limit exposure
- Regular security updates and patch management
User Permissions:
- Administrative access to the primary server
- Network administrator privileges for DNS and routing changes
- Basic understanding of service management and troubleshooting
Installation & Setup
Ubuntu Server Installation
Start by installing Ubuntu Server on your Beelink mini PC. Download the latest LTS version from Ubuntu’s official website and create a bootable USB drive using Rufus or similar tools.
1
2
3
# Boot from USB and follow installation prompts
# Choose minimal installation to save resources
# Configure static IP during installation or afterward
After installation, update the system and install necessary packages:
1
2
3
4
sudo apt update && sudo apt upgrade -y
sudo apt install -y curl wget git docker.io docker-compose
sudo systemctl enable docker
sudo usermod -aG docker $USER
Storage Configuration
Format and mount your external drives for media storage:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Identify drives
lsblk
# Format if necessary (backup data first)
sudo mkfs.ext4 /dev/sda1
# Create mount point
sudo mkdir -p /media/storage
# Mount drive
sudo mount /dev/sda1 /media/storage
# Add to fstab for automatic mounting
echo '/dev/sda1 /media/storage ext4 defaults 0 2' | sudo tee -a /etc/fstab
Docker Compose Setup
Create a docker-compose.yml file to manage your services:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
version: '3.8'
services:
jellyfin:
image: jellyfin/jellyfin:latest
container_name: jellyfin
restart: unless-stopped
ports:
- "8096:8096"
volumes:
- /media/storage/jellyfin/config:/config
- /media/storage/media:/media
environment:
- TZ=America/New_York
pihole:
image: pihole/pihole:latest
container_name: pihole
restart: unless-stopped
ports:
- "53:53/tcp"
- "53:53/udp"
- "80:80"
- "443:443"
volumes:
- /media/storage/pihole/etc-pihole:/etc/pihole
- /media/storage/pihole/etc-dnsmasq.d:/etc/dnsmasq.d
environment:
- TZ=America/New_York
- WEBPASSWORD=your_password_here
- DNS1=1.1.1.1
- DNS2=1.0.0.1
tunarr:
image: tunarr/tunarr:latest
container_name: tunarr
restart: unless-stopped
ports:
- "3000:3000"
volumes:
- /media/storage/tunarr/data:/app/data
environment:
- TZ=America/New_York
Raspberry Pi Setup
For the Raspberry Pi Zero 2W running as backup DNS:
1
2
3
4
5
6
7
# Install Raspberry Pi OS Lite
# Configure static IP
# Install dnsmasq for DNS service
sudo apt install -y dnsmasq
# Configure dnsmasq
sudo nano /etc/dnsmasq.conf
Add these lines to dnsmasq.conf:
1
2
3
4
5
6
7
port=53
domain-needed
bogus-priv
no-resolv
server=1.1.1.1
server=1.0.0.1
listen-address=192.168.1.XX
Configuration & Optimization
Jellyfin Configuration
Access Jellyfin through your browser at http://server-ip:8096 and complete the setup wizard. Configure your media libraries by adding folders from your mounted storage:
1
2
# Create library structure
mkdir -p /media/storage/media/{movies,tv_shows,music,photos}
In Jellyfin’s web interface, navigate to Dashboard > Libraries and add each media type. Configure transcoding settings based on your hardware capabilities—the Beelink N150 can handle basic transcoding, but hardware acceleration may be limited.
Pi-hole Configuration
Access Pi-hole’s admin interface at http://server-ip/admin and set up your network settings. Configure your router to use the Pi-hole as the primary DNS server, with the Raspberry Pi as secondary:
1
2
3
4
5
# Check Pi-hole status
pihole status
# Update blocklists
pihole -g
Tunarr Configuration
Tunarr requires some initial setup to create custom TV channels. Access it at http://server-ip:3000 and configure your content sources. This service aggregates content from various providers to create scheduled programming.
Usage & Operations
Daily Operations
Monitor your services using Docker commands:
1
2
3
4
5
6
7
8
# Check all containers
docker ps -a
# View logs for specific service
docker logs jellyfin
# Restart service if needed
docker restart jellyfin
Media Management
Organize your media files using consistent naming conventions for automatic library updates:
1
2
3
4
Movies/
Movie Title (Year)/movie.mkv
TV Shows/
Show Name/Season X/Show Name S01E01.mkv
Network Management
Monitor Pi-hole statistics and blocklists:
1
2
3
4
5
# View query statistics
pihole -c
# Check for updates
pihole -up
Backup Procedures
Implement regular backups for critical configurations:
1
2
3
4
5
6
7
8
9
10
#!/bin/bash
# Simple backup script
DATE=$(date +%Y%m%d)
BACKUP_DIR="/media/storage/backups"
# Backup Docker volumes
docker run --rm -v jellyfin_jellyfin:/data -v ${BACKUP_DIR}:/backup ubuntu tar cvf /backup/jellyfin_config_${DATE}.tar /data
# Backup Pi-hole configurations
sudo tar cvf ${BACKUP_DIR}/pihole_config_${DATE}.tar /etc/pihole /etc/dnsmasq.d
Troubleshooting
Common Issues
Jellyfin Not Accessible:
1
2
3
4
5
6
7
8
# Check container status
docker ps -a
# View logs for errors
docker logs jellyfin
# Verify port mapping
docker port jellyfin
Pi-hole DNS Issues:
1
2
3
4
5
# Test DNS resolution
nslookup google.com 127.0.0.1
# Check dnsmasq status
sudo systemctl status dnsmasq
Storage Mounting Problems:
1
2
3
4
5
# Check mount status
mount | grep /media/storage
# Verify fstab entry
sudo cat /etc/fstab
Performance Optimization
If experiencing slow media streaming, consider these optimizations:
1
2
# Adjust Docker memory limits
nano /etc/docker/daemon.json
Add this configuration:
1
2
3
4
5
6
7
8
9
{
"default-ulimits": {
"nofile": {
"Name": "nofile",
"Hard": 64000,
"Soft": 64000
}
}
}
Conclusion
Building this humble home lab setup has been an incredibly rewarding experience that combines practical utility with educational value. For around $500, I’ve created a self-hosted environment that handles media streaming, network security, and content creation—all while providing a platform for learning about DevOps concepts and infrastructure management.
The key takeaway from this setup is that you don’t need enterprise-grade hardware or a massive budget to create something powerful and educational. By carefully selecting components and optimizing your software stack, you can build a versatile home lab that serves multiple purposes and grows with your needs.
This setup has taught me valuable lessons about container orchestration, network management, and the importance of redundancy in infrastructure design. The Raspberry Pi backup DNS server, for instance, demonstrates how even modest hardware can provide critical redundancy. Similarly, the Docker Compose setup shows how containerization can simplify service management and deployment.
Looking ahead, there are numerous ways to expand this setup—adding more services like Home Assistant for smart home automation, implementing monitoring with Prometheus and Grafana, or exploring Kubernetes for container orchestration. The foundation is solid, and the learning opportunities are endless.
For anyone considering building their own home lab, I encourage you to start small and focus on what interests you most. Whether it’s media management, network security, or infrastructure experimentation, there’s a setup that fits your needs and budget. The journey of building and maintaining a home lab is as valuable as the end result, offering hands-on experience with concepts that are directly applicable to professional DevOps work.
Remember that the most important aspect of any home lab is not the hardware specifications or the number of services running, but the knowledge and experience you gain along the way. This humble setup has provided me with countless hours of entertainment, learning, and satisfaction—and it can do the same for you.