How to Self-Host Plausible Analytics on Ubuntu VPS with Docker

Introduction to Architecture & Core Concepts

Plausible Analytics is an open-source, privacy-focused alternative to Google Analytics. It avoids cookie banners and GDPR consent modals by anonymizing tracking data. Self-hosting Plausible grants you total data sovereignty. This architecture relies on an Elixir-based backend, a PostgreSQL database for user state, and a ClickHouse columnar database optimized for immense time-series analytics ingestion.

Under the Hood: Process Threading and Socket Architecture

When engineering high-availability topologies, administrators must comprehend how the host processes system calls, threading, and asynchronous I/O interfaces like io_uring or epoll. Standard monolithic software architectures block I/O operations, meaning a single network delay freezes an entire execution thread. Modern software paradigms inherently bypass this limitation. By multiplexing thousands of non-blocking sockets onto a handful of active CPU event loops, the underlying runtime engine ensures that network latency never impacts processing throughput. Furthermore, allocating specific NUMA (Non-Uniform Memory Access) nodes strictly to isolated processes guarantees that CPU cache thrashing is minimized. In distributed Linux environments, this micro-level tuning differentiates an amateur deployment from a truly resilient, carrier-grade service.

Consider the impact of the C-groups (Control Groups) v2 implementation in modern systemd environments. By strictly partitioning CPU quotas and enforcing hard memory limits at the hypervisor or container runtime layer, we completely neutralize noisy-neighbor scenarios. If a specific subprocess experiences a memory leak or a catastrophic thread starvation event, the kernel aggressively terminates the offending control group, instantly shielding the underlying host operating system from kernel panics.

Hardware Sizing & Prerequisite Checklist

Before embarking on the installation phase, verify your hardware capabilities. Insufficient resource allocation is the leading cause of random process termination.

System Performance & Benchmark Comparison

Before moving workloads to production, consider the hardware scaling matrices and expected latency overheads across varied compute configurations.

Storage subsystem IOPS dictates ultimate database throughput. While CPU dictates parsing speed, write-heavy architectures inherently bottleneck at the block-storage layer. Always provision PCIe 4.0 NVMe storage block devices rather than legacy SSDs for heavy infrastructural components.

Advanced Linux Kernel Tuning for High-Performance Workloads

To extract the absolute maximum performance from your Linux VPS, standard kernel parameters often fall short, particularly for high-throughput or connection-heavy services. The default settings prioritize general-purpose desktop stability over aggressive server performance. We must modify the sysctl configuration to optimize the TCP/IP stack, file descriptors, and virtual memory subsystem.

# Edit /etc/sysctl.d/99-custom-server.conf
# Maximize file descriptors for heavy network sockets
fs.file-max = 2097152
fs.nr_open = 2097152

# TCP BBR Congestion Control for reduced latency
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr

# TCP keepalive tuning for stale connection termination
net.ipv4.tcp_keepalive_time = 300
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 5

# Ephemeral port exhaustion prevention
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.core.somaxconn = 65535

# Swap reduction for database stability
vm.swappiness = 1
vm.dirty_ratio = 15
vm.dirty_background_ratio = 5

Apply these changes immediately across the system architecture without requiring a hard reboot by running sysctl --system. The BBR congestion control algorithm significantly reduces packet loss queuing over long-distance WAN links, which is critical for geographically distributed users accessing your infrastructure. Concurrently, dropping vm.swappiness prevents the Linux Out-Of-Memory (OOM) killer from prematurely evicting vital application memory pages to slow disk-based swap space.

Step-by-Step Linux Installation & Configuration

First, install the Docker Engine and Docker Compose V2 plugin. Plausible requires a specific orchestration of containers.

mkdir -p /opt/plausible && cd /opt/plausible
curl -L https://github.com/plausible/hosting/archive/master.tar.gz | tar -xz --strip-components=1

Generate a secure 64-character hexadecimal secret key for the internal application session state: openssl rand -base64 64. Populate your plausible-conf.env file with the correct PostgreSQL and ClickHouse credentials, SMTP delivery configurations, and the newly generated SECRET_KEY_BASE.

# docker-compose.yml configuration snippet
services:
  plausible_db:
    image: postgres:14-alpine
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=postgres
  plausible_events_db:
    image: clickhouse/clickhouse-server:23.3-alpine
    volumes:
      - event-data:/var/lib/clickhouse
    ulimits:
      nofile:
        soft: 262144
        hard: 262144

Execute docker compose up -d to bootstrap the environment. Watch the migration logs carefully using docker compose logs -f plausible to verify database schema initialization.

Enterprise-Grade Security Hardening & UFW Firewall Implementation

Deploying public-facing infrastructure demands a rigorous approach to network security. The Uncomplicated Firewall (UFW) acts as your primary network defense perimeter. Furthermore, we mandate the usage of Fail2Ban to parse systemd journal logs and dynamically ban malicious IP subnets attempting brute-force authentication attacks.

# Enforce default drop policies at the kernel level
ufw default deny incoming
ufw default allow outgoing

# Whitelist strictly necessary administrative and web ports
ufw allow 22/tcp  # SSH (Consider moving to a non-standard port like 2222)
ufw allow 80/tcp  # HTTP ACME challenges
ufw allow 443/tcp # HTTPS TLS traffic

# Reload and enable the ruleset
ufw enable
ufw status numbered

Beyond port filtering, secure the internal UNIX socket permissions. Ensure that the application daemon operates under a dedicated, non-root service account (e.g., useradd -r -s /bin/false app_svc). Avoid utilizing root for any operational binary execution. For cryptographic transit security, integrate Let’s Encrypt TLS 1.3 certificates via Certbot or Caddy, disabling legacy TLS 1.0/1.1 protocols entirely in your reverse proxy configuration.

Real-World Troubleshooting FAQ

Q: Why is ClickHouse required alongside PostgreSQL?

A: PostgreSQL manages relational metadata (users, sites, settings), but time-series event ingestion at high volume requires ClickHouse. ClickHouse’s columnar architecture allows aggregations of millions of analytics rows in milliseconds, which would exhaust standard PostgreSQL indices.

Q: How do I update the self-hosted Plausible instance?

A: Modify the image tag in your docker-compose.yml file to the latest release, pull the new images via docker compose pull, and recreate the containers with docker compose up -d. The Elixir Ecto migrations will run automatically on startup.