Cómo instalar Metabase en Ubuntu 22.04 con Docker

Metabase es una herramienta de Business Intelligence (BI) de código abierto basada en Java. Se conecta a varias bases de datos y utiliza un constructor de preguntas para ocultar la complejidad de las grandes consultas SQL que te permiten visualizar los datos de los clientes en un formato legible y analizarlos. Puedes hacer preguntas sobre tus datos o incrustarlos en tu aplicación para que tus clientes exploren sus datos por su cuenta. Puede generar cuadros de mando y visualizaciones y enviar alertas a tu canal de Slack. Puede conectarse a muchas plataformas de bases de datos y fuentes de datos, como MySQL, Google Analytics, MongoDB, PostgreSQL, ClickHouse, Amazon Athena, Amazon Redshift y muchas más.

Utilizando Docker, aprenderás a instalar Metabase en un servidor Ubuntu 22.04.

Requisitos previos

• Un servidor que ejecute Ubuntu 22.04 con un mínimo de 2 núcleos de CPU y 2 GB de memoria. Tendrás que actualizar el servidor según los requisitos.
• Un usuario no root con privilegios sudo.
• Un nombre de dominio completo (FQDN) que apunte a tu servidor. Para nuestros propósitos, utilizaremos metabase.example.com como nombre de dominio.
• Metabase envía notificaciones por correo electrónico a los usuarios. Te recomendamos que utilices un servicio de correo transaccional de terceros, como Mailgun, Sendgrid, Amazon SES o Sparkpost. Las instrucciones de la guía utilizarán Amazon SES.
• Asegúrate de que todo está actualizado.

  $ sudo apt update
  

• Instala los paquetes de utilidades básicas. Puede que algunos ya estén instalados.

  $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
  

Paso 1 – Configurar el cortafuegos

El primer paso es configurar el cortafuegos. Ubuntu viene con ufw (Uncomplicated Firewall) por defecto.

Comprueba si el cortafuegos se está ejecutando.

$ sudo ufw status

Deberías obtener la siguiente salida.

Status: inactive

Permite el puerto SSH para que el cortafuegos no rompa la conexión actual al activarlo.

$ sudo ufw allow OpenSSH

Permite también los puertos HTTP y HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Habilita el cortafuegos

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

Comprueba de nuevo el estado del cortafuegos.

$ sudo ufw status

Deberías ver un resultado similar.

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)

Paso 2 – Instala Docker y Docker Compose

Ubuntu 22.04 incluye una versión antigua de Docker. Para instalar la última versión, importa primero la clave GPG de Docker.

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

Crea un archivo de repositorio de 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

Actualiza la lista de repositorios del sistema.

$ sudo apt update

Instala la última versión de Docker.

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

Comprueba que se está ejecutando.

$ 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

Por defecto, Docker requiere privilegios de root. Si quieres evitar utilizar sudo cada vez que ejecutes el comando docker, añade tu nombre de usuario al grupo docker.

$ sudo usermod -aG docker $(whoami)

Tendrás que salir del servidor y volver a entrar como el mismo usuario para activar este cambio o utilizar el siguiente comando.

$ su - ${USER}

Confirma que tu usuario se ha añadido al grupo Docker.

$ groups
navjot wheel docker

Paso 3 – Crear un archivo Docker Compose para Metabase

Crea un directorio para Metabase.

$ mkdir ~/metabase

Crea y abre el archivo Docker compose para editarlo.

$ nano docker-compose.yml

Pega en él el siguiente código.

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

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

El archivo Docker compose anterior toma la última versión de la imagen Docker de Metabase y expone la aplicación a través del puerto 3000. Se conecta a la imagen PostgreSQL. El nombre de usuario y la contraseña de la base de datos PostgreSQL se almacenan en los archivos db_user.txt y db_password.txt respectivamente.

Crea y abre el archivo db_user.txt para editarlo.

$ nano db_user.txt

Pega en él tu nombre de usuario y guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Crea y abre el archivo db_password.txt para editarlo.

$ nano db_password.txt

Introduce tu contraseña y guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Paso 4 – Configurar los archivos de entorno e iniciar Metabase

Genera una clave de encriptación utilizando el siguiente comando.

$ openssl rand -base64 32
aWPk99bIjkG7NvWYVqR5NIAojhW1Idk0OvTH1xWVMbY=

Copia la clave para utilizarla más tarde.

Crea y abre el archivo metabase.env para editarlo.

$ nano metabase.env

Pega en él el siguiente código. Pega la clave secreta que has generado en la variable MB_ENCRYPTION_SECRET_KEY. Introduce tu dominio Metabase incluyendo el protocolo https. Introduce los datos SMTP del proveedor que utilices. Nosotros utilizamos Amazon SES. La variable MB_PASSWORD_COMPLEXITY está configurada como fuerte, lo que significa que la contraseña de tu Metabase debe tener un mínimo de 8 caracteres, con 2 minúsculas, 2 mayúsculas, 1 dígito y 1 carácter especial.

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

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Inicia el contenedor Docker.

$ docker compose up -d

Puedes ver el estado de los contenedores utilizando el siguiente comando.

$ watch docker ps

Recibirás una salida similar. Espera a que el estado de ambos contenedores sea saludable y pulsa Ctrl + C para salir de la pantalla.

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

Paso 5 – Instalar Nginx

Ubuntu 22.04 viene con una versión antigua de Nginx. Para instalar la última versión, necesitas descargar el repositorio oficial de Nginx.

Importa la clave de firma de Nginx.

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

Añade el repositorio de la versión estable 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

Actualiza los repositorios del sistema.

$ sudo apt update

Instala Nginx.

$ sudo apt install nginx

Verifica la instalación.

$ nginx -v
nginx version: nginx/1.22.1

Inicia el servidor Nginx.

$ sudo systemctl start nginx

Comprueba el estado del servidor.

$ 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.

Paso 6 – Instalar SSL

Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot utilizando el repositorio de Ubuntu o descargar la última versión utilizando la herramienta Snapd. Nosotros utilizaremos la versión Snapd.

Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd está actualizada. Asegúrate de que tu versión de Snapd está actualizada.

$ sudo snap install core
$ sudo snap refresh core

Instala Certbot.

$ sudo snap install --classic certbot

Utiliza el siguiente comando para asegurarte de que se ejecuta el comando Certbot creando un enlace simbólico al directorio /usr/bin.

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

Ejecuta el siguiente comando para generar un certificado SSL.

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

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/metabase.example.com de tu servidor.

Genera un certificado de grupo Diffie-Hellman.

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

Realiza una ejecución en seco del proceso para comprobar si la renovación SSL funciona correctamente.

$ sudo certbot renew --dry-run

Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.

Paso 7 – Configurar Nginx

Abre el archivo /etc/nginx/nginx.conf para editarlo.

$ sudo nano /etc/nginx/nginx.conf

Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Crea y abre el archivo /etc/nginx/conf.d/metabase.conf para editarlo.

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

Pega en él el siguiente código.

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;
  }
}

Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Verifica la sintaxis del archivo de configuración de 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

Reinicia el servidor Nginx.

$ sudo systemctl restart nginx

Paso 8 – Instalar y acceder a la Metabase

Abre la URL https://metabase.example.com para iniciar el asistente de instalación de la Metabase.

Haz clic en el botón Comencemos para pasar al siguiente paso. En la página siguiente aparecerán varios pasos. Elige tu idioma y haz clic en Siguiente para continuar.

Introduce tus datos de administrador de la Metabase.

A continuación, se te pedirá que añadas datos a la Metabase para explorarlos. Puedes añadir los datos ahora o hacerlo más tarde.

Haz clic en Añadiré mis datos más tarde para continuar.

Desmarca la casilla Permitir que la Metabase recopile anónimamente eventos de uso y haz clic en el botón Finalizar para completar el proceso.

Haz clic en el botón Llévame a Me tabase para iniciar el panel de Metabase.

Ya puedes empezar a utilizar Metabase.

Paso 9 – Hacer una copia de seguridad de la Metabase

Si quieres hacer una copia de seguridad de la base de datos de Metabase, utiliza el siguiente comando.

$ docker exec -t postgres pg_dumpall -c -U navjot > dump_`date +%d-%m-%Y"_"%H_%M_%S`.sql

Sustituye navjot por el nombre de usuario de tu base de datos y postgres por el nombre de tu contenedor Docker para PostgreSQL.

Para restaurar la base de datos, utiliza el siguiente comando.

$ cat dump_*.sql | docker exec -i your-db-container psql -U navjot

Paso 10 – Actualizar Metabase

Actualizar Metabase requiere varios pasos. El primer paso es hacer una copia de seguridad de la base de datos de Metabase utilizando el comando del paso 9.

A continuación, pasa al directorio

$ cd /opt/metabase

Saca las últimas imágenes de contenedor para Mastodon.

$ docker compose pull metabase/metabase:latest

Haz los cambios que quieras en docker-compose.yml.

Reinicia los contenedores de Mastodon.

$ docker compose up -d

Las instrucciones anteriores son instrucciones genéricas de actualización. Consulta siempre la página de versiones de GitHub de Mas todon para buscar tareas y comandos específicos de actualización entre versiones para asegurarte de que todo va bien.

Conclusión

Con esto concluye nuestro tutorial sobre la instalación de Metabase en un servidor Ubuntu 22.04. Si tienes alguna pregunta, publícala en los comentarios a continuación.