Question

从Zeppelin运行时，我正努力让console接收器与PySpark Structured Streaming一起使用。基本上，我没有看到任何结果打印到屏幕或我发现的任何日志文件。

我的问题：有没有人有一个使用PySpark Structured Streaming和一个产生Apache Zeppelin可见输出的接收器的工作示例？理想情况下，它也会使用套接字源，因为它很容易测试。

我正在使用：

Ubuntu 16.04
火花2.2.0彬hadoop2.7
飞艇-0.7.3彬所有
Python3

我的代码基于structured_network_wordcount.py example。它从PySpark shell（./bin/pyspark --master local[2]）运行时有效;我看到每批表格。

%pyspark
# structured streaming
from pyspark.sql.functions import *
lines = spark\
    .readStream\
    .format('socket')\
    .option('host', 'localhost')\
    .option('port', 9999)\
    .option('includeTimestamp', 'true')\
    .load()

# Split the lines into words, retaining timestamps
# split() splits each line into an array, and explode() turns the array into multiple rows
words = lines.select(
    explode(split(lines.value, ' ')).alias('word'),
    lines.timestamp
)

# Group the data by window and word and compute the count of each group
windowedCounts = words.groupBy(
    window(words.timestamp, '10 seconds', '1 seconds'),
    words.word
).count().orderBy('window')

# Start running the query that prints the windowed word counts to the console
query = windowedCounts\
    .writeStream\
    .outputMode('complete')\
    .format('console')\
    .option('truncate', 'false')\
    .start()

print("Starting...")
query.awaitTermination(20)

我希望看到每个批次的结果打印输出，但我只看到Starting...，然后是False，query.awaitTermination(20)的返回值。

在一个单独的终端中，我在上面运行时将一些数据输入nc -lk 9999 netcat会话。

Answer 1

控制台接收器不适合基于交互式笔记本的工作流程。即使在可以捕获输出的Scala中，它也需要awaitTermination调用（或等效）同一段，有效地阻止了音符。

%spark

spark
  .readStream
  .format("socket")
  .option("host", "localhost")
  .option("port", "9999")
  .option("includeTimestamp", "true")
  .load()
  .writeStream
  .outputMode("append")
  .format("console")
  .option("truncate", "false")
  .start()
  .awaitTermination() // Block execution, to force Zeppelin to capture the output

链式awaitTermination可以替换为同一段中的独立调用也可以使用

%spark

val query = df
  .writeStream
  ...
  .start()

query.awaitTermination()

没有它，Zeppelin没有理由等待任何输出。 PySpark只是增加了另一个问题 - 间接执行。因此，即使阻止查询也无法帮助您。

此外，来自流的连续输出在浏览笔记时可能会导致渲染问题和内存问题（可能可以通过InterpreterContext或REST API使用Zeppelin显示系统，以实现更明智的行为，其中输出被覆盖或定期清除。）

使用Zeppelin进行测试的更好选择是memory sink。这样您就可以不受阻塞地启动查询：

%pyspark

query = (windowedCounts
  .writeStream
  .outputMode("complete")
  .format("memory")
  .queryName("some_name")
  .start())

并在另一段中按需查询结果：

%pyspark

spark.table("some_name").show()

它可以与reactive streams或类似解决方案结合使用，以提供基于时间间隔的更新。

也可以使用StreamingQueryListener与Py4j回调将rx与onQueryProgress事件联系起来，尽管PySpark不支持查询侦听器，并且需要一些代码来粘合事情在一起。 Scala界面：

package com.example.spark.observer

import org.apache.spark.sql.streaming.StreamingQueryListener
import org.apache.spark.sql.streaming.StreamingQueryListener._

trait PythonObserver {
  def on_next(o: Object): Unit
}

class PythonStreamingQueryListener(observer: PythonObserver) 
    extends StreamingQueryListener {
  override def onQueryProgress(event: QueryProgressEvent): Unit = {
    observer.on_next(event)
  }
  override def onQueryStarted(event: QueryStartedEvent): Unit = {}
  override def onQueryTerminated(event: QueryTerminatedEvent): Unit = {}
}

构建一个jar，调整构建定义以反映所需的Scala和Spark版本：

scalaVersion := "2.11.8"  

val sparkVersion = "2.2.0"

libraryDependencies ++= Seq(
  "org.apache.spark" %% "spark-sql" % sparkVersion,
  "org.apache.spark" %% "spark-streaming" % sparkVersion
)

将它放在Spark类路径上，修补程序StreamingQueryManager：

%pyspark

from pyspark.sql.streaming import StreamingQueryManager
from pyspark import SparkContext

def addListener(self, listener):
    jvm = SparkContext._active_spark_context._jvm
    jlistener = jvm.com.example.spark.observer.PythonStreamingQueryListener(
        listener
    )
    self._jsqm.addListener(jlistener)
    return jlistener


StreamingQueryManager.addListener = addListener

启动回调服务器：

%pyspark

sc._gateway.start_callback_server()

并添加监听器：

%pyspark

from rx.subjects import Subject

class StreamingObserver(Subject):
    class Java:
        implements = ["com.example.spark.observer.PythonObserver"]

observer = StreamingObserver()
spark.streams.addListener(observer)

最后，您可以使用subscribe并阻止执行：

%pyspark

(observer
    .map(lambda p: p.progress().name())
    # .filter() can be used to print only for a specific query
    .subscribe(lambda n: spark.table(n).show() if n else None))
input()  # Block execution to capture the output

开始流式传输查询后，应执行最后一步。

也可以跳过rx并使用这样的最小观察者：

class StreamingObserver(object):
    class Java:
        implements = ["com.example.spark.observer.PythonObserver"]

    def on_next(self, value):
        try:
            name = value.progress().name()
            if name:
                spark.table(name).show()
        except: pass

它提供的控制比Subject少一点（一点需要注意，这会干扰其他代码打印到标准输出，只能由removing listener停止。使用Subject你可以很容易dispose subscribed观察者，一旦你完成了），否则应该或多或少地相同。

请注意，任何阻塞操作都足以捕获侦听器的输出，并且不必在同一单元中执行。例如

%pyspark

observer = StreamingObserver()
spark.streams.addListener(observer)

和

%pyspark

import time

time.sleep(42)

将以类似的方式工作，打印表定义的时间间隔。

为了完整性，您可以实施StreamingQueryManager.removeListener。

Answer 2

zeppelin-0.7.3-bin-all使用Spark 2.1.0（因此没有rate格式来测试结构化流式传输）。

确保start socket来自nc -lk 9999来源val lines = spark .readStream .format("socket") .option("host", "localhost") .option("port", 9999) .load val q = lines.writeStream.format("console").start的流查询已经启动（因为查询只是停止了）。

还要确保查询确实已启动并正在运行。

console

确实，您无法在Zeppelin笔记本中看到输出，因为：

流式查询从他们自己的线程开始（似乎在Zeppelin的范围之外）

Dataset.show接收writes to standard output（在该单独的线程上使用logs/zeppelin-interpreter-spark-[hostname].log运算符）。

所有这些使得＆＃34;拦截＆＃34; Zeppelin中没有输出。

所以我们来回答真正的问题：

在Zeppelin中写入的标准输出在哪里？

嗯，由于对Zeppelin内部的理解非常有限，我认为它可能是console，但遗憾的是找不到console接收器的输出。您可以在这里找到使用log4j而不是console接收器的Spark（特别是结构化流）的日志。

看起来您唯一的长期解决方案就是编写自己的{{1}} - 就像自定义接收器一样，并使用log4j记录器。老实说，这并不像听起来那么难。关注the sources of console sink。

如何从Zeppelin中获取控制台流水槽的输出？

2 个答案: