kafka搭建及使用
1、上传压缩包到任意节点
2、解压,配置环境变量 所有节点都配置
3、修改config/server.properties
1、broker.id=0 #每一个节点broker.id 要不一样
2、zookeeper.connect=master:2181,node1:2181,node2:2181
3、log.dirs=/usr/local/soft/kafka_2.11-1.0.0/data #消息存放的位置
4、复制到其它节点
scp -r kafka_2.11-1.0.0 node2:`pwd`
scp -r kafka_2.11-1.0.0 node1:`pwd`
5、修改每个节点的broker.id
master=0 node1=1 node2=2
6、启动
先启动zookeeper, 需要在所有节点启动
zkServer.sh start
查看状态每个节点
zkServer.sh status
3,在每台节点启动broker, kafka是去中心化的架构 , 在所有节点启动
-daemon:后台启动
kafka-server-start.sh -daemon /usr/local/soft/kafka_2.11-1.0.0/config/server.properties
使用
1、创建topic
–replication-factor —每一个分区的副本数量
–partition --分区数, 根据数据量设置
kafka-topics.sh --create --zookeeper master:2181 --replication-factor 1 --partitions 3 --topic test_topic1
2、查看topic描述信息
kafka-topics.sh --describe --zookeeper master:2181 --topic test_topic1
3、获取所有topic
kafka-topics.sh --list --zookeeper master:2181
4、创建控制台生产者
kafka-console-producer.sh --broker-list master:9092 --topic test_topic1
5、创建控制台消费者 , 如果不在执行消费的新的数据
–from-beginning 从头消费
kafka-console-consumer.sh --bootstrap-server master:9092 --from-beginning --topic test_topic1
下面的图下半部分是生产者,上半部分是消费者
kafkasource
package com.liu.source
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer
import java.util.Properties
/**
* @ Author : ld
* @ Description :
* @ Date : 2021/11/25 20:16
* @ Version : 1.0
*/
object DemoKafkaSource {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
val properties = new Properties()
properties.setProperty("bootstrap.servers","master:9092")
properties.setProperty("group.id","test2")
//创建flink kafka 消费者
val flinkKafkaConsumer = new FlinkKafkaConsumer[String]("test_topic1", new SimpleStringSchema(), properties)
// flinkKafkaConsumer.setStartFromEarliest()//尽可能从最早的纪录开始
// flinkKafkaConsumer.setStartFromLatest()//从最新的纪录开始
// flinkKafkaConsumer.setStartFromTimestamp()//从指定时间开始(毫秒)
/**
* 如果消费者组之前不存在,读取最新的数据
* 如果消费者组已存在,接着之前读取数据
*/
flinkKafkaConsumer.setStartFromGroupOffsets()//默认方法
val kafkaDS: DataStream[String] = env.addSource(flinkKafkaConsumer)
kafkaDS.print()
env.execute()
}
}
kafka的API
创建生产者例子:
package com.liu.kafka
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord}
import java.util.Properties
/**
* @ Author : ld
* @ Description :
* @ Date : 2021/11/25 20:54
* @ Version : 1.0
*/
object Demo1KafkaProducer {
def main(args: Array[String]): Unit = {
/**
* 1.创建kafka连接
* 创建生产者
*/
val properties = new Properties()
//指定kafka的broker的地址
properties.setProperty("bootstrap.servers","master:9092")
//key和value序列化
properties.setProperty("key.serializer","org.apache.kafka.common.serialization.StringSerializer")
properties.setProperty("value.serializer","org.apache.kafka.common.serialization.StringSerializer")
//生产者
val producer = new KafkaProducer[String,String](properties)
//生产数据
val record = new ProducerRecord[String, String]("test1", "java")
producer.send(record)
//把数据刷到kafka中
producer.flush()
//关闭连接
producer.close()
}
}
创建一个生产者结合消费者使用
package com.liu.kafka
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord}
import java.util.Properties
import scala.io.Source
/**
* @ Author : ld
* @ Description :
* @ Date : 2021/11/25 20:55
* @ Version : 1.0
*/
object Demo2StudentToKafka {
def main(args: Array[String]): Unit = {
/**
* 1、创建kfaka链接
* 创建生产者
*
*/
val properties = new Properties()
//指定kafka地址
properties.setProperty("bootstrap.servers","master:9092")
//key和value序列化
properties.setProperty("key.serializer","org.apache.kafka.common.serialization.StringSerializer")
properties.setProperty("value.serializer","org.apache.kafka.common.serialization.StringSerializer")
//生产者
val producer = new KafkaProducer[String, String](properties)
//读取学生表
Source
.fromFile("Flink/data/student.txt")
.getLines()
.foreach(student=>{
//把同一个班级学生打入同一个分区
val clazz = student.split(",")(4)
val partition = math.abs(clazz.hashCode) % 2
//将数据发送到kafka
//kafka-topics.sh --create --zookeeper master:2181 --replication-factor 1 --partitions 2 --topic student3
val record = new ProducerRecord[String, String]("student3", partition, null, student)
producer.send(record)
producer.flush()
})
//关闭连接
producer.close()
}
}
消费者,结合上面的
package com.liu.kafka
import org.apache.kafka.clients.consumer.KafkaConsumer
import java.util
import java.util.Properties
/**
* @ Author : ld
* @ Description :
* @ Date : 2021/11/25 20:55
* @ Version : 1.0
*/
object Demo3Consumer {
def main(args: Array[String]): Unit = {
//创建消费者
val properties = new Properties()
//指定kafka地址
properties.setProperty("bootstrap.servers","master:9092")
//key和value序列化
properties.setProperty("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer")
properties.setProperty("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer")
properties.setProperty("group.id","aaaa")
/**
* earliest
* 当各分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,从头开始消费
* latest
* 当各分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,消费新产生的该分区下的数据
* none
* topic各分区都存在已提交的offset时,从offset后开始消费;只要有一个分区不存在已提交的offset,则抛出异常
*
*/
//从最早读取数据
properties.put("auto.offset.reset","earliest")
val consumer = new KafkaConsumer[String, String](properties)
//订阅topic
val topics = new util.ArrayList[String]()
topics.add("student3")
consumer.subscribe(topics)
//消费数据
val recodes = consumer.poll(1000)
val iterator = recodes.iterator()
while(iterator.hasNext){
//获取一行数据
val recode = iterator.next()
val topic = recode.topic()
val partition = recode.partition()
val offset = recode.offset()
val key = recode.key()
val value = recode.value()
//默认是系统时间
val timestamp = recode.timestamp()
println(s"$topic\t$partition\t$offset\t$key\t$value\t$timestamp")
}
consumer.close()
}
}
kafka整合flume(监听hadoop日志)
1、生成数据
echo “java,spark” >> /usr/flume/log.log
2、启动flume监听日志文件,将数据打入kafka
- 在kafka里面创建topic (如果没有默认页会创建,但是只有一个分区)
kafka-topics.sh --create --zookeeper node1:2181,node2:2181,master:2181 --replication-factor 3 --partitions 3 --topic flume
3、启动kafka控制台消费者查看数据
kafka-console-consumer.sh --bootstrap-server master:9092,node1:9092,node2:9092 --from-beginning --topic flume
4.监控hadoop的日志
上传一个配置文件FlumeToKafka.properties
agent.sources=s1
agent.channels=c1
agent.sinks=k1
agent.sources.s1.type=exec
#监听文件地址
agent.sources.s1.command=tail -F /usr/local/soft/hadoop-2.7.6/logs/hadoop-root-namenode-master.log
agent.channels.c1.type=memory
agent.channels.c1.capacity=10000
agent.channels.c1.transactionCapacity=100
#设置Kafka接收器
agent.sinks.k1.type=org.apache.flume.sink.kafka.KafkaSink
#设置Kafka的broker地址和端口号
agent.sinks.k1.brokerList=master:9092,node1:9092,node2:9092
#设置Kafka的Topic 如果topic不存在会自动创建一个topic,默认分区为1,副本为1
agent.sinks.k1.topic=hadoop-namenode-log
#设置序列化方式
agent.sinks.k1.serializer.class=kafka.serializer.StringEncoder
#将三个主件串联起来
agent.sources.s1.channels=c1
agent.sinks.k1.channel=c1
#flume-ng agent -n agent -f ./FlumeToKafka.properties -Dflume.root.logger=DEBUG,console
#kafka-console-consumer.sh --zookeeper node1:2181 --from-beginning --topic flume
启动flume
flume-ng agent -n agent -f ./FlumeToKafka.properties -Dflume.root.logger=INFO,console
查看topic,有了hadoop-namenode-log
开始消费
关闭hadoop后日志也出现了
重置kafka相关命令
1、关闭kafka
kill -9 端口号
2、删除元数据 kafka元数据存在ZooKeeper上
zkCli.sh
删除预kafka有关的所有信息
ls /
rmr /config
rmr /brokers
3、删除kafka的数据 所有节点都要删除
rm -rf /usr/local/soft/kafka_2.11-1.0.0/data
4 重启
kafka-server-start.sh -daemon /usr/local/soft/kafka_2.11-1.0.0/config/server.properties