Recentemente, concluí meu mestrado em Engenharia de Software na Universidade Federal do Rio Grande do Norte (UFRN), focado exatamente nessa interseção entre privacidade, conformidade e arquitetura de sistemas distribuídos. O resultado dessa jornada foi muito além da academia: desenvolvemos uma solução tão disruptiva para o mercado que o componente central da pesquisa foi oficialmente patenteado.

Neste post, quero compartilhar a visão de mercado por trás desse projeto e como resolvemos um dos gargalos mais caros da governança de dados moderna.

O Gargalo: O Direito ao Esquecimento em Larga Escala

Para empresas que operam com sistemas legados ou arquiteturas modernas baseadas em microsserviços, o cumprimento do Direito ao Esquecimento (a exclusão definitiva dos dados a pedido do titular) é um pesadelo operacional.

Em estruturas complexas, os dados de um único cliente não estão centralizados. Eles estão espalhados por dezenas de bancos de dados relacionais e não-relacionais, filas de mensageria, data lakes e caches. Quando um usuário solicita a exclusão:

• O risco operacional aumenta: Como garantir, de forma auditável, que o dado foi apagado em todos os pontos sem causar inconsistências no sistema?
• O custo financeiro dispara: Interromper times de engenharia para criar soluções customizadas e manuais de exclusão a cada nova API é financeiramente insustentável.
• A segurança jurídica fica fragilizada: Sem uma orquestração automatizada, o risco de falha humana e sanções administrativas pesadas (como as multas da LGPD) permanece alto.

A Solução: Governança Nativa por Meio de Middleware

A tese central da pesquisa desenvolvida na UFRN, que agora se tornou propriedade intelectual protegida, parte do princípio do Privacy by Design. Em vez de forçar cada microsserviço ou equipe de desenvolvimento a criar sua própria lógica de exclusão e conformidade, centralizamos essa inteligência em uma camada agnóstica: um middleware de orquestração.

O componente patenteado funciona como um maestro invisível em sistemas distribuídos. Ele intercepta de forma segura as requisições de privacidade, mapeia as dependências de dados e garante que o fluxo de exclusão ocorra de forma resiliente, assíncrona e totalmente auditável — sem comprometer a performance, a escalabilidade ou a disponibilidade do ecossistema de software da empresa.

Para o negócio, isso significa:

1. Mitigação Absoluta de Risco: Processos automatizados e à prova de falhas, gerando relatórios de conformidade prontos para auditorias.
2. Eficiência de Engenharia: Os times de desenvolvimento voltam a focar nas regras de negócio e no produto, pois a governança de dados passa a ser uma engrenagem nativa da infraestrutura.
3. Valor de Mercado: Empresas que protegem a privacidade dos clientes com tecnologia proprietária e escalável aumentam drasticamente seu valuation e sua confiabilidade no mercado B2B e B2C.

O Próximo Capítulo: Ciência de Ponta com Impacto no Mercado

A conquista da patente e a conclusão do mestrado coroam um ciclo de validação rigorosa. Ela prova que a pesquisa científica de ponta realizada no Brasil, quando alinhada às dores reais do mercado corporativo, é capaz de gerar ativos de altíssimo valor.

Garantir a privacidade não precisa ser um freio para a inovação; pode ser o motor que posiciona sua infraestrutura tecnológica anos à frente da concorrência.

Gostaria de expressar meu profundo agradecimento à UFRN por toda a infraestrutura e suporte, e em especial ao meu orientador, Prof. Dr. Eiji Adachi Medeiros Barbosa, cuja orientação brilhante e visão estratégica foram fundamentais para transformar uma inquietação acadêmica em um componente tecnológico patenteado de impacto real. O futuro da engenharia de software é, obrigatoriamente, privado e seguro — e estamos prontos para ele.

O post Do Risco à Inovação: Como Transformamos a Conformidade à LGPD em Propriedade Intelectual Patenteada apareceu primeiro em Ramon Domingos Blog.

Post 1: O que é MCP e por que ele importa para o futuro dos agentes de IA?
Post 2: FastMCP: a forma mais rápida de criar servidores MCP em Python

Neste post vamos construir um servidor FastMCP real, do zero, que consulta endereços a partir de um CEP usando a API pública ViaCEP — sem chave de API, sem autenticação, pronto para usar.

Ao final, você vai conectar esse servidor ao Claude Desktop e perguntar diretamente ao Claude: “Qual o endereço do CEP 01310-100?” — e ele vai responder usando a sua tool.

Pré-requisitos

Antes de começar, certifique-se de ter:

• Python 3.10+ instalado
• pip atualizado
• Claude Desktop instalado (download aqui)
• Terminal (usaremos o Terminal do Mac)

Para verificar sua versão do Python:

python3 --version

python3 --version

1. Criando o ambiente do projeto

Abra o Terminal e crie uma pasta para o projeto:

mkdir mcp-cep-server
cd mcp-cep-server

mkdir mcp-cep-server
cd mcp-cep-server

Crie e ative um ambiente virtual:

python3 -m venv .venv
source .venv/bin/activate

python3 -m venv .venv
source .venv/bin/activate

Você verá o prefixo (.venv) no terminal — isso confirma que o ambiente está ativo.

Instale as dependências:

pip install fastmcp httpx

pip install fastmcp httpx

• fastmcp — o framework do servidor
• httpx — cliente HTTP moderno para consumir a API ViaCEP

Você irá ver os logs, com o sucesso da instalação.

2. Criando o servidor

Crie o arquivo principal do servidor:

touch server.py
# ou voce pode criar direto no vscode mesmo...

touch server.py
# ou voce pode criar direto no vscode mesmo...

Abra seu editor de código favorito e escreva o código:

import httpx
from fastmcp import FastMCP

mcp = FastMCP("servidor-cep")

