क्या किसी के पास कोई सूत्र है, या शायद उनके वातावरण से कुछ नमूना डेटा हैं जो मुझे यह अनुमान लगाने में मदद कर सकते हैं कि ग्रेफाइट प्रति डेटाइट द्वारा कितना डिस्क स्थान का उपयोग किया जाएगा?
क्या किसी के पास कोई सूत्र है, या शायद उनके वातावरण से कुछ नमूना डेटा हैं जो मुझे यह अनुमान लगाने में मदद कर सकते हैं कि ग्रेफाइट प्रति डेटाइट द्वारा कितना डिस्क स्थान का उपयोग किया जाएगा?
जवाबों:
whisper-info.py
आपको फ़ाइल के आकार सहित प्रत्येक फ़ाइल को क्या और कैसे एकत्रित किया जाता है, इसकी बहुत जानकारी देता है।
हालाँकि यह केवल मौजूदा कानाफूसी फ़ाइलों के लिए उपयोगी है।
जब आप किसी स्कीमा की भविष्य कहनेवाला आकार देने से पहले देखना चाहते हैं, तो एक कानाफूसी कैलकुलेटर की कोशिश करें, जैसे कि https://gist.github.com/jjmaestro/5774063 पर उपलब्ध
संपादित करें:
जब एक उदाहरण के लिए कहा ...
storage_schema:
{
:catchall => {
:priority => "100",
:pattern => "^\.*",
:retentions => "1m:31d,15m:1y,1h:5y"
}
}
मेरी फाइल को देख रहा है applied-in-last-hour.wsp
, ls -l
पैदावार
-rwxr-xr-x 1 root root 4415092 Sep 16 08:26 applied-in-last-hour.wsp
और whisper-info.py ./applied-in-last-hour.wsp
पैदावार
maxRetention: 157680000
xFilesFactor: 0.300000011921
aggregationMethod: average
fileSize: 4415092
Archive 0
retention: 604800
secondsPerPoint: 10
points: 60480
size: 725760
offset: 52
Archive 1
retention: 2678400
secondsPerPoint: 60
points: 44640
size: 535680
offset: 725812
Archive 2
retention: 157680000
secondsPerPoint: 600
points: 262800
size: 3153600
offset: 1261492
इसलिए, मूल रूप से आप प्रति होस्टेशन प्रति मैच-प्रति-खंड-प्रति-प्रति के अनुसार अपने मेजबान को प्रति-मैच-सेगमेंट में जोड़ते हैं, सिस्टम के एक कारक से गुणा करते हैं जिसे आप इसे लागू करना चाहते हैं, नए आँकड़ों की संख्या में कारक जो आप ट्रैक करने जा रहे हैं। फिर आप जो भी भंडारण की मात्रा लेते हैं और उसे कम से कम दोगुना करते हैं (क्योंकि हम भंडारण खरीद रहे हैं, और हम जानते हैं कि हम इसका उपयोग करेंगे ...)
ls -l
, इसलिए मैं इसे बाइट करता हूं। जब मैं .wsp फ़ाइल (जैसा कि रिपोर्ट किया जाता है whisper-info.py
) के भीतर अभिलेखागार के आकारों को जोड़ देता हूं , तो वे समग्र .wsp फ़ाइल आकार के करीब आ जाते हैं (बाकी मैं मेटाडेटा और इस तरह मान लेता हूं। यह सभी के लिए फ़ाइल का आकार होना चाहिए। समय, जब डेटा कम डेटा रिज़ॉल्यूशन के लिए गिरता है, और पुराने डेटा पॉइंट्स को छोड़ दिया जाता है।
ServerCount * MetricCount * 4.5MBytes
आँकड़े के लिए प्रलेखन में वे एक डेटा अवधारण नीति के लिए एक उदाहरण देते हैं ।
रिटेंशन 10s:6h,1min:7d,10min:5y
जो 2160 + 10080 + 262800 = 275040 डेटा पॉइंट्स हैं और वे 3.2 MiB का आर्काइव साइज देते हैं ।
एक रैखिक संबंध मानते हुए, यह लगभग 12.2 बाइट्स प्रति डेटा बिंदु होगा ।
ग्रेफाइट के साथ कोई प्रत्यक्ष अनुभव नहीं है, लेकिन मैं उसी तर्क की कल्पना करता हूं, जैसा कि हमने कैक्टि या कुछ और आरआरडी या टाइम-रोलओवर संचालित के लिए इस्तेमाल किया था (ग्रेफाइट आंतरिक रूप से आरआरडी का उपयोग नहीं करता है लेकिन भंडारण तर्क तुलनीय लगता है।)
त्वरित उत्तर है "शायद उतना स्थान नहीं है जितना आपको लगता है कि आपको आवश्यकता होगी।"
लंबे उत्तर में कुछ साइट-विशिष्ट गणित शामिल हैं। हमारी निगरानी प्रणाली (इंटरमापर) के लिए मैं अवधारण अवधि, रिज़ॉल्यूशन और डेटा पॉइंट आकार का पता लगाता हूं, कुछ गुणा करता हूं, और ओवरहेड में जोड़ता हूं।
एक उदाहरण के रूप में मैं डिस्क स्थान का उपयोग करूंगा - हम 30 दिनों के लिए 5 मिनट की सटीकता के साथ आंकड़े संग्रहीत करते हैं, 60 दिनों के लिए 15 मिनट की सटीकता और फिर आगे के 300 दिनों के लिए प्रति घंटा सटीक और हम 64 का उपयोग कर रहे हैं। -bit (8 बाइट) पूर्णांक इसे संग्रहीत करने के लिए:
प्रति नमूना 8 बाइट्स जो कि लगभग 173KB है, स्टोरेज इंडेक्सिंग के लिए प्लस हेल्दी ओवरहेड है और एक विभाजन डिस्क उपयोग डेटा (ओवरस्टिमेशन की ओर कोई भी त्रुटि) के लिए इसे लगभग 200KB तक लाता है।
बेस मेट्रिक्स से मैं औसत "प्रति मशीन" आकार (10 डिस्क विभाजन, स्वैप स्पेस, रैम, लोड एवरेज, नेटवर्क ट्रांसफर और कुछ अन्य चीजें) - लगभग 5 एमबी प्रति मशीन पर काम कर सकता हूं।
मैं अंतिम संख्या के शीर्ष पर एक स्वस्थ 10% जोड़ता हूं और राउंड अप करता हूं, इसलिए मैं चीजों को 6 एमबी प्रति मशीन पर आकार देता हूं।
तब मैं अंतरिक्ष के 1TB को देखता हूं जो मैंने चार्टिंग के लिए मैट्रिक्स डेटा संग्रहीत करने के लिए चारों ओर रखा है और कहता है "हाँ, मैं अपने जीवनकाल में भंडारण से बाहर नहीं चल रहा हूं जब तक कि हम पूरी तरह से विकसित न हों!" :-)
मेरे पास 70 नोड हैं जो बहुत अधिक डेटा उत्पन्न करते हैं। कार्बन / व्हिस्पर का उपयोग करते हुए, एक नोड ने अकेले 91k फाइलें बनाईं (नोड में प्रत्येक मल्टीपल काउंटर और चर क्षेत्र वाले कई स्कीमा उत्पन्न होते हैं, जिन्हें चयन करने की आवश्यकता होती है। उदाहरण के लिए: (nodename)। (स्कीमा)।) (काउंटर)। (उप-एनकाउंटर) (आदि) )....और इसी तरह)।
इससे मुझे जो भी ग्राफ़ चाहिए, उसे प्लॉट करने के लिए आवश्यक ग्रैन्युलैरिटी मिल गई। शेष 69 नोड्स को आबाद करने के लिए स्क्रिप्ट चलाने के बाद, मेरे पास डिस्क पर 1.3Tb डेटा था। और वह केवल 6hrs मूल्य का डेटा / नोड है। मुझे क्या मिलता है 6hrs डेटा के लिए वास्तविक फ्लैट सीएसवी फ़ाइल 230Mb / नोड के बारे में है। 70 नोड्स ~ 16 जीबी डेटा है। मेरा स्टोरेज-स्कीमा 120s: 365d था।
मैं डेटाबेस के लिए अपेक्षाकृत नया हूं, इसलिए मैं कुछ गलत कर सकता हूं, लेकिन मुझे लगता है कि यह प्रत्येक नमूने के लिए सभी ओवरहेड है।
तो यह एक मजेदार प्रयोग था, लेकिन मुझे नहीं लगता कि जिस तरह का डेटा मैं स्टोर कर रहा हूं, उसके लिए कानाफूसी का उपयोग करना समझ में आता है। MongoDB एक बेहतर विलेयोन की तरह लगता है, लेकिन मुझे यह पता लगाने की आवश्यकता है कि इसका उपयोग ग्राफाना के बैकएंड के रूप में कैसे किया जाए।