kafka

Debezium作用

l 开源项目，为捕获数据更改(change data capture,CDC)提供了一个低延迟的流式处理平台。

l Debezium监控数据库，应用就可以消费对数据库的每一个行级别(row-level)的更改。

l 只有已提交的更改才是可见的，所以应用不用担心事务(transaction)或者更改被回滚(roll back)。

l Debezium为所有的数据库更改事件提供了一个统一的模型，所以应用不用担心每一种数据库管理系统的错综复杂性。

l Debezium持久化的、有副本备份的日志来记录数据库数据变化的历史，因此，应用可以随时停止再重启，而不会错过它停止运行时发生的事件，保证了所有的事件都能被正确地、完全地处理掉。

l 对MongoDB、MySQL、PostgreSQL、SQL Server、Oracle、DB2等数据库的支持

l 借助于Kafka Connector可以开发出一个基于事件流的变更捕获平台，具有高容错率和极强的扩展性

 

Debezium基础结构

Debezium是一个捕获数据更改(CDC)平台，并且利用Kafka和Kafka Connect实现了自己的持久性、可靠性和容错性。

每一个部署在Kafka Connect分布式的、可扩展的、容错性的服务中的connector监控一个上游数据库服务器，捕获所有的数据库更改，然后记录到一个或者多个Kafka topic(通常一个数据库表对应一个kafka topic)。

Kafka确保所有这些数据更改事件都能够多副本并且总体上有序(Kafka只能保证一个topic的单个分区内有序)，这样，更多的客户端可以独立消费同样的数据更改事件而对上游数据库系统造成的影响降到很小。

 

组件介绍

Kafka

 

Kafka构建数据管道时，通常有两种使用场景：

第一种：把Kafka作为数据管道的两个端点之一，例如，把Kafka里的数据移动到云上，或者把MongoDB里的数据移动到Kafka里；

第二种：把Kafka作为数据管道两个端点的中间媒介，例如，为了把DB的数据移动到ElasticSearch上，需要先把它们移动到Kafka里，再将它们从Kafka移动到Elastic Search上。

 

Kafka为数据管道带来的主要价值在于，它可以作为数据管道各个数据段之间的大型缓冲区，有效地解耦管道数据的生产者和消费者。数据管道的重要作用之一是解耦数据源和数据池，Kafka在这方面的能力以及在安全和效率方面的可靠性，使它成为构建数据管道的最佳选择。

 

备注：新版本kafka2.8已脱离zookeeper的依赖，还需验证。

Kafka Connect

连接器  debezium-connect-postgresql、debezium-connect-mysql

每个连接器都与特定的数据库管理系统（DBMS）一起工作。连接器在DBMS中记录数据更改的历史，方法是检测发生的更改，并将每个更改事件的记录流式传输到Kafka主题。

Zookeeper

1主要服务于分布式系统，可以用ZooKeeper来做：统一配置管理、统一命名服务、分布式锁、集群管理。

2 使用分布式系统就无法避免对节点管理的问题(需要实时感知节点的状态、对节点进行统一管理等等)，而由于这些问题处理起来可能相对麻烦和提高了系统的复杂性，ZooKeeper作为一个能够通用解决这些问题的中间件就应运而生了。

Debezium

作用

能监听数据库数据的变化并根据变化做出一些反应，比如更新对应变化数据的缓存、增量同步到其它数据源、对数据进行检测和审计等等。而这种技术就叫变更数据捕获（Change Data Capture）。

对于这种技术我们可能知道一个国内比较知名的框架Canal，非常好用！但是Canal有一个局限性就是只能用于Mysql的变更数据捕获。

 

Docker Desktop

 

作用：docker 一般部署在linux系统上，通过docker desktop 工具可以部署在windows系统上。

 

基础硬件要求：16个CPU 32G内存

 

Debezium实践中使用的docker desktop 截图：

 

 

 

 

 

docker容器

 

Docker 不依赖宿主系统，可以跨平台部署。

 

Docker就是应用程序依赖的最小基础环境。

 

Docker就是一个小的操作系统+应用

 

docker的思想就是利用操作系统资源，上面构建一些应用程序。因为操作系统的资源是共享的，所以只需要构建上层的应用即可。

 

docker的系统资源是在Linux基础上的，所以如果在windows上使用，需要安装wsl2后才能启动docker（上面提到的doker desktop工具就是在此基础上安装的）。

 

Windows 和 Macintosh 系统不能直接运行 Linux 容器，因为它们不是具有适当设施的 Linux 内核，甚至可以运行 Linux 程序，更不用说支持相同的额外 cgroup 设施了。所以当你在这些上安装 Docker 时，通常它会安装一个 Linux VM 来运行容器。几乎总是它只会安装一个 VM 并在该 VM 中运行所有容器；否则将浪费资源而没有任何好处。

 

 

 

docker镜像

 

很多大厂家都有自己的docker镜像源，国内比较多的是阿里镜像速度比较快，国外镜像下载速度非常慢，下载中断且出错几率高。

 

 

 

Debezium实践中下载的docker镜像源截图：

 

 

 

 

 

Mysql change数据捕获，kafka消费数据输出

 

搭建环境

 

Windows10+mysql8.0+mysqlclient+Zookeeper-1.9+Apache-kafka-1.9+ debezium-connect-mysql

 

wsl-2-backend（windows10系统上）

 

• Windows 11 64-bit: Home or Pro version 21H2 or higher, or Enterprise or Education version 21H2 or higher.
• Windows 10 64-bit: Home or Pro 21H1 (build 19043) or higher, or Enterprise or Education 20H2 (build 19042) or higher.
• Enable the WSL 2 feature on Windows. For detailed instructions, refer to the Microsoft documentation.

 

The following hardware prerequisites are required to successfully run WSL 2 on Windows 10 or Windows 11:

 

• 64-bit processor with Second Level Address Translation (SLAT)
• 4GB system RAM
• BIOS-level hardware virtualization support must be enabled in the BIOS settings. For more information, see Virtualization.
• Download and install the Linux kernel update package.

 

数据库配置

 

Windows下开启mysql binlog：

 

1 查看bonlog是否启用

 

SHOW MASTER STATUS;

 

SHOW VARIABLES LIKE 'log_bin';

 

 

 

2 查看配置文件 my.ini 所在目录

 

SELECT @@basedir;

 

SELECT @@datadir;

 

 

 

3下列内容复制到配置文件中，保存重启mysql服务

 

log_bin = mysql-BIN

 

# log_bin = C:\ProgramData\MySQL\MySQL Server 5.7\Data\log\bin_log

 

binlog_format = ROW

 

 

 

docker镜像搭建命令

 

Zookeeper

 

docker run -it  --name zookeeper -p 2181:2181 -p 2888:2888 -p 3888:3888 quay.io/debezium/zookeeper:1.9

 

 

 

Kafka

 

docker run -it  --name kafka -p 9092:9092 --link zookeeper:zookeeper quay.io/debezium/kafka:1.9

 

 

 

Mysql

 

docker run -it --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=debezium -e MYSQL_USER=mysqluser -e MYSQL_PASSWORD=mysqlpw quay.io/debezium/example-mysql:1.9

 

 

 

Mysql client

 

docker run -it --name mysqlterm --link mysql --rm mysql:8.0 sh -c 'exec mysql -h"$MYSQL_PORT_3306_TCP_ADDR" -P"$MYSQL_PORT_3306_TCP_PORT" -uroot -p"$MYSQL_ENV_MYSQL_ROOT_PASSWORD"'

 

 

 

Kafka connect

 

docker run -it --name connect -p 8083:8083 -e GROUP_ID=1 -e CONFIG_STORAGE_TOPIC=my_connect_configs -e OFFSET_STORAGE_TOPIC=my_connect_offsets -e STATUS_STORAGE_TOPIC=my_connect_statuses --link kafka:kafka --link mysql:mysql quay.io/debezium/connect:1.9

 

 

 

Mysql connector

 

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d '{ "name": "inventory-connector", "config": { "connector.class": "io.debezium.connector.mysql.MySqlConnector", "tasks.max": "1", "database.hostname": "mysql", "database.port": "3306", "database.user": "debezium", "database.password": "dbz", "database.server.id": "184054", "database.server.name": "dbserver1", "database.include.list": "inventory", "database.history.kafka.bootstrap.servers": "kafka:9092", "database.history.kafka.topic": "dbhistory.inventory" } }'

 

 

 

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d "{ \"name\": \"mysql-connect-1122\", \"config\": { \"connector.class\": \"io.debezium.connector.mysql.MySqlConnector\", \"tasks.max\": \"1\", \"database.hostname\": \"192.168.26.46\", \"database.port\": \"3306\", \"database.user\": \"root\", \"database.password\": \"root\", \"database.include.list\": \"test\" ,\"table.include.list\": \"test.tb_test\",\"database.server.id\": \"184054\", \"database.server.name\": \"mysqltest1122\",  \"database.history.kafka.bootstrap.servers\": \"localhost:9092\", \"database.history.kafka.topic\": \"dbhistory.tb_test_1122\"}}"

 

 

Oracle change数据捕获，kafka消费数据输出

搭建环境

Docker desktop+Oracle12C+oracle连接驱动+zookeeper1.6+kafka1.6

+debezium-connect-oracle（connect 容器中）

docker cp d:/ojdbc8.jar connect:/kafka/libs

 

数据库配置

1 开启日志归档 模式

--进入数据库关闭数据库

shutdown immediate;

--启动到mount状态

startup mount;

--修改归归档模式

alter database archivelog;

--启动到open状态，对外提供访问

alter database open;

--查看日志状态

archive log list;

 

2开启日志增补

sqlplus sys/Orcldoc_db1 as sysdba

--修改全局数据库 也可以直接开启ALL级别的全库增补

ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;

SELECT SUPPLEMENTAL_LOG_DATA_MIN FROM V$DATABASE;

--切换到pdb数据库下 也可以直接开启ALL级别的全库增补

alter session set container = ORCLPDB1;

ALTER PLUGGABLE DATABASE ADD SUPPLEMENTAL LOG DATA;

ALTER TABLE DBZ.CUSTOMERS ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS;

SELECT SUPPLEMENTAL_LOG_DATA_MIN FROM V$DATABASE;

Docker镜像搭建命令

Oracle

docker pull wangpengcheng/oracle12c-enterprise:12.2.0.1

docker run -d --name oracle12c-test wangpengcheng/oracle12c-enterprise:12.2.0.1

 

Zookeeper

docker run -d  --name zookeeper -p 2181:2181 -p 2888:2888 -p 3888:3888 -p 9011:9011 debezium/zookeeper:1.6

 

Kafka

docker run -d --name kafka -p 9092:9092 -p 9012:9012 --link zookeeper:zookeeper debezium/kafka:1.6

 

Connect

docker run -d --name connect -p 8083:8083 -p 9010:9010 -e GROUP_ID=1 -e CONFIG_STORAGE_TOPIC=my_connect_configs -e OFFSET_STORAGE_TOPIC=my_connect_offsets -e STATUS_STORAGE_TOPIC=my_connect_statuses  -e CONNECT_MAX_REQUEST_SIZE=20000000  -e CONNECT_BUFFER_MEMORY=800000000    -e CONNECT_FETCH_MAX_BYTES=20000000  -e CONNECT_MAX_PARTITION_FETCH_BYTES=20000000 -e OFFSET_FLUSH_INTERVAL_MS=10000  -e OFFSET_FLUSH_TIMEOUT_MS=6000000 -e CONNECT_CONNECTIONS_MAX_IDLE_MS=6000000 -e  CONNECT_RECEIVE.BUFFER.BYTES=500000000 -e CONNECT_PRODUCER_MAX_REQUEST_SIZE=20000000 --link zookeeper:zookeeper --link kafka:kafka debezium/connect:1.6

 

Oracle驱动

docker cp D:/ojdbc8.jar connect:/kafka/libs

 

