Question

我的项目中有一个场景，其中我正在使用spark-sql-2.4.1版本阅读kafka主题消息。我可以使用结构化流处理这一天。接收到数据并对其进行处理后，我需要将数据保存到hdfs存储中的相应镶木文件中。

我能够存储和读取镶木地板文件，触发时间为15秒到1分钟。这些文件非常小，因此会生成许多文件。

这些实木复合地板文件需要通过配置单元查询稍后读取。

所以 1）此策略在生产环境中有效吗？还是以后导致任何小文件问题？

2）处理/设计这种情况（即行业标准）的最佳实践是什么？

3）生产中通常如何处理这类事情？

谢谢。

Answer 1

我知道这个问题太老了。我遇到了类似的问题，并且使用了Spark结构化的流查询监听器来解决此问题。

我的用例是从kafka提取数据并存储在具有年，月，日和小时分区的hdfs中。

下面的代码将获取前一个小时的分区数据，在现有分区中应用重新分区和覆盖数据。

val session = SparkSession.builder().master("local[2]").enableHiveSupport().getOrCreate()
session.streams.addListener(AppListener(config,session))

class AppListener(config: Config,spark: SparkSession) extends StreamingQueryListener {
  override def onQueryStarted(event: StreamingQueryListener.QueryStartedEvent): Unit = {}
  override def onQueryProgress(event: StreamingQueryListener.QueryProgressEvent): Unit = {
    this.synchronized {AppListener.mergeFiles(event.progress.timestamp,spark,config)}
  }
  override def onQueryTerminated(event: StreamingQueryListener.QueryTerminatedEvent): Unit = {}
}

object AppListener {

  def mergeFiles(currentTs: String,spark: SparkSession,config:Config):Unit = {
    val configs = config.kafka(config.key.get)
    if(currentTs.datetime.isAfter(Processed.ts.plusMinutes(5))) {

      println(
        s"""
           |Current Timestamp     :     ${currentTs}
           |Merge Files           :     ${Processed.ts.minusHours(1)}
           |
           |""".stripMargin)

      val fs = FileSystem.get(spark.sparkContext.hadoopConfiguration)
      val ts = Processed.ts.minusHours(1)
      val hdfsPath = s"${configs.hdfsLocation}/year=${ts.getYear}/month=${ts.getMonthOfYear}/day=${ts.getDayOfMonth}/hour=${ts.getHourOfDay}"
      val path = new Path(hdfsPath)

      if(fs.exists(path)) {

      val hdfsFiles = fs.listLocatedStatus(path)
        .filter(lfs => lfs.isFile && !lfs.getPath.getName.contains("_SUCCESS"))
        .map(_.getPath).toList

      println(
        s"""
           |Total files in HDFS location  : ${hdfsFiles.length}
           | ${hdfsFiles.length > 1}
           |""".stripMargin)

      if(hdfsFiles.length > 1) {

          println(
            s"""
               |Merge Small Files
               |==============================================
               |HDFS Path             : ${hdfsPath}
               |Total Available files : ${hdfsFiles.length}
               |Status                : Running
               |
               |""".stripMargin)

          val df = spark.read.format(configs.writeFormat).load(hdfsPath).cache()
          df.repartition(1)
            .write
            .format(configs.writeFormat)
            .mode("overwrite")
            .save(s"/tmp${hdfsPath}")

          df.cache().unpersist()

        spark
          .read
          .format(configs.writeFormat)
          .load(s"/tmp${hdfsPath}")
          .write
          .format(configs.writeFormat)
          .mode("overwrite")
          .save(hdfsPath)

          Processed.ts = Processed.ts.plusHours(1).toDateTime("yyyy-MM-dd'T'HH:00:00")
          println(
            s"""
               |Merge Small Files
               |==============================================
               |HDFS Path             : ${hdfsPath}
               |Total files           : ${hdfsFiles.length}
               |Status                : Completed
               |
               |""".stripMargin)
        }
      }
    }
  }
  def apply(config: Config,spark: SparkSession): AppListener = new AppListener(config,spark)
}

