OpenVPN ಲಾಗ್‌ಗಳು ಯಾರಿಗೆ ಸೇರಿವೆ: ಡೀಮನ್, rsyslog ಅಥವಾ logrotate?

ಲಾಗ್ ತಿರುಗಿಸುವಿಕೆ ಊಹಿಸಬಹುದಾದ ರೀತಿಯಲ್ಲಿ ಮುರಿಯುತ್ತದೆ: ಮೂರು ಘಟಕಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ ಫೈಲ್ ತನ್ನದು ಎಂದು ಭಾವಿಸುತ್ತದೆ, ಮತ್ತು ಫಲಿತಾಂಶವೆಂದರೆ ಹೊಸದು ಖಾಲಿ ಇರುವಾಗಲೇ ಬೆಳೆಯುತ್ತಲೇ ಇರುವ ತಿರುಗಿಸಿದ ಲಾಗ್. ಡೀಮನ್ ಒಂದು ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಹಿಡಿದಿಡುತ್ತದೆ, logrotate ಮಾರ್ಗದ ಹೆಸರು ಬದಲಿಸುತ್ತದೆ, ಮತ್ತು rsyslog ಸಂಪೂರ್ಣ ಬೇರೆಡೆ ಬರುತ್ತದೆ. ರಾಶಿಗೆ ಇನ್ನೊಂದು ನಿಯಮ ಸೇರಿಸುವ ಮೊದಲು ಒಬ್ಬ ಬರಹಗಾರ ಮತ್ತು ಒಬ್ಬ ತಿರುಗಿಸುವವನನ್ನು ಆರಿಸಿ. ಕೆಳಗಿನ ಪರಿಶೀಲನಾ ಪಟ್ಟಿ ಅದೇ ಕ್ರಮದಲ್ಲಿ ಸಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ಪ್ರತಿ ಮುಂದಿನ ಹೆಜ್ಜೆಯೂ ಅದನ್ನು ಅವಲಂಬಿಸಿದೆ.

ಫೈಲ್ ಯಾರು ಬರುತ್ತಾರೆ ಎಂದು ನಿರ್ಧರಿಸಿ

ಎರಡು ವಿನ್ಯಾಸಗಳು ಮಾನ್ಯ. ಮೊದಲನೆಯದರಲ್ಲಿ VPN ಪ್ರಕ್ರಿಯೆ ತನ್ನದೇ log ಅಥವಾ log-append ಆಯ್ಕೆಯ ಮೂಲಕ ಸ್ವತಃ ಫೈಲ್ ಬರುತ್ತದೆ. ಎರಡನೆಯದರಲ್ಲಿ ದಾಖಲೆಗಳನ್ನು ಸಿಸ್ಟಮ್ ಲಾಗರ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು rsyslog ಅಥವಾ journald ಅವು ಎಲ್ಲಿ ಬೀಳುತ್ತವೆ ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ.

ಇವು ಪರ್ಯಾಯಗಳು, ಪದರಗಳಲ್ಲ. ಎರಡನ್ನೂ ಸಕ್ರಿಯಗೊಳಿಸಿದ ಹೋಸ್ಟ್ ಒಪ್ಪದ ಎರಡು ಫೈಲ್‌ಗಳೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ನೀವು ಓದುತ್ತಿರುವುದು ಹೆಚ್ಚಾಗಿ ಹಳೆಯದು. ಮಾರ್ಗವನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಆರಿಸಿ, ನಂತರ ಇನ್ನೊಬ್ಬ ಬರಹಗಾರನನ್ನು ತೆಗೆದುಹಾಕಿ.

ಏನನ್ನೂ ಬದಲಿಸುವ ಮೊದಲು ಸೇವೆಯ ಪರಿಣಾಮಕಾರಿ ಸಂರಚನೆಯನ್ನು ಓದಿ, unit ಫೈಲ್ ಅನ್ನು ಮೀರಿಸಬಹುದಾದ drop-in ಫೈಲ್‌ಗಳೂ ಸೇರಿ. ನೀವು ಸಂಪಾದಿಸಿದ ಪ್ರೊಫೈಲ್‌ನಲ್ಲಿರುವ ಸೂಚನೆ ಅದೇ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆ ಲೋಡ್ ಮಾಡಿದ ಸೂಚನೆ ಎಂಬುದಕ್ಕೆ ಸಾಕ್ಷಿಯಲ್ಲ. unit ಅನ್ನು ಪ್ರಕ್ರಿಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ, ನಂತರ ಅದು ನಿಜವಾಗಿ ತೆರೆದ ಫೈಲ್‌ಗಳೊಂದಿಗೆ ಹೋಲಿಸಿ.

ಫಿಲ್ಟರ್ ಸಣ್ಣದಾಗಿರಲು ಡೀಮನ್‌ಗೆ ಹೆಸರು ಕೊಡಿ

syslog ಮಾರ್ಗದಲ್ಲಿ ಡೀಮನ್‌ಗೆ ಪ್ರತ್ಯೇಕ ಗುರುತನ್ನು ಕೊಡಿ ಮತ್ತು ಅದರ ಮೇಲೆ ಫಿಲ್ಟರ್ ಮಾಡಿ. ಈ VPN ಆವೃತ್ತಿಯ ಪ್ರೋಗ್ರಾಂ ಹೆಸರಿಗೆ ಹೊಂದುವ ನಿಯಮ ಅದರ ದಾಖಲೆಗಳನ್ನು ಧಾರಣಾ ನೀತಿ ಬೇರೆಯದಕ್ಕೆ ಸೇರಿದ ಹಂಚಿದ ಫೈಲ್‌ನಿಂದ ಹೊರಗಿಡುತ್ತದೆ.

ಸಣ್ಣ ನಿಯಮಗಳು ಮುಂದಿನ ಪ್ರಶ್ನೆಗೂ ಉತ್ತರಿಸಲು ಅವಕಾಶ ಕೊಡುತ್ತವೆ: ಈ ಸಾಲನ್ನು ಯಾವ ಸೇವೆ ಉತ್ಪಾದಿಸಿತು? VPN ಪದವಿರುವ ಎಲ್ಲದಕ್ಕೂ ಹೊಂದುವ ಫಿಲ್ಟರ್ ಎರಡನೇ ಸುರಂಗದ ಸಂಚಾರವನ್ನೂ ಸಂತೋಷದಿಂದ ಸಂಗ್ರಹಿಸಿ ಎರಡನ್ನೂ ಮಸುಕಾಗಿಸುತ್ತದೆ. unit ಲಾಗರ್‌ಗೆ ನೀಡುವ ನಿಖರ ಗುರುತಿಗೆ ಹೊಂದಿಸಿ.

ಕ್ರಿಯೆಯ ನಂತರ ನಿಯಮವನ್ನು ಮುಚ್ಚಿ, ದಾಖಲೆಗಳು ಡಿಫಾಲ್ಟ್ ಗಮ್ಯಸ್ಥಾನಕ್ಕೂ ಬೀಳದಂತೆ. ಎರಡು ಫೈಲ್‌ಗಳಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಸಾಲುಗಳು ಲಾಗಿಂಗ್ ದೋಷದಂತೆ ಕಾಣುತ್ತವೆ, ವಾಸ್ತವದಲ್ಲಿ ಅವು ಕಾಣೆಯಾದ ನಿಲುಗಡೆ. ಆ ಒಂದೇ ಬಿಟ್ಟುಬಿಡುವಿಕೆ ಧಾರಣಾ ನೀತಿಯ ಡಿಸ್ಕ್ ವೆಚ್ಚವನ್ನೂ ದ್ವಿಗುಣಗೊಳಿಸುತ್ತದೆ.

ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಕಳೆದುಕೊಳ್ಳದೆ ತಿರುಗಿಸಿ

ಡೀಮನ್ ಫೈಲ್ ಬರೆಯುವಾಗ, logrotate ಮಾರ್ಗದ ಹೆಸರು ಬದಲಿಸುತ್ತದೆ ಆದರೆ ಪ್ರಕ್ರಿಯೆ ತನ್ನ ತೆರೆದ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಹಿಡಿದಿಡುತ್ತದೆ. ಹೊಸ ದಾಖಲೆಗಳು ಹೆಸರು ಬದಲಾದ ಫೈಲ್‌ಗೆ ಮುಂದುವರಿಯುತ್ತವೆ, ಯಾವುದೋ ಒಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮೂಲ ಮಾರ್ಗವನ್ನು ಮತ್ತೆ ತೆರೆಯಲು ಒತ್ತಾಯಿಸುವವರೆಗೆ; ಆದ್ದರಿಂದ ತಿರುಗಿಸುವಿಕೆ ಕೆಲಸ ಮಾಡುತ್ತಿರುವಂತೆ ಕಾಣಬಹುದು, ಹೊಸ ಫೈಲ್ ಖಾಲಿ ಇರುವಾಗಲೇ.

ಪರಿಹಾರವೆಂದರೆ ಸೇವೆಯ ದಾಖಲಿತ ಮರುಲೋಡ್ ಅಥವಾ ಮರುಪ್ರಾರಂಭದ ವರ್ತನೆಯನ್ನು ಪ್ರಚೋದಿಸುವ postrotate ಕ್ರಿಯೆ. ಲಾಗರ್‌ಗೆ ಸಿಗ್ನಲ್ ಕಳುಹಿಸುವುದು ಸಂಪೂರ್ಣ ಬೇರೆ ಕ್ರಿಯೆ ಮತ್ತು ತನ್ನದೇ ಫೈಲ್ ಹಿಡಿದಿರುವ ಡೀಮನ್‌ಗೆ ಏನೂ ಮಾಡುವುದಿಲ್ಲ.

ಮತ್ತೆ ತೆರೆಯುವುದು ಅಸಾಧ್ಯವಾದಲ್ಲಿ copytruncate ಪರ್ಯಾಯ: ಫೈಲ್ ನಕಲಿಸಿ, ನಂತರ ಅಲ್ಲೇ ಕತ್ತರಿಸಿ. ಇದು ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಮಾನ್ಯವಾಗಿರಿಸುತ್ತದೆ, ಆದರೆ ನಕಲು ಮತ್ತು ಕತ್ತರಿಸುವಿಕೆಯ ನಡುವೆ ಬರೆದ ಎಲ್ಲವನ್ನೂ ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ ಇದು ಪರಿಹಾರವಲ್ಲ, ವಿನಿಮಯ. ಭಾರದಲ್ಲಿ ಆ ಸಂದು ನೀವು ಹಿಡಿಯಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ವೈಫಲ್ಯವನ್ನೇ ನುಂಗಬಹುದು.

ಪ್ರತಿ ಫೈಲ್‌ಗೆ ಎರಡರಲ್ಲಿ ಒಂದನ್ನು ಆರಿಸಿ ಮತ್ತು ಆಯ್ಕೆಯನ್ನು ಬರೆದಿಡಿ, ಏಕೆಂದರೆ ಒಂದೇ ಮಾರ್ಗದಲ್ಲಿ ಎರಡನ್ನೂ ಮಿಶ್ರ ಮಾಡಿದರೆ ನಂತರ ಆರೋಪಿಸಲು ತುಂಬಾ ಕಷ್ಟವಾದ ಸಂದುಗಳು ಉಂಟಾಗುತ್ತವೆ. ಒಂದೇ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಎರಡೂ ಮಾದರಿಗಳನ್ನು ಕಂಡ ಓದುಗ ಯಾವುದು ಪ್ರಾಮಾಣಿಕ ಎಂದು ಹೇಳಲಾರ.

ಘಟನೆಯ ಕಿಟಕಿಯಿಂದ ಧಾರಣೆಯನ್ನು ನಿಗದಿಪಡಿಸಿ

