Big data: 5 V's, Hadoop, Spark, Kafka, Lambda/Kappa, teorema CAP

A ideia que organiza o assunto

Um banco relacional supõe duas coisas silenciosamente: que o dado cabe em uma máquina que se pode ampliar, e que o esquema é conhecido antes da escrita. As duas param de valer ao mesmo tempo quando chegam a telemetria de milhares de sensores, o log de um portal e o vídeo de uma fiscalização. É esse ponto de ruptura — e não um número de terabytes — que a expressão big data nomeia.

Daí saem as duas ideias que organizam o tópico inteiro.

Primeira: a definição é multidimensional. Nenhum V sozinho define big data. Volume é quanto, variedade é de que tipos, velocidade é com que rapidez chega e precisa ser tratado; veracidade e valor entraram depois. A consequência prática é que todo item que reduz o conceito a uma dimensão — “define-se apenas pelo volume”, “somente se aplica a dados não estruturados” — já está errado antes do resto da frase. Esse é, de longe, o item mais repetido deste tópico.

Segunda: se o dado não cabe numa máquina, leva-se o processamento até o dado. Inverter o sentido do movimento é o que torna tudo o mais derivável. O arquivo é fatiado em blocos espalhados por dezenas de nós, e a tarefa vai até o nó que já tem o bloco. Como ninguém consegue fazer tudo isso em um só componente, cada função vira uma peça: guardar (HDFS), processar (MapReduce, Spark), gerenciar recursos (YARN), coordenar (ZooKeeper), transportar (Kafka, Sqoop, Flume), consultar (Hive, Spark SQL). Quase todo item de ecossistema se resolve perguntando de qual dessas colunas é o verbo que o enunciado descreve.

Por que se usa (e o que custa)

Ganha-se escala horizontal sobre hardware comum: crescer é acrescentar nó, não trocar por um servidor maior; e ganha-se esquema na leitura, que permite guardar primeiro o dado bruto e decidir depois como interpretá-lo.

Paga-se em três moedas. Latência: o modelo distribuído é ótimo em varredura de arquivos grandes e ruim em acesso aleatório de baixa latência — HDFS não substitui banco transacional. Garantias: distribuir custa consistência forte, e boa parte do ecossistema oferece consistência eventual no lugar de ACID. Operação: são muitas peças, cada uma com sua configuração, e o esquema na leitura transfere para o consumidor o trabalho que o banco fazia na escrita — um data lake sem governo vira o pântano de sempre.

A formulação honesta para a prova: big data troca a garantia e a simplicidade do modelo relacional por escala e flexibilidade de formato. Quem enuncia o ganho sem o custo, ou o custo sem o ganho, está escrevendo o item errado.

Como funciona

HDFS — armazenar. Arquitetura mestre-escravo. O NameNode guarda os metadados: a árvore de diretórios e o mapa de qual bloco está em qual nó. Os DataNodes guardam os blocos. O dado nunca passa pelo mestre: o cliente pergunta ao NameNode onde está o bloco e conversa direto com o DataNode. O arquivo é quebrado em blocos grandes e cada bloco é replicado em mais de um nó, o que dá tolerância a falhas sem disco especial. O modelo de escrita é write once, read many — acrescenta-se ao fim, não se edita no meio.

MapReduce — processar em lote. O programador escreve duas funções; o framework faz o resto: divide a entrada em splits, cria as tarefas map nos nós que têm os blocos, embaralha e ordena os resultados intermediários, executa os reduce que agregam e reexecuta em outro nó a tarefa que falhou. Entre uma etapa e outra, o resultado intermediário vai para o disco — é essa gravação que custa caro em algoritmos iterativos.

YARN — gerenciar recursos. Separado do MapReduce desde o Hadoop 2: o ResourceManager negocia CPU e memória do cluster e os NodeManagers executam os contêineres. É o que permite Spark, Tez e MapReduce dividirem o mesmo cluster.

Spark — processar em memória. Mesmo princípio de paralelismo, decisão diferente: os conjuntos de dados (RDDs, DataFrames) ficam em memória entre as etapas, o que elimina o vaivém de disco e torna o motor muito mais rápido em cargas iterativas — aprendizado de máquina, grafos, consulta interativa. Não é sistema operacional nem sistema de arquivos: roda sobre YARN, Kubernetes ou Mesos e lê de HDFS, S3 ou bancos. Traz módulos próprios: Spark SQL (DataFrames e SQL), MLlib, GraphX e Structured Streaming.

O resto do ecossistema. Hive dá uma fachada SQL (HiveQL) sobre o armazenamento distribuído — sua razão de existir é dispensar o conhecimento de MapReduce. HBase é a base NoSQL orientada a colunas para acesso aleatório, com a tabela fatiada em regiões por faixa de chave, que se dividem sozinhas quando crescem. Sqoop move dados entre o Hadoop e bancos relacionais; Flume coleta logs; Pig escreve fluxos de transformação; ZooKeeper coordena (configuração, nomeação, sincronização, eleição de líder); Oozie agenda. Hadoop Common é o módulo das bibliotecas e utilitários — serialização, RPC, abstrações de sistema de arquivos.

Kafka — transportar. É um log distribuído, não um banco nem uma fila clássica. O produtor acrescenta eventos a um tópico; o tópico é quebrado em partições distribuídas entre os brokers; cada evento recebe um número sequencial, o offset. Três consequências que a banca cobra: o evento publicado é imutável (não se edita nem se apaga um registro — ele sai por retenção ou compactação); a ordem só é garantida dentro de uma partição; e quem guarda a posição de leitura é o consumidor, que pode reposicionar o offset e reler o histórico. Produtor e consumidor nunca se conhecem — falam com o tópico, o que dá o desacoplamento assíncrono.

Lambda e Kappa — arranjar as duas metades. O problema é que a análise precisa de duas coisas incompatíveis: resposta imediata sobre o que acabou de acontecer e precisão sobre todo o histórico. A Lambda responde com duas trilhas — camada batch que reprocessa o histórico completo, camada de velocidade que dá o resultado aproximado em tempo real, camada de serviço que reúne as duas — e paga com a lógica duplicada em dois códigos. A Kappa responde com uma trilha só: tudo é fluxo, e reprocessar o passado é reler o log de eventos desde o início — possível justamente porque o log é retido e o offset é rebobinável. A camada batch, portanto, é a diferença entre as duas.

Ingestão — lote × fluxo. Em lote, os registros são acumulados e carregados em janelas periódicas (completas ou incrementais, só o que mudou); há latência por construção e picos de consumo de processamento e banda. Em fluxo, cada evento é ingerido e tratado à medida que é gerado; a latência cai para segundos, e o custo sobe, porque a infraestrutura fica permanentemente ativa.

O que decide os itens

Os cinco Vs — a definição de cada um em uma palavra. A troca de um pelo outro é a distorção mais barata do tópico:

V	é	não é
Volume	a magnitude da massa de dados	diversidade de formatos
Velocidade	a rapidez de geração e de tratamento (inclui tempo real)	tamanho
Variedade	tipos e formatos, e a multiplicidade de fontes	quantidade de dados
Veracidade	confiabilidade e qualidade do dado	quantidade de fontes
Valor	o retorno extraído da análise	custo de armazenamento

Visualização, virtualização e validação não são Vs de big data — são iscas com a letra certa.

Graus de estrutura — o eixo mais repetido deste tópico:

	exemplo	onde vive
estruturado	tabelas, planilhas	banco relacional, data warehouse
semiestruturado	JSON, XML, log com marcação	NoSQL documental, data lake
não estruturado	texto livre, imagem, áudio, vídeo, redes sociais	data lake, NoSQL, objetos

Big data cobre os três. Todo item que exclui um deles — “somente dados não estruturados”, “descarta dados não estruturados”, “não engloba dados não estruturados” — é errado pela mesma razão.

Quem faz o quê no Hadoop — armazenar × processar × gerenciar × coordenar:

componente	faz	não faz
HDFS	armazena blocos distribuídos e replicados	não processa
NameNode	guarda metadados e localiza blocos	não armazena nem trafega o dado
DataNode	guarda e serve os blocos	não conhece a árvore de diretórios
MapReduce	processa em lote, em paralelo	não armazena nem gerencia recursos
YARN	negocia CPU e memória do cluster	não processa dado nem o guarda
ZooKeeper	coordena: configuração, sincronização, eleição	não armazena dado de negócio
Hadoop Common	bibliotecas, serialização, interfaces	não executa tarefa de processamento
Hive	consulta com HiveQL (dispensa MapReduce)	não é banco transacional
HBase	acesso aleatório, regiões por faixa de chave	não é motor de consulta SQL
Sqoop	transfere entre Hadoop e banco relacional	não é ferramenta de data warehouse

Spark × MapReduce — memória × disco:

	MapReduce	Spark
dado entre etapas	gravado em disco	mantido em memória
carga iterativa	lenta (relê a cada passada)	rápida
categoria	motor de processamento em lote	motor unificado (lote, fluxo, SQL, ML)
posição na pilha	roda sobre YARN	roda sobre YARN, Kubernetes ou Mesos

Kafka — o que ele é e o que ele não é:

conceito	regra
tópico	log de acréscimo apenas; evento publicado é imutável
partição	divisão do tópico; unidade de paralelismo e de ordenação
ordem	garantida dentro da partição, nunca no tópico inteiro
broker	servidor que hospeda muitas partições de muitos tópicos
offset	posição de leitura controlada pelo consumidor, rebobinável
Producer API	publica
serialização	produtor serializa (key.serializer); consumidor desserializa
segurança	TLS em trânsito, autenticação SSL/SASL, autorização por ACL

Lambda × Kappa:

	Lambda	Kappa
trilhas de processamento	duas (lote + tempo real)	uma (fluxo)
camadas	batch, velocidade, serviço	processamento em fluxo + serviço
histórico	reprocessado pela camada batch	reprocessado relendo o log
custo	lógica duplicada em dois códigos	depende da retenção integral do log

Lote × fluxo (vale para ingestão e para processamento):

	lote	fluxo (streaming)
gatilho	janela periódica	evento, continuamente
dado	em repouso, já persistido	em movimento, antes de persistir
latência	alta, por construção	segundos ou menos — reduzida, nunca zero
recursos	picos em janelas	infraestrutura sempre ativa, custo maior
“incremental”	variante do lote (só o delta)	não é sinônimo de tempo real

Análise, por pergunta — descritiva (o que aconteceu), diagnóstica (por que aconteceu), preditiva (o que vai acontecer), prescritiva (o que fazer). A banca casa a pergunta de um nível com o nome do outro.

BI que entra no tópico — fato guarda o evento mensurável, dimensão guarda o contexto descritivo; OLAP consulta cubo multidimensional sem concorrer com o OLTP (roll up agrega, drill down detalha, slice e dice recortam, pivot gira); índice bitmap é bom em data warehouse e ruim em ambiente de escrita intensa; CRISP-DM constrói o modelo na fase de modelagem, não na de preparação; normalização é projeto lógico, não criação de índice.

Números que caem

bloco padrão do HDFS	128 MB (era 64 MB no Hadoop 1)
fator de replicação padrão do HDFS	3
NameNode ativo por cluster	1 (mais um standby em alta disponibilidade)
Vs originais × ampliados	3 (volume, variedade, velocidade) → 5 (com veracidade e valor)
camadas da arquitetura Lambda	3 (batch, velocidade, serviço)
trilhas de processamento da Kappa	1
retenção padrão de tópico no Kafka	168 horas (7 dias)
fator de replicação usual de tópico Kafka	3
ganho anunciado do Spark sobre o MapReduce	até 100× em memória, 10× em disco
fases do CRISP-DM	6
módulos do Hadoop	4 (Common, HDFS, YARN, MapReduce)

Como a CEBRASPE derruba você aqui

Inverter o sentido do mecanismo. É o padrão mais frequente do tópico, mais de um terço dos itens errados, e costuma morar no fim da frase. Sobre o próprio conceito: “não engloba dados não estruturados”, “descartam dados não estruturados” — é justamente o dado não estruturado que motivou o ecossistema distribuído. Sobre o Hadoop: “o processamento em grandes computadores, o que facilita o processamento centralizado de dados” — o projeto é o oposto, clusters de máquinas comuns com o cálculo levado até o bloco; e “a impossibilidade de conectá-lo ao sistema de arquivos local de uma máquina”, que não existe. Sobre o Kafka: “porém os tópicos não podem ser quebrados em partições” — a partição é a divisão do tópico, não a alternativa a ele; “se necessário, pode ser editado” — o log é de acréscimo apenas. Sobre o Spark: “ele não suporta operações algébricas”. Sobre o tempo real: “geralmente requer menos recursos computacionais” que o lote, quando manter estado em memória e capacidade dimensionada para o pico é o que custa caro; e “em que não é possível entregar dados em fluxos”, que descreve o lote sob o nome de streaming. Metade verdadeira seguida de oração adversativa ou de negativa final é a assinatura: leia a frase até o fim e remonte a direção antes de decidir.

Descrever certo e apontar o componente ou a fase errada. Um quinto dos itens. “O Hadoop MapReduce” para bibliotecas comuns, serialização e chamada remota — é o Hadoop Common. A arquitetura Kappa com “processamento em lote e processamento de fluxo com uma abordagem em quatro camadas” — dois caminhos em camadas é a Lambda, e são três. No CRISP-DM, a construção dos modelos “na etapa de preparação de dados” — é na modelagem. E o par lote × fluxo, que troca de lado nas duas direções: a ingestão em lote que “pode fornecer insights instantâneos”, e o streaming em que “os dados são coletados de forma incremental, ou seja, apenas os dados novos são processados”, que é carga incremental, variante do lote. A frase inteira está correta menos o nome; leia o nome do componente, do modo de ingestão ou da fase por último.

Reduzir a definição a uma dimensão. “Apenas ao grande volume de dados que uma organização coleta”, “apenas pelo volume de dados”, “somente se aplica a dados não estruturados”, “deve ser aplicado exclusivamente no tratamento de dados estruturados” para o MapReduce, “os dados são invariavelmente persistidos antes de serem processados”, “sendo cada broker responsável por hospedar apenas uma partição de tópicos”, “são as mesmas utilizadas em bancos de dados relacionais”. Volume é um V entre cinco; big data abrange os três graus de estrutura; o MapReduce nasceu para texto bruto; o broker hospeda muitas partições de muitos tópicos. A defesa é localizar a palavra de exclusão — apenas, somente, exclusivamente, invariavelmente, as mesmas — e testá-la com um contraexemplo antes de avaliar o resto do conteúdo.

Trocar um termo pelo vizinho de vocabulário. “A análise descritiva permite que eventos futuros sejam previstos” — descreve a preditiva. “A propriedade de volume” para diversidade de tipos e formatos — é variedade. “Volume, variedade e visualização” — o terceiro V é velocidade, e visualização é etapa de apresentação. “A API consumer para publicar eventos em tópicos Kafka” — publicar é da Producer. “Hive e Sqoop” emparelhados com consulta e data warehousing — as duas coisas são do Hive; o Sqoop transfere dados entre o Hadoop e bancos relacionais. E a troca mais grosseira, a de categoria: o Spark como “uma arquitetura de sistema operacional para trabalhar com dados organizados de forma hierárquica”. Antes de discutir o detalhe, confira a categoria: HDFS é sistema de arquivos, YARN é gerenciador de recursos, Spark é motor de processamento, Kafka é log de eventos, Hive é data warehouse sobre o Hadoop. Categoria errada derruba o item sozinha.

Erros clássicos

Achar que big data é um limiar de tamanho. Não existe o número de terabytes a partir do qual o dado “vira” big data. O critério é a inviabilidade de tratá-lo com as ferramentas convencionais, e ela pode vir da variedade ou da velocidade sem volume extremo algum.

Confundir data lake com data warehouse. Lake guarda dado bruto, em formato nativo, com esquema aplicado na leitura. Warehouse guarda dado já modelado, com esquema na escrita. Ligar dado estruturado ao lake, ou dado bruto ao warehouse, é a troca que a banca repete.

Pensar que o dado passa pelo NameNode. Ele só sabe onde o bloco está. O tráfego é entre cliente e DataNode. A mesma lógica vale para o ResourceManager do YARN, que negocia e não executa.

Supor que Hive exige MapReduce do analista. Toda camada de abstração — Hive, Pig, Spark SQL — existe para dispensar o código de baixo nível. Item que reintroduza a exigência eliminada pela ferramenta inventou a causalidade.

Tratar “incremental” como sinônimo de tempo real. Carga incremental é lote que traz só o delta — continua periódica. O que define streaming é a continuidade, não o recorte do que mudou.

Esperar ordenação global no Kafka. A garantia é por partição. Quem precisa de ordem entre eventos relacionados usa a mesma chave, para que caiam na mesma partição — não é o tópico que ordena.

Achar que a Kappa é a Lambda simplificada em duas camadas de processamento. Não há camada batch na Kappa; há um caminho só. Se o item fala em lote e fluxo convivendo em camadas, está descrevendo a Lambda, qualquer que seja o nome que assine.