Comment installer Metabase sur Ubuntu 22.04 avec Docker

Metabase est un outil de Business Intelligence (BI) open-source basé sur Java. Il se connecte à un certain nombre de bases de données et utilise un constructeur de questions pour masquer la complexité des grandes requêtes SQL qui vous permettent de visualiser les données clients dans un format lisible et de les analyser. Vous pouvez poser des questions sur vos données ou les intégrer dans votre application pour permettre à vos clients d’explorer leurs données par eux-mêmes. Il peut générer des tableaux de bord et des visualisations et envoyer des alertes à votre canal Slack. Il peut se connecter à de nombreuses plateformes de bases de données et sources de données, y compris MySQL, Google Analytics, MongoDB, PostgreSQL, ClickHouse, Amazon Athena, Amazon Redshift, et bien d’autres.

En utilisant Docker, vous apprendrez comment installer Metabase sur un serveur Ubuntu 22.04.

Prérequis

• Un serveur exécutant Ubuntu 22.04 avec un minimum de 2 cœurs CPU et 2 Go de mémoire. Vous devrez mettre à niveau le serveur selon les exigences.
• Un utilisateur non-root avec des privilèges sudo.
• Un nom de domaine complètement qualifié (FQDN) pointant vers votre serveur. Pour nos besoins, nous utiliserons metabase.example.com comme nom de domaine.
• Metabase envoie des notifications par e-mail aux utilisateurs. Nous vous recommandons d’utiliser un service de messagerie transactionnelle tiers comme Mailgun, Sendgrid, Amazon SES ou Sparkpost. Les instructions dans le guide utiliseront Amazon SES.
• Assurez-vous que tout est à jour. $ sudo apt update
• Installez des paquets utilitaires de base. Certains d’entre eux peuvent déjà être installés. $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

Étape 1 - Configurer le pare-feu

La première étape consiste à configurer le pare-feu. Ubuntu est livré avec ufw (Uncomplicated Firewall) par défaut.

Vérifiez si le pare-feu est en cours d’exécution.

$ sudo ufw status

Vous devriez obtenir la sortie suivante.

Status: inactive

Autorisez le port SSH afin que le pare-feu ne rompe pas la connexion actuelle lors de son activation.

$ sudo ufw allow OpenSSH

Autorisez également les ports HTTP et HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Activez le pare-feu

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

Vérifiez à nouveau l’état du pare-feu.

$ sudo ufw status

Vous devriez voir une sortie similaire.

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)

Étape 2 - Installer Docker et Docker Compose

Ubuntu 22.04 est livré avec une version plus ancienne de Docker. Pour installer la dernière version, commencez par importer la clé GPG de Docker.

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

Créez un fichier de dépôt 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

Mettez à jour la liste des dépôts du système.

$ sudo apt update

Installez la dernière version de Docker.

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

Vérifiez qu’il fonctionne.

$ 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

Par défaut, Docker nécessite des privilèges root. Si vous souhaitez éviter d’utiliser sudo chaque fois que vous exécutez la commande docker, ajoutez votre nom d’utilisateur au groupe docker.

$ sudo usermod -aG docker $(whoami)

Vous devrez vous déconnecter du serveur et vous reconnecter en tant que même utilisateur pour activer ce changement ou utiliser la commande suivante.

$ su - ${USER}

Confirmez que votre utilisateur est ajouté au groupe Docker.

$ groups
navjot wheel docker

Étape 3 - Créer un fichier Docker Compose pour Metabase

Créez un répertoire pour Metabase.

$ mkdir ~/metabase

Créez et ouvrez le fichier Docker compose pour l’édition.

$ nano docker-compose.yml

Collez le code suivant dedans.

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

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Le fichier Docker compose ci-dessus récupère la dernière version de l’image Docker Metabase et expose l’application via le port 3000. Il est connecté à l’image PostgreSQL. Le nom d’utilisateur et le mot de passe de la base de données PostgreSQL sont stockés dans les fichiers db_user.txt et db_password.txt respectivement.

Créez et ouvrez le fichier db_user.txt pour l’édition.

$ nano db_user.txt

Collez votre nom d’utilisateur dedans et enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Créez et ouvrez le fichier db_password.txt pour l’édition.

$ nano db_password.txt

Collez votre mot de passe dedans et enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Étape 4 - Configurer les fichiers d’environnement et démarrer Metabase

Générez une clé de chiffrement en utilisant la commande suivante.

$ openssl rand -base64 32
aWPk99bIjkG7NvWYVqR5NIAojhW1Idk0OvTH1xWVMbY=

Copiez la clé pour une utilisation ultérieure.

Créez et ouvrez le fichier metabase.env pour l’édition.

$ nano metabase.env

Collez le code suivant dedans. Collez la clé secrète que vous avez générée contre la variable MB_ENCRYPTION_SECRET_KEY. Remplissez votre domaine Metabase y compris le protocole https. Remplissez vos détails SMTP en utilisant le fournisseur que vous utilisez. Nous utilisons Amazon SES. La variable MB_PASSWORD_COMPLEXITY est définie sur forte, ce qui signifie que votre mot de passe Metabase doit avoir une longueur minimale de 8 caractères, avec 2 minuscules, 2 majuscules, 1 chiffre et 1 caractère spécial.

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

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Lancez le conteneur Docker.

$ docker compose up -d

Vous pouvez surveiller l’état des conteneurs en utilisant la commande suivante.

$ watch docker ps

Vous recevrez une sortie similaire. Attendez que l’état des deux conteneurs devienne sain, puis appuyez sur Ctrl + C pour quitter l’écran.

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

Étape 5 - Installer Nginx

Ubuntu 22.04 est livré avec une version plus ancienne de Nginx. Pour installer la dernière version, vous devez télécharger le dépôt officiel de Nginx.

Importez la clé de signature de Nginx.

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

Ajoutez le dépôt pour la version stable de 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

Mettez à jour les dépôts du système.

$ sudo apt update

Installez Nginx.

$ sudo apt install nginx

Vérifiez l’installation.

$ nginx -v
nginx version: nginx/1.22.1

Démarrez le serveur Nginx.

$ sudo systemctl start nginx

Vérifiez l’état du serveur.

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

Étape 6 - Installer SSL

Nous devons installer Certbot pour générer le certificat SSL. Vous pouvez soit installer Certbot en utilisant le dépôt d’Ubuntu, soit obtenir la dernière version en utilisant l’outil Snapd. Nous allons utiliser la version Snapd.

Ubuntu 22.04 est livré avec Snapd installé par défaut. Exécutez les commandes suivantes pour vous assurer que votre version de Snapd est à jour. Assurez-vous que votre version de Snapd est à jour.

$ sudo snap install core
$ sudo snap refresh core

Installez Certbot.

$ sudo snap install --classic certbot

Utilisez la commande suivante pour vous assurer que la commande Certbot s’exécute en créant un lien symbolique vers le répertoire /usr/bin.

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

Exécutez la commande suivante pour générer un certificat SSL.

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

La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/metabase.example.com sur votre serveur.

Générez un certificat de groupe Diffie-Hellman.

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

Faites un essai à sec du processus pour vérifier si le renouvellement SSL fonctionne correctement.

$ sudo certbot renew --dry-run

Si vous ne voyez pas d’erreurs, vous êtes prêt. Votre certificat se renouvellera automatiquement.

Étape 7 - Configurer Nginx

Ouvrez le fichier /etc/nginx/nginx.conf pour l’édition.

$ sudo nano /etc/nginx/nginx.conf

Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Créez et ouvrez le fichier /etc/nginx/conf.d/metabase.conf pour l’édition.

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

Collez le code suivant dedans.

server {
  # Redirigez toutes les requêtes http vers 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;

  # Configuration TLS
  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 ---
  # récupérez les enregistrements OCSP à partir de l'URL dans ssl_certificate et mettez-les en cache
  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;
  }
}

Une fois terminé, enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Vérifiez la syntaxe du fichier de configuration 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

Redémarrez le serveur Nginx.

$ sudo systemctl restart nginx

Étape 8 - Installer et accéder à Metabase

Ouvrez l’URL https://metabase.example.com pour lancer l’assistant de configuration de Metabase.

Cliquez sur le bouton Commençons pour passer à l’étape suivante. La page suivante aura plusieurs étapes listées. Choisissez votre langue et cliquez sur Suivant pour continuer.

Entrez vos détails d’administrateur Metabase.

Ensuite, vous serez invité à ajouter des données à Metabase pour explorer. Vous pouvez ajouter les données maintenant ou le faire plus tard.

Cliquez sur J’ajouterai mes données plus tard pour continuer.

Décochez la case Autoriser Metabase à collecter anonymement des événements d’utilisation et cliquez sur le bouton Terminer pour compléter le processus.

Cliquez sur le bouton Emmenez-moi à Metabase pour lancer le tableau de bord Metabase.

Vous pouvez commencer à utiliser Metabase maintenant.

Étape 9 - Sauvegarder Metabase

Si vous souhaitez sauvegarder la base de données Metabase, utilisez la commande suivante.

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