---
title: "Kafka cơ bản: Cách dùng Kafka 4 với Docker, Confluent và Go"
description: "Hướng dẫn Kafka cơ bản: chạy Kafka 4 bằng Docker không cần ZooKeeper, tạo topic trên Confluent Cloud, viết producer và consumer bằng Go."
canonical: "https://200lab.io/blog/huong-dan-su-dung-kafka"
published: "2023-08-26T02:30:00Z"
updated: "2026-11-02T01:51:53Z"
authors: ["Trần Nhật Anh"]
tags: ["Backend", "DevOps"]
reading_minutes: 23
access: "public"
---

**_Hướng dẫn sử dụng Kafka cơ bản cho người mới: chạy Kafka 4 bằng Docker trên máy cá nhân, kết nối Confluent Cloud và viết ứng dụng producer/consumer bằng ngôn ngữ Go._**

**Apache Kafka** (gọi tắt là Kafka) là một nền tảng phân phối sự kiện phân tán [mã nguồn mở](<https://vi.wikipedia.org/wiki/M%C3%A3_ngu%E1%BB%93n_m%E1%BB%9F>) được phát triển bởi [Apache Software Foundation](<https://www.apache.org/>) và được viết bằng [Java](<https://vi.wikipedia.org/wiki/Java_(ng%C3%B4n_ng%E1%BB%AF_l%E1%BA%ADp_tr%C3%ACnh)>) và [Scala](<https://vi.wikipedia.org/wiki/Scala_(ng%C3%B4n_ng%E1%BB%AF_l%E1%BA%ADp_tr%C3%ACnh)>).

Kafka được tạo ra để giải quyết những thách thức trong việc xử lý lượng dữ liệu khổng lồ trong thời gian thực (_real-time_), cho phép các ứng dụng xuất bản (_publish_), đăng ký (_subscribe_), lưu trữ (_store_) và xử lý (_process_) các luồng bản ghi (_streaming event_) một cách hiệu quả.

Đọc thêm: [Kafka là gì? Các thành phần trong Apache Kafka](</blog/kafka-la-gi>)

[Kafka là gì? Các thành phần trong Kafka](https://200lab.io/blog/kafka-la-gi) — Kafka là một nền tảng phân phối sự kiện phân tán mã nguồn mở được phát triển bởi Apache Software Foundation và được viết bằng Java và Scala

Với sự ra đời của **Confluent Cloud**, các nhà phát triển có thể tận dụng Kafka mà không phải đối mặt với sự phức tạp của việc quản lý cơ sở hạ tầng. Confluent Cloud cung cấp dịch vụ Kafka được quản lý sẵn (fully managed) với các tính năng như tự động mở rộng quy mô, lưu giữ dữ liệu và tích hợp liền mạch với các thành phần khác của Confluent Platform.

Trong bài viết này, mình và bạn sẽ đi theo hai hướng thực hành. Trước tiên, bạn sẽ chạy Kafka local bằng Docker ở chế độ KRaft không cần ZooKeeper để học và thử nghiệm nhanh. Tiếp đó, chúng ta dùng Confluent Cloud để trải nghiệm một cluster được quản lý sẵn, kết hợp viết client bằng Go với thư viện `confluent-kafka-go`.

Toàn bộ source code của bài nằm ở repo Github [kafka-demo](<https://github.com/japananh/kafka-demo>).

## Kafka cơ bản: topic, partition, producer, consumer và consumer group

Để làm việc với Apache Kafka, bạn cần nắm vững 5 khái niệm cốt lõi. Hãy hình dung một shop online xử lý các event "đơn hàng mới" qua hệ thống như sau:

- **Topic**: Kênh phân loại dữ liệu, ví dụ topic `orders` chuyên lưu các event đơn hàng mới. Event được lưu bền vững theo thời gian giữ cấu hình được chứ không bị xoá ngay sau khi đọc.
- **Partition**: Mỗi topic được chia thành một hoặc nhiều partition để phân tải và xử lý song song.
- **Producer**: Ứng dụng ghi event vào topic, chẳng hạn dịch vụ đặt hàng gửi thông tin đơn mới vào `orders`.
- **Consumer**: Ứng dụng đọc event từ topic để xử lý, như dịch vụ kho hàng hoặc thanh toán.
- **Consumer group**: Các consumer có cùng `group.id` sẽ hợp thành một nhóm và chia nhau đọc các partition. Mỗi group tự giữ vị trí đã đọc gọi là offset, nhờ vậy nhiều group khác nhau có thể cùng đọc lại một dữ liệu.

Từ bản **Kafka 4.0**, hệ thống đã bỏ hoàn toàn ZooKeeper và chỉ chạy chế độ KRaft do chính các controller của Kafka quản lý metadata. Nếu muốn tìm hiểu sâu hơn về kiến trúc, bạn hãy xem bài viết [Kafka là gì? Các thành phần trong Kafka](</blog/kafka-la-gi>).

## Cách chạy Kafka 4 trên máy bằng Docker (KRaft, không cần ZooKeeper)

Nhờ chế độ KRaft, bạn có thể dựng một broker đơn lẻ trên máy cá nhân rất nhanh mà không cần cài đặt thêm ZooKeeper hay **Java 17**. Chúng ta sẽ sử dụng Docker image chính thức bản mới nhất là **apache/kafka:4.4.0** phát hành ngày 22/10/2026.

**Bước 1:** Bạn mở terminal và chạy một container broker ở chế độ KRaft lắng nghe tại cổng **9092** bằng lệnh sau:

```bash
docker run -d -p 9092:9092 --name broker apache/kafka:4.4.0
```

Nếu muốn container khởi động nhanh hơn để thử nghiệm ở máy local, bạn có thể đổi sang image **apache/kafka-native:4.4.0** được dựng bằng GraalVM.

**Bước 2:** Tiếp theo, bạn truy cập vào shell của container vừa chạy, nơi chứa sẵn các script quản lý tại thư mục `/opt/kafka/bin`:

```bash
docker exec --workdir /opt/kafka/bin/ -it broker sh
```

**Bước 3:** Tại đây, bạn dùng script `kafka-topics.sh --create` để tạo topic tên là `orders` và kiểm tra lại thông tin của topic vừa tạo:

```bash
./kafka-topics.sh --bootstrap-server localhost:9092 --create --topic orders --partitions 3
./kafka-topics.sh --bootstrap-server localhost:9092 --describe --topic orders
```

**Bước 4:** Bạn chạy script `kafka-console-producer.sh` rồi gõ thử vài dòng dữ liệu đơn hàng để gửi event vào topic:

```bash
./kafka-console-producer.sh --bootstrap-server localhost:9092 --topic orders
# Gõ từng dòng rồi nhấn Enter để gửi, nhấn Ctrl + C để thoát
```

**Bước 5:** Cuối cùng, bạn mở một cửa sổ terminal khác rồi chạy `kafka-console-consumer.sh --from-beginning` để đọc lại toàn bộ các dòng vừa gửi:

```bash
docker exec --workdir /opt/kafka/bin/ -it broker sh
./kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic orders --from-beginning
```

Khi thực hành xong và muốn xoá toàn bộ dữ liệu thử nghiệm này, bạn chỉ cần dừng và xoá container đi là xong.

### Kết nối producer, consumer Go với Kafka chạy local

Khi kết nối ứng dụng Go vào Kafka chạy local, cấu hình sẽ đơn giản hơn nhiều so với lúc dùng Confluent Cloud. Bạn chỉ cần trỏ `bootstrap.servers` về địa chỉ `localhost:9092`, bỏ toàn bộ các dòng xác thực `sasl.*` hay `security.protocol`, và không cần dùng đến Schema Registry.

Dưới đây là đoạn code mẫu cho file `local_producer.go` khi làm việc với broker trên máy:

```go
// local_producer.go
package main

import (
	"fmt"
	"os"

	"github.com/confluentinc/confluent-kafka-go/v2/kafka"
)

func main() {
	topic := "orders"

	// Kafka local không bật SASL/SSL nên chỉ cần bootstrap.servers
	p, err := kafka.NewProducer(&kafka.ConfigMap{
		"bootstrap.servers": "localhost:9092",
	})
	if err != nil {
		fmt.Printf("Failed to create producer: %s\n", err)
		os.Exit(1)
	}
	defer p.Close()

	deliveryChan := make(chan kafka.Event, 1)
	err = p.Produce(&kafka.Message{
		TopicPartition: kafka.TopicPartition{Topic: &topic, Partition: kafka.PartitionAny},
		Key:            []byte("order-5950"),
		Value:          []byte(`{"id": 5950, "quantity": 3, "item_type": "guitar"}`),
	}, deliveryChan)
	if err != nil {
		fmt.Printf("Failed to produce message: %s\n", err)
		os.Exit(1)
	}

	// Chờ báo cáo gửi (delivery report) của message vừa gửi
	m := (<-deliveryChan).(*kafka.Message)
	if m.TopicPartition.Error != nil {
		fmt.Printf("Failed to deliver: %v\n", m.TopicPartition.Error)
		os.Exit(1)
	}
	fmt.Printf("Delivered message to %v\n", m.TopicPartition)
}
```

Bạn khởi chạy chương trình để gửi thử dữ liệu vào Kafka local bằng lệnh sau:

```bash
mkdir kafka-local && cd kafka-local
go mod init kafka-local
# Tạo file local_producer.go với nội dung ở trên, sau đó:
go get github.com/confluentinc/confluent-kafka-go/v2@v2.16.1
go run local_producer.go
```

Đối với file `consumer.go` ở phần hướng dẫn phía sau, bạn cũng chỉ cần bỏ các dòng cấu hình `sasl.*` và `security.protocol` tương tự là có thể đọc được dữ liệu từ máy local.

## Chuẩn bị: Confluent Cloud, Confluent CLI và Go

Phần hướng dẫn trên cloud dùng Confluent Cloud và Go. Sau đây là những thứ bạn cần chuẩn bị.

### 1. Confluent

### 1.1. Confluent Cloud (CCloud)

[Confluent Cloud](<https://www.confluent.io/confluent-cloud>) (gọi tắt là CCloud) là một dịch vụ truyền dữ liệu linh hoạt, có thể mở rộng, dựa trên Apache Kafka và được phân phối dưới dạng dịch vụ được quản lý sẵn.

Để thực hành phần này, bạn cần đăng ký một tài khoản Confluent Cloud. Tài khoản mới sẽ nhận được **$400 credit** để dùng trong **30 ngày** đầu tiên; chương trình dùng thử sẽ kết thúc ngay khi bạn dùng hết số credit này hoặc hết hạn **30 ngày**.

Bạn bắt buộc phải thêm phương thức thanh toán thì mới tạo được tài nguyên, nhưng thẻ sẽ chưa bị trừ tiền trong thời gian dùng thử. Hãy nhớ xoá toàn bộ cluster sau khi thử nghiệm xong, vì các tài nguyên còn chạy sau giai đoạn dùng thử sẽ bắt đầu bị tính phí.

**_Confluent cung cấp 3 cách để tương tác với Confluent Cloud:_**

1. Confluent CLI (giao diện dòng lệnh)
2. Confluent Cloud Console (giao diện web)
3. Confluent Cloud APIs (sử dụng APIs)

Đọc thêm: [Tài liệu hướng dẫn sử dụng Confluent Cloud của Confluent](<https://docs.confluent.io/cloud/current/get-started/index.html>)

### 1.2. Confluent CLI (không bắt buộc)

Confluent CLI (Command-line Interface) là giao diện dòng lệnh của Confluent, cho phép các nhà phát triển quản lý Confluent Cloud và Confluent Platform.

Để cài đặt và sử dụng các lệnh cơ bản trong Confluent CLI, xin bạn vui lòng đọc bài [Hướng dẫn cài đặt và sử dụng Confluent CLI](<https://docs.confluent.io/confluent-cli/current/overview.html>).

### 2. Go

Ở phần viết code, bạn cần cài đặt ngôn ngữ Go từ phiên bản **Go 1.26.10** trở lên vì đây là mức tối thiểu mà thư viện `confluent-kafka-go` bản **v2.16.1** mới nhất yêu cầu.

Do thư viện này bọc lại thư viện C `librdkafka` thông qua `cgo`, máy của bạn cần bật sẵn CGO và có trình biên dịch C hoạt động. Nếu máy chưa có sẵn môi trường, bạn hãy làm theo hướng dẫn cài đặt chính thức tại [go.dev/doc/install](<https://go.dev/doc/install>), lệnh tải thư viện nằm ở Bước 2 bên dưới.

Đọc thêm: [Golang là gì? Backend Developer có nên học Golang](</blog/golang-la-gi>)

[Golang là gì? Backend Developer có nên học Golang?](https://200lab.io/blog/golang-la-gi) — Go (hay Golang) là ngôn ngữ lập trình mã nguồn mở giúp xây dựng phần mềm dễ dàng, tin cậy và hiệu quả do các kỹ sư hàng đầu Google phát triển

## Bước 1: Tạo Kafka cluster và topic trên Confluent Cloud

Ở mục Chuẩn bị phía trên, mình đã liệt kê 3 cách để tương tác với Confluent Cloud. Trong phạm vi bài viết, mình hướng dẫn 2 cách phổ biến là:

1. Dùng Confluent CLI (giao diện dòng lệnh)
2. Dùng Confluent Cloud Console (giao diện web)

### Cách 1: Dùng Confluent CLI

### 1. Tạo cluster

Bỏ qua bước này nếu bạn đã có sẵn một cluster.

```bash
confluent kafka cluster create <name> --cloud <cloud provider> --region <cloud region>
```

_Câu lệnh tạo cluster trong Confluent CLI_

Ví dụ

```bash
confluent kafka cluster create dev0 --cloud aws --region us-east-1
```

_Ví dụ về câu lệnh tạo cluster trong Confluent CLI_

### 2. Tạo topic bên trong cluster vừa tạo ở bước 1

`cluster ID` lấy từ output sau khi tạo cluster ở bước 1.

```bash
confluent kafka topic create <name> --cluster <cluster ID>
```

_Câu lệnh tạo topic trong Confluent CLI_

Ví dụ

```bash
confluent kafka topic create test_topic --cluster <ID of the dev0 cluster>
```

_Ví dụ về câu lệnh tạo topic trong Confluent CLI_

Nếu bạn đã có sẵn cluster, chạy câu lệnh sau để lấy thông tin (bao gồm ID) của tất cả cluster.

```bash
confluent kafka cluster list
```

_Câu lệnh lấy thông tin của tất cả các clusters_

### 3. Tạo API key cho cluster

API key dùng để xác thực kết nối giữa clients với cluster.

```bash
confluent api-key create --resource <cluster ID>
```

_tạo API key cho cluster_

### Cách 2: Dùng Cloud Console

### 1. Tạo cluster

Có nhiều lựa chọn để tạo cluster tương ứng với các cấu hình khác nhau. Ở phạm vi demo của bài này, chúng ta sẽ chọn cluster Basic.

![kafka-co-ban](https://assets.200lab.io/images/2024/12/05/screenshot-2023-08-21-at-18-21-53-b8d18bd2d9132c219c18.webp)

### 2. Tạo topic bên trong cluster vừa tạo ở bước 1

Từ menu điều hướng, click vào **Topics**, sau đó click vào nút **Add Topic**.

![kafka-co-ban](https://assets.200lab.io/images/2024/12/05/screenshot-2023-08-21-at-20-59-38-6f4cb64c28f42c7fded8.webp)

Giá trị mặc định số partition của topic trên Confluent Cloud là **6**. Số partition tối đa không phải vô hạn mà phụ thuộc loại cluster bạn chọn, nên hãy xem mục giới hạn của loại cluster trong tài liệu Confluent khi cần nhiều partition.

![kafka-co-ban](https://assets.200lab.io/images/2024/12/05/screenshot-2023-08-21-at-18-20-50-7d83b097d6ae71e63f09.webp)

**_Việc lựa chọn số partition phụ thuộc vào nhiều yếu tố như:_**

- **Resource overhead** (Chi phí tài nguyên): Mỗi partition yêu cầu một số tài nguyên hệ thống về bộ nhớ và xử lý tệp. Số lượng partitions rất cao có thể chiếm dụng tài nguyên của brokers.
- **Latency** (Độ trễ): Số lượng partitions cao có thể dẫn tới tăng thời gian xử lý gây ra bởi chi phí quản lý và điều phối số lượng lớn partitions.
- **Metadata** (Dữ liệu quản trị cluster): Từ **Kafka 4.0**, metadata do các controller KRaft quản lý thay cho ZooKeeper. Số partition càng lớn thì metadata càng nhiều và controller càng phải xử lý nhiều hơn.
- **Throughput** (Thông lượng): Tăng partitions giúp tăng thông lượng do nhiều consumers cùng đọc đồng thời từ nhiều partitions khác nhau.
- **Scalability** (Độ mở rộng): Số partition tăng sẽ giúp việc xử lý events tốt hơn giữa các brokers.

### 3. Tạo API key cho cluster

Từ menu điều hướng, click vào **API Keys**, sau đó click vào nút **Add Key**. Sau đó, điền mô tả cho key (nếu cần) và tải xuống file chứa key và secret.

![kafka-co-ban](https://assets.200lab.io/images/2024/12/05/screenshot-2023-08-21-at-21-32-25-01446eb13591fd73819f.webp)

## Bước 2: Viết Kafka producer bằng Go (confluent-kafka-go)

Confluent cung cấp sẵn thư viện [confluent-kafka-go](<https://github.com/confluentinc/confluent-kafka-go>) (bản **v2.16.1** ở thời điểm cập nhật) để giúp clients kết nối với Confluent Cloud thông qua ngôn ngữ Go. Ngoài ra, bạn có thể xem code mẫu cho nhiều trường hợp khác nhau ở folder `examples` của repo.

Trong bài, mình khởi tạo một project Go có cấu trúc như sau:

```text
|-- kafka-using-confluent/
	|-- consumer.go
	|-- producer.go
	|-- README.md
	|-- go.mod
	|-- go.sum
```

_Cấu trúc của project chứa client code_

Mở terminal, khởi tạo dự án Go chứa clients code.

```bash
# Tạo folder để chứa source code
mkdir kafka-using-confluent && cd kafka-using-confluent
# Khởi tạo Go project và tải thư viện
go mod init kafka-demo
go get github.com/confluentinc/confluent-kafka-go/v2@v2.16.1
```

_Khởi tạo project Go chứa client code_

Tạo file `producer.go` trong folder `kafka-using-confluent` để gửi message tới Kafka.

```bash
touch producer.go
```

_Tạo file `producer.go`_

Message của chúng ta có dạng JSON như sau:

```json
{
  "id": 5950,
  "quantity": 3,
  "item_type": "guitar",
  "price_per_unit": "BMg="
}
```

_JSON Message_

Nội dung file `producer.go` như sau:

```go
// producer.go
package main

import (
	"fmt"
	"os"
	"time"

	"github.com/confluentinc/confluent-kafka-go/v2/kafka"
	"github.com/confluentinc/confluent-kafka-go/v2/schemaregistry"
	"github.com/confluentinc/confluent-kafka-go/v2/schemaregistry/serde"
	"github.com/confluentinc/confluent-kafka-go/v2/schemaregistry/serde/jsonschema"
)

// Purchase is a simple record example
type Purchase struct {
	Id           int    `json:"id"`
	Quantity     int    `json:"quantity"`
	ItemType     string `json:"item_type"`
	PricePerUnit string `json:"price_per_unit"`
}

func main() {
	// Get env
	if len(os.Args) < 8 {
		fmt.Fprintf(os.Stderr, "Usage: %s <bootstrap-servers> <cluster-api-key> <cluster-api-secret> <topic> <schema-registry-url> <schema-registry-api-key> <schema-registry-api-secret>\n", os.Args[0])
		os.Exit(1)
	}

	bootstrapServers := os.Args[1]
	clusterApiKey := os.Args[2]
	clusterApiSecret := os.Args[3]
	topic := os.Args[4]
	schemaRegistryUrl := os.Args[5]
	schemaRegistryApiKey := os.Args[6]
	schemaRegistryApiSecret := os.Args[7]

	hostname, err := os.Hostname()
	if err != nil {
		fmt.Printf("Failed to get hostname: %s", err)
		os.Exit(1)
	}

	// Create producer
	p, err := kafka.NewProducer(&kafka.ConfigMap{
		"bootstrap.servers": bootstrapServers,
		"sasl.mechanisms":   "PLAIN",
		"security.protocol": "SASL_SSL",
		"client.id":         hostname,
		"sasl.username":     clusterApiKey,
		"sasl.password":     clusterApiSecret,
		"acks":              "all",
	})
	if err != nil {
		fmt.Printf("Failed to create producer: %s", err)
		os.Exit(1)
	}

	// Create schema register client
	client, err := schemaregistry.NewClient(schemaregistry.NewConfigWithAuthentication(
		schemaRegistryUrl,
		schemaRegistryApiKey,
		schemaRegistryApiSecret,
	))
	if err != nil {
		fmt.Printf("Failed to create schema registry client: %s\n", err)
		os.Exit(1)
	}

	ser, err := jsonschema.NewSerializer(client, serde.ValueSerde, jsonschema.NewSerializerConfig())
	if err != nil {
		fmt.Printf("Failed to create serializer: %s\n", err)
		os.Exit(1)
	}

	// Serialize message
	msg := Purchase{
		Id:           5950,
		Quantity:     3,
		ItemType:     "guitar",
		PricePerUnit: "BMg=",
	}
	msgBytes, err := ser.Serialize(topic, &msg)
	if err != nil {
		fmt.Printf("Failed to serialize payload: %s\n", err)
		os.Exit(1)
	}

	// Asynchronous writes
	deliveryChan := make(chan kafka.Event, 10000)
	err = p.Produce(&kafka.Message{
		TopicPartition: kafka.TopicPartition{Topic: &topic, Partition: kafka.PartitionAny},
		Value:          msgBytes,
		Key:            []byte(time.Now().UTC().Format(time.RFC1123)),
		Headers:        []kafka.Header{{Key: "myTestHeader", Value: []byte("header values are binary")}},
	}, deliveryChan)
	if err != nil {
		fmt.Printf("Failed to deliver message: %s", err)
		os.Exit(1)
	}

	// Go-routine to handle message delivery reports and possibly other event types (errors, stats, etc)
	go func() {
		for e := range p.Events() {
			switch ev := e.(type) {
			case *kafka.Message:
				if ev.TopicPartition.Error != nil {
					fmt.Printf("Failed to deliver: %v\n", ev.TopicPartition.Error)
				} else {
					fmt.Printf("Delivered message to topic %s partition [%d] @ offset %v\n",
						*ev.TopicPartition.Topic, ev.TopicPartition.Partition, ev.TopicPartition.Offset)
				}
			case kafka.Error:
				// Generic client instance-level errors, such as
				// broker connection failures, authentication issues, etc.
				//
				// These errors should generally be considered informational
				// as the underlying client will automatically try to
				// recover from any errors encountered, the application
				// does not need to take action on them.
				fmt.Printf("Error: %v\n", ev)
			default:
				fmt.Printf("Ignored event: %s\n", ev)
			}
		}
	}()

	// Wait for all messages to be delivered
	// Flush and close the producer and the events channel
	for p.Flush(1000) > 0 {
		fmt.Print("Still waiting to flush outstanding messages\n")
	}
	p.Close()
}
```

_Source code cho file producer.go_

Chúng ta sẽ cần chạy 2 terminal. Terminal 1 cho producer tạo message tới Kafka. Terminal 2 cho consumer đọc message từ Kafka.

Chạy dòng lệnh sau trên terminal 1, truyền vào các tham số cần thiết để tạo producer và gửi message tới Kafka.

```bash
go run producer.go \
<bootstrap-servers> \
<cluster-api-key> \
<cluster-api-secret> \
<topic> \
<schema-registry-url> \
<schema-registry-api-key> \
<schema-registry-api-secret>
```

_Script tạo producer_

**_Trong câu lệnh trên, ta có các tham số cần thiết là:_**

1. `bootstrap-servers`: danh sách các brokers mà clients sẽ tương tác với. Ví dụ, `host1:port1,host2:port2`.
2. `cluster-api-key`: API key của cluster.
3. `cluster-api-secret`: API secret của cluster.
4. `topic`: topic mà producer sẽ gửi message tới.
5. `schema-registry-url`: API endpoint để các ứng dụng tương tác với Schema Registry.
6. `schema-registry-api-key`: API key của Schema Registry, tạo riêng với API key của cluster.
7. `schema-registry-api-secret`: API secret đi kèm key ở trên.

Một event mới tạo ra sẽ trông như sau ở Confluent Console:

![kafka-co-ban](https://assets.200lab.io/images/2024/12/05/screenshot-2023-08-21-at-21-55-52-8a7171124ba0368f365d.webp)

![kafka-co-ban](https://assets.200lab.io/images/2024/12/05/screenshot-2023-08-21-at-21-59-44-1-03062fe943842693be98.webp)

## Bước 3: Viết Kafka consumer bằng Go và consumer group

Tạo file `consumer.go` trong folder `kafka-using-confluent`. File này dùng để tạo consumer để đọc message từ Kafka và hiển thị ra console.

```go
// consumer.go
package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"

	"github.com/confluentinc/confluent-kafka-go/v2/kafka"
)

func main() {
	if len(os.Args) < 6 {
		fmt.Fprintf(os.Stderr, "Usage: %s <bootstrap-servers> <cluster-api-key> <cluster-api-secret> <group> <topics..>\n", os.Args[0])
		os.Exit(1)
	}

	bootstrapServers := os.Args[1]
	clusterApiKey := os.Args[2]
	clusterApiSecret := os.Args[3]
	group := os.Args[4]
	topics := os.Args[5:]

	sigchan := make(chan os.Signal, 1)
	signal.Notify(sigchan, syscall.SIGINT, syscall.SIGTERM)

	c, err := kafka.NewConsumer(&kafka.ConfigMap{
		"bootstrap.servers": bootstrapServers,
		// Avoid connecting to IPv6 brokers:
		// This is needed for the ErrAllBrokersDown show-case below
		// when using localhost brokers on OSX, since the OSX resolver
		// will return the IPv6 addresses first.
		// You typically don't need to specify this configuration property.
		"broker.address.family": "v4",
		"sasl.mechanisms":       "PLAIN",
		"security.protocol":     "SASL_SSL",
		"sasl.username":         clusterApiKey,
		"sasl.password":         clusterApiSecret,
		"group.id":              group,
		"session.timeout.ms":    6000,
		// Start reading from the first message of each assigned
		// partition if there are no previously committed offsets
		// for this group.
		"auto.offset.reset": "earliest",
		// Whether we store offsets automatically.
		"enable.auto.offset.store": false,
	})
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to create consumer: %s\n", err)
		os.Exit(1)
	}

	fmt.Printf("Created Consumer %v\n", c)

	if err := c.SubscribeTopics(topics, nil); err != nil {
		fmt.Fprintf(os.Stderr, "Failed to subscribe topics %s %s\n", topics, err)
		os.Exit(1)
	}

	run := true

	for run {
		select {
		case sig := <-sigchan:
			fmt.Printf("Caught signal %v: terminating\n", sig)
			run = false
		default:
			// Retrieve records one-by-one
			ev := c.Poll(100)
			if ev == nil {
				continue
			}

			switch e := ev.(type) {
			case *kafka.Message:
				// Process the message received.
				fmt.Printf("%% Message on %s:\n%s\n",
					e.TopicPartition, string(e.Value))
				if e.Headers != nil {
					fmt.Printf("%% Headers: %v\n", e.Headers)
				}

				// We can store the offsets of the messages manually or let
				// the library do it automatically based on the setting
				// enable.auto.offset.store. Once an offset is stored, the
				// library takes care of periodically committing it to the broker
				// if enable.auto.commit isn't set to false (the default is true).
				// By storing the offsets manually after completely processing
				// each message, we can ensure atleast once processing.
				if _, err := c.StoreMessage(e); err != nil {
					fmt.Fprintf(os.Stderr, "%% Error storing offset after message %s:\n", e.TopicPartition)
				}
			case kafka.Error:
				// Errors should generally be considered
				// informational, the client will try to automatically recover.
				// But in this example we choose to terminate the application if all brokers are down.
				fmt.Fprintf(os.Stderr, "%% Error: %v: %v\n", e.Code(), e)
				if e.Code() == kafka.ErrAllBrokersDown {
					run = false
				}
			default:
				fmt.Printf("Ignored %v\n", e)
			}
		}
	}

	fmt.Printf("Closing consumer\n")
	c.Close()
}
```

_Source code cho file consumer.go_

Mở terminal 2, chạy dòng lệnh sau để tạo consumer đọc message từ Kafka.

```bash
# Chạy consumer, truyền vào các tham số cần thiết
go run consumer.go \
<bootstrap-servers> \
<cluster-api-key> \
<cluster-api-secret> \
<consumer-group-id> \
<topic-1> \
<topic-2> \
...
<topic-N>
```

_Câu lệnh tạo consumer_

**_Trong câu lệnh trên, ta có các tham số cần thiết là:_**

1. `bootstrap-servers`: danh sách các brokers mà clients sẽ tương tác với. Ví dụ, `host1:port1,host2:port2`.
2. `cluster-api-key`: API key của cluster
3. `cluster-api-secret`: API secret của cluster
4. `consumer-group-id`: ID của consumer group
5. `topic-1`, `topic-2`, `topic-N`: consumers subscribe tới nhiều topic 1, 2, ..., N.

Consumer group quyết định cách các consumer chia việc. Nếu bạn mở thêm terminal và chạy consumer thứ hai với cùng `consumer-group-id`, Kafka sẽ chia các partition của topic cho hai consumer, mỗi message chỉ được một trong hai consumer xử lý.

Nếu chạy với một `consumer-group-id` mới, group đó có offset riêng. Do code đặt `auto.offset.reset` là `earliest`, group mới sẽ đọc lại topic từ message đầu tiên.

## So sánh thư viện Kafka cho Go: confluent-kafka-go, kafka-go và franz-go

Khi tìm kiếm một Go Kafka client cho dự án, bạn sẽ thường gặp ba cái tên phổ biến là [confluent-kafka-go](<https://github.com/confluentinc/confluent-kafka-go>), [segmentio/kafka-go](<https://github.com/segmentio/kafka-go>) và [twmb/franz-go](<https://github.com/twmb/franz-go>). Mỗi thư viện có cách tiếp cận kỹ thuật riêng phù hợp với từng bối cảnh triển khai khác nhau.

| Thư viện | Cách hoạt động | Hợp khi |
| --- | --- | --- |
| `confluent-kafka-go` | Bọc thư viện C `librdkafka`, yêu cầu bật `cgo` | Dùng hệ sinh thái Confluent Cloud và cần sẵn client Schema Registry |
| `segmentio/kafka-go` | Viết bằng Go thuần, không cần `cgo` | Muốn dùng thiết kế API gần gũi với thư viện chuẩn của Go |
| `twmb/franz-go` | Viết bằng Go thuần, không cần `cgo` | Cần hỗ trợ nhiều tính năng của giao thức Kafka mà không phụ thuộc C |

Không có thư viện nào là lựa chọn tốt nhất cho mọi trường hợp, bạn hãy cân nhắc dựa trên nhu cầu thực tế. Nếu dự án gắn liền với Confluent Cloud và Schema Registry, `confluent-kafka-go` sẽ rất tiện lợi. Ngược lại, nếu bạn muốn quá trình build không phụ thuộc `cgo` để dễ dàng cross-compile hoặc đóng gói vào các container nhỏ như `scratch` và `alpine`, các thư viện Go thuần như `kafka-go` hay `franz-go` sẽ là hướng đi phù hợp.

## Câu hỏi thường gặp khi học Kafka

### Kafka 4 còn cần ZooKeeper không?

Từ phiên bản **Kafka 4.0** ra mắt vào tháng 3/2025, ZooKeeper đã bị loại bỏ hoàn toàn khỏi hệ thống. Kafka hiện chỉ hoạt động ở chế độ KRaft, nơi toàn bộ metadata được quản lý trực tiếp bởi các controller của chính Kafka. Phiên bản **Kafka 3.9** là bản cuối cùng còn duy trì sự hỗ trợ cho ZooKeeper.

### Dùng Kafka có mất phí không?

Bản thân Apache Kafka là nền tảng mã nguồn mở theo giấy phép Apache 2.0 của Apache Software Foundation nên bạn có thể tải về hoặc chạy bằng Docker hoàn toàn miễn phí. Bạn chỉ tốn chi phí hạ tầng máy chủ hoặc trả tiền khi thuê các dịch vụ quản lý sẵn như Confluent Cloud sau khi đã dùng hết **$400 credit** trong **30 ngày** đầu.

### Nên chọn bao nhiêu partition cho một topic?

Chia nhiều partition giúp nhiều consumer trong cùng một group đọc dữ liệu song song để tăng thông lượng, nhưng lại tiêu tốn thêm tài nguyên của broker và làm tăng dung lượng metadata trên controller. Bạn lưu ý là số consumer thực sự hoạt động trong một group sẽ không vượt quá số partition hiện có, vì các consumer thừa sẽ chỉ đứng chờ. Ngoài ra, bạn có thể tăng thêm số partition về sau nhưng không thể giảm đi, và việc tăng này cũng sẽ làm thay đổi cách phân bổ dữ liệu theo key.

### Kafka khác RabbitMQ thế nào?

Kafka lưu trữ các event dưới dạng log bền vững, cho phép nhiều consumer đọc lại dữ liệu theo vị trí offset và rất phù hợp cho bài toán xử lý dữ liệu stream với khối lượng lớn. Trong khi đó, RabbitMQ là một message broker hoạt động theo mô hình hàng đợi, nơi các message thường sẽ bị xoá khỏi queue ngay sau khi consumer gửi xác nhận đã nhận. Bạn có thể đọc phân tích chi tiết hơn tại bài viết [Kafka vs RabbitMQ](</blog/kafka-vs-rabbitmq>).

## Tổng kết

Qua bài viết này, bạn đã nắm được các khái niệm nền tảng của Kafka, biết cách tự khởi chạy nhanh bản **Kafka 4.4.0** trên máy cá nhân bằng Docker với chế độ KRaft cũng như cách thiết lập một cluster trên Confluent Cloud. Bên cạnh đó, chúng ta cũng đã thực hành viết ứng dụng producer và consumer bằng ngôn ngữ Go để gửi nhận dữ liệu thực tế ở cả hai môi trường.

Để hiểu rõ hơn cơ chế phân tải, bạn hãy thử mở nhiều cửa sổ terminal và chạy cùng lúc nhiều tiến trình consumer trong một consumer group để quan sát cách các partition được chia đều. Khi đã quen thuộc với luồng dữ liệu cơ bản, bước tiếp theo bạn nên tìm hiểu là cách quản lý cấu trúc dữ liệu bài bản hơn qua bài [Quản lý Schema và Avro Serialization trong hệ thống Apache Kafka](</blog/quan-ly-schema-va-serialization-trong-he-thong-apache-kafka>).

(\*) Bài viết này có tham khảo thông tin ở [Confluent](<https://docs.confluent.io/cloud/current/get-started/index.html>) & [Tổng quan về Schema Registry](<https://docs.confluent.io/platform/current/schema-registry/develop/api.html>).

**Một vài bài viết liên quan có thể bạn sẽ thích:**

- [Kafka là gì? Các thành phần trong Kafka](</blog/kafka-la-gi>)
- [Kafka vs RabbitMQ](</blog/kafka-vs-rabbitmq>)
- [Quản lý Schema và Avro Serialization trong hệ thống Apache Kafka](</blog/quan-ly-schema-va-serialization-trong-he-thong-apache-kafka>)
- [Golang là gì? Backend Developer có nên học Golang?](</blog/golang-la-gi>)

## Đọc thêm

- [Consistent hashing là gì? Thêm server mà không phải xáo lại toàn bộ cache](https://200lab.io/blog/consistent-hashing-la-gi.md): Consistent hashing đặt key và node lên hash ring để thêm node ít xáo trộn cache. Demo Go: mod N chuyển 79,7% key, ring 100 virtual node chỉ chuyển 21,2%.
- [Cache stampede: khi cache hết hạn và hàng loạt request dồn xuống database](https://200lab.io/blog/cache-stampede-la-gi.md): Cache stampede xảy ra khi key hết hạn và nhiều request cùng gọi xuống database. singleflight gộp lời gọi trong một process, TTL jitter rải thời điểm hết hạn.
- [Connection pool là gì, vì sao service Go treo dù database còn rảnh](https://200lab.io/blog/connection-pool-la-gi.md): Service Go timeout hàng loạt trong khi database vẫn rảnh? Bài này giúp bạn hiểu connection pool trong Go hoạt động ra sao và cách chỉnh pool cho đúng tải.
- [Outbox pattern: ghi database và gửi message mà không mất đơn](https://200lab.io/blog/outbox-pattern-la-gi.md): Outbox pattern là gì: ghi đơn và event trong cùng một transaction, rồi relay gửi sau; demo PostgreSQL cho thấy dual-write làm mất message khi service restart.
- [Retry với backoff và jitter: gọi lại API lỗi mà không làm sập server](https://200lab.io/blog/retry-la-gi.md): Retry là gì: gọi lại khi lỗi tạm dễ thành thundering herd; exponential backoff chưa đủ, cần jitter để lệch nhịp và đo đỉnh request theo giây.
- [Mọi bài viết chủ đề Backend](https://200lab.io/blog/tags/backend.md)

Toàn bộ nội dung: https://200lab.io/llms.txt
