Data Mesh Sem a Complexidade: Um Bucket Por Time

Data mesh soa ótimo na teoria: propriedade descentralizada, dados orientados a domínio, infraestrutura self-serve. Na prática, geralmente significa 18 meses de trabalho de “time de plataforma” construindo um portal self-serve que ninguém usa.

Aqui está o segredo sujo: você não precisa de uma plataforma para fazer data mesh. Você precisa de um bucket por time e um pip install.

A promessa do data mesh (e a falha usual)

A promessa:

• Cada time é dono dos seus dados
• Sem gargalo central
• Infraestrutura self-serve
• Design orientado a domínio

A implementação usual:

• 6 meses construindo uma “plataforma de dados” com Terraform, Kubernetes e Airflow
• Um “time de plataforma” de 5 pessoas mantendo
• Times ainda não conseguem se integrar sem abrir um ticket
• $200k/ano em infraestrutura antes de qualquer query

A implementação DataSpoc:

• Cada time roda pip install dataspoc-pipe dataspoc-lens
• Cada time cria seu próprio bucket S3
• Cada time gerencia seus próprios pipelines
• Custo total: $0 + armazenamento S3 (~$5/mês por time)
• Tempo de setup: 30 minutos por time

A arquitetura

┌─────────────────────────────────────────────────────────────────┐
│                         Company Cloud (AWS/GCS/Azure)            │
│                                                                 │
│  ┌─────────────────┐  ┌─────────────────┐  ┌────────────────┐  │
│  │ s3://finance     │  │ s3://product     │  │ s3://marketing │  │
│  │                  │  │                  │  │                │  │
│  │ Pipe → Parquet   │  │ Pipe → Parquet   │  │ Pipe → Parquet │  │
│  │ Lens → SQL/AI    │  │ Lens → SQL/AI    │  │ Lens → SQL/AI  │  │
│  │ ML → predictions │  │                  │  │                │  │
│  │                  │  │                  │  │                │  │
│  │ IAM: finance-team│  │ IAM: product-team│  │ IAM: mkt-team  │  │
│  └─────────────────┘  └─────────────────┘  └────────────────┘  │
│                                                                 │
│  Cross-domain analyst: registers all 3 buckets in Lens          │
│  AI agent: connects via MCP, scoped to team's bucket            │
└─────────────────────────────────────────────────────────────────┘

Cada time é uma plataforma de dados autocontida:

• Seu próprio bucket (dados isolados)
• Sua própria configuração Pipe (suas fontes, seu agendamento)
• Sua própria configuração Lens (suas queries, seus transforms)
• Seu próprio agente de IA (MCP com escopo no seu bucket)

Sem infraestrutura compartilhada. Sem time central. Sem tickets.

Configurando o time de Finance (exemplo)

Passo 1: Criar o bucket e IAM

# AWS (or equivalent for GCS/Azure)
aws s3 mb s3://company-finance
aws iam create-policy --policy-name finance-data-access --policy-document '{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["s3:GetObject", "s3:PutObject", "s3:ListBucket"],
    "Resource": ["arn:aws:s3:::company-finance", "arn:aws:s3:::company-finance/*"]
  }]
}'

Passo 2: Instalar e configurar o Pipe

pip install dataspoc-pipe[s3]
dataspoc-pipe init

Pipeline: Postgres (ERP) → bucket Finance

source:
  tap: tap-postgres
  config: ~/.dataspoc-pipe/sources/erp.json
  streams:
    - invoices
    - payments
    - accounts_receivable

destination:
  bucket: s3://company-finance
  path: raw
  compression: zstd

incremental:
  enabled: true

schedule:
  cron: "0 6 * * *"  # daily at 6am

Pipeline: Stripe → bucket Finance

source:
  tap: tap-stripe
  config: ~/.dataspoc-pipe/sources/stripe.json
  streams:
    - charges
    - refunds
    - subscriptions

destination:
  bucket: s3://company-finance
  path: raw
  compression: zstd

incremental:
  enabled: true

schedule:
  cron: "0 7 * * *"

dataspoc-pipe run _ --all
dataspoc-pipe schedule install

Passo 3: Instalar e configurar o Lens

pip install dataspoc-lens[s3,ai,mcp]
dataspoc-lens init
dataspoc-lens add-bucket s3://company-finance

Passo 4: Criar transforms de domínio

-- ~/.dataspoc-lens/transforms/001_monthly_revenue.sql
CREATE OR REPLACE TABLE monthly_revenue AS
SELECT
    DATE_TRUNC('month', created_at) AS month,
    SUM(amount) AS revenue,
    COUNT(*) AS transactions,
    SUM(CASE WHEN type = 'refund' THEN amount ELSE 0 END) AS refunds
FROM charges
GROUP BY 1
ORDER BY 1;

-- ~/.dataspoc-lens/transforms/002_accounts_aging.sql
CREATE OR REPLACE TABLE accounts_aging AS
SELECT
    customer_id,
    SUM(CASE WHEN DATEDIFF('day', due_date, CURRENT_DATE) > 90 THEN amount ELSE 0 END) AS over_90,
    SUM(CASE WHEN DATEDIFF('day', due_date, CURRENT_DATE) BETWEEN 60 AND 90 THEN amount ELSE 0 END) AS days_60_90,
    SUM(CASE WHEN DATEDIFF('day', due_date, CURRENT_DATE) BETWEEN 30 AND 60 THEN amount ELSE 0 END) AS days_30_60,
    SUM(CASE WHEN DATEDIFF('day', due_date, CURRENT_DATE) < 30 THEN amount ELSE 0 END) AS current_amount
FROM accounts_receivable
WHERE status = 'open'
GROUP BY 1;

dataspoc-lens transform run

Passo 5: Conectar o agente de IA do time

dataspoc-lens mcp

Configuração Claude Desktop para o time de finance:

{
  "mcpServers": {
    "finance-data": {
      "command": "dataspoc-lens",
      "args": ["mcp"]
    }
  }
}

Agora o agente de IA do CFO pode perguntar:

"What's our monthly revenue trend?"
"Which customers have overdue payments over $10k?"
"What's our net retention rate this quarter?"

Cada resposta vem de SQL real nos dados do time de finance. Sem acesso aos buckets de outros times.

Configurando o time de Product (mesmo padrão, dados diferentes)

pip install dataspoc-pipe[s3] dataspoc-lens[s3,ai]
dataspoc-pipe init

# Product team sources: Postgres (app DB) + Mixpanel events
source:
  tap: tap-postgres
  config: ~/.dataspoc-pipe/sources/app-db.json
  streams:
    - users
    - subscriptions
    - feature_flags

destination:
  bucket: s3://company-product
  path: raw
  compression: zstd

incremental:
  enabled: true

dataspoc-lens add-bucket s3://company-product
dataspoc-lens ask "how many users signed up last week?"

O time de product tem zero visibilidade nos dados de finance. Finance tem zero visibilidade nos dados de product. IAM reforça as fronteiras, não código de aplicação.

Analytics cross-domain

O head de analytics precisa ver entre times. Simples — registre múltiplos buckets:

dataspoc-lens add-bucket s3://company-finance
dataspoc-lens add-bucket s3://company-product
dataspoc-lens add-bucket s3://company-marketing

Agora podem fazer JOIN entre domínios:

SELECT
    p.user_id,
    p.plan,
    f.lifetime_value,
    m.acquisition_channel
FROM product_users p
JOIN finance_customer_360 f ON p.user_id = f.customer_id
JOIN marketing_attribution m ON p.user_id = m.user_id
WHERE p.plan = 'enterprise';

Isso só funciona se o papel IAM do analista tem acesso de leitura aos três buckets. O modelo de acesso é:

Princípios de data mesh mapeados para DataSpoc

O contrato de dados: convenção de bucket

Times concordam em uma coisa — a estrutura do bucket:

s3://team-bucket/
  .dataspoc/manifest.json          # What tables exist (auto-generated)
  raw/<source>/<table>/*.parquet   # Raw ingested data
  curated/<domain>/<table>/*.parquet # Cleaned data
  gold/<domain>/<table>/*.parquet  # Business-ready aggregations

Este é o único contrato entre times. Se o time A quer compartilhar dados com o time B, eles concedem IAM de leitura no seu bucket. O time B registra com dataspoc-lens add-bucket. Pronto.

Sem API para construir. Sem catálogo de dados para manter. Sem reuniões de governança. O manifesto É o catálogo.

Escalando: de 1 time para 20

Team 1:  pip install → bucket → pipe → lens → agent    (30 min)
Team 2:  pip install → bucket → pipe → lens → agent    (30 min)
Team 3:  pip install → bucket → pipe → lens → agent    (30 min)
...
Team 20: pip install → bucket → pipe → lens → agent    (30 min)

Cada time é independente. Adicionar o time 20 não afeta os times 1-19. Sem Airflow compartilhado. Sem warehouse compartilhado. Sem compute compartilhado.

O que um “time de plataforma” faz neste modelo:

• Cria buckets e políticas IAM para novos times (5 min por time)
• Mantém o acesso do analista cross-domain
• Ajuda times com o primeiro setup de pipeline (oferta de serviço)
• Só isso. Sem Kubernetes. Sem Terraform. Sem time de 5 pessoas.

Custo por time

Para uma empresa de 10 times: $30-50/mês total. Compare com Databricks ($30k-100k/ano) ou Snowflake ($24k-120k/ano).

Quando isso não funciona

Sendo honesto:

• Escala de petabytes por time — DuckDB não aguenta. Precisa de Spark/Trino.
• Requisitos de real-time — DataSpoc é batch. Precisa de Kafka + Flink.
• Governança/compliance pesada — Precisa de um catálogo de dados real (DataHub, Atlan). Manifest.json é mínimo.
• 100+ fontes de dados por time — Gerenciar muitos taps Singer pode ficar complexo. Considere Meltano.
• Time sem habilidade técnica nenhuma — Precisa de conforto com CLI. Se não sabem pip install, use Fivetran + Looker.

Experimente

Configure seu primeiro domínio em 10 minutos:

pip install dataspoc-pipe[s3] dataspoc-lens[s3,mcp]

# Create your domain
dataspoc-pipe init
dataspoc-pipe add my-source
dataspoc-pipe run my-source

# Query your domain
dataspoc-lens init
dataspoc-lens add-bucket s3://my-team-data
dataspoc-lens shell

# Connect your team's AI agent
dataspoc-lens mcp

Data mesh não é um produto que você compra. É um padrão que você segue. O DataSpoc torna o padrão trivial: um bucket por time, pip install, pronto.