Backup và restore thủ công cho Kafka

Backup trên nền tảng đã bị gỡ khỏi Kafka từ 15/09/2026, nên việc bảo vệ dữ liệu Kafka giờ do bạn tự vận hành. Trang này dựng một mirror VM riêng, liên tục nhân bản topic bằng MirrorMaker 2, chụp snapshot theo lịch, rồi restore snapshot bạn chọn sang một Kafka service mới.

thông tin

Tab Backup không còn xuất hiện trên database Kafka, và toàn bộ file backup có trước mốc đó đã bị xoá. Xem Tổng quan Backup & Restore để biết những gì đã thay đổi.

Cơ chế hoạt động

Mirror VM là một VM của bạn, chạy Kafka single-node kèm MirrorMaker 2. Nó giữ một bản sao sống của các topic, nhờ đó chụp được snapshot nhất quán mà không phải dừng database nguồn.

Giai đoạn	Diễn ra điều gì
Mirror	MirrorMaker 2 liên tục nhân bản mọi topic từ database nguồn sang mirror VM
Backup	Script dừng Kafka trên mirror VM, nén thư mục dữ liệu, rồi khởi động lại
Restore	Bạn nạp bản archive đã chọn lên mirror VM, rồi nhân bản sang Kafka service mới bằng MirrorMaker 2

Database nguồn không bao giờ bị dừng và không bị chỉnh sửa, ở cả hai chiều.

Điều kiện tiên quyết

Hạng mục	Yêu cầu
OS	Ubuntu 20.04 hoặc 22.04
Kafka binary	`kafka_2.13-<KAFKA_VERSION>.tgz`, trùng hoặc tương thích với phiên bản của database nguồn
Đĩa	Hai đĩa: một cho OS, một cho dữ liệu
Mạng	Mirror VM phải thông tới database nguồn ở port 9092

MirrorMaker 2 có sẵn trong Kafka từ bản 2.4.0 trở đi, nên không phải cài thêm gì cho nó.

Các placeholder dùng trong trang này

Placeholder	Ý nghĩa	Ví dụ
`<KAFKA_VERSION>`	Phiên bản Kafka cần cài	`3.8.0` hoặc `4.1.2`
`<BACKUP_VM_IP>`	IP private của mirror VM	`10.0.1.50`
`<SOURCE_BOOTSTRAP>`	Bootstrap server của database nguồn	`10.0.0.1:9092,10.0.0.2:9092`
`<SOURCE_ADMIN_USER>`	Tài khoản admin trên database nguồn	`admin`
`<SOURCE_ADMIN_PASS>`	Mật khẩu admin trên database nguồn	—
`<BACKUP_ADMIN_PASS>`	Mật khẩu admin bạn đặt trên mirror VM	—
`<RESTORE_BOOTSTRAP>`	Bootstrap server của Kafka service mới	`10.0.2.10:9092,10.0.2.11:9092`
`<RESTORE_ADMIN_USER>`	Tài khoản admin trên Kafka service mới	`admin`
`<RESTORE_ADMIN_PASS>`	Mật khẩu admin trên Kafka service mới	—
`<JAVA_HEAP_GB>`	Kích thước JVM heap tính bằng GB	`4`
`<DISK_DEVICE>`	Thiết bị đĩa dữ liệu	`/dev/sdb` trên VMware, `/dev/vdb` trên OpenStack
`<CONFIG_PATH>`	File config của Kafka, có đổi chỗ giữa các bản	xem bảng bên dưới

Đường dẫn config và tham số controller quorum đều thay đổi qua các bản Kafka:

Phiên bản Kafka	`<CONFIG_PATH>`	Tham số controller quorum	Lệnh format
Dưới 4.0	`/kafka/kafka/config/kraft/server.properties`	`controller.quorum.voters`	không thêm cờ
4.0 đến dưới 4.1.2	`/kafka/kafka/config/kraft/server.properties`	`controller.quorum.bootstrap.servers`	thêm `--standalone`
Từ 4.1.2 trở lên	`/kafka/kafka/config/server.properties`	`controller.quorum.bootstrap.servers`	thêm `--standalone`

