以下内容部分翻译至 http://kafka.apache.org/intro

kafka介绍

我们认为，一个流处理平台具有三个关键能力：

1. 发布和订阅消息（流），在这方面，它类似于一个消息队列或企业消息系统。

2. 以容错的方式存储消息（流）。

3. 在消息流发生时处理它们。

什么是kakfa的优势？

它应用于2大类应用：

1. 构建实时的流数据管道，可靠地获取系统和应用程序之间的数据。

2. 构建实时流的应用程序，对数据流进行转换或反应。

要了解kafka是如何做这些事情的，让我们从下到上深入探讨kafka的能力。

首先几个概念：

1. kafka作为一个集群运行在一个或多个服务器上。

2. kafka集群存储的消息是以topic为类别记录的。

3. 每个消息（也叫记录record，我习惯叫消息）是由一个key，一个value和时间戳构成。

kafka有四个核心API：

• 应用程序使用 Producer API 发布消息到1个或多个topic（主题）。

• 应用程序使用 Consumer API 来订阅一个或多个topic，并处理产生的消息。

• 应用程序使用 Streams API 充当一个流处理器，从1个或多个topic消费输入流，并生产一个输出流到1个或多个输出topic，有效地将输入流转换到输出流。

• Connector API允许构建或运行可重复使用的生产者或消费者，将topic连接到现有的应用程序或数据系统。例如，一个关系数据库的连接器可捕获每一个变化。

image

Client和Server之间的通讯，是通过一条简单、高性能并且和开发语言无关的TCP协议。并且该协议保持与老版本的兼容。Kafka提供了Java Client（客户端）。除了Java Client外，还有非常多的其它编程语言的Client。

首先来了解一下Kafka所使用的基本术语：

Topic

Kafka将消息种子(Feed)分门别类，每一类的消息称之为一个主题(Topic).

Producer

发布消息的对象称之为主题生产者(Kafka topic producer)

Consumer

订阅消息并处理发布的消息的种子的对象称之为主题消费者(consumers)

Broker

已发布的消息保存在一组服务器中，称之为Kafka集群。集群中的每一个服务器都是一个代理(Broker). 消费者可以订阅一个或多个主题（topic），并从Broker拉数据，从而消费这些已发布的消息。

主题和日志 (Topic和Log)

让我们更深入的了解Kafka中的Topic。

Topic是发布的消息的类别或者种子Feed名。对于每一个Topic，Kafka集群维护这一个分区的log，就像下图中的示例：

image

每一个分区都是一个顺序的、不可变的消息队列， 并且可以持续的添加。分区中的消息都被分了一个序列号，称之为偏移量(offset)，在每个分区中此偏移量都是唯一的。

image

分布式(Distribution)

Log的分区被分布到集群中的多个服务器上。每个服务器处理它分到的分区。 根据配置每个分区还可以复制到其它服务器作为备份容错。 每个分区有一个leader，零或多个follower。Leader处理此分区的所有的读写请求，而follower被动的复制数据。如果leader宕机，其它的一个follower会被推举为新的leader。 一台服务器可能同时是一个分区的leader，另一个分区的follower。 这样可以平衡负载，避免所有的请求都只让一台或者某几台服务器处理。

Geo-Replication(异地数据同步技术)

Kafka MirrorMaker为群集提供geo-replication支持。借助MirrorMaker，消息可以跨多个数据中心或云区域进行复制。 您可以在active/passive场景中用于备份和恢复; 或者在active/passive方案中将数据置于更接近用户的位置，或数据本地化。

生产者(Producers)

生产者往某个Topic上发布消息。生产者也负责选择发布到Topic上的哪一个分区。最简单的方式从分区列表中轮流选择。也可以根据某种算法依照权重选择分区。开发者负责如何选择分区的算法。

消费者(Consumers)

image

2个kafka集群托管4个分区（P0-P3），2个消费者组，消费组A有2个消费者实例，消费组B有4个。

正像传统的消息系统一样，Kafka保证消息的顺序不变。 再详细扯几句。传统的队列模型保持消息，并且保证它们的先后顺序不变。但是， 尽管服务器保证了消息的顺序，消息还是异步的发送给各个消费者，消费者收到消息的先后顺序不能保证了。这也意味着并行消费将不能保证消息的先后顺序。用过传统的消息系统的同学肯定清楚，消息的顺序处理很让人头痛。如果只让一个消费者处理消息，又违背了并行处理的初衷。 在这一点上Kafka做的更好，尽管并没有完全解决上述问题。 Kafka采用了一种分而治之的策略：分区。 因为Topic分区中消息只能由消费者组中的唯一一个消费者处理，所以消息肯定是按照先后顺序进行处理的。但是它也仅仅是保证Topic的一个分区顺序处理，不能保证跨分区的消息先后处理顺序。 所以，如果你想要顺序的处理Topic的所有消息，那就只提供一个分区。

Kafka的保证(Guarantees)

• 生产者发送到一个特定的Topic的分区上，消息将会按照它们发送的顺序依次加入，也就是说，如果一个消息M1和M2使用相同的producer发送，M1先发送，那么M1将比M2的offset低，并且优先的出现在日志中。

• 消费者收到的消息也是此顺序。

• 如果一个Topic配置了复制因子（replication factor）为N， 那么可以允许N-1服务器宕机而不丢失任何已经提交（committed）的消息。

有关这些保证的更多详细信息，请参见文档的设计部分。

kafka作为一个消息系统

Kafka的流与传统企业消息系统相比的概念如何？

传统的消息有两种模式：队列和发布订阅。 在队列模式中，消费者池从服务器读取消息（每个消息只被其中一个读取）; 发布订阅模式：消息广播给所有的消费者。这两种模式都有优缺点，队列的优点是允许多个消费者瓜分处理数据，这样可以扩展处理。但是，队列不像多个订阅者，一旦消息者进程读取后故障了，那么消息就丢了。而发布和订阅允许你广播数据到多个消费者，由于每个订阅者都订阅了消息，所以没办法缩放处理。

kafka中消费者组有两个概念：队列：消费者组（consumer group）允许同名的消费者组成员瓜分处理。发布订阅：允许你广播消息给多个消费者组（不同名）。

kafka的每个topic都具有这两种模式。

kafka有比传统的消息系统更强的顺序保证。

传统的消息系统按顺序保存数据，如果多个消费者从队列消费，则服务器按存储的顺序发送消息，但是，尽管服务器按顺序发送，消息异步传递到消费者，因此消息可能乱序到达消费者。这意味着消息存在并行消费的情况，顺序就无法保证。消息系统常常通过仅设1个消费者来解决这个问题，但是这意味着没用到并行处理。

kafka做的更好。通过并行topic的parition —— kafka提供了顺序保证和负载均衡。每个partition仅由同一个消费者组中的一个消费者消费到。并确保消费者是该partition的唯一消费者，并按顺序消费数据。每个topic有多个分区，则需要对多个消费者做负载均衡，但请注意，相同的消费者组中不能有比分区更多的消费者，否则多出的消费者一直处于空等待，不会收到消息。

kafka作为一个存储系统

所有发布消息到消息队列和消费分离的系统，实际上都充当了一个存储系统（发布的消息先存储起来）。Kafka比别的系统的优势是它是一个非常高性能的存储系统。

写入到kafka的数据将写到磁盘并复制到集群中保证容错性。并允许生产者等待消息应答，直到消息完全写入。

kafka的磁盘结构 - 无论你服务器上有50KB或50TB，执行是相同的。

client来控制读取数据的位置。你还可以认为kafka是一种专用于高性能，低延迟，提交日志存储，复制，和传播特殊用途的分布式文件系统。

kafka的流处理

仅仅读，写和存储是不够的，kafka的目标是实时的流处理。

在kafka中，流处理持续获取输入topic的数据，进行处理加工，然后写入输出topic。例如，一个零售APP，接收销售和出货的输入流，统计数量或调整价格后输出。

可以直接使用producer和consumer API进行简单的处理。对于复杂的转换，Kafka提供了更强大的Streams API。可构建聚合计算或连接流到一起的复杂应用程序。

助于解决此类应用面临的硬性问题：处理无序的数据，代码更改的再处理，执行状态计算等。

Sterams API在Kafka中的核心：使用producer和consumer API作为输入，利用Kafka做状态存储，使用相同的组机制在stream处理器实例之间进行容错保障。

拼在一起

消息传递，存储和流处理的组合看似反常，但对于Kafka作为流式处理平台的作用至关重要。

像HDFS这样的分布式文件系统允许存储静态文件来进行批处理。这样系统可以有效地存储和处理来自过去的历史数据。

传统企业的消息系统允许在你订阅之后处理未来的消息：在未来数据到达时处理它。

Kafka结合了这两种能力，这种组合对于kafka作为流处理应用和流数据管道平台是至关重要的。

批处理以及消息驱动应用程序的流处理的概念：通过组合存储和低延迟订阅，流处理应用可以用相同的方式对待过去和未来的数据。它是一个单一的应用程序，它可以处理历史的存储数据，当它处理到最后一个消息时，它进入等待未来的数据到达，而不是结束。

同样，对于流数据管道（pipeline），订阅实时事件的组合使得可以将Kafka用于非常低延迟的管道；但是，可靠地存储数据的能力使得它可以将其用于必须保证传递的关键数据，或与仅定期加载数据或长时间维护的离线系统集成在一起。流处理可以在数据到达时转换它。

使用场景

1. Messaging

对于一些常规的消息系统,kafka是个不错的选择;partitons/replication和容错,可以使kafka具有良好的扩展性和性能优势.不过到目前为止,我们应该很清楚认识到,kafka并没有提供JMS中的"事务性""消息传输担保(消息确认机制)""消息分组"等企业级特性;kafka只能使用作为"常规"的消息系统,在一定程度上,尚未确保消息的发送与接收绝对可靠(比如,消息重发,消息发送丢失等)

2. Websit activity tracking

kafka可以作为"网站活性跟踪"的最佳工具;可以将网页/用户操作等信息发送到kafka中.并实时监控,或者离线统计分析等

3. Log Aggregation

kafka的特性决定它非常适合作为"日志收集中心";application可以将操作日志"批量""异步"的发送到kafka集群中,而不是保存在本地或者DB中;kafka可以批量提交消息/压缩消息等,这对producer端而言,几乎感觉不到性能的开支.此时consumer端可以使hadoop等其他系统化的存储和分析系统.

原理

kafka的设计初衷是希望作为一个统一的信息收集平台,能够实时的收集反馈信息,并需要能够支撑较大的数据量,且具备良好的容错能力.

1、持久性

kafka使用文件存储消息,这就直接决定kafka在性能上严重依赖文件系统的本身特性.且无论任何OS下,对文件系统本身的优化几乎没有可能.文件缓存/直接内存映射等是常用的手段.因为kafka是对日志文件进行append操作,因此磁盘检索的开支是较小的;同时为了减少磁盘写入的次数,broker会将消息暂时buffer起来,当消息的个数(或尺寸)达到一定阀值时,再flush到磁盘,这样减少了磁盘IO调用的次数.

2、性能

需要考虑的影响性能点很多,除磁盘IO之外,我们还需要考虑网络IO,这直接关系到kafka的吞吐量问题.kafka并没有提供太多高超的技巧;对于producer端,可以将消息buffer起来,当消息的条数达到一定阀值时,批量发送给broker;对于consumer端也是一样,批量fetch多条消息.不过消息量的大小可以通过配置文件来指定.对于kafka broker端,似乎有个sendfile系统调用可以潜在的提升网络IO的性能:将文件的数据映射到系统内存中,socket直接读取相应的内存区域即可,而无需进程再次copy和交换. 其实对于producer/consumer/broker三者而言,CPU的开支应该都不大,因此启用消息压缩机制是一个良好的策略;压缩需要消耗少量的CPU资源,不过对于kafka而言,网络IO更应该需要考虑.可以将任何在网络上传输的消息都经过压缩.kafka支持gzip/snappy等多种压缩方式.

3、生产者

负载均衡: producer将会和Topic下所有partition leader保持socket连接;消息由producer直接通过socket发送到broker,中间不会经过任何"路由层".事实上,消息被路由到哪个partition上,有producer客户端决定.比如可以采用"random""key-hash""轮询"等,如果一个topic中有多个partitions,那么在producer端实现"消息均衡分发"是必要的.

其中partition leader的位置(host:port)注册在zookeeper中,producer作为zookeeper client,已经注册了watch用来监听partition leader的变更事件.

异步发送：将多条消息暂且在客户端buffer起来，并将他们批量的发送到broker，小数据IO太多，会拖慢整体的网络延迟，批量延迟发送事实上提升了网络效率。不过这也有一定的隐患，比如说当producer失效时，那些尚未发送的消息将会丢失。

4、消费者

consumer端向broker发送"fetch"请求,并告知其获取消息的offset;此后consumer将会获得一定条数的消息;consumer端也可以重置offset来重新消费消息.

在JMS实现中,Topic模型基于push方式,即broker将消息推送给consumer端.不过在kafka中,采用了pull方式,即consumer在和broker建立连接之后,主动去pull(或者说fetch)消息;这中模式有些优点,首先consumer端可以根据自己的消费能力适时的去fetch消息并处理,且可以控制消息消费的进度(offset);此外,消费者可以良好的控制消息消费的数量,batch fetch.

kafka安装和简单使用(以mac为例)

安装

# kafka依赖zookeeper 这里使用brew安装， 自动会安装　zookeeper
​
brew install kafka
==> Installing dependencies for kafka: zookeeper
==> Installing kafka dependency: zookeeper
==> Downloading https://homebrew.bintray.com/bottles/zookeeper-3.4.13.high_sierra.bottle.tar.gz
######################################################################## 100.0%
==> Pouring zookeeper-3.4.13.high_sierra.bottle.tar.gz
==> Caveats
To have launchd start zookeeper now and restart at login:
 brew services start zookeeper
Or, if you don't want/need a background service you can just run:
 zkServer start
==> Summary
🍺  /usr/local/Cellar/zookeeper/3.4.13: 244 files, 33.4MB
==> Installing kafka
==> Downloading https://homebrew.bintray.com/bottles/kafka-2.0.0.high_sierra.bottle.tar.gz
######################################################################## 100.0%
==> Pouring kafka-2.0.0.high_sierra.bottle.tar.gz
==> Caveats
To have launchd start kafka now and restart at login:
 brew services start kafka
Or, if you don't want/need a background service you can just run:
 zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties & kafka-server-start /usr/local/etc/kafka/server.properties
==> Summary
🍺  /usr/local/Cellar/kafka/2.0.0: 160 files, 46.8MB
==> Caveats
==> zookeeper
To have launchd start zookeeper now and restart at login:
 brew services start zookeeper
Or, if you don't want/need a background service you can just run:
 zkServer start
==> kafka
To have launchd start kafka now and restart at login:
 brew services start kafka
Or, if you don't want/need a background service you can just run:
 zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties & kafka-server-start /usr/local/etc/kafka/server.properties

上面可以看出 配置文件在 /usr/local/etc/kafka 下面</pre>

kafka的文件目录

 brew list kafka
/usr/local/Cellar/kafka/2.0.0/.bottle/etc/ (14 files)
/usr/local/Cellar/kafka/2.0.0/bin/connect-distributed
/usr/local/Cellar/kafka/2.0.0/bin/connect-standalone
/usr/local/Cellar/kafka/2.0.0/bin/kafka-acls
/usr/local/Cellar/kafka/2.0.0/bin/kafka-broker-api-versions
/usr/local/Cellar/kafka/2.0.0/bin/kafka-configs
/usr/local/Cellar/kafka/2.0.0/bin/kafka-console-consumer
/usr/local/Cellar/kafka/2.0.0/bin/kafka-console-producer
/usr/local/Cellar/kafka/2.0.0/bin/kafka-consumer-groups
/usr/local/Cellar/kafka/2.0.0/bin/kafka-consumer-perf-test
/usr/local/Cellar/kafka/2.0.0/bin/kafka-delegation-tokens
/usr/local/Cellar/kafka/2.0.0/bin/kafka-delete-records
/usr/local/Cellar/kafka/2.0.0/bin/kafka-dump-log
/usr/local/Cellar/kafka/2.0.0/bin/kafka-log-dirs
/usr/local/Cellar/kafka/2.0.0/bin/kafka-mirror-maker
/usr/local/Cellar/kafka/2.0.0/bin/kafka-preferred-replica-election
/usr/local/Cellar/kafka/2.0.0/bin/kafka-producer-perf-test
/usr/local/Cellar/kafka/2.0.0/bin/kafka-reassign-partitions
/usr/local/Cellar/kafka/2.0.0/bin/kafka-replica-verification
/usr/local/Cellar/kafka/2.0.0/bin/kafka-run-class
/usr/local/Cellar/kafka/2.0.0/bin/kafka-server-start
/usr/local/Cellar/kafka/2.0.0/bin/kafka-server-stop
/usr/local/Cellar/kafka/2.0.0/bin/kafka-streams-application-reset
/usr/local/Cellar/kafka/2.0.0/bin/kafka-topics
/usr/local/Cellar/kafka/2.0.0/bin/kafka-verifiable-consumer
/usr/local/Cellar/kafka/2.0.0/bin/kafka-verifiable-producer
/usr/local/Cellar/kafka/2.0.0/bin/trogdor
/usr/local/Cellar/kafka/2.0.0/bin/zookeeper-security-migration
/usr/local/Cellar/kafka/2.0.0/bin/zookeeper-server-start
/usr/local/Cellar/kafka/2.0.0/bin/zookeeper-server-stop
/usr/local/Cellar/kafka/2.0.0/bin/zookeeper-shell
/usr/local/Cellar/kafka/2.0.0/homebrew.mxcl.kafka.plist
/usr/local/Cellar/kafka/2.0.0/libexec/bin/ (30 files)
/usr/local/Cellar/kafka/2.0.0/libexec/libs/ (81 files)

brew将kafka安装在/usr/local/Cellar/kafka/2.0.0下
另外 kafka的配置文件 在 /usr/local/etc/kafka下面，配置文件也可以在其他地方，启动的时候指定就可以了。
​

我们看下配置：/usr/local/Cellar/kafka/2.0.0 文件

tree -L 2
.
├── INSTALL_RECEIPT.json
├── LICENSE
├── NOTICE
├── bin
│   ├── connect-distributed
│   ├── connect-standalone
│   ├── kafka-acls
│   ├── kafka-broker-api-versions
│   ├── kafka-configs
│   ├── kafka-console-consumer
│   ├── kafka-console-producer
│   ├── kafka-consumer-groups
│   ├── kafka-consumer-perf-test
│   ├── kafka-delegation-tokens
│   ├── kafka-delete-records
│   ├── kafka-dump-log
│   ├── kafka-log-dirs
│   ├── kafka-mirror-maker
│   ├── kafka-preferred-replica-election
│   ├── kafka-producer-perf-test
│   ├── kafka-reassign-partitions
│   ├── kafka-replica-verification
│   ├── kafka-run-class
│   ├── kafka-server-start
│   ├── kafka-server-stop
│   ├── kafka-streams-application-reset
│   ├── kafka-topics
│   ├── kafka-verifiable-consumer
│   ├── kafka-verifiable-producer
│   ├── trogdor
│   ├── zookeeper-security-migration
│   ├── zookeeper-server-start
│   ├── zookeeper-server-stop
│   └── zookeeper-shell
├── homebrew.mxcl.kafka.plist
└── libexec
 ├── bin
 ├── config -> ../../../../etc/kafka
 └── libs

bin: 程序的文件
libexec: 执行的文件、库等， 执行的很多都是在这里面
下面介绍一下 bin子目录；

bin主要是 用于启动的sh脚本

 /usr/local/Cellar/kafka/2.0.0/libexec/bin  ll -a | awk '{print $9}'
​
.
..
connect-distributed.sh
connect-standalone.sh
kafka-acls.sh
kafka-broker-api-versions.sh
kafka-configs.sh
kafka-console-consumer.sh
kafka-console-producer.sh
kafka-consumer-groups.sh
kafka-consumer-perf-test.sh
kafka-delegation-tokens.sh
kafka-delete-records.sh
kafka-dump-log.sh
kafka-log-dirs.sh
kafka-mirror-maker.sh
kafka-preferred-replica-election.sh
kafka-producer-perf-test.sh
kafka-reassign-partitions.sh
kafka-replica-verification.sh
kafka-run-class.sh
kafka-server-start.sh
kafka-server-stop.sh
kafka-streams-application-reset.sh
kafka-topics.sh
kafka-verifiable-consumer.sh
kafka-verifiable-producer.sh
trogdor.sh
zookeeper-security-migration.sh
zookeeper-server-start.sh
zookeeper-server-stop.sh
zookeeper-shell.sh

​

看一下 kafka-server-start.sh

#!/bin/bash
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
​
if [ $# -lt 1 ];
then
 echo "USAGE: $0 [-daemon] server.properties [--override property=value]*"
 exit 1
fi
base_dir=$(dirname $0)
​
if [ "x$KAFKA_LOG4J_OPTS" = "x" ]; then
 export KAFKA_LOG4J_OPTS="-Dlog4j.configuration=file:$base_dir/../config/log4j.properties"
fi
​
if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then
 export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"
fi
​
EXTRA_ARGS=${EXTRA_ARGS-'-name kafkaServer -loggc'}
​
COMMAND=$1
case $COMMAND in
 -daemon)
 EXTRA_ARGS="-daemon "$EXTRA_ARGS
 shift
 ;;
 *)
 ;;
esac
​
exec $base_dir/kafka-run-class.sh $EXTRA_ARGS kafka.Kafka "$@"

上面就是判断 一下参数，然后调用 kafka-run-class.sh 加一些参数执行，这里就不介绍了

配置

zookeeper配置

vim /usr/local/etc/kafka/zookeeper.properties
​

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# the directory where the snapshot is stored.
dataDir=/usr/local/var/lib/zookeeper # 数据目录
# the port at which the clients will connect
clientPort=2181 # 端口， 在kafka 中需要配置到这个端口上
# disable the per-ip limit on the number of connections since this is a non-production config
maxClientCnxns=0 # 最大连接数
​```
​
​
​
### kafka服务器配置
vim /usr/local/etc/kafka/
​
​```bash
考虑到配置说明太多，
cat /usr/local/etc/kafka/server.properties | grep "^#" -v |grep -v "^$"
broker.id=0 # 主要是 配置不同的节点服务器，集群中唯一标识
​
# 下面是一些性能参数
num.network.threads=3 
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
​
# 数据日志保存位置， kafka通过日志文件进行持久化的
log.dirs=/usr/local/var/lib/kafka-logs
num.partitions=1
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
log.retention.hours=168
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000
​

这里统一集群中的，连接相同的zookeeper

zookeeper.connect=localhost:2181
zookeeper.connection.timeout.ms=6000
group.initial.rebalance.delay.ms=0
​
另外一个比较重要的是： 
服务开启的监听的端口
listeners=PLAINTEXT://:9092</pre>

修改配置 启动 3个broker

在一台机器上启动三个broker监听在不同端口上， 另外启动zookeeper, 使用/usr/local/Cellar/kafka/2.0.0/libexec/bin/下的脚本启动

先启动zookeeper

