Observabilidad de pipeline Kafka + Spark¶
Notebook principal de la sesion 08 para medir disponibilidad, latencia, throughput, logging estructurado y alertas propuestas sobre el pipeline:
Producer -> Kafka -> Spark Structured Streaming -> evidencias
Este notebook empieza desde cero y no reemplaza al 07_spark_streaming_consumer_ordenes.ipynb ni al previo 08_obs_basico.ipynb; los usa como base conceptual, pero aqui se trabaja la observabilidad principal de la sesion 08.
Objetivo¶
- Leer eventos desde Kafka.
- Conservar metadata Kafka:
topic,partition,offset,kafkaTimestamp. - Validar eventos y separar registros validos/invalidos.
- Calcular
processedAtylatencyMs:processedAtes el momento en que Spark procesa el evento;latencyMses la diferencia entreprocessedAty eltimestampenviado por el producer. - Estimar throughput con
lastProgress:numInputRows,inputRowsPerSecondyprocessedRowsPerSeconddescriben el ultimo micro-batch procesado. - Persistir evidencia observable en Parquet.
- Relacionar Spark con Prometheus, Grafana y alertas propuestas.
Datos del entorno¶
- Kafka broker interno:
kafka:9092 - Topic:
orden-eventos - Prometheus:
http://localhost:49090 - Grafana:
http://localhost:43000 - Kafka Exporter:
http://localhost:49308/metrics - Salida Parquet:
/opt/artifacts/output/orden_eventos_observabilidad_p1
Paso 1. Crear SparkSession¶
Se crea la SparkSession. El conector Kafka ya debe estar disponible en el entorno Spark.
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("observabilidad-pipeline-kafka-spark")
.config("spark.jars.packages", KAFKA_CONNECTOR_PACKAGE)
.getOrCreate()
)
spark.sparkContext.setLogLevel("WARN")
spark
Paso 2. Definir parametros y helper de streams¶
El helper evita dejar queries activas cuando una celda se ejecuta mas de una vez.
KAFKA_BOOTSTRAP_SERVERS = "kafka:9092"
TOPIC_ORDENES = "orden-eventos"
OUTPUT_PATH = "/opt/artifacts/output/orden_eventos_observabilidad_p1"
CHECKPOINT_PATH = "/opt/artifacts/checkpoint/orden-eventos-observabilidad-p1"
def stop_query_if_exists(name):
query = globals().get(name)
if query is not None and query.isActive:
query.stop()
print(f"{name} detenida.")
else:
print(f"{name} no estaba activa.")
def stop_active_streams():
active = spark.streams.active
print(f"Queries activas: {len(active)}")
for query in active:
print(f"Deteniendo {query.name or query.id}")
query.stop()
Paso 3. Leer eventos desde Kafka¶
startingOffsets = latest evita reprocesar backlog antiguo cuando se esta haciendo una prueba en vivo.
df_kafka = spark.readStream \
.format("kafka") \
.option("kafka.bootstrap.servers", KAFKA_BOOTSTRAP_SERVERS) \
.option("subscribe", TOPIC_ORDENES) \
.option("startingOffsets", "latest") \
.option("failOnDataLoss", "false") \
.load()
df_kafka.printSchema()
Paso 4. Parsear JSON y conservar metadata Kafka¶
El campo timestamp del evento esta en milisegundos Unix y representa cuando el producer genero/publico el evento.
from pyspark.sql.functions import col, from_json, current_timestamp, unix_millis
from pyspark.sql.types import StructType, StructField, StringType, LongType, DoubleType
schema_evento = 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),
])
df_value = df_kafka.select(
col("topic"),
col("partition"),
col("offset"),
col("timestamp").alias("kafkaTimestamp"),
col("value").cast("string").alias("value")
)
df_parsed = df_value.select(
"topic",
"partition",
"offset",
"kafkaTimestamp",
from_json(col("value"), schema_evento).alias("evento")
).select("topic", "partition", "offset", "kafkaTimestamp", "evento.*")
df_parsed.printSchema()
Paso 5. Crear dataframe observable¶
isValid: indica si el evento cumple campos minimos.processedAt: momento de procesamiento en Spark, en ms.latencyMs: diferencia entre procesamiento y creacion del evento.
df_observable = df_parsed \
.withColumn(
"isValid",
col("tipoEvento").isNotNull()
& col("ordenId").isNotNull()
& col("total").isNotNull()
& col("timestamp").isNotNull()
) \
.withColumn("processedAt", unix_millis(current_timestamp())) \
.withColumn("latencyMs", col("processedAt") - col("timestamp"))
df_observable.printSchema()
Paso 6. Salida a consola¶
Arranca un stream visual para generar evidencia rapida. Para que la evidencia Parquet capture los mismos eventos, inicia tambien el Paso 8 antes de producir eventos.
stop_query_if_exists("query_console")
query_console = df_observable.writeStream \
.queryName("orden_eventos_console_observabilidad") \
.outputMode("append") \
.format("console") \
.option("truncate", False) \
.start()
# query_console.awaitTermination()
Paso 7. Revisar throughput y lag desde Spark¶
Ejecuta esta celda despues de iniciar Parquet y producir eventos. lastProgress muestra el rendimiento del ultimo progreso o ultimo micro-batch.
numInputRows: numero de filas/eventos de entrada en ese micro-batch.inputRowsPerSecond: filas de entrada por segundo.processedRowsPerSecond: filas procesadas por segundo.avgOffsetsBehindLatestymaxOffsetsBehindLatest: atraso promedio/maximo respecto al ultimo offset disponible en Kafka.
Si numInputRows sale 0, significa que Spark ejecuto el micro-batch, pero no habia eventos nuevos.
import json
progress = query_console.lastProgress
if progress is None:
print("Todavia no hay micro-batch procesado. Produce un evento y espera unos segundos.")
else:
source = progress["sources"][0]
metrics = source.get("metrics", {})
status = "idle" if progress["numInputRows"] == 0 else "processed"
log = {
"service": "spark-streaming",
"component": "consumer",
"topic": TOPIC_ORDENES,
"batchId": progress["batchId"],
"numInputRows": progress["numInputRows"],
"inputRowsPerSecond": progress["inputRowsPerSecond"],
"processedRowsPerSecond": progress["processedRowsPerSecond"],
"avgOffsetsBehindLatest": metrics.get("avgOffsetsBehindLatest"),
"maxOffsetsBehindLatest": metrics.get("maxOffsetsBehindLatest"),
"status": status
}
print(json.dumps(log, indent=2))
progress
Interpretacion del resultado del Paso 7¶
Si el resultado muestra numInputRows: 0, Spark esta activo y observando Kafka, pero en ese ultimo micro-batch no encontro eventos nuevos.
batchId: numero del micro-batch ejecutado.numInputRows: eventos recibidos en ese micro-batch.inputRowsPerSecond: velocidad de entrada de eventos.processedRowsPerSecond: velocidad de procesamiento de Spark.avgOffsetsBehindLatestymaxOffsetsBehindLatest: atraso respecto al ultimo offset disponible en Kafka.status: estado calculado para el micro-batch.idlesignifica sin eventos nuevos;processedsignifica que Spark procesó eventos.
Ejemplo: si numInputRows, inputRowsPerSecond y processedRowsPerSecond salen 0, significa que no llegaron eventos nuevos en ese intervalo. Si ademas maxOffsetsBehindLatest es 0, el consumer esta al dia.
Evidencia alternativa: Spark UI¶
Abre http://localhost:4040 y entra a Structured Streaming -> Streaming Query Statistics.
| Seccion Spark UI | Que indica |
|---|---|
Input Rate |
velocidad de entrada de eventos hacia Spark |
Process Rate |
velocidad con la que Spark procesa eventos |
Input Rows |
cantidad de filas/eventos por micro-batch |
Batch Duration |
tiempo que tarda cada micro-batch |
Operation Duration |
desglose del tiempo usado por operaciones internas |
Lectura rapida: si Input Rows es 0, no llegaron eventos en ese micro-batch. Si Process Rate es mayor que Input Rate, Spark procesa mas rapido de lo que entran los eventos.
Paso 8. Persistir evidencia observable en Parquet¶
Esta salida guarda los eventos procesados con metadata Kafka y campos de observabilidad.
stop_query_if_exists("query_parquet")
query_parquet = df_observable.writeStream \
.queryName("orden_eventos_parquet_observabilidad_p1") \
.format("parquet") \
.option("path", OUTPUT_PATH) \
.option("checkpointLocation", CHECKPOINT_PATH) \
.outputMode("append") \
.start()
Paso 8.1. Producir eventos¶
Con query_console y query_parquet activos, genera eventos desde ec-orden-py o ec-orden-ms.
Ejemplo con ec-orden-ms desde PowerShell:
Invoke-RestMethod `
-Method Post `
-Uri "http://localhost:19021/ordenes" `
-ContentType "application/json" `
-Body '{"usuarioId":2,"total":600}'
Despues espera unos segundos y vuelve a ejecutar el Paso 7 para revisar throughput.
Paso 9. Leer evidencia guardada¶
Ejecuta esta celda despues de producir eventos y esperar algunos segundos.
#Leer lo guardado
#df_final = spark.read.parquet("data/orden_eventos_parquet")
#df_final.show(truncate=False)
df_final = spark.read.parquet(OUTPUT_PATH)
df_final.orderBy(col("offset").desc()).show(truncate=False)
Paso 10. Prometheus¶
Abre http://localhost:49090 y revisa:
Status > Targets: los targetsprometheusykafka-exporterdeben estarUP.- Ejecuta estas consultas:
kafka_brokers
up{job="kafka-exporter"}
kafka_broker_info
kafka_consumergroup_lag
Si kafka_consumergroup_lag no devuelve datos, usa un consumer group activo y vuelve a consultar.
Interpretacion rapida:
kafka_broker_info = 1: Kafka Exporter detecta el broker Kafka.up{job="kafka-exporter"} = 1: Prometheus pudo consultar el exporter.up{job="kafka-exporter"} = 0: el exporter esta caido o Prometheus no lo alcanza.kafka_consumergroup_lag = 0: el consumer group esta al dia.kafka_consumergroup_lag > 0: hay eventos pendientes por consumir.
Paso 11. Grafana¶
Abre http://localhost:43000 con admin / admin.
Crea un dashboard minimo:
| Panel | Consulta | Visualizacion |
|---|---|---|
| Kafka Brokers | kafka_brokers |
Stat |
| Kafka Exporter Up | up{job="kafka-exporter"} |
Stat |
| Kafka Broker Info | kafka_broker_info |
Table |
| Consumer Lag | kafka_consumergroup_lag |
Time series o Table |
Interpretacion del panel Consumer Lag¶
Si usas la consulta kafka_consumergroup_lag, Grafana dibuja una linea por cada consumergroup.
- Valor
0: el consumer group esta al dia; no tiene mensajes pendientes. - Valor
1: hay 1 mensaje pendiente por consumir en ese momento. - Pico corto de
1y luego vuelve a0: entro un evento, el consumer se atraso momentaneamente y luego lo consumio. - Valor mayor que
0sostenido: el consumer no esta alcanzando el ritmo de produccion o esta detenido.
En un panel como Consumer Lag, una linea plana en 0 es buena senal. Un pico pequeno y temporal es normal durante la llegada de eventos. Lo preocupante es que el lag crezca o se mantenga alto.
Adjunta capturas de Explore y del dashboard.
Paso 12. Alertas propuestas¶
| Situacion | Regla propuesta | Accion |
|---|---|---|
| Kafka no visible | kafka_brokers < 1 |
Revisar contenedor Kafka |
| Exporter caido | up{job="kafka-exporter"} == 0 |
Revisar exporter y red Docker |
| Lag alto | kafka_consumergroup_lag > 100 |
Revisar consumer, particiones y carga |
| Eventos invalidos | invalidRows > 0 |
Revisar contrato del evento |
Para esta practica, las alertas pueden entregarse como propuesta documentada. Si deseas configurarlas en Grafana Alerting, usa este flujo minimo:
Crear una alerta en Grafana¶
- Entra a
Alerting -> Alert rules. - Selecciona
New alert rule. - Define el nombre, por ejemplo
Lag alto en Kafka. - En
Query, selecciona el datasourcePrometheus. - Usa una consulta, por ejemplo:
kafka_consumergroup_lag > 100
- En
Evaluate every, usa1m. - En
For, usa2mpara evitar alertas por picos muy breves. - En condicion, deja que la regla dispare cuando el resultado sea mayor que
0. - Guarda la regla.
Otra alerta util:
up{job="kafka-exporter"} == 0
Interpretacion: si se cumple, Prometheus no puede consultar el Kafka Exporter.
Ejemplo 2 opcional: latencia calculada en Spark¶
latencyMs no esta en Prometheus por defecto. En esta practica se calcula en Spark y se revisa desde el notebook o desde Parquet.
| Situacion | Regla operativa | Donde se evalua |
|---|---|---|
| Latencia alta sensible | latencyMs > 100 |
Notebook Spark / Parquet |
| Latencia alta critica | latencyMs > 1000 |
Notebook Spark / Parquet |
Ejemplo:
df_final.filter("latencyMs > 100").show()
Resumen: Grafana/Prometheus cubre up, kafka_brokers y kafka_consumergroup_lag; Spark/Parquet cubre latencyMs, eventos invalidos y throughput del micro-batch.
df_final.filter("latencyMs > 100").show()
#Próxima clase: ML
from pyspark.sql.functions import col, window, avg, min as spark_min, max as spark_max, count
df = spark.read.parquet("/opt/artifacts/output/orden_eventos_observabilidad_p1")
serie_latency = df.groupBy(
window(col("kafkaTimestamp"), "1 minute")
).agg(
count("*").alias("numEventos"),
avg("latencyMs").alias("avgLatencyMs"),
spark_min("latencyMs").alias("minLatencyMs"),
spark_max("latencyMs").alias("maxLatencyMs")
).orderBy("window")
serie_latency.show(100, truncate=False)
serie_latency_limpia = serie_latency.select(
col("window.start").alias("inicioVentana"),
col("window.end").alias("finVentana"),
"numEventos",
"avgLatencyMs",
"minLatencyMs",
"maxLatencyMs"
)
serie_latency_limpia.show(100, truncate=False)
#avgLatencyMs = latencia real promedio del minuto
#predictedLatencyMs = predicción usando los 3 minutos anteriores
#errorMs = diferencia entre real y predicho
from pyspark.sql.functions import col, window, avg, count
from pyspark.sql.window import Window
from pyspark.sql.functions import lag
df = spark.read.parquet("/opt/artifacts/output/orden_eventos_observabilidad_p1")
serie = df.groupBy(
window(col("kafkaTimestamp"), "1 minute")
).agg(
count("*").alias("numEventos"),
avg("latencyMs").alias("avgLatencyMs")
).select(
col("window.start").alias("inicioVentana"),
col("window.end").alias("finVentana"),
"numEventos",
"avgLatencyMs"
).orderBy("inicioVentana")
w = Window.orderBy("inicioVentana").rowsBetween(-3, -1)
serie_prediccion = serie.withColumn(
"predictedLatencyMs",
avg("avgLatencyMs").over(w)
).withColumn(
"errorMs",
col("avgLatencyMs") - col("predictedLatencyMs")
)
serie_prediccion.show(100, truncate=False)
Paso 13. Detener streams¶
Al terminar la practica, detiene las queries activas para evitar conflictos con checkpoints o salidas Parquet.
stop_active_streams()
# Sesion 08 - Costos y escalado de pipelines streaming
Propósito¶
Esta segunda parte completa la sesion 08 de observabilidad con una estimación cloud-agnostic de recursos, costos y escalado para el pipeline:
Producer -> Kafka -> Spark Structured Streaming
Debe trabajarse despues de 08_obs_basico.ipynb y 08_observabilidad_pipeline_kafka_spark.ipynb, porque usa las mismas evidencias de latencia, throughput y lag del topic orden-eventos.
La idea no es elegir un proveedor cloud, sino justificar capacidad usando unidades técnicas: vCPU, memoria, almacenamiento, red, particiones Kafka, ejecutores Spark, retención y réplicas.
Resultado esperado¶
Entrega una propuesta técnica que incluya:
- volumen esperado de eventos;
- throughput promedio y de pico;
- número inicial de particiones Kafka;
- recursos estimados para Kafka;
- recursos estimados para Spark;
- estrategia de escalado horizontal o vertical;
- impacto de retención de mensajes y logs;
- riesgos de lag, backpressure o saturacion;
- buenas prácticas para optimizar costos;
- comparacion de escenarios pequeño, medio y alto.
Caso base¶
Usa como referencia:
Producer de ordenes -> Kafka topic orden-eventos -> Spark Structured Streaming
Evento ejemplo:
{
"ordenId": 101,
"tipoEvento": "orden.creada",
"total": 150.0,
"estado": "PENDIENTE",
"timestamp": 1710000000000,
"origen": "ec-orden-ms"
}
Supuestos iniciales:
| Supuesto | Valor inicial |
|---|---|
| Tamaño promedio del evento | 1 KB |
| Topic principal | orden-eventos |
| Retencion inicial | 7 dias |
| Ambiente dev | 1 broker, replication factor 1 |
| Ambiente productivo propuesto | 3 brokers, replication factor 3 |
1. Estimar volumen¶
Formula:
volumen_diario = cantidad_eventos_dia * tamaño_promedio_evento
Ejemplos:
| Escenario | Eventos por dia | Tamaño evento | Volumen diario |
|---|---|---|---|
| Pequeño | 10 000 | 1 KB | 10 MB/dia |
| Medio | 1 000 000 | 1 KB | 1 GB/dia |
| Alto | 10 000 000 | 1 KB | 10 GB/dia |
2. Estimar throughput¶
Formula:
throughput_promedio = eventos_dia / 86 400
throughput_pico = throughput_promedio * factor_pico
Ejemplo:
1 000 000 eventos/dia / 86 400 = 11.57 eventos/s promedio
Si el factor pico es 25, el pico aproximado es 289 eventos/s
3. Definir particiones Kafka¶
Más particiones permiten mas paralelismo, pero también aumentan el overhead operativo.
Regla práctica para la propuesta:
| Escenario | Particiones sugeridas | Criterio |
|---|---|---|
| Pequeño | 1 | Bajo volumen y laboratorio |
| Medio | 3 a 6 | Picos moderados y consumidores paralelos |
| Alto | 12 o mas | Alta concurrencia y crecimiento esperado |
La decisión debe justificarse con throughput, paralelismo de consumidores y crecimiento esperado.
4. Estimar almacenamiento con retención¶
Formula:
almacenamiento_base = volumen_diario * dias_retención
almacenamiento_con_réplicas = almacenamiento_base * replication_factor
almacenamiento_recomendado = almacenamiento_con_réplicas * 1.3
Ejemplo:
volumen diario: 5 GB
retención: 7 dias
replication factor: 3
almacenamiento_base = 35 GB
almacenamiento_con_réplicas = 105 GB
almacenamiento_recomendado = 136.5 GB
5. Escalar Spark¶
Si aumenta el lag o la latencia, evalúa:
- ajustar el intervalo de trigger;
- aumentar memoria del driver o executor;
- aumentar número de executors;
- aumentar cores por executor;
- revisar particiones Kafka;
- optimizar transformaciones;
- evitar operaciónes costosas por micro-batch;
- persistir resultados solo cuando sea necesario.
Ejemplo operativo:
Si Kafka recibe 500 eventos/s y Spark procesa 200 eventos/s,
el lag crecera y sera necesario escalar el consumer o ajustar el procesamiento.
6. Indicadores de riesgo¶
Observa:
| Indicador | Interpretacion |
|---|---|
kafka_consumergroup_lag |
Eventos pendientes de consumo |
numInputRows |
Eventos procesados por micro-batch |
inputRowsPerSecond |
Velocidad de entrada |
processedRowsPerSecond |
Velocidad de procesamiento |
| Duracion del batch | Tiempo usado por cada micro-batch |
latencyMs |
Diferencia entre creacion y procesamiento del evento |
7. Tabla de escenarios¶
Completa y ajusta esta tabla:
| Escenario | Eventos/dia | Pico eventos/s | Tamaño evento | Particiones | Kafka | Spark | Riesgo principal |
|---|---|---|---|---|---|---|---|
| Pequeño | 10 000 | 20 | 1 KB | 1 | 1 broker dev | local/notebook | bajo |
| Medio | 1 000 000 | 300 | 1 KB | 3-6 | 3 brokers | cluster pequeño | lag en picos |
| Alto | 10 000 000 | 3000 | 1 KB | 12+ | 3+ brokers | cluster escalable | backpressure/costo |
8. Buenas prácticas¶
- Iniciar con particiones suficientes para el crecimiento esperado.
- No aumentar particiones sin una razón medible.
- Definir claves de particionado estables.
- Medir lag antes de escalar.
- Ajustar Spark según la duración de micro-batches.
- Separar ambientes
dev,testyprod. - Usar retención acorde al caso de negocio.
- Evitar eventos innecesariamente grandes.
- Monitorear CPU, memoria, disco y red.
- Definir umbrales de alerta antes de operar en produccion.
Evidencias¶
Adjunta:
- tabla de supuestos;
- calculo de volumen diario;
- calculo de throughput promedio y pico;
- estimación de almacenamiento por retención;
- propuesta de particiones Kafka;
- propuesta de recursos para Kafka y Spark;
- tabla de escenarios pequeño, medio y alto;
- lista de riesgos y mitigaciones;
- conclusión técnica de escalado.