Phần 1 — Cài Kafka trên mirror VM

Chuẩn bị hệ thống

# Update system packages
apt update -y

# Install Java (required by Kafka)
apt install -y default-jdk

# Verify Java installation
java -version

# Create Kafka system user and group
groupadd kafka
useradd -g kafka -s /bin/bash kafka

# Create base directories
mkdir -p /kafka

Chuẩn bị đĩa dữ liệu

Thay <DISK_DEVICE> bằng tên thiết bị tương ứng với hạ tầng — /dev/sdb trên VMware, /dev/vdb trên OpenStack.

# Partition the disk
parted <DISK_DEVICE> --script mklabel gpt
parted <DISK_DEVICE> --script mkpart primary 0% 100%
parted <DISK_DEVICE> --script set 1 lvm on

# Create LVM
pvcreate <DISK_DEVICE>1
vgcreate vg_data <DISK_DEVICE>1
lvcreate -l 100%FREE -n lv_data vg_data

# Format and mount
mkfs.xfs /dev/vg_data/lv_data
mkdir -p /data
mount /dev/vg_data/lv_data /data

# Persist mount across reboots
echo "/dev/mapper/vg_data-lv_data /data xfs users,noatime,auto,rw,nodev,exec,nosuid 0 0" >> /etc/fstab

# Set ownership
chown -R kafka:kafka /data

Cài Kafka binary

Chép gói Kafka lên VM rồi giải nén:

# Copy the Kafka binary package to the VM, then extract it
tar -xzf kafka_2.13-<KAFKA_VERSION>.tgz -C /kafka/
mv /kafka/kafka_2.13-<KAFKA_VERSION> /kafka/kafka

# Set ownership
chown -R kafka:kafka /kafka

Tạo service cho Kafka

cat > /lib/systemd/system/kafka.service << 'EOF'
[Unit]
Description=Apache Kafka
After=syslog.target network.target

[Service]
Type=simple
User=kafka
ExecStart=/kafka/kafka/bin/kafka-server-start.sh <CONFIG_PATH>
ExecStop=/kafka/kafka/bin/kafka-server-stop.sh
TimeoutStopSec=180
Restart=on-abnormal

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload

Thay <CONFIG_PATH> đúng theo phiên bản của bạn ở bảng trên trước khi chạy.

Viết cấu hình Kafka

Tạo config nền, một node chạy chế độ KRaft:

# Create the config (single-node, KRaft mode)
# Replace <BACKUP_VM_IP> and <BACKUP_ADMIN_PASS> with actual values

cat > <CONFIG_PATH> << EOF
############################# KRaft Mode - Single Node #############################
process.roles=broker,controller
node.id=1

listener.security.protocol.map=CONTROLLER:SASL_PLAINTEXT,PLAINTEXT:PLAINTEXT,SASL_PLAINTEXT:SASL_PLAINTEXT
listeners=PLAINTEXT://localhost:9091,CONTROLLER://0.0.0.0:9094,SASL_PLAINTEXT://0.0.0.0:9092
advertised.listeners=PLAINTEXT://localhost:9091,SASL_PLAINTEXT://<BACKUP_VM_IP>:9092
inter.broker.listener.name=SASL_PLAINTEXT

############################# Controller #############################
EOF

Ghi thêm tham số controller quorum khớp với phiên bản của bạn.

Với Kafka dưới 4.0:

cat >> <CONFIG_PATH> << EOF
controller.quorum.voters=1@<BACKUP_VM_IP>:9094
EOF

Với Kafka từ 4.0 trở lên:

cat >> <CONFIG_PATH> << EOF
controller.quorum.bootstrap.servers=<BACKUP_VM_IP>:9094
EOF

Rồi ghi nốt phần còn lại, giống nhau ở mọi phiên bản:

cat >> <CONFIG_PATH> << EOF
controller.listener.names=CONTROLLER

############################# SASL Authentication #############################
sasl.mechanism.controller.protocol=PLAIN
listener.name.controller.sasl.enabled.mechanisms=PLAIN
listener.name.controller.plain.sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="admin" \
    password="<BACKUP_ADMIN_PASS>" \
    user_admin="<BACKUP_ADMIN_PASS>";

listener.name.sasl_plaintext.plain.sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="admin" \
    password="<BACKUP_ADMIN_PASS>" \
    user_admin="<BACKUP_ADMIN_PASS>";

sasl.mechanism.inter.broker.protocol=PLAIN
sasl.enabled.mechanisms=PLAIN

############################# ACL #############################
authorizer.class.name=org.apache.kafka.metadata.authorizer.StandardAuthorizer
allow.everyone.if.no.acl.found=false
super.users=User:admin

############################# Storage & Log #############################
log.dirs=/data/kafka/combine-logs
num.partitions=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
default.replication.factor=1

log.retention.hours=168
log.retention.bytes=-1
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000

############################# Network #############################
num.network.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
EOF

Đặt JVM heap

Dùng khoảng 25% RAM của VM, tối thiểu 2 GB và tối đa 24 GB.

# Set heap size (adjust <JAVA_HEAP_GB> based on available RAM)
sed -i 's/export KAFKA_HEAP_OPTS="-Xmx[0-9]*G -Xms[0-9]*G"/export KAFKA_HEAP_OPTS="-Xmx<JAVA_HEAP_GB>G -Xms<JAVA_HEAP_GB>G"/' \
    /kafka/kafka/bin/kafka-server-start.sh

Format storage và khởi động Kafka

Sinh cluster ID cho mirror VM. ID này độc lập với ID của database nguồn.

CLUSTER_ID=$(/kafka/kafka/bin/kafka-storage.sh random-uuid)
echo "Cluster ID: $CLUSTER_ID"

Format storage. Với Kafka dưới 4.0:

/kafka/kafka/bin/kafka-storage.sh format \
    -t $CLUSTER_ID \
    -c <CONFIG_PATH>

Với Kafka từ 4.0 trở lên:

/kafka/kafka/bin/kafka-storage.sh format \
    -t $CLUSTER_ID \
    -c <CONFIG_PATH> \
    --standalone

Rồi khởi động service:

chown -R kafka:kafka /data

systemctl enable kafka
systemctl start kafka

# Verify Kafka is listening
ss -tlnp | grep 9092

Xác nhận Kafka chạy được

Tạo file thông tin đăng nhập cho CLI, rồi tạo và xoá một topic thử:

# Create admin.properties for CLI access
cat > /kafka/kafka/config/kraft/admin.properties << EOF
security.protocol=SASL_PLAINTEXT
sasl.mechanism=PLAIN
sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="admin" \
    password="<BACKUP_ADMIN_PASS>";
EOF

# Create a test topic to confirm Kafka is operational
/kafka/kafka/bin/kafka-topics.sh \
    --bootstrap-server <BACKUP_VM_IP>:9092 \
    --command-config /kafka/kafka/config/kraft/admin.properties \
    --create \
    --topic test-connectivity \
    --partitions 1 \
    --replication-factor 1

# List topics
/kafka/kafka/bin/kafka-topics.sh \
    --bootstrap-server <BACKUP_VM_IP>:9092 \
    --command-config /kafka/kafka/config/kraft/admin.properties \
    --list

# Delete test topic
/kafka/kafka/bin/kafka-topics.sh \
    --bootstrap-server <BACKUP_VM_IP>:9092 \
    --command-config /kafka/kafka/config/kraft/admin.properties \
    --delete \
    --topic test-connectivity

Phần 2 — Thiết lập MirrorMaker 2

MirrorMaker 2 nhân bản topic từ database nguồn sang mirror VM. Cấu hình dưới dùng IdentityReplicationPolicy để giữ nguyên tên topic gốc thay vì thêm tiền tố — đây chính là thứ khiến snapshot trở thành bản sao trung thực.

Viết cấu hình MirrorMaker 2

cat > /kafka/kafka/config/kraft/mm2.properties << EOF
# Cluster identifiers
clusters = source, target

# Source cluster (existing Kafka service)
source.bootstrap.servers = <SOURCE_BOOTSTRAP>
source.security.protocol = SASL_PLAINTEXT
source.sasl.mechanism = PLAIN
source.sasl.jaas.config = org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="<SOURCE_ADMIN_USER>" \
    password="<SOURCE_ADMIN_PASS>";

# Target cluster (mirror VM)
target.bootstrap.servers = <BACKUP_VM_IP>:9092
target.security.protocol = SASL_PLAINTEXT
target.sasl.mechanism = PLAIN
target.sasl.jaas.config = org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="admin" \
    password="<BACKUP_ADMIN_PASS>";

# Replication direction: source -> target
source->target.enabled = true
source->target.topics = .*
source->target.emit.checkpoints.enabled = false
source->target.sync.topic.acls.enabled = false

# Keep original topic names (no prefix added)
replication.policy.class = org.apache.kafka.connect.mirror.IdentityReplicationPolicy

# Internal topic replication factors (set to 1 for single-node mirror)
offset-syncs.topic.replication.factor = 1
heartbeats.topic.replication.factor = 1
checkpoints.topic.replication.factor = 1
mm2-offsets.topic.replication.factor = 1
config.storage.replication.factor = 1
status.storage.replication.factor = 1
offset.storage.replication.factor = 1
replication.policy.separator = .
replication.factor = 1
EOF

chown kafka:kafka /kafka/kafka/config/kraft/mm2.properties

source->target.topics = .* nhân bản tất cả. Nếu chỉ muốn mirror một số topic, thay .* bằng danh sách ngăn cách bởi dấu phẩy hoặc một regex, ví dụ orders,payments,user-events.

Tạo service cho MirrorMaker 2

cat > /lib/systemd/system/kafka-mirror-maker.service << 'EOF'
[Unit]
Description=Kafka MirrorMaker 2 Service
After=network.target kafka.service

[Service]
Type=simple
User=kafka
ExecStart=/kafka/kafka/bin/connect-mirror-maker.sh /kafka/kafka/config/kraft/mm2.properties
StandardOutput=append:/kafka/kafka/logs/mm2.log
StandardError=append:/kafka/kafka/logs/mm2.log

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload

Xoay vòng log của MirrorMaker 2

MirrorMaker 2 ghi log liên tục, phải xoay vòng file nếu không nó sẽ lấp đầy đĩa.

cat > /etc/logrotate.d/mm2 << 'EOF'
/kafka/kafka/logs/mm2.log {
    maxsize 100M
    copytruncate
    rotate 2
    delaycompress
    compress
    notifempty
    missingok
    su root root
}
EOF

# Run logrotate every 15 minutes
crontab -l 2>/dev/null | { cat; echo "15 * * * * /usr/sbin/logrotate /etc/logrotate.d/mm2"; } | crontab -

Chạy nhân bản và kiểm chứng

systemctl enable kafka-mirror-maker
systemctl start kafka-mirror-maker

# Check service status
systemctl status kafka-mirror-maker

# Monitor MM2 logs
tail -f /kafka/kafka/logs/mm2.log

Sau vài phút, liệt kê topic trên mirror VM. Chúng phải trùng với database nguồn, không có tiền tố nào thêm vào:

/kafka/kafka/bin/kafka-topics.sh \
    --bootstrap-server <BACKUP_VM_IP>:9092 \
    --command-config /kafka/kafka/config/kraft/admin.properties \
    --list

Phần 3 — Tạo bản backup

Một bản backup là archive chụp thư mục dữ liệu của mirror VM tại một thời điểm. Script dừng MirrorMaker 2 và Kafka trước, để archive nhất quán bên trong, rồi khởi động lại cả hai.

Tạo script backup

cat > /usr/local/bin/kafka-backup.sh << 'SCRIPT'
#!/bin/bash
set -e

KAFKA_DATA_DIR=/data/kafka/combine-logs
BACKUP_DIR=/backup/kafka
TIMESTAMP=$(date +%F_%H-%M-%S)
BACKUP_FILE=${BACKUP_DIR}/kafka-backup-${TIMESTAMP}.tar.gz
LOCKFILE=/tmp/kafka-backup.lock

# Prevent concurrent runs
if [ -f "$LOCKFILE" ]; then
    echo "ERROR: Another backup is already running (lock file: $LOCKFILE). Exiting."
    exit 1
fi
touch "$LOCKFILE"

cleanup() {
    rm -f "$LOCKFILE"
}
trap cleanup EXIT

mkdir -p "$BACKUP_DIR"

echo "[$(date)] Starting Kafka backup..."

# Step 1: Stop MirrorMaker 2 to freeze incoming replication
echo "[$(date)] Stopping MirrorMaker 2..."
systemctl stop kafka-mirror-maker

# Step 2: Stop Kafka to ensure data consistency
echo "[$(date)] Stopping Kafka..."
systemctl stop kafka

# Step 3: Create compressed archive of the data directory
echo "[$(date)] Creating archive: $BACKUP_FILE"
tar -czf "$BACKUP_FILE" -C / data/kafka/combine-logs

echo "[$(date)] Backup size: $(du -sh $BACKUP_FILE | cut -f1)"

# Step 4: Restart Kafka
echo "[$(date)] Starting Kafka..."
systemctl start kafka
sleep 10

# Step 5: Restart MirrorMaker 2
echo "[$(date)] Starting MirrorMaker 2..."
systemctl start kafka-mirror-maker

echo "[$(date)] Backup completed successfully: $BACKUP_FILE"
SCRIPT

chmod +x /usr/local/bin/kafka-backup.sh

Chạy backup, theo lịch hoặc thủ công

Chạy ngay một bản backup:

/usr/local/bin/kafka-backup.sh

Đặt lịch backup hằng ngày lúc 02:00, và xoá archive cũ hơn bảy ngày:

crontab -l 2>/dev/null | { cat; echo "0 2 * * * /usr/local/bin/kafka-backup.sh >> /var/log/kafka-backup.log 2>&1"; } | crontab -

crontab -l 2>/dev/null | { cat; echo "30 2 * * * find /backup/kafka -name 'kafka-backup-*.tar.gz' -mtime +7 -delete"; } | crontab -

Đổi -mtime +7 để đặt thời gian lưu trữ khác, tính bằng ngày.

Xem những bản đang có

ls -lh /backup/kafka/

# Example output:
-rw-r--r-- 1 root root 2.3G 2026-04-10_02-00-01 kafka-backup-2026-04-10_02-00-01.tar.gz
-rw-r--r-- 1 root root 2.4G 2026-04-11_02-00-02 kafka-backup-2026-04-11_02-00-02.tar.gz
-rw-r--r-- 1 root root 2.4G 2026-04-12_02-00-01 kafka-backup-2026-04-12_02-00-01.tar.gz

Phần 4 — Restore sang Kafka service mới

Restore gồm ba giai đoạn: nạp archive đã chọn lên mirror VM, nhân bản sang Kafka service mới, rồi trả mirror VM về nhiệm vụ thường ngày.

ghi chú

Job mirror từ database nguồn bị dừng trong suốt quá trình. Bản thân database nguồn không bị đụng tới.

Giai đoạn 1 — Nạp archive lên mirror VM

Chọn archive bạn cần rồi dừng cả hai service:

# List available backups
ls -lh /backup/kafka/

# Set the target backup filename
BACKUP_FILE=kafka-backup-<TIMESTAMP>.tar.gz

systemctl stop kafka-mirror-maker
systemctl stop kafka

cảnh báo

Lệnh tiếp theo xoá vĩnh viễn dữ liệu hiện có trên mirror VM và thay bằng archive. Không thể hoàn tác. Hãy xác nhận bạn chọn đúng mốc thời gian trước khi chạy.

# Remove current data
rm -rf /data/kafka/combine-logs

# Extract the selected backup archive
tar -C /data -xzf /backup/kafka/$BACKUP_FILE --strip-components 1

# Fix ownership
chown -R kafka:kafka /data

systemctl start kafka
ss -tlnp | grep 9092

Mirror VM giờ phục vụ đúng dữ liệu tại mốc thời gian bạn chọn.

Giai đoạn 2 — Nhân bản sang service mới

Tạo một Kafka service mới trên portal, rồi ghi lại bootstrap server, tài khoản admin và mật khẩu admin. Xem Tạo database.

Viết cấu hình MirrorMaker 2 thứ hai, lần này từ mirror VM sang service mới:

cat > /kafka/kafka/config/kraft/mm2-restore.properties << EOF
# Cluster identifiers
clusters = source, target

# Source cluster (mirror VM holding the point-in-time snapshot)
source.bootstrap.servers = <BACKUP_VM_IP>:9092
source.security.protocol = SASL_PLAINTEXT
source.sasl.mechanism = PLAIN
source.sasl.jaas.config = org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="admin" \
    password="<BACKUP_ADMIN_PASS>";

# Target cluster (new Kafka service)
target.bootstrap.servers = <RESTORE_BOOTSTRAP>
target.security.protocol = SASL_PLAINTEXT
target.sasl.mechanism = PLAIN
target.sasl.jaas.config = org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="<RESTORE_ADMIN_USER>" \
    password="<RESTORE_ADMIN_PASS>";

# Replication direction: source -> target
source->target.enabled = true
source->target.topics = .*
source->target.emit.checkpoints.enabled = false
source->target.sync.topic.acls.enabled = false

# Keep original topic names (no prefix added)
replication.policy.class = org.apache.kafka.connect.mirror.IdentityReplicationPolicy

# Replication factor = 1 (single-node mirror VM)
offset-syncs.topic.replication.factor = 1
heartbeats.topic.replication.factor = 1
checkpoints.topic.replication.factor = 1
mm2-offsets.topic.replication.factor = 1
config.storage.replication.factor = 1
status.storage.replication.factor = 1
offset.storage.replication.factor = 1
replication.policy.separator = .
replication.factor = 1
EOF

chown kafka:kafka /kafka/kafka/config/kraft/mm2-restore.properties

Tạo service cho nó rồi khởi động:

cat > /lib/systemd/system/kafka-mirror-maker-restore.service << 'EOF'
[Unit]
Description=Kafka MirrorMaker 2 Restore Service
After=network.target kafka.service

[Service]
Type=simple
User=kafka
ExecStart=/kafka/kafka/bin/connect-mirror-maker.sh /kafka/kafka/config/kraft/mm2-restore.properties
StandardOutput=append:/kafka/kafka/logs/mm2-restore.log
StandardError=append:/kafka/kafka/logs/mm2-restore.log

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload

systemctl start kafka-mirror-maker-restore

# Monitor progress
tail -f /kafka/kafka/logs/mm2-restore.log

Kiểm tra topic đã sang tới service mới chưa:

cat > /kafka/kafka/config/kraft/restore-admin.properties << EOF
security.protocol=SASL_PLAINTEXT
sasl.mechanism=PLAIN
sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="<RESTORE_ADMIN_USER>" \
    password="<RESTORE_ADMIN_PASS>";
EOF

/kafka/kafka/bin/kafka-topics.sh \
    --bootstrap-server <RESTORE_BOOTSTRAP> \
    --command-config /kafka/kafka/config/kraft/restore-admin.properties \
    --list

Danh sách phải khớp với nội dung của archive. Khi đã khớp, dừng job restore:

systemctl stop kafka-mirror-maker-restore
systemctl disable kafka-mirror-maker-restore

Giai đoạn 3 — Trả mirror VM về trạng thái thường

Xoá snapshot, format lại storage với cluster ID mới, rồi khởi động lại việc mirror:

systemctl stop kafka

rm -rf /data/kafka/combine-logs

CLUSTER_ID=$(/kafka/kafka/bin/kafka-storage.sh random-uuid)
echo "Cluster ID: $CLUSTER_ID"

/kafka/kafka/bin/kafka-storage.sh format \
    -t $CLUSTER_ID \
    -c <CONFIG_PATH>

/kafka/kafka/bin/kafka-storage.sh format \
    -t $CLUSTER_ID \
    -c <CONFIG_PATH> \
    --standalone

Format bằng lệnh đúng với phiên bản của bạn, y như ở Phần 1, rồi:

chown -R kafka:kafka /data

systemctl start kafka
sleep 10
systemctl start kafka-mirror-maker

MirrorMaker 2 bắt đầu đồng bộ lại từ database nguồn và các bản backup theo lịch tự động chạy tiếp.

Xử lý sự cố

MirrorMaker 2 không nhân bản

Xem log, rồi xác nhận mirror VM có thực sự thông tới database nguồn không:

# Check MM2 logs for errors
tail -100 /kafka/kafka/logs/mm2.log | grep -i error

# Create source-admin.properties
cat > /kafka/kafka/config/kraft/source-admin.properties << EOF
security.protocol=SASL_PLAINTEXT
sasl.mechanism=PLAIN
sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required \
    username="<SOURCE_ADMIN_USER>" \
    password="<SOURCE_ADMIN_PASS>";
EOF

# Verify connectivity to the source cluster
/kafka/kafka/bin/kafka-topics.sh \
    --bootstrap-server <SOURCE_BOOTSTRAP> \
    --command-config /kafka/kafka/config/kraft/source-admin.properties \
    --list

Kafka không khởi động được sau khi restore

Nguyên nhân thường gặp là thư mục bị lồng thêm một cấp khi giải nén. /data/kafka/combine-logs/ phải chứa trực tiếp các thư mục partition, không phải một thư mục combine-logs nữa.

ls -la /data/kafka/combine-logs/
# Should show partition directories, not a nested combine-logs folder

# Check Kafka logs
journalctl -u kafka -n 50

Script backup dừng giữa chừng

Kafka và MirrorMaker 2 có thể vẫn đang dừng, và file lock có thể còn sót. Khởi động lại rồi xoá nó:

systemctl start kafka
sleep 10
systemctl start kafka-mirror-maker

# Remove the stale lock file if present
rm -f /tmp/kafka-backup.lock

Bước tiếp theo

Tổng quan Backup & Restore để biết engine nào còn backup trên nền tảng
Nâng cấp phiên bản database khi bạn cần một snapshot trước lúc đưa Kafka lên phiên bản mới
Backup và restore thủ công cho RabbitMQ nếu bạn còn chạy RabbitMQ, nơi cách làm hoàn toàn khác

Cơ chế hoạt động​

Điều kiện tiên quyết​

Các placeholder dùng trong trang này​

Phần 1 — Cài Kafka trên mirror VM​

Chuẩn bị hệ thống​

Chuẩn bị đĩa dữ liệu​

Cài Kafka binary​

Tạo service cho Kafka​

Viết cấu hình Kafka​

Đặt JVM heap​

Format storage và khởi động Kafka​

Xác nhận Kafka chạy được​

Phần 2 — Thiết lập MirrorMaker 2​

Viết cấu hình MirrorMaker 2​

Tạo service cho MirrorMaker 2​

Xoay vòng log của MirrorMaker 2​

Chạy nhân bản và kiểm chứng​

Phần 3 — Tạo bản backup​

Tạo script backup​

Chạy backup, theo lịch hoặc thủ công​

Xem những bản đang có​

Phần 4 — Restore sang Kafka service mới​

Giai đoạn 1 — Nạp archive lên mirror VM​

Giai đoạn 2 — Nhân bản sang service mới​

Giai đoạn 3 — Trả mirror VM về trạng thái thường​

Xử lý sự cố​

MirrorMaker 2 không nhân bản​

Kafka không khởi động được sau khi restore​

Script backup dừng giữa chừng​

Bước tiếp theo​