Spark Streaming调优参数及最佳实践深入剖析-Spark商业调优实战

最新推荐文章于 2022-09-26 15:46:05 发布
最新推荐文章于 2022-09-26 15:46:05 发布
阅读量228 收藏
点赞数
文章标签： 大数据 java
原文链接：https://juejin.im/post/5bf1780d6fb9a049de6cf51d
版权

本套技术专栏是作者（秦凯新）平时工作的总结和升华，通过从真实商业环境抽取案例进行总结和分享，并给出商业应用的调优建议和集群环境容量规划等内容，请持续关注本套博客。版权声明：禁止转载，欢迎学习。QQ邮箱地址：1120746959@qq.com，如有任何商业交流，可随时联系。

1 开门见山

1.1 优化1：进行HA机制处理-针对updateStateByKey与window等有状态的操作

  • HA高可用性：High Availability，如果有些数据丢失，或者节点挂掉；如果不想让你的实时计算程序挂了，就必须做一些数据上的冗余副本，保证你的实时计算程序可以7 * 24小时的运转。

  • 针对updateStateByKey与window等有状态的操作，自动进行checkpoint，必须设置checkpoint目录。

      HDFS:SparkStreaming.checkpoint("hdfs://192.168.1.105:9090/checkpoint")，
复制代码

  • checkpoint 会把数据保留一份在容错的文件系统中，一旦内存中的数据丢失掉；就可以直接从文 件系统中读取数据,不需要重新进行计算。

      JavaStreamingContext jssc = new JavaStreamingContext(
        conf, Durations.seconds(5));  
  jssc.checkpoint("hdfs://192.168.1.105:9000/streaming_checkpoint");
复制代码

1.2 优化2：进行HA机制处理-针对Driver高可用性

  • 在创建和启动StreamingContext的时候，将元数据写入容错的文件系统（比如hdfs）。保证在driver挂掉之后，spark集群可以自己将driver重新启动起来；而且driver在启动的时候，不会重新创建一个streaming context，而是从容错文件系统（比如hdfs）中读取之前的元数据信息，包括job的执行进度，继续接着之前的进度，继续执行。

  • 使用这种机制，就必须使用cluster模式提交，确保driver运行在某个worker上面；

      JavaStreamingContextFactory contextFactory = new JavaStreamingContextFactory() {
      @Override
     public JavaStreamingContext create() {
       	JavaStreamingContext jssc = new JavaStreamingContext(...);
      	JavaDStream<String> lines = jssc.socketTextStream(...);
      	jssc.checkpoint(checkpointDirectory);
      	return jssc;
        }
      };
 JavaStreamingContext context = JavaStreamingContext.getOrCreate(checkpointDirectory, contextFactory);
 context.start();
 context.awaitTermination();
复制代码

  • JavaStreamingContext.getOrCreate 基于Function0< JavaStreamingContext > 进行Driver高可用

     Function0<JavaStreamingContext> createContextFunc = new Function0<JavaStreamingContext>(){
 	@Override
 	public JavaStreamingContext call() throws Exception
 	{
 		conf = new SparkConf()
 				.setMaster("local[4]")
 				.setAppName("java/RealTimeStreaming")
 				.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
 				.set("spark.default.parallelism", "10")
 				.set("spark.streaming.blockInterval", "50")
 				.set("spark.streaming.receiver.writeAheadLog.enable", "true");
 		Map<String, Object> kafkaParams = new HashMap<>();
 		kafkaParams.put("bootstrap.servers", "Master:9092,Worker1:9092,Worker2:9092");
 		kafkaParams.put("key.deserializer", StringDeserializer.class);
 		kafkaParams.put("value.deserializer", StringDeserializer.class);
 		kafkaParams.put("group.id", "TestGroup");
 		kafkaParams.put("auto.offset.reset", "latest");
 		kafkaParams.put("enable.auto.commit",true);

 		JavaStreamingContext jssc = new JavaStreamingContext(
 				conf, Durations.seconds(30));
 		jssc.checkpoint("hdfs://Master:9000/checkpoint");

 		// 构建topic set
 		String kafkaTopics = ConfigurationManager.getProperty(Constants.KAFKA_TOPICS);
 		String[] kafkaTopicsSplited = kafkaTopics.split(",");
 		Set<String> topics = new HashSet<String>();
 		for(String kafkaTopic : kafkaTopicsSplited) {
 			topics.add(kafkaTopic);
 		}

 		JavaInputDStream<ConsumerRecord<String, String>> adRealTimeLogDStream = KafkaUtils.createDirectStream(jssc,
 				LocationStrategies.PreferConsistent(),
 				ConsumerStrategies.Subscribe(topics, kafkaParams));

 		hostMap = adRealTimeLogDStream.mapToPair(record -> new Tuple2<String, String>(record.key(), record.value()));

 		logPeakDstream  = hostMap.mapToPair(new PairFunction<Tuple2<String, String>, String, Long>() {
 			@Override
 			public Tuple2<String,Long> call(Tuple2<String, String> tuple) throws Exception {
 				String log = tuple._2;
 				String[] logSplited = log.split("\\|");
 				String eventTime= logSplited[1];
 				String todayDate = DATE_FORMAT.format(new Date()).trim();
 				String cutTime= eventTime.substring(13,eventTime.length()-7);

 				String ip = logSplited[0].trim();
 				String host = logSplited[14].trim();
 				return new Tuple2<String, Long>(host+"-"+ip, 1L);
 			}
 		});

 		hostReduce = logPeakDstream.reduceByKeyAndWindow(new Function2<Long, Long, Long>() {
 			@Override
 			public Long call(Long v1, Long v2) throws Exception {
 				return v1 + v2;
 			}
 		}, Durations.minutes(10),Durations.seconds(30));

 		JavaPairDStream<String, Long> topNPairRdd = hostReduce.transformToPair(new Function<JavaPairRDD<String, Long>, JavaPairRDD<String, Long>>() {
 			@Override
 			public JavaPairRDD<String, Long> call(JavaPairRDD<String, Long> rdd) throws Exception {
 				JavaPairRDD<Long, String> sortRDD = (JavaPairRDD<Long, String>) rdd.mapToPair(record -> new Tuple2<Long, String>(record._2, record._1));
 				JavaPairRDD<String, Long> sortedRdd = (JavaPairRDD<String, Long>) sortRDD.sortByKey(false).mapToPair(record -> new Tuple2<String, Long>(record._2, record._1));

 				List<Tuple2<String, Long>> topNs = sortedRdd.take(5);//取前5个输出
 				System.out.println("                                                 ");
 				System.out.println("*****************峰值访问窗统计*******************");
 				for (Tuple2<String, Long> topN : topNs) {
 					System.out.println(topN);
 				}
 				System.out.println("**********************END***********************");
 				System.out.println("                                                 ");
 				return sortedRdd;
 			}
 		});

 		topNPairRdd.foreachRDD(new VoidFunction<JavaPairRDD<String, Long>>() {
 			@Override
 			public void call(JavaPairRDD<String, Long> rdd) throws Exception {

 			}
 		});

 		logDetailDstream = hostMap.map(new Function<Tuple2<String,String>, String>() {
 			@Override
 			public String call(Tuple2<String, String> tuple) throws Exception {
 				String log = tuple._2;
 				String[] logSplited = log.split("\\|");
 				String eventTime= logSplited[1];
 				String todayDate = DATE_FORMAT.format(new Date()).trim();
 				String cutTime= eventTime.substring(13,eventTime.length()-7);
 				String[] urlDetails = logSplited[7].split("/");
 				String ip = logSplited[0].trim();

 				String url ="";
 				if(urlDetails.length==4){
 					url = urlDetails[3];
 				}else if(urlDetails.length==5){
 					url = urlDetails[3] + "/" + urlDetails[4];
 				}else if(urlDetails.length>=6){
 					url = urlDetails[3] + "/" + urlDetails[4]+ "/" + urlDetails[5];
 				}
 				String host = logSplited[14].trim();
 				String dataTime =todayDate +" "+ cutTime;
 				String bytesSent = logSplited[5].trim();
 				return  dataTime+" "+host+" "+ip+" "+url+" "+bytesSent;
 			}
 		});
 		//logDetailDstream.print();
 		return jssc;
 	}
 };
 return createContextFunc;
复制代码

  • 提交方式

      spark-submit
          --deploy-mode cluster
          --supervise
复制代码

1.3 优化3：实现RDD高可用性：启动WAL预写日志机制

  • spark streaming，从原理上来说，是通过receiver来进行数据接收的；接收到的数据，会被划分成一个一个的block；block会被组合成一个batch；针对一个batch，会创建一个rdd；

  • receiver接收到数据后，就会立即将数据写入一份到容错文件系统（比如hdfs）上的checkpoint目录中的，另一份写入到磁盘文件中去；作为数据的冗余副本。无论你的程序怎么挂掉，或者是数据丢失，那么数据都不肯能会永久性的丢失；因为肯定有副本。

      SparkConf conf = new SparkConf()       
      			.setMaster("local[2]")
      			.setAppName("StreamingSpark");
      			.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer");
      			.set("spark.default.parallelism", "1000");
      			.set("spark.streaming.blockInterval", "50");    
      			.set("spark.streaming.receiver.writeAheadLog.enable", "true");   
  JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(5)); 
  jssc.checkpoint("hdfs://192.168.1.164:9000/checkpoint");
复制代码

1.4 优化4：InputDStream并行化数据接收

  • 创建多个InputDStream来接收同一数据源

  • 把多个topic数据细化为单一的kafkaStream来接收

       1：创建kafkaStream
   Map<String, String> kafkaParams = new HashMap<String, String>();
   kafkaParams.put("metadata.broker.list", "192.168.1.164:9092,192.168.1.165:9092,192.168.1.166:9092");
   kafkaParams.put("zookeeper.connect","master:2181,data1:2181,data2:2181");
   
   构建topic set
   String kafkaTopics = ConfigurationManager.getProperty(Constants.KAFKA_TOPICS);
   String[] kafkaTopicsSplited = kafkaTopics.split(",");

   Set<String> topics = new HashSet<String>();
   for(String kafkaTopic : kafkaTopicsSplited) {
   	topics.add(kafkaTopic);
   	
   JavaPairInputDStream<String, String> kafkaStream = KafkaUtils.createDirectStream(
   	jssc, 
   	String.class, 
   	String.class, 
   	StringDecoder.class, 
   	StringDecoder.class, 
   	kafkaParams, 
   	topics);

   2：InputDStream并行化数据接收
       int numStreams = 5;
       List<JavaPairDStream<String, String>> kafkaStreams = new
       ArrayList<JavaPairDStream<String,String>>(numStreams);
       
       for (int i = 0; i < numStreams; i++) {
       	kafkaStreams.add(KafkaUtils.createStream(...));
      	 }
       JavaPairDStream<String, String> unifiedStream = 
   	streamingContext.union(kafkaStreams.get(0), kafkaStreams.subList(1, kafkaStreams.size()));
       unifiedStream.print();
复制代码

1.5 优化5：增加block数量，增加每个batch rdd的partition数量，增加处理并行度

  • 第一步：receiver从数据源源源不断地获取到数据，首先是会按照block interval，将指定时间间隔的数据，收集为一个block；默认时间是200ms，官方推荐不要小于50ms；
  • 第二步：根据指定batch interval时间间隔合并为一个batch，创建为一个rdd，
  • 第三步：启动一个job，去处理这个batch rdd中的数据。
  • 第四步：batch rdd 的partition数量是多少呢？一个batch有多少个block，就有多少个partition；就意味着并行度是多少；就意味着每个batch rdd有多少个task会并行计算和处理。
  • 调优：如果希望可以比默认的task数量和并行度再多一些，可以手动调节blockinterval，减少block interval。每个batch可以包含更多的block。因此也就有更多的partition，因此就会有更多的task并行处理每个batch rdd。

1.6 优化6：重分区，增加每个batch rdd的partition数量

  • inputStream.repartition()：重分区，增加每个batch rdd的partition数量 对dstream中的rdd进行重分区为指定数量的分区，就可以提高指定dstream的rdd的计算并行度
  • 调节并行度具体细节：

1.7 优化7：提升并行度

      方法1： spark.default.parallelism
      方法2： reduceByKey(numPartitions)
复制代码

	JavaPairDStream<String, Long> dailyUserAdClickCountDStream = dailyUserAdClickDStream.reduceByKey(
			new Function2<Long, Long, Long>() {
				private static final long serialVersionUID = 1L;
				@Override
				public Long call(Long v1, Long v2) throws Exception {
					return v1 + v2;
				}
			});
			}, 1000);
复制代码

1.8 优化8：使用Kryo序列化机制

  • spark streaming：提高序列化task发送到executor上执行的性能，比如：task很多的时候，task序列化和反序列化的性能开销也比较可观

  • 默认输入数据的存储级别是StorageLevel.MEMORY_AND_DISK_SER_2，receiver接收到数据，默认就会进行持久化操作；首先序列化数据，存储到内存中；如果内存资源不够大，那么就写入磁盘；而且，还会写一份冗余副本到其他executor的block manager中，进行数据冗余。

      SparkConf conf = new SparkConf()       
  		.setMaster("local[2]")
  		.setAppName("StreamingSpark");
  		
  		.set("spark.serializer", "org.apache.spar.serializer.KryoSerializer"); <= 优化点
  		
  		.set("spark.default.parallelism", "1000");
  		.set("spark.streaming.blockInterval", "50");    
  		.set("spark.streaming.receiver.writeAheadLog.enable", "true");   
复制代码

1.9 优化9：batch interval：流式处理时间必须小于batch interval

  • batch interval，就是指每隔多少时间收集一次数据源中的数据，然后进行处理，因此切忌处理时间过长导致的batch interval。

      JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(5));  
复制代码

1.10 优化10：缓存需要经常使用的数据

调用rdd.cache()来缓存数据，这样也可以加快数据的处理，但是我们需要更多的内存资源

1.11 优化11：定时清除不需要的数据

  • 通过配置spark.cleaner.ttl为一个合理的值，但是这个值不能过小，因为如果后面计算需要用的数据被清除会带来不必要的麻烦。
  • 另外通过配置spark.streaming.unpersist为true(默认就是true)来更智能地去持久化（unpersist）RDD。这个配置使系统找出那些不需要经常保有的RDD，然后去持久化它们。这可以减少Spark RDD的内存使用，也可能改善垃圾回收的行为。

1.12 优化12：GC优化策略(暂时不确定)

建议用并行Mark-Sweep垃圾回收机制，虽然它消耗更多的资源，但是我们还是建议开启。 在spark-submit中使用

--driver-java-options "-XX:+UseConcMarkSweepGC"
--conf "spark.executor.extraJavaOptions=-XX:+UseConcMarkSweepGC"
复制代码

1.13 优化13：去除压缩

在内存充足的情况下，可以设置spark.rdd.compress 设置为false.

1.14 优化14：Executors和cpu核心数设置和Spark On Yarn 动态资源分配

  • 首先需要对YARN的NodeManager进行配置，使其支持Spark的Shuffle Service。

       ##修改
  <property>
  <name>yarn.nodemanager.aux-services</name>
  <value>mapreduce_shuffle,spark_shuffle</value>
  </property>
  ##增加
  <property>
  <name>yarn.nodemanager.aux-services.spark_shuffle.class</name>
  <value>org.apache.spark.network.yarn.YarnShuffleService</value>
  </property>
  <property>
  <name>spark.shuffle.service.port</name>
  <value>7337</value>
  </property>
复制代码

  • 将spark中对应jar包拷贝到hadoop的目录下：

      首先找到spark版本的spark-<version>-yarn-shuffle.jar
  shuffle包，并将该包放到集群所有NodeManager的classpath下，
  比如放到HADOOP_HOME/share/hadoop/yarn/lib
复制代码

  • 重启所有NodeManager。

  • 配置示例如下：

      spark.shuffle.service.enabled=true
  spark.dynamicAllocation.enabled=true
  spark.dynamicAllocation.executorIdleTimeout=60s
  spark.dynamicAllocation.initialExecutors=1
  spark.dynamicAllocation.maxExecutors=5
  spark.dynamicAllocation.minExecutors=0
  
  spark-submit \
  --master yarn \
  --deploy-mode cluster \
  --executor-cores 3 \
  --executor-memory 10G \
  --driver-memory 4G \
  --conf spark.dynamicAllocation.enabled=true \
  --conf spark.shuffle.service.enabled=true \
  --conf spark.dynamicAllocation.initialExecutors=5 \
  --conf spark.dynamicAllocation.maxExecutors=40 \
  --conf spark.dynamicAllocation.minExecutors=0 \
  --conf spark.dynamicAllocation.executorIdleTimeout=30s \
  --conf spark.dynamicAllocation.schedulerBacklogTimeout=10s \
复制代码

1.15 优化15：使用高性能算子

使用reduceByKey/aggregateByKey替代groupByKey 使用mapPartitions替代普通map 使用foreachPartitions替代foreach 使用filter之后进行coalesce操作 使用repartitionAndSortWithinPartitions替代repartition与sort类操作

1.16 优化16：SparkStreaming 与kafka整合调优

LocationStrategies 位置策略：

The new Kafka consumer API will pre-fetch messages into buffers. Therefore it is important for performance 
reasons that the Spark integration keep cached consumers on executors (rather than recreating them for each 
batch), and prefer to schedule partitions on the host locations that have the appropriate consumers.
复制代码

新的Kafka消费者API可以预获取消息缓存到缓冲区，因此Spark整合Kafka让消费者在executor上进行缓存对性能是非常有助的，可以调度消费者所在主机位置的分区。

In most cases, you should use LocationStrategies.PreferConsistent as shown above. This will distribute partitions 
evenly across available executors. If your executors are on the same hosts as your Kafka brokers, use PreferBrokers,
which will prefer to schedule partitions on the Kafka leader for that partition. Finally, if you have a significant 
skew in load among partitions, use PreferFixed. This allows you to specify an explicit mapping of partitions to 
hosts (any unspecified partitions will use a consistent location).
复制代码

通常，你可以使用 LocationStrategies.PreferConsistent，这个策略会将分区分布到所有可获得的executor上。如果你的executor和kafkabroker在同一主机上的话，可以使用PreferBrokers，这样kafka leader会为此分区进行调度。最后，如果你加载数据有倾斜的话可以使用PreferFixed，这将允许你制定一个分区和主机的映射（没有指定的分区将使用PreferConsistent 策略）

The cache for consumers has a default maximum size of 64. If you expect to be handling more than 
(64 * number of executors) Kafka partitions, you can change this setting
via spark.streaming.kafka.consumer.cache.maxCapacity
复制代码

消费者默认缓存大小是64，如果你期望处理较大的Kafka分区的话，你可以使用spark.streaming.kafka.consumer.cache.maxCapacity设置大小。

The cache is keyed by topicpartition and group.id, so use a separate group.id for each call to createDirectStream.
复制代码

缓存是使用key为topic partition 和组id的，因此对于每一次调用 createDirectStream 可以使用不同的 group . id

public  static SparkConf  conf = new SparkConf()
				.setMaster("local[4]")
				.setAppName("java/RealTimeStreaming")
				.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
				.set("spark.default.parallelism", "10")
				.set("spark.streaming.blockInterval", "50")
				.set("spark.streaming.receiver.writeAheadLog.enable", "true");
Map<String, Object> kafkaParams = new HashMap<>();
kafkaParams.put("bootstrap.servers", "Master:9092,Worker1:9092,Worker2:9092");
kafkaParams.put("key.deserializer", StringDeserializer.class);
kafkaParams.put("value.deserializer", StringDeserializer.class);
kafkaParams.put("group.id", "TestGroup");
kafkaParams.put("auto.offset.reset", "latest");
kafkaParams.put("enable.auto.commit",true);

JavaStreamingContext jssc = new JavaStreamingContext(
		conf, Durations.seconds(30));
jssc.checkpoint("hdfs://Master:9000/checkpoint");

构建topic set
String kafkaTopics = ConfigurationManager.getProperty(Constants.KAFKA_TOPICS);
String[] kafkaTopicsSplited = kafkaTopics.split(",");
Set<String> topics = new HashSet<String>();
for(String kafkaTopic : kafkaTopicsSplited) {
	topics.add(kafkaTopic);
		}
		
JavaInputDStream<ConsumerRecord<String, String>> adRealTimeLogDStream = KafkaUtils.createDirectStream(jssc,
		LocationStrategies.PreferConsistent(),
		ConsumerStrategies.Subscribe(topics, kafkaParams));
复制代码

1.17 优化17：SparkStreaming 优雅退出

    public static void main(String[] args) throws Exception{
		Logger.getLogger("org").setLevel(Level.ERROR);
		//String checkpointPath = PropertiesUtil.getProperty("streaming.checkpoint.path");
		JavaStreamingContext javaStreamingContext = JavaStreamingContext.getOrCreate("hdfs://Master:9000/streaming_checkpoint", createContext());
		javaStreamingContext.start();

		每隔20秒钟监控是否有停止指令,如果有则优雅退出streaming
		final Properties serverProps = PropertiesUtil.properties;
		Thread thread = new Thread(new MonitorStopThread(javaStreamingContext,serverProps));
		thread.start();
		javaStreamingContext.awaitTermination();
	   }
    }
复制代码

2 结语

Spark Streaming是一个非常优秀的批处理程序，我已经综合了我所有的调优经验，当然后续有可优化的点，我会及时补充的。辛苦成文，各自珍惜。

秦凯新 20181119 0:23

weixin_33904756
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spark Structured Streaming checkpoint参数优化
赵英超的博客
07-13 350
内容可能持续性修改完善，最新专栏内容与同步，源码与同步。
使用Java编写Spark Streaming来做大数据处理（一）
斯特凡今天也很帅的博客
06-16 2743
写在前面：一般来说spark都是由Scala来实现，但Java一手遮天，非要以一己之力实现（不是） 一、使用JAVA编写有哪几部组成？ 1.获取数据 //往往文件都是根据配置文件修改的时间，动态获取对应的文件来处理 String filePath = "/租户目录/指标/指标分类/指标分类子分支" + startTime.substring(0, 6) + ".csv"; //通过调用JavaSparkContext的获取文本的方法获取数据 jsc.textFile(activeCenter) 一般
params.put()和params.add()的区别
我是一只蘑菇17的博客
09-26 453
两者的主要区别（除了 add() 的字符串仅支持） 是 put() 覆盖先前存在的 param 与现有的键，则 add() 不。
Spark Streaming学习——DStream
weixin_33918357的博客
04-05 433
其他更多java基础文章： java基础学习(目录) 概述 SparkStreaming是流式处理框架，是Spark API的扩展，支持可扩展、高吞吐量、容错的实时数据流处理，实时数据的来源可以是：Kafka, Flume, Twitter, ZeroMQ或者TCP sockets，并且可以使用高级功能的复杂算子来处理流数据。例如：map,reduce,join,window 。最终，处理后的数...
SparkStreaming+kafka参数设置
CircleLee的博客
12-02 3420
近期项目中对SparkStreaming+Kafka模式使用过程中需要限制单批次最大数据量，在容器节点计算出现延迟或故障时进行自动降低消费频率，在此对几个参数进行分享，同时也为加深自己的印象； 由于项目中使用的技术组件主要为SparkStreaming+Kafka+Hbase+Elasticsearch，覆盖了从数据接入-逻辑计算-结果输出几个环节，且业务需求关系，计算逻辑较为复杂，需要与Hb...
记录一次spark配置
麻辣灬小笼包的博客
03-22 427
//序列化 sparksession.conf.set(“spark.serializer”, “org.apache.spark.serializer.KryoSerializer”) //保证数据不丢失 sparksession.conf.set(“spark.streaming.stopGracefullyOnShutdown”, “true”) //开启被压 // sparksession.conf.set(“spark.streaming.backpressure.enabled”, “true”
Kafka 集群扩容、分区重新分配、SparkStreaming自适应上游kafka topic partition数目变化
.
03-26 1455
我们往已经部署好的Kafka集群里面添加机器是最正常不过的需求，而且添加起来非常地方便，我们需要做的事是从已经部署好的Kafka节点中复制相应的配置文件，然后把里面的broker id修改成全局唯一的，最后启动这个节点即可将它加入到现有Kafka集群中。 　　但是问题来了，新添加的Kafka节点并不会自动地分配数据，所以无法分担集群的负载，除非我们新建一个topic。但是现在我们想手动将部分分区...
DStream相关操作
Running_Tiger的博客
03-11 5302
DStream相关操作DStream上的操作与RDD的类似，分为Transformations（转换）和Output Operations（输出）两种，此外转换操作中还有一些比较特殊的操作，如：updateStateByKey()、transform()以及各种Window相关的操作。1、Transformations Transformation 含义 map(func) 对DStr
【转载】DStream 中有几个RDD ?
goldlone的博客
02-24 828
最原始：https://blog.csdn.net/jiangwlee/article/details/51492507 转载：https://blog.csdn.net/WangJinLong_cu/article/details/84145973 转载的文章中更明确地说明了结论。
spark streaming参数调优
littlely_ll的博客
04-30 1866
应用spark streaming的时候，可以在spark UI页面监控spark streaming的运行，UI页面有一个Streaming选项卡，展示如下： 里面有四个选项，分别是input rate,，scheduling delay，processing time和total delay，其中input rate下有一个该应用所使用的输入流的方法，这里是使用的kafkaUtil的dire...
SparkStreaming性能调优
Johnson8702的博客
04-25 1817
一、数据接收并行度调优——创建更多的输入DStream和Receiver 通过网络接收数据时（比如Kafka，Flume），会将数据反序列化，并存储在Spark的内存中。如果数据接收成为系统的瓶颈，可以考虑并行化数据接收。每个输入DStream都会在某个Worker的Executor上启动一个Receiver，该Receiver接收一个数据流。因此可以通过创建多个输入DStream，并配置它们接...
Spark Streaming性能调优详解（转）
weixin_33755847的博客
11-13 251
原文链接：Spark Streaming性能调优详解 　Spark Streaming提供了高效便捷的流式处理模式，但是在有些场景下，使用默认的配置达不到最优，甚至无法实时处理来自外部的数据，这时候我们就需要对默认的配置进行相关的修改。由于现实中场景和数据量不一样，所以我们无法设置一些通用的配置（要不然Spark Streaming开发者就不会弄那么多参数，直接写死不得了），我们需要根据数据量，...
【转载】精讲Spark Streaming集成读取kafka0.10及以上版本
黑羽柚咲
12-27 436
前言 转载于https://blog.csdn.net/daerzei/article/details/80085121，十分感谢作者大大。 Spark版本：2.1.2 JDK版本：1.8 Scala版本：2.11.8 Linux版本：CentOS6.9 IDEA版本：2017.3 Kafka连接jar包：spark-streaming-kafka-0-10_2.11 (2.1.2) 每次重新...
Spark性能调优系列二：Spark流计算重要性能参数测试与分析
Laurence的技术博客
06-21 4634
参数介绍 spark.scheduler.mode spark.streaming.concurrentJobs scheduler线程池 测试用例 Test Case Group 1: FIFO vs. FAIR Test Case 1-1: FIFO Test Case 1-2: FAIR Test Case Group 2: FIFO 1 Slot vs. FIFO 4 Slo...
spark调优总结
玩转曼哈顿的博客
11-01 3062
  1.sparkseaming     从图上可以看到，Batch Interval的间隔是5s，也就是说每经过5s，SparkStreaming会将这5s内的信息封装成一个DStream,然后提交到Spark集群进行计算   1.1执行流程     第一个 DStream 里面是 0-5s 的数据，在第6s的时候会触发 DStream 的job执行，这时会另启动一个线程执行这...
最佳实践｜Apache Pulsar 在拉卡拉的技术实践
Apache Pulsar
05-07 611
关于 Apache PulsarApache Pulsar 是 Apache 软件基金会顶级项目，是下一代云原生分布式消息流平台，集消息、存储、轻量化函数式计算为一体，采用计算与存储分离架...
sparkstreaming调优
最新发布
07-29
针对 Spark Streaming 的调优，有以下几个方面可以考虑： 1. 资源调优：增加 Executor 内存、调整 Executor 数量等。可以通过增加 Executor 内存来提高处理速度和容量，但需要注意不要超过可用内存的限制。同时，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值