group.instance.id

分区读取状态

可见，副本读取状态有截断中和获取中两个：当副本执行截断操作时，副本状态被设置成 Truncating；当副本被读取时，副本状态被设置成 Fetching。

def isReplicaInSync: Boolean = lag.isDefined && lag.get <= 0

highWatermark

lastStableOffset 是最新的 LSO 值，属于 Kafka 事务的概念。

这是社区为了规避因多线程访问产生锁争用导致线程阻塞，从而引发请求超时问题而做的努力

bucket.flush(reinsert)

delayQueue

选择存活副本列表的第一个副本作为 Leader；选择存活副本列表作为 ISR

基本上就是，找出 AR 列表（或给定副本列表）中首个处于存活状态，且在 ISR 列表的副本，将其作为新 Leader。

即副本所在的 Broker 依然在运行中

这是分区的副本列表。该列表有个专属的名称，叫 Assigned Replicas，简称 AR

PartitionLeaderElectionStrategy 接口及其实现对象：定义 4 类分区 Leader 选举策略。你可以认为它们是发生 Leader 选举的 4 种场景。

代码会给所有符合状态转换的副本所在的 Broker，发送 StopReplicaRequest 请求，显式地告诉这些 Broker 停掉其上的对应副本。Kafka 的副本管理器组件（ReplicaManager）负责处理这个逻辑。后面我们会用两节课的时间专门讨论 ReplicaManager 的实现，这里你只需要了解，StopReplica 请求被发送出去之后，这些 Broker 上对应的副本就停止工作了。

源码会获取对应分区的详细数据，然后向该副本对象所在的 Broker 发送 LeaderAndIsrRequest 请求，令其同步获知，并保存该分区数据。

尝试从元数据缓存中，

doHandleStateChanges 方法

它会将 replicas 按照 Broker ID 进行分组。

(validBytes - lastIndexEntry > indexIntervalBytes)

recover 方法

因为目前 Broker 端日志段新增倒计时是全局设置，这就是说，在未来的某个时刻可能同时创建多个日志段对象，这将极大地增加物理磁盘 I/O 压力。有了 rollJitterMs 值的干扰，每个新增日志段在创建时会彼此岔开一小段时间，这样可以缓解物理磁盘的 I/O 负载瓶颈。

Follower 副本拉取消息后写入副本；

但是为什么 AbstractFetcherThread 线程总要不断尝试去做截断呢？这是因为，分区的 Leader 可能会随时发生变化。每当有新 Leader 产生时，Follower 副本就必须主动执行截断操作，将自己的本地日志裁剪成与 Leader 一模一样的消息序列，甚至，Leader 副本本身也需要执行截断操作，将 LEO 调整到分区高水位处。

lastStableOffset

How Tesla is using Kubernetes and Kafka to handle trillions of events per day

Partition Leader Balancing

Replication

Kafka

Protocol

Data Plane

Replication

course

Inside the Apache Kafka Broker

Kafka Broker

Today is 9th Feb. The oldest segment – segment 100 – still can’t be deleted by the 7-day topic retention policy, because the most recent message in that segment is only 5 days old. The result is that they can see messages dating back to 28th January on this topic, even though the 28th Jan is now 12 days ago. In a couple of days, all the messages in segment 100 will be old enough to exceed the retention threshold so that segment file will be deleted.

The Bitnami Apache Kafka docker image disables the PLAINTEXT listener for security reasons. You can enable the PLAINTEXT listener by adding the next environment variable, but remember that this configuration is not recommended for production.

RabbitMQ，ZeroMQ，Kafka 是一个层级的东西吗？相互之间有哪些优缺点？

没有用户态到核心态的拷贝

它采用pull机制，而 不是一般MQ的push模型

You don’t have to download them manually, as a docker-compose.yml will do that for you. Here’s the code, so you can copy it to your machine:

Kafka version 2.8.0 introduced early access to a Kafka version without Zookeeper, but it’s not ready yet for production environments.

Kafka consumer — A program you write to get data out of Kafka. Sometimes a consumer is also a producer, as it puts data elsewhere in Kafka.

Kafka producer — An application (a piece of code) you write to get data to Kafka.

Kafka topic — A category to which records are published. Imagine you had a large news site — each news category could be a single Kafka topic.

Kafka broker — A single Kafka Cluster is made of Brokers. They handle producers and consumers and keeps data replicated in the cluster.

Kafka — Basically an event streaming platform. It enables users to collect, store, and process data to build real-time event-driven applications. It’s written in Java and Scala, but you don’t have to know these to work with Kafka. There’s also a Python API.

