Apache spark Spark Streaming tuning每批大小的记录数不起作用？

我的spark流媒体应用程序正在使用DStream方法读取kafka的内容，我正在尝试使批量大小在10秒内处理60000条消息

我所做的

• 创建了一个包含3个分区的主题

• spark.streaming.kafka.maxRatePerPartition=60000

• spark.streaming.backpressure.enabled=true

• 创建批处理时，将批处理持续时间设置为10秒 StreamingContext
• 在纱线模式下运行，2个执行器（3个执行器共4芯 分区）

现在我如何测试这是否有效

我有一个制作人，一次向主题发送60000条消息。当我检查spark UI时，我得到以下信息：

 batch time | Input size | processing time
 10:54:30   | 17610      | 5s
 10:54:20   | 32790      | 8s
 10:54:10   | 9600       | 3s

因此，每批时间间隔为10秒。我期望的是一批60000条记录。是否有其他我没有设置的参数？从我读到的关于我目前设置的内容来看，我应该在单个批次中获得10*60000*3=1800000

spark.app.id  = application_1551747423133_0677

spark.app.name = KafkaCallDEV

spark.driver.cores = 2

spark.driver.extraJavaOptions   = -XX:+UseG1GC -XX:ConcGCThreads=2
-XX:InitiatingHeapOccupancyPercent=35 -Dlog4j.configuration=log4j.properties -verbose:gc

spark.driver.memory = 3g

spark.driver.port   = 33917

spark.executor.cores = 2

spark.executor.extraJavaOptions = -XX:+UseG1GC -XX:ConcGCThreads=2
-XX:InitiatingHeapOccupancyPercent=35 -Dlog4j.configuration=log4j.properties -verbose:gc

spark.executor.id   = driver

spark.executor.instances    = 2

spark.executor.memory   = 2g

spark.master    = yarn

spark.scheduler.mode    = FIFO

spark.streaming.backpressure.enabled    = true

spark.streaming.kafka.maxRatePerPartition = 60000

spark.submit.deployMode = cluster

spark.ui.filters    = org.apache.hadoop.yarn.server.webproxy.amfilter.AmIpFilter

spark.ui.port = 0

spark.yarn.app.container.log.dir = /data0/yarn/container-logs/application_1551747423133_0677/container_1551747423133_0677_01_000002 

下面是我使用

logger.info(sparkSession.sparkContext.getConf.getAll.mkString("\n"))

我删除了一些不必要的日志，如服务器地址、应用程序名称等

(spark.executor.extraJavaOptions,-XX:+UseG1GC -XX:ConcGCThreads=2

-XX:InitiatingHeapOccupancyPercent=35 -Dlog4j.configuration=log4j.properties -verbose:gc) (spark.yarn.app.id,application_1551747423133_0681)

(spark.submit.deployMode,cluster)

(spark.streaming.backpressure.enabled,true)

(spark.yarn.credentials.renewalTime,1562764821939ms)

(spark.ui.filters,org.apache.hadoop.yarn.server.webproxy.amfilter.AmIpFilter)

(spark.executor.memory,2g) 

(spark.yarn.credentials.updateTime,1562769141873ms)

(spark.driver.cores,2) 

(spark.executor.id,driver)

(spark.executor.cores,2)

(spark.master,yarn)

(spark.driver.memory,3g)

(spark.sql.warehouse.dir,/user/hive/warehouse) 

(spark.ui.port,0)

(spark.driver.extraJavaOptions,-XX:+UseG1GC -XX:ConcGCThreads=2
-XX:InitiatingHeapOccupancyPercent=35 -Dlog4j.configuration=log4j.properties -verbose:gc) 

(spark.executor.instances,2)

(spark.driver.port,37375)

我也有一些卡夫卡的配置，正在打印，所以我会张贴在下面

    org.apache.kafka.clients.consumer.ConsumerConfig:178 - ConsumerConfig values: 
        metric.reporters = []
        metadata.max.age.ms = 300000
        partition.assignment.strategy = [org.apache.kafka.clients.consumer.RangeAssignor]
        reconnect.backoff.ms = 50
        sasl.kerberos.ticket.renew.window.factor = 0.8
        max.partition.fetch.bytes = 1048576
        ssl.keystore.type = JKS
        enable.auto.commit = false
        sasl.mechanism = GSSAPI
        interceptor.classes = null
        exclude.internal.topics = true
        ssl.truststore.password = null
        client.id = 
        ssl.endpoint.identification.algorithm = null
        max.poll.records = 60000
        check.crcs = true
        request.timeout.ms = 40000
        heartbeat.interval.ms = 3000
        auto.commit.interval.ms = 5000
        receive.buffer.bytes = 65536
        ssl.truststore.type = JKS
        ssl.truststore.location = null
        ssl.keystore.password = null
        fetch.min.bytes = 1
        send.buffer.bytes = 131072
        value.deserializer = class org.apache.kafka.common.serialization.StringDeserializer
        retry.backoff.ms = 100
        ssl.secure.random.implementation = null
        sasl.kerberos.kinit.cmd = /usr/bin/kinit
        sasl.kerberos.service.name = null
        sasl.kerberos.ticket.renew.jitter = 0.05
        ssl.trustmanager.algorithm = PKIX
        ssl.key.password = null
        fetch.max.wait.ms = 500
        sasl.kerberos.min.time.before.relogin = 60000
        connections.max.idle.ms = 540000
        session.timeout.ms = 30000
        metrics.num.samples = 2
        key.deserializer = class org.apache.kafka.common.serialization.StringDeserializer
        ssl.protocol = TLS
        ssl.provider = null
        ssl.enabled.protocols = [TLSv1.2, TLSv1.1, TLSv1]
        ssl.keystore.location = null
        ssl.cipher.suites = null
        security.protocol = PLAINTEXT
        ssl.keymanager.algorithm = SunX509
        metrics.sample.window.ms = 30000
        auto.offset.reset = latest

---

spark.streaming.kafka.maxRatePerPartition=60000 意味着

每个卡夫卡播放的最大速率（以每秒消息数为单位） 分区将由该直接API读取，该API将由属性

spark.streaming.backpressure.enabled=true启用

17610+32790+9600=60000您的批量已达到


看

spark以区块/spark分区的形式读取您的3个kafka分区（有60k个消息），在您的情况下，spark读取3个分区。但3个kafka分区中的原始消息数为60000（17610+32790+9600）。即使高消息速率输入流正在返回，压力也将保持消息使用和传输的一致速率

那么你在这里完成了

进一步参考我的

结论：
如果启用背压，则无论发送消息的速率如何。它将允许恒定速率的消息

就像这个基因的例子。。。其中，背压特性类似于流入控制-压力调节螺钉，以保持信息流的均匀速率

所以我找到了Spark将我发送的一批记录分解为多个批次的原因。我有
spark.streaming.backpressure.enabled=true
。这使用以前批次的反馈循环来控制接收速率，该速率的上限是我在
spark.streaming.kafka.maxRatePerPartition
中设置的每个分区的最大速率。所以spark正在为我调整接收速率
 你好，拉姆。我的主题有3个分区。我一次向此主题发送60K条消息。我已经向你展示了我原来帖子中的一些统计数据。处理所有60K消息需要3批，每批10秒，每批获取不同数量的数据。logger.info（sparkContext.getConf.getAll.mkString（“\n”））只需打印这些数据并发布！嗨，拉姆，我发布了配置信息“spark正在为我调整接收速率”，这是我在第一行回答中所说的。请参阅“这是我在第一行答案中所说的”-我实际上在上面发布了关于背压信息的答案，您在我发布的第二天的编辑中提到了这一点。