spark结构化流处理引擎

yyyyjinying

已于 2024-04-18 09:53:30 修改

阅读量529

点赞数

分类专栏： spark 文章标签： spark 大数据 spark结构化流

于 2023-07-28 11:23:03 首次发布

本文链接：https://blog.csdn.net/jinying_51eqhappy/article/details/131974041

版权

spark 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Spark结构化流（Structured Streaming）

是Apache Spark提供的一种流数据处理引擎，它允许以类似于批处理的方式处理连续不断到达的数据流。相比于传统的流处理框架，结构化流提供了更高级和更易用的编程模型，可以轻松地将批处理和流处理结合起来，实现实时的数据处理和分析。

结构化流基于Spark SQL引擎，使用DataFrame和DataSet作为数据抽象，支持SQL查询、流式数据转换和输出操作，提供了丰富的内置函数和操作符来处理数据。它支持常见的输入源和输出目的地，如文件系统、消息队列、数据库等，并提供了灵活的窗口操作、聚合操作、Join操作等功能。

使用结构化流，可以按照批处理的方式处理实时数据，例如可以定义一个查询，每次处理1分钟的数据，并将结果输出到指定的位置。Spark会自动将连续到达的数据流切分成小的批次，并按照查询逻辑处理每个批次，在处理过程中可以进行状态管理和容错恢复。

总结来说，Spark结构化流是一种强大的实时数据处理引擎，它提供了高级的编程模型和丰富的数据操作能力，可以简化实时数据处理的开发和管理，适用于各种实时分析和数据处理场景。

编程模型

Spark结构化流（Structured Streaming）提供了一种简单而强大的编程模型，使开发人员可以方便地处理连续的流数据。下面是Spark结构化流的编程模型的几个关键概念：

数据源（Data Sources）：数据源是指输入流的来源，可以是文件系统（如HDFS、S3）、消息队列（如Kafka、RabbitMQ）、Socket等。Spark结构化流通过提供适配器来支持各种常见的数据源，同时也支持自定义数据源。
数据源格式（Data Source Formats）：数据源格式定义了输入流的数据格式，如JSON、CSV、Parquet等。Spark结构化流支持多种数据源格式，并提供了对各种常见格式的内置支持。
数据流（DataStreams）：数据流是Spark结构化流的核心概念，它代表了连续到达的数据流。数据流可以通过读取数据源来创建，可以是未经处理的原始数据流，也可以是经过转换处理后的数据流。
转换操作（Transformation Operations）：Spark结构化流提供了一系列转换操作，用于对数据流进行处理和转换。例如，可以使用select、filter、groupBy等操作来选择、过滤和聚合数据。转换操作以函数式的方式定义，并可以串联多个操作来形成数据流管道。
输出操作（Output Operations）：输出操作用于将处理后的数据流写入到目的地。Spark结构化流支持将数据流写入到文件系统、数据库、消息队列等，并提供了多种输出格式和写入模式（如追加、覆盖、更新等）。
触发器（Triggers）：触发器定义了数据流处理的触发条件和频率。可以根据时间间隔、数据条数等触发条件来触发数据流处理。可以设置流式处理为连续处理模式，即将每个输入数据都立即触发处理，或设置为微批处理模式，即按照指定的触发条件进行批处理。
状态管理（State Management）：Spark结构化流可以处理具有状态的计算，例如窗口聚合操作。它提供了内置的状态管理机制，可以跟踪和更新中间结果，实现复杂的数据流处理逻辑。

通过组合和使用上述概念，开发人员可以轻松地构建流式数据处理应用程序，实现实时的数据处理、转换和分析。Spark结构化流的编程模型简单而灵活，提供了高级API和内置函数，使得开发人员可以快速开发和部署复杂的实时数据处理任务。

处理事件时间（Event-time）和延迟数据（Late Data）

在Spark结构化流中，处理事件时间（Event-time）和延迟数据（Late Data）是非常重要的功能。事件时间是指数据本身所携带的时间戳，与数据到达系统的时间无关。而延迟数据指的是在数据流中到达时间与事件发生时间之间存在一定延迟的数据。

为了正确处理事件时间和延迟数据，可以采取以下几种方法：

指定事件时间水印（Event Time Watermark）：通过指定事件时间水印，可以告诉Spark处理延迟数据的策略。水印是一个时间戳，在该时间戳之前到达的所有数据都会被视为已到达的数据，并且可以进行相应的处理。水印的延迟时间应该大于数据流的最大延迟时间，以确保系统可以正确处理延迟数据。

使用窗口操作：在处理事件时间数据时，可以使用窗口操作来对数据进行分组和聚合。窗口操作定义了一个时间范围，用于将数据进行分割，并在窗口关闭后执行相应的聚合操作。可以根据事件时间对数据流进行窗口划分，并针对每个窗口执行聚合操作，从而得到期望的结果。

处理延迟数据：当存在延迟数据时，可以使用AllowedLateness参数来指定在窗口关闭之后接收延迟数据的时间范围。这样可以确保延迟数据能够正确地被处理，并将其纳入到已关闭的窗口中进行计算。同时，也可以为延迟数据设置适当的处理策略，例如丢弃、更新或输出到延迟数据流中等。

使用迟到数据处理器（Late Data Processing）：在某些情况下，延迟数据可能会对结果产生重要影响。为了处理这种情况，可以使用迟到数据处理器来处理延迟数据。迟到数据处理器允许在窗口关闭后对延迟数据进行进一步处理，例如重新计算结果或将其发送到特定的输出。

通过使用上述方法，可以在Spark结构化流中有效地处理事件时间和延迟数据，确保数据处理逻辑的准确性和一致性。

容错机制和语义

Spark结构化流（Structured Streaming）具有内建的容错机制和语义，以保证在出现故障或异常情况下的数据处理的可靠性。下面是Spark结构化流的容错语义：

容错数据源：Spark结构化流可以从容错的数据源读取数据。当某个任务失败时，Spark会自动从上次读取的位置继续读取数据，并确保不丢失任何数据。通过数据源的重复性保证，Spark能够从错误或故障中恢复，并继续进行数据处理。
容错数据处理：Spark结构化流使用基于事件时间（Event Time）的处理方式，可以处理延迟数据和乱序数据。即使数据到达的顺序与事件发生的顺序不一致，Spark也可以正确地对数据进行处理，使用水印（Watermark）机制来确定迟到数据的处理逻辑。此外，当任务失败或重启时，Spark会使用检查点（Checkpointing）机制来跟踪处理的状态，以便从故障中恢复并保持处理的一致性。
容错状态管理：在具有状态的计算中，Spark结构化流提供了容错的状态管理机制。它会根据数据处理的进度和检查点信息，自动恢复任务状态，保证每个触发间隔的结果的准确性。Spark通过将状态定期检查点到可靠存储系统中，以便在失败或重启时恢复状态，并从故障中恢复计算。
任务调度和资源管理：Spark结构化流使用Spark的任务调度和资源管理机制，例如Spark Standalone、Apache Mesos或Apache Hadoop YARN等。这些机制具有容错性和故障恢复能力，可以处理节点故障、任务失败和资源调度等情况，确保数据处理的可靠性和高可用性。

总的来说，Spark结构化流具有强大的容错机制和语义，能够应对各种故障和异常情况。它通过容错的数据源、数据处理、状态管理和任务调度等机制，确保数据处理的可靠性和一致性。通过这些机制的结合使用，Spark能够有效地处理连续流数据，并在出现故障或异常时进行恢复和容错。

DataFrames和Dataset

自Spark 2.0以来，DataFrames和Dataset可以表示静态的、有界的数据，也可以表示流式的、无界的数据。与静态Datasets/DataFrames类似，您可以使用公共入口点SparkSession（Scala/Java/Python/R-docs）从流源创建流式DataFrames/Dataset，并对其应用与静态DataFrames/dataset相同的操作
dataFrame创建，流式数据帧可以通过SparkSession.readStream（）返回的DataStreamReader接口（Scala/Java/Python文档）创建。在R中，使用read.stream（）方法。与创建静态DataFrame的读取接口类似，您可以指定源的详细信息——数据格式、模式、选项等。

多种输入源

Spark结构化流（Structured Streaming）支持多种输入源，可以从不同的数据源读取连续的流数据。下面是一些常见的Spark结构化流的输入源：

