大数据之Spark（二）

最新推荐文章于 2024-11-17 21:07:59 发布
最新推荐文章于 2024-11-17 21:07:59 发布
阅读量1.1k 收藏 17
点赞数 30
分类专栏： 大数据 文章标签： 大数据 spark 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wslzoooo/article/details/142165460
版权
9.4.3、RDD持久化

RDD之间进行相互迭代计算（Transformation的转换），当执行开启，新RDD的生成代表旧RDD消失。如果有的rdd需要重复使用就需要将rdd缓存，rdd.cache()或rdd.persist()。清理缓存rdd.unpersist()

在这里插入图片描述

缓存特点（分散存储）：保留rdd之间的血缘关系

from pyspark import  SparkConf,SparkContext
from pyspark.storagelevel import StorageLevel
if __name__ == '__main__':
    conf = SparkConf().setMaster("local[*]").setAppName("test")
    sc = SparkContext(conf=conf)
    #单机对象转分布式对象
    rdd1 = sc.textFile("../../data/input/words.txt")
    rdd2 = rdd1.flatMap(lambda x: x.split(" "))
    rdd3 = rdd2.map(lambda x: (x, 1))
    rdd4 = rdd3.reduceByKey(lambda a, b: a + b)
    print(rdd4.collect())

    rdd3.cache()
    #或者使用
    rdd3.persist(StorageLevel.MEMORY_AND_DISK)
    rdd5 = rdd3.groupByKey()
    rdd6 = rdd5.mapValues(lambda x: sum(x))
    print(rdd6.collect())
    rdd3.unpersist()

checkpoint仅支持硬盘存储，设计认为安全不保留血缘关系

在这里插入图片描述

checkpoint存储rdd数据是收集各个分区数据在HDFS上进行集中存储，而缓存是分散存储

from pyspark import  SparkConf,SparkContext
from pyspark.storagelevel import StorageLevel
if __name__ == '__main__':
    conf = SparkConf().setMaster("local[*]").setAppName("test")
    sc = SparkContext(conf=conf)
    #单机对象转分布式对象
    sc.setCheckpointDir("hdfs://hadoop100:8020/output/ckp")
    rdd1 = sc.textFile("../../data/input/words.txt")
    rdd2 = rdd1.flatMap(lambda x: x.split(" "))
    rdd3 = rdd2.map(lambda x: (x, 1))
    rdd3.checkpoint()
    rdd4 = rdd3.reduceByKey(lambda a, b: a + b)
    print(rdd4.collect())


    
    rdd5 = rdd3.groupByKey()
    rdd6 = rdd5.mapValues(lambda x: sum(x))
    print(rdd6.collect())
、共享变量
9.4.4.1、广播变量

将Driver上的本地变量广播到Excutor分区进行重复使用，广播变量会避免内存浪费和网络IO

from pyspark import  SparkConf,SparkContext
from pyspark.storagelevel import StorageLevel
if __name__ == '__main__':
    conf = SparkConf().setMaster("local[*]").setAppName("test")
    sc = SparkContext(conf=conf)
    stu_info_list=[
        (1,'zhangsan',11),
        (2,'lisi',13),
        (3,'wangwu',12),
        (4,'zhaoliu',11)
    ]
    broadcast = sc.broadcast(stu_info_list)
    rdd = sc.parallelize(
        [(1, "yuwen", 99), (2, 'shuxue', 99), (3, 'yingyu', 99), (4, 'baincheng', 99), (1, "yuwen", 99),
         (2, 'shuxue', 99), (3, 'yingyu', 99), (4, 'baincheng', 99), (1, "yuwen", 99), (2, 'shuxue', 99),
         (3, 'yingyu', 99), (4, 'baincheng', 99), (1, "yuwen", 99), (2, 'shuxue', 99), (3, 'yingyu', 99),
         (4, 'baincheng', 99), ])
    def map_func(data):
        id=data[0]
        for stu_info in broadcast.value:
            stu_id=stu_info[0]
            if id==stu_id:
                name=stu_info[1]
        return (name ,data[1],data[2])
    print(rdd.map(map_func).collect())
9.4.4.2、累加器

普通变量无法实现在分布式下累加，通过 sc.accumulator()创建累加器

from pyspark import  SparkConf,SparkContext
from pyspark.storagelevel import StorageLevel
if __name__ == '__main__':
    conf = SparkConf().setMaster("local[*]").setAppName("test")
    sc = SparkContext(conf=conf)
    rdd = sc.parallelize([1, 4, 8, 2, 7, 8, 2, 5], 2)
    sc_accumulator = sc.accumulator(0)
    def map_func(data):
        global sc_accumulator
        sc_accumulator+=1
        print(sc_accumulator)

    rdd.map(map_func).collect()
    print(sc_accumulator)
9.4.5、Spark内核调度
9.4.5.1、DAG

DAG——有向无环图。

Job与Action：

  • Action返回值不是RDD算子，其作用是一个触发开关将rdd链条执行起来
  • 一个应用程序会产生多个Job，每个Job对应一个Action（如：collect （））
    在这里插入图片描述
    每个rdd链条对应一个Job，每个rdd链条（job）可以看做一个DAG，多个job合并为一个应用，每个job又分成多个stage。
    在这里插入图片描述
    结论：1个Action=1个DAG=1个JOB
9.4.5.2、DAG的宽窄依赖和阶段划分

在RDD前后之前的关系分为：窄依赖和宽依赖

窄依赖：父rdd的一个分区将全部数据发给子rdd的一个分区（一对一）
在这里插入图片描述
宽依赖（shuffle）：父rdd的一个分区将数据发给子rdd的多个分区（一对多）
在这里插入图片描述
宽窄依赖用来划分阶段

划分依据：从后向前，遇到宽依赖就划分出一个阶段，称为stage。所以在stage内部一定是窄依赖。
在这里插入图片描述

9.4.5.3、内存迭代计算

Spark默认受到全局并行度的限制，不推荐在算子上设置并行度，否则会导致shuffle（产生网络IO），影响性能。

9.4.5.4、Spark并行度

同一时间内task同时运行的数量为并行度。在有了6个task并行的前提下，rdd分区就被规划成6个分区。并行度会影响分区。先有并行度后有分区。

并行度设置

  • 设置全局并行度（推荐）

    修改配置文件：

    conf/spark-defaults.conf中设置
spark.defaults.parallelism 100

    在客户端提交参数

    bin/spark-submit --conf "spark.defaults.parallelism=100"

    在代码中设置

    conf=SparkConf()
conf.set("spark.defaults.parallelism","100")

  • 针对rdd单独设置并行度（不推荐）

并行度规划

并行度设置为核心数的2-10倍。防止task压力不均衡会导致CPU空闲。将并行度提高，就提高了分区数，将大的任务分解成小任务，最大化利用资源。

9.4.5.4、Spark任务调度

Spark的任务由Driver进行调度，包含：

  1. 逻辑DAG产生
  2. 分区DAG产生
  3. Task划分
  4. 将Task分配给Executor并监控其工作

调度流程如图：
在这里插入图片描述
具体流程：

  1. 构建Driver
  2. 构建SparkContext
  3. 基于DAG Scheduler（DAG调度器）构建逻辑Task分配
  4. 基于TaskScheduler（Task调度器）将逻辑Task分配到各个Executor上干活并监控
  5. Worker（Executor）被TaskScheduler管理监控，听从其指令干活并定期汇报进度

其中，1,2,3,4都是的Driver的工作，5是Worker的工作

Driver内两个组件：

  • DAG调度器：将逻辑DAG图进行处理得到逻辑上的Task划分
  • Task调度器：基于DAG Scheduler的产出来规划这些逻辑Task应该在哪些物理的Executor上运行，并监控管理它们

总结：
在这里插入图片描述

9.5、Spark SQL

特点：

  1. 无缝集成SQL
  2. 可读写不同数据源
  3. Hive兼容
  4. 标准化连接
9.5.1、概述

Spark与Hive对比
在这里插入图片描述
数据抽象：RDD、DataFrame（二维表数据结构）

SparkSession：在rdd中，程序执行入口对象是SparkContext。SparkSession可用于SparkSQL入口对象，也可用于SparkCore中获取SparkContext

helloworld测试

txt文件

1,shuxue,99
2,shuxue,99
3,shuxue,9
4,shuxue,99
5,shuxue,88
6,shuxue,77
1,yuwen,5
2,yuwen,44
3,yuwen,6
4,yuwen,3
5,yuwen,6
6,yuwen,3

代码

from pyspark.sql import SparkSession
if __name__ == '__main__':
    spark_session = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark_session.sparkContext
    df = spark_session.read.csv("../../data/input/stu_score.txt", sep=",", header=False)
    df2 = df.toDF("id", "name", "score")
    df.printSchema()
    df2.show()
    view = df2.createTempView("score")
    spark_session.sql("select * from score where  id=1").show()
9.5.2、DataFrame
9.5.2.1、组成

二维表结构，row行，column列

结构层面：StructType描述表结构，StructField描述列信息
在这里插入图片描述

9.5.2.2、创建

  1. rdd转DataFrame

    txt

    lilei,29
zhaosi,22
wangwu,11

    方法1：代码

    from pyspark.sql import SparkSession
if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    rdd = sc.textFile("../../data/input/people.txt").\
        map(lambda  x:x.split(",")).\
        map(lambda x:(x[0],int(x[1])))
    df = spark.createDataFrame(rdd, schema=['name', 'age'])
    df.printSchema()
    df.show()

    方法2：代码

    from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    rdd = sc.textFile("../../data/input/people.txt").\
        map(lambda  x:x.split(",")).\
        map(lambda x:(x[0],int(x[1])))
    schema = StructType().add("name", StringType(), nullable=True).add("age", IntegerType(), nullable=False)
    df = spark.createDataFrame(rdd, schema=schema)
    df.printSchema()
    df.show()

    方法3：代码

    from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    rdd = sc.textFile("../../data/input/people.txt").\
        map(lambda  x:x.split(",")).\
        map(lambda x:(x[0],int(x[1])))
    #方式1：
    df = rdd.toDF(["name", "age"])
    df.printSchema()
    df.show()
    #方式2
    schema = StructType().add("name", StringType(), nullable=True).add("age", IntegerType(), nullable=False)
    df1 = rdd.toDF(schema=schema)
    df1.printSchema()
    df1.show()

    方法4：代码

    from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd

if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    pdf = pd.DataFrame({"id": [1, 2, 3], "name": ["zhangsan", "lisi", "wangwu"], "age": [11, 33, 44]})
    schema = StructType().add("id",IntegerType(), nullable=False).add("name", StringType(), nullable=True).add("age", IntegerType(), nullable=False)
    df = spark.createDataFrame(pdf, schema)
    df.printSchema()
    df.show()

  2. 读取外部数据

    通过SparkSQL的统一API进行数据读取构建DataFrame，text数据源文件读取数据将一整行只作为一个列读取，默认列名是value，类型是String

    from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd

if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    schema = StructType().add("data",StringType(), nullable=False)
    df = spark.read.format("text").schema(schema=schema).load("../../data/input/people.txt")
    df.printSchema()
    df.show()

    结果：
    在这里插入图片描述

  3. 读取json数据源，json自带schema信息

    from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd

if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    df = spark.read.format("json").load("../../data/input/people.json")
    df.printSchema()
    df.show()

    读取csv数据源

    from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd

if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    df = spark.read.format("csv").option("seq",",").option("header",True).option("encoding","UTF-8").schema("name STRING,age INT,job STRING").load("../../data/input/people.csv")
    df.printSchema()
    df.show()

    读取parquet数据源，parquet是Spark常用的列存储文件格式

    from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd

if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    df = spark.read.format("parquet").load("../../data/input/people.parquet")
    df.printSchema()
    df.show()
9.5.2.3、编程

两种风格：DSL（领域特定语言）、SQL

DSL

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd


if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    rdd = sc.textFile("../../data/input/people.txt").\
        map(lambda  x:x.split(",")).\
        map(lambda x:(x[0],int(x[1])))
    df = spark.createDataFrame(rdd, schema=['name', 'age'])
    #DSL
    df.select('name').show()
    #过滤 filter=where
    df.filter("age<50").show()
    df.where(df['age']<22).show()

SQL

只要将DataFrame注册成一个视图或表即可

df.createOrReplaceTempView("people")#临时表，如果存在则替换
df.createTempView("people")#临时视图
df.createGlobalTempView("people")#注册全局表

全局表：跨SparkSession对象使用，在一个程序内的多个SparkSession中均可调用，查询带上前缀global_temp.

临时表：只在当前SparkSession可用

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd
if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    rdd = sc.textFile("../../data/input/people.txt").\
        map(lambda  x:x.split(",")).\
        map(lambda x:(x[0],int(x[1])))
    df = spark.createDataFrame(rdd, schema=['name', 'age'])
    df.createTempView("people")  # 临时视图
    df.createOrReplaceTempView("people1")#临时表，如果存在则替换
    df.createGlobalTempView("people2")#注册全局表
    spark.sql("select name from people").show()
    spark.sql("select age from global_temp.people2").show()

词频统计

text

hello hadoop
hello spark
hello spark
hello flink

代码

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd
from pyspark.sql import functions as F
if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    #SQL
    rdd = sc.textFile("../../data/input/words.txt").\
        flatMap(lambda  x:x.split(" ")).\
        map(lambda x:[x])
    df = rdd.toDF(["word"])
    df.createTempView("words")
    spark.sql("select word,count(*) as cnt from words group by word order by cnt desc").show()
    #DSL
    df = spark.read.format("text").load("../../data/input/words.txt")
    #withColumn方法
    #对已经存在的列进行操作返回新的列，如名字和旧列相同则替换，否则作为新列
    df2 = df.withColumn("value", F.explode(F.split(df['value'], " ")))
    df2.groupBy('value').count().withColumnRenamed("value","word").withColumnRenamed("count","cnt").orderBy("cnt",ascending=False).show()

SparkSQL中当job中产生shuffle时，默认的分区数（spark.sql.shuffle.partitons）为200，项目中要合理设置
在这里插入图片描述
异常数据处理

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd

if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    df = spark.read.format("csv").option("seq",",").option("header",True).option("encoding","UTF-8").load("../../data/input/people.csv")
    #行数据去重
    df.dropDuplicates().show()
    #针对某列去重
    df.dropDuplicates(['age','job']).show()
    #缺失值处理
    #缺失值该行删除
    df.dropna().show()
    #每行三个有效值
    df.dropna(thresh=3).show()
    #参数列中每行要有两个有效值
    df.dropna(thresh=2,subset=['age','job']).show()
    #缺失值填充"kong"
    df.fillna("kong").show()
    #针对列进行填充
    df.fillna("N/A",subset=['job']).show()
    #用字典设置默认填充
    df.fillna({"name":"unkown","age":1,"job":"dev"}).show()

DataFrame数据写出统一API

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd
from pyspark.sql import functions as F
if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    df = spark.read.format("csv").option("seq",",").option("header",True).option("encoding","UTF-8").load("../../data/input/people.csv")
    df.show()
    df.select(F.concat("name","age","job")).write.mode("overwrite").format("text").save("../../data/output/text")
    df.write.mode("overwrite").format("csv").option("seq",",").option("header",True).save("../../data/output/csv")
    df.write.mode("overwrite").format("json").save("../../data/output/json")
    #默认写出parqeut格式
    df.write.mode("overwrite").save("../../data/output/parqeut")

写入到MySQL,jdbc会自动建表

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd
from pyspark.sql import functions as F
if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    df = spark.read.format("csv").option("seq",",").option("header",True).option("encoding","UTF-8").load("../../data/input/people.csv")
    df.show()
    df.write.mode("overwrite").format("jdbc")\
        .option("url","jdbc:mysql://127.0.0.1:3306/dalian5?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true&autoReconnect=true")\
        .option("dbtable","spark")\
        .option("user","root") \
        .option("password", "123")\
        .save()

读取MySQL数据

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StringType,IntegerType
import pandas as pd
from pyspark.sql import functions as F
if __name__ == '__main__':
    spark = SparkSession.builder.appName("test").master("local[*]").getOrCreate()
    sc = spark.sparkContext
    df = spark.read.format("csv").option("seq",",").option("header",True).option("encoding","UTF-8").load("../../data/input/people.csv")

    # df.write.mode("overwrite").format("jdbc")\
    #     .option("url","jdbc:mysql://127.0.0.1:3306/dalian5?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true&autoReconnect=true")\
    #     .option("dbtable","spark")\
    #     .option("user","root") \
    #     .option("password", "123")\
    #     .save()
    spark.read.format("jdbc")\
        .option("url","jdbc:mysql://127.0.0.1:3306/dalian5?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true&autoReconnect=true")\
        .option("dbtable","spark")\
        .option("user","root") \
        .option("password", "123")\
        .load().show()
9.5.3、SparkSQL的运行流程
9.5.3.1、Catalyst优化器

SparkSQL相比于rdd可以实现自动优化，优化器Catalyst
在这里插入图片描述

  1. API层接收SQL语句
  2. Catalyst解析SQL并生成执行计划
  3. Catalyst输出是rdd的执行计划
  4. 集群执行

Catalyst优化器具体流程：
在这里插入图片描述
5. 解析SQL并生成AST（抽象语法树）
6. 在AST中加入元数据信息
7. 对已经加入元数据的AST输入优化器进行优化
8. 上述逻辑计划结束后，生成物理计划，从而生成rdd来运行

9.5.3.2、SparkSQL的执行流程
  1. 提交SparkSQL代码
  2. Catalyst优化
  3. Driver执行环境入口构建（SparkSession）
  4. DAG调度器规划逻辑任务
  5. Task调度器分配逻辑任务到具体的Executor上工作并监控、管理任务
  6. Worker干活

9.6、Spark on Hive

Spark借用Metastore服务实现元数据管理的功能
在这里插入图片描述

大数据｜Spark介绍
知识库搭建ing
05-18 8784
park为了解决以往分布式计算框架存在的一些问题(重复计算、资源共享、系统组合)，提出了一个分布式数据集的抽象数据模型：RDD(Resilient Distributed Datasets)弹性分布式数据集。
大数据之Spark入门案例
weixin_43339889的博客
04-09 579
PySpark入门案例
大数据之spark详解
scfvlog的博客
10-30 1394
Spark 是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。属于mapreduce的加强版本，结合了其优点而且spark是可以将数据保存在内存中。从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的map reduce的算法。平台上针对实时数据进行流式计算的组件，提供了丰富的处理。出现的时间相对较晚，并且主要功能主要是用于数据计算，平台上针对实时数据进行流式计算的组件，提供了丰富的。额外的功能，还提供了一些更底层的机器学习原语。语言开发的快速、通用、可扩展的。
大数据之spark
qq_73801124的博客
03-04 1371
Apache Spark™是一个多语言引擎，用于在单节点机器或集群上执行数据工程、数据科学和机器学习。Spark最初由美国加州大学伯克利分校的。
大数据之Spark:Spark 基础
weixin_43597208的博客
05-17 1748
目录1、Spark 发展史2、 Spark 为什么会流行 1、Spark 发展史 2009 年诞生于美国加州大学伯克利分校 AMP 实验室； 2014 年 2 月，Spark 成为 Apache 的顶级项目； Spark 成功构建起了一体化、多元化的大数据处理体系。在任何规模的数据计算中， Spark 在性能和扩展性上都更具优势； 在 FullStack 理想的指引下，Spark 中的 Spark SQL 、SparkStreaming 、MLLib 、GraphX 、R 五大子框架和库之间可以无缝地共享数
09.大数据技术之Spark
wzb1983的博客
07-13 8874
Spark是一种快速、通用、可扩展的大数据分析引擎，2009年诞生于加州大学伯克利分校AMPLab，2010年开源，2013年6月成为Apache孵化项目，2014年2月成为Apache顶级项目。项目是用Scala进行编写。 目前，Spark生态系统已经发展成为一个包含多个子项目的集合，其中包含SparkCore、SparkSQL、Spark Streaming、GraphX、MLib、SparkR等子项目，Spark是基于内存计算的大数据并行计算框架。除了扩展了广泛使用的 MapReduce 计算模型，而
大数据之spark_spark简介
WuBoooo的博客
09-16 4532
什么是Spark Spark是一种快速、通用、可扩展的大数据分析引擎，2009年诞生于加州大学伯克利分校AMPLab，2010年开源，2013年6月成为Apache孵化项目，2014年2月成为Apache的顶级项目，2014年5月发布spark1.0，2016年7月发布spark2.0，2020年6月18日发布spark3.0.0 Spark的特点 Speed：快速高效 Hadoop的MapReduce作为第一代分布式大数据计算引擎，在设计之初，受当时计算机硬件条件所限（内存、磁盘、cpu等），为了能
大数据_Spark常见组件
日积月累，水滴石穿
09-04 1511
它还会将所有的 Spark 操作转换为 DAG 运算，并负责调度，还要将这些计算分成任务分发到 Spark 执行器上。因为集群管理器不需要知道它实际在哪里运行（只要能管理Spark 的执行器，并满足资源请求就行），所以Spark 可以部署在 Apache Hadoop YARN 和Kubernetes 等一些常见环境中，并且以不同的模式运行。出于数据本地性要求，在分配任务时，根据要读取的数据分区与各Spark 执行器在网络上的远近，最好将任务分配到最近的 Spark 执行器上。分区可以实现高效的并行执行。
大数据Spark框架概述
赵广陆
05-04 6692
目录1 Spark 是什么2 Spark 四大特点2.1 速度快2.2 易于使用2.3 通用性强2.4 运行方式3 Spark 框架模块3.1 Spark Core3.2 Spark SQL3.3 Spark Streaming3.4 Spark MLlib3.5 Spark GraphX3.6 Structured Streaming4 Spark 运行模式 1 Spark 是什么 Spark 是加州大学伯克利分校AMP实验室（Algorithms Machines and People Lab）开发的
【图解大数据技术】Spark
weixin_43889578的博客
07-13 1082
Spark与MapReduce一样，也是大数据计算框架。Spark相比MapReduce拥有更快的执行速度和更低的编程复杂度。Spark Core：封装了Spark的基本功能，比如RDD、任务调度等。Spark SQL：Spark SQL可以处理结构化数据，当我们遇到结构化数据的计算时，可以使用Spark SQL，它允许我们把数据集映射为表结构，然后像操作关系型数据库的库表一样操作Spark SQL的表。
大数据技术之Spark
m0_57126939的博客
04-12 1646
1.1回顾：Hadoop主要解决，海量数据的存储和海量数据的分析计算。Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。Hadoop的Yarn框架比Spark框架诞生的晚，所以Spark自己也设计了一套资源调度框架。区别1、MR是基于磁盘，spark是基于内存2、MR的task是进程3、spark的task是线程，在executor进程里执行的线程。4、MR在Container里执行（留有接口方便插入），spark在worker里执行（自己用，没有接口）。
大数据入门spark3.0入门到精通Spark-day06.rar
02-21
2021贺岁大数据入门spark3.0入门到精通资源简介： 本课程中使用官方在2020年9月8日发布的Spark3.0系列最新稳定版：Spark3.0.1。共课程包含9个章节：Spark环境搭建，SparkCore，SparkStreaming，SparkSQL，...
大数据入门spark3.0入门到精通 1-8day 代码-笔记.zip
02-21
2021贺岁大数据入门spark3.0入门到精通资源简介： 本课程中使用官方在2020年9月8日发布的Spark3.0系列最新稳定版：Spark3.0.1。共课程包含9个章节：Spark环境搭建，SparkCore，SparkStreaming，SparkSQL，...
Flink升级程序和版本
chanyue123的博客
11-15 168
讲解如何升级flink程序和flink框架版本
大数据应用开发——实时数据处理（二）
谁呛我名字的博客
11-14 195
大数据应用开发——实时数据采集大数据应用开发——实时数据处理Flink完成Kafka中的数据消费，将数据分发至Kafka的dwd层中hadoop，zookeeper，kafka，flink，hbase要开启目录并在HBase中进行备份。
计算机毕业设计Python+Neo4j知识图谱医疗问答系统 大模型 机器学习 深度学习 人工智能 大数据毕业设计 Python爬虫 Python毕业设计
全网粉丝10W+、全栈领域优质创作者、掘金、阿里云等社区博客专家、专注于全栈领域和毕业项目实战
11-14 1563
计算机毕业设计Python+Neo4j知识图谱医疗问答系统 大模型 机器学习 深度学习 人工智能 大数据毕业设计 Python爬虫 Python毕业设计
如何保证RabbitMQ的可靠性传输
m0_74312445的博客
11-13 1405
默认情况下，消费端取回消息后，默认会自动返回ACK确认消息，所以在前面的测试中消息被消费端消费之后，RabbitMQ得到ACK确认信息就会删除消息。但实际开发中，消费端根据消息队列投递的消息执行对应的业务，未必都能执行成功，如果希望能够多次重试，那么默认设定就不满足要求了。消费者异常，消息还没到消费者，比如说消费者宕机，消费逻辑有问题。生产者端发送消息之后，回调confirm()方法。，因为原交换机转入备份交换机时并不会指定路由键。代码或者配置层错误，导致路由是失败。队列也是有一些特性：长度，有效期。
大数据-222 离线数仓 - 数仓 数仓模型 事实表 维度表 雪花模型 事实星座 元数据
永远好奇，无限进步！
11-13 2379
但是它们之间也有着不同，周期快照事实记录的确定的周期的数据，而积累快照事实记录的不确定的周期的数据。事实数据通常包含大量的行，事实数据表的主要特点是包含数字数据（事实），并且这些数字信息可以汇总，以提供有关单位作为历史的数据，事实表的粒度决定了数据仓库中数据的详细程度。在大数据平台中，元数据贯穿大数据平台数据流动的全过程，主要包括数据源元数据、数据加工处理过程元数据、数据主题专题库元数据、服务层元数据、应用层元数据等。事务事实表记录的事务层面的事实，保存的是最原子的数据，也称为“原子事实表”。
vmWare虚拟环境centos7安装Hadoop 伪分布式实践
最新发布
keep_learn的专栏
11-17 699
背景：近期在研发大数据中台，需要研究Hadoop hive 的各种特性，需要搭建一个Hadoop的虚拟环境，本来想着使用dock ，但突然发现docker 公共仓库的镜像 被XX 了，无奈重新使用vm 搭建虚拟机。大概经历了6个小时完成hadoop 3.3.6 环境的搭建，分享步骤给大家，需要搭建好的虚拟机镜像私信联系，提供百度网盘下载链接。(需要请一杯奶茶)。操作系统版本：centos 7本次实践实践2024年，未来2年内有效。
Python大数据之Spark编程基础与提升视频课程
Python大数据之Spark编程基础与提升视频课程课件PPT模板.pptx是一份15页的PPT文档，分为6个章节和一个附录。第一章到第四章分别是spark入门、spark数据预处理与分析、spark机器学习之特征提取和spark机器学习之核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

空指针异常Null_Point_Ex

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值