Zookeeper+Kafka+Spark streaming单机整合开发
环境准备：
ubuntu 开发环境：
jdk 1.8
scala：2.11.0
spark 2.0
zookeeper 3.4.6
kafka 2.12-0.10.2.0
开始整合：
1 zookeeper的安装，这里我使用的zookeeper版本为3.4.6
a， 下载zookeeper安装包zookeeper-3.4.6.tar.gz
b， 解压安装文件到/usr/local/ 这是我的安装目录，具体可根据自己的情况而定：
sudo tar -zxvf zookeeper-3.4.6.tar.gz -C /usr/local
c， 进入/usr/local并重命名解压的文件名
cd /usr/local
sudo mv zookeeper-3.4.6/ zookeeper
# 为当前用户加入授权
sudo chown -R hadoop ./zookeeper # 我这里的用户名为hadoop,具体情况根据自己的情况写
d，进入zookeeper安装文件夹的配置文件所在文件夹conf
#创建存数据的文件
mkdir /home/hadoop/zookeeper
cd /zookeeper/conf
# 为zookeeper设置配置文件
cp -a zoo_sample.cfg zoo.cfg
修改配置文件
vim zoo.cfg
# 心跳时间，为了确保连接存在的，以毫秒为单位，最小超时时间为两个心跳时间
tickTime=2000
# 多少个心跳时间内，允许其他server连接并初始化数据，如果ZooKeeper管理的数据较大，则应相应增大这个值
initLimit=10
# leader 与 follower 之间发送消息，请求和应答时间长度。如果 follower 在设置的时间内不能与 leader 进行通信，那么此 follower 将被丢弃。这里应答的时间长度为5
syncLimit=5
# 用于存放内存数据库快照的文件夹，同时用于集群的myid文件也存在这个文件夹里，这里设为之前创建的文件夹
dataDir=/home/hadoop/zookeeper
# 服务的监听端口
clientPort=2181
2 kafka的安装以及配置：我使用的版本为2.12-0.10.2.0
a，下载kafka安装包kafka_2.12-0.10.2.0.tgz
b， 解压安装包至指定安装目录，这里我的安装目录是/usr/local/
sudo tar -zxvf kafka_2.12-0.10.2.0.tgz -C /usr/local/
cd /usr/local
sudo mv kafka_2.12-0.10.2.0/ kafka
sudo chwon -R hadoop ./kafka # 把当前用户授权于kafka文件
c， 修改配置文件
cd config
# 创建kafka数据存放的地址
mkdir /home/hadoop/kafka
vim server.properties
# 每一个broker在集群中的唯一表示，要求是正数。当该服务器的IP地址发生改变时，broker.id没有变化，则不会影响consumers的消息情况,这里由于是伪分布式，直接设为0即可
broker.id =0
#broker server服务端口
port =9092
# 配置zookeeper的集群的地址
zookeeper.connect=localhost:2181
# kafka数据的存放地址
log.dirs=/home/hadoop/kafka
# 其他的配置不用修改！！
3 为方便在以后的使用，添加环境变量到~/.bashrc中，并创建简单的启动shell
a，配置环境变量
vim ~/.bashrc
# 在文件的开头添加
# Kafka
export KAFKA_HOME=/usr/local/kafka #这里是我的安装目录，实际情况，根据自己的安装目录来定
export PATH=${KAFKA_HOME}/bin:$PATH
export PATH=${KAFKA_HOME}/config:$PATH
# zookeeper
export ZOOKEEPER_HOME=/usr/local/zookeeper
export PATH=$PATH:$ZOOKEEPER_HOME/bin
b，创建简单的启动shell，启动zookeeper和kafka
vim Start-Server.sh
#!/bin/bash
# 启动 zookeeper
/usr/local/zookeeper/bin/zkServer.sh start
# 启动 kafka
/usr/local/kafka/bin/kafka-server-start.sh /usr/local/kafka/config/server.properties
vim Stop-Server.sh
#!/bin/bash
# 关闭 kafka
/usr/local/kafka/bin/kafka-server-stop.sh /usr/local/kafka/config/server.properties
# 由于可能关闭kafka时有延迟，暂定1毫秒再执行关闭zookeeper的命令
sleep 1
# 关闭 zookeeper
/usr/local/zookeeper/bin/zkServer.sh stop
# 为写的脚本授权
sudo chmod 777 Start-Server.sh
sudo chmod 777 Stop-Server.sh
4 streaming 和 kafka 的整合使用
a，使用maven建立kafka所用到包的依赖
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
<version>2.1.1</version>
</dependency>
</dependencies>
××Buid Path相关spark下面的jar包
b，方式一 命令行方式
创建一个topic test
kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test
发送数据
kafka-topics.sh --list --zookeeper localhost:2181
方式二 创建scala程序Producer类，读取hdfs上的文件，并发送到kafka消息队列上
import java.util.Properties;
import java.lang.Runnable;
import java.net.URI;
import java.io.*;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.conf.*;
import org.apache.hadoop.io.*;
/**
* 向kafka上面发送数据
* 读取hdfs上的文件，并写入本地文件，再发送到kafka消息队列上
* */
class TestKafkaProducer implements Runnable{
/**
* 对于kafka producer的相关配置文件项
**/
public static Properties getProducerCnfig() {
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("acks", "all");
props.put("retries", 0);
props.put("batch.size", 16384);
props.put("linger.ms", 1);
props.put("buffer.memory", 33554432);
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
return props;
}
public void run(){
// 获取配置文件
Properties props = getProducerCnfig();
// 创建生产者
Producer<String, String> producer = new KafkaProducer(props);
try{
//读取保存的文件
FileInputStream fis=new FileInputStream("/home/hadoop/text.txt");
InputStreamReader isr= new InputStreamReader(fis, "UTF-8");
BufferedReader br = new BufferedReader(isr);
String line = "";
String[] arrs = null;
while ((line = br.readLine())!=null) {
producer.send(new ProducerRecord<String, String>("test", line));
}
br.close();
isr.close();
fis.close();
}catch (Exception e){e.printStackTrace();}
}
}
public class Tess{
public static void main(String[] args) throws IOException{
Tess.getFIle();
new Thread(new TestKafkaProducer()).start();
System.out.println("发送结束");
}
/**
* 获取hdfs上的文件，并保存制定文件夹下
* */
public static void getFIle() throws IOException{
String uri = "hdfs://localhost:9000/test/zookeeper.properties";
Configuration conf = new Configuration();
FileSystem fs = FileSystem.get(URI.create(uri), conf);
InputStream in = null;
FileOutputStream fos = new FileOutputStream(new File("/home/hadoop/text.txt"));
try {
in = fs.open(new Path(uri));
in.skip(100);
IOUtils.copyBytes(in, fos, 4096, false);
}catch (Exception e){
e.printStackTrace();
}finally {
IOUtils.closeStream(in);
IOUtils.closeStream(fos);
}
}
}
streaming使用打印kafka上的消息,注意在运行这个程序时，需要配置args的参数，第一个为brokers 第二个为topic，
我这在单机下，配置的args为：localhost：9092 test
package com.learn
import kafka.serializer.StringDecoder
import org.apache.spark.streaming._
import org.apache.spark.streaming.kafka._
import org.apache.spark.SparkConf
object KafkaAndPrintInSpark {
//判断设置的时输入参数，是否包含brokers 和 topic 至少参数的长度为2，即单机运行一个test的topic： broker=localhost:9092 topic=test
def main(args: Array[String]) {
if (args.length < 2) {
System.err.println(s"""
|Usage: DirectKafkaWordCount <brokers> <topics>
| <brokers> is a list of one or more Kafka brokers
| <topics> is a list of one or more kafka topics to consume from
|
""".stripMargin)
System.exit(1)
}
//将参数args读入到数组中
val Array(brokers, topics) = args
// 用2秒批间隔创建上下文
val sparkConf = new SparkConf().setMaster("local[2]").setAppName("DirectKafkaWordCount")
val ssc = new StreamingContext(sparkConf, Seconds(2))
// 创建kafka流与brokers和topic
val topicsSet = topics.split(",").toSet
val kafkaParams = Map[String, String]("metadata.broker.list" -> brokers)
val messages = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](
ssc, kafkaParams, topicsSet)
//打印获取到的数据
val lines = messages.map(_._2)
lines.print()
// 开始计算
ssc.start()
ssc.awaitTermination()
}
}
