Saltar a contenido

Consumer Kafka con Spark Structured Streaming

Cuaderno base para consumir el topic orden-eventos desde Spark y parsear el JSON con un esquema común que funcione tanto si el productor fue hecho en Java como en Python.

Objetivo

  1. Conectarse a Kafka
  2. Leer mensajes del topic orden-eventos
  3. Convertir value a texto
  4. Parsear el JSON
  5. Filtrar eventos válidos
  6. Mostrar en consola los eventos con total > 100

Datos del entorno

  • Kafka broker interno: kafka:9092
  • Topic: orden-eventos
  • Spark: conector Kafka disponible desde el entorno
from pyspark.sql import SparkSession

KAFKA_CONNECTOR_PACKAGE = "org.apache.spark:spark-sql-kafka-0-10_2.13:4.1.2"

spark = (
    SparkSession.builder
    .appName("KafkaSparkOrdenes")
    .config("spark.jars.packages", KAFKA_CONNECTOR_PACKAGE)
    .getOrCreate()
)

spark.sparkContext.setLogLevel("WARN")
print("Spark:", spark.version)
print("Scala JVM:", spark.sparkContext._jvm.scala.util.Properties.versionNumberString())

Paso 1. Leer el stream desde Kafka

Aquí todavía no parseamos el JSON. Solo leemos los mensajes crudos del topic.

df_kafka = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "kafka:9092") \
    .option("subscribe", "orden-eventos") \
    .option("startingOffsets", "earliest") \
    .load()
df_kafka.printSchema()

Paso 2. Convertir value a texto (Saltar al paso 3)

Kafka entrega key y value en binario. Por eso primero convertimos value a STRING.

df_texto = df_kafka.selectExpr("CAST(value AS STRING) AS mensaje")
df_texto.printSchema()
# Vista rápida del mensaje en texto
# Si quieres depurar primero sin parsear JSON, ejecuta esta celda.
query_texto = df_texto.writeStream \
    .format("console") \
    .outputMode("append") \
    .option("truncate", False) \
    .start()

Cuando termines de ver mensajes crudos, detén la consulta antes de seguir:

query_texto.stop()

Paso 3. Definir el esquema común del evento

Este contrato permite que Spark interprete igual los mensajes vengan de Java o de Python.

Evento esperado

{
  "tipoEvento": "orden.creada",
  "ordenId": 1,
  "total": 150.0,
  "estado": "PENDIENTE",
  "origen": "java",
  "timestamp": 1710000000
}

Los campos origen y timestamp son opcionales.

from pyspark.sql.functions import col, from_json
from pyspark.sql.types import StructType, StructField, StringType, LongType, DoubleType

schema = StructType([
    StructField("tipoEvento", StringType(), True),
    StructField("ordenId", LongType(), True),
    StructField("total", DoubleType(), True),
    StructField("estado", StringType(), True),
    StructField("origen", StringType(), True),
    StructField("timestamp", LongType(), True)
])

Paso 4. Parsear el JSON

df_value = df_kafka.selectExpr("CAST(value AS STRING) AS value")

df_parsed = df_value.select(
    from_json(col("value"), schema).alias("data")
).select("data.*")
df_parsed.printSchema()

Paso 5. Validar registros

Filtramos mensajes que sí tengan al menos el contrato básico: - tipoEvento - ordenId - total - estado

df_validado = df_parsed.filter(
    col("tipoEvento").isNotNull() &
    col("ordenId").isNotNull() &
    col("total").isNotNull() &
    col("estado").isNotNull()
)

Paso 6. Transformación de ejemplo

En este caso, solo dejamos órdenes con total > 100.

df_transformed = df_validado.filter(col("total") > 0)

Paso 7. Salida a consola

# Momento 1: Consola debug visual
query_console = df_transformed.writeStream \
    .outputMode("append") \
    .format("console") \
    .option("truncate", False) \
    .start()

#query_console.awaitTermination()

Detener la consulta

Si necesitas detener manualmente la ejecución, puedes usar:

#query_console.stop()

Ejemplos de productores compatibles

Java

@NoArgsConstructor
@AllArgsConstructor
public class EventoOrden {
    private String tipoEvento;
    private Long ordenId;
    private Double total;
    private String estado;
}

Python

from kafka import KafkaProducer
import json, time, random

producer = KafkaProducer(
    bootstrap_servers='kafka:9092',
    value_serializer=lambda v: json.dumps(v).encode('utf-8')
)

while True:
    data = {
        "tipoEvento": "orden.creada",
        "ordenId": random.randint(1, 1000),
        "total": random.randint(50, 1500),
        "estado": "PENDIENTE",
        "origen": "python",
        "timestamp": int(time.time())
    }

    producer.send("orden-eventos", value=data)
    print("Enviado:", data)
    time.sleep(2)
# Momento 2: persistencia Arrancar stream a Parquet o Salida a Parquet

query_parquet = df_transformed.writeStream \
    .format("parquet") \
    .option("path", "data/orden_eventos_parquet") \
    .option("checkpointLocation", "checkpoint/orden-eventos") \
    .outputMode("append") \
    .start()
#Esperar micro-batch
import time
time.sleep(10)
#Leer lo guardado
df_final = spark.read.parquet("data/orden_eventos_parquet")

df_final.show(truncate=False)
df_final.printSchema()
df_final.select("tipoEvento", "ordenId", "total", "estado").show()
#Detener stream cuando ya no lo necesites, Detener ambas
#query_console.stop()
#query_parquet.stop()

# Guia de sesion: Spark Structured Streaming

Propósito

Consumir eventos Kafka con Spark Structured Streaming, parsear mensajes JSON, validar el contrato del evento y aplicar transformaciones básicas en tiempo real.

Esta guía complementa el notebook de la sesion. El notebook contiene la ejecución paso a paso; esta sección resume el objetivo pedagogico, las evidencias y la actividad autónoma.

Requisitos previos

Antes de empezar:

  • levantar Kafka desde kafka/;
  • verificar que exista el topic orden-eventos;
  • generar eventos desde uso-rapido/ec-orden-py o uso-ms-sb/ec-orden-ms;
  • levantar Spark/Jupyter con el override Kafka.
docker compose -f kafka/compose.yml up -d
docker compose -f pyspark/compose.yml -f pyspark/compose.kafka.yml up -d --build

Dentro de Docker, Spark debe usar el broker kafka:9092. Desde Windows/host, el broker expuesto es localhost:49092.

El override pyspark/compose.kafka.yml conecta PySpark a la red de Kafka. El conector spark-sql-kafka se declara en la SparkSession del notebook.

Evento esperado

{
  "tipoEvento": "orden.creada",
  "ordenId": 1,
  "total": 150.0,
  "estado": "PENDIENTE",
  "origen": "ec-orden-ms",
  "timestamp": 1710000000000
}

Campos minimos:

  • tipoEvento
  • ordenId
  • total
  • estado

Campos recomendados:

  • origen
  • timestamp

Practica

En el notebook:

  1. Crea una SparkSession.
  2. Lee desde orden-eventos usando .format("kafka").
  3. Convierte value de binario a texto.
  4. Parsea el JSON con un esquema explicito.
  5. Filtra eventos inválidos.
  6. Aplica una transformacion simple, por ejemplo total > 100.
  7. Configura salida a consola y checkpoint.
  8. Observa latencia, volumen y comportamiento del micro-batch.

Que observar

Registra:

  • si Spark recibe eventos en tiempo real;
  • si el parseo JSON funciona;
  • si el esquema coincide con el contrato;
  • cuantos eventos pasan el filtro;
  • diferencias entre eventos emitidos por Python y por Spring Boot;
  • efecto de cambiar trigger, volumen o frecuencia de generacion.

Evidencias

Adjunta:

  • captura del notebook leyendo desde Kafka;
  • captura del esquema parseado;
  • salida de eventos válidos;
  • evidencia del filtro aplicado;
  • tabla breve con observaciones de latencia y throughput.

Actividad autónoma

Ajusta parametros y registra su efecto:

Prueba Trigger Eventos generados Latencia observada Eventos procesados Observaciones
1
2
3