De MySQL a DolphinDB, práctica de sincronización de datos Debezium + Kafka

12.23 Estación Yuan Chuanghui·Shanghai, hablemos de infraestructura LLM

Debezium es una plataforma distribuida de código abierto para capturar y publicar eventos de cambios en bases de datos en tiempo real. Puede convertir eventos de cambio de bases de datos relacionales (como MySQL, PostgreSQL, Oracle, etc.) en datos de transmisión observables para su consumo y procesamiento en tiempo real por parte de otras aplicaciones. En este artículo utilizaremos una combinación de Debezium y Kafka para lograr la sincronización de datos de MySQL a DolphinDB.

La solución de sincronización de datos de Kafka + Debezium requiere el despliegue de 4 servicios, como se muestra a continuación

• ZooKeeper: implementación de dependencia de Kafka
• Kafka：Cuenta de ahorro de cantidad
• Kafka-Connect: un marco para acceder a los complementos de datos, conector de origen y conector de receptor, que puede proporcionar alta disponibilidad. También se puede implementar una versión de instancia única.
• Schema-Registry : proporciona una función de registro de metadatos para datos sincronizados en tiempo real y admite la serialización de datos.

El diagrama de arquitectura de datos basado en Debezium es el siguiente:

 

A continuación, este artículo presentará las tareas de descarga, instalación y sincronización de datos de configuración de estos servicios una por una.

Implemente almacenamiento de datos en tiempo real de instancia única de Kafka

Toda la arquitectura basada en Kafka admite clústeres de alta disponibilidad. Sin embargo, incluso si se implementa una única instancia del servicio, se puede lograr la tarea de sincronización de datos.

Este artículo presentará la sincronización de datos mediante el almacenamiento de instancia única.

Preparación para la implementación

Primero descargue el paquete del programa, Zookeeper (código abierto), Kafka (código abierto), Confluent (versión comunitaria), puede ir al sitio web oficial para descargar la última versión estable.

y coloque los siguientes 4 paquetes de software en el directorio /opt. (Hay muchos archivos de ruta de software, configuración y datos.Nota: intente mantener la ruta constante durante la primera prueba.)

• jdk-17.0.7_linux-x64_bin.tar.gz
• Apache-zookeeper-3.7.1-bin.tar.gz
• kafka_2.13-3.4.1.tgz (descargar la versión scala 2.13)
• comunidad-confluente-7.4.0.tar.gz

La descarga confluente es un poco más problemática. Debe seleccionar autoadministrado y luego ingresar la información y hacer clic en iniciar descarga gratuita. Tenga en cuenta que descargar la versión comunitaria satisfará sus necesidades. Solo necesitamos el paquete esquema-registro dentro. Por supuesto, si necesita mejores funciones, también puede descargar la versión oficial, que incluye Zookeeper, Kafka y más funciones para administrar y monitorear Kafka. Confluent es una empresa comercial relacionada con Kafka.   

Después de descargar los 4 paquetes anteriores, podemos comenzar la implementación.

Implementar Zookeeper

Preparación básica

Paso 1: crear un usuario de implementación

Cree el usuario kafka y otorgue permisos sin contraseña a sudo (debe configurarlo usted mismo). Luego cambie al usuario de Kafka para realizar operaciones (las siguientes operaciones son todas operaciones del usuario de Kafka).

useradd kafka
su kafka

Paso 2: instalar e implementar el entorno Java

Instale Java en la ruta /opt/java17. Todos los programas involucrados en toda la arquitectura se ejecutan en función de la máquina virtual Java. Entonces se debe instalar Java.

cd /opt
sudo mkdir -p /usr/local/java
sudo tar -xvf jdk-17.0.7_linux-x64_bin.tar.gz
sudo mv jdk-17.0.7 /usr/local/java/java17

Establezca variables de entorno de Java (ejecutadas bajo el usuario de Kafka).

vim ~/.bashrc
# 输入下面代码
JAVA_HOME=/usr/local/java/java17
PATH=$JAVA_HOME/bin:$PATH
export JAVA_HOME PATH

source ~/.bashrc
java --version

Instalar ZooKeeper

Paso 1: descomprime e instala Zookeeper

Los usuarios y grupos de Zookeeper en la versión 3.7.1 tienen valores predeterminados y debemos ajustarlos aquí.

cd /opt
sudo tar -xvf apache-zookeeper-3.7.1-bin.tar.gz
sudo mv apache-zookeeper-3.7.1-bin zookeeper
sudo chown -R root:root zookeeper
sudo chmod -R 755 zookeeper

Paso 2: preparar los archivos de configuración y los archivos de almacenamiento de Zookeeper

Cree rutas de almacenamiento para los archivos de configuración, archivos de datos y archivos de registro de Zookeeper. Intente mantener las rutas consistentes. Al final del artículo, hay un paquete con todos los archivos de configuración del programa.

sudo mkdir -p /KFDATA/zookeeper/etc
sudo mkdir -p /KFDATA/zookeeper/data
sudo mkdir -p /KFDATA/zookeeper/datalog
sudo mkdir -p /KFDATA/zookeeper/logs
sudo chown -R kafka:kafka /KFDATA
chmod -R 700 /KFDATA/zookeeper

Prepare el archivo de configuración del cuidador del zoológicozoo.cfg. Primero copielog4j.properties de la ruta de instalación de zookeeper y luego modifíquelo.    

Nota: diferentes versiones de zookeeperlog4j.propertiesEl contenido de la configuración será ligeramente diferente. Si hay alguna diferencia, ajústela de acuerdo con las reglas de log4j.   

cd /KFDATA/zookeeper/etc
touch zoo.cfg
echo tickTime=2000 > zoo.cfg
echo initLimit=10 >>zoo.cfg
echo syncLimit=5 >>zoo.cfg
echo  dataDir=/KFDATA/zookeeper/data >>zoo.cfg
echo  dataLogDir=/KFDATA/zookeeper/datalog >>zoo.cfg
echo  clientPort=2181 >>zoo.cfg
sudo cp /opt/zookeeper/conf/log4j.properties ./
sudo chown kafka:kafka ./log4j.properties

Revisadolog4j.propertiesneutralzookeeper.log.dirNúmero de referencia    

Paso 3: cree el archivo de inicio de Zookeeper

Cree unzk.env y configure las variables de entorno necesarias para iniciar Zookeeper para iniciar elservicio. Llamada de archivo.     

cd /KFDATA/zookeeper/etc/
touch zk.env
echo JAVA_HOME=/usr/local/java/java17 > zk.env
echo PATH="/usr/local/java/java17/bin:/opt/zookeeper/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin" >> zk.env
echo ZOO_LOG_DIR=/KFDATA/zookeeper/logs >> zk.env
echo ZOO_LOG4J_OPTS=\"-Dlog4j.configuration=file:/KFDATA/zookeeper/etc/log4j.properties\" >> zk.env

Si está muy familiarizado con Zookeeper, puede llamar al script de operación en la carpeta bin en el directorio de instalación de Zookeeper para realizar operaciones o pruebas.   

UsoConjunto de instrucciones de una piezaservicioelemento de texto.  vim   

sudo vim /usr/lib/systemd/system/zookeeper.service

Ingrese la siguiente información del comando de inicio y guárdela.

[Unit]
Description=Apache Kafka - ZooKeeper
After=network.target

[Service]
Type=forking
User=kafka
Group=kafka
EnvironmentFile=/KFDATA/zookeeper/etc/zk.env
ExecStart=/opt/zookeeper/bin/zkServer.sh start /KFDATA/zookeeper/etc/zoo.cfg
ExecStop=/opt/zookeeper/bin/zkServer.sh stop /KFDATA/zookeeper/etc/zoo.cfg
TimeoutStopSec=180
Restart=no


[Install]
WantedBy=multi-user.target

Vuelva a cargar el servicio para iniciarlo.

sudo systemctl daemon-reload

Paso 4: cree un script de prueba

(1) Cree un archivo de prueba de conexión ZookeeperzkCon.sh.  

mkdir -p /KFDATA/bin
cd /KFDATA/bin
touch zkCon.sh
echo export JAVA_HOME=/usr/local/java/java17 >zkCon.sh
echo export PATH="{$JAVE_HOME}/bin:/opt/zookeeper/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin" >>zkCon.sh
echo export ZOO_LOG_DIR=/KFDATA/zookeeper/logs >>zkCon.sh
echo export ZOO_LOG4J_OPTS=\"-Dlog4j.configuration=file:/KFDATA/zookeeper/etc/log4j.properties\" >>zkCon.sh
echo  '/opt/zookeeper/bin/zkCli.sh -server localhost:2181 -Dzookeeper.config.path=/KFDATA/zookeeper/zoo.cfg' >>zkCon.sh

Otorgue permisos de ejecución al script.

chmod +x  zkCon.sh 

Implementar e iniciar Zookeeper

Paso 1: inicie el servicio Zookeeper a través de la herramienta systemctl.

sudo systemctl start zookeeper.service

Paso 2: Verifique el estado de inicio de Zookeeper

Puede ver el proceso de Java a través del comando. El proceso QuorumPeerMain es el proceso de inicio de Zookeeper.  jps 

 

 

también se puede ver mediante el comando , como se muestra en la figura, que muestra el inicio normal.  systemctl 

 sudo systemctl status zookeeper

Paso 3: conéctese a Zookeeper a través del cliente y visualícelo.

cd /KFDATA/bin/
./zkCon.sh
# 等待 zookeeper 命令行窗口
ls /
ls /zookeeper 

Si aparece la siguiente pantalla, significa que Zookeeper se inició correctamente y puede observar su propia información básica en Zookeeper.

Ctrl +c puede salir de la conexión del cliente Zookeeper.

Implementar Kafka

Instalar Kafka

Paso 1: descomprima e instale los archivos Kafka

Ejecute el siguiente comando para modificar el nombre del archivo de instalación de Kafka.

cd /opt
sudo tar -xvf kafka_2.13-3.4.1.tgz
sudo mv kafka_2.13-3.4.1 kafka

Paso 2: preparar los archivos de configuración y los archivos de almacenamiento de Kafka

Cree la ruta de almacenamiento para los archivos de configuración, archivos de datos y archivos de registro de Kafka.

mkdir -p /KFDATA/kafka/etc
mkdir -p /KFDATA/kafka/data
mkdir -p /KFDATA/kafka/logs

Prepare archivos de configuración relacionados con Kafka, cree archivos de configuración de inicio y registre archivos de configuración.

cd /KFDATA/kafka/etc
touch kafka-server.properties
cp /opt/kafka/config/log4j.properties ./
cp /opt/kafka/config/tools-log4j.properties ./

Modificarkafka-server.propertiesLa configuración en el archivo tiene muchas modificaciones. El archivo es el siguiente. También puedes ingresarlo tú mismo. .   

############################# Server Basics #############################
broker.id=1
############################# Socket Server Settings #############################
listeners=PLAINTEXT://0.0.0.0:9092
advertised.listeners=PLAINTEXT://192.168.189.130:9092
num.network.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
############################# Log Basics #############################
log.dirs=/KFDATA/kafka/data
num.partitions=1
num.recovery.threads.per.data.dir=1
############################# Internal Topic Settings  #############################
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
############################# Log Retention Policy #############################
log.retention.hours=-1
log.retention.bytes=21474836480 
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000
auto.create.topics.enable=true
############################# Zookeeper #############################
zookeeper.connect=192.168.189.130:2181
# Timeout in ms for connecting to zookeeper
zookeeper.connection.timeout.ms=12000
############################# Group Coordinator Settings #############################
group.initial.rebalance.delay.ms=0
############################# message Settings #############################
message.max.byte=5242880

Los dos elementos siguientes deben modificarse según el entorno específico: publicidad.listeners es el puerto de escucha externo.

advertised.listeners=PLAINTEXT://192.168.189.130:9092
zookeeper.connect=192.168.189.130:2181

Paso 3: preparar los archivos de inicio de Kafka

Cree un archivo de variable de entorno para el inicio de Kafka. El puerto de monitoreo JMX se configura aquí. Si no es necesario, puede ignorar las dos últimas configuraciones.

La función del puerto JMX es que puedes conectarte a través de este puerto para obtener algunos indicadores de monitoreo.

cd /KFDATA/kafka/etc
touch kf-server.env

echo PATH="/usr/local/java/java17/bin:/opt/zookeeper/bin:/opt/kafka:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin" >>kf-server.env
echo LOG_DIR="/KFDATA/kafka/logs/" >>kf-server.env
echo KAFKA_LOG4J_OPTS=\"-Dlog4j.configuration=file:/KFDATA/kafka/etc/log4j.properties\" >>kf-server.env
echo KAFKA_JMX_OPTS=\"-Dcom.sun.management.jmxremote=true -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false -Djava.rmi.server.hostname=192.168.189.130 -Djava.net.preferIPv4Stack=true\" >>kf-server.env
echo JMX_PORT=29999 >>kf-server.env

Cree elarchivo de servicio systemd de Kafka,abra un archivo.   vim 

sudo vim /usr/lib/systemd/system/kafka-server.service

Ingrese el siguiente contenido y guárdelo.

[Unit]
Description=Apache Kafka - broker
After=network.target confluent-zookeeper.target

[Service]
Type=forking
User=kafka
Group=kafka
EnvironmentFile=/KFDATA/kafka/etc/kf-server.env
ExecStart=/opt/kafka/bin/kafka-server-start.sh -daemon /KFDATA/kafka/etc/kafka-server.properties
ExecStop=/KFDATA/kafka/bin/kafka-server-stop.sh
LimitNOFILE=1000000
TimeoutStopSec=180
Restart=no

[Install]
WantedBy=multi-user.target

Vuelva a cargar el servicio para iniciarlo.

sudo systemctl daemon-reload

Implementar e iniciar Kafka

Paso 1: inicie el servicio Kafka a través de la herramienta systemctl

Ejecute el siguiente comando para iniciar el servicio Kafka:

sudo systemctl start kafka-server.service

Paso 2: Verifique el estado de inicio de Kafka

Para verificar el estado de inicio de Kafka, puede conectarse al cliente Zookeeper. Ver datos en zookeeper.

cd /KFDATA/bin
./zkCon.sh
ls /

Puede ver que Zookeeper ha agregado información de registro de Kafka, como intermediarios, agrupadores, configuraciones, controladores, etc.

En este punto, puede crear un tema para probar:

cd  /opt/kafka/bin
./kafka-topics.sh --bootstrap-server 192.168.189.130:9092 --create --topic test110

Ejecute el siguiente código para ver la lista de temas actual en Kafka:

./kafka-topics.sh --bootstrap-server 192.168.189.130:9092 --list

Si se devuelve el contenido de la imagen de arriba, significa que Kafka se ha iniciado correctamente.

Implementar registro de esquema

Schema-Registry se utiliza para registrar la estructura de datos de los datos transmitidos. Y registre cada versión de los cambios en la estructura de datos. Escribir y leer datos de Kafka requiere estructuras de datos registradas en el registro de esquema para la serialización y deserialización. Registre estructuras de datos mediante el registro de esquemas. Kafka solo necesita guardar los datos serializados. Puede reducir el espacio ocupado por los datos.

Instalar el registro de esquemas

Paso 1: descomprima e instale el archivo Schema-Registry

El programa Schema-Registry es parte del paquete confluente. Entonces aquí necesitamos instalar conluent, la versión comunitaria es suficiente. Descomprimaconfluent-community-7.4.0.tar.gz, modifique el nombre del archivo y configure el grupo de membresía.  

cd /opt
sudo tar -xvf confluent-community-7.4.0.tar.gz
sudo mv confluent-7.4.0 confluent
sudo chown -R root:root confluent
sudo chmod -R 755 confluent

Paso 2: preparar los archivos de configuración y los archivos de almacenamiento del Registro de esquemas

Cree la configuración del registro de esquema y la ruta de almacenamiento del archivo de registro.

mkdir -p /KFDATA/schema-registry/etc
mkdir -p /KFDATA/schema-registry/logs

Prepare el archivo de configuración para el registro de esquema.

cd /KFDATA/schema-registry/etc
cp /opt/confluent/etc/schema-registry/schema-registry.properties ./
cp /opt/confluent/etc/schema-registry/log4j.properties ./

Modificarschema-registry.properties y modificar la dirección del servidor Kafka conectado.   

Paso 3: preparar el archivo de inicio del Registro de esquemas

Cree un archivo de variable de entorno de inicio de Schema-Registry para usarlo cuando se inicie Schema-Registry.

touch schema-registry.env
echo PATH="/usr/local/java/java17/bin:/opt/confluent/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin" >schema-registry.env
echo LOG_DIR="/KFDATA/schema-registry/logs" >>schema-registry.env
echo LOG4J_DIR="/KFDATA/schema-registry/etc/log4j.properties" >>schema-registry.env
echo SCHEMA_REGISTRY_LOG4J_OPTS=\"-Dlog4j.configuration=file:/KFDATA/schema-registry/etc/log4j.properties\" >>schema-registry.env

Cree el archivo de inicio del servicio systemd de Schema-Registry.

sudo vim /usr/lib/systemd/system/schema-registry.service

Ingrese el siguiente contenido y guárdelo.

[Unit]
Description=RESTful Avro schema registry for Apache Kafka
After=network.target

[Service]
Type=forking
User=kafka
Group=kafka
EnvironmentFile=/KFDATA/schema-registry/etc/schema-registry.env
ExecStart=/opt/confluent/bin/schema-registry-start -daemon /KFDATA/schema-registry/etc/schema-registry.properties
TimeoutStopSec=180
Restart=no

[Install]
WantedBy=multi-user.target

Vuelva a cargar el servicio para iniciarlo.

sudo systemctl daemon-reload

Inicio de implementación Schema-Registry

Paso 1: Inicie el servicio Schema-Registry a través de la herramienta systemctl

Ejecute el siguiente comando

sudo systemctl start schema-registry

Paso 2: Verifique el estado de inicio del Registro de esquemas

Verifique el estado de inicio a través de la herramienta systemctl.

sudo systemctl status schema-registry

Ver temas en Kafka

cd /opt/kafka/bin
./kafka-topics.sh --bootstrap-server 192.168.189.130:9092 --list

Puede ver que los temas que debe utilizar el registro de esquema se han creado en Kafka.

El registro de esquema se inició correctamente.

Implementar Kafka-Connect

Kafka-Connect es el marco HA proporcionado por Kafka, implementa el conector de la interfaz Kafka-Connect y solo necesita manejar las tareas de lectura y escritura de datos que necesita. La parte de alta disponibilidad está a cargo del marco kafka-connect.

Kafka-Connect está disponible a través de la API de descanso.

Instalar Kafka-Connect

Paso 1: instalación de Kafka-Connect

Kafka-Connect lo proporciona Kafka y el programa de inicio ya existe en la ruta de instalación de Kafka. El registro de metadatos de datos lo gestiona el registro de esquemas. El paquete de serialización correspondiente se encuentra en la ruta instalada de Confluent. Por lo que ya no es necesario instalar el paquete.

Paso 2: preparar los archivos de configuración y los archivos de almacenamiento de Kafka-Connect

Cree la configuración de Kafka-Connect y la ruta de almacenamiento del archivo de registro

mkdir -p /KFDATA/kafka-connect/etc
mkdir -p /KFDATA/kafka-connect/logs

Cree un archivo de configuración para Kafka-Connect

cd /KFDATA/kafka-connect/etc
vim kafka-connect.properties

Ingrese el siguiente contenido y guárdelo. La parte de la dirección IP debe modificarse de acuerdo con el entorno actual.

bootstrap.servers=192.168.189.130:9092
group.id=connect-cluster

key.converter=io.confluent.connect.avro.AvroConverter
key.converter.schema.registry.url=http://192.168.189.130:8081
value.converter=io.confluent.connect.avro.AvroConverter
value.converter.schema.registry.url=http://192.168.189.130:8081
key.converter.schemas.enable=true
value.converter.schemas.enable=true

internal.key.converter=org.apache.kafka.connect.json.JsonConverter
internal.value.converter=org.apache.kafka.connect.json.JsonConverter
internal.key.converter.schemas.enable=false
internal.value.converter.schemas.enable=false

config.storage.topic=connect-configs
offset.storage.topic=connect-offsets
status.storage.topic=connect-statuses
config.storage.replication.factor=1
offset.storage.replication.factor=1
status.storage.replication.factor=1

plugin.path=/opt/confluent/share/java/plugin
rest.host.name=192.168.189.130
rest.port=8083
rest.advertised.host.name=192.168.189.130
rest.advertised.port=8083

offset.flush.timeout.ms=50000
offset.flush.interval.ms=10000
send.buffer.bytes=13107200
consumer.max.poll.records=10000
consumer.partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor

Cree el archivo de configuración log4j para Kafka-Connect.

cd /KFDATA/kafka-connect/etc
cp /opt/kafka/config/connect-log4j.properties ./log4j.properties

Modifique la siguiente configuración de parámetros en el archivo.

vim ./log4j.properties
log4j.appender.connectAppender.File=${kafka.logs.dir}/connect.log

Modificarlo a

log4j.appender.connectAppender.File=/KFDATA/kafka-connect/logs/connect.log

Paso 3: Prepare el archivo de inicio para Kafka-Connect

Cree un archivo de variable de entorno de inicio de Kafka-Connect.

cd /KFDATA/kafka-connect/etc
touch kafka-connect.env

echo PATH="/usr/local/java/java17/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin" >kafka-connect.env
echo LOG_DIR="/KFDATA/kafka-connect/logs/" >>kafka-connect.env
echo LOG4J_DIR="/KFDATA/kafka-connect/etc/log4j.properties" >>kafka-connect.env
echo KAFKA_LOG4J_OPTS=\"-Dlog4j.configuration=file:/KFDATA/kafka-connect/etc/log4j.properties\" >>kafka-connect.env
echo CLASSPATH=/opt/confluent/share/java/schema-registry/*:/opt/confluent/share/java/kafka-serde-tools/*:/opt/confluent/share/java/confluent-common/* >>kafka-connect.env
echo JMX_PORT=29998 >>kafka-connect.env

Cree el archivo de servicio systemd de Kafka-Connect

sudo vim /usr/lib/systemd/system/kafka-connect.service

Ingrese el siguiente contenido y guárdelo.

[Unit]
Description=Apache Kafka Connect - distributed
After=network.target

[Service]
Type=simple
User=kafka
Group=kafka
EnvironmentFile=/KFDATA/kafka-connect/etc/kafka-connect.env
ExecStart=/opt/kafka/bin/connect-distributed.sh /KFDATA/kafka-connect/etc/kafka-connect.properties
TimeoutStopSec=180
Restart=no

[Install]
WantedBy=multi-user.target

Vuelva a cargar el servicio para iniciarlo.

sudo systemctl daemon-reload

Implementar e iniciar Kafka-Connect

Paso 1: inicie el servicio Kafka-Connect a través de la herramienta systemctl

Ejecute el siguiente comando

sudo systemctl start kafka-connect.service

Paso 2: verifique el estado de inicio de Kafka-Connect

Compruebe el estado de inicio mediante comando jps 

jps -mlvV |grep connect

Verifique la situación del tema en Kafka. Kafka-Connect creará tres temas: configuraciones de conexión, compensaciones de conexión y estados de conexión en Kafka.

cd  /opt/kafka/bin
./kafka-topics.sh --bootstrap-server 192.168.189.130:9092 --list

Utilice el comando para acceder a kafka-connect. Puede ver que aún no hemos configurado la tarea del conector curl 

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

Implementar sincronización de datos MySQL en Kafka

La sincronización de datos MySQL incluye sincronización completa inicial y sincronización incremental en tiempo real CDC.

Sincronización completa: escriba todos los datos de la tabla seleccionada en Kafka en forma de Insertar, se recomienda no operar la base de datos en este momento.

Sincronización incremental en tiempo real de CDC: lea el registro binlog de MySQL en tiempo real a partir del número de secuencia de transacciones registrado durante la sincronización completa y escriba el Carga incremental de datos en Kafka.   

Instale el complemento del conector Debezium-MySQL

Configurar e iniciar el conector Debezium-MySQL requiere los dos pasos siguientes:

1. Descargue e instale el complemento Debezium-MySQL y configure la ruta del complemento en el archivo de configuración de Kafka Connect.
2. Reinicie el programa Kafka Connect para cargar el complemento.

Paso 1: descargue e instale el complemento Debezium-MySQL

Sitio web oficialDebezium, seleccione la última versión estable para descargar.   

Seleccione el complemento del conector MySQL

Cree una ruta de complemento (implemente Kafka, usuario de Kafka del entorno kafka-connnect) y descomprima el paquete de complemento MySQL de Debezium en esta ruta.

sudo mkdir -p /opt/confluent/share/java/plugin
cd /opt/confluent/share/java/plugin
sudo tar -xvf debezium-connector-mysql-2.3.2.Final-plugin.tar.gz
rm ./debezium-connector-mysql-2.3.2.Final-plugin.tar.gz

Paso 2: configurar Kafka-Connect para cargar el complemento

Modifique el archivo de configuración de Kafka Connect y agregue la configuración de ruta del complemento

cd /KFDATA/kafka-connect/etc
vim kafka-connect.properties

Agregue o modifique parámetrosplugin.pathde la siguiente manera  

plugin.path=/opt/confluent/share/java/plugin

Reiniciar Kafka Connect

sudo systemctl stop kafka-connect
sudo systemctl start kafka-connect

Verifique la salida del registro, como se muestra en la figura siguiente, luego el complemento se cargará correctamente.

cat /KFDATA/kafka-connect/logs/connect.log|grep mysql

Configurar la base de datos MySQL

Como base de datos de origen, obtenemos datos incrementales en tiempo real basados ​​en elbinlog de MySQL, por lo que debemos realizar algunas configuraciones para MySQL. base de datos.   

Paso 1: cree un usuario de MySQL para la sincronización de datos

El conector Debezium MySQL requiere una cuenta de usuario MySQL. Este usuario de MySQL debe tener los permisos adecuados en todas las bases de datos donde el conector Debezium MySQL captura cambios.

CREATE USER 'datasyn'@'%' IDENTIFIED BY '1234';

Permiso concedido.

GRANT SELECT, RELOAD, SHOW DATABASES, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'datasyn';

Actualizar la tabla de autorización.

FLUSH PRIVILEGES;

Paso 2: establecer los parámetros de MySQL

La sincronización CDC requiere algunas configuraciones en la base de datos MySQL.

parámetro	valor	ilustrar
ID del servidor	1	Se utiliza para identificar una instancia de servidor MySQL en MySQL Cluster. Puede ajustar la configuración usted mismo.
papelera de registro	mysql-bin	Configúrelo para habilitar la función de registro binario y especificar el nombre del archivo de registro y la ubicación de almacenamiento. Puede ajustar la configuración usted mismo.
formato_binlog	FILA	Debe configurar el formato binlog en FILA o fila. Al conectarse a una instancia de replicación en cascada de MySQL, se debe configurar cada enlace de instancia en el enlace.
binlog_row_imagen	LLENO	Debe binlog_row_image establecerse en FULL o full . Al conectarse a una instancia de replicación en cascada de MySQL, se debe configurar cada enlace de instancia en cascada dentro del enlace.
modo_gtime	EN	Establecer habilitar indicador de transacción global
enforce_gtid_consistency	EN	Configuraciones para hacer cumplir la coherencia de GTID
expirar_logs_days	3	Establezca el tiempo de retención del registro de MySQL.La sincronización de datos CDC de MySQL requiere los archivos de registro correspondientes para la sincronización. Se recomienda fijar el tiempo de retención en al menos 3 días.
binlog_row_value_options	““	Esta variable no se puede establecer en PARTIAL_JSON

Código de referencia del parámetro:

[mysqld]
server-id = 1

log_bin=mysql-bin
binlog_format=ROW
binlog_row_image=FULL
binlog_row_value_options=""

gtid_mode=ON
enforce_gtid_consistency=ON

expire_logs_days=3

Configurar la tarea de conexión de sincronización de datos MySQL

Muchos comandos para configurar tareas de sincronización y verificar requieren parámetros como url. Para una operación rápida, se encapsulan algunos scripts de operación para cargar archivos de configuración, kafka-tools.tar. Descargue el paquete actual y extráigalo al directorio /KFDATA. Muchas operaciones posteriores incluyen verificar temas de Kafka y ver datos. La configuración de tareas de sincronización, etc. utilizará los scripts del paquete kafka-tools. Por favor configúrelo. Todos los scripts del paquete se pueden ejecutar sin parámetros y se generará ayuda.    

cd /KFDATA
sudo tar -xvf kafka-tools.tar
sudo chown kafka:kafka kafka-tools
rm ./kafka-tools.tar

Modifique los parámetros de configuración de kafka-tools/config/config.properties.

Modifique la dirección IP de inicio y el directorio de instalación de Kafka y Kafka_Connect de acuerdo con la ruta y la IP de la máquina local.

Preparar tablas de base de datos MySQL

Paso 1: crear una base de datos

create database basicinfo;

Paso 2: crea dos tablas e inserta algunos datos

Cree la tabla 1index_components, con 4 campos de clave principal.  

use basicinfo;
CREATE TABLE `index_components` (
  `trade_date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `code` varchar(20) NOT NULL,
  `effDate` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `indexShortName` varchar(20) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL,
  `indexCode` varchar(20) NOT NULL,
  `secShortName` varchar(20) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL,
  `exchangeCD` varchar(4) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL,
  `weight` decimal(26,6) DEFAULT NULL,
  `timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `flag` int NOT NULL DEFAULT '1',
  PRIMARY KEY `index_components_pkey` (`trade_date`,`code`,`indexCode`,`flag`)
)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4; 

Insertar 4 datos

insert into index_components (trade_date,code,effdate,indexShortName,indexCode,secShortName,exchangeCD,weight,timestamp,flag)
values('2006-11-30','000759','2018-06-30 03:48:05','中证500','000905','中百集团','XSHE',0.0044,'2018-06-30 05:43:05',1),
('2006-11-30','000759','2018-06-30 04:47:05','中证500','000906','中百集团','XSHE',0.0011,'2018-06-30 05:48:06',1),
('2006-11-30','600031','2018-06-30 05:48:05','上证180','000010','三一重工','XSHG',0.0043,'2018-06-30 05:48:05',1),
('2006-11-30','600031','2018-06-30 06:48:02','沪深300','000300','三一重工','XSHG',0.0029,'2018-06-30 05:48:05',1);

Cree la tabla 2stock_basic, con 2 campos de clave principal.   

CREATE TABLE `stock_basic` (
  `id` bigint NOT NULL ,
  `ts_code` varchar(20) NOT NULL,
  `symbol` varchar(20) DEFAULT NULL,
  `name` varchar(20) DEFAULT NULL,
  `area` varchar(20) DEFAULT NULL,
  `industry` varchar(40) DEFAULT NULL,
  `list_date` date DEFAULT NULL,
  PRIMARY KEY (`id`,`ts_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Inserte 3 datos;

insert into stock_basic(id,ts_code,symbol,name,area,industry,list_date)
values (1,'000001.SZ','000001','平安银行','深圳','银行','1991-04-03'),
(2,'000002.SZ','000002','万科A','深圳','地产','1991-01-29'),
(3,'000004.SZ','000004','ST国华','深圳','软件服务','1991-01-14')

Prepare el archivo de configuración del conector e inicie la tarea de conexión.

Paso 1: preparar el archivo de configuración de la tarea de sincronización de MySQL

Cree un archivo de configuración del conector de origen para conectarse a MySQL.

mkdir /KFDATA/datasyn-config
cd /KFDATA/datasyn-config
vim source-mysql.json

Ingrese la siguiente configuración: el nombre de host y la dirección de inicio de Kafka deben modificarse en consecuencia.

{
    "name": "basicinfo-connector",
    "config":{
        "connector.class": "io.debezium.connector.mysql.MySqlConnector",
        "tasks.max": "1",
        "topic.prefix":"mysqlserver",
        "database.hostname": "192.168.189.130",
        "database.port": "3306",
        "database.user": "datasyn",
        "database.password": "1234",
        "database.server.id": "2223314",
        "database.include.list": "basicinfo",
        "schema.history.internal.kafka.bootstrap.servers": "192.168.189.130:9092",
        "schema.history.internal.kafka.topic": "schema-changes.basicinfo",
        "heartbeat.interval.ms":"20000"
    }
}

Descripción del parámetro: Los parámetros anteriores son obligatorios. Para obtener descripciones más detalladas de los parámetros, consulteConector Debezium para MySQL :: Documentación de Debezium. 

nombre del parámetro	valor por defecto	Descripción de parámetros
conector.clase	ninguno	El nombre de la clase Java del conector. Aquí está el nombre de la clase del conector para mysql.
tareas.max	1	El número máximo actual de tareas paralelas para el conector. El número de tareas del conector de origen de MySQL solo puede ser 1.
tema.prefijo	ninguno	El espacio de nombres de la tarea de escritura síncrona del conector actual. Se utilizará para agregar a la tabla de sincronización antes del nombre del tema correspondiente, etc.
base de datos.nombre de host	ninguno	La dirección IP o nombre de host del servidor de base de datos MySQL.
puerto.base de datos	3306	El número de puerto entero del servidor de base de datos MySQL.
usuario.base de datos	ninguno	Usuario de conexión al servidor de base de datos MySQL.
base de datos.contraseña	ninguno	Contraseña de usuario de conexión al servidor de base de datos MySQL.
base de datos.servidor.id	ninguno	Se utiliza para simular el número de proceso del proceso esclavo MySQL. El programa de sincronización se unirá al clúster MySQL con esta ID numérica.
base de datos.influde.lista	ninguno	Nombre de base de datos coincidente. Puede haber más de uno, simplemente sepárelos con comas.
esquema.historia.interna.kafka.bootstrap.servidores	ninguno	La sincronización de datos registra la conexión kafka de la información de la estructura de la tabla MySQL
esquema.historia.interna.kafka.topic	ninguno	El nombre del tema de la estructura de la tabla MySQL del registro de sincronización de datos.
latido.intervalo.ms	0	Al recibir un evento de cambio de MySQL, se garantiza que se activará un evento de intervalo que registrará la ubicación de la transacción binlog o gtid. (Si este valor es 0, cuando se recibe un evento de cambio que no pertenece a la tabla de sincronización de datos, la posición de la transacción no se registrará, lo que puede hacer que el número de transacción de sincronización registrado actualmente se retrase significativamente con respecto al último número de transacción de MySQL).

Paso 2: inicie la tarea de sincronización de datos MySQL

Inicie el conector de origen de MySQL a través de la API de resto

curl -i -X POST -H "Accept:application/json" -H  "Content-Type:application/json" http://192.168.189.130:8083/connectors/ -d @/KFDATA/datasyn-config/source-mysql.json

También puede iniciarlo a través del script en kafka-tools que le proporcionamos, lo que simplifica la operación.

cd /KFDATA/kafka-tools/bin
./rest.sh create @/KFDATA/datasyn-config/source-mysql.json

Paso 3: ver el estado de la tarea de sincronización de datos de MySQL

Ver la lista de tareas de sincronización. El parámetro list  muestra la lista de nombres de tareas y el parámetro showall  muestra todas las tareas de sincronización.

./rest.sh list
./rest.sh showall

Como puede ver en la figura siguiente, el estado del conector y la tarea son EN EJECUCIÓN y el estado actual de la tarea de sincronización es normal.

Nota: Cada tarea de sincronización tendrá un conector y puede haber varias tareas.

Script usando kafka-toolskafka.shVer temas en kafka  

cd /KFDATA/kafka-tools/bin
./kafka.sh tplist|grep mysqlserver

El tema [mysqlserver.basicinfo.index_components] en la siguiente imagen es nuestra tablabasicinfo.index_componentsAlmacenamiento de datos en Kafka  

Verifique la cantidad de elementos de datos en el tema [mysqlserver.basicinfo.index_components].

./kafka.sh get_offsets mysqlserver.basicinfo.index_components

kafka ha sincronizado 4 datos de la tabla MySQLbasicinfo.index_components.   

Nota: Al sincronizar los datos de la instantánea inicial de MySQL, no se puede interrumpir. De lo contrario, deberá borrar todos los datos sincronizados y empezar de nuevo. Es decir, los datos de la instantánea inicial no admiten la carga reanudable.

Implementar la sincronización de datos de Kafka en DolphinDB

Instale el conector Kafka-DolphinDB

Configurar e iniciar el complemento del conector Kafka-DolphinDB requiere los dos pasos siguientes:

1. Instale el complemento Kafka-DolphinDB y configure la ruta del complemento en el archivo de configuración de Kafka Connect.
2. Reinicie el programa Kafka Connect para cargar el complemento.

Paso 1: descargue el complemento Kafka-DolphinDB

• jdbc-1.30.22.4-ddbsync.Beta1.jar：该 DolphinDB JDBC 包为数据同步做了一些专门修改，后续会同步到主分支上。
• kafka-connect-jdbc-10.7.4-ddb1.01.Beta1.jar：基于 kafka-connect-jdbc-10.7.4 开发，添加了 DolphinDB 连接器。

创建插件路径（部署 Kafka，Kafka-Connnect 环境的 kafka 用户），在此路径下放置 Kafka-DolphinDB 插件包，上面两个包都要放到此目录下。

sudo mkdir -p /opt/confluent/share/java/plugin/kafka-connect-jdbc

第二步：配置 Kafka-Connect 加载插件

Kafka-DolphinDB 插件包的父路径与前文 Debezium-MySQL 连接器插件路径均为 /opt/confluent/share/java/plugin/，因此无需再次配置到 Kafka-Connect 的配置文件中。

如果路径不一致，可以在 kafka-connect.properties 中的 plugin.path 参数里配置，以逗号分隔。

查看 plugin.path 参数配置：

cat /KFDATA/kafka-connect/etc/kafka-connect.properties |grep plugin

重新启动 Kafka Connect：

sudo systemctl stop kafka-connect
sudo systemctl start kafka-connect

查看日志输出

cat /KFDATA/kafka-connect/logs/connect.log|grep JdbcSinkConnector

出现下图中所示信息时，说明插件加载成功。

DolphinDB 的数据同步准备

第一步：创建同步的库、表

要求：当前支持数据同步，需要依赖 TSDB 引擎的 keepDuplicates = LAST 数据来保证数据写入的幂等性，即发生数据重复时，两次及以上的相同增量数据写入，不影响数据的一致性。所以需要满足以下条件：

1. DolphinDB 的表必须是 TSDB 引擎且设置 keepDuplicates = LAST。
2. TSDB 引擎目前不支持单字段 sortColumn 设置 keepDuplicates = LAST，所以同步的 MySQL 目标表主键必 须是 2个及以上字段。
3. sortColumn 最后的字段必须是时间或者数字。对应的 MySQL 目标表主键字段必须包含时间或数字。

分别创建之前 MySQL 中两张表的对应表：

1. 创建 MySQL 表 basicinfo.index_components 的DolphinDB 对应分布式表 [dfs://index_data].[index_components]

def createIndexComDB(dbName){
	if(existsDatabase(dbName)){
	dropDatabase(dbName)
	}
	database(directory=dbName, partitionType=RANGE, partitionScheme= 1999.01M + (0..26)*12,engine="TSDB")
}
def createIndexCom(dbName,tbName){
	db=database(dbName)
             if(existsTable(dbName, tbName)){
                   db.dropTable(tbName)	
	}
	mtable=table(100:0, `trade_date`code`effDate`indexShortName`indexCode`secShortName`exchangeCD`weight`timestamp`flag, [TIMESTAMP,SYMBOL,TIMESTAMP,SYMBOL,SYMBOL,SYMBOL,SYMBOL,DOUBLE,TIMESTAMP,INT]);
	db.createPartitionedTable(table=mtable, tableName=tbName, partitionColumns=`trade_date,sortColumns=`code`indexCode`flag`trade_date,compressMethods={trade_date:"delta"},keepDuplicates=LAST)
}
createIndexComDB("dfs://index_data")
createIndexCom("dfs://index_data",`index_components)

2. 创建 MySQL 表 basicinfo.stock_basic 的 DolphinDB 对应分布式表 [dfs://wddb].[stock_basic]

def createStockBasicDB(dbName){
	if(existsDatabase(dbName)){
	dropDatabase(dbName)
	}
	db=database(directory=dbName, partitionType=HASH, partitionScheme=[LONG, 1],engine="TSDB")
}
def createStockBasic(dbName,tbName){
	db=database(dbName)
             if(existsTable(dbName, tbName)){
                   db.dropTable(tbName)	
	}
             mtable=table(100:5, `id`ts_code`symbol`name`area`industry`list_date, [LONG,SYMBOL,SYMBOL,SYMBOL,SYMBOL,SYMBOL,DATE]);
	 db.createPartitionedTable(table=mtable, tableName=tbName, partitionColumns=`id,sortColumns=`ts_code`id,keepDuplicates=LAST,sortKeyMappingFunction=[hashBucket{,100}])
}
createStockBasicDB("dfs://wddb")
createStockBasic("dfs://wddb", `stock_basic)

第二步：配置同步配置表

DolphinDB 做为数据的接收端，本身无需做数据库上的额外设置，按正常使用配置即可。但由于 DolphinDB 中的数据存储表通常以分布式表为主，且分布式表是按照分区规则放置在不同的库名下，不同库名下的表是支持重名的。所以需要提供对于 DolphinDB 中表的同步配置信息。

1. 在 DolphinDB 中创建一张配置表。库、表名可在后续操作中调整，但是表中字段名要保持一致。

• 数据库名：dfs://ddb_sync_config
• 表名：sync_config

dbName = "dfs://ddb_sync_config"
if(existsDatabase(dbName)){
    dropDatabase(dbName)
}
db=database(dbName, HASH, [SYMBOL, 5])

if(existsTable(dbName, "sync_config"))
    db.dropTable("sync_config")
mtable=table(100:0, `connector_name`topic_name`target_db`target_tab, [SYMBOL,SYMBOL,SYMBOL,SYMBOL]);
db.createTable(table=mtable, tableName="sync_config")

2. 插入配置表信息，配置 MySQL 表 basicinfo.index_components 和 basicinfo.stock_basic 对应的 kafka 中 topic 名称对应的 DolphinDB 分布式表

sync_config=loadTable("dfs://ddb_sync_config","sync_config");
tmp_tab=table(100:0,`connector_name`topic_name`target_db`target_tab, [SYMBOL,SYMBOL,SYMBOL,SYMBOL]);
insert into tmp_tab (connector_name,topic_name,target_db,target_tab) values ("ddb-sink","mysqlserver.basicinfo.index_components","dfs://index_data","index_components");
insert into tmp_tab (connector_name,topic_name,target_db,target_tab) values ("ddb-sink","mysqlserver.basicinfo.stock_basic","dfs://wddb","stock_basic");
sync_config.append!(tmp_tab);

表中数据如下：

注意：对于同一个 connector_name，相同的 topic_name 只能配置一条数据。配置分布式库、表必须在 DolphinDB 书库中存在。

字段名	类型	字段作用
connector_name	Symbol	配置的 DolphinDB sink 同步任务名
topic_name	Symbol	要同步的 kafka topic 名称
target_db	Symbol	对应的 DolphinDB 分布式库名
target_tab	Symbol	对应的 DolphinDB 分布式表名

配置 DolphinDB 的数据同步连接任务

准备连接器配置文件，并启动连接任务

创建 DolphinDB 数据同步任务配置文件

cd /KFDATA/datasyn-config
vim ddb-sink.json

配置如下：

{
    "name": "ddb-sink",
    "config": {
        "connector.class": "io.confluent.connect.jdbc.JdbcSinkConnector",
        "tasks.max": "2",
        "topics": "mysqlserver.basicinfo.index_components,mysqlserver.basicinfo.stock_basic",
        "connection.url": "jdbc:dolphindb://192.168.189.130:8848?user=admin&password=123456",
        "transforms": "unwrap",
        "transforms.unwrap.type": "io.debezium.transforms.ExtractNewRecordState",
        "transforms.unwrap.drop.tombstones": "false",
        "auto.evolve": "false",
        "insert.mode": "insert",
        "delete.enabled": "true",
        "batch.size":"10000",
        "pk.mode": "record_key",
        "ddbsync.config.table":"dfs://ddb_sync_config,sync_config"
    }
}

参数说明：以上参数项为同步 DolphinDB 所需参数。如果对 Confluent 的 JDBC Sink Connect 有经验，可适当调节。

参数名称	默认值	参数说明
name	无	同步任务名称，不可重复。
connector.class	无	连接器的 Java 类的名称。这里是 JdbcSink 的通用连接器类名。
tasks.max	1	当前 connector 的最大并行任务数。可以调节增大，会创建多 consumer 并行消费读取 Kafka 中数据。一般的数据同步场景设置到 10 基本可以满足同步速度上的需求。
topics	无	配置要同步的 Kafka 中的 topic 名称，配置多个 topic 时用逗号分割。
connection.url	无	MySQL 数据库服务器的 IP 地址或主机名。
transforms	无	声明数据转换操作。
transforms.unwrap.type	无	声明数据转换器类别。请保持不变。
transforms.unwrap.drop.tombstones	false	声明是否删除 Kafka 中的墓碑数据。
auto.evolve	true	当 DolphinDB 中缺少列时，是否自动增加列。当前不支持自动增加列，必须配置为 false。
insert.mode	insert	数据插入模式。当前只支持 insert 模式。
pk.mode	none	主键模式。必须设置为 record_key。
delete.enabled	false	在主键模式为 record_key 情况下。对于 null 值 record 是否按照 delete 进行操作。
batch.size	3000	设置在数据量足够大时。以每批最大多少条来写入到目标数据库。注意：当该值大于 Connect worker 中设置的 consumer.max.pol.records 时，每次提交数量会受 consumer.max.pol.records 的值限制。
ddbsync.config.table	dfs://ddb_sync_config, sync_config	Kafka 中的 topic 对应 DolphinDB 表的配置表名称。可以自行定义库、表名称。但表中的字段要保持一致。表结构见“DolphinDB 的数据同步准备”。

通过 REST API 启动 source 连接器

curl -i -X POST -H "Accept:application/json" -H  "Content-Type:application/json" http://192.168.189.130:8083/connectors/ -d @ddb-sink.json

也可以通过我们提供 kafka-tools 中的脚本启动

cd /KFDATA/kafka-tools/bin
./rest.sh create @/KFDATA/datasyn-config/ddb-sink.json

查看同步任务列表。其中，”ddb-sink” 为 DolphinDB 数据同步程序。

./rest.sh list

查看 DolphinDB 的 sink 同步任务状态

./rest.sh status ddb-sink

通过下图可以看到，同步到 DolphinDB 的同步任务包含 1 个 connector 和 2 个 task 。两个 task 状态都是 RUNNING，即正常运行。这里配置了两个线程进行数据消费，并写入 DolphinDB。

查看 DolphinDB 中的数据

select * from loadTable('dfs://index_data', 'index_components');
select * from loadTable('dfs://wddb', 'stock_basic')

数据分别如下，两张表的初始数据均已经同步到了 DolphinDB 中。

实时数据同步验证

第一步：插入新数据

在 MySQL 中插入两条新数据。

insert into basicinfo.index_components (trade_date,code,effdate,indexShortName,indexCode,secShortName,exchangeCD,weight,timestamp,flag)
values
('2006-11-30','600051','2018-06-30 05:48:05','上证180','000010','三一重工','XXXB',0.0043,'2018-06-30 05:48:05',1),
('2006-11-30','600052','2018-06-30 06:48:02','沪深300','000300','三一重工','XSHG',0.0029,'2018-06-30 05:48:05',1)

在 DolphinDB 中进行查询，可以看到已经多了两条 code 值为 600051 和 600052 的。

select * from loadTable('dfs://index_data', 'index_components');

第二步：数据更新

在 MySQL 中更新一条数据，这里我们做一个涉及主键字段的更新。

update basicinfo.index_components set code='600061' where code ='600051'

在 DolphinDB 中进行查询，发现表中已经不存在 code 值为 600051 的数据，但可以看到一条 code 值为 600061 的数据。

select * from loadTable('dfs://index_data', 'index_components');

第三步：数据删除

从 MySQL 中删除一条数据。

delete from basicinfo.index_components where code='600061'

在 DolphinDB 中进行查询，可以看到 code 值为 600061 的数据已经不存在了。

运维操作

DolphinDB 同步须知

1. DolphinDB 是一款支持海量数据的分布式时序数据库。针对不同的数据处理需求，在底层架构上天然上与通常的关系型数据库不同。所以需要有以下限制：

• DolphinDB 的表没有主键设计，需要设置成 sortColumn 字段，并设置 keepDuplicates = LAST 来进行去重，确保数据唯一。
• DolphinDB 表采用 TSDB 引擎，才可以设置 sortColumn。
• DolphinDB 中 TSDB 引擎的 sortColumn 中必须要有时间列或者数字列，对应的来源主键则必须包含同样类型字段。
• DolphinDB 中 TSDB 引擎的 sortColumn 中必须要有至少两个字段，才能设置 keepDuplicates = LAST，所以对应的来源表主键必须是 2 个字段及以上。

2. DDL 语句相关：

• 当前不支持 DDL 语句同步。
• 当前不支持同时修改两边表后的数据传递。

部署检查

1. 查看当前服务是否都在运行状态：

sudo systemctl list-units |egrep 'zookeeper|kafka-server|schema-registry|kafka-connect'

也可以使用 Jps 等其他方法快速查看 Java 进程。

2. 运行以下命令查看当前的同步任务列表查询：

查看当前有哪些同步任务：

./rest.sh list

3. 查看某个同步任务的状态：

./rest.sh status ddb-sink

4. 暂停同步任务，该操作会停止当前整体 connector 同步任务：

./rest.sh c_pause ddb-sink

5. 恢复同步任务：

./rest.sh c_resume ddb-sink

对于曾经由于数据库报错一度暂停的同步任务，在错误消除后，只要 connector 运行正常，可以通过以下命令使其恢复同步：

./rest.sh t_restart ${connector_name} ${task_id}

6. 修改同步任务配置参数：

./rest c_alter ${connector_name} @source_config.json

修改参数时，只需传递参数，不需要带有 connector name，格式示例如下：

数据同步情况检查

正常情况下，数据同步程序会保持稳定的数据同步。对于意外因素造成的数据未同步，可参考以下步骤逐一排查：

1. 查看 MySQL 中binlog中记录的最新位置。

查看该值需要正确的配置 gtid_mode 等参数，按照前面的提供的 MySQL 参数配置既可。

SHOW MASTER STATUS;

查看 MySQL 中的 binlog 具体数据库更改。 可以通过 mysqlbinglog 命令查看 MySQL 的 binlog 中记录的数据库改变。

./mysqlbinlog --base64-output=decode-rows -v --skip-gtids /usr/local/mysql/data/binlog.000003|less

2. 查看 Kafka 中记录的 MySQL 同步的 binlog 位置。

结合前面查看的 MySQL 最新 binlog 位置，可以确定当前数据从 MySQL 到 Kafka 的同步进度。

./consume.sh --topic connect-offsets --from-beginning |grep basicinfo-connector

查看 Kafka 中数据， Kafka 中的数据是已序列化的二进制存储。需要使用 avro 调用 schema-registry 中的表结构信息及进行反序列化。这里我们提供了 tpconsumer.sh 脚本，可以提供反序列化后的 Kafka 中的真实数据，并匹配上该条数据对应的表结构。

./tpconsumer.sh --op=2 --topic=mysqlserver.basicinfo.index_components --offset=1 --max-messages=2

3. 查看当前 DolphinDB 同步任务列表。

下面命令可以查看当前 Kafka 中的消费组。

./kafka.sh cm_list

查看 DolphinDB 同步任务对应的 Kafka 消费组中的每一个 consumer 的消费进度，通过此命令可以查看同步程序中每一张的表同步进度。 Lag 为 0 则表示 Kafka 中 topic 当前没有未消费的数据，即 Kafka 中的数据与对应表的数据是一致的。

./kafka.sh cm_detail connect-ddb-sink|awk '{printf "%-20s %-40s %-9s %-14s %-15s %-10s %-30s\n", $1, $2, $3, $4, $5, $6,$7}'

附录

KFDATA.tar 压缩包包含：数据的同步数据文件夹、配置文件及 Kafka-tools 脚本。

商汤科技创始人汤晓鸥离世，享年 55 岁 2023 年，PHP 停滞不前 Wi-Fi 7 将于 2024 年初全面登场，速度比 Wi-Fi 6 提升 5 倍 鸿蒙系统即将走向独立，多家高校设立“鸿蒙班” 稚晖君创业公司再融资，金额超 6 亿元，投前估值 35 亿元 夸克浏览器 PC 版开启内测 AI 代码助手盛行，编程语言排行榜都没法做了 Mate 60 Pro 的 5G 调制解调器和射频技术遥遥领先 MariaDB 拆分 SkySQL，作为独立公司成立 小米回应余承东“龙骨转轴”抄袭华为言论

{{o.name}}

{{m.name}}