Metabase auf Ubuntu 22.04 mit Docker installieren

Metabase ist ein auf Java basierendes Open-Source-Tool für Business Intelligence (BI). Es verbindet sich mit einer Reihe von Datenbanken und verwendet einen Fragen-Builder, um die Komplexität großer SQL-Abfragen zu verbergen, die es Ihnen ermöglichen, Kundendaten in einem lesbaren Format zu visualisieren und zu analysieren. Sie können Fragen zu Ihren Daten stellen oder sie in Ihre App einbetten, damit Ihre Kunden ihre Daten selbst erkunden können. Es kann Dashboards und Visualisierungen erstellen und Benachrichtigungen an Ihren Slack-Kanal senden. Es kann sich mit vielen Datenbankplattformen und Datenquellen verbinden, darunter MySQL, Google Analytics, MongoDB, PostgreSQL, ClickHouse, Amazon Athena, Amazon Redshift und viele mehr.

Mit Docker lernen Sie, wie Sie Metabase auf einem Ubuntu 22.04-Server installieren.

Voraussetzungen

• Ein Server, der Ubuntu 22.04 mit mindestens 2 CPU-Kernen und 2 GB RAM ausführt. Sie müssen den Server gemäß den Anforderungen aufrüsten.
• Ein Nicht-Root-Benutzer mit Sudo-Rechten.
• Ein vollständig qualifizierter Domainname (FQDN), der auf Ihren Server verweist. Für unsere Zwecke verwenden wir metabase.example.com als Domainnamen.
• Metabase sendet E-Mail-Benachrichtigungen an Benutzer. Wir empfehlen, einen Drittanbieter-Transaktionsmaildienst wie Mailgun, Sendgrid, Amazon SES oder Sparkpost zu verwenden. Die Anweisungen in diesem Leitfaden verwenden Amazon SES.
• Stellen Sie sicher, dass alles aktualisiert ist. $ sudo apt update
• Installieren Sie grundlegende Dienstprogramme. Einige davon sind möglicherweise bereits 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) geliefert.

Überprüfen Sie, ob die Firewall aktiv ist.

$ sudo ufw status

Sie sollten die folgende Ausgabe erhalten.

Status: inactive

Erlauben Sie den SSH-Port, damit die Firewall die aktuelle Verbindung beim Aktivieren nicht unterbricht.

$ sudo ufw allow OpenSSH

Erlauben Sie auch die HTTP- und HTTPS-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Aktivieren Sie die Firewall

$ sudo ufw enable
Befehl kann bestehende SSH-Verbindungen stören. Mit der Operation fortfahren (y|n)? y
Firewall ist aktiv und beim Systemstart aktiviert

Überprüfen Sie den Status der Firewall erneut.

$ sudo ufw status

Sie sollten eine ähnliche Ausgabe sehen.

Status: active

Zu                         Aktion      Von
--                         ------      ----
OpenSSH                    ERLAUBEN    Überall
80/tcp                     ERLAUBEN    Überall
443                        ERLAUBEN    Überall
OpenSSH (v6)               ERLAUBEN    Überall (v6)
80/tcp (v6)                ERLAUBEN    Überall (v6)
443 (v6)                   ERLAUBEN    Überall (v6)

Schritt 2 - Docker und Docker Compose installieren

Ubuntu 22.04 wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, importieren Sie zuerst den Docker GPG-Schlüssel.

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

Erstellen Sie 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

Aktualisieren Sie die System-Repository-Liste.

$ sudo apt update

Installieren Sie die neueste Version von Docker.

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

Überprüfen Sie, ob es 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 Sie vermeiden möchten, bei jedem Ausführen des docker-Befehls sudo zu verwenden, fügen Sie Ihren Benutzernamen zur docker-Gruppe hinzu.

$ sudo usermod -aG docker $(whoami)

Sie müssen sich vom Server abmelden und wieder als derselbe Benutzer anmelden, um diese Änderung zu aktivieren, oder den folgenden Befehl verwenden.

$ su - ${USER}

Bestätigen Sie, dass Ihr Benutzer zur Docker-Gruppe hinzugefügt wurde.

$ groups
navjot wheel docker

Schritt 3 - Docker Compose-Datei für Metabase erstellen

Erstellen Sie ein Verzeichnis für Metabase.

$ mkdir ~/metabase

Erstellen und öffnen Sie die Docker-Compose-Datei zur Bearbeitung.

$ nano docker-compose.yml

Fügen Sie den folgenden Code 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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Die obige Docker-Compose-Datei lädt 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 der PostgreSQL-Datenbank werden in den Dateien db_user.txt und db_password.txt gespeichert.

Erstellen und öffnen Sie die Datei db_user.txt zur Bearbeitung.

$ nano db_user.txt

Fügen Sie Ihren Benutzernamen ein und speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Erstellen und öffnen Sie die Datei db_password.txt zur Bearbeitung.

$ nano db_password.txt

Fügen Sie Ihr Passwort ein und speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Schritt 4 - Umgebungsdateien konfigurieren und Metabase starten

Generieren Sie einen Verschlüsselungsschlüssel mit dem folgenden Befehl.

$ openssl rand -base64 32
aWPk99bIjkG7NvWYVqR5NIAojhW1Idk0OvTH1xWVMbY=

Kopieren Sie den Schlüssel zur späteren Verwendung.

Erstellen und öffnen Sie die Datei metabase.env zur Bearbeitung.

$ nano metabase.env

Fügen Sie den folgenden Code ein. Fügen Sie den geheimen Schlüssel, den Sie generiert haben, der Variablen MB_ENCRYPTION_SECRET_KEY hinzu. Geben Sie Ihre Metabase-Domain einschließlich des HTTPS-Protokolls an. Geben Sie Ihre SMTP-Details mit dem Anbieter an, den Sie verwenden. Wir verwenden Amazon SES. Die Variable MB_PASSWORD_COMPLEXITY ist auf stark gesetzt, was bedeutet, dass Ihr Metabase-Passwort mindestens 8 Zeichen lang sein sollte, mit 2 Kleinbuchstaben, 2 Großbuchstaben, 1 Ziffer und 1 Sonderzeichen.

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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Starten Sie den Docker-Container.

$ docker compose up -d

Sie können den Status der Container mit dem folgenden Befehl überwachen.

$ watch docker ps

Sie erhalten eine ähnliche Ausgabe. Warten Sie, bis der Status beider Container gesund wird, und drücken Sie dann Ctrl + 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, müssen Sie das offizielle Nginx-Repository herunterladen.

Importieren Sie den Signaturschlü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ügen Sie 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

Aktualisieren Sie die System-Repositories.

$ sudo apt update

Installieren Sie Nginx.

$ sudo apt install nginx

Überprüfen Sie die Installation.

$ nginx -v
nginx version: nginx/1.22.1

Starten Sie den Nginx-Server.

$ sudo systemctl start nginx

Überprüfen Sie den Status des Servers.

$ sudo systemctl status nginx
? nginx.service - nginx - Hochleistungs-Webserver
     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 - Hochleistungs-Webserver...
Jan 05 07:21:46 metabase systemd[1]: Started nginx - Hochleistungs-Webserver.

Schritt 6 - SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu generieren. Sie können Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Ubuntu 22.04 wird standardmäßig mit Snapd installiert. Führen Sie die folgenden Befehle aus, um sicherzustellen, dass Ihre Version von Snapd auf dem neuesten Stand ist. Stellen Sie sicher, dass Ihre Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core
$ sudo snap refresh core

Installieren Sie Certbot.

$ sudo snap install --classic certbot

Verwenden Sie den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt wird, indem Sie einen symbolischen Link zum Verzeichnis /usr/bin erstellen.

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

Führen Sie den folgenden Befehl aus, um ein SSL-Zertifikat zu generieren.

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

Der obige Befehl lädt ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/metabase.example.com auf Ihrem Server herunter.

Generieren Sie ein Diffie-Hellman-Gruppen-Zertifikat.

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

Führen Sie einen Testlauf des Prozesses durch, um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert.

$ sudo certbot renew --dry-run

Wenn Sie keine Fehler sehen, sind Sie bereit. Ihr Zertifikat wird automatisch erneuert.

Schritt 7 - Nginx konfigurieren

Öffnen Sie die Datei /etc/nginx/nginx.conf zur Bearbeitung.

$ sudo nano /etc/nginx/nginx.conf

Fügen Sie die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; hinzu.

server_names_hash_bucket_size  64;

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Erstellen und öffnen Sie die Datei /etc/nginx/conf.d/metabase.conf zur Bearbeitung.

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

Fügen Sie den folgenden Code ein.

server {
  # Leiten Sie alle http-Anfragen zu https um
  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-Konfiguration
  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 ---
  # Holen Sie sich OCSP-Daten von der URL im ssl_certificate und cachen Sie sie
  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;
  }
}

Sobald Sie fertig sind, speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Überprüfen Sie die Syntax der Nginx-Konfigurationsdatei.

$ sudo nginx -t
nginx: die Konfigurationsdatei /etc/nginx/nginx.conf hat die Syntax ok
nginx: Konfigurationsdatei /etc/nginx/nginx.conf Test war erfolgreich

Starten Sie den Nginx-Server neu.

$ sudo systemctl restart nginx

Schritt 8 - Metabase installieren und darauf zugreifen

Öffnen Sie die URL https://metabase.example.com, um den Metabase-Setup-Assistenten zu starten.

Klicken Sie auf die Schaltfläche Loslegen, um zum nächsten Schritt zu gelangen. Die nächste Seite zeigt mehrere Schritte an. Wählen Sie Ihre Sprache aus und klicken Sie auf Weiter, um fortzufahren.

Geben Sie Ihre Metabase-Administratordaten ein.

Als Nächstes werden Sie aufgefordert, Daten zu Metabase hinzuzufügen, um sie zu erkunden. Sie können die Daten entweder jetzt hinzufügen oder später.

Klicken Sie auf Ich werde meine Daten später hinzufügen, um fortzufahren.

Deaktivieren Sie das Kontrollkästchen Erlauben Sie Metabase, anonym Nutzungsereignisse zu sammeln und klicken Sie auf die Schaltfläche Fertigstellen, um den Vorgang abzuschließen.

Klicken Sie auf die Schaltfläche Nehmen Sie mich zu Metabase, um das Metabase-Dashboard zu starten.

Sie können Metabase jetzt verwenden.

Schritt 9 - Metabase sichern

Wenn Sie die Metabase-Datenbank sichern möchten, verwenden Sie den folgenden Befehl.

$ docker exec -t postgres pg_dumpall -c -U navjot > dump_`date +%d-%m-%Y