ಧಾರಣೆ, ಸಂಕೋಚನ ಮತ್ತು ಗರಿಷ್ಠ ಗಾತ್ರವು ನೀವು ನಿಜವಾಗಿ ಎಷ್ಟು ಹಿಂದಕ್ಕೆ ತನಿಖೆ ಮಾಡುತ್ತೀರಿ ಎಂಬುದರಿಂದ ಬರಬೇಕು. ಸಂಕೋಚನ ಮತ್ತು ಗಾತ್ರ ಮಿತಿಯೊಂದಿಗೆ ಏಳು ದಿನಗಳ ಕಿಟಕಿ ಅನೇಕ ನಿಯೋಜನೆಗಳಿಗೆ ಸೂಕ್ತ ಆರಂಭ; ಟ್ಯುಟೋರಿಯಲ್‌ನಿಂದ ನಕಲಿಸಿದ ಸಂಖ್ಯೆ ಅಲ್ಲ.

ನೀತಿಯನ್ನು ಒಂದೇ ಕಡೆ ಇರಿಸಿ. logrotate ಫೈಲ್ ತಿರುಗಿಸಿದರೆ ಮತ್ತು rsyslog ಕೂಡ ಅದನ್ನು ತಿರುಗಿಸಿದರೆ, ಎರಡನೇ ತಿರುಗಿಸುವಿಕೆ ಗೆಲ್ಲುತ್ತದೆ ಮತ್ತು ಮೊದಲನೆಯ ಹೆಸರಿಸುವ ಯೋಜನೆ ಗೊಂದಲವಾಗಿ ಉಳಿಯುತ್ತದೆ. ಮಾಲೀಕನನ್ನು ಆರಿಸಿ, ಇನ್ನೊಂದು ತಿರುಗಿಸುವಿಕೆಯನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ, ಮತ್ತು ಆ ನಿರ್ಧಾರವನ್ನು ನೀತಿಯ ಪಕ್ಕದಲ್ಲಿ ಬರೆಯಿರಿ.

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

ಒಂದು ತಿರುಗಿಸುವಿಕೆ ಮತ್ತು ಒಂದು ಹೊಸ ಘಟನೆಯನ್ನು ಪರೀಕ್ಷಿಸಿ

ಒಂದೇ ತಿರುಗಿಸುವಿಕೆಯನ್ನು ಬಲವಂತಪಡಿಸಿ, ನಂತರ ಒಂದು ಹೊಸ ಘಟನೆಯನ್ನು ಸೃಷ್ಟಿಸಿ, ಉದಾಹರಣೆಗೆ ವಿಫಲ ದೃಢೀಕರಣ. ಹೊಸ ದಾಖಲೆ ಹೊಸ ಫೈಲ್‌ನಲ್ಲಿ ಕಾಣಿಸುತ್ತದೆ ಮತ್ತು ಹಳೆಯ ಫೈಲ್ ಬೆಳೆಯುವುದನ್ನು ನಿಲ್ಲಿಸಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿ.

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

ಪ್ರತಿ ಹೆಜ್ಜೆಯ ಮಾಲೀಕನನ್ನು ದಾಖಲಿಸಿ ಮುಗಿಸಿ: ಯಾವ ಘಟಕ ಬರುತ್ತದೆ, ಯಾವುದು ತಿರುಗಿಸುತ್ತದೆ, ಮತ್ತು ಧಾರಣಾ ನೀತಿ ಎಲ್ಲಿದೆ. ಆ ದಾಖಲೆಯೇ ಮುಂದಿನ ಲಾಗಿಂಗ್ ಘಟನೆಯನ್ನು ಯಾವ ಪದರ ಸಾಲನ್ನು ಬೀಳಿಸಿತು ಎಂದು ಊಹಿಸುವ ಅರ್ಧ ದಿನದ ಬದಲು ಐದು ನಿಮಿಷದ ಪರಿಶೀಲನೆಯಾಗಿ ಮಾರ್ಪಡಿಸುತ್ತದೆ.