Author	Nejat Hakan
eMail	nejat.hakan@outlook.de
PayPal Me	https://paypal.me/nejathakan

Media Server Plex

Introduction

Welcome to the world of self-hosted media! This section introduces Plex Media Server, a powerful and popular application for organizing, streaming, and sharing your personal media collection – movies, TV shows, music, and photos. We'll explore what Plex is, why you might want to run your own instance instead of relying solely on cloud streaming services, understand its basic architecture, and define some core concepts you'll encounter frequently.

What is Plex

Plex is a global streaming media service and a client-server media player platform. At its heart, Plex allows you to organize your own digital media files (videos, music, photos) stored on one computer or device (the "server") and then stream them to various client devices (like smartphones, smart TVs, web browsers, game consoles) either on your local network or over the internet.

Think of it like building your own personal Netflix or Spotify, but populated entirely with your own media files. Plex automatically scans your media libraries, downloads rich metadata (like artwork, summaries, cast lists, music album info, artist bios), and presents everything in a beautiful, user-friendly interface across all your devices.

Key features include:

Media Organization: Automatically identifies and categorizes your media, fetching posters, plot summaries, cast info, ratings, subtitles, lyrics, and more.
Cross-Platform Streaming: Access your media from virtually anywhere using Plex apps available for a vast range of devices (iOS, Android, Roku, Apple TV, Fire TV, Smart TVs, Xbox, PlayStation, Web browsers, etc.).
Remote Access: Securely stream your media even when you're away from home.
Media Sharing: Share specific libraries or your entire collection with family and friends who have their own Plex accounts.
Transcoding: Automatically converts media files on-the-fly to a format compatible with the client device or to adjust for available bandwidth.
User Profiles: Create managed user accounts for family members (Plex Home) or share access with regular Plex accounts.
Metadata Management: Offers tools to correct mismatches or manually edit media information.
Plex Pass (Optional Subscription): Unlocks premium features like hardware-accelerated transcoding, mobile sync for offline viewing, live TV & DVR (requires tuner hardware), parental controls, trailers, music lyrics, and more. While not strictly necessary for core functionality, it enhances the experience significantly for many users.

Why Self-Host Plex

In an era dominated by subscription streaming services, why bother setting up your own media server? Self-hosting Plex offers several compelling advantages:

Ultimate Control: You own the media and the server. Your content won't suddenly disappear because a licensing deal expired. You decide what's available, how it's organized, and who can access it.
Privacy: Your viewing habits and media library details are primarily stored on your server, not centrally analyzed by a large corporation for advertising or other purposes (though some anonymized usage data is collected by Plex Inc., especially for account management and remote access). Using your own server significantly reduces the data footprint compared to purely cloud-based services.
Consolidation: Bring together media from various sources (DVD/Blu-ray rips, home videos, downloaded content, music library, photos) into one unified, accessible interface.
Customization: Tailor the server performance, library structure, and user access precisely to your needs. Integrate with other self-hosted tools for enhanced automation (*Arr stack, Tautulli - discussed later).
Offline Access: While cloud services require an internet connection, your Plex server primarily relies on your local network. Even if your internet goes down, you can usually still access your media on devices within your home network. With Plex Pass, you can even sync media to mobile devices for offline viewing on the go.
Cost-Effectiveness (Long Term): While there might be initial hardware costs and potentially a Plex Pass subscription, you avoid paying multiple monthly fees for different content services. If you already own the media, self-hosting can be cheaper over time.
Learning Experience: Setting up and managing a Plex server is a fantastic way to learn about networking, operating systems, file systems, media codecs, and server administration – valuable skills in many IT fields.

Plex Architecture Overview

Understanding the components involved is key to grasping how Plex works:

Plex Media Server (PMS): This is the core software you install on a computer, NAS (Network Attached Storage), or dedicated server within your home network. Its job is to:
- Scan your media folders.
- Identify media files and fetch metadata from online sources.
- Organize media into libraries.
- Manage user accounts and sharing permissions.
- Stream media files to client devices.
- Transcode media files when necessary.
- Communicate with Plex's central servers for account authentication and remote access facilitation.
Plex Clients: These are the apps you install on your playback devices (smart TV, phone, tablet, computer, streaming stick like Roku or Fire TV, game console). Their job is to:
- Connect to your Plex Media Server (either locally or remotely).
- Browse your libraries.
- Request media playback.
- Receive the media stream from the server and display it.
- Report playback status back to the server.
Plex Account (plex.tv): This is a free account you create on the Plex website (plex.tv). It serves several crucial purposes:
- Authentication: Both the server and clients use your Plex account to sign in and verify identity.
- Server Discovery: Helps your clients find your server, especially when accessing remotely.
- Remote Access Facilitation: When direct connection isn't possible, Plex Relay (a bandwidth-limited proxy service provided by Plex) can be used, mediated via your Plex account.
- Plex Pass Management: If you subscribe to Plex Pass, it's tied to your Plex account.
- Sharing: Sharing libraries with friends requires them to have their own Plex accounts.
Plex Relay: A service provided by Plex Inc. that acts as a proxy when a direct connection between your client and server cannot be established for remote access. This often happens due to network configurations like Carrier-Grade NAT (CGNAT) or restrictive firewalls. While convenient, Plex Relay connections are bandwidth-limited (typically 1 Mbps, or 2 Mbps for Plex Pass users), which is often insufficient for high-quality video streaming and usually results in transcoding to a lower quality. Achieving a direct remote connection is highly desirable for the best experience.

Interaction Flow (Simplified):

You add media files to folders on your server machine.
Plex Media Server scans these folders, identifies the media, fetches metadata, and adds it to your libraries.
You open a Plex client app on your phone.
The client app logs into your Plex account.
Through plex.tv, the client discovers the network address of your Plex Media Server.
The client connects directly to your server (if on the same network or if direct remote access is configured) or via Plex Relay.
You browse your library on the client and select a movie to play.
The client tells the server which movie it wants and its own playback capabilities (supported formats, screen resolution, available bandwidth).
The server checks if the movie file is directly compatible with the client (Direct Play). If yes, it streams the file directly.
If not compatible, the server transcodes the video and/or audio into a compatible format/quality on-the-fly and streams the converted version to the client.
The client plays the received stream.

Core Concepts

Familiarize yourself with these fundamental Plex terms:

Libraries: The primary way Plex organizes your media. You create libraries based on media type (e.g., "Movies," "TV Shows," "Music," "Home Videos"). Each library points to one or more folders on your server's storage where the corresponding media files reside.
Metadata: The information about your media files. This includes titles, summaries, posters, cast/artist information, album covers, ratings, release dates, genres, etc. Plex uses "agents" to automatically download metadata from online databases (like The Movie Database, The TVDB, MusicBrainz).
Scanning: The process where Plex Media Server examines the folders associated with your libraries to detect new media files, changes, or deletions.
Matching: After scanning, Plex tries to identify (match) your files with entries in online databases to fetch the correct metadata. Correct file naming is crucial for accurate matching.
Transcoding: The process of converting a media file from its original format (codec, container, bitrate, resolution) to a different format or quality. This is necessary when the client device doesn't support the original format, or when network bandwidth is insufficient for the original quality, or when subtitles need to be burned into the video stream. Transcoding is CPU-intensive but can be offloaded to compatible GPUs (hardware acceleration) with a Plex Pass.
Direct Play: The ideal scenario. The server sends the media file directly to the client without any modification because the file is fully compatible with the client device and there's enough bandwidth. This uses minimal server resources.
Direct Stream: A middle ground. The container format (e.g., MKV) might be incompatible, but the underlying video and audio streams (codecs) are compatible. Plex repackages the streams into a compatible container (e.g., MP4) without re-encoding the video or audio. This uses very little CPU power.
Remote Access: The ability to connect to your Plex Media Server and stream media from outside your home network (e.g., while traveling, at a friend's house). Requires proper network configuration (usually port forwarding) for optimal performance (Direct Connection) or relies on the limited Plex Relay service.
Plex Pass: The optional premium subscription offering features like hardware transcoding, offline sync, advanced user controls, Live TV/DVR, and more.

Workshop Introduction Setting the Stage

Throughout this guide, each section will conclude with a "Workshop." These are hands-on exercises designed to reinforce the concepts you've just learned. They will provide step-by-step instructions for practical tasks you'd perform when setting up and managing your own Plex server.

Your Goal for this Introduction Workshop: Ensure you have a clear understanding of what Plex is fundamentally trying to achieve.

Steps:

Create a Plex Account:
- Navigate to https://www.plex.tv/ in your web browser.
- Click on "Sign Up" (usually in the top right corner).
- Choose a method to sign up (Google, Facebook, Apple, or Email). Using email is often preferred for better control.
- Follow the on-screen instructions to create your free Plex account. Remember the username and password you choose.
- Verify your email address if required.
Explore the Plex Web App (Pre-Server):
- Once logged in on the Plex website, you might be guided through an initial setup asking about a server. Since you don't have one yet, you can skip this or close the wizard.
- Look around the web interface. You'll likely see some free content offered by Plex itself (Live TV channels, Movies & Shows on Demand). This gives you a feel for the client interface, even without your own server connected.
- Notice the different sections (Home, Live TV, Movies & Shows). Imagine these populated with your own media later.
- Click on your account icon (top right) and explore the "Account Settings." See where your Plex Pass status (if any) would appear, authorized devices (currently just your browser), and online media sources. Don't change anything critical yet.
Reflect:
- Mentally revisit the "Why Self-Host Plex" points. Which ones resonate most with you?
- Consider the Plex Architecture diagram. Can you trace the path data would take from a hypothetical server (your future setup) to the Plex web app you are currently using? Where does your Plex account fit in?

This initial workshop familiarizes you with the Plex ecosystem account and the basic client interface before you dive into server setup. Having an account ready is the first practical step.

1. Basic Setup and Configuration

This section covers the essential first steps to get your Plex Media Server up and running. We'll discuss hardware and operating system choices, walk through the installation process, show you how to create your first media libraries, configure basic network access, and connect your first client device.

Choosing Your Server Hardware

The hardware you choose for your Plex Media Server significantly impacts its performance, especially regarding transcoding. Let's break down the key components:

Minimum Requirements vs. Recommended Specs:
- Minimum: Plex officially states very low minimums (e.g., Intel Core i3 or equivalent, 2GB RAM). However, this is only sufficient for Direct Play/Direct Stream of maybe one or two low-bitrate streams. Transcoding even a single 1080p stream will struggle significantly. Do not aim for the minimum.
- Recommended (Basic): For handling a couple of 1080p Direct Play streams and perhaps one 1080p transcode: A modern Intel Core i3/i5 (or AMD Ryzen 3/5) with at least 4GB RAM (8GB+ recommended).
- Recommended (Robust): For multiple streams, including potential 4K content (Direct Play) and multiple 1080p transcodes: A recent Intel Core i5/i7 (or AMD Ryzen 5/7) with 8GB-16GB+ RAM. For 4K transcoding (which should be avoided if possible), requirements increase significantly.
- Key Takeaway: Plan for your peak usage scenario. How many simultaneous streams do you anticipate? Will transcoding be common?
CPU Considerations: The CPU is the most critical component for transcoding if you are not using hardware acceleration.
- Transcoding Performance: Plex uses CPU power to convert video and audio. The more demanding the conversion (e.g., 4K down to 720p, H.265 to H.264), the more CPU power is needed.
- PassMark Score: A common, albeit rough, guideline is CPU PassMark score. Plex suggests:
  - ~1500 PassMark: Single 720p (4Mbps) transcode.
  - ~2000 PassMark: Single 1080p (10Mbps) transcode.
  - ~12000 PassMark: Single 4K SDR (40Mbps) transcode.
  - ~17000 PassMark: Single 4K HDR (40Mbps) transcode.
  - Note: These are estimates; real-world performance varies. Find scores at cpubenchmark.net. Multiple simultaneous transcodes require adding up these scores.
- Intel Quick Sync Video (QSV): Most modern Intel Core processors (i3/i5/i7/i9 from ~Sandy Bridge/2nd gen onwards, though newer generations are much better) include integrated graphics with QSV. This is a dedicated hardware block designed for video encoding/decoding. Plex Pass allows you to leverage QSV for hardware-accelerated transcoding, drastically reducing CPU usage and enabling many more simultaneous transcodes on modest CPUs (e.g., a 7th gen or later i5 can often handle several 1080p hardware transcodes). Highly recommended if you anticipate transcoding.
- AMD VCE/VCN (Video Coding Engine / Video Core Next): AMD's equivalent to QSV, found in Ryzen APUs (with integrated graphics) and Radeon GPUs. Plex Pass also supports AMD hardware acceleration, though historically, driver support and performance (especially on Linux) have sometimes lagged behind Intel QSV. It's become much more viable in recent years.
- Dedicated GPUs (NVIDIA NVENC/NVDEC): NVIDIA GeForce (GTX/RTX) and Quadro cards have powerful hardware encoders (NVENC) and decoders (NVDEC). Plex Pass can utilize these for hardware transcoding. This is often the most powerful option (especially for multiple 4K transcodes, if needed) but consumes more power and adds cost. Note that consumer GeForce cards often have an artificial limit on the number of simultaneous encode sessions (usually 3-5, though this can sometimes be bypassed with patched drivers on Linux/Windows). Quadro cards don't have this limit.
RAM Requirements:
- While Plex itself doesn't use excessive RAM for basic operation, more is needed during intense activity.
- Minimum Practical: 4GB (expect potential swapping/slowness during scans or multiple streams).
- Recommended: 8GB provides comfortable headroom for the OS, Plex, and moderate transcoding/scanning.
- Heavy Use/Large Libraries: 16GB or more is beneficial, especially if the server runs other applications (like Docker containers, download clients) or handles very large libraries or frequent transcoding. RAM is also used for the transcode buffer.
Storage Considerations: Where will your media files live?
- Internal Hard Drives: Simplest option for a dedicated server machine. Use reliable drives (e.g., NAS-specific drives like WD Red or Seagate IronWolf) if running 24/7. Consider data redundancy (RAID).
- Direct Attached Storage (DAS): External enclosures connected via USB, Thunderbolt, or eSATA. Good for expanding storage on desktops or mini-PCs. Performance depends heavily on the interface (USB 3.0+ recommended).
- Network Attached Storage (NAS): Devices like Synology or QNAP. Many NAS devices can run Plex Media Server directly (check compatibility and CPU power). Alternatively, a more powerful separate server can access media files stored on the NAS via network shares (NFS or SMB). This is a very common setup.
- RAID (Redundant Array of Independent Disks): Not a backup, but provides redundancy against single drive failure (RAID 1, 5, 6, 10/0+1) or improves performance (RAID 0 - no redundancy). Consider your tolerance for data loss vs. cost and complexity.
- SSD vs. HDD:
  - OS/Plex Metadata: Highly recommended to install the Operating System and the Plex Media Server data directory (which contains the database and metadata) on an SSD. This dramatically improves the responsiveness of the Plex interface, browsing speed, and library scanning times. A small SSD (128GB-256GB) is often sufficient for this.
  - Media Files: HDDs (Hard Disk Drives) offer the best cost per terabyte and are perfectly adequate for storing media files, as sequential read speed is usually sufficient for streaming even high-bitrate 4K content.
Network Requirements:
- Wired Ethernet (Gigabit): Strongly recommended for the Plex server. Wi-Fi can be unreliable, prone to interference, and often has lower consistent throughput, which can cause buffering issues, especially with high-bitrate media or multiple streams. Connect your server directly to your router/switch with an Ethernet cable.
- Bandwidth:
  - Local Network: Gigabit Ethernet (1000 Mbps) is standard and sufficient for almost all local streaming, including multiple 4K streams.
  - Internet Upload Speed: Crucial for remote streaming quality. Your upload speed limits the total bitrate you can stream out to remote clients. If your upload speed is low (e.g., 10 Mbps), you'll only be able to support one or two remote streams, likely requiring transcoding to lower quality. Estimate ~5-10 Mbps upload per 1080p stream, and 20-40+ Mbps upload per 4K stream (Direct Play). Test your speed at speedtest.net.

Workshop Hardware Selection Scenario

Scenario: You want to build a Plex server primarily for yourself and 2-3 family members (max 3 simultaneous streams). Most media is 1080p H.264/H.265, but you have a small, growing 4K HDR collection you want to Direct Play locally. Remote streaming (max 1-2 streams) will occur, mostly 1080p, and your internet upload speed is 50 Mbps. You anticipate needing transcoding for some older devices or remote viewing. You plan to run the server 24/7 and might run a couple of other small services (like a download client) later. You prefer a low-power solution if possible.

Task: Based on the information above, outline recommended specifications for the CPU, RAM, Storage (OS/Plex Data and Media), and Network connection. Justify your choices.

Guidance:

Simultaneous Streams: 3 total (mix of local/remote).
Transcoding Needs: Yes, anticipate 1-2 1080p transcodes, especially for remote access or older clients. 4K transcoding should be avoided (aim for Direct Play locally).
CPU: Since transcoding is needed and you want low power, what CPU feature is highly desirable? Which brands/models offer this effectively? Do you need a high PassMark score if you have this feature?
RAM: Consider the OS, Plex, 1-2 transcodes, and potential future services. What's a safe amount?
Storage: How should you handle the OS/Plex database vs. the media files for best performance and capacity? What type of drives for media if running 24/7?
Network: What connection type is essential for the server? Is the 50 Mbps upload sufficient for the remote streaming goals?

Example Answer Structure (Fill in your choices):

CPU: Recommend [Specific CPU type/generation range, e.g., Intel Core i3/i5 8th Gen+] because [Justification: e.g., includes excellent QSV for hardware transcoding, low power draw, sufficient base performance]. Plex Pass will be necessary to leverage hardware transcoding.
RAM: Recommend [Specific amount, e.g., 16GB] because [Justification: e.g., provides ample room for OS, Plex, multiple transcodes using hardware acceleration buffer, and future light services without bottlenecking].
Storage (OS/Plex Data): Recommend [Type and Size, e.g., 256GB NVMe SSD] because [Justification: e.g., significantly improves UI responsiveness, library scanning speed, and overall system performance].
Storage (Media): Recommend [Type and Size/Configuration, e.g., 2x 8TB NAS-grade HDDs (like WD Red Plus or Seagate IronWolf) potentially in a RAID 1 configuration or managed individually] because [Justification: e.g., HDDs offer cost-effective bulk storage, NAS drives are designed for 24/7 operation. RAID 1 offers redundancy against single drive failure, or individual disks simplify expansion].
Network: Recommend [Connection type, e.g., Gigabit Wired Ethernet] because [Justification: e.g., ensures reliable, high-speed connection to the network, crucial for smooth streaming, especially 4K local playback]. The 50 Mbps upload speed is adequate for 1-2 1080p remote streams, potentially needing transcoding to fit within bitrate limits set in Plex.

Operating System Choices

The OS forms the foundation of your Plex server. While Plex runs on various platforms, the choice impacts installation, maintenance, performance tuning, and compatibility with other self-hosted services.

Comparison:
- Linux (Various Distributions):
  - Pros: Free, open-source, highly stable, excellent performance, resource-efficient (uses less RAM/CPU for the OS itself), vast community support, excellent Docker support, ideal for running 24/7 servers. Generally better hardware transcoding driver support (especially for Intel QSV and modern AMD) than in the past. Highly customizable.
  - Cons: Can have a steeper learning curve for users unfamiliar with the command line (though modern desktops are user-friendly). Hardware compatibility can sometimes be trickier than Windows for very new or obscure components (less common now).
  - Popular Choices:
    - Ubuntu Server/Desktop: Very popular, large community, extensive documentation, relatively user-friendly, frequent updates. LTS (Long Term Support) versions offer stability. Good starting point.
    - Debian: Known for stability and reliability, forms the base for Ubuntu. Slightly less cutting-edge than Ubuntu but rock-solid.
    - Fedora: More bleeding-edge, good if you want the latest features, but shorter support cycles.
    - CentOS Stream / RHEL Clones (AlmaLinux, Rocky Linux): Enterprise-focused, very stable, longer learning curve.
    - Unraid / TrueNAS SCALE: NAS-focused OSes with strong Docker/VM support and excellent storage management features. TrueNAS SCALE is Debian-based. Unraid is Linux-based but proprietary. Both can run Plex very well (often in Docker).
- Windows (Desktop/Server):
  - Pros: Familiar interface for most users, broad hardware compatibility, easy setup for basic use, good support for Intel QSV and NVIDIA NVENC hardware transcoding.
  - Cons: Requires a paid license (though desktop versions are often pre-installed), generally consumes more system resources (RAM/CPU) than Linux, forced updates/reboots can interrupt server uptime, Docker support exists but is often considered less mature/performant than on Linux. Less ideal for a dedicated, lean 24/7 server environment compared to Linux.
- macOS:
  - Pros: User-friendly interface, stable Unix-based foundation, good power management, decent hardware transcoding support (especially on Apple Silicon via VideoToolbox, though Plex support evolved).
  - Cons: Requires Apple hardware (can be expensive), less flexible for server hardware choices, less common for dedicated 24/7 servers compared to Linux or Windows.
- NAS Operating Systems (Synology DSM, QNAP QTS):
  - Pros: Designed for storage management and running services 24/7, often energy-efficient, user-friendly web interfaces, offer official Plex packages or Docker support.
  - Cons: Hardware is tied to the NAS vendor, often less powerful CPUs compared to dedicated PCs (especially lower-end models, limiting transcoding), OS customization is limited. Performance heavily depends on the NAS model.
Focus on Linux (Ubuntu/Debian): For self-hosting enthusiasts aiming for stability, performance, efficiency, and flexibility (especially with Docker), Linux is often the preferred choice. Ubuntu and Debian offer a great balance of usability, support, and reliability. This guide will primarily use Ubuntu/Debian for command-line examples.

Workshop OS Decision Guide

Task: Evaluate which OS would be the best fit for the following user profiles. Justify your choice based on the pros and cons discussed.

User A: A university student, comfortable with technology but new to Linux. Wants to set up Plex on an old desktop PC they have. Plans to use it primarily for themselves and maybe share with one friend. Wants low maintenance and good community support for troubleshooting. Values learning new technical skills.
User B: A user who wants a simple, set-it-and-forget-it solution. They just bought a Synology NAS primarily for file backup and want to add Plex functionality. They are not comfortable with command lines and prefer a graphical interface for everything. Transcoding needs are minimal (mostly Direct Play).
User C: An experienced Windows user who wants to run Plex on their powerful gaming PC, which is usually on anyway. They have a high-end NVIDIA GPU and want maximum transcoding performance using NVENC for several remote users. They are not interested in learning Linux at this time.
User D: A sysadmin student who wants to build a dedicated, energy-efficient, highly reliable Plex server. They plan to run Plex alongside several other self-hosted services using Docker and want fine-grained control over the system. They are comfortable with the command line and prioritize stability and resource efficiency.

Guidance: Consider the user's technical comfort level, existing hardware/software environment, primary goals (simplicity vs. control vs. performance), and future plans.

Example Answer Structure:

User A: Recommended OS: [Your Choice, e.g., Ubuntu Desktop/Server LTS]. Justification: [e.g., Balances user-friendliness with Linux power, large community, LTS stability, good learning platform, runs well on older hardware, good Docker support for future expansion].
User B: Recommended OS: [Your Choice, e.g., Synology DSM (using the official Plex package)]. Justification: [e.g., Leverages existing NAS hardware, uses familiar graphical interface, simple package installation, meets minimal transcoding needs assuming NAS CPU is adequate].
User C: Recommended OS: [Your Choice, e.g., Windows 10/11]. Justification: [e.g., User is familiar with Windows, leverages existing powerful hardware and NVIDIA GPU for NVENC transcoding (requires Plex Pass), straightforward setup on their current OS].
User D: Recommended OS: [Your Choice, e.g., Debian or Ubuntu Server LTS]. Justification: [e.g., Offers stability, resource efficiency, excellent Docker support, command-line control suits sysadmin profile, ideal for dedicated 24/7 server].

Installing Plex Media Server

Now, let's install the Plex Media Server software. We'll focus on Linux (Ubuntu/Debian) using the official .deb package, as it's a common and relatively straightforward method for beginners on these distributions.

Installation Methods Overview:
- Package Manager (Linux): Many distributions include Plex in their repositories, but these can sometimes be outdated. Adding the official Plex repository is often preferred for timely updates. Direct download of .deb (Debian/Ubuntu) or .rpm (Fedora/CentOS) packages is also common.
- Docker: Highly recommended for intermediate/advanced users (covered later). Isolates Plex, simplifies updates and dependency management.
- Manual Download (Windows/macOS): Download the installer from the Plex website and run it like any other application.
- NAS Package Center (Synology/QNAP etc.): Install directly from the NAS's app store. Ensure you're getting a recent version.
Step-by-step Installation on Linux (Ubuntu/Debian via .deb):
1. Access Your Server's Terminal: Connect to your server via SSH (if headless) or open a terminal window (if using a desktop environment).
2. Update Package Lists: Ensure your system knows about the latest available software versions.
```
sudo apt update
```
  Explanation: sudo grants administrative privileges for the command. apt is the package manager for Debian/Ubuntu. update refreshes the list of available packages from the repositories defined in your system.
3. Install Prerequisites: Plex might require certain packages. apt transport-https allows apt to retrieve packages over HTTPS, which the Plex repository uses. curl or wget is needed to download the repository key or package file.
```
sudo apt install apt-transport-https curl wget -y
```
  Explanation: install tells apt to install packages. -y automatically answers "yes" to prompts, useful in scripts or when you're sure.
4. Download the latest Plex Media Server .deb package:
  - Go to the Plex Media Server downloads page: https://www.plex.tv/media-server-downloads/
  - Select "Linux" and then choose "Ubuntu (16.04+) / Debian (8+) - Intel/AMD 64-bit".
  - Right-click the download button/link for the .deb file and select "Copy Link Address".
  - In your server terminal, use wget to download it. Replace <COPIED_URL> with the link you just copied.
```
# Example - URL will change with versions!
wget <COPIED_URL>
# Example: wget https://downloads.plex.tv/plex-media-server-new/1.32.8.7639-fb6452ebf/debian/plexmediaserver_1.32.8.7639-fb6452ebf_amd64.deb
```
    Explanation: wget is a command-line utility to download files from the internet.
5. Install the downloaded package: Replace plexmediaserver_*.deb with the actual filename you downloaded. You can use tab completion (type plex and press Tab).
```
sudo dpkg -i plexmediaserver_*.deb
```
  Explanation: dpkg is the underlying Debian package management tool. -i tells it to install the specified .deb file.
6. (Optional but Recommended) Add Plex Repository for Automatic Updates: Installing the .deb manually often automatically adds the official Plex repository to your system's sources. This allows apt to find and install future Plex updates easily. You can verify this:
```
# Check if Plex repo file exists
ls /etc/apt/sources.list.d/plexmediaserver.list

# If it exists, future Plex updates can be installed via:
# sudo apt update
# sudo apt upgrade
```
7. Check Plex Service Status: After installation, the Plex Media Server service should start automatically. Verify its status:
```
sudo systemctl status plexmediaserver
```
  Explanation: systemctl is used to manage systemd services, the standard on modern Linux. status shows the current state of the service. Look for "active (running)". Press q to exit the status view.
8. Enable Plex Service on Boot (usually done automatically by installer): Ensure Plex starts automatically if the server reboots.
```
sudo systemctl enable plexmediaserver
```
  Explanation: enable ensures the service is started during the system boot sequence.
Initial Server Setup (Claiming):
- IMPORTANT: The very first time you access the Plex web interface after installation, you need to do it from the same local network as the server to "claim" it to your Plex account. If your server has a desktop environment, you can open a browser directly on it. If it's headless (like Ubuntu Server), you need to use a technique called SSH Tunneling or access it from another computer on the same LAN.
- Method 1: Browser on the Server (if it has a GUI):
  - Open a web browser on the server machine itself.
  - Navigate to http://localhost:32400/web or http://127.0.0.1:32400/web.
- Method 2: Access from another computer on the same LAN:
  - Find the local IP address of your Plex server. You can use ip a or hostname -I on the server's terminal. Let's say it's 192.168.1.100.
  - On another computer connected to the same router, open a web browser.
  - Navigate to http://<SERVER_IP_ADDRESS>:32400/web (e.g., http://192.168.1.100:32400/web).
- Method 3: SSH Tunneling (for headless servers accessed remotely):
  - If you are accessing your server via SSH from outside its local network for the initial setup (not ideal, but possible), you need an SSH tunnel. From your local machine's terminal (not the server's):
```
# Replace <server_user> with your username on the server
# Replace <server_ip_address> with the server's actual IP
ssh <server_user>@<server_ip_address> -L 8888:localhost:32400
```
    Explanation: -L 8888:localhost:32400 forwards connections made to port 8888 on your local machine through the SSH connection to port 32400 on the server (localhost from the server's perspective).
  - Keep this SSH session running.
  - Now, open a web browser on your local machine and navigate to http://localhost:8888/web. This traffic will be securely tunneled to your server's Plex setup page.
- The Setup Wizard:
  - You should be greeted by the Plex setup wizard. Log in with the Plex account you created earlier.
  - Got it!: Acknowledge the explanation of how Plex works.
  - Server Name: Give your server a friendly name (e.g., "MyPlexServer"). Decide if you want to allow remote access (you can change this later).
  - Media Library: The wizard will prompt you to add libraries. You can do this now if your media folders are ready, or skip and do it later (we'll cover this next).
  - Finish: Complete the wizard. Your server is now installed and claimed to your account! You should be redirected to the main Plex dashboard.

Workshop Installing Plex on Ubuntu

Goal: Install Plex Media Server on an Ubuntu system (real or virtual machine) using the .deb package method and complete the initial claiming process.

Prerequisites:

An Ubuntu Desktop or Server system (version 18.04 LTS or later recommended). This could be a virtual machine (using VirtualBox, VMware) or a physical machine.
Internet access from the Ubuntu system.
Terminal access to the Ubuntu system (either directly or via SSH).
A web browser on a computer on the same local network as the Ubuntu system (or knowledge of SSH tunneling if accessing remotely).
Your Plex account login details.

Steps:

Open Terminal: Access the terminal on your Ubuntu system.
Update Packages:
```
sudo apt update
sudo apt upgrade -y
```

Install Prerequisites:

sudo apt install apt-transport-https curl wget -y

Download Plex .deb:
- Go to https://www.plex.tv/media-server-downloads/.
- Select Linux -> Ubuntu (16.04+)/Debian(8+) Intel/AMD 64-bit.
- Copy the link address for the .deb file.
- In the terminal, download using wget:
```
# Paste the copied URL here
wget <COPIED_URL>
```
Install Plex: (Use Tab completion for the filename)
```
sudo dpkg -i plexmediaserver_*.deb
```
- Troubleshooting: If you get dependency errors, run sudo apt --fix-broken install and then try the dpkg -i command again.
Verify Service Status:
```
sudo systemctl status plexmediaserver
```
- Check for "active (running)". Press q to exit. If not running, try sudo systemctl start plexmediaserver.
Find Server IP Address:
```
hostname -I
```
- Note the first IP address listed (e.g., 192.168.1.150).
Claim the Server:
- Go to another computer on the same local network.
- Open a web browser.
- Navigate to http://<SERVER_IP_ADDRESS>:32400/web (replace <SERVER_IP_ADDRESS> with the IP you found in step 7).
- Log in with your Plex account when prompted.
- Follow the setup wizard:
  - Give your server a name.
  - Decide whether to allow remote access for now (we'll cover configuring it properly later).
  - Skip adding libraries for this workshop (click "Next" or "Skip").
  - Click "Finish".
Confirmation: You should now see the main Plex dashboard, connected to your newly installed server. You have successfully installed and claimed your Plex Media Server!

Creating Your First Libraries

With the server installed and claimed, it's time to tell Plex where your media files are located. This involves creating libraries and understanding how Plex organizes content.

Understanding Library Types: Plex requires you to categorize your media into specific library types. This helps it apply the correct scanner and metadata agent to identify and fetch information accurately. Common types include:
- Movies: For feature-length films. Uses agents like "Plex Movie" (default, recommended) which pull data from sources like TMDb and IMDb.
- TV Shows: For episodic content. Uses agents like "Plex TV Series" (default, recommended) pulling from sources like TheTVDB and TMDb. Proper naming and folder structure are critical here.
- Music: For audio tracks and albums. Uses agents like "Plex Music" which leverage MusicBrainz and other sources for metadata, including sonic analysis for features like Plexamp radio.
- Photos: For your personal photo collections.
- Other Videos: A catch-all for things that don't fit the other categories, like home movies, workout videos, or miscellaneous clips. Metadata fetching is generally less sophisticated for this type.

Organizing Media Files (Standard Naming Conventions): This is arguably the most important step for a smooth Plex experience. Plex relies heavily on specific naming patterns to correctly identify your media and fetch metadata. Failing to follow these conventions will lead to mismatches, missing artwork, and general frustration.

Movies: Store each movie file in its own folder named Movie Title (Year). The movie file itself should ideally be named similarly.

/path/to/your/movies/    <-- Folder added to Plex Library
    └── Avatar (2009)/
        └── Avatar (2009).mkv
    └── The Dark Knight (2008)/
        └── The Dark Knight (2008).mp4
    └── Pulp Fiction (1994)/
        └── Pulp Fiction (1994).mkv

TV Shows: This structure is crucial. Have a main folder for the show, then subfolders for each season, and finally the episode files named correctly.

/path/to/your/tvshows/  <-- Folder added to Plex Library
    └── Breaking Bad (2008)/
        └── Season 01/
            └── Breaking Bad (2008) - s01e01 - Pilot.mkv
            └── Breaking Bad (2008) - s01e02 - Cat's in the Bag....mkv
            └── ...
        └── Season 02/
            └── Breaking Bad (2008) - s02e01 - Seven Thirty-Seven.mkv
            └── ...
    └── Game of Thrones (2011)/
        └── Season 01/
            └── Game of Thrones (2011) - S01E01 - Winter is Coming.mp4
            └── Game of Thrones (2011) - S01E02 - The Kingsroad.mp4
            └── ...

Show Title (Year) for the main folder.
Season XX for season subfolders (e.g., Season 01, Season 02). Use Season 00 or Specials for specials.
Show Title (Year) - sXXeYY - Optional Episode Title.ext for files (e.g., s01e01, s01e02). The sXXeYY part is critical.

Music: Typically organized by Artist -> Album -> Tracks. Plex relies heavily on embedded metadata tags within the audio files (MP3, FLAC, AAC etc.).

/path/to/your/music/    <-- Folder added to Plex Library
    └── Artist Name/
        └── Album Title (Year)/
            └── 01 - Track Title.mp3
            └── 02 - Another Track.flac
            └── ...
        └── Another Album Title (Year)/
            └── ...
    └── Another Artist/
        └── ...

Ensure your music files have accurate embedded tags (Artist, Album Artist, Album Title, Track Title, Track Number, Year). Tools like MusicBrainz Picard can help automate tagging.

Resources: Refer to the official Plex naming guides for details:

Adding Media Folders to Plex:
1. Prepare Folders: Create the main directories on your server where your media will be stored (e.g., /mnt/storage/movies, /mnt/storage/tvshows). Ensure the plex user (the user the Plex Media Server process runs as on Linux) has permission to read (and ideally execute for directories) these folders. You might need to adjust permissions using chown and chmod if Plex can't see the files. For example:
```
# Find the Plex user (often 'plex')
ps aux | grep -i "plex media server"

# Example: Assuming user is 'plex' and media is in /mnt/storage
# Make sure the 'plex' user can access the directories
sudo chown -R plex:plex /mnt/storage/movies
sudo chmod -R 755 /mnt/storage/movies # Read/Execute for owner/group/others, Write for owner

sudo chown -R plex:plex /mnt/storage/tvshows
sudo chmod -R 755 /mnt/storage/tvshows
```
  Explanation: chown -R changes ownership recursively. plex:plex sets user plex and group plex. chmod -R 755 sets permissions recursively: owner=read/write/execute (7), group=read/execute (5), others=read/execute (5). This is a common setting allowing Plex to read files and navigate directories.
2. Open Plex Web App: Access your Plex server via http://<SERVER_IP_ADDRESS>:32400/web.
3. Add Library:
  - In the left sidebar, hover over "Libraries" and click the + icon.
  - Select the library type (e.g., "Movies").
  - Enter a name for the library (e.g., "My Movies").
  - Select the language for metadata.
  - Click "Next".
  - Click "Browse For Media Folder".
  - Navigate to and select the folder containing your media files for this library type (e.g., /mnt/storage/movies). Ensure you select the correct base folder matching the structure discussed above.
  - Click "Add". You can add multiple folders to a single library if needed.
  - Click "Add Library".
4. Repeat for Other Types: Repeat step 3 for other media types like "TV Shows", adding the corresponding folders (e.g., /mnt/storage/tvshows).
Scanning Libraries and Metadata Agents:
- Once a library is created, Plex will automatically initiate a scan. You'll see activity indicators as it finds files and starts downloading metadata. This can take time, especially for large libraries on the first scan.
- You can monitor progress in the Plex Dashboard (Activity icon - top right).
- Metadata Agents: You can view and configure advanced agent settings under Plex Settings -> Server -> Agents. For most users, the default "Plex Movie" and "Plex TV Series" agents work best. Ensure they are selected and ordered correctly for your library types. These newer agents combine data from multiple sources. You can tweak agent-specific settings here (e.g., prefer local metadata, country for ratings).

Workshop Setting Up Movie and TV Show Libraries

Goal: Create correctly named and structured folders for a few sample movie and TV show files, add these folders as libraries in Plex, and verify that Plex identifies them correctly.

Prerequisites:

Your Plex Media Server installed and running (from the previous workshop).
Access to the Plex Web App.
Ability to create folders and files on the storage used by your Plex server.

Steps:

Create Media Folders on Server:
- Connect to your server's terminal (or use a file manager if available).
- Choose a base location for your media (e.g., /media/plex). Create it if it doesn't exist: sudo mkdir -p /media/plex.
- Create subdirectories for movies and TV shows:
```
sudo mkdir /media/plex/movies
sudo mkdir /media/plex/tvshows
```

Set Permissions: Ensure the plex user can access these folders.

# Assuming 'plex' user/group, adjust if different
sudo chown -R plex:plex /media/plex
sudo chmod -R 755 /media/plex

Create Sample Movie Structure and Files:

Create folders and dummy files (real files not needed for this exercise, but use correct naming).

# Movie 1
sudo mkdir "/media/plex/movies/Inception (2010)"
sudo touch "/media/plex/movies/Inception (2010)/Inception (2010).mkv"

# Movie 2
sudo mkdir "/media/plex/movies/The Matrix (1999)"
sudo touch "/media/plex/movies/The Matrix (1999)/The Matrix (1999).mp4"

Explanation: touch creates an empty file with the given name. We use quotes because of spaces in filenames/directories.

Create Sample TV Show Structure and Files:

# Show 1: Chernobyl
sudo mkdir -p "/media/plex/tvshows/Chernobyl (2019)/Season 01"
sudo touch "/media/plex/tvshows/Chernobyl (2019)/Season 01/Chernobyl (2019) - s01e01 - 1-23-45.mkv"
sudo touch "/media/plex/tvshows/Chernobyl (2019)/Season 01/Chernobyl (2019) - s01e02 - Please Remain Calm.mkv"

# Show 2: The Mandalorian
sudo mkdir -p "/media/plex/tvshows/The Mandalorian (2019)/Season 01"
sudo touch "/media/plex/tvshows/The Mandalorian (2019)/Season 01/The Mandalorian (2019) - S01E01 - Chapter 1.mkv"
sudo touch "/media/plex/tvshows/The Mandalorian (2019)/Season 01/The Mandalorian (2019) - S01E02 - Chapter 2 The Child.mkv"

Explanation: mkdir -p creates parent directories as needed.

Add Movie Library in Plex:
- Open the Plex Web App (http://<SERVER_IP>:32400/web).
- Click the + next to "Libraries".
- Select "Movies", name it (e.g., "Movies"), click "Next".
- Click "Browse For Media Folder".
- Navigate to and select /media/plex/movies. Click "Add".
- Click "Add Library".
Add TV Show Library in Plex:
- Click the + next to "Libraries".
- Select "TV Shows", name it (e.g., "TV Shows"), click "Next".
- Click "Browse For Media Folder".
- Navigate to and select /media/plex/tvshows. Click "Add".
- Click "Add Library".
Monitor Scan and Verify:
- Plex should start scanning. Watch the Activity icon (top right).
- Once scanning is complete, click on your "Movies" library. You should see entries for "Inception" and "The Matrix" with correct posters and metadata.
- Click on your "TV Shows" library. You should see entries for "Chernobyl" and "The Mandalorian". Click into one - you should see "Season 01" and the individual episodes listed correctly with metadata.
Troubleshooting (If it fails):
- Permissions: Double-check folder permissions using ls -l /media/plex and ls -l /media/plex/movies, etc. Ensure plex can read.
- Naming: Verify your folder and file names exactly match the recommended structure. Even small deviations can cause issues.
- Scanner/Agent: Check library settings (Edit Library -> Advanced) to ensure the correct scanner ("Plex Movie Scanner", "Plex TV Series Scanner") and agent ("Plex Movie", "Plex TV Series") are selected.
- Manual Scan: Trigger a manual scan (Click ... next to the library name -> Scan Library Files).
- Fix Match: If an item is mismatched, click ... on the item -> Fix Match. Search for the correct title/year.

By completing this workshop, you've learned the critical importance of file naming/structure and how to add your organized media folders into Plex libraries.

Basic Network Configuration and Access

Now that your server is installed and has libraries, let's ensure you can access it reliably, both from within your home network and potentially from outside.

Accessing Plex Web App Locally:
- As established during the claiming process, you can access the Plex Web App from any device on the same local network (connected to the same router) as your server.
- Use the URL: http://<SERVER_IP_ADDRESS>:32400/web (e.g., http://192.168.1.100:32400/web).
- You can also use the Plex-hosted web app: https://app.plex.tv/desktop. After logging in, it should automatically discover and connect to your local server. This is often more convenient as you don't need to remember the IP address.
Understanding Remote Access (Plex Relay vs. Direct Connection):
- Goal: Access your media when you are not on your home Wi-Fi (e.g., using mobile data, at a friend's house, traveling).
- Direct Connection (Ideal): Your Plex client app connects directly to your server's public IP address and the specific port Plex is listening on (default TCP 32400). This requires:
  1. Your server having Remote Access enabled in settings.
  2. Your router being configured to forward incoming traffic on a specific public port to your server's internal IP address and port 32400 (Port Forwarding).
  3. Your ISP not blocking incoming connections or using Carrier-Grade NAT (CGNAT), which prevents direct connections.
  4. Benefits: Full speed determined by your server's upload bandwidth and the client's download bandwidth. Allows higher quality streaming (Direct Play/Stream more likely).
- Indirect Connection (Plex Relay): If a direct connection cannot be established, Plex provides a fallback mechanism called Plex Relay. Your client connects to a Plex Inc. server, and the Plex Inc. server connects to your server. Your stream is proxied through Plex's infrastructure.
  - Drawbacks: Bandwidth is severely limited (1 Mbps free, 2 Mbps with Plex Pass). This usually forces low-quality transcoding (e.g., 480p or lower) and can result in buffering. It's a fallback, not a desirable primary method.
  - How to Check: In the Plex Web App, go to Settings -> Remote Access. It will tell you if your server is "Fully accessible outside your network" (Direct) or potentially using Relay if direct fails. Client apps often indicate if the connection is "Indirect".
Enabling Remote Access (Port Forwarding Basics):
1. Enable in Plex:
  - Go to Plex Web App -> Settings (wrench icon) -> Remote Access (under Settings section).
  - Click "Enable Remote Access". Plex will attempt to automatically configure your router using UPnP or NAT-PMP. This works on some routers but is often unreliable or considered a security risk by some.
2. Manual Port Forwarding (Recommended): If automatic configuration fails or you prefer manual control:
  - Find Server's Local IP: Note down the internal IP address of your Plex server (e.g., 192.168.1.100). It's best to configure your server to have a static internal IP address or use DHCP reservation in your router settings, so this IP doesn't change.
  - Log into Your Router: Open a web browser and navigate to your router's administration page (common addresses are 192.168.0.1, 192.168.1.1, 10.0.0.1 - check your router's manual). Log in with your router's admin credentials.
  - Find Port Forwarding Settings: Look for sections named "Port Forwarding," "Virtual Server," "Applications," or similar (location varies greatly by router brand/model).
  - Create a New Rule:
    - Application Name: Give it a name (e.g., "Plex").
    - External Port / Public Port: Choose a port number for the outside world to connect to. You can use 32400, but for slightly better security (obscurity), some recommend choosing a different random high port number (e.g., 25384). Let's assume you choose 25384.
    - Internal Port / Private Port: This must be 32400 (the port Plex listens on internally).
    - Internal IP Address / Server IP: Enter the static IP address of your Plex server (e.g., 192.168.1.100).
    - Protocol: Select TCP.
    - Enable/Activate: Make sure the rule is enabled.
    - Save/Apply: Save the changes on your router.
  - Tell Plex About the Manual Port:
    - Go back to Plex Settings -> Remote Access.
    - Check the box "Manually specify public port".
    - Enter the External Port you chose in the router settings (e.g., 25384) into the box.
    - Click "Apply" or "Retry Connection".
Testing Remote Access:
- The Plex Remote Access settings page should now hopefully show "Fully accessible outside your network" with a green checkmark. It might take a moment to update.
- Real-world Test: The best test is to use a device not connected to your home Wi-Fi.
  - Disconnect your smartphone from Wi-Fi so it uses mobile data.
  - Open the Plex app on your phone.
  - Try browsing your libraries and playing a media file.
  - Check the playback info (often accessible via settings during playback) to see if the connection is "Direct" or "Indirect". Aim for Direct. You can also check the Plex Dashboard (Activity -> Now Playing) on the web app to see connection details.
Troubleshooting Common Issues:
- Double NAT: If you have two routers between your server and the internet (e.g., an ISP modem/router combo and your own Wi-Fi router), port forwarding needs to be set up on both devices, or the ISP device needs to be put into "bridge mode". Double NAT often prevents successful direct remote access. Search online for "how to check for double NAT".
- CGNAT (Carrier-Grade NAT): Some ISPs (especially mobile or satellite providers, but increasingly some fixed-line ISPs) share a single public IP address among multiple customers using CGNAT. This makes direct incoming connections impossible as you don't have a unique public IP. Symptoms include the Remote Access page flapping between accessible/inaccessible or consistently failing. Check if your router's WAN/Internet IP address shown in its status page is within private ranges (like 100.64.x.x to 100.127.x.x, 10.x.x.x, 192.168.x.x, 172.16.x.x to 172.31.x.x). If you suspect CGNAT, contact your ISP to ask if they offer static public IP addresses or if they can opt you out. Alternatives include using a VPN with port forwarding capabilities or relying on Plex Relay (limited).
- Firewall: Ensure the firewall on your Plex server OS allows incoming connections on TCP port 32400. For Ubuntu/Debian using ufw: sudo ufw allow 32400/tcp. Also check any firewall settings on your router.
- Incorrect IP/Port: Double-check the internal IP address, external port, and internal port (32400) in your router's port forwarding rule and in the Plex Remote Access settings.

Workshop Enabling and Testing Basic Remote Access

Goal: Configure port forwarding on your router for Plex and verify if direct remote access is working.

Prerequisites:

Your Plex Media Server installed, running, and accessible locally.
Access to your home router's administration page.
Know the local IP address of your Plex server (make sure it's static or reserved).
A smartphone or other device capable of accessing the internet without using your home Wi-Fi (e.g., via mobile data).

Steps:

Set Static IP / DHCP Reservation (Recommended):
- Log into your router. Find the DHCP settings or LAN settings.
- Either configure a static IP address on the Plex server itself (outside the router's DHCP range) or find your Plex server in the list of connected devices and configure a DHCP reservation, tying its current IP address to its MAC address so it always receives the same IP. This prevents the IP from changing and breaking the port forward rule. Note down the reserved/static IP (e.g., 192.168.1.100).
Configure Port Forwarding on Router:
- Log into your router's admin page.
- Find the "Port Forwarding" or "Virtual Server" section.
- Create a new rule:
  - Name: Plex Server
  - External Port: 32400 (For simplicity in this basic workshop, we'll use the default. You can use a custom port later).
  - Internal Port: 32400
  - Internal IP Address: The static/reserved IP of your Plex server (e.g., 192.168.1.100).
  - Protocol: TCP
  - Enable the rule.
  - Save/Apply changes.
Configure Plex Remote Access:
- Open the Plex Web App (http://<SERVER_IP>:32400/web).
- Go to Settings -> Remote Access.
- If Remote Access is disabled, click "Enable Remote Access".
- If Plex doesn't automatically detect the forwarded port:
  - Check the box "Manually specify public port".
  - Enter 32400 (the External Port you set on the router).
  - Click "Apply".
- Wait for Plex to test the connection. Look for the message "Fully accessible outside your network" and a green checkmark.
Test with External Device:
- Take your smartphone. Turn OFF its Wi-Fi connection to ensure it's using mobile data.
- Open the Plex app on your phone (log in if necessary).
- Navigate to your server's libraries. Does it connect?
- Try playing a short video or music track.
- While playing, check the playback settings/info within the app. Does it say the connection is "Direct" or "Indirect"? (Direct is the goal).
- Alternatively, check the Plex Web App Dashboard (Activity icon -> Now Playing) on your computer. It should show the remote stream and indicate if it's Direct or Indirect.
Troubleshooting (If it shows Indirect or Fails):
- Wait & Retry: Sometimes it takes a minute for settings to apply. Click "Retry Connection" in Plex Remote Access settings.
- Double-Check Router: Ensure the rule is saved, enabled, and uses the correct IP/ports/protocol (TCP).
- Firewall: Temporarily disable the firewall on your server OS (sudo ufw disable on Ubuntu - remember to sudo ufw enable later!) and test again. If it works, you need to add a specific rule: sudo ufw allow 32400/tcp.
- CGNAT/Double NAT: If problems persist, investigate these possibilities as described in the theory section. Search online using your router's WAN IP address ("is [WAN IP] CGNAT?").

Successfully achieving "Fully accessible outside your network" and confirming a "Direct" connection on your external device means you've correctly configured basic remote access.

Using Plex Clients

The Plex ecosystem shines because of its wide range of client applications, allowing you to access your media library from almost anywhere.

Overview of Available Clients: Plex offers official apps for:
- Web Browsers: Accessible via https://app.plex.tv/desktop or locally via http://<SERVER_IP>:32400/web. Works on Chrome, Firefox, Edge, Safari.
- Desktop Computers: Dedicated apps for Windows and macOS (Plex HTPC for powerful home theater PC setups, and the standard Plex desktop app). Often provide better codec support and performance than web browsers.
- Mobile Devices: iOS (iPhone/iPad) and Android phones/tablets. Essential for on-the-go access and offers Mobile Sync (Plex Pass required) for offline playback.
- Smart TVs: Major brands like Samsung (Tizen), LG (webOS), Sony (Android TV), Vizio (SmartCast) have dedicated Plex apps in their app stores. Performance varies by TV model.
- Streaming Boxes/Sticks: Roku, Amazon Fire TV, Apple TV, Google TV / Android TV boxes (like NVIDIA Shield TV - often considered the best client). These dedicated devices often offer the best performance and compatibility.
- Game Consoles: PlayStation (PS4, PS5) and Xbox (One, Series S/X) have Plex apps.
- Other: Some NAS devices, Raspberry Pi (RasPlex/Plex Media Player), Linux desktops (via web or Plex HTPC).
Connecting Clients to Your Server:
1. Install the App: Download and install the appropriate Plex client app on your chosen device from its app store or the Plex website.
2. Sign In: Launch the app. It will usually prompt you to sign in. Use the same Plex account that you used to claim your server.
3. Link (If Necessary): Some apps (especially TVs) might display a 4-character code and ask you to visit https://plex.tv/link on a computer or phone, log in, and enter the code to link the device to your account.
4. Discovery: Once signed in, the client app communicates with plex.tv to find servers linked to your account. It should automatically discover and list your server.
5. Select Server: If you have multiple servers (or access to shared servers), you might need to select your primary server from a list. The client will then connect (either locally or remotely, directly or indirectly, depending on your network).
Basic Playback Controls and Settings:
- Navigation: Clients generally present your libraries (Movies, TV Shows, etc.) on a home screen or sidebar. You can browse by category, search, filter, and sort your media.
- Playback: Select a media item and press Play. Standard controls (Play/Pause, Seek forward/backward, Volume, Stop) are usually available.
- Quality Settings: During playback (or in the app's general settings), you can often adjust the streaming quality.
  - Local Quality: Usually set to "Original" or "Maximum" by default when on the same network as the server.
  - Remote Quality: Defaults to a lower setting (e.g., 4 Mbps 720p) to conserve internet bandwidth. You can often manually increase this if your connection supports it, up to "Original" quality if bandwidth allows for Direct Play/Stream. Setting this too high for your connection will cause buffering.
  - Auto Adjust Quality: Some clients offer an option to automatically adjust quality based on network conditions (often requires Plex Pass).
- Audio & Subtitle Selection: During playback, look for icons (often a speech bubble or gear) to select different audio tracks (e.g., different languages, commentary tracks) or subtitle tracks if available for the media file.
- Client Settings: Explore the settings menu within each Plex client app. You can often customize things like interface appearance, autoplay behavior, passthrough audio settings (for home theater receivers), burn-in subtitle options, and more. These settings are specific to the client device.

Workshop Connecting a Web and Mobile Client

Goal: Connect to your Plex server using the Plex Web App and the Plex mobile app, and explore basic navigation and playback settings.

Prerequisites:

Your Plex Media Server running and accessible (locally and ideally remotely).
A computer with a web browser on the same local network.
A smartphone (iOS or Android) with the Plex app installed.
Your Plex account login details.

Steps:

Connect via Web App (Local):
- On your computer (on the same network as the server), open a web browser.
- Navigate to http://<SERVER_IP>:32400/web (using your server's actual IP).
- If not already logged in, sign in with your Plex account.
- Confirm you see your server name and libraries listed in the left sidebar.
- Browse your "Movies" or "TV Shows" library created in the previous workshop.
- Click on one of the sample items (e.g., Inception). Note how the metadata (poster, summary, cast) is displayed.
Connect via Web App (Hosted):
- In a new browser tab, navigate to https://app.plex.tv/desktop.
- Log in with your Plex account.
- Verify that it automatically connects to your server and shows the same libraries and content. This demonstrates discovery via your Plex account.
Install and Connect Mobile App:
- On your smartphone, go to the App Store (iOS) or Google Play Store (Android).
- Search for "Plex" and install the official Plex app.
- Launch the Plex app.
- Tap "Sign In" and enter your Plex account credentials.
- The app should automatically find and connect to your server. You might see a brief tutorial or overview.
- Verify you can see your server name and libraries.
Explore Mobile Playback and Settings (Local Wi-Fi):
- Ensure your phone is connected to your home Wi-Fi.
- Navigate to one of your libraries (e.g., Movies) and select an item.
- Tap the Play button (since the workshop used dummy files, it won't actually play video, but the interface will load).
- Tap the screen to bring up the playback controls. Look for a settings icon (often a gear or sliders).
- Explore the Playback Settings / Quality options. Note the settings for "Home Streaming" or "Local Quality". It should default to "Maximum" or "Original".
- Look for Audio & Subtitle selection options (likely empty for dummy files).
Explore Mobile Playback and Settings (Remote - If Configured):
- Turn off Wi-Fi on your phone so it uses mobile data.
- Relaunch the Plex app (or ensure it reconnects).
- Navigate to the same media item and access the playback settings/quality menu again.
- Note the settings for "Remote Streaming" or "Internet Streaming". It will likely default to a lower quality (e.g., 2 Mbps 720p, 4 Mbps 720p).
- Observe the difference compared to the local quality settings. This demonstrates how Plex tries to adapt to different network conditions. You could manually change this setting, but playback would fail with dummy files.
Observe Server Dashboard:
- Go back to the Plex Web App on your computer.
- Click the Activity icon (top right) -> Dashboard.
- Under "Now Playing", you might briefly see entries corresponding to your attempts to play files from the web and mobile clients, showing which user, client, and IP address was used.

This workshop familiarizes you with accessing your server through different clients and understanding how basic quality settings differ between local and remote connections.

2. Intermediate Plex Management

Having mastered the basics, let's delve into more sophisticated ways to manage your libraries, users, and server performance. This section covers advanced library organization, user management and sharing, a deeper look at transcoding, customizing the Plex experience, and essential security practices.

Advanced Library Management

Go beyond simple libraries with tools to curate, optimize, and refine your media collection's presentation and accessibility.

Collections: Group related items together within a library. Useful for movie franchises, thematic sets, director spotlights, etc.
- Manual Collections: Create a collection and manually add items to it.
  1. Find a movie/show you want in a collection.
  2. Hover over its poster -> Click ... -> Edit.
  3. Go to the "Tags" tab.
  4. In the "Collections" field, type a name for your new collection (e.g., "Marvel Cinematic Universe") or select an existing one.
  5. Add the same tag to other related items.
  6. Items with the same collection tag will be grouped. You can control how collections are displayed in the library's advanced settings (e.g., hide items within the collection, show collection and its items).
- Smart Collections: Automatically group items based on filters and criteria (e.g., all unwatched Sci-Fi movies from the 1980s, all TV shows with a specific actor). This is incredibly powerful.
  1. Go to the library view (e.g., Movies).
  2. Use the filter dropdowns (top left) to select your criteria (e.g., Genre is Sci-Fi, Decade is 1980s, Unwatched is true).
  3. Once filtered, click the "Save As..." button (top right) and choose "Smart Collection".
  4. Give the smart collection a name and description.
  5. The collection will automatically update as new items meeting the criteria are added to your library.
Optimized Versions (Plex Pass Required): Pre-transcode media files into specific formats or qualities suitable for certain devices or limited bandwidth scenarios. This avoids on-the-fly transcoding, saving CPU resources during playback, especially useful for lower-powered servers or frequently accessed remote streams.
1. Find a media item (movie, TV show season/episode, even entire library) you want to optimize.
2. Click the ... menu -> Optimize...
3. Choose an optimization profile:
  - Optimized for Mobile: Lower quality, smaller file size.
  - Optimized for TV: Higher quality, compatible with most streaming devices.
  - Original Quality: Creates a copy in a highly compatible format (MP4 H.264/AAC) at the original bitrate (useful if the original container/codec causes issues but quality is fine).
  - Custom: Define specific quality levels, formats, or limit bitrate.
4. Select where to store the optimized version (e.g., "In folder with original items" or a separate location).
5. Click "Optimize". Plex will transcode the file(s) in the background (view progress in Settings -> Conversions).
6. When a client requests playback under conditions matching the optimized version (e.g., quality setting matches, Direct Play failed), Plex will serve the pre-optimized file instead of transcoding live.
Managing Metadata: Fine-tune the information associated with your media.
- Fix Match: If Plex misidentified an item:
  1. Click ... on the item -> Fix Match...
  2. Plex will search based on the filename. Review the results.
  3. If the correct item isn't listed, click "Search Options" to refine the title/year or change the agent/language.
  4. Select the correct match. Plex will download the new metadata.
- Edit Details: Manually change titles, sort titles (for custom ordering), summaries, ratings, genres, collections, posters, backgrounds, etc.
  1. Click ... on the item -> Edit.
  2. Modify fields across the tabs (General, Tags, Sharing, Poster, Background, Info). Use the "Info" tab to see the file path and media properties.
  3. Lock fields (click the orange lock icon) to prevent Plex from overwriting your manual changes during future metadata refreshes.
- Local Assets: Use your own artwork or metadata files.
  1. Enable "Use local assets" in your library's advanced settings AND potentially in the Agent settings (Settings -> Server -> Agents).
  2. Place asset files alongside your media files following Plex naming conventions (e.g., poster.jpg, background.jpg, moviename-poster.jpg). See Plex documentation for specifics. Plex will prioritize these local assets if configured to do so.
Playlists: Create custom ordered lists of media items (movies, episodes, music tracks). Unlike collections, playlists are ordered and don't group items within the library view. Useful for specific viewing sequences or music mixes.
1. Find an item you want to add.
2. Click ... -> Add to Playlist...
3. Choose an existing playlist or type a name to create a new one.

Workshop Creating Smart Collections and Optimizing Media

Goal: Create a smart collection for unwatched movies in a specific genre and create an optimized version for a sample movie file (if you have Plex Pass and a real media file).

Prerequisites:

Plex Media Server running with Movie library containing several items (ideally including some marked as unwatched and spanning different genres). If using dummy files from before, manually edit a few to assign genres and mark one as "played".
Plex Pass required for Optimization part. If no Plex Pass, only do the Smart Collection part.
A real media file (movie) for the optimization part.

Steps:

(Optional) Prepare Sample Data:
- If needed, manually edit a few movies in your library:
  - Select a movie -> Edit -> Tags -> Add a Genre (e.g., "Action", "Comedy"). Do this for a few movies, using at least two different genres.
  - Select one movie -> Edit -> General -> Mark as Played. Select another -> Mark as Unplayed.
Create a Smart Movie Collection:
- Go to your "Movies" library in the Plex Web App.
- Click the "All" dropdown (top left) to open filters.
- Select Filter -> Unplayed.
- Select Filter -> Genre -> Choose a genre you assigned (e.g., "Action").
- You should now see only unwatched Action movies.
- Click "Save As..." (top right).
- Select "Smart Collection".
- Name: Unwatched Action Flicks
- Description (Optional): Action movies I haven't seen yet
- Click "Save".
- Go back to the main library view. You should see your new Smart Collection listed (you might need to refresh or change the library sort order). Click into it to see the dynamically filtered contents.
Optimize a Movie Version (Requires Plex Pass and a real movie file):
- Choose a movie file in your library (ensure it's a real video file, not a dummy .mkv from touch).
- Click the ... menu on the movie poster -> Optimize...
- Target: Choose where the optimized version will be played (e.g., "Mobile", "TV"). Select "Mobile" for this exercise.
- Quality: Choose a profile (e.g., "2 Mbps 720p"). This creates a version suitable for mobile streaming over limited bandwidth.
- Storage: Leave as default ("In folder with original items") or choose another location if preferred.
- Note the estimated file size.
- Click "Optimize".
Monitor Optimization:
- Go to Settings (wrench icon) -> Conversions (under Status section).
- You should see the movie listed with its optimization progress. This may take time depending on the movie length/quality and your server hardware.
Verify Optimized Version:
- Once complete, go back to the movie's detail page in the library.
- Click "Get Info" (from the ... menu or usually an icon on the page).
- Scroll down. You should now see multiple versions listed, including the original and the newly created "Optimized for Mobile" version, showing its resolution and bitrate.
- (Bonus Test): If you try playing this movie on your mobile app using remote connection settings limited to 2 Mbps 720p or lower, Plex should choose the optimized version for Direct Play instead of transcoding the original. You can verify this via playback info or the server dashboard.

This workshop demonstrates how to use collections for better organization and (with Plex Pass) how optimization can proactively prepare files for specific playback scenarios, potentially improving performance and user experience.

Plex allows you to create managed accounts for family members within your home or share your libraries with friends who have their own Plex accounts.

Plex Home: Designed for families living in the same household.
- Benefits:
  - Centralized subscription: One Plex Pass covers premium features for all Home members.
  - Managed Users: Create accounts for family members (especially kids) that don't need their own email address. You control their restrictions.
  - Fast User Switching: Easily switch between profiles on shared client devices (like a living room TV).
  - Parental Controls (Plex Pass): Restrict access based on content ratings (G, PG, R, etc.) or specific labels.
- Setup:
  1. Go to Plex Web App -> Settings -> Plex Home (under Family & Friends).
  2. If you haven't set a PIN for your admin account, you'll be prompted to do so first. This prevents others from changing settings.
  3. Invite Existing Plex User: Enter the email address or username of a family member who already has a Plex account. They become a Home member.
  4. Create Managed User: Click "Create Managed User". Give them a username, set restrictions (which libraries they can access, content ratings - requires Plex Pass), and optionally set a PIN for their profile.
- Limitations: Plex Home is intended for people in the same household. While technically usable remotely, its primary design is local shared access. Max 15 members (including admin).
Sharing Libraries with Friends (Guest Accounts): Share specific libraries with friends or family who live elsewhere and have their own free Plex accounts.
- Benefits: Allows friends to access your curated content remotely. You control exactly which libraries they can access. Does not require Plex Pass for basic sharing (though some features shared from a Plex Pass server might benefit the friend).
- Setup:
  1. Go to Plex Web App -> Settings -> Manage Library Access (under Family & Friends).
  2. Click "Grant Library Access".
  3. Enter the email address or Plex username of the friend you want to invite. Click "Continue".
  4. Select Your Server.
  5. Choose which Libraries you want to share with this friend. Uncheck libraries you want to keep private.
  6. (Optional) Set Restrictions:
    - You can restrict based on content ratings or labels (similar to Managed Users, requires your Plex Pass).
    - Allow Sync (Requires your Plex Pass): Lets the friend sync content to their mobile device for offline viewing.
    - Allow Camera Upload: Lets the friend upload photos from their device to a photo library you share with them (use with caution).
  7. Click "Send Invitation" or "Save Changes".
- Friend's Perspective: The friend will receive an email or notification within Plex. They need to accept the invitation. Your server and shared libraries will then appear in their Plex clients alongside their own (if any) or other shared servers.
Monitoring User Activity: Keep track of who is watching what and how your server resources are being used.
- Plex Dashboard: The primary built-in tool.
  - Go to Plex Web App -> Activity icon (top right) -> Dashboard.
  - Now Playing: Shows currently active streams, including the user, client device, location (local/remote), stream quality (Direct/Transcode), and connection type (Direct/Indirect). Clicking the stream provides more detail (video/audio format, transcode reason if any). Essential for real-time monitoring.
  - Bandwidth Usage: Shows real-time LAN and Remote bandwidth usage.
  - CPU Usage: Basic graph of server CPU load.
  - RAM Usage: Basic graph of server RAM usage.
  - Top Played: Shows most played items recently.
  - Play History: A basic log of recently played items.
- Tautulli (Introduction): A popular, third-party application specifically designed for monitoring and statistics for Plex Media Server. It provides much more detailed information than the built-in dashboard.
  - Features: Rich playback history with filtering/searching, detailed user stats (watch time, popular content per user), real-time activity monitoring with more data, historical graphs (plays, bandwidth), customizable notifications (e.g., notify when a user starts watching, when new content is added), script integration, and much more.
  - Setup: Tautulli runs as a separate service (often in Docker). You configure it to connect to your Plex server via API keys.
  - Note: We will cover Tautulli installation and configuration in the Advanced section. For now, just be aware of its existence as the go-to tool for serious monitoring.

Goal: Create a Managed User within Plex Home and share a specific library with a friend's Plex account (you can use a secondary email/Plex account for testing if needed). Monitor activity via the Dashboard.

Prerequisites:

Your Plex Media Server running.
Your primary Plex account (Admin).
(Optional but Recommended) Plex Pass on the admin account to test restrictions.
(Optional) A secondary email address to create another free Plex account for testing the "Friend Share" part, or a real friend's Plex username/email who agrees to test.

Steps:

Set Admin Account PIN:
- Go to Plex Web App -> Account (top right icon) -> Account Settings.
- Under "Security", find the "Account PIN" section.
- Set a 4-digit PIN for your main admin account if you haven't already. This is required for Plex Home.
Create a Managed User (Plex Home):
- Go to Settings -> Plex Home.
- Click "Create Managed User".
- Username: KidZone
- (If you have Plex Pass) Restrictions:
  - Click "Edit Restrictions".
  - Select "Allow Only Ratings" -> Choose appropriate ratings (e.g., G, PG).
  - You can also restrict by specific labels if you use them.
  - Click "Save Restrictions".
- Library Access: By default, they might have access to all libraries. Click "Edit Access" -> Uncheck any libraries you don't want this user to see (e.g., maybe only allow access to a "Kids Movies" library if you had one). For now, leave access to your main Movie/TV libraries. Click "Save Access".
- Click "Save User".
- You should now see KidZone listed under Plex Home.
Test Managed User Access:
- In the Plex Web App, click your account icon (top right).
- You should see the option to "Switch User". Select KidZone.
- Enter the PIN if you set one for this user (if not, it might just switch).
- Browse the libraries. If you set rating restrictions, you should only see content matching those ratings. Content outside the allowed ratings should be hidden.
- Switch back to your admin account (Account Icon -> Switch User -> Select your admin profile -> Enter your admin PIN).
Invite a Friend (Share Libraries):
- (Optional) If testing yourself, create a new free Plex account using a secondary email address at plex.tv.
- Go to Settings -> Manage Library Access.
- Click "Grant Library Access".
- Enter the email address or Plex username of your friend (or your secondary test account). Click "Continue".
- Ensure your server is selected. Click "Continue".
- Choose which libraries to share. For example, share only your "Movies" library but not your "TV Shows" library.
- (Optional - Plex Pass) Review restriction options (ratings, labels, sync) but leave defaults for now unless desired.
- Click "Grant Access" (or "Send Invitation").
Accept Invitation (Friend's Perspective):
- Log into the Plex account you invited (your secondary account or have your friend do this).
- Check email for the invitation or look for a notification within the Plex app/website (sometimes under Settings -> Users & Sharing -> Friends).
- Accept the invitation.
- Now, using this friend account in a Plex client, they should see your server listed, and only the libraries you explicitly shared (e.g., "Movies" but not "TV Shows").
Monitor Activity:
- Using your admin account in the Plex Web App, go to Activity -> Dashboard.
- If your "friend" (or you using the second account) starts playing a movie from the shared library, you should see their session appear under "Now Playing".
- Note the username, client, and connection details (likely Remote/Direct if testing from outside your LAN, or Remote/Indirect if direct access failed).

This workshop demonstrates the two main ways to grant access to your Plex server: Plex Home for tightly integrated household use and Library Sharing for controlled remote access for friends, along with basic monitoring using the Dashboard.

Understanding Transcoding Deep Dive

Transcoding is one of Plex's most powerful features, but also the most resource-intensive. Understanding when and why it happens is crucial for optimizing performance and user experience.

What Triggers Transcoding? Transcoding occurs when the source media file is not directly compatible with the client device or the connection limitations. Plex Media Server converts the file (or parts of it) on-the-fly into a compatible format. Common triggers include:
- Video Codec Incompatibility: The client doesn't support the video codec used in the file (e.g., HEVC/H.265 file played on an old device that only supports H.264). Server transcodes video to H.264.
- Audio Codec Incompatibility: Client doesn't support the audio codec (e.g., DTS-HD MA 7.1 audio played on a stereo TV or mobile phone). Server transcodes audio to a compatible format (AAC, AC3, Opus). Audio transcoding is much less CPU-intensive than video.
- Container Incompatibility: Client supports the video/audio streams but not the container format (e.g., MKV file played on an Apple TV which prefers MP4/MOV). Server performs a "Direct Stream" - repackages the streams into a compatible container without re-encoding video/audio. Very low CPU usage.
- Resolution/Bitrate Limits: The client requests a lower resolution or bitrate than the source file due to:
  - Client Quality Settings: User explicitly set lower remote/local quality settings in the Plex app.
  - Bandwidth Constraints: Server detects insufficient internet upload speed (for remote streams) or client download speed. Plex automatically lowers quality (transcodes) to prevent buffering. This is common with low upload speeds or poor mobile connections.
  - Optimized Versions: If an optimized version matches the request, it's used instead of transcoding the original.
- Subtitle Burn-In: When image-based subtitles (PGS - common on Blu-rays, VOBSUB - common on DVDs) are selected, and the client app does not support rendering them directly, Plex must "burn" the subtitle text directly into the video frames. This forces a video transcode, even if the video/audio codecs were otherwise compatible. Text-based subtitles (SRT, ASS) are usually preferred as most clients can overlay them without forcing a transcode. You can configure subtitle settings in the client app (e.g., "Automatic" vs. "Always Burn") and on the server (Settings -> Server -> Language -> Subtitle mode).
Transcoding Pipeline (Simplified):
1. Demuxing: Server reads the source file and separates the container (e.g., MKV) into its individual streams (video, audio, subtitles).
2. Decoding: If video or audio needs conversion, the relevant stream is decoded from its original format (e.g., H.265 video, DTS audio) into raw, uncompressed data. This uses CPU or hardware decoders (NVDEC, QSV decode, VCN decode).
3. Filtering/Processing (Optional): Applying filters like subtitle burn-in, tone mapping (HDR to SDR conversion), or potentially scaling.
4. Encoding: The raw video/audio data is re-encoded into the target format required by the client (e.g., H.264 video, AAC audio) at the specified bitrate/resolution. This is usually the most intensive step and uses CPU or hardware encoders (NVENC, QSV encode, VCE encode).
5. Muxing: The newly encoded streams (or original streams if Direct Streamed/Played) are packaged into a container format suitable for the client (e.g., MP4, HLS).
6. Streaming: The resulting data is sent to the client over the network, often in segments (e.g., using HLS - HTTP Live Streaming).
CPU vs. Hardware Transcoding (Plex Pass Required):
- CPU Transcoding (Software): Uses the server's main CPU cores for decoding and encoding. Can handle most formats, but demanding transcodes (especially 4K or multiple 1080p streams) consume significant CPU resources, potentially leading to server slowdown or playback buffering if the CPU isn't powerful enough (refer back to PassMark scores).
- Hardware-Accelerated Streaming (Hardware Transcoding): Offloads parts of the transcoding pipeline (usually decoding and encoding, sometimes filtering like tone mapping) to dedicated hardware on the CPU's integrated graphics (Intel QSV, AMD VCN) or a dedicated graphics card (NVIDIA NVENC/NVDEC, AMD VCE).
  - Benefits: Drastically reduces CPU usage during transcodes, allows significantly more simultaneous transcodes on modest hardware, often more power-efficient than maxing out the CPU. Essential for servers that need to handle multiple transcodes frequently.
  - Requirements: Plex Pass subscription, compatible hardware (Intel CPU with QSV 6th Gen+, AMD Ryzen APU/GPU with VCN/VCE, NVIDIA GPU Maxwell 2nd Gen+), correct drivers installed on the server OS, and enabling the feature in Plex settings.
  - Limitations: Hardware capabilities vary (older QSV/NVENC might not support HEVC/10-bit efficiently), driver quality can matter (especially on Linux, though much improved), NVIDIA consumer cards have artificial session limits (often 3-5 encodes).
Configuring Transcoding Settings:
- Plex Web App -> Settings -> Transcoder:
  - Transcoder temporary directory: Location where Plex stores temporary transcode segments. By default, it's within the Plex data directory. If your OS drive is small or slow (not recommended), you might move this to a faster drive (SSD recommended) or even a RAM disk (advanced technique) with sufficient space. Ensure the plex user has write permissions. Needs enough space for multiple simultaneous transcodes (can be tens of GB).
  - Transcoder quality: Automatic (default), Prefer higher speed encoding, Prefer higher quality encoding, Make my CPU hurt. "Automatic" is usually fine. Higher speed uses less CPU but might result in slightly lower quality for the same bitrate. Higher quality does the opposite.
  - Background transcoding x264 preset: Controls the speed/quality trade-off for background tasks like Optimization or Media Optimizer. Slower presets = better quality/smaller files but take longer.
  - Use hardware acceleration when available: (Plex Pass) Check this box to enable hardware transcoding using QSV, NVENC, VCN, etc. Must have compatible hardware and drivers.
  - Use hardware-accelerated video encoding: (Plex Pass) Specifically enables using the hardware encoder. Usually enabled if the main option is checked.
  - (If detected) Hardware transcoding device: Allows selecting a specific GPU if multiple are present.
  - Maximum simultaneous video transcode: Limit the number of concurrent transcodes to prevent overloading the server. Defaults based on detection but can be adjusted.
Analyzing Transcoding Sessions:
- Plex Dashboard: The primary real-time tool.
  - Go to Activity -> Dashboard -> Expand a "Now Playing" session.
  - Video: Shows Original (Codec Res @ Bitrate) -> Transcoded (Codec Res @ Bitrate). If it says (HW) next to the decode or encode step, hardware acceleration is being used for that part. If transcoding, it usually provides a brief reason (e.g., "Video codec not supported," "Audio codec not supported," "Bitrate exceeds limit," "Subtitles are burning").
  - Audio: Shows Original (Codec Channels) -> Transcoded (Codec Channels).
- Plex Console / Logs: For deeper analysis.
  - Settings -> Console (under Manage section). Shows live log output. Can be noisy.
  - Settings -> Troubleshooting -> Download Logs. Provides zipped archives of all server logs. The Plex Media Server.log file contains detailed information about transcoding decisions (search for MDE:, TranscodeSession). Can be complex to interpret but invaluable for difficult issues.

Workshop Configuring and Analyzing Hardware Transcoding

Goal: Enable hardware transcoding (if you have Plex Pass and compatible hardware), trigger a transcode, and verify using the Plex Dashboard that hardware acceleration is active.

Prerequisites:

Plex Media Server running.
Plex Pass subscription active on your account.
Compatible Hardware:
- Intel CPU with Quick Sync Video (QSV) - 6th Generation Core (Skylake) or newer recommended for good HEVC support. Check Intel ARK website for your CPU model.
- OR AMD APU/GPU with VCN/VCE (Ryzen 2xxxG APU or newer, recent Radeon GPUs).
- OR NVIDIA GPU (GTX 9xx Maxwell 2nd Gen or newer, GTX 10xx Pascal highly recommended for HEVC).
Correct Drivers Installed:
- Linux: This is crucial.
  - Intel QSV: Usually requires installing intel-media-va-driver-non-free (Debian/Ubuntu) or similar packages, ensuring /dev/dri device nodes exist, and the plex user has permission to access them (often by adding plex to the render or video group: sudo usermod -aG render plex).
  - NVIDIA: Requires the official proprietary NVIDIA drivers installed, plus ensuring the driver version supports the NVENC/NVDEC features needed.
  - Check Plex documentation or community forums for specific driver setup steps for your Linux distribution and hardware.
- Windows: Install the latest graphics drivers from Intel, NVIDIA, or AMD.
A media file likely to trigger transcoding (e.g., an HEVC/H.265 file if your test client only supports H.264, or a high-bitrate 4K file you force to play at 1080p).
A Plex client device for playback testing.

Steps:

Verify Hardware and Drivers (Conceptual - OS Specific):
- Linux Example (Intel QSV):
  - Check for render device: ls /dev/dri (should show card0, renderD128, etc.)
  - Check driver package: dpkg -l | grep intel-media-va-driver
  - Check plex user group membership: groups plex (should include render or video). If not, add it: sudo usermod -aG render plex and restart the Plex service: sudo systemctl restart plexmediaserver.
- Linux Example (NVIDIA):
  - Check driver version: nvidia-smi
- Consult specific guides for your OS/Hardware if unsure.
Enable Hardware Acceleration in Plex:
- Go to Plex Web App -> Settings -> Transcoder.
- Check the box "Use hardware acceleration when available".
- Ensure "Use hardware-accelerated video encoding" is also checked.
- (Optional) If you have multiple GPUs, select the correct one from "Hardware transcoding device".
- Click "Save Changes".
Trigger a Transcode:
- Choose a media file that you know will require transcoding on your test client. For example:
  - Use a 4K HEVC file and play it on a client set to request 1080p quality.
  - Use an HEVC file and play it on an older device known only to support H.264.
  - Use a file with PGS subtitles and force subtitles to be shown (ensure client setting isn't "Only Image Formats" if it supports that, or set server subtitle mode to "Always Burn").
- Start playback on your chosen client device. Make sure it's actually transcoding (not Direct Playing). You might need to manually select a lower quality in the client's playback settings to force it.
Analyze the Session on the Dashboard:
- While the media is playing and transcoding, go to the Plex Web App on your computer.
- Click Activity -> Dashboard.
- Expand the "Now Playing" section for your streaming session.
- Look closely at the Video line.
  - If hardware acceleration is working for decoding, you should see OriginalCodec -> DecodeCodec (HW).
  - If hardware acceleration is working for encoding, you should see EncodeCodec (HW).
  - Example of Full HW Transcode: Video: 4K (HEVC Main 10) -> 1080p (H.264)—Transcode (HW) (This implies both HW decode of HEVC and HW encode to H.264 occurred).
  - Example of SW Transcode: Video: 4K (HEVC Main 10) -> 1080p (H.264)—Transcode (No (HW) indicates CPU/Software transcoding).
- Look at the CPU Usage graph on the Dashboard. With hardware transcoding active, the CPU usage should be significantly lower than if the same transcode was happening in software.
Troubleshooting (If no (HW) appears):
- Plex Pass: Double-check your subscription is active.
- Setting: Ensure "Use hardware acceleration..." is checked and saved in Transcoder settings.
- Restart Plex: After making driver or group changes, always restart the Plex server (sudo systemctl restart plexmediaserver).
- Drivers: This is the most common issue, especially on Linux. Verify correct drivers are installed and loaded, and permissions for /dev/dri (Intel/AMD) or NVIDIA devices are correct for the plex user. Check Plex logs (Plex Media Server.log) for errors related to vaapi (Intel/AMD) or nvenc/nvdec (NVIDIA).
- Hardware Compatibility: Ensure your specific CPU/GPU model actually supports hardware decoding/encoding for the source video codec (e.g., older hardware might not accelerate HEVC 10-bit).
- Codec/Format: Some very specific or obscure codecs might still fall back to software decoding even if hardware acceleration is generally working.

Successfully seeing the (HW) indicator on your Dashboard confirms that you've configured hardware acceleration correctly, allowing your server to handle transcodes much more efficiently.

Customizing the Plex Experience

Fine-tune server behavior, client settings, and subtitle handling to better suit your preferences and needs.

Advanced Server Settings: Explore the main server settings for deeper control:
- Settings -> Server -> Library:
  - Scan my library automatically: Detects changes in folders in real-time (requires filesystem support, usually works well on Linux/Windows/macOS). Generally recommended.
  - Run a partial scan when changes are detected: Updates only changed folders instead of rescanning everything. More efficient.
  - Scan my library periodically: Fallback scan interval if automatic detection fails or is disabled. Set frequency (e.g., hourly, daily).
  - Empty trash automatically after every scan: If checked, media that is deleted from your drive will be removed from the Plex library after the next scan confirms it's gone. Uncheck if you have network drives that might temporarily disconnect, to prevent accidental library removals.
  - Allow media deletion: Lets users with appropriate permissions delete media files directly from Plex clients (use with caution!). Requires specific user/owner permissions on the files/folders.
- Settings -> Server -> Scheduled Tasks:
  - Configure time windows for background maintenance tasks like database backups, metadata refreshing, optimization, etc. Set this to a period of low server usage (e.g., early morning hours).
  - Enable/disable specific tasks (e.g., Backup Database, Optimize Database, Refresh Local Metadata). Regularly optimizing the database is recommended for performance.
- Settings -> Server -> Network:
  - Secure connections: Prefer (default) or Required. "Required" forces HTTPS connections, which might break access from very old clients or certain network setups if not using a custom certificate/reverse proxy correctly. "Prefer" allows fallback to HTTP if needed. "Disabled" is not recommended.
  - Custom server access URLs: Useful if using a reverse proxy with a custom domain name (e.g., https://plex.mydomain.com). Enter the full URL here.
  - Enable Relay: Keep enabled as a fallback, even if you aim for direct connection.
  - (Other settings): LAN Networks (define your local subnets), Custom certificate options (for advanced HTTPS setup).
- Settings -> Server -> Language:
  - Prefer audio tracks in: Select your preferred language for automatic audio track selection.
  - Prefer subtitles in: Select preferred language for subtitles.
  - Subtitle mode: Controls automatic subtitle selection behavior (Manual, Shown with foreign audio, Always enabled). "Shown with foreign audio" is popular.
  - Prefer forced subtitles: Automatically select subtitles marked as "Forced" (typically translating only foreign dialogue parts).
Customizing Client Settings: Each Plex client app (Web, Mobile, TV, etc.) has its own settings menu. Explore these on your most-used devices:
- Video Quality: Adjust default Remote/Home streaming quality, Auto Adjust Quality (Plex Pass).
- Audio Settings: Enable audio passthrough (HDMI/Optical) if connecting to an AV receiver (clients like NVIDIA Shield, HTPC apps), normalize multi-channel audio.
- Subtitle Settings: Control size, color, position, burn-in behavior (e.g., "Automatic", "Only image formats", "Always"). Setting burn-in to "Only image formats" or "Never" on capable clients can help avoid unnecessary video transcoding.
- Interface: Customize home screen layout, library visibility, clock format, theme.
- Advanced: Player settings (e.g., H.264 level limits), network timeouts, logging levels.
Using Subtitles: Manage subtitle selection, formats, and automatic downloads.
- Formats:
  - Text-based (Preferred): SRT (SubRip Text) is the most common and widely compatible format. ASS/SSA (Advanced SubStation Alpha) supports advanced styling but compatibility varies more. Clients can usually overlay these without forcing a transcode.
  - Image-based (Avoid if possible): PGS (Presentation Graphic Stream - from Blu-rays), VOBSUB (from DVDs). These are essentially images of the subtitle text. Most clients cannot render these directly and require the server to burn them into the video, forcing a video transcode.
- Selection: During playback, use the playback settings menu to choose from available embedded or external subtitle tracks. You can also select "None" to turn them off.
- Naming External Subtitles: Place external subtitle files (e.g., .srt) alongside your video file. Name them correctly for Plex to detect them automatically:
  - Movie Title (Year).mkv
  - Movie Title (Year).eng.srt (English subtitles)
  - Movie Title (Year).fre.forced.srt (French "forced" subtitles)
  - TV Show (Year) - sXXeYY - Episode Title.mkv
  - TV Show (Year) - sXXeYY - Episode Title.eng.srt
  - Refer to Plex's subtitle naming guide for full details.
- Automatic Subtitle Download (via Agents): Plex can automatically search for and download subtitles from OpenSubtitles.org.
  1. Go to Settings -> Server -> Agents.
  2. Select Movies -> Plex Movie (or your active agent).
  3. Make sure "OpenSubtitles.org" is checked and enabled. Drag it higher in the list if you want to prioritize it.
  4. Click the gear icon next to OpenSubtitles.org. Enter your OpenSubtitles.org username/password (free account required). Select languages you want to download subtitles for.
  5. Repeat for Shows -> Plex TV Series agent.
  6. After setup, you can refresh metadata for items (or the whole library) to trigger subtitle searches. Downloaded subtitles are stored alongside Plex metadata, not with your media files.

Workshop Fine-tuning Server Settings and Subtitle Management

Goal: Adjust library scan settings, configure automatic subtitle downloads, and observe client subtitle handling.

Prerequisites:

Plex Media Server running.
Access to Plex Web App settings.
An OpenSubtitles.org account (free to create).
A movie or TV episode in your library that is likely to have subtitles available on OpenSubtitles (e.g., a popular English-language movie).
A Plex client device for testing playback.

Steps:

Adjust Library Scan Settings:
- Go to Settings -> Server -> Library.
- Ensure "Scan my library automatically" and "Run a partial scan when changes are detected" are checked (these are usually good defaults).
- Set "Scan my library periodically" to a longer interval, like "Every 12 hours" or "Daily", as a fallback.
- Decide on "Empty trash automatically after every scan". If your media storage is stable (internal drives, reliable NAS), leave it checked. If using sometimes-offline USB drives, consider unchecking it.
- Click "Save Changes".
Configure OpenSubtitles Agent:
- Go to Settings -> Server -> Agents.
- Click Movies -> Plex Movie.
- Find "OpenSubtitles.org" in the list. Check the box to enable it.
- Click the gear icon next to OpenSubtitles.org.
- Enter your OpenSubtitles.org Username and Password.
- Select the primary language you want subtitles for (e.g., "English"). You can select a secondary language if desired.
- Check "Hearing impaired subtitles" if you want those versions as well.
- Click "Save".
- Repeat the process under Shows -> Plex TV Series (or your active TV agent).
Trigger Subtitle Search:
- Navigate to a movie or TV show in your library that you think needs subtitles downloaded.
- Click the ... menu on the item -> Refresh Metadata.
- Monitor the Activity indicator. Plex should scan the item and query OpenSubtitles.
- Wait a minute or two for the search to complete.
Verify Subtitle Download and Selection:
- Select the item you just refreshed.
- Start playback on a Plex client (Web, Desktop, Mobile, TV).
- During playback, open the Playback Settings menu.
- Look at the "Subtitles" track list. You should now see one or more language options (e.g., "English (SRT)") that weren't there before, indicating the automatic download worked.
- Select an SRT subtitle track. Observe if it displays correctly overlaid on the video.
Observe Burn-In Behavior (Optional - if you have image subs):
- If you have a file with PGS or VOBSUB subtitles:
  - Start playback and select the image-based subtitle track.
  - Go to the Plex Dashboard (Activity -> Now Playing) on the web app and expand the session.
  - Check the Video line. It will likely show Transcode and mention "Subtitles are burning" or similar as the reason, even if the video was previously Direct Playing.
  - Go into the Client's subtitle settings and change the "Burn Subtitles" option (e.g., try "Only Image Formats" vs "Automatic" vs "Always") and see how it affects the Dashboard transcode status for both SRT and PGS/VOBSUB subtitles. (Note: Client capabilities vary).

This workshop helps you understand how to automate library maintenance and subtitle acquisition, and how subtitle format and client settings interact to determine whether transcoding is necessary.

Securing Your Plex Server

While Plex aims to be secure by default, taking extra steps is prudent, especially when exposing it for remote access.

Importance of Security: Your Plex server potentially contains personal media and handles user authentication. Protecting it prevents unauthorized access, data breaches, and misuse of your server resources. Key risks include unauthorized viewing, deletion of media, compromising the server OS itself, or using it as a pivot point into your home network.
Using HTTPS/SSL: Encrypts the connection between clients and your server, preventing eavesdropping, especially over the internet.
- Plex's Built-in SSL: Plex automatically provisions a *.plex.direct SSL certificate for your server for connections via its infrastructure (including app.plex.tv and Plex Relay). This provides basic encryption for standard remote access. By default, "Secure connections" is set to "Preferred" (Settings -> Network), using HTTPS when possible but allowing HTTP fallback. Setting it to "Required" enforces HTTPS but might break older clients or require careful configuration.
- Reverse Proxy Introduction (Nginx Proxy Manager / Traefik / Caddy): For more robust security, custom domain names (e.g., https://plex.myawesome. Kdomain), and centralized SSL certificate management (especially if running other services), using a reverse proxy is highly recommended.
  - How it Works: A reverse proxy sits in front of your Plex server (and potentially other services). Clients connect to the reverse proxy (e.g., https://plex.myawesome.domain) using standard HTTPS (port 443). The reverse proxy handles the SSL encryption/decryption and forwards the request internally to the Plex server (usually on http://<plex_server_ip>:32400).
  - Benefits:
    - Valid SSL certificates for your own domain via Let's Encrypt (free, automated).
    - Hides the default Plex port (32400) from the internet (only port 443 needs forwarding to the proxy).
    - Can provide additional security features (access control, rate limiting - more advanced).
    - Simplifies managing multiple services behind a single point of entry.
  - Tools: Nginx Proxy Manager (NPM - very user-friendly GUI, often run in Docker), Traefik (popular for Docker integration, config via labels or files), Caddy (automatic HTTPS).
  - Note: Setting up a reverse proxy is covered in the Advanced section. For basic security, ensuring "Secure connections" is "Preferred" or "Required" in Plex settings is the first step.
Network Security Best Practices:
- Firewall Rules: Configure the firewall on your server's operating system to only allow necessary incoming ports.
  - Local Access: Allow TCP 32400 from your local network subnet only (e.g., sudo ufw allow from 192.168.1.0/24 to any port 32400 proto tcp).
  - Remote Access (Direct): If using direct port forwarding without a reverse proxy, allow the specific external port you forwarded (e.g., sudo ufw allow 32400/tcp or sudo ufw allow 25384/tcp if using a custom port) from any.
  - Remote Access (Reverse Proxy): Only allow access to the proxy's ports (usually 80 for HTTP validation and 443 for HTTPS) from any. The proxy itself needs to reach Plex on 32400 locally, but that port doesn't need to be open to the internet.
  - Other Plex Ports: Plex uses other ports for discovery (GDM - UDP 32410, 32412-32414) and internal communication. Usually, allowing the main TCP port (32400) and related/established connections is sufficient for client access. See Plex documentation for a full list if needed.
  - Default Deny: Configure your firewall to deny all incoming traffic by default and only explicitly allow necessary ports/services. (sudo ufw default deny incoming, sudo ufw default allow outgoing, sudo ufw enable).
- Minimize Exposure: Only forward the ports absolutely necessary for remote access. Avoid opening unnecessary ports on your router.
- Strong Passwords & Account Security: Use a strong, unique password for your Plex account. Enable 2-Factor Authentication (2FA) on your Plex account if available (check Account settings on plex.tv). Ensure users you share with also use good security practices.
Keeping Plex Updated: Plex Inc. regularly releases updates for Plex Media Server that include new features, bug fixes, and importantly, security patches.
- Check for Updates: Periodically check for updates within the Plex Web App (Settings -> General under the Server section will show an update notification if available).
- Update Process:
  - Linux (.deb/repo): If you added the repository, use sudo apt update && sudo apt upgrade. If installed manually via .deb, download the new .deb and install it using sudo dpkg -i <new_package_file.deb>. The service usually restarts automatically.
  - Docker: Pull the new image (docker pull <image_name>:<tag>) and recreate the container (docker-compose up -d).
  - Windows/macOS/NAS: Use the built-in update mechanism or download the new installer.
- Frequency: Aim to install updates reasonably promptly after release, especially if they mention security fixes. Read release notes if available.

Workshop Basic Security Hardening Updates and Firewall

Goal: Ensure Plex Media Server is updated and configure basic firewall rules using ufw on Ubuntu/Debian for local and direct remote access scenarios.

Prerequisites:

Plex Media Server running on Ubuntu/Debian.
Terminal access with sudo privileges.
ufw (Uncomplicated Firewall) installed (sudo apt install ufw if needed).
Knowledge of your local network subnet (e.g., 192.168.1.0/24). Find it using ip a (look for your main network interface's inet address and change the last number to 0, adding /24).
You have decided whether you are using default port 32400 or a custom port for remote access (if enabled). Let's assume default 32400 for this workshop.

Steps:

Check for Plex Updates:
- Open Plex Web App -> Settings -> General (under your Server Name).
- Look for an "Update Available" notification and button.
- Note the installed version and the available version.
Update Plex (Using APT Repository Method):
- Open your server terminal.
- Run the update commands:
```
sudo apt update
sudo apt install plexmediaserver
# Or 'sudo apt upgrade' which upgrades all packages including Plex
```
- APT should download and install the latest version from the Plex repository (if added previously). The service should restart.
- Go back to the Plex Web App settings and verify the server version has been updated.
- (Alternative: If you installed via .deb download, download the new .deb and use sudo dpkg -i <new_plex.deb>)
Configure Basic ufw Rules:
- Enable ufw (if not already enabled):
```
sudo ufw enable
# Answer 'y' to proceed. This may disconnect SSH if rule not added yet!
# If disconnected via SSH, you might need console access to fix.
# FIRST, allow SSH if you use it: sudo ufw allow ssh (or sudo ufw allow 22/tcp)
```
- Set Defaults: Deny incoming, allow outgoing (good practice).
```
sudo ufw default deny incoming
sudo ufw default allow outgoing
```
- Allow SSH (Crucial if managing remotely):
```
sudo ufw allow ssh
# Or specify port: sudo ufw allow 22/tcp
```
- Allow Plex Local Access: Replace 192.168.1.0/24 with your actual local network subnet.
```
sudo ufw allow from 192.168.1.0/24 to any port 32400 proto tcp comment 'Plex Web UI Local'
```
- Allow Plex Remote Access (Direct - Port 32400): Only add this rule if you have configured port forwarding for remote access directly to port 32400.
```
sudo ufw allow 32400/tcp comment 'Plex Remote Access Direct'
```
  - (If using a custom forwarded port, e.g., 25384, use sudo ufw allow 25384/tcp comment 'Plex Remote Custom Port' instead).
  - (If using a reverse proxy later, you would typically remove this rule and allow 80/tcp and 443/tcp instead).
- Allow Plex Discovery (Optional - Local Network): Plex uses UDP ports for local discovery (GDM). This helps clients find the server automatically on the LAN.
```
sudo ufw allow proto udp from 192.168.1.0/24 to any port 32410 comment 'Plex GDM Discovery'
sudo ufw allow proto udp from 192.168.1.0/24 to any port 32412:32414 comment 'Plex GDM Discovery'
```
Check ufw Status:
```
sudo ufw status verbose
```
- Review the rules list. Ensure SSH, local Plex access, and remote Plex access (if needed) are allowed. Default policy should be deny incoming, allow outgoing.
Test Access:
- Try accessing Plex Web App from another computer on your local network. It should work (testing the allow from 192.168.1.0/24... rule).
- If you enabled remote access and added the corresponding ufw rule, test access from your phone using mobile data. It should still work.
- Try accessing a port that isn't allowed (e.g., try to telnet to a random port on your server from another machine) - it should be blocked by the firewall.

This workshop establishes essential security habits: keeping Plex updated and implementing a basic firewall configuration to restrict access only to necessary ports and origins, significantly improving your server's security posture.

3. Advanced Plex Operations

Ready to elevate your Plex game? This section explores more complex topics like containerization with Docker, securing remote access with a reverse proxy, integrating with automation tools, advanced monitoring, backup strategies, and performance tuning.

Running Plex in Docker

Containerizing Plex Media Server using Docker offers significant advantages in terms of isolation, portability, dependency management, and simplified updates.

Benefits of Docker for Plex:
- Isolation: Plex and its dependencies run in a self-contained environment (the container), separate from your host operating system. This prevents conflicts with other applications or system libraries.
- Portability: Easily move your Plex setup (configuration, metadata) to another Docker host by transferring the persistent volumes and the Docker Compose file.
- Reproducibility: Define your entire Plex setup (image version, volumes, ports, environment variables) in a configuration file (docker-compose.yml), ensuring consistent deployment.
- Simplified Updates: Updating Plex is often as simple as pulling the latest Docker image and recreating the container. Docker handles the application update process.
- Dependency Management: The Docker image includes all necessary libraries and dependencies for Plex, eliminating the need to manage them directly on the host OS.
- Running Multiple Instances (Advanced): Docker makes it easier to run multiple isolated instances of Plex if needed (though typically one is sufficient).
Docker Concepts Recap:
- Image: A read-only template containing the application (Plex), its runtime environment, and dependencies. You pull images from a registry (like Docker Hub).
- Container: A runnable instance of an image. It's isolated from the host and other containers but can interact via defined networks and ports.
- Volume: A mechanism to persist data generated by a container outside the container's lifecycle. Essential for storing Plex's configuration database, metadata, logs, and transcode cache, so they aren't lost when the container is updated or removed. Volumes map a directory inside the container to a directory on the host OS or a Docker-managed volume.
- Networking: Docker containers can communicate with each other and the outside world via different network modes (bridge, host, overlay). Bridge networking is common, where Docker creates a virtual network, and you map container ports to host ports.
- Docker Compose: A tool for defining and managing multi-container Docker applications using a YAML file (docker-compose.yml). Simplifies defining volumes, networks, environment variables, and container dependencies. Highly recommended for Plex setup.
Choosing a Plex Docker Image: Several popular options exist:
- Official Plex Image (plexinc/pms-docker): Maintained by Plex Inc. Generally provides the latest official releases quickly. Can sometimes have quirks related to permissions or hardware transcoding setup compared to community versions.
- LinuxServer.io Image (linuxserver/plex): Very popular community-maintained image. Known for excellent documentation, well-thought-out defaults (especially regarding user permissions - PUID/PGID), easier hardware transcoding setup on Linux, and often includes helpful patches or workarounds. Frequently updated. Often recommended, especially for users running Docker on Linux.

Docker Compose for Plex Setup (linuxserver/plex Example):

Create a directory on your host system to store your Plex Docker configuration (e.g., /opt/docker/plex).
Inside that directory, create a file named docker-compose.yml.
Paste the following content into the file, adjusting paths and variables as needed:

---
version: "3.8" # Use a recent compose file version
services:
    plex:
    image: linuxserver/plex:latest # Use the LSIO image, :latest tag
    container_name: plex           # Assign a specific name
    network_mode: host             # Easiest for local discovery & no port conflicts initially
                                    # Alternatively use bridge mode (see notes below)
    environment:
        - PUID=1000                  # Your User ID (run `id -u your_username`)
        - PGID=1000                  # Your Group ID (run `id -g your_username`)
        - TZ=Etc/UTC                 # Your Timezone (e.g., America/New_York, Europe/London)
        - VERSION=docker             # Set to 'docker' for LSIO images
        # - PLEX_CLAIM=claim-xxxxxxx # Use for initial server claim (get from plex.tv/claim), then remove/comment out
    volumes:
        - /path/to/host/plex/config:/config   # Map host config dir to container /config
        - /path/to/host/plex/transcode:/transcode # Map host transcode dir (optional, SSD recommended)
        - /path/to/your/movies:/data/movies   # Map host movies folder (read-only recommended)
        - /path/to/your/tvshows:/data/tvshows # Map host TV shows folder (read-only recommended)
        # Add more volumes for music, photos etc. following the pattern
    restart: unless-stopped        # Automatically restart container unless manually stopped
    # --- Hardware Transcoding (Uncomment and adjust for your hardware) ---
    # devices:
    #   - /dev/dri:/dev/dri  # For Intel QSV / AMD VAAPI on Linux
    # OR
    #   - /dev/nvidia0:/dev/nvidia0 # For NVIDIA (adjust device name if needed)
    #   - /dev/nvidiactl:/dev/nvidiactl
    #   - /dev/nvidia-uvm:/dev/nvidia-uvm
    # Add required NVIDIA environment variables if using NVIDIA drivers >= 470:
    # environment:
    #   ... (keep existing env vars)
    #   - NVIDIA_VISIBLE_DEVICES=all # Or specify GPU UUID
    #   - NVIDIA_DRIVER_CAPABILITIES=all
    # --- End Hardware Transcoding ---

# Notes on network_mode:
# 'host' mode: Shares the host's network stack. Simplest for discovery (mDNS/GDM works easily).
#              Plex runs directly on host IP:32400. Can cause port conflicts if other apps use 32400.
# 'bridge' mode (alternative): Creates a private Docker network. Requires mapping ports.
#              Replace 'network_mode: host' with:
# ports:
#   - 32400:32400/tcp  # Plex Web UI/API
#   - 3005:3005/tcp   # Plex Companion
#   - 8324:8324/tcp   # Plex Roku Control
#   - 32469:32469/tcp  # Plex DLNA Server
#   - 1900:1900/udp   # Plex DLNA Server (discovery)
#   - 32410:32410/udp  # GDM Discovery
#   - 32412:32412/udp  # GDM Discovery
#   - 32413:32413/udp  # GDM Discovery
#   - 32414:32414/udp  # GDM Discovery
#              With bridge mode, local discovery (GDM) might require extra config or specific client support.
#              Host mode is often easier for Plex beginners.

Managing Persistent Data:
- /config volume: CRITICAL. This mapped volume stores the Plex database, metadata, plugins, preferences, logs. Never lose this data. Ensure the host path (/path/to/host/plex/config) exists and the user specified by PUID/PGID has write permissions to it. Back this directory up regularly!
- /transcode volume: Optional but recommended. Maps the container's temporary transcode directory to the host. Point this to an SSD or a fast drive with plenty of space if you anticipate heavy transcoding. Ensure PUID/PGID user has write permissions.
- Media Volumes (/data/movies, /data/tvshows, etc.): Map the parent directories containing your media collections on the host to specific paths inside the container. Use the :/data/... convention shown. It's good practice to mount these as read-only (:ro) in Docker if Plex doesn't need write access (e.g., :/data/movies:ro), unless you use features like media deletion or potentially some types of local asset generation. Ensure PUID/PGID user has read permissions on the host media directories/files.
Hardware Transcoding with Docker:
- Requires passing the appropriate hardware device(s) from the host into the container.
- Intel QSV / AMD VAAPI (Linux): Pass the /dev/dri render nodes using the devices section in docker-compose.yml. Ensure the host user (PUID/PGID) is in the correct group (render or video) on the host system to access these devices.
- NVIDIA (Linux): Requires the NVIDIA container toolkit (nvidia-docker2) installed on the host. Pass the NVIDIA device files (/dev/nvidia*) using the devices section. For modern drivers (>=470), you also need to set the NVIDIA_VISIBLE_DEVICES and NVIDIA_DRIVER_CAPABILITIES environment variables as shown in the example compose file.
- Enable in Plex Settings: After setting up the compose file and starting the container, you still need to go into Plex Settings -> Transcoder -> Check "Use hardware acceleration when available".

Workshop Deploying Plex using Docker Compose with Hardware Transcoding

Goal: Deploy Plex Media Server using Docker Compose, leveraging the linuxserver/plex image, map persistent volumes, configure basic environment variables, and enable hardware transcoding (if applicable).

Prerequisites:

Docker and Docker Compose installed on your host system (Linux recommended for this workshop).
Your user's UID and GID (run id -u and id -g in the terminal).
Paths to your existing media directories (Movies, TV Shows).
A directory created on the host to store Plex config (e.g., /srv/docker/plex/config) and optionally transcode cache (/srv/docker/plex/transcode). Ensure your user has write access.
(Hardware Transcoding) Compatible hardware (Intel QSV, AMD, or NVIDIA) and necessary host drivers installed. Know the required device paths (/dev/dri or /dev/nvidia*) and if environment variables are needed (NVIDIA). Ensure your user is in the correct group (render or video) on the host for Intel/AMD.

Steps:

Create Project Directory:

# Choose a location like /srv/docker/ or ~/docker/
PLEX_DOCKER_DIR="/srv/docker/plex" # Or your preferred path
mkdir -p ${PLEX_DOCKER_DIR}/config
mkdir -p ${PLEX_DOCKER_DIR}/transcode # Optional, for transcode cache
cd ${PLEX_DOCKER_DIR}

# Set permissions for your user (replace 1000:1000 with your UID:GID if different)
# This ensures the container, running as PUID/PGID, can write here.
sudo chown -R 1000:1000 ${PLEX_DOCKER_DIR}

Create docker-compose.yml:
- Create a file named docker-compose.yml in the ${PLEX_DOCKER_DIR} directory.
- Paste the example YAML from the theory section above into this file.
Customize docker-compose.yml:
- network_mode: Decide between host (simpler) or bridge (more isolated, requires port mapping). Start with host if unsure.
- environment:
  - Set PUID and PGID to your actual user ID and group ID.
  - Set TZ to your correct timezone (e.g., America/Los_Angeles). Find yours from timedatectl list-timezones.
  - (First Run Only) Get a claim token from https://www.plex.tv/claim. Uncomment the PLEX_CLAIM= line and paste the token: PLEX_CLAIM=claim-xxxxxxxxxxxxxxxxx. Only use this the very first time you start the container.
- volumes:
  - Change /path/to/host/plex/config to your actual config path (e.g., ${PLEX_DOCKER_DIR}/config or /srv/docker/plex/config).
  - Change /path/to/host/plex/transcode to your actual transcode path (e.g., ${PLEX_DOCKER_DIR}/transcode).
  - Change /path/to/your/movies to the actual host path where your movie files are stored. Ensure this path exists and the PUID/PGID user can read it.
  - Change /path/to/your/tvshows similarly.
  - Add more volumes for other media types if needed. Consider adding :ro for read-only media mounts.
- devices (Hardware Transcoding):
  - If using Intel/AMD: Uncomment the /dev/dri:/dev/dri line.
  - If using NVIDIA: Uncomment the /dev/nvidia* lines and the NVIDIA environment variables. Ensure nvidia-container-toolkit is installed on the host.
  - If not using hardware transcoding, leave the entire devices: section and NVIDIA environment variables commented out or remove them.
- Save the docker-compose.yml file.
Start the Container:
- Ensure you are in the directory containing the docker-compose.yml file (cd ${PLEX_DOCKER_DIR}).
- Run:
```
docker-compose up -d
```
  Explanation: docker-compose up reads the yml file and creates/starts the services defined. -d runs the containers in detached mode (in the background).
- Docker will pull the linuxserver/plex image if you don't have it locally, then create and start the container.
Claim the Server (First Run Only):
- If you added the PLEX_CLAIM token, access the Plex UI immediately: http://<HOST_IP_ADDRESS>:32400/web.
- Log in with your Plex account. The server should be automatically claimed due to the token.
- IMPORTANT: Once claimed, stop the container (docker-compose down), comment out or remove the PLEX_CLAIM line from your docker-compose.yml, and restart the container (docker-compose up -d). Claim tokens expire quickly and should not be left in the configuration.
- If you didn't use a claim token, access http://<HOST_IP_ADDRESS>:32400/web and go through the standard web setup wizard to log in and claim the server (ensure you're accessing from the same local network or use an SSH tunnel as described in the basic installation section).
Configure Plex Libraries:
- Inside the Plex UI, set up your libraries again, but this time point them to the paths inside the container that you defined in the volumes section (e.g., /data/movies, /data/tvshows). Plex (running inside Docker) only sees the paths defined in the volume mappings.
Verify Hardware Transcoding (If Enabled):
- Go to Plex Settings -> Transcoder. Check "Use hardware acceleration when available" and Save.
- Trigger a transcode (as in the previous workshop) and check the Dashboard -> Now Playing section for the (HW) indicator next to the video transcode status.
Check Logs:
- View container logs: docker-compose logs -f (press Ctrl+C to stop following). Look for any errors during startup or operation.

You have now successfully deployed Plex using Docker Compose, with persistent storage and optional hardware acceleration configured. Updates are now as simple as running docker-compose pull && docker-compose up -d.

Setting Up a Reverse Proxy for Secure Remote Access

Using a reverse proxy enhances security, simplifies access with custom domains, and centralizes SSL certificate management. We'll use Nginx Proxy Manager (NPM) as it provides a user-friendly web interface, ideal for managing proxies without deep Nginx configuration knowledge.

Why Use a Reverse Proxy Recap:
- SSL Termination: Handles HTTPS encryption/decryption, providing valid SSL certificates (via Let's Encrypt) for your custom domain.
- Custom Domain: Access Plex via an easy-to-remember domain (e.g., https://plex.yourdomain.com) instead of IP address and port.
- Security: Hides the Plex server's internal IP and default port (32400) from the internet. Only the proxy ports (80/443) need to be exposed. Can add extra security layers like access lists or HTTP authentication (though Plex uses its own auth).
- Centralized Management: Manage access and SSL for multiple self-hosted services through one interface.
Prerequisites for Reverse Proxy:
- Domain Name: You need a registered domain name (e.g., mydomain.com) from a registrar like Namecheap, GoDaddy, Cloudflare Registrar, etc.
- DNS Control: Ability to add DNS records (specifically A or CNAME records) for your domain.
- Static Public IP (Recommended): While possible with dynamic DNS, a static public IP address from your ISP makes setup much simpler and more reliable. If dynamic, you'll need a dynamic DNS service (like DuckDNS, No-IP) configured.
- Port Forwarding: You need to forward ports 80 (for HTTP-01 Let's Encrypt validation) and 443 (for HTTPS traffic) from your router to the internal IP address of the machine running Nginx Proxy Manager. You should remove the port forward for Plex's default port (32400) if you had one.
- Docker and Docker Compose: NPM is most easily deployed as a Docker container.
Choosing a Reverse Proxy (Nginx Proxy Manager Focus):
- Nginx Proxy Manager (NPM): Web UI built on Nginx. Great for beginners, easy SSL management via Let's Encrypt, simple proxy host setup. Runs well in Docker.
- Traefik: Powerful, designed for cloud-native/Docker environments. Configuration often done via Docker labels or YAML files. Steeper learning curve initially but very automated.
- Caddy: Known for its automatic HTTPS by default. Simpler configuration files than Nginx/Apache. Good alternative.
- NGINX/Apache (Manual Config): Highly flexible but requires manually editing configuration files. Higher learning curve.

Deploying Nginx Proxy Manager (Docker Compose):

Create a directory for NPM: mkdir -p /srv/docker/npm
Create subdirectories for data and Let's Encrypt certs: mkdir /srv/docker/npm/data /srv/docker/npm/letsencrypt

Create docker-compose.yml in /srv/docker/npm:

version: '3.8'
services:
    app:
    image: 'jc21/nginx-proxy-manager:latest'
    container_name: npm
    restart: unless-stopped
    ports:
        # Public HTTP Port:
        - '80:8080'
        # Public HTTPS Port:
        - '443:4443'
        # Admin Web Port:
        - '8181:81' # Map internal admin port 81 to host 8181 (or choose another)
    environment:
        # These are the important settings
        DB_SQLITE_FILE: "/data/database.sqlite"
        # Uncomment the following lines if you want to use MySQL/MariaDB
        # DB_MYSQL_HOST: "db"
        # DB_MYSQL_PORT: 3306
        # DB_MYSQL_USER: "npm"
        # DB_MYSQL_PASSWORD: "npm"
        # DB_MYSQL_NAME: "npm"
        # If you uncomment the MySQL lines, you also need to uncomment the 'db' service below
    volumes:
        - ./data:/data
        - ./letsencrypt:/etc/letsencrypt
    # depends_on:
    #   - db # Uncomment if using MySQL/MariaDB

    # Uncomment this database service if you want to use MySQL/MariaDB instead of SQLite
    # db:
    #   image: 'jc21/mariadb-aria:latest'
    #   container_name: npm_db
    #   restart: unless-stopped
    #   environment:
    #     MYSQL_ROOT_PASSWORD: 'npm'
    #     MYSQL_DATABASE: 'npm'
    #     MYSQL_USER: 'npm'
    #     MYSQL_PASSWORD: 'npm'
    #   volumes:
    #     - ./data/mysql:/var/lib/mysql

Start NPM: cd /srv/docker/npm && docker-compose up -d

Configuring Nginx Proxy Manager for Plex:
1. Access NPM Web UI: Open http://<NPM_SERVER_IP>:8181.
2. Default Login: Email: admin@example.com, Password: changeme. You'll be forced to change these immediately.
3. DNS Setup: Go to your domain registrar or DNS provider. Create an A record pointing your desired subdomain (e.g., plex.yourdomain.com) to your public IP address. (If using dynamic DNS, ensure your DDNS client is running and point a CNAME record to your DDNS hostname). Allow time for DNS propagation.
4. Port Forwarding Check: Ensure ports 80 and 443 are forwarded on your router to the internal IP address of the machine running the NPM Docker container. Remove any existing forward for port 32400.
5. Add Proxy Host:
  - In NPM, go to Hosts -> Proxy Hosts -> Add Proxy Host.
  - Domain Names: Enter your full subdomain (e.g., plex.yourdomain.com).
  - Scheme: http (NPM talks to Plex internally over HTTP).
  - Forward Hostname / IP: Enter the internal IP address of your Plex server (the machine running Plex, or the Docker host IP if Plex is in bridge mode Docker).
  - Forward Port: 32400.
  - Enable Block Common Exploits (Recommended).
  - Enable Websockets Support (Important for Plex connectivity).
6. Configure SSL:
  - Go to the "SSL" tab for this proxy host entry.
  - Select "Request a new SSL Certificate" from the dropdown.
  - Enable "Force SSL" (Redirects HTTP requests to HTTPS).
  - Enable "HTTP/2 Support" (Recommended).
  - Provide your email address for Let's Encrypt notifications.
  - Agree to the Let's Encrypt ToS.
  - Click "Save".
7. Wait for Certificate: NPM will attempt to obtain the Let's Encrypt certificate using the HTTP-01 challenge (which requires port 80 to be correctly forwarded and accessible from the internet). The status icon should turn green (secure). If it fails, check DNS propagation, port forwarding for port 80, and NPM logs.
Configure Plex for Reverse Proxy:
1. Go to Plex Web App -> Settings -> Network.
2. Secure connections: Set to Preferred or Required. Required is safer if you know all your clients support HTTPS and the proxy setup is correct. Preferred offers a fallback.
3. Custom server access URLs: Enter your full HTTPS URL: https://plex.yourdomain.com. You can add multiple URLs separated by commas if needed (e.g., for local access via IP and remote via domain).
4. Click "Save Changes".
Testing:
- Try accessing Plex via https://plex.yourdomain.com. It should load securely (padlock icon in browser).
- Log out and log back into your Plex clients (especially mobile/TV) to ensure they pick up the new custom URL for remote connections. They should now connect via your domain over HTTPS (port 443).
- Verify remote access still works (e.g., phone on mobile data). Check the Plex Dashboard - connections should now originate from the reverse proxy's IP address locally, but the ultimate client IP might still be logged depending on proxy headers.

Workshop Securing Plex with Nginx Proxy Manager and Let's Encrypt

Goal: Set up Nginx Proxy Manager (NPM) in Docker, configure it to reverse proxy Plex using a custom subdomain and a valid Let's Encrypt SSL certificate.

Prerequisites:

Plex Media Server running (either native or Docker). Know its internal IP address.
Docker and Docker Compose installed.
A registered domain name (yourdomain.com) and access to its DNS settings.
Your public IP address (ideally static). If dynamic, set up a Dynamic DNS service first.
Router access to forward ports 80 and 443 to the host running NPM. Ensure port 32400 is not forwarded anymore.
A chosen subdomain (e.g., plex.yourdomain.com).

Steps:

DNS Setup:
- Log in to your domain registrar/DNS provider.
- Create an A record for your chosen subdomain (e.g., plex) pointing to your public IP address.
- Example: Record Type: A, Name/Host: plex, Value/Points to: YOUR_PUBLIC_IP_ADDRESS, TTL: Automatic/Default.
- Save the record. Wait 5-15 minutes for initial propagation (can take longer). You can use nslookup plex.yourdomain.com or online DNS checkers to see if it resolves correctly to your public IP.
Port Forwarding Setup:
- Log in to your router.
- Remove any existing port forward rule for port 32400 (or your custom Plex port).
- Create a new rule to forward TCP Port 80 (External) to Port 80 (Internal) on the internal IP address of the machine that will run Nginx Proxy Manager.
- Create another rule to forward TCP Port 443 (External) to Port 443 (Internal) on the same internal IP address.
- Save changes on the router.
Deploy Nginx Proxy Manager:
- Create directories:
```
mkdir -p /srv/docker/npm/data /srv/docker/npm/letsencrypt
cd /srv/docker/npm
```
- Create the docker-compose.yml file from the theory section (using SQLite, ports 80:8080, 443:4443, 8181:81).
- Start NPM: docker-compose up -d
Initial NPM Login and Setup:
- Access NPM UI: http://<NPM_HOST_IP>:8181.
- Log in with admin@example.com / changeme.
- Change the admin email and password immediately when prompted.
Add Plex Proxy Host in NPM:
- Go to Hosts -> Proxy Hosts -> Add Proxy Host.
- Domain Names: plex.yourdomain.com (use your actual subdomain).
- Scheme: http
- Forward Hostname / IP: Internal IP address of your Plex server (e.g., 192.168.1.100).
- Forward Port: 32400
- Enable: Block Common Exploits.
- Enable: Websockets Support.
- Go to the SSL tab.
- SSL Certificate: Select "Request a new SSL Certificate".
- Enable: Force SSL.
- Enable: HTTP/2 Support.
- Email Address: Enter your real email address.
- Agree to ToS: Check the box.
- Click Save.
- Wait for NPM to obtain the certificate. The status icon next to the host entry should turn green/secure. Troubleshoot (DNS, port 80 forwarding) if it fails.
Configure Plex Network Settings:
- Access Plex normally (e.g., via local IP http://<PLEX_IP>:32400/web).
- Go to Settings -> Network.
- Secure connections: Set to Required (or Preferred if you anticipate issues).
- Custom server access URLs: Enter https://plex.yourdomain.com (use your actual URL).
- Click "Save Changes".
Test Secure Remote Access:
- Wait a few minutes.
- Try accessing https://plex.yourdomain.com in your browser. It should load the Plex UI securely over HTTPS.
- On your smartphone (using mobile data, not Wi-Fi), log out of the Plex app and log back in. It should connect using the secure custom domain. Try playing media.
- Check the Plex Dashboard -> Now Playing. The connection should be secure.

You have now successfully secured your Plex remote access using Nginx Proxy Manager, a custom domain, and a valid Let's Encrypt SSL certificate, significantly improving your security and usability.

Integration with Other Services The Arr Stack

Automate the process of discovering, downloading, and organizing your media library using a suite of popular tools often referred to as the "*Arr stack". These integrate seamlessly with Plex.

Introduction to Sonarr, Radarr, Lidarr, Prowlarr, Bazarr:
- Radarr: Monitors multiple sources (indexers via Prowlarr) for movies you want. When a desired movie becomes available (based on quality profiles you set), it can automatically grab the download file (e.g., a .torrent or NZB file) and send it to your download client (e.g., qBittorrent, Sabnzbd). Once downloaded, Radarr renames the file according to your specifications and moves it to your Plex movies directory, triggering a library scan in Plex.
- Sonarr: Does the same thing as Radarr, but specifically for TV shows. It monitors for new episodes of series you add, grabs them when available in the desired quality, sends to download client, renames (Show Title - sXXeYY - Episode Title.ext), moves to your Plex TV shows directory, and notifies Plex.
- Lidarr: Similar concept, but for music. Monitors artists, grabs albums when available in desired formats/bitrates, sends to downloader, renames/tags, moves to music library, notifies Plex (or other music players).
- Prowlarr: Acts as a central management hub for your indexers (sites that list torrent/NZB files) and trackers. You configure your indexer site accounts/APIs in Prowlarr once, and then Radarr, Sonarr, Lidarr connect to Prowlarr to perform searches across all configured indexers. Simplifies indexer management.
- Bazarr: Works alongside Radarr and Sonarr to automatically find and download matching subtitles for your movies and TV episodes based on configurable criteria (languages, formats, sources like OpenSubtitles).
Automating Media Acquisition and Management Flow:
1. Add Request: You add a movie to Radarr or a TV show to Sonarr (either manually or via lists/external tools). You specify the desired quality profile (e.g., "1080p Blu-ray", "Any WEBDL").
2. Search: Radarr/Sonarr periodically searches configured indexers (via Prowlarr) for releases matching the request and quality profile.
3. Grab: When a matching release is found, Radarr/Sonarr grabs the download link (.torrent/NZB).
4. Send to Downloader: The link is sent to your configured download client (e.g., qBittorrent, Deluge, Sabnzbd, NZBGet).
5. Download: The download client downloads the actual media file(s).
6. Import & Rename: Radarr/Sonarr monitors the download client. Once the download is complete, Radarr/Sonarr copies or hardlinks/moves the file, renames it according to your specified naming convention (crucial for Plex!), and places it into the final media library directory (e.g., /media/plex/movies/Movie Title (Year)/Movie Title (Year).mkv).
7. Notify Plex: Radarr/Sonarr sends a notification to your Plex Media Server, telling it to scan the library updates, making the new media appear quickly.
8. (Optional) Subtitles: Bazarr scans your library, identifies media missing desired subtitles, searches subtitle providers, downloads matching SRT/etc files, and places them alongside the media file.
Connecting *Arr Tools to Plex: The primary connection is for notifications and library awareness.
1. Enable Plex API: In Radarr/Sonarr/Lidarr/Bazarr settings, find the "Connect" or "Notifications" section.
2. Add Plex Media Server Notification:
  - Select "Plex Media Server".
  - Configure the connection details:
    - Hostname/IP: Your Plex server's internal IP address (or plex if using Docker bridge network and connecting containers).
    - Port: 32400 (unless changed).
    - Use SSL: Check if using HTTPS (e.g., via reverse proxy).
    - Username/Password: Your Plex admin username and password OR (better) obtain an Authentication Token from Plex (Settings -> Authorized Devices -> click X on one, then "Get an XML file", look for Plex-Token="...") and paste the token into the *Arr tool's password field (leaving username blank often works). Using a token is more secure than storing your password directly.
  - Test Connection: Use the "Test" button in the *Arr tool to verify it can reach your Plex server.
  - Configure Triggers: Choose when to send notifications (e.g., "On Grab", "On Download/Import", "On Upgrade"). "On Download/Import" is key for triggering library scans.
  - Update Library: Ensure the option to trigger a library scan in Plex upon import is enabled.
Basic Configuration Examples:
- Docker Compose: The *Arr stack is perfectly suited for Docker. You'd add services for Radarr, Sonarr, Prowlarr, Bazarr, and your download client(s) to your docker-compose.yml, linking them via Docker networks and mapping their respective config volumes and potentially download directories.
- Root Folders: In Radarr/Sonarr/Lidarr, you must configure the "Root Folder" - this is the final destination where media should be placed (e.g., /movies inside the Radarr container, which maps to /path/to/your/movies on the host - the same path Plex uses).
- Download Client Integration: Configure connection details (IP, port, API key/password) for your download client(s) within each Arr app. Set up "Categories" in your download client (e.g., movies, tv) and configure the Arr tools to assign these categories so they know which downloads to monitor.
- Quality Profiles: Define profiles based on resolution (720p, 1080p, 2160p), source (Blu-ray, WEBDL, HDTV), and codecs. The *Arr tools will prioritize releases matching your preferred profiles.
- Indexers (via Prowlarr): Add your indexer site credentials/APIs to Prowlarr. Test them. Then in Radarr/Sonarr/Lidarr, add Prowlarr as the indexer source.
Ethical Considerations: Be aware of copyright laws in your jurisdiction. Use these tools responsibly and only for acquiring media you are legally entitled to possess or access. Many users utilize these tools primarily to manage Linux ISOs or other legitimate large file transfers.

Workshop Integrating Radarr and Sonarr with Plex

Goal: Set up Radarr and Sonarr (preferably in Docker), connect them to Plex for notifications/library scans, and configure basic settings (root folder, quality profile). This workshop focuses on the *Arr-Plex connection, not the full download client/indexer setup which is complex.

Prerequisites:

Plex Media Server running (native or Docker). Know its internal IP/hostname and port (32400).
Docker and Docker Compose installed.
Paths to your host media folders for Movies and TV Shows.
Your Plex username/password OR preferably an Authentication Token.
User UID/GID for Docker permissions (id -u, id -g).

Steps:

Add Radarr/Sonarr to Docker Compose:

Choose a base directory (e.g., /srv/docker/arr). Create subdirectories for Radarr config (/srv/docker/arr/radarr_config) and Sonarr config (/srv/docker/arr/sonarr_config). Set permissions (sudo chown -R PUID:PGID /srv/docker/arr).

Edit your main docker-compose.yml (or create a new one in /srv/docker/arr). Add services for Radarr and Sonarr (using linuxserver/radarr and linuxserver/sonarr images is recommended):

# Add these services to your existing compose file or a new one
services:
  # ... (Your Plex service, NPM service if any) ...

  radarr:
    image: linuxserver/radarr:latest
    container_name: radarr
    environment:
      - PUID=1000 # Your UID
      - PGID=1000 # Your GID
      - TZ=Etc/UTC # Your Timezone
    volumes:
      - /srv/docker/arr/radarr_config:/config # Map Radarr config
      - /path/to/your/movies:/movies        # Map Movies library (ensure PUID/GID can read/write)
      - /path/to/your/downloads:/downloads  # Map download client's completed folder (read-only recommended if possible after import)
    ports:
      - 7878:7878 # Radarr Web UI Port
    restart: unless-stopped

  sonarr:
    image: linuxserver/sonarr:latest
    container_name: sonarr
    environment:
      - PUID=1000 # Your UID
      - PGID=1000 # Your GID
      - TZ=Etc/UTC # Your Timezone
    volumes:
      - /srv/docker/arr/sonarr_config:/config # Map Sonarr config
      - /path/to/your/tvshows:/tv           # Map TV Shows library (ensure PUID/GID can read/write)
      - /path/to/your/downloads:/downloads  # Map download client's completed folder
    ports:
      - 8989:8989 # Sonarr Web UI Port
    restart: unless-stopped

# Optional: Define a network if Plex/NPM are also in Docker for easier inter-container comms
# networks:
#   default:
#     name: my_proxy_network # Or whatever network your Plex/NPM uses

Adjust: PUID, PGID, TZ, volume paths (/path/to/your/movies, /path/to/your/tvshows, /path/to/your/downloads). The /movies and /tv volume targets inside the containers are important - these are the paths Radarr/Sonarr will use. /downloads should map to where your (future) download client saves completed files. Ensure the PUID/PGID user has write access to the media library paths (/movies, /tv) on the host, as Radarr/Sonarr need to move files there.
If Plex is also in Docker on the same bridge network, you can use container names (e.g., plex) instead of IP addresses for connections. If using host network mode for Plex, use the host IP.
Start the containers: docker-compose up -d (from the directory with the yml file).

Configure Radarr:
- Access Radarr Web UI: http://<DOCKER_HOST_IP>:7878.
- Go through the initial setup if prompted.
- Media Management:
  - Go to Settings -> Media Management.
  - Enable "Rename Movies". Review the naming convention (Standard format is usually fine for Plex).
  - Root Folders: Click + -> Add Root Folder. Enter the path inside the container where movies should go (e.g., /movies). Click "Save". This MUST match the target side of your movies volume mount in docker-compose.yml.
- Quality Profiles:
  - Go to Settings -> Profiles. Review the default profiles (e.g., "Any", "HD-1080p"). You can customize these later based on preferred sources/resolutions.
- Connect to Plex:
  - Go to Settings -> Connect -> Click + -> Add Notification -> Select "Plex Media Server".
  - Name: Plex Connection
  - Triggers: Check "On Grab", "On Import" (was On Download), "On Upgrade". "On Import" is key for library scans.
  - Host: IP address of your Plex server (e.g., 192.168.1.100 or plex if networked in Docker).
  - Port: 32400.
  - Authentication Method: Choose Username/Password or (better) Authentication Token.
  - Username: (Leave blank if using token) Your Plex username.
  - Password: Your Plex password OR your Plex Authentication Token.
  - Click "Test". It should show success. If not, check IP/port/credentials/token/SSL setting.
  - Enable "Update Library": Check this box.
  - Click "Save".
Configure Sonarr:
- Access Sonarr Web UI: http://<DOCKER_HOST_IP>:8989.
- Initial setup if prompted.
- Media Management:
  - Go to Settings -> Media Management.
  - Enable "Rename Episodes". Ensure "Standard Episode Format" is selected (good for Plex).
  - Root Folders: Click + -> Add Root Folder. Enter the path inside the container (e.g., /tv). Click "Save". Match the volume target in docker-compose.yml.
- Quality Profiles:
  - Settings -> Profiles. Review/customize as needed.
- Connect to Plex:
  - Settings -> Connect -> Click + -> Add Notification -> Select "Plex Media Server".
  - Configure identically to Radarr (Name, Triggers, Host, Port, Auth Method, Credentials/Token, Test, Enable "Update Library", Save).
Test the Integration (Manual Import Simulation):
- (Optional - Requires a sample file) Place a correctly named movie file (e.g., Some Movie (2023).mkv) into the /downloads directory that Radarr monitors.
- In Radarr, go to "Activity" or look for "Manual Import" options (under Wanted). Point it to the /downloads folder. Radarr should detect the file, allow you to match it to a movie entry, and import it.
- Check your actual movie library directory on the host - the file should be moved/copied and renamed.
- Check Plex - it should automatically perform a library scan (triggered by Radarr's notification) and the movie should appear relatively quickly.

This workshop sets up the foundational connection between the *Arr tools and Plex. While we didn't configure indexers or download clients (which are needed for full automation), the critical link enabling automatic library updates upon import is now established.

Advanced Monitoring with Tautulli

While the Plex Dashboard provides basic real-time stats, Tautulli offers significantly more detailed historical data, user tracking, statistics, and notification capabilities.

What is Tautulli? A free, open-source, third-party web application specifically designed to monitor your Plex Media Server activity. It runs separately from Plex but connects to it via the Plex API.
Why Use Tautulli?
- Detailed Playback History: Log every play, including user, IP address, client, duration, time, quality, transcode decision (with HW indicator), stream type (direct/indirect). Searchable and filterable.
- User Statistics: Track individual user watch times, most played content, platform usage, completion rates, last seen, etc.
- Library Statistics: See most popular movies/shows/artists across all users, recently added media overview.
- Real-Time Activity: More detailed "Now Playing" screen than the Plex Dashboard, often showing more granular transcode info or stream details.
- Historical Graphs: Visualize trends like plays over time, concurrent stream counts, bandwidth usage.
- Customizable Notifications: Set up detailed notifications via various agents (Email, Discord, Slack, Telegram, Webhooks, etc.) for events like:
  - Playback start/stop/pause/resume (per user or globally).
  - New content added to Plex.
  - User concurrent stream limit exceeded.
  - Transcoding started (with/without HW acceleration).
  - Remote access down/up.
  - Errors encountered during playback.
- Scripting: Trigger custom scripts based on playback events (e.g., dim lights when playback starts, control other smart home devices).
- Newsletters: Automatically generate and send newsletters to users highlighting recently added media.

Installation (Docker Recommended): Tautulli is easily deployed via Docker.

Add to your docker-compose.yml:

services:
    # ... (Plex, Arr tools, etc.) ...

    tautulli:
    image: linuxserver/tautulli:latest
    container_name: tautulli
    environment:
        - PUID=1000 # Your UID
        - PGID=1000 # Your GID
        - TZ=Etc/UTC # Your Timezone
    volumes:
        - /srv/docker/tautulli/config:/config # Map Tautulli config volume
        # Optional: Map Plex logs directory (read-only) for richer data
        - /path/to/host/plex/config/Library/Application Support/Plex Media Server/Logs:/plex_logs:ro
    ports:
        - 8182:8181 # Tautulli Web UI Port (use a different host port than NPM, e.g., 8182)
    restart: unless-stopped
    # If Tautulli and Plex are in the same Docker bridge network:
    # depends_on:
    #   - plex # Ensure Plex starts first (optional)

Adjust: PUID, PGID, TZ, config volume path (/srv/docker/tautulli/config), Plex logs volume path (/path/to/host/plex/config/.../Logs - this path depends on whether Plex is native or Docker, find the correct host path to the Logs subdir within the Plex config). Host port (8182).
Create the Tautulli config directory on the host and set permissions (sudo mkdir -p /srv/docker/tautulli/config && sudo chown -R PUID:PGID /srv/docker/tautulli).
Start the container: docker-compose up -d.

Connecting Tautulli to Plex:
1. Access Tautulli Web UI: http://<DOCKER_HOST_IP>:8182 (or your chosen host port).
2. Tautulli will likely start a setup wizard.
3. Plex Authentication: Choose "Sign in with Plex". Log in using your Plex account credentials. Tautulli will fetch an API token.
4. Plex Server Settings:
  - Verify the Plex IP Address/Hostname and Port are detected correctly (use internal IP/hostname if on the same network/Docker network).
  - Plex Logs Folder (Optional but Recommended): If you mapped the Plex logs volume in Docker, enter the path inside the Tautulli container where you mapped it (e.g., /plex_logs). This allows Tautulli to parse logs for more detailed info (like transcode reasons).
5. Click "Verify Server". It should connect successfully.
6. Complete the wizard (username/password for Tautulli itself, etc.).
Exploring Tautulli Features:
- Home Page: Dashboard overview of current activity, library stats, user activity.
- Activity: Real-time "Now Playing" details.
- Libraries: Browse library stats, most popular items.
- Users: View detailed stats per user.
- History: Searchable and filterable log of all playback activity.
- Graphs: Visualize historical data.
- Settings: Extensive configuration options:
  - Plex Media Server: Manage connection, API key.
  - Notification Agents: Configure Discord, Email, etc.
  - Triggers: Define which events trigger which notification agents (using Notification IDs).
  - Newsletters: Configure recently added content summaries.
  - Scripts: Set up custom script triggers.
Custom Scripts and Notifications:
- Notifications: Go to Settings -> Notification Agents -> Add Agent. Select type (e.g., Discord). Configure API keys/webhooks. Note the Agent ID.
- Triggers: Go to Settings -> Triggers -> Add Trigger. Select event (e.g., "Playback Start"). Optionally add conditions (e.g., User is 'FriendName', Stream Type is 'transcode'). Select the Notification Agent ID to send the notification to. Customize the message body using available parameters (e.g., {user}, {title}, {player}).
- Scripts: Similar process, but select "Script" as the agent, provide the path to the script inside the container (requires mapping script folder as a volume), and pass parameters.

Workshop Setting Up Tautulli and Creating Custom Notifications

Goal: Install Tautulli via Docker, connect it to your Plex server, and set up a basic notification (e.g., to Discord, or just view in Tautulli logs) when a user starts playing media remotely.

Prerequisites:

Plex Media Server running.
Docker and Docker Compose installed.
Host path to your Plex Logs directory (find it within your Plex config directory).
User UID/GID.
(Optional) Discord Account and Server: To test Discord notifications, you need a Discord account and a server where you can create a Webhook URL (Server Settings -> Integrations -> Webhooks -> New Webhook). Copy the Webhook URL.

Steps:

Add Tautulli to Docker Compose:
- Edit your docker-compose.yml. Add the Tautulli service definition from the theory section.
- Crucially, update the volume mapping for Plex logs: Find the host path to your Plex Media Server Logs directory. Update the line: - /path/to/host/plex/config/Library/Application Support/Plex Media Server/Logs:/plex_logs:ro Replace /path/to/host/plex/config/.../Logs with the actual path. (If Plex is Dockerized via LSIO, the host path might be something like /srv/docker/plex/config/Library/Application Support/Plex Media Server/Logs).
- Ensure PUID, PGID, TZ, and the Tautulli config volume are correct. Choose a host port (e.g., 8182).
Deploy Tautulli:
- Create Tautulli config dir: mkdir -p /srv/docker/tautulli/config && sudo chown -R PUID:PGID /srv/docker/tautulli
- Start the container: docker-compose up -d (from the directory with the yml file).
Configure Tautulli:
- Access Tautulli: http://<DOCKER_HOST_IP>:8182.
- Follow the setup wizard:
  - Sign in with your Plex account.
  - Verify Plex Server details (IP/hostname, port).
  - Plex Logs Folder: Enter /plex_logs (the path inside the Tautulli container).
  - Click "Verify Server".
  - Set a username and password for accessing Tautulli itself.
  - Finish the wizard.
Configure Notification Agent (Discord Example):
- (Skip if not using Discord) Go to Tautulli Settings -> Notification Agents -> Add a New Notification Agent -> Select Discord.
- Webhook URL: Paste your Discord Webhook URL.
- Username: (Optional) Name for the bot posting the message (e.g., "TautulliBot").
- Click "Test Notification". You should see a test message appear in your Discord channel.
- Click "Save". Note the Agent ID assigned (e.g., 1).
Configure Notification Trigger:
- Go to Settings -> Triggers -> Add a New Trigger.
- Trigger: Select Playback Start.
- Conditions (To notify only for remote plays):
  - Click + Add Condition.
  - Condition {1}: Select Location. Operator: is. Value: WAN.
  - (Optional) Add more conditions (e.g., specific user, specific content).
- Notifications:
  - Agent: Select the Discord agent ID you just created (e.g., 1). (If not using Discord, you can select Agent ID 0, which logs to Tautulli's own logs).
  - Subject/Body: Customize the notification message using parameters listed below the text boxes. Example Body:
```
▶️ Playback Started (Remote)!
User: {user} ({friendly_name})
Title: {title} ({year})
Player: {player} on {platform}
Quality: {video_full_resolution}@{stream_video_bitrate}kbps ({video_decision})
IP Address: {ip_address}
```
- Click "Save".
Test the Notification:
- Start playing media on your Plex server using a client connected remotely (e.g., phone on mobile data).
- Check your Discord channel (or Tautulli Logs if using Agent ID 0: View Logs -> Filter by Notifications). You should receive the notification you configured, detailing the remote playback session start.
- Start playback locally (on Wi-Fi) - you should not receive the notification because the condition (Location is WAN) wasn't met.

This workshop introduces the power of Tautulli for detailed monitoring and demonstrates how to set up conditional notifications, giving you much greater insight and control over your Plex server usage.

Backup and Recovery Strategies

Protecting your Plex setup involves backing up the essential configuration and metadata, separate from backing up your actual media files. Losing the Plex data means losing all your watch history, collections, custom metadata edits, and server settings.

What to Back Up (Plex Data): The most critical part is the Plex Media Server data directory. The exact location varies by OS and installation method:
- Linux (Native Install): Usually /var/lib/plexmediaserver/Library/Application Support/Plex Media Server/
- Linux (Docker - LSIO Image): The host directory mapped to /config in your docker-compose.yml (e.g., /srv/docker/plex/config/). Inside this, the structure mirrors the native install (Library/Application Support/Plex Media Server/).
- Windows: %LOCALAPPDATA%\Plex Media Server\
- macOS: ~/Library/Application Support/Plex Media Server/
- Key Subdirectories/Files within Plex Media Server:
  - Metadata/: Contains posters, artwork, theme music etc. Can be large but potentially regenerated (slowly) if lost.
  - Media/: Contains analysis files, chapter thumbnails, etc. Also potentially regeneratable.
  - Plug-in Support/Databases/: CRITICAL. Contains the main server database (com.plexapp.plugins.library.db) including libraries, metadata links, watch history, collections, settings. Also includes the Blobs database. Losing this is the worst outcome.
  - Preferences.xml: CRITICAL. Contains core server settings, claim token, custom URLs etc.
  - Plug-ins/ (If you use custom plugins).
  - Codecs/ (Downloaded transcoder codecs, can be redownloaded).
- Recommendation: Back up the entire Plex Media Server directory (or the host directory mapped to /config in Docker). While some parts can be regenerated, restoring the whole directory is the easiest and most complete recovery method.
Backup Methods:
- Manual Copy (Simple, Not Ideal): Periodically stop the Plex server process/container and simply copy the entire data directory to a backup location (external drive, NAS, cloud storage). Requires manual intervention and server downtime.
- Scheduled Scripting (Recommended): Create a script (Bash on Linux, PowerShell on Windows) that:
  1. (Optional but Safest) Stops the Plex Media Server process/container to ensure database consistency.
  2. Uses a tool like rsync (Linux) or robocopy (Windows) to efficiently copy the data directory to the backup location. rsync is excellent as it only copies changed files.
  3. (Optional) Creates a compressed archive (e.g., .tar.gz, .zip) of the copied data for easier management or storage efficiency. Include a timestamp in the filename.
  4. Restarts the Plex Media Server process/container.
  5. (Optional) Prunes old backups (e.g., keep last 7 daily backups).
  6. Schedule this script to run automatically using cron (Linux) or Task Scheduler (Windows) during off-peak hours (e.g., matching Plex's scheduled task window).
- Backup Software: Use dedicated backup applications (Veeam Agent, Duplicati, BorgBackup, Restic, etc.) that can be configured to back up the Plex data directory on a schedule. Many offer features like deduplication, encryption, and cloud storage integration. Ensure the software can handle backing up the databases correctly (some might need Plex stopped or use VSS on Windows).
- Database Dump (Advanced): For minimal downtime, you could potentially use SQLite commands to dump the main database file (com.plexapp.plugins.library.db) while Plex is running, although pausing/stopping Plex briefly is still the safest guarantee against corruption during the backup. Then back up the dumped file along with Preferences.xml and potentially the Metadata folder separately. Restoration is more complex.
Restoring Plex Data:
1. Stop Plex: Stop the Plex Media Server process or container completely.
2. Locate Data Directory: Identify the location where Plex expects its data directory to be (e.g., /var/lib/plexmediaserver/... or the host path mapped to /config).
3. Clear/Rename Existing Data: Rename or delete the current (potentially corrupted or empty) Plex Media Server directory.
4. Copy Backup: Copy the entire backed-up Plex Media Server directory structure into the location identified in step 2. Ensure file ownership and permissions are correct (e.g., owned by plex:plex on Linux, or the PUID:PGID user for Docker volumes). You might need sudo chown -R ... and sudo chmod -R ... after copying.
5. Start Plex: Start the Plex Media Server process or container.
6. Verify: Access Plex and check if your libraries, settings, and watch history are restored. You might need to re-scan libraries if media paths have changed, but the core metadata/history should be intact.
Importance of Media Backup (Separate Strategy): Backing up the Plex database does NOT back up your actual movie, TV show, or music files. You need a completely separate backup strategy for your media library itself (e.g., using RAID for redundancy is good, but not a backup; use external drives, NAS replication, cloud backup services like Backblaze B2, etc.). Losing your media files is catastrophic!

Workshop Creating a Script to Backup Plex Metadata

Goal: Create a simple Bash script on Linux to stop Plex (Docker container), back up the configuration directory using rsync, create a timestamped archive, restart Plex, and optionally clean up old backups.

Prerequisites:

Plex running in Docker using Docker Compose (this script assumes control via docker-compose). Adapt if using native install (use sudo systemctl stop/start plexmediaserver).
Host path to your Plex config volume (e.g., /srv/docker/plex/config).
A backup destination directory on the host (e.g., /mnt/backups/plex). Ensure this directory exists and the user running the script has write permissions.
rsync installed (sudo apt install rsync if needed).
Basic familiarity with Bash scripting.

Steps:

Create the Backup Script:

Create a new file, e.g., plex_backup.sh, in a suitable location (e.g., /usr/local/bin/ or your home directory).
Paste the following script content into the file:

#!/bin/bash

# --- Configuration ---
PLEX_CONFIG_DIR="/srv/docker/plex/config" # Host path mapped to /config in Docker
BACKUP_DEST_DIR="/mnt/backups/plex"       # Destination for backups
DOCKER_COMPOSE_DIR="/srv/docker/plex"     # Directory containing docker-compose.yml
DOCKER_COMPOSE_FILE="docker-compose.yml"  # Your compose file name
PLEX_SERVICE_NAME="plex"                  # Service name in docker-compose.yml
KEEP_BACKUPS=7                            # Number of daily backups to keep (archives)
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
LOG_FILE="${BACKUP_DEST_DIR}/plex_backup_log_${TIMESTAMP}.log"
ARCHIVE_NAME="plex_config_backup_${TIMESTAMP}.tar.gz"
RSYNC_TMP_DIR="${BACKUP_DEST_DIR}/rsync_temp_${TIMESTAMP}" # Temporary dir for rsync

# --- Logging Function ---
log() {
    echo "$(date +"%Y-%m-%d %H:%M:%S") - $1" | tee -a "$LOG_FILE"
}

# --- Ensure Backup Destination Exists ---
mkdir -p "$BACKUP_DEST_DIR"
if [ ! -d "$BACKUP_DEST_DIR" ]; then
    log "ERROR: Backup destination directory '$BACKUP_DEST_DIR' does not exist or could not be created."
    exit 1
fi

# --- Start Backup ---
log "Starting Plex backup script..."

# --- Stop Plex Container ---
log "Stopping Plex service ($PLEX_SERVICE_NAME)..."
cd "$DOCKER_COMPOSE_DIR" || { log "ERROR: Could not change to Docker Compose directory '$DOCKER_COMPOSE_DIR'."; exit 1; }
docker-compose -f "$DOCKER_COMPOSE_FILE" stop "$PLEX_SERVICE_NAME" >> "$LOG_FILE" 2>&1
if [ $? -ne 0 ]; then
    log "WARNING: Failed to stop Plex service gracefully. Continuing backup, but data might be inconsistent."
    # Optionally exit here if consistency is paramount:
    # log "ERROR: Failed to stop Plex. Aborting backup."; exit 1
else
    log "Plex service stopped successfully."
fi
# Give it a second to fully stop
sleep 5

# --- Perform Backup using rsync ---
log "Backing up Plex config from '$PLEX_CONFIG_DIR' to temporary dir '$RSYNC_TMP_DIR'..."
mkdir -p "$RSYNC_TMP_DIR" # Ensure temp dir exists
rsync -a --delete "$PLEX_CONFIG_DIR/" "$RSYNC_TMP_DIR/" >> "$LOG_FILE" 2>&1
if [ $? -ne 0 ]; then
    log "ERROR: rsync backup failed. Check permissions and paths."
    # Attempt to restart Plex even if backup failed
    log "Attempting to restart Plex service ($PLEX_SERVICE_NAME)..."
    docker-compose -f "$DOCKER_COMPOSE_FILE" start "$PLEX_SERVICE_NAME" >> "$LOG_FILE" 2>&1
    exit 1
fi
log "rsync backup completed successfully."

# --- Create Timestamped Archive ---
log "Creating compressed archive '$ARCHIVE_NAME'..."
tar -czf "${BACKUP_DEST_DIR}/${ARCHIVE_NAME}" -C "$RSYNC_TMP_DIR" . >> "$LOG_FILE" 2>&1
if [ $? -ne 0 ]; then
    log "ERROR: Failed to create tar archive."
    # Cleanup temp dir even if archive failed
    rm -rf "$RSYNC_TMP_DIR"
    # Attempt to restart Plex
    log "Attempting to restart Plex service ($PLEX_SERVICE_NAME)..."
    docker-compose -f "$DOCKER_COMPOSE_FILE" start "$PLEX_SERVICE_NAME" >> "$LOG_FILE" 2>&1
    exit 1
fi
log "Archive created successfully: ${BACKUP_DEST_DIR}/${ARCHIVE_NAME}"

# --- Clean up rsync temporary directory ---
log "Cleaning up temporary rsync directory '$RSYNC_TMP_DIR'..."
rm -rf "$RSYNC_TMP_DIR"
log "Temporary directory removed."

# --- Restart Plex Container ---
log "Restarting Plex service ($PLEX_SERVICE_NAME)..."
docker-compose -f "$DOCKER_COMPOSE_FILE" start "$PLEX_SERVICE_NAME" >> "$LOG_FILE" 2>&1
if [ $? -ne 0 ]; then
    log "ERROR: Failed to restart Plex service after backup."
    exit 1
fi
log "Plex service restarted successfully."

# --- Prune Old Backups ---
log "Pruning old backups (keeping last $KEEP_BACKUPS)..."
ls -dt "${BACKUP_DEST_DIR}"/plex_config_backup_*.tar.gz | tail -n +$(($KEEP_BACKUPS + 1)) | xargs -r rm -- >> "$LOG_FILE" 2>&1
log "Old backups pruned."

log "Plex backup script finished successfully."
exit 0

2. Customize the Script:

Carefully review and update the variables in the --- Configuration --- section to match your specific environment paths, Docker Compose details, and desired number of backups to keep.
Make Script Executable:
```
chmod +x plex_backup.sh
```
Run Manually for Testing:
Execute the script directly from your terminal:
```
sudo ./plex_backup.sh
```
(Use sudo if required to manage Docker or access certain directories).
Check the output in the terminal and examine the log file created in your $BACKUP_DEST_DIR.
Verify that a .tar.gz archive file is created in the backup destination.
Check that your Plex container stops and restarts correctly (docker ps -a).
Schedule with Cron (Optional):
Edit the root crontab (or your user's crontab if permissions allow Docker control): sudo crontab -e.
Add a line to run the script daily at a specific time (e.g., 3:30 AM):
```
# Example: Run Plex backup daily at 3:30 AM
30 3 * * * /path/to/your/plex_backup.sh > /dev/null 2>&1
```
(Adjust the time and the full path to your script. > /dev/null 2>&1 suppresses standard output/error from cron emails, relying on the script's own logging).
Save the crontab.

This workshop provides a practical, automated solution for backing up your critical Plex configuration data, significantly reducing the risk of data loss and simplifying recovery. Remember to test your restoration process periodically!

Performance Tuning and Troubleshooting

Even with proper setup, you might encounter playback issues or performance bottlenecks. This section covers identifying problems and optimizing your server.

Identifying Bottlenecks: Determine what resource is limiting performance:
- CPU:
  - Symptom: Buffering during transcodes, server UI becomes unresponsive, high CPU usage reported by OS tools (top, htop on Linux; Task Manager on Windows) or the Plex Dashboard during playback.
  - Cause: CPU not powerful enough for the number/type of software transcodes requested. Hardware transcoding might be disabled, not working, or incapable of handling the specific codec/resolution.
  - Solution: Enable/fix hardware transcoding (Plex Pass required), reduce number of simultaneous transcodes allowed (Settings -> Transcoder), optimize media to formats that Direct Play more often, upgrade CPU/server hardware.
- RAM:
  - Symptom: General system sluggishness, slow loading of Plex UI/metadata, excessive swap usage reported by OS, potential crashes during heavy activity (multiple streams, library scans).
  - Cause: Insufficient RAM for the OS, Plex, other running services, and transcode buffers.
  - Solution: Close unnecessary applications on the server, add more RAM. Monitor usage with OS tools.
- Disk I/O:
  - Symptom: Buffering even during Direct Play (especially high-bitrate files), slow library scanning, slow UI responsiveness, high disk active time reported by OS tools (iotop on Linux; Resource Monitor on Windows).
  - Cause: Slow storage device (especially for OS/Plex config/metadata or transcode directory), fragmented drive, failing drive, network bottleneck if accessing media over slow network share (e.g., slow Wi-Fi to NAS).
  - Solution: Move Plex data directory (/config) and Transcoder temporary directory to an SSD. Ensure media drives are healthy and performant (use faster interfaces like internal SATA, USB 3+, Gigabit Ethernet for NAS). Defragment HDDs (less common on Linux filesystems like ext4/XFS). Optimize network path to media storage.
- Network:
  - Symptom: Buffering on remote streams, low quality forced by Plex ("Indirect" connection or low auto quality), buffering on local streams if using Wi-Fi or slow LAN.
  - Cause: Insufficient internet upload bandwidth (for remote), poor Wi-Fi signal/congestion (local/remote), router issues, ISP throttling, CGNAT preventing direct connection (forcing limited Relay), client device has poor download speed.
  - Solution: Check server internet upload speed (speedtest.net). Compare required bitrate (check media info via Plex Get Info) vs. available bandwidth. Use wired Ethernet for server and ideally clients. Improve Wi-Fi coverage/switch channels/use mesh system. Troubleshoot router/modem. Investigate CGNAT with ISP. Advise remote users to lower quality settings if their download speed is the issue. Ensure direct remote connection is established (check Dashboard/Tautulli).
Optimizing Database Performance: The Plex database can grow large and sometimes slow down.
- Analyze Database: Settings -> Troubleshooting -> Optimize Database. Plex performs routine optimization during scheduled tasks, but manual optimization can help if experiencing slowdowns.
- Clean Bundles: Settings -> Troubleshooting -> Clean Bundles. Removes unused or old metadata components.
- Location: Ensure the database files (within the Plug-in Support/Databases/ subdirectory of your Plex data folder) are located on a fast drive (SSD strongly recommended).
Troubleshooting Playback Issues: A systematic approach:
1. Identify Scope: Does the issue affect all users/clients or just one? All media or specific files? Local network or remote only?
2. Check Plex Dashboard/Tautulli: While the issue occurs, check the "Now Playing" section.
  - Is it Direct Play, Direct Stream, or Transcoding?
  - If transcoding, what's the reason given? (Codec, Bitrate, Subtitles?)
  - Is hardware acceleration (HW) active if expected?
  - Is the connection Direct or Indirect (Relay)? What's the reported bandwidth?
3. Check Server Resources: Look at CPU, RAM, Disk I/O, and Network usage on the server OS during the problematic playback. Is any resource maxed out?
4. Examine Media File: Use Plex "Get Info" or tools like MediaInfo (standalone app) to check the specific codecs, bitrate, container, and subtitle formats of the problematic file. Is it an unusual format? Very high bitrate? Image-based subtitles?
5. Test Client Settings: Have the user try adjusting playback quality settings in their client app (lower quality, disable auto-adjust). Try disabling subtitles.
6. Test Different Client/File: Can the same user play a different file without issues? Can a different user/client play the problematic file without issues? This helps isolate client vs. server vs. file issues.
7. Check Plex Logs: For persistent issues, dive into the logs.
  - Enable Debug logging temporarily (Settings -> General -> Enable Plex Media Server debug logging). Disable verbose logging unless specifically requested, as it's extremely noisy.
  - Reproduce the issue.
  - Download logs (Settings -> Troubleshooting -> Download Logs).
  - Examine Plex Media Server.log. Search for errors around the time of the issue, look for lines containing MDE: (Media Decision Engine) to understand why Plex chose Direct Play or Transcode. Look for transcode speed indicators (speed=...) - values less than 1.0 mean the transcode cannot keep up in real-time.
  - (Disable Debug logging afterwards).
Common Errors and Solutions:
- "Playback Error - An error occurred loading items to play" / "Conversion failed. The transcoder exited unexpectedly.": Often indicates a transcoder crash. Causes: Corrupt media file, driver issues (especially with hardware transcoding), insufficient disk space in transcode temp directory, unsupported codec/format, permission errors in transcode directory, server instability (RAM/CPU issues). Check Plex Media Server.log and Plex Transcoder Statistics.log for details. Try analyzing the specific media file. Ensure transcode temp dir has space/permissions. Test with hardware transcoding disabled.
- Database Corruption: Plex UI becomes extremely slow, fails to load libraries, errors related to database locks or malformed entries in logs. Causes: Improper server shutdown (power loss), disk errors, filesystem corruption, failed database optimization. Solution: Try restoring from backup (best option!). Alternatively, try repairing the database using SQLite commands (advanced procedure, requires stopping Plex, see Plex support articles for instructions). Run Optimize Database regularly.
- Remote Access Flapping/Unavailable: Constantly switching between accessible/unavailable, or never working. Causes: Double NAT, CGNAT, incorrect port forwarding rules, firewall blocking, dynamic public IP changing without DDNS update, Plex Relay issues. Systematically check each possibility (verify public/WAN IP, test ports externally, check router/firewall rules, ensure Plex network settings/custom URLs are correct).
- Metadata Matching Issues: Incorrect posters/summaries, shows not grouping seasons correctly. Cause: Incorrect file/folder naming conventions, old/stuck agent cache. Solution: Fix naming and structure! Follow Plex guidelines strictly. Perform the "Plex Dance" (Move files out -> Scan library -> Empty trash -> Clean bundles -> Move files back -> Scan library). Use "Fix Match" or "Match" options. Ensure correct agents are selected for the library.

Workshop Diagnosing a Playback Problem Using Logs

Goal: Simulate a common playback issue (forcing a transcode due to subtitles) and use the Plex Dashboard and Logs to understand why it's happening.

Prerequisites:

Plex Media Server running.
Tautulli running (optional, but helpful).
Access to Plex Web App and server logs.
A media file (movie or TV episode) that:
- Can Direct Play fine without subtitles.
- Has an image-based subtitle track available (PGS or VOBSUB). If you don't have one, you might need to find a sample or use a tool like MKVToolNix to add a dummy PGS track to an existing file for testing purposes (advanced). Alternatively, use a very high bitrate file and force a low quality on the client to simulate a bandwidth transcode. We'll proceed assuming an image subtitle scenario.
A Plex client for testing.

Steps:

Enable Debug Logging (Temporarily):
- Go to Plex Web App -> Settings -> General.
- Check the box "Enable Plex Media Server debug logging".
- Do NOT enable Verbose logging.
- Click "Save Changes".
Baseline Test (Direct Play):
- On your test client, start playing the chosen media file.
- Ensure no subtitles are selected in the playback settings.
- Check the Plex Dashboard (or Tautulli). Expand the "Now Playing" session.
- Verify that Video and Audio are listed as "Direct Play" (or potentially Direct Stream for audio/container). Note the status.
Trigger the Problem (Subtitle Burn-In Transcode):
- While the media is playing, open the playback settings on the client.
- Select the image-based subtitle track (PGS or VOBSUB).
- The video might pause briefly as Plex adjusts.
Observe the Change (Dashboard/Tautulli):
- Go back to the Plex Dashboard (or Tautulli). Refresh if necessary.
- Expand the "Now Playing" session again.
- Observe the Video line. It should now indicate Transcode.
- Look for the reason provided. It should mention something like "Subtitle is image format" or "Subtitle burning".
- Note if (HW) appears next to the transcode, indicating if hardware acceleration kicked in (it should if configured and capable). Check CPU usage on the dashboard - it will likely be higher than during Direct Play, especially if hardware acceleration isn't used/working.

Examine the Logs:

Stop playback on the client.
Go to Plex Web App -> Settings -> Troubleshooting -> Download Logs.
Download the ZIP file and extract it.
Open Plex Media Server.log in a text editor capable of handling large files (e.g., Notepad++, VS Code, Sublime Text, less on Linux).
Search for the title of the media file you were playing around the timestamp you performed the test.
Look for lines containing MDE: (Media Decision Engine) related to your playback session. You should find entries detailing the initial decision (likely Direct Play) and then a later decision reflecting the transcode.

Example log snippet showing transcode decision due to PGS subtitles:

DEBUG - MDE: E1 - Avengers Endgame: selected media 0 / 113345
...
DEBUG - MDE: E1 - Avengers Endgame: analyzing media direct play capabilities
DEBUG - MDE: E1 - Avengers Endgame: Direct Play is disabled for subtitle stream id 654321 (pgs)
DEBUG - MDE: E1 - Avengers Endgame: no direct play subtitle profile exists for pgs
DEBUG - MDE: E1 - Avengers Endgame: subtitles require burning in based on selected subtitle stream id 654321 (pgs)
DEBUG - MDE: E1 - Avengers Endgame: Direct Streaming is disabled for subtitle stream id 654321 (pgs)
DEBUG - MDE: E1 - Avengers Endgame: no direct stream subtitle profile exists for pgs
DEBUG - MDE: E1 - Avengers Endgame: subtitles require burning in based on selected subtitle stream id 654321 (pgs)
DEBUG - MDE: E1 - Avengers Endgame: avoiding video transcode because subtitle burning is required
DEBUG - MDE: E1 - Avengers Endgame: Scaled up video bitrate to 15000Kbps based on 1.500000x fudge factor.
DEBUG - MDE: E1 - Avengers Endgame: decision: transcode

(Note: Log messages evolve; exact wording may differ slightly). This shows the decision process explicitly stating PGS subtitles require burning, forcing a transcode.

Search for TranscodeSession start messages related to the session. Look for speed => values later in the transcode messages - if consistently below 1.0, the server isn't keeping up.

Disable Debug Logging:
- Go back to Settings -> General -> Uncheck "Enable Plex Media Server debug logging" -> Save Changes.

This workshop demonstrates a practical troubleshooting workflow: observe the behavior, use the Dashboard for real-time clues, and dive into the logs for definitive reasons behind Plex's playback decisions, specifically illustrating how image-based subtitles often force unwanted transcoding.

Conclusion

Embarking on the journey of self-hosting Plex Media Server opens up a world of control, customization, and unparalleled access to your personal media collection. We've traveled from the fundamental concepts and basic setup through intermediate management techniques like user handling and transcoding optimization, culminating in advanced operations such as Docker deployment, secure remote access via reverse proxies, automation with the *Arr stack, in-depth monitoring with Tautulli, and crucial backup strategies.

You've learned how to:

Choose appropriate hardware and an operating system for your needs.
Install and perform the initial configuration of Plex Media Server.
Organize your media meticulously using standard naming conventions for optimal metadata matching.
Manage libraries, users, and sharing permissions effectively.
Understand the intricacies of transcoding, Direct Play, and Direct Stream, and leverage hardware acceleration.
Enhance security through HTTPS, firewalls, and reverse proxies.
Streamline deployment and updates using Docker.
Automate media acquisition and organization by integrating Radarr and Sonarr.
Gain deep insights into server usage with Tautulli.
Protect your valuable setup data through robust backup procedures.
Diagnose and troubleshoot common performance and playback issues.

The power and flexibility of self-hosting Plex lie in this ability to tailor the experience precisely to your requirements. Whether you're running a small server for personal use on modest hardware or managing a robust setup for family and friends with extensive automation, the principles remain the same.

This is a field of continuous learning. Media formats evolve, software updates bring new features and challenges, and the vibrant Plex community (forums, Reddit, blogs) is an invaluable resource for support, ideas, and troubleshooting assistance. Don't hesitate to explore further, experiment (carefully!), and continue refining your self-hosted media haven. Enjoy the freedom and control that comes with managing your own media universe!

Media Server Plex

Introduction

What is Plex

Why Self-Host Plex

Plex Architecture Overview

Core Concepts

Workshop Introduction Setting the Stage

1. Basic Setup and Configuration

Choosing Your Server Hardware

Workshop Hardware Selection Scenario

Operating System Choices

Workshop OS Decision Guide

Installing Plex Media Server

Workshop Installing Plex on Ubuntu

Creating Your First Libraries

Workshop Setting Up Movie and TV Show Libraries

Basic Network Configuration and Access

Workshop Enabling and Testing Basic Remote Access

Using Plex Clients

Workshop Connecting a Web and Mobile Client

2. Intermediate Plex Management

Advanced Library Management

Workshop Creating Smart Collections and Optimizing Media

User Management and Sharing

Workshop Setting up Plex Home and Sharing Libraries

Understanding Transcoding Deep Dive

Workshop Configuring and Analyzing Hardware Transcoding

Customizing the Plex Experience

Workshop Fine-tuning Server Settings and Subtitle Management

Securing Your Plex Server

Workshop Basic Security Hardening Updates and Firewall

3. Advanced Plex Operations

Running Plex in Docker

Workshop Deploying Plex using Docker Compose with Hardware Transcoding

Setting Up a Reverse Proxy for Secure Remote Access

Workshop Securing Plex with Nginx Proxy Manager and Let's Encrypt

Integration with Other Services The Arr Stack

Workshop Integrating Radarr and Sonarr with Plex

Advanced Monitoring with Tautulli

Workshop Setting Up Tautulli and Creating Custom Notifications

Backup and Recovery Strategies

Workshop Creating a Script to Backup Plex Metadata

Performance Tuning and Troubleshooting

Workshop Diagnosing a Playback Problem Using Logs

Conclusion