Question

我有一个流媒体作业，初始运行必须处理大量数据。其中一个DoFn调用支持批量请求的远程服务，因此在使用有界集合时，我使用以下方法：

  private static final class Function extends DoFn<String, Void> implements Serializable {
    private static final long serialVersionUID = 2417984990958377700L;

    private static final int LIMIT = 500;

    private transient Queue<String> buffered;

    @StartBundle
    public void startBundle(Context context) throws Exception {
      buffered = new LinkedList<>();
    }

    @ProcessElement
    public void processElement(ProcessContext context) throws Exception {
      buffered.add(context.element());

      if (buffered.size() > LIMIT) {
        flush();
      }
    }

    @FinishBundle
    public void finishBundle(Context c) throws Exception {
      // process remaining
      flush();
    }

    private void flush() {
      // build batch request
      while (!buffered.isEmpty()) {
        buffered.poll();
        // do something
      }
    }
  }

有没有办法窗口数据，所以可以在无界集合上使用相同的方法？

我试过以下：

pipeline
    .apply("Read", Read.from(source))
    .apply(WithTimestamps.of(input -> Instant.now()))
    .apply(Window.into(FixedWindows.of(Duration.standardMinutes(2L))))
    .apply("Process", ParDo.of(new Function()));

但是为每个元素调用startBundle和finishBundle。是否有机会使用RxJava（2分钟窗口或100个元素包）：

source
    .toFlowable(BackpressureStrategy.LATEST)
    .buffer(2, TimeUnit.MINUTES, 100)

Answer 1

这是每个键和窗口state和timers的新功能的典型用例。

状态在a Beam blog post中描述，而对于计时器，您将不得不依赖于Javadoc。没关系javadoc对支持他们的跑步者所说的，真实的状态可以在Beam的capability matrix中找到。

该模式非常类似于您所编写的模式，但是状态允许它与窗口以及捆绑包一起使用，因为它们在流式传输中可能非常小。由于必须以某种方式对state进行分区以保持并行性，因此您需要添加某种键。目前没有自动分片。

private static final class Function extends DoFn<KV<Key, String>, Void> implements Serializable {
  private static final long serialVersionUID = 2417984990958377700L;

  private static final int LIMIT = 500;

  @StateId("bufferedSize")
  private final StateSpec<Object, ValueState<Integer>> bufferedSizeSpec =
      StateSpecs.value(VarIntCoder.of());

  @StateId("buffered")
  private final StateSpec<Object, BagState<String>> bufferedSpec =
      StateSpecs.bag(StringUtf8Coder.of());

  @TimerId("expiry")
  private final TimerSpec expirySpec = TimerSpecs.timer(TimeDomain.EVENT_TIME);

  @ProcessElement
  public void processElement(
      ProcessContext context,
      BoundedWindow window,
      @StateId("bufferedSize") ValueState<Integer> bufferedSizeState,
      @StateId("buffered") BagState<String> bufferedState,
      @TimerId("expiry") Timer expiryTimer) {

    int size = firstNonNull(bufferedSizeState.read(), 0);
    bufferedState.add(context.element().getValue());
    size += 1;
    bufferedSizeState.write(size);
    expiryTimer.set(w.maxTimestamp().plus(allowedLateness));

    if (size > LIMIT) {
      flush(context, bufferedState, bufferedSizeState);
    }
  }

  @OnTimer("expiry")
  public void onExpiry(
      OnTimerContext context,
      @StateId("bufferedSize") ValueState<Integer> bufferedSizeState,
      @StateId("buffered") BagState<String> bufferedState) {
    flush(context, bufferedState, bufferedSizeState);
  }

  private void flush(
      Context context,
      BagState<String> bufferedState,
      ValueState<Integer> bufferedSizeState) {
    Iterable<String> buffered = bufferedState.read();

    // build batch request from buffered
    ...

    // clear things
    bufferedState.clear();
    bufferedSizeState.clear();
  }
}

在这里做几点说明：

State替换了DoFn的实例变量，因为实例变量在窗口之间没有凝聚力。
缓冲区和大小只是根据需要进行初始化 @StartBundle。
BagState支持“盲”写入，因此不需要任何读 - 修改 - 写，只需提交相同的新元素当你输出时的方式。
同时重复设置计时器就好了; 它应该主要是一个noop。
@OnTimer("expiry")取代@FinishBundle，因为完成一个包不是每个窗口的东西，而是一个神器跑步者如何执行你的管道。

所有这一切，如果你正在写一个外部系统，也许你会想要重新启动窗口并重新窗口进入全局窗口，然后再进行写入，其中写入的方式取决于窗口，因为“外部世界是全球性的“。

Answer 2

apache beam 0.6.0的文档说StateId是＆＃34;目前没有任何跑步者支持。＆＃34;

缓冲和刷新Apache Beam流数据

2 个答案: