zeppelin on CDH及配置spark查询hive表

跟風遠走 提交于 2019-12-05 13:20:09

1.下载zeppelin

http://zeppelin.apache.org/download.html 

我下载的是796MB的那个已经编译好的,如果需要自己按照环境编译也可以,但是要很长时间编译,这个版本包含了很多插件,我虽然是CDH环境但是这个也可以使用。

2.修改配置文件

cd  /zeppelin-0.7.3-bin-all/conf

cp  zeppelin-env.sh.template zeppelin-env.sh

cp zeppelin-site.xml.template zeppelin-site.xml

vim zeppelin-env.sh

添加配置如下:我的是spark2用不了spark1.6版本这个版本的zeppelin

export HIVE_HOME=/opt/cloudera/parcels/CDH-5.9.0-1.cdh5.9.0.p0.23/lib/hive
export JAVA_HOME=/usr/java/jdk1.8.0_121
export MASTER=yarn-client
export ZEPPELIN_JAVA_OPTS="-Dmaster=yarn-client -Dspark.yarn.jar=/home/zeppelin-0.7.3-bin-all/interpreter/spark/zeppelin-spark_2.11-0.7.3.jar"
export DEFAULT_HADOOP_HOME=/opt/cloudera/parcels/CDH-5.9.0-1.cdh5.9.0.p0.23/lib/hadoop
export SPARK_HOME=/data/parcels/cloudera/parcels/SPARK2/lib/spark2
#export SPARK_HOME=/opt/cloudera/parcels/CDH-5.9.0-1.cdh5.9.0.p0.23/lib/spark
export HADOOP_HOME=${HADOOP_HOME:-$DEFAULT_HADOOP_HOME}
if [ -n "$HADOOP_HOME" ]; then
  export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${HADOOP_HOME}/lib/native
fi
export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-/etc/hadoop/conf}


export ZEPPELIN_LOG_DIR=/var/log/zeppelin
export ZEPPELIN_PID_DIR=/var/run/zeppelin
export ZEPPELIN_WAR_TEMPDIR=/var/tmp/zeppelin

3.配置这些其实已经足够了。

在启动

./zeppelin-daemon.sh start

4.在界面上配置就可以使用了hive的配置这个

添加依赖:

这些就可以查询hive了

5.用spark读取hive表这个比直接查询hive表快十倍

我把hive的配置文件hive-site.xml拷贝到hadoop_home/conf

添加需要的依赖

%dep
 z.load("org.apache.hive:hive-jdbc:0.14.0")
z.load("org.apache.hadoop:hadoop-common:2.6.0")
z.load("/home/gl/hive-hcatalog-core-1.1.0-cdh5.9.0.jar")

%spark
import java.util.Properties
import org.apache.spark.sql.SparkSession
import org.apache.spark.SparkConf


val sparkConf = new SparkConf().setAppName("hive")
val spark = SparkSession.builder().config(sparkConf).enableHiveSupport().getOrCreate()


val connectionProperties = new Properties()
connectionProperties.put("user", "")
connectionProperties.put("password", "")
connectionProperties.put("driver", "org.apache.hive.jdbc.HiveDriver")
val jdbcDF2 = spark.read
  .jdbc("jdbc:hive2://*******:****/test", "bbb", connectionProperties)//.createTempView("bbb")
  
   spark.sql("select count(*) from pc_db.pc_txt group by responseset").show()

6.

.修改登陆zeeplin验证方式
禁止匿名访问

Zeppelin启动默认是匿名(anonymous)模式登录的.如果设置访问登录权限,需要设置conf/zeppelin-site.xml文件下的zeppelin.anonymous.allowed选项为false(默认为true).如果你还没有这个文件,只需将conf/zeppelin-site.xml.template复制为conf/zeppelin-site.xml

<property>
<name>zeppelin.anonymous.allowed</name>
<value>false</value>
<description>Anonymous user allowed by default</description>
</property>
a)开启Shiro

在刚安装完毕之后,默认情况下,在conf中,将找到shiro.ini.template,该文件是一个配置示例,建议你通过执行如下命令行创建shiro.ini文件:

cp conf/shiro.ini.template conf/shiro.ini
[users]
#admin = password1, admin
#user1 = password2, role1, role2
#user2 = password3, role3
#user3 = password4, role2

hadoop = hadoop, admin # 用户名、密码都是hadoop,角色为admin
bin/zeppelin-daemon.sh restart

2.How to do

  首先,我们来了解一下这款工具的背景及用途。Zeppelin 目前已托管于 Apache 基金会,但并未列为顶级项目,可以在其公布的 官网访问。它提供了一个非常友好的 WebUI 界面,操作相关指令。它可以用于做数据分析和可视化。其后面可以接入不同的数据处理引擎。包括 Flink,Spark,Hive 等。支持原生的 Scala,Shell,Markdown 等。

2.1 Install

  对于 Zeppelin 而言,并不依赖 Hadoop 集群环境,我们可以部署到单独的节点上进行使用。首先我们使用以下地址获取安装包:

http://zeppelin.incubator.apache.org/download.html

  这里,有2种选择,其一,可以下载原文件,自行编译安装。其二,直接下载二进制文件进行安装。这里,为了方便,笔者直接使用二进制文件进行安装使用。这里有些参数需要进行配置,为了保证系统正常启动,确保的 zeppelin.server.port 属性的端口不被占用,默认是8080,其他属性大家可按需配置即可。[配置链接

2.2 Start/Stop

  在完成上述步骤后,启动对应的进程。定位到 Zeppelin 安装目录的bin文件夹下,使用以下命令启动进程:

./zeppelin-daemon.sh start

  若需要停止,可以使用以下命令停止进程:

./zeppelin-daemon.sh stop

  另外,通过阅读 zeppelin-daemon.sh 脚本的内容,可以发现,我们还可以使用相关重启,查看状态等命令。内容如下:

复制代码

case "${1}" in
  start)
    start
    ;;
  stop)
    stop
    ;;
  reload)
    stop
    start
    ;;
  restart)
    stop
    start
    ;;
  status)
    find_zeppelin_process
    ;;
  *)
    echo ${USAGE}

复制代码

3.How to use

  在启动相关进程后,可以使用以下地址在浏览器中访问:

http://<Your_<IP/Host>:Port>

  启动之后的界面如下所示:

  该界面罗列出插件绑定项。如图中的 spark,md,sh 等。那我如何使用这些来完成一些工作。在使用一些数据引擎时,如 Flink,Spark,Hive 等,是需要配置对应的连接信息的。在 Interpreter 栏处进行配置。这里给大家列举一些配置示例:

3.1 Flink

  可以找到 Flink 的配置项,如下图所示:

 

  然后指定对应的 IP 和地址即可。

3.2 Hive

  这里 Hive 配置需要指向其 Thrift 服务地址,如下图所示:

  另外,其他的插件,如 Spark,Kylin,phoenix等配置类似,配置完成后,记得点击 “restart” 按钮。

3.3 Use md and sh

  下面,我们可以创建一个 Notebook 来使用,我们拿最简单的 Shell 和 Markdown 来演示,如下图所示:

3.4 SQL

  当然,我们的目的并不是仅仅使用 Shell 和 Markdown,我们需要能够使用 SQL 来获取我们想要的结果。

3.4.1 Spark SQL

  下面,我们使用 Spark SQL 去获取想要的结果。如下图所示:

  这里,可以将结果以不同的形式来可视化,量化,趋势,一目了然。

3.4.2 Hive SQL

  另外,可以使用动态格式来查询分区数据,以"${partition_col=20160101,20160102|20160103|20160104|20160105|20160106}"的格式进行表示。如下图所示:

3.5 Video Guide

  另外,官方也给出了一个快速指导的入门视频,观看地址:[入口]

4.总结

  在使用的过程当中,有些地方需要注意,必须在编写 Hive SQL 时,%hql 需要替换为 %hive.sql 的格式;另外,在运行 Scala 代码时,如果出现以下异常,如下图所示:

  解决方案,在 zeppelin-env.sh 文件中添加以下内容:

export ZEPPELIN_MEM=-Xmx4g

  该 BUG 在 0.5.6 版本得到修复,参考码:[ZEPPELIN-305]

五、Hue、Zeppelin比较
        上一节简单介绍了Hue这种Hadoop生态圈的数据可视化组件,本节讨论另一种类似的产品——Zeppelin。首先介绍一下Zeppelin,然后说明其安装的详细步骤,之后演示如何在Zeppelin中添加MySQL翻译器,最后从功能、架构、使用场景几方面将Hue和Zeppelin做一个比较。
1. Zeppelin简介
        Zeppelin是一个基于Web的软件,用于交互式地数据分析。一开始是Apache软件基金会的孵化项目,2016年5月正式成为一个顶级项目(Top-Level Project,TLP)。Zeppelin描述自己是一个可以进行数据摄取、数据发现、数据分析、数据可视化的笔记本,用以帮助开发者、数据科学家以及相关用户更有效地处理数据,而不必使用复杂的命令行,也不必关心集群的实现细节。Zeppelin的架构图如下所示。

        从图中可以看到,Zeppelin具有客户端/服务器架构,客户端一般就是指浏览器。服务器接收客户端的请求,并将请求通过Thrift协议发送给翻译器组。翻译器组物理表现为JVM进程,负责实际处理客户端的请求并与服务器进行通信。
        翻译器是一个插件式的体系结构,允许任何语言/后端数据处理程序以插件的形式添加到Zeppelin中。特别需要指出的是,Zeppelin内建Spark翻译器,因此不需要构建单独的模块、插件或库。Spark翻译器的架构图如下所示。


        当前的Zeppelin已经支持很多翻译器,如Zeppelin 0.6.0版本自带的翻译器有alluxio、cassandra、file、hbase、ignite、kylin、md、phoenix、sh、tajo、angular、elasticsearch、flink、hive、jdbc、lens、psql、spark等18种之多。插件式架构允许用户在Zeppelin中使用自己熟悉的特定程序语言或数据处理方式。例如,通过使用%spark翻译器,可以在Zeppelin中使用Scala语言代码。
        在数据可视化方面,Zeppelin已经包含一些基本的图表,如柱状图、饼图、线形图、散点图等,任何后端语言的输出都可以被图形化表示。
        用户建立的每一个查询叫做一个note,note的URL在多用户间共享,Zeppelin将向所有用户实时广播note的变化。Zeppelin还提供一个只显示查询结果的URL,该页不包括任何菜单和按钮。用这种方式可以方便地将结果页作为一帧嵌入到自己的web站点中。

2. Zeppelin安装配置
        下面用一个典型的使用场景——使用Zeppelin运行SparkSQL访问Hive表,在一个实验环境上说明Zeppelin的安装配置步骤。
(1)安装环境
        12个节点的Spark集群,以standalone方式部署,各个节点运行的进程如下表所示。
主机名

运行进程

nbidc-agent-03

NameNode、Spark Master

nbidc-agent-04

SecondaryNameNode

nbidc-agent-11

ResourceManager、DataNode、NodeManager、Spark Worker

nbidc-agent-12

DataNode、NodeManager、Spark Worker

nbidc-agent-13

DataNode、NodeManager、Spark Worker

nbidc-agent-14

DataNode、NodeManager、Spark Worker

nbidc-agent-15

DataNode、NodeManager、Spark Worker

nbidc-agent-18

DataNode、NodeManager、Spark Worker

nbidc-agent-19

DataNode、NodeManager、Spark Worker

nbidc-agent-20

DataNode、NodeManager、Spark Worker

nbidc-agent-21

DataNode、NodeManager、Spark Worker

nbidc-agent-22

DataNode、NodeManager、Spark Worker


        操作系统:CentOS release 6.4
        Hadoop版本:2.7.0
        Hive版本:2.0.0
        Spark版本:1.6.0

(2)在nbidc-agent-04上安装部署Zeppelin及其相关组件
        前提:nbidc-agent-04需要能够连接互联网。
安装Git:在nbidc-agent-04上执行下面的指令。
yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel  
yum install gcc perl-ExtUtils-MakeMaker  
yum remove git  
cd /home/work/tools/  
wget https://github.com/git/git/archive/v2.8.1.tar.gz  
tar -zxvf git-2.8.1.tar.gz  
cd git-2.8.1.tar.gz  
make prefix=/home/work/tools/git all  
make prefix=/home/work/tools/git install
安装Java:在nbidc-agent-03机器上执行下面的指令拷贝Java安装目录到nbidc-agent-04机器上。
scp -r jdk1.7.0_75 nbidc-agent-04:/home/work/tools/
安装Apache Maven:在agent-04上执行下面的指令。
cd /home/work/tools/  
wget ftp://mirror.reverse.net/pub/apache/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz  
tar -zxvf apache-maven-3.3.9-bin.tar.gz
 安装Hadoop客户端:在nbidc-agent-03机器上执行下面的指令拷贝Hadoop安装目录到nbidc-agent-04机器上。
scp -r hadoop nbidc-agent-04:/home/work/tools/
安装Spark客户端:在nbidc-agent-03机器上执行下面的指令拷贝Spark安装目录到nbidc-agent-04机器上。
scp -r spark nbidc-agent-04:/home/work/tools/
安装Hive客户端:在nbidc-agent-03机器上执行下面的指令拷贝Hive安装目录到nbidc-agent-04机器上。
scp -r hive nbidc-agent-04:/home/work/tools/
安装phantomjs:在nbidc-agent-04上执行下面的指令。
cd /home/work/tools/  
tar -jxvf phantomjs-2.1.1-linux-x86_64.tar.bz2
下载最新的zeppelin源码:在nbidc-agent-04上执行下面的指令。
cd /home/work/tools/  
git clone https://github.com/apache/incubator-zeppelin.git
设置环境变量:在nbidc-agent-04上编辑/home/work/.bashrc文件,内容如下。
vi /home/work/.bashrc
# 添加下面的内容  
export PATH=.:$PATH:/home/work/tools/jdk1.7.0_75/bin:/home/work/tools/hadoop/bin:/home/work/tools/spark/bin:/home/work/tools/hive/bin:/home/work/tools/phantomjs-2.1.1-linux-x86_64/bin:/home/work/tools/incubator-zeppelin/bin;  
export JAVA_HOME=/home/work/tools/jdk1.7.0_75  
export HADOOP_HOME=/home/work/tools/hadoop  
export SPARK_HOME=/home/work/tools/spark  
export HIVE_HOME=/home/work/tools/hive  
export ZEPPELIN_HOME=/home/work/tools/incubator-zeppelin  
# 保存文件,并是设置生效  
source /home/work/.bashrc
编译zeppelin源码:在nbidc-agent-04上执行下面的指令。
cd /home/work/tools/incubator-zeppelin  
mvn clean package -Pspark-1.6 -Dspark.version=1.6.0 -Dhadoop.version=2.7.0 -Phadoop-2.6 -Pyarn -DskipTests
(3)配置zeppelin
配置zeppelin-env.sh文件:在nbidc-agent-04上执行下面的指令。
cp /home/work/tools/incubator-zeppelin/conf/zeppelin-env.sh.template  /home/work/tools/incubator-zeppelin/conf/zeppelin-env.sh 
vi /home/work/tools/incubator-zeppelin/conf/zeppelin-env.sh
# 添加下面的内容  
export JAVA_HOME=/home/work/tools/jdk1.7.0_75  
export HADOOP_CONF_DIR=/home/work/tools/hadoop/etc/hadoop  
export MASTER=spark://nbidc-agent-03:7077
配置zeppelin-site.xml文件:在nbidc-agent-04上执行下面的指令。
cp /home/work/tools/incubator-zeppelin/conf/zeppelin-site.xml.template  /home/work/tools/incubator-zeppelin/conf/zeppelin-site.xml
vi /home/work/tools/incubator-zeppelin/conf/zeppelin-site.xml
# 修改下面这段的value值,设置zeppelin的端口为9090  
<property>  
  <name>zeppelin.server.port</name>  
  <value>9090</value>  
  <description>Server port.</description>  
</property>
将hive-site.xml拷贝到zeppelin的配置目录下:在nbidc-agent-04上执行下面的指令。
cd /home/work/tools/incubator-zeppelin  
cp /home/work/tools/hive/conf/hive-site.xml .
(4)启动zeppelin
        在nbidc-agent-04上执行下面的指令。
zeppelin-daemon.sh start
(5)测试
        从浏览器输入http://nbidc-agent-04:9090/,如下图所示。


        点击‘Interpreter’菜单,配置并保存spark解释器,如下图所示。


        配置并保存hive解释器,如下图所示。


        点击‘NoteBook’->‘Create new note’子菜单项,建立一个新的查询并执行,结果如下图所示。


        说明:这是一个动态表单SQL,SparkSQL语句为:
%sql  
select * from wxy.t1 where rate > ${r} 
        第一行指定解释器为SparkSQL,第二行用${r}指定一个运行时参数,执行时页面上会出现一个文本编辑框,输入参数后回车,查询会按照指定参数进行,如图会查询rate > 100的记录。

3. 在Zeppelin中添加MySQL翻译器
        数据可视化的需求很普遍,如果常用的如MySQL这样的关系数据库也能使用Zeppelin查询,并将结果图形化显示,那么就可以用一套统一的数据可视化方案处理大多数常用查询。Zeppelin本身还不带MySQL翻译器,幸运的是已经有MySQL翻译器插件了。下面说明该插件的安装步骤及简单测试。
(1)编译MySQL Interpreter源代码
cd /home/work/tools/
git clone https://github.com/jiekechoo/zeppelin-interpreter-mysql
mvn clean package
(2)部署二进制包
mkdir /home/work/tools/incubator-zeppelin/interpreter/mysql
cp /home/work/tools/zeppelin-interpreter-mysql/target/zeppelin-mysql-0.5.0-incubating.jar /home/work/tools/incubator-zeppelin/interpreter/mysql/
# copy dependencies to mysql directory
cp commons-exec-1.1.jar mysql-connector-java-5.1.6.jar slf4j-log4j12-1.7.10.jar log4j-1.2.17.jar slf4j-api-1.7.10.jar /home/work/tools/incubator-zeppelin/interpreter/mysql/
vi /home/work/tools/incubator-zeppelin/conf/zeppelin-site.xml
        在zeppelin.interpreters 的value里增加一些内容“,org.apache.zeppelin.mysql.MysqlInterpreter”,如下图所示。


(3)重启Zeppelin
zeppelin-daemon.sh restart
(4)加载MySQL Interpreter
打开主页http://nbidc-agent-04:9090/,‘Interpreter’ -> ‘Create’,完成类似下图的页面,完成点击‘Save’ 

(5)测试
创建名为mysql_test的note,如下图所示。

输入下面的查询语句,按创建日期统计建立表的个数。
%mysql
select date_format(create_time,'%Y-%m-%d') d, count(*) c 
  from information_schema.tables 
 group by date_format(create_time,'%Y-%m-%d') 

5. Hue与Zeppelin比较
(1)功能
Zeppelin和Hue都能提供一定的数据可视化的功能,都提供了多种图形化数据表示形式。单从这点来说,个人认为功能类似,大同小异,Hue可以通过经纬度进行地图定位,这个功能我在Zeppelin 0.6.0上没有找到。
Zeppelin支持的后端数据查询程序较多,0.6.0版本缺省有18种,原生支持Spark。而Hue的3.9.0版本缺省只支持Hive、Impala、Pig和数据库查询。
Zeppelin只提供了单一的数据处理功能,包括前面提到的数据摄取、数据发现、数据分析、数据可视化等都属于数据处理的范畴。而Hue的功能相对丰富的多,除了类似的数据处理,还有元数据管理、Oozie工作流管理、作业管理、用户管理、Sqoop集成等很多管理功能。从这点看,Zeppelin只是一个数据处理工具,而Hue更像是一个综合管理工具。
(2)架构
Zeppelin采用插件式的翻译器,通过插件开发,可以添加任何后端语言和数据处理程序。相对来说更独立和开放。
Hue与Hadoop生态圈的其它组件密切相关,一般都与CDH一同部署。
(3)使用场景
Zeppelin适合单一数据处理、但后端处理语言繁多的场景,尤其适合Spark。
Hue适合与Hadoop集群的多个组件交互、如Oozie工作流、Sqoop等联合处理数据的场景,尤其适合与Impala协同工作。
--------------------- 

前提:服务器已经安装好了hadoop_client端即hadoop的环境hbase,hive等相关组件

1.环境和变量配置
①拷贝hive的配置文件hive-site.xml到zeppelin-0.7.2-bin-all/conf下

# cp /root/hadoop-2.6.0/conf/hive-site.xml /data/hadoop/zeppelin/zeppelin-0.7.2-bin-all/conf
 

②进入conf下进行环境变量的配置

# cd /data/hadoop/zeppelin/zeppelin-0.7.2-bin-all/conf
vim zeppelin-env.sh

export JAVA_HOME=/usr/java/jdk1.8.0_111
export HADOOP_CONF_DIR=/root/hadoop-2.6.0/conf
2.在web界面配置集成hive
访问zeppelin的web界面(http://ip:8080)

右上角anonymous --> interpreter --> +Create新建一个叫做hive的集成环境(也可以在jdbc的基础上修改,不用新建)


编辑hive的相关属性,hive相关的配置可以到hive-site.xml中查看

Properties        value
common.max_count    1000
hive.driver    org.apache.hive.jdbc.HiveDriver
hive.password    hive
hive.url    jdbc:hive2://uhadoop-bwgkeu-master2:10000 # 注意是hive2不是hive
hive.user    hive
zeppelin.interpreter.localRepo    /data/hadoop/zeppelin/zeppelin-0.7.2-bin-all/local-repo/2CNPYUV7Z
zeppelin.interpreter.output.limit    102400
zeppelin.jdbc.auth.type    
zeppelin.jdbc.concurrent.max_connection    10
zeppelin.jdbc.concurrent.use    true
zeppelin.jdbc.keytab.location    
zeppelin.jdbc.principal    
 

填写Dependencies相关属性
2个hive依赖包,一个mysql依赖包,不用mysql可以不用写mysql jdbc包
填好后点保存,这个时候zeppelin会出现卡顿,这是因为上面填的2个Dependencies,zeppelin去指定maven库下载相关依赖包去了,等待时间可能需几分钟。

下载完成可在local-repo目录下查看,依赖包放在local-repo/2CNPYUV7Z/(可能不同)目录下,等完全下载完成,就可查询。

Dependencies

artifact    exclude
org.apache.hive:hive-jdbc:0.14.0    
org.apache.hadoop:hadoop-common:2.6.0    
mysql:mysql-connector-java:5.1.38
--------------------- 

概述
Apache Spark是一种快速和通用的集群计算系统。它提供Java,Scala,Python和R中的高级API,以及支持一般执行图的优化引擎。Zeppelin支持Apache Spark,Spark解释器组由5个解释器组成。

名称

描述
%spark    SparkInterpreter    创建一个SparkContext并提供Scala环境
%spark.pyspark    PySparkInterpreter    提供Python环境
%spark.r    SparkRInterpreter    提供具有SparkR支持的R环境
%spark.sql    SparkSQLInterpreter    提供SQL环境
%spark.dep    DepInterpreter    依赖加载器
 

配置
Spark解释器可以配置为由Zeppelin提供的属性。您还可以设置表中未列出的其他Spark属性。有关其他属性的列表,请参阅Spark可用属性。

属性
默认
描述
ARGS         Spark命令行参考
master    local[*]    Spark master uri.
例如:spark://masterhost:7077
spark.app.name    Zeppelin    Spark应用的名称。
spark.cores.max         要使用的核心总数。
空值使用所有可用的核心。
spark.executor.memory    1g    每个worker实例的执行程序内存。
ex)512m,32g
zeppelin.dep.additionalRemoteRepository    spark-packages, 
http://dl.bintray.com/spark-packages/maven, 
false;     id,remote-repository-URL,is-snapshot;
每个远程存储库的列表。
zeppelin.dep.localrepo    local-repo    依赖加载器的本地存储库
zeppelin.pyspark.python    python    Python命令来运行pyspark
zeppelin.spark.concurrentSQL    python    如果设置为true,则同时执行多个SQL。
zeppelin.spark.maxResult    1000    要显示的Spark SQL结果的最大数量。
zeppelin.spark.printREPLOutput    true    打印REPL输出
zeppelin.spark.useHiveContext    true    如果它是真的,使用HiveContext而不是SQLContext。
zeppelin.spark.importImplicit    true    导入含义,UDF集合和sql如果设置为true。
没有任何配置,Spark解释器在本地模式下开箱即用。但是,如果要连接到Spark群集,则需要按照以下两个简单步骤进行操作。

1.导出SPARK_HOME
在conf/zeppelin-env.sh,导出SPARK_HOME环境变量与您的Spark安装路径。

例如,


export SPARK_HOME=/usr/lib/spark 

您可以选择设置更多的环境变量


# set hadoop conf dir

export HADOOP_CONF_DIR=/usr/lib/hadoop

  

# set options to pass spark-submit command

export SPARK_SUBMIT_OPTIONS="--packages com.databricks:spark-csv_2.10:1.2.0"

  

# extra classpath. e.g. set classpath for hive-site.xml

export ZEPPELIN_INTP_CLASSPATH_OVERRIDES=/etc/hive/conf 

对于Windows,确保你winutils.exe在%HADOOP_HOME%\bin。有关详细信息,请参阅在Windows上运行Hadoop的问题。

2.在“解释器”菜单中设置主机
启动Zeppelin后,转到解释器菜单并在Spark解释器设置中编辑主属性。该值可能因您的Spark群集部署类型而异。

例如,

local[*]  本地模式
spark://master:7077 standalone 集群模式
yarn-client Yarn 客户端模式
mesos://host:5050 Mesos 集群模式
而已。Zeppelin将使用任何版本的Spark和任何部署类型,而不用这种方式重建Zeppelin。有关Spark&Zeppelin版本兼容性的更多信息,请参阅Zeppelin下载页面中的“可用的口译员”部分。

请注意,不导出SPARK_HOME,它以本地模式运行,包含版本的Spark。附带的版本可能因构建配置文件而异。

 

SparkContext,SQLContext,SparkSession,ZeppelinContext
SparkContext,SQLContext和ZeppelinContext会自动创建并显示为变量名sc,sqlContext并z分别在Scala,Python和R环境中公开。从0.6.1起,spark当您使用Spark 2.x时,SparkSession可以作为变量使用。

请注意,Scala / Python / R环境共享相同的SparkContext,SQLContext和ZeppelinContext实例。

 

