Introducción La captura de datos de cambio (CDC) es una técnica que identifica y registra todos los cambios (inserciones, actualizaciones y eliminaciones) realizados en una fuente de datos, como una base de datos relacional, y transmite estos cambios a otros sistemas, lo que permite la sincronización en tiempo real. Este enfoque es fundamental para muchas arquitecturas de datos modernas que requieren información actualizada y consistente en distintos sistemas.
Beneficios CDC aporta una serie de beneficios que van más allá del simple movimiento de datos. Los principales beneficios se pueden ver en la lista a continuación.
Reducción de la carga en el sistema de origen al capturar solo los cambios y evitar lecturas masivas de datos, lo que resulta en menores costos de infraestructura.
Replicación de datos en tiempo real, eliminando la latencia que normalmente existe en los procesos ETL tradicionales.
Capacidad de realizar un seguimiento de los cambios para auditoría, realización de copias de seguridad y reprocesamiento en otras plataformas.
Actualizaciones continuas de lagos de datos y almacenes de datos, alimentando los sistemas analíticos con datos actuales.
Técnicas principales La implementación del CDC se puede llevar a cabo de diferentes maneras, cada una con ventajas y limitaciones específicas. Conocer estas alternativas ayuda a seleccionar la solución más adecuada al contexto de cada organización. A continuación se presentan las técnicas más habituales.
Lectura de registros de transacciones: captura los cambios directamente de los registros de transacciones, un método utilizado por herramientas como Debezium.
Columnas de marca de tiempo: uso de una columna que registra la última modificación en cada fila. Ideal para sistemas que no tienen registros transaccionales detallados.
Desencadenantes: uso de desencadenadores para registrar cambios en las tablas, aunque esto puede afectar el rendimiento.
Diferenciación de instantáneas: compara instantáneas tomadas periódicamente. Es un enfoque más pesado y menos preciso.
Técnicas de Binlog (registro de transacciones) El binlog, o registro de transacciones, es un archivo que registra todas las operaciones realizadas en la base de datos. Las bases de datos como MySQL (binlog) y PostgreSQL (WAL) tienen registros transaccionales que pueden monitorearse en tiempo real para capturar cambios. Este enfoque es eficiente y preciso porque captura cada cambio realizado en los datos, pero requiere acceso a los registros y permisos de lectura. La desventaja es que no todos los bancos tienen registros de transacciones tan detallados y la configuración puede requerir ajustes de infraestructura.
Columna de marca de tiempo Consiste en crear una columna que registra el último cambio realizado en cada fila de una tabla. Al consultar únicamente las filas modificadas desde la última ejecución, el sistema captura los cambios incrementales. Esta técnica es simple y aplicable a cualquier base de datos, pero no captura las eliminaciones de datos y requiere que todas las tablas monitoreadas incluyan esta columna.
Los activadores son funciones definidas en la base de datos que realizan acciones cuando ocurre un evento específico (como una inserción, actualización o eliminación). Con CDC, se pueden configurar activadores para registrar estos cambios en una tabla de historial. Si bien es eficiente, este método a menudo se evita debido a su impacto en el rendimiento y la complejidad del mantenimiento.
Diferencia entre instantáneas Consiste en crear instantáneas periódicas de los datos y compararlas para identificar cambios. Es un método laborioso y con mayor impacto en el sistema, ya que requiere un procesamiento intensivo, y sólo se utiliza cuando no se encuentran disponibles otros enfoques CDC.
Herramientas A continuación se muestran algunas de las principales herramientas de captura de datos de cambios del mercado.
Debezium: Herramienta de código abierto que utiliza registros de transacciones para capturar cambios en tiempo real. Admite bases de datos como MySQL, PostgreSQL, MongoDB y otras, y está integrado con Kafka, lo que facilita la transmisión de datos en canales de datos distribuidos.
Oracle GoldenGate: herramienta propietaria de Oracle para la replicación e integración de datos en tiempo real, compatible con múltiples sistemas de bases de datos.
StreamSets: Plataforma de integración que incluye componentes para CDC en diversas bases de datos y fuentes de datos.
Qlik Replicate (Attunity): Solución CDC robusta utilizada para la replicación y sincronización de datos entre bases de datos.
Amazon DMS y Azure Data Factory: soluciones CDC ofrecidas en sus respectivas plataformas de nube para la replicación y sincronización de datos entre servicios.
Airbyte: Airbyte es una plataforma de integración de datos de código abierto que admite CDC a través de varios conectores, incluido el monitoreo de registros de transacciones para bases de datos como MySQL y PostgreSQL. Es una opción flexible y escalable, con una interfaz fácil de usar que facilita la creación de canales de datos. Airbyte cuenta con una amplia librería de conectores y destaca por su comunidad activa y posibilidades de personalización.
Striim: Striim es una plataforma de integración de datos en tiempo real que combina CDC con análisis de transmisión y procesamiento de eventos. Admite múltiples fuentes de datos, como bases de datos relacionales, y puede transmitir datos a múltiples plataformas, incluidas nubes como AWS, Azure y Google Cloud. Su arquitectura robusta permite la replicación de datos a gran escala y el procesamiento en tiempo real, lo que la hace popular para casos de uso que requieren información instantánea de los datos.
Si bien existen muchas herramientas, en este artículo nos centraremos en Debezium, una popular opción de código abierto creada sobre Kafka Connect, para ilustrar una implementación práctica.
Kafka Connector Kafka Connector es una característica fundamental de Kafka Connect, una herramienta de la plataforma Apache Kafka diseñada para simplificar y automatizar la integración entre Kafka y otros sistemas, como bases de datos, almacenes de datos, sistemas de almacenamiento en la nube y más. Kafka Connect funciona como una capa de integración distribuida y escalable que utiliza conectores especializados para transferir datos de manera confiable entre sistemas.
Cómo funciona Kafka Connect Kafka Connect utiliza conectores, que son complementos especializados para cada tipo de sistema o fuente de datos, divididos en dos categorías: Conectores de fuente: capturan datos de una fuente externa y los publican en temas de Kafka.
Conectores de sumidero: consumen datos de temas de Kafka y los escriben en un sistema de destino.
Los conectores se configuran mediante archivos de configuración JSON o API REST, donde puede definir la fuente o el destino de los datos, la información de autenticación, la configuración de replicación y las transformaciones opcionales para adaptar los datos al formato deseado.
Arquitectura de Kafka Connect La arquitectura de Kafka Connect se compone de trabajadores, que son instancias que ejecutan conectores de manera distribuida. Esto permite a Kafka Connect: escalar horizontalmente a medida que aumenta la carga de datos.
Sea tolerante a los fallos: si un trabajador falla, otro puede tomar el relevo. Centralice la configuración y supervisión del conector.
Los datos se procesan en bloques llamados tareas, que distribuyen la carga de trabajo entre los trabajadores y permiten el procesamiento paralelo.
"No todo es color de rosa" (limitaciones) Opciones limitadas Hay menos de 20 tipos diferentes de conectores en Kafka Connect. Si un conector genérico no es adecuado, deberá desarrollar uno personalizado. De manera similar, Kafka Connect solo proporciona un conjunto básico de transformaciones, y es posible que también tengas que escribir tus propias transformaciones personalizadas. Esto puede aumentar el tiempo y el esfuerzo necesarios para la implementación.
Complejidad de configuración Las configuraciones de Kafka Connect se vuelven complejas rápidamente, especialmente cuando se trata de múltiples conectores, tareas y transformaciones. Esto puede dificultar la administración, el mantenimiento y la resolución de problemas del sistema. También es un desafío integrar Kafka Connect con otras herramientas que su organización pueda ya estar utilizando. Esto crea una barrera para la adopción y ralentiza el proceso de implementación.
Soporte limitado para manejo de errores El enfoque principal de Kafka es la transmisión de datos, lo que genera capacidades limitadas de manejo de errores integradas. La naturaleza distribuida y las posibles interdependencias entre los distintos componentes de Kafka aumentan la complejidad, lo que dificulta descubrir la causa raíz de un error. Es posible que tenga que implementar mecanismos de manejo de errores personalizados, lo que puede llevar mucho tiempo y no siempre ser tan confiable como las capacidades integradas que ofrecen otras herramientas ETL e integración de datos.
La recuperación elegante de errores complejos también es un desafío en Kafka, ya que puede no haber un camino claro para reanudar el procesamiento de datos después de que ocurre un error. Esto puede generar ineficiencias y requerir más intervención manual para restablecer las operaciones normales.
Problemas de rendimiento La mayoría de las aplicaciones requieren canales de datos de alta velocidad para casos de uso en tiempo real. Sin embargo, dependiendo del tipo de conector y del volumen de datos, Kafka Connect puede introducir cierta latencia en su sistema. Esto puede no ser adecuado si su aplicación no tolera retrasos.
"Pero hay una solución" (mejores prácticas) Incluso con estas limitaciones, sería incorrecto decir que Kafka Connect no es una buena opción; tiene numerosos beneficios que superan ampliamente sus limitaciones.
Kafka Connect es una herramienta poderosa para crear canales de datos escalables, pero para garantizar una implementación y una adopción operativa exitosas es necesario seguir las mejores prácticas. A continuación se ofrecen algunos consejos y sugerencias para evitar errores y lograr el éxito con Kafka Connect.
Planifique su canalización Antes de comenzar el proceso de implementación, determine las fuentes y los destinos de sus datos y asegúrese de que su canalización sea escalable y pueda manejar volúmenes de datos crecientes. Además, asegúrese de aprovisionar la infraestructura adecuadamente. Kafka Connect requiere una infraestructura escalable y confiable para un rendimiento óptimo. Utilice una arquitectura basada en clústeres con recursos suficientes para manejar la carga del flujo de datos y garantizar que su infraestructura tenga alta disponibilidad.
Utilizar un registro de esquemas El uso de un registro de esquemas en Kafka Connect puede ser beneficioso porque permite el almacenamiento y la gestión centralizados de esquemas. Esto ayuda a mantener la coherencia del esquema en todos los sistemas, reduce la probabilidad de corrupción de datos y simplifica la evolución del esquema.
Configurar para el rendimiento Es importante diseñar y configurar Kafka Connect para lograr una escala y un rendimiento futuros. Por ejemplo, puede implementar una estrategia de partición adecuada para distribuir sus datos de manera uniforme entre las particiones. Esto ayudará a que su clúster de Kafka Connect administre un gran volumen de datos de manera efectiva. Asimismo, puede utilizar un formato de serialización eficiente como Avro o Protobuf para transferirlo más rápido a través de la red.
Monitoreo El monitoreo es esencial para garantizar el buen funcionamiento de su canal de datos. Utilice herramientas de monitoreo para rastrear el rendimiento de su implementación de Kafka Connect e identificar y resolver rápidamente cualquier problema.
Opciones de monitoreo de Kafka Connect: Prometheus + Grafana Confluent Control Center Lenses.io Elastic Stack (ELK) Metrics Kafka Connect API Dead Letter Topic (DLT) También puede considerar implementar un Dead Letter Topic (DLT) como una red de seguridad para capturar y manejar cualquier mensaje que falle repetidamente durante los reintentos, asegurando que no se pierdan y además de eso, construir una estrategia de reprocesamiento para todos los mensajes DLT.
Debezium Debezium es una plataforma CDC de código abierto construida sobre Kafka Connect. Lee directamente los registros de transacciones de la base de datos, captura los cambios en tiempo real y publica estos eventos en los temas de Kafka. Esto permite la integración de estos datos con múltiples consumidores y facilita el desarrollo de canales de datos en tiempo real.
Arquitectura Debezium se ejecuta como un conector de Kafka Connect y utiliza un conector específico para cada tipo de base de datos. Cuando está configurado, Debezium lee los registros de transacciones y transmite los cambios a los temas en Kafka, donde los consumidores pueden acceder a estos eventos. Este proceso permite que Debezium sea altamente escalable y fácil de integrar con otras aplicaciones y sistemas.
Beneficios de Debezium: Código abierto y flexible: ser gratuito y extensible.
Escalable con Kafka: ideal para sistemas distribuidos y de alta demanda.
Consistencia y confiabilidad: captura cambios sin intervenir en la estructura de datos.
Transformaciones de Debezium (SMT) Las transformaciones de mensaje único (SMT) en Debezium son transformaciones que se pueden aplicar a mensajes individuales durante el procesamiento de captura de datos modificados (CDC). Estas transformaciones ocurren después de leer los datos de la fuente y antes de escribirlos en el sistema kafka o de destino.
Tipos de transformación Transformaciones de enrutamiento Le permiten modificar la forma en que se enrutan los mensajes dentro del sistema.
RegexRouter: modifica el tema de destino mediante expresiones regulares ByteBufferConverter: convierte campos entre diferentes formatos de bytes TopicRouter: redirecciona mensajes a temas específicos según condiciones Transformaciones de contenido Modifica el contenido de los mensajes.
ExtractField: Extrae un campo específico del mensaje InsertField: Agrega campos estáticos o dinámicos ReplaceField: Reemplaza valores de campos existentes MaskField: Enmascara datos confidenciales DropFields: Elimina campos específicos Transformaciones de valores Cambia valores dentro de los mensajes.
ValueToKey: Mueve un valor a la clave del mensaje ValueToTimestamp: Convierte un campo en una marca de tiempo Cast: Convierte tipos de datos TimestampConverter: Convierte formatos de marca de tiempo Transformaciones estructurales Modifica la estructura de los mensajes.
Flatten: convierte estructuras anidadas en estructuras planas HoistField: eleva campos anidados al nivel superior WrapField: encapsula campos en una nueva estructura Casos de uso comunes Enmascaramiento de datos confidenciales { "transforms": "maskFields", "transforms.maskFields.type": "org.apache.kafka.connect.transforms.MaskField$Value", "transforms.maskFields.fields": "creditCard,ssn", "transforms.maskFields.replacement": "****" } 2. Cambio de nombre de campo { "transforms": "RenameField", "transforms.RenameField.type": "org.apache.kafka.connect.transforms.ReplaceField$Value", "transforms.RenameField.renames": "oldName:newName" } 3. Adición de metadatos { "transforms": "insertSourceDetails", "transforms.insertSourceDetails.type": "org.apache.kafka.connect.transforms.InsertField$Value", "transforms.insertSourceDetails.static.field": "source_database", "transforms.insertSourceDetails.static.value": "production_db" } Consideraciones de rendimiento Orden de ejecución: las transformaciones se ejecutan en el orden en que se enumeran Impacto en el rendimiento: cada transformación agrega sobrecarga de procesamiento Complejidad: las transformaciones complejas pueden afectar la latencia Mejores prácticas Minimizar las transformaciones: usar solo las transformaciones necesarias Orden eficiente: priorizar las transformaciones más selectivas Monitoreo: monitorear el impacto de las transformaciones en el rendimiento Pruebas: validar las transformaciones en un entorno de desarrollo Documentación: mantener una documentación clara de las transformaciones aplicadas Limitaciones Algunas transformaciones pueden no conservar los tipos de datos originales Las transformaciones complejas pueden afectar la garantía del orden de los mensajes No todas las transformaciones son compatibles entre sí Algunas transformaciones pueden no funcionar con todos los formatos de serialización Recomendaciones de uso 1. Análisis de requisitos Identificar claramente las necesidades de transformación Evaluar el impacto en el sistema en su conjunto 2. Implementación Comenzar con transformaciones simples Probar cada transformación individualmente Documentar todas las transformaciones aplicadas 3. Mantenimiento Supervisar el rendimiento regularmente Revisar periódicamente la necesidad de cada transformación Mantener las transformaciones actualizadas con las nuevas versiones de Debezium Casos de uso CDC se puede aplicar en una variedad de escenarios para optimizar la integración y replicación de datos en tiempo real, algunos de los cuales se mencionan a continuación.
Patrón de bandeja de salida (monitorea y reenvía eventos a un Kafka (p. ej.), garantizando que los mensajes se publiquen, incluso con fallas, y desacoplando la lógica de la entrega de mensajes). Duplicación de datos (migración de monolito -> microservicio) Replicación de datos (integración/microservicios -> microservicios) Auditoría de datos Análisis en tiempo real (paneles e informes en tiempo real) Almacenamiento en caché de datos (almacenamiento en caché de ciertos datos de Postgres en Redis, por ejemplo) Datos para consulta (hacer que los datos estén disponibles en un motor de búsqueda como ElasticSearch) CQRS (hacer que los datos de comando estén disponibles en las fuentes de datos de consulta), etc.
Uso práctico de la infraestructura de Debezium Preparación Asegúrese de que Docker y Docker Compose estén instalados y en ejecución, ya que necesitaremos cargar Kafka, Zookeeper, Debezium Connector y la base de datos.
Creando Docker Compose Cree un archivo docker-compose.yml con el siguiente contenido: version: '3.8' services: postgres: image: debezium/postgres:16 ports: - "5433:5432" environment: - POSTGRES_DB=inventory - POSTGRES_USER=postgres - POSTGRES_PASSWORD=postgres command: postgres -c wal_level=logical networks: debezium-network: aliases: - postgres zookeeper: image: confluentinc/cp-zookeeper:7.5.0 ports: - "2181:2181" environment: ZOOKEEPER_CLIENT_PORT: 2181 ZOOKEEPER_TICK_TIME: 2000 networks: debezium-network: aliases: - zookeeper kafka: image: confluentinc/cp-kafka:7.5.0 depends_on: - zookeeper ports: - "9092:9092" entorno: ID_DE_BROKER_KAFKA: 1 CONEXIÓN_ZOOKEEPER_KAFKA: zookeeper:2181 OYENTES_ANUNCIADOS_KAFKA: INTERNO://kafka:9093, EXTERNO://localhost:9092 MAPA_DE_PROTOCOLO_DE_SEGURIDAD_DE_OYENTES_KAFKA: INTERNO:PLAINTEXT, EXTERNO:PLAINTEXT OYENTES_KAFKA: INTERNO://0.0.0.0:9093, EXTERNO://0.0.0.0:9092 NOMBRE_DE_OYENTE_INTER_BROKER_KAFKA: INTERNO FACTOR_DE_REPLICACIÓN_DE_TEMA_DESPLAZAMIENTOS_KAFKA: 1 redes: debezium-network: alias: - kafka kafka-connect: imagen: debezium/connect:2.5 puertos: - "8083:8083" depende de: - kafka - postgres entorno: SERVIDORES BOOTSTRAP: kafka:9093 ID DE GRUPO: 1 TEMA DE ALMACENAMIENTO DE CONFIGURACIÓN: configuraciones de conexión TEMA DE ALMACENAMIENTO DE DESPLAZAMIENTO: desplazamientos de conexión TEMA DE ALMACENAMIENTO DE ESTADO: estados de conexión CONVERSOR DE CLAVE: org.apache.kafka.connect.json.JsonConverter CONVERSOR DE VALOR: org.apache.kafka.connect.json.JsonConverter HABILITAR ESQUEMAS DE CONVERSOR DE CLAVE DE CONEXIÓN: "falso" HABILITAR ESQUEMAS DE CONVERSOR DE VALOR DE CONEXIÓN: "falso" NOMBRE DE HOST ANUNCIADO DE REST DE CONEXIÓN: kafka-connect redes: debezium-network: alias: - kafka-connect redes: debezium-network: controlador: puente Ejecutando los servicios En la carpeta donde se creó docker-compose.yml, ejecute (en la terminal): # dependiendo de cómo se instaló su docker, # deberá usar 'sudo' antes del comando docker compose up Configuración del conector de Debezium Envíe una configuración JSON al punto final REST de Kafka Connect para configurar el conector de Debezium: # 1. Primero, verifique si Debezium Connect se está ejecutando: curl -X GET http://localhost:8083/connectors # 2. Creando el conector # 2.1. Comando principal para crear el conector (SIN transformación / empezar con esto): curl -X POST http://localhost:8083/connectors\-H "Content-Type: application/json"\-d '{ "name": "inventory-clientes-connector", "config": { "connector.class": "io.debezium.connector.postgresql.PostgresConnector", "database.hostname": "postgres", "database.port": "5433", "database.user": "postgres", "database.password": "postgres", "database.dbname": "inventory", "database.server.name": "dbserver1", "table.include.list": "public.clientes", "topic.prefix": "inventory", "schema.include.list": "public", "decimal.handling.mode": "precise", "plugin.name": "pgoutput" } }' # 2.2. Comando principal para crear el conector (transformación COM): curl -X POST http://localhost:8083/connectors \ -H "Content-Type: application/json" \ -d '{ "name": "inventory-clientes-connector", "config": { "connector.class": "io.debezium.connector.postgresql.PostgresConnector", "database.hostname": "postgres", "database.port": "5433", "database.user": "postgres", "database.password": "postgres", "database.dbname": "inventory", "database.server.name": "dbserver1", "table.include.list": "public.clientes", "topic.prefix": "inventory", "schema.include.list": "public", "decimal.handling.mode": "precise", "plugin.name": "pgoutput", "transforms": "unwrap", "transforms.unwrap.type": "io.debezium.transforms.ExtractNewRecordState", "transforms.unwrap.drop.tombstones": "false", "transforms.unwrap.delete.handling.mode": "rewrite" } }' # Ejemplo de configuración de un conector Sink para Redis curl -X POST http://localhost:8083/connectors \ -H "Content-Type: application/json" \ -d '{ "name": "redis-sink", "config": { "connector.class": "com.github.jcustenborder.kafka.connect.redis.RedisSinkConnector", "redis.hosts": "redis:6379", "topics": "inventory.public.clientes", "tasks.max": "1", "key.converter": "org.apache.kafka.connect.json.JsonConverter", "valor.convertidor": "org.apache.kafka.connect.json.JsonConverter", "clave.convertidor.schemas.enable": "verdadero", "valor.convertidor.schemas.enable": "verdadero" } }' # 3. Para comprobar el estado del conector: curl -X GET http://localhost:8083/connectors/inventory-clientes-connector/status Explicación del parámetro: name: Nombre del conector, utilizado para la administración (se puede personalizar).
connector.class: especifica el conector de Debezium para PostgreSQL (io.debezium.connector.postgresql.PostgresConnector).
task.max: Número máximo de tareas paralelas para el conector (puede aumentar dependiendo de la carga).
database.hostname: Dirección del servidor PostgreSQL.
database.port: Puerto en el que se ejecuta PostgreSQL (el valor predeterminado es 5432).
database.user y database.password: Nombre de usuario y contraseña para acceder a la base de datos (el usuario necesita permisos para leer los registros de transacciones).
database.dbname: Nombre de la base de datos a monitorear.
database.server.name: Nombre lógico del servidor; se utilizará como prefijo para los temas de Kafka creados para las tablas.
slot.name: Nombre de la ranura de replicación. Esto cambia los datos en tiempo real mediante la replicación lógica.
plugin.name: define el complemento de replicación lógica. Para PostgreSQL 10+ y Debezium, se recomienda pgoutput.
table.include.list: Lista de tablas a monitorear (en formato schema.table). Si desea supervisar varias tablas, puede separar los nombres con comas.
publication.name: Nombre de la publicación de replicación lógica que captura los cambios en la tabla especificada. database.history.kafka.bootstrap.servers: dirección de Kafka donde se almacenará el historial del esquema, esencial para que Debezium comprenda la estructura de la tabla y los cambios del esquema.
database.history.kafka.topic: Tema de Kafka donde se almacenará el historial del esquema.
Supervisión de cambios kafka-console-consumer Herramienta de pila de Kafka para consumir temas directamente en la consola.
# Consumidor de consola: comprobar mensajes en el tema sudo docker exec -it cdc-kafka kafka-console-consumer \ --bootstrap-server localhost:9092 \ --topic inventory.public.clientes \ --from-beginning Plugin Big Data Tools para IntelliJ Provectus Kafka UI GitHub - provectus/kafka-ui: Interfaz de usuario web de código abierto para la gestión de Apache Kafka kafka-ui: imagen: provectuslabs/kafka-ui:latest container_name: cdc-kafka-ui puertos: - 8080:8080 depende_de: - kafka environment: DYNAMIC_CONFIG_ENABLED: 'true' redes: debezium-network: alias: - kafka-ui "Ver cómo sucede la magia" Crear la tabla -- Crear la tabla CREATE TABLE inventory.public.clientes ( SERIAL PRIMARY KEY id, name VARCHAR(50), email VARCHAR(50), data_criacao TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- Comprueba si hay datos SELECT * FROM inventory.public.clientes; Conectando el consumidor Puedes conectar el consumidor predeterminado de Kafka para consumir mensajes tan pronto como ingresan al tema: # Consumidor de consola: verifica los mensajes en el tema sudo docker exec -it cdc-kafka kafka-console-consumer \ --bootstrap-server localhost:9092 \ --topic inventory.public.clientes \ --from-beginning O usa una de las herramientas mencionadas arriba (complemento IntelliJ o Kafka UI).
Probando cómo funciona Insertando datos INSERT INTO inventario.public.clientes (nombre, correo electrónico) VALUES ('João Silva 1', 'joao1@email.com'); INSERT INTO inventario.public.clientes (nombre, correo electrónico) VALORES ('João Silva 2', 'joao2@email.com'); INSERT INTO inventario.public.clientes (nombre, correo electrónico) VALORES ('João Silva 3', 'joao3@email.com'); Actualizando datos ACTUALIZAR inventario.public.clientes SET nombre = 'Pedro Silva', correo electrónico = 'pedro.silva@email.com' WHERE id = 1; ACTUALIZAR inventario.public.clientes SET nombre = 'José Silva', correo electrónico = 'jose.silva@email.com' DONDE id = 2; Eliminar datos -- Elimina el registro DELETE FROM inventory.public.clientes WHERE id = 1; DELETE FROM inventory.public.clientes WHERE id = 2; DELETE FROM inventory.public.clientes WHERE id = 3; Cambiar la cantidad de información de replicación -- Cambia la cantidad de información que está disponible para la decodificación lógica en caso de eventos UPDATE y DELETE. ALTER TABLE inventory.public.clientes REPLICA IDENTITY FULL; Vuelva a ejecutar las pruebas (insertar, actualizar y eliminar) después de ajustar el nivel de replicación.
Solución de problemas # Visualización de los registros sudo docker compose --file debezium-docker-compose.yml logs kafka sudo docker compose --file debezium-docker-compose.yml logs zookeeper sudo docker compose --file debezium-docker-compose.yml logs postgres sudo docker compose --file debezium-docker-compose.yml logs kafka-connect # Inspeccionando la red sudo docker network inspect debezium-network Conclusión La captura de datos de cambios es una técnica ampliamente utilizada por el mercado, en sus diversas modalidades, en sus diversas herramientas. Es especialmente útil en migraciones de datos y sistemas, facilitando la limitación de un monolito o replicando algunos datos de un microservicio a otro, o simplemente aplicado al patrón Bandeja de salida.
En este escenario, Debezium se presenta como una gran herramienta para ello, basada en la plataforma Connect de Kafka, ya probada y comprobada. Pero como en cualquier escenario, tiene sus puntos de atención, riesgos y desventajas.