Instalação do Metabase usando Docker no Linux e Conexão com PostgreSQL - Parte 2

Introdução

Para ilustrar o uso de Business Intelligence open source em ambientes Linux que comentamos no artigo Parte - 1, vamos realizar a instalação do Metabase utilizando Docker, uma abordagem moderna, leve e altamente portátil que simplifica a implantação e a gestão de aplicações. Em seguida, conectaremos o Metabase a um banco de dados PostgreSQL, também executado em container, demonstrando como é possível criar um ambiente completo de análise de dados com ferramentas open source, totalmente funcional e compatível com o ecossistema Linux. Esse cenário prático mostra como equipes técnicas podem desenvolver dashboards interativos, fazer consultas em linguagem natural e compartilhar insights sem depender de soluções proprietárias ou sistemas operacionais específicos, promovendo um BI mais acessível, escalável e alinhado com os princípios de liberdade e transparência do software livre.

Aqui vamos usar dois serviços principais:

PostgreSQL + PostGIS → banco de dados relacional com suporte geoespacial.
Metabase → ferramenta de visualização e exploração de dados.

Objetivo

Ao final, você terá:

Containers Docker do PostgreSQL e Metabase funcionando.
Banco populado com tabelas e dados de vendas/entregas.
Uma conexão entre Metabase e PostgreSQL.
Seu primeiro dashboard interativo pronto.

1. Pré-requisitos

Certifique-se de ter no Linux:

Docker está instalado

docker --version

docker-compose está instalado

docker-compose --version

2. Estrutura do Projeto

Crie uma pasta para organizar o projeto

mkdir -p ~/metabase-demo/{postgres/data,metabase/data,scripts}

cd ~/metabase-demo

2.1 Criar o arquivo do script

Abra o terminal e crie um arquivo .sh:

nano create_metabase_demo.sh

2.2 Copiar o conteúdo do script

#!/bin/bash
set -e

# === Nome e raiz do projeto ===
PROJECT_NAME="metabase-demo"
PROJECT_ROOT="$HOME/$PROJECT_NAME"

echo "Criando estrutura do projeto em: $PROJECT_ROOT"

# Criar diretórios
mkdir -p "$PROJECT_ROOT/scripts"
mkdir -p "$PROJECT_ROOT/postgres/data"
mkdir -p "$PROJECT_ROOT/metabase/data"

# Criar arquivo docker-compose.yml vazio (se não existir)
DOCKER_COMPOSE_FILE="$PROJECT_ROOT/docker-compose.yml"
if [ ! -f "$DOCKER_COMPOSE_FILE" ]; then
  touch "$DOCKER_COMPOSE_FILE"
  echo "Criado: docker-compose.yml"
else
  echo "docker-compose.yml já existe. Pulando."
fi

# Criar script setup_metabase_data.sh vazio (se não existir)
SETUP_SCRIPT="$PROJECT_ROOT/scripts/setup_metabase_data.sh"
if [ ! -f "$SETUP_SCRIPT" ]; then
  echo "#!/bin/bash" > "$SETUP_SCRIPT"
  echo "echo 'Inicializando dados do Metabase...'" >> "$SETUP_SCRIPT"
  chmod +x "$SETUP_SCRIPT"
  echo "Criado: scripts/setup_metabase_data.sh"
else
  echo "setup_metabase_data.sh já existe. Pulando."
fi

echo "Estrutura do projeto criada com sucesso!"
echo
echo "Estrutura:"
tree -a "$PROJECT_ROOT" || ls -R "$PROJECT_ROOT"

Salve (CTRL+O) e saia (CTRL+X).

2.3 – Dar permissão de execução

chmod +x create_metabase_demo.sh

2.4 – Executar o script

Agora é só rodar:

./create_metabase_demo.sh

Isso vai criar a estrutura em ~/metabase-demo/.

Estrutura final do projeto

