Postal è una piattaforma open source per l’invio e la ricezione di email, pensata per siti web, applicazioni e servizi che devono spedire grandi quantità di messaggi in modo affidabile.
Si può considerare un’alternativa self-hosted a servizi commerciali come SendGrid, Mailgun o Amazon SES: offre le stesse funzionalità principali, ma lascia il pieno controllo dell’infrastruttura, dei dati e dei costi.
Sviluppato dal provider britannico Krystal e distribuito con licenza MIT, Postal mette a disposizione un’interfaccia web completa per gestire organizzazioni, server di posta e domini.
Gli invii avvengono via SMTP o tramite API HTTP, con firma DKIM automatica dei messaggi. Postal offre anche il tracciamento di aperture e clic, i webhook per notificare alle applicazioni consegne e rimbalzi, la gestione dei pool di IP e un sistema di instradamento per la posta in arrivo.
Un punto va chiarito subito: Postal non è un server di caselle di posta.
Non offre IMAP o POP3 e non sostituisce soluzioni come Dovecot, Exchange o Microsoft 365.
È un Mail Transfer Agent orientato all’invio transazionale e massivo: email di registrazione, reset password, notifiche, newsletter e comunicazioni generate da applicazioni.
Dalla versione 3 l’architettura si è semplificata: Postal gira interamente in container Docker e non richiede più RabbitMQ, ma solo un database MariaDB.
Un server dedicato basta quindi per avere in poco tempo una piattaforma di invio professionale.
In questa guida vedremo passo dopo passo come installare e configurare Postal su Ubuntu Server 26.04 LTS con Docker Engine.
Partiremo dalla configurazione dei record DNS e arriveremo al primo accesso all’interfaccia web, con HTTPS gestito automaticamente da Caddy.
PREREQUISITI
Un server Ubuntu Server 26.04 LTS con un utente sudo e accesso SSH, dedicato (Postal non convive bene con altri servizi che occupano le stesse porte o risorse).
RAM: almeno 4 GB. CPU: almeno 2 core. Disco: almeno 25 GB (di più se prevedi volumi alti di invio, per via dei log dei messaggi).
Un dominio dedicato all’infrastruttura di invio (es. postal.tuodominio.it), con accesso al pannello DNS.
La porta 25 in uscita non bloccata dal provider: è la condizione più comune di fallimento — verificala prima di iniziare.
NOTA BENE: Postal gira interamente in container Docker: qualunque sistema operativo compatibile con Docker va bene, questa guida usa Ubuntu 26.04 come richiesto.
CONFIGURAZIONE DEL DNS
Configura nel pannello DNS del dominio scelto per Postal:
Record A (e AAAA se hai IPv6):
|
0
1
|
postal.tuodominio.it. IN A a.b.c.d
postal.tuodominio.it. IN AAAA ipv6::address
|
Record MX:
|
0 |
postal.tuodominio.it. IN MX 10 postal.tuodominio.it.
|
PTR (reverse DNS) richiesto lato provider, l’IP deve risolvere all’indietro nell’hostname:
|
0 |
nslookup a.b.c.d → deve restituire postal.tuodominio.it
|
I record SPF, return-path e DKIM li completerai allo step 11, dopo aver avviato Postal e creato il dominio dalla dashboard.
PREPARAZIONE DEL SISTEMA
|
0
1
|
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y ca-certificates curl gnupg git jq ufw
|
NOTA BENE: se l’aggiornamento include un nuovo kernel, riavvia con sudo reboot prima di proseguire.
INSTALLAZIONE DI DOCKER ENGINE
Aggiungi la chiave GPG e il repository Docker:
|
0
1
2
3
4
5
6
7
|
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
|
Quindi aggiornare con il comando:
|
0 |
sudo apt update
|
Installa Docker Engine e il plugin Compose:
|
0 |
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
|
Verifica e abilita l’utente corrente:
|
0
1
2
|
sudo docker run hello-world
sudo usermod -aG docker $USER
newgrp docker
|
ATTENZIONE: se poco dopo il rilascio di Ubuntu 26.04 il repository Docker non ha ancora una build per il suo codename, sostituisci $(. /etc/os-release && echo “$VERSION_CODENAME”) con il codename della LTS precedente supportata (es. noble) nel comando sopra.
AVVIARE MARIADB E RABBITMQ
Postal richiede MariaDB (10.6+) per i dati e RabbitMQ come coda dei messaggi. Genera prima due password robuste:
|
0
1
2
|
openssl rand -hex 16 # usala come password di MariaDB
openssl rand -hex 16 # usala come password di RabbitMQ
|
Avvia i due container (sostituisci PASSWORD_MARIADB e PASSWORD_RABBITMQ con i valori generati):
|
0
1
2
3
4
5
6
7
8
9
10
11
12
13
|
sudo docker run -d --name postal-mariadb \
-p 127.0.0.1:3306:3306 \
--restart always \
-e MARIADB_DATABASE=postal \
-e MARIADB_ROOT_PASSWORD=PASSWORD_MARIADB \
mariadb
sudo docker run -d --name postal-rabbitmq \
-p 127.0.0.1:5672:5672 \
--restart always \
-e RABBITMQ_DEFAULT_USER=postal \
-e RABBITMQ_DEFAULT_PASS=PASSWORD_RABBITMQ \
-e RABBITMQ_DEFAULT_VHOST=postal \
rabbitmq:3.8
|
Entrambi pubblicano la porta solo su 127.0.0.1, quindi restano raggiungibili esclusivamente dal server stesso.
NOTA BENE: per volumi di invio elevati o messaggi molto grandi, la documentazione ufficiale consiglia di alzare innodb_log_file_size di MariaDB ad almeno 10 volte la dimensione massima prevista dei messaggi.
INSTALLAZIONE DELLA CLI DI POSTAL
|
0
1
|
sudo git clone https://github.com/postalserver/install /opt/postal/install
sudo ln -s /opt/postal/install/bin/postal /usr/bin/postal
|
Verifica che il comando sia disponibile:
|
0 |
postal --help
|
Se è tutto corretto dovremmo visualizzare il seguente output:
|
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
Usage: postal [command]
Running postal:
* start - start Postal
* stop - stop Postal
* restart - restart Postal
* status - view current process status
* logs [service] - view logs from services
Setup/upgrade tools:
* initialize - create and load the DB schema
* upgrade - upgrade the DB schema
Other tools:
* version - show the current Postal version
* make-user - create a new global admin user
* default-dkim-record - display the default DKIM record
* console - open an interactive console
* test-app-smtp - send a test message through Postal
* bootstrap hostname [path] - create a new set of config
* bash [service] - access a bash console for a running process
|
BOOTSTRAP DELLA CONFIGURAZIONE
|
0 |
sudo postal bootstrap postal.tuodominio.it
|
Sostituisci postal.tuodominio.it con l’hostname configurato al passo CONFIGURAZIONE DEL DNS.
Il comando crea in /opt/postal/config:
|
0
1
2
3
|
Latest version is: 3.3.7
=> Creating /opt/postal/config/postal.yml
=> Creating /opt/postal/config/Caddyfile
=> Creating signing private key
|
postal.yml — file di configurazione principale
signing.key — chiave privata per la firma dei messaggi
Caddyfile — configurazione del proxy web/TLS
CONFIGURAZIONE DI POSTAL.YML
Apri il file postal.yml con il comando:
|
0 |
sudo nano /opt/postal/config/postal.yml
|
Quindi inserire all’interno del file il seguente output:
|
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
main_db:
host: 127.0.0.1
username: root
password: LA_PASSWORD_MARIADB generata allo step AVVIARE MARIADB E RABBITMQ
database: postal
message_db:
host: 127.0.0.1
username: root
password: LA_PASSWORD_MARIADB generata allo step AVVIARE MARIADB E RABBITMQ
prefix: postal
rabbitmq:
host: 127.0.0.1
username: postal
password: LA_PASSWORD_RABBITMQ generata allo step AVVIARE MARIADB E RABBITMQ
vhost: postal
dns:
mx_records:
- postal.tuodominio.it
smtp_server_hostname: postal.tuodominio.it
spf_include: spf.postal.tuodominio.it
return_path: rp.postal.tuodominio.it
route_domain: routes.postal.tuodominio.it
track_domain: postal.tuodominio.it
|
Sezione DNS (sostituisci tuodominio.it con il tuo dominio)
INIZIALIZZARE IL DATABASE E CREARE L’AMMINISTRATORE
|
0
1
|
sudo postal initialize
sudo postal make-user
|
Il secondo comando chiede email, nome, cognome e password del primo utente amministratore: rispondi ai prompt interattivi.
Se è andato tutto a buon fine dovremmo visualizzare un output simile al seguente:
|
0
1
2
3
4
5
6
7
8
9
|
Postal User Creator
Enter the information required to create a new Postal user.
This tool is usually only used to create your initial admin user.
E-Mail Address : admin@lab.prv
First Name : admin
Last Name : admin
Initial Password : ***********
User has been created with e-mail address admin@lab.prv
|
AVVIO DI POSTAL E DEL PROXY CADDY
|
0
1
|
sudo postal start
sudo postal status
|
Tutti i servizi devono risultare Up. Avvia poi Caddy per la gestione automatica di TLS/HTTPS:
|
0
1
2
3
4
5
|
sudo docker run -d --name postal-caddy \
--restart always \
--network host \
-v /opt/postal/config/Caddyfile:/etc/caddy/Caddyfile \
-v /opt/postal/caddy-data:/data \
caddy
|
Verifica che tutti i container siano attivi:
|
0 |
sudo docker ps
|
ACCESSO A POSTAL DA WEB GUI
Visita https://postal.tuodominio.it e accedi con l’utente creato allo step INIZIALIZZARE IL DATABASE E CREARE L’AMMINISTRATORE
Inserire le credenziali e cliccare Login
Dovremmo visualizzare la schermata di benvenuto di Postal
COMPLETARE I RECORD DNS (SPF, RETURN-PATH, DKIM)
Dalla dashboard: crea un’organizzazione, poi un mail server al suo interno, quindi aggiungi il dominio da cui invierai la posta.
Postal genera automaticamente la chiave DKIM specifica per quel dominio, mostrata nella pagina di verifica.
Cliccare su Create the first Organization
Inserire i dati e cliccare Create Organization
Cliccare Build your first mail server
Inserire le info richieste quindi cliccare Build Server
A questo punto dovremmo visualizzare la Dashboard di Postal
AGGIUNTE NEL DNS
Aggiungi nel DNS i seguenti record:
SPF sul sottodominio dedicato (TXT su spf.postal.tuodominio.it):
|
0 |
v=spf1 ip4:a.b.c.d ip6:ipv6::address ~all
|
SPF sull’hostname principale (TXT su postal.tuodominio.it):
|
0 |
v=spf1 a mx include:spf.postal.tuodominio.it ~all
|
Return-path (A/AAAA su rp.postal.tuodominio.it verso l’IP del server, più un CNAME psrp.postal.tuodominio.it → rp.postal.tuodominio.it) e lo stesso TXT SPF di cui sopra sul record rp.
DKIM copia esattamente il record TXT mostrato dalla dashboard, nel formato postal-[CHIAVE]._domainkey.postal.tuodominio.it.
Usa il pulsante “verifica DNS” nella dashboard per confermare che tutti i record siano stati recepiti prima di iniziare a inviare.
CONFIGURAZIONE DEL FIREWALL
Aprire le porte con i seguenti comandi:
|
0
1
2
3
4
5
6
|
sudo ufw allow OpenSSH
sudo ufw allow 25/tcp # SMTP (ricezione e invio)
sudo ufw allow 587/tcp # Submission, se usato dalle tue app
sudo ufw allow 80/tcp # HTTP (validazione TLS)
sudo ufw allow 443/tcp # HTTPS (dashboard)
sudo ufw enable
sudo ufw status
|
MANUTENZIONE E COMANDI UTILI
Stato dei servizi: sudo postal status
Log di Postal: sudo postal logs -f
Riavviare Postal: sudo postal restart
Fermare/avviare Postal: sudo postal stop / sudo postal start
Aggiornare Postal: sudo postal upgrade
Console Rails (debug avanzato): sudo postal console
Backup: i dati critici sono nel database MariaDB (container postal-mariadb) e nella cartella /opt/postal/config (in particolare signing.key, da conservare con cura: è la chiave usata per firmare i messaggi). Un mysqldump periodico più una copia di /opt/postal/config coprono un ripristino completo.
Risoluzione problemi: se l’invio non parte, verifica di nuovo la porta 25 in uscita (causa più comune) e che i record SPF/DKIM/return-path risultino “verificati” nella dashboard prima di dichiarare il dominio pronto all’invio.
CONCLUSIONI
In questa guida abbiamo visto come installare e configurare Postal su Ubuntu Server 26.04 LTS con Docker Engine.
Siamo partiti dalla preparazione dei record DNS e siamo arrivati al primo accesso all’interfaccia web in HTTPS, passando per l’installazione di Docker, l’avvio di MariaDB, la generazione della configurazione e la creazione dell’utente amministratore.
Prima di decidere se adottare Postal in produzione, conviene valutarne con attenzione punti di forza e limiti.
PRO
- Open source e gratuito: distribuito con licenza MIT, senza costi di licenza né tariffe per singolo messaggio inviato, a differenza dei servizi commerciali.
- Pieno controllo dei dati: messaggi, log e statistiche restano sui propri server, un aspetto rilevante per privacy, GDPR e requisiti di compliance.
- Interfaccia web completa: gestione centralizzata di organizzazioni, server, domini, credenziali e log dei messaggi, senza dover lavorare solo da riga di comando.
- Multi-tenant: permette di separare clienti, progetti o applicazioni in organizzazioni e server distinti, ideale per MSP e agenzie.
- SMTP e API HTTP: si integra facilmente con qualsiasi applicazione, CMS o gestionale.
- Funzionalità avanzate: firma DKIM automatica, tracciamento di aperture e clic, webhook per consegne e rimbalzi, pool di IP e route per la posta in arrivo.
- Installazione semplificata: dalla versione 3 gira interamente in Docker e richiede solo MariaDB, senza RabbitMQ.
CONTRO
- La consegnabilità è tutta a carico vostro: reputazione dell’IP, warm-up, monitoraggio delle blacklist e configurazione corretta di SPF, DKIM, DMARC e PTR sono responsabilità dell’amministratore. Con un IP nuovo o “sporco”, i messaggi finiscono facilmente in spam.
- Porta 25 spesso bloccata: molti provider cloud (AWS, Azure, Google Cloud e diversi VPS) bloccano il traffico SMTP in uscita, e a volte è difficile ottenerne lo sblocco.
- Non è un server di caselle di posta: niente IMAP o POP3. Per la posta degli utenti servono altre soluzioni.
- Niente gestione delle campagne: mancano liste di contatti, editor di template e gestione delle disiscrizioni. Per le newsletter serve un software dedicato, come Listmonk o Mautic, che usi Postal come motore di invio.
- Server dedicato e risorse non trascurabili: almeno 4 GB di RAM e un host riservato, perché Postal non convive bene con altri servizi sulle stesse porte.
- Manutenzione e sicurezza a carico vostro: aggiornamenti, backup, monitoraggio e protezione del server non sono inclusi come in un servizio gestito, e non c’è un supporto ufficiale con SLA.
- Community e documentazione più limitate rispetto alle alternative commerciali: per i problemi meno comuni spesso bisogna cercare tra le issue su GitHub.
In sintesi, Postal è un’ottima scelta per chi ha competenze sistemistiche, vuole mantenere il controllo dell’infrastruttura di invio e gestisce volumi tali da rendere costosi i servizi a consumo.
Chi invece preferisce non occuparsi di reputazione degli IP, blacklist e manutenzione troverà più comodo un servizio gestito, accettandone costi e dipendenza da terzi.
0 Commenti