CommunityPesquisa e Análise de Dadosgithub.com

Projetando Contratos de Dados

Defina e imponha contratos de dados entre produtores e consumidores — esquema, semântica, responsabilidade, SLAs e versionamento explícitos — para evitar que mudanças upstream silenciosas quebrem pipelines downstream. Utilize quando uma alteração no esquema do produtor puder quebrar consumidores, ao definir uma interface entre equipes/serviços e o data warehouse, ou ao adicionar imposição de esquema na ingestão.

O que é Projetando Contratos de Dados?

Este skill orienta engenheiros de dados e desenvolvedores na criação e aplicação de contratos de dados entre times produtores e consumidores. Ele ajuda a evitar quebras silenciosas em pipelines downstream causadas por mudanças não comunicadas em esquemas upstream. O skill cobre desde a definição explícita de esquemas, semânticas, garantias de atualização e responsabilidades, até o versionamento e políticas de mudança. O fluxo de trabalho proposto envolve escrever o contrato como código versionado, impô-lo na fronteira de ingestão (validando na chegada), classificar mudanças como aditivas (seguras) ou quebra (exigindo nova versão) e, em caso de violação, rejeitar ou colocar em quarentena os dados enquanto alerta o produtor. Exemplos concretos incluem o uso de JSON Schema validado na ingestão e registro de esquemas Kafka/Avro com compatibilidade retroativa. Armadilhas comuns, como contratos apenas documentados (não impostos), versionamento ausente e falta de responsável, são destacadas para garantir uma adoção robusta.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Unknown-333/awesome-data-engineering-skills/tree/main/skills/designing-data-contracts

Installed? Explore more Pesquisa e Análise de Dados skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

O que Projetando Contratos de Dados faz?

Quando usar

  • Um upstream (serviço, evento, API, arquivo) alimenta pipelines downstream e uma alteração poderia quebrá-los silenciosamente.
  • Definindo a interface entre um time/sistema produtor e o data warehouse.
  • Adicionando imposição de esquema/qualidade na fronteira de ingestão.
  • NÃO use para alterações internas modelo-a-modelo dentro de um único projeto dbt (use testes + handling-schema-evolution).

O que um contrato especifica

  • Esquema: campos, tipos, nulabilidade e valores permitidos.
  • Semântica: o que cada campo significa e sua unidade/granularidade.
  • Garantias: frescor/SLA, expectativas de volume, unicidade de chaves.
  • Responsabilidade: quem produz e a quem contatar.
  • Versionamento + política de mudanças: como mudanças que quebram são comunicadas.

Fluxo de trabalho

- [ ] Escreva o contrato como um esquema versionado e versionado (não conhecimento tribal)
- [ ] Imponha-o na fronteira de ingestão (valide na chegada)
- [ ] Classifique as mudanças: aditivas (seguras) vs. quebra (precisa de nova versão)
- [ ] Em caso de violação, rejeite/coloque em quarentena e alerte o produtor
- [ ] Versione e comunique mudanças que quebram com antecedência
  1. Torne-o explícito e versionado. Armazene o contrato como código (JSON Schema, esquema Avro/Protobuf ou especificação YAML) junto ao pipeline, revisado como qualquer API.
  2. Imponha na fronteira. Valide os dados de entrada contra o contrato na chegada; rejeite ou coloque em quarentena violações em vez de carregá-los.
  3. Classifique as mudanças. Campos aditivos/opcionais = compatível com versões anteriores. Remover campos, renomear, restringir tipos/nulabilidade = quebra → nova versão.
  4. Falhe alto para o produtor, não silenciosamente downstream.

Padrões

Contrato como JSON Schema (imposto na ingestão):

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "required": ["order_id", "amount", "ordered_at"],
  "properties": {
    "order_id": { "type": "string" },
    "amount": { "type": "number", "minimum": 0 },
    "ordered_at": { "type": "string", "format": "date-time" },
    "coupon": { "type": ["string", "null"] }
  },
  "additionalProperties": false
}

Ponto de imposição — valide cada registro na ingestão; direcione falhas para um local de quarentena com o motivo e alerte o time produtor. Isso transforma uma quebra silenciosa downstream em um sinal imediato e com responsável na origem.

Registro de esquemas (Kafka/Avro) — imponha compatibilidade (BACKWARD) no momento da publicação para que produtores não possam enviar um esquema incompatível.

Armadilhas comuns

  • Contrato como documentação apenas — se não for imposto em código, ele se desvia e quebra silenciosamente.
  • Imposição no fundo do warehouse — capture violações na fronteira, antes que dados ruins se espalhem.
  • Sem versionamento — toda mudança se torna uma emergência; versione e desative gradualmente.
  • additionalProperties irrestrito quando você precisa de rigidez — campos inesperados passam; defina como false onde apropriado.
  • Sem responsável — um lote rejeitado sem ninguém para contatar paralisa o pipeline.
  • Mudanças que quebram sem prazo de aviso — coordene produtor/consumidor via esquemas versionados e uma janela de descontinuação.

Individual skills in this repo

This repo contains 9 individual skills — each has its own dedicated page.

Unknown-333/authoring-airflow-dags

Write production-grade Apache Airflow DAGs using the TaskFlow API — idempotent tasks, correct scheduling and catchup, retries/SLAs, connections/variables, and avoiding top-level code. Use when creating or reviewing Airflow DAGs, scheduling pipelines, wiring task dependencies, configuring retries/backfills, or fixing non-idempotent tasks.

Unknown-333/building-dagster-assets

Build Dagster pipelines using software-defined assets — asset dependencies, partitions, resources and IO managers, asset checks, and schedules/sensors. Use when creating Dagster assets or jobs, modeling data as assets, adding partitions or backfills, wiring resources/IO managers, or migrating from task-based orchestration to assets.

Unknown-333/building-dbt-models

Build well-structured dbt models — staging/intermediate/marts layers, ref() and source(), materializations, and incremental models with the right strategy. Use when creating or refactoring dbt models, choosing table vs view vs incremental, structuring a dbt project, or writing incremental logic.

Unknown-333/building-feature-pipelines

Build ML feature pipelines and feature stores — point-in-time-correct joins to avoid label leakage, offline/online parity, feature freshness and backfills, and materialization with tools like Feast. Use when engineering features for ML, preventing train/serve skew or data leakage, building a feature store, or backfilling historical features for training.

Unknown-333/building-iceberg-tables

Design and operate Apache Iceberg tables — partitioning and hidden partitioning, partition/schema evolution, snapshots and time travel, compaction and small-file cleanup, and MERGE/upsert for lakehouse tables on Spark, Flink, Trino, or Snowflake. Use when creating or maintaining Iceberg tables, choosing partitioning, evolving schema/partitions, or fixing small-file and metadata bloat.

Unknown-333/building-ingestion-pipelines

Build batch and incremental data ingestion (extract-load) pipelines — full vs incremental extraction, change data capture (CDC), watermarks and high-water marks, API pagination and rate limits, and choosing managed EL tools (Fivetran, Airbyte) vs custom code. Use when ingesting data from databases, APIs, files, or SaaS into a warehouse/lake, or designing incremental extraction and CDC.

Unknown-333/building-kafka-consumers

Build reliable Apache Kafka consumers and producers — consumer groups and partition assignment, offset commit strategy, at-least-once vs exactly-once, idempotent/transactional producers, rebalancing, and dead-letter handling. Use when writing Kafka consumers/producers, configuring offset commits or consumer groups, tuning throughput, or handling rebalances and poison messages.

Unknown-333/debugging-data-pipelines

Systematically root-cause data pipeline failures and data incidents — job errors, wrong or missing data, duplicates, and freshness misses — by tracing lineage upstream, isolating the failing stage, reconciling against source, and planning a safe fix and backfill. Use when a pipeline fails, numbers look wrong, data is missing or duplicated, a dashboard is stale, or a stakeholder reports a data discrepancy.

Unknown-333/designing-backfills-and-replays

Plan and run safe data backfills and replays — idempotent reprocessing of historical windows, partition-by-partition execution, isolating backfill compute from production, verifying results, and avoiding double-counting or changed history. Use when backfilling a new or fixed model, reprocessing after a bug, replaying events, or loading history for a new pipeline without corrupting existing data.

Habilidades Relacionadas