~/metabase-demo/
├── docker-compose.yml
├── scripts/
│   └── setup_metabase_data.sh
├── postgres/
│   └── data/        # dados do banco
└── metabase/
  └── data/        # dados internos do Metabase

3. Criando o docker-compose.yml

version: '3.8'

services:
postgres:
  image: postgis/postgis:15-3.3
  container_name: metabase-postgres
  environment:
    POSTGRES_DB: metabase_data
    POSTGRES_USER: metabase
    POSTGRES_PASSWORD: metabase123
  ports:
    - "5432:5432"
  volumes:
    - ./postgres/data:/var/lib/postgresql/data
  restart: unless-stopped

metabase:
  image: metabase/metabase:v0.48.0
  container_name: metabase-app
  depends_on:
    - postgres
  ports:
    - "3000:3000"
  environment:
    MB_DB_FILE: /metabase-data/metadata.db
  volumes:
    - ./metabase/data:/metabase-data
  restart: unless-stopped

4. Inicializando os Containers

No diretório do projeto:

docker-compose up -d

-d → roda em background.

Verifique:

docker ps

Você verá dois containers: metabase-postgres e metabase-app.

5. Criando Script para Popular o Banco

Vamos criar tabelas e dados de exemplo.

nano ~/metabase-demo/scripts/setup_metabase_data.sh

Criamos um exemplo de Loja de eletrônicos, mas você pode criar o seu próprio projeto:

#!/bin/bash

set -e  # Para execução em caso de erro
SQL_FILE=vendas_entregas_postgis.sql
cat <<EOF > $SQL_FILE

-- ===========================
-- Habilitar PostGIS
-- ===========================

CREATE EXTENSION IF NOT EXISTS postgis;

-- ===========================
-- Criar tabelas
-- ===========================

DROP TABLE IF EXISTS entregas CASCADE;
DROP TABLE IF EXISTS vendas CASCADE;

CREATE TABLE vendas (
 id SERIAL PRIMARY KEY,
 produto VARCHAR(100) NOT NULL,
 valor NUMERIC(10,2) NOT NULL,
 data_venda DATE NOT NULL,
 regiao VARCHAR(50) NOT NULL
);

CREATE TABLE entregas (
  id SERIAL PRIMARY KEY,
  venda_id INT NOT NULL REFERENCES vendas(id) ON DELETE CASCADE,
  loja_geom geometry(Point, 4326) NOT NULL,
  cliente_geom geometry(Point, 4326) NOT NULL
);

-- ===========================
-- Inserir dados em vendas
-- ===========================

INSERT INTO vendas (produto, valor, data_venda, regiao) VALUES
('Notebook', 3500.00, '2024-01-15', 'São Paulo'),
('Mouse', 80.00, '2024-01-16', 'Rio de Janeiro'),
('Teclado', 250.00, '2024-01-17', 'São Paulo'),
('Monitor', 1200.00, '2024-01-18', 'Minas Gerais'),
('Cabo USB', 30.00, '2024-01-19', 'Bahia');

-- ===========================
-- Inserir dados em entregas (geográficos)
-- ===========================

INSERT INTO entregas (venda_id, loja_geom, cliente_geom) VALUES
(1, ST_SetSRID(ST_MakePoint(-46.633308, -23.550520), 4326), ST_SetSRID(ST_MakePoint(-46.625378, -23.561684), 4326)),
(2, ST_SetSRID(ST_MakePoint(-43.172896, -22.906847), 4326), ST_SetSRID(ST_MakePoint(-43.200198, -22.913903), 4326)),
(3, ST_SetSRID(ST_MakePoint(-43.935238, -19.920830), 4326), ST_SetSRID(ST_MakePoint(-43.940000, -19.930000), 4326)),
(4, ST_SetSRID(ST_MakePoint(-43.935238, -19.920830), 4326), ST_SetSRID(ST_MakePoint(-43.950000, -19.900000), 4326)),
(5, ST_SetSRID(ST_MakePoint(-38.501558, -12.977860), 4326), ST_SetSRID(ST_MakePoint(-38.520000, -12.980000), 4326));