object Processed {
  var ts: DateTime = DateTime.now(DateTimeZone.forID("UTC")).toDateTime("yyyy-MM-dd'T'HH:00:00")
}

有时候数据非常庞大，我使用以下逻辑将数据分为多个文件。文件大小约为160 MB

val bytes = spark.sessionState.executePlan(df.queryExecution.logical).optimizedPlan.stats(spark.sessionState.conf).sizeInBytes
    val dataSize = bytes.toLong
    val numPartitions = (bytes.toLong./(1024.0)./(1024.0)./(10240)).ceil.toInt

    df.repartition(if(numPartitions == 0) 1 else numPartitions)
      .[...]

Edit-1

使用它-spark.sessionState.executePlan（df.queryExecution.ologic）.optimizedPlan.stats（spark.sessionState.conf）.sizeInBytes我们可以将实际Dataframe的大小加载到内存中，例如，您可以检查下面的代码。

scala> val df = spark.read.format("orc").load("/tmp/srinivas/")
df: org.apache.spark.sql.DataFrame = [channelGrouping: string, clientId: string ... 75 more fields]

scala> import org.apache.commons.io.FileUtils
import org.apache.commons.io.FileUtils

scala> val bytes = spark.sessionState.executePlan(df.queryExecution.logical).optimizedPlan.stats(spark.sessionState.conf).sizeInBytes
bytes: BigInt = 763275709

scala> FileUtils.byteCountToDisplaySize(bytes.toLong)
res5: String = 727 MB

scala> import sys.process._
import sys.process._

scala> "hdfs dfs -ls -h /tmp/srinivas/".!
Found 2 items
-rw-r-----   3 svcmxns hdfs          0 2020-04-20 01:46 /tmp/srinivas/_SUCCESS
-rw-r-----   3 svcmxns hdfs    727.4 M 2020-04-20 01:46 /tmp/srinivas/part-00000-9d0b72ea-f617-4092-ae27-d36400c17917-c000.snappy.orc
res6: Int = 0

Answer 2

我们也有类似的问题。经过大量的谷歌搜索之后，似乎普遍接受的方式是编写另一种工作，即经常聚合许多小文件并将它们写在较大的合并文件中的其他位置。这就是我们现在要做的。

顺便说一句：您可以在这里做什么都受到限制，因为您拥有的并行性越强，文件的数量就越多，因为每个执行程序线程都会写入自己的文件。他们从不写入共享文件。这似乎是野兽的本质，即并行处理。

Answer 3

这是火花流的常见燃烧问题，没有任何固定答案。我采用了一种非常规的方法，该方法基于附加的想法。当您使用spark 2.4.1时，此解决方案将很有帮助。

因此，如果以Parquet或Orc的列式文件格式支持append，则将变得更加容易，因为可以将新数据附加到同一文件中，并且每次微型批处理后文件的大小都会越来越大。但是，由于不受支持，因此我采用了版本控制方法来实现此目的。在每个微批处理之后，将使用版本分区生成数据。例如

/prod/mobility/cdr_data/date=01–01–2010/version=12345/file1.parquet
/prod/mobility/cdr_data/date=01–01–2010/version=23456/file1.parquet

我们可以做的是，在每个微批处理中，读取旧版本数据，将其与新的流数据合并，然后在与新版本相同的路径上再次写入。然后，删除旧版本。这样，在每个微批处理之后，每个分区中将只有一个版本和一个文件。每个分区中的文件大小将不断增长并变得更大。

由于不允许流数据集和静态数据集的并集，我们可以使用forEachBatch接收器（在spark> = 2.4.0中可用）将流数据集转换为静态数据集。

我已经描述了如何在链接中最佳实现这一目标。您可能想看看。 https://medium.com/@kumar.rahul.nitk/solving-small-file-problem-in-spark-structured-streaming-a-versioning-approach-73a0153a0a

如何处理Spark结构化流中的小文件问题？

3 个答案: