Question

我是流媒体数据处理的新手，我觉得必须是一个非常基本的用例。

假设我有一群(User, Alert)元组。我想要的是对每个用户的流量进行速率限制。即我想要一个只为用户输出一次警报的流。在下面说60分钟，用户的任何传入警报都应该被吞下。在那60分钟之后，传入的警报应该再次触发。

我尝试了什么：

使用aggregate作为有状态转换，但聚合状态是时间相关的。但是，即使生成的KTable的聚合值没有变化，KTable（作为更改日志）也会继续向下发送元素，从而无法实现“限速”流的预期效果

val fooStream: KStream[String, String] = builder.stream("foobar2")
fooStream
  .groupBy((key, string) => string)
  .aggregate(() => "constant",
    (aggKey: String, value: String, aggregate: String) => aggregate,
    stringSerde,
    "name")
  .print

提供以下输出：

[KSTREAM-AGGREGATE-0000000004]: string , (constant<-null)
[KSTREAM-AGGREGATE-0000000004]: string , (constant<-null)

我一般不清楚aggregate如何/何时决定向下游发布元素。我最初的理解是它是立竿见影的，但事实似乎并非如此。就我所见，窗口应该没有帮助。

Kafka Streams DSL目前是否可以解释这种状态转换的用例，类似于Spark的updateStateByKey或Akka的statefulMapConcat？我是否必须使用较低级别的Processor / Transformer API？

编辑：

Possible duplicate确实涉及到记录缓存如何导致关于何时聚合决定向下游发布元素的混淆的问题。然而，主要问题是如何在DSL中实现“速率限制”。正如@miguno指出的那样，必须恢复到较低级别的处理器API。下面我贴了一个非常详细的方法：

  val logConfig = new util.HashMap[String, String]();
  // override min.insync.replicas
  logConfig.put("min.insyc.replicas", "1")

  case class StateRecord(alert: Alert, time: Long)

  val countStore = Stores.create("Limiter")
    .withKeys(integerSerde)
    .withValues(new JsonSerde[StateRecord])
    .persistent()
    .enableLogging(logConfig)
    .build();
  builder.addStateStore(countStore)

  class RateLimiter extends Transformer[Integer, Alert, KeyValue[Integer, Alert]] {
    var context: ProcessorContext = null;
    var store: KeyValueStore[Integer, StateRecord] = null;

    override def init(context: ProcessorContext) = {
      this.context = context
      this.store = context.getStateStore("Limiter").asInstanceOf[KeyValueStore[Integer, StateRecord]]
    }

    override def transform(key: Integer, value: Alert) = {
      val current = System.currentTimeMillis()
      val newRecord = StateRecord(value._1, value._2, current)
      store.get(key) match {
        case StateRecord(_, time) if time + 15.seconds.toMillis < current => {
          store.put(key, newRecord)
          (key, value)
        }
        case StateRecord(_, _) => null
        case null => {
          store.put(key, newRecord)
          (key, value)
        }
      }
    }
  }

Answer 1

假设我有一群(User, Alert)元组。我想要的是对每个用户的流量进行速率限制。即我想要一个只为用户输出一次警报的流。在下面说60分钟，用户的任何传入警报都应该被吞下。在那60分钟之后，传入的警报应该再次触发。

使用Kafka Streams的DSL时，目前无法做到这一点。相反，您可以（并且将需要）使用较低级别的处理器API手动实现此类行为。

仅供参考：我们一直在Kafka社区讨论是否要向DSL添加此类功能（通常称为“触发器”）。到目前为止，决定暂时还没有达到这样的功能。

我一般不清楚aggregate如何/何时决定向下游发布元素。我最初的理解是它是立竿见影的，但事实似乎并非如此。

是的，这是Kafka 0.10.0.0的初始行为。从那时起（不确定你使用的是什么版本）我们引入了记录缓存;如果你禁用记录缓存，你会回到最初的行为，虽然从我的理解记录缓存会给你一些（间接）旋钮进行速率限制。所以你可能想要保持启用缓存。

不幸的是，Apache Kafka文档还没有涵盖记录缓存，与此同时您可能想要阅读http://docs.confluent.io/current/streams/developer-guide.html#memory-management。

如何在Kafka Streams中为流添加冷却/速率限制？

1 个答案: