Deployment guide

Plausible

Overview

Plausible is an open-source, privacy-friendly, lightweight web analytics platform and a simple, ethical alternative to Google Analytics. It does not use cookies and is fully compliant with GDPR, CCPA and PECR.

This image ships the self-hosted Community Edition (AGPL-3.0) as the official Docker Compose stack. The SecureAnyCloud image installs Plausible Community Edition v3.0.1 and runs the stack under a systemd unit behind an nginx reverse proxy on port 80. It persists all data on a dedicated Azure data disk and seeds a unique admin account with a strong per-VM password on the first boot of every VM.

What you get:

Plausible Community Edition v3.0.1 (AGPL-3.0), the self-hosted community build
The official three-container stack via Docker Compose: the Plausible app, plausible_db (PostgreSQL 16) and plausible_events_db (ClickHouse). PostgreSQL stores dashboard and user metadata, and ClickHouse stores the analytics events
nginx on :80 as a reverse proxy to the Plausible app on loopback 127.0.0.1:8000
PostgreSQL and ClickHouse kept on the private Docker network only, never exposed on the host or any external interface
A per-VM admin account (admin@sac.local) seeded on first boot with a strong unique password, recorded in a root-only file, with open registration disabled
A dedicated Azure data disk at /var/lib/plausible holding the Docker data-root, all database volumes and the analytics events
plausible.service and nginx.service as systemd units, enabled and active
24/7 SecureAnyCloud support

Prerequisites

You need an active Azure subscription, an SSH key pair, and a VNet plus subnet in the target region.

Standard_B4ms (4 vCPU / 16 GiB RAM) is the recommended size. ClickHouse is memory-hungry, so a smaller VM is not advised.

Configure the network security group (NSG) to allow inbound 22/tcp from your management network and 80/tcp for the Plausible dashboard. Plausible serves plain HTTP on port 80, so terminate TLS in front of it with your own domain.

Step 1 - Deploy from the Azure Marketplace

Sign in to the Azure Portal, choose Create a resource, search the Marketplace for Plausible by SecureAnyCloud, and select Create.

On the Basics tab, pick your subscription, resource group, region and size (Standard_B4ms). Under Administrator account, choose SSH public key and paste your key. Under Inbound port rules, allow SSH (22) and HTTP (80).

Review the dedicated data disk on the Disks tab. Then select Review + create and Create.

Step 2 - Deploy from the Azure CLI

# Accept the Marketplace terms once per subscription (required before the first CLI deploy)
az vm image terms accept --urn sac1647283583153:plausible-ubuntu-24-04:default:latest
az vm create \
  --resource-group <your-rg> \
  --name plausible \
  --image sac1647283583153:plausible-ubuntu-24-04:default:latest \
  --size Standard_B4ms \
  --admin-username azureuser \
  --ssh-key-values ~/.ssh/id_ed25519.pub \
  --vnet-name <your-vnet> --subnet <your-subnet> \
  --public-ip-sku Standard
az vm open-port --resource-group <your-rg> --name plausible --port 80 --priority 1010

Step 3 - Connect to your VM

ssh azureuser@<vm-public-ip>

Step 4 - Confirm the services are running

On first boot, the VM generates per-VM secrets, brings up the Compose stack and seeds the admin account. Confirm that both systemd units are active:

systemctl is-active plausible.service nginx.service

Both report active. The Plausible app, PostgreSQL and ClickHouse run as containers managed by plausible.service. The data disk is mounted at /var/lib/plausible.

Step 5 - Retrieve your admin password

The admin password is generated uniquely on the first boot of your VM and written to a root-only file. Read it:

sudo cat /root/plausible-credentials.txt

The file contains PLAUSIBLE_ADMIN_EMAIL (admin@sac.local) and PLAUSIBLE_ADMIN_PASSWORD. Store the password somewhere safe. Open registration is disabled, so this seeded account is your only way in.

Step 6 - Confirm the health endpoint

Plausible exposes an unauthenticated health endpoint that reports the status of the app, PostgreSQL and ClickHouse:

curl -s http://localhost:8000/api/health

The endpoint returns a JSON object with "postgres":"ok" and "clickhouse":"ok" once the whole stack is healthy. All three containers report healthy, and the dashboard is reachable on :80.

Step 7 - Sign in to the dashboard

Browse to http://<vm-public-ip>/ and sign in as admin@sac.local with the password from Step 5.

After you sign in, you land on My Sites, where every website you track is listed. Click + Add Website to register your first site. Enter its domain and timezone, then add the provided snippet to your site.

Opening a site shows its analytics dashboard. It covers unique visitors, total visits, pageviews, bounce rate, visit duration, top sources, top pages and more, all updating in real time.

The Settings area covers your account preferences, security (including two-factor authentication), API keys for the Stats API, and more.

Step 8 - Verify authentication from the command line

You can confirm without the browser that the seeded admin credentials work end to end. Read the password with sudo grep '^PLAUSIBLE_ADMIN_PASSWORD=' /root/plausible-credentials.txt | cut -d= -f2-. Then fetch the login page to capture its CSRF token and a session cookie, and POST the login form.

Plausible protects the login form with a CSRF token, so the round trip looks like this in a shell. The password is read from the credentials file into $PW, so no secret is typed on the command line. First run curl -s -c cj /login to get the _csrf_token. Then run curl -b cj --data-urlencode "_csrf_token=$C" --data-urlencode "email=admin@sac.local" --data-urlencode "password=$PW" http://localhost:8000/login.

A correct password returns HTTP 302 redirecting to /sites. A wrong password re-renders the login form (HTTP 200) and grants no session. The screenshot below shows the Docker data-root on the data disk, the backing databases isolated from all external interfaces, and both the correct and wrong password outcomes.

Step 9 - Confirm data lives on the dedicated disk

All Plausible state is stored on the dedicated Azure data disk, so it survives OS changes and can be resized independently. That state includes the Docker data-root, the PostgreSQL database and the ClickHouse events, which are the bulk of the data. Check the mount:

findmnt /var/lib/plausible

The mount is backed by a separate Azure data disk captured into the image and re-provisioned on every VM. The pre-pulled container images and every database volume live under it.

Adding your analytics

Plausible is designed to be dropped onto any website in minutes. Add a website in the dashboard and copy the lightweight tracking snippet (under 1 KB) into your site's <head>. Visitors then start appearing in real time.

Plausible also offers a Stats API, so you can pull metrics into your own dashboards. Create an API key under Settings. It supports custom events and goals for conversion tracking. See the Plausible documentation for the tracking script, the Stats API and integration guides.

Maintenance

Users: open registration is disabled. Invite additional team members from the dashboard, or manage the admin account under Settings.
Backups: snapshot the /var/lib/plausible data disk. Alternatively, use pg_dump against the plausible_db container for the metadata and ClickHouse backups for the events.
Data: the PostgreSQL and ClickHouse volumes plus the Docker images live under /var/lib/plausible.
TLS: Plausible serves plain HTTP on port 80. Front it with TLS (for example certbot, or an Azure Application Gateway or Front Door) and your own domain, and set BASE_URL accordingly.
Upgrades: update the image tags in /opt/plausible/compose.yml and run sudo systemctl restart plausible.service to roll the stack forward.
Security patches: unattended-upgrades remains enabled, so the OS continues to receive security updates automatically.

Support

SecureAnyCloud provides 24/7 expert support for this image. Contact sales@secureanycloud.com.

Deploy on Azure

Launch Plausible Community Edition on Ubuntu 24.04 on Azure with 24/7 support from SecureAnyCloud.

View this image

Need Help?

Our support team is available 24/7.

sales@secureanycloud.com

Deploy on Azure

Overview

Plausible Community Edition 3.0.1 is an open-source, privacy-friendly web analytics platform and a lightweight alternative to Google Analytics. This image runs it on Ubuntu 24.04 LTS as a complete, pinned stack, with first-boot secrets generated per instance.

What you get:

A three-tier application shipped as a pinned Docker Compose project in /opt/plausible:
- plausible: ghcr.io/plausible/community-edition:v3.0.1, the Plausible application (Elixir / Phoenix)
- plausible_db: postgres:16-alpine, which holds dashboard, site and user metadata
- plausible_events_db: clickhouse/clickhouse-server:24.12-alpine, the analytics events store
The application listening on the loopback address 127.0.0.1:8000 by design, and never exposed directly
nginx as a reverse proxy on port 80 that forwards every request to Plausible, with the WebSocket upgrade headers the live dashboard needs
PostgreSQL and ClickHouse kept inside the private Docker network, never published to a host interface or to the network
No secrets baked in. Plausible needs a SECRET_KEY_BASE, a TOTP vault key, a database password and an initial administrator, and this image ships none of them
A one-shot service on the first boot of every instance. It generates fresh per-instance values for all of those secrets and resolves the instance's own public address through EC2 instance metadata (IMDSv2) to set BASE_URL. It then seeds a single administrator account with a freshly generated password and writes the details to /root/plausible-credentials.txt (mode 0600, readable only by root)
Open registration disabled, so there is no public signup form on your analytics instance
No shared secrets: two instances launched from the same AMI never share a secret or a password
All stack state (the PostgreSQL metadata, the ClickHouse events store and the application data) in Docker named volumes on a dedicated, independently resizable EBS data volume mounted at /var/lib/docker, kept separate from the operating system disk
The pinned image layers on that volume too, so first boot starts the stack in seconds rather than pulling gigabytes
A default security group for this listing that opens port 22 (SSH) and port 80 (HTTP) only

Plausible does not use cookies and does not collect personal data or persistent identifiers, so it needs no cookie banner and no consent prompt under GDPR, CCPA or PECR. The tracking script is roughly 1 KB.

Prerequisites

Before you deploy this image, you need:

An AWS account subscribed to this product in AWS Marketplace
An EC2 key pair in your target region for SSH access
A security group allowing inbound TCP 22 (SSH) from your IP and TCP 80 (HTTP) from your users
Recommended instance type: m5.large or larger. ClickHouse is memory-hungry. The image provisions a 4 GB swapfile on first boot and ships a low-resource ClickHouse configuration, but give it more memory for heavier traffic
A website whose traffic you want to track

Connecting to your instance

SSH in as the default login user for your operating system variant, using the key pair you launched with.

Ubuntu 24.04: the login user is ubuntu, for example ssh -i your-key.pem ubuntu@<instance-public-ip>

Step 1 - Launch from AWS Marketplace

Open the product page in AWS Marketplace and choose Continue to Subscribe, then Continue to Configuration.
Select the Plausible Analytics 3.0.1 on Ubuntu 24.04 delivery option and your region, then choose Continue to Launch.
Choose your instance type, VPC and subnet, key pair, and the security group described above. Then launch the instance.

Step 2 - Launch from the AWS CLI

Replace the AMI ID with the one shown on the product's launch page for your region. Use your own key pair and security group.

aws ec2 run-instances \
  --image-id ami-xxxxxxxxxxxxxxxxx \
  --instance-type m5.large \
  --key-name your-key \
  --security-group-ids sg-xxxxxxxx \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=plausible}]'

Step 3 - Connect to your instance

ssh -i your-key.pem ubuntu@<instance-public-ip>

First boot brings the three containers up, runs the database migrations and seeds your administrator account. This takes a couple of minutes on a fresh instance. Confirm that it has finished. The sentinel file appears only when first boot has completed successfully:

test -f /var/lib/sac/data/plausible-firstboot.done && echo "first boot complete"

Step 4 - Retrieve your administrator password

On the first boot, a one-shot service generated a unique administrator password for this instance. Read the credentials file (root only):

sudo cat /root/plausible-credentials.txt

The file shows the sign-in URL, the administrator email admin@sac.local and the generated password. Keep this password somewhere safe. It belongs to the only account on a fresh instance, and registration is disabled.

Step 5 - Sign in to Plausible

Open http://<instance-public-ip>/ in your browser. The Plausible sign-in page appears. Enter admin@sac.local and the password from the credentials file, and sign in.

You can verify from the instance that the sign-in round trip works, without printing the password anywhere. The helper reads the credential itself, proves that the generated password is accepted and that a wrong password is rejected, and prints only the verdict:

sudo /usr/local/sbin/plausible-roundtrip.sh

Change the administrator password once you are signed in. Open the user menu (top right) and choose Settings. You can invite additional users from the same menu. Registration stays closed to the public.

Step 6 - Add your website and install the tracking script

On a fresh instance, there are no sites yet.

Choose + Add Website.
Enter the Domain: just the naked domain or subdomain, without www or https (for example example.com). Pick your Reporting Timezone, and choose Install Plausible.
Plausible shows the tracking snippet for that site.

Copy the snippet and paste it into the <head> of every page of your website. The data-domain is the site you just added, and the src host is your Plausible instance. The snippet looks like this:

<script defer data-domain="example.com" src="http://<instance-public-ip>/js/script.js"></script>

On the same screen, you can enable optional measurements before you copy the snippet. These are outbound links, file downloads, 404 pages, hashed page paths, custom events, custom properties and ecommerce revenue. They swap in a richer variant of the script.

Once the script is live and visitors arrive, pageviews appear on the dashboard in real time. The script is cookieless and collects no personal data, so no cookie banner is required.

Step 7 - Read your analytics

Select a site to open its dashboard. Across the top are unique visitors, total visits, total pageviews, views per visit, bounce rate and visit duration. A visitor graph sits beneath, and you select the reporting period on the right.

Below the graph, Top Sources breaks traffic down by referrer, channel or campaign. Top Pages breaks it down by page, entry page or exit page.

Further down, Locations maps visitors by country, region and city. Devices breaks them down by browser, operating system and screen size.

Per-site configuration lives under Settings for <your site>, reached from the site menu. It covers domain and reporting timezone, people and invitations, public visibility, goals, custom properties, imports and exports, traffic shields for IP addresses, countries, pages and hostnames, and email reports.

Setting your base URL and enabling HTTPS

This image serves HTTP on port 80 and sets BASE_URL to the instance public IP on first boot. Put your own domain in front and terminate TLS. Two common options:

AWS-managed TLS: put the instance behind an Application Load Balancer (or Amazon CloudFront) with an AWS Certificate Manager certificate, and forward to the instance on port 80.
On-instance TLS with Let's Encrypt: point a DNS record at the instance and open port 443 in the security group. Then install certbot and obtain a certificate:

sudo apt-get update
sudo apt-get install -y certbot python3-certbot-nginx
sudo certbot --nginx -d analytics.example.com

Either way, tell Plausible its public address afterwards. Otherwise, links and the tracking snippet still reference the IP. Edit BASE_URL in the environment file and restart the stack:

sudo sed -i 's#^BASE_URL=.*#BASE_URL=https://analytics.example.com#' /opt/plausible/.env
sudo systemctl restart plausible

After you enable HTTPS, update the src in your tracking snippet to use https:// and your domain.

Service management

A single systemd unit, plausible.service, manages the stack. It runs docker compose up -d against /opt/plausible/compose.yml on boot and docker compose down on stop. nginx and the Docker daemon are separate units. Confirm that they are all active:

systemctl is-active docker plausible nginx

Check that the three containers are running:

sudo docker compose -f /opt/plausible/compose.yml ps --format 'table {{.Service}}\t{{.State}}'

Confirm that only the intended ports are exposed. The application is bound to loopback and the databases are not on a host interface at all, so only 22 and 80 are reachable from the network:

ss -tln | grep -E ':(80|8000|5432|8123) ' || true

After a configuration change, restart Plausible with sudo systemctl restart plausible. Configuration lives in /opt/plausible/.env (the per-instance secrets and BASE_URL). The Compose project and the ClickHouse configuration drop-ins are in /opt/plausible.

Health check

Plausible exposes an unauthenticated health endpoint that reports the application together with both databases. A 200 means that the app, PostgreSQL and ClickHouse are all healthy:

curl -s -o /dev/null -w 'plausible health HTTP %{http_code}\n' http://127.0.0.1:8000/api/health

nginx also serves a static health endpoint on port 80. It answers as soon as the proxy is up:

curl -s -o /dev/null -w 'nginx health HTTP %{http_code}\n' http://127.0.0.1/health

Storage layout

All analytics data and the pinned images live on the dedicated EBS data volume mounted at /var/lib/docker. Both the Docker data root and the containerd image store are configured to write there:

findmnt -no SOURCE,TARGET,FSTYPE,SIZE /var/lib/docker

sudo docker volume ls --filter name=plausible --format '{{.Name}}'

Backup and maintenance

Metadata backup: the dashboard, site and user metadata is in PostgreSQL. Dump it from the container with the command below.

sudo docker compose -f /opt/plausible/compose.yml exec -T plausible_db \ pg_dump -U postgres plausible_db | gzip > plausible-db-$(date +%F).sql.gz

Events backup: the analytics events are in ClickHouse and are the bulk of the data. The most practical durable backup is an EBS snapshot of the data volume, which captures PostgreSQL, ClickHouse and the application data consistently at the block level. Use Amazon Data Lifecycle Manager or AWS Backup to schedule it.
Resizing storage: the volume mounted at /var/lib/docker is an ordinary EBS volume. Grow it from the EC2 console, then extend the filesystem on the instance (sudo growpart where applicable, then sudo resize2fs).
OS updates: apply security updates with sudo apt-get update && sudo apt-get upgrade. Reboot if a new kernel is installed. The stack comes back automatically.
Upgrading Plausible: back up first, then change the pinned image tag in /opt/plausible/compose.yml, pull and recreate. Follow the upstream upgrade notes at https://github.com/plausible/community-edition/wiki, which call out any migration steps between versions.

Support

This image is backed by 24/7 SecureAnyCloud technical support by email and chat. Support covers deployment, adding and tracking sites, reading the dashboard, database backup and scaling, and TLS termination.

Plausible Community Edition is open-source software licensed under the AGPL-3.0 and is shipped unmodified. SecureAnyCloud provides the packaging and support and is not affiliated with or endorsed by Plausible Insights OU.

Deploy on AWS

Launch Plausible Analytics on AWS with 24/7 support from SecureAnyCloud.

View on Marketplace

Need Help?

Our support team is available 24/7.

sales@secureanycloud.com

Deploy on AWS