So installierst du Metabase auf Ubuntu 22.04 mit Docker
Metabase ist ein Java-basiertes Open-Source Business Intelligence (BI)-Tool. Es lässt sich mit einer Reihe von Datenbanken verbinden und nutzt einen Question Builder, um die Komplexität großer SQL-Abfragen zu verbergen, die es dir ermöglichen, Kundendaten in einem lesbaren Format zu visualisieren und zu analysieren. Du kannst Fragen zu deinen Daten stellen oder sie in deine App einbetten, damit deine Kunden ihre Daten selbständig erkunden können. Es kann Dashboards und Visualisierungen erstellen und Warnmeldungen an deinen Slack-Kanal senden. Sie kann sich mit vielen Datenbankplattformen und Datenquellen verbinden, darunter MySQL, Google Analytics, MongoDB, PostgreSQL, ClickHouse, Amazon Athena, Amazon Redshift und viele mehr.
Mit Docker lernst du, wie du Metabase auf einem Ubuntu 22.04 Server installierst.
Voraussetzungen
- Ein Server mit Ubuntu 22.04 mit mindestens 2 CPU-Kernen und 2 GB Arbeitsspeicher. Du musst den Server entsprechend den Anforderungen aufrüsten.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Einen voll qualifizierten Domainnamen (FQDN), der auf deinen Server zeigt. Für unsere Zwecke verwenden wir
metabase.example.comals Domänennamen. - Metabase sendet E-Mail-Benachrichtigungen an die Benutzer. Wir empfehlen dir, einen Transaktions-E-Mail-Dienst eines Drittanbieters wie Mailgun, Sendgrid, Amazon SES oder Sparkpost zu verwenden. Die Anweisungen in diesem Leitfaden verwenden Amazon SES.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update - Installiere grundlegende Hilfspakete. Einige davon sind vielleicht schon installiert.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Ubuntu wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall aktiv ist.
$ sudo ufw status
Du solltest die folgende Ausgabe erhalten.
Status: inactive
Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.
$ sudo ufw allow OpenSSH
Lasse auch HTTP- und HTTPS-Ports zu.
$ sudo ufw allow http
$ sudo ufw allow https
Aktiviere die Firewall
$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup
Überprüfe den Status der Firewall erneut.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
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)
Schritt 2 – Installiere Docker und Docker Compose
Ubuntu 22.04 wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, importiere zunächst den Docker GPG-Schlüssel.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
Erstelle eine Docker-Repository-Datei.
$ 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
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Installiere die neueste Version von Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin
Überprüfe, ob sie läuft.
$ 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
Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden möchtest, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.
$ sudo usermod -aG docker $(whoami)
Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.
$ su - ${USER}
Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.
$ groups
navjot wheel docker
Schritt 3 – Docker Compose-Datei für die Metabase erstellen
Erstelle ein Verzeichnis für die Metabase.
$ mkdir ~/metabase
Erstelle und öffne die Docker Compose-Datei zur Bearbeitung.
$ nano docker-compose.yml
Füge den folgenden Code in die Datei ein.
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
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Die obige Docker compose Datei holt sich die neueste Version des Metabase Docker Images und stellt die App über Port 3000 zur Verfügung. Sie ist mit dem PostgreSQL-Image verbunden. Der Benutzername und das Passwort für die PostgreSQL-Datenbank sind in den Dateien db_user.txt und db_password.txt gespeichert.
Erstelle und öffne die Datei db_user.txt zum Bearbeiten.
$ nano db_user.txt
Füge deinen Benutzernamen dort ein und speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle und öffne die Datei db_password.txt zum Bearbeiten.
$ nano db_password.txt
Füge dein Passwort ein und speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 4 – Umgebungsdateien konfigurieren und Metabase starten
Erstelle mit dem folgenden Befehl einen Verschlüsselungsschlüssel.
$ openssl rand -base64 32
aWPk99bIjkG7NvWYVqR5NIAojhW1Idk0OvTH1xWVMbY=
Kopiere den Schlüssel für die spätere Verwendung.
Erstelle und öffne die Datei metabase.env zum Bearbeiten.
$ nano metabase.env
Füge den folgenden Code in die Datei ein. Füge den geheimen Schlüssel, den du erzeugt hast, in die Variable MB_ENCRYPTION_SECRET_KEY ein. Gib deine Metabase-Domain einschließlich des https-Protokolls ein. Gib deine SMTP-Details bei dem Anbieter ein, den du verwendest. Wir verwenden Amazon SES. Die Variable MB_PASSWORD_COMPLEXITY ist auf „strong“ eingestellt, was bedeutet, dass dein Metabase-Passwort mindestens 8 Zeichen lang sein sollte, davon 2 Kleinbuchstaben, 2 Großbuchstaben, 1 Ziffer und 1 Sonderzeichen.
MB_SITE_URL=https://metabase.example.com
MB_SITE_NAME="Howtoforge"
MB_ADMIN_EMAIL=navjot@example.com
MB_EMAIL_FROM_ADDRESS=noreply@example.com
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
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Docker-Container.
$ docker compose up -d
Du kannst den Status der Container mit dem folgenden Befehl beobachten.
$ watch docker ps
Du wirst eine ähnliche Ausgabe erhalten. Warte, bis der Status beider Container in Ordnung ist und drücke dann Strg + C, um den Bildschirm zu verlassen.
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
Schritt 5 – Nginx installieren
Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ 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
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation.
$ nginx -v
nginx version: nginx/1.22.1
Starte den Nginx-Server.
$ sudo systemctl start nginx
Überprüfe den Status des Servers.
$ 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.
Schritt 6 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist. Vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core
$ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt wird, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d metabase.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/metabase.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 7 – Nginx konfigurieren
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle und öffne die Datei /etc/nginx/conf.d/metabase.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/metabase.conf
Füge den folgenden Code in die Datei ein.
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;
}
}
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Server neu.
$ sudo systemctl restart nginx
Schritt 8 – Metabase installieren und aufrufen
Öffne die URL https://metabase.example.com, um den Einrichtungsassistenten der Metabase zu starten.
Klicke auf die Schaltfläche Let’s get started, um zum nächsten Schritt zu gelangen. Auf der nächsten Seite sind mehrere Schritte aufgelistet. Wähle deine Sprache und klicke auf Weiter, um fortzufahren.
Gib die Daten deines Metabase-Administrators ein.
Als Nächstes wirst du aufgefordert, der Metabase Daten hinzuzufügen, die du untersuchen möchtest. Du kannst die Daten entweder jetzt oder später hinzufügen.
Klicke auf “ Ich füge meine Daten später hinzu „, um fortzufahren.
Deaktiviere das Kontrollkästchen Anonyme Erfassung von Nutzungsereignissen durch die Metabase zulassen und klicke auf die Schaltfläche Fertig stellen, um den Vorgang abzuschließen.
Klicke auf die Schaltfläche Bring mich zur Metabase, um das Metabase-Dashboard zu starten.
Du kannst jetzt mit der Metabase arbeiten.
Schritt 9 – Metabase sichern
Wenn du eine Sicherungskopie der Metabase-Datenbank erstellen möchtest, verwende den folgenden Befehl.
$ docker exec -t postgres pg_dumpall -c -U navjot > dump_`date +%d-%m-%Y"_"%H_%M_%S`.sql
Ersetze navjot durch deinen Datenbank-Benutzernamen und postgres durch den Namen deines Docker-Containers für PostgreSQL.
Um die Datenbank wiederherzustellen, verwende den folgenden Befehl.
$ cat dump_*.sql | docker exec -i your-db-container psql -U navjot
Schritt 10 – Upgrade der Metabase
Das Upgrade der Metabase erfordert mehrere Schritte. Der erste Schritt besteht darin, die Metabase-Datenbank mit dem Befehl aus Schritt 9 zu sichern.
Dann wechselst du in das Verzeichnis.
$ cd /opt/metabase
Ziehe die neuesten Container-Images für Mastodon.
$ docker compose pull metabase/metabase:latest
Nimm ggf. Änderungen an der docker-compose.yml vor.
Starte die Mastodon-Container neu.
$ docker compose up -d
Die obigen Anweisungen sind allgemeine Update-Anweisungen. Schau immer auf der GitHub-Releaseseite von Mastodon nach, ob es spezielle Update-Aufgaben und Befehle zwischen den Versionen gibt, um sicherzustellen, dass alles reibungslos funktioniert.
Fazit
Damit ist unsere Anleitung zur Installation von Metabase auf einem Ubuntu 22.04 Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.