ಪೈಥಾನ್ ಮತ್ತು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಬಳಸಿ ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು, ಸಂಗ್ರಹಿಸುವುದು ಮತ್ತು ವಿಶ್ಲೇಷಿಸುವುದು ಹೇಗೆಂದು ತಿಳಿಯಿರಿ. ಈ ಆಳವಾದ ಮಾರ್ಗದರ್ಶಿಯು ಸೆಟಪ್, ಡೇಟಾ ಬರೆಯುವುದು, ಫ್ಲಕ್ಸ್‌ನೊಂದಿಗೆ ಪ್ರಶ್ನಿಸುವುದು, ಮತ್ತು ಡೆವಲಪರ್‌ಗಳು ಹಾಗೂ ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳಿಗೆ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು: ಪೈಥಾನ್ ಮತ್ತು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಏಕೀಕರಣಕ್ಕೆ ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ
ಇಂದಿನ ಡೇಟಾ-ಚಾಲಿತ ಜಗತ್ತಿನಲ್ಲಿ, ಒಂದು ನಿರ್ದಿಷ್ಟ ರೀತಿಯ ಡೇಟಾವು ಹಲವಾರು ಉದ್ಯಮಗಳಲ್ಲಿ ಹೆಚ್ಚು ಮಹತ್ವ ಪಡೆಯುತ್ತಿದೆ: ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾ. ಡೆವ್‌ಆಪ್ಸ್ ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ಸರ್ವರ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದರಿಂದ ಹಿಡಿದು, ಐಒಟಿ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಸೆನ್ಸರ್ ರೀಡಿಂಗ್‌ಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು ಮತ್ತು ಹಣಕಾಸು ಮಾರುಕಟ್ಟೆಗಳಲ್ಲಿ ಸ್ಟಾಕ್ ಬೆಲೆಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವವರೆಗೆ, ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿತವಾದ ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳು ಎಲ್ಲೆಡೆ ಇವೆ. ಆದಾಗ್ಯೂ, ಈ ಡೇಟಾವನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುವುದು ವಿಶಿಷ್ಟ ಸವಾಲುಗಳನ್ನು ಒಡ್ಡುತ್ತದೆ, ಇದನ್ನು ಸಾಂಪ್ರದಾಯಿಕ ರಿಲೇಶನಲ್ ಡೇಟಾಬೇಸ್‌ಗಳು ಪರಿಹರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿಲ್ಲ.
ಇಲ್ಲಿಯೇ ವಿಶೇಷವಾದ ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾಬೇಸ್‌ಗಳು (TSDB) ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತವೆ. ಈ ಕ್ಷೇತ್ರದಲ್ಲಿ ಮುಂಚೂಣಿಯಲ್ಲಿರುವ ಒಂದು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ, ಇದು ಟೈಮ್-ಸ್ಟ್ಯಾಂಪ್ ಮಾಡಿದ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ನಿರ್ಮಿಸಲಾದ ಒಂದು ಉನ್ನತ-ಕಾರ್ಯಕ್ಷಮತೆಯ, ಓಪನ್-ಸೋರ್ಸ್ ಡೇಟಾಬೇಸ್ ಆಗಿದೆ. ಇದನ್ನು ಪೈಥಾನ್‌ನ ಬಹುಮುಖತೆ ಮತ್ತು ಶಕ್ತಿಯುತ ಡೇಟಾ ಸೈನ್ಸ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ, ಇದು ಅಳೆಯಬಹುದಾದ ಮತ್ತು ಒಳನೋಟವುಳ್ಳ ಟೈಮ್ ಸೀರೀಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಒಂದು ನಂಬಲಾಗದಷ್ಟು ದೃಢವಾದ ಸ್ಟಾಕ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು ಪೈಥಾನ್ ಅನ್ನು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಬೇಕಾದ ಎಲ್ಲವನ್ನೂ ತಿಳಿಸುತ್ತದೆ. ನಾವು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳು, ಪರಿಸರ ಸೆಟಪ್, ಡೇಟಾ ಬರೆಯುವುದು ಮತ್ತು ಪ್ರಶ್ನಿಸುವುದು, ಒಂದು ಪ್ರಾಯೋಗಿಕ ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆ, ಮತ್ತು ಉತ್ಪಾದನೆ-ಸಿದ್ಧ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅಗತ್ಯವಾದ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇವೆ. ನೀವು ಡೇಟಾ ಇಂಜಿನಿಯರ್, ಡೆವ್‌ಆಪ್ಸ್ ವೃತ್ತಿಪರ, ಅಥವಾ ಡೇಟಾ ವಿಜ್ಞಾನಿ ಆಗಿರಲಿ, ಈ ಲೇಖನವು ನಿಮ್ಮ ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಕೌಶಲ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಮೂಲ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ನಾವು ಕೋಡ್ ಬರೆಯಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಇದು ನಿಮಗೆ ಸಮರ್ಥವಾದ ಡೇಟಾ ಸ್ಕೀಮಾವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲು ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಬರೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಎಂದರೇನು?
ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಎಂಬುದು ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾದ ವೇಗದ, ಉನ್ನತ-ಲಭ್ಯತೆಯ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಹಿಂಪಡೆಯುವಿಕೆಗಾಗಿ ಹೊಂದುವಂತೆ ಮಾಡಿದ ಡೇಟಾಬೇಸ್ ಆಗಿದೆ. PostgreSQL ಅಥವಾ MySQL ನಂತಹ ಸಾಮಾನ್ಯ-ಉದ್ದೇಶದ ಡೇಟಾಬೇಸ್‌ಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯ ಆಂತರಿಕ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಟೈಮ್ ಸೀರೀಸ್ ಕೆಲಸದ ಹೊರೆಗಳ ನಿರ್ದಿಷ್ಟ ಮಾದರಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮೂಲದಿಂದಲೇ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ—ಅಂದರೆ, ಹೆಚ್ಚಿನ-ಪ್ರಮಾಣದ ಬರವಣಿಗೆಗಳು ಮತ್ತು ಸಮಯ-ಕೇಂದ್ರಿತ ಪ್ರಶ್ನೆಗಳು.
ಇದು ಎರಡು ಮುಖ್ಯ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಲಭ್ಯವಿದೆ:
- InfluxDB OSS: ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಮೂಲಸೌಕರ್ಯದಲ್ಲಿ ಹೋಸ್ಟ್ ಮಾಡಬಹುದಾದ ಓಪನ್-ಸೋರ್ಸ್ ಆವೃತ್ತಿ.
- InfluxDB Cloud: ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ವಹಿಸಲಾದ, ಬಹು-ಕ್ಲೌಡ್ ಡೇಟಾಬೇಸ್-ಆಸ್-ಎ-ಸರ್ವೀಸ್ (DBaaS) ಕೊಡುಗೆ.
ಈ ಮಾರ್ಗದರ್ಶಿಗಾಗಿ, ನಾವು ನಮ್ಮ ಉದಾಹರಣೆಗಳಿಗಾಗಿ ಸ್ಥಳೀಯ OSS ಇನ್‌ಸ್ಟಾನ್ಸ್ ಬಳಸಿ, ಎರಡಕ್ಕೂ ಅನ್ವಯವಾಗುವ ಪರಿಕಲ್ಪನೆಗಳ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತೇವೆ.
ಪ್ರಮುಖ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಪರಿಭಾಷೆ
ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಗೆ ತನ್ನದೇ ಆದ ಡೇಟಾ ಮಾದರಿ ಮತ್ತು ಪರಿಭಾಷೆ ಇದೆ. ಈ ಪದಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅದನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವ ಮೊದಲ ಹೆಜ್ಜೆಯಾಗಿದೆ.
- ಡೇಟಾ ಪಾಯಿಂಟ್ (Data Point): ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯಲ್ಲಿನ ಡೇಟಾದ ಮೂಲಭೂತ ಘಟಕ. ಒಂದೇ ಡೇಟಾ ಪಾಯಿಂಟ್ ನಾಲ್ಕು ಘಟಕಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ:
- ಮೆಷರ್‌ಮೆಂಟ್ (Measurement): ನಿಮ್ಮ ಡೇಟಾಗೆ ಕಂಟೇನರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಒಂದು ಸ್ಟ್ರಿಂಗ್, SQL ನಲ್ಲಿನ ಟೇಬಲ್ ಹೆಸರಿಗೆ ಹೋಲುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,
cpu_usageಅಥವಾtemperature_readings. - ಟ್ಯಾಗ್ ಸೆಟ್ (Tag Set): ಡೇಟಾದ ಬಗ್ಗೆ ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ಕೀ-ವ್ಯಾಲ್ಯೂ ಜೋಡಿಗಳ (ಎರಡೂ ಸ್ಟ್ರಿಂಗ್‌ಗಳು) ಸಂಗ್ರಹ. ಟ್ಯಾಗ್‌ಗಳನ್ನು ಇಂಡೆಕ್ಸ್ ಮಾಡಲಾಗುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಅವು ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ಫಿಲ್ಟರ್ ಮಾಡಲು ಮತ್ತು ಗುಂಪು ಮಾಡಲು ಸೂಕ್ತವಾಗಿವೆ. ಉದಾಹರಣೆಗಳು:
host=server_A,region=us-east-1,sensor_id=T-1000. - ಫೀಲ್ಡ್ ಸೆಟ್ (Field Set): ನಿಜವಾದ ಡೇಟಾ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಕೀ-ವ್ಯಾಲ್ಯೂ ಜೋಡಿಗಳ ಸಂಗ್ರಹ. ಫೀಲ್ಡ್ ಮೌಲ್ಯಗಳು ಇಂಟಿಜರ್‌ಗಳು, ಫ್ಲೋಟ್‌ಗಳು, ಬೂಲಿಯನ್‌ಗಳು ಅಥವಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿರಬಹುದು. ಫೀಲ್ಡ್‌ಗಳನ್ನು ಇಂಡೆಕ್ಸ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಪ್ರಶ್ನೆ
WHEREಕ್ಲಾಸ್‌ಗಳಲ್ಲಿ ಬಳಸುವುದು ಸಮರ್ಥವಲ್ಲ. ಉದಾಹರಣೆಗಳು:value=98.6,load=0.75,is_critical=false. - ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (Timestamp): ಡೇಟಾ ಪಾಯಿಂಟ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿತವಾದ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್, ನ್ಯಾನೊಸೆಕೆಂಡ್ ನಿಖರತೆಯೊಂದಿಗೆ. ಇದು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯಲ್ಲಿನ ಎಲ್ಲಾ ಡೇಟಾದ ಕೇಂದ್ರ ಸಂಘಟನಾ ತತ್ವವಾಗಿದೆ.
- ಮೆಷರ್‌ಮೆಂಟ್ (Measurement): ನಿಮ್ಮ ಡೇಟಾಗೆ ಕಂಟೇನರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಒಂದು ಸ್ಟ್ರಿಂಗ್, SQL ನಲ್ಲಿನ ಟೇಬಲ್ ಹೆಸರಿಗೆ ಹೋಲುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,
- ಬಕೆಟ್ (Bucket): ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ಹೆಸರಿಸಲಾದ ಸ್ಥಳ. ಇದು ಸಾಂಪ್ರದಾಯಿಕ RDBMS ನಲ್ಲಿನ 'ಡೇಟಾಬೇಸ್'ಗೆ ಸಮಾನವಾಗಿದೆ. ಒಂದು ಬಕೆಟ್‌ಗೆ ರಿಟೆನ್ಶನ್ ಪಾಲಿಸಿ ಇರುತ್ತದೆ, ಇದು ಡೇಟಾವನ್ನು ಎಷ್ಟು ಕಾಲ ಇಡಬೇಕು ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.
- ಸಂಸ್ಥೆ (Organization - Org): ಬಳಕೆದಾರರ ಗುಂಪಿಗೆ ಒಂದು ಕಾರ್ಯಕ್ಷೇತ್ರ. ಬಕೆಟ್‌ಗಳು, ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳು ಮತ್ತು ಕಾರ್ಯಗಳಂತಹ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳು ಒಂದು ಸಂಸ್ಥೆಗೆ ಸೇರಿರುತ್ತವೆ.
ಇದನ್ನು ಈ ರೀತಿ ಯೋಚಿಸಿ: ನೀವು ತಾಪಮಾನದ ಡೇಟಾವನ್ನು ಲಾಗ್ ಮಾಡುತ್ತಿದ್ದರೆ, ನಿಮ್ಮ ಮೆಷರ್‌ಮೆಂಟ್ environment_sensors ಆಗಿರಬಹುದು. ಡೇಟಾವನ್ನು ಎಲ್ಲಿ ಮತ್ತು ಯಾವುದು ಉತ್ಪಾದಿಸಿತು ಎಂಬುದನ್ನು ವಿವರಿಸಲು ಟ್ಯಾಗ್‌ಗಳು location=lab_1 ಮತ್ತು sensor_type=DHT22 ಆಗಿರಬಹುದು. ಫೀಲ್ಡ್‌ಗಳು ನಿಜವಾದ ರೀಡಿಂಗ್‌ಗಳಾಗಿರುತ್ತವೆ, ಉದಾಹರಣೆಗೆ temperature=22.5 ಮತ್ತು humidity=45.1. ಮತ್ತು ಸಹಜವಾಗಿ, ಪ್ರತಿ ರೀಡಿಂಗ್‌ಗೂ ಒಂದು ವಿಶಿಷ್ಟ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಇರುತ್ತದೆ.
ನಿಮ್ಮ ಪರಿಸರವನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು
ಈಗ, ನಾವು ನಮ್ಮ ಕೈಗಳನ್ನು ಕೊಳಕು ಮಾಡಿಕೊಂಡು ಅಗತ್ಯ ಉಪಕರಣಗಳನ್ನು ಸಿದ್ಧಪಡಿಸೋಣ. ತ್ವರಿತ ಮತ್ತು ಜಾಗತಿಕವಾಗಿ ಸ್ಥಿರವಾದ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಸೆಟಪ್‌ಗಾಗಿ ನಾವು ಡಾಕರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
ಡಾಕರ್‌ನೊಂದಿಗೆ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು
ಡಾಕರ್ ಸೇವೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಒಂದು ಸ್ವಚ್ಛ, ಪ್ರತ್ಯೇಕವಾದ ಪರಿಸರವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ಡಾಕರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿಲ್ಲದಿದ್ದರೆ, ದಯವಿಟ್ಟು ನಿಮ್ಮ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಾಗಿ ಅಧಿಕೃತ ದಸ್ತಾವೇಜನ್ನು ನೋಡಿ.
ಒಂದು InfluxDB 2.x ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ತೆರೆಯಿರಿ ಮತ್ತು ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:
docker run --name influxdb -p 8086:8086 influxdb:latest
ಈ ಆಜ್ಞೆಯು ಇತ್ತೀಚಿನ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಇಮೇಜ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತದೆ, `influxdb` ಹೆಸರಿನ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಸ್ಥಳೀಯ ಯಂತ್ರದಲ್ಲಿನ ಪೋರ್ಟ್ 8086 ಅನ್ನು ಕಂಟೇನರ್‌ನೊಳಗಿನ ಪೋರ್ಟ್ 8086 ಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ. ಇದು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ API ಗಾಗಿ ಡೀಫಾಲ್ಟ್ ಪೋರ್ಟ್ ಆಗಿದೆ.
ಆರಂಭಿಕ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಸೆಟಪ್
ಕಂಟೇನರ್ ಚಾಲನೆಯಾದ ನಂತರ, ನಿಮ್ಮ ವೆಬ್ ಬ್ರೌಸರ್‌ನಲ್ಲಿ http://localhost:8086 ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡುವ ಮೂಲಕ ನೀವು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್ (UI) ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
- ನಿಮಗೆ "Welcome to InfluxDB" ಸೆಟಪ್ ಪರದೆಯು ಸ್ವಾಗತಿಸುತ್ತದೆ. "Get Started" ಕ್ಲಿಕ್ ಮಾಡಿ.
- ಬಳಕೆದಾರರ ಸೆಟಪ್ (User Setup): ಆರಂಭಿಕ ಬಳಕೆದಾರರನ್ನು ರಚಿಸಲು ನಿಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ. ಬಳಕೆದಾರಹೆಸರು ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಭರ್ತಿ ಮಾಡಿ.
- ಆರಂಭಿಕ ಸಂಸ್ಥೆ ಮತ್ತು ಬಕೆಟ್ (Initial Organization and Bucket): ನಿಮ್ಮ ಪ್ರಾಥಮಿಕ ಸಂಸ್ಥೆಗೆ ಒಂದು ಹೆಸರನ್ನು (ಉದಾ., `my-org`) ಮತ್ತು ನಿಮ್ಮ ಮೊದಲ ಬಕೆಟ್‌ಗೆ (ಉದಾ., `my-bucket`) ಒಂದು ಹೆಸರನ್ನು ಒದಗಿಸಿ.
- ನಿಮ್ಮ ಟೋಕನ್ ಅನ್ನು ಉಳಿಸಿ (Save Your Token): ಸೆಟಪ್ ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ನಿಮ್ಮ ಆರಂಭಿಕ ನಿರ್ವಾಹಕ ಟೋಕನ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಇದು ಅತ್ಯಂತ ಮುಖ್ಯ! ಈ ಟೋಕನ್ ಅನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಸುರಕ್ಷಿತ ಸ್ಥಳದಲ್ಲಿ ಉಳಿಸಿ. ನಿಮ್ಮ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ಡೇಟಾಬೇಸ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ನಿಮಗೆ ಇದು ಬೇಕಾಗುತ್ತದೆ.
ಸೆಟಪ್ ನಂತರ, ನಿಮ್ಮನ್ನು ಮುಖ್ಯ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗೆ ಕರೆದೊಯ್ಯಲಾಗುತ್ತದೆ. ನೀವು ಈಗ ಪೈಥಾನ್‌ನಿಂದ ಅದಕ್ಕೆ ಸಂಪರ್ಕಿಸಲು ಸಿದ್ಧರಾಗಿದ್ದೀರಿ.
ಪೈಥಾನ್ ಕ್ಲೈಂಟ್ ಲೈಬ್ರರಿಯನ್ನು ಸ್ಥಾಪಿಸುವುದು
InfluxDB 2.x ಮತ್ತು ಕ್ಲೌಡ್‌ಗಾಗಿ ಅಧಿಕೃತ ಪೈಥಾನ್ ಕ್ಲೈಂಟ್ ಲೈಬ್ರರಿ `influxdb-client` ಆಗಿದೆ. ಇದನ್ನು ಸ್ಥಾಪಿಸಲು, pip ಬಳಸಿ:
pip install influxdb-client
ಈ ಲೈಬ್ರರಿಯು ನಿಮ್ಮ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಇನ್‌ಸ್ಟಾನ್ಸ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಬರೆಯಲು, ಪ್ರಶ್ನಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಡೇಟಾ ಬರೆಯುವುದು
ನಮ್ಮ ಪರಿಸರ ಸಿದ್ಧವಾದ ನಂತರ, ಪೈಥಾನ್ ಬಳಸಿ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಗೆ ಡೇಟಾವನ್ನು ಬರೆಯುವ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ. ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ, ವಿಶೇಷವಾಗಿ ಹೆಚ್ಚಿನ-ಥ್ರೋಪುಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಮರ್ಥವಾಗಿ ಬರೆಯುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಗೆ ಸಂಪರ್ಕಿಸುವುದು
ಯಾವುದೇ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಮೊದಲ ಹಂತವೆಂದರೆ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸುವುದು. ನಿಮಗೆ URL, ನಿಮ್ಮ ಸಂಸ್ಥೆಯ ಹೆಸರು ಮತ್ತು ನೀವು ಮೊದಲು ಉಳಿಸಿದ ಟೋಕನ್ ಅಗತ್ಯವಿರುತ್ತದೆ.
ಟೋಕನ್‌ಗಳಂತಹ ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಯನ್ನು ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡುವ ಬದಲು ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಈ ಉದಾಹರಣೆಗಾಗಿ, ಸ್ಪಷ್ಟತೆಗಾಗಿ ನಾವು ಅವುಗಳನ್ನು ವೇರಿಯಬಲ್‌ಗಳಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.
import influxdb_client
from influxdb_client.client.write_api import SYNCHRONOUS
# --- Connection Details ---
url = "http://localhost:8086"
token = "YOUR_SUPER_SECRET_TOKEN" # Replace with your actual token
org = "my-org"
bucket = "my-bucket"
# --- Instantiate the Client ---
client = influxdb_client.InfluxDBClient(url=url, token=token, org=org)
# --- Get the Write API ---
# SYNCHRONOUS mode writes data immediately. For high-throughput, consider ASYNCHRONOUS.
write_api = client.write_api(write_options=SYNCHRONOUS)
print("Successfully connected to InfluxDB!")
ಒಂದೇ ಡೇಟಾ ಪಾಯಿಂಟ್ ಅನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಬರೆಯುವುದು
ಕ್ಲೈಂಟ್ ಲೈಬ್ರರಿಯು `Point` ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ ಡೇಟಾ ಮಾದರಿಯ ಪ್ರಕಾರ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ರಚಿಸಲು ಒಂದು ಅನುಕೂಲಕರ ಮಾರ್ಗವಾಗಿದೆ.
ಸರ್ವರ್‌ನ ಸಿಪಿಯು ಲೋಡ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಒಂದೇ ಡೇಟಾ ಪಾಯಿಂಟ್ ಅನ್ನು ಬರೆಯೋಣ.
from influxdb_client import Point
import time
# Create a data point using the fluent API
point = (
Point("system_metrics")
.tag("host", "server-alpha")
.tag("region", "eu-central-1")
.field("cpu_load_percent", 12.34)
.field("memory_usage_mb", 567.89)
.time(int(time.time_ns())) # Use nanosecond precision timestamp
)
# Write the point to the bucket
write_api.write(bucket=bucket, org=org, record=point)
print(f"Wrote a single point to '{bucket}'.")
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `system_metrics` ಎಂಬುದು ಮೆಷರ್‌ಮೆಂಟ್, `host` ಮತ್ತು `region` ಟ್ಯಾಗ್‌ಗಳಾಗಿವೆ, ಮತ್ತು `cpu_load_percent` ಮತ್ತು `memory_usage_mb` ಫೀಲ್ಡ್‌ಗಳಾಗಿವೆ. ನಾವು ನ್ಯಾನೊಸೆಕೆಂಡ್ ನಿಖರತೆಯೊಂದಿಗೆ ಪ್ರಸ್ತುತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪಡೆಯಲು `time.time_ns()` ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯ ಸ್ಥಳೀಯ ನಿಖರತೆಯಾಗಿದೆ.
ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಬ್ಯಾಚ್ ಬರವಣಿಗೆ
ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಒಂದೊಂದಾಗಿ ಬರೆಯುವುದು ಅಸಮರ್ಥ ಮತ್ತು ಅನಗತ್ಯ ನೆಟ್‌ವರ್ಕ್ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಯಾವುದೇ ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ, ನೀವು ನಿಮ್ಮ ಬರವಣಿಗೆಗಳನ್ನು ಬ್ಯಾಚ್ ಮಾಡಬೇಕು. `write_api`ಯು `Point` ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಸ್ವೀಕರಿಸಬಹುದು.
ಹಲವಾರು ಸೆನ್ಸರ್ ರೀಡಿಂಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ ಒಂದೇ ಬ್ಯಾಚ್‌ನಲ್ಲಿ ಬರೆಯುವುದನ್ನು ಅನುಕರಿಸೋಣ.
points = []
# Simulate 5 readings from two different sensors
for i in range(5):
# Sensor 1
point1 = (
Point("environment")
.tag("sensor_id", "A001")
.tag("location", "greenhouse-1")
.field("temperature", 25.1 + i * 0.1)
.field("humidity", 60.5 + i * 0.2)
.time(int(time.time_ns()) - i * 10**9) # Stagger timestamps by 1 second
)
points.append(point1)
# Sensor 2
point2 = (
Point("environment")
.tag("sensor_id", "B002")
.tag("location", "greenhouse-2")
.field("temperature", 22.8 + i * 0.15)
.field("humidity", 55.2 - i * 0.1)
.time(int(time.time_ns()) - i * 10**9)
)
points.append(point2)
# Write the entire batch of points
write_api.write(bucket=bucket, org=org, record=points)
print(f"Wrote a batch of {len(points)} points to '{bucket}'.")
ಈ ವಿಧಾನವು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ API ಗೆ ಮಾಡಿದ HTTP ವಿನಂತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ ಬರವಣಿಗೆಯ ಥ್ರೋಪುಟ್ ಅನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ.
ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳಿಂದ ಡೇಟಾ ಬರೆಯುವುದು
ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಮತ್ತು ವಿಶ್ಲೇಷಕರಿಗೆ, ಪಾಂಡಾಸ್ ಆಯ್ಕೆಯ ಸಾಧನವಾಗಿದೆ. `influxdb-client` ಲೈಬ್ರರಿಯು ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ನಿಂದ ನೇರವಾಗಿ ಡೇಟಾ ಬರೆಯಲು ಪ್ರಥಮ-ದರ್ಜೆಯ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ, ಇದು ನಂಬಲಾಗದಷ್ಟು ಶಕ್ತಿಯುತವಾಗಿದೆ.
ಕ್ಲೈಂಟ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಡೇಟಾಫ್ರೇಮ್ ಕಾಲಮ್‌ಗಳನ್ನು ಮೆಷರ್‌ಮೆಂಟ್‌ಗಳು, ಟ್ಯಾಗ್‌ಗಳು, ಫೀಲ್ಡ್‌ಗಳು ಮತ್ತು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡಬಹುದು.
import pandas as pd
import numpy as np
# Create a sample DataFrame
now = pd.Timestamp.now(tz='UTC')
dates = pd.to_datetime([now - pd.Timedelta(minutes=i) for i in range(10)])
data = {
'price': np.random.uniform(100, 110, 10),
'volume': np.random.randint(1000, 5000, 10),
'symbol': 'XYZ',
'exchange': 'GLOBALEX'
}
df = pd.DataFrame(data=data, index=dates)
# The DataFrame must have a timezone-aware DatetimeIndex
print("Sample DataFrame:")
print(df)
# Write the DataFrame to InfluxDB
# data_frame_measurement_name: The measurement name to use
# data_frame_tag_columns: Columns to be treated as tags
write_api.write(
bucket=bucket,
record=df,
data_frame_measurement_name='stock_prices',
data_frame_tag_columns=['symbol', 'exchange']
)
print(f"\nWrote DataFrame to measurement 'stock_prices' in bucket '{bucket}'.")
# Remember to close the client
client.close()
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಡೇಟಾಫ್ರೇಮ್‌ನ ಇಂಡೆಕ್ಸ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಆಗಿ ಬಳಸಲ್ಪಡುತ್ತದೆ. ನಾವು `symbol` ಮತ್ತು `exchange` ಕಾಲಮ್‌ಗಳನ್ನು ಟ್ಯಾಗ್‌ಗಳಾಗಿ ಪರಿಗಣಿಸಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ, ಮತ್ತು ಉಳಿದ ಸಂಖ್ಯಾತ್ಮಕ ಕಾಲಮ್‌ಗಳು (`price` ಮತ್ತು `volume`) ಫೀಲ್ಡ್‌ಗಳಾಗುತ್ತವೆ.
ಪೈಥಾನ್ ಮತ್ತು ಫ್ಲಕ್ಸ್‌ನೊಂದಿಗೆ ಡೇಟಾ ಪ್ರಶ್ನಿಸುವುದು
ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಕೇವಲ ಅರ್ಧದಷ್ಟು ಯುದ್ಧ. ನಿಜವಾದ ಶಕ್ತಿಯು ಅದನ್ನು ಪ್ರಶ್ನಿಸಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು ಸಾಧ್ಯವಾಗುವುದರಿಂದ ಬರುತ್ತದೆ. InfluxDB 2.x ಫ್ಲಕ್ಸ್ ಎಂಬ ಶಕ್ತಿಯುತ ಡೇಟಾ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಯನ್ನು ಬಳಸುತ್ತದೆ.
ಫ್ಲಕ್ಸ್‌ಗೆ ಪರಿಚಯ
ಫ್ಲಕ್ಸ್ ಎಂಬುದು ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾವನ್ನು ಪ್ರಶ್ನಿಸಲು, ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು ಅದರ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಒಂದು ಫಂಕ್ಷನಲ್ ಭಾಷೆಯಾಗಿದೆ. ಇದು ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡಿಸಲು ಪೈಪ್-ಫಾರ್ವರ್ಡ್ ಆಪರೇಟರ್ (`|>`) ಅನ್ನು ಬಳಸುತ್ತದೆ, ಓದಲು ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಸಲು ಸುಲಭವಾದ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
ಒಂದು ಸರಳ ಫ್ಲಕ್ಸ್ ಪ್ರಶ್ನೆಯು ಹೀಗಿರುತ್ತದೆ:
from(bucket: "my-bucket")
|> range(start: -1h)
|> filter(fn: (r) => r._measurement == "system_metrics")
|> filter(fn: (r) => r.host == "server-alpha")
ಈ ಪ್ರಶ್ನೆಯು `my-bucket` ನಿಂದ ಡೇಟಾವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಅದನ್ನು ಕಳೆದ ಗಂಟೆಗೆ ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ನಂತರ ನಿರ್ದಿಷ್ಟ ಮೆಷರ್‌ಮೆಂಟ್ ಮತ್ತು ಹೋಸ್ಟ್ ಟ್ಯಾಗ್‌ಗಾಗಿ ಮತ್ತಷ್ಟು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ.
ಪೈಥಾನ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಮೊದಲ ಫ್ಲಕ್ಸ್ ಪ್ರಶ್ನೆ
ಡೇಟಾವನ್ನು ಪ್ರಶ್ನಿಸಲು, ನೀವು ನಿಮ್ಮ ಕ್ಲೈಂಟ್‌ನಿಂದ `QueryAPI` ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಪಡೆಯಬೇಕು.
# --- Re-establish connection for querying ---
client = influxdb_client.InfluxDBClient(url=url, token=token, org=org)
query_api = client.query_api()
# --- Define the Flux query ---
flux_query = f'''
from(bucket: "{bucket}")
|> range(start: -10m)
|> filter(fn: (r) => r._measurement == "environment")
'''
# --- Execute the query ---
result_tables = query_api.query(query=flux_query, org=org)
print("Query executed. Processing results...")
ಪ್ರಶ್ನೆ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಸ್ಕರಿಸುವುದು
ಫ್ಲಕ್ಸ್ ಪ್ರಶ್ನೆಯ ಫಲಿತಾಂಶವು ಟೇಬಲ್‌ಗಳ ಒಂದು ಸ್ಟ್ರೀಮ್ ಆಗಿದೆ. ಪ್ರತಿ ಟೇಬಲ್ ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳ ಒಂದು ವಿಶಿಷ್ಟ ಗುಂಪನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ (ಮೆಷರ್‌ಮೆಂಟ್, ಟ್ಯಾಗ್‌ಗಳು ಇತ್ಯಾದಿಗಳಿಂದ ಗುಂಪು ಮಾಡಲಾಗಿದೆ). ನೀವು ಈ ಟೇಬಲ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ರೆಕಾರ್ಡ್‌ಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಬಹುದು.
# Iterate through tables
for table in result_tables:
print(f"--- Table (series for tags: {table.records[0].values}) ---")
# Iterate through records in each table
for record in table.records:
print(f"Time: {record.get_time()}, Field: {record.get_field()}, Value: {record.get_value()}")
print("\nFinished processing query results.")
ಈ ಕಚ್ಚಾ ಸಂಸ್ಕರಣೆಯು ಕಸ್ಟಮ್ ಲಾಜಿಕ್‌ಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ, ಆದರೆ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಗಾಗಿ, ಡೇಟಾವನ್ನು ನೇರವಾಗಿ ಪರಿಚಿತ ರಚನೆಗೆ ಪಡೆಯುವುದು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ.
ಸುಧಾರಿತ ಪ್ರಶ್ನಿಸುವಿಕೆ: ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ ಮತ್ತು ರೂಪಾಂತರ
ನೀವು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಗಳನ್ನು ನಿರ್ವಹಿಸಿದಾಗ ಫ್ಲಕ್ಸ್ ನಿಜವಾಗಿಯೂ ಹೊಳೆಯುತ್ತದೆ. ನಾವು ಮೊದಲು ಬರೆದ `environment` ಡೇಟಾಗಾಗಿ ಪ್ರತಿ 2 ನಿಮಿಷಗಳಿಗೊಮ್ಮೆ ಸರಾಸರಿ ತಾಪಮಾನವನ್ನು ಕಂಡುಹಿಡಿಯೋಣ.
flux_aggregate_query = f'''
from(bucket: "{bucket}")
|> range(start: -1h)
|> filter(fn: (r) => r._measurement == "environment")
|> filter(fn: (r) => r._field == "temperature")
|> window(every: 2m)
|> mean()
|> yield(name: "mean_temperature")
'''
# Execute and process
aggregated_results = query_api.query(query=flux_aggregate_query, org=org)
print("\n--- Aggregated Results (Average Temperature per 2m) ---")
for table in aggregated_results:
for record in table.records:
print(f"Time Window End: {record.get_time()}, Average Temp: {record.get_value():.2f}")
ಇಲ್ಲಿ, `window(every: 2m)` ಡೇಟಾವನ್ನು 2-ನಿಮಿಷದ ಮಧ್ಯಂತರಗಳಾಗಿ ಗುಂಪು ಮಾಡುತ್ತದೆ, ಮತ್ತು `mean()` ಪ್ರತಿ ವಿಂಡೋಗೆ ಸರಾಸರಿ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.
ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗೆ ನೇರವಾಗಿ ಪ್ರಶ್ನಿಸುವುದು
ಪೈಥಾನ್ ಡೇಟಾ ಸೈನ್ಸ್ ಸ್ಟಾಕ್‌ನೊಂದಿಗೆ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯನ್ನು ಸಂಯೋಜಿಸಲು ಅತ್ಯಂತ ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗೆ ನೇರವಾಗಿ ಪ್ರಶ್ನಿಸುವುದು. `query_api` ಇದಕ್ಕಾಗಿ ಒಂದು ಮೀಸಲಾದ ವಿಧಾನವನ್ನು ಹೊಂದಿದೆ: `query_data_frame()`.
# --- Query stock prices into a DataFrame ---
flux_df_query = f'''
from(bucket: "{bucket}")
|> range(start: -1h)
|> filter(fn: (r) => r._measurement == "stock_prices")
|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
'''
# Execute the query
df_result = query_api.query_data_frame(query=flux_df_query, org=org)
# The result might have extra columns, let's clean it up
if not df_result.empty:
df_result = df_result[['_time', 'symbol', 'price', 'volume']]
df_result.set_index('_time', inplace=True)
print("\n--- Query Result as Pandas DataFrame ---")
print(df_result)
else:
print("\nQuery returned no data.")
client.close()
ಇಲ್ಲಿ ಫ್ಲಕ್ಸ್‌ನಲ್ಲಿನ `pivot()` ಫಂಕ್ಷನ್ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಇದು ಡೇಟಾವನ್ನು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯ ಟಾಲ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಿಂದ (ಪ್ರತಿ ಫೀಲ್ಡ್‌ಗೆ ಒಂದು ಸಾಲು) ವೈಡ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ (ಪ್ರತಿ ಫೀಲ್ಡ್‌ಗೆ ಕಾಲಮ್‌ಗಳು) ಪರಿವರ್ತಿಸುತ್ತದೆ, ಇದು ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾಫ್ರೇಮ್‌ನಲ್ಲಿ ನಿರೀಕ್ಷಿಸುವುದಾಗಿದೆ. ಡೇಟಾ ಈಗ ಪಾಂಡಾಸ್‌ನಲ್ಲಿದ್ದಾಗ, ನೀವು ದೃಶ್ಯೀಕರಣ ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆಗಾಗಿ ಮ್ಯಾಟ್‌ಪ್ಲಾಟ್‌ಲಿಬ್, ಸೀಬಾರ್ನ್, ಅಥವಾ scikit-learn ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಬಹುದು.
ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಯ ಪ್ರಕರಣ: ಸಿಸ್ಟಮ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದು
ಸ್ಥಳೀಯ ಸಿಸ್ಟಮ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು (ಸಿಪಿಯು ಮತ್ತು ಮೆಮೊರಿ) ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಮತ್ತು ಅವುಗಳನ್ನು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಗೆ ಲಾಗ್ ಮಾಡುವ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಎಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಸೇರಿಸೋಣ.
ಮೊದಲಿಗೆ, ನಿಮಗೆ `psutil` ಲೈಬ್ರರಿ ಬೇಕಾಗುತ್ತದೆ:
pip install psutil
ಮೇಲ್ವಿಚಾರಣಾ ಸ್ಕ್ರಿಪ್ಟ್
ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಚಾಲನೆಯಾಗುತ್ತದೆ, ಪ್ರತಿ 10 ಸೆಕೆಂಡುಗಳಿಗೊಮ್ಮೆ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ ಬರೆಯುತ್ತದೆ.
import influxdb_client
from influxdb_client import Point
from influxdb_client.client.write_api import SYNCHRONOUS
import psutil
import time
import socket
# --- Configuration ---
url = "http://localhost:8086"
token = "YOUR_SUPER_SECRET_TOKEN" # Replace with your token
org = "my-org"
bucket = "monitoring"
# Get the hostname to use as a tag
hostname = socket.gethostname()
# --- Main Monitoring Loop ---
def monitor_system():
print("Starting system monitor...")
with influxdb_client.InfluxDBClient(url=url, token=token, org=org) as client:
write_api = client.write_api(write_options=SYNCHRONOUS)
while True:
try:
# Get metrics
cpu_percent = psutil.cpu_percent(interval=1)
memory_percent = psutil.virtual_memory().percent
# Create data points
cpu_point = (
Point("system_stats")
.tag("host", hostname)
.field("cpu_usage_percent", float(cpu_percent))
)
memory_point = (
Point("system_stats")
.tag("host", hostname)
.field("memory_usage_percent", float(memory_percent))
)
# Write batch
write_api.write(bucket=bucket, org=org, record=[cpu_point, memory_point])
print(f"Logged CPU: {cpu_percent}%, Memory: {memory_percent}%")
# Wait for the next interval
time.sleep(10)
except KeyboardInterrupt:
print("\nMonitoring stopped by user.")
break
except Exception as e:
print(f"An error occurred: {e}")
time.sleep(10) # Wait before retrying
if __name__ == "__main__":
# Note: You may need to create the 'monitoring' bucket in the InfluxDB UI first.
monitor_system()
ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸುವುದು
ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕೆಲವು ನಿಮಿಷಗಳ ಕಾಲ ಚಲಾಯಿಸಿದ ನಂತರ, `http://localhost:8086` ನಲ್ಲಿರುವ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ UI ಗೆ ಹಿಂತಿರುಗಿ. ಡೇಟಾ ಎಕ್ಸ್‌ಪ್ಲೋರರ್ (ಅಥವಾ ಎಕ್ಸ್‌ಪ್ಲೋರ್) ಟ್ಯಾಬ್‌ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಿ. ನಿಮ್ಮ `monitoring` ಬಕೆಟ್, `system_stats` ಮೆಷರ್‌ಮೆಂಟ್ ಮತ್ತು ನೀವು ದೃಶ್ಯೀಕರಿಸಲು ಬಯಸುವ ಫೀಲ್ಡ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು UI ಬಿಲ್ಡರ್ ಅನ್ನು ಬಳಸಿ. ನಿಮ್ಮ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ಚಾಲಿತವಾದ ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ನ ಸಿಪಿಯು ಮತ್ತು ಮೆಮೊರಿ ಬಳಕೆಯ ಲೈವ್ ಗ್ರಾಫ್ ಅನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ!
ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಸುಧಾರಿತ ವಿಷಯಗಳು
ದೃಢವಾದ ಮತ್ತು ಅಳೆಯಬಹುದಾದ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸಿ.
ಸ್ಕೀಮಾ ವಿನ್ಯಾಸ: ಟ್ಯಾಗ್‌ಗಳು vs. ಫೀಲ್ಡ್‌ಗಳು
- ನೀವು ಪ್ರಶ್ನಿಸುವ ಮೆಟಾಡೇಟಾಗಾಗಿ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಬಳಸಿ. ಟ್ಯಾಗ್‌ಗಳನ್ನು ಇಂಡೆಕ್ಸ್ ಮಾಡಲಾಗುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಅವುಗಳ ಮೇಲೆ `filter()` ಕಾರ್ಯಾಚರಣೆಗಳು ಬಹಳ ವೇಗವಾಗಿರುತ್ತವೆ. ಹೋಸ್ಟ್‌ಹೆಸರುಗಳು, ಪ್ರದೇಶಗಳು, ಸೆನ್ಸರ್ ಐಡಿಗಳು, ಅಥವಾ ನಿಮ್ಮ ಮೆಷರ್‌ಮೆಂಟ್‌ಗಳನ್ನು ವಿವರಿಸುವ ಯಾವುದೇ ಕಡಿಮೆ-ಮಧ್ಯಮ ಕಾರ್ಡಿನಾಲಿಟಿ ಡೇಟಾವು ಟ್ಯಾಗ್‌ಗಳಿಗೆ ಉತ್ತಮ ಅಭ್ಯರ್ಥಿಗಳಾಗಿವೆ.
- ಕಚ್ಚಾ ಡೇಟಾ ಮೌಲ್ಯಗಳಿಗಾಗಿ ಫೀಲ್ಡ್‌ಗಳನ್ನು ಬಳಸಿ. ಫೀಲ್ಡ್‌ಗಳನ್ನು ಇಂಡೆಕ್ಸ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಫೀಲ್ಡ್ ಮೌಲ್ಯದಿಂದ ಫಿಲ್ಟರ್ ಮಾಡುವುದು ಹೆಚ್ಚು ನಿಧಾನವಾಗಿರುತ್ತದೆ. ಬಹುತೇಕ ಪ್ರತಿ ಡೇಟಾ ಪಾಯಿಂಟ್‌ನೊಂದಿಗೆ ಬದಲಾಗುವ ಯಾವುದೇ ಮೌಲ್ಯ (ತಾಪಮಾನ ಅಥವಾ ಬೆಲೆಯಂತಹ) ಒಂದು ಫೀಲ್ಡ್ ಆಗಿರಬೇಕು.
- ಕಾರ್ಡಿನಾಲಿಟಿ ಮುಖ್ಯ. ಟ್ಯಾಗ್‌ಗಳಲ್ಲಿನ ಹೆಚ್ಚಿನ ಕಾರ್ಡಿನಾಲಿಟಿ (ದೊಡ್ಡ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಬಳಕೆದಾರರ ಐಡಿಯಂತಹ ಅನೇಕ ವಿಶಿಷ್ಟ ಮೌಲ್ಯಗಳು) ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ನಿಮ್ಮ ಸ್ಕೀಮಾವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ ಇದನ್ನು ಗಮನದಲ್ಲಿಡಿ.
ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವ
ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕಗಳು ವಿಫಲವಾಗಬಹುದು. ಸಂಭಾವ್ಯ ವಿನಾಯಿತಿಗಳನ್ನು ಸೌಜನ್ಯಯುತವಾಗಿ ನಿರ್ವಹಿಸಲು ನಿಮ್ಮ ಬರವಣಿಗೆ ಮತ್ತು ಪ್ರಶ್ನೆ ಕರೆಗಳನ್ನು ಯಾವಾಗಲೂ `try...except` ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವರಿಯಿರಿ. `influxdb-client` ಸಹ ಅಂತರ್ನಿರ್ಮಿತ ಮರುಪ್ರಯತ್ನ ತಂತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಇವುಗಳನ್ನು ನೀವು ಹೆಚ್ಚು ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವಕ್ಕಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು.
ಭದ್ರತೆ: ಟೋಕನ್ ನಿರ್ವಹಣೆ
- ನಿಮ್ಮ ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿ ಟೋಕನ್‌ಗಳನ್ನು ಎಂದಿಗೂ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಬೇಡಿ. ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳು ಅಥವಾ HashiCorp Vault ಅಥವಾ AWS Secrets Manager ನಂತಹ ರಹಸ್ಯಗಳ ನಿರ್ವಹಣಾ ಸೇವೆಯನ್ನು ಬಳಸಿ.
- ಸೂಕ್ಷ್ಮ-ಧಾನ್ಯದ ಟೋಕನ್‌ಗಳನ್ನು ಬಳಸಿ. ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿ UI ನಲ್ಲಿ, API Tokens ಅಡಿಯಲ್ಲಿ, ನೀವು ನಿರ್ದಿಷ್ಟ ಅನುಮತಿಗಳೊಂದಿಗೆ ಹೊಸ ಟೋಕನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ಡೇಟಾವನ್ನು ಮಾತ್ರ ಬರೆಯುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ, ನಿರ್ದಿಷ್ಟ ಬಕೆಟ್‌ಗೆ ಬರೆಯಲು-ಮಾತ್ರ ಪ್ರವೇಶದೊಂದಿಗೆ ಟೋಕನ್ ಅನ್ನು ರಚಿಸಿ. ಇದು ಕನಿಷ್ಠ ಸವಲತ್ತುಗಳ ತತ್ವವನ್ನು ಅನುಸರಿಸುತ್ತದೆ.
ಡೇಟಾ ಧಾರಣ ನೀತಿಗಳು
ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾವು ನಂಬಲಾಗದಷ್ಟು ವೇಗವಾಗಿ ಬೆಳೆಯಬಹುದು. ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯ ಧಾರಣ ನೀತಿಗಳು ನಿರ್ದಿಷ್ಟ ಅವಧಿಗಿಂತ ಹಳೆಯದಾದ ಡೇಟಾವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳಿಸುತ್ತವೆ. ನಿಮ್ಮ ಡೇಟಾ ಜೀವನಚಕ್ರವನ್ನು ಯೋಜಿಸಿ: ನೀವು 30 ದಿನಗಳವರೆಗೆ ಹೆಚ್ಚಿನ-ರೆಸಲ್ಯೂಶನ್ ಡೇಟಾವನ್ನು ಇರಿಸಬಹುದು ಆದರೆ ಡೌನ್‌ಸ್ಯಾಂಪಲ್ ಮಾಡಿದ, ಒಟ್ಟುಗೂಡಿಸಿದ ಡೇಟಾವನ್ನು (ಉದಾ., ದೈನಂದಿನ ಸರಾಸರಿಗಳು) ಮತ್ತೊಂದು ಬಕೆಟ್‌ನಲ್ಲಿ ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಸಂಗ್ರಹಿಸಬಹುದು.
ತೀರ್ಮಾನ
ಪೈಥಾನ್ ಮತ್ತು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯ ಸಂಯೋಜನೆಯು ಯಾವುದೇ ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾ ಸವಾಲನ್ನು ಎದುರಿಸಲು ಒಂದು ಪ್ರಬಲ ವೇದಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಾವು ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯ ಡೇಟಾ ಮಾದರಿಯ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳಿಂದ ಹಿಡಿದು ಅಧಿಕೃತ ಪೈಥಾನ್ ಕ್ಲೈಂಟ್ ಬಳಸಿ ಡೇಟಾವನ್ನು ಬರೆಯುವ ಮತ್ತು ಪ್ರಶ್ನಿಸುವ ಪ್ರಾಯೋಗಿಕತೆಗಳವರೆಗೆ ಪ್ರಯಾಣಿಸಿದ್ದೇವೆ. ನೀವು ಒಂದೇ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಬರೆಯುವುದು, ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಡೇಟಾವನ್ನು ಬ್ಯಾಚ್ ಮಾಡುವುದು ಮತ್ತು ಶಕ್ತಿಯುತ ಪಾಂಡಾಸ್ ಲೈಬ್ರರಿಯೊಂದಿಗೆ ಮನಬಂದಂತೆ ಸಂಯೋಜಿಸುವುದು ಹೇಗೆಂದು ಕಲಿತಿದ್ದೀರಿ.
ಸ್ಕೀಮಾ ವಿನ್ಯಾಸ, ಭದ್ರತೆ, ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನೀವು ಈಗ ಅಳೆಯಬಹುದಾದ, ಸ್ಥಿತಿಸ್ಥಾಪಕ, ಮತ್ತು ಒಳನೋಟವುಳ್ಳ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸುಸಜ್ಜಿತರಾಗಿದ್ದೀರಿ. ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾದ ಜಗತ್ತು ವಿಶಾಲವಾಗಿದೆ, ಮತ್ತು ಈಗ ಅದನ್ನು ಅನ್ವೇಷಿಸಲು ನಿಮ್ಮ ಬಳಿ ಮೂಲಭೂತ ಸಾಧನಗಳಿವೆ.
ನಿಮ್ಮ ಪ್ರಯಾಣದ ಮುಂದಿನ ಹಂತಗಳು ಸ್ವಯಂಚಾಲಿತ ಡೌನ್‌ಸ್ಯಾಂಪ್ಲಿಂಗ್‌ಗಾಗಿ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯ ಕಾರ್ಯ ಎಂಜಿನ್ ಅನ್ನು ಅನ್ವೇಷಿಸುವುದು, ವೈಪರೀತ್ಯ ಪತ್ತೆಗಾಗಿ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಸ್ಥಾಪಿಸುವುದು, ಅಥವಾ ಗ್ರಾಫಾನಾದಂತಹ ದೃಶ್ಯೀಕರಣ ಸಾಧನಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ಸಾಧ್ಯತೆಗಳು ಅಂತ್ಯವಿಲ್ಲ. ಇಂದೇ ನಿಮ್ಮ ಟೈಮ್ ಸೀರೀಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಾರಂಭಿಸಿ!