Select Page

The writer decided on the Free and Open Source Fund to obtain a donation as a part of the Write for DOnations program.


Apache Kafka is a well-liked dispensed message dealer designed to successfully deal with huge volumes of real-time knowledge. A Kafka cluster is not just extremely scalable and fault-tolerant, however it additionally has a miles upper throughput in comparison to different message agents equivalent to ActiveMQ and RabbitMQ. Although it’s in most cases used as a post/subscribe messaging gadget, a large number of organizations additionally use it for log aggregation as it provides chronic garage for printed messages.

A post/subscribe messaging gadget lets in a number of manufacturers to post messages with out bearing in mind the collection of shoppers or how they’ll procedure the messages. Subscribed purchasers are notified mechanically about updates and the introduction of recent messages. The program is extra environment friendly and scalable than methods the place purchasers ballot periodically to resolve if new messages are to be had.

On this instructional, you’re going to set up and use Apache Kafka 1.1.Zero on Ubuntu 18.04.


To practice alongside, you’re going to want:

  • One Ubuntu 18.04 server and a non-root consumer with sudo privileges. Practice the stairs specified on this guide in case you shouldn’t have a non-root consumer arrange.
  • A minimum of 4GB of RAM at the server. Installations with out this quantity of RAM might purpose the Kafka provider to fail, with the Java virtual machine (JVM) throwing an “Out Of Memory” exception throughout startup.
  • OpenJDK Eight put in in your server. To put in this model, practice these instructions on putting in particular variations of OpenJDK. Kafka is written in Java, so it calls for a JVM; then again, its startup shell script has a model detection trojan horse that reasons it to fail first of all JVM variations above 8.

Step 1 — Making a Consumer for Kafka

Since Kafka can deal with requests over a community, you must create a devoted consumer for it. This minimizes harm for your Ubuntu system must the Kafka server be compromised. We will be able to create a devoted kafka consumer on this step, however you must create a special non-root consumer to accomplish different duties in this server upon getting completed putting in Kafka.

Logged in as your non-root sudo consumer, create a consumer referred to as kafka with the useradd command:

The -m flag guarantees {that a} house listing shall be created for the consumer. This house listing, /house/kafka, will act as our workspace listing for executing instructions within the sections under.

Set the password the usage of passwd:

Upload the kafka consumer to the sudo crew with the adduser command, in order that it has the privileges required to put in Kafka’s dependencies:

Your kafka consumer is now able. Log into this account the usage of su:

Now that now we have created the Kafka-specific consumer, we will transfer directly to downloading and extracting the Kafka binaries.

Step 2 — Downloading and Extracting the Kafka Binaries

Let’s obtain and extract the Kafka binaries into devoted folders in our kafka consumer’s house listing.

To start out, create a listing in /house/kafka referred to as Downloads to retailer your downloads:

Use curl to obtain the Kafka binaries:

  • curl "" -o ~/Downloads/kafka.tgz

Create a listing referred to as kafka and alter to this listing. This would be the base listing of the Kafka set up:

  • mkdir ~/kafka && cd ~/kafka

Extract the archive you downloaded the usage of the tar command:

  • tar -xvzf ~/Downloads/kafka.tgz --strip 1

We specify the --strip 1 flag to make certain that the archive’s contents are extracted in ~/kafka/ itself and now not in every other listing (equivalent to ~/kafka/kafka_2.12-1.1.0/) inside it.

Now that now we have downloaded and extracted the binaries effectively, we will transfer on configuring to Kafka to permit for subject deletion.

Step 3 — Configuring the Kafka Server

Kafka’s default habits won’t let us delete a subject, the class, crew, or feed identify to which messages may also be printed. To switch this, let’s edit the configuration report.

Kafka’s configuration choices are laid out in server.houses. Open this report with nano or your favourite editor:

  • nano ~/kafka/config/server.houses

Let’s upload a environment that can let us delete Kafka subjects. Upload the next to the ground of the report:


delete.subject.permit = true

Save the report, and go out nano. Now that now we have configured Kafka, we will transfer on to making systemd unit information for working and enabling it on startup.

Step 4 — Developing Systemd Unit Recordsdata and Beginning the Kafka Server

On this phase, we can create systemd unit files for the Kafka provider. This may lend a hand us carry out commonplace provider movements equivalent to beginning, preventing, and restarting Kafka in a fashion in step with different Linux services and products.

Zookeeper is a provider that Kafka makes use of to regulate its cluster state and configurations. It’s often utilized in many dispensed methods as an integral element. If you need to understand extra about it, discuss with the reliable Zookeeper docs.

Create the unit report for zookeeper:

  • sudo nano /and many others/systemd/gadget/zookeeper.provider

Input the next unit definition into the report:

/and many others/systemd/gadget/zookeeper.provider

Calls for=community.goal remote-fs.goal
After=community.goal remote-fs.goal

ExecStart=/house/kafka/kafka/bin/ /house/kafka/kafka/config/zookeeper.houses


The [Unit] phase specifies that Zookeeper calls for networking and the filesystem to be able sooner than it might beginning.

The [Service] phase specifies that systemd must use the and shell information for beginning and preventing the provider. It additionally specifies that Zookeeper must be restarted mechanically if it exits abnormally.

Subsequent, create the systemd provider report for kafka:

  • sudo nano /and many others/systemd/gadget/kafka.provider

Input the next unit definition into the report:

/and many others/systemd/gadget/kafka.provider

Calls for=zookeeper.provider

ExecStart=/bin/sh -c '/house/kafka/kafka/bin/ /house/kafka/kafka/config/server.houses > /house/kafka/kafka/kafka.log 2>&1'


The [Unit] phase specifies that this unit report will depend on zookeeper.provider. This may make certain that zookeeper will get began mechanically when the kafa provider begins.

The [Service] phase specifies that systemd must use the and shell information for beginning and preventing the provider. It additionally specifies that Kafka must be restarted mechanically if it exits abnormally.

Now that the devices had been outlined, beginning Kafka with the next command:

  • sudo systemctl beginning kafka

To make certain that the server has began effectively, take a look at the magazine logs for the kafka unit:

You must see output very similar to the next:


Jul 17 18:38:59 kafka-ubuntu systemd[1]: Began kafka.provider.

You presently have a Kafka server listening on port 9092.

Whilst we’ve got began the kafka provider, if we have been to reboot our server, it might now not be began mechanically. To permit kafka on server boot, run:

  • sudo systemctl permit kafka

Now that now we have began and enabled the services and products, let’s take a look at the set up.

Step 5 — Checking out the Set up

Let’s post and devour a “Hello World” message to verify the Kafka server is behaving accurately. Publishing messages in Kafka calls for:

  • A manufacturer, which permits the newsletter of information and information to subjects.
  • A user, which reads messages and information from subjects.

First, create a subject matter named TutorialTopic by way of typing:

  • ~/kafka/bin/ --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic TutorialTopic

You’ll create a manufacturer from the command line the usage of the script. It expects the Kafka server’s hostname, port, and a subject matter identify as arguments.

Submit the string "Hello, World" to the TutorialTopic subject by way of typing:

  • echo "Hello, World" | ~/kafka/bin/ --broker-list localhost:9092 --topic TutorialTopic > /dev/null

Subsequent, you’ll create a Kafka user the usage of the script. It expects the ZooKeeper server’s hostname and port, at the side of a subject matter identify as arguments.

The next command consumes messages from TutorialTopic. Notice using the --from-beginning flag, which permits the intake of messages that have been printed sooner than the shopper used to be began:

  • ~/kafka/bin/ --bootstrap-server localhost:9092 --topic TutorialTopic --from-beginning

If there aren’t any configuration problems, you must see Hi, International to your terminal:


Hi, International

The script will proceed to run, looking forward to extra messages to be printed to the subject. Be at liberty to open a brand new terminal and beginning a manufacturer to post a couple of extra messages. You must be capable to see all of them within the user’s output.

If you end up achieved trying out, press CTRL+C to prevent the shopper script. Now that we have got examined the set up, let’s transfer directly to putting in KafkaT.

Step 6 — Set up KafkaT (Non-compulsory)

KafkaT is a device from Airbnb that makes it more straightforward so that you can view information about your Kafka cluster and carry out sure administrative duties from the command line. As a result of this can be a Ruby gem, you’re going to want Ruby to make use of it. You’ll additionally want the build-essential bundle so to construct the opposite gemstones it will depend on. Set up them the usage of apt:

  • sudo apt set up ruby ruby-dev build-essential

You’ll now set up KafkaT the usage of the gem command:

KafkaT makes use of .kafkatcfg because the configuration report to resolve the set up and log directories of your Kafka server. It must even have an access pointing KafkaT for your ZooKeeper example.

Create a brand new report referred to as .kafkatcfg:

Upload the next traces to specify the desired details about your Kafka server and Zookeeper example:


  "kafka_path": "~/kafka",
  "log_path": "/tmp/kafka-logs",
  "zk_path": "localhost:2181"

You at the moment are able to make use of KafkaT. For a beginning, this is how you may use it to view information about all Kafka walls:

You’ll see the next output:


Subject Partition Chief Replicas ISRs TutorialTopic 0 0 [0] [0] __consumer_offsets 0 0 [0] [0] ... ...

You’ll see TutorialTopic, in addition to __consumer_offsets, an inside subject utilized by Kafka for storing client-related data. You’ll safely forget about traces beginning with __consumer_offsets.

To be told extra about KafkaT, confer with its GitHub repository.

Step 7 — Surroundings Up a Multi-Node Cluster (Non-compulsory)

If you wish to create a multi-broker cluster the usage of extra Ubuntu 18.04 machines, you must repeat Step 1, Step 4, and Step Five on each and every of the brand new machines. Moreover, you must make the next adjustments within the server.houses report for each and every:

  • The price of the dealer.identification belongings must be modified such that it’s distinctive during the cluster. This belongings uniquely identifies each and every server within the cluster and could have any string as its price. For instance, "server1", "server2", and many others.

  • The price of the zookeeper.attach belongings must be modified such that every one nodes level to the similar ZooKeeper example. This belongings specifies the Zookeeper example’s cope with and follows the : layout. For instance, "", "" and many others.

If you wish to have a couple of ZooKeeper circumstances in your cluster, the price of the zookeeper.attach belongings on each and every node must be an equivalent, comma-separated string list the IP addresses and port numbers of the entire ZooKeeper circumstances.

Step 8 — Proscribing the Kafka Consumer

Now that the entire installations are achieved, you’ll take away the kafka consumer’s admin privileges. Sooner than you achieve this, sign off and log again in as every other non-root sudo consumer. In case you are nonetheless working the similar shell consultation you began this instructional with, merely sort go out.

Take away the kafka consumer from the sudo crew:

To additional fortify your Kafka server’s safety, lock the kafka consumer’s password the usage of the passwd command. This makes certain that no one can immediately log into the server the usage of this account:

At this level, simplest root or a sudo consumer can log in as kafka by way of typing within the following command:

Someday, if you wish to free up it, use passwd with the -u possibility:

You might have now effectively limited the kafka consumer’s admin privileges.


You presently have Apache Kafka working securely in your Ubuntu server. You’ll employ it to your initiatives by way of growing Kafka manufacturers and shoppers the usage of Kafka clients, which can be to be had for many programming languages. To be told extra about Kafka, you’ll additionally seek the advice of its documentation.