Wéivill gläichzäiteg Benotzer bedéngt e VPS: d’Rechnung maachen

Vu Benotzer zu Ufroen

„Gläichzäiteg Benotzer“ bezeechent dräi verschidde Gréissten, jee nodeem, wien et seet:

• Déi registréiert Konten: si kaschten de Server näischt, soulaang se sech net umellen.
• D’Benotzer, déi zur selwechter Zäit aktiv sinn: Leit, déi surfen, liesen, e Formulaire ausfëllen. Jidderee schéckt vun Zäit zu Zäit eng Ufro, typesch all 10 bis 30 Sekonnen, plus e puer API-Opriff pro Écran an enger moderner Applikatioun.
• D’Ufroen, déi grad veraarbecht ginn: déi, déi de Server zu engem bestëmmte Moment berechent. Dat ass déi eenzeg Gréisst, déi Prozessor an Aarbechtsspäicher verbraucht.

Vun enger zur anerer kommt Dir mam Gesetz vu Little: d’Zuel vun den Ufroen, déi lafen, ass gläich dem Duerchsaz, an Ufroe pro Sekonn, multiplizéiert mat der duerchschnëttlecher Dauer vun enger Ufro.

Beispill. 600 aktiv Benotzer zur selwechter Zäit, déi jidderee all 20 Sekonnen eng Ufro ausléisen, maachen 30 Ufroe pro Sekonn. Wann all Ufro 100 ms dauert, huet de Server am Duerchschnëtt nëmmen 3 Ufroen, déi lafen. D’Erausfuerderung läit anzwousch anescht: an de Spëtzten an an de luese Ufroen.

Wat e vCPU packt

Eng Ufro hält de Prozessor fir d’Zäit vun hirem Calcul besat: de Code ausféieren, d’Datebank ofroen, d’Äntwert opbauen. E vCPU veraarbecht also héchstens 1.000 ÷ t Ufroe pro Sekonn, wou t d’Rechenzäit vun enger Ufro a Millisekonnen ass. D’Zäit, déi mat Waarde vergeet (eng extern API, en Disk), hält de Prozessor net besat, awer se hält e Worker besat.

Mat dëse Gréisstenuerdnungen halen 30 API-Ufroe pro Sekonn mat 10 ms Calcul 30 % vun engem eenzege vCPU besat. Déi selwecht 30 Ufroe pro Sekonn op WordPress-Säiten ouni Cache brauchen 3 bis 9 vCPU. De Säitecache déngt genee dofir, eng Säit vun der véierter Zeil vun der Tabell op déi zweet ze bréngen.

Wat den Aarbechtsspäicher packt

All Ufro, déi leeft, gëtt vun engem Worker iwwerholl, an d’Worker huelen Aarbechtsspäicher, egal ob se schaffen oder net. Et ass dacks den Aarbechtsspäicher, méi wéi de Prozessor, deen d’Zuel vun den Ufroe festleet, déi parallel veraarbecht ginn:

• PHP-FPM: ee Prozess pro Ufro, déi leeft, 40 bis 80 MB all eenzelen. pm.max_children leet de Plafong fest: 20 Prozesser, dat sinn 800 MB bis 1,6 GB.
• Python (Gunicorn, Uvicorn): d’Dokumentatioun vu Gunicorn proposéiert, mat (2 × Zuel vun de Kären) + 1 Worker unzefänken, vun 80 bis 200 MB all eenzelen. En asynchrone Worker hält vill Ufroen am Waarden, mat engem eenzege Prozess.
• Node.js: een eenzege Prozess hält Dausende vu Verbindungen am Waarden, mä e benotzt nëmmen ee Kär; de Cluster-Modus, oder PM2, start ee Prozess pro vCPU.
• D’Datebank: PostgreSQL mécht ee Prozess pro Verbindung op, an akzeptéiert standardméisseg 100 dovun. Soubal vill Verbindunge gläichzäiteg aktiv sinn, ass e Pooler wéi PgBouncer besser wéi e méi héije max_connections.

Déi persistent Verbindungen (Websockets, Notifikatiounen an Echtzäit) ginn apaart gezielt: si bleiwe permanent op, huele wéineg Prozessor a just e Brochdeel vun engem Megabyte Aarbechtsspäicher pro Verbindung. En Node.js-Server hält der Dausende mat e puer honnert MB.

Déi richteg Engpäss

Op enger realer Applikatioun kënnt de Server selten do u seng Grenz, wou een et erwaart. Déi heefegst Ursaachen, an der Reiefolleg, an där Dir se sicht:

1. Eng lues SQL-Ufro: en Index, deen feelt, mécht aus enger Ufro vun 2 ms eng Ufro vun 2 Sekonnen, déi e Worker an eng Verbindung festhält. pg_stat_statements op PostgreSQL, oder de Log vun de luese Ufroe vu MySQL, weist se.
2. Ufroen a Kaskad (de N+1-Problem): eng Säit, déi eng Ufro pro ugewisen Zeil start, start der Honnerte.
3. En externe synchronen Opruff: eng Bezuelungs- oder KI-API, déi an 3 Sekonnen äntwert, blockéiert e synchrone Worker 3 Sekonne laang.
4. Schwéier Veraarbechtungen an der Ufro: E-Maile verschécken, Biller redimensionéieren, PDF-Fichieren generéieren; dat gehéiert an eng Job-Queue.
5. Kee Cache: Säiten, déi fir all Besicher gläich sinn, kommen aus engem Cache, statesch Fichieren direkt vum Webserver.

Et iwwerpréiwen: de Laaschttest

D’Gréisstenuerdnunge ginn eng éischt Gréisst; e Laaschttest gëtt déi richteg. De Prinzip: ëmmer méi Benotzer op enger Kopie vun der Applikatioun simuléieren, a feststellen, wéini d’Äntwertzäit an d’Luucht geet.

wrk -t2 -c50 -d30s --latency https://preprod.meng-websait.com/

Fir e komplette Parcours (Umeldung, Navigatioun, Sich) beschreift k6 e Szenario a JavaScript a setzt d’Laascht a Stufen erop:

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 },
    { duration: '5m', target: 100 },
    { duration: '2m', target: 300 },
    { duration: '5m', target: 300 },
    { duration: '2m', target: 0 },
  ],
  thresholds: { http_req_duration: ['p(95)<500'] },
};

export default function () {
  http.get('https://preprod.meng-websait.com/');
  sleep(15);
}

• Testt eng Kopie, net d’Produktioun, a sot Ärem Hostingubidder Bescheed, wann den Test e Server trëfft, deen hie bedreift.
• Lancéiert den Test vun enger anerer Maschinn aus wéi dem Server, deen getest gëtt, soss hëlt d’Tool him seng eege Ressourcen.
• Kuckt op de 95. Perzentil vun der Äntwertzäit, net op den Duerchschnëtt: dat ass dat, wat déi Benotzer erliewen, déi am schlechtste bedéngt ginn.
• Iwwerwaacht de Server wärend dem Test: htop fir de Prozessor, free -h fir den Aarbechtsspäicher, d’Logs fir d’Feeler.

Wann d’Laascht wiisst

D’Reiefolleg, déi am mannste kascht an am meeschte bréngt:

1. Cachen, wat sech cache léisst (Säiten, Fragmenter, Resultater vun Ufroen), a lues Ufroe korrigéieren.
2. D’Zuel vun de Worker op den disponibelen Aarbechtsspäicher an de Prozessor ofstëmmen.
3. Op eng méi grouss Gréisst wiesselen: méi vCPU a méi Aarbechtsspäicher, ouni eppes un der Applikatioun z’änneren.
4. D’Datebank op en eegene Server setzen.
5. D’Applikatioun op e puer Serveren hannert engem Load Balancer verdeelen.

Déi éischt dräi Etappen decken déi grouss Majoritéit vun de Geschäftsapplikatiounen, Websäiten an APIen of: e puer honnert aktiv Benotzer zur selwechter Zäit lafen op engem eenzege Server, deen gutt agestallt ass.