ಅಪಾಚೆ ಕಾಫ್ಕಾಗಾಗಿ ಡೆಬೆಜಿಯಮ್ - ಸಿಡಿಸಿ ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ

ನನ್ನ ಕೆಲಸದಲ್ಲಿ, ನಾನು ಆಗಾಗ್ಗೆ ಹೊಸ ತಾಂತ್ರಿಕ ಪರಿಹಾರಗಳು / ಸಾಫ್ಟ್‌ವೇರ್ ಉತ್ಪನ್ನಗಳನ್ನು ನೋಡುತ್ತೇನೆ, ರಷ್ಯಾದ ಮಾತನಾಡುವ ಇಂಟರ್ನೆಟ್‌ನಲ್ಲಿ ಅದರ ಬಗ್ಗೆ ಮಾಹಿತಿಯು ವಿರಳವಾಗಿದೆ. ಈ ಲೇಖನದೊಂದಿಗೆ, ನನ್ನ ಇತ್ತೀಚಿನ ಅಭ್ಯಾಸದಿಂದ ಅಂತಹ ಒಂದು ಅಂತರವನ್ನು ತುಂಬಲು ನಾನು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ, ನಾನು ಎರಡು ಜನಪ್ರಿಯ DBMS ಗಳಿಂದ (PostgreSQL ಮತ್ತು MongoDB) Debezium ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ಗೆ CDC ಈವೆಂಟ್‌ಗಳನ್ನು ಕಳುಹಿಸಲು ಹೊಂದಿಸಲು ಅಗತ್ಯವಿದ್ದಾಗ. ಮಾಡಿದ ಕೆಲಸದ ಪರಿಣಾಮವಾಗಿ ಕಾಣಿಸಿಕೊಂಡ ಈ ವಿಮರ್ಶೆ ಲೇಖನವು ಇತರರಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ಸಾಮಾನ್ಯವಾಗಿ Debezium ಮತ್ತು CDC ಎಂದರೇನು?

ಡೆಬೆಜಿಯಮ್ - CDC ಸಾಫ್ಟ್‌ವೇರ್ ವರ್ಗದ ಪ್ರತಿನಿಧಿ (ಡೇಟಾ ಬದಲಾವಣೆಯನ್ನು ಸೆರೆಹಿಡಿಯಿರಿ), ಅಥವಾ ಹೆಚ್ಚು ನಿಖರವಾಗಿ, ಇದು ಅಪಾಚೆ ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುವ ವಿವಿಧ DBMS ಗಳಿಗೆ ಕನೆಕ್ಟರ್‌ಗಳ ಒಂದು ಸೆಟ್ ಆಗಿದೆ.

ಈ ಮುಕ್ತ ಮೂಲ ಯೋಜನೆ, Apache ಪರವಾನಗಿ v2.0 ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿ ಪಡೆದಿದೆ ಮತ್ತು Red Hat ಪ್ರಾಯೋಜಿಸಿದೆ. 2016 ರಿಂದ ಅಭಿವೃದ್ಧಿ ನಡೆಯುತ್ತಿದೆ ಮತ್ತು ಈ ಸಮಯದಲ್ಲಿ ಇದು ಕೆಳಗಿನ DBMS ಗೆ ಅಧಿಕೃತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ: MySQL, PostgreSQL, MongoDB, SQL ಸರ್ವರ್. ಕಸ್ಸಂದ್ರ ಮತ್ತು ಒರಾಕಲ್‌ಗಾಗಿ ಕನೆಕ್ಟರ್‌ಗಳು ಸಹ ಇವೆ, ಆದರೆ ಈ ಸಮಯದಲ್ಲಿ ಅವು "ಆರಂಭಿಕ ಪ್ರವೇಶ" ಸ್ಥಿತಿಯಲ್ಲಿವೆ ಮತ್ತು ಹೊಸ ಬಿಡುಗಡೆಗಳು ಹಿಂದುಳಿದ ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಾತರಿಪಡಿಸುವುದಿಲ್ಲ.

ನಾವು CDC ಅನ್ನು ಸಾಂಪ್ರದಾಯಿಕ ವಿಧಾನದೊಂದಿಗೆ ಹೋಲಿಸಿದರೆ (ಅಪ್ಲಿಕೇಶನ್ ನೇರವಾಗಿ DBMS ನಿಂದ ಡೇಟಾವನ್ನು ಓದಿದಾಗ), ನಂತರ ಅದರ ಮುಖ್ಯ ಅನುಕೂಲಗಳು ಕಡಿಮೆ ಸುಪ್ತತೆ, ಹೆಚ್ಚಿನ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ಲಭ್ಯತೆಯೊಂದಿಗೆ ಸಾಲು ಮಟ್ಟದಲ್ಲಿ ಡೇಟಾ ಬದಲಾವಣೆಯ ಸ್ಟ್ರೀಮಿಂಗ್ ಅನುಷ್ಠಾನವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಸಿಡಿಸಿ ಈವೆಂಟ್‌ಗಳಿಗಾಗಿ ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರೆಪೊಸಿಟರಿಯಾಗಿ ಬಳಸುವ ಮೂಲಕ ಕೊನೆಯ ಎರಡು ಅಂಕಗಳನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ.

ಅಲ್ಲದೆ, ಪ್ರಯೋಜನಗಳು ಈವೆಂಟ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಒಂದೇ ಮಾದರಿಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬ ಅಂಶವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಅಂತಿಮ ಅಪ್ಲಿಕೇಶನ್ ವಿಭಿನ್ನ DBMS ಅನ್ನು ನಿರ್ವಹಿಸುವ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ.

ಅಂತಿಮವಾಗಿ, ಸಂದೇಶ ಬ್ರೋಕರ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ ಡೇಟಾದಲ್ಲಿನ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಸಮತಲ ಸ್ಕೇಲಿಂಗ್‌ಗೆ ವ್ಯಾಪ್ತಿ ತೆರೆಯುತ್ತದೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಡೇಟಾ ಮೂಲದ ಮೇಲಿನ ಪ್ರಭಾವವನ್ನು ಕಡಿಮೆಗೊಳಿಸಲಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ಡೇಟಾವನ್ನು ನೇರವಾಗಿ DBMS ನಿಂದ ಸ್ವೀಕರಿಸಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ನಿಂದ ಪಡೆಯಲಾಗುತ್ತದೆ.

ಡೆಬೆಜಿಯಮ್ ವಾಸ್ತುಶಿಲ್ಪದ ಬಗ್ಗೆ

Debezium ಅನ್ನು ಬಳಸುವುದು ಈ ಸರಳ ಯೋಜನೆಗೆ ಬರುತ್ತದೆ:

DBMS (ಡೇಟಾ ಮೂಲವಾಗಿ) → ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್‌ನಲ್ಲಿ ಕನೆಕ್ಟರ್ → ಅಪಾಚೆ ಕಾಫ್ಕಾ → ಗ್ರಾಹಕ

ವಿವರಣೆಯಾಗಿ, ನಾನು ಯೋಜನೆಯ ವೆಬ್‌ಸೈಟ್‌ನಿಂದ ರೇಖಾಚಿತ್ರವನ್ನು ನೀಡುತ್ತೇನೆ:

ಹೇಗಾದರೂ, ನಾನು ಈ ಯೋಜನೆಯನ್ನು ನಿಜವಾಗಿಯೂ ಇಷ್ಟಪಡುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಸಿಂಕ್ ಕನೆಕ್ಟರ್ ಮಾತ್ರ ಸಾಧ್ಯ ಎಂದು ತೋರುತ್ತದೆ.