文件系统（File Systems）：Spark结构化流可以从本地文件系统或分布式文件系统（如HDFS、S3等）读取数据。它支持各种文件格式，如文本文件（例如JSON、CSV、XML）、二进制文件、Avro文件、Parquet文件等。可以通过指定文件路径或通配符模式来读取一个或多个文件。
消息队列（Message Queues）：Spark结构化流支持各种常见的消息队列作为输入源，例如Apache Kafka、RabbitMQ、Apache Pulsar等。可以指定消息队列的主题或队列名称，并使用适当的连接参数进行配置。Spark会根据主题或队列中的消息流来读取连续的数据。
Socket：可以通过TCP/IP套接字来作为输入源，在指定的主机和端口上监听数据流。Spark结构化流会作为TCP服务器接收来自套接字的数据，并将其转换为数据流进行处理。
自定义数据源（Custom Sources）：除了以上常见的输入源，Spark结构化流还支持自定义数据源。开发人员可以根据自己的需求实现自定义数据源，通过实现org.apache.spark.sql.sources.DataSourceV2接口进行数据读取和数据格式化。

无论是从文件系统、消息队列还是自定义数据源读取数据，Spark结构化流提供了统一的API来处理这些输入源，使得开发人员可以方便地进行流数据处理和分析。可以通过指定数据源的路径、格式、选项和模式等参数来配置输入源，并使用DataFrame或DataStream API对数据进行转换和操作。

Schema推断（Schema inference）和数据分区（Partition）

在Spark结构化流（Structured Streaming）中，Schema推断（Schema inference）和数据分区（Partition）是与流式DataFrames和Datasets相关的重要概念。

Schema推断：Schema推断是指根据输入数据的结构自动推断数据的模式（Schema）。在流式处理中，由于数据可能是连续和动态的，因此在开始处理之前往往无法提前了解数据的结构。在这种情况下，Spark结构化流会自动对输入数据进行分析，从数据中提取相关的元信息（如字段名称、数据类型）来推断数据的模式。通过Schema推断，Spark能够自动确定输入数据的模式，使得数据处理和转换更加方便和灵活。
数据分区：数据分区是指对流式DataFrame或Dataset进行分区，以便在分布式环境中并发地处理数据。Spark结构化流使用数据分区来将输入数据分配给集群中的不同任务和执行器，从而实现数据的并行处理。数据分区可以根据键（Key）进行分组，以便在数据处理过程中进行聚合、排序等操作。Spark结构化流提供了各种分区策略，例如基于哈希的分区、范围分区等，可以根据不同的需求和数据特性选择合适的分区方法。

通过结合Schema推断和数据分区，Spark结构化流能够自动处理连续的流式数据，并在分布式环境中进行高效的并行计算。开发人员无需显式地指定数据的模式和分区，而是依靠Spark自动进行推断和优化。这简化了开发流式数据处理应用程序的过程，并提供了灵活性和性能优化的机会。

基于事件时间（Event Time）的窗口操作

在Spark结构化流（Structured Streaming）中，基于事件时间（Event Time）的窗口操作是一种常见的流式数据处理方式，用于处理和聚合在特定时间窗口内的数据。通过使用事件时间而不是处理时间（Processing Time）来进行窗口操作，可以处理流数据中的延迟和乱序，并获得准确的数据窗口结果。

以下是在事件时间上执行窗口操作的一般步骤：

定义事件时间：首先，需要将数据流中的事件时间与每个数据记录关联起来。事件时间是数据实际发生的时间，可以是消息的时间戳、传感器读数的时间等。在Spark结构化流中，可以使用withWatermark方法来指定事件时间的属性以及水印（Watermark），以处理数据的延迟和乱序。
定义窗口的长度和滑动间隔：根据需求，定义窗口的长度和滑动间隔。窗口的长度表示每个窗口包含的时间范围，滑动间隔表示窗口之间的时间跨度。例如，可以定义一个5分钟长度的固定窗口，每隔1分钟滑动一次。
应用窗口操作：使用DataFrame或Dataset的窗口操作方法，如window、groupBy等，对数据流进行窗口分组和聚合。在窗口操作中，可以使用聚合函数（如count、sum、avg等）对各个窗口内的数据进行处理。例如，可以计算每个窗口内某个指标的总和或平均值。
指定输出触发器：指定在窗口操作中触发结果输出的条件和频率。触发器可以基于时间间隔（如每分钟、每小时）或数据条数（如每100条）等条件来触发结果的输出。可以使用trigger方法来指定触发器。

通过以上步骤，可以在Spark结构化流中实现基于事件时间的窗口操作。这样就可以根据流数据的事件时间对数据进行分组和聚合，并获取准确的窗口结果。Spark结构化流提供了丰富的窗口操作方法和灵活的窗口定义方式，以满足不同的窗口处理需求。

数据流的去重

数据流的去重（Streaming Deduplication）是在流式数据处理中常见的一个步骤，用于消除重复数据并确保数据的唯一性。在Spark结构化流（Structured Streaming）中，可以使用不同的方法进行流数据的去重操作。

以下是一些常见的流式数据去重方法：

基于主键的去重：如果数据流中有一个唯一的主键字段（如ID），可以通过对该字段进行分组操作并选择最新的记录来进行去重。可以使用groupBy和agg函数来按照主键字段进行分组，然后通过聚合函数（如max或min）选择最新或最早的记录。这样可以确保每个主键值仅有一条最新的记录存在。
滑动窗口去重：利用窗口操作（Window）将数据按照时间窗口进行分组，然后在窗口内进行去重操作。可以指定窗口的长度和滑动间隔，然后使用groupBy和agg函数对窗口内的数据进行去重处理。这样可以确保每个时间窗口内的数据是唯一的，去除重复的数据。
布隆过滤器去重：布隆过滤器是一种概率性数据结构，用于快速判断某个元素是否已经存在。在流式数据去重中，可以使用布隆过滤器来记录已经出现过的元素，从而避免处理已经重复的数据。可以在Spark结构化流中使用自定义的布隆过滤器实现去重操作。

具体选择哪种方法取决于数据的特点、数据流的规模以及处理需求。在选择方法时，需要考虑计算和内存的开销，以及对数据唯一性的准确性要求。

需要注意的是，流式数据的去重是一个动态的过程，需要持续地处理和更新数据。Spark结构化流通过持续输入数据流来进行实时的去重操作，并确保每个触发间隔的结果的准确性。

使用多个水印策略

在Spark结构化流（Structured Streaming）中，水印（Watermark）是用于处理事件时间（Event Time）数据延迟和乱序的重要机制。当使用多个水印时，需要考虑一些策略来处理这些水印。

下面是一些处理多个水印的策略：

延迟策略：当存在多个水印时，可以选择较大的延迟值作为整体处理延迟的边界。这意味着只有当所有水印的时间戳都超过该边界时，才会触发下游操作的执行。这种策略适用于对延迟非常敏感的场景，确保流处理的完整性和准确性。
优先级策略：为每个水印分配优先级，根据优先级顺序来确定数据处理的先后顺序。较高优先级的水印会被优先考虑，只有当这些水印的时间戳超过较低优先级水印时，才会触发下游操作的执行。这种策略可以在处理有限资源和有限计算能力的情况下，优先处理关键数据。
平均时间策略：将多个水印的时间戳取平均值作为整体的水印时间戳。这种策略可以用于处理多个数据流中的事件时间，将它们整合成一个统一的时间线，并根据平均时间来决定数据处理的时间窗口。这种策略适用于希望将多个数据流进行同步处理的场景。

无论选择哪种策略，重要的是根据具体的业务需求和数据特点进行权衡和选择。合理设置水印的生成和推进频率，以及选择适当的延迟和优先级策略，可以保证流处理的准确性和性能。在实际应用中，可以根据实时数据处理的需求和负载情况进行调整和优化。

Stateful处理能力

在Spark结构化流（Structured Streaming）中，支持任意状态ful（Stateful）操作是一项功能强大且常用的能力。这允许您在流数据处理过程中使用自定义的状态来跟踪和更新数据状态。您可以执行各种复杂的、基于状态的计算，例如窗口聚合、累积计数、连续查询等。

以下是一些关于任意状态ful操作的要点：

状态管理：要执行状态ful操作，需要使用Spark提供的状态管理机制。Spark提供了一种分布式、容错的键值状态存储，用于存储和更新状态数据。您可以使用mapGroupsWithState、flatMapGroupsWithState等操作来定义状态ful操作，并指定状态管理器。
状态更新：状态ful操作涉及对状态的更新。您可以使用自定义的更新逻辑来更新状态数据。Spark提供了一种方便的接口，使您可以用上一批次的状态值、输入数据和时间信息来更新状态。
状态超时：状态ful操作中的状态可能需要在一定时间后过期，以限制状态数据的生命周期。Spark结构化流提供了设置状态超时时间的选项，允许您定义状态的有效期。超出有效期的状态将被自动清除并释放资源。
检查点：由于状态ful操作需要在多个批次之间保持状态，因此频繁的检查点操作对于确保流处理的健壮性和容错能力是至关重要的。使用检查点可以定期将状态保存到可靠的持久化存储中，以便在故障恢复时快速恢复状态。

需要注意的是，状态ful操作会引入更多的计算和资源开销。因此，应谨慎设计状态ful操作逻辑，避免状态过大或计算复杂度过高，以保证流处理的性能和可伸缩性。

总结而言，Spark结构化流的状态ful操作能力为您提供了处理流数据中复杂状态的灵活性和强大性能。通过使用Spark提供的状态管理机制，您可以对流数据执行任意自定义状态更新操作，并实现更复杂的数据处理和计算。

不支持的操作和功能

在Spark结构化流（Structured Streaming）中，存在一些不支持的操作和功能，主要是由于流处理的本质和限制。

以下是一些常见的不支持操作和功能：

更新操作（Update Operations）：Spark结构化流主要支持追加模式（Append Mode）和完全输出模式（Complete Mode），不支持更新模式（Update Mode）。即，无法直接对流数据进行原地更新，而是以追加或全量输出的方式处理数据。
连接操作（Join Operations）：在流式处理中，对两个或多个数据流进行连接和关联操作是非常常见的需求。然而，Spark结构化流目前不支持对流数据的连接操作。只能在单个数据流内部进行处理和转换。
重分区（Repartitioning）：在批处理中，可以随时对数据进行重分区以进行负载均衡或重新组织数据。但是，在实时流处理中，由于数据的乱序到达和无限流的特性，Spark结构化流不支持对数据流进行动态的重分区操作。
数据排序（Data Sorting）：在流处理中，数据通常是按照事件时间（Event Time）到达的顺序进行处理，而不是按照数据本身的值排序。因此，Spark结构化流不支持直接对流数据进行排序操作。
过程时间（Processing Time）窗口操作：虽然Spark结构化流支持基于事件时间的窗口操作，但不支持以过程时间为基准进行窗口操作。过程时间是指处理数据时的系统时间，与数据本身的时间戳无关。

要在Spark结构化流中使用正确的操作和功能，请确保遵循支持的操作和功能，并根据实际需求进行合理的数据处理和转换。可以查看官方文档以获取更详细的信息和更新的支持功能列表。
流式DataFrame/Dataset不支持一些DataFrame/DDataset操作。其中一些如下。

流式数据集不支持限制并获取前N行。
不支持对流式数据集执行不同的操作。
只有在聚合之后并且在完全输出模式下，流式数据集才支持排序操作。
流式数据集上不支持少数类型的外部联接。有关更多详细信息，请参阅“加入操作”部- 分中的支持矩阵。
更新和完成模式不支持在流式数据集上链接多个有状态操作。
在追加模式下，不支持以下操作后接其他有状态操作。
流时间间隔联接（内部/外部）
带状态的平面图组
一种已知的解决方法是将流式查询拆分为多个查询，每个查询都有一个有状态操作，并确保每个查询只进行一次端到端操作。确保最后一个查询只进行一次端到端查询是可选的。
此外，还有一些数据集方法在流式数据集上不起作用。它们是将立即运行查询并返回结果的操作，这在流式数据集上没有意义。相反，这些功能可以通过显式启动流式查询来实现（请参阅下一节）。
count（）-无法从流式数据集中返回单个计数。相反，使用ds.groupBy（）.count（）返回一个包含运行计数的流式数据集。
foreach（）-改为使用ds.writeStream.foreach（…）（请参阅下一节）。
show（）-使用控制台接收器（请参阅下一节）。
如果您尝试这些操作中的任何一个，您将看到类似“流式数据帧/数据集不支持操作XYZ”的AnalysisException。虽然其中一些可能会在Spark的未来版本中得到支持，但还有一些从根本上讲很难在流数据上有效实现。例如，不支持对输入流进行排序，因为这需要跟踪流中接收到的所有数据。因此，从根本上说，这很难有效执行。

State Store

状态存储是一个版本化的键值存储，它提供读取和写入操作。在结构化流中，我们使用状态存储提供程序来处理跨批的有状态操作。有两个内置的状态存储提供程序实现。最终用户还可以通过扩展StateStoreProvider接口来实现他们自己的状态存储提供程序。
状态存储（State Store）是Spark结构化流（Structured Streaming）中用于管理和存储状态（state）的重要组件。状态存储允许您在流式数据处理过程中跟踪和更新状态，以支持状态ful操作，如窗口聚合和连续查询。

以下是有关状态存储的一些重要信息：

