Hoe benchmark ik een VPS op de juiste manier?
Leer hoe u een VPS betrouwbaar benchmarkt met yabs.sh, fio, sysbench en iperf3. Ontdek waarom een enkele test onvoldoende is en hoe u de resultaten correct interpreteert.
Wat het betekent om een VPS te benchmarken
Om een VPS te benchmarken meet u vier zaken: hoe snel een enkele CPU-kern werkt, hoeveel geheugenbandbreedte de machine heeft, hoeveel kleine willekeurige schijfbewerkingen de opslag per seconde verwerkt en hoeveel doorvoer de netwerkverbinding levert. Eén run van yabs.sh geeft u binnen ongeveer tien minuten resultaten voor CPU, schijf en netwerk; gebruik de afzonderlijke geheugentest hieronder voor de geheugenbandbreedte. Het interpreteren van de resultaten is het lastigste deel, omdat een VPS (virtual private server) fysieke hardware deelt met andere huurders. Hierdoor kan dezelfde machine om 03:00 uur een ander getal rapporteren dan om 20:00 uur.
Het plan is om yabs.sh uit te voeren voor een snel overzicht en daarna de onderliggende tools handmatig te draaien. Door ze zelf uit te voeren kunt u een flag aanpassen, zien hoe het getal verandert en leren wat dat getal daadwerkelijk meet. Doe dit nadat de machine is geconfigureerd, niet daarvoor. De stappen in de eerste tien minuten op een nieuwe VPS komen eerst, omdat een machine die nog bezig is met de eerste reeks updates slecht scoort om redenen die niets met de hardware te maken hebben.
Bekijk de machine voordat u deze meet
De helft van alle slechte benchmarks is het gevolg van een machine die de auteur niet begreep.
nproc
lscpu | grep -E 'Model name|Hypervisor|Thread'
free -h
df -hT /
uname -r
systemd-detect-virtHypervisor vendor: KVM staat voor volledige virtualisatie, waarbij u uw eigen kernel draait. systemd-detect-virt met de vermelding lxc of openvz duidt daarentegen op containervirtualisatie: u deelt de kernel van de host, en uw CPU- en geheugenlimieten zijn cgroup-instellingen (control group) in plaats van virtuele hardware. Op een cgroup v2-systeem kunt u de CPU-limiet uitlezen vanuit de cgroup van uw container; het volgende pad is van toepassing wanneer die cgroup is aangekoppeld op /sys/fs/cgroup.
cat /sys/fs/cgroup/cpu.maxmax 100000 betekent dat deze cgroup geen eigen quotum heeft; bovenliggende cgroups kunnen er echter nog steeds een opleggen. 200000 100000 betekent dat u 200000 microseconden aan CPU-tijd mag gebruiken in elke periode van 100000 microseconden, wat overeenkomt met een quotum van twee cores. Een abonnement dat wordt geadverteerd als 4 vCPU met een quotum van twee cores zal nooit presteren als vier cores. Benchmarktools kunnen deze beperking identificeren: VoxelBench rapporteert CPU-quota en markeert een gedeelde of beperkte CPU wanneer de host veel meer CPU's blootstelt dan de server mag gebruiken.
df -hT / is om een andere reden van belang: de kolom Type. Als hier overlay staat, bevindt u zich in een container en zullen uw schijfresultaten de opslag beschrijven die zich onder die overlay bevindt. Noteer dit nu.
Monitor steal time continu
Steal time is het deel van de tijd dat uw virtuele CPU onvrijwillig moest wachten omdat de hypervisor deze niet inplande. Het is een nuttige indicator voor onbeschikbare CPU-tijd, maar het maakt geen onderscheid tussen drukke buren en de provider die uw CPU-quotum afdwingt.
vmstat 1 10Lees de kolom st aan de rechterkant. Aanhoudende steal time betekent dat CPU-tijd niet beschikbaar was voor de guest, maar een waarde boven 5% bewijst niet dat de host overboekt is. Providers kunnen de handhaving van CPU-quota bewust weergeven als steal time. top toont hetzelfde cijfer als %st op de CPU-regel. Laat vmstat 1 draaien in een tweede SSH-sessie terwijl u benchmarks uitvoert en noteer het steal-cijfer naast elk resultaat.
Beginnen met yabs.sh
yabs.sh (Yet Another Bench Script) is een shell-script dat fio, iperf3 en Geekbench uitvoert en één samenvatting weergeeft. Het gebruikt fio en iperf3 als deze al zijn geïnstalleerd en downloadt statische binaries wanneer dat niet het geval is. Het is de standaardtaal voor VPS-benchmarkdiscussies, dus een yabs-output is de snelste manier om resultaten met anderen te vergelijken.
De officiële one-liner van het project is als volgt.
curl -sL yabs.sh | bashDit sluist de inhoud van de URL direct door naar een shell. Download het, lees het door en voer het daarna uit.
curl -sLo yabs.sh https://raw.githubusercontent.com/masonr/yet-another-bench-script/master/yabs.sh
less yabs.sh
bash yabs.shFlags plaatst u na -s -- wanneer u een pipe gebruikt, of direct na de bestandsnaam wanneer u een lokale kopie uitvoert. De nuttige opties zijn: -f slaat de schijftest over, -i slaat de netwerktest over, -g slaat Geekbench over, -r beperkt de iperf3-locaties tot drie, -j geeft de resultaten weer als JSON en -w results.json schrijft die JSON naar een bestand.
bash yabs.sh -r -w yabs-run1.jsonTwee zaken om te weten voor de eerste uitvoering. Geekbench uploadt uw resultaat en genereert een openbare browser.geekbench.com URL, waardoor iedereen met die link uw CPU-model en scores kan inzien. -g slaat die test volledig over. Ten tweede verplaatst de iperf3-fase echt netwerkverkeer naar servers in verschillende regio's, wat meetelt voor uw maandelijkse bandbreedteverbruik. Op een 1 Gbit/s verbinding kan een volledige netwerkfase tientallen gigabytes verbruiken, dus gebruik -r bij een kleine databundel en -i op een verbinding met datalimiet.
Wat elk onderdeel van de yabs-output betekent
De disk-sectie voert fio uit met een 50/50 lees- en schrijfmix bij vier blokgroottes: 4k, 64k, 512k en 1m. Het rapporteert IOPS (input/output operations per second) en bandbreedte voor elk daarvan. De 4k-rij is de rij waar u op moet letten voor een database, een mailserver of elke andere toepassing die veel kleine schrijfacties uitvoert, omdat het meeste server-IO klein en verspreid is. De 1m-rij is de rij voor back-ups en video, waarbij u grote hoeveelheden data verplaatst.
De network-sectie voert iperf3 uit tegen publieke servers in verschillende regio's, in beide richtingen, met gebruik van parallelle streams. Beschouw een laag getal hier als een vraag in plaats van een antwoord, omdat publieke iperf3-servers gedeeld en vaak verzadigd zijn; een slecht resultaat kan dus aan de ontvangende kant liggen.
De Geekbench-sectie geeft een single core score en een multi core score. Single core voorspelt hoe snel één verzoek, één compilatie of één query wordt voltooid. Multi core geeft vooral aan hoeveel cores u daadwerkelijk heeft.
Schijf: voer fio zelf uit
fio (flexible IO tester) is de tool die onder de yabs-schijfsectie draait. Door deze direct aan te sturen, krijgen de flags hun werkelijke betekenis.
sudo apt update && sudo apt install -y fio sysbench iperf3Een 4k random read-test met een queue depth van 32, op het bestandssysteem dat voor u relevant is:
fio --name=randread4k --filename=./fio-testfile --size=2G --bs=4k \
--rw=randread --ioengine=libaio --iodepth=32 --direct=1 \
--runtime=60 --time_based --group_reportingDe samenvattingsregel die u uit de output moet lezen, ziet er als volgt uit.
read: IOPS=184k, BW=719MiB/s (754MB/s)(42.1GiB/60001msec)Daaronder print fio een clat percentiles-blok. Het 99.00e percentiel is de waarde die u moet noteren, omdat dit aangeeft hoe lang het traagste verzoek van de honderd moest wachten. Een gemiddelde latentie verbergt precies de vertragingen die een gebruiker opmerkt.
--direct=1opent het bestand metO_DIRECT, waardoor leesacties de kernel page cache omzeilen. Zonder deze optie wordt de tweede pass over een 2G-bestand op een machine met 8G RAM vanuit het geheugen geserveerd en rapporteert fio IOPS in de miljoenen. Dat getal is reëel, maar het is een geheugenwaarde.--ioengine=libaioverstuurt asynchrone verzoeken, waardoor--iodepth=32er 32 tegelijk in de wachtrij kan houden. Met een synchrone engine zoalspsyncheeft een iodepth hoger dan 1 geen enkel effect, waardoor u slechts één verzoek tegelijk meet.--time_based --runtime=60draait gedurende een vaste tijd van 60 seconden in plaats van een vaste hoeveelheid werk. Hierdoor krijgen een snelle en een trage schijf dezelfde tijd en blijft de vergelijking eerlijk.--size=2Gstelt de grootte van het testbestand in. Houd deze groter dan elke cache in het pad en controleer eerst of u voldoende vrije ruimte heeft.
Random write gebruikt hetzelfde commando met --rw=randwrite. Voer dit afzonderlijk uit en verwijder daarna het bestand.
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-testfileGebruik voor een mix die dichter bij echt verkeer ligt --rw=randrw --rwmixread=70. Welk type opslag u gebruikt, heeft meer invloed op deze resultaten dan welke flag dan ook. Dit onderscheid wordt behandeld in het verschil tussen NVMe en SATA SSD-opslag op een VPS.
Wanneer fio stopt met Unknown error -1
Direct IO is niet op elk bestandssysteem beschikbaar. Wanneer fio faalt bij het eerste verzoek met --direct=1 ingesteld, is direct IO het eerste dat moet worden uitgesloten. De foutmelding kan er als volgt uitzien:
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 -1Voer eerst df -hT . uit. Een Type van overlay, het bestandssysteem dat Docker standaard aan een container toewijst, is op zichzelf niet de oorzaak. overlayfs geeft O_DIRECT door aan het onderliggende bestandssysteem en weigert dit alleen wanneer dat bestandssysteem geen direct IO ondersteunt; daarom werkt --direct=1 --ioengine=libaio op een overlay die op ext4 of xfs draait. Wanneer het bestandssysteem onder het testbestand daadwerkelijk geen direct IO kan uitvoeren, meldt fio dit meestal bij het openen van het bestand: fio: looks like your file system does not support direct=1/buffered=0. Wijs in dat geval --filename naar een pad op echte lokale opslag, zoals een bind-mounted volume, of voer fio uit op de host in plaats van in de container. Als echte opslag niet beschikbaar is, bewijst een gebufferde synchrone run in ieder geval dat het commando zelf correct is.
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-testfileWees eerlijk over wat die run inhoudt. Na de eerste pass bevindt het 256M bestand zich in de page cache, waardoor het IOPS-cijfer uw RAM beschrijft. Gebruik dit om te bevestigen dat fio is geïnstalleerd en de flags correct worden geparseerd. Citeer dit nooit als een schijfresultaat.
Waarom dd geen geschikte disk-benchmark is
dd komt vaak voor in VPS-discussies en beantwoordt slechts één beperkte vraag.
dd if=/dev/zero of=./ddtest bs=1M count=1024 oflag=direct conv=fdatasync
rm -f ./ddtestDit meet de sequentiële schrijfdoorvoer met één thread en één uitstaande aanvraag. Het is een redelijke controle voor een eerste indruk. Het zegt echter niets over random IO, en niets over wat er gebeurt wanneer er 32 aanvragen tegelijk binnenkomen. Laat oflag=direct weg en schrijfacties verlopen via de page cache, maar conv=fdatasync dwingt de uitvoerdata nog steeds naar de opslag voordat het commando wordt voltooid. Laat ook dat weg en het resultaat meet grotendeels hoe snel uw kernel schrijfacties naar het geheugen accepteert; dit is de reden waarom dd-cijfers in forumberichten vaak absurd zijn.
CPU: sysbench cpu
sysbench cpu --cpu-max-prime=20000 --threads=1 run
sysbench cpu --cpu-max-prime=20000 --threads=$(nproc) runHet getal om in de gaten te houden is events per second. Voer de test eerst single-threaded uit. Dit getal bepaalt hoe snel één PHP-verzoek wordt afgehandeld of één compilatieklus wordt voltooid, en dit varieert het meest tussen hosts in dezelfde prijsklasse. Voer de test daarna uit met alle threads; dit toont aan hoe de doorvoer schaalt over uw toegewezen vCPU's.
Wees duidelijk over wat dit meet: sysbench cpu vindt herhaaldelijk priemgetallen door middel van proefdeling. Voor elke kandidaat berekent het een vierkantswortel met dubbele precisie, test vervolgens delers met 64-bit integer modulo, en vergelijkt elke deler met die floating-point limiet. Het combineert dus integer- en floating-point-werkzaamheden. Het belast de geheugenbandbreedte, vector-units of cache op geen enkele wijze die lijkt op een echte werklast. Het is daarom geschikt voor het rangschikken van twee hosts, maar ongeschikt voor het voorspellen van de prestaties van uw applicatie.
Ubuntu 24.04 levert sysbench 1.0.20, waarbij de testnaam vooraan staat. Kopieert u een commando met --test=cpu uit een oud bericht, dan krijgt u WARNING: the --test option is deprecated. Scores van sysbench 0.4 en sysbench 1.0 zijn totaal niet vergelijkbaar. Meet uzelf daarom nooit af aan een gepubliceerd getal waarbij de versie niet wordt vermeld.
Geheugen: 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 runHet resultaat wordt uitgedrukt in MiB/sec. Houd --memory-block-size op 1M en zorg dat deze waarde identiek is voor elke host die u vergelijkt. Bij 1K stort het getal in, omdat u duizend keer vaker betaalt voor de overhead per operatie. U meet dan de kosten van de lus in plaats van de geheugenbandbreedte. Dit is de meest gemaakte fout bij het vergelijken van gepubliceerde geheugenscores.
Netwerk: iperf3
De betrouwbare manier om doorvoersnelheid te testen is tegen een tweede machine die u beheert, omdat u dan weet wat beide uiteinden doen.
Aan de ontvangende kant:
iperf3 -sDit luistert op TCP 5201. Open de poort alleen voor het adres vanwaaruit u test en sluit deze zodra u klaar bent. Basis ufw firewallregels op een VPS behandelt de syntaxis.
Vanaf de VPS die wordt getest:
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 8De eerste meet de upload vanaf de machine die wordt getest. -R draait de richting om, wat de download meet. -P 8 opent acht parallelle streams.
Voer zowel de enkele stream als de parallelle versie uit, omdat deze verschillende vragen beantwoorden. Eén TCP-verbinding kan slechts zoveel niet-bevestigde data bevatten als het venster toestaat; het plafond is dus grofweg de venstergrootte gedeeld door de round-trip time. Bij 80 ms latentie met een venster van 4 MB is dat plafond ongeveer 400 Mbit/s, ongeacht hoe snel de onderliggende verbinding is. Het cijfer van de enkele stream vertelt u wat één download zal behalen. Het parallelle cijfer vertelt u de capaciteit van de verbinding.
Houd uw bandbreedteverbruik in de gaten terwijl u dit doet. Dertig seconden op 1 Gbit/s verplaatst ongeveer 3,75 GB, en u zult dit meerdere keren in elke richting uitvoeren.
Referentiecijfers en hoe u de uwe moet interpreteren
De gegevens achter deze grafiek
[
{
"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"
}
]Een lokaal NVMe-volume in gepubliceerde resultaten haalt doorgaans ongeveer 180,000 4k random read IOPS. Een lokale SATA SSD komt uit op ongeveer 90,000. Netwerkgekoppelde block storage, waarbij elk verzoek een netwerk doorkruist voordat het een schijf bereikt, ligt dichter bij 12,000, en een harde schijf haalt ongeveer 180, omdat deze voor elk random verzoek een fysieke leesarm moet verplaatsen.
Dit zijn typische gepubliceerde cijfers voor elke opslagklasse, geen metingen van één specifieke host. Gebruik ze voor één doel: controleren of uw eigen resultaat in de juiste grootteorde ligt. Als een abonnement dat als NVMe wordt verkocht in de lage duizendtallen 4k IOPS presteert, controleer dan eerst of --direct=1 was ingeschakeld. Als dat zo was, controleer dan de IOPS-limieten en burst-credits van het abonnement, evenals de opslagcongestie en de geadverteerde hardware.
Waarom één run geen benchmark is
Een enkel resultaat is een momentopname van één minuut op een gedeelde machine. Beschouw dit als één steekproef.
- Voer elke test minstens vijf keer uit, verspreid over verschillende uren en ten minste twee verschillende dagen. Noteer de mediaan en de spreiding. Een resultaat dat zonder spreiding wordt gepubliceerd, is een marketingcijfer.
- Registreer de steal time naast elke run. Bewaar runs waarbij
sthoog was en onderzoek of deze duiden op contention of op het CPU-quotum van het abonnement; het negeren hiervan kan de werkelijke prestaties die u ontvangt maskeren. - Voer de schijftest uit met twee verschillende looptijden. Veel abonnementen bieden een burst IOPS-toelage die in de loop van de tijd wordt aangevuld, maar noch een fio-run van 60 seconden, noch
--runtime=600garandeert dat u de ondergrens heeft gemeten. AWS gp2-credits kunnen bij een volledig saldo minstens 30 minuten lang 3.000 IOPS volhouden, dus beide runs kunnen de burst-prestaties meten. Controleer het creditmodel van de provider en monitor het creditsaldo voordat u een resultaat als duurzame prestatie bestempelt. - Controleer of er niets anders draait. Een
unattended-upgradesdie een apt-transactie start tijdens een CPU-test kost u daadwerkelijke punten, enps -e -o comm= | grep -E 'apt|dpkg'voor elke run kost een seconde. - Wijzig telkens slechts één variabele. Verschillende versies van tools, blokgroottes of thread-aantallen leveren getallen op die niet met elkaar vergeleken kunnen worden, hoe vergelijkbaar ze er ook uitzien.
Wanneer u twee providers vergelijkt, voer de tests dan uit op hetzelfde uur van dezelfde dag. Anders heeft u het tijdstip van de dag gemeten.
Benchmark uw eigen workload als laatste
Synthetische tools rangschikken machines. Alleen uw eigen workload vertelt u of een machine volstaat. Meet de tijd van de taken die u daadwerkelijk uitvoert.
time tar -czf /tmp/bench.tgz /usr/share
rm -f /tmp/bench.tgzDit comprimeert enkele honderden megabytes, waardoor zowel de CPU als de schijf worden belast en de prestaties veranderen zodra een van beide wijzigt. De Removing leading / from member names waarschuwing is normaal. Beter nog is het om uw eigen build, uw traagste query of uw eigen paginarendering te timen. Een build die 4 minuten duurt op de ene host en 7 op de andere, beantwoordt de vraag, ongeacht wat Geekbench aangaf. Dit is ook de meting die u vertelt wanneer een krachtigere machine de extra kosten niet meer waard is. Dat is nuttige informatie voordat u leest wat een VPS daadwerkelijk per maand kost of de workload verplaatst naar een dedicated server.
FAQ
Waarom krijg ik telkens een ander benchmarkresultaat?
Een VPS deelt fysieke CPU, opslag en netwerk met andere huurders, dus uw resultaat hangt af van wat zij op dat moment doen. Voer vmstat 1 uit tijdens de test en lees de kolom st: aanhoudende 'steal time' registreert onbeschikbare CPU-tijd, maar het kan zowel de handhaving van uw gekochte CPU-allocatie door de provider als host-congestie weerspiegelen. Een waarde boven 5% wijst niet direct naar de oorzaak. Het antwoord ligt in de methode, niet in tuning. Voer elke test vijf of meer keer uit op verschillende tijdstippen en rapporteer de mediaan samen met de spreiding.
Waarom rapporteert fio miljoenen IOPS?
Bijna altijd omdat --direct=1 ontbreekt. Zonder deze vlag leest fio door de kernel page cache heen; na de eerste run wordt een testbestand van 2G vanuit het RAM geserveerd en meet u de geheugenbandbreedte. Voeg --direct=1 toe en zorg dat het testbestand groter is dan elke cache in het pad. Als --direct=1 vervolgens faalt, voer dan df -hT . uit en controleer waar het testbestand op staat. Een overlay-type is op zichzelf niet het probleem, omdat overlayfs O_DIRECT doorgeeft aan de onderliggende opslag. Verplaats het testbestand alleen naar echte lokale opslag als het onderliggende bestandssysteem direct IO weigert.
Is yabs.sh op zichzelf voldoende?
Voor een eerste indruk wel. Het voert fio uit met vier blokgroottes, iperf3 in beide richtingen en Geekbench, en het print één samenvatting die anderen kunnen lezen. Het is niet langer voldoende wanneer u wilt weten waarom een getal is wat het is, omdat u de vlaggen niet per test kunt variëren. Zodra een yabs-resultaat onjuist lijkt, reproduceer het dan direct met fio of sysbench en wijzig één vlag tegelijk.
Welk enkel getal voorspelt hoe mijn applicatie aanvoelt?
Single-core CPU-snelheid en 4k random read latency, in die volgorde, voor de meeste web- en databaseworkloads. Doorvoersnelheden zien er indrukwekkend uit, maar zijn zelden doorslaggevend, omdat een typisch verzoek klein is. Citeer het 99e percentiel uit het fio clat percentiles-blok in plaats van het gemiddelde, aangezien de gebruiker juist dat ene trage verzoek op de honderd opmerkt.
Moet ik iets installeren voordat ik ga benchmarken?
fio, sysbench en iperf3 zitten allemaal in de Ubuntu- en Debian-archieven: sudo apt install -y fio sysbench iperf3. yabs.sh draait in Bash en heeft curl of wget nodig voor downloads, plus tar om Geekbench uit te pakken; zonder tar wordt Geekbench overgeslagen. Het gebruikt fio en iperf3 wanneer deze zijn geïnstalleerd en downloadt statische binaries wanneer ze ontbreken. Verwijder elk testbestand wanneer u klaar bent, aangezien een 2G fio-bestand dat achterblijft op een 20G schijf weken later iemands 'disk full'-melding wordt.