Formbricks è una piattaforma open source per la gestione dell’experience management, pensata per la raccolta di feedback e la creazione di sondaggi (survey) sia in-app che tramite link condivisibili.

Nato come alternativa self-hosted a strumenti SaaS come Typeform o SurveyMonkey, Formbricks consente alle organizzazioni di mantenere il pieno controllo sui dati raccolti, senza vincoli di licenza per numero di risposte e con piena conformità alle politiche di data privacy interne, un aspetto particolarmente rilevante per enti che gestiscono dati sensibili o operano in contesti normati (GDPR, policy aziendali di data residency).

L’architettura di Formbricks è containerizzata e si basa su un’infrastruttura Docker composta da diversi servizi: l’applicazione web principale (Next.js), un database PostgreSQL per la persistenza dei dati, Redis per la gestione di cache e code, un servizio di storage oggetti (RustFS) per gli allegati, e componenti aggiuntivi come Cube per l’analisi dei dati e Hub per funzionalità di integrazione.

L’accesso all’applicativo avviene tipicamente tramite un reverse proxy (Traefik), che gestisce il routing verso i singoli container e, dove necessario, la terminazione TLS.

Questo documento descrive la procedura di installazione e configurazione base di Formbricks su un server Ubuntu Server 26.04, in ambiente di test/laboratorio, coprendo il deployment tramite Docker Compose, la configurazione delle variabili d’ambiente principali (URL pubblico dell’applicazione, parametri di autenticazione), la creazione e gestione dell’utente amministratore, e le verifiche di funzionamento post-installazione.

PREREQUISITI

Prima di iniziare assicurarsi di avere:

• Un server con Ubuntu Server 26.04, accesso SSH e utente con privilegi sudo.
• Requisiti minimi hardware: 1 vCPU, 2 GB di RAM, 8 GB di spazio SSD (per un uso reale con più progetti/risposte, meglio partire da 2 vCPU / 4 GB RAM).
• Un nome a dominio (es. feedback.tuodominio.it) con un record DNS di tipo A che punti all’IP pubblico del server.
• Le porte 80 e 443 raggiungibili dall’esterno (aperte sul firewall del server e su eventuale firewall del provider/cloud).
• Un indirizzo email valido, da usare per le notifiche del certificato SSL (Let’s Encrypt).

PREPARAZIONE DEL SERVER

Collegarsi via SSH al server e aggiornare il sistema con il comando:

sudo apt update && sudo apt upgrade -y

Se non hai già un utente non-root con sudo, creane uno (consigliato non lavorare come root):

sudo adduser formbricks-admin

sudo usermod -aG sudo formbricks-admin

su - formbricks-admin

CONFIGURAZIONE DEL FIREWALL

Configurare il firewall con i seguenti comandi:

sudo apt install -y ufw

sudo ufw allow OpenSSH

sudo ufw allow 80/tcp

sudo ufw allow 443/tcp

sudo ufw enable

sudo ufw status

VERIFICA DEL DNS

Prima di procedere, controlla che il dominio scelto risolva correttamente verso l’IP del server:

dig +short feedback.tuodominio.it

L’output deve corrispondere all’IP pubblico del tuo server Ubuntu. Se non è ancora propagato, attendi qualche minuto prima di continuare (il rilascio del certificato SSL fallisce se il DNS non è corretto).

INSTALLAZIONE DI FORMBRICKS (SCRIPT ONE-CLICK)

Lo script ufficiale gestisce da solo l’installazione di Docker e di tutti i componenti necessari, quindi non serve installare Docker manualmente prima.

Creare una cartella di lavoro e scaricare lo script con i seguenti comandi:

mkdir -p ~/formbricks-install && cd ~/formbricks-install

curl -fsSL https://raw.githubusercontent.com/formbricks/formbricks/stable/docker/formbricks.sh \
-o formbricks.sh && chmod +x formbricks.sh

Avviare l’installazione con il comando:

./formbricks.sh install

Durante l’esecuzione lo script farà alcune domande interattive:

Chiavi GPG di Docker: se richiesto, conferma il sovrascrivere eventuali chiavi Docker già presenti.

Dominio: inserire il tuo dominio senza protocollo, cioè senza http:// o https:// (es. feedback.tuodominio.it).

Certificato HTTPS: rispondi “sì” per attivare la generazione automatica del certificato con Let’s Encrypt.

Verifica DNS: conferma che il dominio punti correttamente al server e che le porte 80/443 siano raggiungibili.

Email per SSL: indirizzo email da associare al certificato (notifiche di scadenza/rinnovo).

HSTS: puoi abilitarlo per forzare sempre HTTPS (consigliato per un ambiente di produzione stabile).

Servizio email/SMTP: opzionale, puoi rispondere “no” e configurarlo in un secondo momento (vedi punto 6).

Al termine, lo script crea una cartella ./formbricks/ contenente:

docker-compose.yml: la definizione dei container

.env: variabili d’ambiente e credenziali (da tenere privato e da includere nei backup)

traefik.yaml / traefik-dynamic.yaml: configurazione del reverse proxy

acme.json: i certificati SSL emessi da Let’s Encrypt

VERIFICA DELL’INSTALLAZIONE

Controllare che tutti i container siano attivi:

cd ~/formbricks-install/formbricks

docker ps

Dovremmo vedere in esecuzione (tra gli altri) i container di Formbricks, PostgreSQL, Redis, Traefik e Cube.

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
421e398d73b1 traefik:v3.6.4 "/entrypoint.sh trae…" About a minute ago Up About a minute 0.0.0.0:80->80/tcp, [::]:80->80/tcp, 0.0.0.0:443->443/tcp, [::]:443->443/tcp traefik
feafd58746f0 cubejs/cube:v1.6.6 "docker-entrypoint.s…" About a minute ago Up About a minute (healthy) 4000/tcp formbricks-cube-1
6bb06dd3e131 ghcr.io/formbricks/hub:latest "/app/hub-api" About a minute ago Up About a minute (healthy) 8080/tcp formbricks-hub-1
ac8b179d82ed ghcr.io/formbricks/formbricks:latest "docker-entrypoint.s…" About a minute ago Up About a minute 0.0.0.0:3000->3000/tcp, [::]:3000->3000/tcp formbricks-formbricks-1
498bdc4abc05 rustfs/rustfs:1.0.0-rc.2 "/entrypoint.sh /data" About a minute ago Up About a minute 9000-9001/tcp formbricks-rustfs-1
af4eff0dc365 pgvector/pgvector:pg18 "docker-entrypoint.s…" About a minute ago Up About a minute (healthy) 5432/tcp formbricks-postgres-1
63140f3ade9c e0eb7c480958 "docker-entrypoint.s…" About a minute ago Up About a minute (healthy) 6379/tcp formbricks-redis-1

Aprire quindi nel browser:

https://feedback.tuodominio.it

Se tutto è andato a buon fine, il certificato HTTPS sarà valido (lucchetto verde) e comparirà la schermata di primo avvio di Formbricks.

CONFIGURAZIONE INZIALE VIA BROWSER

Alla prima apertura del dominio, Formbricks ti guida nella configurazione base:

Cliccare su Continue with mail

Crea l’account amministratore: nome, email e password del primo utente (avrà ruolo di owner dell’organizzazione)

Spuntare l’opzione Security Updates quindi cliccare Continue with Email

Cliccare Log In

Cliccare Log in with Email

Inserire le credenziali amministrative create in precedenza quindi cliccare Log In with Email

Inserire il nome dell’organizzazione quindi cliccare Continue

Dato che l’SMTP non è configurato cliccare Skip

Cliccare Start From Scratch per creare il primo progetto. Formbricks propone anche modelli pronti (survey NPS, feedback prodotto, ecc.) da cui partire.

Inserire tutte le info della Survey quindi cliccare Save and Close

La survey è Live. Cliccare su Preview per vedere l’anteprima

Se è tutto OK dovremmo visualizzare la Survey appena creata

Da questo momento l’app è pienamente operativa: puoi creare survey, invitare collaboratori e collegare i tuoi siti/app tramite l’SDK Formbricks.

CONFIGURAZIONE BASE AGGIUNTIVA (OPZIONALE MA CONSIGLIATA)

Le impostazioni aggiuntive si configurano modificando il file .env nella cartella ~/formbricks-install/formbricks/ e poi riavviando lo stack.

Invio email (SMTP)

Necessario per inviti team, notifiche e reset password. Aggiungi/modifica nel file .env:

MAIL_FROM=notifiche@tuodominio.it
MAIL_FROM_NAME="Formbricks - Tuo Nome Azienda"
SMTP_HOST=smtp.tuoprovider.it
SMTP_PORT=587
SMTP_USER=nome-utente-smtp
SMTP_PASSWORD=password-smtp
SMTP_SECURE_ENABLED=1

Login con Google o GitHub (opzionale)

Se vuoi permettere il login con account Google o GitHub, aggiungi le credenziali OAuth ottenute dalla rispettiva console sviluppatori:

GOOGLE_CLIENT_ID=...
GOOGLE_CLIENT_SECRET=...

GITHUB_ID=...
GITHUB_SECRET=...

Applicare le modifiche

Dopo ogni modifica al file .env, riavviare lo stack perché le variabili vengano ricaricate:

cd ~/formbricks-install/formbricks

./formbricks.sh restart

NOTA BENE: non modificare mai a mano i secret generati automaticamente durante l’installazione (NEXTAUTH_SECRET, ENCRYPTION_KEY, CRON_SECRET, ecc.) sono legati ai dati già cifrati nel database.

COMANDI DI GESTIONE UTILI

Tutti i comandi vanno eseguiti dentro ~/formbricks-install/formbricks/:

./formbricks.sh logs # visualizza i log dei container
./formbricks.sh stop # ferma lo stack
./formbricks.sh restart # riavvia lo stack
./formbricks.sh update # aggiorna Formbricks all'ultima versione stabile
./formbricks.sh uninstall # disinstalla e rimuove tutti i dati (irreversibile)

Lo script update non sovrascrive il tuo docker-compose.yml personalizzato, quindi eventuali modifiche manuali vengono preservate.

BACKUP CONSIGLIATI

Per poter ripristinare l’installazione in caso di problemi, includi periodicamente nel tuo piano di backup:

Il file ~/formbricks-install/formbricks/.env (contiene tutti i secret).

Un dump del database PostgreSQL:

cd ~/formbricks-install/formbricks

docker compose exec postgres pg_dump -U postgres formbricks > backup-formbricks-$(date +%F).sql

Se usi lo storage file locale (RustFS incluso), anche i relativi volumi Docker.

PRO E CONTRO

PRO

• Open source e self-hosted senza limiti artificiali: a differenza di alternative SaaS come Typeform o SurveyMonkey, la versione self-hosted di Formbricks non impone limiti sul numero di risposte raccolte, e il codice sorgente è liberamente ispezionabile e modificabile.
• Controllo completo sui dati: essendo ospitato su infrastruttura propria, tutti i dati restano all’interno del perimetro dell’organizzazione, un vantaggio rilevante per requisiti di data residency, GDPR o policy interne di sicurezza.
• Targeting comportamentale avanzato: consente di attivare micro-survey in-app basate su comportamento dell’utente, pagine visitate o eventi personalizzati, permettendo di raccogliere feedback nel momento più significativo.
• Builder no-code: la creazione di sondaggi (NPS, CSAT, CES e altri template predefiniti) non richiede competenze tecniche, rendendo lo strumento accessibile anche a team non sviluppatori.
• Flessibilità nei canali di distribuzione: supporta sondaggi in-app, pop-up su sito web e link condivisibili, coprendo diversi scenari di raccolta feedback.

CONTRO

• Complessità dell’auto-hosting: come abbiamo sperimentato direttamente in questa installazione, il deployment richiede familiarità con Docker, Docker Compose, reverse proxy (Traefik) e gestione di variabili d’ambiente — non è un prodotto “plug and play” per team privi di competenze sistemistiche.
• Manutenzione continuativa: essendo self-hosted, l’organizzazione si assume la responsabilità di aggiornamenti, backup del database, gestione dei certificati TLS e troubleshooting (come il problema di “Invalid origin” legato al mismatch tra protocollo configurato e protocollo di accesso).
• Focus limitato a survey in-app e su sito: è meno adatto a form standalone complessi, quiz strutturati o flussi collegati a pagamenti, ambiti in cui strumenti come Typeform restano più maturi.
• Libreria template ridotta: rispetto a competitor consolidati, offre meno template predefiniti e minori opzioni di personalizzazione grafica “out of the box”.
• Integrazione per survey in-app: richiede l’integrazione di un SDK JavaScript nel prodotto/sito, il che comporta un carico di lavoro di sviluppo iniziale non banale.
• Analytics essenziali: le dashboard di reporting integrate sono più basilari rispetto a strumenti concorrenti orientati all’analisi avanzata dei dati.

Excalidraw è una lavagna virtuale open source, distribuita con licenza MIT, pensata per creare in modo rapido diagrammi, schizzi e wireframe con un caratteristico stile “disegnato a mano”.

A differenza degli strumenti di diagrammistica tradizionali, dove la precisione formale è spesso richiesta fin da subito, Excalidraw punta sull’informalità del tratto: questo lo rende particolarmente adatto alle fasi di brainstorming, alla progettazione rapida di flussi e architetture di sistema, o semplicemente a spiegare un’idea con pochi tratti essenziali, senza la rigidità di strumenti come UML o BPMN.

Il progetto, scritto in TypeScript e React, è sviluppato attivamente ed è oggi uno dei punti di riferimento tra le alternative open source a strumenti come Miro o FigJam.

Uno degli aspetti che rende Excalidraw interessante per un’organizzazione è proprio la possibilità di self-hosting: l’applicazione può essere eseguita interamente sui propri server tramite container Docker, mantenendo così pieno controllo sui dati e sui diagrammi prodotti, senza dipendere da un servizio cloud di terze parti né dover condividere contenuti potenzialmente sensibili (schemi di rete, architetture applicative, processi interni) al di fuori della propria infrastruttura.

Va però precisato un dettaglio tecnico non sempre evidente: l’immagine Docker ufficiale distribuita dal progetto fornisce solo l’editor client, mentre le funzionalità di collaborazione in tempo reale (più utenti che disegnano contemporaneamente sulla stessa lavagna) richiedono componenti aggiuntivi, come il servizio excalidraw-room per il canale WebSocket e un backend di storage per il salvataggio delle scene condivise.

Nella pratica, un self-hosting completo si realizza tipicamente componendo più container tramite Docker Compose.

In questo articolo vedremo come installare e configurare Excalidraw in versione base su un sistema Ubuntu Server 26.04, utilizzando Docker Engine per l’esecuzione dei container: dalla preparazione dell’ambiente Docker fino all’avvio della lavagna, con l’obiettivo di ottenere un’istanza funzionante e pronta all’uso.

PREREQUISITI

• Server con Ubuntu Server 26.04 LTS appena installato, accesso sudo o root via SSH.
• Risorse minime: 1 vCPU, 1 GB di RAM, 5 GB di spazio disco (l’app è molto leggera, ~40 MB l’immagine).
• Un dominio che punti all’IP del server (consigliato: Excalidraw usa WebSocket per la collaborazione live, che funziona meglio dietro HTTPS).
• Firewall con le porte 22 (SSH), 80 (HTTP) e 443 (HTTPS) raggiungibili.

AGGIORNAMENTO DEL SISTEMA

Aggiornare il sikstema con i seguenti comandi:

sudo apt update && sudo apt upgrade -y

sudo apt install -y ca-certificates curl ufw

sudo ufw allow OpenSSH

sudo ufw enable

NOTA PRELIMINARE

Excalidraw non ha un metodo di installazione “tradizionale” (niente PHP/MySQL): il progetto distribuisce un’immagine Docker ufficiale ed è il modo supportato per self-hostarlo.

Questa guida usa Docker + Apache come reverse proxy HTTPS.

INSTALLAZIONE DI DOCKER ENGINE

Per l’installazione di Docker eseguire i comandi:

sudo apt remove -y docker.io docker-doc docker-compose podman-docker containerd runc 2>/dev/null

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
newgrp docker

