spark基于源码进行离线任务监控

最新推荐文章于 2024-02-21 18:06:17 发布
最新推荐文章于 2024-02-21 18:06:17 发布
阅读量342 收藏 1
点赞数 1
文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42359675/article/details/108483515
版权

import javax.mail.Authenticator;
import javax.mail.Message.RecipientType;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import java.util.Properties;

/**

  • Created by angel
    /
    public class MailUtil {
    /    *

    • args[0]:接收人邮箱，以‘,’连接
    • args[1]:邮件标题
    • args[2]:邮件内容
    • @param args
    • @throws Exception
      */

    //问题 Properties这个怎么获取 有一个DataStruct类
    public static void sendMail(Properties props, String[] args) throws Exception{

     if(args.length != 3){
     System.out.println("请输入三个参数：\nargs[0]：接收人邮箱，以‘,’连接；\nargs[1]：邮件标题；\nargs[2]：邮件内容。");
     return;
 }
 String reciveEmails = args[0];
 String title = args[1];
 String content = args[2];

 // 构建授权信息，用于进行SMTP进行身份验证
 Authenticator authenticator = new Authenticator() {
     @Override
     protected PasswordAuthentication getPasswordAuthentication() {
         // 用户名、密码
         String userName = "####@163.com";
         String password = "qwe123";
         return new PasswordAuthentication(userName, password);
     }
 };
 // 使用环境属性和授权信息，创建邮件会话
 Session mailSession = Session.getInstance(props, authenticator);
 // 创建邮件消息
 MimeMessage message = new MimeMessage(mailSession);
 // 设置发件人
 InternetAddress form = new InternetAddress(
         "###@163.com");
 message.setFrom(form);
 // 设置收件人  "xxx@xxx.com,xxx@xxx.com,xxx@xxx.com"
 InternetAddress[] internetAddressTo = new InternetAddress().parse(reciveEmails);
 message.setRecipients(RecipientType.TO, internetAddressTo);

 // 设置邮件标题
 message.setSubject(title);
 // 设置邮件的内容体
 message.setContent(content, "text/html;charset=UTF-8");
 // 发送邮件
 Transport.send(message);

    }

    public static void main(String[] args) {
    Properties properties = new Properties();
    properties.setProperty(“mail.host”,“smtp.163.com”);
    properties.setProperty(“mail.transport.protocol”, “smtp”);
    properties.setProperty(“mail.smtp.auth”,“true”);
    String[] str = new String[]{"###@163.com", “spark任务监控” , “测试==============”};
    try {
    MailUtil.sendMail(properties , str);
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
    }

import java.util
import java.util.Properties

import org.codehaus.jettison.json.JSONObject

/**

  • Created by angel

*/
object DataStruct {

/*转JSON/
def convertJson(tuples:(String , Any)*):JSONObject ={
tuples.foldLeft(new JSONObject()){
case (obj , (k,v)) => obj.put(k , v)
obj
}
}

/*转map/
def convertMap(tuples:(String , String)*): java.util.HashMap[String , String] ={
tuples.foldLeft(new util.HashMapString , String){
case (map , (k,v)) => map.put(k,v)
map
}
}

/*转properties/
def convertProp(tuples:(String , String)*):Properties = {
tuples.foldLeft(new Properties()){
case (prop , (k,v)) => prop.setProperty(k,v)
prop
}
}
}

import java.util.Properties
import javafx.scene.chart.NumberAxis.DefaultFormatter

import com.cartravel.common.MailUtil
import com.cartravel.loggings.Logging
import com.cartravel.utils.{DataStruct, GlobalConfigUtils}
import org.apache.spark._
import org.apache.spark.scheduler.{SparkListener, SparkListenerTaskEnd}
import org.json4s.DefaultFormats
import org.json4s.jackson.Json
import redis.clients.jedis.Jedis

/**

  • Created by angel
    */
    class SparkAppListener(conf:SparkConf) extends SparkListener with Logging{
    //获取redis的配置
    val defaultRedisConfig = “jedisConfig.properties”
    //redis的机器
    val jedis = new Jedis(“cdh1”)

override def onTaskEnd(taskEnd: SparkListenerTaskEnd): Unit = {
/**
* 1、taskMetrics 监控框架的性能分析
* 2、shuffle
* 3、task运行（input output的信息）
* 4、taskInfo
* */
//插入到那个库
jedis.select(2)
//获取当前时间
val currentTimestamp = System.currentTimeMillis()
//获取metrics
val metrics = taskEnd.taskMetrics

val taskMetricsMap = scala.collection.mutable.HashMap(
  "executorDeserializeTime" -> metrics.executorDeserializeTime ,//executor的反序列化时间
  "executorDeserializeCpuTime" -> metrics.executorDeserializeCpuTime ,//executor的反序列化的 cpu时间
  "executorRunTime" -> metrics.executorRunTime ,//executoor的运行时间
  "resultSize" -> metrics.resultSize , //结果集大小
  "jvmGCTime" -> metrics.jvmGCTime ,  //jvm GC时间
  "resultSerializationTime" -> metrics.resultSerializationTime , //result的序列化时间
  "memoryBytesSpilled" -> metrics.memoryBytesSpilled , //内存益写
  "diskBytesSpilled" -> metrics.diskBytesSpilled , //益写到磁盘是多少
  "peakExecutionMemory" -> metrics.peakExecutionMemory//executor的最大内存
)
//实现一个key
val taskMetricsKey = s"taskMetrics_${currentTimestamp}"
//直接使用map报错，所以使用json进行处理
jedis.set(taskMetricsKey , Json(DefaultFormats).write(taskMetricsMap))
//指定key的生病周期
jedis.expire(taskMetricsKey , 3600)


//####################shuffle监控#######
//shuffle 读写监控
val shuffleReadMetrics = metrics.shuffleReadMetrics
val shuffleWriteMetrics = metrics.shuffleWriteMetrics

val shuffleMap = scala.collection.mutable.HashMap(
  "remoteBlocksFetched" -> shuffleReadMetrics.remoteBlocksFetched ,//shuffle远程拉取数据块
  "localBlocksFetched" -> shuffleReadMetrics.localBlocksFetched ,
  "remoteBytesRead" -> shuffleReadMetrics.remoteBytesRead , //shuffle远程读取的字节数
  "localBytesRead" -> shuffleReadMetrics.localBytesRead ,
  "fetchWaitTime" -> shuffleReadMetrics.fetchWaitTime ,
  "recordsRead" -> shuffleReadMetrics.recordsRead , //shuffle读取的记录总数
  "bytesWritten" -> shuffleWriteMetrics.bytesWritten , //shuffle写的总大小
  "recordsWritte" -> shuffleWriteMetrics.recordsWritten , //shuffle写的总记录数
  "writeTime" -> shuffleWriteMetrics.writeTime
)

val shuffleKey = s"shuffleKey${currentTimestamp}"
jedis.set(shuffleKey , Json(DefaultFormats).write(shuffleMap))
jedis.expire(shuffleKey , 3600)


//####################input   output   写入和写出的字节数#######
val inputMetrics = metrics.inputMetrics
val outputMetrics = metrics.outputMetrics
val input_output = scala.collection.mutable.HashMap(
  "bytesRead" ->  inputMetrics.bytesRead ,//读取的大小
  "recordsRead" -> inputMetrics.recordsRead , //总记录数
  "bytesWritten" -> outputMetrics.bytesWritten ,//写的大小
  "recordsWritten" -> outputMetrics.recordsWritten//写的总大小
)
val input_outputKey = s"input_outputKey${currentTimestamp}"
jedis.set(input_outputKey , Json(DefaultFormats).write(input_output))
jedis.expire(input_outputKey , 3600)


//####################taskInfo#######
val taskInfo = taskEnd.taskInfo

val taskInfoMap = scala.collection.mutable.HashMap(
  "taskId" -> taskInfo.taskId ,
  "host" -> taskInfo.host ,
  "speculative" -> taskInfo.speculative , //推测执行
  "failed" -> taskInfo.failed ,//失败的
  "killed" -> taskInfo.killed ,//是否被杀死
  "running" -> taskInfo.running//是否在运行
)


val taskInfoKey = s"taskInfo${currentTimestamp}"
jedis.set(taskInfoKey , Json(DefaultFormats).write(taskInfoMap))
jedis.expire(taskInfoKey , 3600)

//如果taskInfo失败 则应该去报警
//####################邮件告警#######
if(taskInfo != null &&  taskEnd.stageAttemptId != -1){
  val reason: TaskEndReason = taskEnd.reason
  val errmsg = reason match{
    case kill : TaskKilledException => Some(kill.getMessage)
    case e: TaskFailedReason => Some(e.toErrorString)
    case e: ExceptionFailure => Some(e.toErrorString)
    case e:Exception => Some(e.getMessage)
    case _ => None
  }

  if(errmsg.nonEmpty){
    if(conf.getBoolean("enableSendEmailOnTaskFail" , false)){
      val args = Array(GlobalConfigUtils.getProp("mail.host") , s"spark监控任务:${reason}" , errmsg.get)
      val prop: Properties = DataStruct.convertProp(
        ("mail.host", GlobalConfigUtils.getProp("mail.host")),
        ("mail.transport.protocol", GlobalConfigUtils.getProp("mail.transport.protocol")),
        ("mail.smtp.auth", GlobalConfigUtils.getProp("mail.smtp.auth"))
      )
      
      MailUtil.sendMail(prop , args)
    }
  }

}

}
}

resource下的fairscheduler.xml


FAIR
10
10


FAIR
4
3


FAIR
1
3


FAIR
1
3

Spark引擎
import com.cartravel.bean._
import com.cartravel.utils.GlobalConfigUtils
import org.apache.spark.SparkConf
import org.apache.spark.sql.SparkSession

/**

  • Created by angel
    */
    object SparkEngine {
    def getSparkConf():SparkConf = {

    val sparkConf: SparkConf = new SparkConf()
    .set(“spark.worker.timeout” , GlobalConfigUtils.getProp(“spark.worker.timeout”))
    .set(“spark.cores.max” , GlobalConfigUtils.getProp(“spark.cores.max”))
    .set(“spark.rpc.askTimeout” , GlobalConfigUtils.getProp(“spark.rpc.askTimeout”))
    .set(“spark.task.maxFailures” , GlobalConfigUtils.getProp(“spark.task.maxFailures”))
    .set(“spark.driver.allowMutilpleContext” , GlobalConfigUtils.getProp(“spark.driver.allowMutilpleContext”))
    .set(“spark.serializer”, “org.apache.spark.serializer.KryoSerializer”)
    .set(“spark.sql.adaptive.enabled” , “true”)
    .set(“spark.streaming.kafka.maxRatePerPartition” , GlobalConfigUtils.getProp(“spark.streaming.kafka.maxRatePerPartition”))
    .set(“spark.streaming.backpressure.enabled” , GlobalConfigUtils.getProp(“spark.streaming.backpressure.enabled”))
    .set(“spark.streaming.backpressure.initialRate” , GlobalConfigUtils.getProp(“spark.streaming.backpressure.initialRate”))
    .set(“spark.streaming.backpressure.pid.minRate”,“10”)
    .set(“enableSendEmailOnTaskFail”, “true”)
    .set(“spark.buffer.pageSize” , “16m”)
    // .set(“spark.streaming.concurrentJobs” , “5”)
    .set(“spark.driver.host”, “localhost”)
    .setMaster(“local[*]”)
    .setAppName(“query”)
    sparkConf.set(“spark.speculation”, “true”)
    sparkConf.set(“spark.speculation.interval”, “300”)
    sparkConf.set(“spark.speculation.quantile”,“0.9”)
    sparkConf.set(“spark.streaming.backpressure.initialRate” , “500”)
    sparkConf.set(“spark.streaming.backpressure.enabled” , “true”)
    sparkConf.set(“spark.streaming.kafka.maxRatePerPartition” , “5000”)
    sparkConf.registerKryoClasses(
    Array(
    classOf[OrderInfo],
    classOf[Opt_alliance_business],
    classOf[DriverInfo],
    classOf[RegisterUsers] ,
    classOf[Reservation]
    )
    )
    sparkConf
    }
    def getSparkSession(sparkConf:SparkConf):SparkSession = {
    val sparkSession: SparkSession = SparkSession.builder()
    .config(sparkConf)
    //调度模式
    .config(“spark.scheduler.mode”, “FAIR”)
    .config(“spark.executor.memoryOverhead”, “512”)//堆外内存
    //邮件告警
    .config(“enableSendEmailOnTaskFail”, “true”)
    .config(“spark.extraListeners”, “com.cartravel.spark.SparkAppListener”)//TODO 离线
    .enableHiveSupport() //开启支持hive
    .getOrCreate()
    sparkSession.sparkContext.setLocalProperty(“spark.scheduler.pool”, “n1”)
    sparkSession
    }
    }

jedisConfig.properties的配置文件
#jedisCluster连接配置

#redisCluster实例地址
servers = cdh1:6379
#连接redisCluster实例超时时间
connectionTimeout = 300000
#读写redisCluster实例超时时间
soTimeout = 300000
#连接redisCluster实例重试次数
maxAttempts = 6

#jedis连接池配置
#连接池最大连接数
maxTotal = 200
#获取连接池连接最大等待时间(毫秒)
maxWaitMillis = 15000
#最大空闲连接数
maxIdle = 50
#最小空闲连接数
minIdle = 10
#对拿到的connection进行validateObject校验
testOnBorrow = false
#从连接池获取不到连接则阻塞
blockWhenExhausted = true
#连接对象后进先出
lifo = true
#归还连接到池时测试连接
testOnReturn = false
#测试连接池空闲的连接
testWhileIdle = true
#测试连接池空闲连接的时间间隔，testWhileIdle=true时生效
timeBetweenEvictionRunsMillis = 30000
#监控数据-键标识
cluster.key.monitor.dataProcess = MONITOR_DP
#监控数据有效期-单位秒
cluster.exptime.monitor = 86400

import com.typesafe.config.ConfigFactory

/**

  • Created by angel
    */
    //获取参数的一个工具
    class GlobalConfigUtils {

private def conf = ConfigFactory.load()
def heartColumnFamily = “MM”
val getProp = (argv:String) => conf.getString(argv)
}

object GlobalConfigUtils extends GlobalConfigUtils

resource下的application.conf的配置
hdfs.host=“hdfs://node01:8020/hfile/”
mail.smtp.auth=“true”
mail.host=“smtp.163.com”
mail.smtp.port=“587”
mail.user="####@163.com"
mail.transport.protocol=“smtp”
#设置的秘钥
mail.password=“qwe123”

import java.util
import java.util.Properties

import org.codehaus.jettison.json.JSONObject

/**

  • Created by angel

*/
object DataStruct {

/*转JSON/
def convertJson(tuples:(String , Any)*):JSONObject ={
tuples.foldLeft(new JSONObject()){
case (obj , (k,v)) => obj.put(k , v)
obj
}
}

/*转map/
def convertMap(tuples:(String , String)*): java.util.HashMap[String , String] ={
tuples.foldLeft(new util.HashMapString , String){
case (map , (k,v)) => map.put(k,v)
map
}
}

/*转properties/
def convertProp(tuples:(String , String)*):Properties = {
tuples.foldLeft(new Properties()){
case (prop , (k,v)) => prop.setProperty(k,v)
prop
}
}
}

package com.cartravel.loggings

import org.slf4j.LoggerFactory

/**

  • Created by angel
    */

trait Logging {
lazy val logger = LoggerFactory.getLogger(this.getClass)

def trace(message: => Any): Unit = {
if (logger.isTraceEnabled) {
logger.trace(message.toString)
}
}

def debug(message: => Any): Unit = {
if (logger.isDebugEnabled) {
logger.debug(message.toString)
}
}

def info(message: => Any): Unit = {
if (logger.isInfoEnabled) {
logger.info(message.toString)
}
}

def warn(message: => Any): Unit = {
logger.warn(message.toString)
}

def warn(message: => Any, t: Throwable): Unit = {
logger.warn(message.toString, t)
}

def error(message: => Any, t: Throwable): Unit = {
logger.error(message.toString, t)
}

def error(message: => Any): Unit = {
logger.error(message.toString)
}
}

一个奇怪的数据人
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【经验02】记录一次生产spark离线任务产生数据倾斜的问题处理
奋斗的阿杰的博客
05-09 156
记录一次生产spark离线任务产生数据倾斜的问题处理
pyspark写入mysql内存溢出_Spark开发-Spark内存溢出原因以及解决方式
weixin_30128407的博客
02-02 1302
Dpark内存溢出Spark内存溢出堆内内存溢出堆外内存溢出堆内内存溢出java.lang.OutOfMemoryError: GC overhead limit execeededjava.lang.OutOfMemoryError: Java heap space具体说明Heap size JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设...
spark 监听
weixin_47014745的博客
06-25 387
spark 监听 spark 提供了一系列整个任务生命周期中各个阶段变化的事件监听机制。通过这一机制可以在任务的各个阶段做一些自定义的各种动作。 SparkListener便是这些阶段的事件监听接口类，通过实现这个类中的各种方法便可实现自定义的事件处理动作。 如下是sparkListener的实现方法，可以通过下面的参数获取spark的数据 object SparkAppListener extends SparkListener with Logging{ //完成的job数量 p
spark任务在executor端的运行过程分析
cnmeimei的博客
07-04 1173
CoarseGrainedExecutorBackend 上一篇，我们主要分析了一次作业的提交过程，严格说是在driver端的过程，作业提交之后经过DAGScheduler根据shuffle依赖关系划分成多个stage，依次提交每个stage，将每个stage创建于分区数相同数量的Task，并包装成一个任务集，交给TaskSchedulerImpl进行分配。TaskSchedulerImpl则会根据SchedulerBackEnd提供的计算资源（executor），并考虑任务本地性，黑名单，调度池...
spark 内存溢出解决方法
baibaichenchen的博客
09-06 1224
1.map过程产生大量对象导致内存溢出 这种溢出的原因是单个map中产生了大量的对象导致的 例如:rdd.map(x=>for(i<-1 to 10000) yield i.tostring) 这个操作在rdd中，每个对象产生了10000个对象，肯定很容易产生内存溢出，针对这种问题，在不增加内存下， 通过减少每个task的大小，以便达到每个task 即使产生大量的对象execu...
Spark日志过大导致磁盘溢出问题解决方案
PowerMe
05-20 1398
一 问题背景 平台近期出现多次spark任务日志文件将磁盘打满，导致平台异常报警和任务失败的情况，这些任务包括Spark-Streaming任务和普通Spark任务。产生该问题的原因主要是： Spark-Streaming任务运行时间比较长，Executor和Driver进程产生的Spark系统日志数量很大；业务用户在应用代码中使用System.out.print等输出了大量的调试信息（曾有任务运行40分钟打满100G日志文件）。以上信息全部输出在Yarn Container日志路径下的stdout和std
离线任务平台 v1.0-源码.zip
02-26
2. **分布式系统**：了解如何设计和实现分布式任务调度，例如使用Zookeeper进行协调，或者基于Mesos或YARN的资源管理。 3. **数据处理框架**：可能会用到Apache Spark或Hadoop MapReduce等大数据处理框架，理解它们...
基于Spark的电影推荐系统源码.rar
04-11
最后，核心的推荐系统基于Spark平台，采用大数据处理技术进行实时或离线推荐计算。 二、Spark技术应用 Spark作为分布式计算框架，以其高效、易用和可扩展性在大数据领域广泛应用。在本推荐系统中，Spark主要承担...
基于Hadoop、Spark的大数据金融信贷风险控系统.zip
最新发布
03-06
4. 实时监控：通过Spark Streaming处理实时数据流，实时检测异常交易和潜在风险，及时发出预警。 5. 可视化分析：Spark的Shark或Spark SQL可以对接BI工具，如Tableau，生成直观的报表，帮助决策者理解风险状况。 6...
源码 spark shuffle service在中通的优化实践.docx
11-12
在中通快递的业务场景中，随着业务量的快速增长，传统的基于Hive+MapReduce的离线计算方式无法满足实时性和效率的需求。因此，中通快递在2021年底开始尝试将Hive计算迁移至Spark 2.3.2，以提升离线处理的速度和资源...
cdh6.3.2 离线安装5个所需文件及安装小笔记
04-25
9. **监控和维护**：安装完成后，使用Cloudera Manager监控集群状态，进行性能优化和故障排查。 在提供的文件名“cdh6.3.2离线安装flink”中，Flink是一个高速、分布式、状态ful的流处理框架。在CDH6.3.2中，可能...
big-whale:Spark、Flink等离线任务的调度以及实时任务的监控
05-13
Big Whale 巨鲸任务调度平台为美柚大数据研发的分布式计算任务调度系统，提供Spark、Flink等批处理任务的DAG调度和流处理任务的运行管理和状态监控，并具有Yarn应用管理、重复应用检测、大内存应用检测等功能。 服务基于Spring Boot 2.0开发，打包后即可运行。 概述 1.架构图 2.特性 基于SSH的脚本执行机制，部署简单快捷，仅需单个服务 基于Yarn Rest Api的任务状态同步机制，对Spark、Flink无版本限制 支持分布式 支持失败重试 支持任务依赖 支持复杂任务编排（DAG） 支持流处理任务运行管理和监控 支持Yarn应用管理 部署 1.准备 Java 1.8+ Mysql 5.1.0+ 下载项目或git clone项目 为解决 github README.md 图片无法正常加载的问题，请在hosts文件中加入相关域名解析规则，参考： 2.安装 创建
智慧出行Spark/Utils-实现Spark的内置离线监控(细粒度任务的监控和异常报警)---2.spark粒度监控实现
weixin_45154559的博客
07-18 425
啊
Spark 离线开发框架设计与实现
m0_66404702的博客
02-21 1363
最后，我们在使用离线开发框架回溯一个一年的串行任务中，代码的执行只需要 5 分钟左右，我们发现，不使用离线开发框架回溯的任务在最理想的情况下（即最短时间分配到资源、所有子任务均无失败情况、一次可以串行启动 365 天），需要的时间为 2.5 天，但使用离线开发框架回溯的任务，在最坏的情况下（即最长时间分配到资源，任务失败情况出现 10%），只需要 6 个小时就可完成，提效 90% 以上，且基本无需人力关注。在日常的数据仓库开发工作中，我们除了开发工作外，也涉及大量的数据回溯任务。
Spark内存管理之Execution内存管理
pre_tender的博客
10-04 515
文章目录概述1. 多任务间的分配2. Shuffle的内存占用2.1 Shuffle Write对内存的使用2.2 Shuffle Read对内存的使用2.3 溢写：处理shuffle执行内存不足2.4 Tungsten介绍总结致谢 概述 以Shuffle的临时数据存储为例，介绍执行内存的使用。 在Spark内存管理之堆内/堆外内存原理详解一文中，我们可以知道，无论是on-heap还是off-he...
[Spark]二Spark性能调优|Spark任务监控|程序调优|资源调优
胖胖的博客
10-20 1162
对Spark性能的调优离不开对任务的监控，只有在运行过程中，通过监控手段发现问题，才能迅速定位问题所在。SparkUI使用在运行Spark应用程序时，默认会在Driver节点的4040端口启动WebUI服务，通过此WebUI可对Spark的应用程序的Job划分、Stage划分、Task执行缓存的使用等各个方面进行了监控。在执行Shuffle操作时，Map端使用ExternalSorter对数据进行分组，按分区排序，如果内存不足，则会将内存中的数据写入磁盘，为后续数据迭代留出内存空间。
Spark Shuffle模块详解
晓晓的天空
03-17 1171
Spark Shuffle模块详解
深入理解Spark 2.1 Core （十一）：Shuffle Reduce 端的原理与源码分析
02-24 4057
http://blog.csdn.net/u011239443/article/details/56843264 在《深入理解Spark 2.1 Core （九）：迭代计算和Shuffle的原理与源码分析 》我们讲解了，以传统Hadoop MapReduce类似的从HDFS中读取数据，再到rdd.HadoopRDD.compute便可以调用函数f，即map中的函数的过程。在《深入理解Spark ...
Spark 源码分析之ShuffleMapTask内存数据Spill和合并
weixin_33928137的博客
12-14 243
Spark 源码分析之ShuffleMapTask内存数据Spill和合并 更多资源分享 SPARK 源码分析技术分享(视频汇总套装视频): https://www.bilibili.com/video/av37442139/ github: https://github.com/opensourceteams/spark-scala-maven ...
基于Spark的实时与离线数据分析：Hadoop与日志应用
首先，作者构建了一个基于Hadoop平台的网站日志数据分析系统，这个系统利用HDFS存储海量数据，并通过Hadoop的MapReduce框架进行离线分析，提供可靠的数据处理能力。同时，Spark Streaming被应用于实时数据处理，它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值