Come installare Metabase su Ubuntu 22.04 con Docker
Su questa pagina
- Prerequisiti
- Passaggio 1: configurazione del firewall
- Passaggio 2 - Installa Docker e Docker Compose
- Passaggio 3 - Crea il file Docker Compose per Metabase
- Passaggio 4 - Configurare i file dell'ambiente e avviare la metabase
- Passaggio 5 - Installa Nginx
- Passaggio 6 - Installa SSL
- Passaggio 7 - Configura Nginx
- Passaggio 8 - Installa e accedi alla metabase
- Passaggio 9 - Backup della metabase
- Passaggio 10 - Aggiorna la metabase
- Conclusione
Metabase è uno strumento di Business Intelligence (BI) open source basato su Java. Si collega a una serie di database e utilizza un generatore di domande per nascondere la complessità delle query SQL di grandi dimensioni che consentono di visualizzare i dati dei clienti in un formato leggibile e analizzarli. Puoi porre domande sui tuoi dati o incorporarli nella tua app per consentire ai tuoi clienti di esplorare i propri dati da soli. 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 molti altri.
Usando Docker, imparerai come installare Metabase su un server Ubuntu 22.04.
Prerequisiti
-
A server running Ubuntu 22.04 with a minimum of 2 CPU cores and 2GB of memory. You will need to upgrade the server as per requirements.
-
A non-root user with sudo privileges.
-
A fully qualified domain name (FQDN) pointing to your server. For our purposes, we will use
metabase.example.comas the domain name. -
Metabase sends email notifications to users. We recommend you use a 3rd party Transactional mail service like Mailgun, Sendgrid, Amazon SES, or Sparkpost. The instructions in the guide will be using Amazon SES.
-
Make sure everything is updated.
$ sudo apt update -
Install basic utility packages. Some of them may already be installed.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Passaggio 1: configurare il firewall
Il primo passo è configurare il firewall. Ubuntu viene fornito con ufw (Uncomplicated Firewall) per impostazione predefinita.
Controlla se il firewall è in esecuzione.
$ sudo ufw status
Dovresti ottenere il seguente output.
Status: inactive
Consenti porta SSH in modo che il firewall non interrompa la connessione corrente attivandola.
$ sudo ufw allow OpenSSH
Consenti anche 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)
Passaggio 2: installa Docker e Docker Compose
Ubuntu 22.04 viene fornito con una versione precedente di Docker. Per installare la versione più recente, importa innanzitutto 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
Verificare 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 i 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)
Sarà necessario disconnettersi dal server e riconnettersi come lo stesso utente per abilitare questa modifica o utilizzare il seguente comando.
$ su - ${USER}
Verifica che il tuo utente sia stato aggiunto al gruppo Docker.
$ groups
navjot wheel docker
Passaggio 3: creare il file Docker Compose per Metabase
Creare una directory per Metabase.
$ mkdir ~/metabase
Crea e apri il file di composizione Docker per la modifica.
$ nano docker-compose.yml
Incolla il seguente codice al suo interno.
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 immettendo Y quando richiesto.
Il file di composizione Docker precedente acquisisce l'ultima versione dell'immagine Metabase Docker ed espone l'app tramite la porta 3000. È connesso all'immagine PostgreSQL. Il nome utente e la password del database PostgreSQL sono archiviati rispettivamente nei file db_user.txt e db_password.txt.
Crea e apri il file db_user.txt per la modifica.
$ nano db_user.txt
Incolla il tuo nome utente 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 e salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passaggio 4: configurare i file dell'ambiente e avviare la metabase
Genera una chiave di crittografia utilizzando il seguente comando.
$ openssl rand -base64 32
aWPk99bIjkG7NvWYVqR5NIAojhW1Idk0OvTH1xWVMbY=
Copia la chiave per usarla in seguito.
Crea e apri il file metabase.env per la modifica.
$ nano metabase.env
Incolla il seguente codice al suo interno. Incolla la chiave segreta che hai generato nella variabile MB_ENCRYPTION_SECRET_KEY. Inserisci il tuo dominio Metabase incluso il protocollo https. Inserisci i tuoi dati SMTP utilizzando il provider che utilizzi. Stiamo usando Amazon SES. La variabile MB_PASSWORD_COMPLEXITY è impostata su strong, il che significa che la tua password Metabase deve avere una lunghezza minima di 8 caratteri, con 2 lettere minuscole, 2 maiuscole, 1 cifra e 1 carattere speciale.
MB_SITE_URL=https://metabase.example.com
MB_SITE_NAME="Howtoforge"
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 immettendo Y quando richiesto.
Avvia il contenitore Docker.
$ docker compose up -d
Puoi controllare lo stato dei contenitori usando il seguente comando.
$ watch docker ps
Riceverai un output simile. Attendi che lo stato di entrambi i contenitori diventi integro, quindi premi Ctrl + C per uscire dalla schermata.
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
Passaggio 5: installa Nginx
Ubuntu 22.04 viene fornito con una versione precedente di Nginx. Per installare l'ultima versione, devi scaricare il repository Nginx ufficiale.
Importa la chiave di firma Nginxs.
$ 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 Nginxs.
$ 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
Verificare 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.
Passaggio 6: installa SSL
Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot usando il repository Ubuntus o prendere l'ultima versione usando lo strumento Snapd. Useremo la versione Snapd.
Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. 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 Cerbot.
$ sudo snap install --classic certbot
Utilizzare il seguente comando per assicurarsi che il comando Certbot venga eseguito creando un collegamento simbolico alla directory /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Eseguire il seguente comando per generare un certificato SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m -d metabase.example.com
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/metabase.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Esegui un'esecuzione a secco del processo per verificare se il rinnovo SSL funziona correttamente.
$ sudo certbot renew --dry-run
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Passaggio 7: configurare Nginx
Apri il file /etc/nginx/nginx.conf per la modifica.
$ sudo nano /etc/nginx/nginx.conf
Aggiungi la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Salva il file premendo Ctrl + X e immettendo 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 al suo interno.
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-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.
Verificare la sintassi del file di configurazione 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
Passaggio 8: installazione e accesso alla metabase
Apri l'URL https://metabase.example.com per avviare l'installazione guidata di Metabase.
Fare clic sul pulsante Iniziamo per procedere al passaggio successivo. La pagina successiva avrà diversi passaggi elencati. Scegli la lingua e fai clic su Avanti per procedere.
Inserisci i dettagli dell'amministratore di Metabase.
Successivamente, ti verrà chiesto di aggiungere dati alla metabase da esplorare. Puoi aggiungere i dati ora o farlo in un secondo momento.
Fare clic su Aggiungerò i miei dati più tardi per procedere.
Deseleziona il segno di spunta Consenti alla metabase di raccogliere in modo anonimo gli eventi di utilizzo e fai clic sul pulsante Fine per completare il processo.
Fare clic sul pulsante Portami a Metabase per avviare il dashboard di Metabase.
Puoi iniziare a utilizzare Metabase ora.
Passaggio 9: backup della metabase
Se si desidera eseguire il backup del database Metabase, utilizzare il seguente comando.
$ docker exec -t postgres pg_dumpall -c -U navjot > dump_`date +%d-%m-%Y"_"%H_%M_%S`.sql
Sostituisci navjot con il nome utente del tuo database e postgres con il nome del tuo contenitore docker per PostgreSQL.
Per ripristinare il database, utilizzare il seguente comando.
$ cat dump_*.sql | docker exec -i your-db-container psql -U navjot
Passaggio 10: aggiornare la metabase
L'aggiornamento di Metabase richiede diversi passaggi. Il primo passaggio consiste nell'eseguire il backup del database Metabase utilizzando il comando del passaggio 9.
Quindi, passa alla directory.
$ cd /opt/metabase
Estrai le ultime immagini del container per Mastodon.
$ docker compose pull metabase/metabase:latest
Apporta eventuali modifiche in docker-compose.yml se lo desideri.
Riavvia i contenitori Mastodon.
$ docker compose up -d
Le istruzioni di cui sopra sono istruzioni di aggiornamento generiche. Controlla sempre la pagina delle versioni di GitHub di Mastodon per cercare attività e comandi di aggiornamento specifici tra le versioni per assicurarti che tutto vada liscio.
Conclusione
Questo conclude il nostro tutorial sull'installazione di Metabase su un server Ubuntu 22.04. Se hai domande, pubblicale nei commenti qui sotto.