Windows系统下注册kafka connect

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" http://localhost:8083/connectors/ -d "{    \"name\": \"test-connector\",   \"config\": {  \"connector.class\" : \"io.debezium.connector.oracle.OracleConnector\",        \"tasks.max\" : \"1\",        \"database.server.name\" : \"ORCLCDB\",        \"database.user\" : \"c##dbzuser\",        \"database.password\" : \"dbz\",        \"database.url\": \"jdbc:oracle:thin:@(DESCRIPTION= (ADDRESS= (PROTOCOL=TCP)(HOST=172.17.0.2)(PORT=1521)) (CONNECT_DATA= (SID=ORCLCDB) (SERVER=dedicated)))\",        \"database.dbname\" : \"ORCLCDB\",        \"database.pdb.name\" : \"ORCLPDB1\",                \"table.include.list\": \"DBZ.CUSTOMERS\",         \"database.history.kafka.bootstrap.servers\" : \"kafka:9092\",        \"database.history.kafka.topic\": \"schema-changes.test\"  ,\"log.mining.strategy\":\"online_catalog\"   }}"

 

 

 

查询connector情况

bin/kafka-topics.sh --list --zookeeper zookeeper:2181

 

实时查看消费数据

bin/kafka-console-consumer.sh --bootstrap-server 172.17.0.4:9092 --topic schema-changes.test  --from-beginning

bin/kafka-console-consumer.sh --bootstrap-server 172.17.0.4:9092 --topic ORCLCDB.DBZ.CUSTOMERS  --from-beginning --skip-message-on-error

 

结果：change数据输出

表结构输出

 

 

表数据输出

 

bin/kafka-console-consumer.sh --bootstrap-server 172.17.0.3:9092 --topic ORCLCDB.DBZ.CUSTOMER  --from-beginning

 

Sqlserver 数据捕获，kafka消费数据输出

数据库配置

--1需要为监控的数据库开启cdc功能以便debezium连接器能够获取日志文件

EXEC sys.sp_cdc_enable_db

 

--2找出当前filegroup_name的值，一般为PRIMARY

找出当前filegroup_name的值，一般为PRIMARY

 

--3为监控的表开启cdc

EXEC sys.sp_cdc_enable_table

@source_schema = N'dbo',

@source_name   = N'orders',     --  #填写要开启的表名

@role_name     = N'dbo',

@filegroup_name = N'PRIMARY',      --#文件组标识 (ID) 号的文件组名，可不写

@supports_net_changes = 1

 

--4查看验证

EXEC sys.sp_cdc_help_change_data_capture

 

Connect 注册命令：

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d "{  \"name\": \"sqlserver-connector\", \"config\": { \"connector.class\":\"io.debezium.connector.sqlserver.SqlServerConnector\",\"database.hostname\": \"192.168.10.108\", \"database.port\": \"1433\", \"database.user\": \"sa\", \"database.password\": \"a123456!\",\"database.dbname\": \"test\", \"database.server.name\": \"fullfillment\", \"table.whitelist\": \"dbo.customers\",  \"database.history.kafka.bootstrap.servers\": \"kafka:9092\", \"database.history.kafka.topic\": \"dbhistory.fullfillment\",}}"

备注：需根据实际情况配置参数

 

结果：change数据输出

 

 

 

 

Oracle数据写入到mysql

Source 同上oracle环境

Sink搭建环境

Mysql(8.0)+mysql连接驱动(mysql-connector-java-8.0.30.jar)+kafka connect 插件(confluentinc-kafka-connect-jdbc-10.5.4)

docker cp d:/confluentinc-kafka-connect-jdbc-10.5.4 connect:/kafka/connect

docker cp d:/mysql-connector-java-8.0.30.jar connect:/kafka/connect/confluentinc-kafka-connect-jdbc-10.5.2/lib

Docker镜像搭建命令

 

Mysql8.0

docker run -it --rm --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=debezium -e MYSQL_USER=mysqluser -e MYSQL_PASSWORD=mysqlpw quay.io/debezium/example-mysql:1.9

 

mysqlsink注册

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d " { \"name\": \"sinkmysqltest\",\"config\": {\"topics\": \"ORCLCDB.DBZ.CUSTOMERS\",\"connector.class\":\"io.confluent.connect.jdbc.JdbcSinkConnector\",\"tasks.max\":\"1\",\"connection.url\":\"jdbc:mysql://172.17.0.2:3306/test\",\"connection.user\":\"root\",\"connection.password\":\"mysql\",\"transforms\":\"unwrap\",\"transforms.unwrap.type\":\"io.debezium.transforms.ExtractNewRecordState\",\"transforms.unwrap.drop.tombstones\":\"false\",\"insert.mode\":\"insert\",\"auto.create\":\"true\",\"auto.evolve\":\"true\",\"table.name.format\":\"customers\"}}"

 

20221122 测试成功

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d " { \"name\": \"sinkmysqltest-1124\",\"config\": {\"topics\": \"mysqltest1122.test.tb_test\",\"connector.class\":\"io.confluent.connect.jdbc.JdbcSinkConnector\",\"tasks.max\":\"1\",\"connection.url\":\"jdbc:mysql://192.168.26.46:3306/test\",\"connection.user\":\"root\",\"connection.password\":\"root\",\"transforms\":\"unwrap\",\"transforms.unwrap.type\":\"io.debezium.transforms.ExtractNewRecordState\",\"transforms.unwrap.drop.tombstones\":\"false\",\"insert.mode\":\"insert\",\"auto.create\":\"true\",\"auto.evolve\":\"true\",\"table.name.format\":\"tb_test_sink\"}}"

结果：同步数据

Oracle数据

 

 

 

 

 

 

 

Mysql数据

 

 

Ubuntu 中部署

du -ah --max-depth=1

装ubuntu

docker run -itd --name sf-datasync-base  -p 2181:2181 -p 9092:9092 -p 8083:8083 ubuntu

 

进入容器

docker exec -it sf-datasync-base  /bin/bash

mkdir datasync

cd  datasync

mkdir zookeeper

mkdir kafka

cd kafka

mkdir logs

配置zookeeper

#wget https://dlcdn.apache.org/zookeeper/zookeeper-3.7.1/apache-zookeeper-3.7.1-bin.tar.gz

Docker cp d:/apache-zookeeper-3.7.1-bin.tar.gz sf-datasync-base:/datasync

tar -zxvf apache-zookeeper-3.7.1-bin.tar.gz  --解压到/datasync 目录

rm -rf apache-zookeeper-3.7.1-bin.tar.gz

--配置zoo.cfg datadir=/datasync/zookeeper

 

--启动zookeeper

/datasync/apache-zookeeper-3.7.1-bin/bin/zkServer.sh --config ../conf  start

 

安装jdk

--解决内存问题（java.io.ioexception:map failed） 64位

--安装jdk8（11）

docker cp d:\jdk-8u351-linux-x64.tar.gz sf-datasync-base:/datasync

tar -zxvf jdk-8u351-linux-x64.tar.gz

rm -rf jdk-8u351-linux-x64.tar.gz

 

--配置环境变量

/etc/profile

export JAVA_HOME=/datasync/jdk1.8.0_351

export JRE_HOME=${JAVA_HOME}/jre

export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib

export PATH=${JAVA_HOME}/bin:$PATH

--安装编译环境

apt-get install -y libc6-i386

source /etc/profile

 

安装jdk11

docker cp d:\jdk-11_linux-x64_bin.tar.gz sf-datasync-base:/datasync

tar -zxvf jdk-11_linux-x64_bin.tar.gz

rm -rf jdk-11_linux-x64_bin.tar.gz

 

--配置环境变量

/etc/profile

export JAVA_HOME=/datasync/jdk-11

export JRE_HOME=${JAVA_HOME}/jre

export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib

export PATH=${JAVA_HOME}/bin:$PATH

--安装编译环境

apt-get install -y libc6-i386

source /etc/profile

 

安装kafka

docker cp d:\kafka_2.12-2.8.1.tgz sf-datasync-base:/datasync

tar -zxvf  kafka_2.12-2.8.1.tgz

rm -rf  kafka_2.12-2.8.1.tgz

 

 

cd /datasync/kafka_2.12-2.8.1/config

--配置 server.properties

log.dirs=/datasync/kafka/logs

delete.topic.enable=true

listeners=PLAINTEXT://0.0.0.0:9092

advertised.listeners=PLAINTEXT://192.168.26.46:9092

(设置 advertised.listeners(外网要通过这个访问kafka，记得配置)

)

 

 

--启动

../bin/kafka-server-start.sh server.properties

 

--kafka connect 文本文件

plugin.path=libs/connect-file-2.8.1.jar

/root/kafka_2.12-2.8.1/libs/connect-file-2.8.1.jar

 

bin/connect-standalone.sh config/connect-standalone.properties config/connect-file-source.properties config/connect-file-sink.properties

connect-standalone.properties：bootstrap.servers=localhost:9092   plugin.path=libs/connect-file-2.8.1.jar

kafka connect  

关系数据库

--添加connct 到 plugin  

Docker cp d:/connect  sf-datasync-base:/datasync/kafka_2.12-2.8.1

 

修改 connect-distributed.properties

plugin.path=/datasync/kafka_2.12-2.8.1/connect

 

 

 

默认端口8083

Connect随着Kafka一起发布，所以无需单独安装。

如果你打算在生产环境使用 Connect 来移动大量的数据，或者打算运行多个连接器，那么 最好把 Connect 部署在独立于 broker 的服务器上。在所有的机器上安装 Kafka，并在部分服务器上启动 broker，然后在其他服务器上启动 Connect

 

kafka connect 启动

单机启动方式：bin/connect-standalone.sh -daemon config/connect-standalone.properties config/connect-console-sink.properties

 

分布式启动方式：bin/connect-distributed.sh -daemon config/connect-distributed.properties

 

curl -v http://localhost:8083

自动启动

1 创建自启动sh文件

 chmod 777 autostart.sh

 

autostart.sh

#!/bin/bash

set fileformat=unix

source /etc/profile

/datasync/kafka_2.12-2.8.1/bin/kafka-server-stop.sh  /datasync/kafka_2.12-2.8.1/config/server.properties

sleep 3

/datasync/apache-zookeeper-3.7.1-bin/bin/zkServer.sh --config /datasync/apache-zookeeper-3.7.1-bin/conf  stop

sleep 3

/datasync/apache-zookeeper-3.7.1-bin/bin/zkServer.sh --config /datasync/apache-zookeeper-3.7.1-bin/conf  start

sleep 20

/datasync/kafka_2.12-2.8.1/bin/kafka-server-start.sh -daemon /datasync/kafka_2.12-2.8.1/config/server.properties

sleep 3

/datasync/kafka_2.12-2.8.1/bin/connect-distributed.sh /datasync/kafka_2.12-2.8.1/config/connect-distributed.properties

 

 

2打包成镜像1 sf-datasync:1.0

Docker commit -m “ sf-datasync-base-0.0” sf-datasync-base sf-datasync-base:0.0

 

Dockerfile

FROM sf-datasync-base:0.0    

WORKDIR /datasync

ENTRYPOINT /datasync/autostart.sh && tail -f /dev/null

 

Cd D:\dockerfile

docker build -t sf-datasync:1.0 .

保存成tar包

Docker save -o D:\sf-datasync.tar sf-datasync:1.0

 

现场部署

1 安装 docker desktop 工具

基础硬件要求：内存32GB 、CPU 16GB 、磁盘固态

Window 重要配置：

 

 

安装详细参考地址：

https://www.runoob.com/docker/windows-docker-install.html

https://docs.docker.com/desktop/install/windows-install/

(32条消息) Windows Server 2019安装Docker搭建Ubuntu虚拟环境_moses1994的博客-CSDN博客_windows 17763 is deprecated

 

虚拟化启用验证：

 

2 Load tar文件成容器镜像:

Window cmd环境下运行：

--加载镜像tar包到docker

Docker load -i sf-datasync.tar

Tar文件内网共享地址：share (file://DC-LIUCL/share3)

3 镜像tar包创建容器

docker run -d -it --name  sf-datasync  -p 2181:2181 -p 9092:9092 -p 8083:8083 -p 1099:1099 sf-datasync:1.0  /bin/bash

docker run -d -it --name  sf-datasync  -p 2181:2181 -p 9092:9092 -p 8083:8083 sf-datasync:1.0  /bin/bash  

 

#!/bin/bash

需要修改的参数：

sf-datasync ：为容器名称，自定义

sf-datasync:1.0：镜像名称，一般默认即可

 

4 相关服务（自动启动）

创建容器后，检查服务均已自动启动

 

5 服务器监听IP配置

1cmd下进到容器  docker exec -it sf-datasync  /bin/bash

2修改文件 vim /datasync/kafka_2.12-2.8.1/config/server.properties

3 修改配置 advertised.listeners=PLAINTEXT://192.168.26.46:9092（修改为自己服务器IP）

 

6配置数据库

Sqlserver：

部署环境：windows server2019 + docker+debezium+kafka

 

1 sqlserver 代理服务需启动

 

2启用Sqlserver表的cdc功能（改绿色字体参数）

--数据库开启cdc功能

EXEC sys.sp_cdc_enable_db

 

--表开启cdc

EXEC sys.sp_cdc_enable_table

@source_schema = N'dbo',

@source_name   = N'tbname',     --  #填写要开启的表名

@role_name     = N'dbo',

@filegroup_name = N'PRIMARY',     

@supports_net_changes = 1

 

--查看已开启CDC表

EXEC sys.sp_cdc_help_change_data_capture

 

 

Mysql：

Windows下开启mysql binlog：

1 查看bonlog是否启用

SHOW MASTER STATUS;

SHOW VARIABLES LIKE 'log_bin';

 

2 查看配置文件 my.ini 所在目录

SELECT @@basedir;

SELECT @@datadir;

 

3下列内容复制到配置文件中，保存重启mysql服务

log_bin = mysql-BIN

# log_bin = C:\ProgramData\MySQL\MySQL Server 5.7\Data\log\bin_log

binlog_format = ROW

 

USE mysql;

UPDATE USER SET HOST = '%' WHERE USER ='root';

FLUSH PRIVILEGES;

SET GLOBAL time_zone='+8:00'

 

 

Oracle：

1 开启日志归档 模式

--进入数据库关闭数据库

shutdown immediate;

--启动到mount状态

startup mount;

--修改归归档模式

alter database archivelog;

--启动到open状态，对外提供访问

alter database open;

--查看日志状态

archive log list;

 

2开启日志增补

sqlplus sys/Orcldoc_db1 as sysdba

--修改全局数据库 也可以直接开启ALL级别的全库增补

ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;

SELECT SUPPLEMENTAL_LOG_DATA_MIN FROM V$DATABASE;

--切换到pdb数据库下 也可以直接开启ALL级别的全库增补

alter session set container = ORCLPDB1;

ALTER PLUGGABLE DATABASE ADD SUPPLEMENTAL LOG DATA;

ALTER TABLE DBZ.CUSTOMERS ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS;

SELECT SUPPLEMENTAL_LOG_DATA_MIN FROM V$DATABASE;

 

7 数据库连接配置

Sqlserver：

Source:

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d "{  \"name\": \"source-sqlserver-test-1122\", \"config\": { \"connector.class\":\"io.debezium.connector.sqlserver.SqlServerConnector\",\"database.hostname\": \"192.168.26.194\", \"database.port\": \"1433\", \"database.user\": \"sa\", \"database.password\": \"Sf@194.sql\",\"database.dbname\": \"SFFC_SY_2022\", \"database.server.name\": \"test1122\", \"table.whitelist\": \"dbo.test2\",  \"database.history.kafka.bootstrap.servers\": \"localhost:9092\", \"database.history.kafka.topic\": \"dbhistory.test21122\", \"decimal.handling.mode\": \"string\", \"time.precision.mode\": \"connect\"}}"

 

Source：（源库配置）

name=SqlServerConnector  --连接名字自定义

database.server.name=sy --保存dll数据，自定义

database.history.kafka.topic=dbhistory.sy  --保存dll数据，自定义

 

connector.class=io.debezium.connector.sqlserver.SqlServerConnector

tasks.max=1

database.hostname=192.169.59.2

database.port=9833

database.user=sfsys

database.password=Abc!@#sy456

database.history.kafka.bootstrap.servers=localhost:9092

database.dbname=SY_SFFC_TEST   --数据库名

table.whitelist=dbo.sytest      --表名

 

 

decimal.handling.mode=string  --处理decimal类型

 

--转换timestamp为datetime

converters=timestampConverter

timestampConverter.type=oryanmoshe.kafka.connect.util.TimestampConverter

timestampConverter.format.time=HH:mm:ss.SSS

timestampConverter.format.date=YYYY-MM-dd

timestampConverter.format.datetime=YYYY-MM-dd HH:mm:ss.SSS

timestampConverter.debug=false

 

 

--转换timestamp为datetime，需指定列

transforms=tsFormat1

transforms.tsFormat1.type=com.github.howareyouo.kafka.connect.transforms.TimestampConverter$Value

transforms.tsFormat1.target.type=string

transforms.tsFormat1.format=yyyy-MM-dd HH:mm:ss

transforms.tsFormat1.fields=dd,tt

 

--转换jason格式为简易格式

transforms=unwrap

transforms.unwrap.type=io.debezium.transforms.ExtractNewRecordState

transforms.unwrap.drop.tombstones=false

 

Sink:

--SQL server sink test1122.dbo.test2

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d " { \"name\": \"sink-mysql-sqlserver-1208\",\"config\":{\"topics\":\"mysql_1208.test.tb_test2\",\"connector.class\":\"io.confluent.connect.jdbc.JdbcSinkConnector\",\"tasks.max\":\"1\",\"connection.url\":\"jdbc:jtds:sqlserver://192.168.26.194:1433/SFFC_SY_sink\",\"connection.user\":\"sa\",\"connection.password\":\"Sf@194.sql\",\"transforms\":\"unwrap,tsFormat1\", \"transforms.unwrap.type\": \"io.debezium.transforms.ExtractNewRecordState\",\"transforms.tsFormat1.type\":\"org.apache.kafka.connect.transforms.TimestampConverter$Value\",\"transforms.tsFormat1.target.type\": \"string\",\"transforms.tsFormat1.field\":\"tt\",\"transforms.tsFormat1.format\": \"yyyy-MM-dd HH:mm:ss\",\"transforms.unwrap.drop.tombstones\":\"false\",\"insert.mode\":\"upsert\",\"pk.mode\":\"record_key\",\"pk.fields\" : \"id\",\"auto.create\":\"true\",\"auto.evolve\":\"true\",\"delete.enabled\":\"true\",\"table.name.format\":\"tb_test_1208\"}}"

--备注

写入修改数据方式：

\"insert.mode\":\"upsert\",\"pk.fields\" : \"id\"（id为主键）

删除数据同步：

\"delete.enabled\":\"true\"，\"pk.mode\":\"record_key\"

自动创建目标表：

\"auto.create\":\"true\"

Datetime类型同步：

\"transforms\":\"unwrap,tsFormat1\"

 

 

https://blog.csdn.net/winsanity/article/details/125599194?spm=1001.2101.3001.6650.3&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7ERate-3-125599194-blog-111929918.pc_relevant_aa2&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7ERate-3-125599194-blog-111929918.pc_relevant_aa2&utm_relevant_index=4

 

 

Sink：（目标库配置，按照目前的沟通的情况需要用kettle代替）

name=sink-sqlserver

topics=sy.dbo.sytest   --source中database.dbname+table.whitelist

connector.class=io.confluent.connect.jdbc.JdbcSinkConnector

tasks.max=1

connection.url=jdbc:jtds:sqlserver://192.169.59.3:12233/APS   --APS为数据库名
connection.user=sfsys

connection.password=Abc!@#sy456

insert.mode=upsert

pk.mode=record_key

pk.fields=id       --表的主键列

auto.create=true

auto.evolve=true

delete.enabled=true

table.name.format=sytest   --同步到目标库的表名称

transforms=unwrap,tsFormat1

transforms.unwrap.type=io.debezium.transforms.ExtractNewRecordState

transforms.unwrap.drop.tombstones=false

transforms.tsFormat1.type:org.apache.kafka.connect.transforms.TimestampConverter$Value

transforms.tsFormat1.target.type=string

transforms.tsFormat1.field=tt

transforms.tsFormat1.format=yyyy-MM-dd HH:mm:ss

https://debezium.io/documentation/reference/stable/transformations/event-flattening.html

 

Mysq：

Source:

容器：

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d '{ "name": "inventory-connector", "config": { "connector.class": "io.debezium.connector.mysql.MySqlConnector", "tasks.max": "1", "database.hostname": "mysql", "database.port": "3306", "database.user": "debezium", "database.password": "dbz", "database.server.id": "184054", "database.server.name": "dbserver1", "database.include.list": "inventory", "database.history.kafka.bootstrap.servers": "kafka:9092", "database.history.kafka.topic": "dbhistory.inventory" } }'

 

Linux：

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d "{ \"name\": \"mysql-connect-1122\", \"config\": { \"connector.class\": \"io.debezium.connector.mysql.MySqlConnector\", \"tasks.max\": \"1\", \"database.hostname\": \"192.168.26.46\", \"database.port\": \"3306\", \"database.user\": \"root\", \"database.password\": \"root\", \"database.include.list\": \"test\" ,\"table.include.list\": \"test.tb_test\",\"database.server.id\": \"184054\", \"database.server.name\": \"mysqltest1122\",  \"database.history.kafka.bootstrap.servers\": \"localhost:9092\", \"database.history.kafka.topic\": \"dbhistory.tb_test_1122\"}}"

 

UI:

 

 

\"database.server.name\": \"mysqltest1122\",

\"database.include.list\": \"test\"

\"table.include.list\": \"test.tb_test\"

 

 {\"topics\": \"mysqltest1122.test.tb_test\"

Sink:

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d " { \"name\": \"sinkmysqltest-1124\",\"config\": {\"topics\": \"mysqltest1122.test.tb_test\",\"connector.class\":\"io.confluent.connect.jdbc.JdbcSinkConnector\",\"tasks.max\":\"1\",\"connection.url\":\"jdbc:mysql://192.168.26.46:3306/test\",\"connection.user\":\"root\",\"connection.password\":\"root\",\"transforms\":\"unwrap\",\"transforms.unwrap.type\":\"io.debezium.transforms.ExtractNewRecordState\",\"transforms.unwrap.drop.tombstones\":\"false\",\"insert.mode\":\"insert\",\"auto.create\":\"true\",\"auto.evolve\":\"true\",\"table.name.format\":\"tb_test_sink\"}}"

 

 

Oracle：

Source:

curl -i -X POST -H "Accept:application/json" -H "Content-Type:application/json" localhost:8083/connectors/ -d " { \"name\": \"sinkmysqltest\",\"config\": {\"topics\": \"ORCLCDB.DBZ.CUSTOMERS\",\"connector.class\":\"io.confluent.connect.jdbc.JdbcSinkConnector\",\"tasks.max\":\"1\",\"connection.url\":\"jdbc:mysql://172.17.0.2:3306/test\",\"connection.user\":\"root\",\"connection.password\":\"mysql\",\"transforms\":\"unwrap\",\"transforms.unwrap.type\":\"io.debezium.transforms.ExtractNewRecordState\",\"transforms.unwrap.drop.tombstones\":\"false\",\"insert.mode\":\"insert\",\"auto.create\":\"true\",\"auto.evolve\":\"true\",\"table.name.format\":\"customers\"}}"

 

重要节点验证语句

--查看connect 列表

curl -H "Accept:application/json" localhost:8083/connectors/         

 

--查看某个connect 状态

curl -i -X GET -H "Accept:application/json" localhost:8083/connectors/SqlServerConnectortest031507/status

 

Curl  GET /connectors/SqlServerConnectortest031507/config：获取指定 connector 的配置信息

Curl  GET http://localhost:8083/connectors/SqlServerConnectortest031507

 

 

--删除某个connect

curl -X DELETE http://localhost:8083/connectors/mysql-connector

curl -X DELETE http://localhost:8083/connectors/sqlserver-connector

 

--查看topic

/datasync/kafka_2.12-2.8.1/bin/kafka-topics.sh --list --zookeeper localhost:2181

 

--查看详细情况

/datasync/kafka_2.12-2.8.1/bin/kafka-topics.sh --describe  --zookeeper localhost:2181

--topic t_copd_ordprontfitem.dbo.t_COPD_OrdProNtfItem

 

--生产topic

bin/kafka-console-producer.sh --bootstrap-server 172.17.0.3:9092 --topic ORCLCDB.DBZ.CUSTOMER

 

--消费topic

/datasync/kafka_2.12-2.8.1/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic tb_0311.dbo.tb_0311 --from-beginning --skip-message-on-error

 

--删除topic

/datasync/kafka_2.12-2.8.1/bin/kafka-topics.sh --delete --zookeeper localhost:2181 --topic test0228.dbo.test

topic信息查看

bin/kafka-topics.sh --list --zookeeper zookeeper:2181 

 

UI界面查看

curl -H "Accept:application/json" localhost:8083/connectors/ 

debezium ui

docker run -d  --name debezium-ui -p 8085:8080 -e KAFKA_CONNECT_URIS=http://172.17.0.2:8083 debezium/debezium-ui --restart=always

 

http://localhost:8085/

kafka connect ui 

docker run  --name kafka-connect-ui -it -p 8001:8000  -e "CONNECT_URL=http://172.17.0.2:8083" landoop/kafka-connect-ui

 

http://localhost:8000/

Kafka ui

https://github.com/xxd763795151/kafka-console-ui

访问：http://127.0.0.1:7766

Kafka 监控

Kafka assistant

Broker dashboard 指标数据为空问题?

Kafka Broker 需要配置以允许 JMX 连接

Java 平台的管理和监控技术，它提供了一种标准的方式来监控和管理 Java 应用程序的性能、状态和资源。在 Kafka 中，JMX 用于监控和管理 Kafka Broker 的运行时状态和指标

 

Linux：

 

# for JMX monitoring

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote=true"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.port=1099"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.rmi.port=1099"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.ssl=false"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.authenticate=false"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Djava.rmi.server.hostname=172.17.0.2"

 

Microsoft Windows：

 

set KAFKA_JMX_OPTS=%KAFKA_JMX_OPTS% -Dcom.sun.management.jmxremote=true

set KAFKA_JMX_OPTS=%KAFKA_JMX_OPTS% -Dcom.sun.management.jmxremote.port=1099

set KAFKA_JMX_OPTS=%KAFKA_JMX_OPTS% -Dcom.sun.management.jmxremote.rmi.port=1099

set KAFKA_JMX_OPTS=%KAFKA_JMX_OPTS% -Dcom.sun.management.jmxremote.ssl=false

set KAFKA_JMX_OPTS=%KAFKA_JMX_OPTS% -Dcom.sun.management.jmxremote.authenticate=false

set KAFKA_JMX_OPTS=%KAFKA_JMX_OPTS% -Djava.rmi.server.hostname=192.168.1.106

 

 

常见问题

1 docker Host is not allowed to connect to this mysql server

 

use mysql; update user set host = '%' where user ='root';

flush privileges;

 

2 SET GLOBAL time_zone='+8:00';

3 数据库ip连接地址不对

Caused by: com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure\n\n

The last packet sent successfully to the server was 0 milliseconds ago.

The driver has not received any packets from the server.\n\t

at com.mysql.cj.jdbc.exceptions.SQLError.createCommunicationsException(SQLError.java:174)\n\t

4 注册连接配置

Caused by: com.microsoft.sqlserver.jdbc.SQLServerException: The TCP/IP connection to the host 192.168.26.194/SFFC_SY_sink, port 1433 has failed. Error: \"192.168.26.194/SFFC_SY_sink. Verify the connection properties. Make sure that an instance of SQL Server is running on the host and accepting TCP/IP connections at the port. Make sure that TCP connections to the port are not blocked by a firewall.

处理：连接配置 192.168.26.194/SFFC_SY_sink 分开配置

 

5 注册配置添加相关参数transforms

 org.apache.kafka.connect.errors.ConnectException: mysqltest1122.test.tb_test.Value (STRUCT) type

doesn't have a mapping to the SQL database column type

at io.confluent.connect.jdbc.dialect.GenericDatabaseDialect

处理：transforms.unwrap.type

 

6 内存CPU配置

Cmd    %UserProfile%

 

7 docker image 存储目录

%USERPROFILE%\AppData\Local\Docker\wsl\data\ext4.vhdx

 

Container 目录：

\\wsl$\docker-desktop-data\data\docker\containers

c97ccbc4f0ab8db0ffb1380b0467dc0f8455b8a29a6b0bf4ef719a5c06acf18b

\\wsl.localhost 是一个特殊的域名，用于访问 Windows Subsystem for Linux (WSL) 中运行的应用程序。WSL 允许在 Windows 操作系统上运行 Linux 环境，而 \\wsl.localhost 则用于访问这些运行在 WSL 中的应用程序。

\\wsl$\docker-desktop-data\data\docker\containers\0d39c7f2c8dc3413d15dd3978c6e453d84d221e4ee0aaf76680e870fec9be0d0

 

26.46 上截图

 

 双叶同步服务器虚拟文件大小--20230815 14：34

 

 

 

8 commit image镜像越来越大

docker容器commit的镜像越来越大怎么办？酱紫试试 - 永不退缩 (imadiaos.com)

 

9默认值

t_COPD_DlvItem   fId

 

 

Caused by: java.sql.SQLException: Exception chain:\njava.sql.SQLException: 数据类型 varchar 和 varchar 在 subtract 运算符中不兼容。

 

解决方法：提前创建表结构，只同步数据不报错

 

10 网络

https://blog.csdn.net/qq_45380083/article/details/124612501

 

 

Docker0 网桥

路由

Nat

代理

 

结论：window 宿主机 + docker windows container 宿主机可以ping通容器ip

Windows 宿主机+ docker linux container 宿主机不可以ping通容器IP

Linux宿主机+docker linux container 宿主机可以ping通容器IP

 

 

 

12 数据库重启后，kafka connect 报错

 

 

 

参见参数

Kafka Connect 的 REST API 接口

 Connect topic

由于 Kafka Connect 的意图是以服务的方式去运行，所以它提供了 REST API 去管理 connectors，默认的端口是 8083（我们也可以在启动 Kafka Connect 之前在配置文件中添加 rest.port 配置）：

 

GET /connectors：返回所有正在运行的 connector 名

POST /connectors：新建一个 connector；请求体必须是 json 格式并且需要包含 name 字段和 config 字段，name 是 connector 的名字，config 是 json 格式，必须包含你的 connector 的配置信息。

GET /connectors/{name}：获取指定 connetor 的信息

GET /connectors/{name}/config：获取指定 connector 的配置信息

PUT /connectors/{name}/config：更新指定 connector 的配置信息

GET /connectors/{name}/status：获取指定 connector 的状态，包括它是否在运行、停止、或者失败，如果发生错误，还会列出错误的具体信息。

GET /connectors/{name}/tasks：获取指定 connector 正在运行的 task。

GET /connectors/{name}/tasks/{taskid}/status：获取指定 connector 的 task 的状态信息

PUT /connectors/{name}/pause：暂停 connector 和它的 task，停止数据处理知道它被恢复。

PUT /connectors/{name}/resume：恢复一个被暂停的 connector

POST /connectors/{name}/restart：重启一个 connector，尤其是在一个 connector 运行

curl -X POST localhost:8083/connectors/SqlServerConnector0306001/restart

失败的情况下比较常用

POST /connectors/{name}/tasks/{taskId}/restart：重启一个 task，一般是因为它运行失败才这样做。

DELETE /connectors/{name}：删除一个 connector，停止它的所有 task 并删除配置。

 

 

Kafka connect 参数解析

 

#消费的topic，对应source.properties中的

database.server.name+table.whitelist

topics=cdctest.dbo.TestUser

 

database.server.name:数据库服务器的唯一名称或标识符,

标识连接到的数据库

database.history.kafka.topic  --connect 可用 保存ddl数据

关于数据库模式、表结构更改和其他历史事件的信息。通过将这些历史事件写入

 

connector.class=io.confluent.connect.jdbc.JdbcSinkConnector

tasks.max=1

#JDBC连接URL

connection.url=jdbc:jtds:sqlserver://192.168.xx.xxx:1433/CDCTestDB

 

#debezium获取的json信息转换为kafka-connect-jdbc能够消费的信息

transforms=unwrap

transforms.unwrap.type=io.debezium.transforms.ExtractNewRecordState

transforms.unwrap.drop.tombstones=false

#使用的插入模式

insert.mode=upsert

#将null记录值视为删除，要求pk.mode是record_key

delete.enabled=true

#如果目标表不存在，自动创建目标表

auto.create=true

#同步表结构更新

auto.evolve=true

#主键模式

pk.mode=record_key

#主键

pk.fields=userId

#目标表

table.name.format=TestUserSink

 

#消费offset

auto.offset.reset: earliest（从头开始） / latest /none

 

https://blog.csdn.net/huryer/article/details/104689336

 

 

kafka-topics.sh脚本有5种指令类型: create、list、describe、alter和 delete

 

 Kafka 主题

mysql12.test.customers ：server.name+数据库名+表名主题表 保存dml数据

 

 

delete.topic.enable=true ； auto.create.topics.enable=false ；

topic 有一定的 生成规则 前缀.db名.表名

 

jar包：通常是开发时要引用通用类，打成包便于存放管理。

 项目的开发和运行都需要,在项目打包时也需要将jar包依赖打包进项目中

 

Kafka参数

producer.linger.ms=5000  生产数据5S发送一次到kafka，默认为0无延迟

producer.batch.size=300000  生产数据发送到kafa的批次大小，默认16KB

 

buffer.memory 生产数据发送到kafka前先写入内存缓冲大小，然后把很多消息收集成一个一个的Batch，通过send线程发送，默认32M

缺点：buffer.memory设置的太小，可能导致的问题是：消息快速的写入内存缓冲里，但Sender线程来不及把Request发送到Kafka服务器，会造成内存缓冲很快就被写满。而一旦被写满，就会阻塞用户线程，不让继续往Kafka写消息了

 

 

group.id=connect-cluster：用于形成连接集群组

 

key.converter=org.apache.kafka.connect.json.JsonConverter

value.converter=org.apache.kafka.connect.json.JsonConverter

用来转换写入或者读出kafka中消息的key的，

例如：org.apache.kafka.connect.json.JsonConverter。
效果是对指定了key是id=1000，转换成{“id” : 1000}，也可以使用Avro的格式

 

key.converter.schemas.enable=true

value.converter.schemas.enable=true

发送普通的json格式而不是avro格式的话，很简单key.converter.schemas.enable和value.converter.schemas.enable设置为false就行。这样就能发送普通的json格式数据

 

 

offset.flush.interval.ms
1分钟
源偏移量刷新到其存储
2尝试提交偏移量的时间间隔。默认值为 1 分钟。
3 debezium 保证接受一次

 

 

Rebalance.timeout.ms

均匀地分配某个 topic 下的所有 partition 到各个消费者，从而使得消息的消费速度达到最快，这就是平衡（balance）。而 rebalance（重平衡）其实就是重新进行 partition 的分配，从而使得 partition 的分配重新达到平衡状态。

 

session.timeout.ms 表示 consumer 向 broker 发送心跳的超时时间。例如 session.timeout.ms = 180000 表示在最长 180 秒内 broker 没收到 consumer 的心跳，那么 broker 就认为该 consumer 死亡了，会启动 rebalance。

heartbeat.interval.ms 表示 consumer 每次向 broker 发送心跳的时间间隔。heartbeat.interval.ms = 60000 表示 consumer 每 60 秒向 broker 发送一次心跳。一般来说，session.timeout.ms 的值是 heartbeat.interval.ms 值的 3 倍以上。

max.poll.interval.ms 表示 consumer 每两次 poll 消息的时间间隔。简单地说，其实就是 consumer 每次消费消息的时长。如果消息处理的逻辑很重，那么市场就要相应延长。否则如果时间到了 consumer 还么消费完，broker 会默认认为 consumer 死了，发起 rebalance。

max.poll.records 表示每次消费的时候，获取多少条消息。获取的消息条数越多，需要处理的时间越长。所以每次拉取的消息数不能太多，需要保证在 max.poll.interval.ms 设置的时间内能消费完，否则会发生 rebalance。

简单来说，会导致崩溃的几个点是：

• 消费者心跳超时，导致 rebalance。
• 消费者处理时间过长，导致 rebalance。

阿里云官方文档建议超时时间（session.timeout.ms）设置成 25s，最长不超过 30s。那么心跳间隔时间（heartbeat.interval.ms）就不超过 10s。

 

https://cloud.tencent.com/developer/article/1631633

 

 

 

 

 

 

 

Linux 版本

linux 内核版

linux 发行版：redhat

                     debian

                     ubuntu  常用

                     fedora 桌面版

                     centos 常用

                     openSUSE

 

 

apache-zookeeper-3.7.1-bin

 kafka_2.12-2.8.1

debezium-connector-sqlserver-1.6.3.Final

confluentinc-kafka-connect-jdbc-10.5.4

 

清理数据

 

Connect

curl -X DELETE http://localhost:8083/connectors/1118

 

Topic

delete.topic.enable=true

 

auto.create.topics.enable = false

server.properties文件log.dirs配置，默认为"/data/kafka-logs"

log.dirs=/root/kafka_2.12-2.8.1/kafka-logs

 

 

同步日志查看 （目前是以文件的形式查看）

 transform

static.field	添加写死的记录名
static.field	添加写死的记录值
blacklist	要丢弃的字段名
whitelist	要改名的字段列表
renames	改名对应映射：old_fied1:new_filed1,old_fied2:new_filed2

 

 

https://blog.csdn.net/sinat_32176947/article/details/83998272?spm=1001.2101.3001.6650.10&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-10-83998272-blog-126505372.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-10-83998272-blog-126505372.pc_relevant_default&utm_relevant_index=11

 

https://docs.confluent.io/platform/current/connect/transforms/overview.html#single-message-transforms-for-cp

 

tar文件大小

du -ah --max-depth=1

4.0K    ./home

4.0K    ./srv

628K    ./etc

4.0K    ./opt

12K     ./root

0       ./lib

4.0K    ./mnt

73M     ./usr

4.0K    ./media

0       ./lib64

0       ./sys

0       ./dev

0       ./sbin

4.0K    ./boot

0       ./bin

20K     ./run

0       ./lib32

0       ./libx32

du: cannot access './proc/39/task/39/fd/3': No such file or directory

du: cannot access './proc/39/task/39/fdinfo/3': No such file or directory

du: cannot access './proc/39/fd/4': No such file or directory

du: cannot access './proc/39/fdinfo/4': No such file or directory

0       ./proc

4.0K    ./tmp

4.5M    ./var

0       ./.dockerenv

78M     .

 

验证结果

Kafka connect 删除后可以重建一个，正常工作

Kafka connect 创建完之后不能删除，不可获缺

 

 

Kettle 消费第一次数据后第二次消费不到了

命令行中查看topic消息 可以反复查看

 

Group 同一个topic 会广播给每一个消费组

分区 broker节点  分布式 并行存储

 

删除topic 正常不用重启kafka

 

更新connect ，添加两张表，不需要重启connect

 

Request.required.acks

 

 

Windows 安装 Docker Desktop 到其他盘、迁移虚拟硬盘映像文件、压缩虚拟硬盘映像占用空间 - 掘金 (juejin.cn)

 C:\Users\司大帅\AppData\Local\Docker\wsl 文件夹，里面应该是 windows 的 linux 子系统的虚拟磁盘文件

 

 

 

Kafka 性能问题

producer.linger.ms=10000

producer.batch.size=300000  可以允许更多的数据缓冲在里面  300KB

 

Kafka 创建topic 超时异常： Timed out waiting for a node assignment

解决办法：

1、确保zookeeper和kafka服务启动

 

2、修改connect-standalone.properties 文件，将bootstrap.servers=localhost:9092改为ip：9092

 

 

ERROR Failed to flush WorkerSourceTask

{id=local-file-source-0}, timed out while waiting for producer to flush outstanding 1 messages (org.apache.kafka.connect.runtime.WorkerSourceTask:304)

 

原因：生产者在30S（offset.flush.timeout.ms）内发送累积的记录到kafka 超时

有很多消息发送到kafka，但发送没有在kafka connect允许的时间内完成，目的是让您知道哪些消息需要仍然需要刷新并保持缓冲状态。

 

 

方法：

offset.flush.timeout.ms    Connect 时间来处理累积的记录 30000 30S

Offset.flush.interval.ms=10000

producer.buffer.memory 消息发送给kafka前的缓存

 

 

 

Failed to commit offsets (org.apache.kafka.connect.runtime.SourceTaskOffsetCommitter:113)

 

 

https://www.editcode.net/article-439378-1.html

 

kafka消息积压解决

https://blog.csdn.net/AlbenXie/article/details/128299752

 

异常

现象 ：120230308 17：20 195数据库挂掉

可疑原因：26.33 通过connect ui修改connect 时 ，195服务器突然挂掉

 

 

 

 

 

 

问题：

kafka中只能保证partition中记录是有序的，而不保证topic中不同partition的顺序

多个partiotion之间消息无序，update时数据会产生错误

 

Kafka比传统消息系统有更强的顺序性保证，它使用主题的分区作为消息处理的并行单元。Kafka以分区作为最小的粒度，将每个分区分配给消费者组中不同的而且是唯一的消费者，并确保一个分区只属于一个消费者，即这个消费者就是这个分区的唯一读取线程。那么，只要分区的消息是有序的，消费者处理的消息顺序就有保证。每个主题有多个分区，不同的消费者处理不同的分区，所以Kafka不仅保证了消息的有序性，也做到了消费者的负载均衡。

https://blog.csdn.net/feiying0canglang/article/details/114332733

https://zhuanlan.zhihu.com/p/38269875 --原理架构流程例子

 

Poll

实际上调用 poll 方法去拉取数据是你的应用自己的事，然后 Kafka 并不是很信任你，它可能怀疑你在尸位素餐。所以作为预防，consumer 会记录你多久调用一次 poll 方法，一旦这个间隔超过了指定值 max.poll.interval.ms，那么当前 consumer 就会从消费者组中离开，这样其他 consumer 就可以接盘当前 consumer 的工作了

 

 max.poll.interval.ms=5分钟

 

kafka 自动提交 和 手动提交

https://blog.csdn.net/fenglepeng/article/details/109748696?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-109748696-blog-89472416.pc_relevant_3mothn_strategy_and_data_recovery&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-109748696-blog-89472416.pc_relevant_3mothn_strategy_and_data_recovery&utm_relevant_index=1

 

Docker desktop 与wsl2 的关系

 

Docker Desktop 和 WSL 2 之间存在一定的关系，特别是在 Windows 环境中运行容器化应用程序时。以下是它们之间的关系：

 

1. **容器化环境：**

   - Docker Desktop 是 Docker 公司提供的一个工具，用于在本地计算机上创建、运行和管理容器化应用程序。它提供了一个图形界面和命令行工具，使开发人员能够轻松地构建和部署容器。

   

2. **WSL 2 集成：**

   - 在 Windows 10 版本 2004 及更高版本中，Docker Desktop 可以与 WSL 2 集成，从而提供更快的容器性能和更好的开发体验。

   - Docker Desktop 使用 WSL 2 作为默认的运行时，这意味着它可以在 WSL 2 中运行容器，从而利用 WSL 2 的性能优势。

 

3. **Docker Desktop 和 WSL 2 的关系：**

   - Docker Desktop 与 WSL 2 集成后，Docker 使用 WSL 2 的虚拟机来运行容器。这允许容器在更接近原生 Linux 的环境中运行，提供更好的性能和兼容性。

   - WSL 2 为 Docker 提供了一个性能更强大的运行时环境，它直接在 Windows 内核上运行，并在其中运行一个 Linux 内核，进而在其中运行 Docker 容器。

 

总之，Docker Desktop 和 WSL 2 一起提供了一个强大的容器化开发和运行环境，使开发人员能够在 Windows 上以更高效的方式构建和部署容器化应用程序。通过集成 Docker 和 WSL 2，您可以在本地计算机上体验到更快、更稳定的容器化工作流程。

 

消息丢失

1Producer:

l linger.ms设置为5S，producer被非法停止，buffer中的数据将会丢失，broker将无法收到该部分数据

结果：数据丢失

方法：linger.ms设置为0，默认值

l producer内存不够，如果采用的策略是丢弃消息，消息也会丢失

 

方法：增加生产者所在机器的内存，以便更好地容纳消息。

这是解决内存不足问题的根本方法。

buffer.memory：buffer容量配置，配置项用于设置生产者缓冲区的总内存大小。默认值是 33554432 字节（32MB）。

batch.size：批次发送给broker 的大小

linger.ms： 固定时间发送给broker 默认值0，立即发送

 

l 消息生产过快，导致挂起线程过多，内存不足，导致程序崩溃，消息丢失

方法：无

 

l service不直接将消息发送到buffer，而是保存到本地磁盘中，另外起一个线程进行发送。

方法：需修改源码

 

 

生产者（Producer）默认使用内存缓冲区（buffer）来暂存待发送的消息，以提高发送性能。但是，如果您希望将消息直接从磁盘发送给 Broker，而不经过内存缓冲区，目前 Kafka 并没有内置的配置选项来支持这种行为。Kafka 的设计思想是利用内存缓冲区来提高性能，并将消息写入磁盘以实现持久化。

 

2 broker服务端

l broker发生故障，那么此时page cache的数据就会丢失，broker端可以设置刷盘的参数，比如多久刷盘一次

异步发送改为同步发送

acks=-1是保证消息从生产者到broker不丢失的最佳设置方式（需多副本）

3消费者

l 当我们收到消息后对消息进行处理，如果在处理的过程中发生异常，而又设置为自动提交offset，那么消息没有处理成功，offset已经提交了，当下次获取消息的时候，由于已经提交过ofset，所以之前的消息就获取不到了

方法：所以应该改为手动提交offset，当消息处理成功后，再进行手动提交offset

enable.auto.commit=false

 

4 如何正常重启kafka，避免丢失数据

1一定要先启动ZooKeeper 再启动Kafka 顺序不可以改变。
2先关闭kafka ，再关闭zookeeper。

 

 

https://blog.csdn.net/u014753478/article/details/117932192

 

 

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote=true"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.port=1099"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.rmi.port=1099"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.ssl=false"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Dcom.sun.management.jmxremote.authenticate=false"

KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS -Djava.rmi.server.hostname=192.168.1.106"

 

$KAFKA_HOME/bin/kafka-server-start.sh $KAFKA_CONFIG/server.properties $KAFKA_OPTS $KAFKA_JMX_OPTS