Wéivill RAM brauch e VPS? D’Reegel, Fall fir Fall

Den Aarbechtsspäicher ass d’Ressource, déi am dackste bestëmmt, wéi grouss e Server muss sinn: en ass déi éischt, déi ausgeet, a wann e feelt, gëtt de Server net einfach méi lues, e stoppt Servicer. Dëse Guide gëtt Iech d’Reegel fir ze rechnen, wat all Bestanddeel vun enger Applikatioun verbraucht, typesch Fäll, a wéi Dir op engem Server moosst, dee schonn leeft.

Publizéiert de 15. Oktober 2026 Auteur: Lieszäit: 9 Minutten

All Guiden

Dat Wesentlecht

  1. Addéiert alles, wat permanent am Aarbechtsspäicher bleift: de System, de Webserver, all Prozess vun der Applikatioun, d’Datebank, de Cache.
  2. Dimensionéiert no der Spëtzt, net nom Duerchschnëtt: eng Kompilatioun, e Backup oder eng geplangten Aufgab ka fir e puer Minutten de Verbrauch verduebelen.
  3. Rechent 25 % Marge derbäi. Den Aarbechtsspäicher, dee fräi bleift, déngt als Disk-Cache a mécht d’Datebank méi séier.
  4. Op engem Server, dee schonn leeft, liest Dir d’Kolonn available vu free -h, net d’Kolonn free.
  5. Wann den Aarbechtsspäicher feelt, stoppt Linux e Prozess, dacks dee gréissten: d’Datebank. E Service, dee vun eleng nei start, ass dat éischt Zeechen, dat Dir iwwerwaache sollt.
  6. Wielt eng Gréisst, déi sech ouni Neiinstallatioun erweidere léisst: de Besoin vun enger Applikatioun an der Produktioun wiisst mat hiren Donnéeën.

D’Reegel: addéieren, wat am Aarbechtsspäicher bleift

E Server verbraucht net „am Allgemengen“ Aarbechtsspäicher: all Programm, dat leeft, hält en Deel dovun, soulaang et leeft. D’Rechnung fänkt also mat der Lëscht vun de Prozesser un, déi permanent lafen, an dann kommen d’Spëtzt an eng Marge derbäi:

Aarbechtsspäicher, dee virzegesinn ass = (System + permanent Servicer + Spëtzt vun de punktuellen Aufgaben) × 1,25

Wat all Bestanddeel verbraucht

Déi Gréisstenuerdnungen hei drënner gëllen fir eng Applikatioun vun üblecher Gréisst, an der Produktioun gemooss. Si sinn e Startpunkt; d’Miessung op Ärer eegener Applikatioun, déi weider ënne beschriwwen ass, huet ëmmer dat lescht Wuert.

BestanddeelTypesche VerbrauchWouvun en ofhänkt
Nginx, Caddy (Webserver, Proxy)10 bis 50 MBBal fix: d’Zuel vun de Verbindunge fällt kaum an d’Gewiicht.
PHP-FPM (WordPress, Laravel, Symfony)40 bis 80 MB pro ProzessD’Zuel vun de Prozesser, begrenzt duerch pm.max_children: 10 Prozesser brauchen 400 bis 800 MB.
Node.js (API, Next.js, NestJS)60 bis 300 MB pro ProzessD’Zuel vun de Prozesser (Cluster-Modus, PM2) an d’Gréisst vum Heap, begrenzt duerch --max-old-space-size.
Python (Django, FastAPI, Flask)80 bis 200 MB pro ProzessD’Zuel vun de Gunicorn- oder Uvicorn-Worker an d’Bibliothéiken, déi geluede sinn: pandas oder e Modell fir Maschinnléieren bréngen Honnerte vu MB derbäi.
Java (Spring Boot)300 MB bis 1 GB pro ApplikatiounDéi maximal Gréisst vum Heap: standardméisseg hëlt d’JVM sech e Véierel vum Späicher, deen se gesäit.
Go, Rust10 bis 100 MBD’Donnéeën, déi d’Applikatioun selwer am Späicher hält.
PostgreSQL25 % vum Späicher fir shared_buffers, plus e puer MB pro VerbindungD’Quantitéit un Donnéeën, déi dacks gelies ginn, d’Zuel vun de Verbindungen, work_mem.
MySQL, MariaDBinnodb_buffer_pool_size, standardméisseg 128 MBOp engem Server, deen nëmmen der Datebank déngt, hëlt dëse Puffer üblecherweis bis zu 80 % vum Späicher.
RedisD’Gréisst vun den Donnéeën, plus seng StrukturenWärend engem Backup op den Disk ginn déi geännert Säiten duebel gespäichert: am schlëmmste Fall bis zum Duebelen.
Elasticsearch, OpenSearchOp mannst 2 GB fir den HeapDen Heap bleift ënner der Hallschent vum Späicher: de Rescht déngt als Cache fir d’Fichieren.

Eng Spëtzt kënnt bei JavaScript-Applikatiounen ëmmer erëm: d’Kompilatioun. npm run build brauch bei engem Next.js-, Nuxt- oder Angular-Projet eleng üblecherweis 1 bis 2 GB, e puer Minutte laang, zousätzlech zu deem, wat schonn leeft. Um Server kompiléieren heescht, fir dës Spëtzt ze dimensionéieren; op Ärem Computer oder an Ärer CI-Pipeline kompiléieren an nëmmen d’Resultat eropzelueden heescht, se ze vermeiden.

Déi selwecht Iwwerleeung gëllt fir Docker-Container: all Container ass eng Grupp vu Prozesser wéi all aner, an den Docker-Daemon bréngt säin eegene Verbrauch mat. docker stats weist, wat jidderee vun hinnen hëlt.

Typesch Fäll

Dës Fäll addéieren d’Bestanddeeler vun uewen, Spëtzt a Marge inklusiv. Si setzen eng Applikatioun vun üblecher Gréisst an den Traffic vun engem Start viraus; eng voluminéis Datebank oder e konstant héijen Traffic dréckt de Wäert erop.

Wat um Server leeftAarbechtsspäicher, dee virzegesinn ass
Statesch Websäit, Proxy, klenge Bot oder geplangte Script1 bis 2 GB
Eng WordPress-Websäit mat MariaDB an engem Säitecache2 GB
E WooCommerce-Buttek, oder méi WordPress-Websäiten4 GB
Eng Node.js- oder Python-API mat PostgreSQL, éischt Benotzer4 GB
Eng Next.js-Applikatioun, déi um Server kompiléiert gëtt, hir API an hir PostgreSQL-Datebank6 bis 8 GB
Méi Applikatiounen a Container, Testëmfeld a Produktioun8 GB
Eng Datebank vu ville Gigabyte, déi intensiv ofgefrot gëtt16 GB a méi
E Sproochmodell mat 7 bis 8 Milliarde Parameteren, dat um Server leeft16 GB

Eng Applikatioun, déi e KI-Modell iwwer eng API oprifft (OpenAI, Anthropic, Mistral), gëtt wéi all aner Webapplikatioun dimensionéiert: de Modell leeft bei sengem Editeur, an Äre Server waart op d’Äntwert. Eréischt wann de Modell um Server selwer leeft, ännert sech d’Gréisstenuerdnung.

Op engem Server moossen, dee leeft

Op engem Server, deen a Betrib ass, ersetzt d’Miessung d’Schätzung. Dräi Befeeler weisen, wou Dir stitt:

Terminal
free -h
ps aux --sort=-rss | head -n 15
vmstat 5 5

Moosst zur Zäit vum Dag, wou am meeschte lass ass, a wärend de punktuellen Aufgaben: Kompilatioun, Backup, Import. Et ass d’Spëtzt, déi zielt.

Wann den Aarbechtsspäicher feelt

E Server ouni fräie Späicher gëtt net lues a lues méi lues. Wann näischt méi fräizeginn ass, léist de Linux-Kernel den OOM killer (out of memory) aus: e wielt e Prozess, an der Reegel deen, deen am meeschte Späicher hëlt, a stoppt en direkt. Op engem Applikatiounsserver ass dat dacks d’Datebank.

D’Symptomer: heiansdo Feeler 502 oder 503, e Service, deen ouni siichtbare Grond nei start, eng Kompilatioun, déi mat Killed ofbrécht. D’Logs bestätegen et:

Terminal
journalctl -k | grep -i "out of memory"
systemctl status numm-vum-service

An der Ausgab vu systemctl status weist d’Mentioun Failed with result 'oom-kill' op e Service, deen aus Mangel u Späicher gestoppt gouf.

De Swap, wann de Server een huet, verzögert dëse Moment, andeems e de Späicher, deen am mannste benotzt gëtt, op den Disk verlagert. En ass e Sécherheetsnetz, keng Kapazitéit: e Server, deen dauernd op de Swap ugewisen ass, äntwert e puer Mol méi lues, och op NVMe-Disken.

D’Léisungen, vun der einfachster bis zu där dauerhaftster: d’Zuel vun de Prozesser vun der Applikatioun erofsetzen (pm.max_children, Gunicorn-Worker), ausserhalb vum Server kompiléieren, de Späicher vun der Datebank begrenzen, an dann op déi nächst Gréisst wiesselen.

Seng Gréisst wielen, an un d’Zukunft denken

  1. Lëscht op, wat lafe soll: Webserver, Applikatioun an d’Zuel vun hire Prozesser, Datebank, Cache, déi geplangten Aufgaben.
  2. Addéiert mat der Tabell vun de Bestanddeeler, setzt déi schwéierst Spëtzt derbäi (dacks d’Kompilatioun), an dann 25 % Marge.
  3. Wielt d’Gréisst, déi dës Zomm ofdeckt. Tëscht zwou Gréissten, déi openeen folgen, geet déi méi kleng duer, soubal de Wiessel op déi nächst Gréisst ouni Neiinstallatioun geschitt.
  4. Moosst, soubal d’Applikatioun online ass, zur Spëtzestonn vum Dag, an duerno bei all Etapp vun hirem Wuesstem.

Den Aarbechtsspäicher ass net déi eenzeg Ressource: de Prozessor zielt fir alles, wat rechent (Kompilatioun, Bildveraarbechtung, Ausféiere vun engem KI-Modell), den Disk fir d’Datebank an d’Fichieren. Bei enger Webapplikatioun ass et awer bal ëmmer den Aarbechtsspäicher, deen d’Gréisst festleet.

Déi richteg Gréisst, an d’Fräiheet, se ze wiesselen

De VPS Pro gëtt et a sechs Gréissten, op Intel-Xeon-Prozessoren, ECC-Späicher a gespigelten NVMe-SSD, an e wiesselt zu all Moment op déi nächst Gréisst, ouni Neiinstallatioun. De Full-Stack-Support ass abegraff: beschreift eis, wat Äre Server soll lafe loossen, mir beroden Iech bei der Gréisst, an duerno stelle mir bei all Fro d’Diagnos a soen Iech, wat ze maachen ass, vum System bis zum Code vun Ärer Applikatioun.

VPS Pro entdecken

Dacks gestallte Froen

Wéivill RAM brauch e klenge VPS?

Eng statesch Websäit, e Proxy oder e klenge Script lafe mat 1 bis 2 GB. Soubal eng Datebank an eng Applikatioun (PHP, Node.js, Python) de Server deelen, rechent mat 2 GB fir eng WordPress-Websäit a 4 GB fir eng Applikatioun op Mooss mat PostgreSQL.

Wéivill RAM brauch WordPress op engem VPS?

2 GB fir eng Websäit mat MariaDB an engem Säitecache, 4 GB fir e WooCommerce-Buttek oder méi Websäiten. D’Zuel vun de PHP-FPM-Prozesser ass déi éischt Astellung: all Prozess hëlt 40 bis 80 MB.

Kann de Swap den Aarbechtsspäicher ersetzen?

Nee. De Swap verhënnert e brutale Stopp, wann de Späicher voll ass, mä e Server, deen en dauernd benotzt, äntwert e puer Mol méi lues, och op NVMe-Disken. En ass e Sécherheetsnetz; d’Gréisst gëtt nom Aarbechtsspäicher gewielt.

Firwat weist free bal kee fräie Späicher méi un?

Well Linux den ongenotzte Späicher als Cache fir d’Fichiere benotzt. Dëse Cache gëtt fräi, soubal e Programm Späicher brauch. D’Kolonn, op déi et ukënnt, ass available: si weist de Späicher, dee wierklech disponibel ass.

Wéivill RAM brauch d’Kompilatioun vun enger Next.js-Applikatioun?

Rechent mat 1 bis 2 GB eleng fir d’Kompilatioun, zousätzlech zu deem, wat schonn um Server leeft. Wann Dir op Ärem Computer oder an Ärer CI-Pipeline kompiléiert an nëmmen d’Resultat eropluet, vermeit Dir dës Spëtzt.

Kontaktéiert eis