Moviento 0deps: ಸ್ಥಳೀಯ ಅವಲಂಬನೆಗಳು ಮತ್ತು ಭದ್ರತೆ
ಹೆಚ್ಚಿನ ಪ್ರಾಜೆಕ್ಟ್ಗಳಲ್ಲಿ ಸಾಫ್ಟ್ವೇರ್ ಡೆವಲಪರ್ಗಳು ನೂರಾರು ಬಾಹ್ಯ ಲೈಬ್ರರಿಗಳನ್ನು (external libraries) ಇನ್ಸ್ಟಾಲ್ ಮಾಡುತ್ತಾರೆ. ಆಧುನಿಕ ಫ್ರೇಮ್ವರ್ಕ್ಗಳು ಸಾವಿರಾರು ಟ್ರಾನ್ಸಿಟಿವ್ ಅವಲಂಬನೆಗಳನ್ನು (transitive dependencies) ಅವಲಂಬಿಸಿವೆ. ಇದರರ್ಥ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ನೂರಾರು ಅಪರಿಚಿತ ವ್ಯಕ್ತಿಗಳು ಬರೆದ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ.
ಈ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯು ಅಭಿವೃದ್ಧಿಯ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಆದರೆ ಇದು ಬೃಹತ್ ಸಪ್ಲೈ ಚೈನ್ ರಿಸ್ಕ್ಗಳನ್ನು (supply chain risks) ಕೂಡ ಸೃಷ್ಟಿಸುತ್ತದೆ.
0deps ಚಳುವಳಿಯು ಒಂದು ಸರಳ ಪ್ರಶ್ನೆಯನ್ನು ಕೇಳುತ್ತದೆ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೇವಲ ನೀವು ನಿಯಂತ್ರಿಸುವ ಕೋಡ್ ಅನ್ನು ಮಾತ್ರ ರನ್ ಮಾಡಿದರೆ ಏನಾಗಬಹುದು?
ಪ್ರತಿಯೊಂದು ಅವಲಂಬನೆಯು ಹೊಸ ಅಟ್ಯಾಕ್ ಸರ್ಫೇಸ್ ಅನ್ನು (attack surface) ಸೇರಿಸುತ್ತದೆ. ಒಂದು ಅವಲಂಬನೆಯು ಹೀಗೆ ಮಾಡಬಹುದು:
- ಭದ್ರತಾ ಲೋಪಗಳನ್ನು (security flaws) ಉಂಟುಮಾಡಬಹುದು.
- ಸಪ್ಲೈ ಚೈನ್ ಅಟ್ಯಾಕ್ಗಳಿಗೆ ಗುರಿಯಾಗಬಹುದು.
- ತನ್ನ ಸೃಷ್ಟಿಕರ್ತನಿಂದ ಕೈಬಿಡಲ್ಪಡಬಹುದು.
- ತನ್ನ ಪಬ್ಲಿಕ್ API ಅನ್ನು ಬದಲಾಯಿಸಬಹುದು.
- ಬ್ಯಾಕ್ವರ್ಡ್ ಕಾಂಪ್ಯಾಟಿಬಿಲಿಟಿಯನ್ನು (backward compatibility) ಹಾಳುಮಾಡಬಹುದು.
0deps ಮಾದರಿಯಲ್ಲಿ, ನೀವು ಎಲ್ಲಾ ಅಗತ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ನೇರವಾಗಿ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿಗೆ (repository) ವರ್ಗಾಯಿಸುತ್ತೀರಿ. ಬಿಲ್ಡ್ ಸಮಯದಲ್ಲಿ ಪ್ಯಾಕೇಜ್ಗಳನ್ನು ಡೈನಾಮಿಕವಾಗಿ ಡೌನ್ಲೋಡ್ ಮಾಡುವುದನ್ನು ನೀವು ನಿಲ್ಲಿಸುತ್ತೀರಿ. ನೀವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕ್ಲೋನ್ ಮಾಡಿದ ಕ್ಷಣದಿಂದಲೇ ಅದನ್ನು ರನ್ ಮಾಡಲು ಬೇಕಾದ ಎಲ್ಲವೂ ರೆಪೊಸಿಟರಿಯಲ್ಲಿಯೇ ಇರುತ್ತದೆ.
ಈ ವಿಧಾನವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:
- ಪುನರಾವರ್ತಿತ ಬಿಲ್ಡ್ಗಳು (Reproducible builds).
- ಬಾಹ್ಯ ಪ್ಯಾಕೇಜ್ ರಿಜಿಸ್ಟರಿಗಳ ಮೇಲಿನ ಅವಲಂಬನೆ ಕಡಿಮೆ ಇರುತ್ತದೆ.
- ಕೇಂದ್ರೀಕೃತ ಭದ್ರತಾ ಆಡಿಟ್ಗಳು (Centralized security audits).
- ಊಹಿಸಬಹುದಾದ ಫಲಿತಾಂಶಗಳು.
ಗುರಿಯು ಕೋಡ್ ಅನ್ನು ಸ್ಥಿರ (static) ಮಾಡುವುದಲ್ಲ. ಬಗ್ಗಳನ್ನು ಸರಿಪಡಿಸಲು ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿರಲು ಇಂಪ್ಲಿಮೆಂಟೇಶನ್ಗಳು ಮತ್ತು ಅಲ್ಗಾರಿದಮ್ಗಳು ವಿಕಸನಗೊಳ್ಳಬೇಕು. ಪಬ್ಲಿಕ್ ಕಾಂಟ್ರಾಕ್ಟ್ ಅನ್ನು ಸ್ಥಿರವಾಗಿಡುವುದು ಇದರ ಗುರಿಯಾಗಿದೆ.
ಪ್ರತಿಯೊಂದು ಲೈಬ್ರರಿಯು ನಿರ್ದಿಷ್ಟ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:
authenticate()createSession()verifyPasskey()
ಈ ಫಂಕ್ಷನ್ಗಳು ಒಂದು ಕಾಂಟ್ರಾಕ್ಟ್ ಅನ್ನು ರೂಪಿಸುತ್ತವೆ. ನೀವು ಅಡಿಪಾಯದ ಕೋಡ್ ಅನ್ನು ಮರುಬರೆಯುವಾಗಲೂ ಈ ಕಾಂಟ್ರಾಕ್ಟ್ ಬದಲಾಗುವುದಿಲ್ಲ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ನ ಉಳಿದ ಭಾಗಗಳಿಗೆ ತೊಂದರೆಯಾಗದಂತೆ ನೀವು ಲೈಬ್ರರಿಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು ಅಥವಾ ಪ್ರೊಟೊಕಾಲ್ಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು.
ಭದ್ರತಾ ಲೋಪವು (vulnerability) ಕಂಡುಬಂದಾಗ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಎರಡು ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸುತ್ತೀರಿ:
- ಬಗ್ ಅನ್ನು ಸರಿಪಡಿಸುವುದು.
- ಅಪ್ಡೇಟ್ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹಾಳುಮಾಡುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು.
0deps ಆರ್ಕಿಟೆಕ್ಚರ್ನಲ್ಲಿ, ಎರಡನೇ ಸಮಸ್ಯೆ ಮಾಯವಾಗುತ್ತದೆ. ನೀವು ಇಂಟರ್ಫೇಸ್ನ ಹಿಂದಿರುವ ಇಂಪ್ಲಿಮೆಂಟೇಶನ್ ಅನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡುತ್ತೀರಿ. ಪಬ್ಲಿಕ್ API ಯೇ ಹಾಗೆಯೇ ಇರುತ್ತದೆ. ಯಾವುದೇ ಕೋಡ್ ಬದಲಾವಣೆ ಇಲ್ಲದೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ.
ಬಾಹ್ಯ ಕೋಡ್ ಅನ್ನು ಆಂತರಿಕ ಅಡಾಪ್ಟರ್ಗಳ (internal adapters) ಹಿಂದೆ ಪ್ರತ್ಯೇಕಿಸುವ ಮೂಲಕ, ನೀವು ದೀರ್ಘಕಾಲದ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತೀರಿ. ಒಂದು ವೇಳೆ ನಾಳೆ ಯಾವುದಾದರೂ ಲೈಬ್ರರಿ ಮಾಯವಾದರೆ, ನೀವು ಕೇವಲ ಅಡಾಪ್ಟರ್ ಅನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡಿದರೆ ಸಾಕು.
0deps ಓಪನ್ ಸೋರ್ಸ್ಗೆ ವಿರುದ್ಧವಾಗಿಲ್ಲ. ಇದು ನೀವು ಅದನ್ನು ಬಳಸುವ ರೀತಿಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ. ಲೈಬ್ರರಿಗಳು ಡೈನಾಮಿಕ್ ಬಾಹ್ಯ ಲಿಂಕ್ಗಳ ಬದಲಿಗೆ ಸಂಯೋಜಿತ ಘಟಕಗಳಾಗಿ (integrated components) ಬದಲಾಗುತ್ತವೆ.
ಇದು ಊಹಿಸಬಹುದಾದ, ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವವುಳ್ಳ (resilient) ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾದ ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಇಂಪ್ಲಿಮೆಂಟೇಶನ್ಗಳು ವಿಕಸನಗೊಳ್ಳುತ್ತವೆ, ಆದರೆ ಕಾಂಟ್ರಾಕ್ಟ್ ಹಾಗೆಯೇ ಇರುತ್ತದೆ.