User topics must be created and manually managed ahead of time

In the Penal Settlement

Macksey is also responsible for one of his first short films. “When I was at Hopkins, there was no film program. We talked to Dick [about making a short film] and he said ‘let’s do it,’ and we ended up doing a movie in which he has a small part.”

This minimal, yet poignant presence is reflected in the brick work—Kafka’s novel showcasing how a small idea can have a monumental presence.

Now he stood there naked.

his women

I usually kneel down at this point and observe the phenomenon.

Guilt is always beyond a doubt.

“It would be useless to give him that information. He experiences it on his own body.

“That’s cotton wool?” asked the Traveler and bent down. “Yes, it is,” said the Officer smiling, “feel it for yourself.”

harrow

epaulettes

the administration of the colony was so self-contained that even if his successor had a thousand new plans in mind, he would not be able to alter anything of the old plan, at least not for several years.

vacant-looking man with a broad mouth and dilapidated hair and face

Officer to the Traveler,

Then the Traveler heard a cry of rage from the Officer.

That gave rise to certain technical difficulties with fastening the needles securely, but after several attempts we were successful. We didn’t spare any efforts. And now, as the inscription is made on the body, everyone can see through the glass. Don’t you want to come closer and see the needles for yourself.”

The Traveler wanted to raise various questions, but after looking at the Condemned Man he merely asked, “Does he know his sentence?” “No,” said the Officer. He wished to get on with his explanation right away, but the Traveler interrupted him: “He doesn’t know his own sentence?” “No,” said the Officer once more. He then paused for a moment, as if he was asking the Traveler for a more detailed reason for his question, and said, “It would be useless to give him that information. He experiences it on his own body.”

“He was indeed,” said the Officer, nodding his head with a fixed and thoughtful expression. Then he looked at his hands, examining them. They didn’t seem to him clean enough to handle the diagrams. So he went to the bucket and washed them again. Then he pulled out a small leather folder and said, “Our sentence does not sound severe. The law which a condemned man has violated is inscribed on his body with the harrow. This Condemned Man, for example,” and the Officer pointed to the man, “will have inscribed on his body, ‘Honour your superiors.’”

“However,” the Officer said, interrupting himself, “I’m chattering, and his apparatus stands here in front of us. As you see, it consists of three parts. With the passage of time certain popular names have been developed for each of these parts. The one underneath is called the bed, the upper one is called the inscriber, and here in the middle, this moving part is called the harrow.” “The harrow?” the Traveler asked. He had not been listening with full attention. The sun was excessively strong, trapped in the shadowless valley, and one could hardly collect one’s thoughts. So the Officer appeared to him all the more admirable in his tight tunic weighed down with epaulettes and festooned with braid, ready to go on parade, as he explained the matter so eagerly and, while he was talking, adjusted screws here and there with a screwdriver.

Of course, interest in the execution was not very high, not even in the penal colony itself.

The Log: What every software engineer should know about real-time data's unifying abstraction

SubscribePattern allows you to use a regex to specify topics of interest

The cache for consumers has a default maximum size of 64. If you expect to be handling more than (64 * number of executors) Kafka partitions, you can change this setting via spark.streaming.kafka.consumer.cache.maxCapacity.

In distributed mode, you start many worker processes using the same group.id and they automatically coordinate to schedule execution of connectors and tasks across all available workers. I

Connectors and tasks are logical units of work and must be scheduled to execute in a process. Kafka Connect calls these processes workers and has two types of workers: standalone and distributed.

up vote 7 down vote accepted When you are starting your kafka broker you can define set of properties in conf/server.properties file. This file is just key value property file. One of the property is auto.create.topics.enable if it set tot true(by default) kafka will create topic automatically when you send message to non existing topic. All config options you can find here Imho Simple rule for creating topics is the following: number of replicas must be not less than number of nodes that you have. Number of topics must be the multiplier of number of node in your cluster for example: You have 9 node cluster your topic must have 9 partitions and 9 replicas or 18 partitions and 9 replicas or 36 partitions and 9 replicas and so on

ab -t 15 -k -T "application/vnd.kafka.binary.v1+json" -p postfile http://localhost:8082/topics/test

in sync replicas (ISRs) should be exactly equal to the total number of replicas.

Kafka metrics can be broken down into three categories:Kafka server (broker) metricsProducer metricsConsumer metrics

"isr" is the set of "in-sync" replicas.

We run Kafka on the old and trusty m1.xlarge

You measure the throughout that you can achieve on a single partition for production (call it p) and consumption (call it c). Let’s say your target throughput is t.

Messages are immediately written to the filesystem when they are received. Messages are not deleted when they are read but retained with some configurable SLA (say a few days or a week)

ZooKeeper snapshots can be one such a source of concurrent writes, and ideally should be written on a disk group separate from the transaction log.

If you do end up sharing the ensemble, you might want to use the chroot feature. With chroot, you give each application its own namespace.

Designing a High Level Consumer

the High Level Consumer is provided to abstract most of the details of consuming events from Kafka.

In merced, we used the low-level simple consumer and wrote our own work dispatcher to get precise control.

A better alternative is at least once message delivery. For at least once delivery, the consumer reads data from a partition, processes the message, and then commits the offset of the message it has processed. In this case, the consumer could crash between processing the message and committing the offset and when the consumer restarts it will process the message again. This leads to duplicate messages in downstream systems but no data loss.

no data loss will occur as long as producers and consumers handle this possibility and retry appropriately.

By electing a new leader as soon as possible messages may be dropped but we will minimized downtime as any new machine can be leader.

keep in mind that these guarantees hold as long as you are producing to one partition and consuming from one partition.

On every received heartbeat, the coordinator starts (or resets) a timer. If no heartbeat is received when the timer expires, the coordinator marks the member dead and signals the rest of the group that they should rejoin so that partitions can be reassigned. The duration of the timer is known as the session timeout and is configured on the client with the setting session.timeout.ms. 

The high watermark is the offset of the last message that was successfully copied to all of the log’s replicas.

Kafka scales topic consumption by distributing partitions among a consumer group, which is a set of consumers sharing a common group identifier.

Kafka consumer offset management protocol to keep track of what’s been uploaded to S3

Data lost or corrupted at this stage isn’t recoverable so the greatest design objective for Secor is data integrity.

An index can potentially store a large amount of data that can exceed the hardware limits of a single node. For example, a single index of a billion documents taking up 1TB of disk space may not fit on the disk of a single node or may be too slow to serve search requests from a single node alone.

incidents are an unavoidable reality of working with distributed systems, no matter how reliable. A prompt alerting solution should be an integral part of the design,

Consumers in this group are designed to be dead-simple, performant, and highly resilient. Since the data copied verbatim, no code upgrades are required to support new message types.

More events may arrive late for various reasons, we need to handle late-arrived events consistently.

With Flume & FlumeNG, and a File channel, if you loose a broker node you will lose access to those events until you recover that disk.

The Kafka cluster retains all published records—whether or not they have been consumed—using a configurable retention period. For example, if the retention policy is set to two days, then for the two days after a record is published, it is available for consumption, after which it will be discarded to free up space. Kafka's performance is effectively constant with respect to data size so storing data for a long time is not a problem.

Kafka for Stream Processing

replication factor N, we will tolerate up to N-1 server failures without losing any records

Messages sent by a producer to a particular topic partition will be appended in the order they are sent. That is, if a record M1 is sent by the same producer as a record M2, and M1 is sent first, then M1 will have a lower offset than M2 and appear earlier in the log.

Consumers label themselves with a consumer group name, and each record published to a topic is delivered to one consumer instance within each subscribing consumer group. Consumer instances can be in separate processes or on separate machines.

The partitions of the log are distributed over the servers in the Kafka cluster with each server handling data and requests for a share of the partitions.

The first limitation is that each partition is physically represented as a directory of one or more segment files. So you will have at least one directory and several files per partition. Depending on your operating system and filesystem this will eventually become painful. However this is a per-node limit and is easily avoided by just adding more total nodes in the cluster.

the number of partitions -- there's no real "formula" other than this: you can have no more parallelism than you have partitions.

The offset the ordering of messages as an immutable sequence. Kafka maintains this message ordering for you.

replication-factor 3

For a topic with replication factor N, we will tolerate up to N-1 server failures without losing any records committed to the log.

The way consumption is implemented in Kafka is by dividing up the partitions in the log over the consumer instances so that each instance is the exclusive consumer of a "fair share" of partitions at any point in time. This process of maintaining membership in the group is handled by the Kafka protocol dynamically. If new instances join the group they will take over some partitions from other members of the group; if an instance dies, its partitions will be distributed to the remaining instances.

Consumers label themselves with a consumer group name

The producer is responsible for choosing which record to assign to which partition within the topic.

individual partition must fit on the servers that host it

the only metadata retained on a per-consumer basis is the offset or position of that consumer in the log. This offset is controlled by the consumer: normally a consumer will advance its offset linearly as it reads records, but, in fact, since the position is controlled by the consumer it can consume records in any order it likes.

the retention policy is set to two days, then for the two days after a record is published,