ವಾಸ್ತವದಲ್ಲಿ, ಪರಿಸ್ಥಿತಿ ವಿಭಿನ್ನವಾಗಿದೆ: ನಿಮ್ಮ ಡೇಟಾ ಲೇಕ್ ಅನ್ನು ತುಂಬುವುದು (ಮೇಲಿನ ರೇಖಾಚಿತ್ರದಲ್ಲಿ ಕೊನೆಯ ಲಿಂಕ್) Debezium ಅನ್ನು ಬಳಸುವ ಏಕೈಕ ಮಾರ್ಗವಲ್ಲ. ಅಪಾಚೆ ಕಾಫ್ಕಾಗೆ ಕಳುಹಿಸಲಾದ ಈವೆಂಟ್‌ಗಳನ್ನು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ವಿವಿಧ ಸಂದರ್ಭಗಳನ್ನು ಎದುರಿಸಲು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

• ಸಂಗ್ರಹದಿಂದ ಅಪ್ರಸ್ತುತ ಡೇಟಾವನ್ನು ತೆಗೆದುಹಾಕುವುದು;
• ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸುವುದು;
• ಹುಡುಕಾಟ ಸೂಚ್ಯಂಕ ನವೀಕರಣಗಳು;
• ಕೆಲವು ರೀತಿಯ ಆಡಿಟ್ ದಾಖಲೆಗಳು;
• ...

ನೀವು ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಬಳಸುವ ಅವಶ್ಯಕತೆ/ಸಾಧ್ಯತೆ ಇಲ್ಲದಿದ್ದರೆ, ಕೆಲಸ ಮಾಡುವ ಸಾಧ್ಯತೆಯೂ ಇದೆ ಎಂಬೆಡೆಡ್ ಕನೆಕ್ಟರ್. ಸ್ಪಷ್ಟವಾದ ಪ್ಲಸ್ ಅದರೊಂದಿಗೆ ನೀವು ಹೆಚ್ಚುವರಿ ಮೂಲಸೌಕರ್ಯವನ್ನು (ಕನೆಕ್ಟರ್ ಮತ್ತು ಕಾಫ್ಕಾ ರೂಪದಲ್ಲಿ) ನಿರಾಕರಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಆವೃತ್ತಿ 1.1 ರಿಂದ ಈ ಪರಿಹಾರವನ್ನು ಅಸಮ್ಮತಿಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಬಳಕೆಗೆ ಇನ್ನು ಮುಂದೆ ಶಿಫಾರಸು ಮಾಡಲಾಗುವುದಿಲ್ಲ (ಭವಿಷ್ಯದ ಬಿಡುಗಡೆಗಳಲ್ಲಿ ಇದನ್ನು ತೆಗೆದುಹಾಕಬಹುದು).

ಈ ಲೇಖನವು ಡೆವಲಪರ್‌ಗಳು ಶಿಫಾರಸು ಮಾಡಿದ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಚರ್ಚಿಸುತ್ತದೆ, ಇದು ದೋಷ ಸಹಿಷ್ಣುತೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಕನೆಕ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್

ಪ್ರಮುಖ ಮೌಲ್ಯದಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಲು - ಡೇಟಾ - ನಮಗೆ ಅಗತ್ಯವಿದೆ:

1. ಡೇಟಾ ಮೂಲ, ಇದು MySQL ಆಗಿರಬಹುದು ಆವೃತ್ತಿ 5.7, PostgreSQL 9.6+, MongoDB 3.2+ (ಪೂರ್ಣ ಪಟ್ಟಿ);
2. ಅಪಾಚೆ ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್
3. ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ ನಿದರ್ಶನ (ಆವೃತ್ತಿಗಳು 1.x, 2.x);
4. Debezium ಕನೆಕ್ಟರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ.

ಮೊದಲ ಎರಡು ಅಂಶಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡಿ, ಅಂದರೆ. DBMS ಮತ್ತು Apache Kafka ಅನ್ನು ಸ್ಥಾಪಿಸುವ ಪ್ರಕ್ರಿಯೆಯು ಲೇಖನದ ವ್ಯಾಪ್ತಿಯನ್ನು ಮೀರಿದೆ. ಆದಾಗ್ಯೂ, ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ನಿಯೋಜಿಸಲು ಬಯಸುವವರಿಗೆ, ಅಧಿಕೃತ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಸಿದ್ಧವಾದ ಒಂದು ಇದೆ. ಡಾಕರ್-compose.yaml.

ನಾವು ಕೊನೆಯ ಎರಡು ಅಂಶಗಳನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ.

0. ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್

ಇಲ್ಲಿ ಮತ್ತು ನಂತರ ಲೇಖನದಲ್ಲಿ, ಎಲ್ಲಾ ಕಾನ್ಫಿಗರೇಶನ್ ಉದಾಹರಣೆಗಳನ್ನು ಡೆಬೆಜಿಯಮ್ ಡೆವಲಪರ್‌ಗಳು ವಿತರಿಸಿದ ಡಾಕರ್ ಚಿತ್ರದ ಸಂದರ್ಭದಲ್ಲಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ಇದು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಪ್ಲಗಿನ್ ಫೈಲ್‌ಗಳನ್ನು (ಕನೆಕ್ಟರ್‌ಗಳು) ಒಳಗೊಂಡಿದೆ ಮತ್ತು ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.

ನೀವು ಸಂಗಮದಿಂದ ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ ಅನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ, ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೈರೆಕ್ಟರಿಗೆ ಅಗತ್ಯವಾದ ಕನೆಕ್ಟರ್‌ಗಳ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ನೀವೇ ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ. plugin.path ಅಥವಾ ಪರಿಸರ ವೇರಿಯಬಲ್ ಮೂಲಕ ಹೊಂದಿಸಲಾಗಿದೆ CLASSPATH. ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ ವರ್ಕರ್ ಮತ್ತು ಕನೆಕ್ಟರ್‌ಗಳ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳ ಮೂಲಕ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ಅದನ್ನು ವರ್ಕರ್ ಸ್ಟಾರ್ಟ್ ಕಮಾಂಡ್‌ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ರವಾನಿಸಲಾಗುತ್ತದೆ. ವಿವರಗಳಿಗಾಗಿ ನೋಡಿ ದಸ್ತಾವೇಜನ್ನು.

ಕನೆಕ್ಟರ್ ಆವೃತ್ತಿಯಲ್ಲಿ Debeizum ಅನ್ನು ಹೊಂದಿಸುವ ಸಂಪೂರ್ಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಎರಡು ಹಂತಗಳಲ್ಲಿ ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ. ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನು ಪರಿಗಣಿಸೋಣ:

1. ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಅಪಾಚೆ ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ಗೆ ಡೇಟಾವನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡಲು, ನಿರ್ದಿಷ್ಟ ನಿಯತಾಂಕಗಳನ್ನು ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ, ಅವುಗಳೆಂದರೆ:

• ಕ್ಲಸ್ಟರ್ ಸಂಪರ್ಕ ಸೆಟ್ಟಿಂಗ್‌ಗಳು,
• ಕನೆಕ್ಟರ್ನ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಸ್ವತಃ ಸಂಗ್ರಹಿಸಲಾಗುವ ವಿಷಯಗಳ ಹೆಸರುಗಳು,
• ಕನೆಕ್ಟರ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಗುಂಪಿನ ಹೆಸರು (ವಿತರಣಾ ಕ್ರಮವನ್ನು ಬಳಸುವ ಸಂದರ್ಭದಲ್ಲಿ).

ಪ್ರಾಜೆಕ್ಟ್‌ನ ಅಧಿಕೃತ ಡಾಕರ್ ಚಿತ್ರವು ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ - ಇದನ್ನೇ ನಾವು ಬಳಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ ಚಿತ್ರವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡೋಣ:

docker pull debezium/connect

ಕನೆಕ್ಟರ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವ ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳ ಕನಿಷ್ಠ ಸೆಟ್ ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

• BOOTSTRAP_SERVERS=kafka-1:9092,kafka-2:9092,kafka-3:9092 - ಕ್ಲಸ್ಟರ್ ಸದಸ್ಯರ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್ ಸರ್ವರ್‌ಗಳ ಆರಂಭಿಕ ಪಟ್ಟಿ;
• OFFSET_STORAGE_TOPIC=connector-offsets - ಕನೆಕ್ಟರ್ ಪ್ರಸ್ತುತ ಇರುವ ಸ್ಥಾನಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ವಿಷಯ;
• CONNECT_STATUS_STORAGE_TOPIC=connector-status - ಕನೆಕ್ಟರ್ನ ಸ್ಥಿತಿ ಮತ್ತು ಅದರ ಕಾರ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ವಿಷಯ;
• CONFIG_STORAGE_TOPIC=connector-config - ಕನೆಕ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್ ಡೇಟಾ ಮತ್ತು ಅದರ ಕಾರ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ವಿಷಯ;
• GROUP_ID=1 - ಕನೆಕ್ಟರ್ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕಾರ್ಮಿಕರ ಗುಂಪಿನ ಗುರುತಿಸುವಿಕೆ; ವಿತರಿಸಿದಾಗ ಬಳಸುವಾಗ ಅಗತ್ಯವಿದೆ (ವಿತರಣೆ) ಆಡಳಿತ

ನಾವು ಈ ಅಸ್ಥಿರಗಳೊಂದಿಗೆ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ:

docker run 
  -e BOOTSTRAP_SERVERS='kafka-1:9092,kafka-2:9092,kafka-3:9092' 
  -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  debezium/connect:1.2

Avro ಬಗ್ಗೆ ಗಮನಿಸಿ

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಡೆಬೆಜಿಯಂ JSON ಸ್ವರೂಪದಲ್ಲಿ ಡೇಟಾವನ್ನು ಬರೆಯುತ್ತದೆ, ಇದು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ಗಳು ಮತ್ತು ಸಣ್ಣ ಪ್ರಮಾಣದ ಡೇಟಾಗೆ ಸ್ವೀಕಾರಾರ್ಹವಾಗಿದೆ, ಆದರೆ ಹೆಚ್ಚು ಲೋಡ್ ಮಾಡಲಾದ ಡೇಟಾಬೇಸ್‌ಗಳಲ್ಲಿ ಸಮಸ್ಯೆಯಾಗಬಹುದು. JSON ಪರಿವರ್ತಕಕ್ಕೆ ಪರ್ಯಾಯವಾಗಿ ಸಂದೇಶಗಳನ್ನು ಧಾರಾವಾಹಿಯಾಗಿ ಬಳಸುವುದು ಆವ್ರೋ ಬೈನರಿ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ, ಇದು ಅಪಾಚೆ ಕಾಫ್ಕಾದಲ್ಲಿ I / O ಉಪವ್ಯವಸ್ಥೆಯ ಮೇಲಿನ ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

Avro ಬಳಸಲು, ನೀವು ಪ್ರತ್ಯೇಕ ನಿಯೋಜಿಸಲು ಅಗತ್ಯವಿದೆ ಸ್ಕೀಮಾ-ನೋಂದಾವಣೆ (ಸ್ಕೀಮಾಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದಕ್ಕಾಗಿ). ಪರಿವರ್ತಕಕ್ಕಾಗಿ ಅಸ್ಥಿರಗಳು ಈ ರೀತಿ ಕಾಣುತ್ತವೆ:

name: CONNECT_VALUE_CONVERTER_SCHEMA_REGISTRY_URL
value: http://kafka-registry-01:8081/
name: CONNECT_KEY_CONVERTER_SCHEMA_REGISTRY_URL
value: http://kafka-registry-01:8081/
name: VALUE_CONVERTER   
value: io.confluent.connect.avro.AvroConverter

Avro ಅನ್ನು ಬಳಸುವ ಮತ್ತು ಅದಕ್ಕೆ ನೋಂದಾವಣೆ ಹೊಂದಿಸುವ ವಿವರಗಳು ಲೇಖನದ ವ್ಯಾಪ್ತಿಯನ್ನು ಮೀರಿವೆ - ಮುಂದೆ, ಸ್ಪಷ್ಟತೆಗಾಗಿ, ನಾವು JSON ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

2. ಕನೆಕ್ಟರ್ ಅನ್ನು ಸ್ವತಃ ಹೊಂದಿಸುವುದು

ಈಗ ನೀವು ನೇರವಾಗಿ ಕನೆಕ್ಟರ್ನ ಕಾನ್ಫಿಗರೇಶನ್ಗೆ ಹೋಗಬಹುದು, ಅದು ಮೂಲದಿಂದ ಡೇಟಾವನ್ನು ಓದುತ್ತದೆ.

ಎರಡು DBMS ಗಾಗಿ ಕನೆಕ್ಟರ್‌ಗಳ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ: PostgreSQL ಮತ್ತು MongoDB, ಇದಕ್ಕಾಗಿ ನನಗೆ ಅನುಭವವಿದೆ ಮತ್ತು ಇದಕ್ಕಾಗಿ ವ್ಯತ್ಯಾಸಗಳಿವೆ (ಸಣ್ಣ, ಆದರೆ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಗಮನಾರ್ಹವಾಗಿದೆ!).

ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು JSON ಸಂಕೇತದಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ ಮತ್ತು ಪೋಸ್ಟ್ ವಿನಂತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗಿದೆ.

2.1. PostgreSQL

PostgreSQL ಗಾಗಿ ಉದಾಹರಣೆ ಕನೆಕ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್:

{
  "name": "pg-connector",
  "config": {
    "connector.class": "io.debezium.connector.postgresql.PostgresConnector",
    "plugin.name": "pgoutput",
    "database.hostname": "127.0.0.1",
    "database.port": "5432",
    "database.user": "debezium",
    "database.password": "definitelynotpassword",
    "database.dbname" : "dbname",
    "database.server.name": "pg-dev",
    "table.include.list": "public.(.*)",
    "heartbeat.interval.ms": "5000",
    "slot.name": "dbname_debezium",
    "publication.name": "dbname_publication",
    "transforms": "AddPrefix",
    "transforms.AddPrefix.type": "org.apache.kafka.connect.transforms.RegexRouter",
    "transforms.AddPrefix.regex": "pg-dev.public.(.*)",
    "transforms.AddPrefix.replacement": "data.cdc.dbname"
  }
}

ಈ ಸಂರಚನೆಯ ನಂತರ ಕನೆಕ್ಟರ್ನ ಕಾರ್ಯಾಚರಣೆಯ ತತ್ವವು ತುಂಬಾ ಸರಳವಾಗಿದೆ:

• ಮೊದಲ ಪ್ರಾರಂಭದಲ್ಲಿ, ಇದು ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾಬೇಸ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ ಮತ್ತು ಮೋಡ್‌ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಆರಂಭಿಕ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್, ಷರತ್ತುಗಳೊಂದಿಗೆ ಸ್ವೀಕರಿಸಿದ ಡೇಟಾದ ಆರಂಭಿಕ ಸೆಟ್ ಅನ್ನು ಕಾಫ್ಕಾಗೆ ಕಳುಹಿಸಲಾಗುತ್ತಿದೆ SELECT * FROM table_name.
• ಪ್ರಾರಂಭವು ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಕನೆಕ್ಟರ್ PostgreSQL WAL ಫೈಲ್‌ಗಳಿಂದ ಬದಲಾವಣೆಗಳನ್ನು ಓದುವ ವಿಧಾನವನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ.

ಬಳಸಿದ ಆಯ್ಕೆಗಳ ಬಗ್ಗೆ:

• name - ಕೆಳಗೆ ವಿವರಿಸಿದ ಸಂರಚನೆಯನ್ನು ಬಳಸುವ ಕನೆಕ್ಟರ್‌ನ ಹೆಸರು; ಭವಿಷ್ಯದಲ್ಲಿ, ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ REST API ಮೂಲಕ ಕನೆಕ್ಟರ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಈ ಹೆಸರನ್ನು ಬಳಸಲಾಗುತ್ತದೆ (ಅಂದರೆ ಸ್ಥಿತಿಯನ್ನು ವೀಕ್ಷಿಸಿ / ಮರುಪ್ರಾರಂಭಿಸಿ / ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನವೀಕರಿಸಿ);
• connector.class - ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಕನೆಕ್ಟರ್‌ನಿಂದ ಬಳಸಲಾಗುವ DBMS ಕನೆಕ್ಟರ್ ವರ್ಗ;
• plugin.name WAL ಫೈಲ್‌ಗಳಿಂದ ಡೇಟಾದ ತಾರ್ಕಿಕ ಡಿಕೋಡಿಂಗ್‌ಗಾಗಿ ಪ್ಲಗಿನ್‌ನ ಹೆಸರು. ಆಯ್ಕೆ ಮಾಡಲು ಲಭ್ಯವಿದೆ wal2json, decoderbuffs и pgoutput. ಮೊದಲ ಎರಡು DBMS ನಲ್ಲಿ ಸೂಕ್ತವಾದ ವಿಸ್ತರಣೆಗಳ ಸ್ಥಾಪನೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ ಮತ್ತು pgoutput PostgreSQL ಆವೃತ್ತಿ 10 ಮತ್ತು ಹೆಚ್ಚಿನವುಗಳಿಗೆ ಹೆಚ್ಚುವರಿ ಕುಶಲತೆಯ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ;
• database.* - ಡೇಟಾಬೇಸ್‌ಗೆ ಸಂಪರ್ಕಿಸುವ ಆಯ್ಕೆಗಳು, ಅಲ್ಲಿ database.server.name - ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ವಿಷಯದ ಹೆಸರನ್ನು ರೂಪಿಸಲು ಬಳಸಿದ PostgreSQL ನಿದರ್ಶನದ ಹೆಸರು;
• table.include.list - ನಾವು ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಯಸುವ ಕೋಷ್ಟಕಗಳ ಪಟ್ಟಿ; ರೂಪದಲ್ಲಿ ನೀಡಲಾಗಿದೆ schema.table_name; ಜೊತೆಯಲ್ಲಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ table.exclude.list;
• heartbeat.interval.ms - ಮಧ್ಯಂತರ (ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ) ಕನೆಕ್ಟರ್ ವಿಶೇಷ ವಿಷಯಕ್ಕೆ ಹೃದಯ ಬಡಿತ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ;
• heartbeat.action.query - ಪ್ರತಿ ಹೃದಯ ಬಡಿತ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸುವಾಗ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ವಿನಂತಿ (ಆವೃತ್ತಿ 1.1 ರಿಂದ ಆಯ್ಕೆಯು ಕಾಣಿಸಿಕೊಂಡಿದೆ);
• slot.name - ಕನೆಕ್ಟರ್‌ನಿಂದ ಬಳಸಲಾಗುವ ಪ್ರತಿಕೃತಿ ಸ್ಲಾಟ್‌ನ ಹೆಸರು;
• publication.name - ಹೆಸರು ಪ್ರಕಟಣೆಗಳು ಕನೆಕ್ಟರ್ ಬಳಸುವ PostgreSQL ನಲ್ಲಿ. ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಡೆಬೆಜಿಯಮ್ ಅದನ್ನು ರಚಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಸಂಪರ್ಕವನ್ನು ಹೊಂದಿರುವ ಬಳಕೆದಾರರು ಈ ಕ್ರಿಯೆಗೆ ಸಾಕಷ್ಟು ಹಕ್ಕುಗಳನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ಕನೆಕ್ಟರ್ ದೋಷದೊಂದಿಗೆ ನಿರ್ಗಮಿಸುತ್ತದೆ;
• transforms ಉದ್ದೇಶಿತ ವಿಷಯದ ಹೆಸರನ್ನು ಹೇಗೆ ನಿಖರವಾಗಿ ಬದಲಾಯಿಸುವುದು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ:
  • transforms.AddPrefix.type ನಾವು ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸುತ್ತೇವೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ;
  • transforms.AddPrefix.regex - ಉದ್ದೇಶಿತ ವಿಷಯದ ಹೆಸರನ್ನು ಮರು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮುಖವಾಡ;
  • transforms.AddPrefix.replacement - ನೇರವಾಗಿ ನಾವು ಮರುವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.

ಹೃದಯ ಬಡಿತ ಮತ್ತು ರೂಪಾಂತರಗಳ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಕನೆಕ್ಟರ್ ಪ್ರತಿ ಬದ್ಧ ವಹಿವಾಟಿಗೆ ಕಾಫ್ಕಾಗೆ ಡೇಟಾವನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು ಅದರ LSN (ಲಾಗ್ ಅನುಕ್ರಮ ಸಂಖ್ಯೆ) ಅನ್ನು ಸೇವಾ ವಿಷಯಕ್ಕೆ ಬರೆಯುತ್ತದೆ offset. ಆದರೆ ಕನೆಕ್ಟರ್ ಅನ್ನು ಸಂಪೂರ್ಣ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಓದಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದರೆ ಏನಾಗುತ್ತದೆ, ಆದರೆ ಅದರ ಕೋಷ್ಟಕಗಳ ಭಾಗವನ್ನು ಮಾತ್ರ (ಇದರಲ್ಲಿ ಡೇಟಾವನ್ನು ವಿರಳವಾಗಿ ನವೀಕರಿಸಲಾಗುತ್ತದೆ)?

• ಕನೆಕ್ಟರ್ WAL ಫೈಲ್‌ಗಳನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಅದರಲ್ಲಿನ ವಹಿವಾಟು ಬದ್ಧತೆಗಳನ್ನು ಅದು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಕೋಷ್ಟಕಗಳಿಗೆ ಪತ್ತೆ ಮಾಡುವುದಿಲ್ಲ.
• ಆದ್ದರಿಂದ, ಇದು ವಿಷಯ ಅಥವಾ ಪ್ರತಿಕೃತಿ ಸ್ಲಾಟ್‌ನಲ್ಲಿ ಅದರ ಪ್ರಸ್ತುತ ಸ್ಥಾನವನ್ನು ನವೀಕರಿಸುವುದಿಲ್ಲ.
• ಇದು ಪ್ರತಿಯಾಗಿ, WAL ಫೈಲ್‌ಗಳು ಡಿಸ್ಕ್‌ನಲ್ಲಿ "ಸ್ಟಕ್" ಆಗಲು ಕಾರಣವಾಗುತ್ತದೆ ಮತ್ತು ಡಿಸ್ಕ್ ಸ್ಥಳಾವಕಾಶದಿಂದ ಹೊರಗುಳಿಯಬಹುದು.

ಮತ್ತು ಇಲ್ಲಿ ಆಯ್ಕೆಗಳು ಪಾರುಗಾಣಿಕಾಕ್ಕೆ ಬರುತ್ತವೆ. heartbeat.interval.ms и heartbeat.action.query. ಜೋಡಿಯಾಗಿ ಈ ಆಯ್ಕೆಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಪ್ರತಿ ಬಾರಿ ಹೃದಯ ಬಡಿತದ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಿದಾಗ ಪ್ರತ್ಯೇಕ ಕೋಷ್ಟಕದಲ್ಲಿ ಡೇಟಾವನ್ನು ಬದಲಾಯಿಸಲು ವಿನಂತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ಕನೆಕ್ಟರ್ ಪ್ರಸ್ತುತ ಇರುವ LSN ಅನ್ನು (ಪ್ರತಿಕೃತಿ ಸ್ಲಾಟ್‌ನಲ್ಲಿ) ನಿರಂತರವಾಗಿ ನವೀಕರಿಸಲಾಗುತ್ತದೆ. ಇದು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದ WAL ಫೈಲ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಲು DBMS ಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಆಯ್ಕೆಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ನೋಡಿ ದಸ್ತಾವೇಜನ್ನು.

ಹೆಚ್ಚು ಗಮನ ಹರಿಸಬೇಕಾದ ಮತ್ತೊಂದು ಆಯ್ಕೆಯಾಗಿದೆ transforms. ಇದು ಅನುಕೂಲತೆ ಮತ್ತು ಸೌಂದರ್ಯದ ಬಗ್ಗೆ ಹೆಚ್ಚು ಆದರೂ ...

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, Debezium ಕೆಳಗಿನ ಹೆಸರಿಸುವ ನೀತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ವಿಷಯಗಳನ್ನು ರಚಿಸುತ್ತದೆ: serverName.schemaName.tableName. ಇದು ಯಾವಾಗಲೂ ಅನುಕೂಲಕರವಾಗಿಲ್ಲದಿರಬಹುದು. ಆಯ್ಕೆಗಳು transforms ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ನಿರ್ದಿಷ್ಟ ಹೆಸರಿನ ವಿಷಯಕ್ಕೆ ಈವೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸಬೇಕಾದ ಕೋಷ್ಟಕಗಳ ಪಟ್ಟಿಯನ್ನು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

ನಮ್ಮ ಸಂರಚನೆಯಲ್ಲಿ ಧನ್ಯವಾದಗಳು transforms ಕೆಳಗಿನವುಗಳು ಸಂಭವಿಸುತ್ತವೆ: ಟ್ರ್ಯಾಕ್ ಮಾಡಲಾದ ಡೇಟಾಬೇಸ್‌ನಿಂದ ಎಲ್ಲಾ CDC ಈವೆಂಟ್‌ಗಳು ಹೆಸರಿನೊಂದಿಗೆ ವಿಷಯಕ್ಕೆ ಹೋಗುತ್ತವೆ data.cdc.dbname. ಇಲ್ಲದಿದ್ದರೆ (ಈ ಸೆಟ್ಟಿಂಗ್‌ಗಳಿಲ್ಲದೆ), ಡೆಬೆಜಿಯಮ್ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಫಾರ್ಮ್‌ನ ಪ್ರತಿ ಟೇಬಲ್‌ಗೆ ವಿಷಯವನ್ನು ರಚಿಸುತ್ತದೆ: pg-dev.public.<table_name>.

ಕನೆಕ್ಟರ್ ಮಿತಿಗಳು

PostgreSQL ಗಾಗಿ ಕನೆಕ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್ ವಿವರಣೆಯ ಕೊನೆಯಲ್ಲಿ, ಅದರ ಕೆಲಸದ ಕೆಳಗಿನ ವೈಶಿಷ್ಟ್ಯಗಳು / ಮಿತಿಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವುದು ಯೋಗ್ಯವಾಗಿದೆ:

1. PostgreSQL ಗಾಗಿ ಕನೆಕ್ಟರ್ ಕಾರ್ಯವು ತಾರ್ಕಿಕ ಡಿಕೋಡಿಂಗ್ ಪರಿಕಲ್ಪನೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ಆದ್ದರಿಂದ ಅವನು ಡೇಟಾಬೇಸ್ ರಚನೆಯನ್ನು ಬದಲಾಯಿಸಲು ವಿನಂತಿಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದಿಲ್ಲ (ಡಿಡಿಎಲ್) - ಅದರ ಪ್ರಕಾರ, ಈ ಡೇಟಾವು ವಿಷಯಗಳಲ್ಲಿ ಇರುವುದಿಲ್ಲ.
2. ಪ್ರತಿಕೃತಿ ಸ್ಲಾಟ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ, ಕನೆಕ್ಟರ್‌ನ ಸಂಪರ್ಕವು ಸಾಧ್ಯ ಮಾತ್ರ ಮಾಸ್ಟರ್ DBMS ನಿದರ್ಶನಕ್ಕೆ.
3. ಡೇಟಾಬೇಸ್‌ಗೆ ಕನೆಕ್ಟರ್ ಅನ್ನು ಸಂಪರ್ಕಿಸುವ ಬಳಕೆದಾರರು ಓದಲು-ಮಾತ್ರ ಹಕ್ಕುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ನಂತರ ಮೊದಲ ಉಡಾವಣೆಯ ಮೊದಲು, ನೀವು ಹಸ್ತಚಾಲಿತವಾಗಿ ಪ್ರತಿಕೃತಿ ಸ್ಲಾಟ್ ಅನ್ನು ರಚಿಸಬೇಕು ಮತ್ತು ಡೇಟಾಬೇಸ್‌ಗೆ ಪ್ರಕಟಿಸಬೇಕು.

ಸಂರಚನೆಯನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತಿದೆ

ಆದ್ದರಿಂದ ನಮ್ಮ ಸಂರಚನೆಯನ್ನು ಕನೆಕ್ಟರ್‌ಗೆ ಲೋಡ್ ಮಾಡೋಣ:

curl -i -X POST -H "Accept:application/json" 
  -H  "Content-Type:application/json"  http://localhost:8083/connectors/ 
  -d @pg-con.json

ಡೌನ್‌ಲೋಡ್ ಯಶಸ್ವಿಯಾಗಿದೆಯೇ ಮತ್ತು ಕನೆಕ್ಟರ್ ಪ್ರಾರಂಭವಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ:

$ curl -i http://localhost:8083/connectors/pg-connector/status 
HTTP/1.1 200 OK
Date: Thu, 17 Sep 2020 20:19:40 GMT
Content-Type: application/json
Content-Length: 175
Server: Jetty(9.4.20.v20190813)

{"name":"pg-connector","connector":{"state":"RUNNING","worker_id":"172.24.0.5:8083"},"tasks":[{"id":0,"state":"RUNNING","worker_id":"172.24.0.5:8083"}],"type":"source"}

ಅದ್ಭುತವಾಗಿದೆ: ಇದನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ ಮತ್ತು ಹೋಗಲು ಸಿದ್ಧವಾಗಿದೆ. ಈಗ ನಾವು ಗ್ರಾಹಕರಂತೆ ನಟಿಸೋಣ ಮತ್ತು ಕಾಫ್ಕಾಗೆ ಸಂಪರ್ಕಿಸೋಣ, ಅದರ ನಂತರ ನಾವು ಕೋಷ್ಟಕದಲ್ಲಿ ನಮೂದನ್ನು ಸೇರಿಸುತ್ತೇವೆ ಮತ್ತು ಬದಲಾಯಿಸುತ್ತೇವೆ:

$ kafka/bin/kafka-console-consumer.sh 
  --bootstrap-server kafka:9092 
  --from-beginning 
  --property print.key=true 
  --topic data.cdc.dbname

postgres=# insert into customers (id, first_name, last_name, email) values (1005, 'foo', 'bar', '[email protected]');
INSERT 0 1
postgres=# update customers set first_name = 'egg' where id = 1005;
UPDATE 1

ನಮ್ಮ ವಿಷಯದಲ್ಲಿ, ಇದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ:

ನಮ್ಮ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ಬಹಳ ದೀರ್ಘವಾದ JSON

{
"schema":{
"type":"struct",
"fields":[
{
"type":"int32",
"optional":false,
"field":"id"
}
],
"optional":false,
"name":"data.cdc.dbname.Key"
},
"payload":{
"id":1005
}
}{
"schema":{
"type":"struct",
"fields":[
{
"type":"struct",
"fields":[
{
"type":"int32",
"optional":false,
"field":"id"
},
{
"type":"string",
"optional":false,
"field":"first_name"
},
{
"type":"string",
"optional":false,
"field":"last_name"
},
{
"type":"string",
"optional":false,
"field":"email"
}
],
"optional":true,
"name":"data.cdc.dbname.Value",
"field":"before"
},
{
"type":"struct",
"fields":[
{
"type":"int32",
"optional":false,
"field":"id"
},
{
"type":"string",
"optional":false,
"field":"first_name"
},
{
"type":"string",
"optional":false,
"field":"last_name"
},
{
"type":"string",
"optional":false,
"field":"email"
}
],
"optional":true,
"name":"data.cdc.dbname.Value",
"field":"after"
},
{
"type":"struct",
"fields":[
{
"type":"string",
"optional":false,
"field":"version"
},
{
"type":"string",
"optional":false,
"field":"connector"
},
{
"type":"string",
"optional":false,
"field":"name"
},
{
"type":"int64",
"optional":false,
"field":"ts_ms"
},
{
"type":"string",
"optional":true,
"name":"io.debezium.data.Enum",
"version":1,
"parameters":{
"allowed":"true,last,false"
},
"default":"false",
"field":"snapshot"
},
{
"type":"string",
"optional":false,
"field":"db"
},
{
"type":"string",
"optional":false,
"field":"schema"
},
{
"type":"string",
"optional":false,
"field":"table"
},
{
"type":"int64",
"optional":true,
"field":"txId"
},
{
"type":"int64",
"optional":true,
"field":"lsn"
},
{
"type":"int64",
"optional":true,
"field":"xmin"
}
],
"optional":false,
"name":"io.debezium.connector.postgresql.Source",
"field":"source"
},
{
"type":"string",
"optional":false,
"field":"op"
},
{
"type":"int64",
"optional":true,
"field":"ts_ms"
},
{
"type":"struct",
"fields":[
{
"type":"string",
"optional":false,
"field":"id"
},
{
"type":"int64",
"optional":false,
"field":"total_order"
},
{
"type":"int64",
"optional":false,
"field":"data_collection_order"
}
],
"optional":true,
"field":"transaction"
}
],
"optional":false,
"name":"data.cdc.dbname.Envelope"
},
"payload":{
"before":null,
"after":{
"id":1005,
"first_name":"foo",
"last_name":"bar",
"email":"[email protected]"
},
"source":{
"version":"1.2.3.Final",
"connector":"postgresql",
"name":"dbserver1",
"ts_ms":1600374991648,
"snapshot":"false",
"db":"postgres",
"schema":"public",
"table":"customers",
"txId":602,
"lsn":34088472,
"xmin":null
},
"op":"c",
"ts_ms":1600374991762,
"transaction":null
}
}{
"schema":{
"type":"struct",
"fields":[
{
"type":"int32",
"optional":false,
"field":"id"
}
],
"optional":false,
"name":"data.cdc.dbname.Key"
},
"payload":{
"id":1005
}
}{
"schema":{
"type":"struct",
"fields":[
{
"type":"struct",
"fields":[
{
"type":"int32",
"optional":false,
"field":"id"
},
{
"type":"string",
"optional":false,
"field":"first_name"
},
{
"type":"string",
"optional":false,
"field":"last_name"
},
{
"type":"string",
"optional":false,
"field":"email"
}
],
"optional":true,
"name":"data.cdc.dbname.Value",
"field":"before"
},
{
"type":"struct",
"fields":[
{
"type":"int32",
"optional":false,
"field":"id"
},
{
"type":"string",
"optional":false,
"field":"first_name"
},
{
"type":"string",
"optional":false,
"field":"last_name"
},
{
"type":"string",
"optional":false,
"field":"email"
}
],
"optional":true,
"name":"data.cdc.dbname.Value",
"field":"after"
},
{
"type":"struct",
"fields":[
{
"type":"string",
"optional":false,
"field":"version"
},
{
"type":"string",
"optional":false,
"field":"connector"
},
{
"type":"string",
"optional":false,
"field":"name"
},
{
"type":"int64",
"optional":false,
"field":"ts_ms"
},
{
"type":"string",
"optional":true,
"name":"io.debezium.data.Enum",
"version":1,
"parameters":{
"allowed":"true,last,false"
},
"default":"false",
"field":"snapshot"
},
{
"type":"string",
"optional":false,
"field":"db"
},
{
"type":"string",
"optional":false,
"field":"schema"
},
{
"type":"string",
"optional":false,
"field":"table"
},
{
"type":"int64",
"optional":true,
"field":"txId"
},
{
"type":"int64",
"optional":true,
"field":"lsn"
},
{
"type":"int64",
"optional":true,
"field":"xmin"
}
],
"optional":false,
"name":"io.debezium.connector.postgresql.Source",
"field":"source"
},
{
"type":"string",
"optional":false,
"field":"op"
},
{
"type":"int64",
"optional":true,
"field":"ts_ms"
},
{
"type":"struct",
"fields":[
{
"type":"string",
"optional":false,
"field":"id"
},
{
"type":"int64",
"optional":false,
"field":"total_order"
},
{
"type":"int64",
"optional":false,
"field":"data_collection_order"
}
],
"optional":true,
"field":"transaction"
}
],
"optional":false,
"name":"data.cdc.dbname.Envelope"
},
"payload":{
"before":{
"id":1005,
"first_name":"foo",
"last_name":"bar",
"email":"[email protected]"
},
"after":{
"id":1005,
"first_name":"egg",
"last_name":"bar",
"email":"[email protected]"
},
"source":{
"version":"1.2.3.Final",
"connector":"postgresql",
"name":"dbserver1",
"ts_ms":1600375609365,
"snapshot":"false",
"db":"postgres",
"schema":"public",
"table":"customers",
"txId":603,
"lsn":34089688,
"xmin":null
},
"op":"u",
"ts_ms":1600375609778,
"transaction":null
}
}

ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ, ದಾಖಲೆಗಳು ಬದಲಾದ ದಾಖಲೆಯ ಕೀ (PK) ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ ಮತ್ತು ಬದಲಾವಣೆಗಳ ಮೂಲಭೂತವಾಗಿ: ದಾಖಲೆಯು ಮೊದಲು ಮತ್ತು ನಂತರ ಏನಾಯಿತು.

• ಸಂದರ್ಭದಲ್ಲಿ INSERT: ಮೊದಲು ಮೌಲ್ಯ (before) ಸಮಾನವಾಗಿರುತ್ತದೆ nullಸೇರಿಸಲಾದ ಸ್ಟ್ರಿಂಗ್ ನಂತರ.
• ಸಂದರ್ಭದಲ್ಲಿ UPDATE: ನಲ್ಲಿ payload.before ಸಾಲಿನ ಹಿಂದಿನ ಸ್ಥಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಇನ್ payload.after - ಬದಲಾವಣೆಯ ಮೂಲತತ್ವದೊಂದಿಗೆ ಹೊಸದು.

2.2 ಮೊಂಗೋಡಿಬಿ

ಈ ಕನೆಕ್ಟರ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಮೊಂಗೊಡಿಬಿ ರೆಪ್ಲಿಕೇಶನ್ ಮೆಕ್ಯಾನಿಸಂ ಅನ್ನು ಬಳಸುತ್ತದೆ, ಡಿಬಿಎಂಎಸ್ ಪ್ರಾಥಮಿಕ ನೋಡ್‌ನ ಆಪ್ಲಾಗ್‌ನಿಂದ ಮಾಹಿತಿಯನ್ನು ಓದುತ್ತದೆ.

PgSQL ಗಾಗಿ ಈಗಾಗಲೇ ವಿವರಿಸಿದ ಕನೆಕ್ಟರ್‌ನಂತೆಯೇ, ಇಲ್ಲಿಯೂ ಸಹ, ಮೊದಲ ಪ್ರಾರಂಭದಲ್ಲಿ, ಪ್ರಾಥಮಿಕ ಡೇಟಾ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ, ಅದರ ನಂತರ ಕನೆಕ್ಟರ್ ಆಪ್ಲಾಗ್ ರೀಡಿಂಗ್ ಮೋಡ್‌ಗೆ ಬದಲಾಯಿಸುತ್ತದೆ.

ಕಾನ್ಫಿಗರೇಶನ್ ಉದಾಹರಣೆ:

{
"name": "mp-k8s-mongo-connector",
"config": {
"connector.class": "io.debezium.connector.mongodb.MongoDbConnector",
"tasks.max": "1",
"mongodb.hosts": "MainRepSet/mongo:27017",
"mongodb.name": "mongo",
"mongodb.user": "debezium",
"mongodb.password": "dbname",
"database.whitelist": "db_1,db_2",
"transforms": "AddPrefix",
"transforms.AddPrefix.type": "org.apache.kafka.connect.transforms.RegexRouter",
"transforms.AddPrefix.regex": "mongo.([a-zA-Z_0-9]*).([a-zA-Z_0-9]*)",
"transforms.AddPrefix.replacement": "data.cdc.mongo_$1"
}
}

ನೀವು ನೋಡುವಂತೆ, ಹಿಂದಿನ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಹೋಲಿಸಿದರೆ ಯಾವುದೇ ಹೊಸ ಆಯ್ಕೆಗಳಿಲ್ಲ, ಆದರೆ ಡೇಟಾಬೇಸ್ ಮತ್ತು ಅವುಗಳ ಪೂರ್ವಪ್ರತ್ಯಯಗಳಿಗೆ ಸಂಪರ್ಕಿಸುವ ಜವಾಬ್ದಾರಿಯುತ ಆಯ್ಕೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮಾತ್ರ ಕಡಿಮೆ ಮಾಡಲಾಗಿದೆ.

ಸೆಟ್ಟಿಂಗ್ಗಳು transforms ಈ ಸಮಯದಲ್ಲಿ ಅವರು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡುತ್ತಾರೆ: ಯೋಜನೆಯಿಂದ ಗುರಿ ವಿಷಯದ ಹೆಸರನ್ನು ತಿರುಗಿಸಿ <server_name>.<db_name>.<collection_name> в data.cdc.mongo_<db_name>.

ದೋಷಸಹಿಷ್ಣುತೆ

ನಮ್ಮ ಸಮಯದಲ್ಲಿ ದೋಷ ಸಹಿಷ್ಣುತೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಲಭ್ಯತೆಯ ಸಮಸ್ಯೆಯು ಎಂದಿಗಿಂತಲೂ ಹೆಚ್ಚು ತೀವ್ರವಾಗಿದೆ - ವಿಶೇಷವಾಗಿ ನಾವು ಡೇಟಾ ಮತ್ತು ವಹಿವಾಟುಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವಾಗ ಮತ್ತು ಡೇಟಾ ಬದಲಾವಣೆಯ ಟ್ರ್ಯಾಕಿಂಗ್ ಈ ವಿಷಯದಲ್ಲಿ ಬದಿಯಲ್ಲಿಲ್ಲ. ತಾತ್ವಿಕವಾಗಿ ಏನು ತಪ್ಪಾಗಬಹುದು ಮತ್ತು ಪ್ರತಿ ಸಂದರ್ಭದಲ್ಲಿ ಡೆಬೆಜಿಯಂಗೆ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

ಮೂರು ಆಯ್ಕೆಯಿಂದ ಹೊರಗುಳಿಯುವ ಆಯ್ಕೆಗಳಿವೆ:

1. ಕಾಫ್ಕಾ ಸಂಪರ್ಕ ವಿಫಲವಾಗಿದೆ. ವಿತರಣಾ ಮೋಡ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ಸಂಪರ್ಕವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದರೆ, ಒಂದೇ group.id ಅನ್ನು ಹೊಂದಿಸಲು ಬಹು ಕೆಲಸಗಾರರ ಅಗತ್ಯವಿರುತ್ತದೆ. ನಂತರ, ಅವುಗಳಲ್ಲಿ ಒಂದು ವಿಫಲವಾದರೆ, ಕನೆಕ್ಟರ್ ಅನ್ನು ಇತರ ಕೆಲಸಗಾರನ ಮೇಲೆ ಮರುಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕಾಫ್ಕಾದಲ್ಲಿನ ವಿಷಯದ ಕೊನೆಯ ಬದ್ಧ ಸ್ಥಾನದಿಂದ ಓದುವುದನ್ನು ಮುಂದುವರಿಸಲಾಗುತ್ತದೆ.
2. ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ನೊಂದಿಗೆ ಸಂಪರ್ಕದ ನಷ್ಟ. ಕನೆಕ್ಟರ್ ಕಾಫ್ಕಾಗೆ ಕಳುಹಿಸಲು ವಿಫಲವಾದ ಸ್ಥಾನದಲ್ಲಿ ಓದುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರಯತ್ನವು ಯಶಸ್ವಿಯಾಗುವವರೆಗೆ ನಿಯತಕಾಲಿಕವಾಗಿ ಅದನ್ನು ಮರುಕಳುಹಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.
3. ಡೇಟಾ ಮೂಲ ಲಭ್ಯವಿಲ್ಲ. ಕನೆಕ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್ ಪ್ರಕಾರ ಮೂಲಕ್ಕೆ ಮರುಸಂಪರ್ಕಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಡೀಫಾಲ್ಟ್ ಅನ್ನು 16 ಪ್ರಯತ್ನಗಳನ್ನು ಬಳಸಲಾಗಿದೆ ಘಾತೀಯ ಬ್ಯಾಕ್ಆಫ್. 16 ನೇ ವಿಫಲ ಪ್ರಯತ್ನದ ನಂತರ, ಕಾರ್ಯವನ್ನು ಎಂದು ಗುರುತಿಸಲಾಗುತ್ತದೆ ವಿಫಲವಾಗಿದೆ ಮತ್ತು ಇದನ್ನು ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ REST ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಹಸ್ತಚಾಲಿತವಾಗಿ ಮರುಪ್ರಾರಂಭಿಸಬೇಕಾಗುತ್ತದೆ.
   • ಸಂದರ್ಭದಲ್ಲಿ PostgreSQL ಡೇಟಾ ಕಳೆದುಹೋಗುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಪ್ರತಿಕೃತಿ ಸ್ಲಾಟ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಕನೆಕ್ಟರ್‌ನಿಂದ ಓದದ WAL ಫೈಲ್‌ಗಳ ಅಳಿಸುವಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ತೊಂದರೆಯೂ ಇದೆ: ಕನೆಕ್ಟರ್ ಮತ್ತು ಡಿಬಿಎಂಎಸ್ ನಡುವಿನ ನೆಟ್ವರ್ಕ್ ಸಂಪರ್ಕವು ದೀರ್ಘಕಾಲದವರೆಗೆ ಅಡ್ಡಿಪಡಿಸಿದರೆ, ಡಿಸ್ಕ್ ಸ್ಪೇಸ್ ಖಾಲಿಯಾಗುವ ಅವಕಾಶವಿರುತ್ತದೆ ಮತ್ತು ಇದು ಸಂಪೂರ್ಣ ಡಿಬಿಎಂಎಸ್ನ ವೈಫಲ್ಯಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು.
   • ಸಂದರ್ಭದಲ್ಲಿ MySQL ಸಂಪರ್ಕವನ್ನು ಮರುಸ್ಥಾಪಿಸುವ ಮೊದಲು ಬಿನ್‌ಲಾಗ್ ಫೈಲ್‌ಗಳನ್ನು DBMS ಮೂಲಕ ತಿರುಗಿಸಬಹುದು. ಇದು ಕನೆಕ್ಟರ್ ವಿಫಲ ಸ್ಥಿತಿಗೆ ಹೋಗಲು ಕಾರಣವಾಗುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮರುಸ್ಥಾಪಿಸಲು ಬಿನ್‌ಲಾಗ್‌ಗಳಿಂದ ಓದುವುದನ್ನು ಮುಂದುವರಿಸಲು ಇದು ಆರಂಭಿಕ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಮೋಡ್‌ನಲ್ಲಿ ಮರುಪ್ರಾರಂಭಿಸಬೇಕಾಗುತ್ತದೆ.
   • ಮೇಲೆ ಮೊಂಗೋಡಬ್ಬಿ. ದಸ್ತಾವೇಜನ್ನು ಹೇಳುತ್ತದೆ: ಲಾಗ್/ಆಪ್ಲಾಗ್ ಫೈಲ್‌ಗಳು ಅಳಿಸಲ್ಪಟ್ಟಿರುವ ಸಂದರ್ಭದಲ್ಲಿ ಕನೆಕ್ಟರ್‌ನ ನಡವಳಿಕೆ ಮತ್ತು ಕನೆಕ್ಟರ್ ಅದನ್ನು ಬಿಟ್ಟುಹೋದ ಸ್ಥಾನದಿಂದ ಓದುವುದನ್ನು ಮುಂದುವರಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ ಎಲ್ಲಾ DBMS ಗೆ ಒಂದೇ ಆಗಿರುತ್ತದೆ. ಕನೆಕ್ಟರ್ ರಾಜ್ಯಕ್ಕೆ ಹೋಗುತ್ತದೆ ಎಂಬ ಅಂಶದಲ್ಲಿ ಇದು ಇರುತ್ತದೆ ವಿಫಲವಾಗಿದೆ ಮತ್ತು ಮೋಡ್‌ನಲ್ಲಿ ಮರುಪ್ರಾರಂಭದ ಅಗತ್ಯವಿರುತ್ತದೆ ಆರಂಭಿಕ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್.

     ಆದಾಗ್ಯೂ, ವಿನಾಯಿತಿಗಳಿವೆ. ಕನೆಕ್ಟರ್ ದೀರ್ಘಕಾಲದವರೆಗೆ ಸಂಪರ್ಕ ಕಡಿತಗೊಂಡ ಸ್ಥಿತಿಯಲ್ಲಿದ್ದರೆ (ಅಥವಾ ಮೊಂಗೊಡಿಬಿ ನಿದರ್ಶನವನ್ನು ತಲುಪಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ), ಮತ್ತು ಈ ಸಮಯದಲ್ಲಿ ಆಪ್ಲಾಗ್ ಅನ್ನು ತಿರುಗಿಸಿದರೆ, ನಂತರ ಸಂಪರ್ಕವನ್ನು ಮರುಸ್ಥಾಪಿಸಿದಾಗ, ಕನೆಕ್ಟರ್ ಶಾಂತವಾಗಿ ಲಭ್ಯವಿರುವ ಮೊದಲ ಸ್ಥಾನದಿಂದ ಡೇಟಾವನ್ನು ಓದುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ. , ಅದಕ್ಕಾಗಿಯೇ ಕಾಫ್ಕಾದಲ್ಲಿನ ಕೆಲವು ಡೇಟಾ ಕೇವಲ ಹೊಡೆಯುತ್ತಾರೆ.

ತೀರ್ಮಾನಕ್ಕೆ

Debezium CDC ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ನನ್ನ ಮೊದಲ ಅನುಭವವಾಗಿದೆ ಮತ್ತು ಒಟ್ಟಾರೆಯಾಗಿ ತುಂಬಾ ಧನಾತ್ಮಕವಾಗಿದೆ. ಯೋಜನೆಯು ಮುಖ್ಯ DBMS ನ ಬೆಂಬಲ, ಸಂರಚನೆಯ ಸುಲಭತೆ, ಕ್ಲಸ್ಟರಿಂಗ್‌ಗೆ ಬೆಂಬಲ ಮತ್ತು ಸಕ್ರಿಯ ಸಮುದಾಯಕ್ಕೆ ಲಂಚ ನೀಡಿತು. ಅಭ್ಯಾಸದಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿರುವವರಿಗೆ, ನೀವು ಮಾರ್ಗದರ್ಶಿಗಳನ್ನು ಓದಬೇಕೆಂದು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ и ಡೆಬೆಜಿಯಮ್.

ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್‌ಗಾಗಿ JDBC ಕನೆಕ್ಟರ್‌ಗೆ ಹೋಲಿಸಿದರೆ, Debezium ನ ಮುಖ್ಯ ಪ್ರಯೋಜನವೆಂದರೆ ಬದಲಾವಣೆಗಳನ್ನು DBMS ಲಾಗ್‌ಗಳಿಂದ ಓದಲಾಗುತ್ತದೆ, ಇದು ಡೇಟಾವನ್ನು ಕನಿಷ್ಠ ವಿಳಂಬದೊಂದಿಗೆ ಸ್ವೀಕರಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. JDBC ಕನೆಕ್ಟರ್ (ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್ ಒದಗಿಸಿದ) ಸ್ಥಿರ ಮಧ್ಯಂತರದಲ್ಲಿ ಟ್ರ್ಯಾಕ್ ಮಾಡಿದ ಟೇಬಲ್ ಅನ್ನು ಪ್ರಶ್ನಿಸುತ್ತದೆ ಮತ್ತು (ಅದೇ ಕಾರಣಕ್ಕಾಗಿ) ಡೇಟಾವನ್ನು ಅಳಿಸಿದಾಗ ಸಂದೇಶಗಳನ್ನು ರಚಿಸುವುದಿಲ್ಲ (ಇಲ್ಲದ ಡೇಟಾಕ್ಕಾಗಿ ನೀವು ಹೇಗೆ ಪ್ರಶ್ನಿಸಬಹುದು?).

ಇದೇ ರೀತಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು, ನೀವು ಈ ಕೆಳಗಿನ ಪರಿಹಾರಗಳಿಗೆ ಗಮನ ಕೊಡಬಹುದು (ಡೆಬೆಜಿಯಂ ಜೊತೆಗೆ):

• JDBC ಕನೆಕ್ಟರ್ ಕಾಫ್ಕಾ ಕನೆಕ್ಟ್
• ಕೆಲವು MySQL-ಮಾತ್ರ ಪರಿಹಾರಗಳು:
  • MySQL ಸ್ಟ್ರೀಮರ್;
  • ಮ್ಯಾಕ್ಸ್ವೆಲ್;
  • ಬೆನ್ನುಮೂಳೆಯ ಟ್ಯಾಪ್;
• ಒರಾಕಲ್ ಗೋಲ್ಡನ್ ಗೇಟ್, ಆದರೆ ಇದು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನವಾದ "ತೂಕದ ವರ್ಗ".

ಪಿಎಸ್

ನಮ್ಮ ಬ್ಲಾಗ್‌ನಲ್ಲಿಯೂ ಓದಿ:

• «ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಕಾಫ್ಕಾ ಕ್ಲಸ್ಟರ್‌ಗೆ ಸೂಕ್ತವಾದ ಗಾತ್ರವನ್ನು ನಿರ್ಧರಿಸಿ";
• «ನಮ್ಮ SRE ದೈನಂದಿನ ಜೀವನದಿಂದ ಪ್ರಾಯೋಗಿಕ ಕಥೆಗಳು. ಭಾಗ 2";
• «ಕುಬರ್ನೆಟ್ಸ್, ನಮ್ಮ ಆಯ್ಕೆಗಳು ಮತ್ತು ಅನುಭವಕ್ಕಾಗಿ PostgreSQL ಹೇಳಿಕೆಗಳ ಸಂಕ್ಷಿಪ್ತ ಅವಲೋಕನ».

ಮೂಲ: www.habr.com