/usr/local/Cellar/kafka/2.0.0/libexec/bin/zookeeper-server-start.sh /usr/local/etc/kafka/zookeeper.properties

zookeeper-server-start.sh 后面跟配置文件 即可

复制配置

cd /usr/local/etc/kafka/
cp server.properties server-00.properties
cp server.properties server-01.properties
cp server.properties server-02.properties
​
# 修改配置
vim server-00.properties
broker.id=0
listeners=PLAINTEXT://:9092
log.dirs=/usr/local/var/lib/kafka-logs-00
# 主要是修改上面的内容， 修改完 三个配置
​
​
# 启动broker
/usr/local/Cellar/kafka/2.0.0/libexec/bin/kafka-server-start.sh /usr/local/etc/kafka/server-00.properties
​
# 第二个
/usr/local/Cellar/kafka/2.0.0/libexec/bin/kafka-server-start.sh /usr/local/etc/kafka/server-01.properties
​
​
# 第三个
/usr/local/Cellar/kafka/2.0.0/libexec/bin/kafka-server-start.sh /usr/local/etc/kafka/server-02.properties</pre>

### 简单使用

# 创建topic
cd /usr/local/Cellar/kafka/2.0.0/libexec/bin/
./kafka-topics.sh --help # 查看使用
​
./kafka-topics.sh --zookeeper localhost:2181 --create --topic test --partitions 3 --replication-factor 3
​
# 查看topic的信息
./kafka-topics.sh --zookeeper localhost:2181 --describe --topic test
Topic:test  PartitionCount:3  ReplicationFactor:3  Configs:
 Topic: test  Partition: 0  Leader: 0  Replicas: 0,1,2  Isr: 0,1,2
 Topic: test  Partition: 1  Leader: 1  Replicas: 1,2,0  Isr: 1,2,0
 Topic: test  Partition: 2  Leader: 2  Replicas: 2,0,1  Isr: 2,0,1

# 列出所有的 topic
./kafka-topics.sh --zookeeper localhost:2181 --list
​
​
# 下面使用kafka的cli的方式演示生产者和消费者
​
./kafka-console-consumer.sh --bootstrap-server localhost:9092,localhost:9093,localhost:9094 --topic test
​
# 上面消费者就启动起来了
​
​
# 启动生产者， > 后面输入消息， 在消费者就可以接受到
./kafka-console-producer.sh --broker-list localhost:9092,localhost:9093,localhost:9094 --topic test
​
 ~ ./kafka-console-producer.sh --broker-list localhost:9092,localhost:9093,localhost:9094 --topic test
>hello
>world
>kafka hello world
​
~  ./kafka-console-consumer.sh --bootstrap-server localhost:9092,localhost:9093,localhost:9094 --topic test
hello
world
kafka hello world
​</pre>

### kafka数据日志

### 配置在  log.dirs=/usr/local/var/lib/kafka-logs-00
​
~ cd /usr/local/var/lib/
 ~  ls
kafka-logs-00 kafka-logs-01 kafka-logs-02 zookeeper
​
.
├── __consumer_offsets-0
├── __consumer_offsets-12
├── __consumer_offsets-15
├── __consumer_offsets-18
├── __consumer_offsets-21
├── __consumer_offsets-24
├── __consumer_offsets-27
├── __consumer_offsets-3
├── __consumer_offsets-30
├── __consumer_offsets-33
├── __consumer_offsets-36
├── __consumer_offsets-39
├── __consumer_offsets-42
├── __consumer_offsets-45
├── __consumer_offsets-48
├── __consumer_offsets-6
├── __consumer_offsets-9
├── cleaner-offset-checkpoint
├── log-start-offset-checkpoint
├── meta.properties
├── recovery-point-offset-checkpoint
├── replication-offset-checkpoint
├── test-0
├── test-1
└── test-2
​
# 这里的文件对应不同的partition， offset等。</pre>

本文只是介绍搭建kafka， 具体接入到具体项目中使用，后面的文章后更新补充上。