NOTA BENE: se sudo apt update restituisce un errore sul repository Docker (può succedere nei primi mesi dopo l’uscita di una nuova versione LTS, se Docker non ha ancora pubblicato i pacchetti per il codename “resolute”), sostituisci temporaneamente il valore di Suites con noble nel file /etc/apt/sources.list.d/docker.sources: i pacchetti di Ubuntu 24.04 sono compatibili.

AVVIO DEL CONTAINER EXCALIDRAW

Usare Docker Compose per gestire il servizio in modo ordinato:

sudo mkdir -p /opt/excalidraw

sudo nano /opt/excalidraw/docker-compose.yml

Quindi copiare all’interno del file il seguente output:

services:
excalidraw:
image: excalidraw/excalidraw:latest
container_name: excalidraw
restart: unless-stopped
ports:
- "127.0.0.1:5000:80"

NOTA BENE: Il container ascolta solo su localhost: sarà Apache a esporlo pubblicamente in HTTPS

cd /opt/excalidraw

sudo docker compose up -d

Dovremmo visualizzare un output simile al seguente:

[+] up 13/13
 Image excalidraw/excalidraw:latest Pulled 4.1s
 Network excalidraw_default Created 0.0s
 Container excalidraw Started

VERIFICA LOCALE

Fare una verifica con i seguenti comandi:

sudo docker ps

curl -I http://127.0.0.1:5000

Il primo comando deve mostrare il container excalidraw in stato Up:

2f8a6f688111 excalidraw/excalidraw:latest "/docker-entrypoint.…" 51 seconds ago Up 50 seconds (healthy) 127.0.0.1:5000->80/tcp excalidraw

il secondo deve restituire HTTP/1.1 200 OK:

HTTP/1.1 200 OK
Server: nginx/1.27.5
Date: Thu, 27 Aug 2026 12:31:08 GMT
Content-Type: text/html
Content-Length: 6843
Last-Modified: Wed, 06 May 2026 21:19:55 GMT
Connection: keep-alive
ETag: "69fbb07b-1abb"
Accept-Ranges: bytes

INSTALLAZIONE DI APACHE COME REVERSE PROXY

Installare Apache come Reverse Proxy con i seguenti comandi:

sudo apt install -y apache2

sudo a2enmod proxy proxy_http proxy_wstunnel headers rewrite

sudo systemctl restart apache2

sudo ufw allow "Apache Full"

NOTA BENE: I moduli proxy_http e proxy_wstunnel sono necessari perché Excalidraw usa WebSocket per la modalità collaborativa.

VIRTUAL HOST DI APACHE

Configurare il Virtual Host di Apache editando il file con il comando:

sudo nano /etc/apache2/sites-available/excalidraw.conf

Copiare il seguente output:

<VirtualHost *:80>
ServerName draw.tuodominio.org

ProxyPreserveHost On
ProxyPass / http://127.0.0.1:5000/
ProxyPassReverse / http://127.0.0.1:5000/

ErrorLog ${APACHE_LOG_DIR}/excalidraw_error.log
CustomLog ${APACHE_LOG_DIR}/excalidraw_access.log combined
</VirtualHost>

ATTENZIONE: Sostituire draw.tuodominio.org con il tuo dominio

Attivare il sito con i comandi:

sudo a2ensite excalidraw.conf

sudo a2dissite 000-default.conf

sudo systemctl reload apache2

HTTPS CON LET’S ENCRYPT

Attivare HTTPS con Let’s Encrypt con i seguenti comandi:

sudo apt install -y certbot python3-certbot-apache

sudo certbot --apache -d draw.tuodominio.org

sudo certbot renew --dry-run

ACCESSO VIA WEB GUI

A questo punto è possibile richiamare da un qualsiasi browser il link http://draw.tuodominio.org

Se è andato tutto a buon fine dovremmo visualizzare la lavagna virtuale come mostrato nell’immagine sovrastante

GESTIONE DEL CONTAINER

Alcuni comandi utili per la manutenzione ordinaria, da eseguire in /opt/excalidraw:

sudo docker compose logs -f # log in tempo reale

sudo docker compose pull # scarica un aggiornamento dell'immagine

sudo docker compose up -d # riavvia con la nuova immagine

sudo docker compose down # ferma il servizio

Grazie a restart: unless-stopped e a docker abilitato come servizio di sistema, il container riparte automaticamente anche dopo un riavvio del server.

COLLABORAZIONE IN TEMPO REALE (OPZIONALE-AVANZATO)

Va detto con chiarezza: l’immagine ufficiale excalidraw/excalidraw è una build statica che, per la funzione “Live collaboration”, punta al server pubblico gratuito di Excalidraw (oss-collab.excalidraw.com). Questo continua a funzionare anche su un’istanza self-hosted, e i dati della sessione restano comunque cifrati end-to-end lato client.

Se invece vuoi che tutto il traffico di collaborazione resti sul tuo server, serve affiancare il servizio ufficiale excalidraw/excalidraw-room e ricompilare il frontend da sorgente con la variabile VITE_APP_WS_SERVER_URL impostata sul tuo dominio: nell’immagine pre-costruita questo indirizzo è “congelato” nel bundle JavaScript in fase di build, non è configurabile a runtime con una semplice variabile d’ambiente.

Per questo motivo esula da una configurazione “base”: richiede una build Node.js personalizzata del frontend.

Se vuoi comunque provare il solo servizio di relay (utile se in futuro ricompili il frontend), il pezzo di configurazione è:

excalidraw-room:
image: excalidraw/excalidraw-room:latest
container_name: excalidraw-room
restart: unless-stopped
ports:
- "127.0.0.1:5001:80"

con un secondo Virtual Host Apache su un sottodominio dedicato (es. collab.tuodominio.org) che inoltra sia le richieste HTTP sia l’upgrade WebSocket verso 127.0.0.1:5001.

SALVATAGGIO E BACKUP

L’immagine base non include un database né uno storage lato server: ogni disegno viene salvato automaticamente solo nel localStorage del browser di chi lo sta usando.

Non c’è quindi nulla da backuppare sul server in questa configurazione base vale però la pena avvisare gli utenti di esportare periodicamente i lavori importanti da File → Esporta (formato .excalidraw o immagine), perché cancellare i dati del browser equivale a perdere il disegno.

PRO E CONTRO

PRO

• Gratuito, open source e senza registrazione: licenza MIT, nessun costo di licenza né account da creare per iniziare a disegnare.
• Interfaccia essenziale e curva di apprendimento minima: canvas pulito, tante scorciatoie da tastiera, adatto a chi vuole buttare giù un’idea senza distrazioni.
• Stile “disegnato a mano” efficace per l’informalità: perfetto per brainstorming, wireframe rapidi e schemi di architettura da usare in fase di discussione, senza la rigidità di strumenti UML/BPMN.
• Leggero ed embeddabile: distribuito anche come pacchetto React (@excalidraw/excalidraw), è integrabile in altre applicazioni ed esiste come plugin/estensione in strumenti come Obsidian e VS Code.
• Controllo completo dei dati con il self-hosting: eseguendolo su propri container Docker, i diagrammi (anche quelli che rappresentano schemi di rete o architetture interne) restano sulla propria infrastruttura invece che su un servizio cloud di terze parti.
• Esportazione flessibile: i lavori possono essere esportati in PNG, SVG o nel formato nativo .excalidraw per backup o condivisione manuale.

CONTRO

• Non adatto a diagrammi formali complessi: manca di funzionalità per notazioni rigorose come UML, ER o BPMN, ed è meno indicato per presentazioni che richiedono un aspetto grafico curato e “pulito”.
• Persistenza limitata nella versione self-hosted di base: senza un backend di storage dedicato, i disegni vengono salvati solo localmente nel browser (localStorage/IndexedDB); svuotando i dati del browser si perde tutto ciò che non è stato esportato manualmente.
• Collaborazione in tempo reale non inclusa “di serie”: l’immagine Docker ufficiale fornisce solo l’editor; abilitare la collaborazione multi-utente richiede componenti aggiuntivi (excalidraw-room, backend di storage) e una configurazione più articolata via Docker Compose.
• Nessuna condivisione tramite link diretto: a differenza della versione pubblica excalidraw.com, l’istanza self-hosted non genera link di condivisione: la distribuzione dei lavori avviene esportando e inviando manualmente i file.
• Dipendenza da accesso HTTPS in uscita per le librerie della community: in ambienti isolati o air-gapped questa funzionalità non è disponibile senza interventi manuali.
• Versionamento dell’immagine Docker poco strutturato: sono disponibili solo i tag latest o basati sull’hash del commit, senza versioning semantico, il che rende più delicata la gestione degli aggiornamenti in un ambiente di produzione.

EspoCRM è un software di Customer Relationship Management (CRM) open source, distribuito sotto licenza GNU Affero General Public License v3 (AGPLv3), pensato per la gestione delle relazioni con clienti, fornitori e partner all’interno di un’organizzazione.

A differenza delle soluzioni CRM proprietarie basate su abbonamento, EspoCRM viene installato ed eseguito interamente sui server dell’organizzazione che lo adotta: questo garantisce il pieno controllo sui dati, l’assenza di costi di licenza per utente e nessun vincolo verso un fornitore esterno (vendor lock-in), aspetti particolarmente rilevanti per realtà come le organizzazioni non profit, dove il controllo dei costi operativi e la sovranità sui propri dati sono priorità concrete.

Dal punto di vista funzionale, EspoCRM consente di gestire in un unico ambiente i contatti e le anagrafiche aziendali, le opportunità di vendita e la relativa pipeline commerciale, le richieste di assistenza e supporto ai clienti, le attività di marketing e la comunicazione, oltre a automatizzare flussi di lavoro ricorrenti tramite regole configurabili. Il sistema è altamente personalizzabile: è possibile creare entità, campi e relazioni su misura senza dover intervenire sul codice sorgente, adattando lo strumento ai processi specifici dell’organizzazione anziché il contrario. L’architettura applicativa si basa su un frontend single-page che dialoga con un backend tramite API REST aperta, il che rende EspoCRM facilmente integrabile con altri sistemi (siti web, strumenti di posta elettronica, applicazioni gestionali) e ne fa, più che un semplice CRM, una piattaforma su cui costruire applicazioni gestionali su misura.

Sul piano tecnico, EspoCRM è un’applicazione web scritta in PHP che richiede un server web (Apache o Nginx), un database relazionale (MySQL o MariaDB) e un insieme di estensioni PHP dedicate per funzionare correttamente.

Essendo self-hosted, l’intero ciclo di vita del software — installazione, configurazione, aggiornamenti, backup e messa in sicurezza — è responsabilità di chi lo gestisce.

Il presente documento descrive la procedura di installazione e configurazione di base di EspoCRM su un sistema Ubuntu Server 26.04, a partire dalla preparazione dell’ambiente (stack LAMP/LEMP e relative dipendenze) fino alla prima configurazione applicativa, con l’obiettivo di fornire un ambiente funzionante, sicuro e pronto per un utilizzo in produzione.

PREREQUISITI

• Server con Ubuntu Server 26.04 LTS (“Resolute Raccoon”) appena installato, accesso sudo o root via SSH.
• Risorse minime consigliate: 2 vCPU, 4 GB di RAM, 20 GB di spazio disco (EspoCRM funziona anche con 2 GB di RAM su installazioni piccole, ma 4 GB evitano rallentamenti).
• Un nome di dominio che punti all’IP del server (facoltativo ma consigliato, necessario per il certificato HTTPS allo step 10).
• Firewall con le porte 22 (SSH), 80 (HTTP) e 443 (HTTPS) raggiungibili.

AGGIORNAMENTO DEL SISTEMA

Si parte sempre allineando i pacchetti di sistema e installando gli strumenti di base che serviranno più avanti.

sudo apt update && sudo apt upgrade -y
sudo apt install -y software-properties-common curl wget unzip ufw

Se il server è nuovo, conviene attivare subito il firewall di base:

sudo ufw allow OpenSSH
sudo ufw enable

INSTALLAZIONE DI APACHE

EspoCRM supporta Apache, Nginx e IIS: questa guida usa Apache perché è la scelta più semplice da configurare per un’installazione base con .htaccess.

Installare Apache con i seguenti comandi:

sudo apt install -y apache2
sudo systemctl enable --now apache2
sudo ufw allow "Apache Full"

Verificare che il servizio sia attivo puntando il browser all’indirizzo IP del server: deve comparire la pagina predefinita di Apache.

INSTALLAZIONE DI PHP 8.5 E DELLE ESTENSIONI

Ubuntu 26.04 include PHP 8.5 nei repository ufficiali, che rientra nell’intervallo richiesto da EspoCRM (PHP 8.3–8.5): non serve aggiungere repository di terze parti.

Eseguire i comandi:

sudo apt install -y php libapache2-mod-php php-cli \
php-mysql php-gd php-mbstring php-xml php-curl \
php-zip php-bcmath php-intl

Parametri consigliati. Aprire /etc/php/8.5/apache2/php.ini e impostare i valori consigliati da EspoCRM (aumentano i limiti di memoria, tempo di esecuzione e dimensione degli upload):

sudo sed -i \
-e 's/^max_execution_time = .*/max_execution_time = 180/' \
-e 's/^max_input_time = .*/max_input_time = 180/' \
-e 's/^memory_limit = .*/memory_limit = 256M/' \
-e 's/^post_max_size = .*/post_max_size = 50M/' \
-e 's/^upload_max_filesize = .*/upload_max_filesize = 50M/' \
-e 's/^;date.timezone =.*/date.timezone = Europe\/Rome/' \
/etc/php/8.5/apache2/php.ini

Riavviare Apache con il comando:

sudo systemctl restart apache2

Di seguito i paramentri che dovremmo avere:

max_execution_time: 180
max_input_time: 180
memory_limit: 256M
post_max_size: 50M
upload_max_filesize: 50M

INSTALLAZIONE E CONFIGURAZIONE DI MARIADB

In Ubuntu 26.04 MariaDB 11.8 è disponibile direttamente nell’archivio principale (in precedenza era in “universe”), ben oltre la versione minima 10.3 richiesta da EspoCRM.

sudo apt install -y mariadb-server

sudo systemctl enable --now mariadb

sudo mariadb-secure-installation

Durante mariadb-secure-installation rispondere Y a tutte le domande (impostare una password per root, rimuovere utenti anonimi e il database di test).

Creare il database con i seguenti comandi:

sudo mysql -u root -p

CREATE DATABASE espocrm CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'espocrm_user'@'localhost' IDENTIFIED BY 'Password_Sicura!Lel';
GRANT ALL PRIVILEGES ON espocrm.* TO 'espocrm_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

NOTA BENE: sostituire Password_Sicura!Lel con una password robusta e conservarla: servirà nel wizard di installazione.

DOWNLOAD ED ESTRAZIONE DI ESPOCRM

Scaricare il pacchetto ufficiale (versione 10.0.6 al momento della stesura di questa guida verifica su espocrm.com/download se è uscita una versione più recente) ed estrailo nella document root.

Eseguire i comandi:

cd /tmp

wget https://www.espocrm.com/downloads/EspoCRM-10.0.6.zip

sudo mkdir -p /var/www/espocrm

sudo unzip -q EspoCRM-10.0.6.zip -d /var/www/espocrm

Controllare il contenuto della cartella: se l’archivio ha creato una sottocartella invece di estrarre i file direttamente, spostane il contenuto un livello sopra con i seguenti comandi:

ls /var/www/espocrm

# se compare una sola cartella tipo "EspoCRM-10.0.6", eseguire i comandi:

sudo mv /var/www/espocrm/EspoCRM-10.0.6/* /var/www/espocrm/

sudo rm -rf /var/www/espocrm/EspoCRM-10.0.6

CONFIGURAZIONE DEI PERMESSI SUI FILES

EspoCRM richiede permessi specifici perché Apache possa scrivere cache, upload e log senza esporre l’intera installazione in scrittura.

sudo chown -R www-data:www-data /var/www/espocrm
sudo find /var/www/espocrm -type d -exec chmod 755 {} \;
sudo find /var/www/espocrm -type f -exec chmod 644 {} \;
sudo chmod -R 775 /var/www/espocrm/data

CONFIGURAZIONE DEL VIRTUALHOST IN APACHE

Il document root di EspoCRM deve puntare alla sottocartella public/, non alla radice del pacchetto: è lì che si trova il punto d’ingresso dell’applicazione.

sudo a2enmod rewrite

sudo nano /etc/apache2/sites-available/espocrm.conf

Contenuto del file /etc/apache2/sites-available/espocrm.conf:

<VirtualHost *:80>
ServerName crm.tuodominio.org
DocumentRoot /var/www/espocrm/public
Alias /client/ /var/www/espocrm/client/

<Directory /var/www/espocrm/public/>
AllowOverride All
Require all granted
</Directory>

<Directory /var/www/espocrm/>
AllowOverride None
</Directory>

ErrorLog ${APACHE_LOG_DIR}/espocrm_error.log
CustomLog ${APACHE_LOG_DIR}/espocrm_access.log combined
</VirtualHost>

NOTA BENE: Sostituire crm.tuodominio.org con il tuo dominio (o rimuovere la riga ServerName per usare temporaneamente il solo IP).

Poi attivare il sito con is eguenti comandi:

sudo a2ensite espocrm.conf

sudo a2dissite 000-default.conf

sudo systemctl reload apache2

INSTALLAZIONE GUIDATA VIA BROWSER

Aprire da un qualsiasi browser http://crm.tuodominio.org (o l’IP del server).

EspoCRM avvia automaticamente il wizard di installazione perché non trova ancora una configurazione.

Selezionare la lingua, il tema quindi cliccare Inizio

Accettare il contratto quindi cliccare Avanti

Inserire tutte le info relative al database quindi cliccare su Test Connessione. Se è tutto OK cliccare Avanti

Verificare che sia tutto OK quindi cliccare Installa

Creare le credenziali amministrative quindi cliccare Avanti

Configurare tutte le Impostazioni di Sistema quindi cliccare Avanti

Cliccare su Vai a EspoCMR per proseguire

Inserire le credenziali create in precedenza quindi cliccare Accedi

Se è andato tutto a buon fine dovremmo visualizzare la Dashboard di EspoCRM

CONFIGURAZIONE DEL CRON JOB

I processi pianificati di EspoCRM (invio email in coda, notifiche, workflow, report automatici) girano tramite un job cron che va aggiunto manualmente.

sudo crontab -u www-data -e

Aggiungere questa riga (esecuzione ogni minuto):

* * * * * /usr/bin/php -f /var/www/espocrm/cron.php > /dev/null 2>&1

Il cron va eseguito come utente www-data (lo stesso proprietario dei file) per evitare problemi di permessi su cache e log.

HTTPS CON LET’S ENCRYPT

Con un dominio già puntato al server, attivare HTTPS richiede un solo comando grazie a Certbot.

sudo apt install -y certbot python3-certbot-apache

sudo certbot --apache -d crm.tuodominio.org

Certbot modifica automaticamente il Virtual Host per servire in HTTPS e configura il rinnovo automatico del certificato. Verifica il rinnovo con:

sudo certbot renew --dry-run

CONFIGURAZIONE BASE POST-INSTALLAZIONE

Accedere come amministratore e completare queste impostazioni essenziali prima di invitare gli utenti (menu Amministrazione in alto a destra):

Impostazioni generali: nome dell’organizzazione, logo, fuso orario e formati di data/valuta, sotto Amministrazione → Impostazioni.

Email in uscita (SMTP): sotto Amministrazione → Email in uscita, necessaria per notifiche, reset password e invii da EspoCRM.

Utenti e ruoli: creare gli account per il team sotto Amministrazione → Utenti e definire i ruoli di accesso prima di condividere l’URL.

Backup: pianificare un backup regolare che copra sia i file (/var/www/espocrm, in particolare data/ e custom/) sia un dump del database (mysqldump espocrm).

PRO E CONTRO

Come ogni soluzione software, anche EspoCRM presenta punti di forza e limiti di cui tenere conto in fase di valutazione e adozione.

PRO

• Nessun costo di licenza per utente e controllo dei dati: essendo open source e self-hosted, l’organizzazione non paga canoni per utente e mantiene i dati interamente sui propri server, un aspetto rilevante per realtà con budget limitati o vincoli sulla riservatezza dei dati.
• Personalizzazione senza scrivere codice: tramite l’Entity Manager è possibile creare entità, campi, layout e relazioni su misura per i propri processi, senza dover modificare il codice sorgente dell’applicazione.
• Interfaccia pulita e curva di apprendimento contenuta: per le funzioni di base (contatti, opportunità, attività) l’interfaccia è generalmente descritta come intuitiva e semplice da usare.
• Automazione dei flussi di lavoro: regole, notifiche e processi (BPM) configurabili permettono di automatizzare attività ricorrenti senza sviluppo custom.
• API REST aperta: facilita l’integrazione con siti web, strumenti di posta elettronica e altri sistemi gestionali dell’organizzazione.
• Costo complessivo contenuto rispetto a CRM enterprise paragonabili, sia nella versione community gratuita sia nel piano cloud a pagamento.

CONTRO

• Funzionalità di comunicazione native limitate: mancano automazioni integrate per canali come SMS o WhatsApp; per queste esigenze occorre affidarsi a strumenti terzi.
• Integrazioni native ridotte: di serie sono previste solo poche integrazioni (es. Google/Outlook, Mailchimp, VoIP); per collegare altri servizi è spesso necessario ricorrere a strumenti come Zapier/Make oppure sviluppare integrazioni custom via API.
• Le funzionalità avanzate richiedono competenze tecniche: automazioni complesse, integrazioni e personalizzazioni profonde presuppongono un amministratore con un minimo di preparazione tecnica.
• Reportistica meno sofisticata: le capacità di analisi e reporting sono giudicate meno avanzate rispetto a CRM enterprise dedicati.
• Prestazioni da monitorare con grandi volumi di dati: alcuni utenti segnalano rallentamenti in presenza di dataset molto grandi o workflow particolarmente complessi.
• App mobile meno matura: le applicazioni mobile ufficiali sono ritenute meno complete e con qualche criticità rispetto alla versione web.
• Responsabilità gestionale del self-hosting: essendo il software installato ed eseguito sui server dell’organizzazione, aggiornamenti, backup e sicurezza (patch, hardening del server, certificati) restano a carico di chi lo amministra, a differenza di una soluzione SaaS dove questi aspetti sono gestiti dal fornitore.

LimeSurvey è una piattaforma open source per la creazione e gestione di sondaggi online, nata nel 2003 e oggi una delle alternative gratuite più diffuse a servizi commerciali come SurveyMonkey, Typeform o Google Forms.

È utilizzata da aziende, università, enti pubblici e organizzazioni non profit per raccogliere dati tramite questionari anche molto complessi, restando al 100% sotto il controllo di chi la installa: nessun dato di sondaggio transita verso server di terzi, il che la rende una scelta naturale quando la titolarità dei dati raccolti (specialmente dati personali dei rispondenti) deve rimanere interna.

La Community Edition (CE), quella che installeremo, è distribuita sotto licenza GPL v2 ed è completamente gratuita e autonoma: comprende sondaggi e domande illimitate, oltre 30 tipologie di domanda, più di 900 template grafici, supporto multilingua (80+ lingue), logica condizionale avanzata, autenticazione a due fattori, integrazioni LDAP/SAML e API REST, oltre a funzionalità di accessibilità (WCAG 2.0) e strumenti per la conformità GDPR.

Le funzionalità aggiuntive di supporto, hosting gestito e servizi enterprise restano nell’offerta commerciale a pagamento di LimeSurvey GmbH, ma non sono necessarie per un’installazione self-hosted funzionale al 100%.

NOTE IMPORTANTI

Un paio di note prima di partire, verificate di recente:

• Con MySQL 9.x l’autenticazione di LimeSurvey si rompe perché è stato rimosso mysql_native_password → meglio pinnare MySQL 8.4.
• La cartella /var/www/html/upload contiene anche temi e plugin, non solo i file dei sondaggi: va montata per intero, altrimenti un rebuild del container li cancella.

PREREQUISITI

Docker e Docker Compose già installati sul tuo Ubuntu Server 26.04.

NSTALLAZIONE DI DOCKER E DOCKER COMPOSE

Se il server non ha già Docker installato eseguire i comandi elencati di seguito:

sudo apt update

sudo apt install -y ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Verificare l’installazione di docker con i comandi:

docker --version

Dovremmo visualizzare il seguente output:

Docker version 29.7.2, build a7dcaa6

Eseguire quindi il comando:

docker compose version

Dovremmo visualizzare il seguente output:

Docker Compose version v5.5.0

(Facoltativo) Per usare docker senza sudo eseguire i comandi:

sudo usermod -aG docker $USER
newgrp docker

STRUTTURA DELLE CARTELLE

Eseguire i comandi:

mkdir -p ~/limesurvey/{upload,db-data}
cd ~/limesurvey

CREAZIONE FILE .ENV

Eseguire il comando:

cat > .env << 'EOF'
# Database
MYSQL_ROOT_PASSWORD=CambiaQuestaPassword!
MYSQL_DATABASE=limesurvey
MYSQL_USER=limesurvey
MYSQL_PASSWORD=CambiaAncheQuestaPassword!

# LimeSurvey Admin
LS_ADMIN_USER=admin
LS_ADMIN_NAME=Amministratore
LS_ADMIN_EMAIL=admin@tuodominio.it
LS_ADMIN_PASSWORD=CambiaQuestaPasswordAdmin!

# URL pubblico (adatta al tuo dominio/reverse proxy)
LS_PUBLIC_URL=https://survey.mypsx.net
EOF

Quindi eseguire il comando:

chmod 600 .env

CREAZIONE DEL FILE DOCKER-COMPOSE.YML

Creare il file docker-compose.yml con il comando:

sudo nano docker-compose.yml

Quindi incollare all’interno il seguente output:

services:
mysql:
image: mysql:8.4
container_name: limesurvey-mysql
restart: unless-stopped
environment:
MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
MYSQL_DATABASE: ${MYSQL_DATABASE}
MYSQL_USER: ${MYSQL_USER}
MYSQL_PASSWORD: ${MYSQL_PASSWORD}
volumes:
- ./db-data:/var/lib/mysql
healthcheck:
test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p${MYSQL_ROOT_PASSWORD}"]
interval: 10s
timeout: 5s
retries: 10

limesurvey:
image: martialblog/limesurvey:7-apache
container_name: limesurvey-app
restart: unless-stopped
depends_on:
mysql:
condition: service_healthy
environment:
DB_TYPE: mysql
DB_HOST: mysql
DB_PORT: 3306
DB_NAME: ${MYSQL_DATABASE}
DB_USERNAME: ${MYSQL_USER}
DB_PASSWORD: ${MYSQL_PASSWORD}
ADMIN_USER: ${LS_ADMIN_USER}
ADMIN_NAME: ${LS_ADMIN_NAME}
ADMIN_EMAIL: ${LS_ADMIN_EMAIL}
ADMIN_PASSWORD: ${LS_ADMIN_PASSWORD}
PUBLIC_URL: ${LS_PUBLIC_URL}
ports:
- "8080:8080"
volumes:
- ./upload:/var/www/html/upload

AVVIO DEL CONTAINER

Avviare il container con il comando:

docker compose up -d

Dovremmo visualizzare un output simile al seguente:

[+] up 40/40
 Image martialblog/limesurvey:7-apache Pulled
 Image mysql:8.4 Pulled
 Network limesurvey_default Created
 Container limesurvey-mysql Healthy
 Container limesurvey-app Started

Quindi analizzare i log con il comando:

docker compose logs -f limesurvey

Dovremmo visualizzare un output simile al seguente:

limesurvey-app | Info: Customizing Apache Listen port to 8080
limesurvey-app | Connection to mysql (172.18.0.2) 3306 port [tcp/*] succeeded!
limesurvey-app | Info: Generating config.php
limesurvey-app | Info: Using MySQL configuration
limesurvey-app | Info: Using TCP connection
limesurvey-app | Info: Creating security.php
limesurvey-app | Warning: No encryption keys were provided
limesurvey-app | Warning: A security.php config will be created by the application
limesurvey-app | Info: Check if database already provisioned. Nevermind the Stack trace.
limesurvey-app | Warning: THIS FILE NEEDS TO BE PERSISTENT

PRIMO AVVIO TRAMITE WEB GUI

Al primo avvio l’entrypoint crea config.php ed esegue l’installazione via CLI usando le variabili ADMIN_*.

Attendere che i log mostrino il completamento poi richiamare i seguenti link:

Frontend: http://<ip-server>:8080/

Questo è il Front End

Backend: http://<ip-server>:8080/index.php/admin

Questo è il Back End

Inserire le credenziali censite nel file .env quindi cliccare Log In

NOTA BENE: cambiare le variabili ADMIN_* dopo l’installazione iniziale non ha alcun effetto. Le credenziali si modificano solo dal pannello di amministrazione.

Cliccare su Chiudere per andare direttamante alla Dashboard oppure Creare una Nuova Indagine se si intende procedere subito con la creazione di una survey

Sopra un immagine che mostra la Dashboard di Backend di LimeSurvey

CONFIGURAZIONE REVERSE PROXY (NGINX PROXY MANAGER)

In Ngnix Proxy Manager creare un Proxy Host puntato a limesurvey-app:8080 (se sono sulla stessa rete Docker) o all’IP:8080 del server, con SSL Let’s Encrypt.

Se noti redirect che portano con sé la porta interna nell’URL aggiungere in Advanced:

proxy_set_header Host $host;
proxy_set_header X-Forwarded-Proto $scheme;

BACKUP DI LIMESURVEY

Di seguito i comandi per effettuare il backup di Limesurvey

# Database
docker exec limesurvey-mysql sh -c 'exec mysqldump -u root -p"$MYSQL_ROOT_PASSWORD" limesurvey' > backup_$(date +%F).sql

# File (temi, plugin, upload sondaggi)
tar czf upload_backup_$(date +%F).tar.gz ./upload

PRO E CONTRO

PRO

• Open source, GDPR-friendly per chi deve gestire dati sensibili in EU
• Immagine Docker martialblog/limesurvey mantenuta attivamente, con supporto sia Apache che FPM
• Motore di survey molto maturo: logica condizionale avanzata, quote, token per inviti, export in decine di formati
• Nessun limite sul numero di sondaggi, domande o risposte raccolte
• Enorme flessibilità nei tipi di domanda e nella logica dei questionari (skip logic, quote, randomizzazione)
• Dati dei sondaggi interamente sotto il proprio controllo, nessuna trasmissione a terzi
• Community ampia e attiva, centinaia di template e plugin disponibili
• Multilingua nativo, utile per sondaggi rivolti a pubblici internazionali

CONTRO

• Configurazione iniziale non banale dietro reverse proxy con sub-path (bug noto sul routing dell’area admin)
• L’immagine Docker non è “ufficiale” LimeSurvey ma community-maintained
• L’engine MyISAM di default per le tabelle dei sondaggi è datato; per uso serio conviene passare a InnoDB via DB_MYSQL_ENGINE=InnoDB
• Nessuna immagine Docker ufficiale: bisogna scegliere e fidarsi di un’immagine mantenuta dalla community
• Stack PHP + database relazionale più “pesante” da configurare correttamente (permessi file, cron per task pianificati, configurazione email) rispetto a soluzioni moderne a container singolo
• Interfaccia amministrativa meno immediata rispetto a strumenti commerciali blasonati; richiede un minimo di curva di apprendimento
• Gli aggiornamenti tra versioni maggiori possono richiedere passaggi manuali (backup e migrazione del database) più delicati

Plausible Analytics è una piattaforma di web analytics open source, leggera e privacy-friendly: non usa cookie, non traccia dati personali degli utenti e nasce già conforme al GDPR, senza bisogno di banner di consenso.

È una delle alternative più mature a Google Analytics per chi vuole tenere i dati dei propri siti interamente in casa.

Dalla versione 3.x, il progetto ha semplificato molto il self-hosting: la Community Edition (CE) ufficiale si installa tramite il repository plausible/community-edition, con un unico file compose.yml già pronto e gestione automatica del certificato TLS via Let’s Encrypt integrata nel container stesso (senza bisogno di un reverse proxy dedicato, a meno che non lo si preferisca).

PREREQUISITI

• Una VM o server con Ubuntu Server 26.04, accesso SSH con privilegi sudo/root
• Un dominio che punti all’IP del server (es. plausible.tuodominio.it), necessario per l’emissione automatica del certificato TLS
• Docker Engine ≥ 20.10.0 e Docker Compose ≥ 2.0.0
• Almeno 2 GB di RAM liberi (ClickHouse ne ha bisogno per funzionare senza OOM)
• Porte 80 e 443 libere e raggiungibili dall’esterno (per HTTP-01 challenge Let’s Encrypt

INSTALLAZIONE DI DOCKER E DOCKER COMPOSE

Se il server non ha già Docker installato eseguire i comandi elencati di seguito:

sudo apt update

sudo apt install -y ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Verificare l’installazione di docker con i comandi:

docker --version

Dovremmo visualizzare il seguente output:

Docker version 29.7.2, build a7dcaa6

Eseguire il comando:

docker compose version

Dovremmo visualizzare il seguente output:

Docker Compose version v5.5.0

(Facoltativo) Per usare docker senza sudo eseguire i comandi:

sudo usermod -aG docker $USER
newgrp docker

CLONAZIONE DEL REPOSITORY UFFICIALE

Clonare il repository ufficiale con i comandi:

git clone -b v3.2.1 --single-branch https://github.com/plausible/community-edition plausible-ce
cd plausible-ce
ls -1

Dovremmo visualizzare un output simile al seguente:

Cloning into 'plausible-ce'...
remote: Enumerating objects: 112, done.
remote: Counting objects: 100% (83/83), done.
remote: Compressing objects: 100% (49/49), done.
remote: Total 112 (delta 58), reused 34 (delta 34), pack-reused 29 (from 2)
Receiving objects: 100% (112/112), 22.15 KiB | 3.69 MiB/s, done.
Resolving deltas: 100% (63/63), done.
LICENSE
README.md
clickhouse
compose.yml

NOTA BENE: Controllare su GitHub se è disponibile un tag più recente di v3.2.1 al momento dell’installazione.

CONFIGURAZIONE DEL FILE .ENV

Creare il file .env con dominio e chiave segreta con i comandi:

touch .env
echo "BASE_URL=https://plausible.tuodominio.it" >> .env
echo "SECRET_KEY_BASE=$(openssl rand -base64 48)" >> .env

Verificare il contenuto con il seguente comando:

cat .env

Dovremmo visualizzare il seguente output:

BASE_URL: deve corrispondere al dominio che punta al tuo server (il DNS deve essere già propagato, serve per l’emissione automatica del certificato Let’s Encrypt).

SECRET_KEY_BASE: deve essere una stringa di almeno 64 byte (il comando openssl rand -base64 48 genera un valore adeguato). Conservala al sicuro, non versionarla su Git.

Test in locale: per provare Plausible senza un dominio pubblico puoi usare BASE_URL=http://localhost:8000.

ESPOSIZIONE DEL SERVIZIO WEB

Esistono due opzioni: TLS automatico integrato oppure dietro un reverse proxy che già gestisci (es. Nginx Proxy Manager).

OPZIONE A – TLS automatico (Let’s Encrypt integrato, nessun reverse proxy esterno)

echo "HTTP_PORT=80" >> .env
echo "HTTPS_PORT=443" >> .env

cat > compose.override.yml << 'EOF'
services:
plausible:
ports:
- 80:80
- 443:443
EOF

In questo modo il container stesso emette e rinnova il certificato TLS per il dominio in BASE_URL, senza bisogno di configurare nulla lato Nginx/Caddy.

OPZIONE B – Dietro un reverse proxy esistente (es. Nginx Proxy Manager)

Se preferisci mantenere la gestione dei certificati su Nginx Proxy Manager esporre Plausible solo su localhost su una porta interna e disabilitare il TLS automatico con i comandi:

echo "HTTP_PORT=8000" >> .env

cat > compose.override.yml << 'EOF'
services:
plausible:
ports:
- "127.0.0.1:8000:80"
EOF

Poi in NPM creare un nuovo Proxy Host con le seguenti info:

Domain: plausible.tuodominio.it

Forward Hostname/IP: IP del server Docker (o host.docker.internal se NPM è sullo stesso host in un’altra rete Docker)

Forward Port: 8000

Abilita SSL: con richiesta certificato Let’s Encrypt e “Force SSL” dal tab SSL di NPM

AVVIO DEL CONTAINER

Avviare il container con il comando:

docker compose up -d

Dovremmo visualizzare un output simile al seguente:

[+] up 43/43
 Image postgres:16-alpine Pulled 16.1s
 Image clickhouse/clickhouse-server:24.12-alpine Pulled 16.0s
 Image ghcr.io/plausible/community-edition:v3.2.1 Pulled 26.6s
 Network plausible-ce_default Created 0.0s
 Volume plausible-ce_db-data Created 0.0s
 Volume plausible-ce_event-data Created 0.0s
 Volume plausible-ce_event-logs Created 0.0s
 Volume plausible-ce_plausible-data Created 0.0s
 Container plausible-ce-plausible_events_db-1 Healthy 12.5s
 Container plausible-ce-plausible_db-1 Healthy 12.5s
 Container plausible-ce-plausible-1 Started

Controllare lo stato e i log con i seguenti comandi:

docker compose ps

docker compose logs -f plausible

ATTENZIONE: Attendere che PostgreSQL e ClickHouse superino i rispettivi health check prima che Plausible completi il setup del database: la prima partenza può richiedere qualche decina di secondi.

PRIMO ACCESSO VIA WEB GUI

Aprire il browser su $BASE_URL (es. https://plausible.tuodominio.it).

Al primo avvio la Community Edition mostra direttamente la pagina di registrazione: crea qui il primo utente amministratore (le registrazioni successive richiedono un invito).

Inserire tutte le info relative al primo amministratore quindi cliccare Create my account

Inserire le info relative al dominio quindi cliccare Install Palusible

Selezionare lo script da inserire sul sito da analizzare quindi cliccare Verify Script Installation

Attendere qualche minuto…

Al termine del check dovremmo visualizzare la dashboard con i siti sotto analisi

Dopo un po dovremmo iniziare a vedere tutte le statistiche dei siti come mostrato nell’immagine sovrastante

AGGIORNAMENTO NUOVA VERSIONE

Per aggiornare Plausible alla nuova versione eseguire i comandi:

cd plausible-ce

git fetch --tags

git checkout v3.x.x # nuovo tag disponibile

docker compose pull

docker compose up -d

BACKUP DI PLAUSIBLE

Per il backup i dati persistenti (PostgreSQL account/config e ClickHouse eventi) risiedono nei volumi Docker: identificali con docker volume ls e includili nella tua routine di backup abituale (es. snapshot del volume o pg_dump/clickhouse-backup pianificati).

PRO E CONTRO

PRO

• Nessun cookie, nessun dato personale raccolto: conforme GDPR by design
• Dashboard semplice, leggera, tutto su un’unica pagina
• Script di tracciamento minuscolo (pochi KB), impatto quasi nullo sulle performance
• Setup Docker Compose ufficiale e ben mantenuto, con TLS automatico incluso

CONTRO

• ClickHouse richiede CPU con set di istruzioni SSE 4.2 (o NEON su ARM): quasi tutte le CPU moderne lo supportano, ma va verificato su hardware datato o alcune VM
• Consiglia almeno 2 GB di RAM dedicati solo per ClickHouse + Plausible
• Le funzionalità avanzate (multi-utente su larga scala, funnel avanzati, ecc.) restano nelle versioni Cloud/Enterprise

CONCLUSIONI

Con la Community Edition attuale, il self-hosting di Plausible si riduce a clonare un repository, impostare due variabili in .env e lanciare docker compose up -d: il TLS automatico integrato elimina quasi del tutto la configurazione manuale di un reverse proxy, a meno che non si voglia integrarlo nell’infrastruttura esistente (come Nginx Proxy Manager). Il risultato è un’analytics leggera, privacy-first e completamente sotto il proprio controllo.

CloudBeaver Community è la versione open source e gratuita della piattaforma di gestione database sviluppata da DBeaver Corp, pensata per offrire un accesso ai dati completamente basato su browser, senza bisogno di installare alcun client desktop sulle postazioni degli utenti.

A differenza del classico DBeaver, che è un’applicazione desktop, CloudBeaver gira come servizio web: si installa una sola volta su un server centrale e da quel momento chiunque in azienda può connettersi, navigare tra schemi e tabelle, eseguire query SQL e consultare i risultati semplicemente aprendo un browser, da qualsiasi postazione o dispositivo.

Questa caratteristica lo rende particolarmente adatto in contesti dove serve dare accesso ai database a più persone (sviluppatori, analisti, team di supporto) senza dover gestire installazioni multiple, licenze client o configurazioni di rete complicate per ogni singolo utente.

Supporta nativamente i principali motori di database (PostgreSQL, MySQL, MariaDB, SQLite e molti altri tramite driver JDBC), e consente di centralizzare in un unico punto la gestione delle connessioni e dei permessi di accesso.

In questa guida vedremo come installare e configurare CloudBeaver Community su un server Ubuntu Server 26.04, sfruttando Docker Compose per ottenere un deployment pulito, riproducibile e facile da mantenere nel tempo: dalla preparazione dell’ambiente Docker, alla stesura del file docker-compose.yml, fino ai primi passi di configurazione post-installazione necessari per rendere l’istanza operativa.

PREREQUISITI

Docker e Docker Compose già installati. Se non presenti eseguire i comandi:

curl -fsSL https://get.docker.com -o get-docker.sh

sudo sh get-docker.sh

sudo usermod -aG docker $USER

newgrp docker

Verificare che il plugin Compose sia disponibile con il comando:

docker compose version

Dovremmo visualizzare il seguente output:

Docker Compose version v5.5.0

CREAZIONE DELLA STRUTTURA DI CARTELLE

Creare la struttura delle cartelle con i comandi:

sudo mkdir -p /opt/cloudbeaver/workspace

sudo chown -R $USER:$USER /opt/cloudbeaver

cd /opt/cloudbeaver

Il volume workspace è dove CloudBeaver salva configurazione, connessioni e credenziali cifrate: deve essere persistente.

CREAZIONE DEL FILE DOCKER-COMPOSE.YML

Creare il file docker-compose.yml con il comando:

nano /opt/cloudbeaver/docker-compose.yml

Quindi incollare il seguente output:

services:
cloudbeaver:
image: dbeaver/cloudbeaver:26.0.1
container_name: cloudbeaver
restart: unless-stopped
ports:
- "8978:8978"
volumes:
- ./workspace:/opt/cloudbeaver/workspace
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8978/status"]
interval: 30s
timeout: 10s
retries: 3

Salvare e chiudere il file di configurazione

NOTA BENE: 26.0.1 è la versione stabile più recente al momento; puoi anche usare il tag latest, ma per un ambiente di produzione è meglio fissare la versione (i downgrade non sono supportati, quindi conviene aggiornare consapevolmente).

AVVIARE IL CONTAINER

Avviare il container con i comandi:

cd /opt/cloudbeaver

docker compose up -d

Dovremmo visualizzare il seguente output:

[+] up 13/13
 Image dbeaver/cloudbeaver:26.0.1 Pulled
 Network cloudbeaver_default Created
 Container cloudbeaver Started

Controllare i log per verificare che sia partito correttamente con il comando:

docker compose logs -f cloudbeaver

Dovremmo visualizzare un output simile al seguente:

cloudbeaver | Starting Cloudbeaver Server
cloudbeaver | 2026-08-25 15:46:30.280 - Workspace path initialized: /opt/cloudbeaver/workspace
cloudbeaver | 2026-08-25 15:46:30.323 - Platform not initialized: metadata folder may be not set
cloudbeaver | 2026-08-25 15:46:30.333 - Starting instance server at http://localhost:33071
cloudbeaver | SLF4J(I): Logback configuration is used: conf/logback.xml
cloudbeaver | 25-08-2026 15:46:30.440 [main] DEBUG i.c.model.app.BaseServletApplication - Loading configuration from /opt/cloudbeaver/conf/cloudbeaver.conf

APERTURA PORTE FIREWALL

Aprire la porta sul firewall (se usi UFW) con il comando:

sudo ufw allow 8978/tcp

Se preferisci esporlo solo su localhost (per poi metterci un reverse proxy come Nginx Proxy Manager, che già usi), modificare il binding della porta così:

ports:
- "127.0.0.1:8978:8978"

SETUP INIZIALE VIA BROWSER

Richiamare da un qualsiasi browser il link http://<IP-del-server>:8978

Cliccare su Next

In questa schermata compilare:

Server Name: impostare un nome del server
Administrator Credentials: impostare username e password amministratore
Allow Anonymus Access: Decidere se abilitare l’accesso anonimo. Ti consiglio di disabilitarlo, soprattutto se il servizio è raggiungibile fuori dalla LAN

Confermare la configurazione e cliccare Next

Terminare la configurazione cliccando Finish

Inserire le credendiziali create in precendenza e cliccare Login

AGGIUNGERE UNA CONNESSIONE AL DATABASE

Dal pannello cliccare sull’icona a forma di database/plug in alto a sinistra

Cliccare New Connection

Scegliere il driver (PostgreSQL, MySQL, MSSQL, ecc)

Inserire tutte le info relative alla connessione quindi cliccare Create

NOTE OPERATIVE

Backup: prima di ogni aggiornamento fare un backup della cartella workspace (contiene config e connessioni salvate).

Aggiornamenti: cambiare il tag immagine nel compose e rilanciare docker compose up -d (ATTENZIONE: non usare mai una versione più vecchia di quella già in uso, i downgrade non sono supportati).

HTTPS: se lo esponi con un reverse Proxy davanti, ricordarsi di forzare redirect HTTP→HTTPS e di impostare gli header giusti per il WebSocket (CloudBeaver lo usa per l’editor SQL live).

CONCLUSIONI

Ecco un quadro pro/contro di CloudBeaver Community:

PRO

• È completamente gratuito e open source, senza costi di licenza né limiti sul numero di utenti o connessioni, a differenza delle edizioni Lite/Enterprise/Ultimate a pagamento.
• Essendo web-based, non richiede installazioni sui client: basta un browser, il che semplifica molto la distribuzione in team distribuiti o con policy IT restrittive sui pacchetti installabili.
• Il deployment con Docker è molto rapido e riproducibile, ed è lo stesso identico stack usato per la Enterprise, quindi eventuali migrazioni future sono semplici.
• Supporta un buon numero di database out-of-the-box (PostgreSQL, MySQL, MariaDB, SQLite e altri via driver JDBC) e offre un editor SQL, navigazione degli schemi e gestione dati di base già solida per usi quotidiani.
• Interfaccia centralizzata: amministratori e utenti condividono le stesse connessioni configurate sul server, riducendo duplicazione di credenziali e configurazioni sparse.

CONTRO

• Manca il single sign-on e i metodi di autenticazione avanzati (SSO, OpenID, Entra ID/AzureAD, Okta, IAM): l’autenticazione resta basilare, il che può essere un problema in ambienti aziendali con requisiti di identity management centralizzato.
• Non ha la gestione multi-utente/team avanzata con ruoli e permessi granulari, né la condivisione sicura delle credenziali tra utenti autorizzati: funzionalità di collaborazione più fini restano riservate alla Enterprise.
• Mancano strumenti “PRO” utili in contesti più complessi: query builder visuale, diagrammi entità-relazione, gestione avanzata dei driver, query manager/history, session manager, secret management.
• Nessun supporto nativo per Cloud Explorer / Cloud Storage (AWS, Azure, GCP), quindi per scenari cloud-native più integrati serve comunque l’Enterprise.
• Nessun dominio personalizzato/SSL brandizzato incluso: per un deployment pubblico “professionale” bisogna comunque occuparsi tu stesso di reverse proxy, certificati e dominio (cosa comunque fattibile, ma è lavoro in più).
• Essendo la fascia gratuita, il supporto è essenzialmente quello della community (GitHub, forum), senza SLA o supporto commerciale diretto.