DEV Community: Alexandre Justen Filho

Database-per-tenant {Explicando Padrões de arquitetura de banco de dados multilocatários}

Alexandre Justen Filho — Fri, 03 Oct 2025 01:43:45 +0000

Arquiteturas de Banco de Dados para Multi-Tenancy

=================================================

Quando comecei a desenvolver a versão web de um sistema que já rodava localmente, me deparei com uma decisão estratégica: como estruturar o banco de dados para suportar vários clientes (multi-tenancy). Essa escolha não é apenas técnica; ela impacta escalabilidade, segurança, custos e até a forma como a equipe vai trabalhar no dia a dia.

Grosso modo, existem três modelos principais: desde o mais simples, onde todos compartilham as mesmas tabelas, até o mais isolado, com um banco dedicado para cada cliente.

Padrão 1 – Banco Único e Tabelas Compartilhadas

CREATE TABLE customers (
  id INT PRIMARY KEY,
  tenant_id INT NOT NULL,
  name VARCHAR(255),
  email VARCHAR(255),
  INDEX(tenant_id)
);

Nesse modelo, todos os clientes dividem as mesmas tabelas. O que diferencia os dados é uma coluna tenant_id. É o desenho mais direto e geralmente o primeiro que vem à mente.

Vantagens

Mais barato e simples de operar.
Backups, monitoramento e atualizações em um único ponto.
Mudanças de schema refletem em todos os clientes de uma vez.

Desvantagens

Qualquer descuido em queries pode vazar dados entre clientes.
Um cliente pesado pode afetar todos os outros.
Não dá muita flexibilidade de customização.

Padrão 2 – Banco Único, Schemas Separados

CREATE SCHEMA tenant1;
CREATE TABLE tenant1.customers (...);

CREATE SCHEMA tenant2;
CREATE TABLE tenant2.customers (...);

Aqui ainda temos um banco só, mas cada cliente fica em um schema separado. É algo que bancos como PostgreSQL e SQL Server oferecem nativamente.

Vantagens

Mais isolamento do que o modelo anterior.
Possibilita pequenas customizações por cliente.
Custos ainda controlados (um único banco físico).

Desvantagens

As migrações precisam ser replicadas em cada schema.
Com muitos clientes, o banco pode atingir limites de objetos.
Gerenciar backups/restores é mais trabalhoso.

Padrão 3 – Um Banco por Cliente

CREATE DATABASE tenant1;
CREATE DATABASE tenant2;

Esse é o modelo mais isolado: cada cliente tem sua própria base de dados, totalmente separada das demais.

Vantagens

Isolamento total (ideal para compliance e segurança).
Escalabilidade independente por cliente.
Facilidade em atender exigências regulatórias.

Desvantagens

Maior custo de operação e infraestrutura.
Migrações de schema são mais trabalhosas.
Exige automação para gerenciar conexões e atualizações.

Comparativo Rápido

Critério	Compartilhar Banco + Esquema	Compartilhar Banco + Schemas	Banco por Tenant
Suporte em SGDBs	Todos	PostgreSQL, SQL Server, etc.	Todos
Conformidade	Difícil	Possível com esforço extra	Mais simples
Complexidade	Baixa	Média/Alta	Alta
Customização	Limitada	Moderada	Total
Escalabilidade	Banco inteiro	Banco inteiro	Por cliente

Dicas para Migrações de Schema

Não importa o modelo que você escolha, mudar a estrutura do banco será sempre uma dor de cabeça se não houver disciplina.

Versione seus scripts no Git com numeração sequencial.
Automatize com CI/CD, rodando testes antes de aplicar.
Escreva scripts idempotentes (seguros para rodar mais de uma vez).
Aplique mudanças primeiro em staging e depois em subset de clientes.
Mantenha compatibilidade retroativa sempre que possível.
Use um catálogo centralizado para acompanhar versões de cada tenant.

Conclusão

Não existe receita única. O melhor modelo depende do seu estágio e das exigências do seu negócio.

Quer começar simples e barato? → Banco + Tabelas Compartilhadas
Precisa de isolamento e compliance? → Banco por Cliente
Busca um equilíbrio? → Banco único com Schemas separados

O mais importante é escolher algo que funcione bem hoje, mas com clareza de como migrar no futuro conforme sua base de clientes crescer.

