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