pysqark

pyspark连接spark的配置，spark连接有sparkcontext和sparksession这两种方式，同时这两种方式之间可以互相转换，连接代码如下：

通过SparkConf和SparkContext连接

SparkContext 是通往 Spark 集群的唯一入口，可以用来在 Spark 集群中创建 RDDs 、累加和广播变量( BroadcastVariables )。

SparkContext 的核心作用是初始化 Spark 应用程序运行所需要的核心组件，包括高层调度器( DAGScheduler )、底层调度器( TaskScheduler )和调度器的通信终端( SchedulerBackend )，同时还会负责 Spark 程序向 Master 注册程序等。

只可以有一个 SparkContext 实例运行在一个 JWM 内存中，所以在创建新的 SparkContext 实例前，必须调用 stop 方法停止当前 JVM 唯一运行的 SparkContext 实例。

from pyspark.sql import SparkSession

spark_host = "spark://spark-master:7077"  # spark集群的地址，如果是本地单机版的，设置为local[x]，x为使用的核数，单机版的即为线程数
app_name = "test"

# 设置连接配置，这里的1g是设置使用的核数
spark_conf = SparkConf().setMaster(spark_host).setAppName(app_name).set("spark.executor.memory", "1g")
spark_context = SparkContext.getOrCreate(conf=spark_conf)

 
spark_session = SparkSession.builder.master(spark_host).appName(app_name).getOrCreate()

 pyspark连接hbase

配置 HBase 连接: 你需要配置一个 Configuration 对象，其中包含了连接到 HBase 所需的配置信息，如 HBase 集群地址、表名、列族等。

创建 StructType 对象，定义 RDD 中数据的结构

# 定义 keyConverter 和 valueConverter 函数，用于将 HBase 中的 key 和 value 转换为 Spark 中的格式

from pyspark.sql.types import StructType, StructField, StringType
from pyspark.sql.functions import udf

# 定义 keyConverter 和 valueConverter 函数，用于将 HBase 中的 key 和 value 转换为 Spark 中的格式
keyConv = udf(lambda k: str(k), StringType())
valueConv = udf(lambda v: str(v), StringType())

# 创建 Configuration 对象
conf = spark.sparkContext._conf.set("hbase.zookeeper.quorum", "hbase-host:port")
conf = conf.set("hbase.mapred.output.outputtable", "table_name")
conf = conf.set("hbase.columns.mapping", "cf1:c1,cf1:c2")
conf = conf.set("hbase.mapreduce.inputtable", "table_name")
conf = conf.set("hbase.mapreduce.input.row.start", "row_start")
conf = conf.set("hbase.mapreduce.input.row.stop", "row_stop")
conf = conf.set("hbase.mapreduce.scan.cacheblocks", "true")
conf = conf.set("hbase.mapreduce.scan.caching", "500")
conf = conf.set("hbase.mapreduce.scan.row.start", "row_start")
conf = conf.set("hbase.mapreduce.scan.row.stop", "row_stop")

# 创建 StructType 对象，定义 RDD 中数据的结构
structType = StructType([
    StructField("key", StringType(), True),
    StructField("value", StringType(), True)
])

使用 newAPIHadoopRDD 方法创建一个 HBase RDD。你需要提供 HBase 的输入格式、key 和 value 的类，以及一个转换器函数，用于将 HBase 中的 key 和 value 转换为 Spark 中的格式。

hbase_df = hbase_rdd.toDF("key", "value")

# pysaprk连接hbase目前只能通过sparkContext对象，所以这里用的前面设置的spark_context
hbase_rdd = spark_context.newAPIHadoopRDD(
    "org.apache.hadoop.hbase.mapreduce.TableInputFormat",
    "org.apache.hadoop.hbase.io.ImmutableBytesWritable",
    "org.apache.hadoop.hbase.client.Result",
    keyConverter=keyConv,
    valueConverter=valueConv,
    conf=conf,
)

# 如果想通过sparkSesssion对象连接hbase，代码如下
hbase_rdd = spark_session.SparkContext.newAPIHadoopRDD(
    "org.apache.hadoop.hbase.mapreduce.TableInputFormat",
    "org.apache.hadoop.hbase.io.ImmutableBytesWritable",
    "org.apache.hadoop.hbase.client.Result",
    keyConverter=keyConv,
    valueConverter=valueConv,
    conf=conf,
)

 RDD

Resilient Distributed Dataset

弹性分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD是spark core的底层核心。

Dataset:

• RDD 可以不保存具体数据, 只保留创建自己的必备信息, 例如依赖和计算函数；
• RDD 也可以缓存起来, 相当于存储具体数据。

Distributed：

        RDD 支持分区, 可以运行在集群中。

Resilient：

• RDD 支持高效的容错；
• RDD 中的数据即可以缓存在内存中, 也可以缓存在磁盘中, 也可以缓存在外部存储中。

RDD特点

