VPS హోస్టింగ్ కోసం NVMe SSD అవసరమా? పూర్తి వివరాలు
NVMe మరియు SATA SSD మధ్య తేడాలను తెలుసుకోండి. IOPS మరియు లేటెన్సీలో NVMe మెరుగ్గా ఉన్నా, VPS పనితీరుపై హైపర్వైజర్ ప్రభావం ఎలా ఉంటుందో మరియు fio ద్వారా దీన్ని ఎలా పరీక్షించాలో చూడండి.
VPSలో NVMe ప్రాముఖ్యత ఏమిటి?
మీ software అనేక చిన్న reads మరియు writes పంపి, ప్రతి operation పూర్తయ్యే వరకు వేచి ఉన్నప్పుడు VPSలో NVMe ప్రాముఖ్యత కలిగి ఉంటుంది. Cached pages అందించే siteకు లేదా network కోసం ఎక్కువ సమయం వేచి ఉండే programకు దీని వల్ల పెద్దగా మార్పు ఉండదు. Storage medium ఒక అంశం. Disk ముందు ఉన్న hypervisor మరియు అదే hostను పంచుకునే ఇతర guests కలిసి, మీకు వాస్తవంగా లభించే పనితీరుకు గరిష్ఠ పరిమితిని నిర్ణయిస్తాయి.
NVMeలో మారేది, మారనిది
NVMe (non-volatile memory express) అనేది flash memory రకం కాదు. Flash memoryని చేరుకోవడానికి ఉపయోగించే protocol మరియు connection ఇది. NVMe device PCIe (peripheral component interconnect express) lanesపై పనిచేస్తూ NVMe protocolతో communicate చేస్తుంది. SATA (serial ATA) SSD, SATA linkపై పనిచేస్తూ AHCI (advanced host controller interface) protocolతో communicate చేస్తుంది. మీ data bytes ను నిల్వ చేసే memory chips రెండింటిలోనూ ఒకేలా ఉండవచ్చు.
రెండు విషయాలు మాత్రమే మారుతాయి. అవి storageలో కాకుండా command pathలో ఉంటాయి.
Queues. ప్రతి SATA portకు AHCI ఒక command listను ఇస్తుంది. అందులో గరిష్ఠంగా 32 command slots ఉంటాయి. అందువల్ల SATA drive ఒకేసారి 32 కంటే ఎక్కువ commandsను ఉంచదు. NVMe వేల సంఖ్యలో queuesను అనుమతిస్తుంది. ఆచరణలో ప్రతి CPU coreకు ఒక queue ఉండవచ్చు. ప్రతి queue 32 కంటే చాలా లోతుగా ఉంటుంది. ఒక process ఒకసారి ఒక blockను మాత్రమే చదివితే ఈ తేడా కనిపించదు. ఒక databaseకు ఒకేసారి 64 reads pendingగా ఉంటే తేడా కనిపిస్తుంది: SATAలో 33వ requestకు ఖాళీ slot లభించే వరకు వేచి ఉండాలి. Device దాన్ని చూడకముందే ఈ నిరీక్షణ జరుగుతుంది. NVMe device అన్ని requestsను స్వీకరించి, వాటిపై ఒకేసారి పని చేస్తుంది.
Link width. SATA III link 6 Gbit/s వేగంతో పనిచేస్తుంది. Protocol overhead తీసిన తర్వాత ఇది వాస్తవ dataకు సుమారు 550 MB/s అవుతుంది. దాని వెనుక ఏ flash ఉన్నా ఈ పరిమితి మారదు. నాలుగు PCIe lanes సెకనుకు అనేక gigabytesను మోయగలవు. అందువల్ల SATA కంటే చాలా ఎక్కువ bandwidth లభిస్తుంది. అయినప్పటికీ link పరిమితిగా మారవచ్చు: random workloadsలో PCIe Gen5 SSDలు PCIe Gen5 linkను పూర్తిగా వినియోగించగలవని Micron వివరిస్తుంది.
Latency విషయంలో సాధారణ అంచనాలు తరచుగా తప్పుతాయి. Queue depth 1లో, అంటే ఒక request మాత్రమే అమలులో ఉన్నప్పుడు, SATA SSD 4k readకు సుమారు 100 నుంచి 150 microsecondsలో స్పందిస్తుంది. NVMe సుమారు 80 నుంచి 100 microsecondsలో స్పందిస్తుంది. రెండూ వేగంగా ఉంటాయి. ఒక requestపై ఈ తేడాను మీరు నడిపే ఏ software కూడా గమనించదు. Concurrency పెరిగినప్పుడు తేడా స్పష్టమవుతుంది. ఒకేసారి అమలులో ఉన్న requests సంఖ్య అయిన queue depth, ఈ రెండు media ఒకేలా కనిపిస్తాయా లేదా చాలా భిన్నంగా కనిపిస్తాయా అనేది నిర్ణయించే setting.
Network block storage మూడవ తరగతికి చెందుతుంది. దీనికి భిన్నమైన పనితీరు పరిమితులు ఉంటాయి. ఒక write network ద్వారా storage clusterకు చేరుతుంది. Cluster దాన్ని నిల్వ చేసిన తర్వాత మాత్రమే acknowledgement ఇస్తుంది. అందువల్ల దాని latency microseconds బదులుగా millisecondsలో కొలుస్తారు. ఆ latencyకి బదులుగా మీకు లభించేది durability: volume దానికి attachedగా ఉన్న host కంటే ఎక్కువకాలం ఉంటుంది. దానికి snapshot తీసుకోవచ్చు, దాని పరిమాణాన్ని మార్చవచ్చు.
సాధారణంగా ప్రచురించే గణాంకాలు: NVMe, SATA SSD మరియు network storage
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"disk": "Local NVMe SSD",
"iops_4k_read": "184,000",
"p99_latency_ms": 0.4,
"seq_read_mbps": "3,400"
},
{
"disk": "Local SATA SSD",
"iops_4k_read": "90,000",
"p99_latency_ms": 1.2,
"seq_read_mbps": "550"
},
{
"disk": "Network block storage",
"iops_4k_read": "12,500",
"p99_latency_ms": 6.5,
"seq_read_mbps": "250"
}
]స్థానిక NVMe device ను queue depth 32 వద్ద సాధారణంగా 184,000 random 4k read IOPS (input/output operations per second) గా పేర్కొంటారు. అదే పరీక్షలో SATA SSD విలువ సుమారు 90,000గా ఉంటుంది. ప్రతి port కు AHCI అందించే 32 command slots మరియు 6 Gbit/s link దీనిని పరిమితం చేస్తాయి. Network block storage ను hardware కంటే provider పరిమితం చేయడం సాధారణం. అందువల్ల 12,500 సాధారణంగా documentation లో పేర్కొనే గరిష్ఠ పరిమితి.
Latency ను users అనుభవించే unit లో పరిశీలిస్తే ఇదే విషయం స్పష్టమవుతుంది. p99 read latency అంటే 99 శాతం requests పూర్తయ్యే సమయం. మిగిలిన నెమ్మదైన 1 శాతం requests మాత్రమే దీనికంటే ఎక్కువ సమయం తీసుకుంటాయి. స్థానిక NVMe పై ఇది సుమారు 0.4 ms, SATA పై 1.2 ms ఉంటుంది. మధ్యలో network ను ఉంచితే ఇది 6.5 ms అవుతుంది. ఇది NVMe విలువ కంటే పది రెట్లకు మించి.
Sequential reads లో తేడా అత్యధికంగా ఉంటుంది. అయితే ఇది తక్కువ ఉపయోగకరమైన కొలత: 3,400 MB/s తో పోలిస్తే 550 MB/s. Server లో దాదాపు ఏదీ ఒక పెద్ద file ను మొదటి నుంచి చివరి వరకు పూర్తి వేగంతో చదవదు. Database, mail queue లేదా package manager వాస్తవంగా చేసే పనిని random column మరియు latency column బాగా వివరిస్తాయి.
ఈ గణాంకాలు ఎక్కడి నుంచి వచ్చాయి, మీ విలువలు ఎందుకు భిన్నంగా ఉంటాయి
ఈ 3 rows స్థానిక devices కు vendor datasheet figures, network storage కు documentation లో ఉన్న per-volume limits ఆధారంగా రూపొందించబడ్డాయి. ఇవి July 2026 నాటికి అందుబాటులో ఉన్న విలువలు, rounded figures. ఇవి 4k block size, random reads మరియు queue depth 32 ను ఆధారంగా తీసుకుంటాయి. దీనికి అదనంగా vendors అందరూ ఒకే సంఖ్యలో workers ను ఉపయోగించరు. ఉదాహరణకు, Samsung's 990 PRO datasheet తన ప్రధాన random figures ను "QD 32 Thread 16" కోసం పేర్కొంటుంది. అందువల్ల queue depth 32 తో నడిపిన ఒకే fio job, datasheet కు ఆధారమైన పరీక్ష కంటే తేలికైనది. మీ VPS ఒక shared host పై guest గా నడుస్తుంది. కాబట్టి అదే పరీక్ష మీ box పై సాధారణంగా తక్కువ విలువను ఇస్తుంది. ప్రతి run లో ఈ విలువ మారవచ్చు. ఈ rows ను మూడు తరగతుల మధ్య తేడా ఎలా ఉంటుందో చూపించే ఆకృతిగా చూడండి. వాటిని చేరుకోవాల్సిన target గా చూడవద్దు.
ఏ వర్క్లోడ్లు డిస్క్ను గమనిస్తాయి
వాటన్నింటికీ ఒకే నియమం వర్తిస్తుంది: ఒక వర్క్లోడ్ డిస్క్ కోసం వేచి ఉన్నప్పుడు మాత్రమే అది డిస్క్ను గమనిస్తుంది. Linux ఇటీవల ఉపయోగించిన ఫైల్ డేటాను RAMలో, పేజీ కాష్లో ఉంచుతుంది, కాబట్టి ఒక ఫైల్ను రెండోసారి చదివినప్పుడు అది స్టోరేజ్కు వెళ్లదు. వర్కింగ్ సెట్, అంటే వాస్తవానికి ఉపయోగంలో ఉన్న డేటా, RAMలో సరిపోతే, మొదటిసారి చదివిన తర్వాత రీడ్ ఆపరేషన్లు మెమరీ రీడ్స్గా మారుతాయి. రైట్ ఆపరేషన్లు భిన్నంగా ఉంటాయి. అప్లికేషన్ fsync() ద్వారా ఫ్లష్ చేసే ఏదైనా రైట్ ఆపరేషన్, అప్లికేషన్ కొనసాగడానికి అనుమతించబడటానికి ముందే స్థిరమైన స్టోరేజ్లో ఉండాలి.
కమిట్ చేసే పని. PostgreSQL, MySQL మరియు SQLite కమిట్ సమయంలో fsync() లేదా fdatasync()ని పిలుస్తాయి, మరియు ప్రతి కమిట్ డివైజ్ నుండి సమాధానం కోసం వేచి ఉంటుంది. కాబట్టి ఒక కనెక్షన్ యొక్క కమిట్ రేటు బ్యాండ్విడ్త్ ద్వారా కాకుండా, రైట్ లేటెన్సీ ద్వారా నిర్ణయించబడుతుంది. 0.2 msలో ఫ్లష్ చేసే డివైజ్, 5 ms తీసుకునే డివైజ్ కంటే సెకనుకు ఎక్కువ కమిట్లను అనుమతిస్తుంది, మరియు ఎంత త్రూపుట్ ఉన్నా అది మారదు. ఫ్లష్ వేగం సరిపోనప్పుడు MySQL ఎర్రర్ లాగ్లో ఇలా చెబుతుంది:
[Note] InnoDB: page_cleaner: 1000ms intended loop took 4589ms. The settings might not be optimal.PostgreSQL దీనిని తన చెక్పాయింట్ లైన్లలో నివేదిస్తుంది, అక్కడ పెద్ద sync= విలువ అంటే ఫ్లష్ ప్రక్రియ నెమ్మదిగా ఉందని అర్థం:
LOG: checkpoint complete: wrote 8192 buffers (25.0%); write=27.694 s, sync=11.207 s, total=39.001 sఅనేక చిన్న ఫైళ్లను తాకే పని. ప్రతి ఫైల్ మెటాడేటా ఆపరేషన్లను కలిగి ఉంటుంది, ఇవి పెద్ద సీక్వెన్షియల్ రీడ్లో ఉండవు. npm install, పెద్ద రిపోజిటరీ యొక్క git clone, కంటైనర్ ఇమేజ్లను అన్ప్యాక్ చేయడం, Maildir మెయిల్ స్టోర్ మరియు పెద్ద ట్రీని వాక్ చేసే బ్యాకప్ అన్నీ తమ సమయాన్ని చిన్న రాండమ్ యాక్సెస్ కోసం వెచ్చిస్తాయి. ఒక VPSపై restic బ్యాకప్ జాబ్ తాను ఇంతకు ముందు చూడని ప్రతి ఫైల్ను చదివి హ్యాష్ చేస్తుంది, కాబట్టి మిలియన్ ఫైళ్లపై బ్యాకప్ తీసుకునే సమయం రాండమ్ రీడ్ లేటెన్సీని దగ్గరగా అనుసరిస్తుంది. du -sh విషయంలో కూడా ఇదే నిజం, ఇది మెటాడేటాను మాత్రమే చదువుతుంది.
RAM పరిమితిని మించే డేటాబేస్లు కూడా ఈ వర్గంలోకే వస్తాయి. ఇండెక్స్ ఇకపై పేజీ కాష్లో సరిపోనప్పుడు, ప్రతి లుకప్ ఒక రాండమ్ రీడ్గా మారుతుంది మరియు డిస్క్ మళ్లీ క్రిటికల్ పాత్లోకి వస్తుంది.
ఏ వర్క్లోడ్లు డిస్క్ పనితీరును గమనించవు
బ్లాగ్ లేదా చిన్న కంపెనీ సైట్. పేజీలు చిన్నవిగా ఉంటాయి. మొదటి అభ్యర్థన తర్వాత పేజీ కాష్ (page cache) వాటన్నింటినీ నిల్వ చేస్తుంది. రెండరింగ్ కోసం CPU లేదా అసెట్స్ కోసం బ్యాండ్విడ్త్ పరిమితిగా ఉంటాయి. తక్కువ ట్రాఫిక్ ఉన్న సైట్ను అందించే Ubuntu 24.04 పై LAMP stack వేడెక్కిన తర్వాత దాదాపు ఎటువంటి డిస్క్ IOని ఉపయోగించదు.
మీడియా స్ట్రీమింగ్. 40 Mbit/s వేగంతో ఒక 4K స్ట్రీమ్ 5 MB/s డేటాను చదువుతుంది. పది స్ట్రీమ్లు 50 MB/s డేటాను చదువుతాయి, దీనిని నెట్వర్క్ బ్లాక్ స్టోరేజ్ కూడా సులభంగా అందించగలదు. VPS పై Jellyfin మీడియా సర్వర్ మీ నెట్వర్క్ ఈగ్రెస్ (egress) పరిమితి ద్వారా మరియు ట్రాన్స్కోడింగ్ చేసేటప్పుడు CPU ద్వారా పరిమితం చేయబడుతుంది, స్టోరేజ్ మాధ్యమం ద్వారా కాదు.
లోకల్ మోడల్ ఇన్ఫరెన్స్. LLMని సెల్ఫ్-హోస్ట్ చేయడానికి VPSలో Ollamaని రన్ చేయడం మోడల్ ఫైల్ను ఒకసారి చదివి, ఆపై RAMలో పనిచేస్తుంది. NVMe 20 GB మోడల్ లోడ్ అయ్యే సమయాన్ని నిమిషాల నుండి సెకన్లకు తగ్గిస్తుంది. ఇది టోకెన్ల వేగాన్ని మార్చదు, ఎందుకంటే అది మెమరీ బ్యాండ్విడ్త్ మరియు CPUపై ఆధారపడి ఉంటుంది.
బాహ్య సేవ కోసం వేచి ఉండే ఏదైనా. ప్రతి జాబ్కు HTTP అభ్యర్థన కోసం 800 ms సమయం తీసుకునే వర్కర్, మెరుగైన డిస్క్ ఉన్నంత మాత్రాన వేగంగా పనిచేయదు.
Hypervisor medium తో సమానంగా ఎందుకు ముఖ్యమో
మీరు నేరుగా device తో మాట్లాడరు. సాధారణంగా virtio ద్వారా hypervisor అందించే virtual disk తోనే పని చేస్తారు. ఆ layer లోని అనేక నిర్ణయాలు NVMe మరియు SATA మధ్య తేడాకన్నా ఎక్కువ ప్రభావం చూపుతాయి.
Guest లోపల medium ను చూడలేరు. lsblk -d -o NAME,ROTA,SIZE,MODEL ఖాళీ model తో vda ను చూపిస్తుంది, ఎందుకంటే virtio drive identity ని దాటి పంపదు. cat /sys/block/vda/queue/rotational hypervisor ప్రకటించే వివరాలను report చేస్తుంది. అందువల్ల అక్కడ 0 కనిపించడం flash storage ఉందని నిరూపించదు. nvme-cli package కు చెందిన nvme list చాలా VPS లలో ఏదీ చూపించదు. Host లో NVMe drives ఉన్నప్పటికీ ఇది జరుగుతుంది, ఎందుకంటే మీ disk virtio device, NVMe device కాదు. NVMe అని చెప్పే plan సాధారణంగా host లో ఉన్న storage ను సూచిస్తుంది. మీ volume network-attached అయి ఉండవచ్చు.
Host cache mode medium కన్నా numbers పై ఎక్కువ ప్రభావం చూపుతుంది. Host లో writeback caching enabled ఉంటే, host data ను తన RAM లో ఉంచగానే guest write పూర్తయినట్లు కనిపించవచ్చు. Flush చేయని benchmark ఫలితాలను ఇది కృత్రిమంగా మెరుగ్గా చూపిస్తుంది. Host flushes ను కూడా ignore చేసేలా configured అయితే, QEMU unsafe అని పిలిచే mode లో, guest fsync() కూడా host RAM నుంచి వెంటనే return అవుతుంది. ఏ physical device కూడా అందించలేని benchmark ఫలితం వస్తుంది. Database సురక్షితంగా ఉందని భావించే writes ను host crash సమయంలో కోల్పోయే ప్రమాదం కూడా ఉంటుంది. Cache mode none ఉపయోగించినప్పుడు host page cache ను దాటవేస్తుంది. అప్పుడు numbers తక్కువగా ఉన్నా వాస్తవానికి దగ్గరగా ఉంటాయి.
Caps మరియు burst credits. చాలామంది providers volume లేదా plan కు IOPS పరిమితి విధిస్తారు. అనేక network volumes burst allowance ను ఉపయోగిస్తాయి. Burst allowance అనేది credits pool. Credits ఉన్నంతకాలం volume వేగంగా నడుస్తుంది. తరువాత చాలా తక్కువ baseline కు పడిపోతుంది. దీని లక్షణం సులభంగా గుర్తించవచ్చు. Import లేదా restore కొన్ని నిమిషాలు వేగంగా నడుస్తుంది. తరువాత configuration లో ఏ మార్పూ లేకుండానే వేగం తీవ్రంగా తగ్గి అలాగే ఉంటుంది. మీరు credits ఖర్చు చేశారు.
Neighbours. Shared host లో ఇతర guests ఏమి చేస్తున్నారనే దాని ఆధారంగా మీ disk latency మారుతుంది. అందుకే ఒకసారి కంటే ఎక్కువసార్లు measure చేయాలి. అదే test ను ఉదయం ఒకసారి, సాయంత్రం మరోసారి run చేసి, రెండు ఫలితాల spread ను compare చేయండి. Busy host లో అదే volume పై రెండు runs మధ్య తేడా, రెండు media ల మధ్య ప్రచురించిన తేడాకన్నా తరచుగా ఎక్కువగా ఉంటుంది.
మీ VPSలో వాస్తవంగా ఉన్న disk పరిమాణాన్ని ఎలా కొలవాలి
ప్రామాణిక IO benchmark అయిన fioను install చేసి కొలవండి. ముందుగా మూడు జాగ్రత్తలు. ఈ test ఒక fileను సృష్టిస్తుంది. కాబట్టి ఇది disk spaceను ఉపయోగిస్తుంది. మీకు billingలో వర్తించే ఏదైనా IOPS allowanceలో ఇది లెక్కించబడుతుంది. Runsను తక్కువసేపు మాత్రమే కొనసాగించండి. Live trafficను అందిస్తున్న volumeపై full queue depthతో దీన్ని run చేయవద్దు. అలా చేస్తే మీ స్వంత applicationతో resources కోసం పోటీ పడతారు.
sudo apt update && sudo apt install -y fio ioping sysstat
cd /var/tmpQueue depth 32 వద్ద random read. Vendors సాధారణంగా quote చేసే depth ఇదే. చాలామంది ఒకేసారి అనేక threadsను కూడా run చేస్తారు. అందువల్ల single job సాధారణంగా datasheetలోని విలువ కంటే తక్కువగా ఉంటుంది:
fio --name=randread --filename=fio.test --size=1G --bs=4k --rw=randread \
--ioengine=libaio --direct=1 --iodepth=32 --numjobs=1 \
--runtime=30 --time_based --group_reportingప్రాముఖ్యమైన line read:తో ప్రారంభమవుతుంది
read: IOPS=184k, BW=719MiB/s (754MB/s)(21.1GiB/30001msec)--direct=1 guest page cacheను దాటవేస్తుంది. అందువల్ల ఫలితం మీ guest RAMను కాకుండా virtual diskను వివరిస్తుంది. ఇది hostలోని cacheను దాటవేయదు. Host page cache pathలో ఉందా లేదా అనేది host cache modeపై ఆధారపడి ఉంటుంది. QEMU దాన్ని cache.direct=on ఉన్నప్పుడు మాత్రమే దాటవేస్తుంది. Guest లోపల నుంచి ఆ settingను చూడలేరు. --direct=1ను వదిలేస్తే మీరు memoryను measure చేస్తారు. అప్పుడు ఏ diskకూ చేరుకోలేని సంఖ్య వస్తుంది. మీకు తగినంత space ఉంటే --size=4G లేదా అంతకంటే పెద్ద విలువను ఉపయోగించండి. 1G file మొత్తం host cacheలోనే ఉండి ఫలితాన్ని కృత్రిమంగా ఎక్కువగా చూపించవచ్చు.
Queue depth 1లో ఒకేసారి ఒక request మాత్రమే in flightలో ఉంటుంది. అందువల్ల ఇది raw latencyను చూపిస్తుంది. ఒకదాని తర్వాత ఒకటి synchronous reads చేసే process అనుభవించేది ఇదే. Asynchronous IO ఉపయోగించే single thread అనేక requestsను in flightలో ఉంచగలదు. కాబట్టి అది ఈ సంఖ్యకు పరిమితం కాదు:
fio --name=lat --filename=fio.test --size=1G --bs=4k --rw=randread \
--ioengine=libaio --direct=1 --iodepth=1 --runtime=30 --time_basedCommit test database ప్రవర్తనను అంచనా వేస్తుంది. ఇది 4kను write చేసి, ప్రతి write తర్వాత fdatasync()ను call చేస్తుంది. అందువల్ల నివేదించిన rateలో flush కూడా చేర్చబడుతుంది:
fio --name=commit --filename=fio.test --size=1G --bs=4k --rw=randwrite \
--ioengine=psync --fdatasync=1 --runtime=30 --time_based
rm -f fio.testఆ runలోని IOPS figure, ఒక database connection commit చేయగల చిన్న transactions per second గరిష్ఠ సంఖ్యకు దగ్గరగా ఉంటుంది. కారణం, commit కూడా ఇదే flush పూర్తయ్యే వరకు వేచి ఉంటుంది.
fio లేకుండా త్వరిత sample కోసం:
ioping -c 20 .--- . (ext4 /dev/vda1) ioping statistics ---
19 requests completed in 4.13 ms, 76 KiB read, 4.60 k iops, 17.9 MiB/s
min/avg/max/mdev = 174.2 us / 217.6 us / 386.1 us / 51.3 usmdev value, అంటే mean deviation, averageతో సమానంగా ప్రాముఖ్యమైనది. Idle boxలో deviation పెద్దగా ఉంటే storage backend sharedగా ఉండి busyగా ఉందని అర్థం.
ఫలితాన్ని ఎలా చదవాలి
July 2026 నాటికి, చిన్న VPS కోసం ఇవి సమంజసమైన అంచనాలు. queue depth 32 వద్ద 4k random read IOPS పదివేల స్థాయిలో ఉండటం, అలాగే queue depth 1 latency సుమారు 0.3 ms కంటే తక్కువగా ఉండటం local flash కు అనుగుణంగా ఉంటుంది. అయితే పెద్ద DRAM cache కలిగిన storage array కూడా సుమారు 0.2 msలో సమాధానం ఇవ్వగలదు. queue depth 1 latency అనేక milliseconds గా ఉంటే, అది network path లేదా hostపై ఉన్న IOPS పరిమితిని సూచిస్తుంది. plan పేరు ఏదైనా కావచ్చు: hypervisor పరిమితి 250 IOPS మాత్రమే ఉన్నా, ఒక్కో అభ్యర్థనను ఒకేసారి నిర్వహించడం వల్ల ప్రతి అభ్యర్థనకు సుమారు 4 ms పడుతుంది. Sequential reads సుమారు 550 MB/s వద్ద ఆగితే అది SATA link కు సరిపోతుంది. అయితే hostపై విధించిన bandwidth పరిమితి కూడా అదే స్థిరమైన రేఖను చూపిస్తుంది. అందువల్ల దీన్ని నిర్ధారణగా కాకుండా సూచనగా మాత్రమే పరిగణించాలి. ఏ ఒక్క device చేయగల సామర్థ్యాన్ని చాలా మించిన సంఖ్య కనిపిస్తే, ఆ ప్రక్రియలో caching ఉన్నదని అర్థం. ఇది దాదాపు ఎల్లప్పుడూ hostపైనే జరుగుతుంది.
మీ live workload diskపై చూపుతున్న ప్రభావాన్ని చూడటానికి:
iostat -x 1 3
vmstat 1 5
cat /proc/pressure/ioiostat -x outputలో r_await మరియు w_await ను చదవండి. ఇవి ఒక request వేచి ఉన్న సగటు milliseconds ను సూచిస్తాయి. అలాగే సగటు queue length అయిన aqu-sz ను చదవండి. Virtual diskపై %util ను పట్టించుకోకండి. కనీసం ఒక request pendingగా ఉన్న సమయ భాగాన్ని ఇది చూపిస్తుంది. ఒకేసారి అనేక requestsను నిర్వహించే deviceపై saturation స్థితి గురించి ఇది ఏమీ చెప్పదు. అందువల్ల %util విలువ 100గా ఉండి, r_await విలువ 0.2 msగా ఉంటే, అది సాధారణంగా పనిచేస్తున్న busy diskను సూచిస్తుంది. vmstat లో wa column, IO కోసం వేచి ఉండటంలో గడిచిన CPU time శాతాన్ని చూపిస్తుంది. మీ kernelలో /proc/pressure/io ఉంటే, దాని some avg10= విలువ కనీసం ఒక task IO కారణంగా నిలిచిపోయిన సమయ భాగానికి సంబంధించిన decaying average. దీని time constant 10 seconds. Storage మీ bottleneck కాదా అనే ప్రశ్నకు ఇదే అత్యంత ప్రత్యక్ష సమాధానం.
డిస్క్పై ఆధారపడిన VPS ఎలా కనిపిస్తుంది
CPU idle గా ఉండి, load average ఎక్కువగా ఉండటంతో పాటు wa లో పెద్ద విలువ vmstat కనిపిస్తే, processes డిస్క్ వెనుక queue లో వేచి ఉన్నాయని అర్థం. దీనికి స్పష్టమైన kernel సంకేతం dmesg -T లో కనిపించే ఈ message:
INFO: task jbd2/vda1-8:194 blocked for more than 120 seconds.Storage సమాధానం ఇవ్వడానికి ఒక kernel thread రెండు నిమిషాలకంటే ఎక్కువసేపు వేచి ఉన్నందున ఈ line కనిపిస్తుంది. అందువల్ల hung task watchdog దీనిని log చేసింది. jbd2 అనేది ext4 journal thread. కాబట్టి stall ఒక తప్పుగా ప్రవర్తిస్తున్న program లో కాకుండా filesystem commit path లో ఏర్పడింది. ఆ journal commit పూర్తయ్యే వరకు అవసరమయ్యే ప్రతిదీ, ఉదాహరణకు fsync(), దాని వెనుక వేచి ఉంటుంది. VPSలో ఇది సాధారణంగా storage backend సమస్యను లేదా పూర్తిగా వినియోగించబడిన IOPS పరిమితిని సూచిస్తుంది.
Application లక్షణాలు కూడా ఇదే విధానాన్ని అనుసరిస్తాయి. Median response time సాధారణంగా ఆమోదయోగ్యంగానే ఉంటుంది. అయితే disk ను తాకే requests మాత్రమే ఆలస్యం చెందుతాయి కాబట్టి, అత్యంత నెమ్మదైన requests కోసం long tail పెరుగుతుంది. apt upgrade నిమిషాల పాటు Unpacking దశలోనే ఉంటుంది, ఎందుకంటే dpkg రాస్తున్నప్పుడు flush చేస్తుంది. పెద్ద repositoryలో git status పూర్తవడానికి seconds పడతాయి. ఇవి metadata మరియు flush ఖర్చులు. అందువల్ల ఎక్కువ bandwidth దీనిని పరిష్కరించదు.
Disk పరిమితిగా ఉన్నప్పుడు చేయాల్సినవి
IOPS కొనుగోలు చేయడానికి ముందు RAM కొనుగోలు చేయండి. Working set page cacheలో సరిపోతే reads diskను అసలు చేరవు. Memoryని రెట్టింపు చేయడం, వేగవంతమైన storage classకు మారడం కంటే తరచుగా మెరుగైన ఫలితాన్ని ఇస్తుంది, మరియు దీనికి సాధారణంగా తక్కువ ఖర్చవుతుంది.
Data అనుమతించే చోట flushల సంఖ్యను తగ్గించండి. PostgreSQLలో, synchronous_commit = off ఉపయోగిస్తే write diskపై పడకముందే commit తిరిగి రావచ్చు. Server విఫలమైతే, చివరి fraction of a secondలో జరిగిన transactionsను కోల్పోవచ్చు. Write-ahead log ఇప్పటికీ క్రమంలోనే రాయబడుతుంది కాబట్టి database corrupted కాదు. Analytics copyకి ఈ trade-off సరైనది, paymentsకి సరైనది కాదు. MySQLలోని innodb_flush_log_at_trx_commit = 2 కూడా ఇదే trade-off.
చిన్న filesను batch చేయండి. Million చిన్న filesను transfer లేదా backup చేయడంలో ప్రతి fileకు అయ్యే ఖర్చే ప్రధానంగా ఉంటుంది. అందువల్ల ముందుగా archive చేసి, ఒకే streamను తరలించడం, high-latency storageపై treeని file by fileగా copy చేయడం కంటే వేగంగా ఉంటుంది.
Thin volumesపై discard పనిచేసేలా ఉంచండి. Thin provisioned storageలో filesystem తెలియజేసే వరకు backendకు ఒక block ఖాళీగా ఉందని తెలియదు. ఎప్పుడూ trim చేయని volumeలో write performance క్రమంగా తగ్గుతుంది. Ubuntu దీని కోసం weekly timerను అందిస్తుంది:
systemctl status fstrim.timer
sudo fstrim -avfstrim -av ప్రతి mount pointకు trim చేసిన bytesను ముద్రిస్తుంది. Discard operationకు support లేదని message వస్తే, virtual disk discardను hostకు pass through చేయడం లేదని అర్థం. కాబట్టి మీరు సరిచేయాల్సిందేమీ లేదు.
IO scheduler tuningను వదిలేయండి. virtio diskపై cat /sys/block/vda/queue/scheduler సాధారణంగా ఇప్పటికే none చూపిస్తుంది. అసలు scheduling hostపై జరుగుతుంది, అక్కడ మీకు access ఉండదు. noatime ను కూడా వదిలేయండి: Ubuntu defaultగా relatime తో mount చేస్తుంది. ఇది దాదాపు ప్రతి atime writeను ఇప్పటికే నివారిస్తుంది.
ప్లాన్ను ఎంచుకోవడం
డేటాబేస్, mail server, CI runner లేదా package-heavy build సర్వర్లో నడుస్తుంటే NVMe కోసం చెల్లించండి. Cached website కోసం లేదా ఎక్కువ సమయం external calls కోసం వెచ్చించే app కోసం అదనపు ధర చెల్లించవద్దు. మీకు సందేహంగా ఉంటే, disk మీ పరిమితి అయ్యే అవకాశం తక్కువ. చాలా చిన్న VPS workloads ముందుగా RAM లేదా bandwidth పరిమితిని చేరుతాయి.
కొత్త VPSలో మొదటి పది నిమిషాలు పని చేస్తున్న సమయంలోనే మొదటి రోజున కొలతలు తీసుకోండి. ఆ output ను ఒక fileలో భద్రపరచండి. Host నెమ్మదించిందా లేదా మీ code కారణమా అని తరువాత నిరూపించడానికి baseline ఉపయోగపడుతుంది. Storage class మరియు ఏదైనా IOPS cap ను లిఖితపూర్వకంగా స్పష్టంగా పేర్కొనే providers కు ప్రాధాన్యం ఇవ్వండి. ఒక planలో NVMe అని పేర్కొని ఉండి, queue depth 1 read కు 4 ms పడితే, మీరు local NVMe latency పొందడం లేదు. ఆ volume NVMe కలిగిన hostపై network storage అయి ఉండవచ్చు. లేదా ప్రతి request 4 msకు పరిమితం అయ్యేంత తక్కువగా host మీ IOPSను cap చేసి ఉండవచ్చు. ఏది జరుగుతోందో providerను అడగండి. రెండింటిలో ఏదైనా విక్రయించడం సముచితమే. కానీ కొనుగోలు చేసేది మాత్రం వేర్వేరు విషయం.
FAQ
VPSలో NVMe ఎల్లప్పుడూ SATA SSD కంటే వేగంగా ఉంటుందా?
లేదు. queue depth 1 వద్ద రెండింటి పనితీరు దగ్గరగా ఉంటుంది; 4k read కోసం సాధారణంగా 80 నుంచి 150 microseconds పడుతుంది. ఒకేసారి ఒక్క request మాత్రమే పంపే ప్రోగ్రామ్కు వీటి మధ్య తేడా తెలియదు. అనేక requests ఒకేసారి pendingలో ఉన్నప్పుడు NVMe ముందంజ వేస్తుంది. కారణం, AHCI ప్రతి portకు గరిష్ఠంగా 32 command slots మాత్రమే అందిస్తుంది, అయితే NVMe వేలాది లోతైన queuesను అందిస్తుంది. Shared hostలో ఇతర guests వల్ల వచ్చే load, storage medium కంటే మీ latencyని ఎక్కువగా మార్చవచ్చు. అందువల్ల plan పేరును చూసే బదులు మీ స్వంత volumeపై fioతో కొలవండి.
నా VPS నిజంగా NVMe ఉపయోగిస్తుందో ఎలా తనిఖీ చేయాలి?
దాన్ని నేరుగా తనిఖీ చేయలేరు, ఎందుకంటే virtio భౌతిక device వివరాలను దాచుతుంది. lsblk, model string లేకుండా vda ను చూపుతుంది; nvme list ఏదీ తిరిగి ఇవ్వదు; /sys/block/vda/queue/rotational hypervisor ప్రకటించిన వివరాలను మాత్రమే report చేస్తుంది. అందువల్ల behaviourను కొలవండి. ఫలితాన్ని ఆధారంగా పరిగణించండి, ఖచ్చితమైన నిర్ధారణగా కాదు. queue depth 1 వద్ద random 4k read latency 0.3 ms కంటే తక్కువగా ఉంటే అది local flashతో అనుకూలంగా ఉంటుంది. అయితే DRAM cache కలిగిన storage array కూడా అంత వేగంగా స్పందించవచ్చు. అనేక milliseconds latency ఉంటే network hop లేదా hostపై ఉన్న IOPS పరిమితి కారణం కావచ్చు. Sequential reads సుమారు 550 MB/s వద్ద ఆగితే SATA link లేదా bandwidth cap ఉన్నట్లు సూచిస్తుంది.
NVMe నా websiteను వేగంగా load చేయిస్తుందా?
సాధారణంగా కాదు. మొదటి request తర్వాత Linux filesను RAMలోని page cache నుంచి అందిస్తుంది. అందువల్ల disk idleగా ఉంటుంది. చిన్న VPSలో page speed సాధారణంగా application CPU time మరియు bandwidthపై ఆధారపడి ఉంటుంది. ప్రతి requestపై site write చేస్తే disk మళ్లీ critical pathలోకి వస్తుంది. ఉదాహరణకు, తరచుగా commit చేసే database-backed cartలో ప్రతి commit పూర్తయ్యే flush కోసం వేచి ఉండాలి.
VPSకు మంచి fio ఫలితం ఎలా ఉంటుంది?
July 2026 నాటికి, local flashపై నడిచే చిన్న VPS సాధారణంగా queue depth 32 వద్ద 4k random readకు పదివేల సంఖ్యలో IOPS ఇస్తుంది. queue depth 1 latency 0.3 ms కంటే తక్కువగా ఉంటుంది. Network block storage సాధారణంగా కొన్ని వేల IOPSను, కొన్ని milliseconds latencyతో ఇస్తుంది. వేర్వేరు సమయాల్లో testను మూడు సార్లు నడపండి. Runs మధ్య విస్తృతమైన తేడా ఉంటే, average కంటే అది ఎక్కువ సమాచారాన్ని ఇస్తుంది. ఎందుకంటే hostపై ఉన్న ఇతర guests మీ పనితీరును ఎంత ప్రభావితం చేస్తున్నారో అది చూపిస్తుంది.
నా databaseను network block storageపై ఉంచాలా?
ఉంచవచ్చు. అనేక managed services కూడా అదే చేస్తాయి. అయితే commit pathపై దాని ప్రభావం ఉంటుంది. ప్రతి flush networkను దాటి వెళ్లాలి. అందువల్ల local flashతో పోలిస్తే ఒకే connection ప్రతి secondలో తక్కువ చిన్న transactionsను commit చేస్తుంది. దానికి బదులుగా host విఫలమైనా నిలిచే durability లభిస్తుంది. Write-heavy database కోసం network storage ఎంచుకుంటే, పెద్ద transactionsగా పనిని సమూహీకరించండి. అప్పుడు తక్కువ flushలలో ఎక్కువ rowsను రాయవచ్చు.