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¶
- Conectarse a Kafka
- Leer mensajes del topic
orden-eventos - Convertir
valuea texto - Parsear el JSON
- Filtrar eventos válidos
- 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-pyouso-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:
tipoEventoordenIdtotalestado
Campos recomendados:
origentimestamp
Practica¶
En el notebook:
- Crea una
SparkSession. - Lee desde
orden-eventosusando.format("kafka"). - Convierte
valuede binario a texto. - Parsea el JSON con un esquema explicito.
- Filtra eventos inválidos.
- Aplica una transformacion simple, por ejemplo
total > 100. - Configura salida a consola y checkpoint.
- 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 |