Saltar a contenido

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

  1. Leer eventos desde Kafka.
  2. Conservar metadata Kafka: topic, partition, offset, kafkaTimestamp.
  3. Validar eventos y separar registros validos/invalidos.
  4. Calcular processedAt y latencyMs: processedAt es el momento en que Spark procesa el evento; latencyMs es la diferencia entre processedAt y el timestamp enviado por el producer.
  5. Estimar throughput con lastProgress: numInputRows, inputRowsPerSecond y processedRowsPerSecond describen el ultimo micro-batch procesado.
  6. Persistir evidencia observable en Parquet.
  7. 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.
  • avgOffsetsBehindLatest y maxOffsetsBehindLatest: 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.
  • avgOffsetsBehindLatest y maxOffsetsBehindLatest: atraso respecto al ultimo offset disponible en Kafka.
  • status: estado calculado para el micro-batch. idle significa sin eventos nuevos; processed significa 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:

  1. Status > Targets: los targets prometheus y kafka-exporter deben estar UP.
  2. 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 1 y luego vuelve a 0: entro un evento, el consumer se atraso momentaneamente y luego lo consumio.
  • Valor mayor que 0 sostenido: 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

  1. Entra a Alerting -> Alert rules.
  2. Selecciona New alert rule.
  3. Define el nombre, por ejemplo Lag alto en Kafka.
  4. En Query, selecciona el datasource Prometheus.
  5. Usa una consulta, por ejemplo:
kafka_consumergroup_lag > 100
  1. En Evaluate every, usa 1m.
  2. En For, usa 2m para evitar alertas por picos muy breves.
  3. En condicion, deja que la regla dispare cuando el resultado sea mayor que 0.
  4. 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, test y prod.
  • 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.