Installazione · 10 min read · Dec 20, 2025

Come installare Metabase su Ubuntu 22.04 con Docker

Metabase è uno strumento di Business Intelligence (BI) open-source basato su Java. Si connette a diversi database e utilizza un costruttore di domande per nascondere la complessità di grandi query SQL che ti permettono di visualizzare i dati dei clienti in un formato leggibile e di analizzarli. Puoi porre domande sui tuoi dati o incorporarlo nella tua app per consentire ai tuoi clienti di esplorare i loro dati autonomamente. Può generare dashboard e visualizzazioni e inviare avvisi al tuo canale Slack. Può connettersi a molte piattaforme di database e fonti di dati, tra cui MySQL, Google Analytics, MongoDB, PostgreSQL, ClickHouse, Amazon Athena, Amazon Redshift e molte altre.

Utilizzando Docker, imparerai come installare Metabase su un server Ubuntu 22.04.

Prerequisiti

  • Un server che esegue Ubuntu 22.04 con un minimo di 2 core CPU e 2GB di memoria. Dovrai aggiornare il server secondo le necessità.
  • Un utente non root con privilegi sudo.
  • Un nome di dominio completamente qualificato (FQDN) che punta al tuo server. Per i nostri scopi, utilizzeremo metabase.example.com come nome di dominio.
  • Metabase invia notifiche email agli utenti. Ti consigliamo di utilizzare un servizio di email transazionale di terze parti come Mailgun, Sendgrid, Amazon SES o Sparkpost. Le istruzioni nella guida utilizzeranno Amazon SES.
  • Assicurati che tutto sia aggiornato. $ sudo apt update
  • Installa i pacchetti di utilità di base. Alcuni di essi potrebbero già essere installati. $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

Passo 1 - Configura il Firewall

Il primo passo è configurare il firewall. Ubuntu viene fornito di default con ufw (Uncomplicated Firewall).

Controlla se il firewall è attivo.

$ sudo ufw status

Dovresti ottenere il seguente output.

Status: inactive

Consenti la porta SSH affinché il firewall non interrompa la connessione attuale quando viene abilitato.

$ sudo ufw allow OpenSSH

Consenti anche le porte HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Abilita il Firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Controlla di nuovo lo stato del firewall.

$ sudo ufw status

Dovresti vedere un output simile.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Passo 2 - Installa Docker e Docker Compose

Ubuntu 22.04 viene fornito con una versione più vecchia di Docker. Per installare l’ultima versione, prima importa la chiave GPG di Docker.

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

Crea un file di repository Docker.

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

Aggiorna l’elenco dei repository di sistema.

$ sudo apt update

Installa l’ultima versione di Docker.

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

Verifica che sia in esecuzione.

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2023-01-05 05:55:23 UTC; 2min 16s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 2116 (dockerd)
      Tasks: 8
     Memory: 22.5M
        CPU: 252ms
     CGroup: /system.slice/docker.service
             ??2116 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Per impostazione predefinita, Docker richiede privilegi di root. Se vuoi evitare di usare sudo ogni volta che esegui il comando docker, aggiungi il tuo nome utente al gruppo docker.

$ sudo usermod -aG docker $(whoami)

Dovrai disconnetterti dal server e riconnetterti come lo stesso utente per abilitare questa modifica o utilizzare il seguente comando.

$ su - ${USER}

Conferma che il tuo utente è stato aggiunto al gruppo Docker.

$ groups
navjot wheel docker

Passo 3 - Crea il file Docker Compose per Metabase

Crea una directory per Metabase.

$ mkdir ~/metabase

Crea e apri il file Docker compose per la modifica.

$ nano docker-compose.yml

Incolla il seguente codice in esso.

version: '3.9'
services:
  metabase:
    image: metabase/metabase:latest
    container_name: metabase
    hostname: metabase
    volumes:
    - /dev/urandom:/dev/random:ro
    ports:
      - 3000:3000
    environment:
      MB_DB_TYPE: postgres
      MB_DB_DBNAME: metabase
      MB_DB_PORT: 5432
      MB_DB_USER_FILE: /run/secrets/db_user
      MB_DB_PASS_FILE: /run/secrets/db_password
      MB_DB_HOST: postgres
    env_file:
      - metabase.env
    healthcheck:
      test: curl --fail -I http://localhost:3000/api/health || exit 1
      interval: 15s
      retries: 5
      start_period: 10s
      timeout: 5s
    networks:
      - metanet1
    depends_on:
      - postgres
    secrets:
      - db_password
      - db_user
  postgres:
    image: postgres:latest
    container_name: postgres
    hostname: postgres
    environment:
      POSTGRES_USER_FILE: /run/secrets/db_user
      POSTGRES_DB: metabase
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    healthcheck:
      test: ['CMD', 'pg_isready', '-U', 'postgres']
    volumes:
      - ./postgresql:/var/lib/postgresql/data
    networks:
      - metanet1
    secrets:
      - db_password
      - db_user
networks:
  metanet1:
    driver: bridge
secrets:
   db_password:
     file: db_password.txt
   db_user:
     file: db_user.txt

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Il file Docker compose sopra acquisisce l’ultima versione dell’immagine Docker di Metabase ed espone l’app tramite la porta 3000. È collegato all’immagine PostgreSQL. Il nome utente e la password del database PostgreSQL sono memorizzati nei file db_user.txt e db_password.txt rispettivamente.

Crea e apri il file db_user.txt per la modifica.

$ nano db_user.txt

Incolla il tuo nome utente in esso e salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Crea e apri il file db_password.txt per la modifica.

$ nano db_password.txt

Incolla la tua password in esso e salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Passo 4 - Configura i file di ambiente e avvia Metabase

Genera una chiave di crittografia utilizzando il seguente comando.

$ openssl rand -base64 32
aWPk99bIjkG7NvWYVqR5NIAojhW1Idk0OvTH1xWVMbY=

Copia la chiave per un uso successivo.

Crea e apri il file metabase.env per la modifica.

$ nano metabase.env

Incolla il seguente codice in esso. Incolla la chiave segreta che hai generato contro la variabile MB_ENCRYPTION_SECRET_KEY. Compila il tuo dominio Metabase incluso il protocollo https. Compila i tuoi dettagli SMTP utilizzando il provider che utilizzi. Stiamo usando Amazon SES. La variabile MB_PASSWORD_COMPLEXITY è impostata su forte, il che significa che la tua password Metabase deve avere una lunghezza minima di 8 caratteri, con 2 minuscole, 2 maiuscole, 1 cifra e 1 carattere speciale.

MB_SITE_URL=https://metabase.example.com
MB_SITE_NAME="Howtoforge"

[email protected]
[email protected]
MB_EMAIL_FROM_NAME=Howtoforge
MB_EMAIL_SMTP_HOST=email-smtp.us-west-2.amazonaws.com
MB_EMAIL_SMTP_USERNAME=AWS_USERID
MB_EMAIL_SMTP_PASSWORD=AWS_KEY
MB_EMAIL_SMTP_PORT=587
MB_EMAIL_SMTP_SECURITY=starttls

MB_ENCRYPTION_SECRET_KEY=aWPk99bIjkG7NvWYVqR5NIAojhW1Idk0OvTH1xWVMbY=
MB_ANON_TRACKING_ENABLED=false
MB_APPLICATION_NAME=Howtoforge Metabase
MB_PASSWORD_COMPLEXITY=strong

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Avvia il contenitore Docker.

$ docker compose up -d

Puoi controllare lo stato dei contenitori utilizzando il seguente comando.

$ watch docker ps

Riceverai un output simile. Aspetta che lo stato di entrambi i contenitori diventi sano e poi premi Ctrl + C per uscire dallo schermo.

CONTAINER ID   IMAGE                      COMMAND                  CREATED         STATUS                   PORTS                                       NAMES
15698ae2de6a   metabase/metabase:latest   "/app/run_metabase.sh"   2 minutes ago   Up 2 minutes (healthy)   0.0.0.0:3000->3000/tcp, :::3000->3000/tcp   metabase
ee2d03dc3a00   postgres:latest            "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes (healthy)   5432/tcp                                    postgres

Passo 5 - Installa Nginx

Ubuntu 22.04 viene fornito con una versione più vecchia di Nginx. Per installare l’ultima versione, devi scaricare il repository ufficiale di Nginx.

Importa la chiave di firma di Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
    | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Aggiungi il repository per la versione stabile di Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verifica l’installazione.

$ nginx -v
nginx version: nginx/1.22.1

Avvia il server Nginx.

$ sudo systemctl start nginx

