Apache Beam 赋能 OCTO:法国大型零售商的流式事务数据处理实战案例

原创2026-10-11 19:53:511,880 阅读
文章标签:批处理流处理大数据

Apache Beam 赋能 OCTO:法国大型零售商的流式事务数据处理实战案例

Apache Beam 的统一编程模型如何帮助法国零售巨头完成从批处理到流式处理的历史性迁移?本文基于 Apache Beam 官方案例研究站点收录的 OCTO 技术案例,完整还原 OCTO Technology 数据工程团队在大型零售客户项目中,借助 Beam 的 Python SDK、流式能力、定时器与自定义 I/O,实现 4 倍性能提升、5 倍基础设施成本优化的全过程。

OCTO 为大型零售客户构建的流式 Apache Beam 数据流水线架构示意图

客户背景:一家数万家门店的跨国零售巨头

OCTO Technology(隶属于 Accenture)是一家专注于新技术与数字化转型的技术咨询与软件工程公司。自 1998 年成立以来,OCTO 为从初创公司到跨国企业的各类客户构建可扩展的数字解决方案。

本案例的主角是 OCTO 的一位重要客户——一家拥有数万家门店的大型杂货与便利店零售商。该客户依赖一个内部 Web 应用来赋能店长做出明智的采购决策并进行高效的店铺管理。这个 Web 应用为店长提供关键的商品详情、库存数量、定价、促销等信息,这些数据来自多个内部数据存储、平台和系统。

OCTO 的数据架构师 Godefroy Clair、数据工程师 Florian Bastin 和 Leo Babonnaud 主导了这次技术转型。正如 Godefroy Clair 所总结的:

“我经常告诉客户,Apache Beam 就是数据处理界的‘Docker’。它具有高度可移植性,可以在任何地方无缝运行,统一了批处理和流处理,还提供了大量开箱即用的模板。采用 Beam 能够加速从批处理到流式的迁移,实现流水线跨场景的轻松复用,并更快地启用新的使用场景。Apache Beam 带来的收益和卓越性能对很多人来说是改变游戏规则的!”

转型前的痛点:批处理无法满足 SLA

在 2022 年之前,该客户使用一个编排引擎来编排批处理流水线:从 Cloud Storage 文件和 Pub/Sub 消息中合并和处理数据,并将输出写入 BigQuery。

这种批处理架构面临一系列问题:

  • SLA 难以达成:大多数源数据在夜间上传,批处理方式难以在门店开门前将最新信息提供给店长;
  • 数据回滚代价高昂:错误或缺失的数据上传需要进行繁琐的数据库状态回退,涉及大量事务数据和日志;
  • 维护成本高:客户内部团队花费大量时间维护庞大的 SQL 查询或手动更新数据库状态。

为此,客户寻求 OCTO 的专业支持,将核心用例从批处理迁移到流式处理,目标包括:更快的处理速度、确保 Web 应用中的数据最新、简化流水线和数据库维护、保证可扩展性与韧性、高效应对数据量激增。

Godefroy Clair 描述了当时的场景:

“客户需要非常快速地合并和处理来自 Cloud Storage 和 Pub/Sub 事件的大量不同格式的文件,以便每天在他们的 Web 应用中提供关于新产品、促销等的最新信息。对于这一切来说,Apache Beam 是完美的工具。”

解决方案:Beam 统一模型 + Dataflow Runner + Python SDK

Apache Beam 及其统一模型成为完美解决方案:既能为客户的核心事务数据处理提供近实时流式处理,又能为独立的用例保留批处理能力。此外,Beam 还带来了 Dataflow Runner 的自动扩缩容(autoscaling)能力。

借助 Python SDK 和开箱即用的 I/O connectors,OCTO 得以在现有和新的批处理与流式流水线之间复用 Python 组件,并利用与 Pub/Sub 和 Cloud Storage 的原生优化连接,加速了迁移。

数据源特征与规模

驱动客户 Web 应用的流式 Beam 流水线现在处理来自 Pub/Sub 消息和 Cloud Storage 文件的商品与库存数据。这些文件特征鲜明:

  • 文件大小从几行到 170 万行不等;
  • 在不同时间到达 Cloud Storage,顺序不可预测;
  • 格式多样(如 CSV、JSON 和 zip 文件)。

Beam 的 timely processing(及时处理)能力使流式流水线能够高效处理这些数据。每天,Beam 流水线完成对数据的合并(consolidate)、去重(deduplicate)、富化(enrich),并输出到 Firestore 和 Algolia,处理超过 1 亿行数据,在 不到 3 小时内合并数百 GB的事务数据以及超过 1 TB的外部状态。

Leo Babonnaud 强调了时间窗口的重要性:

“Web 应用需要在门店开门前的清晨获得最新数据。以前,及时处理客户的全部数据是不可行的。感谢 Apache Beam,他们现在可以在 3 小时内完成处理,即使输入文件在深夜到达也能确保数据可用。”

核心技术一:Timers 与受控聚合

面对顺序不可预测、到达时间各异的文件流,Beam 的 timers(定时器)提供了一种控制聚合的方式:等待所有必要的事件和文件到达后,再按正确顺序处理它们。

Beam 的定时器机制在 Python SDK 中有完整实现。例如 GroupIntoBatches 的内部实现(sdks/python/apache_beam/transforms/util.py)就演示了定时器与状态的典型配合:

class _GroupIntoBatchesDoFn(DoFn):
    def process(
        self,
        element,
        window=DoFn.WindowParam,
        element_state=DoFn.StateParam(ELEMENT_STATE),
        count_state=DoFn.StateParam(COUNT_STATE),
        window_timer=DoFn.TimerParam(WINDOW_TIMER),
        buffering_timer=DoFn.TimerParam(BUFFERING_TIMER)):
      # 设置窗口结束定时器
      window_timer.set(window.end)
      element_state.add(element)
      count_state.add(1)
      count = count_state.read()
      if count == 1 and max_buffering_duration_secs > 0:
        # 批次中的第一个元素:若设置了缓冲时限,开始计时
        buffering_timer.set(clock() + max_buffering_duration_secs)
      if count >= batch_size:
        return self.flush_batch(element_state, count_state, buffering_timer)

    @on_timer(WINDOW_TIMER)
    def on_window_timer(...):
      return self.flush_batch(element_state, count_state, buffering_timer)

    @on_timer(BUFFERING_TIMER)
    def on_buffering_timer(...):
      return self.flush_batch(element_state, count_state, buffering_timer)

该实现使用 TimerSpec(定义于 sdks/python/apache_beam/transforms/userstate.py)声明了两种定时器:

  • WINDOW_TIMER:基于 watermark 的窗口结束定时器,确保窗口内的所有元素被收集完毕;
  • BUFFERING_TIMER:基于实时时间的缓冲定时器,保证在 max_buffering_duration_secs 内即使批次不满也会被冲刷输出。

GroupByKey 与 GroupIntoBatches 的配合

GroupByKey 和 GroupIntoBatches 两个 transform 允许对每个键进行高效分组,并将输入批量化为期望的大小。

GroupIntoBatches 的公开 API(sdks/python/apache_beam/transforms/util.py)支持两个关键参数:

GroupIntoBatches(
    batch_size,                      # 必填:每个批次包含多少元素
    max_buffering_duration_secs=None # 可选:不完整批次最多允许缓冲的秒数,
                                     # 设为 0 表示无缓冲限制
)

其中 max_buffering_duration_secs 的语义尤为关键:它定义了“不满的批次”在状态中最多允许缓冲的时长。该参数直接服务于本案例中“等待所有必要事件和文件到达后再处理”的受控聚合需求。

核心技术二:外部化 DoFn 状态到 Cloud SQL

客户的特定用例带来了独特挑战:

  • 富化数据太大,无法放入内存;
  • 文件到达顺序和到达时间不可预测,导致 timers 和 state API 不可行。

无法利用 Beam 原生的有状态处理(stateful processing)能力时,OCTO 找到的解决方案是:将 DoFns 的状态外部化到事务性的 Cloud SQL Postgres 数据库。

当处理新的事件和文件时,Beam 流水线使用流式查询对 Cloud SQL 数据库中的状态行执行 select、insert、upsert 和 delete 操作。Apache Beam 在处理代表 sink 数据库中记录的过去、现在和未来状态的文件、Pub/Sub 事件和日志时,擅长复杂的状态合并。

如果传入数据有误,需要回退 sink 数据存储,Beam 流水线会处理特定时间范围内海量的数据移动日志,并将它们合并为状态,消除了人工干预。

Florian Bastin 补充道:

“Web 应用需要在门店开门前的清晨获得最新数据。以前,及时处理客户的全部数据是不可行的。感谢 Apache Beam,他们现在可以在 3 小时内完成处理,即使输入文件在深夜到达也能确保数据可用。”

核心技术三:自定义 I/O 与 SQL 连接的精细控制

客户的用例要求在 Cloud SQL 数据库中基于 PCollection 中的值执行 CRUD 操作。虽然内置的 JDBC I/O connector 支持从 Cloud SQL 数据库读写,但无法满足此类 SQL 操作。

自定义 I/O 的开放框架

Apache Beam 的自定义 I/O 框架为创建针对复杂用例的新连接器打开了大门,提供了与开箱即用 I/O 相同的连接能力。OCTO 利用这一优势,结合 ParDo 和 GroupByKey transform,成功开发了一个新的 Beam I/O。

