kafka搭建及使用

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