@mcp.tool()
async def consultar_cep(cep: str) -> str:
    """
    Consulta o endereço completo a partir de um CEP brasileiro.
    Retorna rua, bairro, cidade e estado.
    """
    cep_limpo = cep.replace("-", "").replace(" ", "")

    if len(cep_limpo) != 8 or not cep_limpo.isdigit():
        return "CEP inválido. Informe um CEP com 8 dígitos numéricos."

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://viacep.com.br/ws/{cep_limpo}/json/"
        )

    if response.status_code != 200:
        return "Erro ao consultar o CEP. Tente novamente."

    dados = response.json()

    if "erro" in dados:
        return f"CEP {cep} não encontrado."

    return (
        f"CEP: {dados.get('cep', '-')}\n"
        f"Rua: {dados.get('logradouro', '-')}\n"
        f"Bairro: {dados.get('bairro', '-')}\n"
        f"Cidade: {dados.get('localidade', '-')}\n"
        f"Estado: {dados.get('uf', '-')}"
    )

if __name__ == "__main__":
    mcp.run()

import httpx
from fastmcp import FastMCP

mcp = FastMCP("servidor-cep")

@mcp.tool()
async def consultar_cep(cep: str) -> str:
    """
    Consulta o endereço completo a partir de um CEP brasileiro.
    Retorna rua, bairro, cidade e estado.
    """
    cep_limpo = cep.replace("-", "").replace(" ", "")

    if len(cep_limpo) != 8 or not cep_limpo.isdigit():
        return "CEP inválido. Informe um CEP com 8 dígitos numéricos."

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://viacep.com.br/ws/{cep_limpo}/json/"
        )

    if response.status_code != 200:
        return "Erro ao consultar o CEP. Tente novamente."

    dados = response.json()

    if "erro" in dados:
        return f"CEP {cep} não encontrado."

    return (
        f"CEP: {dados.get('cep', '-')}\n"
        f"Rua: {dados.get('logradouro', '-')}\n"
        f"Bairro: {dados.get('bairro', '-')}\n"
        f"Cidade: {dados.get('localidade', '-')}\n"
        f"Estado: {dados.get('uf', '-')}"
    )

if __name__ == "__main__":
    mcp.run()

O que esse código faz?

• Linha 4: instancia o servidor FastMCP com o nome "servidor-cep"
• Linha 6: decora a função com @mcp.tool() — o FastMCP registra automaticamente a tool no protocolo
• Linhas 7-10: a docstring vira a descrição da tool que o LLM vai ler para decidir quando usá-la
• Linhas 12-14: limpa o CEP removendo traços e espaços, e valida o formato
• Linhas 16-20: faz a requisição HTTP para a API ViaCEP de forma assíncrona
• Linhas 22-30: trata erros e formata a resposta

3. Testando o servidor localmente

Antes de conectar ao Claude Desktop, vamos garantir que o servidor está funcionando. O FastMCP tem um modo de inspeção embutido:

fastmcp dev inspector  server.py

fastmcp dev inspector  server.py

Esse comando sobe o servidor e abre o MCP Inspector no navegador, uma interface visual onde você pode chamar suas tools manualmente.

No Inspector:

1. Clique em “Tools” no menu lateral
2. Selecione “consultar_cep”
3. Preencha o campo cep com 01310-100
4. Clique em “Run”

Você deve ver a resposta:

4. Conectando ao Claude Desktop

Agora vamos conectar o servidor ao Claude Desktop para que o Claude possa usar a tool diretamente nas conversas.

4.1 Localize o arquivo de configuração

O Claude Desktop usa um arquivo JSON para registrar servidores MCP. No Mac, ele fica em:

~/Library/Application Support/Claude/claude_desktop_config.json  

~/Library/Application Support/Claude/claude_desktop_config.json  

Abra o Terminal e edite o arquivo:

open -a TextEdit ~/Library/Application\ Support/Claude/claude_desktop_config.json

open -a TextEdit ~/Library/Application\ Support/Claude/claude_desktop_config.json

Se o arquivo não existir, crie-o com o comando:

mkdir -p ~/Library/Application\ Support/Claude
touch ~/Library/Application\ Support/Claude/claude_desktop_config.json

mkdir -p ~/Library/Application\ Support/Claude
touch ~/Library/Application\ Support/Claude/claude_desktop_config.json

4.2 Adicione o servidor

Cole o seguinte conteúdo no arquivo, ajustando o caminho para o seu projeto:

{
  "mcpServers": {
    "servidor-cep": {
      "command": "/caminho/para/seu/projeto/mcp-cep-server/.venv/bin/python",
      "args": [
        "/caminho/para/seu/projeto/mcp-cep-server/server.py"
      ]
    }
  }
}

{
  "mcpServers": {
    "servidor-cep": {
      "command": "/caminho/para/seu/projeto/mcp-cep-server/.venv/bin/python",
      "args": [
        "/caminho/para/seu/projeto/mcp-cep-server/server.py"
      ]
    }
  }
}

Para descobrir o caminho correto do Python no seu ambiente virtual, rode:

which python

which python

4.3 Reinicie o Claude Desktop

Feche e abra o Claude Desktop novamente. Após reiniciar, você verá um ícone de conectore na interface de chat — isso indica que tools MCP estão disponíveis.

5. Testando no Claude Desktop

Com tudo configurado, abra uma nova conversa no Claude Desktop e pergunte:

“Qual o endereço do CEP 01310-100?”

O Claude vai identificar que tem uma tool disponível para isso, vai chamá-la automaticamente e retornar a resposta formatada.

Você também pode testar casos de erro:

“Consulta o CEP 00000-000 pra mim”

E o Claude vai retornar a mensagem de CEP não encontrado — exatamente como programamos.

Conclusão

Em menos de 40 linhas de Python, criamos um servidor MCP real que:

• Expõe uma tool funcional via protocolo MCP
• Consome uma API externa de forma assíncrona
• Valida entradas e trata erros
• Está conectado ao Claude Desktop e pronto para uso

Isso é o poder do MCP na prática: você escreve a lógica, o protocolo cuida da comunicação, e o LLM sabe exatamente quando e como usar sua tool.

Próximos passos

A partir daqui, as possibilidades são muitas:

• Adicionar mais tools ao mesmo servidor (ex: consulta de CNPJ, cotação de moeda)
• Criar Resources para expor dados estáticos ou dinâmicos
• Fazer deploy do servidor em modo SSE para acesso remoto
• Publicar seu servidor no ecossistema MCP para que outros usem

A série não para por aqui — fique ligado nos próximos posts.

Conseguiu rodar? Compartilha um print nos comentários! Tem alguma dúvida? Me chama.

O post Criando seu primeiro servidor FastMCP do zero apareceu primeiro em Ramon Domingos Blog.

Agora vamos dar um passo à frente: conhecer o FastMCP, a biblioteca Python que torna a criação de servidores MCP algo surpreendentemente simples — e entender por que ela existe.

O SDK oficial do MCP

A Anthropic disponibilizou um SDK oficial em Python para criar servidores MCP. Ele funciona, é completo e segue o protocolo à risca. Mas tem um problema: é verboso.

Para criar um servidor com uma única tool usando o SDK oficial, você escreve algo assim:

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types
import asyncio

server = Server("meu-servidor")

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="somar",
            description="Soma dois números",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number"},
                    "b": {"type": "number"}
                },
                "required": ["a", "b"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "somar":
        return [types.TextContent(
            type="text",
            text=str(arguments["a"] + arguments["b"])
        )]

async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write, server.create_initialization_options())

asyncio.run(main())

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types
import asyncio

server = Server("meu-servidor")

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="somar",
            description="Soma dois números",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number"},
                    "b": {"type": "number"}
                },
                "required": ["a", "b"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "somar":
        return [types.TextContent(
            type="text",
            text=str(arguments["a"] + arguments["b"])
        )]

async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write, server.create_initialization_options())

asyncio.run(main())

Funciona. Mas são mais de 30 linhas para uma operação trivial. Imagine isso escalando para 10, 20 tools.

O que é o FastMCP?

O FastMCP é uma biblioteca Python de alto nível construída sobre o SDK oficial do MCP. A inspiração é clara no nome: assim como o FastAPI simplificou a criação de APIs REST em Python, o FastMCP simplifica a criação de servidores MCP.

O mesmo servidor acima, com FastMCP:

from fastmcp import FastMCP

mcp = FastMCP("meu-servidor")

@mcp.tool()
def somar(a: float, b: float) -> float:
    """Soma dois números"""
    return a + b

from fastmcp import FastMCP

mcp = FastMCP("meu-servidor")

@mcp.tool()
def somar(a: float, b: float) -> float:
    """Soma dois números"""
    return a + b

4 linhas. Mesmo resultado. Mesmo protocolo. Mesma compatibilidade.

O FastMCP cuida de toda a camada de serialização, validação de schema, registro de tools e comunicação via JSON-RPC — você foca apenas na lógica.

Por que FastMCP e não o SDK puro?

	SDK Oficial	FastMCP
Linhas para 1 tool	~30	~4
Tipagem automática		via type hints
Validação de schema	Manual	Automática
Curva de aprendizado	Alta	Baixa
Compatibilidade MCP
Ideal para	Controle total	Produtividade

A escolha não é binária — para casos que exigem controle fino do protocolo, o SDK oficial ainda faz sentido. Mas para a grande maioria dos projetos, o FastMCP é a escolha certa.

Arquitetura de um servidor FastMCP

Um servidor FastMCP é composto pelos mesmos três conceitos do protocolo MCP:

Tools

Funções Python decoradas com @mcp.tool(). O FastMCP lê os type hints e a docstring automaticamente para gerar o schema JSON da tool.

@mcp.tool()
def buscar_usuario(user_id: int) -> str:
    """Busca um usuário pelo ID"""
    # sua lógica aqui
    return f"Usuário {user_id}"

@mcp.tool()
def buscar_usuario(user_id: int) -> str:
    """Busca um usuário pelo ID"""
    # sua lógica aqui
    return f"Usuário {user_id}"

Resources

Fontes de dados expostas via URI, decoradas com @mcp.resource().

@mcp.resource("dados://config")
def get_config() -> str:
    """Retorna a configuração atual"""
    return "versão: 1.0"

@mcp.resource("dados://config")
def get_config() -> str:
    """Retorna a configuração atual"""
    return "versão: 1.0"

Prompts

Templates reutilizáveis decorados com @mcp.prompt().

@mcp.prompt()
def resumir(texto: str) -> str:
    """Prompt para resumir um texto"""
    return f"Resuma o seguinte texto em 3 bullets:\n\n{texto}"

@mcp.prompt()
def resumir(texto: str) -> str:
    """Prompt para resumir um texto"""
    return f"Resuma o seguinte texto em 3 bullets:\n\n{texto}"

Instalação e configuração do ambiente

O FastMCP requer Python 3.10+. A instalação é simples:

# Com pip
pip install fastmcp

# Com uv (recomendado)
uv add fastmcp

# Com pip
pip install fastmcp

# Com uv (recomendado)
uv add fastmcp

Por que uv? O uv é um gerenciador de pacotes e ambientes Python extremamente rápido, escrito em Rust. É a ferramenta recomendada pelo ecossistema MCP para gerenciar dependências. Se ainda não usa, vale a pena conhecer.

Para verificar a instalação:

python -c "import fastmcp; print(fastmcp.__version__)"

python -c "import fastmcp; print(fastmcp.__version__)"

A estrutura mínima de um servidor FastMCP

Todo servidor FastMCP segue esta estrutura base:

from fastmcp import FastMCP

# 1. Instancia o servidor com um nome
mcp = FastMCP("nome-do-servidor")

# 2. Define tools, resources e prompts
@mcp.tool()
def minha_tool(parametro: str) -> str:
    """Descrição da tool — o LLM vai ler isso"""
    return f"Resultado: {parametro}"

# 3. Ponto de entrada
if __name__ == "__main__":
    mcp.run()

from fastmcp import FastMCP

# 1. Instancia o servidor com um nome
mcp = FastMCP("nome-do-servidor")

# 2. Define tools, resources e prompts
@mcp.tool()
def minha_tool(parametro: str) -> str:
    """Descrição da tool — o LLM vai ler isso"""
    return f"Resultado: {parametro}"

# 3. Ponto de entrada
if __name__ == "__main__":
    mcp.run()

Três partes: instância, definição e execução. Simples assim.

No próximo post, vamos pegar exatamente essa estrutura e transformar em um servidor funcional, rodando localmente e conectado a um cliente MCP real.

O FastMCP remove a fricção entre a ideia e a implementação. Com ele, você não precisa conhecer os detalhes do protocolo JSON-RPC, nem gerenciar manualmente schemas e serialização — tudo isso é abstraído de forma elegante.

Se o MCP é a “tomada universal” dos agentes de IA, o FastMCP é o cabo que torna tudo mais fácil de conectar.

No próximo post, vamos colocar a mão na massa: criar um servidor FastMCP do zero, definir tools reais, rodar localmente e conectar ao Claude Desktop para ver tudo funcionando.

Está acompanhando a série? Deixa um comentário ou compartilha com alguém que trabalha com IA!

O post FastMCP: a forma mais rápida de criar servidores MCP em Python apareceu primeiro em Ramon Domingos Blog.

Neste post, vamos entender o que é o MCP, por que ele foi criado, qual problema ele resolve e por que você, desenvolvedor, deveria prestar atenção nele agora.

O problema que o MCP resolve

Imagine que você quer construir um agente de IA capaz de:

• Consultar um banco de dados
• Ler arquivos do seu sistema
• Chamar uma API externa
• Executar código

Antes do MCP, cada integração era feita de forma ad hoc. Cada LLM tinha sua própria forma de lidar com ferramentas externas. O OpenAI tinha o function calling, o LangChain tinha seus tools, o LlamaIndex tinha seus query engines… e assim por diante.

O resultado? Fragmentação total. Uma ferramenta construída para funcionar com GPT-4 não funcionava nativamente com Claude. Um servidor de contexto construído para LangChain não era reaproveitável em outro framework.

Era como se cada fabricante de eletrônicos usasse um tipo diferente de tomada — e você precisasse de um adaptador diferente para cada aparelho.

O que é o MCP?

O Model Context Protocol é um protocolo aberto, criado pela Anthropic e lançado em novembro de 2024, que define uma forma padronizada de conectar modelos de linguagem a fontes de dados e ferramentas externas.

Em termos simples: o MCP é uma interface universal entre LLMs e o mundo externo.

Ele define como:

• Um cliente (ex: Claude Desktop, um agente, uma IDE) se comunica com
• Um servidor MCP (ex: um serviço que acessa seu banco de dados, seu sistema de arquivos, uma API)

Essa separação é poderosa. O servidor MCP não sabe — e não precisa saber — qual LLM está do outro lado. E o cliente não precisa saber como o servidor foi implementado.

A arquitetura do MCP

O protocolo é baseado em três conceitos centrais:

Tools (Ferramentas)

São funções que o LLM pode invocar. Exemplos: buscar um registro no banco, enviar um e-mail, executar um script.

Resources (Recursos)

São fontes de dados que o LLM pode ler. Exemplos: um arquivo de texto, um endpoint REST, um documento PDF.

Prompts

São templates de prompt reutilizáveis que o servidor pode expor para o cliente. Útil para padronizar interações complexas.

A comunicação entre cliente e servidor acontece via JSON-RPC 2.0, podendo usar diferentes transportes: stdio (processo local) ou SSE (HTTP, para servidores remotos).

Tools Funções que o LLM pode invocar ex: buscar DB, enviar e-mail Resources Fontes de dados que o LLM pode ler ex: arquivos, APIs, PDFs Prompts Templates reutilizáveis expostos pelo servidor ex: padrões de interação Banco de Dados APIs Externas Sistema de Arquivos Fontes reais de dados O servidor não sabe qual LLM está do outro lado — e o cliente não sabe como o servidor foi implementado. Imagem gerada com auxilio de IA.

Por que isso é importante?

O MCP resolve um problema clássico de engenharia de software: acoplamento. Antes dele, sua lógica de integração estava amarrada ao framework ou ao modelo que você escolhia. Com o MCP, você desacopla completamente o como conectar do o que conectar.

Isso traz benefícios concretos:

• Reusabilidade — Um servidor MCP pode ser usado por qualquer cliente compatível
• Interoperabilidade — Funciona com Claude, com agentes customizados, com IDEs como Cursor e VS Code
• Ecossistema crescente — Empresas como Cloudflare, Stripe, GitHub e Notion já publicaram servidores MCP oficiais
• Padronização — Menos reinvenção de roda, mais foco no que realmente importa

MCP na prática: onde ele já está sendo usado?

Hoje, o MCP já é suportado nativamente por:

• Claude Desktop (Anthropic)
• Cursor e Windsurf (IDEs com IA)
• VS Code (via extensões)
• Amazon Bedrock e Google Gemini (suporte em expansão)

E o número de servidores MCP públicos cresce diariamente. Existe até um repositório comunitário chamado mcp.so que cataloga centenas deles.

O MCP não é apenas mais um padrão técnico. Ele representa uma mudança de paradigma na forma como construímos sistemas com IA: saindo de integrações frágeis e acopladas para uma arquitetura modular, interoperável e escalável.

Se você quer construir agentes de IA sérios — seja para uso pessoal, para sua empresa ou para o mercado — entender o MCP é essencial.

No próximo post, vamos conhecer o FastMCP, a biblioteca Python que torna a criação de servidores MCP algo surpreendentemente simples e elegante.

Gostou do post? Deixa um comentário e volta no blog nos próximos dias para ler os próximos post da série!

O post O que é MCP e por que ele importa para o futuro dos agentes de IA? apareceu primeiro em Ramon Domingos Blog.

Se você me perguntasse há alguns meses como eu estava, a resposta técnica seria, processamento em 100% de CPU, com vazamento de memória constante, pod em CrashLoopBackOff, race conditions , deadlocks  e resource exhaustion; Mas a resposta humana é mais profunda. Olhar para a ata de defesa assinada não foi apenas o recebimento de um título; foi o momento em que o silêncio finalmente venceu o barulho mental de anos de cobrança.

A Síndrome do Impostor: O Bug no Sistema

No mundo técnico, somos treinados para ter respostas. No mestrado, a primeira lição é aceitar que não sabemos quase nada. E é aí que a Síndrome do Impostor se instala.

Em muitas noites, enquanto eu revisava o capítulo de teoria sobre Middleware, processamento distribuído, uma voz no fundo da mente dizia: “Em algum momento, a banca vai perceber que eu não sou tão bom quanto pareço, passar na seleção foi pura sorte”.

A verdade que aprendi é que a síndrome do impostor não é um erro de sistema; ela é uma consequência de estar na fronteira do conhecimento. Se você sente que não sabe tudo, é porque finalmente chegou onde ninguém mais pisou exatamente do seu jeito. O título não cura a síndrome, mas te ensina que você é capaz de entregar resultados mesmo quando não se sente um “expert”.

Atalhos que são, na verdade, Labirintos – DICA PARA QUEM TA COMEÇANDO NA PESQUISA!

Para quem está entrando agora no mestrado ou começando uma pesquisa, o instinto de desenvolvedor, o de otimizar processos, pode ser perigoso. No mestrado, atalhos raramente funcionam.

RETIRE SEU CHAPEUZINHO DE DEV E BOTE O DE PESQUISADOR.

• O atalho da leitura rápida: Tentar escrever sua fundamentação sem ler os artigos clássicos a fundo é como construir um sistema em cima de uma biblioteca que você não entende. Mais cedo ou mais tarde, o código quebra e você terá que refazer tudo do zero.
• Confie no processo: O seu orientador(a) ja fez isso várias vezes, ele/a sabe a ordem dos passos, se perder faz parte do processo, uma hora voce encontra o seu caminho.
• O atalho da “Ferramenta da Moda”: Não escolha um método ou tecnologia só porque ela está no topo do Hype Cycle. Se a ferramenta não resolve o seu problema científico, ela é apenas ruído acumulado no seu cronograma.
• O atalho do isolamento: Achar que pesquisar é um ato solitário é o erro mais comum. O mestrado é um esporte de equipe. O tempo que você economiza não falando com seu orientador ou com seus pares, você perde dando voltas em problemas que uma conversa de 15 minutos resolveria.

Conselhos de quem “sobreviveu” ao Quilômetro Zero

Se você está começando hoje, aqui estão três coisas que eu gostaria de ter ouvido logo no primeiro dia:

1. Documente seus “Erros”: No desenvolvimento, amamos logs. Na pesquisa, o resultado que deu errado também é ciência. Anote por que aquela abordagem não funcionou. Isso vale ouro na hora de escrever a conclusão.
2. Defina seu MVP (Minimum Viable Thesis): O mestrado não é para resolver todos os problemas do mundo, mas para resolver UM problema com profundidade. Foque no coração da sua contribuição e deixe a perfumaria para o doutorado.
3. Saúde Mental é Infraestrutura: Se o seu hardware (você) pifar, o software (a tese) não roda. Reserve janelas de tempo onde a tese não existe. Se puder, faça terapia, isso me ajudou muito. Normalmente, sua vida não irá parar para você fazer seu mestrado, problemas pessoais, familiares, e do trabalho irão continuar acontecendo, e irão concorrer com esse novo projeto.

Conclusão: A Realização é um Processo

A sensação de realização não veio na assinatura da ata, mas na percepção de que hoje sou capaz de encarar um problema complexo e sem resposta sem entrar em pânico. O mestrado me deu o título de Mestre, mas a jornada me deu a resiliência de quem sabe que, para debugar a vida, é preciso paciência e muitas iterações.

Obrigado por me acompanharem nesta jornada técnica (e agora pessoal). Se você está no meio desse furacão chamado mestrado, saiba que o “deployment” final vale cada linha de esforço.

E eu acho que já estou com saudades da UFRN….

O post Além do Código e dos Dados: O que o Mestrado me ensinou sobre a Vida (e sobre mim) apareceu primeiro em Ramon Domingos Blog.

A Base: O Que Acontece Quando Você Salva Dados?

Imagine que você está usando um aplicativo bancário para transferir dinheiro. Quando você clica em “confirmar”, o sistema precisa registrar essa transação. Na maioria das vezes, essa informação é escrita em um banco de dados primário. Tudo simples até aqui, certo?

Entendendo o Dual Write

O Dual Write (escrita dupla, em tradução livre) é exatamente o que o nome sugere: o processo de escrever os mesmos dados em dois sistemas de armazenamento de dados diferentes, de forma simultânea ou quase simultânea.

Pense no nosso exemplo do aplicativo bancário. Se, além do banco de dados principal do banco, a informação da sua transação também fosse registrada ao mesmo tempo em um sistema de relatórios ou em um data warehouse para análise de dados. Isso seria um cenário de Dual Write.

Por Que Usamos Dual Write?

Existem várias razões pelas quais um engenheiro de software escolheria implementar o Dual Write. As mais comuns incluem:

• Sincronização de Dados em Tempo Real: Em muitos cenários, precisamos que as informações estejam atualizadas em múltiplos sistemas imediatamente. Por exemplo, se uma venda é feita no sistema de e-commerce, o estoque no sistema de gerenciamento de armazém precisa ser atualizado instantaneamente. O Dual Write garante que ambos os sistemas recebam a informação ao mesmo tempo.
• Redundância e Recuperação de Desastres: Ao escrever dados em dois lugares, você cria uma cópia de segurança. Se um sistema falhar, o outro ainda tem os dados, o que ajuda na recuperação e garante a continuidade do negócio.
• Integração de Sistemas Distintos: Às vezes, diferentes departamentos usam sistemas diferentes que precisam da mesma informação. Em vez de construir integrações complexas que puxam e empurram dados de um lado para o outro, o Dual Write pode ser uma solução mais direta para manter ambos atualizados.
• Desempenho Otimizado: Em alguns casos, um sistema pode ser otimizado para transações rápidas (por exemplo, um banco de dados de pedidos), enquanto outro é otimizado para análises complexas (um data warehouse). O Dual Write permite que cada sistema use os dados da forma mais eficiente para sua finalidade.

Os Desafios do Dual Write

Apesar de seus benefícios, o Dual Write não é uma bala de prata e apresenta seus próprios desafios:

• Consistência dos Dados: O maior desafio é garantir que os dados sejam exatamente os mesmos em ambos os sistemas. O que acontece se uma escrita em um sistema falha e no outro não? É preciso ter mecanismos robustos para lidar com essas falhas e garantir a consistência.
• Complexidade na Implementação: Gerenciar duas escritas simultâneas, lidar com erros, retentativas e garantir a ordem correta das operações pode tornar a arquitetura do sistema mais complexa.
• Desempenho: Embora possa otimizar o desempenho para propósitos específicos, o Dual Write adiciona uma sobrecarga, pois cada operação de escrita precisa ser realizada duas vezes. Isso pode impactar a latência, especialmente se os sistemas estiverem geograficamente distantes.
• Tratamento de Conflitos: Se ambos os sistemas permitirem escritas independentes, pode haver conflitos que precisam ser resolvidos de forma inteligente para evitar dados inconsistentes.

Alternativas ao Dual Write

É importante mencionar que o Dual Write não é a única forma de sincronizar dados. Existem outras abordagens, como:

• Event-Driven Architecture (Arquitetura Orientada a Eventos): Onde um sistema publica um “evento” (ex: “pedido criado”) e outros sistemas interessados escutam e reagem a esse evento, atualizando seus próprios dados. Isso é geralmente mais robusto e escalável para cenários complexos.
• ETL (Extract, Transform, Load): Processos que extraem dados de uma fonte, os transformam e os carregam em um destino. Isso geralmente acontece em lotes e é mais comum para data warehouses ou sistemas de relatórios onde a latência de tempo real não é crítica.

O Dual Write é uma técnica valiosa no arsenal de um engenheiro de software para manter sistemas em sincronia. Embora ofereça benefícios significativos em termos de sincronização em tempo real e redundância, é crucial entender seus desafios e considerar se é a melhor abordagem para um determinado problema. A escolha da estratégia de sincronização de dados depende das necessidades específicas do negócio, da tolerância a falhas e dos requisitos de desempenho.

Espero que esta explicação tenha desmistificado o Dual Write para vocês! Se tiverem alguma dúvida ou quiserem compartilhar suas experiências, deixem um comentário.

O post O Que é Dual Write? Escrevendo Dados em Dois Lugares ao Mesmo Tempo apareceu primeiro em Ramon Domingos Blog.

Meu Tema: Adaptando-se à LGPD com Middleware em Sistemas Distribuídos

Minha pesquisa, intitulada “Adaptação à LGPD: Proposta de Middleware para a Implementação do Direito ao Esquecimento em Sistemas Distribuídos“, mergulha em um desafio crescente para muitas empresas: como garantir o direito ao esquecimento de dados, exigido pela LGPD, em sistemas modernos baseados em microsserviços?

Para quem não está familiarizado, sistemas de microsserviços são complexos, com dados espalhados e gerenciados de forma independente. Isso torna a exclusão consistente e confiável de dados uma tarefa manual e suscetível a erros, com grandes ramificações legais se não for bem executada.

É aí que entra a minha proposta! Desenvolvi uma solução de middleware automatizada, utilizando o padrão two-phase commit (2PC), para orquestrar a exclusão de dados de forma consistente e segura nesses ambientes distribuídos. Além disso, criei uma biblioteca que pode ser facilmente importada em códigos existentes, simplificando a vida dos desenvolvedores e facilitando a adesão às regulamentações. Em minhas 118 páginas de trabalho, detalho a arquitetura e avalio o desempenho dessa abordagem, demonstrando sua eficácia para um problema que hoje é repleto de complexidade manual.

Em resumo, o objetivo é oferecer uma solução robusta e escalável que capacite as organizações a gerenciar efetivamente a exclusão de dados em ambientes de microsserviços, promovendo maior confiança e adesão às regulamentações de proteção de dados.

Quem é próximo a mim, sabe que eu, mesmo fazendo um trabalho bom, fico diversas vezes inseguro; Em relação a essa apresentação não poderia ser diferente; Quando eu vi meu nome no site da UFRN, com a data da defesa (link), começou o nervosismo, o medo de não responder adequadamente alguma pergunta, mesmo estando imerso no tema por 2 anos.

Minha dica pra quem chegou nesse momento:

Os professores estão ali para contribuir como seu trabalho, para ele ficar mais maduro;

Seu orientador JAMAIS iria deixar você levar algo que não esteja suficiente para aquele momento;

Este é um passo gigante e sou imensamente grato a todos que me apoiaram nessa jornada. A energia agora se renova para os próximos desafios até a defesa final!

O post Qualificado! Minha Jornada e os Desafios da LGPD em Microsserviços apareceu primeiro em Ramon Domingos Blog.

Se você notou um silêncio maior do que o normal por aqui, tem uma boa razão para isso: estou imerso na escrita da minha tese de mestrado! Como muitos de vocês que trabalham com TI e buscam aprofundar seus conhecimentos, sei que a jornada acadêmica exige uma dedicação enorme.

Conciliar as horas de pesquisa, escrita e revisão com a rotina de um blog de TI e o meu trabalho, é, sem dúvida, um desafio. Confesso que tem sido uma verdadeira maratona, mas estou aprendendo muito no processo – tanto sobre o tema da minha tese quanto sobre gerenciamento de tempo e prioridades!

Ainda não quero detalhar muito sobre o assunto da tese, mas em breve, espero trazer alguns insights e, quem sabe, até um post mais aprofundado sobre a minha pesquisa. Por enquanto, a prioridade máxima é entregar um trabalho de qualidade.

Agradeço a compreensão de todos vocês e prometo que, assim que tiver um fôlego, voltarei com conteúdo novo e interessante. Enquanto isso, continuem explorando os posts antigos e deixando seus comentários!

Em breve, mais novidades!

Um abraço,

O post Conciliando a Tese e o Blog: Um Desafio da Vida de TI! apareceu primeiro em Ramon Domingos Blog.

É aí que entram os Trace IDs (IDs de rastreamento)!

Um Trace ID é um identificador único gerado para cada requisição que entra na sua aplicação. Esse ID é propagado por todos os serviços e componentes envolvidos no processamento daquela requisição, permitindo que você correlacione logs e métricas de diferentes partes do sistema.

Por que usar Trace IDs no seu FastAPI?

• Debugging Facilitado: Rastreie o fluxo completo de uma requisição, desde o ponto de entrada até a resposta final, identificando exatamente onde ocorreu um erro ou lentidão.
• Análise de Performance: Visualize o tempo gasto em cada etapa do processamento, identificando gargalos e áreas para otimização.
• Observabilidade Aprimorada: Integre com ferramentas de logging e monitoramento (como ELK Stack, Grafana Loki, Datadog) para ter uma visão centralizada do comportamento da sua aplicação.
• Microserviços: Essencial em arquiteturas de microsserviços para entender a interação entre diferentes serviços em uma única requisição.

Como implementar Trace IDs no FastAPI?

Existem algumas maneiras de implementar Trace IDs no seu FastAPI:

1. Middleware Personalizado:

Você pode criar um middleware personalizado para gerar um Trace ID para cada requisição e adicioná-lo aos headers da requisição e/ou ao contexto da aplicação.

from fastapi import FastAPI, Request, Response
from uuid import uuid4
import logging

app = FastAPI()
logger = logging.getLogger(__name__)

TRACE_ID_HEADER = "X-Request-ID"

@app.middleware("http")
async def add_trace_id(request: Request, call_next):
    trace_id = request.headers.get(TRACE_ID_HEADER) or str(uuid4())
    request.state.trace_id = trace_id
    response: Response = await call_next(request)
    response.headers[TRACE_ID_HEADER] = trace_id
    logger.info(f"Request: {request.method} {request.url} - Trace ID: {trace_id}")
    return response

@app.get("/")
async def read_root(request: Request):
    trace_id = request.state.trace_id
    logger.info(f"Processing root endpoint - Trace ID: {trace_id}")
    return {"Hello": "World", "trace_id": trace_id}

Explicação:

• O middleware add_trace_id é executado para cada requisição HTTP.
• Ele tenta obter um Trace ID do header X-Request-ID (uma prática comum). Se não existir, gera um novo UUID.
• O Trace ID é armazenado no request.state para ser acessado em outras partes da sua aplicação.
• O Trace ID também é adicionado como um header na resposta.
• Você pode incluir o Trace ID nos seus logs para facilitar o rastreamento.

2. Utilizando Bibliotecas de Observabilidade:

Bibliotecas como Opentracing ou Opentelemetry oferecem soluções mais completas para tracing distribuído, incluindo a geração e propagação de Trace IDs, além de integração com diversas ferramentas de observabilidade.

Exemplo com Opentelemetry (simplificado):

from fastapi import FastAPI, Request
from opentelemetry import trace
from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator

app = FastAPI()
propagator = TraceContextTextMapPropagator()
tracer = trace.get_tracer(__name__)

@app.middleware("http")
async def trace_request(request: Request, call_next):
    carrier = {}
    for k, v in request.headers.items():
        carrier[k] = v
    context = propagator.extract(carrier)
    with tracer.start_as_current_span(f"{request.method} {request.url.path}", context=context) as span:
        span.set_attribute("http.method", request.method)
        span.set_attribute("http.url", str(request.url))
        response = await call_next(request)
        span.set_attribute("http.status_code", response.status_code)
        return response

@app.get("/")
async def read_root():
    current_span = trace.get_current_span()
    current_span.set_attribute("greeting", "Hello World")
    return {"Hello": "World"}

Considerações Importantes:

• Propagação: Em arquiteturas com múltiplos serviços, é crucial garantir que o Trace ID seja propagado corretamente entre as chamadas HTTP. Isso geralmente envolve passar o Trace ID em headers HTTP.
• Logging: Configure sua solução de logging para incluir o Trace ID em cada log, permitindo a correlação de eventos relacionados à mesma requisição.
• Ferramentas de Observabilidade: Integre sua aplicação com ferramentas de observabilidade para visualizar os traces, analisar a performance e identificar problemas de forma mais intuitiva.

Implementar Trace IDs no seu FastAPI é um investimento valioso que melhora significativamente a capacidade de entender, depurar e otimizar sua aplicação, especialmente em cenários mais complexos. Comece com um middleware simples e explore bibliotecas de observabilidade para uma solução mais robusta!

O post Rastreando Requisições no FastAPI com Trace IDs: Desvendando o Fluxo da sua Aplicação! 🕵️‍♂️ apareceu primeiro em Ramon Domingos Blog.

Recentemente consegui minha certificação Individual do Google Analytics , e no início da jornada de estudo me perguntei, isso é para o pessoal de Marketing ou para desenvolvedor? Mas ao final, entendi que todo mundo precisa entender um pouco de analytics. Fazer sua aplicação gerar dados é fundamental, para identificar insights de todos os aspectos da aplicação. No fundo, ser guiados por dados é mais importante do que seguir seu sentimento. E ter um google analytcs bem configurado, promoverá esses dados para toda equipe.

Já pararam para pensar na importância de entender como seus projetos são utilizados? Enquanto o pessoal de marketing se concentra em analisar os dados para criar estratégias, os desenvolvedores têm um papel fundamental em garantir que os dados coletados sejam precisos e completos. Neste post, vamos explorar por que o Google Analytics é uma ferramenta importante para desenvolvedores coletar esses dados, nesse post especialmente iremos aplicar o GA numa aplicação Next.js, mas facilmente é adaptável para outras aplicações, Te guiarei passo a passo na instalação e configuração do funil de vendas. Identificando desde o início da sessão, a primeira visita ao site, até efetuar a compra no checkout. Podendo assim, identificar a porcentagem de abandono de carrinhos, por exemplo.

Por que os Desenvolvedores Devem Entender o Google Analytics?

• Otimização de Desempenho: Ao acompanhar métricas como tempo de carregamento de página, taxa de rejeição e erros, os desenvolvedores podem identificar gargalos e implementar melhorias para otimizar a experiência do usuário.
• Qualidade do Código: Analisando eventos e interações do usuário, é possível identificar bugs e problemas de usabilidade que podem passar despercebidos em testes.
• Validação de Hipóteses: Ao desenvolver novas funcionalidades, o Google Analytics permite validar se as mudanças estão tendo o impacto esperado nos usuários.
• Integração com Outras Ferramentas: O Google Analytics pode ser integrado com outras ferramentas de desenvolvimento, como ferramentas de monitoramento de desempenho e sistemas de versionamento, proporcionando uma visão mais completa do ciclo de vida do software.

Instalando o Google Analytics com Funil de Vendas em um Aplicação Next.js

• Criar uma Conta no Google Analytics: Se você ainda não tem uma conta, acesse o Google Analytics e crie uma nova propriedade para o seu site. (Provavelmente o marketing da empresa ja possuirá )
• Obter o Código de Rastreamento: Após criar a propriedade, você receberá um código de rastreamento único.
• Instalar o Pacote do Google Analytics: No seu projeto Next.js, instale o pacote oficial do Google Analytics.

 npm install @google/analytics

• Configurar o Rastreamento: Crie um componente customizado para envolver o seu aplicativo e enviar os dados para o Google Analytics.

const GoogleAnalytics = () => {
return (<>
/* 1. Initialize the Google tag and gtag.js library */
   <!-- Google tag (gtag.js) -->
   <script async src="https://www.googletagmanager.com/gtag/js?id=TAG_ID"></script>
   <script>
     window.dataLayer = window.dataLayer || [];
     function gtag(){dataLayer.push(arguments)};
     gtag('js', new Date());
     gtag('config', 'TAG_ID');
   </script>
   </>
   )
   
export { GoogleAnalytics };

• Use esse componente no layout principal da sua aplicação.

import { GoogleAnalytics } from "seu_componente_google-analytics";
export default function RootLayout({
  children,
}: Readonly<{
  children: React.ReactNode;
}>) {
  return (
    <html>
      <body>
        {children}
        <GoogleAnalytics />
      </body>
    </html>
  );
}

Eventos principais

Para criar um funil de vendas, você precisa mapear alguns eventos:

1. Início da sessão (o número de usuários que acionaram o evento  session_start)
2. Ver produto (o número de usuários que acionaram o evento  view_item)
3. Adicionar ao carrinho (o número de usuários que acionaram o evento add_to_cart)
4. Iniciar checkout (o número de usuários que acionaram o evento begin_checkout)
5. Compra (o número de usuários que acionaram o evento purchase ou in_app_purchase)

Nos links de cada evento tem o formato de dados que devem ser enviados junto do evento, alguns não precisa enviar nada além do titulo do evento. É muito importante enviar exatamente os campos necessários, dados faltando, ou em excesso irá fazer com que o evento seja descartado.

Para fazer o envio, basicamente será necessário usa a função, gtag. Aconselho criar uma função mais generalista e reutilizar em todos os lugares, pois será importante caso precise debugar, adicionar o debug_mode:true, em cada envio.)

 window.gtag("event", event,eventParams ) 

Exemplo para adicionar um ou mais item ao carrinho:

gtag("event", "add_to_cart", {
  currency: "BRL",
  value: 9.99,
  items: [
    {
      item_id: "SKU_12345",
      item_name: "Stan and Friends Tee",
      index: 0,
      price: 9.99,
      quantity: 1
    }
  ]
});

Exemplo de purchase:

gtag("event", "purchase", {
    transaction_id: "T_12345",
    value: 25.42,
    tax: 4.90,
    shipping: 5.99,
    currency: "USD",
    coupon: "SUMMER_SALE",
    items: [
     {
      item_id: "SKU_12345",
      item_name: "Stan and Friends Tee",
      affiliation: "Google Merchandise Store",
      coupon: "SUMMER_FUN",
      discount: 2.22,
      index: 0,
      item_brand: "Google",
      item_category: "Apparel",
      item_category2: "Adult",
      item_category3: "Shirts",
      item_category4: "Crew",
      item_category5: "Short sleeve",
      item_list_id: "related_products",
      item_list_name: "Related Products",
      item_variant: "green",
      location_id: "ChIJIQBpAG2ahYAR_6128GcTUEo",
      price: 9.99,
      quantity: 1
    },
    {
      item_id: "SKU_12346",
      item_name: "Google Grey Women's Tee",
      affiliation: "Google Merchandise Store",
      coupon: "SUMMER_FUN",
      discount: 3.33,
      index: 1,
      item_brand: "Google",
      item_category: "Apparel",
      item_category2: "Adult",
      item_category3: "Shirts",
      item_category4: "Crew",
      item_category5: "Short sleeve",
      item_list_id: "related_products",
      item_list_name: "Related Products",
      item_variant: "gray",
      location_id: "ChIJIQBpAG2ahYAR_6128GcTUEo",
      price: 20.99,
      promotion_id: "P_12345",
      promotion_name: "Summer Sale",
      quantity: 1
    }]
});

Visualizando o funil de vendas. Em Relatório > Monetization/sales/vendas > Purchase Journey. Ficará algo parecido com isso:

Debug view

Os dados do GA podem demorar ate 24h para surgirem nos relatório. Para você acompanhar em tempo real os eventos chegando, voce pode adicionar o modo debug,

 window.gtag("event", event,{ ...eventParams, debug_mode: true});

(lembra que falei de criar uma função e reutilizar?)

Em admin > Data Display > Debug view. Você irá acompanhar em tempo real todos os eventos.

Eventos que possuem parâmetros, como items ficará assim:

Você pode estranhar o preço. Mas nesse link do StackOverflow, encontrei esse reposta:

Isso não é um problema em relatórios reais e só aparece no DebugView.

Internamente, o valor é multiplicado por 1000000 para que possa ser armazenado como um inteiro para economizar espaço. A ferramenta de depuração falha em convertê-lo de volta, mas relatórios reais parecem acertar.

Dominar o Google Analytics é uma habilidade fundamental para qualquer desenvolvedor que busca criar produtos digitais de sucesso. Ao entender como os usuários interagem com seus aplicativos, você pode tomar decisões mais informadas e entregar experiências cada vez melhores.

Dicas Extras:

• Personalização: Explore as opções de personalização do Google Analytics para criar relatórios personalizados e segmentar seus dados.
• Integrações: Descubra as diversas integrações do Google Analytics com outras ferramentas para obter uma visão mais completa dos seus dados.
• Aprendizado Contínuo: O Google Analytics está em constante evolução. Mantenha-se atualizado sobre as novas funcionalidades e recursos.

E aí, gostou deste guia? Compartilhe suas experiências nos comentários e me diga quais outras ferramentas você utiliza para analisar seus projetos.

O post Desenvolvedores precisam Dominar o Google Analytics? Um Guia Prático com Next.js apareceu primeiro em Ramon Domingos Blog.