状态存储介质：状态存储可以使用多种介质来存储和管理状态数据，包括内存、本地磁盘和分布式存储系统（如HDFS、S3等）。Spark提供了可配置的状态存储选项，以适应不同的存储需求和计算资源。默认情况下，状态存储使用内存来存储状态，但在容错和可靠性方面会有限制。
状态存储管理：状态存储由Spark引擎负责管理和维护。Spark将状态数据划分为不同的分区，以便并行处理和分布式存储。每个分区都包含一部分状态数据，并在分区之间进行数据交换和传输。Spark通过内部存储格式和索引机制进行高效的状态管理和查询。
状态恢复：由于流处理中可能存在故障和中断，状态存储对于状态的恢复和容错是至关重要的。Spark会通过检查点（checkpoint）和写入持久性存储来保护状态数据，并在故障恢复或重新调度后恢复状态。检查点将状态存储的快照保存到可靠的持久性存储中，以便在故障发生时能够快速恢复状态。
扩展性和性能：状态存储的扩展性和性能是流处理中需要考虑的重要因素。随着状态数据的增长和并发处理的要求，您可能需要调整状态存储的配置和资源分配，以满足高吞吐量和低延迟的需求。使用适当的存储介质和调优策略可以提高状态存储的性能和可伸缩性。

状态存储在Spark结构化流中扮演了关键的角色，使得使用状态ful操作在流数据处理中成为可能。通过适当的配置和管理状态存储，您可以构建复杂的数据处理和计算流程，并支持实时和连续的查询。在实际应用中，需要根据数据特点、负载需求和可靠性要求来选择和优化状态存储。

RocksDB

是一种基于持久性键值存储引擎的状态存储实现，用于管理和存储Spark结构化流（Structured Streaming）中的状态数据。它提供了高性能和可靠的状态存储，并在大规模流数据处理场景中得到广泛应用。

以下是有关RocksDB状态存储实现的一些关键特点：

高性能：RocksDB基于LSM树（Log-Structured Merge Tree）的存储结构，具有出色的读写性能。它通过将数据按照顺序写入磁盘，并定期进行合并和压缩，以提高读取和更新操作的效率。这使得RocksDB非常适用于流数据处理中频繁的状态更新操作。
低延迟：RocksDB采用了内存和磁盘的组合存储，既具备了内存存储的低延迟特性，又能处理大规模状态数据存储的需求。这使得RocksDB能够快速响应实时流数据的状态读取和更新请求，保证流处理的低延迟性能。
可靠性和容错：RocksDB提供了持久性的存储机制，保证了状态数据在故障或断电后的可靠性恢复。它支持将状态存储持久化到磁盘，并提供了故障恢复和容错机制，确保在系统崩溃或重新启动后能够恢复状态数据的一致性。
可扩展性：RocksDB对于大规模状态数据和高并发访问是可扩展的。它支持在集群中进行分布式存储和处理，以处理更大规模的状态数据。通过调整RocksDB的配置和优化，可以实现更高的吞吐量和并发性能。

要使用RocksDB作为状态存储实现，在Spark结构化流的配置中，需要设置spark.sql.streaming.stateStore.providerClass参数为org.apache.spark.sql.execution.streaming.state.RocksDbStateStoreProvider，以启用RocksDB作为状态存储引擎。

总结而言，RocksDB提供了一个可靠、高性能的状态存储解决方案，适用于对大规模流数据进行状态管理和更新的场景。通过集成RocksDB状态存储，您可以构建强大的流数据处理应用，支持复杂的状态ful操作，并实现流畅的实时查询和分析。

状态存储（State Store）和任务本地性（Task Locality）

是 Spark 结构化流（Structured Streaming）中两个关键的概念。它们在流式数据处理和任务调度中起着重要的作用。

状态存储是用于管理和存储流处理过程中的状态数据的组件。它可以在任务之间共享和交换状态信息，并在流式处理中支持状态ful操作。状态存储通常用于存储聚合、连接或其他需要跟踪状态的计算结果，并在后续的批次中使用这些状态来更新结果。

任务本地性是 Spark 在任务调度中考虑的策略之一。任务本地性指的是 Spark 尽可能将数据和计算任务调度到同一台机器或同一网络节点上，以最大化数据的本地性。具有良好的任务本地性可以减少数据的网络传输和复制开销，并提高任务的执行效率和性能。

结合状态存储和任务本地性，以下是一些相关要点：

状态存储位置：为了提高性能和减少网络开销，Spark 尽可能将状态存储与执行任务的节点放置在相同的机器上。这可以降低在任务之间交换状态数据的网络传输成本，并提高状态访问的效率。
任务调度与状态恢复：在任务执行期间，Spark 尽可能将状态恢复到与任务具有本地性的状态存储位置。这样可以最大程度地减少状态数据的迁移和网络传输，并提高任务的容错性和可靠性。
本地性级别：任务本地性可以具有不同的级别，通常包括 PROCESS_LOCAL、NODE_LOCAL、RACK_LOCAL 和 ANY。PROCESS_LOCAL 表示任务与状态存储在同一进程中，NODE_LOCAL 表示任务和状态存储在同一节点上，RACK_LOCAL 表示任务和状态存储在同一机架上，而 ANY 则没有本地性限制。Spark 会尽量选择具有更高本地性级别的节点或机器来调度任务。

通过合理设置状态存储位置和任务本地性级别，可以最大限度地提升流处理任务的性能和效率。状态存储的本地性和任务调度的策略有助于减少数据传输、提高任务执行速度，并在处理大规模流数据时保持一致性和可靠性。

需要注意的是，任务本地性并非绝对保证。在某些情况下，由于资源限制或数据分布等因素，任务可能无法具备理想的本地性。因此，在设计和调整流处理作业时，要综合考虑状态存储和任务本地性，并根据数据分布和资源状况做出适当的优化和调整。

输出模式

附加模式（默认）-这是默认模式，只有自上次触发以来添加到结果表的新行才会输出到接收器。只有那些添加到结果表中的行永远不会更改的查询才支持这种方式。因此，这种模式保证每一行只输出一次（假设容错汇点）。例如，只有select、where、map、flatMap、filter、join等的查询将支持追加模式。
完整模式-每次触发后，整个结果表将输出到接收器。聚合查询支持此功能。
更新模式-（自Spark 2.1.1起可用）只有自上次触发以来更新的结果表中的行才会输出到接收器。更多信息将在以后的版本中添加。

输出接收器（Output Sinks）

在 Spark 结构化流（Structured Streaming）中，输出接收器（Output Sinks）用于将流式查询的结果写入到不同的目的地。Spark 提供了多种内置的输出接收器，以满足不同的需求。以下是一些常见的输出接收器：

Console：console 接收器将查询结果以表格的形式打印到控制台上，用于测试和调试目的。这是一个简单方便的输出接收器，适用于快速查看查询结果。
File：file 接收器将查询结果写入文件系统中的一个目录。您可以指定输出文件格式，如 Parquet、CSV 等。例如：

result.writeStream \
    .format("parquet") \
    .option("path", "output/dir") \
    .start()

该接收器可将查询结果持久化到文件系统，便于后续处理和分析。

Kafka：kafka 接收器将查询结果写入到 Apache Kafka 消息队列中。您可以指定要写入的主题（Topic），以及一些其他配置参数，如 Kafka 服务器地址等。例如：

result.writeStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "localhost:9092") \
    .option("topic", "output-topic") \
    .start()

这种接收器适用于将查询结果实时发送到 Kafka 中，以供其他消费者或系统使用。

Foreach：foreach 接收器允许您自定义输出逻辑，将查询结果写入到外部存储系统或其他目标。您需要实现自定义的 ForeachWriter 类，并在接收器中指定该类，以进行相应的写入操作。例如：

class CustomWriter extends ForeachWriter[Row] {
    // 实现打开连接、写入数据和关闭连接等方法

    override def open(partitionId: Long, version: Long): Boolean = {
        // 打开连接
    }

    override def process(record: Row): Unit = {
        // 写入数据
    }

    override def close(errorOrNull: Throwable): Unit = {
        // 关闭连接
    }
}

result.writeStream \
    .foreach(new CustomWriter) \
    .start()

通过自定义逻辑，您可以将查询结果写入到任何外部系统或存储中。

这些是 Spark 结构化流中常见的输出接收器示例。根据实际需求，您可以选择适合的接收器，并进行相应的配置和参数设置。如果内置接收器无法满足需求，您还可以开发自定义的输出接收器，以实现更具体的输出行为和目标。

流查询管理

query=df.writeStream.format（“console”）.start（）#获取查询对象
query.id（）#从检查点数据获取在重新启动时持续存在的正在运行的查询的唯一标识符
query.runId（）#获取该查询运行的唯一id，该id将在每次启动/重新启动时生成
query.name（）#获取自动生成或用户指定名称的名称
query.deexplain（）#打印查询的详细说明
query.stop（）#停止查询
query.awaitTermination（）#块，直到查询终止，带stop（）或带error
query.exception（）#如果查询因错误而终止，则为异常
query.recentProgress#此查询的最新进度更新列表
query.lastProgress#此流式查询的最新进度更新

Dropwizard报告度量

park supports reporting metrics using the Dropwizard Library. To enable metrics of Structured Streaming queries to be reported as well, you have to explicitly enable the configuration spark.sql.streaming.metricsEnabled in the SparkSession.
使用Dropwizard报告度量

park支持使用Dropwizard库报告指标。要使结构化流式查询的指标也能报告，您必须在SparkSession中显式启用配置spark.sql.Streaming.metricsEnabled。

检查节点和故障恢复Recovering from Failures with Checkpointing

spark按字段划分分区，在各自的分区内存中计算

要在Apache Spark中按照某个字段对数据进行分区，并在每个分区内存中计算，您可以利用Spark的DataFrame或Dataset API，结合partitionBy方法（用于重新分区）和相应的转换操作（如mapInPandas、groupBy等）来实现。以下是具体步骤：
示例代码（使用PySpark）
假设您有一个名为df的DataFrame，其中包含一个用于分区的字段partition_field，以及一些需要在各自分区内存中计算的列。以下是如何实现这一目标的示例代码：
from pyspark.sql import SparkSession

# 初始化SparkSession
spark = SparkSession.builder.getOrCreate()

# 假设df是您的原始DataFrame，包含一个用于分区的字段partition_field
df.show(5, False)
# +-------------+-----+-----+
# |partition_field|col1|col2|
# +-------------+-----+-----+
# |value1       |10   |20   |
# |value1       |15   |25   |
# |value2       |30   |40   |
# |value2       |35   |45   |
# |value3       |50   |60   |
# +-------------+-----+-----+

# 按照partition_field字段重新分区
repartitioned_df = df.repartitionBy('partition_field')

# 在各个分区内部进行内存计算，这里以一个简单的例子为例：
# 对于每个分区，计算col1和col2的总和
def compute_sum(partition):
    partition['sum_col1'] = partition['col1'].sum()
    partition['sum_col2'] = partition['col2'].sum()
    return partition

result_df = repartitioned_df.mapInPandas(compute_sum)

result_df.show(5, False)
# +-------------+-----+-----+--------+--------+
# |partition_field|col1|col2|sum_col1|sum_col2|
# +-------------+-----+-----+--------+--------+
# |value1       |10   |20   |25      |45      |
# |value1       |15   |25   |25      |45      |
# |value2       |30   |40   |65      |85      |
# |value2       |35   |45   |65      |85      |
# |value3       |50   |60   |50      |60      |
# +-------------+-----+-----+--------+--------+
解释
repartitionBy：使用DataFrame.repartitionBy方法根据指定的字段（这里是partition_field）重新分区数据。这会将数据划分为多个子集，每个子集包含具有相同partition_field值的行。
mapInPandas：这是一个在每个分区内部应用Python Pandas函数进行内存计算的方法。在这个例子中，定义了一个名为compute_sum的函数，它接收一个Pandas DataFrame（即Spark分区的数据），计算col1和col2的总和，并添加新列sum_col1和sum_col2。mapInPandas将此函数应用于每个分区，返回一个新的DataFrame，其中包含了每个分区内的计算结果。
请根据实际需求调整上述示例中的计算逻辑（compute_sum函数）。如果您需要进行更复杂的聚合或转换操作，可以考虑使用groupBy搭配相应的聚合函数，如sum、avg、count等，这些操作也会在分区内部进行，从而充分利用分布式计算的优势。
注意：使用mapInPandas要求您的Spark集群配置了Pandas UDF支持，并且所有参与计算的节点上都安装了Pandas库。如果不满足这些条件，您可能需要改用其他Spark原生的转换操作（如groupBy等）。
```

yyyyjinying

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spark结构化流处理引擎

是Apache Spark提供的一种流数据处理引擎，它允许以类似于批处理的方式处理连续不断到达的数据流。相比于传统的流处理框架，结构化流提供了更高级和更易用的编程模型，可以轻松地将批处理和流处理结合起来，实现实时的数据处理和分析。结构化流基于Spark SQL引擎，使用DataFrame和DataSet作为数据抽象，支持SQL查询、流式数据转换和输出操作，提供了丰富的内置函数和操作符来处理数据。
复制链接

扫一扫