Metabase auf Kubernetes bereitstellen und absichern

Metabase ist eine Open-Source-Business-Intelligence-Plattform, mit der du aus deinen Daten aussagekräftige Dashboards und Diagramme erstellen kannst. Sie unterstützt gängige Datenbanken wie MySQL, PostgreSQL, MongoDB und Redshift. Durch die Bereitstellung von Metabase auf Kubernetes erhältst du skalierbare Analysen in Echtzeit und erleichterst den Datenaustausch zwischen Teams, um die Zusammenarbeit und das KPI-Tracking zu verbessern.

Diese Anleitung erklärt, wie du Metabase in einem Kubernetes-Cluster bereitstellst. Du erstellst eine Datenbank mit einem Beispieldatensatz, installierst Metabase, verbindest es mit deiner Datenbank und visualisierst die Daten in einem Dashboard. Außerdem richtest du Nginx Ingress und TLS ein, um Metabase sicher über einen Domainnamen verfügbar zu machen.

Voraussetzungen

Bevor du beginnst, stelle sicher, dass folgende Anforderungen erfüllt sind:

• Ein bestehender Kubernetes-Cluster.
• Zugriff auf eine Linux-basierte Arbeitsstation, z. B. Ubuntu.
• Zugriff auf einen entfernten MySQL-Server, der vom Cluster erreichbar ist.
• Kubectl ist konfiguriert, um den Cluster zu verwalten.
• Helm ist auf der Arbeitsstation installiert.
• Eine registrierte Domain, die du mit Metabase verwenden kannst.

Eine Beispieldatenbank einrichten

Die Sakila-Beispieldatenbank simuliert eine DVD-Videothek mit Daten zu Filmen, Schauspielern, Geschäften und Ausleihen. Folge diesen Schritten, um Sakila für die Verwendung mit Metabase einzurichten.

Installiere Unzip, falls es noch nicht vorhanden ist:

$ sudo apt install zip -y

Lade das Sakila-Datenbankarchiv herunter:

$ wget https://downloads.mysql.com/docs/sakila-db.zip

Entpacke das Sakila-Archiv:

$ unzip sakila-db.zip

Das Archiv enthält drei Dateien: sakila-schema.sql, sakila-data.sql und sakila.mwb.

Melde dich am MySQL-Server an (ersetze Platzhalter mit den tatsächlichen Werten):

$ mysql -h  -P  -u  -p

Erstelle die Sakila-Datenbank:

mysql> CREATE DATABASE sakila;

Führe das Skript aus, um die Datenbankstruktur zu erstellen:

mysql> SOURCE sakila-db/sakila-schema.sql;

Importiere die Daten in die Datenbank:

mysql> SOURCE sakila-db/sakila-data.sql;

Metabase auf Kubernetes bereitstellen

Als Nächstes wird Metabase über eine Deployment-Datei und einen LoadBalancer-Service im Kubernetes-Cluster bereitgestellt.

Erstelle das Deployment-Manifest:

$ nano metabase.yaml

Füge die folgende Konfiguration hinzu:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: metabase
spec:
  selector:
    matchLabels:
      app: metabase
  replicas: 1
  template:
    metadata:
      labels:
        app: metabase
    spec:
      containers:
        - name: metabase
          image: metabase/metabase:latest
          ports:
            - containerPort: 3000
              protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  name: metabase-svc
spec:
  type: LoadBalancer
  selector:
    app: metabase
  ports:
    - name: http
      port: 8080
      targetPort: 3000

Wende das Deployment an:

$ kubectl apply -f metabase.yaml

Überprüfe Deployments und Services:

$ kubectl get deployments

Überprüfe die externen IP-Adressen der Services:

$ kubectl get services

Rufe Metabase im Browser über die externe IP auf:

http://192.0.2.9:8080

Metabase mit der Beispieldatenbank verbinden

Folge diesen Schritten, um Metabase mit der Sakila-Datenbank zu verbinden und ein Dashboard zu erstellen:

1. Klicke auf Let’s get started.
2. Wähle die bevorzugte Sprache.
3. Gib deinen Namen, deine E-Mail, dein Unternehmen und ein Passwort ein.
4. Wähle MySQL als Datenbank-Engine aus.
5. Trage die Datenbank-Zugangsdaten ein und klicke auf Connect Database.
6. Lege deine Datenfreigabe-Einstellungen fest und klicke auf Finish.
7. Klicke auf Take me to Metabase, um das Dashboard zu öffnen.

Ein Metabase-Dashboard erstellen

So erstellst du ein neues Dashboard:

1. Klicke auf + New → Dashboard.
2. Fülle die Dashboard-Details aus und klicke auf Create.
3. Füge ein Diagramm hinzu → New SQL query → wähle deine Datenbank.

Führe die folgende SQL-Abfrage aus, um den täglichen Gesamtumsatz zu berechnen:

SELECT CAST(payment_date AS DATE) AS payment_date, SUM(amount) AS total_revenue
FROM payment
GROUP BY CAST(payment_date AS DATE)
ORDER BY payment_date;

Klicke auf Run Query, um die Ergebnisse anzuzeigen, wähle Visualization → Line und speichere dein Diagramm. Das Dashboard zeigt nun ein Liniendiagramm mit den täglichen Umsätzen an.

Metabase mit TLS-Verschlüsselung absichern

Sichere die Metabase-Bereitstellung, indem du TLS-Verschlüsselung mit Nginx Ingress und Cert-Manager aktivierst.

Ändere den Service-Typ zu ClusterIP:

$ kubectl patch svc metabase-svc -p '{"spec": {"type": "ClusterIP"}}'

Installiere den Nginx Ingress Controller mit Helm:

$ helm install my-ingress-nginx ingress-nginx \
--repo https://kubernetes.github.io/ingress-nginx \
--namespace ingress-nginx --create-namespace

Installiere Cert-Manager:

$ kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.17.0/cert-manager.yaml

Erstelle eine Issuer-Datei:

$ nano cert-issuer.yaml

Füge den folgenden Inhalt ein:

apiVersion: cert-manager.io/v1
kind: Issuer
metadata:
  name: tls-certificate-issuer
  namespace: default 
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: abc@example.com  
    privateKeySecretRef:
      name: letsencrypt-private-key 
    solvers:
      - http01:
          ingress:
            class: nginx

Wende die Issuer-Konfiguration an:

$ kubectl apply -f cert-issuer.yaml

Erstelle und wende die Ingress-Datei an:

$ nano ingress.yaml

Füge den folgenden Inhalt hinzu (ersetze example.com durch deine Domain):

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-metabase
  annotations:
    cert-manager.io/issuer: tls-certificate-issuer
spec:
  ingressClassName: nginx
  rules:
  - host: example.com 
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: metabase-svc 
            port:
              number: 8080
  tls:
  - hosts:
      - example.com  
    secretName: my-webapp-tls

Wende die Ingress-Datei an:

$ kubectl apply -f ingress.yaml

Nach der Ausstellung kannst du Metabase sicher über HTTPS aufrufen:

https://example.com

Fazit

Du hast Metabase erfolgreich in einem Kubernetes-Cluster bereitgestellt, mit einer Beispieldatenbank verbunden und Daten in Dashboards visualisiert. Außerdem wurde Metabase mit TLS-Verschlüsselung über Nginx Ingress abgesichert. Weitere Informationen und erweiterte Konfigurationsoptionen findest du in der offiziellen Metabase-Dokumentation.