Referências

Tianzhou 18 de março de 2025 – Multi-Tenant Database Architecture Patterns Explained
turso – Database Multi-Tenancy Made Easy

GitHub em 1 Clique: De Público para Privado em Segundos!🔒

Alexandre Justen Filho — Sat, 01 Feb 2025 02:26:12 +0000

Você já quis alterar rapidamente um repositório público para privado no GitHub sem precisar navegar pelas configurações? Este script em Node.js permite fazer isso diretamente pelo terminal, em apenas um clique!

Para contextualizar: fui contratado como professor de desenvolvimento de sistemas e, ao montar meus planos de aula, percebi que tinha muitos códigos e algoritmos no meu GitHub que seriam úteis durante as aulas. Como alguns alunos já estão me procurando nas redes sociais, percebi que deveria tornar meus repositórios importantes privados.

Quando comecei essa tarefa, achei que seria fácil, mas depois de 10 repositórios, ainda faltavam 53, kkkkk. Então, achei mais prudente resolver isso com um script simples, e foi isso que fiz.

Primeiro passo: Obter sua API token.

Acesse o link: https://github.com/settings/tokens

Você pode gerar um token, que será muito importante para termos acesso e modificar a visibilidade do repositório.

Você deve marcar a opção "repo".

Pronto! Agora que você tem a chave, vamos ao código:

const axios = require('axios');
const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

async function ask(query) {
  return new Promise(resolve => rl.question(query, resolve));
}

async function getRepositories(username, token) {
  try {
    const response = await axios.get(`https://api.github.com/users/${username}/repos`, {
      headers: { Authorization: `Bearer ${token}` }
    });

    return response.data.map(repo => repo.name);
  } catch (error) {
    console.error('Erro ao buscar repositórios');
    return [];
  }
}

async function visibility(username, token, repoName) {
  try {
    await axios.patch(`https://api.github.com/repos/${username}/${repoName}`, 
      { private: true }, 
      { headers: { Authorization: `Bearer ${token}` } }
    );
    console.log(`O repositório ${repoName} foi privado`);
  } catch (error) {
    console.error('Erro ao alterar visibilidade');
  }
}

async function main() {
  const username = await ask('Nome de usuário do GitHub: ');
  const token = await ask('Digite sua token: ');

  const repos = await getRepositories(username, token);

  if (repos.length === 0) {
    console.log('Nenhum repositório encontrado');
    rl.close();
    return;
  }

  repos.forEach((repo, index) => console.log(`${index + 1}. ${repo}`));

  const choice = await ask('\nDigite o número do repositório que deseja tornar privado: ');
  const selectedRepo = repos[parseInt(choice) - 1];

  if (selectedRepo) {
    await visibility(username, token, selectedRepo);
  } else {
    console.log('Escolha inválida.');
  }

  rl.close();
}

main();

Resumo do Fluxo do Código
O usuário fornece seu nome de usuário e token do GitHub.
O script faz uma requisição para listar os repositórios do usuário.
O script exibe os repositórios disponíveis e pede ao usuário para escolher um.
O script altera a visibilidade do repositório escolhido, tornando-o privado.
O script exibe uma mensagem de confirmação ou erro dependendo do resultado.
Esse código usa axios para fazer as requisições HTTP e readline para interação com o usuário, criando uma solução simples, mas eficaz, para alterar rapidamente a visibilidade de múltiplos repositórios no GitHub.

Se esse código foi útil para você, deixe um comentário ou curta! Muito obrigado por ler até aqui.

Transforme Seu Servidor Local em um Site Público com Ngrok

Alexandre Justen Filho — Thu, 31 Oct 2024 02:20:43 +0000

Quando desenvolvemos uma aplicação web localmente e queremos compartilhá-la para testes ou demonstrações, encontramos uma barreira comum: a aplicação só está acessível em nossa rede local. É aqui que entra o ngrok!

O Que é Tunelamento?

O tunelamento permite expor um servidor local para a internet através de um canal seguro. Isso é especialmente útil em ambientes de desenvolvimento, onde você deseja compartilhar seu servidor com clientes ou testá-lo em outros dispositivos sem ter que fazer o deploy completo.

Por Que Usar o Ngrok?

O ngrok é uma das ferramentas mais populares para tunelamento, e por boas razões:

Rápido e Fácil de Usar: Com apenas uma linha de comando, você pode criar um túnel para o seu servidor local.
Segurança: Cria uma conexão segura (HTTPS) automaticamente.
Flexível: Funciona com HTTP, HTTPS, TCP e até WebSockets.
Insights e Depuração: Permite monitorar e depurar requisições recebidas em tempo real.

Como Usar o Ngrok?

Baixe e Instale o Ngrok:

Acesse ngrok.com e baixe a versão adequada para o seu sistema.

Após o download, descompacte o arquivo e coloque o executável em uma pasta de fácil acesso.

Autenticação (opcional, mas recomendado):

Crie uma conta no ngrok e copie seu token de autenticação.
No terminal, execute:

ngrok authtoken SEU_TOKEN

Iniciando o Túnel:

Com o servidor da sua aplicação rodando (por exemplo, na porta 3000), inicie o túnel com o comando:

ngrok http 3000

Este comando cria um túnel HTTP e HTTPS para a porta 3000 do seu localhost. Você verá um endereço público no formato https://xxxx.ngrok.io que pode ser acessado de qualquer lugar.

Visualize e Depure o Tráfego:

Acesse http://localhost:4040 para ver informações detalhadas sobre cada requisição recebida, incluindo cabeçalhos, payload e status de resposta. Essa visualização é ótima para depurar APIs.

Encerrando o Túnel:

Para parar o ngrok, basta fechar o terminal ou pressionar Ctrl+C.

Exemplos de Uso do Ngrok

Testes de Webhooks: Ideal para desenvolver e testar webhooks de serviços externos como Stripe, PayPal e GitHub, sem precisar fazer o deploy do código.
Demonstrar Aplicações em Tempo Real: Compartilhe seu progresso com colegas ou clientes em uma aplicação em execução localmente.
Desenvolvimento de APIs: Teste e depure endpoints localmente antes de enviá-los para produção.

O ngrok é uma ferramenta indispensável para quem desenvolve aplicações web e precisa de acesso rápido, seguro e fácil a um servidor local a partir da internet. Com ele, o tunelamento se torna simples, ampliando as possibilidades de desenvolvimento e teste.

🐍Como Importar Dados do Excel para SQLite com Python em Poucas Linhas

Alexandre Justen Filho — Wed, 30 Oct 2024 22:13:11 +0000

Neste post, vou ensinar como transferir dados de uma planilha Excel diretamente para um banco de dados SQLite usando apenas algumas linhas de código em Python. Muito útil para quem precisa centralizar dados em um banco de dados, especialmente para uso em aplicações que fazem consultas frequentes, como dashboards ou ferramentas de análise!

Bibliotecas:

import pandas as pd
import sqlite3

Carregar o Arquivo Excel:

arquivo_excel = './teste.xlsx'
df = pd.read_excel(arquivo_excel)

Conectar ao Banco de Dados SQLite:

conexao = sqlite3.connect('database.db')

Exportar os Dados para o SQLite:

df.to_sql('tabela_excel', conexao, if_exists='replace', index=False)

Fechar a Conexão e Confirmação:

conexao.close()
print("Dados importados com sucesso!")

Dessa forma em poucas linhas de código temos a nossa tabela xlsx exportada para um banco SQLite!

Análise de Sulco de Pneus com Inteligência Artificial em Python!

Alexandre Justen Filho — Wed, 30 Oct 2024 21:16:09 +0000

A análise de sulcos de pneus é uma tarefa crucial para identificar o desgaste e garantir a segurança, especialmente em veículos que percorrem longas distâncias. Com o uso de Inteligência Artificial (IA) e Python, podemos automatizar esse processo de maneira rápida e precisa. Aqui, mostramos como um modelo de rede neural convolucional (CNN), baseado na arquitetura VGG16, classifica pneus em "novos" ou "usados", enquanto o OpenCV ajuda a analisar as imagens para medir a profundidade dos sulcos.

Tecnologias Usadas

Python:
Linguagem de programação popular para IA e Machine Learning, especialmente por suas bibliotecas avançadas.
OpenCV:
Usado para processar as imagens, detectar contornos e medir a área dos sulcos dos pneus.
TensorFlow e Keras:
Bibliotecas de aprendizado profundo. Utilizamos o Keras para trabalhar com o modelo VGG16, uma CNN pré-treinada para reconhecimento de imagens.
Matplotlib:
Biblioteca para visualização de dados e criação de gráficos, tornando os resultados da classificação mais interpretáveis.

Código:

1. Carregar e Pré-processar as Imagens:
As imagens dos pneus são carregadas e redimensionadas para um formato padrão (150x150 pixels) necessário para a entrada do modelo. Esse redimensionamento mantém a proporção e normaliza os valores dos pixels entre 0 e 1 para facilitar o processamento pelo modelo.

import cv2
import numpy as np
from tensorflow.keras.applications.vgg16 import preprocess_input

def process_image(image_path, target_size=(150, 150)):
    image = cv2.imread(image_path)
    if image is None:
        print(f"Erro ao carregar a imagem: {image_path}. Verifique o caminho e a integridade do arquivo.")
        return None, None

    image_resized = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)
    image_array = np.array(image_resized) / 255.0  
    image_array = np.expand_dims(image_array, axis=0)
    image_preprocessed = preprocess_input(image_array)

    return image_resized, image_preprocessed

2. Classificação com o Modelo Treinado:
Carregamos um modelo de rede neural convolucional pré-treinado, que foi ajustado para classificar pneus como "novos" ou "usados". Esse modelo fornece uma pontuação de confiança que indica a probabilidade de um pneu ser novo.

from tensorflow.keras.models import load_model

model = load_model('pneu_classificador.keras')
prediction = model.predict(image_preprocessed)

3. Análise dos Contornos para Profundidade de Sulco:
A detecção da profundidade do sulco é realizada com técnicas de visão computacional. A imagem em escala de cinza passa por um filtro de borrão e pela detecção de bordas com Canny, o que ajuda a identificar contornos dos sulcos. Em seguida, calculamos a área total dos contornos, o que nos permite estimar o desgaste.

def detect_tread_depth(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    edges = cv2.Canny(blurred, 30, 100)
    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    total_area = sum(cv2.contourArea(c) for c in contours if cv2.contourArea(c) > 100)
    return total_area

4. Visualização e Análise de Resultados:
Após a classificação e análise de cada pneu, os resultados são exibidos com Matplotlib. Comparamos a pontuação de confiança da classificação e a área dos sulcos detectada em cada imagem.

import matplotlib.pyplot as plt

confidence_scores = []
total_area_green_values = []
predicted_classes = []

for image_file in os.listdir(ver_dir):
    image_path = os.path.join(ver_dir, image_file)
    image_resized, image_preprocessed = process_image(image_path)
    if image_preprocessed is not None:
        prediction = model.predict(image_preprocessed)
        confidence_score = prediction[0][0]
        total_area_green = detect_tread_depth(image_resized)

        predicted_class = "novo" if total_area_green > 500 else "usado"
        confidence_scores.append(confidence_score)
        total_area_green_values.append(total_area_green)
        predicted_classes.append(predicted_class)

        plt.imshow(cv2.cvtColor(image_resized, cv2.COLOR_BGR2RGB))
        plt.title(f"Pneu {predicted_class} (Área: {total_area_green:.2f}, Confiança: {confidence_score:.2f})")
        plt.axis('off')
        plt.show()

fig, axs = plt.subplots(2, 1, figsize=(10, 10))

axs[0].bar(os.listdir(ver_dir), confidence_scores, color='skyblue')
axs[0].set_title('Confiança na Classificação')
axs[0].set_ylim(0, 1)
axs[0].tick_params(axis='x', rotation=45)

axs[1].bar(os.listdir(ver_dir), total_area_green_values, color='lightgreen')
axs[1].set_title('Área Verde Detectada')
axs[1].tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.show()

Esse meu projeto demonstra como é possível automatizar a análise do desgaste de pneus utilizando IA e visão computacional, resultando em uma classificação precisa e rápida. A arquitetura VGG16 e o uso de OpenCV são fundamentais para combinar a precisão do modelo de rede neural com a análise visual dos sulcos. Esse sistema pode ser expandido para monitoramento contínuo em frotas de veículos, ajudando a reduzir acidentes e otimizar o gerenciamento de pneus.