Sankhya + Power BI: integração moderna com API, sincronização e atualização automática

ntegrar o Sankhya ao Power BI vai muito além de consumir dados diretamente do ERP.

Em ambientes corporativos, a arquitetura correta precisa considerar:

performance
estabilidade
paginação
autenticação
escalabilidade
atualização automática
proteção do ERP

O erro mais comum é:

❌ conectar o Power BI diretamente na API do Sankhya.

Embora funcione inicialmente, isso rapidamente gera:

lentidão
timeouts
excesso de chamadas
sobrecarga no ERP
falhas de autenticação
problemas com paginação

A arquitetura moderna separa:

👉 camada operacional (ERP/API)
👉 camada analítica (Power BI)

Arquitetura recomendada

Sankhya API
      ↓
Serviço de sincronização
      ↓
Banco MySQL intermediário
      ↓
Power BI + Gateway
      ↓
Atualização automática

Nesse modelo:

o Sankhya fornece os dados
o backend sincroniza
o MySQL armazena
o Power BI consome localmente

Resultado:

✅ dashboards rápidos
✅ ERP protegido
✅ integração escalável

Consumindo a API do Sankhya

O sincronizador pode trabalhar tanto com:

APIs legadas (service.sbr)
API V1 REST paginada

O importante é:

👉 controlar paginação e sincronização no backend.

Exemplo de autenticação OAuth 2.0

const response = await fetch(
  "https://empresa.sankhya.com.br/gateway/v1/oauth/token",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      grant_type: "password",
      client_id: "client_id",
      client_secret: "client_secret",
      username: "usuario",
      password: "senha"
    })
  }
);

const data = await response.json();

const token = data.access_token;

Exemplo de consulta paginada na API V1

Exemplo consumindo produtos:

async function buscarProdutos(page = 0) {

  const response = await fetch(
    `https://empresa.sankhya.com.br/gateway/v1/mge/produto?page=${page}&size=500`,
    {
      headers: {
        Authorization: `Bearer ${token}`
      }
    }
  );

  return await response.json();
}

Percorrendo todas as páginas

Aqui está o ponto mais importante.

A sincronização precisa percorrer todas as páginas automaticamente.

async function sincronizarProdutos() {

  let page = 0;
  let possuiDados = true;

  while (possuiDados) {

    const result = await buscarProdutos(page);

    const registros = result.data;

    if (!registros || registros.length === 0) {
      possuiDados = false;
      break;
    }

    console.log(`Página ${page} carregada`);

    await salvarNoBanco(registros);

    page++;
  }
}

Criando o banco MySQL

O ideal é utilizar um banco intermediário analítico.

Exemplo:

CREATE DATABASE sankhya_bi;

Tabela de produtos:

CREATE TABLE produtos (
    id BIGINT PRIMARY KEY,
    codigo VARCHAR(50),
    descricao VARCHAR(255),
    marca VARCHAR(100),
    ativo CHAR(1),
    data_atualizacao DATETIME
);

Alimentando o banco

Agora o sincronizador grava os dados recebidos.

Exemplo usando Node.js + MySQL:

const mysql = require("mysql2/promise");

const connection = await mysql.createConnection({
  host: "localhost",
  user: "root",
  password: "senha",
  database: "sankhya_bi"
});

Inserindo registros:

async function salvarNoBanco(registros) {

  for (const item of registros) {

    await connection.execute(`
      INSERT INTO produtos
      (id, codigo, descricao, marca, ativo, data_atualizacao)

      VALUES (?, ?, ?, ?, ?, NOW())

      ON DUPLICATE KEY UPDATE
        descricao = VALUES(descricao),
        marca = VALUES(marca),
        ativo = VALUES(ativo),
        data_atualizacao = NOW()
    `,
    [
      item.id,
      item.codigo,
      item.descricao,
      item.marca,
      item.ativo
    ]);
  }
}

Sincronização por reconciliação

Aqui está a diferença entre um projeto simples e um projeto corporativo.

O sincronizador não deve:

DELETE + INSERT completo

O correto é:

sincronização por reconciliação de estado

Ou seja:

✅ cria novos registros
✅ atualiza alterados
✅ evita duplicidade
✅ mantém histórico
✅ reduz processamento

Estratégia incremental

O ideal é sincronizar apenas alterações recentes.

Exemplo:

?modifiedSince=2026-05-01T00:00:00

Isso reduz drasticamente:

payload
consumo da API
tempo de sincronização

Conectando o Power BI no MySQL

Depois do banco pronto:

o Power BI passa a consumir apenas o MySQL.

Instalar conector MySQL

No Power BI Desktop:

Obter Dados
→ MySQL Database

Informe:

host
banco
usuário
senha

Configurando o Gateway

Em ambiente corporativo normalmente o MySQL fica:

localmente
em VPN
em cloud privada

Por isso é necessário instalar:

On-Premises Data Gateway

Download:

https://powerbi.microsoft.com/gateway/

Configuração do Gateway

Após instalar:

Power BI Service
→ Configurações
→ Gateway
→ Adicionar Fonte de Dados

Configure:

servidor MySQL
usuário
senha

Atualização automática

Depois de publicar o relatório:

Dataset
→ Agendamento de Atualização

Configure:

Atualizar a cada 30 minutos

Fluxo completo:

Sankhya API
    ↓
Sincronizador Node.js
    ↓
MySQL
    ↓
Gateway
    ↓
Power BI

Frequência recomendada

Estoque

5 minutos

Pedidos

10 minutos

Produtos e clientes

30 minutos

Histórico financeiro

Carga noturna

Benefícios da arquitetura

Performance

O Power BI consulta localmente.

Sem depender do ERP.

Segurança

O Power BI não acessa:

token
OAuth
credenciais Sankhya

Escalabilidade

O ERP deixa de receber consultas analíticas massivas.

Estabilidade

A sincronização fica controlada pelo backend.

Conclusão

Integrar Sankhya ao Power BI da forma correta não significa apenas consumir APIs.

A arquitetura moderna exige:

sincronização controlada
paginação
backend intermediário
reconciliação de estado
banco analítico
gateway corporativo
atualização automática

A API do Sankhya deve funcionar como camada operacional de extração.

Já o Power BI deve trabalhar sobre um banco preparado para leitura analítica massiva.

Essa separação é o que transforma uma integração simples em uma solução realmente escalável e pronta para produção.