SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor

VPS benchmark योग्य प्रकारे कसा करावा?

VPS benchmark साठी आधी yabs.sh, नंतर fio, sysbench आणि iperf3 चालवा. CPU, memory, storage आणि network चे आकडे समजून घ्या, कारण एकच run दिशाभूल करू शकते.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, July 30, 2026.

VPS बेंचमार्क करणे म्हणजे काय

VPS बेंचमार्क करताना तुम्ही चार गोष्टी मोजता: सिंगल CPU कोर किती वेगाने चालतो, मशीनमध्ये मेमरी बँडविड्थ किती आहे, स्टोरेज प्रति सेकंद किती लहान रँडम डिस्क ऑपरेशन्स हाताळते आणि नेटवर्क लिंक किती थ्रूपुट देते. yabs.sh ची एक रन तुम्हाला सुमारे दहा मिनिटांत CPU, डिस्क आणि नेटवर्कचे निकाल देते; मेमरी बँडविड्थसाठी खालील स्वतंत्र मेमरी टेस्ट वापरा. निकालांचे विश्लेषण करणे हा कठीण भाग आहे, कारण VPS (virtual private server) इतर वापरकर्त्यांसोबत फिजिकल हार्डवेअर शेअर करतो. त्यामुळे एकाच मशीनवर 03:00 वाजता मिळणारा आकडा आणि 20:00 वाजता मिळणारा आकडा यात खूप फरक असू शकतो.

येथील योजना अशी आहे की, जलद चित्र मिळवण्यासाठी आधी yabs.sh चालवा आणि त्यानंतर खाली दिलेली टूल्स स्वतः चालवा. स्वतः टूल्स चालवल्यामुळे तुम्ही एखादा फ्लॅग बदलून आकड्यांमध्ये होणारा बदल पाहू शकता आणि तो आकडा नेमके काय मोजत होता हे समजू शकता. हे काम मशीन सेटअप केल्यानंतर करा, आधी नको. नवीन VPS वरील पहिली दहा मिनिटे यातील पायऱ्या आधी पूर्ण करा, कारण जे मशीन अजूनही अपडेट्स घेत आहे, त्याचे बेंचमार्क निकाल खराब येतात आणि त्याचा हार्डवेअरशी काहीही संबंध नसतो.

मोजमाप करण्यापूर्वी मशीनची स्थिती तपासा

प्रत्येक चुकीच्या बेंचमार्कचे अर्धे कारण म्हणजे लेखकाला न समजलेले मशीन.

nproc
lscpu | grep -E 'Model name|Hypervisor|Thread'
free -h
df -hT /
uname -r
systemd-detect-virt

Hypervisor vendor: KVM म्हणजे पूर्ण व्हर्च्युअलायझेशन, त्यामुळे तुम्ही स्वतःचे कर्नल चालवता. systemd-detect-virt मध्ये lxc किंवा openvz प्रिंट होणे म्हणजे त्याऐवजी कंटेनर व्हर्च्युअलायझेशन वापरले जात आहे: तुम्ही होस्ट कर्नल शेअर करता आणि तुमच्या CPU व मेमरीच्या मर्यादा या व्हर्च्युअल हार्डवेअरऐवजी cgroup (कंट्रोल ग्रुप) सेटिंग्ज असतात. cgroup v2 सिस्टिमवर तुम्ही तुमच्या कंटेनरच्या cgroup मधून CPU मर्यादा वाचू शकता; जेव्हा तो cgroup /sys/fs/cgroup वर माउंट केलेला असतो, तेव्हा खालील पाथ लागू होतो.

cat /sys/fs/cgroup/cpu.max

max 100000 चा अर्थ असा की या cgroup चा स्वतःचा कोणताही कोटा नाही; तरीही पूर्वज (ancestor) cgroups कोटा लादू शकतात. 200000 100000 चा अर्थ असा की तुम्ही दर 100000 मायक्रोसेकंद कालावधीत 200000 मायक्रोसेकंद CPU वापरू शकता, जो दोन कोअर्सच्या कोट्याइतका आहे. दोन कोअर्सचा कोटा असलेला 4 vCPU चा प्लॅन कधीही चार कोअर्सप्रमाणे कामगिरी करणार नाही. बेंचमार्क टूल्स ही मर्यादा ओळखू शकतात: VoxelBench CPU कोटा रिपोर्ट करते आणि जेव्हा होस्ट सर्व्हर वापरू शकणाऱ्या CPU पेक्षा कितीतरी जास्त CPU दाखवतो, तेव्हा ते शेअर केलेला किंवा थ्रॉटल केलेला CPU फ्लॅग करते.

df -hT / वेगळ्या कारणासाठी महत्त्वाचे आहे: ते म्हणजे Type कॉलम. जर त्यात overlay असे वाचले जात असेल, तर तुम्ही कंटेनरच्या आत आहात आणि तुमचे डिस्क रिझल्ट्स त्या ओव्हरलेच्या खाली असलेल्या स्टोरेजचे वर्णन करतील. याची आताच नोंद घ्या.

स्टील टाइमवर (steal time) सतत लक्ष ठेवा

स्टील टाइम म्हणजे तुमच्या व्हर्च्युअल CPU ने अनैच्छिकपणे घालवलेला वेळ, जेव्हा हायपरवायझरने त्याला शेड्युल केलेले नसते. उपलब्ध नसलेल्या CPU वेळेचे हे एक उपयुक्त लक्षण आहे, परंतु हे व्यस्त शेजारी (busy neighbours) आणि प्रोव्हायडरने लादलेला CPU कोटा यांमधील फरक स्पष्ट करत नाही.

vmstat 1 10

उजवीकडील st कॉलम वाचा. सततचा स्टील टाइम म्हणजे गेस्टसाठी CPU वेळ उपलब्ध नव्हता, परंतु 5% पेक्षा जास्त मूल्य म्हणजे होस्ट ओव्हरसबस्क्राईब (oversubscribed) आहेच असे सिद्ध होत नाही. प्रोव्हायडर मुद्दामहून CPU कोटा अंमलबजावणीला स्टील टाइम म्हणून दर्शवू शकतात. top मध्ये CPU ओळीवरील %st सारखीच आकडेवारी दिसते. बेंचमार्क करताना दुसऱ्या SSH सेशनमध्ये vmstat 1 चालू ठेवा आणि प्रत्येक निकालाच्या शेजारी स्टील टाइमची आकडेवारी लिहून ठेवा.

yabs.sh ने सुरुवात करा

yabs.sh (Yet Another Bench Script) ही shell script आहे. ती fio, iperf3 आणि Geekbench चालवते आणि एकत्रित सारांश दाखवते. हे प्रोग्राम आधीपासून installed असतील, तर script तेच वापरते. नसतील, तर ती static binaries download करते. VPS benchmark चर्चांमध्ये ही सर्वसाधारण पद्धत आहे. त्यामुळे दुसऱ्या व्यक्तीच्या निकालांशी तुलना करण्याचा yabs output हा सर्वात जलद मार्ग आहे.

या प्रकल्पाने सुचवलेला one-line command हा आहे.

curl -sL yabs.sh | bash

यामुळे URL सध्या जे देते ते थेट shell कडे pipe केले जाते. आधी ते download करा, वाचा आणि त्यानंतरच चालवा.

curl -sLo yabs.sh https://raw.githubusercontent.com/masonr/yet-another-bench-script/master/yabs.sh
less yabs.sh
bash yabs.sh

तुम्ही pipe वापरत असल्यास flags -s -- नंतर द्या. Local copy चालवत असल्यास flags filename नंतर थेट द्या. उपयुक्त flags पुढीलप्रमाणे आहेत: -f disk test वगळतो, -i network test वगळतो, -g Geekbench वगळतो, -r iperf3 locations ची संख्या तीनपर्यंत कमी करतो, -j results JSON म्हणून दाखवतो आणि -w results.json ते JSON file मध्ये लिहितो.

bash yabs.sh -r -w yabs-run1.json

पहिल्यांदा चालवण्यापूर्वी दोन गोष्टी लक्षात ठेवा. Geekbench तुमचा result upload करतो आणि सार्वजनिक browser.geekbench.com URL दाखवतो. त्यामुळे ही link असलेली कोणतीही व्यक्ती तुमचा CPU model आणि scores पाहू शकते. -g हा test पूर्णपणे वगळतो. दुसरे म्हणजे, iperf3 stage अनेक regions मधील servers कडे वास्तविक network traffic पाठवते. हा traffic तुमच्या monthly bandwidth allowance मध्ये मोजला जातो. 1 Gbit/s link वर पूर्ण network stage मुळे tens of gigabytes traffic जाऊ शकतो. त्यामुळे कमी allowance असल्यास -r वापरा आणि metered link असल्यास -i वापरा.

yabs आउटपुटमधील प्रत्येक भागाचा अर्थ

डिस्क विभाग 4k, 64k, 512k आणि 1m या चार ब्लॉक आकारांसह 50/50 read आणि write मिश्रण वापरून fio चालवतो. प्रत्येक ब्लॉक आकारासाठी तो IOPS (input/output operations per second) आणि bandwidth नोंदवतो. डेटाबेस, mail server किंवा अनेक लहान write करणाऱ्या कोणत्याही प्रणालीसाठी 4k ही ओळ महत्त्वाची आहे, कारण बहुतेक server IO लहान आणि विखुरलेले असते. 1m ही ओळ backups आणि video साठी महत्त्वाची आहे, कारण त्यात bytes चे मोठे सलग संच हलवले जातात.

नेटवर्क विभाग अनेक regions मधील public servers विरुद्ध, दोन्ही दिशांनी आणि parallel streams वापरून iperf3 चालवतो. येथे कमी आकड्याकडे अंतिम निष्कर्ष म्हणून नव्हे, तर तपासण्यासारखा संकेत म्हणून पाहा. Public iperf3 servers सामायिक असतात आणि त्यांच्यावर अनेकदा जास्त भार असतो. त्यामुळे खराब निकाल remote end मुळे मिळालेला असू शकतो.

Geekbench विभाग single core score आणि multi core score देतो. Single core score मुळे एक request, एक compile किंवा एक query किती वेगाने पूर्ण होईल याचा अंदाज येतो. Multi core score वरून तुम्हाला प्रत्यक्षात किती cores मिळाले हे प्रामुख्याने समजते.

Disk: fio स्वतः चालवा

fio (flexible IO tester) हे yabs च्या disk विभागामागील साधन आहे. ते थेट चालवल्यावर flags चा प्रत्यक्ष अर्थ स्पष्ट होतो.

sudo apt update && sudo apt install -y fio sysbench iperf3

तुम्हाला महत्त्वाच्या असलेल्या filesystem वर, queue depth 32 सह 4k random read चाचणी:

fio --name=randread4k --filename=./fio-testfile --size=2G --bs=4k \
  --rw=randread --ioengine=libaio --iodepth=32 --direct=1 \
  --runtime=60 --time_based --group_reporting

आउटपुटमधील वाचायची summary line अशी दिसते.

read: IOPS=184k, BW=719MiB/s (754MB/s)(42.1GiB/60001msec)

याखाली fio एक clat percentiles block दाखवते. 99.00th percentile हा नमूद करण्यास योग्य आकडा आहे, कारण 100 पैकी सर्वात धीम्या 1 request ला किती वेळ प्रतीक्षा करावी लागली हे तो दाखवतो. Average latency मुळे वापरकर्त्याला जाणवणारे stalls लपतात.

  • --direct=1 मुळे file O_DIRECT सह उघडली जाते. त्यामुळे reads kernel page cache ला वगळतात. हे नसल्यास, 8G RAM असलेल्या machine वर 2G file वरची दुसरी pass memory मधून पूर्ण होते आणि fio लाखोंमध्ये IOPS दाखवते. तो आकडा खरा आहे, पण तो memory चा आकडा आहे.
  • --ioengine=libaio asynchronous requests submit करते. त्यामुळे --iodepth=32 32 requests in flight ठेवू शकते. psync सारख्या synchronous engine सह iodepth 1 पेक्षा जास्त ठेवून काहीही साध्य होत नाही. त्यामुळे तुम्ही एका वेळी एकच request मोजता.
  • --time_based --runtime=60 ठरावीक कामाच्या प्रमाणाऐवजी निश्चित 60 seconds चालते. त्यामुळे fast disk आणि slow disk साठी wall clock time समान राहतो आणि तुलना निष्पक्ष राहते.
  • --size=2G test file चा size सेट करते. तो path मधील कोणत्याही cache पेक्षा मोठा ठेवा आणि आधी free space उपलब्ध आहे का ते तपासा.

Random write साठी --rw=randwrite वापरून हीच command चालवा. ती स्वतंत्रपणे चालवल्यानंतर file delete करा.

fio --name=randwrite4k --filename=./fio-testfile --size=2G --bs=4k \
  --rw=randwrite --ioengine=libaio --iodepth=32 --direct=1 \
  --runtime=60 --time_based --group_reporting
rm -f ./fio-testfile

प्रत्यक्ष network traffic शी अधिक जवळचा mix वापरण्यासाठी --rw=randrw --rwmixread=70 वापरा. तुम्ही वापरत असलेल्या storage च्या class मुळे हे results कोणत्याही flag पेक्षा अधिक बदलतात. हा फरक VPS वरील NVMe आणि SATA SSD storage मधील फरक येथे स्पष्ट केला आहे.

fio Unknown error -1 देऊन थांबल्यावर

प्रत्येक filesystem वर direct IO उपलब्ध नसते. त्यामुळे --direct=1 सेट असताना fio पहिल्याच request वर अपयशी ठरल्यास, सर्वप्रथम direct IO तपासा. अपयश असे दिसू शकते:

fio: io_u error on file ./fio-testfile: Unknown error -1: read offset=0, buflen=4096
fio: pid=1234, err=-1/file:ioengines.c:321, func=get_events, error=Unknown error -1

प्रथम df -hT . चालवा. overlay चा Type, म्हणजे Docker container ला default ने देत असलेला filesystem, स्वतःहून कारण नसतो. overlayfs O_DIRECT अंतर्गत असलेल्या filesystem कडे पाठवतो. अंतर्गत filesystem direct IO करू शकत नसेल, तरच तो ते नाकारतो. त्यामुळे ext4 किंवा xfs वर असलेल्या overlay वर --direct=1 --ioengine=libaio कार्य करते. Test file ज्या अंतर्गत filesystem वर आहे तो direct IO करू शकत नसेल, तर file उघडतानाच fio सहसा हे सांगते: fio: looks like your file system does not support direct=1/buffered=0. अशा वेळी --filename वास्तविक local storage वरील path कडे निर्देशित करा, उदाहरणार्थ bind mounted volume वापरा. किंवा container ऐवजी host वर fio चालवा. वास्तविक storage उपलब्ध नसेल, तर buffered synchronous run मुळे किमान command स्वतः योग्य आहे हे सिद्ध होते.

fio --name=randread4k-buffered --filename=./fio-testfile --size=256M --bs=4k \
  --rw=randread --ioengine=psync --direct=0 --numjobs=1 \
  --runtime=15 --time_based --group_reporting
rm -f ./fio-testfile

या run चा अर्थ स्पष्टपणे समजा. पहिल्या pass नंतर 256M file page cache मध्ये राहते. त्यामुळे IOPS आकडा disk चा नसून RAM चा वेग दर्शवतो. fio install आहे आणि flags योग्य प्रकारे parse होतात हे तपासण्यासाठी तो वापरा. हा आकडा disk result म्हणून कधीही नमूद करू नका.

dd हे डिस्क बेंचमार्क का नाही

dd हे अनेक VPS थ्रेड्समध्ये दिसते आणि ते एका मर्यादित प्रश्नाचे उत्तर देते.

dd if=/dev/zero of=./ddtest bs=1M count=1024 oflag=direct conv=fdatasync
rm -f ./ddtest

हे कमांड एका थ्रेड आणि एका सक्रिय विनंतीसह (request in flight) सीक्वेंशियल राइट थ्रूपुट मोजते. हे एक सामान्य कार्यक्षमता तपासण्यासाठी (sanity check) योग्य आहे. हे रँडम IO बद्दल काहीही सांगत नाही आणि जेव्हा एकाच वेळी 32 विनंत्या येतात तेव्हा काय होते, याबद्दलही माहिती देत नाही. oflag=direct काढून टाकल्यास राइट्स हे पेज कॅशेमधून जातात, परंतु conv=fdatasync मुळे कमांड पूर्ण होण्यापूर्वी आउटपुट डेटा स्टोरेजवर पाठवणे अनिवार्य असते. ते देखील काढून टाकल्यास, निकाल प्रामुख्याने तुमचा कर्नल मेमरीमध्ये किती वेगाने राइट्स स्वीकारतो हे मोजतो; म्हणूनच फोरम पोस्टमध्ये दिलेले dd चे आकडे अनेकदा अतार्किक असतात.

CPU: sysbench cpu

sysbench cpu --cpu-max-prime=20000 --threads=1 run
sysbench cpu --cpu-max-prime=20000 --threads=$(nproc) run

लक्षात ठेवण्यासाठीची संख्या events per second आहे. प्रथम सिंगल थ्रेडेड चाचणी चालवा. ही संख्या ठरवते की एखादी PHP विनंती किंवा एखादे compile जॉब किती वेगाने पूर्ण होईल, आणि समान किमतीच्या होस्ट्समध्ये यात सर्वाधिक फरक आढळतो. त्यानंतर सर्व थ्रेड्ससह चाचणी चालवा, ज्यामुळे तुमच्या वाट्याला आलेल्या vCPUs वर थ्रूपुट (throughput) कसे स्केल होते हे समजते.

हे कशाचे मोजमाप करते हे स्पष्ट असणे आवश्यक आहे: sysbench cpu वारंवार ट्रायल डिव्हिजनद्वारे मूळ संख्या (prime numbers) शोधते. प्रत्येक उमेदवारासाठी ते डबल प्रिसिजन स्क्वेअर रूट घेते, त्यानंतर 64-बिट इंटीजर मॉड्युलोजचा वापर करून भाजकांची चाचणी करते आणि प्रत्येक भाजकाची तुलना त्या फ्लोटिंग पॉइंट मर्यादेशी करते. त्यामुळे यात इंटीजर आणि फ्लोटिंग पॉइंट अशा दोन्ही कामांचे मिश्रण असते. हे मेमरी बँडविड्थ, वेक्टर युनिट्स किंवा कॅशेवर अशा प्रकारे ताण देत नाही जे वास्तविक वर्कलोडसारखे असेल, त्यामुळे दोन होस्ट्सची तुलना करण्यासाठी हे चांगले आहे, परंतु तुमचे ॲप्लिकेशन कसे चालेल याचा अंदाज घेण्यासाठी हे फारसे उपयुक्त नाही.

Ubuntu 24.04 मध्ये sysbench 1.0.20 समाविष्ट आहे, जिथे चाचणीचे नाव आधी येते. जुन्या पोस्टमधील --test=cpu असलेली कमांड कॉपी केल्यास तुम्हाला WARNING: the --test option is deprecated मिळेल. sysbench 0.4 आणि sysbench 1.0 चे स्कोअर एकमेकांशी अजिबात तुलना करण्यायोग्य नाहीत, त्यामुळे ज्या प्रकाशित आकड्यामध्ये आवृत्तीचा उल्लेख नाही, त्याच्याशी स्वतःची तुलना कधीही करू नका.

मेमरी: sysbench memory

sysbench memory --memory-block-size=1M --memory-total-size=20G --memory-oper=write --threads=1 run
sysbench memory --memory-block-size=1M --memory-total-size=20G --memory-oper=read --threads=1 run

निकाल MiB/sec मध्ये असतो. --memory-block-size ला 1M वर ठेवा आणि तुम्ही तुलना करत असलेल्या प्रत्येक होस्टवर ते सारखेच ठेवा. 1K वर आकडा कमी होतो, कारण तुम्हाला प्रति-ऑपरेशन ओव्हरहेड हजार पटीने जास्त मोजावा लागतो, त्यामुळे तुम्ही मेमरी बँडविड्थऐवजी लूपची किंमत मोजता. प्रकाशित मेमरी स्कोअरमध्ये हा सर्वात सामान्यपणे चुकीचा वापरला जाणारा फ्लॅग आहे.

नेटवर्क: iperf3

थ्रूपुट तपासण्याची योग्य पद्धत म्हणजे तुमच्या नियंत्रणाखालील दुसऱ्या मशीनविरुद्ध चाचणी घेणे. त्यामुळे दोन्ही टोकांवर काय सुरू आहे हे तुम्हाला माहीत असते.

दूरच्या टोकावर:

iperf3 -s

हा TCP 5201 वर ऐकतो. तुम्ही ज्या address वरून चाचणी घेणार आहात त्यासाठीच हा port उघडा. चाचणी पूर्ण झाल्यावर तो बंद करा. VPS वरील मूलभूत ufw firewall नियम याची syntax स्पष्ट करते.

चाचणीच्या VPS वरून:

iperf3 -c 203.0.113.10 -t 30
iperf3 -c 203.0.113.10 -t 30 -R
iperf3 -c 203.0.113.10 -t 30 -P 8

पहिली कमांड चाचणी होत असलेल्या मशीनकडून होणारे upload मोजते. -R दिशानिर्देश उलटते आणि download मोजते. -P 8 आठ समांतर streams उघडते.

एकल stream आणि समांतर आवृत्ती, दोन्ही चालवा. कारण त्या वेगवेगळ्या प्रश्नांची उत्तरे देतात. एका TCP connection मध्ये त्याच्या window ने परवानगी दिलेल्या मर्यादेइतकाच unacknowledged data ठेवता येतो. त्यामुळे त्याची कमाल गती साधारणपणे window size भागिले round trip time इतकी असते. 80 ms latency आणि 4 MB window असल्यास ही कमाल गती सुमारे 400 Mbit/s असते, जरी त्यामागील link कितीही वेगवान असली तरी. एकल stream मधून एका download ला मिळणारी गती समजते. समांतर आवृत्तीतून link ची capacity समजते.

ही चाचणी घेताना तुमच्या bandwidth allowance वर लक्ष ठेवा. 1 Gbit/s वेगाने 30 सेकंदांत सुमारे 3.75 GB data transfer होतो. प्रत्येक दिशेने ही चाचणी अनेकदा चालवावी लागेल.

संदर्भ आकडेवारी आणि ती कशी वाचावी

तक्ताTypical published 4k random read IOPS by storage class
या तक्त्यामागील डेटा
[
  {
    "device": "Local NVMe",
    "iops_4k_read": "180,000"
  },
  {
    "device": "Local SATA SSD",
    "iops_4k_read": "90,000"
  },
  {
    "device": "Network block",
    "iops_4k_read": "12,000"
  },
  {
    "device": "Spinning disk",
    "iops_4k_read": "180"
  }
]

प्रकाशित निकालांमध्ये स्थानिक NVMe व्हॉल्यूम साधारणपणे 180,000 4k रँडम रीड IOPS च्या आसपास असतो. स्थानिक SATA SSD ची क्षमता 90,000 च्या आसपास असते. नेटवर्क-अॅटॅच्ड ब्लॉक स्टोरेज, जिथे प्रत्येक विनंती डिस्कपर्यंत पोहोचण्यापूर्वी नेटवर्कवरून प्रवास करते, ते 12,000 च्या जवळ असते, आणि फिरणारी डिस्क (spinning disk) साधारणपणे 180 इतकी कामगिरी करते, कारण तिला प्रत्येक रँडम विनंतीसाठी भौतिक हेड हलवावे लागते.

ही प्रत्येक प्रकारच्या स्टोरेजसाठीची प्रमाणित प्रकाशित आकडेवारी आहे, एकाच होस्टवरील मोजमापे नाहीत. याचा वापर केवळ एकाच उद्देशासाठी करा: तुमचा स्वतःचा निकाल योग्य परिमाणात (order of magnitude) आहे का हे तपासण्यासाठी. जर NVMe म्हणून विकल्या जाणाऱ्या प्लॅनचे 4k IOPS बेंचमार्क काही हजारांच्या घरात येत असतील, तर सर्वप्रथम --direct=1 सुरू असल्याची खात्री करा. जर ते सुरू असेल, तर प्लॅनच्या IOPS मर्यादा आणि बर्स्ट क्रेडिट्स तसेच स्टोरेजमधील स्पर्धा (contention) आणि जाहिरात केलेल्या हार्डवेअरची पडताळणी करा.

एकच रन बेंचमार्क का मानू नये

एकच निकाल म्हणजे सामायिक मशीनवर घेतलेला एका मिनिटाचा स्नॅपशॉट असतो. त्याकडे केवळ एक नमुना म्हणून पहा.

  • प्रत्येक चाचणी किमान पाच वेळा चालवा. या चाचण्या वेगवेगळ्या वेळी आणि किमान दोन वेगवेगळ्या दिवसांत विभागून घ्या. मध्यक (median) आणि व्याप्ती (spread) नोंदवून ठेवा. व्याप्तीशिवाय प्रकाशित केलेला निकाल हा केवळ मार्केटिंगचा आकडा असतो.
  • प्रत्येक रनसोबत steal time नोंदवा. जेव्हा st जास्त असेल तेव्हा ते रन जपून ठेवा आणि ते contention मुळे आहे की प्लॅनच्या CPU कोटा मुळे, याचा तपास करा; त्यांना काढून टाकल्यास तुम्हाला प्रत्यक्षात मिळणारी कामगिरी लपली जाऊ शकते.
  • डिस्क चाचणी दोन कालावधीसाठी चालवा. अनेक प्लॅनमध्ये burst IOPS ची सवलत असते जी कालांतराने भरून निघते, परंतु 60 सेकंदांची fio रन किंवा --runtime=600 यापैकी कशाचीही खात्री नसते की तुम्ही किमान कामगिरी (floor) मोजली आहे. AWS gp2 क्रेडिट्स पूर्ण बॅलन्स असताना किमान 30 मिनिटांसाठी 3,000 IOPS टिकवू शकतात, त्यामुळे दोन्ही रन burst कामगिरी मोजू शकतात. प्रोव्हायडरचे क्रेडिट मॉडेल तपासा आणि निकालाला 'सस्टेन्ड परफॉर्मन्स' म्हणण्यापूर्वी क्रेडिट बॅलन्सवर लक्ष ठेवा.
  • इतर काहीही सुरू नाही याची खात्री करा. CPU चाचणीच्या मध्यभागी unattended-upgrades ने apt ट्रान्झॅक्शन सुरू केल्यास तुमचे गुण कमी होतात आणि प्रत्येक रनपूर्वी ps -e -o comm= | grep -E 'apt|dpkg' घेतल्यास एक सेकंद वाया जातो.
  • एका वेळी एकच व्हेरिएबल बदला. टूलच्या वेगवेगळ्या आवृत्त्या, ब्लॉक साईज किंवा थ्रेड काउंटमुळे मिळणारे आकडे एकमेकांशी तुलना करण्यायोग्य नसतात, मग ते दिसायला कितीही सारखे का असेनात.

जेव्हा तुम्ही दोन प्रोव्हायडर्सची तुलना करता, तेव्हा त्या चाचण्या एकाच दिवशी आणि एकाच वेळी चालवा. अन्यथा, तुम्ही केवळ वेळेचा प्रभाव मोजत असता.

तुमच्या स्वतःच्या वर्कलोडचे शेवटी बेंचमार्क करा

सिंथेटिक साधने मशीनची क्रमवारी ठरवतात. मशीन पुरेसे आहे की नाही हे फक्त तुमचे स्वतःचे वर्कलोड सांगते. तुम्ही प्रत्यक्षात करत असलेल्या कामाचा वेळ मोजा.

time tar -czf /tmp/bench.tgz /usr/share
rm -f /tmp/bench.tgz

यामुळे काहीशे मेगाबाइट्सचे संकुचन होते. त्यामुळे CPU आणि डिस्क या दोन्हींची एकत्र चाचणी होते आणि त्यापैकी कोणत्याही घटकात बदल झाल्यास निकाल बदलतो. Removing leading / from member names चेतावणी सामान्य आहे. त्याहून चांगले म्हणजे तुमच्या स्वतःच्या build चा, सर्वाधिक वेळ घेणाऱ्या query चा किंवा page render चा वेळ मोजा. एका host वर build पूर्ण होण्यासाठी 4 मिनिटे आणि दुसऱ्यावर 7 मिनिटे लागत असतील, तर Geekbench ने काहीही निष्कर्ष दिला असला तरी प्रश्नाचे उत्तर स्पष्ट झाले आहे. अधिक क्षमतेच्या मशीनसाठी पैसे देणे कधी थांबवावे हेही याच मोजमापातून समजते. VPS ची दरमहा प्रत्यक्ष किंमत किती असते हे वाचण्यापूर्वी किंवा वर्कलोड dedicated server वर हलवण्यापूर्वी हे जाणून घेणे उपयुक्त आहे.

FAQ

प्रत्येक वेळी बेंचमार्क चालवताना मला वेगवेगळे निकाल का मिळतात?

VPS मध्ये फिजिकल CPU, स्टोरेज आणि नेटवर्क इतर भाडेकरूंशी (tenants) सामायिक केलेले असते, त्यामुळे तुमचा निकाल त्या क्षणी ते काय करत आहेत यावर अवलंबून असतो. चाचणी दरम्यान vmstat 1 चालवा आणि st कॉलम वाचा: 'sustained steal time' उपलब्ध नसलेला CPU वेळ नोंदवतो, परंतु ते तुमच्या खरेदी केलेल्या CPU वाटपाची अंमलबजावणी किंवा होस्टवरील गर्दी (contention) दर्शवू शकते. 5% पेक्षा जास्त मूल्य म्हणजे नेमके कारण काय हे स्पष्ट होत नाही. याचे उत्तर ट्युनिंगमध्ये नसून पद्धतीमध्ये आहे. प्रत्येक चाचणी वेगवेगळ्या वेळी पाच किंवा अधिक वेळा चालवा, त्यानंतर मध्यक (median) आणि त्याचा विस्तार (spread) नोंदवा.

fio लाखो IOPS का दाखवते?

जवळजवळ नेहमीच याचे कारण --direct=1 गहाळ असणे हे असते. त्याशिवाय fio कर्नल पेज कॅशेमधून वाचते, त्यामुळे पहिल्या पासनंतर 2G ची टेस्ट फाईल RAM मधून सर्व्ह केली जाते आणि तुम्ही मेमरी बँडविड्थ मोजता. --direct=1 जोडा आणि टेस्ट फाईल मार्गातील कोणत्याही कॅशेपेक्षा मोठी ठेवा. जर --direct=1 अपयशी ठरले, तर df -hT . चालवा आणि टेस्ट फाईल कशावर आहे ते तपासा. overlay प्रकार स्वतःहून समस्या नाही, कारण overlayfs O_DIRECT ला खालच्या स्टोरेजपर्यंत पोहोचवते. जर खालची फाईलसिस्टम direct IO नाकारत असेल, तरच टेस्ट फाईल खऱ्या लोकल स्टोरेजवर हलवा.

yabs.sh एकट्याने पुरेसे आहे का?

प्राथमिक निरीक्षणासाठी, हो. हे चार ब्लॉक साईजवर fio, दोन्ही दिशांना iperf3 आणि Geekbench चालवते आणि एक सारांश छापते जो इतर लोक वाचू शकतात. जेव्हा तुम्हाला एखादा आकडा तसा का आहे हे जाणून घ्यायचे असते, तेव्हा हे अपुरे पडते, कारण तुम्ही प्रत्येक चाचणीसाठी त्याचे फ्लॅग बदलू शकत नाही. एकदा का yabs चा निकाल चुकीचा वाटला की, तो fio किंवा sysbench वापरून थेट पुन्हा तयार करा आणि एका वेळी एकच फ्लॅग बदला.

माझा ॲप्लिकेशन कसा चालेल हे कोणता एक आकडा सांगू शकतो?

बहुतेक वेब आणि डेटाबेस वर्कलोडसाठी, सिंगल कोअर CPU स्पीड आणि 4k रँडम रीड लॅटन्सी हे दोन घटक महत्त्वाचे आहेत. थ्रूपुटचे आकडे प्रभावी वाटतात पण ते क्वचितच निर्णायक ठरतात, कारण सामान्य विनंती (request) लहान असते. सरासरीऐवजी fio clat percentiles ब्लॉक मधील 99 व्या पर्सेंटाईलचा (99th percentile) आकडा पहा, कारण शंभरपैकी एक मंद विनंती वापरकर्त्याला जाणवते.

बेंचमार्किंग करण्यापूर्वी मला काही इन्स्टॉल करण्याची गरज आहे का?

fio, sysbench आणि iperf3 हे सर्व Ubuntu आणि Debian आर्काइव्हमध्ये उपलब्ध आहेत: sudo apt install -y fio sysbench iperf3. yabs.sh हे Bash मध्ये चालते आणि डाउनलोडसाठी curl किंवा wget ची गरज असते, तसेच Geekbench एक्सट्रॅक्ट करण्यासाठी tar लागते; tar शिवाय, ते Geekbench वगळते. जेव्हा fio आणि iperf3 इन्स्टॉल केलेले असतात तेव्हा ते त्यांचा वापर करते आणि ते नसल्यास स्टॅटिक बायनरीज डाउनलोड करते. काम संपल्यावर प्रत्येक टेस्ट फाईल डिलीट करा, कारण 20G डिस्कवर मागे राहिलेली 2G ची fio फाईल काही आठवड्यांनंतर कोणाच्या तरी डिस्क फुल होण्याचे कारण ठरू शकते.

हा लेख उपयुक्त होता का?

#benchmarks#fio#sysbench#yabs#iperf3#vps-performance