-- ===========================
-- Função para calcular distância em km
-- ===========================

CREATE OR REPLACE FUNCTION calcular_distancia_km(
  p1 geometry,
  p2 geometry
) RETURNS NUMERIC AS \$\$

BEGIN
  RETURN ST_Distance(p1::geography, p2::geography) / 1000.0;
END;
\$\$ LANGUAGE plpgsql IMMUTABLE;

-- ===========================
-- Criar view para Metabase
-- ===========================

CREATE OR REPLACE VIEW entregas_map AS
SELECT
e.id,
e.venda_id,
v.produto,
v.valor,
v.regiao,
ST_Y(e.loja_geom) AS loja_latitude,
ST_X(e.loja_geom) AS loja_longitude,
ST_Y(e.cliente_geom) AS cliente_latitude,
ST_X(e.cliente_geom) AS cliente_longitude,
calcular_distancia_km(e.loja_geom, e.cliente_geom) AS distancia_km,
5.00 + 2.00 * calcular_distancia_km(e.loja_geom, e.cliente_geom) AS valor_entrega

FROM entregas e
JOIN vendas v ON e.venda_id = v.id;
EOF
echo "Executando script no PostgreSQL..."
docker exec -i metabase-postgres psql -U metabase -d metabase_data < "$SQL_FILE"
rm -f "$SQL_FILE"
echo "Banco configurado com sucesso!"

Dar permissão e rodar:

chmod +x ~/metabase-demo/scripts/setup_metabase_data.sh

cd ~/metabase-demo/scripts

./setup_metabase_data.sh

Entendendo o PostGIS e a Função de Distância

O que é PostGIS?

O PostGIS é uma extensão do PostgreSQL que adiciona suporte para dados espaciais e geográficos.
Com ele, você pode trabalhar com pontos, linhas, polígonos, mapas e coordenadas geográficas diretamente no banco de dados.
PostGIS é muito usado em aplicações de:
Logística e Supply Chain
Mapas interativos (GIS)
Cálculo de rotas
Georreferenciamento de clientes/lojas

Exemplo básico de tipos de dados que o PostGIS permite:

geometry(Point, 4326) -- Ponto no sistema de coordenadas WGS84 (latitude/longitude padrão GPS)
geometry(LineString, 4326) -- Linha entre dois pontos
geometry(Polygon, 4326) -- Área delimitada

No nosso caso, usamos geometry(Point, 4326) para representar localização da loja e do cliente.

O que significa ST_Distance?

ST_Distance(p1, p2) calcula a distância entre dois objetos geométricos.
Por padrão, se você passar apenas geometry, a distância é medida em unidades do sistema de coordenadas (no SRID 4326, seriam graus de latitude/longitude → não útil para distâncias reais).
Para corrigir isso, convertemos para geography, que interpreta os pontos como coordenadas reais na Terra e calcula distâncias em metros.

ST_Distance(p1::geography, p2::geography)

p1::geography → converte o ponto de geometry para geography.
ST_Distance(..., ...) → retorna a distância em metros, considerando a curvatura da Terra.
No nosso script, fazemos a divisão por 1000 para converter em quilômetros:

RETURN ST_Distance(p1::geography, p2::geography) / 1000.0;

Então temos:

SELECT ST_Distance(

  ST_SetSRID(ST_MakePoint(-46.633308, -23.550520), 4326)::geography,

  ST_SetSRID(ST_MakePoint(-46.625378, -23.561684), 4326)::geography

) / 1000 AS distancia_km;

Resultado: ~1.4 km

Essa é a distância entre dois pontos no centro de São Paulo no nosso exemplo.

Por que isso é útil?

Permite calcular distâncias reais entre clientes e lojas.
Serve como base para cálculo de frete, rotas, regiões de entrega, análise logística.
No Metabase, podemos criar gráficos mostrando tempo médio de entrega por região ou custo por quilômetro.

Dica:

Outras funções úteis do PostGIS: