精华内容
下载资源
问答
  • Spark入门

    2020-09-21 20:44:17
    Spark入门 问1:Hadoop与Spark区别? 答:Hadoop主要解决海量数据的存储和海量数据的分析计算;Spark是一种基于内存的快 速、通用、可扩展的大数据分析计算引擎。 问2:Spark的资源调度框架? 答:Hadoop 的 Yarn ...

    Spark入门

    问1:Hadoop与Spark区别?

    答:Hadoop主要解决海量数据的存储和海量数据的分析计算;Spark是一种基于内存的快

    速、通用、可扩展的大数据分析计算引擎

    问2:Spark的资源调度框架?

    答:Hadoop 的 Yarn 框架比 Spark 框架诞生的晚,所以 Spark 自己也设计了一套资源调

    度框架。

    问3:Hadoop与Spark框架对比?

    答:Hadoop MR框架:从数据源获取数据,经过分析计算,将结果输出到指定位置。核

    心是一次计算,不适合迭代运算。

    在这里插入图片描述

    Spark框架:支持迭代计算,图形计算;Spark框架比 MR 快的原因是:中间结果不落

    盘。但是Spark的 Shuffle 也是落盘的。

    在这里插入图片描述

    问4:Spark特点?(官网:http://spark.apache.org/

    1)Speed

    Run workloads 100x faster.

    2)Ease of Use

    Write applications quickly in Java, Scala, Python, R, and SQL.

    3)Generality

    Combine SQL, streaming, and complex analytics.

    4)Runs Everywhere

    Spark runs on Hadoop, Apache Mesos, Kubernetes, standalone, or in the cloud. It can

    access diverse data sources.

    问5:Spark运行模式?

    (1)Local模式:在本地部署单个Spark服务

    (2)Standalone模式:Spark自带的任务调度模式。(国内常用)

    (3)YARN模式:Spark使用Hadoop的YARN组件进行资源与任务调度。(国内常用)

    (4)Mesos模式:Spark使用Mesos平台进行资源与任务的调度。(国内常用)

    (4)Mesos模式:Spark使用Mesos平台进行资源与任务的调度。

    展开全文
  • spark入门

    2020-05-27 14:44:21
    spark 入门1. 下载2. 二进制包目录3. 配置4. 启动5. 体验5.1 数据准备5.2 spark-shell5.3 加载数据5.4 简单体验6. spark UI6.1 UI 入口6.2 作业汇总6.3 作业计算过程6.4 作业DAG6.5 作业描述指标6.6 作业调度6.7 ...

    1. 下载

    在spark下载地址,下载spark二进制包。
    http://spark.apache.org/downloads.html
    在这里插入图片描述
    这里不仅仅需要选择spark版本,也需要选择spark编译环境的包。
    spark中文文档
    http://spark.apachecn.org/#/
    spark英文文档
    http://spark.apache.org/docs/latest/

    这里借用网络上的一张图片来描述spark的生态圈:
    在这里插入图片描述
    之前在hadoop安装中安装好了hadoop。不过,spark有自己的资源调度,所以,我们只需要启动hadoop的hdfs即可。

    因为spark是基于hadoop的,所以在第一步选择了hadoop的版本后,需要选择编译二进制包的hadoop的环境。选择之后,第三部会给出下载地址,点击进去,选择一个镜像,下载二进制包即可。

    2. 二进制包目录

    在这里插入图片描述
    在这个位置解压缩,接下来看下spark二进制包的目录结构。
    在这里插入图片描述

    • bin: 和spark进行交互的可执行文件
      在这里插入图片描述
    • conf: 配置目录
      在这里插入图片描述
    • data: 一些spark计算的配置数据
      在这里插入图片描述
    • examples: spark一些例子
      在这里插入图片描述
      在这里插入图片描述
    • jars: spark的自己的jar包
      在这里插入图片描述
    • kuberbetes: spark对于k8s的支持,包含一些dockerfile等
      在这里插入图片描述
    • LICENSE:开源协议
    • licenses:开源授权协议等文件
    • logs:spark的日志文件
    • NOTICE:公告信息
    • python: spark对python做的兼容支持
    • R: spark对R语言做的兼容支持
    • README.md:使用须知?^v^
    • RELEASE:发布包编译环境
      在这里插入图片描述
    • sbin:启动脚本,spark的一些启动的脚本,主要是使用配置文件里面设置的参数,启动bin目录里面的二进制文件。
      在这里插入图片描述
    • work: 记录了spark提交的作业历史
      在这里插入图片描述
      主要保存了作业的日志,包括输出与异常。
    • yarn: spark对yarn的集成,之前就说过,spark自己集成了资源调度,所以我们安装好hadoop后,只需要启动hdfs即可,yarn可以交给spark自己管理。
      在这里插入图片描述

    3. 配置

    因为spark是基于hadoop的,所以,如果你将hadoop的环境搭建好了,那么在hadoop的基础上搭建spark就很容易,甚至说,非常的简单(简单配置,不包含调优):
    首先,conf是spark的配置目录:
    在这里插入图片描述
    这里面是一个个的template文件,默认是不存在任何配置文件的。
    为了让spark能够启动,我们需要配置一些环境变量
    cp spark-env.sh.template spark-env.sh
    首先,拷贝模板,得到环境变量的配置文件
    vim spark-env.sh
    然后进行配置
    在这里插入图片描述
    主要是配置JAVA_HOME(JAVA_HOME可以省去,因为在hadoop中,已经配置了JAVA_HOME),SPARK_MASTER_HOST,SPARK_MASTER_IP,SPARK_MASTER_PORT
    然后配置worker:
    cp slaves.template slaves
    得到worker的配置文件
    在这里插入图片描述
    在这个文件里面填入worker的主机名即可。

    4. 启动

    将配置好的spark二进制解压目录,拷贝到worker机器上的相同目录下。
    然后在spark的sbin目录下执行 ./start-all.sh即可
    使用jps验证
    master
    在这里插入图片描述
    worker
    在这里插入图片描述
    访问界面http://master-host:8080/
    在这里插入图片描述

    5. 体验

    5.1 数据准备

    我准备了一个log文件,大小是460M左右
    在这里插入图片描述
    首先我们使用hdfs的命令,将文件存入hdfs中:
    hadoop fs -mkdir /data
    hadoop fs -put /data/ /study/data/real.log
    存入成功后,使用hadoop fs -ls /data可以查看在hdfs中的文件
    在这里插入图片描述

    5.2 spark-shell

    spark提供了交互界面,供开发人员开发调试等使用。
    如果你不是使用scala开发,而是其他语言,需要启动对应语言的交互shell

    编程语言 对应shell
    scala spark-shell
    java spark-class
    python pyspark
    R sparkR

    spark-shell在bin目录下:
    在这里插入图片描述
    这种方式启动spark-shell是默认启动单机模式的spark。
    在交互式shell中使用ctrl+d退出
    既然我们已将搭建好了集群的spark,那么就应该使用集群的spark。
    spark-shell --master spark://host-10-0-228-117:7077
    当然:spark-shell --master spark://10.0.228.117:7077也是可以的
    交互式shell连接成功后:
    在这里插入图片描述
    此时在```http://10.0.228.117:8080/上可以看到一个活动:
    在这里插入图片描述
    这个shell的一些信息在界面上都可以看到。
    在启动shell的时候,也可以指定shell的资源,名字等信息。

    5.3 加载数据

    我们在5.1中,将一个日志文件放到了hdfs中了,此时我们在shell中使用sc对象读取文件
    val lines = sc.textFile("hdfs://host-10-0-228-117:8020/data/real.log")
    在这里插入图片描述
    此时,spark已经将log文件加载为了RDD[String]了

    5.4 简单体验

    println(lines.count())计算日志文件有多少行
    在这里插入图片描述
    在这里插入图片描述
    println(lines.filter(l => l.contains("Stop")).count())统计包含指定字符的日志的行数
    在这里插入图片描述
    这里展示了将这个任务分为几个子任务进行处理
    在这里插入图片描述
    这是执行结果
    println(lines.flatMap(l => l.split(" ").toStream).count())日志文件有多少个单词
    在这里插入图片描述
    在这里插入图片描述

    6. spark UI

    6.1 UI 入口

    在```http://spark-master-host:4040/jobs可以查看我们之前执行的三次作业:
    在这里插入图片描述

    6.2 作业汇总

    作业用时,作业资源消耗等都可以查看
    在这里插入图片描述

    6.3 作业计算过程

    计算过程描述
    在这里插入图片描述

    6.4 作业DAG

    job的dag
    在这里插入图片描述

    6.5 作业描述指标

    job描述指标
    在这里插入图片描述

    6.6 作业调度

    job调度(基于6.5的指标)
    在这里插入图片描述

    6.7 作业拆分

    job拆分任务描述
    在这里插入图片描述

    6.8 作业执行

    job执行worker
    在这里插入图片描述

    6.9 任务执行详细

    job拆分任务执行详细
    在这里插入图片描述

    6.10 任务日志

    job某个拆分任务的日志
    在这里插入图片描述

    展开全文
  • Spark 入门

    千次阅读 2017-11-30 11:09:35
    Spark概述 1 11 什么是Spark 2 Spark特点 3 Spark的用户和用途 二 Spark集群安装 1 集群角色 2 机器准备 3 下载Spark安装包 4 配置SparkStandalone 5 配置Job History ServerStandalone 6 配置Spark HAStandalone...

    一、 Spark概述

    1.1 1.1 什么是Spark

    官网:http://spark.apache.org

    这里写图片描述
    这里写图片描述

    Spark是一种快速、通用、可扩展的大数据分析引擎,2009年诞生于加州大学伯克利分校AMPLab,2010年开源,2013年6月成为Apache孵化项目,2014年2月成为Apache顶级项目。项目是用Scala进行编写。

    目前,Spark生态系统已经发展成为一个包含多个子项目的集合,其中包含SparkSQL、Spark Streaming、GraphX、MLib、SparkR等子项目,Spark是基于内存计算的大数据并行计算框架。除了扩展了广泛使用的 MapReduce 计算模型,而且高效地支持更多计算模式,包括交互式查询和流处理。Spark 适用于各种各样原先需要多种不同的分布式平台的场景,包括批处理、迭代算法、交互式查询、流处理。通过在一个统一的框架下支持这些不同的计算,Spark 使我们可以简单而低耗地把各种处理流程整合在一起。而这样的组合,在实际的数据分析 过程中是很有意义的。不仅如此,Spark 的这种特性还大大减轻了原先需要对各种平台分 别管理的负担。

    大一统的软件栈,各个组件关系密切并且可以相互调用,这种设计有几个好处:1、软件栈中所有的程序库和高级组件 都可以从下层的改进中获益。2、运行整个软件栈的代价变小了。不需要运 行 5 到 10 套独立的软件系统了,一个机构只需要运行一套软件系统即可。系统的部署、维护、测试、支持等大大缩减。3、能够构建出无缝整合不同处理模型的应用。

    Spark的内置项目如下:

    这里写图片描述

    Spark Core: 实现了 Spark 的基本功能,包含任务调度、内存管理、错误恢复、与存储系统 交互等模块。Spark Core 中还包含了对弹性分布式数据集(resilient distributed dataset,简称RDD)的 API 定义。
    Spark SQL: 是 Spark 用来操作结构化数据的程序包。通过 Spark SQL,我们可以使用 SQL 或者 Apache Hive 版本的 SQL 方言(HQL)来查询数据。Spark SQL 支持多种数据源,比 如 Hive 表、Parquet 以及 JSON 等。
    Spark Streaming: 是 Spark 提供的对实时数据进行流式计算的组件。提供了用来操作数据流的 API,并且与 Spark Core 中的 RDD API 高度对应。
    Spark MLlib: 提供常见的机器学习(ML)功能的程序库。包括分类、回归、聚类、协同过滤等,还提供了模型评估、数据 导入等额外的支持功能。
    集群管理器: Spark 设计为可以高效地在一个计算节点到数千个计算节点之间伸缩计 算。为了实现这样的要求,同时获得最大灵活性,Spark 支持在各种集群管理器(cluster manager)上运行,包括 Hadoop YARN、Apache Mesos,以及 Spark 自带的一个简易调度 器,叫作独立调度器。

    Spark得到了众多大数据公司的支持,这些公司包括Hortonworks、IBM、Intel、Cloudera、MapR、Pivotal、百度、阿里、腾讯、京东、携程、优酷土豆。当前百度的Spark已应用于凤巢、大搜索、直达号、百度大数据等业务;阿里利用GraphX构建了大规模的图计算和图挖掘系统,实现了很多生产系统的推荐算法;腾讯Spark集群达到8000台的规模,是当前已知的世界上最大的Spark集群。

    1.2 Spark特点


    与Hadoop的MapReduce相比,Spark基于内存的运算要快100倍以上,基于硬盘的运算也要快10倍以上。Spark实现了高效的DAG执行引擎,可以通过基于内存来高效处理数据流。计算的中间结果是存在于内存中的。

    这里写图片描述

    易用
    Spark支持Java、Python和Scala的API,还支持超过80种高级算法,使用户可以快速构建不同的应用。而且Spark支持交互式的Python和Scala的shell,可以非常方便地在这些shell中使用Spark集群来验证解决问题的方法。

    这里写图片描述

    通用
    Spark提供了统一的解决方案。Spark可以用于批处理、交互式查询(Spark SQL)、实时流处理(Spark Streaming)、机器学习(Spark MLlib)和图计算(GraphX)。这些不同类型的处理都可以在同一个应用中无缝使用。Spark统一的解决方案非常具有吸引力,毕竟任何公司都想用统一的平台去处理遇到的问题,减少开发和维护的人力成本和部署平台的物力成本。

    兼容性
    Spark可以非常方便地与其他的开源产品进行融合。比如,Spark可以使用Hadoop的YARN和Apache Mesos作为它的资源管理和调度器,器,并且可以处理所有Hadoop支持的数据,包括HDFS、HBase和Cassandra等。这对于已经部署Hadoop集群的用户特别重要,因为不需要做任何数据迁移就可以使用Spark的强大处理能力。Spark也可以不依赖于第三方的资源管理和调度器,它实现了Standalone作为其内置的资源管理和调度框架,这样进一步降低了Spark的使用门槛,使得所有人都可以非常容易地部署和使用Spark。此外,Spark还提供了在EC2上部署Standalone的Spark集群的工具。

    这里写图片描述

    1.3 Spark的用户和用途

    我们大致把Spark的用例分为两类:数据科学应用和数据处理应用。也就对应的有两种人群:数据科学家和工程师。

    数据科学任务
    主要是数据分析领域,数据科学家要负责分析数据并建模,具备 SQL、统计、预测建模(机器学习)等方面的经验,以及一定的使用 Python、 Matlab 或 R 语言进行编程的能力。

    数据处理应用
    工程师定义为使用 Spark 开发 生产环境中的数据处理应用的软件开发者,通过对接Spark的API实现对处理的处理和转换等任务。

    二、 Spark集群安装

    2.1 集群角色

    这里写图片描述

    从物理部署层面上来看,Spark主要分为两种类型的节点,Master节点和Worker节点,Master节点主要运行集群管理器的中心化部分,所承载的作用是分配Application到Worker节点,维护Worker节点,Driver,Application的状态。Worker节点负责具体的业务运行。

    从Spark程序运行的层面来看,Spark主要分为驱动器节点和执行器节点。

    2.2 机器准备

    准备两台以上Linux服务器,安装好JDK1.8

    2.3 下载Spark安装包

    这里写图片描述

    上传解压安装包
    上传spark-2.1.1-bin-hadoop2.7.tgz安装包到Linux上
    解压安装包到指定位置
    tar -xf spark-2.1.1-bin-hadoop2.7.tgz -C /opt/modules

    这里写图片描述

    这里写图片描述

    2.4 配置Spark【Standalone】

    Spark的部署模式有Local、Local-Cluster、Standalone、Yarn、Mesos,我们选择最具代表性的Standalone集群部署模式。

    进入到Spark安装目录
    cd /home/bigdata/hadoop/spark-2.1.1-bin-hadoop2.7/conf

    这里写图片描述

    将slaves.template复制为slaves
    将spark-env.sh.template复制为spark-env.sh
    修改slave文件,将work的hostname输入:

    这里写图片描述

    修改spark-env.sh文件,添加如下配置:

    这里写图片描述

    将配置好的Spark文件拷贝到其他节点上

    Spark集群配置完毕,目前是1个Master,2个Work,linux01上启动Spark集群
    /opt/modules/spark-2.1.1-bin-hadoop2.7/sbin/start-all.sh

    这里写图片描述

    启动后执行jps命令,主节点上有Master进程,其他子节点上有Work进行,登录Spark管理界面查看集群状态(主节点):http://linux01:8080/

    这里写图片描述

    到此为止,Spark集群安装完毕.

    注意:如果遇到 “JAVA_HOME not set” 异常,可以在sbin目录下的spark-config.sh 文件中加入如下配置:
    export JAVA_HOME=XXXX

    2.5 配置Job History Server【Standalone】

    进入到Spark安装目录
    cd /opt/modules/spark-2.1.1-bin-hadoop2.7/conf

    这里写图片描述

    将spark-default.conf.template复制为spark-default.conf

    修改spark-default.conf文件,开启Log:

    这里写图片描述

    【注意:HDFS上的目录需要提前存在】

    修改spark-env.sh文件,添加如下配置:

    这里写图片描述

    在HDFS上创建好你所指定的eventLog日志目录。

    spark-defaults.conf

    spark.eventLog.enabled  true
    spark.eventLog.dir       hdfs://master01:9000/directory
    spark.eventLog.compress true

    spark-env.sh

    export SPARK_HISTORY_OPTS="-Dspark.history.ui.port=4000
    -Dspark.history.retainedApplications=3
    -Dspark.history.fs.logDirectory=hdfs://linux01:9000/directory"

    参数描述:
    spark.eventLog.dir:Application在运行过程中所有的信息均记录在该属性指定的路径下;

    spark.history.ui.port=4000 调整WEBUI访问的端口号为4000

    spark.history.fs.logDirectory=hdfs://master01:9000/directory 配置了该属性后,在start-history-server.sh时就无需再显式的指定路径,Spark History Server页面只展示该指定路径下的信息

    spark.history.retainedApplications=3 指定保存Application历史记录的个数,如果超过这个值,旧的应用程序信息将被删除,这个是内存中的应用数,而不是页面上显示的应用数。

    将配置好的Spark文件拷贝到其他节点上

    /opt/modules/spark-2.1.1-bin-hadoop2.7/sbin/start-all.sh

    这里写图片描述

    启动后执行:【别忘了启动HDFS】

    /opt/modules/spark-2.1.1-bin-hadoop2.7/sbin/start-history-server.sh

    这里写图片描述

    到此为止,Spark History Server安装完毕.

    如果遇到Hadoop HDFS的写入权限问题:
    org.apache.hadoop.security.AccessControlException
    解决方案: 在hdfs-site.xml中添加如下配置,关闭权限验证

    <property>
                <name>dfs.permissions</name>
                <value>false</value>
    

    2.6 配置Spark HA【Standalone】

    集群部署完了,但是有一个很大的问题,那就是Master节点存在单点故障,要解决此问题,就要借助zookeeper,并且启动至少两个Master节点来实现高可靠,配置方式比较简单:

    这里写图片描述

    Spark集群规划:master01,master02是Master;slave01,slave02,slave03是Worker

    安装配置Zookeeper集群,并启动Zookeeper集群
    停止spark所有服务,修改配置文件spark-env.sh,在该配置文件中删掉SPARK_MASTER_IP并添加如下配置

    这里写图片描述

    这里写图片描述

    export SPARK_DAEMON_JAVA_OPTS="
     -Dspark.deploy.recoveryMode=ZOOKEEPER
     -Dspark.deploy.zookeeper.url=zk1,zk2,zk3
     -Dspark.deploy.zookeeper.dir=/spark"

    1.在 master01节点上修改spark-env.sh配置文件
    2.将配置文件同步到所有节点。
    3.在master01上执行sbin/start-all.sh脚本,启动集群并启动第一个master节点,然后在master02上执行sbin/start-master.sh启动第二个master节点。
    4.程序中spark集群的访问地址需要改成:
    spark://master01:port1,master02:port2

    2.7 配置Spark【Yarn】

    修改Hadoop配置下的yarn-site.xml:

    <configuration>
    
    <!-- Site specific YARN configuration properties -->
            <property>
                    <name>yarn.resourcemanager.hostname</name>
                    <value>master01</value>
            </property>
            <property>
                    <name>yarn.nodemanager.aux-services</name>
                    <value>mapreduce_shuffle</value>
            </property>
            <!--是否启动一个线程检查每个任务正使用的物理内存量,如果任务超出分配值,则直接将其杀掉,默认是true -->
            <property>
                    <name>yarn.nodemanager.pmem-check-enabled</name>
                    <value>false</value>
            </property>
            <!--是否启动一个线程检查每个任务正使用的虚拟内存量,如果任务超出分配值,则直接将其杀掉,默认是true -->
            <property>
                    <name>yarn.nodemanager.vmem-check-enabled</name>
                    <value>false</value>
            </property>
    </configuration>
    

    修改Spark-env.sh 添加:

    这里写图片描述

    让Spark能够发现Hadoop配置文件

    HADOOP_CONF_DIR=/opt/modules/hadoop-2.7.3/etc/hadoop
    YARN_CONF_DIR=/opt/modules/hadoop-2.7.3/etc/hadoop
    

    这里写图片描述

    启动spark history server:

    这里写图片描述

    可以查看日志。

    三、 执行Spark程序

    3.1 执行第一个spark程序(standalone)

    /opt/modules/spark-2.1.1-bin-hadoop2.7/bin/spark-submit \
    --class org.apache.spark.examples.SparkPi \
    --master spark://linux01:7077 \
    --executor-memory 1G \
    --total-executor-cores 2 \
    /opt/modules/spark-2.1.1-bin-hadoop2.7/examples/jars/spark-examples_2.11-2.1.1.jar \
    100

    参数说明:
    –master spark://master01:7077 指定Master的地址
    –executor-memory 1G 指定每个executor可用内存为1G
    –total-executor-cores 2 指定每个executor使用的cup核数为2个
    该算法是利用蒙特·卡罗算法求PI

    这里写图片描述

    3.2 执行第一个spark程序(yarn)

    /opt/modules/spark-2.1.1-bin-hadoop2.7/bin/spark-submit \
    --class org.apache.spark.examples.SparkPi \
    --master yarn \
    --deploy-mode client \
    /opt/modules/spark-2.1.1-bin-hadoop2.7/examples/jars/spark-examples_2.11-2.1.1.jar \
    100

    3.3 Spark应用提交

    一旦打包好,就可以使用bin/spark-submit脚本启动应用了. 这个脚本负责设置spark使用的classpath和依赖,支持不同类型的集群管理器和发布模式:

    ./bin/spark-submit \
      --class <main-class>
      --master <master-url> \
      --deploy-mode <deploy-mode> \
      --conf <key>=<value> \
      ... # other options
      <application-jar> \
      [application-arguments]

    一些常用选项:
    1) –class: 你的应用的启动类 (如 org.apache.spark.examples.SparkPi)
    2) –master: 集群的master URL (如 spark://23.195.26.187:7077)
    3) –deploy-mode: 是否发布你的驱动到worker节点(cluster) 或者作为一个本地客户端 (client) (default: client)*
    4) –conf: 任意的Spark配置属性, 格式key=value. 如果值包含空格,可以加引号“key=value”. 缺省的Spark配置
    5) application-jar: 打包好的应用jar,包含依赖. 这个URL在集群中全局可见。 比如hdfs:// 共享存储系统, 如果是 file:// path, 那么所有的节点的path都包含同样的jar.
    6) application-arguments: 传给main()方法的参数

    Master URL 可以是以下格式:
    查看Spark-submit全部参数:

    参数 解释
    local 本地以一个worker线程运行(例如非并行的情况).
    local[K] 本地以K worker 线程 (理想情况下, K设置为你机器的CPU核数).
    local[*] 本地以本机同样核数的线程运行.
    spark://HOST:PORT 连接到指定的Spark standalone cluster master. 端口是你的master集群配置的端口,缺省值为7077.
    mesos://HOST:PORT 连接到指定的Mesos 集群. Port是你配置的mesos端口, 缺省是5050. 或者如果Mesos使用ZOoKeeper,格式为 mesos://zk://….
    yarn-client 以client模式连接到YARN cluster. 集群的位置基于HADOOP_CONF_DIR 变量找到.
    yarn-cluster 以cluster模式连接到YARN cluster. 集群的位置基于HADOOP_CONF_DIR 变量找到.

    3.4 启动Spark Shell

    spark-shell是Spark自带的交互式Shell程序,方便用户进行交互式编程,用户可以在该命令行下用scala编写spark程序。

    3.4.1 启动Spark shell

    /opt/modules/spark-2.1.1-bin-hadoop2.7/bin/spark-shell \
    –master spark://master01:7077 \
    –executor-memory 2g \
    –total-executor-cores 2
    注意:
    如果启动spark shell时没有指定master地址,但是也可以正常启动spark shell和执行spark shell中的程序,其实是启动了spark的local模式,该模式仅在本机启动一个进程,没有与集群建立联系。

    Spark Shell中已经默认将SparkContext类初始化为对象sc。用户代码如果需要用到,则直接应用sc即可

    3.4.2 在Spark shell中编写WordCount程序

    首先启动hdfs

    将Spark目录下的RELEASE文件上传一个文件到hdfs://linux01:9000/RELEASE
    ~/opt/modules/hadoop-2.7.3/bin/hdfs dfs -put ./RELEASE /

    这里写图片描述

    在Spark shell中用scala语言编写spark程序

    sc.textFile("hdfs://linux01:9000/RELEASE").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).saveAsTextFile("hdfs://linux01:9000/out")

    这里写图片描述

    使用hdfs命令查看结果

    hdfs dfs -cat hdfs://master01:9000/out/p*

    这里写图片描述

    说明:
    sc是SparkContext对象,该对象时提交spark程序的入口
    textFile(hdfs://master01:9000/RELEASE)是hdfs中读取数据
    flatMap(_.split(” “))先map在压平
    map((_,1))将单词和1构成元组
    reduceByKey(+)按照key进行reduce,并将value累加
    saveAsTextFile(“hdfs:// master01:9000/out”)将结果写入到hdfs中

    这里写图片描述

    3.5 在IDEA中编写WordCount程序

    spark shell仅在测试和验证我们的程序时使用的较多,在生产环境中,通常会在IDE中编制程序,然后打成jar包,然后提交到集群,最常用的是创建一个Maven项目,利用Maven来管理jar包的依赖。

    1.创建一个项目

    这里写图片描述

    2.选择Maven项目,然后点击next

    这里写图片描述

    3.填写maven的GAV,然后点击next

    这里写图片描述

    4.填写项目名称,然后点击finish

    这里写图片描述

    6.配置Maven的pom.xml

        <?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.apache.org/POM/4.0.0"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            <parent>
                <artifactId>spark</artifactId>
                <groupId>com.atguigu</groupId>
                <version>1.0-SNAPSHOT</version>
            </parent>
            <modelVersion>4.0.0</modelVersion>
    
            <artifactId>wordcount</artifactId>
    
            <dependencies>
                <dependency>
                    <groupId>org.scala-lang</groupId>
                    <artifactId>scala-library</artifactId>
                    <version>${scala.version}</version>
                    <scope>provided</scope>
                </dependency>
    
                <dependency>
                    <groupId>org.apache.spark</groupId>
                    <artifactId>spark-core_2.11</artifactId>
                    <version>${spark.version}</version>
                    <scope>provided</scope>
                </dependency>
                <dependency>
                    <groupId>org.apache.hadoop</groupId>
                    <artifactId>hadoop-client</artifactId>
                    <version>${hadoop.version}</version>
                    <scope>provided</scope>
                </dependency>
    
                <!-- Logging -->
                <dependency>
                    <groupId>org.slf4j</groupId>
                    <artifactId>jcl-over-slf4j</artifactId>
                    <version>${slf4j.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                    <version>${slf4j.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                    <version>${slf4j.version}</version>
                </dependency>
                <dependency>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                    <version>${log4j.version}</version>
                </dependency>
                <!-- Logging End -->
            </dependencies>
            <build>
                <finalName>wordcount</finalName>
                <plugins>
                    <plugin>
                        <groupId>net.alchim31.maven</groupId>
                        <artifactId>scala-maven-plugin</artifactId>
                        <version>3.2.2</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>compile</goal>
                                    <goal>testCompile</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-assembly-plugin</artifactId>
                        <version>3.0.0</version>
                        <configuration>
                            <archive>
                                <manifest>
                                    <mainClass>com.atguigu.spark.WordCount</mainClass>
                                </manifest>
                            </archive>
                            <descriptorRefs>
                                <descriptorRef>jar-with-dependencies</descriptorRef>
                            </descriptorRefs>
                        </configuration>
                        <executions>
                            <execution>
                                <id>make-assembly</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>single</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
    
    
        </project>

    7.将src/main/scala设置成源代码目录。

    这里写图片描述

    这里写图片描述

    8.添加IDEA Scala(执行此操作后,pom文件中不用添加scala依赖,应为已经以lib库的方式加入)

    这里写图片描述

    这里写图片描述

    这里写图片描述

    这里写图片描述

    9.新建一个Scala class,类型为Object

    这里写图片描述

    10.编写spark程序

    package com.atguigu.spark
    
    import org.apache.spark.{SparkConf, SparkContext}
    import org.slf4j.LoggerFactory
    
    /**
      * Created by wuyufei on 31/07/2017.
      */
    object WordCount {
    
      val logger = LoggerFactory.getLogger(WordCount.getClass)
    
      def main(args: Array[String]) {
        //创建SparkConf()并设置App名称
        val conf = new SparkConf().setAppName("WC")
        //创建SparkContext,该对象是提交spark App的入口
        val sc = new SparkContext(conf)
        //使用sc创建RDD并执行相应的transformation和action
        sc.textFile(args(0)).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_, 1).sortBy(_._2, false).saveAsTextFile(args(1))
        //停止sc,结束该任务
    
        logger.info("complete!")
    
        sc.stop()
      }
    
    }

    11.使用Maven打包:首先修改pom.xml中的main class

    这里写图片描述

    12.点击idea右侧的Maven Project选项,点击Lifecycle,选择clean和package,然后点击Run Maven Build

    这里写图片描述

    13.选择编译成功的jar包,并将该jar上传到Spark集群中的某个节点上

    这里写图片描述

    14.首先启动hdfs和Spark集群
    启动hdfs
    /opt/modules/hadoop-2.7.3/sbin/start-dfs.sh
    启动spark
    /opt/modules/spark-2.1.1-bin-hadoop2.7/sbin/start-all.sh

    15.使用spark-submit命令提交Spark应用(注意参数的顺序)

    /opt/modules/spark-2.1.1-bin-hadoop2.7/bin/spark-submit\
       --class WordCount\
       --master spark://linux01:7077\
       --executor-memory 1G \
       --total-executor-cores 2 \
       wordcount-jar-with-dependencies.jar\
       hdfs://linux01:9000/calllog.csv\
       hdfs://linux01:9000/out

    16.查看程序执行结果
    hdfs dfs -cat hdfs://linux01:9000/out/part-*

    3.6 在IDEA中本地调试WordCount程序

    本地Spark程序调试需要使用local提交模式,即将本机当做运行环境,Master和Worker都为本机。运行时直接加断点调试即可。如下:

    这里写图片描述

    如果本机操作系统是windows,如果在程序中使用了hadoop相关的东西,比如写入文件到HDFS,则会遇到如下异常:

    这里写图片描述

    出现这个问题的原因,并不是程序的错误,而是用到了hadoop相关的服务,解决办法是将附加里面的hadoop-common-bin-2.7.3-x64.zip解压到任意目录。

    这里写图片描述

    在IDEA中配置Run Configuration,添加HADOOP_HOME变量

    这里写图片描述

    3.7 在IDEA中远程调试WordCount程序

    通过IDEA进行远程调试,主要是将IDEA作为Driver来提交应用程序,配置过程如下:

    修改sparkConf,添加最终需要运行的Jar包、Driver程序的地址,并设置Master的提交地址:

    这里写图片描述

    然后加入断点,直接调试即可:

    这里写图片描述

    3.8 Spark核心概念

    每个Spark应用都由一个驱动器程序(driver program)来发起集群上的各种 并行操作。驱动器程序包含应用的 main 函数,并且定义了集群上的分布式数据集,还对这 些分布式数据集应用了相关操作。 


    驱动器程序通过一个 SparkContext 对象来访问 Spark。这个对象代表对计算集群的一个连 接。shell 启动时已经自动创建了一个 SparkContext 对象,是一个叫作 sc 的变量。

    驱动器程序一般要管理多个执行器(executor)节点。

    这里写图片描述

    展开全文
  • spark 入门

    2018-08-23 16:58:47
    spark机器学习 推荐原因:书籍附带源码,有python,对于简单的机器学习

    针对python开发
    1、spark官网手册
    https://spark.apache.org/docs/latest/api/python/index.html
    2、spark机器学习
    推荐原因:书籍附带源码和数据,有python示例,完整的重现一个简单项目的实现过程。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,562
精华内容 3,024
关键字:

spark入门