How to Replace Your Subscriptions with a Raspberry Pi

Summary: Replace subscriptions with a self-hosted Raspberry Pi home server

The video walks through building a local media server using a Raspberry Pi (setup focused on Pi 5) to host:

• Immich (photo backup/gallery)
• Jellyfin (media streaming, Plex alternative)
• Samba (file sharing so you can upload media via Finder/Explorer)
• Tailscale (VPN so you can securely access Immich/Jellyfin from anywhere)

---

Hardware + kit contents

• Uses a CanaKit bundle including:

  • Raspberry Pi board
  • 128GB SD card
  • Case
  • Heatsink + fan (cooling installed in the case)
  • Power supply
  • MicroSD USB reader

• User supplies:

  • Ethernet cable
  • External storage device (example used: 1TB Samsung external SSD)

---

Install Raspberry Pi OS Lite (from another computer)

Based on guidance from raspberrypi.com/software, the key setup steps are:

1. Insert microSD via USB reader.
2. Download/install Raspberry Pi Imager.
3. Select:
   • Pi model: Pi 5
   • OS: Raspberry Pi OS Lite (“other” list)
4. Configure:
   • Hostname (example: MediaPi; placeholders must be replaced later in commands)
   • Time zone + country
   • Username + password
   • Optional Wi‑Fi (tutorial prefers Ethernet for reliability)
5. Enable SSH with password authentication.
6. Flash the card (writes take ~10 minutes).

---

Physical assembly steps

• Install heatsink:
  • Remove protective film
  • Align using the small alignment element
• Install fan:
  • Follow the fan connector wiring/latch guidance
• Snap Pi into the case:
  • Align port cutouts
• Insert microSD:
  • Into the back panel slot
• Connect:
  • Power via USB‑C (port labeled “power”)
  • Ethernet to the network/router
• Connect external SSD to Pi:
  • Warning included: Formatting will delete all data on the drive

---

SSH configuration and system updates

Using terminal/command prompt:

• SSH into the Pi:
  • ssh <username>@<hostname>.local
  • Example shown: ssh tucker@mediapi.local
• Full system update:
  • sudo apt update && sudo apt full-upgrade -y
• Reboot:
  • sudo reboot
• Tip:
  • Use terminal up/down arrow to reuse previous commands

---

Validate timezone, confirm SD boot, and prepare the external SSD

Check/set timezone

• If needed:
  • sudo timedatectl set-timezone <zone>

Confirm SD boot with available space

• df -h

Reformat external SSD (explicit destructive steps)

1. List devices:
   • lsblk (identify the SSD name, e.g., sda)
2. Unmount partition:
   • sudo umount /dev/sda1
3. Wipe filesystem signatures:
   • sudo wipefs -a /dev/sda
4. Create new GPT partition table:
   • sudo parted /dev/sda script mklabel gpt
5. Create a single partition using 100% of disk:
   • sudo parted /dev/sda mkpart primary 100%
6. Create ext4 filesystem:
   • sudo mkfs ext4 -F /dev/sda1
7. Get partition UUID:
   • sudo blkid /dev/sda1
8. Create mount directory:
   • sudo mkdir -p /mnt/storage
9. Add to /etc/fstab using the UUID
   • Careful: no quotes around UUID
10. Mount all:
    • sudo mount -a

Verify and ensure persistence after reboot

• Check mounted free space:
  • df -h /mnt/storage
• Reboot → re-check:
  • reboot then run df -h /mnt/storage again

---

Ownership + directory layout for apps

• Set ownership so the non-root user can access storage:
  • sudo chown -R user:user /mnt/storage
• Create folders:
  • Two folders for Immich
  • Two folders for Jellyfin
• Verify structure:
  • find /mnt/storage -maxdepth 3

---

Install Docker safely + verify

• Strong warning: don’t blindly copy curl commands from random sources.
• Install Docker via the official Docker repository script.
• Add your user to the docker group:
  • sudo usermod -aG docker $USER
• Verify Docker:
  • docker run --rm hello-world
  • docker compose version

---

Install and run Immich (self-hosted photo system)

• Create workspace:
  • ~/immich
• Download with wget:
  • Immich repo/assets from GitHub
  • the .env file
• Edit .env:
  • Update timezone and other required variables (only a few lines; others left as-is)
• Start Immich stack:
  • docker compose up -d
• Check services:
  • docker compose ps
• Access in browser:
  • mediapi.local:2283

Notes:

• Setup is local (not inherently remote).
• Mobile app uses the same server URL with /api appended.
• Mentions 3-2-1 backup rule:
  • If this is your only backup plan, they recommend reconsidering backups (e.g., extra drive or offsite storage).

---

Install and run Jellyfin (media streaming)

• Create ~/jellyfin and prepare Jellyfin Docker Compose.
• Check docker-compose config:
  • Ensure user: 1000:1000 mapping works (use id -u / id -g if needed).
• Create required bind-mount directories:
  • Order matters to avoid permission/access issues.
• Troubleshoot kernel memory page size issue:
  • Check with getconf
  • If expected is 4096 but your system differs:
    1. Edit /boot/firmware/config.txt
    2. Add kernel parameter:
       • kernel=kernel8.img
    3. Reboot
    4. Re-validate with getconf and confirm containers stay up

Access:

• mediapi.local:8096

Initial setup steps:

• Language selection
• Admin account
• Add libraries:
  • Movies → media/movies
  • TV / Series → media/tv
• Leave remote connections enabled (per checkbox behavior described)
  • Actual remote access is handled later by Tailscale.

Performance/config instruction (critical):

• Disable hardware transcoding acceleration:
  • Set Hardware acceleration = None
• Reason: Pi lacks suitable video encoder/graphics hardware.

---

Add Samba file sharing (upload media without SSH)

• Install Samba:
  • sudo apt install -y samba samba-common-bin
• Validate config:
  • tail -12 /etc/samba/smb.conf
• Set Samba user password:
  • sudo smbpasswd
• Restart/enable service:
  • sudo systemctl restart smbd
  • sudo systemctl enable smbd

Mounting Samba share

• Windows
  • Access path: \\media-pi.local\media
  • Optionally map a drive (example: drive letter Z) to persist
• macOS
  • Finder → Command + K
  • Connect to: smb://media.pi.local
  • Authenticate with Samba credentials

Tutorial flow includes:

• Drag-and-drop a media file into the share
• In Jellyfin: run Scan all libraries
• Confirm the content appears (example: “Big Buck Bunny”)

---

Enable remote access securely with Tailscale (VPN)

• Install Tailscale via curl (installer detects the appropriate package).
• Start the client:
  • sudo tailscale up
• Concept reminder:
  • Tailscale provides stable addresses without complex port forwarding.

Key reminder:

• Disable key expiration on the Pi (default ~6 months) to prevent future connection failures.

Phone setup:

• Install Tailscale app on iOS/Android
• Log into the same account and enable VPN
• Allow VPN setup prompts on first iOS install

Validate from outside Wi‑Fi:

• Test app URLs:
  • Jellyfin: MediaPi:8096
  • Immich: MediaPi:2283

---

“Review/guide/tutorial” focus

This is primarily a step-by-step tutorial/guide (not product reviews), emphasizing:

• Guided installation/configuration of Immich + Jellyfin using Docker
• Detailed storage formatting and persistent mounts using UUID in fstab
• Samba for easy uploads
• Tailscale for remote access
• Practical troubleshooting for Jellyfin kernel page size and Pi transcoding limitations
• Backup guidance referencing the 3-2-1 rule

---

Main speakers/sources

• Speaker: Unspecified (tutorial narrator; repeatedly uses “I” and provides command examples)
• Sources referenced/used:
  • CanaKit (Raspberry Pi kit vendor)
  • raspberrypi.com/software
  • Docker (official installation approach)
  • Immich GitHub (downloads + docker-compose assets)
  • Tailscale (VPN installation and client setup)