Hadoop And Spark

最新推荐文章于 2024-10-13 23:31:37 发布

：D ：

最新推荐文章于 2024-10-13 23:31:37 发布

阅读量617

点赞数

分类专栏：笔记文章标签： hadoop spark

本文链接：https://blog.csdn.net/qq_52170993/article/details/118711726

版权

笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Hadoop 优点

HDFS是一个高度容错性的系统，适合部署在廉价的机器上。HDFS能提供高吞吐量的数据访问，非常适合大规模数据集上的应用。HDFS放宽了一部分POSIX约束，来实现流式读取文件系统数据的目的。

HDFS应用需要一个“一次写入多次读取”的文件访问模型。一个文件经过创建、写入和关闭之后就不需要改变。

HDFS 架构图解

在这里插入图片描述

Hadoop 架构设计

HDFS采用master/slave架构

通常，集群里的一台机器被指定为 NameNode，另一台不同的机器被指定为JobTracker。这些机器是masters。余下的机器即作为DataNode也作为TaskTracker。这些机器是slaves。

在conf/slaves文件中列出所有slave的主机名或者IP地址，一行一个。

管理员可在conf/hadoop-env.sh脚本内对Hadoop守护进程的运行环境做特别指定
管理员可以通过配置选项HADOOP_*_OPTS来分别配置各个守护进程。

在这里插入图片描述

基本关系

JobTracker 对应于 NameNode

TaskTracker 对应于 DataNode

DataNode 和NameNode 是针对数据存放来而言的

JobTracker和TaskTracker是对于MapReduce执行而言的

JobTracker和TaskTracker

1 、
JobClient会在用户端通过JobClient类将应用已经配置参数打包成jar文件存储到hdfs，

并把路径提交到Jobtracker,然后由JobTracker创建每一个Task（即MapTask和ReduceTask）

并将它们分发到各个TaskTracker服务中去执行

2、
JobTracker是一个master服务，软件启动之后JobTracker接收Job，负责调度Job的每一个子任务task运行于TaskTracker上，

并监控它们，如果发现有失败的task就重新运行它。一般情况应该把JobTracker部署在单独的机器上。

3、
TaskTracker是运行在多个节点上的slaver服务。TaskTracker主动与JobTracker通信，接收作业，并负责直接执行每一个任务。

TaskTracker都需要运行在HDFS的DataNode上

NameNode 和 DataNode

1 、一个HDFS集群主要由一个NameNode和很多个Datanode组成：Namenode管理文件系统的元数据，而Datanode存储了实际的数据。

2 、Namenode执行文件系统的名字空间操作，比如打开、关闭、重命名文件或目录。它也负责确定数据块到具体Datanode节点的映射。Datanode负责处理文件系统客户端的读写请求。在Namenode的统一调度下进行数据块的创建、删除和复制。

3、由于采用了可移植性极强的Java语言，使得HDFS可以部署到多种类型的机器上

4 、HDFS被设计成能够在一个大集群中跨机器可靠地存储超大文件。它将每个文件存储成一系列的数据块，除了最后一个，所有的数据块都是同样大小的。
HDFS被设计成。支持大文件，适用HDFS的是那些需要处理大规模的数据集的应用。HDFS支持文件的“一次写入多次读取”语义

5 、Namenode在内存中保存着整个文件系统的名字空间和文件数据块映射(Blockmap)的映像 NameNode启动的时候首先将fsimage（镜像）载入内存，并执行（replay）编辑日志editlog的的各项操作

6、 Namenode上保存着HDFS的名字空间。对于任何对文件系统元数据产生修改的操作，Namenode都会使用一种称为EditLog的事务日志记录下来。整个文件系统的名字空间，包括数据块到文件的映射、文件的属性等，都存储在一个称为FsImage的文件中

7 、所有的HDFS通讯协议都是建立在TCP/IP协议之上。客户端通过一个可配置的TCP端口连接到Namenode，通过ClientProtocol协议与Namenode交互。而Datanode使用DatanodeProtocol协议与Namenode交互。Namenode不会主动发起RPC，而是响应来自客户端或 Datanode 的RPC请求

8、将所有Editlog中的事务作用在内存中的FsImage上，并将这个新版本的FsImage从内存中保存到本地磁盘上，然后删除旧的Editlog，因为这个旧的Editlog的事务都已经作用在FsImage上了。这个过程称为一个检查点(checkpoint)
在当前实现中，检查点只发生在Namenode启动时，在不久的将来将实现支持周期性的检查点。

9 、每个Datanode节点周期性地向Namenode发送心跳信号 。
Namenode全权管理数据块的复制，它周期性地从集群中的每个Datanode接收心跳信号和块状态报告(Blockreport)

10 、HDFS的架构支持数据均衡策略。如果某个Datanode节点上的空闲空间低于特定的临界点，按照均衡策略系统就会自动地将数据从这个Datanode移动到其他空闲的Datanode。当对某个文件的请求突然增加，那么也可能启动一个计划创建该文件新的副本，并且同时重新平衡集群中的其他数据。这些均衡策略目前还没有实现

11 、HDFS客户端软件实现了对HDFS文件内容的校验和(checksum)检查。当客户端创建一个新的HDFS文件，会计算这个文件每个数据块的校验和，并将校验和作为一个单独的隐藏文件保存在同一个HDFS名字空间下。当客户端获取文件内容后，它会检验从Datanode获取的数据跟相应的校验和文件中的校验和是否匹配，如果不匹配，客户端可以选择从其他Datanode获取该数据块的副本

12 、FsImage和Editlog是HDFS的核心数据结构。如果这些文件损坏了，整个HDFS实例都将失效。因而，Namenode可以配置成支持维护多个FsImage和Editlog的副本。任何对FsImage或者Editlog的修改，都将同步到它们的副本上
当Namenode重启的时候，它会选取最近的完整的FsImage和Editlog来使用。

Hadoop的机架感知

NameNode和JobTracker通过调用管理员配置模块中的APIresolve来获取集群里每个slave的机架id。该API将slave的DNS名称（或者IP地址）转换成机架id。使用哪个模块是通过配置项topology.node.switch.mapping.impl来指定的。模块的默认实现会调用topology.script.file.name配置项指定的一个的脚本/命令。如果topology.script.file.name未被设置，对于所有传入的IP地址，模块会返回/default-rack作为机架id。

启动Hadoop

格式化一个新的分布式文件系统：
$ bin/hadoop namenode -format

在分配的NameNode上，运行下面的命令启动HDFS：
$ bin/start-dfs.sh

bin/start-dfs.sh脚本会参照NameNode上 ${HADOOP_CONF_DIR}/slaves 文件的内容，在所有列出的slave上启动DataNode守护进程。

在分配的JobTracker上，运行下面的命令启动Map/Reduce：
$ bin/start-mapred.sh

bin/start-mapred.sh脚本会参照JobTracker上 ${HADOOP_CONF_DIR}/slaves 文件的内容，在所有列出的slave上启动TaskTracker守护进程。

关闭 hadoop

在分配的NameNode上，执行下面的命令停止HDFS：

$ bin/stop-dfs.sh

在分配的JobTracker上，运行下面的命令停止Map/Reduce：

$ bin/stop-mapred.sh

spark

在这里插入图片描述

组成

Spark applications run as independent sets of processes on a cluster, coordinated by the SparkContext object in your main program (called the driver program).
SparkContext can connect to several types of cluster managers，which allocate resources across applications.
Spark acquires executors on nodes in the cluster,
it sends your application code to the executors
Finally, SparkContext sends tasks to the executors to run.

architecture

在这里插入图片描述

Cluster Manager Types

Standalone –

a simple cluster manager included with Spark that makes it easy to set up a cluster.

Apache Mesos –

a general cluster manager that can also run Hadoop MapReduce and service applications.

Hadoop YARN –

the resource manager in Hadoop 2.

Kubernetes –

an open-source system for automating deployment, scaling, and management
of containerized applications.

Spark概念理解

Driver program

The process running the main() function of the application and creating the SparkContext

Cluster manager

An external service for acquiring resources on the cluster (e.g. standalone manager, Mesos, YARN)

Worker node

Any node that can run application code in the cluster

Executor

A process launched for an application on a worker node, that runs tasks and keeps data in memory or disk storage across them. Each application has its own executors.

Task

A unit of work that will be sent to one executor

Job

A parallel computation consisting of multiple tasks that gets spawned in response to a Spark action (e.g. save, collect); you'll see this term used in the driver's logs.

Stage

Each job gets divided into smaller sets of tasks called stages that depend on each other (similar to the map and reduce stages in MapReduce); you'll see this term used in the driver's logs.

Deploy mode

Distinguishes where the driver process runs. In "cluster" mode, the framework launches the driver inside of the cluster. In "client" mode, the submitter launches the driver outside of the cluster.

master 和 worker

master节点常驻master守护进程，负责管理worker节点，我们从master节点提交应用。

worker节点常驻worker守护进程，与master节点通信，并且管理executor进程。

Submitting Applications

Once a user application is bundled, it can be launched using the bin/spark-submit script
This script takes care of setting up the classpath with Spark and its dependencies, and can support different cluster managers and deploy modes that Spark supports:

command

手动上传Jar包到集群运行

运行在集群，计算在集群，输出在集群

spark-submit
–class
–master
–deploy-mode
–conf =
… # other options

[application-arguments]

--class: The entry point for your application (e.g. org.apache.spark.examples.SparkPi)

--master: The master URL for the cluster (e.g. spark://23.195.26.187:7077)

--deploy-mode: Whether to deploy your driver on the worker nodes 
(cluster) or locally as an external client (client) (default: client) †

--conf: Arbitrary Spark configuration property in key=value format. For 
values that contain spaces wrap “key=value” in quotes (as shown).

application-jar: Path to a bundled jar including your application and all 
dependencies. The URL must be globally visible inside of your cluster, 
for instance, an hdfs:// path or a file:// path that is present on all 
nodes.

application-arguments: Arguments passed to the main method of your main class, if any


//  代码内 Sparkconf 的获取不用具体指定
conf = new SparkConf().setAppName("DemoApp")

使用IDEA本地连接集群运行

运行在集群，计算在集群，输出可以在本地(从远程取回)

使用IDEA本地运行(Local模式)

本地运行，本地计算，本地输出，与集群无关

 conf = new SparkConf().setAppName("DemoApp").setMaster("local")

Spark streaming

concept

Spark Streaming is an extension of the core Spark API that enables scalable, high-throughput, fault-tolerant stream processing of live data streams.

Internally, it works as follows. Spark Streaming receives live input data streams and divides
the data into batches, which are then processed by the Spark engine to generate the final
stream of results in batches

Internally, a DStream is represented as a sequence of RDDs.

graph

在这里插入图片描述

RDD

The main abstraction Spark provides is a resilient distributed dataset (RDD), which is a collection of elements partitioned across the nodes of the cluster that can be operated on in parallel.

A second abstraction in Spark is shared variables that can be used in parallel operations.
it ships a copy of each variable used in the function to each tasks.
Spark supports two types of shared variables: broadcast variables, which can be used to cache a value in memory on all nodes, and accumulators, which are variables that are only “added” to, such as counters and sums.

feature

只读：不能修改，只能通过转换操作生成新的 RDD。
分布式：可以分布在多台机器上进行并行处理。
弹性：计算过程中内存不够时它会和磁盘进行数据交换。
基于内存：可以全部或部分缓存在内存中，在多次计算间重用, 有容错机制。

RDD 的操作分为转化（Transformation）操作和行动（Action）操作。转化操作就是从一个 RDD 产生一个新的 RDD，而行动操作就是进行实际的计算

-RDD 的转换操作是返回新的 RDD 的操作。转换出来的 RDD 是惰性求值的，只有在行动操作中用到这些 RDD 时才会被计算。

graph

RDD 的分区及分区与工作结点（Worker Node）的分布关系
在这里插入图片描述

create RDD

1).使用程序中的集合创建rdd
2).使用本地文件系统创建rdd
3).使用hdfs创建rdd，
4).基于数据库db创建rdd
5).基于Nosql创建rdd，如hbase
6).基于s3创建rdd，
7).基于数据流，如socket创建rdd

RDD 生成 DAG

在这里插入图片描述

1.窄依赖

1）子 RDD 的每个分区依赖于常数个父分区（即与数据规模无关)。 
2）输入输出一对一的算子，且结果 RDD 的分区结构不变，如 map、flatMap。 
3）输入输出一对一的算子，但结果 RDD 的分区结构发生了变化，如 union。 
4）从输入中选择部分元素的算子，如 filter、distinct、subtract、sample。

2、宽依赖

1）子 RDD 的每个分区依赖于所有父 RDD 分区
2）对单个 RDD 基于 Key 进行重组和 reduce，如 groupByKey、reduceByKey
3）对两个 RDD 基于 Key 进行 join 和重组，如 join。

用户提交的计算任务是一个由 RDD 构成的 DAG，如果 RDD 的转换是宽依赖，那么这个宽依赖转换就将这个 DAG 分为了不同的阶段（Stage)。由于宽依赖会带来“洗牌”，所以不同的 Stage 是不能并行计算的，后面 Stage 的 RDD 的计算需要等待前面 Stage 的 RDD 的所有分区全部计算完毕以后才能进行

案例

SparkConf conf=new SparkConf();        conf.set("spark.testing.memory", "2147480000");    

JavaSparkContext sc = new JavaSparkContext("local", "First Spark App",conf);
System.out.println(sc);
//通过hdfs上的文件定义一个RDD 这个数据暂时还没有加载到内存，也没有在上面执行动作,lines仅仅指向这个文件       
JavaRDD<String> lines = sc.textFile("hdfs://master:9000/testFile/README.md");

JavaRDD<Integer> lineLengths = lines.map(new Function<String, Integer>() {        
  public Integer call(String s) {
   	System.out.println("每行长度"+s.length());             
   	return s.length();
    }
});

int totalLength = lineLengths.reduce(new Function2<Integer, Integer, Integer>() {
     public Integer call(Integer a, Integer b) {
      return a + b; 
      }   
 });