<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Mateus Oliveira on Medium]]></title>
        <description><![CDATA[Stories by Mateus Oliveira on Medium]]></description>
        <link>https://medium.com/@mateus-oliveira?source=rss-7fca70243d3f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*0e9JBEKM9wtE4WRyWEzmlw.png</url>
            <title>Stories by Mateus Oliveira on Medium</title>
            <link>https://medium.com/@mateus-oliveira?source=rss-7fca70243d3f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 05:49:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mateus-oliveira/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Data Lineage: Rastreando Dados de Ponta a Ponta]]></title>
            <link>https://mateus-oliveira.medium.com/data-lineage-rastreando-dados-de-ponta-a-ponta-7e8d16350e38?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e8d16350e38</guid>
            <category><![CDATA[data-streaming]]></category>
            <category><![CDATA[data-governance]]></category>
            <category><![CDATA[data-lineage]]></category>
            <category><![CDATA[kafka]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 21:01:09 GMT</pubDate>
            <atom:updated>2026-03-31T21:01:09.150Z</atom:updated>
            <content:encoded><![CDATA[<p>Como implementar rastreabilidade completa em pipelines de streaming para governança, compliance e confiança nos dados</p><p>Em arquiteturas modernas de streaming com Apache Kafka, dados fluem por dezenas de serviços, transformações e destinos. Diante dessa complexidade, toda organização orientada a dados precisa responder a uma pergunta fundamental: <strong>“De onde vieram esses dados e por onde passaram?”</strong></p><p>Imagine o seguinte cenário: um relatório regulatório do Banco Central apresenta valores inconsistentes. O time de compliance precisa identificar, em minutos, quais sistemas geraram aquele dado, quais transformações foram aplicadas e se houve alguma anomalia no caminho. Sem <strong>data lineage</strong>, esse processo pode levar dias. Com lineage, leva minutos.</p><p>Segundo o Gartner, até 2025, organizações que implementam data lineage ativo reduzem em <strong>60% o tempo de análise de impacto</strong> em mudanças de dados [1]. Em arquiteturas de streaming, onde dados fluem em tempo real por dezenas de topics e serviços, a rastreabilidade não é um luxo — é uma necessidade.</p><p><strong>Neste artigo, você vai aprender:</strong></p><ul><li>O que é Data Lineage e por que é crítico para governança</li><li>Os diferentes níveis de lineage: coluna, tabela e pipeline</li><li>Como lineage funciona em arquiteturas de streaming com Kafka</li><li>Ferramentas: OpenLineage, Confluent Stream Lineage, Apache Atlas e Marquez</li><li>Exemplos práticos de rastreabilidade em pipelines financeiros</li><li>Aspectos de compliance com LGPD e GDPR</li></ul><h3>O que é Data Lineage?</h3><p><strong>Data lineage</strong> (linhagem de dados) é o rastreamento completo do ciclo de vida de um dado — desde sua origem, passando por todas as transformações, até seu destino final. É o “mapa genealógico” dos seus dados.</p><p>Em termos práticos, lineage responde a três perguntas fundamentais:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FHrKMi%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FHrKMi%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FHrKMi%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="237" frameborder="0" scrolling="no"><a href="https://medium.com/media/94206048077fd218f6cc4be3b6695ed0/href">https://medium.com/media/94206048077fd218f6cc4be3b6695ed0/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rfyDcMJdBqzWWhCIU6h8Sw.png" /><figcaption><em>Fluxo de Data Lineage — da origem (sistemas transacionais) passando por Kafka topics e processamento até destinos</em></figcaption></figure><h3>Níveis de Granularidade</h3><p>Data lineage opera em diferentes níveis de profundidade, cada um atendendo a necessidades distintas:</p><p><strong>1. Pipeline-level lineage</strong> — visão macro dos sistemas e fluxos:</p><p>Sistema Core Banking → topic.transacoes.raw → Flink Job → topic.transacoes.enriquecidas → Data Lake</p><p>Útil para análise de impacto e planejamento de capacidade. Responde “quais sistemas participam desse fluxo?”</p><p><strong>2. Table/Topic-level lineage</strong> — relacionamento entre datasets:</p><p>topic.clientes + topic.transacoes → JOIN no Flink → topic.transacoes.enriquecidas → tabela BigQuery</p><p>Essencial para entender dependências entre equipes e domínios. Responde “quais topics alimentam esse dataset?”</p><p><strong>3. Column-level lineage</strong> — rastreamento campo a campo:</p><p>transacoes.valor_bruto — transacoes.taxa_iof = transacoes_enriquecidas.valor_liquido</p><p>O nível mais granular. Crítico para compliance regulatório (LGPD/GDPR) e auditoria. Responde “como esse campo específico foi calculado?”</p><h3>Lineage em Arquiteturas de Streaming</h3><p>Em arquiteturas batch tradicionais, lineage é relativamente simples: jobs têm entrada e saída bem definidas, executam em horários programados. Em <strong>streaming</strong>, o desafio é maior:</p><ul><li><strong>Dados fluem continuamente</strong> — não há “execução” com início e fim claros</li><li><strong>Múltiplos consumidores</strong> — um topic pode alimentar dezenas de serviços</li><li><strong>Transformações em cadeia</strong> — um evento passa por vários stages de processamento</li><li><strong>Estado distribuído</strong> — joins, agregações e janelas de tempo adicionam complexidade</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*isd6K9CBNWHzmzkhZLk0mA.png" /><figcaption><em>Lineage de um pipeline bancário — do core banking até relatórios regulatórios do BACEN, passando por enriquecimento, detecção de fraude e agregação.</em></figcaption></figure><h3>Propagando Lineage com CloudEvents via Kafka Headers</h3><p>Uma abordagem eficaz para manter lineage em streaming é adotar o padrão <strong>CloudEvents</strong> [8] nos headers das mensagens Kafka. O CloudEvents é uma especificação da CNCF que define um formato comum para descrever eventos, garantindo interoperabilidade entre sistemas. Seu <strong>Kafka Protocol Binding</strong> [9] mapeia os atributos do CloudEvents diretamente para Kafka headers com o prefixo ce_.</p><p>O mecanismo funciona assim: cada mensagem Kafka carrega, além do payload (valor), um conjunto de headers com metadados padronizados. Quando um serviço consome e republica um evento, ele <strong>preserva os atributos de origem</strong> (como ce_source e ce_id) e <strong>adiciona informações do processamento atual</strong> via extension attributes.</p><p><strong>Exemplo prático</strong> — uma transação PIX passando pelo pipeline:</p><pre>Mensagem Kafka no topic &quot;banking.transacoes.raw&quot;:<br><br>  Headers:<br>    ce_specversion  = &quot;1.0&quot;<br>    ce_id           = &quot;a1b2c3d4-e5f6-7890-abcd-ef1234567890&quot;<br>    ce_source       = &quot;//core-banking-v3/schema_public/transacoes&quot;<br>    ce_type         = &quot;br.com.intelium.banking.transacao.criada&quot;<br>    ce_time         = &quot;2026-02-19T10:30:00.000Z&quot;<br>    ce_subject      = &quot;TXN-2026-001&quot;<br>    ce_lineagestage = &quot;ingestao&quot;<br><br>  Payload (value):<br>    {&quot;transacao_id&quot;: &quot;TXN-2026-001&quot;, &quot;tipo&quot;: &quot;PIX&quot;, &quot;valor&quot;: 1500.00, ...}</pre><p>Após processamento pelo serviço de enriquecimento, a mensagem é republicada no topic de saída com o lineage propagado:</p><pre>Mensagem Kafka no topic &quot;banking.transacoes.enriquecidas&quot;:<br><br>  Headers:<br>    ce_specversion           = &quot;1.0&quot;<br>    ce_id                    = &quot;f9e8d7c6-b5a4-3210-fedc-ba9876543210&quot;  (novo ID)<br>    ce_source                = &quot;//flink/enriquecimento-transacoes&quot;<br>    ce_type                  = &quot;br.com.intelium.banking.transacao.enriquecida&quot;<br>    ce_time                  = &quot;2026-02-19T10:30:00.150Z&quot;<br>    ce_subject               = &quot;TXN-2026-001&quot;  (preservado)<br>    ce_lineagestage          = &quot;enriquecimento&quot;<br>    ce_lineagetransformation = &quot;adicao_risco_e_categoria&quot;<br>    ce_lineageorigin         = &quot;//core-banking-v3/schema_public/transacoes&quot;  (preservado)<br>    ce_lineagechain          = &quot;//core-banking-v3/... -&gt; //flink/enriquecimento-transacoes&quot;<br><br>  Payload (value):<br>    {&quot;transacao_id&quot;: &quot;TXN-2026-001&quot;, &quot;tipo&quot;: &quot;PIX&quot;, &quot;valor&quot;: 1500.00,<br>     &quot;risco_score&quot;: 0.12, &quot;categoria&quot;: &quot;baixo_risco&quot;, ...}</pre><p>Os atributos CloudEvents mapeados para Kafka headers seguem a convenção do protocol binding:</p><iframe src="https://cdn.embedly.com/widgets/media.html?url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FigWIz%2F1%2F&amp;type=text%2Fhtml&amp;schema=dwcdn&amp;display_name=Datawrapper&amp;src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FigWIz%2F1%2F" width="600" height="603" frameborder="0" scrolling="no"><a href="https://medium.com/media/0fa2252586208f82e4b7a532a0c22f9a/href">https://medium.com/media/0fa2252586208f82e4b7a532a0c22f9a/href</a></iframe><p>A regra fundamental é: <strong>atributos obrigatórios do CloudEvents são gerados novos a cada stage</strong> (novo ce_id, novo ce_source, novo ce_time), enquanto <strong>extension attributes de lineage são preservados ou acumulados</strong> para manter a rastreabilidade fim-a-fim.</p><h3>Registrando Lineage com OpenLineage</h3><p>O <strong>OpenLineage</strong> é um padrão aberto (projeto da Linux Foundation) para coleta de metadados de lineage [2]. Ele define um modelo comum baseado em três conceitos:</p><ul><li><strong>Job</strong> — qualquer processo que transforma dados (um Flink job, um DAG do Airflow, um consumer Kafka)</li><li><strong>Dataset</strong> — entrada ou saída de um job (um topic Kafka, uma tabela BigQuery, um bucket S3)</li><li><strong>Run</strong> — uma execução específica de um job, com timestamps de início/fim e status</li></ul><p>Cada execução de um job emite um <strong>evento OpenLineage</strong> (via HTTP para um backend como Marquez) que registra quais datasets foram lidos, quais foram escritos e quais transformações foram aplicadas. Isso constrói automaticamente o grafo de lineage.</p><p>Na prática, ferramentas como <strong>Spark</strong>, <strong>Airflow</strong> e <strong>dbt</strong> já possuem integrações OpenLineage nativas — basta habilitar o listener/plugin. Para pipelines Kafka customizados, a instrumentação pode ser feita via o SDK OpenLineage no código do consumer/producer, ou de forma centralizada com o <strong>Confluent Stream Lineage</strong> (que captura lineage automaticamente sem instrumentação).</p><h3>Ferramentas de Data Lineage</h3><p>O ecossistema de lineage evoluiu significativamente nos últimos anos. Vamos comparar as principais ferramentas para ambientes Kafka/streaming:</p><h3>Confluent Stream Lineage</h3><p>O <strong>Stream Lineage</strong> é a solução nativa da Confluent Cloud para rastreabilidade em tempo real [3]. Integrado ao Stream Governance, ele captura automaticamente o fluxo de dados entre topics, schemas, connectors e Flink jobs.</p><p><strong>Vantagens:</strong> — Captura <strong>automática</strong> — não requer instrumentação manual — Visualização em tempo real do fluxo de dados — Integração nativa com Schema Registry, Connect e Flink — Column-level lineage para queries Flink SQL</p><p><strong>Limitação:</strong> exclusivo para Confluent Cloud; não funciona com Kafka open source.</p><h3>Apache Atlas</h3><p>O <strong>Apache Atlas</strong> é o projeto de governança do ecossistema Hadoop/Apache, com suporte a lineage para Kafka, Hive, Spark e outros [4]. É open source e amplamente utilizado em organizações que operam ambientes on-premises.</p><p><strong>Vantagens:</strong> — Open source e extensível — Suporte a classificações e políticas de segurança — Integração com Apache Ranger para controle de acesso</p><p><strong>Limitação:</strong> complexidade de deploy e manutenção; UI menos intuitiva.</p><h3>Marquez + OpenLineage</h3><p>O <strong>Marquez</strong> é o backend de referência para o padrão OpenLineage [5]. Fornece API REST, UI para visualização de lineage e armazenamento de metadados. Combinado com OpenLineage, permite coletar lineage de qualquer ferramenta que implemente o padrão.</p><p><strong>Vantagens:</strong> — Padrão aberto e vendor-neutral — Suporte a Spark, Airflow, dbt, Flink — API REST bem documentada — Comunidade ativa (Linux Foundation)</p><p><strong>Limitação:</strong> requer instrumentação manual ou uso de integrações existentes.</p><h3>Comparação</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fv0wzM%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fv0wzM%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fv0wzM%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="387" frameborder="0" scrolling="no"><a href="https://medium.com/media/438c9ae4d6908a0a869a24a86238e326/href">https://medium.com/media/438c9ae4d6908a0a869a24a86238e326/href</a></iframe><h3>Lineage e Compliance: LGPD e GDPR</h3><p>Em setores regulados como o financeiro, data lineage deixa de ser uma “boa prática” e se torna uma <strong>obrigação legal</strong>. Tanto a LGPD (Brasil) quanto a GDPR (Europa) exigem capacidades que dependem diretamente de lineage [6][7]:</p><h3>Direito ao Esquecimento (Art. 18, LGPD)</h3><p>Quando um titular solicita a exclusão de seus dados pessoais, a organização precisa identificar <strong>todos os locais</strong> onde esses dados existem. Sem lineage, isso é um exercício de adivinhação.</p><pre>Solicitação LGPD: &quot;Excluir dados do CPF 123.456.789-00&quot;<br><br>Com lineage, o sistema identifica automaticamente:<br>├── topic: banking.clientes.raw (campo: cpf)<br>├── topic: banking.transacoes.enriquecidas (campo: cpf_titular)<br>├── tabela: bigquery.analytics.transacoes_diarias (campo: documento)<br>├── tabela: bigquery.compliance.relatorios_bacen (campo: cpf) [RETENÇÃO LEGAL]<br>└── cache: redis.sessoes_ativas (campo: user_document)<br><br>Ação: excluir de todos, EXCETO onde há obrigação legal de retenção</pre><h3>Análise de Impacto (DPIA)</h3><p>A LGPD exige a elaboração de Relatório de Impacto à Proteção de Dados (RIPD) para tratamentos de alto risco. O lineage fornece automaticamente o mapeamento de quais dados pessoais são coletados, onde são armazenados e como são transformados.</p><h3>Rastreabilidade de Consentimento</h3><p>Com column-level lineage, é possível rastrear se um campo com dados sensíveis (PII) foi utilizado em pipelines que respeitam o consentimento do titular. Na prática, isso significa cruzar o grafo de lineage com as classificações do Data Catalog:</p><pre>Verificação de compliance para campo &quot;cpf&quot;:<br>banking.clientes.raw          → cpf [PII] [criptografado: ✅] [máscara: hash_sha256]<br>banking.transacoes.enriquecidas → cpf_titular [PII] [criptografado: ✅] [máscara: hash_sha256]<br>bigquery.analytics.dashboard  → documento [PII] [criptografado: ❌] [máscara: nenhuma]<br>⚠️ ALERTA: campo PII sem criptografia ou mascaramento!<br>bigquery.compliance.bacen     → cpf [PII] [criptografado: ✅] [retenção legal: 5 anos]</pre><p>Esse tipo de verificação pode ser automatizada: ferramentas como Confluent Stream Lineage e Marquez permitem criar <strong>políticas de compliance</strong> que disparam alertas quando um campo classificado como PII aparece em um dataset sem as proteções adequadas (criptografia, mascaramento ou tokenização).</p><h3>Boas Práticas</h3><h3>Faça</h3><ul><li><strong>Adote lineage desde o início</strong> — retrofitting lineage em pipelines existentes é exponencialmente mais caro do que implementar desde o design</li><li><strong>Use padrões abertos</strong> — OpenLineage garante interoperabilidade e evita vendor lock-in, mesmo quando usando Confluent Stream Lineage como complemento</li><li><strong>Adote CloudEvents nos headers Kafka</strong> — o padrão CNCF com o Kafka Protocol Binding (ce_* headers) garante interoperabilidade e permite propagar ce_id, ce_source e extensões de lineage por toda a cadeia de processamento</li><li><strong>Classifique campos PII no lineage</strong> — integre com tags de Data Catalog para identificar automaticamente campos sensíveis e suas propagações</li><li><strong>Automatize verificações de compliance</strong> — crie alertas automáticos quando campos PII aparecem em datasets sem criptografia ou mascaramento</li><li><strong>Monitore a completude do lineage</strong> — gaps no grafo de lineage são tão perigosos quanto gaps nos dados; implemente métricas de cobertura</li></ul><h3>Evite</h3><ul><li><strong>Lineage apenas em batch</strong> — em streaming, lineage precisa ser contínuo; não espere o “fim do job” para registrar</li><li><strong>Confiar em documentação manual</strong> — wikis e planilhas ficam desatualizadas; lineage deve ser capturado automaticamente ou via instrumentação no código</li><li><strong>Ignorar column-level lineage</strong> — pipeline-level é um bom começo, mas compliance regulatório exige rastreamento campo a campo</li><li><strong>Tratar lineage como projeto isolado</strong> — lineage é parte da governança; integre com Data Catalog, Data Contracts e controle de acesso</li><li><strong>Armazenar lineage apenas no produtor</strong> — o grafo de lineage deve ser centralizado (Marquez, Atlas ou Confluent) para consultas cross-pipeline</li></ul><h3>Conclusão</h3><p>Data lineage é o componente que transforma dados em ativos auditáveis e confiáveis. Em arquiteturas de streaming com Kafka, onde eventos fluem continuamente entre dezenas de serviços, a rastreabilidade é o que separa organizações que <strong>usam dados</strong> de organizações que <strong>confiam nos seus dados</strong>.</p><p>Principais aprendizados:</p><ol><li><strong>Data lineage rastreia a origem, transformações e destino dos dados</strong> — é o “DNA” do dado, permitindo backward e forward lineage</li><li><strong>Existem três níveis de granularidade</strong> — pipeline-level para visão macro, table-level para dependências e column-level para compliance</li><li><strong>Em streaming, lineage requer abordagens específicas</strong> — CloudEvents via Kafka headers (ce_*), eventos OpenLineage contínuos e captura automática</li><li><strong>Ferramentas maduras estão disponíveis</strong> — Confluent Stream Lineage para Cloud, Marquez/OpenLineage para ambientes abertos, Apache Atlas para ecossistemas Hadoop</li><li><strong>Compliance regulatório depende de lineage</strong> — LGPD e GDPR exigem rastreabilidade de dados pessoais que só é viável com column-level lineage automatizado</li><li><strong>Lineage não é um projeto isolado</strong> — é parte integral da governança, conectando Data Contracts, Data Catalog e controle de acesso em um ecossistema coeso</li></ol><h3>Recursos</h3><ul><li><a href="https://cloudevents.io/">CloudEvents Specification</a> — especificação CNCF para formato padronizado de eventos</li><li><a href="https://openlineage.io/docs/">OpenLineage — Documentação Oficial</a> — especificação do padrão aberto de lineage</li><li><a href="https://docs.confluent.io/cloud/current/stream-governance/stream-lineage.html">Confluent Stream Lineage</a> — documentação do lineage nativo da Confluent Cloud</li><li><a href="https://github.com/MarquezProject/marquez">Marquez — GitHub</a> — backend de referência para OpenLineage</li><li><a href="https://atlas.apache.org/">Apache Atlas</a> — governança e lineage open source do ecossistema Apache</li><li><a href="https://www.planalto.gov.br/ccivil_03/_ato2015-2018/2018/lei/l13709.htm">LGPD — Lei 13.709/2018</a> — texto completo da Lei Geral de Proteção de Dados</li></ul><h3>Referências</h3><p>[1] Gartner, “Data Management Solutions for Analytics”, 2024. Disponível em: <a href="https://www.gartner.com/reviews/market/data-management-solutions-for-analytics">https://www.gartner.com/reviews/market/data-management-solutions-for-analytics</a></p><p>[2] OpenLineage Project, “OpenLineage Specification v1.0”, Linux Foundation, 2024. Disponível em: <a href="https://openlineage.io/spec/">https://openlineage.io/spec/</a></p><p>[3] Confluent, “Stream Lineage — Confluent Cloud Documentation”, 2025. Disponível em: <a href="https://docs.confluent.io/cloud/current/stream-governance/stream-lineage.html">https://docs.confluent.io/cloud/current/stream-governance/stream-lineage.html</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e8d16350e38" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data Catalog: Descoberta e Documentação de Dados em Streaming]]></title>
            <link>https://mateus-oliveira.medium.com/data-catalog-descoberta-e-documenta%C3%A7%C3%A3o-de-dados-em-streaming-521bae75c45b?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/521bae75c45b</guid>
            <category><![CDATA[data-governance]]></category>
            <category><![CDATA[data-streaming]]></category>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[data-catalog]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 20:59:34 GMT</pubDate>
            <atom:updated>2026-04-01T00:07:43.773Z</atom:updated>
            <content:encoded><![CDATA[<p>Como catalogar, documentar e descobrir dados em arquiteturas Kafka para acelerar desenvolvimento e garantir governança</p><p>Schemas e contratos garantem qualidade nos dados do Apache Kafka. Mas em organizações com dezenas de topics Kafka, surge uma pergunta fundamental: <strong>“Onde estão os dados que preciso?”</strong></p><p>Segundo pesquisas, desenvolvedores gastam até <strong>30% do tempo procurando dados</strong> [1]. Em arquiteturas de streaming, esse problema se multiplica: topics com nomes crípticos, schemas sem documentação, e nenhuma visibilidade sobre quem produz ou consome cada dado.</p><p>A solução está no <strong>Data Catalog</strong> — um repositório centralizado de metadados que permite descobrir, entender e acessar dados de forma self-service [2]. Como Reis e Housley destacam em <em>Fundamentals of Data Engineering</em>, “metadata é o dado sobre os dados — sem ele, os dados são apenas bytes sem contexto” [3].</p><p><strong>Neste artigo, você vai aprender:</strong></p><ul><li>O que é um Data Catalog e por que é essencial para streaming</li><li>Tipos de metadados: técnico, de negócio e operacional</li><li>Confluent Stream Catalog e Data Portal</li><li>Lenses.io Data Catalog</li><li>OpenMetadata para Kafka</li><li>Comparação entre as três soluções</li><li>Como implementar um catálogo de dados efetivo</li><li>Melhores práticas para catalogação de streams</li></ul><h3>O Problema: Dados Invisíveis</h3><p>Em uma arquitetura Kafka típica, os dados são <strong>invisíveis</strong> para quem não os criou:</p><pre>Desenvolvedor: &quot;Preciso de dados de pedidos para minha feature&quot;<br><br>Processo sem Data Catalog:<br>1. Perguntar no Slack → &quot;Alguém sabe onde estão os dados de pedidos?&quot;<br>2. Esperar resposta → 2 horas (se tiver sorte)<br>3. Receber nome do topic → &quot;orders-v2&quot; ou &quot;vendas_pedidos&quot;?<br>4. Descobrir o schema → Onde está documentado?<br>5. Entender semântica → O que significa &quot;status = 3&quot;?<br>6. Pedir acesso → Quem aprova?<br>7. Validar dados → São confiáveis? Estão atualizados?<br><br>Tempo total: 1-2 dias (se não desistir antes)</pre><p>Com um Data Catalog:</p><pre>Desenvolvedor: &quot;Preciso de dados de pedidos&quot;<br><br>Processo com Data Catalog:<br>1. Buscar &quot;pedidos&quot; no catálogo<br>2. Ver resultados com descrição, owner, schema<br>3. Explorar sample data (mascarado)<br>4. Solicitar acesso via workflow<br>5. Começar a desenvolver<br><br>Tempo total: 15 minutos</pre><h3>O Que é um Data Catalog?</h3><p>Um <strong>Data Catalog</strong> é um inventário pesquisável de ativos de dados, enriquecido com contexto de negócio [4]. Segundo Zhamak Dehghani em <em>Data Mesh</em>, um catálogo de dados efetivo deve tratar dados como <strong>produtos</strong>, onde cada ativo possui “documentação de produto, informações de contato do time responsável, e métricas de qualidade” [5].</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u1U7YTixPKYHkS3_mQL3MA.png" /><figcaption>Arquitetura Data Catalog</figcaption></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FvLD1u%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FvLD1u%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FvLD1u%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="364" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f6eda80424871c406e6c595743704c1/href">https://medium.com/media/0f6eda80424871c406e6c595743704c1/href</a></iframe><h3>Tipos de Metadados</h3><p>Para um Data Catalog ser útil, ele precisa capturar três tipos de metadados [6]. Martin Kleppmann, em <em>Designing Data-Intensive Applications</em>, enfatiza que “sem um entendimento compartilhado do significado dos dados, é impossível construir sistemas confiáveis” [7]:</p><h4>1. Metadados Técnicos</h4><p>Estrutura e características técnicas dos dados:</p><pre># Metadados técnicos de um topic Kafka<br>topic:<br>  name: vendas.pedidos.criado.v1<br>  partitions: 12<br>  replication_factor: 3<br>  retention_ms: 604800000  # 7 dias<br>  cleanup_policy: delete<br><br>schema:<br>  type: Avro<br>  subject: vendas.pedidos.criado.v1-value<br>  version: 3<br>  compatibility: BACKWARD_TRANSITIVE<br>  fields:<br>    - name: pedido_id<br>      type: string<br>      doc: &quot;UUID único do pedido&quot;<br>    - name: total<br>      type: bytes<br>      logical_type: decimal<br>      precision: 15<br>      scale: 2<br>    - name: created_at<br>      type: long<br>      logical_type: timestamp-millis</pre><h4>2. Metadados de Negócio</h4><p>Contexto e significado para usuários de negócio:</p><pre># Metadados de negócio<br>business:<br>  display_name: &quot;Pedido Criado&quot;<br>  description: |<br>    Evento emitido quando um pedido é finalizado no checkout.<br>    Contém informações do pedido, cliente e itens comprados.<br><br>  domain: Vendas<br>  subdomain: Checkout<br><br>  owner:<br>    team: Squad Checkout<br>    contact: checkout@empresa.com<br>    slack: &quot;#squad-checkout&quot;<br><br>  tier: Tier1  # Business-critical<br><br>  glossary_terms:<br>    - Pedido<br>    - Checkout<br>    - E-commerce<br><br>  tags:<br>    - PII.CustomerID<br>    - LGPD.PersonalData<br>    - Revenue.Transaction</pre><h4>3. Metadados Operacionais</h4><p>Informações sobre uso e performance:</p><pre># Metadados operacionais<br>operational:<br>  created_at: 2024-03-15T10:30:00Z<br>  last_modified: 2025-01-15T14:22:00Z<br><br>  throughput:<br>    messages_per_second: 5200<br>    bytes_per_second: 2.4MB<br><br>  consumers:<br>    - name: fraud-detection<br>      lag: 0<br>      status: healthy<br>    - name: analytics-pipeline<br>      lag: 12400<br>      status: warning<br><br>  quality:<br>    completeness: 99.98%<br>    freshness: 2s<br>    last_quality_check: 2025-01-20T08:00:00Z<br><br>  usage:<br>    queries_last_30d: 1547<br>    unique_users: 23<br>    most_accessed_fields: [pedido_id, total, cliente_id]</pre><h3>Confluent Stream Catalog</h3><p>O <strong>Stream Catalog</strong> é o Data Catalog nativo do Confluent Cloud, integrado ao Stream Governance [8]:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FsMTUy%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FsMTUy%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FsMTUy%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="298" frameborder="0" scrolling="no"><a href="https://medium.com/media/5d06a1c22f19c1af57c102ff72a28d8f/href">https://medium.com/media/5d06a1c22f19c1af57c102ff72a28d8f/href</a></iframe><h4>Busca no Stream Catalog</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*afEiNGy1KuN2ty_A_a-uKA.png" /><figcaption><em>Interface de busca do Stream Catalog</em></figcaption></figure><p>Ao buscar “pedido” no catálogo, o resultado inclui 3 topics relacionados (com domain, owner e tier) e 5 campos de schema que correspondem ao termo. O desenvolvedor pode clicar em qualquer resultado para ver detalhes completos.</p><h4>Configurando Tags</h4><pre># CLI: Adicionar tag PII a um campo<br>confluent schema-registry tag create \<br>  --subject vendas.pedidos.criado.v1-value \<br>  --version latest \<br>  --field cliente_id \<br>  --tag PII.CustomerID<br><br># CLI: Adicionar business metadata<br>confluent schema-registry business-metadata create \<br>  --subject vendas.pedidos.criado.v1-value \<br>  --name Domain \<br>  --attributes &#39;{&quot;name&quot;: &quot;Vendas&quot;, &quot;team_owner&quot;: &quot;Squad Checkout&quot;, &quot;slack&quot;: &quot;#checkout&quot;}&#39;</pre><h4>API REST</h4><pre>import requests<br><br># Buscar topics com tag PII<br>response = requests.get(<br>    &quot;https://psrc-xxxxx.region.confluent.cloud/catalog/v1/search/basic&quot;,<br>    params={<br>        &quot;query&quot;: &quot;tag:PII*&quot;,<br>        &quot;types&quot;: &quot;sr_subject&quot;<br>    },<br>    auth=(api_key, api_secret)<br>)<br><br>results = response.json()<br>for entity in results[&#39;entities&#39;]:<br>    print(f&quot;Topic: {entity[&#39;attributes&#39;][&#39;name&#39;]}&quot;)<br>    print(f&quot;Tags: {entity[&#39;classificationNames&#39;]}&quot;)</pre><h3>Confluent Data Portal</h3><p>O <strong>Data Portal</strong> é a interface self-service do Confluent para descoberta de dados [9]:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ifZ7g5hRh6yz3lUL1kQoyw.png" /><figcaption>Data Portal</figcaption></figure><h4>Workflow de Descoberta</h4><pre>1. Descobrir<br>Usuário busca &quot;pagamentos&quot; no Data Portal<br>→ Lista de topics relacionados com metadados<br>→ Visualiza descrição, schema, owner<br><br>2. Explorar<br>Usuário clica em &quot;pagamentos.pix.iniciado.v1&quot;<br>→ Vê schema completo com documentação<br>→ Visualiza Stream Lineage (upstream/downstream)<br>→ Verifica métricas de qualidade<br><br>3. Solicitar Acesso<br>Usuário não tem acesso ao topic<br>→ Clica em &quot;Request Access&quot;<br>→ Preenche justificativa<br>→ Owner recebe notificação<br>→ Owner aprova/rejeita<br>→ Usuário é notificado<br><br>4. Usar<br>Acesso concedido<br>→ Usuário vê credenciais/instruções<br>→ Configura consumer/producer<br>→ Começa a usar os dados</pre><h4>Stream Lineage</h4><p>O Stream Lineage mostra o fluxo de dados visualmente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jPEstk48WQubVtK1nIstow.png" /></figure><p><strong>Benefícios do Lineage:</strong> — Análise de impacto antes de mudar schemas — Debug de problemas de dados — Compliance e auditoria — Entendimento do sistema</p><h3>Lenses.io Data Catalog</h3><p>O <strong>Lenses.io</strong> oferece capacidades de Data Catalog integradas à sua plataforma de Developer Experience para Kafka [10]:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2F1dFy4%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2F1dFy4%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2F1dFy4%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="298" frameborder="0" scrolling="no"><a href="https://medium.com/media/ce919caacaccef5174e1e9c6bd8cd400/href">https://medium.com/media/ce919caacaccef5174e1e9c6bd8cd400/href</a></iframe><h4>Busca no Lenses</h4><pre>-- SQL Studio: Explorar topic antes de usar<br>SELECT *<br>FROM vendas_pedidos<br>LIMIT 10;<br><br>-- Ver estrutura inferida automaticamente<br>-- Funciona com Avro, JSON, Protobuf, XML</pre><h4>Catálogo Multi-Cluster (Lenses 6.0)</h4><pre># Configuração multi-kafka<br>lenses.kafka.clusters = [<br>  { name = &quot;production&quot;, bootstrap.servers = &quot;kafka-prod:9092&quot; },<br>  { name = &quot;staging&quot;, bootstrap.servers = &quot;kafka-stg:9092&quot; }<br>]<br><br># Busca global encontra topics em todos os clusters</pre><h4>Topology como Lineage</h4><p>O Topology do Lenses mostra automaticamente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kv8_Nbj2PGiHmwSvl3LWlQ.png" /><figcaption><em>Lenses Topology — lineage automático de producers e consumers</em></figcaption></figure><h4>Data Policies para Compliance</h4><pre># Mascaramento automático de PII<br>policies:<br>  - name: &quot;mask-cpf&quot;<br>    fields: [&quot;cpf&quot;, &quot;*.cpf&quot;]<br>    redaction: &quot;Last4&quot;<br><br>  - name: &quot;mask-email&quot;<br>    fields: [&quot;email&quot;]<br>    redaction: &quot;Email&quot;  # ***@domain.com</pre><h4>Quando Usar Lenses como Catálogo</h4><p><strong>Ideal quando:</strong> — Precisa de SQL para exploração de dados — Tem múltiplos clusters Kafka (diferentes vendors) — Compliance (LGPD) é prioridade — Quer catálogo + DevEx na mesma ferramenta</p><p><strong>Limitações:</strong> — Foco em Kafka (não cataloga DBs, warehouses) — Menos recursos de glossário de negócio — Licença comercial</p><h3>OpenMetadata para Kafka</h3><p><strong>OpenMetadata</strong> é uma plataforma open source de Data Catalog que suporta Kafka nativamente [11]:</p><h4>Configuração do Connector</h4><pre># openmetadata-kafka-ingestion.yaml<br>source:<br>  type: kafka<br>  serviceName: kafka-production<br>  serviceConnection:<br>    config:<br>      type: Kafka<br>      bootstrapServers: &quot;kafka:9092&quot;<br>      schemaRegistryURL: &quot;http://schema-registry:8081&quot;<br>      consumerConfig:<br>        security.protocol: SASL_SSL<br>        sasl.mechanism: PLAIN<br>        sasl.jaas.config: &quot;...&quot;<br>      schemaRegistryConfig:<br>        basic.auth.credentials.source: USER_INFO<br>        basic.auth.user.info: &quot;key:secret&quot;<br>  sourceConfig:<br>    config:<br>      type: MessagingMetadata<br>      topicFilterPattern:<br>        includes:<br>          - &quot;vendas.*&quot;<br>          - &quot;pagamentos.*&quot;<br>        excludes:<br>          - &quot;.*_retry$&quot;<br>          - &quot;.*_dlq$&quot;<br><br>sink:<br>  type: metadata-rest<br>  config:<br>    api_endpoint: http://openmetadata:8585/api<br><br>workflowConfig:<br>  openMetadataServerConfig:<br>    hostPort: http://openmetadata:8585/api<br>    authProvider: openmetadata<br>    securityConfig:<br>      jwtToken: &quot;...&quot;</pre><h4>Executando Ingestion</h4><pre># Instalar o connector<br>pip install openmetadata-ingestion[kafka]<br><br># Executar ingestion<br>metadata ingest -c openmetadata-kafka-ingestion.yaml</pre><h4>Documentando Topics no OpenMetadata</h4><pre># Adicionar metadata via API<br>topic:<br>  name: vendas.pedidos.criado.v1<br>  displayName: Pedido Criado<br>  description: |<br>    Evento emitido quando um pedido é finalizado no checkout.<br><br>    ## Uso<br>    - Triggera processamento de pagamento<br>    - Alimenta dashboards de vendas<br>    - Base para fraud detection<br><br>  owner:<br>    name: Squad Checkout<br>    type: team<br><br>  domain: Vendas<br><br>  tags:<br>    - PII.Sensitive<br>    - LGPD.PersonalData<br>    - Tier.Tier1<br><br>  glossaryTerms:<br>    - Pedido<br>    - Checkout</pre><h3>Interface do OpenMetadata</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kK6H8m6aLx3eOnKvGlWijg.png" /><figcaption><em>Interface do OpenMetadata — detalhe de um topic com description, schema, tags e lineage</em></figcaption></figure><p>A interface mostra todas as informações consolidadas: descrição do topic, owner (Squad Checkout), domain (Vendas), tier (Tier1), quality score (98%), tags de classificação (PII, LGPD, Revenue), schema Avro completo com documentação por campo, e o lineage mostrando a cadeia completa — desde o PostgreSQL CDC até os consumidores (Fraud Detection, Analytics, BigQuery Sink).</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FjvFms%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FjvFms%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FjvFms%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="777" frameborder="0" scrolling="no"><a href="https://medium.com/media/d851ccbe57ea7d377290c09853b4938e/href">https://medium.com/media/d851ccbe57ea7d377290c09853b4938e/href</a></iframe><h3>Quando Usar Cada Um</h3><p><strong>Use Confluent Stream Catalog quando:</strong> — Já está no Confluent Cloud — Precisa de setup zero — Lineage automático é crítico — Precisa de Data Portal integrado</p><p><strong>Use Lenses.io quando:</strong> — Tem múltiplos clusters de diferentes vendors — Precisa de SQL para explorar dados — Compliance (LGPD) com mascaramento é prioridade — Quer catálogo + developer experience juntos</p><p><strong>Use OpenMetadata quando:</strong> — Precisa de catálogo multi-source (Kafka + DBs + warehouses) — Budget é restrito (open source) — Quer controle total e customização — Glossário de negócio robusto é importante</p><h3>Implementando um Data Catalog Efetivo</h3><pre>1. Defina Padrões de Metadados<br># standards/topic-metadata.yaml<br>required:<br>  - displayName        # Nome amigável<br>  - description        # Descrição mínima 50 chars<br>  - owner              # Time responsável<br>  - domain             # Domínio de negócio<br>  - tier               # Tier1, Tier2, Tier3<br><br>recommended:<br>  - glossaryTerms      # Termos do glossário<br>  - sla                # SLAs documentados<br>  - dataContract       # Link para contrato<br><br>pii_fields:<br>  required:<br>    - tag: PII.*       # Tag de classificação<br>    - retention        # Período de retenção<br><br>2. Automatize a Coleta<br># scripts/catalog_sync.py<br>from confluent_kafka.schema_registry import SchemaRegistryClient<br>from openmetadata.ingestion.api.common import Entity<br><br>def sync_topic_metadata(topic_name: str):<br>    &quot;&quot;&quot;Sincroniza metadados do Schema Registry para o catálogo.&quot;&quot;&quot;<br><br>    # Buscar schema<br>    sr_client = SchemaRegistryClient({&#39;url&#39;: SR_URL})<br>    schema = sr_client.get_latest_version(f&quot;{topic_name}-value&quot;)<br><br>    # Extrair metadados<br>    metadata = {<br>        &#39;name&#39;: topic_name,<br>        &#39;schema_type&#39;: schema.schema.schema_type,<br>        &#39;schema_version&#39;: schema.version,<br>        &#39;fields&#39;: extract_fields(schema.schema.schema_str),<br>        &#39;created_at&#39;: get_topic_creation_time(topic_name)<br>    }<br><br>    # Enriquecer com business metadata<br>    business_meta = load_business_metadata(topic_name)<br>    metadata.update(business_meta)<br><br>    # Publicar no catálogo<br>    publish_to_catalog(metadata)<br><br>    return metadata<br><br>3. Estabeleça Governança<br># governance/data-catalog-policy.yaml<br>ownership:<br>  rule: &quot;Todo topic deve ter owner definido&quot;<br>  enforcement: block_creation<br><br>documentation:<br>  rule: &quot;Descrição mínima de 50 caracteres&quot;<br>  enforcement: warning<br><br>pii_classification:<br>  rule: &quot;Campos PII devem ser tagueados&quot;<br>  enforcement: block_production<br>  scan: automated  # Scan automático de PII<br><br>quality:<br>  rule: &quot;Tier1 topics devem ter quality checks&quot;<br>  enforcement: warning<br><br>4. Meça Adoção<br># metrics/catalog-adoption.yaml<br>metrics:<br>  catalog_coverage:<br>    formula: documented_topics / total_topics<br>    target: 95%<br><br>  metadata_completeness:<br>    formula: filled_fields / required_fields<br>    target: 90%<br><br>  search_success_rate:<br>    formula: searches_with_results / total_searches<br>    target: 85%<br><br>  time_to_discovery:<br>    formula: avg_time_from_search_to_access<br>    target: &lt; 30 minutes<br><br>  user_adoption:<br>    formula: monthly_active_users / total_developers<br>    target: 80%</pre><h3>Melhores Práticas</h3><h3>Para Times de Plataforma</h3><ul><li><strong>Automatize ingestion</strong>: Não dependa de documentação manual</li><li><strong>Defina padrões antes de escalar</strong>: Governança desde o início</li><li><strong>Integre no workflow</strong>: Catalogação como parte do CI/CD</li><li><strong>Meça adoção</strong>: Se ninguém usa, não tem valor</li></ul><h3>Para Desenvolvedores</h3><ul><li><strong>Documente ao criar</strong>: É mais fácil no momento da criação</li><li><strong>Use o catálogo primeiro</strong>: Antes de perguntar no Slack</li><li><strong>Mantenha atualizado</strong>: Atualize quando mudar</li><li><strong>Contribua com feedback</strong>: Ratings, comentários, correções</li></ul><h3>Para Data Stewards</h3><ul><li><strong>Revise regularmente</strong>: Metadados ficam stale</li><li><strong>Classifique PII proativamente</strong>: Use scanning automático</li><li><strong>Conecte ao glossário</strong>: Termos de negócio padronizados</li><li><strong>Monitore qualidade</strong>: Metadados ruins = catálogo inútil</li></ul><h3>Exemplo Completo: E-commerce</h3><h4>Catalogando o Domínio de Vendas</h4><pre># domains/vendas.yaml<br>domain:<br>  name: Vendas<br>  description: |<br>    Domínio responsável por todo o ciclo de vida de vendas,<br>    desde a criação do pedido até a entrega.<br><br>  owner:<br>    team: Tribe Vendas<br>    contact: vendas@empresa.com<br><br>  topics:<br>    - name: vendas.pedidos.criado.v1<br>      tier: Tier1<br>      description: Pedido finalizado no checkout<br>      owner: Squad Checkout<br>      consumers:<br>        - fraud-detection<br>        - pagamentos<br>        - analytics<br><br>    - name: vendas.pedidos.atualizado.v1<br>      tier: Tier2<br>      description: Status do pedido atualizado<br>      owner: Squad Fulfillment<br><br>    - name: vendas.pedidos.entregue.v1<br>      tier: Tier2<br>      description: Pedido entregue ao cliente<br>      owner: Squad Logística<br><br>  glossary:<br>    - term: Pedido<br>      definition: Conjunto de itens comprados por um cliente<br><br>    - term: Checkout<br>      definition: Processo de finalização da compra<br><br>    - term: GMV<br>      definition: Gross Merchandise Value - valor bruto de vendas</pre><h4>Resultado no Catálogo</h4><pre>📂 Domínio: Vendas<br>├── 📦 vendas.pedidos.criado.v1<br>│   ├── Owner: Squad Checkout<br>│   ├── Tier: Tier1 ⭐<br>│   ├── Tags: [PII] [LGPD] [Revenue]<br>│   ├── Quality: 99.8%<br>│   └── Consumers: 8<br>│<br>├── 📦 vendas.pedidos.atualizado.v1<br>│   ├── Owner: Squad Fulfillment<br>│   ├── Tier: Tier2<br>│   ├── Tags: [Revenue]<br>│   ├── Quality: 99.5%<br>│   └── Consumers: 5<br>│<br>└── 📦 vendas.pedidos.entregue.v1<br>    ├── Owner: Squad Logística<br>    ├── Tier: Tier2<br>    ├── Tags: [Revenue]<br>    ├── Quality: 98.9%<br>    └── Consumers: 3</pre><h3>Conclusão</h3><p>Um Data Catalog é essencial para escalar arquiteturas de streaming:</p><ol><li><strong>Descoberta self-service</strong> reduz tempo gasto procurando dados</li><li><strong>Metadados de negócio</strong> traduzem dados técnicos para contexto</li><li><strong>Lineage</strong> permite análise de impacto antes de mudanças</li><li><strong>Governança integrada</strong> garante compliance e qualidade</li><li><strong>Colaboração</strong> multiplica o conhecimento organizacional</li></ol><p>Com Confluent Stream Catalog, Lenses.io ou OpenMetadata, você pode transformar seus topics Kafka de <strong>dados invisíveis</strong> em <strong>ativos descobríveis</strong> — acelerando desenvolvimento e garantindo governança.</p><h3>Recursos</h3><ul><li><a href="https://docs.confluent.io/cloud/current/stream-governance/stream-catalog.html">Confluent Stream Catalog</a></li><li><a href="https://docs.confluent.io/cloud/current/stream-governance/data-portal.html">Confluent Data Portal</a></li><li><a href="https://docs.lenses.io/">Lenses.io Documentation</a></li><li><a href="https://docs.open-metadata.org/latest/connectors/messaging/kafka">OpenMetadata Kafka Connector</a></li><li><a href="https://docs.confluent.io/cloud/current/stream-governance/stream-lineage.html">Stream Lineage</a></li></ul><h3>Referências</h3><ol><li><strong>Data Discovery Time</strong>: <a href="https://www.acceldata.io/blog/what-is-a-data-catalog-explore-its-benefits-use-cases-and-best-practices">Acceldata — What is a Data Catalog</a></li><li><strong>Data Catalog Definition</strong>: <a href="https://www.secoda.co/learn/best-practices-for-data-cataloging">Secoda — Best Practices for Data Cataloging</a></li><li>Reis, J. &amp; Housley, M. (2022). <em>Fundamentals of Data Engineering</em>. O’Reilly Media. Chapter 8: Metadata Management.</li><li><strong>Metadata Management</strong>: <a href="https://atlan.com/data-catalog-vs-metadata-management/">Atlan — Data Catalog vs Metadata Management</a></li><li>Dehghani, Z. (2022). <em>Data Mesh: Delivering Data-Driven Value at Scale</em>. O’Reilly Media. Chapter 12: Data Product Discoverability.</li><li><strong>Types of Metadata</strong>: <a href="https://www.decube.io/post/data-catalog-metadata-management-guide">Decube — Data Catalog &amp; Metadata Management Guide</a></li><li>Kleppmann, M. (2017). <em>Designing Data-Intensive Applications</em>. O’Reilly Media. Chapter 4: Encoding and Evolution.</li><li><strong>Confluent Stream Catalog</strong>: <a href="https://docs.confluent.io/cloud/current/stream-governance/stream-catalog.html">Confluent Documentation — Stream Catalog</a></li><li><strong>Confluent Data Portal</strong>: <a href="https://www.confluent.io/blog/data-portal-stream-governance/">Confluent Blog — Data Portal</a></li><li><strong>Lenses.io Data Catalog</strong>: <a href="https://lenses.io/">Lenses.io Platform</a></li><li><strong>OpenMetadata Kafka</strong>: <a href="https://docs.open-metadata.org/latest/connectors/messaging/kafka">OpenMetadata Documentation — Kafka Connector</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=521bae75c45b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lenses: Developer Experience para Apache Kafka]]></title>
            <link>https://mateus-oliveira.medium.com/lenses-developer-experience-para-apache-kafka-c0446416ae93?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0446416ae93</guid>
            <category><![CDATA[lenses]]></category>
            <category><![CDATA[devex]]></category>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[stream-governance]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Fri, 20 Feb 2026 18:45:38 GMT</pubDate>
            <atom:updated>2026-02-20T18:45:38.344Z</atom:updated>
            <content:encoded><![CDATA[<p>Minha experiência trabalhando com o time da Lenses e como a plataforma transforma o dia a dia de quem desenvolve com Kafka</p><p>Como entusiasta de Kafka, eu tive a grande oportunidade de trabalhar diretamente com o time da Lenses nos anos 2023 a 2024, consegui entender a paixão do time em resolver problemas complexos envolvendo ambientes de Apache Kafka, além de features que tornam a experiência em desenvolver sistemas reativos ainda mais completa e robusta.</p><p>Durante esse período, acompanhei de perto os desafios que grandes organizações enfrentam com Kafka em escala: times de dezenas de desenvolvedores tentando entender qual topic usar, como os dados estão estruturados, quem produz o quê — muitas vezes dependendo de “conhecimento tribal” que existe na cabeça de meia dúzia de pessoas. Vi equipes gastando dias configurando consumers apenas para explorar dados que poderiam ser consultados com uma query SQL simples. Vi incidentes em produção onde a falta de visibilidade sobre o fluxo de dados transformava uma investigação de minutos em horas de debug.</p><p>O Lenses resolve exatamente esses problemas. Fundada em 2016 por Antonios Chalkiopoulos e Christina Daskalaki — ambos vindos de posições de engenharia sênior em empresas como Barclays e Tesco, onde vivenciaram a adoção inicial do Kafka — a plataforma nasceu da frustração real de quem precisava trabalhar com streaming no dia a dia.</p><p>E em abril de 2025, o <strong>Lenses 6.0</strong> (codinome <strong>Panoptes</strong>, em referência ao personagem da mitologia grega com muitos olhos) marcou um ponto de virada. Lembro de estar em <strong>Tenerife, na Espanha</strong>, com o time da Lenses quando os conceitos do <strong>Multi-Kafka</strong> estavam sendo discutidos. Claro, eu estava ali como observador — o mérito completo é do time interno da Lenses — mas foi inspirador ver a energia e a convicção de que gerenciar múltiplos clusters de diferentes vendors (Confluent, AWS MSK, Redpanda, Apache Kafka open-source) a partir de uma interface unificada era o futuro.</p><p><strong>Neste artigo, você vai aprender:</strong></p><ul><li>Por que a Developer Experience em Kafka importa tanto</li><li>SQL Studio: explorando e prototipando com dados reais</li><li>Data Catalog: descobrindo e entendendo seus dados</li><li>SQL Processors: criando pipelines de dados com SQL</li><li>Topology: entendendo o fluxo de dados visualmente</li><li>Multi-Kafka (Lenses 6.0): o breakthrough que unifica clusters</li><li>Self-service para desenvolvedores com governança</li></ul><h3>O Problema: A Barreira de Entrada do Kafka</h3><p>Uma das coisas que mais vi trabalhando com clientes do Lenses era a mesma cena se repetindo: um desenvolvedor novo no time precisava entender os dados de um topic e passava horas configurando ferramentas de linha de comando, deserializando Avro manualmente, filtrando com grep. Às vezes desistia e ia perguntar para alguém “o que tem nesse topic?”.</p><pre>Opção tradicional:<br>1. Configurar kafka-console-consumer ❌ Verbose<br>2. Deserializar Avro/Protobuf manualmente ❌ Complexo<br>3. Filtrar com grep/jq ❌ Limitado<br>4. Escrever um consumer em Java/Python ❌ Demorado<br><br>Com Lenses:<br>SELECT * FROM pedidos WHERE total &gt; 1000 LIMIT 10 ✅ Simples</pre><p>O Lenses resolve isso oferecendo uma <strong>camada de abstração</strong> que torna Kafka acessível para desenvolvedores de qualquer nível — e foi exatamente essa simplicidade que me impressionou quando vi o produto pela primeira vez em ação.</p><h3>O Que é Lenses?</h3><p><strong>Lenses</strong> é uma plataforma de Developer Experience para Apache Kafka que nasceu da comunidade open-source — o time começou contribuindo para o ecossistema Kafka e criando ferramentas gratuitas como o Kafka Topics UI, que ganhou tração orgânica entre desenvolvedores. Dessa base, evoluíram para uma plataforma enterprise que fornece:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*Ud8gvsQRgG5EVdll2bvbrg.png" /><figcaption>Arquitetura Lenses</figcaption></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FSDUX8%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FSDUX8%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FSDUX8%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="401" frameborder="0" scrolling="no"><a href="https://medium.com/media/f68868b263ec15129fec0b3918d650eb/href">https://medium.com/media/f68868b263ec15129fec0b3918d650eb/href</a></iframe><h3>Diferencial: Multi-Kafka (Lenses 6.0 — Panoptes)</h3><p>Essa é a feature que vi nascer. Quando estive em Tenerife com o time, o problema que eles queriam resolver era claro: empresas grandes não têm <em>um</em> cluster Kafka — têm dezenas, às vezes centenas, espalhados por diferentes clouds, vendors e ambientes. E cada um com suas ferramentas, seus acessos, suas peculiaridades.</p><p>A arquitetura do Lenses 6.0 foi redesenhada com um <strong>Control Plane centralizado</strong> (chamado <strong>HQ</strong>) e <strong>Agents distribuídos</strong> que são deployados ao lado de cada cluster Kafka. Os agents só são acessíveis através do HQ, criando uma experiência verdadeiramente unificada:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/899/1*SNAe4gZqWyHTf-dcYctL8w.png" /><figcaption>Lense 6.0 — Multi-kafka</figcaption></figure><pre># Uma interface para todos os seus clusters — qualquer vendor<br>lenses.kafka.clusters = [<br>  { name = &quot;production&quot;, bootstrap.servers = &quot;kafka-prod:9092&quot; },    # Confluent Platform<br>  { name = &quot;analytics&quot;, bootstrap.servers = &quot;msk-analytics:9092&quot; },  # AWS MSK<br>  { name = &quot;staging&quot;, bootstrap.servers = &quot;redpanda-stg:9092&quot; },     # Redpanda<br>  { name = &quot;development&quot;, bootstrap.servers = &quot;kafka-dev:9092&quot; }     # Apache Kafka OSS<br>]</pre><p>Isso significa que um desenvolvedor pode: — <strong>Comparar dados entre ambientes</strong> de diferentes vendors no split-screen — <strong>Descobrir topics</strong> de qualquer cluster através de um catálogo global — <strong>Replicar dados</strong> entre clusters com um clique (K2K — sem depender de MirrorMaker 2) — <strong>Governar</strong> tudo de um único ponto, com AI que identifica topics vazios, duplicados e dados de teste em produção</p><h3>SQL Studio: Sua IDE para Kafka</h3><p>O <strong>SQL Studio</strong> é o coração do Lenses — e na minha experiência, é o que causa o “efeito wow” em todo desenvolvedor que vê pela primeira vez. Lembro de demos com clientes onde o engenheiro passava de ceticismo a entusiasmo em 30 segundos, quando via seus dados de produção sendo consultados com SQL. Ele transforma Kafka em algo que qualquer desenvolvedor familiarizado com SQL consegue usar imediatamente.</p><h3>Explorando Dados Rapidamente</h3><pre>-- Ver as últimas mensagens de um topic<br>SELECT *<br>FROM vendas_pedidos<br>LIMIT 10;<br><br>-- Metadados do Kafka disponíveis automaticamente<br>SELECT<br>  _key,           -- Chave da mensagem<br>  _partition,     -- Partition<br>  _offset,        -- Offset<br>  _timestamp,     -- Timestamp<br>  pedido_id,      -- Campos do payload<br>  total<br>FROM vendas_pedidos<br>WHERE _timestamp &gt; NOW() - INTERVAL &#39;1 hour&#39;;</pre><h3>Prototipando Queries</h3><p>Antes de escrever um consumer, valide sua lógica:</p><pre>-- Prototipar agregação para um dashboard<br>SELECT<br>  cliente_id,<br>  COUNT(*) as num_pedidos,<br>  SUM(total) as valor_total,<br>  AVG(total) as ticket_medio<br>FROM vendas_pedidos<br>WHERE _timestamp &gt; NOW() - INTERVAL &#39;24 hours&#39;<br>GROUP BY cliente_id<br>ORDER BY valor_total DESC<br>LIMIT 20;</pre><p>Se a query faz sentido, você pode transformá-la em um <strong>SQL Processor</strong> para rodar continuamente.</p><h3>Joins Entre Topics</h3><pre>-- Enriquecer pedidos com dados de clientes<br>SELECT<br>  p.pedido_id,<br>  p.total,<br>  c.nome as cliente_nome,<br>  c.segmento,<br>  c.cidade<br>FROM vendas_pedidos p<br>JOIN clientes c ON p.cliente_id = c._key<br>WHERE p.total &gt; 500;</pre><h3>Debug de Problemas</h3><pre>--Encontrar mensagens com erro<br> SELECT *<br> FROM vendas_pedidos<br> WHERE status = &#39;ERROR&#39;<br> OR total &lt; 0<br> OR cliente_id IS NULL;<br> <br> --Ver distribuição por partition<br> SELECT<br> _partition,<br> COUNT(*) as mensagens<br> FROM vendas_pedidos<br> GROUP BY _partition;</pre><p>Split-Screen: Comparar Ambientes (Lenses 6.0)</p><pre>┌─────────────────────────────┬─────────────────────────────┐<br>│  STAGING                    │  PRODUCTION                 │<br>├─────────────────────────────┼─────────────────────────────┤<br>│  SELECT COUNT(*) FROM orders│  SELECT COUNT(*) FROM orders│<br>│  WHERE status = &#39;PENDING&#39;   │  WHERE status = &#39;PENDING&#39;   │<br>│                             │                             │<br>│  count: 5                   │  count: 1,234               │<br>│  &quot;Parece ok no staging&quot;     │  &quot;Problema em prod!&quot;        │<br>└─────────────────────────────┴─────────────────────────────┘</pre><h3>Data Catalog: Descobrindo Seus Dados</h3><p>O <strong>Data Catalog</strong> resolve o problema de “qual topic eu devo usar?”:</p><h3>Busca Global</h3><pre>🔍 Pesquisar: &quot;pedido&quot;<br><br>Resultados:<br>├── vendas_pedidos (12 partitions, Avro)<br>│   └── Owner: Squad Checkout | Tier: Tier1<br>├── pedidos_processados (6 partitions, JSON)<br>│   └── Owner: Squad Fulfillment | Tier: Tier2<br>└── pedidos_cancelados (3 partitions, Avro)<br>    └── Owner: Squad Checkout | Tier: Tier3</pre><h3>Documentação Inline</h3><p>Cada topic pode ter:</p><ul><li><strong>Descrição</strong>: O que esse topic representa</li><li><strong>Owner</strong>: Quem é responsável</li><li><strong>Schema</strong>: Estrutura dos dados (integrado com Schema Registry)</li><li><strong>Tags</strong>: Classificações (PII, Tier, Domain)</li><li><strong>Sample Data</strong>: Exemplos reais (com mascaramento)</li></ul><h3>Schema Discovery</h3><p>O Lenses detecta automaticamente o formato dos dados:</p><p><strong>Avro</strong>: Lê do Schema Registry</p><p><strong>JSON</strong>: Infere estrutura das mensagens</p><p><strong>Protobuf</strong>: Lê dos descriptors</p><p><strong>XML</strong>: Parse automático</p><h3>SQL Processors: Pipelines Self-Service</h3><p>Os <strong>SQL Processors</strong> foram uma das features que mais vi sendo adotadas rapidamente por times de dados. A proposta é simples: se você consegue escrever SQL, consegue criar um pipeline de streaming. Sem Kafka Streams, sem Flink, sem deploy complexo:</p><h3>Caso de Uso: Filtrar Eventos</h3><pre>-- Desenvolvedor cria um processor em minutos<br>SET defaults.topic.autocreate = true;<br><br>INSERT INTO pedidos_alto_valor<br>SELECT<br>  pedido_id,<br>  cliente_id,<br>  total,<br>  itens,<br>  _timestamp as created_at<br>FROM vendas_pedidos<br>WHERE total &gt; 1000;</pre><h3>Caso de Uso: Enriquecer Dados</h3><pre>--Join stream com tabela de referência<br> INSERT INTO pedidos_enriquecidos<br> SELECT<br> p.*,<br> c.nome as cliente_nome,<br> c.segmento,<br> c.regiao<br> FROM vendas_pedidos p<br> JOIN clientes c ON p.cliente_id = c._key;</pre><h3>Caso de Uso: Agregar Métricas</h3><pre>--Métricas em tempo real para dashboard<br> INSERT INTO metricas_vendas<br> SELECT<br> TUMBLE_START(event_time, &#39;5m&#39;) as janela,<br> COUNT(*) as total_pedidos,<br> SUM(total) as valor_total,<br> AVG(total) as ticket_medio<br> FROM vendas_pedidos<br> GROUP BY TUMBLE(event_time, &#39;5m&#39;);</pre><h3>Gerenciamento de Processors</h3><pre># Listar processors<br> lenses-cli processors list<br> <br> # Status de um processor<br> lenses-cli processors describe pedidos-alto-valor<br> <br> # Escalar horizontalmente<br> lenses-cli processors scale pedidos-alto-valor - runners 4<br> <br> # Parar para manutenção<br> lenses-cli processors stop pedidos-alto-valor</pre><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FuxdWp%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FuxdWp%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FuxdWp%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="298" frameborder="0" scrolling="no"><a href="https://medium.com/media/3e2f90737065c2bd643036c051e35c4b/href">https://medium.com/media/3e2f90737065c2bd643036c051e35c4b/href</a></iframe><h3>Topology: Entendendo o Fluxo de Dados</h3><p>De todas as features do Lenses, o <strong>Topology</strong> é a que mais me impressionou em cenários de incidentes. Vi situações onde um time de plataforma levaria horas para mapear o impacto de uma mudança de schema — com o Topology, a resposta era visual e instantânea. Ele oferece uma visão de como os dados fluem pelo ecossistema:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/760/1*_MI5oK9c9YX2tWaMggTpPg.png" /><figcaption>Data Lineage + Consumer Lag em tempo ral</figcaption></figure><h3>Para Desenvolvedores</h3><ul><li><strong>“De onde vêm os dados desse topic?”</strong> → Veja os producers upstream</li><li><strong>“Quem consome esse topic?”</strong> → Veja consumers downstream</li><li><strong>“Se eu mudar o schema, quem é afetado?”</strong> → Análise de impacto visual</li></ul><h3>Registrando Sua Aplicação</h3><pre>TopologyClient client = TopologyClient.builder()<br>    .kafkaBootstrapServers(&quot;kafka:9092&quot;)<br>    .build();<br><br>client.register(<br>    Topology.builder()<br>        .appName(&quot;order-processor&quot;)<br>        .appType(AppType.MICROSERVICE)<br>        .description(&quot;Processa pedidos e calcula frete&quot;)<br>        .inputTopics(List.of(&quot;vendas_pedidos&quot;))<br>        .outputTopics(List.of(&quot;pedidos_processados&quot;, &quot;calculos_frete&quot;))<br>        .build()<br>);</pre><h3>Self-Service com Governança</h3><p>O Lenses permite <strong>autonomia para desenvolvedores</strong> sem comprometer a <strong>governança</strong>:</p><h3>Data Policies: Proteção de PII</h3><p>Uma das dores que mais vi em clientes — especialmente no contexto de LGPD no Brasil — era o dilema: como dar acesso a dados reais para desenvolvedores sem expor informações sensíveis? O Lenses resolve isso de forma elegante. Desenvolvedores veem dados mascarados automaticamente:</p><pre># Política configurada pelo time de compliance<br>policies:<br>  - name: &quot;mask-cpf&quot;<br>    fields: [&quot;cpf&quot;, &quot;*.cpf&quot;]<br>    redaction: &quot;Last4&quot;  # Mostra apenas últimos 4 dígitos<br><br>  - name: &quot;mask-email&quot;<br>    fields: [&quot;email&quot;, &quot;*.email&quot;]<br>    redaction: &quot;Email&quot;  # ***@domain.com</pre><p><strong>Resultado no SQL Studio:</strong></p><pre>SELECT cliente_id, nome, cpf, email FROM clientes;<br><br>┌────────────┬───────────────┬─────────────┬──────────────────┐<br>│ cliente_id │ nome          │ cpf         │ email            │<br>├────────────┼───────────────┼─────────────┼──────────────────┤<br>│ C001       │ M*** O***     │ *******8901 │ ***@gmail.com    │<br>│ C002       │ J*** S***     │ *******2345 │ ***@outlook.com  │<br>└────────────┴───────────────┴─────────────┴──────────────────┘<br></pre><p>O desenvolvedor trabalha com dados reais (estrutura, volume, padrões) mas <strong>PII está protegido</strong>.</p><h3>Controle de Acesso por Role</h3><pre>roles:<br>  developer:<br>    - topics: [&quot;dev.*&quot;, &quot;staging.*&quot;]<br>      permissions: [READ, WRITE]<br>    - topics: [&quot;prod.*&quot;]<br>      permissions: [READ]  # Só leitura em prod<br><br>  data_engineer:<br>    - topics: [&quot;*&quot;]<br>      permissions: [READ, WRITE]<br>    - processors: [CREATE, MANAGE]<br><br>  analyst:<br>    - topics: [&quot;*.metrics&quot;, &quot;*.aggregated&quot;]<br>      permissions: [READ]</pre><h3>Workflow do Desenvolvedor com Lenses</h3><pre>1. Descobrir Dados<br>Desenvolvedor: &quot;Preciso de dados de pedidos para minha feature&quot;<br><br>→ Data Catalog: Busca &quot;pedidos&quot;<br>→ Encontra: vendas_pedidos (Avro, 12 partitions)<br>→ Lê descrição, schema, vê samples<br>2. Explorar e Prototipar<br>-- SQL Studio: Entende a estrutura<br>SELECT * FROM vendas_pedidos LIMIT 5;<br><br>-- Prototipar a lógica<br>SELECT<br>  DATE_TRUNC(&#39;hour&#39;, _timestamp) as hora,<br>  COUNT(*) as pedidos,<br>  SUM(total) as valor<br>FROM vendas_pedidos<br>WHERE regiao = &#39;SUDESTE&#39;<br>GROUP BY DATE_TRUNC(&#39;hour&#39;, _timestamp);<br>3. Criar Pipeline (se necessário)<br>-- SQL Processor: Transforma protótipo em pipeline<br>INSERT INTO metricas_sudeste<br>SELECT<br>  TUMBLE_START(event_time, &#39;1h&#39;) as hora,<br>  COUNT(*) as pedidos,<br>  SUM(total) as valor<br>FROM vendas_pedidos<br>WHERE regiao = &#39;SUDESTE&#39;<br>GROUP BY TUMBLE(event_time, &#39;1h&#39;);<br>4. Registrar no Topology<br>// Registrar aplicação para visibilidade<br>client.register(<br>    Topology.builder()<br>        .appName(&quot;metricas-sudeste-processor&quot;)<br>        .inputTopics(List.of(&quot;vendas_pedidos&quot;))<br>        .outputTopics(List.of(&quot;metricas_sudeste&quot;))<br>        .build()<br>);<br>5. Verificar em Produção<br>-- Split-screen: Comparar staging vs prod<br>-- Validar que a lógica funciona igual</pre><h3>Quando Usar Lenses</h3><p>Baseado no que vi com clientes reais:</p><p>✅ <strong>Use Lenses quando:</strong> — Desenvolvedores precisam de acesso self-service a Kafka (o ROI em onboarding é visível) — Você tem múltiplos clusters de diferentes vendors (o caso de uso #1 do Lenses 6.0) — Compliance (LGPD/GDPR) é requisito e dados precisam ser mascarados por padrão — Quer reduzir tempo de onboarding em Kafka de semanas para dias — Precisa de visibilidade sobre o fluxo de dados para análise de impacto</p><p>⚠️ <strong>Considere alternativas</strong> se já utiliza Confluent Cloud como plataforma principal (que já oferece governança e observabilidade nativas), se o ambiente é mais enxuto e ferramentas open source como Kafka UI atendem os requisitos mínimos, ou se o orçamento atual não comporta um produto enterprise com licenciamento comercial.</p><h3>Boas Práticas</h3><h3>Para Times de Plataforma</h3><ul><li><strong>Configure Data Policies antes de liberar acesso</strong>: Proteja PII desde o início</li><li><strong>Defina roles claros</strong>: Dev, Data Engineer, Analyst com permissões apropriadas</li><li><strong>Integre no onboarding</strong>: Lenses facilita aprender Kafka</li></ul><h3>Para Desenvolvedores</h3><ul><li><strong>Use SQL Studio antes de escrever código</strong>: Entenda os dados primeiro</li><li><strong>Prototipe queries antes de criar consumers</strong>: Valide a lógica</li><li><strong>Registre suas apps no Topology</strong>: Ajuda outros devs a entender o sistema</li><li><strong>Use SQL Processors para ETL simples</strong>: Não reinvente a roda</li></ul><h3>Conclusão</h3><p>Depois de dois anos trabalhando próximo ao time da Lenses e acompanhando a adoção da plataforma por clientes de diferentes tamanhos e setores, posso dizer com convicção: o Lenses muda a forma como times interagem com Kafka.</p><ol><li><strong>SQL Studio</strong> elimina a barreira de entrada — vi desenvolvedores juniores produtivos em Kafka no primeiro dia</li><li><strong>Data Catalog</strong> acaba com o “conhecimento tribal” — dados se tornam descobríveis</li><li><strong>SQL Processors</strong> democratizam a criação de pipelines — sem precisar de um time dedicado</li><li><strong>Topology</strong> traz visibilidade — análise de impacto que antes levava horas passa a ser visual</li><li><strong>Data Policies</strong> resolvem o dilema segurança vs. produtividade — LGPD sem bloquear o desenvolvedor</li><li><strong>Multi-Kafka (6.0)</strong> unifica o que antes era caos — múltiplos clusters, múltiplos vendors, uma só experiência</li></ol><p>O Lenses 6.0 Panoptes foi um marco. Ver aquela ideia nascer em Tenerife e se tornar um produto que resolve um problema real de centenas de organizações foi uma das experiências mais gratificantes da minha carreira com Kafka.</p><h3>Recursos</h3><ul><li><a href="https://docs.lenses.io/">Lenses Documentation</a></li><li><a href="https://help.lenses.io/">Lenses Help Center</a></li><li><a href="https://docs.lenses.io/latest/user-guide/sql-studio/">SQL Studio Guide</a></li><li><a href="https://docs.lenses.io/4.0/sql/streaming/">SQL Processors</a></li><li><a href="https://lenses.io/blog/2025/04/introducing-lenses-6.0-multi-kafka-tool/">Lenses 6.0 Release — Panoptes</a></li><li><a href="https://lenses.io/blog/kafka-topics-ui">From Kafka Topics UI to Multi-Kafka DevEx</a></li></ul><h3>Referências</h3><ol><li><strong>Lenses.io Platform</strong>: <a href="https://lenses.io/">Lenses.io — AI-assisted data streaming</a></li><li><strong>Lenses 6.0 Multi-Kafka (Panoptes)</strong>: <a href="https://lenses.io/blog/2025/04/introducing-lenses-6.0-multi-kafka-tool/">Lenses Blog — Introducing Lenses 6.0</a></li><li><strong>SQL Studio Documentation</strong>: <a href="https://docs.lenses.io/latest/user-guide/sql-studio/">Lenses Docs — SQL Studio</a></li><li><strong>SQL Processors</strong>: <a href="https://docs.lenses.io/4.0/sql/streaming/">Lenses Docs — Streaming SQL</a></li><li><strong>Topology View</strong>: <a href="https://help.lenses.io/using-lenses/flows/topology/">Lenses Help — Topology</a></li><li><strong>Data Policies</strong>: <a href="https://docs.lenses.io/5.5/guides/compliance/data-policies/">Lenses Documentation — Data Policies</a></li><li><strong>Lenses.io About Us</strong>: <a href="https://lenses.io/company/about-us/">Lenses.io — About</a></li><li><strong>Multi-Kafka Replication Strategy</strong>: <a href="https://lenses.io/blog/2025/10/multi-kafka-replication-strategy/">Lenses Blog — K2K</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0446416ae93" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data Contracts: O Alicerce da Governança em Streaming]]></title>
            <link>https://mateus-oliveira.medium.com/data-contracts-o-alicerce-da-governan%C3%A7a-em-streaming-d226d6611138?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d226d6611138</guid>
            <category><![CDATA[data-contract]]></category>
            <category><![CDATA[streaming-governance]]></category>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[data-governance]]></category>
            <category><![CDATA[confluent]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Fri, 13 Feb 2026 16:44:10 GMT</pubDate>
            <atom:updated>2026-02-13T16:51:50.984Z</atom:updated>
            <content:encoded><![CDATA[<p>Como acordos formais entre produtores e consumidores garantem qualidade, consistência e confiança em arquiteturas de dados em tempo real</p><h3>Introdução</h3><p>Nos artigos anteriores, exploramos o <a href="https://medium.com/@mateus-oliveira/apache-kafka-o-cora%C3%A7%C3%A3o-do-streaming-moderno-ef0f7a5ac6e5">Apache Kafka</a> e o <a href="https://medium.com/@mateus-oliveira/confluent-o-ecossistema-enterprise-para-apache-kafka-da7cb215cc48">ecossistema Confluent</a>. Vimos que o Schema Registry garante compatibilidade de schemas. Mas em organizações com dezenas de equipes e centenas de topics, surge um problema maior: <strong>como garantir que produtores e consumidores tenham expectativas alinhadas sobre os dados?</strong></p><p>Segundo o relatório Data Streaming Report 2025, <strong>67% dos líderes de TI citam baixa qualidade de dados</strong> como um desafio crítico, e <strong>63% apontam silos de dados</strong> como barreira para integração [1]. A raiz desses problemas está na falta de acordos claros entre quem produz e quem consome dados.</p><p>A solução está nos <strong>Data Contracts</strong> — acordos formais que definem não apenas a estrutura dos dados, mas também semântica, qualidade, SLAs e responsabilidades.</p><p><strong>Neste artigo, você vai aprender:</strong></p><p>· O que são Data Contracts e por que são essenciais para streaming</p><p>· Como implementar Data Contracts com Confluent Schema Registry</p><p>· Definir regras de qualidade, metadata e tags</p><p>· Exemplos práticos de um e-commerce com pedidos e pagamentos</p><p>· Ciclo de vida e evolução de contratos</p><h3>O Que São Data Contracts?</h3><p>Um <strong>Data Contract</strong> é um acordo formal entre um componente upstream (produtor) e componentes downstream (consumidores) sobre a estrutura, semântica, qualidade e termos de uso dos dados [2].</p><p>Pense em uma API, mas para dados. Assim como uma API REST define endpoints, parâmetros e respostas esperadas, um Data Contract define:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/870/1*hucefIAVoqDTCpdNHn6NUA.png" /><figcaption>Anatomia de um Data Contract</figcaption></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fo1XaD%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fo1XaD%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2Fo1XaD%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="327" frameborder="0" scrolling="no"><a href="https://medium.com/media/18edebac976f8a87f69952d4e58b1303/href">https://medium.com/media/18edebac976f8a87f69952d4e58b1303/href</a></iframe><h3>Por Que Data Contracts São Essenciais?</h3><h3>O Problema: Sem Contrato</h3><p>Sem Data Contracts, cada equipe faz suposições diferentes:</p><p>Squad Pedidos (Producer):<br> — Envia campo “valor” como float<br> — Às vezes envia null quando há erro<br> — Muda o schema sem avisar<br> <br> Squad Pagamentos (Consumer):<br> — Espera campo “total” como decimal<br> — Assume que nunca é null<br> — Quebra quando schema muda</p><p><strong>Resultado</strong>: Falhas em produção, dados inconsistentes, desconfiança entre equipes.</p><h3>A Solução: Com Contrato</h3><p>Com Data Contracts, as expectativas são explícitas:</p><pre># Contrato formal entre Pedidos e Pagamentos<br>schema:<br>  total:<br>    type: decimal<br>    precision: 15<br>    scale: 2<br>    required: true<br>    description: &quot;Valor total do pedido em BRL&quot;<br><br>quality:<br>  rules:<br>    - total &gt; 0<br>    - total &lt;= 1000000<br><br>sla:<br>  availability: 99.99%<br>  latency_p95: 100ms</pre><p><strong>Resultado</strong>: Produtores validam antes de enviar, consumidores confiam nos dados recebidos.</p><h3>Data Contracts no Confluent Schema Registry</h3><p>O Confluent Schema Registry oferece suporte nativo a Data Contracts através de três recursos [3]:</p><p>1. <strong>Metadata</strong>: Informações adicionais sobre o schema</p><p>2. <strong>Tags</strong>: Classificações e categorias</p><p>3. <strong>Rules</strong>: Regras de validação e transformação</p><h3>Estrutura Completa</h3><pre>{<br>  &quot;schema&quot;: &quot;...&quot;,<br>  &quot;schemaType&quot;: &quot;AVRO&quot;,<br>  &quot;metadata&quot;: {<br>    &quot;properties&quot;: {<br>      &quot;owner&quot;: &quot;squad-pedidos&quot;,<br>      &quot;domain&quot;: &quot;vendas&quot;,<br>      &quot;tier&quot;: &quot;tier1&quot;,<br>      &quot;slack&quot;: &quot;#squad-pedidos&quot;<br>    }<br>  },<br>  &quot;ruleSet&quot;: {<br>    &quot;domainRules&quot;: [<br>      {<br>        &quot;name&quot;: &quot;validateTotal&quot;,<br>        &quot;kind&quot;: &quot;CONDITION&quot;,<br>        &quot;mode&quot;: &quot;WRITE&quot;,<br>        &quot;type&quot;: &quot;CEL&quot;,<br>        &quot;expr&quot;: &quot;message.total &gt; 0 &amp;&amp; message.total &lt;= 1000000&quot;<br>      }<br>    ]<br>  }<br>}</pre><h3>Exemplo Prático: E-commerce</h3><p>Vamos implementar Data Contracts para um e-commerce com dois eventos principais: pedidos e pagamentos.</p><ol><li>Schema Avro com Data Contract</li></ol><pre>Topic: vendas.pedidos.criado.v1<br>{<br>  &quot;type&quot;: &quot;record&quot;,<br>  &quot;name&quot;: &quot;PedidoCriado&quot;,<br>  &quot;namespace&quot;: &quot;br.com.ecommerce.vendas&quot;,<br>  &quot;doc&quot;: &quot;Evento emitido quando um novo pedido é criado no checkout&quot;,<br>  &quot;fields&quot;: [<br>    {<br>      &quot;name&quot;: &quot;pedido_id&quot;,<br>      &quot;type&quot;: &quot;string&quot;,<br>      &quot;doc&quot;: &quot;Identificador único do pedido (UUID)&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;cliente_id&quot;,<br>      &quot;type&quot;: &quot;string&quot;,<br>      &quot;doc&quot;: &quot;Identificador do cliente que fez o pedido&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;total&quot;,<br>      &quot;type&quot;: {<br>        &quot;type&quot;: &quot;bytes&quot;,<br>        &quot;logicalType&quot;: &quot;decimal&quot;,<br>        &quot;precision&quot;: 15,<br>        &quot;scale&quot;: 2<br>      },<br>      &quot;doc&quot;: &quot;Valor total do pedido em BRL&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;itens&quot;,<br>      &quot;type&quot;: {<br>        &quot;type&quot;: &quot;array&quot;,<br>        &quot;items&quot;: {<br>          &quot;type&quot;: &quot;record&quot;,<br>          &quot;name&quot;: &quot;ItemPedido&quot;,<br>          &quot;fields&quot;: [<br>            {&quot;name&quot;: &quot;produto_id&quot;, &quot;type&quot;: &quot;string&quot;},<br>            {&quot;name&quot;: &quot;quantidade&quot;, &quot;type&quot;: &quot;int&quot;},<br>            {&quot;name&quot;: &quot;preco_unitario&quot;, &quot;type&quot;: {&quot;type&quot;: &quot;bytes&quot;, &quot;logicalType&quot;: &quot;decimal&quot;, &quot;precision&quot;: 15, &quot;scale&quot;: 2}}<br>          ]<br>        }<br>      },<br>      &quot;doc&quot;: &quot;Lista de itens do pedido&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;created_at&quot;,<br>      &quot;type&quot;: {<br>        &quot;type&quot;: &quot;long&quot;,<br>        &quot;logicalType&quot;: &quot;timestamp-millis&quot;<br>      },<br>      &quot;doc&quot;: &quot;Timestamp de criação do pedido&quot;<br>    }<br>  ]<br>}</pre><p>2. Registrando com Metadata e Tags</p><pre>from confluent_kafka.schema_registry import SchemaRegistryClient, Schema<br><br>sr_client = SchemaRegistryClient({&#39;url&#39;: &#39;http://schema-registry:8081&#39;})<br><br># Schema Avro<br>schema_str = &quot;&quot;&quot;...&quot;&quot;&quot;  # Schema acima<br><br># Metadata do Data Contract<br>metadata = {<br>    &quot;properties&quot;: {<br>        &quot;owner&quot;: &quot;squad-checkout&quot;,<br>        &quot;domain&quot;: &quot;vendas&quot;,<br>        &quot;tier&quot;: &quot;tier1&quot;,<br>        &quot;contact&quot;: &quot;checkout@ecommerce.com&quot;,<br>        &quot;slack&quot;: &quot;#squad-checkout&quot;,<br>        &quot;documentation&quot;: &quot;https://docs.internal/events/pedido-criado&quot;<br>    },<br>    &quot;tags&quot;: [<br>        {&quot;name&quot;: &quot;PII.CustomerID&quot;, &quot;path&quot;: &quot;cliente_id&quot;},<br>        {&quot;name&quot;: &quot;Criticality.High&quot;},<br>        {&quot;name&quot;: &quot;LGPD.PersonalData&quot;}<br>    ]<br>}<br><br># Regras de validação (CEL - Common Expression Language)<br>rule_set = {<br>    &quot;domainRules&quot;: [<br>        {<br>            &quot;name&quot;: &quot;validateTotal&quot;,<br>            &quot;kind&quot;: &quot;CONDITION&quot;,<br>            &quot;mode&quot;: &quot;WRITE&quot;,<br>            &quot;type&quot;: &quot;CEL&quot;,<br>            &quot;expr&quot;: &quot;message.total &gt; 0&quot;<br>        },<br>        {<br>            &quot;name&quot;: &quot;validateItens&quot;,<br>            &quot;kind&quot;: &quot;CONDITION&quot;,<br>            &quot;mode&quot;: &quot;WRITE&quot;,<br>            &quot;type&quot;: &quot;CEL&quot;,<br>            &quot;expr&quot;: &quot;size(message.itens) &gt; 0&quot;<br>        }<br>    ]<br>}<br><br># Registrar schema com Data Contract<br>schema = Schema(<br>    schema_str=schema_str,<br>    schema_type=&quot;AVRO&quot;,<br>    metadata=metadata,<br>    rule_set=rule_set<br>)<br><br>schema_id = sr_client.register_schema(<br>    subject_name=&quot;vendas.pedidos.criado.v1-value&quot;,<br>    schema=schema<br>)<br><br>print(f&quot;Schema registrado com ID: {schema_id}&quot;)</pre><p>3.Producer com Validação de Contrato</p><pre>from confluent_kafka import Producer<br>from confluent_kafka.serialization import SerializationContext, MessageField<br>from confluent_kafka.schema_registry.avro import AvroSerializer<br>from confluent_kafka.schema_registry import SchemaRegistryClient<br>from data_gen.generators.financial import TransactionGenerator<br>from decimal import Decimal<br>from datetime import datetime<br><br># Configuração<br>sr_client = SchemaRegistryClient({&#39;url&#39;: &#39;http://schema-registry:8081&#39;})<br><br># Buscar schema com regras de Data Contract<br>schema = sr_client.get_latest_version(&quot;banking.transactions-value&quot;)<br><br>avro_serializer = AvroSerializer(<br>    sr_client,<br>    schema.schema.schema_str,<br>    conf={&#39;auto.register.schemas&#39;: False}  # Usar schema existente<br>)<br><br>producer = Producer({<br>    &#39;bootstrap.servers&#39;: &#39;localhost:29092&#39;,<br>    &#39;acks&#39;: &#39;all&#39;<br>})<br><br># Gerador de transações bancárias realistas<br>tx_gen = TransactionGenerator(seed=42)<br><br>def transaction_to_dict(tx) -&gt; dict:<br>    &quot;&quot;&quot;Converte transação data-gen para dict compatível com o contrato.&quot;&quot;&quot;<br>    return {<br>        &#39;transaction_id&#39;: tx.transaction_id,<br>        &#39;account_id&#39;: tx.account_id,<br>        &#39;transaction_type&#39;: tx.transaction_type,<br>        &#39;amount&#39;: float(tx.amount),<br>        &#39;direction&#39;: tx.direction,<br>        &#39;counterparty_key&#39;: tx.counterparty_key,<br>        &#39;counterparty_name&#39;: tx.counterparty_name,<br>        &#39;description&#39;: tx.description,<br>        &#39;timestamp&#39;: int(tx.timestamp.timestamp() * 1000),<br>        &#39;status&#39;: tx.status,<br>        &#39;pix_e2e_id&#39;: tx.pix_e2e_id,<br>        &#39;pix_key_type&#39;: tx.pix_key_type<br>    }<br><br>def enviar_transacao(transaction: dict) -&gt; None:<br>    &quot;&quot;&quot;Envia transação para Kafka com validação do Data Contract.&quot;&quot;&quot;<br>    try:<br>        # Serialização inclui validação das regras CEL<br>        value = avro_serializer(<br>            transaction,<br>            SerializationContext(&quot;banking.transactions&quot;, MessageField.VALUE)<br>        )<br><br>        producer.produce(<br>            topic=&quot;banking.transactions&quot;,<br>            key=transaction[&#39;account_id&#39;].encode(&#39;utf-8&#39;),<br>            value=value,<br>            callback=lambda err, msg: print(<br>                f&quot;Erro: {err}&quot; if err else f&quot;Transação {transaction[&#39;transaction_id&#39;]} enviada&quot;<br>            )<br>        )<br>        producer.flush()<br><br>    except Exception as e:<br>        # Regra do Data Contract falhou<br>        print(f&quot;Violação do Data Contract: {e}&quot;)<br>        raise<br><br># Exemplo de uso com dados realistas<br>transaction = tx_gen.generate(account_id=&quot;ACC-456789&quot;)<br>tx_dict = transaction_to_dict(transaction)<br><br>enviar_transacao(tx_dict)<br># Output: Transação 7f8a9b2c-... enviada</pre><p>4.Consumer com Confiança no Contrato</p><pre>from confluent_kafka import Consumer<br>from confluent_kafka.schema_registry import SchemaRegistryClient<br>from confluent_kafka.schema_registry.avro import AvroDeserializer<br>from confluent_kafka.serialization import SerializationContext, MessageField<br><br>sr_client = SchemaRegistryClient({&#39;url&#39;: &#39;http://schema-registry:8081&#39;})<br><br>avro_deserializer = AvroDeserializer(<br>    sr_client,<br>    conf={&#39;use.latest.version&#39;: True}<br>)<br><br>consumer = Consumer({<br>    &#39;bootstrap.servers&#39;: &#39;localhost:29092&#39;,<br>    &#39;group.id&#39;: &#39;fraud-detector&#39;,<br>    &#39;auto.offset.reset&#39;: &#39;earliest&#39;<br>})<br><br>consumer.subscribe([&#39;banking.transactions&#39;])<br><br>def processar_transacao(transaction: dict) -&gt; None:<br>    &quot;&quot;&quot;<br>    Processa transação com confiança no Data Contract.<br><br>    Garantias do contrato:<br>    - amount &gt; 0 (validado na produção)<br>    - transaction_type válido (PIX, TED, DOC, etc.)<br>    - account_id presente (required no schema)<br>    &quot;&quot;&quot;<br>    print(f&quot;Processando transação {transaction[&#39;transaction_id&#39;]}&quot;)<br>    print(f&quot;  Conta: {transaction[&#39;account_id&#39;]}&quot;)<br>    print(f&quot;  Tipo: {transaction[&#39;transaction_type&#39;]}&quot;)<br>    print(f&quot;  Valor: R$ {transaction[&#39;amount&#39;]:.2f}&quot;)<br><br>    # Pode confiar que amount &gt; 0, não precisa validar novamente<br>    analisar_fraude(transaction[&#39;transaction_id&#39;], transaction[&#39;amount&#39;])<br><br>try:<br>    while True:<br>        msg = consumer.poll(timeout=1.0)<br><br>        if msg is None:<br>            continue<br>        if msg.error():<br>            continue<br><br>        transaction = avro_deserializer(<br>            msg.value(),<br>            SerializationContext(msg.topic(), MessageField.VALUE)<br>        )<br><br>        processar_transacao(transaction)<br><br>finally:<br>    consumer.close()</pre><h3>Regras de Qualidade Avançadas</h3><p>O Confluent Schema Registry suporta diferentes tipos de regras [4]:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FnimkV%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FnimkV%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FnimkV%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="272" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a7ceda295712b8aee24f1c5b1e03ebb/href">https://medium.com/media/3a7ceda295712b8aee24f1c5b1e03ebb/href</a></iframe><pre>Exemplo: Proteção de PII<br>{<br>  &quot;ruleSet&quot;: {<br>    &quot;domainRules&quot;: [<br>      {<br>        &quot;name&quot;: &quot;maskCPF&quot;,<br>        &quot;kind&quot;: &quot;TRANSFORM&quot;,<br>        &quot;mode&quot;: &quot;READ&quot;,<br>        &quot;type&quot;: &quot;CEL&quot;,<br>        &quot;expr&quot;: &quot;message.cpf.replaceAll(&#39;(\\\\d{3})\\\\d{6}(\\\\d{2})&#39;, &#39;$1******$2&#39;)&quot;<br>      },<br>      {<br>        &quot;name&quot;: &quot;encryptEmail&quot;,<br>        &quot;kind&quot;: &quot;TRANSFORM&quot;,<br>        &quot;mode&quot;: &quot;WRITE&quot;,<br>        &quot;type&quot;: &quot;ENCRYPT&quot;,<br>        &quot;tags&quot;: [&quot;PII.Email&quot;],<br>        &quot;params&quot;: {<br>          &quot;encrypt.kek.name&quot;: &quot;pii-key&quot;,<br>          &quot;encrypt.kms.type&quot;: &quot;gcp-kms&quot;<br>        }<br>      }<br>    ]<br>  }<br>}<br>Exemplo: Validação de Negócio<br>{<br>  &quot;ruleSet&quot;: {<br>    &quot;domainRules&quot;: [<br>      {<br>        &quot;name&quot;: &quot;validatePedidoCompleto&quot;,<br>        &quot;kind&quot;: &quot;CONDITION&quot;,<br>        &quot;mode&quot;: &quot;WRITE&quot;,<br>        &quot;type&quot;: &quot;CEL&quot;,<br>        &quot;expr&quot;: &quot;message.total &gt; 0 &amp;&amp; size(message.itens) &gt; 0 &amp;&amp; message.cliente_id != &#39;&#39;&quot;<br>      },<br>      {<br>        &quot;name&quot;: &quot;validateLimiteValor&quot;,<br>        &quot;kind&quot;: &quot;CONDITION&quot;,<br>        &quot;mode&quot;: &quot;WRITE&quot;,<br>        &quot;type&quot;: &quot;CEL&quot;,<br>        &quot;expr&quot;: &quot;message.total &lt;= 100000&quot;,<br>        &quot;doc&quot;: &quot;Pedidos acima de R$100k requerem aprovação manual&quot;<br>      },<br>      {<br>        &quot;name&quot;: &quot;validateFreshness&quot;,<br>        &quot;kind&quot;: &quot;CONDITION&quot;,<br>        &quot;mode&quot;: &quot;WRITE&quot;,<br>        &quot;type&quot;: &quot;CEL&quot;,<br>        &quot;expr&quot;: &quot;message.created_at &gt; (now() - duration(&#39;5m&#39;))&quot;,<br>        &quot;doc&quot;: &quot;Rejeita eventos com mais de 5 minutos de atraso&quot;<br>      }<br>    ]<br>  }<br>}</pre><h3>Ciclo de Vida do Data Contract</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*9k_LHXpsidlyZYfv8MAD9w.png" /><figcaption>Ciclo de Vida — Design, Review, Implement, Operate &amp; Evolve</figcaption></figure><h3>1. Design</h3><pre># datacontract.yaml (Open Data Contract Standard)<br>dataContractSpecification: 0.9.3<br>id: vendas-pedido-criado<br>version: 1.0.0<br><br>info:<br>  title: Pedido Criado<br>  owner: Squad Checkout<br>  domain: Vendas<br>  description: Evento emitido quando um pedido é criado no checkout<br><br>servers:<br>  production:<br>    type: kafka<br>    host: kafka.ecommerce.com:9092<br>    topic: vendas.pedidos.criado.v1<br>    format: avro<br><br>terms:<br>  sla:<br>    availability: 99.99%<br>    latency_p95: 100ms<br>    freshness: 5s<br><br>quality:<br>  - field: total<br>    rule: &quot;&gt; 0&quot;<br>  - field: itens<br>    rule: &quot;size &gt; 0&quot;</pre><h3>2. Review</h3><p>Checklist de revisão do Data Contract:</p><p>☐ Schema segue naming conventions (dominio.entidade.acao.v{major})</p><p>☐ Campos PII identificados e taggeados</p><p>☐ Owner e contact definidos</p><p>☐ SLAs realistas e acordados com consumidores</p><p>☐ Regras de qualidade cobrem casos críticos</p><p>☐ Compatibilidade backward verificada</p><h3>3. Implement</h3><pre># Registrar schema com Data Contract<br>curl -X POST http://schema-registry:8081/subjects/vendas.pedidos.criado.v1-value/versions \<br>  -H &quot;Content-Type: application/vnd.schemaregistry.v1+json&quot; \<br>  -d @schema-with-contract.json<br><br># Verificar registro<br>curl http://schema-registry:8081/subjects/vendas.pedidos.criado.v1-value/versions/latest</pre><h3>4. Operate</h3><pre>-- Monitorar qualidade em tempo real (Flink SQL)<br>CREATE VIEW contract_violations AS<br>SELECT<br>  TUMBLE_START(event_time, INTERVAL &#39;1&#39; MINUTE) as window_start,<br>  COUNT(*) FILTER (WHERE total &lt;= 0) as invalid_total,<br>  COUNT(*) FILTER (WHERE itens IS NULL OR CARDINALITY(itens) = 0) as empty_itens,<br>  COUNT(*) as total_events<br>FROM pedidos<br>GROUP BY TUMBLE(event_time, INTERVAL &#39;1&#39; MINUTE);<br><br>-- Alertar violações<br>CREATE TABLE contract_alerts AS<br>SELECT *<br>FROM contract_violations<br>WHERE invalid_total &gt; 0 OR empty_itens &gt; 0;</pre><h3>5. Evolve</h3><pre>{<br>  &quot;schema&quot;: &quot;...&quot;,<br>  &quot;metadata&quot;: {<br>    &quot;properties&quot;: {<br>      &quot;version&quot;: &quot;1.1.0&quot;,<br>      &quot;changelog&quot;: &quot;Adicionado campo endereco_entrega (opcional)&quot;<br>    }<br>  },<br>  &quot;ruleSet&quot;: {<br>    &quot;migrationRules&quot;: [<br>      {<br>        &quot;name&quot;: &quot;addEnderecoDefault&quot;,<br>        &quot;kind&quot;: &quot;TRANSFORM&quot;,<br>        &quot;mode&quot;: &quot;READ&quot;,<br>        &quot;type&quot;: &quot;CEL&quot;,<br>        &quot;expr&quot;: &quot;message.endereco_entrega ?? &#39;N/A&#39;&quot;<br>      }<br>    ]<br>  }<br>}</pre><h3>Stream Governance na Confluent</h3><p>Para implementar Data Contracts em escala, a Confluent oferece o <strong>Stream Governance</strong> [5]:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2Frfl5S%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2Frfl5S%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2Frfl5S%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="200" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee999b1706bad78bba9b09f09a0a544d/href">https://medium.com/media/ee999b1706bad78bba9b09f09a0a544d/href</a></iframe><h3>Quando Usar Advanced?</h3><p>· Regras de validação (CEL expressions)</p><p>· Criptografia de PII automática</p><p>· Lineage point-in-time</p><p>· Organizações com requisitos de compliance (LGPD, PCI)</p><h3>Boas Práticas</h3><h3>Faça</h3><p>· <strong>Defina contratos antes de implementar</strong>: Design-first, não code-first</p><p>· <strong>Inclua SLAs realistas</strong>: Baseados em métricas históricas</p><p>· <strong>Tagueie PII desde o início</strong>: Facilita compliance depois</p><p>· <strong>Versione semanticamente</strong>: MAJOR para breaking changes</p><p>· <strong>Documente em português</strong>: Facilita adoção pelas equipes</p><h3>Evite</h3><p>· <strong>Evite regras muito complexas</strong>: CEL tem limitações, valide edge cases</p><p>· <strong>Evite schemas sem owner</strong>: Sem dono = sem responsável por quebras</p><p>· <strong>Evite mudar contratos sem comunicar</strong>: Notifique consumidores antes</p><h3>Conclusão</h3><p>Data Contracts são o alicerce da governança em streaming:</p><p>1. <strong>Definem expectativas claras</strong> entre produtores e consumidores</p><p>2. <strong>Garantem qualidade na origem</strong> com regras de validação</p><p>3. <strong>Protegem dados sensíveis</strong> com tags e transformações</p><p>4. <strong>Habilitam evolução segura</strong> com compatibilidade verificada</p><p>5. <strong>Criam confiança</strong> entre equipes de uma organização</p><p>Com o Confluent Schema Registry e Stream Governance Advanced, você pode implementar Data Contracts em escala, garantindo que seus dados em streaming sejam confiáveis, governados e de alta qualidade.</p><h3>Recursos</h3><p>· <a href="https://datacontract.com/">Data Contract Specification</a></p><p>· <a href="https://opendatacontract.com/">Open Data Contract Standard (ODCS)</a></p><p>· <a href="https://docs.confluent.io/platform/current/schema-registry/fundamentals/data-contracts.html">Confluent Schema Registry — Data Contracts</a></p><p>· <a href="https://docs.confluent.io/cloud/current/stream-governance/index.html">Stream Governance</a></p><h3>Referências</h3><p>1. <strong>Data Streaming Report 2025</strong>: <a href="https://www.confluent.io/resources/report/2025-data-streaming-report/">Confluent — Data Streaming Report</a></p><p>2. <strong>Data Contracts Concept</strong>: <a href="https://www.confluent.io/blog/data-contracts-confluent-schema-registry/">Confluent Blog — Data Contracts</a></p><p>3. <strong>Schema Registry Data Contracts</strong>: <a href="https://docs.confluent.io/platform/current/schema-registry/fundamentals/data-contracts.html">Confluent Documentation — Data Contracts</a></p><p>4. <strong>Data Contract Rules</strong>: <a href="https://docs.confluent.io/cloud/current/sr/fundamentals/data-contracts.html">Confluent Cloud — Data Contracts</a></p><p>5. <strong>Stream Governance Packages</strong>: <a href="https://docs.confluent.io/cloud/current/stream-governance/packages.html">Confluent Documentation — Stream Governance Packages</a></p><p>6. <strong>PII Protection with Data Contracts</strong>: <a href="https://www.confluent.io/blog/protect-pii-kafka-data-contracts/">Confluent Blog — Protect PII</a></p><p>7. <strong>Open Data Contract Standard</strong>: <a href="https://github.com/bitol-io/open-data-contract-standard">ODCS GitHub</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d226d6611138" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Confluent: O Ecossistema Enterprise para Apache Kafka]]></title>
            <link>https://mateus-oliveira.medium.com/confluent-o-ecossistema-enterprise-para-apache-kafka-da7cb215cc48?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/da7cb215cc48</guid>
            <category><![CDATA[confluent]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[data-streaming]]></category>
            <category><![CDATA[data-platforms]]></category>
            <category><![CDATA[kafka]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Fri, 06 Feb 2026 18:29:50 GMT</pubDate>
            <atom:updated>2026-02-06T18:29:50.673Z</atom:updated>
            <content:encoded><![CDATA[<p>Nos artigos anteriores, exploramos o <a href="https://mateus-oliveira.medium.com/apache-kafka-o-cora%C3%A7%C3%A3o-do-streaming-moderno-ef0f7a5ac6e5">Apache Kafka</a> e sua <a href="https://mateus-oliveira.medium.com/arquitetura-kafka-brokers-topics-partitions-e-offset-be4d95512924">arquitetura de Brokers, Topics, Partitions e Offsets</a>. Vimos que o Kafka é poderoso, mas gerenciar um cluster em produção exige muito mais do que apenas brokers rodando.</p><p><strong>O desafio</strong>: Como garantir que schemas não quebrem entre produtores e consumidores? Como conectar dezenas de bancos de dados sem escrever código? Como processar streams em tempo real com SQL? Como governar milhares de topics em uma organização com centenas de equipes?</p><p>A resposta está na <strong>Confluent</strong>, a empresa fundada pelos criadores do Kafka para resolver exatamente esses problemas. Em 2025, a Confluent foi reconhecida como <strong>líder no Forrester Wave para Streaming Data Platforms</strong> [1], recebendo a pontuação máxima em 14 de 18 critérios avaliados.</p><p><strong>Neste artigo, você vai aprender:</strong></p><ul><li>A história da Confluent e sua relação com o Apache Kafka</li><li>Os produtos disponíveis: Confluent Cloud vs Confluent Platform</li><li>Os componentes do ecossistema: Schema Registry, Connect, ksqlDB, Flink SQL</li><li>Stream Governance: como governar dados em streaming</li><li>Como escolher entre Cloud e Self-Managed</li></ul><h3>A Confluent e o Apache Kafka</h3><h3>A Origem</h3><p>O Apache Kafka foi criado em 2010 no <strong>LinkedIn</strong> por Jay Kreps, Neha Narkhede e Jun Rao para resolver o problema de integração de dados em tempo real. Em 2011, o projeto foi open-sourced e doado à Apache Software Foundation.</p><p>Em 2014, os mesmos criadores fundaram a <strong>Confluent</strong> com uma missão clara: transformar o Kafka de uma tecnologia complexa em uma <strong>plataforma completa de Data Streaming</strong> acessível a qualquer empresa.</p><h3>O Que a Confluent Adiciona ao Kafka</h3><p>O Apache Kafka open source fornece o core de mensageria. A Confluent adiciona todo o ecossistema necessário para produção enterprise:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*xRXNefG8wkMAbwNLHxRJxg.png" /><figcaption>Ecossistema Confluent</figcaption></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FYhHta%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FYhHta%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FYhHta%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="440" frameborder="0" scrolling="no"><a href="https://medium.com/media/59a46ffa6c0b70a0d3974d6d2c1d387d/href">https://medium.com/media/59a46ffa6c0b70a0d3974d6d2c1d387d/href</a></iframe><h3>Opções de Deployment: Cloud vs Platform</h3><p>A Confluent oferece duas formas de usar a plataforma:</p><h3>Confluent Cloud (Fully Managed)</h3><p>Serviço gerenciado onde a Confluent cuida de toda a infraestrutura. Você foca apenas em produzir e consumir dados.</p><p><strong>Ideal para:</strong> — Equipes que querem começar rápido sem overhead operacional — Empresas que preferem OpEx sobre CapEx — Workloads com demanda variável (auto-scaling)</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FuStTW%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FuStTW%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FuStTW%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="490" frameborder="0" scrolling="no"><a href="https://medium.com/media/dede10a6a792b0f1fb65408d4f591bbb/href">https://medium.com/media/dede10a6a792b0f1fb65408d4f591bbb/href</a></iframe><h4>Basic</h4><p>Cluster para experimentação e desenvolvimento inicial. Escala automaticamente com eCKUs, mas tem limitações significativas: sem RBAC para recursos do cluster, sem mTLS, sem audit logs. <strong>Não use em produção.</strong></p><h4>Standard</h4><p>Primeiro tier com features production-ready: RBAC, private networking, Stream Sharing. SLA de 99.99% disponível com mínimo de 2 eCKUs. Boa relação custo-benefício para workloads de volume moderado.</p><h4>Enterprise</h4><p>Para organizações que exigem <strong>private networking avançado</strong> (PNI, PrivateLink, VPC Peering, Transit Gateway). Suporta mTLS, audit logs, self-managed encryption keys e fast scaling até 10 eCKUs. Escala até 32 eCKUs com PNI [3].</p><h4>Dedicated</h4><p>O tipo mais robusto, com <strong>recursos pré-alocados</strong> (CKUs, não eCKUs). Ao contrário dos outros tipos, não escala automaticamente — você define a capacidade. Ideal quando previsibilidade e isolamento total são requisitos. Suporte a todas as opções de networking.</p><h4>Freight (Novo em 2025)</h4><p>Lançado no Q1 2025, o <strong>Freight</strong> é projetado para workloads de <strong>alto throughput com latência relaxada</strong> [5]. Usa a tecnologia “direct write” do Kora engine para escrever diretamente no object storage (S3), eliminando a replicação multi-AZ cara.</p><p><strong>Economia</strong>: Clientes early access reportaram <strong>até 90% de redução em custos de infraestrutura</strong> comparado a clusters tradicionais [6].</p><p><strong>Casos de uso ideais:</strong></p><ul><li>Logging e monitoramento de alto volume</li><li>Ingestão massiva de dados IoT</li><li>Pipelines de ETL onde latência de segundos é aceitável</li><li>Backup e replicação de dados</li></ul><p><strong>Limitações do Freight:</strong></p><ul><li>Sem suporte a produtores idempotentes</li><li>Sem transações (exactly-once semântico não disponível)</li><li>Sem log compaction</li><li>Disponível apenas em regiões AWS selecionadas</li><li>Sem ksqlDB ou Custom Connectors</li><li>Requer clientes otimizados</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*QBvOHqv_9W-9E2FZUEt9gQ.png" /><figcaption><em>Comparação dos modelos de escala eCKU (elástico) vs CKU (manual)</em></figcaption></figure><h3>Confluent Platform (Self-Managed)</h3><p>Software que você instala e gerencia na sua própria infraestrutura (VMs, Kubernetes, bare metal).</p><p><strong>Ideal para:</strong></p><ul><li>Requisitos rígidos de residência de dados (LGPD, BACEN)</li><li>Integrações complexas com sistemas legados</li><li>Organizações com equipes de SRE dedicadas</li><li>Escala muito grande (100+ brokers)</li></ul><p><strong>Opções de Deployment:</strong></p><ul><li><strong>Confluent for Kubernetes (CFK)</strong>: Operator para Kubernetes</li><li><strong>Ansible/Terraform</strong>: Automação para VMs</li><li><strong>Manual</strong>: Instalação tradicional em VMs</li></ul><h3>Os Componentes do Ecossistema</h3><h3>1. Schema Registry: Contratos de Dados</h3><p>O <strong>Schema Registry</strong> é o componente que garante que produtores e consumidores concordem sobre a estrutura dos dados. Sem ele, uma mudança no formato de uma mensagem pode quebrar dezenas de consumers.</p><p><strong>Formatos Suportados:</strong></p><ul><li><strong>Apache Avro</strong>: Mais eficiente, schema evolution nativo</li><li><strong>Protocol Buffers</strong>: Popular em microservices gRPC</li><li><strong>JSON Schema</strong>: Familiar para desenvolvedores web</li></ul><p><strong>Exemplo Real: E-commerce com Schema Evolution</strong></p><p>Seu topic pedidos começou com um schema simples:</p><pre>{<br>  &quot;type&quot;: &quot;record&quot;,<br>  &quot;name&quot;: &quot;Pedido&quot;,<br>  &quot;namespace&quot;: &quot;br.com.ecommerce&quot;,<br>  &quot;fields&quot;: [<br>    {&quot;name&quot;: &quot;pedido_id&quot;, &quot;type&quot;: &quot;string&quot;},<br>    {&quot;name&quot;: &quot;cliente_id&quot;, &quot;type&quot;: &quot;string&quot;},<br>    {&quot;name&quot;: &quot;total&quot;, &quot;type&quot;: &quot;double&quot;}<br>  ]<br>}</pre><p>Meses depois, você precisa adicionar informações de frete. Com Schema Registry e compatibilidade BACKWARD:</p><pre>{<br>  &quot;type&quot;: &quot;record&quot;,<br>  &quot;name&quot;: &quot;Pedido&quot;,<br>  &quot;namespace&quot;: &quot;br.com.ecommerce&quot;,<br>  &quot;fields&quot;: [<br>    {&quot;name&quot;: &quot;pedido_id&quot;, &quot;type&quot;: &quot;string&quot;},<br>    {&quot;name&quot;: &quot;cliente_id&quot;, &quot;type&quot;: &quot;string&quot;},<br>    {&quot;name&quot;: &quot;total&quot;, &quot;type&quot;: &quot;double&quot;},<br>    {&quot;name&quot;: &quot;frete&quot;, &quot;type&quot;: [&quot;null&quot;, &quot;double&quot;], &quot;default&quot;: null},<br>    {&quot;name&quot;: &quot;endereco_entrega&quot;, &quot;type&quot;: [&quot;null&quot;, &quot;string&quot;], &quot;default&quot;: null}<br>  ]<br>}</pre><p>Os consumers antigos continuam funcionando (campos novos têm default null), enquanto consumers novos podem usar os campos adicionais.</p><pre>from confluent_kafka.schema_registry import SchemaRegistryClient<br>from confluent_kafka.schema_registry.avro import AvroSerializer<br><br># Configurar Schema Registry<br>sr_client = SchemaRegistryClient({&#39;url&#39;: &#39;http://schema-registry:8081&#39;})<br><br># Serializer com registro automático de schema<br>avro_serializer = AvroSerializer(<br>    sr_client,<br>    schema_str=pedido_schema,<br>    conf={&#39;auto.register.schemas&#39;: True}<br>)</pre><h3>2. Kafka Connect: Integração sem Código</h3><p>O <strong>Kafka Connect</strong> permite mover dados entre Kafka e sistemas externos (bancos, data warehouses, SaaS) sem escrever código.</p><p><strong>120+ Connectors Disponíveis:</strong></p><ul><li><strong>Databases</strong>: PostgreSQL CDC, MySQL CDC, MongoDB, Oracle</li><li><strong>Cloud Storage</strong>: S3, GCS, Azure Blob</li><li><strong>Data Warehouses</strong>: BigQuery, Snowflake, Databricks</li><li><strong>SaaS</strong>: Salesforce, ServiceNow, Elasticsearch</li></ul><p><strong>Exemplo Real: CDC do PostgreSQL para Kafka</strong></p><p>Capturar mudanças do banco de pedidos em tempo real:</p><pre>{<br>  &quot;name&quot;: &quot;postgres-pedidos-source&quot;,<br>  &quot;config&quot;: {<br>    &quot;connector.class&quot;: &quot;io.debezium.connector.postgresql.PostgresConnector&quot;,<br>    &quot;database.hostname&quot;: &quot;postgres-pedidos&quot;,<br>    &quot;database.port&quot;: &quot;5432&quot;,<br>    &quot;database.user&quot;: &quot;kafka_cdc&quot;,<br>    &quot;database.password&quot;: &quot;${secrets:postgres-password}&quot;,<br>    &quot;database.dbname&quot;: &quot;ecommerce&quot;,<br>    &quot;table.include.list&quot;: &quot;public.pedidos,public.itens_pedido&quot;,<br>    &quot;topic.prefix&quot;: &quot;cdc.ecommerce&quot;,<br>    &quot;slot.name&quot;: &quot;kafka_slot&quot;,<br>    &quot;publication.name&quot;: &quot;kafka_publication&quot;,<br>    &quot;snapshot.mode&quot;: &quot;initial&quot;<br>  }<br>}</pre><p>Cada INSERT, UPDATE ou DELETE na tabela pedidos gera automaticamente um evento no topic cdc.ecommerce.public.pedidos.</p><p><strong>Sink para BigQuery (Analytics):</strong></p><pre>{<br>  &quot;name&quot;: &quot;bigquery-pedidos-sink&quot;,<br>  &quot;config&quot;: {<br>    &quot;connector.class&quot;: &quot;com.wepay.kafka.connect.bigquery.BigQuerySinkConnector&quot;,<br>    &quot;topics&quot;: &quot;cdc.ecommerce.public.pedidos&quot;,<br>    &quot;project&quot;: &quot;meu-projeto-gcp&quot;,<br>    &quot;defaultDataset&quot;: &quot;streaming_data&quot;,<br>    &quot;autoCreateTables&quot;: &quot;true&quot;,<br>    &quot;tasks.max&quot;: &quot;3&quot;,<br>    &quot;errors.tolerance&quot;: &quot;all&quot;,<br>    &quot;errors.deadletterqueue.topic.name&quot;: &quot;dlq-bigquery&quot;<br>  }<br>}</pre><h3>3. ksqlDB e Flink SQL: Stream Processing</h3><p>Para processar streams em tempo real, a Confluent oferece duas opções:</p><p><strong>ksqlDB</strong>: SQL streaming nativo, ideal para transformações simples e agregações.</p><p><strong>Apache Flink SQL</strong>: Engine de stream processing mais poderoso, com suporte a complex event processing (CEP), exactly-once e integração com data lakes.</p><p><strong>Exemplo Real: Detecção de Fraude em Pagamentos</strong></p><pre>-- Criar stream a partir do topic de pagamentos<br>CREATE STREAM pagamentos (<br>  pagamento_id STRING,<br>  pedido_id STRING,<br>  valor DECIMAL(15,2),<br>  metodo STRING,<br>  cliente_id STRING,<br>  ip_origem STRING,<br>  event_time TIMESTAMP(3),<br>  WATERMARK FOR event_time AS event_time - INTERVAL &#39;5&#39; SECOND<br>) WITH (<br>  &#39;connector&#39; = &#39;kafka&#39;,<br>  &#39;topic&#39; = &#39;pagamentos&#39;,<br>  &#39;properties.bootstrap.servers&#39; = &#39;kafka:9092&#39;,<br>  &#39;value.format&#39; = &#39;avro-confluent&#39;,<br>  &#39;value.avro-confluent.url&#39; = &#39;http://schema-registry:8081&#39;<br>);<br><br>-- Detectar padrões suspeitos: &gt;5 pagamentos em 5 minutos do mesmo cliente<br>INSERT INTO alertas_fraude<br>SELECT<br>  cliente_id,<br>  COUNT(*) as num_transacoes,<br>  SUM(valor) as valor_total,<br>  COLLECT(ip_origem) as ips_utilizados,<br>  TUMBLE_END(event_time, INTERVAL &#39;5&#39; MINUTE) as janela_fim<br>FROM pagamentos<br>GROUP BY<br>  cliente_id,<br>  TUMBLE(event_time, INTERVAL &#39;5&#39; MINUTE)<br>HAVING COUNT(*) &gt; 5 OR SUM(valor) &gt; 10000;</pre><h3>4. Stream Governance: Governança para Streaming</h3><p>À medida que o número de topics cresce, a governança se torna crítica. O <strong>Stream Governance</strong> da Confluent oferece:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/1*S-wz9UMtCOWEWOyd4ZSAoQ.png" /><figcaption><em>Componentes do Stream Governance — Catalog, Lineage, Quality</em></figcaption></figure><p><strong>Stream Catalog</strong>: Descoberta de dados self-service</p><ul><li>Busque topics por nome, tags ou metadados</li><li>Documente schemas e significado de negócio</li><li>Defina owners e SLAs por topic</li></ul><p><strong>Stream Lineage</strong>: Visualização do fluxo de dados</p><ul><li>Mapa interativo de onde os dados vêm e para onde vão</li><li>Identifique impacto de mudanças (quem consome este topic?)</li><li>Essencial para compliance e auditoria</li></ul><p><strong>Data Quality Rules</strong>: Garantia de qualidade</p><ul><li>Defina regras no schema (campo não pode ser nulo, deve estar em range)</li><li>Validação automática na produção de mensagens</li><li>Métricas de qualidade por topic</li></ul><p><strong>Data Portal</strong>: Marketplace interno de dados</p><ul><li>Equipes publicam seus data products</li><li>Outras equipes descobrem e solicitam acesso</li><li>Governance descentralizado (Data Mesh)</li></ul><h3>Pricing: Como Estimar Custos no Confluent Cloud</h3><p>Um dos maiores desafios na adoção do Confluent Cloud é <strong>estimar custos com precisão</strong>. Vamos decompor o modelo de billing e fornecer um guia prático para estimativas [8].</p><h3>Modelo de Billing</h3><p>O Confluent Cloud cobra por <strong>consumo</strong>, não por provisionamento (exceto Dedicated). Os custos acumulam por hora em UTC [8].</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*EDpmqWFIzgxgfb8cfUprkQ.png" /><figcaption><em>Componentes do custo Confluent Cloud — Stream, Connect, Process, Govern.</em></figcaption></figure><h3>Dimensões de Custo Detalhadas</h3><h4>1. Kafka Cluster (Stream)</h4><p>O custo do cluster depende de <strong>três fatores</strong> [8]:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2F4M1iS%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2F4M1iS%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2F4M1iS%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="205" frameborder="0" scrolling="no"><a href="https://medium.com/media/9d18688e9d2ee4f7b262645dcf603365/href">https://medium.com/media/9d18688e9d2ee4f7b262645dcf603365/href</a></iframe><p><strong>Importante sobre storage</strong>: O Confluent Cloud usa fator de replicação 3 para alta disponibilidade. Isso significa que 1 GB escrito se torna ~3 GB de storage cobrado [8].</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2F5d3HN%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2F5d3HN%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2F5d3HN%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="219" frameborder="0" scrolling="no"><a href="https://medium.com/media/30f99cf48faaed2f57ad8a4ff5e17e13/href">https://medium.com/media/30f99cf48faaed2f57ad8a4ff5e17e13/href</a></iframe><h4>2. Connectors (Connect)</h4><p>Connectors são cobrados por duas dimensões [7]:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FOpMvJ%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FOpMvJ%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FOpMvJ%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="168" frameborder="0" scrolling="no"><a href="https://medium.com/media/8dd09418f600a6a8582228959465ceca/href">https://medium.com/media/8dd09418f600a6a8582228959465ceca/href</a></iframe><p><strong>Nota</strong>: Connectors pausados ainda incorrem no custo base por task. Se não estiver usando, delete o connector [8].</p><h4>3. Flink (Process)</h4><p>O Apache Flink no Confluent Cloud usa <strong>CFUs (Confluent Flink Units)</strong> [9]:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FIAunF%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FIAunF%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FIAunF%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="205" frameborder="0" scrolling="no"><a href="https://medium.com/media/a7f1ac476ebeabbea930e8b1eeae2816/href">https://medium.com/media/a7f1ac476ebeabbea930e8b1eeae2816/href</a></iframe><p><strong>Exemplo</strong>: 5 queries interativas consumindo 5 CFU-minutos = 5 x $0.0035 = <strong>$0.0175</strong> [9].</p><h4>4. Stream Governance (Govern)</h4><p>Cobrado por <strong>environment por hora</strong>. Inclui Schema Registry, Stream Catalog, Stream Lineage e Data Portal.</p><h3>Multiplicadores Regionais</h3><p>Preços base se aplicam à região us-east-1 (AWS). Outras regiões têm multiplicadores. As regiões da América do Sul geralmente têm multiplicador mais alto [8].</p><p><strong>Dica</strong>: Use a <a href="https://www.confluent.io/pricing/cost-estimator/">Confluent Cost Estimator</a> para obter valores exatos por região [10].</p><h3>Guia Prático: Como Estimar Custos</h3><p>Para estimar o custo mensal, siga este framework:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*31B9LqOxUpm2jIZd1a2cuQ.png" /><figcaption><em>Fórmula passo a passo para estimar custos mensais no Confluent Cloud.</em></figcaption></figure><p><strong>Nota</strong>: Os valores abaixo são estimativas baseadas na documentação pública da Confluent e servem como referência para dimensionamento. Preços exatos variam por região e devem ser verificados na <a href="https://www.confluent.io/confluent-cloud/pricing/">página de pricing</a> ou no <a href="https://www.confluent.io/pricing/cost-estimator/">Cost Estimator</a> [8] [10].</p><h4>Cenário 1: Startup (Standard Cluster)</h4><pre>Perfil: 10K msgs/seg, 1 KB avg, 7 dias retenção, 3 consumers<br><br>Throughput:<br>  Ingress:  ~860 GB/dia (10K × 1KB × 86.400)<br>  Egress:   ~2.580 GB/dia (860 × 3 consumers)<br><br>eCKUs necessários: ~1-2 (pico de ~10 MB/s ingress)<br><br>Estimativa mensal (verificar no Cost Estimator):<br>  Cluster (Standard eCKUs):     ~$500-800/mês<br>  Networking (ingress + egress): ~$200-400/mês<br>  Storage (860 × 7 × 3 = 18TB): ~$150-300/mês<br>  Schema Registry:               ~$50-100/mês<br>  ─────────────────────────────────────────────<br>  Total estimado:                ~$900-1.600/mês</pre><h4>Cenário 2: Enterprise Médio (Enterprise Cluster)</h4><pre>Perfil: 100K msgs/seg, 1 KB avg, 14 dias retenção, 5 consumers, 3 connectors<br><br>Throughput:<br>  Ingress:  ~8.6 TB/dia<br>  Egress:   ~43 TB/dia<br><br>eCKUs necessários: ~3-5 (pico de ~100 MB/s ingress)<br><br>Estimativa mensal (verificar no Cost Estimator):<br>  Cluster (Enterprise eCKUs):    ~$3.000-5.000/mês<br>  Networking (ingress + egress):  ~$1.500-3.000/mês<br>  Storage (8.6 × 14 × 3 = 360TB): ~$500-1.000/mês<br>  Connectors (3 tasks):           ~$300-600/mês<br>  Flink (2 CFUs médios):          ~$300-500/mês<br>  Governance:                     ~$100-200/mês<br>  ─────────────────────────────────────────────────<br>  Total estimado:                 ~$5.700-10.300/mês</pre><h4>Cenário 3: Alto Volume com Freight</h4><pre>Perfil: 500K msgs/seg (logging), 0.5 KB avg, 3 dias retenção, 1 consumer<br><br>Throughput:<br>  Ingress:  ~21.5 TB/dia<br>  Egress:   ~21.5 TB/dia<br><br>Freight: Até 90% mais barato que clusters tradicionais [6]<br><br>Estimativa mensal (verificar no Cost Estimator):<br>  Cluster (Freight eCKUs):       ~$500-1.500/mês (vs ~$5K-15K Enterprise)<br>  Networking:                     ~$1.000-2.000/mês<br>  Storage (21.5 × 3 × 3 = 193TB): ~$200-500/mês<br>  ────────────────────────────────────────────────<br>  Total estimado:                 ~$1.700-4.000/mês</pre><h3>Comparativo: Quando Usar Cada Opção</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FwKwdl%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FwKwdl%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FwKwdl%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="335" frameborder="0" scrolling="no"><a href="https://medium.com/media/db73d50633c4232173dbb0d81bfc5ef6/href">https://medium.com/media/db73d50633c4232173dbb0d81bfc5ef6/href</a></iframe><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FQfA9t%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FQfA9t%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FQfA9t%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="277" frameborder="0" scrolling="no"><a href="https://medium.com/media/1970ae04e11372d213c6f627d801fc1f/href">https://medium.com/media/1970ae04e11372d213c6f627d801fc1f/href</a></iframe><p><strong>Nota</strong>: Para a maioria dos casos, Confluent Cloud é mais econômico que self-managed quando se consideram custos de operação (FTE dedicado para SRE, patching, upgrades, disaster recovery).</p><h3>Começando com Confluent Cloud</h3><p>Para testar rapidamente, o Confluent Cloud oferece <strong>$400 em créditos gratuitos</strong> para novos usuários.</p><ol><li><strong>Criar Cluster via Terraform:</strong></li></ol><pre># main.tf<br>terraform {<br>  required_providers {<br>    confluent = {<br>      source  = &quot;confluentinc/confluent&quot;<br>      version = &quot;~&gt; 1.55&quot;<br>    }<br>  }<br>}<br><br>provider &quot;confluent&quot; {<br>  cloud_api_key    = var.confluent_cloud_api_key<br>  cloud_api_secret = var.confluent_cloud_api_secret<br>}<br><br>resource &quot;confluent_environment&quot; &quot;ecommerce&quot; {<br>  display_name = &quot;ecommerce-prod&quot;<br>}<br><br>resource &quot;confluent_kafka_cluster&quot; &quot;main&quot; {<br>  display_name = &quot;ecommerce-cluster&quot;<br>  availability = &quot;MULTI_ZONE&quot;<br>  cloud        = &quot;GCP&quot;<br>  region       = &quot;southamerica-east1&quot;<br><br>  standard {}<br><br>  environment {<br>    id = confluent_environment.ecommerce.id<br>  }<br>}<br><br>resource &quot;confluent_kafka_topic&quot; &quot;pedidos&quot; {<br>  kafka_cluster {<br>    id = confluent_kafka_cluster.main.id<br>  }<br><br>  topic_name       = &quot;pedidos&quot;<br>  partitions_count = 6<br><br>  config = {<br>    &quot;retention.ms&quot; = &quot;604800000&quot;  # 7 dias<br>  }<br><br>  rest_endpoint = confluent_kafka_cluster.main.rest_endpoint<br>}</pre><p><strong>2. Criar Service Account e API Key:</strong></p><pre>resource &quot;confluent_service_account&quot; &quot;app_producer&quot; {<br>  display_name = &quot;app-pedidos-producer&quot;<br>  description  = &quot;Service account para aplicação de pedidos&quot;<br>}<br><br>resource &quot;confluent_api_key&quot; &quot;app_producer&quot; {<br>  display_name = &quot;app-pedidos-api-key&quot;<br><br>  owner {<br>    id          = confluent_service_account.app_producer.id<br>    api_version = confluent_service_account.app_producer.api_version<br>    kind        = confluent_service_account.app_producer.kind<br>  }<br><br>  managed_resource {<br>    id          = confluent_kafka_cluster.main.id<br>    api_version = confluent_kafka_cluster.main.api_version<br>    kind        = confluent_kafka_cluster.main.kind<br>    environment {<br>      id = confluent_environment.ecommerce.id<br>    }<br>  }<br>}<br><br>resource &quot;confluent_kafka_acl&quot; &quot;app_producer_write&quot; {<br>  kafka_cluster {<br>    id = confluent_kafka_cluster.main.id<br>  }<br><br>  resource_type = &quot;TOPIC&quot;<br>  resource_name = &quot;pedidos&quot;<br>  pattern_type  = &quot;LITERAL&quot;<br>  principal     = &quot;User:${confluent_service_account.app_producer.id}&quot;<br>  host          = &quot;*&quot;<br>  operation     = &quot;WRITE&quot;<br>  permission    = &quot;ALLOW&quot;<br><br>  rest_endpoint = confluent_kafka_cluster.main.rest_endpoint<br>}</pre><h3>Boas Práticas</h3><h3>Faça</h3><ul><li><strong>Use Schema Registry desde o dia 1</strong>: Evite dívida técnica de schemas inconsistentes</li><li><strong>Defina naming conventions</strong>: &lt;dominio&gt;.&lt;entidade&gt;.&lt;versao&gt; para topics</li><li><strong>Implemente RBAC</strong>: Service accounts com permissões mínimas necessárias</li><li><strong>Monitore consumer lag</strong>: Alerte quando lag ultrapassar threshold</li></ul><h3>Evite</h3><ul><li><strong>Evite Basic clusters em produção</strong>: SLA de 99.5% não é suficiente para apps críticas</li><li><strong>Evite schemas sem compatibilidade</strong>: Configure BACKWARD ou FORWARD sempre</li><li><strong>Evite connectors sem DLQ</strong>: Configure dead-letter-queue para erros</li></ul><p>A Confluent transformou o Apache Kafka de uma tecnologia de infraestrutura em uma <strong>plataforma completa de Data Streaming</strong>:</p><ol><li><strong>5 tipos de cluster</strong> para cada perfil: Basic (dev), Standard (produção), Enterprise (private networking), Dedicated (isolamento), Freight (alto volume low-cost)</li><li><strong>Schema Registry</strong> garante contratos de dados entre equipes</li><li><strong>Kafka Connect</strong> integra sistemas sem escrever código</li><li><strong>ksqlDB e Flink SQL</strong> processam streams com SQL</li><li><strong>Stream Governance</strong> traz descoberta, lineage e qualidade</li><li><strong>Pricing transparente</strong> baseado em consumo com eCKUs elásticos</li></ol><p>Para a maioria das empresas, <strong>Confluent Cloud Standard</strong> é o caminho mais rápido para começar. Para workloads de alto volume e baixo custo, <strong>Freight</strong> é uma revolução. Para requisitos específicos de compliance ou escala, <strong>Confluent Platform</strong> oferece controle total.</p><h3>Recursos</h3><ul><li><a href="https://www.confluent.io/confluent-cloud/tryfree/">Confluent Cloud — 400 créditos gratuitos</a></li><li><a href="https://docs.confluent.io/platform/current/overview.html">Documentação Confluent Platform</a></li><li><a href="https://developer.confluent.io/">Confluent Developer</a></li><li><a href="https://www.confluent.io/resources/kafka-the-definitive-guide/">Kafka: The Definitive Guide (O’Reilly)</a></li></ul><h3>Referências</h3><ol><li><strong>Forrester Wave Leader 2025</strong>: <a href="https://www.confluent.io/blog/forrester-2025-streaming-data-platform-leader/">Confluent: A Leader in Forrester Wave Streaming Data Platforms Q4&#39;25</a></li><li><strong>Confluent Platform Overview</strong>: <a href="https://docs.confluent.io/platform/current/get-started/platform.html">Confluent Documentation — Platform Overview</a></li><li><strong>Confluent Cloud Cluster Types</strong>: <a href="https://docs.confluent.io/cloud/current/clusters/cluster-types.html">Kafka Cluster Types in Confluent Cloud</a></li><li><strong>Stream Governance</strong>: <a href="https://docs.confluent.io/cloud/current/stream-governance/index.html">Confluent Documentation — Stream Governance</a></li><li><strong>Confluent Cloud Q1 2025 Launch (Freight, Tableflow)</strong>: <a href="https://www.confluent.io/blog/2025-q1-confluent-cloud-launch/">Confluent Blog — Q1 2025 Launch</a></li><li><strong>Freight Clusters GA</strong>: <a href="https://www.confluent.io/blog/freight-clusters-are-generally-available/">Confluent Blog — Freight Clusters Are Generally Available</a></li><li><strong>Confluent Connectors</strong>: <a href="https://www.confluent.io/hub/">Confluent Marketplace — Connectors</a></li><li><strong>Confluent Cloud Billing</strong>: <a href="https://docs.confluent.io/cloud/current/billing/overview.html">Manage Billing in Confluent Cloud</a></li><li><strong>Flink Billing</strong>: <a href="https://docs.confluent.io/cloud/current/flink/concepts/flink-billing.html">Billing in Confluent Cloud for Apache Flink</a></li><li><strong>Confluent Cost Estimator</strong>: <a href="https://www.confluent.io/pricing/cost-estimator/">Estimate Confluent Cloud Costs</a></li><li><strong>Schema Registry</strong>: <a href="https://docs.confluent.io/platform/current/schema-registry/index.html">Confluent Documentation — Schema Registry</a></li><li><strong>Confluent Cloud Pricing</strong>: <a href="https://www.confluent.io/confluent-cloud/pricing/">Confluent Cloud Pricing</a></li><li><strong>Elastic CKUs</strong>: <a href="https://www.confluent.io/blog/sizing-scaling-kafka-clusters-with-confluent-cloud/">Kafka Scaling Reinvented with Elastic CKUs</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da7cb215cc48" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Arquitetura Kafka: Brokers, Topics, Partitions e Offset]]></title>
            <link>https://mateus-oliveira.medium.com/arquitetura-kafka-brokers-topics-partitions-e-offset-be4d95512924?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/be4d95512924</guid>
            <category><![CDATA[data]]></category>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[apache-spark]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[kafka]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Thu, 29 Jan 2026 13:03:14 GMT</pubDate>
            <atom:updated>2026-01-29T13:03:14.475Z</atom:updated>
            <content:encoded><![CDATA[<p>Mergulhe na arquitetura distribuída do Kafka e entenda como seus componentes trabalham juntos para processar trilhões de eventos</p><p>No artigo anterior, <a href="https://medium.com/p/ef0f7a5ac6e5">Apache Kafka: O Coração do Streaming Moderno</a>, vimos que o Kafka é uma plataforma de streaming que processa mais de <strong>1,1 trilhão de mensagens por dia</strong> globalmente [1]. Mas como ele consegue essa escala impressionante?</p><p>A resposta está na sua <strong>arquitetura distribuída</strong>. Diferente de filas tradicionais que centralizam mensagens em um único servidor, o Kafka distribui dados entre múltiplos brokers, usa partições para paralelismo e rastreia posição através de offsets. Cada decisão de design foi pensada para maximizar throughput sem sacrificar durabilidade.</p><p><strong>Neste artigo, você vai aprender:</strong></p><ul><li>Como <strong>Brokers</strong> formam um cluster e garantem alta disponibilidade</li><li>Por que <strong>Topics e Partitions</strong> são a chave para escalabilidade</li><li>O papel dos <strong>Offsets</strong> no rastreamento de mensagens</li><li>Exemplos práticos de um sistema de e-commerce com a biblioteca <strong>confluent-kafka</strong></li></ul><h3>Visão Geral da Arquitetura</h3><p>Antes de mergulhar em cada componente, veja como eles se conectam:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hBPIM_IeUhr2eieM4BGFRQ.png" /><figcaption>Visão Geral Arquitetura Kafka</figcaption></figure><p>O fluxo é simples: <strong>Producers</strong> enviam eventos para <strong>Topics</strong>, que são divididos em <strong>Partitions</strong> distribuídas entre <strong>Brokers</strong>. Cada mensagem recebe um <strong>Offset</strong> único dentro da sua partition. Cada componente foi projetado para escalar horizontalmente.</p><h3>Brokers: Os Servidores do Cluster</h3><p>Um <strong>Broker</strong> é um servidor Kafka que armazena dados e atende requisições de clientes. Em produção, um cluster Kafka típico possui múltiplos brokers para garantir alta disponibilidade e distribuir a carga.</p><h3>Como os Brokers Funcionam</h3><p>Cada broker no cluster:</p><ul><li><strong>Armazena partições</strong> de um ou mais topics</li><li><strong>Recebe mensagens</strong> dos producers e as persiste em disco</li><li><strong>Atende requisições</strong> de consumers para leitura de dados</li><li><strong>Replica dados</strong> para outros brokers (tolerância a falhas)</li></ul><h3>Identificação e Coordenação</h3><p>Cada broker possui um <strong>ID único</strong> no cluster. Um dos brokers assume o papel de <strong>Controller</strong>, responsável por:</p><ul><li>Gerenciar a eleição de líderes para partições</li><li>Detectar falhas de brokers</li><li>Coordenar operações administrativas</li></ul><p><strong>Listando brokers do cluster:</strong></p><pre># Kafka CLI - Listar brokers e metadados<br>kafka-metadata --snapshot /var/kafka-logs/__cluster_metadata-0/00000000000000000000.log --command &quot;broker-list&quot;<br><br># Ou via kafka-broker-api-versions (mais comum)<br>kafka-broker-api-versions --bootstrap-server localhost:9092<br><br># kcat - Listar metadados do cluster (recomendado para debug)<br>kcat -b localhost:9092 -L<br>Saída do kcat -L:<br>Metadata for all topics (from broker 1: localhost:9092/1):<br> 3 brokers:<br>  broker 1 at localhost:9092 (controller)<br>  broker 2 at localhost:9093<br>  broker 3 at localhost:9094</pre><h3>Alta Disponibilidade</h3><p>Para garantir que o cluster continue operando mesmo com falhas, configure:</p><ul><li><strong>Mínimo de 3 brokers</strong> em produção</li><li><strong>Replication factor &gt;= 3</strong> para topics críticos</li><li><strong>min.insync.replicas = 2</strong> para garantir durabilidade</li></ul><h3>Topics: Organizando Seus Eventos</h3><p>Um <strong>Topic</strong> é uma categoria ou feed de mensagens. Pense nele como uma tabela em um banco de dados, mas otimizada para streaming.</p><h3>Exemplo Real: Topics de um E-commerce</h3><p>Um e-commerce típico organiza eventos em topics separados:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FN31Y7%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FN31Y7%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FN31Y7%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="322" frameborder="0" scrolling="no"><a href="https://medium.com/media/f61a83b53ccf10e49e4596a8e262d26c/href">https://medium.com/media/f61a83b53ccf10e49e4596a8e262d26c/href</a></iframe><h3>Criando Topics para o E-commerce</h3><pre># Topic de pedidos: 6 partições para alta vazão<br>kafka-topics --bootstrap-server localhost:9092 \<br>  --create \<br>  --topic pedidos \<br>  --partitions 6 \<br>  --replication-factor 3 \<br>  --config retention.ms=604800000<br><br># Topic de pagamentos: 3 partições (menor volume)<br>kafka-topics --bootstrap-server localhost:9092 \<br>  --create \<br>  --topic pagamentos \<br>  --partitions 3 \<br>  --replication-factor 3<br><br># Verificar configuração<br>kafka-topics --bootstrap-server localhost:9092 --describe --topic pedidos<br>Saída:<br>Topic: pedidos    PartitionCount: 6    ReplicationFactor: 3<br>  Partition: 0  Leader: 1  Replicas: 1,2,3  Isr: 1,2,3<br>  Partition: 1  Leader: 2  Replicas: 2,3,1  Isr: 2,3,1<br>  ...</pre><h3>Partitions: A Chave para Escalabilidade</h3><p><strong>Partitions</strong> são a unidade fundamental de paralelismo no Kafka. Cada topic é dividido em uma ou mais partitions, e cada partition é um log ordenado e imutável de mensagens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*hoGHLbM8SbF01Cd5UlEK3Q.png" /><figcaption>Partitions e Distribuição de Mensagens</figcaption></figure><h3>Por que Partitions são Importantes?</h3><ol><li><strong>Paralelismo</strong>: Múltiplos consumers podem ler de diferentes partitions simultaneamente</li><li><strong>Ordenação</strong>: Mensagens são ordenadas <strong>dentro de cada partition</strong></li><li><strong>Distribuição</strong>: Partitions são distribuídas entre brokers para balanceamento de carga</li></ol><h3>Exemplo Real: Garantindo Ordem de Pedidos por Cliente</h3><p>Um cliente faz 3 pedidos em sequência. Precisamos garantir que sejam processados na ordem correta:</p><pre>from confluent_kafka import Producer<br> import json<br> from datetime import datetime<br> <br> producer = Producer({<br> &#39;bootstrap.servers&#39;: &#39;localhost:9092&#39;,<br> &#39;acks&#39;: &#39;all&#39;<br> })<br> <br> def on_delivery(err, msg):<br> if err:<br> print(f&#39;Falha no envio: {err}&#39;)<br> else:<br> print(f&#39;Pedido enviado - Partition: {msg.partition()}, Offset: {msg.offset()}&#39;)<br> <br> # Pedidos do mesmo cliente (cliente_id como chave)<br> pedidos_cliente = [<br> {&#39;pedido_id&#39;: &#39;ped-001&#39;, &#39;cliente_id&#39;: &#39;cli-456&#39;, &#39;total&#39;: 150.00, &#39;itens&#39;: 2},<br> {&#39;pedido_id&#39;: &#39;ped-002&#39;, &#39;cliente_id&#39;: &#39;cli-456&#39;, &#39;total&#39;: 89.90, &#39;itens&#39;: 1},<br> {&#39;pedido_id&#39;: &#39;ped-003&#39;, &#39;cliente_id&#39;: &#39;cli-456&#39;, &#39;total&#39;: 320.00, &#39;itens&#39;: 5},<br> ]<br> <br> for pedido in pedidos_cliente:<br> pedido[&#39;timestamp&#39;] = datetime.now().isoformat()<br> <br> # Usando cliente_id como chave: todos vão para mesma partition<br> producer.produce(<br> topic=&#39;pedidos&#39;,<br> key=pedido[&#39;cliente_id&#39;],<br> value=json.dumps(pedido).encode(&#39;utf-8&#39;),<br> callback=on_delivery<br> )<br> <br> producer.flush()<br></pre><pre>Saída:<br>Pedido enviado - Partition: 2, Offset: 1000<br>Pedido enviado - Partition: 2, Offset: 1001<br>Pedido enviado - Partition: 2, Offset: 1002</pre><p>Todos os pedidos do cli-456 foram para a <strong>Partition 2</strong>, garantindo ordem de processamento.</p><h3>Dimensionando Partitions</h3><p>A Confluent recomenda 10–20 MB/s por partition [2]. Para um e-commerce com pico de 50 MB/s em pedidos:</p><p>Partitions = 50 MB/s / 10 MB/s = 5 partitions (arredonde para 6)</p><p><strong>Importante</strong>: Partitions não podem ser reduzidas depois de criadas. Comece conservador e aumente conforme necessário.</p><h3>Offsets: Rastreando a Posição nas Mensagens</h3><p>O <strong>Offset</strong> é um identificador sequencial único atribuído a cada mensagem dentro de uma partition. É o mecanismo que permite rastrear o progresso e habilita funcionalidades como replay.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*f-bG7yAq6hixEonjJKcqVA.png" /><figcaption>Estrutura de Offsets em uma Partition</figcaption></figure><h3>Exemplo Real: Monitorando Lag de Processamento</h3><p>Um sistema de detecção de fraude precisa processar pagamentos em tempo real. Se o consumer ficar atrasado (lag alto), fraudes podem passar despercebidas.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FkTxRm%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FkTxRm%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FkTxRm%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="242" frameborder="0" scrolling="no"><a href="https://medium.com/media/ebc93241fe0188d34b94483cc66f4643/href">https://medium.com/media/ebc93241fe0188d34b94483cc66f4643/href</a></iframe><p><strong>Consultando offsets:</strong></p><pre># Ver lag do consumer group<br> kafka-consumer-groups - bootstrap-server localhost:9092 \<br> - describe - group detector-fraude<br>Saída:<br>GROUP TOPIC PARTITION CURRENT-OFFSET LOG-END-OFFSET LAG<br> detector-fraude pagamentos 0 9500 10000 500<br> detector-fraude pagamentos 1 8200 8200 0<br> detector-fraude pagamentos 2 7800 7900 100</pre><h3>Trabalhando com Offsets em Python</h3><pre>from confluent_kafka import Consumer, TopicPartition<br> <br> consumer = Consumer({<br> &#39;bootstrap.servers&#39;: &#39;localhost:9092&#39;,<br> &#39;group.id&#39;: &#39;monitor-offsets&#39;,<br> &#39;auto.offset.reset&#39;: &#39;earliest&#39;<br> })<br> <br> def verificar_lag(topic: str) -&gt; None:<br> &quot;&quot;&quot;Verifica lag de todas as partitions de um topic.&quot;&quot;&quot;<br> consumer.subscribe([topic])<br> consumer.poll(1.0) # Trigger assignment<br> <br> for tp in consumer.assignment():<br> low, high = consumer.get_watermark_offsets(tp)<br> committed = consumer.committed([tp])[0]<br> <br> lag = high - (committed.offset if committed.offset &gt; 0 else low)<br> <br> print(f&quot;Partition {tp.partition}: &quot;<br> f&quot;disponíveis={high - low}, &quot;<br> f&quot;lag={lag}&quot;)<br> <br> verificar_lag(&#39;pagamentos&#39;)<br> consumer.close()</pre><h3>Exemplo Real: Reprocessando Pedidos após Correção de Bug</h3><p>Um bug no sistema calculou frete errado para 1.000 pedidos. Precisamos reprocessar a partir de um offset específico:</p><pre>from confluent_kafka import Consumer, TopicPartition, KafkaError<br>import json<br><br>consumer = Consumer({<br>    &#39;bootstrap.servers&#39;: &#39;localhost:9092&#39;,<br>    &#39;group.id&#39;: &#39;reprocessador-frete&#39;,<br>    &#39;enable.auto.commit&#39;: False<br>})<br><br>consumer.subscribe([&#39;pedidos&#39;])<br>consumer.poll(1.0)<br><br># Reprocessar partition 2 a partir do offset 1000<br>tp = TopicPartition(&#39;pedidos&#39;, partition=2, offset=1000)<br>consumer.seek(tp)<br><br>print(&quot;Reprocessando pedidos com frete incorreto...&quot;)<br><br>pedidos_corrigidos = 0<br>try:<br>    while pedidos_corrigidos &lt; 1000:<br>        msg = consumer.poll(timeout=1.0)<br><br>        if msg is None:<br>            continue<br>        if msg.error():<br>            continue<br><br>        pedido = json.loads(msg.value().decode(&#39;utf-8&#39;))<br><br>        # Recalcular frete<br>        frete_correto = calcular_frete(pedido)<br>        pedido[&#39;frete&#39;] = frete_correto<br><br>        # Atualizar no banco<br>        atualizar_pedido(pedido)<br><br>        pedidos_corrigidos += 1<br><br>        if pedidos_corrigidos % 100 == 0:<br>            print(f&quot;Corrigidos: {pedidos_corrigidos}/1000&quot;)<br>            consumer.commit()<br><br>finally:<br>    consumer.close()<br>    print(f&quot;Reprocessamento concluído: {pedidos_corrigidos} pedidos corrigidos&quot;)</pre><h3>Commit de Offsets: At-Least-Once vs At-Most-Once</h3><p>O momento do commit define a semântica de processamento:</p><pre>from confluent_kafka import Consumer, KafkaError<br>import json<br><br>consumer = Consumer({<br>    &#39;bootstrap.servers&#39;: &#39;localhost:9092&#39;,<br>    &#39;group.id&#39;: &#39;processador-pagamentos&#39;,<br>    &#39;auto.offset.reset&#39;: &#39;earliest&#39;,<br>    &#39;enable.auto.commit&#39;: False  # Controle manual<br>})<br><br>consumer.subscribe([&#39;pagamentos&#39;])<br><br>try:<br>    while True:<br>        msg = consumer.poll(timeout=1.0)<br><br>        if msg is None:<br>            continue<br>        if msg.error():<br>            if msg.error().code() == KafkaError._PARTITION_EOF:<br>                continue<br>            break<br><br>        pagamento = json.loads(msg.value().decode(&#39;utf-8&#39;))<br><br>        # Processar pagamento (pode falhar)<br>        resultado = processar_pagamento(pagamento)<br><br>        if resultado.sucesso:<br>            # Commit APÓS processamento = at-least-once<br>            # Se falhar aqui, pagamento será reprocessado<br>            consumer.commit(message=msg)<br>            print(f&quot;Pagamento {pagamento[&#39;pedido_id&#39;]} processado - Offset: {msg.offset()}&quot;)<br>        else:<br>            print(f&quot;Falha no pagamento {pagamento[&#39;pedido_id&#39;]}, será retentado&quot;)<br><br>except KeyboardInterrupt:<br>    pass<br>finally:<br>    consumer.close()</pre><h3>Boas Práticas</h3><h3>Faça</h3><ul><li><strong>Use cliente_id/pedido_id como chave</strong>: Garante ordenação por entidade</li><li><strong>Monitore o LAG</strong>: Alertas quando lag &gt; threshold definido</li><li><strong>Configure replication factor &gt;= 3</strong>: Para dados críticos como pagamentos</li><li><strong>Use commit manual</strong>: Para garantir processamento at-least-once</li></ul><h3>Evite</h3><ul><li><strong>Evite partitions demais</strong>: 6–12 partitions é suficiente para maioria dos casos</li><li><strong>Evite auto-commit com dados financeiros</strong>: Risco de perda ou duplicação</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FRW4vA%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FRW4vA%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FRW4vA%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="341" frameborder="0" scrolling="no"><a href="https://medium.com/media/f84f23a386fb7ea0c9423aee9999ff24/href">https://medium.com/media/f84f23a386fb7ea0c9423aee9999ff24/href</a></iframe><h3>Conclusão</h3><ol><li><strong>Brokers</strong> distribuem a carga e garantem disponibilidade — use pelo menos 3 em produção</li><li><strong>Topics</strong> organizam eventos por domínio (pedidos, pagamentos, estoque)</li><li><strong>Partitions</strong> habilitam paralelismo — use chaves para garantir ordenação por entidade</li><li><strong>Offsets</strong> rastreiam posição — permitem replay e recuperação de falhas</li></ol><h3>Referências</h3><ol><li><strong>1,1 trilhão de mensagens/dia globalmente</strong>: <a href="https://www.confluent.io/blog/apache-kafka-hits-1-1-trillion-messages-per-day-joins-the-4-comma-club/">Confluent — Apache Kafka Hits 1.1 Trillion Messages Per Day</a></li><li><strong>Throughput por partition (10–20 MB/s)</strong>: <a href="https://docs.confluent.io/cloud/current/clusters/cluster-types.html">Confluent Cloud Cluster Types</a></li><li><strong>Arquitetura e design do Kafka</strong>: <a href="https://kafka.apache.org/documentation/#design">Apache Kafka Documentation — Design</a></li><li><strong>Conceitos de Offsets e Commits</strong>: <a href="https://developer.confluent.io/learn-kafka/apache-kafka/kafka-consumers/">Confluent Developer — Kafka Consumers</a></li><li><strong>Kafka CLI Tools</strong>: <a href="https://kafka.apache.org/documentation/#operations">Apache Kafka Documentation — Operations</a></li><li><strong>kcat (kafkacat)</strong>: <a href="https://github.com/edenhill/kcat">edenhill/kcat — GitHub</a></li><li>Kleppmann, M. (2017). <em>Designing Data-Intensive Applications</em>. O’Reilly Media. Capítulo 11: Stream Processing</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be4d95512924" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Apache Kafka: O Coração do Streaming Moderno]]></title>
            <link>https://mateus-oliveira.medium.com/apache-kafka-o-cora%C3%A7%C3%A3o-do-streaming-moderno-ef0f7a5ac6e5?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef0f7a5ac6e5</guid>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[apache-kafka]]></category>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[event-driven-architecture]]></category>
            <category><![CDATA[fundamentals]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Fri, 23 Jan 2026 20:29:09 GMT</pubDate>
            <atom:updated>2026-01-23T20:29:09.602Z</atom:updated>
            <content:encoded><![CDATA[<p>Entenda por que as maiores empresas do mundo escolheram Kafka para processar trilhões de eventos em tempo real</p><p>Imagine que você está pedindo um Uber. Em milissegundos, o app precisa: encontrar sua localização, identificar motoristas próximos, calcular preços dinâmicos, processar seu pagamento e atualizar a posição do carro em tempo real. A Uber processa <strong>trilhões de mensagens e petabytes de dados por dia</strong> para fazer isso funcionar — e no centro dessa operação está o Apache Kafka.</p><p>A resposta para esse desafio de escala está no <strong>Apache Kafka</strong>, a plataforma de streaming que se tornou o coração pulsante das arquiteturas de dados modernas. Criado pelo LinkedIn para resolver seus próprios desafios de escala, o Kafka hoje processa mais de <strong>1,1 trilhão de mensagens por dia</strong> globalmente e é utilizado por mais de <strong>150.000 organizações</strong>.</p><p><strong>Neste artigo, você vai aprender:</strong></p><ul><li>O que é Apache Kafka e por que ele revolucionou o processamento de dados</li><li>Como funciona a arquitetura básica do Kafka</li><li>Por que empresas como Netflix, Uber e LinkedIn dependem dele</li><li>Um exemplo prático para você começar hoje</li></ul><h3>O que é Apache Kafka?</h3><p>Apache Kafka é uma <strong>plataforma de streaming de eventos distribuída</strong> de código aberto, projetada para lidar com fluxos de dados em tempo real de forma confiável e escalável.</p><p>Para entender melhor, pense no Kafka como um <strong>sistema postal ultramoderno</strong>. Em vez de cartas, ele transporta mensagens (eventos) entre sistemas. Mas diferente do correio tradicional, o Kafka:</p><ul><li><strong>Nunca perde uma carta</strong>: todas as mensagens são persistidas em disco</li><li><strong>Permite múltiplos destinatários</strong>: uma mesma mensagem pode ser lida por vários consumidores</li><li><strong>Guarda histórico</strong>: você pode “voltar no tempo” e reprocessar mensagens antigas</li><li><strong>Escala infinitamente</strong>: de milhares a trilhões de mensagens por dia</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/779/1*oQCr091fPPCQnD2BMpyBdg.png" /><figcaption>Arquitetura de Apache Kafka Simplificada</figcaption></figure><h3>Por que Kafka é Tão Importante?</h3><p>O Kafka não é apenas mais uma ferramenta de mensageria. Ele representa uma <strong>mudança fundamental</strong> na forma como pensamos sobre dados: de batches para streams, de reativo para proativo.</p><p><strong>Principais benefícios:</strong></p><ul><li><strong>Alta Performance</strong>: Um único broker Kafka pode processar milhões de mensagens por segundo, usando I/O sequencial otimizado</li><li><strong>Durabilidade</strong>: Diferente de filas tradicionais, o Kafka persiste todas as mensagens em disco, permitindo replay e auditoria</li><li><strong>Desacoplamento</strong>: Produtores e consumidores não precisam se conhecer, tornando sistemas mais resilientes</li><li><strong>Escalabilidade Horizontal</strong>: Adicione mais brokers conforme sua demanda cresce, sem downtime</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FgpQJB%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FgpQJB%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FgpQJB%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="277" frameborder="0" scrolling="no"><a href="https://medium.com/media/d9fc3f7c5dd6dcd5cdf8a0e3b77f18b4/href">https://medium.com/media/d9fc3f7c5dd6dcd5cdf8a0e3b77f18b4/href</a></iframe><h3>Como o Kafka Funciona</h3><p>Para entender o Kafka, você precisa conhecer seus quatro componentes principais:</p><h3>1. Producers (Produtores)</h3><p>São as aplicações que <strong>enviam mensagens</strong> para o Kafka. Pode ser qualquer coisa: uma aplicação web registrando cliques, um sensor IoT enviando leituras, ou um banco de dados emitindo mudanças.</p><pre>from confluent_kafka import Producer<br>from data_gen.generators.financial import TransactionGenerator<br>import json<br><br># Configuração do producer<br>config = {<br>    &#39;bootstrap.servers&#39;: &#39;localhost:29092&#39;,<br>    &#39;client.id&#39;: &#39;banking-producer&#39;<br>}<br><br># Criar producer e gerador de dados<br>producer = Producer(config)<br>tx_gen = TransactionGenerator(seed=42)<br><br># Gerar transação bancária realista<br>transaction = tx_gen.generate(account_id=&quot;ACC-12345&quot;)<br><br># Enviar mensagem<br>producer.produce(<br>    topic=&#39;banking.transactions&#39;,<br>    key=transaction.account_id.encode(&#39;utf-8&#39;),<br>    value=json.dumps({<br>        &#39;transaction_id&#39;: transaction.transaction_id,<br>        &#39;account_id&#39;: transaction.account_id,<br>        &#39;type&#39;: transaction.transaction_type,  # PIX, TED, DOC, etc.<br>        &#39;amount&#39;: float(transaction.amount),<br>        &#39;direction&#39;: transaction.direction,<br>        &#39;timestamp&#39;: transaction.timestamp.isoformat()<br>    })<br>)<br><br># Garantir entrega<br>producer.flush()<br>print(f&quot;Transação {transaction.transaction_type} enviada!&quot;)</pre><h3>2. Topics (Tópicos)</h3><p>Topics são <strong>categorias</strong> onde as mensagens são organizadas. Pense neles como pastas temáticas: pedidos, pagamentos, logs-erro. Cada topic pode ter múltiplas <strong>partições</strong> para distribuir a carga.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/507/1*gZCdmXEkLUCoruUQeJTHrw.png" /><figcaption>Partições de um tópico</figcaption></figure><h3>3. Consumers (Consumidores)</h3><p>São as aplicações que <strong>leem mensagens</strong> dos topics. O diferencial do Kafka é que múltiplos consumidores podem ler o mesmo topic independentemente, sem “roubar” mensagens uns dos outros.</p><pre>from confluent_kafka import Consumer<br>import json<br><br># Configuração do consumer<br>config = {<br>    &#39;bootstrap.servers&#39;: &#39;localhost:29092&#39;,<br>    &#39;group.id&#39;: &#39;banking-consumer-group&#39;,<br>    &#39;auto.offset.reset&#39;: &#39;earliest&#39;<br>}<br><br># Criar consumer<br>consumer = Consumer(config)<br>consumer.subscribe([&#39;banking.transactions&#39;])<br><br># Consumir transações bancárias<br>while True:<br>    msg = consumer.poll(timeout=1.0)<br>    if msg is None:<br>        continue<br>    if msg.error():<br>        print(f&quot;Erro: {msg.error()}&quot;)<br>    else:<br>        transaction = json.loads(msg.value().decode(&#39;utf-8&#39;))<br>        print(f&quot;Transação: {transaction[&#39;type&#39;]} - R$ {transaction[&#39;amount&#39;]:.2f}&quot;)</pre><h3>4. Brokers</h3><p>São os <strong>servidores</strong> que armazenam e distribuem as mensagens. Em produção, você terá múltiplos brokers formando um cluster para garantir alta disponibilidade.</p><h3>Kafka vs Filas Tradicionais</h3><p>Uma dúvida comum é: “Por que não usar RabbitMQ ou ActiveMQ?”. A diferença está no <strong>modelo fundamental</strong>:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fdatawrapper.dwcdn.net%2FjkN00%2F1%2F&amp;display_name=Datawrapper&amp;url=https%3A%2F%2Fdatawrapper.dwcdn.net%2FjkN00%2F1%2F&amp;image=https%3A%2F%2Fdatawrapper.dwcdn.net%2FjkN00%2Fplain-s.png%3Fv%3D1&amp;type=text%2Fhtml&amp;schema=dwcdn" width="600" height="341" frameborder="0" scrolling="no"><a href="https://medium.com/media/9234ade5f8deddf38aac0c79c692d5c7/href">https://medium.com/media/9234ade5f8deddf38aac0c79c692d5c7/href</a></iframe><h3>Boas Práticas para Iniciantes</h3><h3>Faça</h3><ul><li><strong>Comece com um cluster local</strong>: Use Docker para experimentar sem complicações</li><li><strong>Defina schemas desde o início</strong>: Use Avro ou JSON Schema para garantir qualidade dos dados</li><li><strong>Monitore consumer lag</strong>: Garanta que seus consumidores estão acompanhando os produtores</li></ul><h3>Evite</h3><ul><li><strong>Topics com muitas partições desnecessárias</strong>: Comece pequeno e escale conforme necessário</li><li><strong>Mensagens muito grandes</strong>: Kafka funciona melhor com mensagens de até 1MB</li><li><strong>Ignorar configurações de retenção</strong>: Configure quanto tempo manter mensagens para não estourar disco</li></ul><h3>Conclusão</h3><p>O Apache Kafka transformou a forma como empresas processam dados em tempo real. O que aprendemos:</p><ol><li><strong>Kafka é uma plataforma de streaming</strong> que processa trilhões de eventos diariamente</li><li><strong>Diferente de filas tradicionais</strong>, ele persiste mensagens e permite replay</li><li><strong>A arquitetura</strong> baseia-se em producers, topics, consumers e brokers</li><li><strong>Empresas líderes</strong> como Netflix, Uber e LinkedIn dependem dele para operações críticas</li><li><strong>É acessível</strong>: Você pode começar com Docker localmente em minutos</li></ol><h3>Recursos</h3><ul><li><a href="https://kafka.apache.org/documentation/">Documentação Apache Kafka</a></li><li><a href="https://developer.confluent.io/">Confluent Developer</a></li><li><a href="https://www.confluent.io/resources/kafka-the-definitive-guide/">Kafka: The Definitive Guide (O’Reilly)</a></li></ul><h3>Referências</h3><p>As estatísticas citadas neste artigo foram extraídas das seguintes fontes:</p><ol><li><strong>1,1 trilhão de mensagens/dia globalmente</strong>: <a href="https://www.confluent.io/blog/apache-kafka-hits-1-1-trillion-messages-per-day-joins-the-4-comma-club/">Confluent — Apache Kafka Hits 1.1 Trillion Messages Per Day</a></li><li><strong>150.000+ organizações usando Kafka</strong>: <a href="https://www.eweek.com/big-data-and-analytics/apache-kafka/">eWEEK — Apache Kafka Gains Adoption</a></li><li><strong>Uber — Trilhões de mensagens e petabytes/dia</strong>: <a href="https://www.uber.com/blog/kafka/">Uber Engineering Blog</a> — Uber descreve Kafka como “cornerstone of our technology stack”</li><li><strong>LinkedIn — 1+ trilhão msgs/dia</strong>: <a href="https://engineering.linkedin.com/apache-kafka/how-we_re-improving-and-advancing-kafka-linkedin">LinkedIn Engineering — How We’re Improving Kafka</a></li><li><strong>Netflix — Bilhões de eventos/dia</strong>: <a href="https://medium.com/@abel.ncm/how-apache-kafka-powers-the-real-world-inside-netflix-uber-and-beyond-f8dc28cd2db4">Medium — How Apache Kafka Powers Netflix, Uber, and Beyond</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef0f7a5ac6e5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Produzindo Dados no Apache Kafka com Python]]></title>
            <link>https://mateus-oliveira.medium.com/produzindo-dados-no-apache-kafka-com-python-d072b6aae298?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d072b6aae298</guid>
            <category><![CDATA[data-engineer]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[kafka]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Tue, 08 Oct 2024 18:11:53 GMT</pubDate>
            <atom:updated>2024-10-08T18:11:53.479Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NqUvD3XRkNIPycmyg8KB5w.png" /></figure><p>Um dos grandes desafios em se utilizar Apache Kafka pelo time de dados é programar em Java. Bom, aqui vamos falar um pouco sobre como podemos utilizar Python para produzir, além de algumas práticas para facilitar ainda mais o seu dia.</p><p>Importante dizer, que esse artigo faz parte de um serie em que vamos falar de como produzir, transformar e consumir dados no Apache Kafka usando Python, ou seja, muito Kafka e muito Python.</p><p>Vamos começar com o nosso ambiente:</p><ul><li><em>Apache Kafka 3.8 on Kubernetes — Strimzi 0.43 utilizando Kraft (Zookeeper-less) single-node</em></li><li><em>Python 3.11</em></li><li><em>Biblioteca Python Confluent-kafka-python 2.5.0</em></li></ul><p>Todas as bibliotecas usadas estão no <strong>requirements.txt</strong> que está no <a href="https://github.com/owshq-academy/medium-academy/tree/main/medium-producer-kafka-py">github</a></p><p>Vamos produzir dados em 2 formatos:</p><ul><li><em>Json</em></li><li><em>Avro</em></li></ul><p><strong>Particularmente falando, o ideal seria trabalhar somente com Avro, por ser um formato nativo e mais usado para ambientes de Apache Kafka.</strong></p><p>Eventos que serão ingeridos:</p><pre>{<br>    &quot;id&quot;: 1,<br>    &quot;name&quot;: &quot;Mateus&quot;,<br>    &quot;age&quot;: 37,<br>    &quot;created_at&quot;: datetime.now(),<br>    &quot;event&quot;: &quot;login&quot;<br>},<br>{<br>    &quot;id&quot;: 2,<br>    &quot;name&quot;: &quot;Luan&quot;,<br>    &quot;age&quot;: 35,<br>    &quot;created_at&quot;: datetime.now(),<br>    &quot;event&quot;: &quot;logout&quot;<br>},<br>{<br>    &quot;id&quot;: 3,<br>    &quot;name&quot;: &quot;Leonardo&quot;,<br>    &quot;age&quot;: 42,<br>    &quot;created_at&quot;: datetime.now(),<br>    &quot;event&quot;: &quot;purchase&quot;,<br>    &quot;amount&quot;: 250.5<br>}</pre><p>Primeiro vamos começar com o nosso producer.</p><p>Aqui separei uma classe:</p><pre>class KafkaJson(object):<br>    def __init__(self, broker, auth=False):<br>        self.broker = broker<br>        self.auth = auth<br><br>    def json_producer(self, object_name, kafka_topic, client_id, additional_config=None, batch_size=100, max_workers=4):<br>        # Choose auth settings and merge with additional config<br>        base_config = producer_settings_json(self.broker) if self.auth else producer_settings_json(self.broker, client_id)<br>        if additional_config:<br>            base_config.update(additional_config)<br><br>        try:<br>            p = Producer(base_config)<br>        except KafkaException as e:<br>            logging.error(f&quot;Failed to create Kafka producer: {e}&quot;)<br>            return<br><br>        # Data preparation<br>        get_data = self._prepare_data(object_name)<br>        if not get_data:<br>            logging.error(&quot;Error: Invalid format for object_name.&quot;)<br>            return<br><br>        # Split data into partitions for parallel processing<br>        partition_size = max(1, len(get_data) // max_workers)  # Handle cases with fewer items<br>        partitions = [get_data[i:i + partition_size] for i in range(0, len(get_data), partition_size)]<br><br>        with ThreadPoolExecutor(max_workers=max_workers) as executor:<br>            for partition in partitions:<br>                executor.submit(self._produce_batch, p, partition, kafka_topic, batch_size)<br><br>        p.flush()<br>        logging.info(&quot;All messages have been flushed to Kafka.&quot;)</pre><p>Esta classe possui melhorias como controle de threads para ingestão mais rápida</p><p>Aqui está o mais importante, usando o producer_settins_json:</p><pre>def producer_settings_json(broker, client_id):<br>    return {<br>        &#39;bootstrap.servers&#39;: broker,<br>        &#39;client.id&#39;: client_id,<br>        &#39;compression.type&#39;: &#39;gzip&#39;,  # Compress messages to save bandwidth<br>        &#39;batch.size&#39;: 65536,  # Double the batch size to improve throughput<br>        &#39;linger.ms&#39;: 50,  # Allow more time for messages to batch, improving efficiency<br>        &#39;queue.buffering.max.messages&#39;: 100000,  # Max messages in the queue<br>        &#39;queue.buffering.max.ms&#39;: 500,  # Max time before sending a batch<br>        &#39;acks&#39;: &#39;all&#39;,  # Ensure all replicas acknowledge the message for reliability<br>        &#39;retries&#39;: 10,  # Increase retries to handle transient failures<br>        &#39;retry.backoff.ms&#39;: 200,  # Increase backoff to avoid overwhelming broker<br>        &#39;enable.idempotence&#39;: True,  # Ensures exactly-once delivery in case of retries<br>        &#39;max.in.flight.requests.per.connection&#39;: 5,  # Allow up to 5 in-flight requests for higher throughput<br>        &#39;delivery.timeout.ms&#39;: 30000,  # Set a delivery timeout<br>        &#39;request.timeout.ms&#39;: 30000  # Set request timeout<br>    }</pre><p>Segue aqui as configurações que precisamos ter mais atenção:</p><ul><li><strong>acks</strong> = Define o tipo de garantia de entrega de mensagem (Deliver Message Guarantee), temos 3 tipos de opções:</li></ul><p>[0] <em>at most once {não tem a confirmação do recebimento da mensagem}</em></p><p>[1] <em>at least once {somente o broker líder retorna o recebimento}</em></p><p>[all] <em>exactly once (Nesse caso temos que ter enable.idempotence = true) {todos os broker leader &amp; followers devem retornar com o recebimento do evento.}</em></p><ul><li><strong>linger.ms</strong> = linger é o tempo entre o envio de batches do producer, sendo 0 por default. Entretanto, o ideal é aumenta-lo em milissegundos ao enviar batches pro Kafka. Sim batches! Em muitos casos aumentar um pouco a latência e enviar batches pro Kafka, pode ser benéfico para pipeline de produção de dados.</li><li><strong>batch.size </strong>= juntamente com o <em>linger</em>, precisamos modificar o batch size para definir o tamanho do batches de eventos que vamos enviar para o Kafka, sendo assim podemos enviar mais eventos em um único batch ao invés de enviar mensagem a mensagem</li></ul><p>Agora, vamos entender como funciona o nosso envio, já que entendemos as partes principais. Aqui vamos simplesmente executar a nossa classe juntamente com alguns parâmetros.</p><pre># Sample message data (could be a dict, list of dicts, or a string)<br>message_data = [<br>    {<br>        &quot;id&quot;: 1,<br>        &quot;name&quot;: &quot;Mateus&quot;,<br>        &quot;age&quot;: 37,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;login&quot;<br>    },<br>    {<br>        &quot;id&quot;: 2,<br>        &quot;name&quot;: &quot;Luan&quot;,<br>        &quot;age&quot;: 35,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;logout&quot;<br>    },<br>    {<br>        &quot;id&quot;: 3,<br>        &quot;name&quot;: &quot;Leonardo&quot;,<br>        &quot;age&quot;: 42,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;purchase&quot;,<br>        &quot;amount&quot;: 250.5<br>    }<br>]<br><br># Kafka topic and broker details<br>kafka_topic = &quot;user_activity&quot;<br>broker = &quot;localhost:9094&quot;<br>client_id = &quot;python_client_json&quot;<br><br># Initialize the KafkaJson producer<br>kafka_json_producer = KafkaJson(broker=broker, auth=False)<br><br># Produce JSON messages to Kafka<br># Optional arguments: batch_size, max_workers, additional_config<br>kafka_json_producer.json_producer(<br>    object_name=message_data,           # Can be a dict, list of dicts, or a string<br>    kafka_topic=kafka_topic,            # Kafka topic to send messages to<br>    client_id=client_id,                # Client ID for the Kafka producer<br>    batch_size=2,                       # Number of messages to send per batch<br>    max_workers=2                       # Number of threads to process batches<br>)</pre><p>Primeiro é a mensagem ou, como eu prefiro chamar, o evento que eu quero inserir no Kafka.</p><pre>message_data = [<br>    {<br>        &quot;id&quot;: 1,<br>        &quot;name&quot;: &quot;Mateus&quot;,<br>        &quot;age&quot;: 37,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;login&quot;<br>    },<br>    {<br>        &quot;id&quot;: 2,<br>        &quot;name&quot;: &quot;Luan&quot;,<br>        &quot;age&quot;: 35,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;logout&quot;<br>    },<br>    {<br>        &quot;id&quot;: 3,<br>        &quot;name&quot;: &quot;Leonardo&quot;,<br>        &quot;age&quot;: 42,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;purchase&quot;,<br>        &quot;amount&quot;: 250.5<br>    }<br>]</pre><p>Na sequência, os parâmetros iniciais para o envio dos eventos:</p><pre># Kafka topic and broker details<br>kafka_topic = &quot;user_activity&quot;<br>broker = &quot;localhost:9094&quot;<br>client_id = &quot;python_client_json&quot;</pre><ul><li><strong>kafka_topic</strong> = nome do tópico que iremos produzir os dados</li><li><strong>broker</strong> = servidor do Apache Kafka que iremos realizar a conexão.</li><li><strong>client_id</strong> = nome da aplicação producer que estamos usando</li></ul><pre># Initialize the KafkaJson producer<br>kafka_json_producer = KafkaJson(broker=broker, auth=False)<br><br># Produce JSON messages to Kafka<br># Optional arguments: batch_size, max_workers, additional_config<br>kafka_json_producer.json_producer(<br>    object_name=message_data,           # Can be a dict, list of dicts, or a string<br>    kafka_topic=kafka_topic,            # Kafka topic to send messages to<br>    client_id=client_id,                # Client ID for the Kafka producer<br>    batch_size=2,                       # Number of messages to send per batch<br>    max_workers=2                       # Number of threads to process batches<br>)</pre><p>Neste ponto, vamos instanciar a nossa classe KafkaJson e configurar a função para receber os dados.</p><p><strong>object_name</strong> = é o dictionary ou uma lista de dictionaries (dados que quero enviar como eventos).</p><p><strong>batch_size</strong> = quantidade de mensagens que minha aplicação está enviando, lembrando que as configurações do producer não tem relação direta com essa configuração.</p><p><strong>max_workers</strong> = como estou trabalhando com multi-threading aqui são quantos workers irão executar em paralelo.</p><p>Finalizado o nosso producer Json, passamos ao entendimento do nosso producer avro. Importante ressaltar, que esta classe é diferente da classe <em>KafkaJson</em> pois iremos utilizar a integração com Schema Registry.</p><pre>def avro_producer(self, object_list, kafka_topic, schema_key_path, kafka_client_id_avro, schema_value_path, additional_config=None, batch_size=100):<br>    schema_key = self.load_json_schema(schema_key_path)<br>    schema_value = self.load_json_schema(schema_value_path)<br><br>    schema_registry_conf = {&#39;url&#39;: self.schema_registry_url}<br>    schema_registry_client = SchemaRegistryClient(schema_registry_conf)</pre><p>O código descrito acima é a nossa função para schemas. Nessa caso, sim, temos que ter um schema para <strong>key</strong> e outro para <strong>value</strong>.</p><p>Seguem abaixo, exemplos dos 2 schemas:</p><pre># schema key<br>{<br>  &quot;type&quot;: &quot;record&quot;,<br>  &quot;name&quot;: &quot;UserKey&quot;,<br>  &quot;namespace&quot;: &quot;com.example&quot;,<br>  &quot;fields&quot;: [<br>    {<br>      &quot;name&quot;: &quot;id&quot;,<br>      &quot;type&quot;: &quot;int&quot;<br>    }<br>  ]<br>}<br><br># schema value<br>{<br>  &quot;type&quot;: &quot;record&quot;,<br>  &quot;name&quot;: &quot;UserEvent&quot;,<br>  &quot;namespace&quot;: &quot;com.example&quot;,<br>  &quot;fields&quot;: [<br>    {<br>      &quot;name&quot;: &quot;id&quot;,<br>      &quot;type&quot;: &quot;int&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;name&quot;,<br>      &quot;type&quot;: &quot;string&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;age&quot;,<br>      &quot;type&quot;: &quot;int&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;created_at&quot;,<br>      &quot;type&quot;: &quot;string&quot;,<br>      &quot;logicalType&quot;: &quot;timestamp-millis&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;event&quot;,<br>      &quot;type&quot;: &quot;string&quot;<br>    },<br>    {<br>      &quot;name&quot;: &quot;amount&quot;,<br>      &quot;type&quot;: [<br>        &quot;null&quot;,<br>        &quot;double&quot;<br>      ],<br>      &quot;default&quot;: null<br>    }<br>  ]<br>}</pre><p>Abaixo, temos a integração do Schema Registry Client.</p><pre>avro_serializer_key = AvroSerializer(schema_str=json.dumps(schema_key), schema_registry_client=schema_registry_client)<br>avro_serializer_value = AvroSerializer(schema_str=json.dumps(schema_value), schema_registry_client=schema_registry_client)</pre><p>E, por fim, o metódo de produção de dados usando avro:</p><pre>producer.produce(<br>    topic=topic,<br>    key=avro_serializer_key({&#39;id&#39;: id_value}, SerializationContext(topic, MessageField.KEY)),<br>    value=avro_serializer_value(data, SerializationContext(topic, MessageField.VALUE)),<br>    on_delivery=lambda err, msg: on_delivery_avro(err, msg, data)</pre><p>Estas são as partes principais no código e agora vamos mostrar a instância da classe KafkaAvroProducer:</p><pre>from datetime import datetime<br>from src.producer.producer_avro import KafkaAvroProducer<br><br># Sample data to be sent to Kafka<br>message_data = [<br>    {<br>        &quot;id&quot;: 1,<br>        &quot;name&quot;: &quot;Mateus&quot;,<br>        &quot;age&quot;: 37,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;login&quot;<br>    },<br>    {<br>        &quot;id&quot;: 2,<br>        &quot;name&quot;: &quot;Luan&quot;,<br>        &quot;age&quot;: 35,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;logout&quot;<br>    },<br>    {<br>        &quot;id&quot;: 3,<br>        &quot;name&quot;: &quot;Leonardo&quot;,<br>        &quot;age&quot;: 42,<br>        &quot;created_at&quot;: datetime.now(),<br>        &quot;event&quot;: &quot;purchase&quot;,<br>        &quot;amount&quot;: 250.5<br>    }<br>]<br><br># Paths to the Avro schemas for key and value<br>schema_key_path = &#39;schemas/s_key_user_activity.json&#39;<br>schema_value_path = &#39;schemas/s_value_user_activity.json&#39;<br><br># Kafka broker and Schema Registry configuration<br>broker = &quot;localhost:9094&quot;<br>schema_registry_url = &quot;http://localhost:8081&quot;<br>client_id = &quot;python_client_json_avro&quot;<br><br># Initialize the KafkaAvroProducer<br>kafka_producer = KafkaAvroProducer(broker=broker, schema_registry_url=schema_registry_url, max_workers=4)<br><br># Produce the messages to Kafka topic &#39;user_activity&#39;<br>kafka_producer.avro_producer(<br>    object_list=message_data,                # List of messages to be sent<br>    kafka_topic=&quot;user_activity_avro&quot;,        # Kafka topic name<br>    schema_key_path=schema_key_path,         # Path to the key schema<br>    schema_value_path=schema_value_path,     # Path to the value schema<br>    batch_size=2,                            # Number of messages to send per batch<br>    kafka_client_id_avro=client_id           # Client Application name<br>)</pre><p>Desta forma, agora que vimos a produção de dados com Json e Avro, podemos concluir que:</p><ul><li>Trabalhar com Apache Kafka e Python não complicado como parece.</li><li>Integrar com o Schema Registry também é simples. No momento de consumo de dados as vantagens vão ficar claras.</li></ul><p>Nos próximos artigos, vamos demonstrar o processamento e o consumo de dados usando Python.</p><p>Todos os scripts estão disponíveis no Github.</p><p><a href="https://github.com/owshq-academy/medium-academy/tree/main/medium-producer-kafka-py">https://github.com/owshq-academy/medium-academy/tree/main/medium-producer-kafka-py</a></p><p>Links úteis:</p><ul><li><a href="https://strimzi.io/">Strimzi - Apache Kafka on Kubernetes</a></li><li><a href="https://docs.confluent.io/kafka-clients/python/current/overview.html">Apache Kafka Python Client | Confluent Documentation</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d072b6aae298" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Instalando Apache Pulsar no Kubernetes]]></title>
            <link>https://medium.com/engenharia-de-dados-academy/instalando-apache-pulsar-no-kubernetes-63e242675446?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/63e242675446</guid>
            <category><![CDATA[apache-pulsar]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[pulsar]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Tue, 28 Jun 2022 17:48:47 GMT</pubDate>
            <atom:updated>2022-06-28T17:48:47.186Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WRfem-MXxs0YqmuKOpQ7AA.jpeg" /></figure><p>Falando de Big Data, não podemos falar de 2 grandes trends no mundo de engenharia de dados.</p><ul><li>Kubernetes = Sem dúvida próxima senão a atual geração de infraestrutura de big data, hoje sem dúvida para desenvolvimento não se fala em outra coisa e porque analytics seria diferente.</li><li>Apache Pulsar = Plataforma de streaming de dados que veio para competir de frente com Apache Kafka, claro que além das similaridades ainda temos os diferenciais: Apache BookKeeper, geo-replication, Pulsar Functions e Tiered Storage (tem muita mais coisa por isso temos um artigo só para falar dos conceitos)</li></ul><p>Antes de entrarmos no Hands-On de como instalar o Apache Pulsar temos que entender algumas coisas, não adianta somente fazer o get started sem saber aos conceitos básicos que podemos te ajudar muito lá na frente.</p><p>O que são tenants e namespaces no Apache Pulsar?</p><p>Vamos começar pelo Tenant, é a unidade mais basica de categorização de um tópico, ou seja tópicos são armazenados em um determinado namespace que está dentro de um tenant que por sua vez está espalhado nos clusters de Pulsar, acredito que com a imagem fica mais claro.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*fha7ffDjjaBRG08tSZ_J-w.png" /></figure><p>Vamos entender primeiro como estão organizados os dados. Primeiro temos o Apache Pulsar Cluster (Broker e BookKeeper) dentro do cluster temos a primeira camada que é o Tenant, por exemplo o Tenant BackEnd para aplicações back-end e outro Tenant FrontEnd para aplicações do nosso front-end, nesse camada podemos aplicar por exemplo configurações de autorização, já podemos entender um pouco melhor o desejo, por exemplo agora podemos ver que a aplicação de BackEnd tem acesso ao tópico de user-log e a aplicação de FrontEnd não, (acesso em verde OK, acesso em vermelho NEGADO).</p><p>Agora temos o namespace, o namespace é uma organização lógica dentro do Tenant, podemos separar pro microserviços que irão utilizar por exemplo e agrupar os tópicos dentro dos namespaces, outra habilidade que teremos usando namespaces é de aplicar um grupo de politicas em todos os tópicos de uma determinada namespace, por exemplo, configurar tempo de retenção por namespace.</p><p>Entendido essa parte conceitual, fica mais simples de seguirmos para a parte prática.</p><p>Vamos as seguintes ferramentas usar:</p><ul><li>Minikube = Ambiente de implementação</li><li>Helm = Gerenciador de pacotes de aplicação do Kubernetes</li><li>Pulsar Helm chart [oficial] = Repositório oficial do Apache Pulsar para Kubernetes</li></ul><p>Iremos usar o get started pois a documentação está em um excelente nível mas vamos explicar cada passo a passo em português.</p><p>Primeiro passo é adicionar o repositório do Helm chart localmente:</p><pre>helm repo add apache https://pulsar.apache.org/charts</pre><p>Casos em que já tem ele adicionado, você pode atualizar com o seguinte comando:</p><pre>helm repo update</pre><p>Agora vamos baixar o repositório do helm localmente na nossa maquina, e acessar a pasta, esse passo é necessário para preparmos o ambiente.</p><pre>git clone <a href="https://github.com/apache/pulsar-helm-chart">https://github.com/apache/pulsar-helm-chart</a><br>cd pulsar-helm-chart</pre><p>Será executado um script agora de preparação, esse script além de criar os secrets para o deployment, configura o usuário e senha do dashboard do grafana e da UI de gerenciamento do Pulsar para pulsar/pulsar.</p><p>Além disso vale ressaltar alguns coisas, -n é a para especificar a namespace que irá utilizar por exemplo iremos usar o nome ingestion, que é o nome que normalmente eu uso para aplicações de ingestão e armazenamento em tempo real, -k é o nome da aplicação na sua implementação helm, neste caso irei usar somente pulsar</p><pre>./scripts/pulsar/prepare_helm_release.sh \<br>    -n ingestion \<br>    -k pulsar \<br>    -c</pre><p>Agora é a hora de implementar, dentro do examples, temos os arquivos yamls para deployment, podemos customizar e criar novos yamls de acordo com as nossas necessidades, por exemplo, quantos replicas por componentes e configurações por componentes. No yaml padrão do minikube não o Pulsar Manager, adicionei para vermos a interface gráfica.</p><pre># disable auto recovery<br>components:<br>  autorecovery: false<br>  pulsar_manager: true</pre><p>Aplicando o Helm chart no minikube:</p><pre>helm install \<br>    --values examples/values-minikube.yaml \<br>    --set <em>initialize</em>=true \<br>    --namespace ingestion\<br>    pulsar apache/pulsar</pre><p>Ponto de atenção para Minikube, não esquecer de abrir um outra aba ou sessão no terminal é executar o comando abaixo para criação de load balancer local.</p><pre>minikube tunnel</pre><p>Agora só aguardar que os pods inicializarem é o seu ambiente está pronto.</p><pre>mateusoliveira@mateuss-MacBook-Pro pulsar-helm-chart % k get pods<br>NAME                                     READY   STATUS      RESTARTS<br>pulsar-bookie-0                          1/1     Running     0          <br>pulsar-bookie-init-vtql2                 0/1     Completed   0          <br>pulsar-broker-0                          1/1     Running     0          <br>pulsar-grafana-6b99586f69-t8gz4          1/1     Running     0          <br>pulsar-prometheus-6f4fdcbf48-b6tnt       1/1     Running     0          <br>pulsar-proxy-0                           1/1     Running     0          <br>pulsar-pulsar-init-d8m79                 0/1     Completed   0          <br>pulsar-pulsar-manager-5c9ddcc44d-2l6kp   1/1     Running     0          <br>pulsar-toolset-0                         1/1     Running     0          <br>pulsar-zookeeper-0                       1/1     Running     0          </pre><p>Agora vamos acessar a UI do Pulsar Manager, mas antes disso, vamos configurar um usuário administrador para o nosso cluster.</p><pre>CSRF_TOKEN=$(curl http://localhost:9527/pulsar-manager/csrf-token)</pre><pre>curl \</pre><pre>-H &#39;X-XSRF-TOKEN: $CSRF_TOKEN&#39; \</pre><pre>-H &#39;Cookie: XSRF-TOKEN=$CSRF_TOKEN;&#39; \</pre><pre>-H &quot;Content-Type: application/json&quot; \</pre><pre>-X PUT http://localhost:9527/pulsar-manager/users/superuser \</pre><pre>-d &#39;{&quot;name&quot;: &quot;admin&quot;, &quot;password&quot;: &quot;apachepulsar&quot;, &quot;description&quot;: “admin user for apache pulsar on minikube”, &quot;email&quot;: “adminpulsar@test.org&quot;}&#39;</pre><p>Esse comando irá criar um superuser para acesso e controle do Pulsar Manager.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6TJETKHfUjK9iJZ0iw3C9Q.png" /></figure><p>Após isso ele irá solicitar a criação de um novo environment (Ambiente) com o nome do amniente a a URL de serviço, o nome pode ser a sua escolha e a URL é essa abaixo:</p><pre><a href="http://pulsar-broker.ingestion.svc.cluster.local:8080/">http://pulsar-broker.ingestion.svc.cluster.local:8080</a></pre><p>Depois de criar o ambiente é só clicar no nome do ambiente e teremos essa tela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jwNGwRv7GttcySEG-sg0rg.png" /></figure><p>Dessa forma temos um UI de gereciamento para criação de tenants, namespaces e informações sobre tópicos.</p><p>Espero que tenham gostado do conteúdo e iremos trazer mais coisas de Apache Pulsar e engenharia de dados no perfil Engenharia de dados Academy.</p><p>Continue nos acompanhando para mais conteúdo gratuito e feito para a comunidade de engenharia de dados.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63e242675446" width="1" height="1" alt=""><hr><p><a href="https://medium.com/engenharia-de-dados-academy/instalando-apache-pulsar-no-kubernetes-63e242675446">Instalando Apache Pulsar no Kubernetes</a> was originally published in <a href="https://medium.com/engenharia-de-dados-academy">Engenharia de Dados Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entendendo Apache Pulsar, uma plataforma de Streaming de dados]]></title>
            <link>https://medium.com/engenharia-de-dados-academy/entendendo-apache-pulsar-uma-plataforma-de-streaming-de-dados-8f80ef975601?source=rss-7fca70243d3f------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f80ef975601</guid>
            <category><![CDATA[data-pipeline]]></category>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[apache-pulsar]]></category>
            <category><![CDATA[pulsar]]></category>
            <category><![CDATA[data-engineering]]></category>
            <dc:creator><![CDATA[Mateus Oliveira]]></dc:creator>
            <pubDate>Mon, 27 Jun 2022 13:26:55 GMT</pubDate>
            <atom:updated>2022-06-27T13:26:55.461Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*EIeHOvuyCumyr97PdHAACQ.jpeg" /></figure><p>Um dos maiores desafios da nossa era é extrair, processar e entregar dados em tempo real. Não só isso, mas da melhor forma possível com latência de até 10 milissegundos, sim pode parecer fora da nossa realidade mas em diversos casos essa latência não é só necessária mas como crucial para a evolução de um negócio de sucesso.</p><p>Muito assim como eu utilizam o Apache Kafka para realizar essa tarefa, excelente plataforma de streaming que te garante robustez e componentes desacoplados, computação e armazenamento.</p><p>Porém assim como em qualquer mercado a competição e sempre melhor para o consumidor nesse caso nós engenheiros de dados, sendo assim para aumentar as nossas opções vem o Apache Pulsar.</p><p>Apache Pulsar foi criado no Yahoo em 2016 e se tornou um top level project da Apache Software foundation em 2018, mas o que o Apache Pulsar tem de tão diferente que pode ameaçar a hegemonia do apache Kafka?</p><p>Vamos ver a lista de recursos do Apache Pulsar:</p><ul><li>Cloud Native</li><li>Multi tenant</li><li>geo-replicação de eventos entre os clusters</li><li>Persistência de eventos através do Apache BookKeeper (Zero Rebalance)</li><li>Pulsar Functions</li><li>Pulsar IO</li><li>Pulsar Proxy</li><li>Pulsar SQL</li><li>Tiered Storage (open-source)</li></ul><p>Iremos entrar em cada um desses recursos.</p><p><strong>Cloud Native</strong></p><p>Apache Pulsar foi criado após o sucesso do Apache Kafka, sendo assim ele já vem com melhorias para superar o seu competidor, como ser cloud native, ele foi desenhado para aproveitar o máximo dos recursos de nuvem, hoje a versão open-source está disponível para AWS por meio de Ansible, Kubernetes, VM e Docker.</p><p><strong>Multi-Tenant</strong></p><p>Para seguir hoje as maiores tendências no mercado, o Apache Pulsar foi desenvolvido para ser multi-tenant ou o tenant é a unidade mais básica de categorização de tópicos, aonde você pode associar um namespace, ou seja você pode criar vários tenant em 1 cluster de Pulsar é associar namespaces a essa tenant, garantindo assim autorização em nível do namespace, múltiplas aplicações com namespaces diferentes cada um lendo de um set de tópicos.</p><p><strong>Geo-replicação</strong></p><p>Esse é um dos pontos muito interessantes no Pulsar, de forma bem simples, podemos criar replicação de eventos entre diferentes cluster, por exemplo podemos produzir dados em uma região e realizar a leitura em outra que irá receber os dados replicados. Podemos trabalhar de 2 formas.</p><p>Geo-replicação [Assíncrono]</p><p>Os eventos são persistidos no cluster Local, eventualmente eles vão para os clusters remotos de forma assícrona, responsabilidade dos brokers. Neste modo não temos perda de performance pois o cluster local irá receber e em seguida enviar para os clusters remotos porém eu tenho baixa consistência entre os cluster pois podemos ter um lag de replicações de eventos que não persistiram ainda, não é síncrono.</p><p>Geo-replicação [Síncrono]</p><p>No modo síncrono, os dados são enviados para o cluster local porém o Apache BookKeeper fica responsável por replicar os eventos, só recebemos o acknowledgment, retorno de persistência, com sucesso depois de gravar em todos os clusters envolvidos na replicação. Neste caso temos a mais alta disponibilidade e consistência de dados, porém será necessário maior latência pois temos que receber o retorno de todos os clusters.</p><p>Podemos ver que em todos os modos de replicação temos pontos positivos e negativos, avalie bem o seu use case.</p><p><strong>Apache BookKeeper</strong></p><p>O Apache BookKeeper ou Bookie é o componente responsável pela persistência dos dados no storage, sendo um sistema distríbuido WAL (write-ahead log). BookKeeper é bem interessante pois ele habilita alguns coisas bem legais para o Apache Pulsar, que são:</p><ul><li>Ledgers = estrutura de dados incrementais (append-only) de gravação única e designado para os bookies (cluster de BookKeeper). Broker cria o ledger, acrescenta as entradas para o Ledge e fecha o Ledge, após isso um ledge só pode ser aberta como modo de leitura.</li><li>Bookie oferece uma eficiente armazenamento de dados sequêncial que suporta entradas de replicação.</li><li>Entradas e saídas (I/O) entre os bookies.</li><li>Escalabilidade horizontal tanto para capacidade quanto performance.</li></ul><p>Dentre vários outros benefícios, Bookie é realmente um característica marcante no Apache Pulsar, porém acrescenta uma complexidade a mais por se tratar de mais um componente que requer gerenciamento. Não existe almoço de graça em tecnologia.</p><p><strong>Pulsar Functions</strong></p><p>Além do bookie, na minha opinião esse componentes é muito interessante e deixa o Apache Pulsar mais atrativo.</p><p>Functions, sim e isso que você leu, no Apache Pulsar temos um framework de desenvolvimento serverless (não precisa de servidor) para processamento simples de eventos, ou seja o tópico entra e a função e executada e gerado um tópico de saída processado.</p><p>Linguagens disponíveis:</p><ul><li>Java</li><li>Python</li><li>Go</li></ul><p>lembrando que esta é uma explicação resumida, em artigo futuros teremos maiores explicações sobre como utilizar esse recurso.</p><p>Lembrando que ele está usando o Apache Pulsar então não é um implementação separada. Muito interessante correto?</p><p><strong>Pulsar IO</strong></p><p>Pulsar IO tem o mesmo principio do Kafka Connect, desenvolver uma aplicação que lê dados de um data store e gravar no Pulsar em forma de um conector, o usuário só utiliza um arquivo de configuração.</p><p>Teste um pouco o Pulsar IO é ainda precisa de alguns ajustes se compararmos ao Kafka Connect, claro que o Kafka Connect tem mais tempo de mercado e dessa forma já está bem mais maduro, mas o Pulsar IO vem sendo acelerado para ser um concorrente direto e expressivo.</p><p><strong>Pulsar SQL</strong></p><p>Aqui temos uma integração do Pulsar e o PrestoSQL, podemos configurar um servidor de PrestoSQL e utilizar dentro do Pulsar para consultas SQL de forma simples e transparente, ou seja, consultar tópicos através de instruções SQL. Acredito que em pouco tempo teremos o Trino para a versão Kubernetes do Pulsar SQL.</p><p><strong>Pulsar Proxy</strong></p><p>Outro componente bem interessante é o Pulsar Proxy, aonde podemos criar um gateway opcional na frente do meu cluster de Brokers, a ideia é ao invés dos meus clientes acessarem diretamente os brokers através de uma lista de IPs, a chamada ser no Pulsar Proxy que ele irá se encarregar de fazer o networking load balance para que o cliente acesse o broker desejado.</p><p>Facilita muitas coisas além de aplicar uma camada de segurança na borda do cluster do Apache Pulsar, aonde ninguém de fora conhece o cluster de brokers.</p><p><strong>Tiered Storage</strong></p><p>Esse é uma opção que ainda não temos no Apache Kafka (open-source), que é o Tiered Storage, a ideia é mover os dados geralmente históricos que estão no Pulsar para um storage de longo termo mais barato, melhor que de forma automatizada. Por exemplo se o tópico atingiu o seu tempo de retenção, antes do expurgo dos dados, podemos mover para um AWS S3, GCS ou Azure Blob Storage, isso se torna interessante em empresas que precisam de rastreabilidade do dados por conta de auditorias.</p><p>Podemos ver que Apache Pulsar tem muitas features interessantes que irão elevar a competição no mundo de streaming, o que é muito bom para nós, engenheiros de dados que precisamos de mais tecnologias no nosso cinturão do batman!</p><p>Para fechar vamos ver a arquitetura do Apache Pulsar com algumas features mencionadas aqui?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zm8JNhrrUml0DBPY1UgAAA.png" /></figure><p>As features que não foram demonstradas aqui serão faladas em artigos futuros, a ideia é evitar confusão no entendimento do Apache Pulsar.</p><p>Nos acompanhe no perfil Engenharia de dados Academy, conteúdo de alto nível no mundo de engenharia de dados nacional e internacional.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f80ef975601" width="1" height="1" alt=""><hr><p><a href="https://medium.com/engenharia-de-dados-academy/entendendo-apache-pulsar-uma-plataforma-de-streaming-de-dados-8f80ef975601">Entendendo Apache Pulsar, uma plataforma de Streaming de dados</a> was originally published in <a href="https://medium.com/engenharia-de-dados-academy">Engenharia de Dados Academy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>