ನಾನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನಾನು ಹೊರಡಬೇಕು ಇದರಿಂದ ನಾವು ನಿಖರವಾಗಿ ಏನು ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ.
ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ಫೈಲ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಜವಾಬ್ದಾರರಾಗಿರುವ ಪದರವನ್ನು ನೋಡಲು ಬಯಸುತ್ತೇನೆ ಮತ್ತು ಅದನ್ನು ಯಾರಾದರೂ ಹೇಗೆ ಬಳಸಬಹುದು. , ಸಂಗೀತದೊಂದಿಗೆ ನೇರ ಸಂಪರ್ಕವಿಲ್ಲ. ನೀವು ಯಾವುದೇ ಫೈಲ್‌ಗಳ ಸಂಗ್ರಹಣೆಯನ್ನು ಆಯೋಜಿಸಬಹುದು.
ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ, ನಾನು ಸ್ವಲ್ಪ "ಬ್ಯಾರೆಲ್ ಅನ್ನು ಸುತ್ತಿಕೊಂಡಿದ್ದೇನೆ" ipfs, ಆದರೆ ನಾನು ಪರಿಹರಿಸುತ್ತಿರುವ ಸಮಸ್ಯೆಯ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ನಿಖರವಾಗಿ ಸಂಭವಿಸಿದೆ. ಒಟ್ಟಾರೆಯಾಗಿ, ಈ ಯೋಜನೆಯು ತಂಪಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ವಿಭಿನ್ನ ಕಾರ್ಯಗಳಿಗಾಗಿ ವಿಭಿನ್ನ ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ರಚಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನಾನು ಬಯಸುತ್ತೇನೆ. ರಚನೆಯನ್ನು ಉತ್ತಮವಾಗಿ ಸಂಘಟಿಸಲು ಮತ್ತು ವೈಯಕ್ತಿಕ ನೋಡ್ಗಳಲ್ಲಿ ಮತ್ತು ಒಟ್ಟಾರೆಯಾಗಿ ನೆಟ್ವರ್ಕ್ನಲ್ಲಿ ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಒಂದು ಯೋಜನೆಯ ಚೌಕಟ್ಟಿನೊಳಗೆ ಸಹ, ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು ಕೆಲವು ಮಾನದಂಡಗಳ ಪ್ರಕಾರ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ತುಂಡುಗಳಾಗಿ ವಿಭಜಿಸಬಹುದು, ಒಟ್ಟಾರೆ ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು.
ಆದ್ದರಿಂದ ಸ್ಟೊರಾಕಲ್ ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸುತ್ತದೆ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಸಂಘಟಿಸಲು. ಪ್ರಮುಖ ಲಕ್ಷಣಗಳು:
- ಯಾವುದೇ ನೋಡ್ ಮೂಲಕ ಫೈಲ್ಗಳನ್ನು ರೆಪೊಸಿಟರಿಗೆ ಸೇರಿಸಬಹುದು.
- ಫೈಲ್ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಉಳಿಸಲಾಗಿದೆ, ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಅಲ್ಲ.
- ಪ್ರತಿಯೊಂದು ಫೈಲ್ ಅದರೊಂದಿಗೆ ಹೆಚ್ಚಿನ ಕೆಲಸಕ್ಕಾಗಿ ತನ್ನದೇ ಆದ ಅನನ್ಯ ವಿಷಯ ಹ್ಯಾಶ್ ಅನ್ನು ಹೊಂದಿದೆ.
- ಹೆಚ್ಚಿನ ವಿಶ್ವಾಸಾರ್ಹತೆಗಾಗಿ ಫೈಲ್ಗಳನ್ನು ನಕಲು ಮಾಡಬಹುದು
- ಒಂದು ನೋಡ್‌ನಲ್ಲಿನ ಫೈಲ್‌ಗಳ ಸಂಖ್ಯೆಯು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಿಂದ ಮಾತ್ರ ಸೀಮಿತವಾಗಿದೆ (ಒಂದು ವಿನಾಯಿತಿ ಇದೆ, ಕೆಳಗೆ ಹೆಚ್ಚು)
- ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿನ ಮಾನ್ಯವಾದ ನೋಡ್‌ಗಳ ಸಂಖ್ಯೆಗೆ ಅನುಗುಣವಾಗಿ ಹರಡಬಹುದಾದ ಸಾಮರ್ಥ್ಯಗಳಿಂದ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿರುವ ಫೈಲ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೀಮಿತಗೊಳಿಸಲಾಗಿದೆ, ಇದು ಎರಡನೇ ಆವೃತ್ತಿಯಲ್ಲಿ ಅನಂತ ಸಂಖ್ಯೆಯ ನೋಡ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ (ಇದರ ಕುರಿತು ಇನ್ನೊಂದು ಲೇಖನದಲ್ಲಿ ಇನ್ನಷ್ಟು)
ಪ್ರೋಗ್ರಾಂನಿಂದ ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಸರಳ ಉದಾಹರಣೆ:
ಸರ್ವರ್:
const Node = require('storacle').Node;
(async () => {
try {
const node = new Node({
port: 4000,
hostname: 'localhost'
});
await node.init();
}
catch(err) {
console.error(err.stack);
process.exit(1);
}
})();ಗ್ರಾಹಕ:
const Client = require('storacle').Client;
(async () => {
try {
const client = new Client({
address: 'localhost:4000'
});
await client.init();
const hash = await client.storeFile('./my-file');
const link = await client.getFileLink(hash);
await client.removeFile(hash);
}
catch(err) {
console.error(err.stack);
process.exit(1);
}
})();ಒಳ ನೋಟ
ಹುಡ್ ಅಡಿಯಲ್ಲಿ ಅಲಂಕಾರಿಕ ಏನೂ ಇಲ್ಲ. ಫೈಲ್‌ಗಳ ಸಂಖ್ಯೆ, ಅವುಗಳ ಒಟ್ಟು ಗಾತ್ರ ಮತ್ತು ಇತರ ಬಿಂದುಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಇನ್-ಮೆಮೊರಿ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಫೈಲ್ಗಳನ್ನು ಅಳಿಸಿದಾಗ ಮತ್ತು ಸೇರಿಸಿದಾಗ ನವೀಕರಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಆಗಾಗ್ಗೆ ಪ್ರವೇಶಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಒಂದು ನಿರ್ದಿಷ್ಟ ಶೇಖರಣಾ ಗಾತ್ರವನ್ನು ತಲುಪಿದಾಗ ನೀವು ಫೈಲ್ಗಳನ್ನು ಪ್ರಸಾರ ಮಾಡಬೇಕಾದಾಗ ಕಸ ಸಂಗ್ರಾಹಕವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಹೊಸದನ್ನು ಸೇರಿಸುವುದನ್ನು ನಿಷೇಧಿಸುವುದಿಲ್ಲ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಸಂಗ್ರಹಣೆಯನ್ನು ಬೈಪಾಸ್ ಮಾಡಬೇಕು ಮತ್ತು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು (> ಮಿಲಿಯನ್ ಎಂದು ಹೇಳುವುದು) ಗಮನಾರ್ಹ ಲೋಡ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಮತ್ತು ಕಡಿಮೆ ಫೈಲ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಮತ್ತು ಹೆಚ್ಚಿನ ನೋಡ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವುದು ಉತ್ತಮ. "ಕ್ಲೀನರ್" ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿದರೆ, ಅಂತಹ ಸಮಸ್ಯೆ ಇಲ್ಲ.
ಫೈಲ್ ಸಂಗ್ರಹಣೆಯು 256 ಫೋಲ್ಡರ್‌ಗಳನ್ನು ಮತ್ತು 2 ಹಂತದ ಗೂಡುಕಟ್ಟುವಿಕೆಯನ್ನು ಒಳಗೊಂಡಿದೆ. ಫೈಲ್ಗಳನ್ನು ಎರಡನೇ ಹಂತದ ಫೋಲ್ಡರ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. ಅಂದರೆ, 1 ಮಿಲಿಯನ್ ಇದ್ದರೆ. ಅಂತಹ ಪ್ರತಿಯೊಂದು ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಸುಮಾರು 62500 ಫೈಲ್‌ಗಳು ಇರುತ್ತವೆ (1000000 / sqrt(256)).
ಫೋಲ್ಡರ್ ಹೆಸರುಗಳನ್ನು ಫೈಲ್ ಹ್ಯಾಶ್‌ನಿಂದ ರಚಿಸಲಾಗಿದೆ ಇದರಿಂದ ನಿಮಗೆ ಹ್ಯಾಶ್ ತಿಳಿದಿದ್ದರೆ ನೀವು ಅದನ್ನು ತ್ವರಿತವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು.
ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ವಿಭಿನ್ನ ಶೇಖರಣಾ ಅಗತ್ಯತೆಗಳ ಆಧಾರದ ಮೇಲೆ ಈ ರಚನೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ: ದುರ್ಬಲ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳಿಗೆ ಬೆಂಬಲ, ಅಲ್ಲಿ ಒಂದು ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಅನೇಕ ಫೈಲ್ಗಳನ್ನು ಹೊಂದಲು ಅಪೇಕ್ಷಣೀಯವಲ್ಲ, ಅಗತ್ಯವಿದ್ದರೆ ಎಲ್ಲಾ ಫೋಲ್ಡರ್‌ಗಳ ತ್ವರಿತ ಪ್ರಯಾಣ, ಇತ್ಯಾದಿ. ಕೆಲವು ರೀತಿಯ ಗೋಲ್ಡನ್ ಮೀನ್.
ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದು
ಫೈಲ್ಗಳನ್ನು ಸೇರಿಸುವಾಗ, ಹಾಗೆಯೇ ಅವುಗಳನ್ನು ಸ್ವೀಕರಿಸುವಾಗ, ಫೈಲ್ಗಳಿಗೆ ಲಿಂಕ್ಗಳನ್ನು ಸಂಗ್ರಹಕ್ಕೆ ಬರೆಯಲಾಗುತ್ತದೆ.
ಇದಕ್ಕೆ ಧನ್ಯವಾದಗಳು, ಆಗಾಗ್ಗೆ ಫೈಲ್ ಹುಡುಕಾಟದಲ್ಲಿ ಇಡೀ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಹಾದುಹೋಗುವ ಅಗತ್ಯವಿಲ್ಲ. ಇದು ಲಿಂಕ್ಗಳ ಸ್ವೀಕೃತಿಯನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನೆಟ್ವರ್ಕ್ನಲ್ಲಿ ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆಯು http ಹೆಡರ್ ಮೂಲಕವೂ ಸಂಭವಿಸುತ್ತದೆ.
ಐಸೋಮಾರ್ಫಿ
ಕ್ಲೈಂಟ್ ಅನ್ನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಐಸೋಮಾರ್ಫಿಕ್ ಆಗಿದೆ, ಇದನ್ನು ನೇರವಾಗಿ ಬ್ರೌಸರ್‌ನಿಂದ ಬಳಸಬಹುದು.
ನೀವು ಫೈಲ್ ಅನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಬಹುದು ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಪ್ರವೇಶವಾಗಿ window.ClientStoracle ಅಥವಾ ನಿರ್ಮಾಣ ವ್ಯವಸ್ಥೆಯ ಮೂಲಕ ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ, ಇತ್ಯಾದಿ.
ಮುಂದೂಡಲ್ಪಟ್ಟ ಲಿಂಕ್‌ಗಳು
ಆಸಕ್ತಿದಾಯಕ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ "ಮುಂದೂಡಲ್ಪಟ್ಟ ಉಲ್ಲೇಖ". ಇದು ಇಲ್ಲಿ ಮತ್ತು ಈಗ ಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಪಡೆಯಬಹುದಾದ ಫೈಲ್‌ಗೆ ಲಿಂಕ್ ಆಗಿದೆ ಮತ್ತು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಈಗಾಗಲೇ ಕಂಡುಬಂದಾಗ ಫೈಲ್ ಅನ್ನು ಎಳೆಯಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಸೈಟ್‌ನಲ್ಲಿ ಕೆಲವು ಚಿತ್ರಗಳನ್ನು ತೋರಿಸಬೇಕಾದಾಗ ಇದು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ. ನಾವು ಎಸ್‌ಆರ್‌ಸಿಯಲ್ಲಿ ಮುಂದೂಡಲ್ಪಟ್ಟ ಲಿಂಕ್ ಅನ್ನು ಹಾಕಿದ್ದೇವೆ ಮತ್ತು ಅಷ್ಟೆ. ನೀವು ಅನೇಕ ಪ್ರಕರಣಗಳೊಂದಿಗೆ ಬರಬಹುದು.
ಕ್ಲೈಂಟ್ API
- ಅಸಿಂಕ್ Client.prototype.storeFile() - ಫೈಲ್ ಅನ್ನು ಉಳಿಸಲಾಗುತ್ತಿದೆ
- ಅಸಿಂಕ್ Client.prototype.getFileLink() — ಫೈಲ್‌ಗೆ ನೇರ ಲಿಂಕ್ ಪಡೆಯುವುದು
- ಅಸಿಂಕ್ Client.prototype.getFileLinks() — ಫೈಲ್ ಇರುವ ಎಲ್ಲಾ ನೋಡ್‌ಗಳಿಂದ ನೇರ ಲಿಂಕ್ಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯುವುದು
- ಅಸಿಂಕ್ Client.prototype.getFileToBuffer() - ಫೈಲ್ ಅನ್ನು ಬಫರ್‌ಗೆ ಪಡೆಯಿರಿ
- ಅಸಿಂಕ್ Client.prototype.getFileToPath() — ಫೈಲ್ ಸಿಸ್ಟಮ್ಗೆ ಫೈಲ್ ಅನ್ನು ಪಡೆಯಿರಿ
- ಅಸಿಂಕ್ Client.prototype.getFileToBlob() - ಫೈಲ್ ಅನ್ನು ಬ್ಲಾಬ್‌ನಲ್ಲಿ ಪಡೆಯಿರಿ (ಬ್ರೌಸರ್ ಆವೃತ್ತಿಗಾಗಿ)
- ಅಸಿಂಕ್ Client.prototype.removeFile() - ಫೈಲ್ ಅನ್ನು ಅಳಿಸಿ
- Client.prototype.createRequestedFileLink() - ಮುಂದೂಡಲ್ಪಟ್ಟ ಲಿಂಕ್ ಅನ್ನು ರಚಿಸಿ
ಇನ್ನೊಂದು ಸರ್ವರ್‌ಗೆ ಫೈಲ್ಗಳನ್ನು ರಫ್ತು ಮಾಡಿ
ಫೈಲ್ಗಳನ್ನು ಮತ್ತೊಂದು ನೋಡ್‌ಗೆ ವರ್ಗಾಯಿಸಲು, ನೀವು ಹೀಗೆ ಮಾಡಬಹುದು:
- ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಜೊತೆಗೆ ಸಂಪೂರ್ಣ ಶೇಖರಣಾ ಫೋಲ್ಡರ್ ಅನ್ನು ನಕಲಿಸಿ. (ಭವಿಷ್ಯದಲ್ಲಿ ಇದು ಕೆಲಸ ಮಾಡದಿರಬಹುದು)
- ಫೈಲ್ಗಳೊಂದಿಗೆ ಫೋಲ್ಡರ್ ಅನ್ನು ಮಾತ್ರ ನಕಲಿಸಿ. ಆದರೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಒಮ್ಮೆ ಕಾರ್ಯವನ್ನು ರನ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ node.normalizeFilesInfo()ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಮತ್ತು ಅದನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ ನಮೂದಿಸಿ.
- ಕಾರ್ಯವನ್ನು ಬಳಸಿ node.exportFiles()ಇದು ಫೈಲ್ಗಳನ್ನು ನಕಲಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
ಮೂಲ ನೋಡ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು
ಶೇಖರಣಾ ನೋಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ, ನೀವು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.
ನಾನು ಅತ್ಯಂತ ಮೂಲಭೂತವಾದವುಗಳನ್ನು ವಿವರಿಸುತ್ತೇನೆ, ಉಳಿದವುಗಳನ್ನು Github ನಲ್ಲಿ ಕಾಣಬಹುದು.
- store.dataSize - ಫೈಲ್ಗಳೊಂದಿಗೆ ಫೋಲ್ಡರ್‌ನ ಗಾತ್ರ
- store.tempSize - ತಾತ್ಕಾಲಿಕ ಫೋಲ್ಡರ್ ಗಾತ್ರ
- store.autoCleanSize - ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬೇಕಾದ ಕನಿಷ್ಠ ಶೇಖರಣಾ ಗಾತ್ರ. ನೀವು ಈ ನಿಯತಾಂಕವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ, ಸ್ಥಳವು ಖಾಲಿಯಾಗಲು ಪ್ರಾರಂಭಿಸಿದ ತಕ್ಷಣ, ಕಡಿಮೆ ಬಳಸಿದ ಫೈಲ್ಗಳನ್ನು ಅಳಿಸಲಾಗುತ್ತದೆ.
- file.maxSize - ಗರಿಷ್ಠ ಫೈಲ್ ಗಾತ್ರ
- file.minSize - ಕನಿಷ್ಠ ಫೈಲ್ ಗಾತ್ರ
- file.preferredDuplicates - ನೆಟ್ವರ್ಕ್ನಲ್ಲಿ ಫೈಲ್ ನಕಲುಗಳ ಆದ್ಯತೆಯ ಸಂಖ್ಯೆ
- file.mimeWhitelist - ಮಾನ್ಯ ಫೈಲ್ ಪ್ರಕಾರಗಳು
- file.mimeBlacklist - ಅಮಾನ್ಯ ಫೈಲ್ ಪ್ರಕಾರಗಳು
- file.extWhitelist - ಮಾನ್ಯ ಫೈಲ್ ವಿಸ್ತರಣೆಗಳು
- file.extBlacklist - ಅಮಾನ್ಯ ಫೈಲ್ ವಿಸ್ತರಣೆಗಳು
- file.linkCache - ವಿವಿಧ ಲಿಂಕ್ ಕ್ಯಾಶಿಂಗ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು
ಆಯಾಮಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಬಹುತೇಕ ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳನ್ನು ಸಂಪೂರ್ಣ ಮತ್ತು ಸಾಪೇಕ್ಷ ಮೌಲ್ಯಗಳಲ್ಲಿ ನಮೂದಿಸಬಹುದು.
ಆಜ್ಞಾ ಸಾಲಿನ ಮೂಲಕ ಕೆಲಸ
ಆಜ್ಞಾ ಸಾಲಿನ ಮೂಲಕ ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸಬಹುದು. ಇದನ್ನು ಮಾಡಲು ನೀವು ಅದನ್ನು ಜಾಗತಿಕವಾಗಿ ಸ್ಥಾಪಿಸಬೇಕು: npm i -g ಸ್ಟೊರಾಕಲ್. ಇದರ ನಂತರ, ನೋಡ್ ಇರುವ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯಿಂದ ನೀವು ಅಗತ್ಯ ಕ್ರಮಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, storacle -a storeFile -f ./file.txt -c ./config.jsಫೈಲ್ ಸೇರಿಸಲು. ಎಲ್ಲಾ ಕ್ರಿಯೆಗಳನ್ನು ಕಾಣಬಹುದು
ನಿಮಗೆ ಇದು ಏಕೆ ಬೇಕಾಗಬಹುದು?
- ಅನುಕೂಲಕರ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಫೈಲ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಕೆಲಸ ಮಾಡಲು ನೀವು ಯೋಜಿಸಿರುವ ಕೆಲವು ರೀತಿಯ ವಿಕೇಂದ್ರೀಕೃತ ಯೋಜನೆಯನ್ನು ರಚಿಸಲು ನೀವು ಬಯಸಿದರೆ. ಉದಾಹರಣೆಗೆ, ಲೇಖನದ ಆರಂಭದಲ್ಲಿ ಲಿಂಕ್‌ನಲ್ಲಿ ವಿವರಿಸಿದ ಸಂಗೀತ ಯೋಜನೆಯು ಬಳಸುತ್ತದೆ ಶೇಖರಣೆ.
- ನೀವು ಯಾವುದೇ ಇತರ ಯೋಜನೆಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ ಅಲ್ಲಿ ನೀವು ಫೈಲ್ಗಳನ್ನು ವಿತರಿಸಿದ ರೀತಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಕಾಗುತ್ತದೆ. ನಿಮ್ಮ ಮುಚ್ಚಿದ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ನೀವು ಸುಲಭವಾಗಿ ನಿರ್ಮಿಸಬಹುದು, ನೋಡ್‌ಗಳನ್ನು ಸುಲಭವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು ಮತ್ತು ಅಗತ್ಯವಿದ್ದಾಗ ಹೊಸದನ್ನು ಸೇರಿಸಬಹುದು.
- ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್ ಫೈಲ್ಗಳನ್ನು ನೀವು ಎಲ್ಲೋ ಸಂಗ್ರಹಿಸಬೇಕಾದರೆ ಮತ್ತು ಎಲ್ಲವನ್ನೂ ನೀವೇ ಬರೆಯಲು ನಿಮಗೆ ತುಂಬಾ ಹೆಚ್ಚು. ಬಹುಶಃ ಈ ಗ್ರಂಥಾಲಯವು ನಿಮ್ಮ ವಿಷಯದಲ್ಲಿ ಇತರರಿಗಿಂತ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿರುತ್ತದೆ.
- ನೀವು ಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಯೋಜನೆಯನ್ನು ಹೊಂದಿದ್ದರೆ, ಆದರೆ ಬ್ರೌಸರ್‌ನಿಂದ ಎಲ್ಲಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಯಸಿದರೆ. ನೀವು ಸರ್ವರ್ ಕೋಡ್ ಬರೆಯುವುದನ್ನು ತಪ್ಪಿಸಬಹುದು.
ನನ್ನ ಸಂಪರ್ಕಗಳು:
ಮೂಲ: www.habr.com