• 弹性
  • 容错的弹性:数据丢失可以自动恢复;
  • 存储的弹性:内存与磁盘的自动切换;
  • 计算的弹性:计算出错重试机制;
  • 分片的弹性:可根据需要重新分片。

• 分布式:数据存储在集群不同节点上/计算分布式。
• 数据集: RDD封装了计算逻辑，并不保存数据。
• 数据抽象: RDD是一个抽象类，需要子类具体实现。
• 不可变: RDD封装了计算逻辑，是不可以改变的，想要改变，只能产生新的RDD，在新的RDD里面封装计算逻辑。
• 可分区、并行计算。

RDD的五大属性：

1.分区列表( a list of partitions)
        Spark RDD是被分区的，每一个分区都会被一个计算任务(Task)处理，分区数决定了并行计算的数量，RDD的并行度默认从父RDD传给子RDD。默认情况下，一个HDFS上的数据分片就是一个 partiton，RDD分片数决定了并行计算的力度，可以在创建RDD时指定RDD分片个数（分区）。

        如果不指定分区数量，当RDD从集合创建时，则默认分区数量为该程序所分配到的资源的CPU核数(每个Core可以承载2~4个 partition)，如果是从HDFS文件创建，默认为文件的 Block数。

2.每一个分区都有一个计算函数( a function for computing each split）
        每个分区都会有计算函数， Spark的RDD的计算函数是以分片为基本单位的，每个RDD都会实现 compute函数，对具体的分片进行计算，不需要保存每次计算的结果。RDD中的分片是并行的，所以是分布式并行计算。

        有一点非常重要，就是由于RDD有前后依赖关系，遇到宽依赖关系，如reduceByKey等这些操作时划分成 Stage， Stage内部的操作都是通过 Pipeline进行的，在具体处理数据时它会通过 Blockmanager来获取相关的数据，因为具体的 split要从外界读数据，也要把具体的计算结果写入外界，所以用了一个管理器，具体的 split都会映射成 BlockManager的Block，而具体的split会被函数处理，函数处理的具体形式是以任务的形式进行的。

3.依赖关系( a list of dependencies on other RDDS)
由于RDD每次转换都会生成新的RDD，所以RDD会形成类似流水线一样的前后依赖关系，当然宽依赖就不类似于流水线了，宽依赖后面的RDD具体的数据分片会依赖前面所有的RDD的所有数据分片，这个时候数据分片就不进行内存中的 Pipeline，一般都是跨机器的，因为有前后的依赖关系，所以当有分区的数据丢失时， Spark会通过依赖关系进行重新计算，从而计算出丢失的数据，而不是对RDD所有的分区进行重新计算。

RDD之间的依赖有两种：窄依赖( Narrow Dependency)和宽依赖( Wide Dependency)。

窄依赖(Narrow Dependency)

窄依赖是指每个父RDD的一个Partition最多被子RDD的一个Partition所使用，例如map、filter、union等操作都会产生窄依赖；

对于窄依赖，由于partition依赖关系的确定性，partition的转换处理就可以在同一个线程里完成，这种转换不会引起shuffle操作，速度快！

宽依赖(Wide Dependency)

宽依赖是指一个父RDD的Partition会被多个子RDD的Partition所使用，例如groupByKey、reduceByKey、sortByKey等操作都会产生宽依赖；

这种转换会引起shuffle操作，速度慢！

Shuffle是MapReduce框架中的一个特定的phase，介于Map phase和Reduce phase之间，当Map的输出结果要被Reduce使用时，输出结果需要按key哈希，并且分发到每一个Reducer上去，这个过程就是shuffle。由于shuffle涉及到了磁盘的读写和网络的传输，因此shuffle性能的高低直接影响到了整个程序的运行效率。

4.key- value数据类型的RDD分区器( a Partitioner for key- alue RDDS)
一个Partitioner，即RDD的分区函数（可选项），Partitioner函数不但决定了RDD本身的分片数量，也决定了parent RDD Shuffle输出时的分片数量。

当前Spark中实现了两种类型的分区函数，

基于哈希的HashPartitioner，(key.hashcode % 分区数= 分区号)。它是默认值
基于范围的RangePartitioner。
什么会有Partitioner?

只有对于key-value的RDD(RDD[(String, Int)]),并且产生shuffle，才会有Partitioner;
非key-value的RDD(RDD[String])的Parititioner的值是None。
Option类型：可以表示有值或者没有值，它有2个子类：

Some：表示封装了值
None：表示没有值
/** Optionally overridden by subclasses to specify how they are partitioned. */
 @transient val partitioner: Option[Partitioner] = None

5 每个分区都有一个优先位置列表，即首选位置( a list of preferred locations to compute each split on）
存储每个切片优先(preferred location)位置的列表。 比如对于一个 HDFS 文件来说, 这个列表保存的就是每个 Partition 所在文件块的位置.。按照“移动数据不如移动计算”的理念, Spark 在进行任务调度的时候, 会尽可能地将计算任务分配到其所要处理数据块的存储位置。