依赖管理 
在Spark解释器中加载外部库有两种方法。首先是使用解释器设置菜单,其次是加载Spark属性。

1.通过解释器设置设置依赖关系
有关详细信息,请参阅解释器依赖管理。

2.加载Spark属性
一旦SPARK_HOME被设置conf/zeppelin-env.sh,Zeppelin使用spark-submit作为Spark解释赛跑者。spark-submit支持两种方式来加载配置。第一个是命令行选项,如--master和飞艇可以通过这些选项spark-submit通过导出SPARK_SUBMIT_OPTIONS在conf/zeppelin-env.sh。二是从中读取配置选项SPARK_HOME/conf/spark-defaults.conf。用户可以设置分发库的Spark属性有:

火花defaults.conf
SPARK_SUBMIT_OPTIONS
描述
spark.jars    --jars    包含在驱动程序和执行器类路径上的本地jar的逗号分隔列表。
spark.jars.packages    --packages    
逗号分隔列表,用于包含在驱动程序和执行器类路径上的jar的maven坐标。

将搜索当地的maven repo,然后搜索maven中心和由–repositories提供的任何其他远程存储库。

坐标的格式应该是groupId:artifactId:version。

spark.files    --files    要放置在每个执行器的工作目录中的逗号分隔的文件列表。
以下是几个例子:

SPARK_SUBMIT_OPTIONS 在 conf/zeppelin-env.sh


export SPARK_SUBMIT_OPTIONS="--packages com.databricks:spark-csv_2.10:1.2.0 --jars /path/mylib1.jar,/path/mylib2.jar --files /path/mylib1.py,/path/mylib2.zip,/path/mylib3.egg" 

SPARK_HOME/conf/spark-defaults.conf


spark.jars        /path/mylib1.jar,/path/mylib2.jar

spark.jars.packages   com.databricks:spark-csv_2.10:1.2.0

spark.files       /path/mylib1.py,/path/mylib2.egg,/path/mylib3.zip  

3.通过%spark.dep解释器加载动态依赖关系
注:%spark.dep解释负载库%spark和%spark.pyspark而不是 %spark.sql翻译。所以我们建议你改用第一个选项。

当你的代码需要外部库,而不是下载/复制/重新启动Zeppelin,你可以使用%spark.dep解释器轻松地完成以下工作。

从maven库递归加载库
从本地文件系统加载库
添加额外的maven仓库
自动将库添加到SparkCluster(可以关闭)
解释器利用Scala环境。所以你可以在这里编写任何Scala代码。需要注意的是%spark.dep解释前应使用%spark,%spark.pyspark,%spark.sql。

这是用法


%spark.dep

z.reset() // clean up previously added artifact and repository

  

// add maven repository

z.addRepo("RepoName").url("RepoURL")

  

// add maven snapshot repository

z.addRepo("RepoName").url("RepoURL").snapshot()

  

// add credentials for private maven repository

z.addRepo("RepoName").url("RepoURL").username("username").password("password")

  

// add artifact from filesystem

z.load("/path/to.jar")

  

// add artifact from maven repository, with no dependency

z.load("groupId:artifactId:version").excludeAll()

  

// add artifact recursively

z.load("groupId:artifactId:version")

  

// add artifact recursively except comma separated GroupID:ArtifactId list

z.load("groupId:artifactId:version").exclude("groupId:artifactId,groupId:artifactId, ...")

  

// exclude with pattern

z.load("groupId:artifactId:version").exclude(*)

z.load("groupId:artifactId:version").exclude("groupId:artifactId:*")

z.load("groupId:artifactId:version").exclude("groupId:*")

  

// local() skips adding artifact to spark clusters (skipping sc.addJar())

z.load("groupId:artifactId:version").local() 

ZeppelinContext
Zeppelin 在Scala / Python环境中自动注入ZeppelinContext变量z。ZeppelinContext提供了一些额外的功能和实用程序。

对象交换
ZeppelinContext扩展地图,它在Scala和Python环境之间共享。所以你可以把Scala的一些对象从Python中读出来,反之亦然。

Scala

// Put object from scala

%spark

val myObject = ...

z.put("objName", myObject)

  

// Exchanging data frames

myScalaDataFrame = ...

z.put("myScalaDataFrame", myScalaDataFrame)

  

val myPythonDataFrame = z.get("myPythonDataFrame").asInstanceOf[DataFrame] 

Python 展开原码
表格创作
ZeppelinContext提供了创建表单的功能。在Scala和Python环境中,您可以以编程方式创建表单。

Scala

%spark

/* Create text input form */

z.input("formName")

  

/* Create text input form with default value */

z.input("formName", "defaultValue")

  

/* Create select form */

z.select("formName", Seq(("option1", "option1DisplayName"),

                         ("option2", "option2DisplayName")))

  

/* Create select form with default value*/

z.select("formName", "option1", Seq(("option1", "option1DisplayName"),

                                    ("option2", "option2DisplayName"))) 

 


%spark.pyspark

# Create text input form

z.input("formName")

 

# Create text input form with default value

z.input("formName", "defaultValue")

 

# Create select form

z.select("formName", [("option1", "option1DisplayName"),

                      ("option2", "option2DisplayName")])

 

# Create select form with default value

z.select("formName", [("option1", "option1DisplayName"),

                      ("option2", "option2DisplayName")], "option1") 

在sql环境中,可以在简单的模板中创建表单。

%spark.sql

select * from ${table=defaultTableName} where text like '%${search}%' 

要了解有关动态表单的更多信息,请检查Zeppelin 动态表单。

 

Matplotlib集成(pyspark)
这两个python和pyspark解释器都内置了对内联可视化的支持matplotlib,这是一个流行的python绘图库。更多细节可以在python解释器文档中找到,因为matplotlib的支持是相同的。通过利用齐柏林内置的角度显示系统,可以通过pyspark进行更先进的交互式绘图,如下所示:

 

解释器设置选项
您可以选择其中之一shared,scoped以及isolated配置Spark解释器的选项。Spark解释器为每个笔记本创建分离的Scala编译器,但在scoped模式(实验)中共享一个SparkContext。它在每个笔记本isolated模式下创建分离的SparkContext 。

 

用Kerberos设置Zeppelin
使用Zeppelin,Kerberos Key Distribution Center(KDC)和Spark on YARN进行逻辑设置:

配置设置
在安装Zeppelin的服务器上,安装Kerberos客户端模块和配置,krb5.conf。这是为了使服务器与KDC进行通信。

设置SPARK_HOME在[ZEPPELIN_HOME]/conf/zeppelin-env.sh使用火花提交(此外,您可能需要设置export HADOOP_CONF_DIR=/etc/hadoop/conf)

将以下两个属性添加到Spark configuration([SPARK_HOME]/conf/spark-defaults.conf)中:


spark.yarn.principal

spark.yarn.keytab

注意:如果您没有访问以上spark-defaults.conf文件的权限,可以选择地,您可以通过Zeppelin UI中的“解释器”选项卡将上述行添加到“Spark Interpreter”设置。

而已。玩Zeppelin!

 
--------------------- 

本文基于centos6.4、CDH版本5.7.6、spark版本为1.6.0

1.环境准备
git1.7.1、maven3.3.9、JDK1.8
1
2.下载最新版zeepline源码
wget http://mirror.bit.edu.cn/apache/zeppelin/zeppelin-0.7.3/zeppelin-0.7.3.tgz
tar -zxvf zeppelin-0.7.3.tgz 
cd zeeplin-0.7.3
1
2
3
3.编译
mvn -X clean package -Pspark-1.6 -Dhadoop.version=2.6.0-cdh5.7.6 -Phadoop-2.6  -Pyarn -Ppyspark -Psparkr  -Pvendor-repo -DskipTests -Pbuild-distr

[INFO] Zeppelin ........................................... SUCCESS [  8.360 s]
[INFO] Zeppelin: Interpreter .............................. SUCCESS [  5.909 s]
[INFO] Zeppelin: Zengine .................................. SUCCESS [ 22.396 s]
[INFO] Zeppelin: Display system apis ...................... SUCCESS [ 10.373 s]
[INFO] Zeppelin: Spark dependencies ....................... SUCCESS [ 32.613 s]
[INFO] Zeppelin: Spark .................................... SUCCESS [ 18.004 s]
[INFO] Zeppelin: Markdown interpreter ..................... SUCCESS [  0.734 s]
[INFO] Zeppelin: Angular interpreter ...................... SUCCESS [  0.259 s]
[INFO] Zeppelin: Shell interpreter ........................ SUCCESS [  0.374 s]
[INFO] Zeppelin: Livy interpreter ......................... SUCCESS [02:06 min]
[INFO] Zeppelin: HBase interpreter ........................ SUCCESS [  2.358 s]
[INFO] Zeppelin: Apache Pig Interpreter ................... SUCCESS [  2.589 s]
[INFO] Zeppelin: PostgreSQL interpreter ................... SUCCESS [  0.371 s]
[INFO] Zeppelin: JDBC interpreter ......................... SUCCESS [  0.682 s]
[INFO] Zeppelin: File System Interpreters ................. SUCCESS [  0.650 s]
[INFO] Zeppelin: Flink .................................... SUCCESS [  4.925 s]
[INFO] Zeppelin: Apache Ignite interpreter ................ SUCCESS [ 21.882 s]
[INFO] Zeppelin: Kylin interpreter ........................ SUCCESS [  0.298 s]
[INFO] Zeppelin: Python interpreter ....................... SUCCESS [01:29 min]
[INFO] Zeppelin: Lens interpreter ......................... SUCCESS [  1.920 s]
[INFO] Zeppelin: Apache Cassandra interpreter ............. SUCCESS [ 35.499 s]
[INFO] Zeppelin: Elasticsearch interpreter ................ SUCCESS [  5.039 s]
[INFO] Zeppelin: BigQuery interpreter ..................... SUCCESS [  2.585 s]
[INFO] Zeppelin: Alluxio interpreter ...................... SUCCESS [  1.680 s]
[INFO] Zeppelin: Scio ..................................... SUCCESS [ 29.029 s]
[INFO] Zeppelin: web Application .......................... SUCCESS [07:18 min]
[INFO] Zeppelin: Server ................................... SUCCESS [ 46.044 s]
[INFO] Zeppelin: Packaging distribution ................... SUCCESS [ 52.455 s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 16:00 min
[INFO] Finished at: 2018-03-25T12:10:07+08:00
[INFO] Final Memory: 332M/5705M
[INFO] ------------------------------------------------------------------------
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
具体参数请参考:http://zeppelin.apache.org/docs/0.7.3/install/build.html

4.部署Zeppelin
tar -zxvf ~/zeppelin-0.7.3/zeppelin-distribution/target/zeppelin-0.7.3.tar.gz -C /opt/bigdata/
ln -s /opt/bigdata/zeppelin-0.7.3 /opt/bigdata/zeppelin
bin/zeppelin-daemon.sh start
1
2
3
访问地址:http://localhost:8080,也可修改zeppelin-site.xml默认端口

5.配置访问hive仓库
通过jdbc方式访问hive,首先确保启动hiveserver2. 
1.拷贝hive相关驱动到zeppelin

cp ~/hive/lib/hive-exec-1.1.0-cdh5.7.6.jar   /opt/zepplin/interpreter/jdbc/
cp ~/hive/lib/hive-jdbc-1.1.0-cdh5.7.6.jar   /opt/zepplin/interpreter/jdbc/
cp ~/hive/lib/hive-metastore-1.1.0-cdh5.7.6.jar   /opt/zepplin/interpreter/jdbc/
cp ~/hive/lib/hive-serde-1.1.0-cdh5.7.6.jar   /opt/zepplin/interpreter/jdbc/
cp ~/hive/lib/hive-service-1.1.0-cdh5.7.6.jar  /opt/zepplin/interpreter/jdbc/
cp ~/hadoop/lib/hadoop-common-2.6.0-cdh5.7.6.jar /opt/zepplin/interpreter/jdbc/
1
2
3
4
5
6
2.重启zepplin

bin/zeppelin-daemon.sh restart
1
3.修改页面Interpreters jdbc配置 

点击restart按钮 
4.查询验证 


6.配置集成spark on yarn
zepplin目前支持,local、yarn-client、standalone和mesos等模式,默认为local模式 
1.修改zeppelin-env.sh

cp zeppelin-env.sh.template zeppelin-env.sh
export MASTER=yarn-client
export HADOOP_CONF_DIR=[your_hadoop_conf_path]
export SPARK_HOME=[your_spark_home_path]
export SPARK_SUBMIT_OPTIONS="--conf spark.dynamicAllocation.minExecutors=10 --executor-memory 2G --driver-memory 2g  --executor-cores 2"
1
2
3
4
5
*重启zepplin,打开UI.设置spark参数,restart 

验证spark,出错 

发现是zepplin/lib下面的有hadoop的commonjar包里面没有这个方法,本身已经配置CDH环境了,所以删除所有hadoopjar(很奇怪,之前编译的是CDH版本的) 


查看hdfs文件,报错 

jackson版本冲突导致,zepplin中的版本为2.5.3,spark1.6使用的为2.4,更换zepplin/lib下jackson-databind的版本重启即可。

wget http://central.maven.org/maven2/com/fasterxml/jackson/core/jackson-databind/2.4.4/jackson-databind-2.4.4.jar 
1
7.用户权限配置
zeppelin主要利用Apache Shiro做用户权限管理。 
1.关闭匿名访问,拷贝zeppelin-site.xml,设置zeppelin.anonymous.allowed=false

conf/zeppelin-site.xml.template to conf/zeppelin-site.xml
1
2.启用shiro,拷贝shiro文件

cp conf/shiro.ini.template conf/shiro.ini
1
shiro提供了基于users/roles/urls的权限控制,也有提供基于目录服务做用户权限,本问主要介绍基于用户角色权限的方式。 

[users] 
admin = admin, admin 
zhangsan=123456,readonly 
[roles] 
readonly= * 
admin = * 
[urls] 
/api/interpreter/** = authc, roles[admin] 
/api/configurations/** = authc, roles[admin] 
/api/credential/** = authc, roles[admin] 
/** = authc 

3.设置zeppelin已当前登录用户访问hive,不设置的话是已启动zeppelin进程的用户访问。 
参考官方文档:https://zeppelin.apache.org/docs/0.7.3/manual/userimpersonation.html 
有两种方式设置:

给每个用户做免密登录
设置ZEPPELIN_IMPERSONATE_CMD,这里采用ZEPPELIN_IMPERSONATE_CMD,vim zeppelin-env.sh 
“` 
export ZEPPELIN_IMPERSONATE_CMD=’sudo -H -u ${ZEPPELIN_IMPERSONATE_USER} bash -c ’ 
export ZEPPELIN_IMPERSONATE_SPARK_PROXY_USER=false
“` 
3. 重启zeppelin server. 
4. 管理员账号登录UI,设置spark interceptor的Impersonate,参考sh interceptor设置 
 

5. 创建hive表验证,查看hdfs目录用户权限

4设置node book权限,每个用户可以设置自己notebook权限 

文本框带suggest功能,输入用户简称可以自动提示

最后,有一篇zeppelin的中文翻译,虽然翻译的不怎么样,推荐给需要的朋友 
http://cwiki.apachecn.org/pages/viewpage.action?pageId=10030467

7.使用期间出现的bug有:
1.执行任务无法显示任务执行进度。 
WARN [2018-04-24 16:04:56,238] ({qtp745160567-15917} ServletHandler.java[doHandle]:620) - 
javax.servlet.ServletException: Filtered request failed. 
at org.apache.shiro.web.servlet.AbstractShiroFilter.doFilterInternal(AbstractShiroFilter.java:384) 
at org.apache.shiro.web.servlet.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:125) 
at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1652) 
at org.apache.zeppelin.server.CorsFilter.doFilter(CorsFilter.java:72) 
at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1652) 
at org.eclipse.jetty.servlet.ServletHandler.doHandle(ServletHandler.java:585) 
at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:143) 
at org.eclipse.jetty.security.SecurityHandler.handle(SecurityHandler.java:577) 
at org.eclipse.jetty.server.session.SessionHandler.doHandle(SessionHandler.java:223) 
at org.eclipse.jetty.server.handler.ContextHandler.doHandle(ContextHandler.java:1127) 
at org.eclipse.jetty.servlet.ServletHandler.doScope(ServletHandler.java:515) 
at org.eclipse.jetty.server.session.SessionHandler.doScope(SessionHandler.java:185) 
at org.eclipse.jetty.server.handler.ContextHandler.doScope(ContextHandler.java:1061) 
at org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:141) 
at org.eclipse.jetty.server.handler.ContextHandlerCollection.handle(ContextHandlerCollection.java:215) 
at org.eclipse.jetty.server.handler.HandlerWrapper.handle(HandlerWrapper.java:97) 
at org.eclipse.jetty.server.Server.handle(Server.java:499) 
at org.eclipse.jetty.server.HttpChannel.handle(HttpChannel.java:311) 
at org.eclipse.jetty.server.HttpConnection.onFillable(HttpConnection.java:257) 
at org.eclipse.jetty.io.AbstractConnection$2.run(AbstractConnection.java:544) 
at org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:635) 
at org.eclipse.jetty.util.thread.QueuedThreadPool$3.run(QueuedThreadPool.java:555) 
at java.lang.Thread.run(Thread.java:745) 
Caused by: java.lang.AbstractMethodError: javax.ws.rs.core.Response.getStatusInfo()Ljavax/ws/rs/core/Response$StatusType; 
at javax.ws.rs.WebApplicationException.validate(WebApplicationException.java:186) 
at javax.ws.rs.ClientErrorException.<init>(ClientErrorException.java:88) 
at org.apache.cxf.jaxrs.utils.JAXRSUtils.findTargetMethod(JAXRSUtils.java:503) 
at org.apache.cxf.jaxrs.interceptor.JAXRSInInterceptor.processRequest(JAXRSInInterceptor.java:198) 
at org.apache.cxf.jaxrs.interceptor.JAXRSInInterceptor.handleMessage(JAXRSInInterceptor.java:90) 
at org.apache.cxf.phase.PhaseInterceptorChain.doIntercept(PhaseInterceptorChain.java:272) 
at org.apache.cxf.transport.ChainInitiationObserver.onMessage(ChainInitiationObserver.java:121) 
at org.apache.cxf.transport.http.AbstractHTTPDestination.invoke(AbstractHTTPDestination.java:239) 
at org.apache.cxf.transport.servlet.ServletController.invokeDestination(ServletController.java:248) 
at org.apache.cxf.transport.servlet.ServletController.invoke(ServletController.java:222) 
at org.apache.cxf.transport.servlet.ServletController.invoke(ServletController.java:153) 
at org.apache.cxf.transport.servlet.CXFNonSpringServlet.invoke(CXFNonSpringServlet.java:167) 
at org.apache.cxf.transport.servlet.AbstractHTTPServlet.handleRequest(AbstractHTTPServlet.java:286) 
at org.apache.cxf.transport.servlet.AbstractHTTPServlet.doGet(AbstractHTTPServlet.java:211) 
at javax.servlet.http.HttpServlet.service(HttpServlet.java:687) 
at org.apache.cxf.transport.servlet.AbstractHTTPServlet.service(AbstractHTTPServlet.java:262) 
at org.eclipse.jetty.servlet.ServletHolder.handle(ServletHolder.java:812) 
at org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1669) 

解决方案: 
javax.ws.rs.core.Response.getStatusInfo(),是JAX-RS 2里面的功能,cxf使用是JAX-RX 1,替换cxf相关依赖。 
zeppelin 0.8.0好像已经解决。https://issues.apache.org/jira/browse/ZEPPELIN-903
--------------------- 

一.需求

在使用spark-streaming 处理流式任务时,由于spark-shell需要登录到和生产集群相连的机器开启,使用起来也有诸多不便,且默认不支持kafka等源,所以萌生使用zeppelin 中的spark interpreter来完成streaming 任务.

 

二.尝试

在网上找到了一个改版的zeppelin版wordcount例子.

第一步启动nc 监听端口7777

第二步在zeppelin spark interpreter 中启动streming任务

%spark

sc.version
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.StreamingContext._
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.Duration
import org.apache.spark.streaming.Seconds
case class Message(createdAt:Long, text:String)
val ssc = new StreamingContext(sc, Seconds(10))
val lines = ssc.socketTextStream("10.104.90.40", 7777)
val errorLines = lines.window(Seconds(10))
val message = errorLines.map(status=>
Message(System.currentTimeMillis()/1000, status)
).foreachRDD(rdd=>
if (rdd.isEmpty()==false) {
rdd.toDF().registerTempTable("message")}
)
errorLines.print
ssc.start()

 

第三步在nc中输入一些测试数据,在zeppelin spark interpreter读取streaming处理的结果

%spark
val data = sqlContext.sql("select * from message")
data.show()

得到类似如下的输出

data: org.apache.spark.sql.DataFrame = [createdAt: bigint, text: string]
+----------+----+
| createdAt|text|
+----------+----+
|1493709315| asd|
|1493709321| as|
|1493709321| d|
|1493709321| asd|
|1493709315| as|
|1493709315| d|
|1493709321| asd|
|1493709321| as|
|1493709321| das|
|1493709315| d|
|1493709321| as|
|1493709315| d|
|1493709315| 1q2|
|1493709321| 3|
|1493709321| 12|
|1493709321| 312|
|1493709315| |
|1493709321| 3|
|1493709315| 123|
|1493709321| qw|
+----------+----+
only showing top 20 rows


三.问题

尝试的过程中发现了如下问题:

1.停止streaming context的方式不正确

如果使用ssc.stop()停止spark streaming context 会导致zeppelin 服务端的spark context也一并停止,导致出现如下的错误,并且在web ui重启spark interpreter也不解决问题,最后只能重启整个zeppelin 服务.

java.lang.IllegalStateException: RpcEnv has been stopped

在zeppelin中停止streaming context的正确方式为

ssc.stop(stopSparkContext=false, stopGracefully=true)

 

2.nc server同一时间只能服务一个client

刚开始尝试nc用法时,先使用nc -lk 7777启动server端,再使用nc locahost 7777启动client,尝试互相传送信息成功,在zeppelin 中streaming任务却总是读不到任何数据

原因就在于nv server只能同时服务一个client端.

在多个client 端同时链接server 端时,按建立链接的先后会出现只有一个client端口能接收数据的情况.

如果zeppelin中的streaming任务作为client端接收到了server端的消息,即使按照1中的方法停止了streaming context,别的client端也依然接受不到消息,推测可能是server端服务对象仍然为streaming 任务.

 

3.ERROR [2017-05-02 11:31:12,686] ({dispatcher-event-loop-2} Logging.scala[logError]:70) - Deregistered receiver for stream 0: Restarting receiver with delay 2000ms: Error connecting to loc 

alhost:7777 - java.net.ConnectException: Connection refuse

开始时使用localhost 作为socketTextStream中的host地址,却总是会出现上面的错误,但是使用telnet >open  localhost 7777却可以成功建立链接

把localhost 改成10.104.90.40 则不会再出现上述错误,推测原因在于zepplin 使用的spark interpreter设置运行在了cluster mode,在除10.104.90.40 以为的机器上并没有nc 运行,7777端口也是不通的,所以会出现访问拒绝.

4.Attempted to use BlockRDD[36063] at socketTextStream at <console>:217 after its blocks have been removed!

当使用val data = sqlContext.sql("select * from message")查看streaming 处理结果时,查询后一段时间(几s)后再次运行查询任务就会出现如上错误.

在zeppelin spark interpreter日志中发现每个窗口执行完之后都与类似如下的日志

Removing RDD 37697 from persistence list 

从这篇文章中的代码分析可见出错原因在于blockrdd 已经被删了导致,结合spark streaming dag任务结束后会删除数据可知

这个报错的原因在于message这张由registerTempTable 产生的表实际的存储rdd已经被删除导致.

5.hive接入问题,不解

 

INFO [2017-04-28 22:15:10,455] ({pool-2-thread-2} HiveMetaStoreClient.java[open]:376) - Trying to connect to metastore with URI thrift://10.104.90.40:9083 

 

WARN [2017-04-28 22:15:10,456] ({pool-2-thread-2} UserGroupInformation.java[getGroupNames]:1492) - No groups available for user heyang.wang 

 

WARN [2017-04-28 22:15:10,462] ({pool-2-thread-2} HiveMetaStoreClient.java[open]:444) - set_ugi() not successful, Likely cause: new client talking to old server. Continuing without it.

5.1假期前一度出现的问题,只要对rdd进行相关action类操作如rdd.toDf,rdd.collect等就会触发,但是当时hive cli和beeline都可以正常访问hive,hive metastore 日志中也没有报错信息.

但是5.1假期或却又没问题了.

四.尝试在livy中运行spark-streaming任务


经过测试,在livy中可以以同样的方式使用spark streaming,只需要改%spark为%livy.spark


五.接入kafka数据源(未完)

参考来源:

https://www.zeppelinhub.com/viewer/notebooks/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2hhZml6dXItcmFobWFuL2NjcC1jaGFsbGVuZ2UxL21hc3Rlci96ZXBwZWxpbi9ub3RlYm9vay8yQVdLWFhKTVgvbm90ZS5qc29u

http://apache-spark-user-list.1001560.n3.nabble.com/Lifecycle-of-RDD-in-spark-streaming-td19749.html

http://www.jianshu.com/p/0e7e540de15c

http://stackoverflow.com/questions/29728151/how-to-listen-for-multiple-tcp-connection-using-nc

http://apache-zeppelin-users-incubating-mailing-list.75479.x6.nabble.com/Thrift-Exception-when-executing-a-custom-written-Interpreter-td1993.html


--------------------- 

lin参数配置
Kylin Interpreter已经集成到Zeppelin 0.5.5的主代码中,所以直接在Zeppelin的配置页面可以找到Kylin配置信息。启动Zeppelin后,在主页点击header上的 Interpreter到该页面找到Kylin配置栏填上配置信息。

Kylin Interpreter主要功能是把前台的配置信息和要运行的SQL转换成一个HTTP请求以获取结果,然后按照Zeppelin的规范转换格式,主要就是完成一次HTTP请求,并把自己项目的查询结果按照Zeppelin的规范格式化,这样就能配合前端展示。所以这里的配置参考Kylin Query API即可,默认修改URL,账号,密码,Project信息即可,更多关于Kylin API信息点这里(http://kylin.apache.org/docs/howto/howto_use_restapi.html)。
---------------------

--------------------- 

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!