这个自定义 I/O 使用 Cloud SQL Python Connector 与 Cloud SQL 数据库无缝交互,并在 DoFn.Setup 方法中将其实例化为连接对象。

关于如何创建自定义连接器,可以参考仓库中的 developing-io-overview 文档。

在 DoFn.Setup 中管理连接

Python SDK 中 DoFn.setup 的语义(sdks/python/apache_beam/transforms/core.py)如下:

def setup(self):
    """Called to prepare an instance for processing bundles of elements.

    This is a good place to initialize transient in-memory resources, such as
    network connections. The resources can then be disposed in
    ``DoFn.teardown``.
    """

setup 是初始化瞬态内存资源的理想位置(如网络连接),这些资源可在 DoFn.teardown 中释放。OCTO 正是利用这一点,在 setup 方法中创建 Cloud SQL 连接对象。

用 beam.utils.Shared 构建连接池

Apache Beam 还提供了 beam.utils.Shared 模块,用于在同一进程内的多个线程之间共享单个对象实例。OCTO 利用它创建了 Cloud SQL 数据库的连接池,在 worker 级别跨所有进程共享。

Shared 类在仓库中的实现位于 sdks/python/apache_beam/utils/shared.py。其核心用法如下:

from apache_beam.utils import shared

class CloudSQLConnectorFn(beam.DoFn):
    def __init__(self):
        self._shared_handle = shared.Shared()

    def setup(self):
        # setup 是初始化瞬态内存资源的理想位置
        def initialize_connection_pool():
            # 构建并返回 Cloud SQL 连接池
            return create_connection_pool()

        self._pool = self._shared_handle.acquire(initialize_connection_pool)

    def process(self, element):
        # 复用共享连接池
        ...

Shared.acquire() 接收一个构造函数,该函数只在缓存中不存在对象时才会被调用,从而保证每个 worker 进程内只初始化一次连接池。同时,它还通过内部 _SharedControlBlock 的 threading.Lock()(sdks/python/apache_beam/utils/shared.py)保证并发获取的安全性。

这一做法直接回应了 Cloud SQL 对并发连接数的限制:Dataflow Runner 的强并行性和自动扩缩容能力会导致并发连接数超出 Cloud SQL 配额约束,而共享连接池机制让所有并发操作复用有限的连接资源。

OCTO 的数据工程师在 Beam Summit 2023 上展示了这些创新成果,议题为 “How to balance power and control when using Dataflow with an OLTP SQL database”。

成果:4 倍性能提升与 5 倍成本优化

Apache Beam 为 OCTO 带来了革命性的数据处理转型:

  • 5 倍基础设施成本优化;
  • 4 倍数据处理性能提升;
  • 统一模型和 Python SDK 通过跨流水线复用组件、包和模块,加速了从批处理到流式处理的迁移;
  • 流式流水线每天高效处理 超过 1 亿行数据;
  • 在 3 小时内合并超过 1 TB 外部状态的事务数据——这在以前是不可能完成的任务。

Beam 的灵活性和可扩展性使 OCTO 能够应对特定用例的技术约束,在“能力”与“控制”之间实现了完美平衡,以契合客户的特定业务目标。

从源码看:Beam 能力如何在仓库中落地

Python SDK 生态验证

OCTO 使用的核心能力都能在仓库的 Python SDK 源码中找到对应实现:

测试用例佐证

仓库还提供了完整的测试来佐证这些能力:

这些测试表明,本案例中提到的定时器受控聚合、批量分组、共享连接池等能力并非“一次性定制”,而是 Beam Python SDK 提供的标准化、可复现的机制。

学习更多

完整的案例原文收录于 website/www/site/content/en/case-studies/octo.md。

结语

本案例充分展示了 Apache Beam 在实际生产场景中的价值:当批处理无法满足 SLA、流式处理又面临状态外置难题时,Beam 的统一模型、Python SDK 与可扩展的 I/O 框架提供了恰到好处的“能力 + 控制”组合。对开发者而言,OCTO 的实践提供了几条可复用的经验:

  1. 迁移路径清晰:先利用 Beam 的 Python SDK 复用现有组件,将批处理流水线逐步替换为流式流水线,无需重写业务逻辑;
  2. 状态外置模式:当数据量大到无法放入内存、文件到达顺序不可控时,用事务性数据库(如 Cloud SQL)作为外部状态存储,配合流式 SQL 操作完成状态合并;
  3. 连接资源治理:用 DoFn.Setup + beam.utils.Shared 构建 worker 级共享连接池,在享受 Dataflow 自动扩缩容的同时,规避外部系统(如 Cloud SQL)的并发连接配额限制。

这些经验对于任何正在评估“从批处理迁移到流式处理”的大型数据团队,都具有直接的参考价值。

登录后查看全文
beam