flink06 kafka的搭建与使用

一、kafka的搭建

1、上传解压修改环境变量

# 解压
tar -xvf kafka_2.11-1.0.0.tgz
mv kafka_2.11-1.0.0 kafka-1.0.0


# 配置环境变量
vim /etc/profile

export KAFKA_HOME=/usr/local/soft/kafka-1.0.0
export PATH=$PATH:$KAFKA_HOME/bin

source /etc/profile

2、修改配置文件

vim config/server.properties

broker.id=0 #每一个节点broker.id 要不一样
zookeeper.connect=master:2181,node1:2181,node2:2181/kafka  #zookeeper集群
log.dirs=/usr/local/soft/kafka-1.0.0/data   #数据存放的位置

3、将kafka文件进行同步

# 同步kafka文件
scp -r kafka-1.0.0/ node1:`pwd`
scp -r kafka-1.0.0/ node2:`pwd`

# 将master中的而环境变量同步到node1和node2中
scp /etc/profile node1:/etc/
scp /etc/profile node2:/etc/

#  在ndoe1和node2中执行source
source /etc/profile

4、修改同步的配置文件中的broker.id

vim config/server.properties

# node1
broker.id=1
# node2
broker.id=2

5、启动kafka

# 1、需要启动zookeeper,  kafka使用zo保存元数据
# 需要在每隔节点中执行启动的命令
zkServer.sh start
# 查看启动的状体
zkServer.sh status

# 2、启动kafka，每个节点中都要启动（去中心化的架构）
# -daemon后台启动
kafka-server-start.sh -daemon /usr/local/soft/kafka-1.0.0/config/server.properties

# 测试是否成功
#生产者
kafka-console-producer.sh --broker-list master:9092,node1:9092,node2:9092 --topic shujia

# 消费者
 --from-beginning   从头消费，， 如果不在执行消费的新的数据
kafka-console-consumer.sh --bootstrap-server  master:9092,node1:9092,node2:9092 --from-beginning --topic shujia

二、使用kafka

1、创建topic

        在生产和消费数据时，如果topic不存在会自动创建一个分区为1，副本为1的topic

--replication-factor  ---每一个分区的副本数量, 同一个分区的副本不能放在同一个节点，副本的数量不能大于kafak集群节点的数量
--partition   --分区数，  根据数据量设置
--zookeeper zk的地址，将topic的元数据保存在zookeeper中

kafka-topics.sh --create --zookeeper master:2181,node1:2181,node2:2181/kafka --replication-factor 2 --partitions 3 --topic bigdata

2、查看topic描述信息

kafka-topics.sh --describe  --zookeeper master:2181,node1:2181,node2:2181/kafka --topic bigdata

3、获取所有topic

        __consumer_offsetsL kafka用于保存消费便宜量的topic

kafka-topics.sh --list  --zookeeper  master:2181,node1:2181,node2:2181/kafka

4、创建控制台生产者

kafka-console-producer.sh --broker-list master:9092,node1:9092,node2:9092 --topic bigdata

5、创建控制台消费者

 --from-beginning   从头消费，， 如果不在执行消费的新的数据
kafka-console-consumer.sh --bootstrap-server  master:9092,node1:9092,node2:9092 --from-beginning --topic bigdata

kafka数据的保存

# 1、保存的文件
/usr/local/soft/kafka_2.11-1.0.0/data

# 2，每一个分区每一个副本对应一个目录

# 3、每一个分区目录中可以有多个文件， 文件时滚动生成的
00000000000000000000.log
00000000000000000001.log
00000000000000000002.log

# 4、滚动生成文件的策略
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000

# 5、文件删除的策略，默认时7天，以文件为单位删除
log.retention.hours=168

三、Kafka Java API

java代码创建生产者：

public class Demo01KafkaProducer {
    public static void main(String[] args) {

        Properties properties = new Properties();

        //指定broker列表
        properties.setProperty("bootstrap.servers", "master:9092,node2:9092,node2:9092");
        //指定key和value的数据格式
        properties.setProperty("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.setProperty("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        //创建生产者
        KafkaProducer<String,String> producer = new KafkaProducer<>(properties);

        //生产数据
        producer.send(new ProducerRecord<>("words","java"));
        producer.flush();

        //关闭连接
        producer.close();
    }
}

java代码创建生产者案例：

public class Demo02StudentToKafka {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();

        //指定broker列表
        properties.setProperty("bootstrap.servers", "master:9092,node2:9092,node2:9092");
        //指定key和value的数据格式
        properties.setProperty("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.setProperty("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //创建生产者
        KafkaProducer<String,String> producer = new KafkaProducer<>(properties);

        FileReader fw = new FileReader("flink/src/data/students.csv");
        BufferedReader br = new BufferedReader(fw);
        String line;
        while ((line = br.readLine()) != null){
            producer.send(new ProducerRecord<>("students",line));
            producer.flush();
        }

        //关闭资源
        fw.close();
        br.close();
        producer.close();

    }
}

java代码创建消费者：

public class Demo03Consumer {
    public static void main(String[] args) {

        Properties properties = new Properties();
        //kafka 集群列表
        properties.setProperty("bootstrap.servers", "master:9092,node2:9092,node2:9092");

        //读取数据的格式
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        /*
         * earliest
         * 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
         * latest  默认
         * 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产认值生的该分区下的数据
         * none
         * topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
         *
         */
        properties.setProperty("auto.offset.reset", "earliest");
        //指定消费者组，一条数据在一个组内只消费一次
        properties.setProperty("group.id", "asdsadasd");

        //创建消费者
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(properties);

        //订阅topic
        ArrayList<String> topics = new ArrayList<>();
        topics.add("students");
        consumer.subscribe(topics);

        while (true){
            //拉取数据
            ConsumerRecords<String, String> consumerRecords = consumer.poll(1000);

            //循环解析数据
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                String topic = consumerRecord.topic();
                long offset = consumerRecord.offset();
                int partition = consumerRecord.partition();
                String value = consumerRecord.value();
                long timestamp = consumerRecord.timestamp();

                System.out.println(topic + "\t" + offset + "\t" + partition + "\t" + value + "\t" + timestamp);
            }
        }

    }
}

四、Kafka ON Flink

KafkaSource：

public class Demo01KafkaSource {
    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //创建kafka source
        KafkaSource<String> source = KafkaSource.<String>builder()
                .setBootstrapServers("master:9092,node1:9092,node2:9092")//kafka集群列表
                .setTopics("students")//指定消费的topic
                .setGroupId("my-group")//指定消费者组

                // 从消费组提交的位点开始消费，如果提交位点不存在，使用最早位点
                //.setStartingOffsets(OffsetsInitializer.committedOffsets(OffsetResetStrategy.EARLIEST))
                // 从最早位点开始消费
                .setStartingOffsets(OffsetsInitializer.earliest())
                // 从最末尾位点开始消费
                //.setStartingOffsets(OffsetsInitializer.latest())

                .setValueOnlyDeserializer(new SimpleStringSchema())//指定读取数据的格式
                .build();

        //使用kafka source
        DataStreamSource<String> studentDS = env
                .fromSource(source, WatermarkStrategy.noWatermarks(), "Kafka Source");

        studentDS.print();

        env.execute();
    }
}

KafkaSink：

public class Demo02KafkaSink {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<String> carsDS = env.readTextFile("flink/src/data/cars_sample.json");

        //创建kafka sink
        KafkaSink<String> sink = KafkaSink.<String>builder()
                .setBootstrapServers("master:9092,node1:9092,node2:9092")//kafka集群列表
                .setRecordSerializer(KafkaRecordSerializationSchema.builder()
                        .setTopic("cars")//指定topic
                        .setValueSerializationSchema(new SimpleStringSchema())//指定数据格式
                        .build()
                )
                //指定数据处理的语义
                .setDeliverGuarantee(DeliveryGuarantee.AT_LEAST_ONCE)
                .build();

        //使用kafka sink
        carsDS.sinkTo(sink);

        env.execute();
    }
}

jason数据cars的解析：

public class Demo03Cars {
    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //创建kafka source
        KafkaSource<String> source = KafkaSource.<String>builder()
                .setBootstrapServers("master:9092,node1:9092,node2:9092")//kafka集群列表
                .setTopics("cars")//指定消费的topic
                .setGroupId("my-group")//指定消费者组
                // 从最早位点开始消费
                .setStartingOffsets(OffsetsInitializer.earliest())
                .setValueOnlyDeserializer(new SimpleStringSchema())//指定读取数据的格式
                .build();

        //使用kafka source
        DataStream<String> linesDS = env
                .fromSource(source, WatermarkStrategy.noWatermarks(), "Kafka Source");

        //解析json格式的深故居
        DataStream<Car> cars = linesDS.map(line -> JSON.parseObject(line, Car.class));

        cars.print();

        env.execute();
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Car {
    private String car;
    private String city_code;
    private String county_code;
    private String card;
    private String camera_id;
    private String orientation;
    private Long road_id;
    private Long time;
    private Double speed;
}