Controlla lo stato del server.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2023-01-05 07:21:46 UTC; 1s ago
       Docs: https://nginx.org/en/docs/
    Process: 13197 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 13198 (nginx)
      Tasks: 3 (limit: 2237)
     Memory: 2.6M
        CPU: 7ms
     CGroup: /system.slice/nginx.service
             ??13198 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??13199 "nginx: worker process" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""
             ??13200 "nginx: worker process" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""

Jan 05 07:21:46 metabase systemd[1]: Starting nginx - high performance web server...
Jan 05 07:21:46 metabase systemd[1]: Started nginx - high performance web server.

Passo 6 - Installa SSL

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Ubuntu o scaricare l’ultima versione utilizzando lo strumento Snapd. Useremo la versione Snapd.

Ubuntu 22.04 viene fornito con Snapd installato di default. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata. Assicurati che la tua versione di Snapd sia aggiornata.

$ sudo snap install core
$ sudo snap refresh core

Installa Certbot.

$ sudo snap install --classic certbot

Usa il seguente comando per assicurarti che il comando Certbot venga eseguito creando un collegamento simbolico alla directory /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Esegui il seguente comando per generare un certificato SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d metabase.example.com

Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/metabase.example.com sul tuo server.

Genera un certificato Diffie-Hellman group.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Fai una prova del processo per controllare se il rinnovo SSL funziona correttamente.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passo 7 - Configura Nginx

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Crea e apri il file /etc/nginx/conf.d/metabase.conf per la modifica.

$ sudo nano /etc/nginx/conf.d/metabase.conf

Incolla il seguente codice in esso.

server {
  # Redirect any http requests to https
  listen         80;
  listen         [::]:80;
  server_name    metabase.example.com;
  return 301     https://$host$request_uri;
}

server {
  listen                    443 ssl http2;
  listen                    [::]:443 ssl http2;
  server_name               metabase.example.com;

  access_log                /var/log/nginx/metabase.access.log;
  error_log                 /var/log/nginx/metabase.error.log;

  # TLS configuration
  ssl_certificate           /etc/letsencrypt/live/metabase.example.com/fullchain.pem;
  ssl_certificate_key       /etc/letsencrypt/live/metabase.example.com/privkey.pem;
  ssl_trusted_certificate   /etc/letsencrypt/live/metabase.example.com/chain.pem;
  ssl_protocols             TLSv1.2 TLSv1.3;

  ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-GCM-SHA384';
  ssl_prefer_server_ciphers on;
  ssl_session_cache         shared:SSL:50m;
  ssl_session_timeout       1d;

  # OCSP Stapling ---
  # fetch OCSP records from URL in ssl_certificate and cache them
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  location / {
    proxy_set_header        X-Real-IP $remote_addr;
    proxy_set_header        X-Forwarded-Proto $scheme;
    proxy_set_header        X-Forwarded-Host $http_host;
    proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass              http://127.0.0.1:3000;
  }
}

Una volta terminato, salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la sintassi del file di configurazione di Nginx.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Riavvia il server Nginx.

$ sudo systemctl restart nginx

Passo 8 - Installa e accedi a Metabase

Apri l’URL https://metabase.example.com per avviare la procedura guidata di configurazione di Metabase.

Procedura guidata di configurazione di Metabase

Clicca sul pulsante Iniziamo per procedere al passaggio successivo. La pagina successiva avrà diversi passaggi elencati. Scegli la tua lingua e clicca su Avanti per procedere.

Scelta della lingua di Metabase

Inserisci i dettagli dell’amministratore di Metabase.

Dettagli amministratore di Metabase

Successivamente, ti verrà chiesto di aggiungere dati a Metabase per esplorarli. Puoi aggiungere i dati ora o farlo in seguito.

Aggiungi dati a Metabase

Clicca su Aggiungerò i miei dati più tardi per procedere.

Preferenze dati di Metabase

Deseleziona la casella Consenti a Metabase di raccogliere eventi di utilizzo in modo anonimo e clicca sul pulsante Fine per completare il processo.

Configurazione di Metabase completata

Clicca sul pulsante Portami a Metabase per avviare la dashboard di Metabase.

Dashboard di Metabase

Puoi iniziare a usare Metabase ora.

Passo 9 - Backup di Metabase

Se desideri eseguire il backup del database di Metabase, utilizza il seguente comando.

$ docker exec -t postgres pg_dumpall -c -U navjot > dump_`date +%d-%m-%Y
Share: X/Twitter LinkedIn
#Installazione

Ricevi i nuovi post nella tua casella di posta.

Nessuno spam. Disiscriviti in qualsiasi momento.