Artikulo Direktoryo
Ang bilang ng mga sabay-sabay na gumagamit na kayang hawakan ng isang server ay hindi nakadepende sa kung ilang core ang mayroon ito, kundi sa kung gaano karaming memorya ang nagagamit ng bawat proseso.
Maaaring magmukhang isang probokasyon ang pahayag na ito, ngunit ito ang pinakamatotoo at pinakamasakit na karanasan sa industriya ng operasyon at pagpapanatili.
Bakit ang memorya ang pangunahing hadlang?
Maraming tao ang nakakakita ng VPS na may 8-core CPU at 24GB ng memory at hindi namamalayang iniisip na madali nilang mapapatakbo ang daan-daang proseso ng PHP-FPM.
Gayunpaman, sa katotohanan, ang paggamit ng RSS memory ng isang proseso ng PHP ay kadalasang kasingtaas ng 200MB.
Ito ang resultang nakuha sa pamamagitan ng aktwal na pagsubok sa pamamagitan ng command line:
ps --no-headers -o rss -p $(pgrep php-fpm) | awk '{sum+=$1} END {print sum/NR/1024 " MB"}'
Sa masalimuot na framework at multi-plugin environment ng HestiaCP , lalo na kung walang OPcache optimization, 200MB ang karaniwan.
Nangangahulugan ito na ang memorya, hindi ang CPU, ang mahigpit na limitasyon na tumutukoy sa pinakamataas na concurrency.
Inirerekomendang file ng pagsasaayos (php-fpm.conf)
pm = dynamic
pm.max_children = 80
pm.start_servers = 16
pm.min_spare_servers = 8
pm.max_spare_servers = 24
pm.max_requests = 500
pm.process_idle_timeout = 10s
request_terminate_timeout = 60s
Lohika ng pagkalkula ng parameter at batayan ng pagtatakda
| Mga parameter ng pagsasaayos | Pagtatakda ng halaga | Batayan ng pagkalkula at pag-setup ng core |
|---|---|---|
| pm | dynamic | Pinapayagan ng dynamic mode ang elastic na pagdaragdag o pagtanggal ng mga proseso batay sa mga kinakailangan sa concurrency, pagbabalanse ng bilis ng tugon at paggamit ng memorya. |
| pm.max_children | 80 | 24GB na kabuuang memorya na binawasan ng system kernel at MySQL/RedisPagkatapos ng Nginx, humigit-kumulang 16GB ang natitira para sa PHP.16,384 MB / 200 MB ≈ 81.9Ang pagtatakda nito sa 80 ay maaaring ganap na maalis ang OOM (Out of Memory) habang nasa mataas na concurrency. |
| pm.start_servers | 16 | Ang preheating sa startup ay nakatakda sa doble ng bilang ng mga CPU core (8 core × 2 = 16) upang matiyak na agad na kayang pangasiwaan ng serbisyo ang basic concurrency pagkatapos mag-restart. |
| pm.min_spare_servers | 8 | Itakda ang bilang ng CPU core sa 8 core upang matiyak na maaaring matugunan ang mga bagong kahilingan anumang oras sa mga panahong mababa ang trapiko. |
| pm.max_spare_servers | 24 | Itakda ito sa 3 beses ang bilang ng mga CPU core (8 core × 3 = 24) upang mapanatili ang katamtamang bilang ng mga proseso pagkatapos humupa ang trapiko, upang mapangasiwaan ang mga banayad na pagbabago-bago. |
| pm.max_requests | 500 | Kung ang isang proseso ay umabot sa malaking base na 200MB, ang pagbabawas ng bilang ng mga kahilingan sa 500 bago sirain at muling itayo ay maaaring mas mabilis na linisin ang mga implicit memory leak. |
| pm.process_idle_timeout | 10s | 超出 min_spare_servers Ang mga prosesong idle ay awtomatikong inilalabas at ibinabalik sa memorya ng system pagkatapos ng 10 segundo ng walang mga kahilingan. |
Mga Mahahalagang Setting ng Suporta at Mga Mungkahi sa Pag-optimize
1. Mekanismo ng timeout laban sa hangover
request_terminate_timeout = 60s Iyan ang susi.
Maaari nitong piliting wakasan ang mga prosesong natigil dahil sa deadlock ng database o pagharang ng third-party API.
Samantala, ang Nginx fastcgi_read_timeout Dapat itong itago nang hindi bababa sa 60 segundo, kung hindi ay matatanggap ito ng kliyente nang wala sa panahon. 504 Gateway Timeout.
2. Mga estratehiya upang malampasan ang mga hadlang sa memorya
Ang maximum na 80 sabay-sabay na proseso ay nangangahulugan na sa ilalim ng matinding mga kondisyon ng sabay-sabay, ang sistema ay maaaring humawak ng maximum na 80 dynamic na kahilingan ng HTTP nang sabay-sabay.
Kung gusto mong higit pang mapabuti ang kapasidad, ang dapat na pokus ay ang pagbabawas ng paggamit ng memorya sa bawat proseso.
- Paganahin ang OPcache：在
php.iniKatamtamang konpigurasyonopcache.enable=1Atopcache.memory_consumption=256Maaaring mabawasan ng bytecode caching ang paggamit ng memorya ng isang proseso mula 200MB hanggang 60~100MB. - Makatwirang kontrol ng memory_limit：将
php.inigitnamemory_limitLimitado sa128MO256MUpang maiwasan ang mga indibidwal na abnormal na scriptwalang hanggananNakakaubos ito ng maraming memorya.
Kapag ang paggamit ng memorya ng isang proseso ay bumaba sa 100MB...pm.max_children Maaari itong ligtas na i-upgrade sa 150 Bukod pa rito, halos dumoble ang kakayahan sa sabay-sabay na paggamit.
Mga nabanggit na awtoridad na pananaw
Ayon sa mga rekomendasyon sa opisyal na dokumentasyon ng Nginx :
"Ang mga aplikasyon ng FastCGI ay dapat palaging subaybayan gamit ang mga direktiba ng timeout upang maiwasan ang pagkaubos ng mapagkukunan."
(Pinagmulan: Mga Dokumento ng Nginx)
Malinaw na nakasaad sa opisyal na manwal ng PHP :
"Tinutukoy ng pm.max_children ang pinakamataas na bilang ng mga prosesong anak na gagawin. Ito ang pinakamahalagang direktiba."
(Pinagmulan: Dokumentasyon ng PHP-FPM)
Ang mga makapangyarihang pananaw na ito ay ganap na naaayon sa aming mga kasanayan, na nagpapatunay na ang lohika ng pag-optimize ay hindi lamang batay sa karanasan, kundi pati na rin sa mga pamantayang pinakamahusay na kasanayan.
Konklusyon: Ang Aking mga Pananaw at Pangunahing Sipi
Sa mga sitwasyong may mataas na sabay-sabay na operasyon, ang CPU ang makina, ang memorya ang tangke ng gasolina, at ang PHP-FPM ang dispatcher ng fleet.
Gaano man kalakas ang makina, kung hindi sapat ang laki ng tangke ng gasolina, hindi rin lalayo ang mararating ng convoy.
Ang mga tunay na eksperto ay hindi basta-basta na lamang nagma-maximize ng mga parameter, ngunit sa halip ay tumpak na kinakalkula ang paggamit ng memorya ng bawat proseso upang maiwasan ang parehong pag-aaksaya at pag-apaw.
Ang esensya ng pag-optimize ay ang paghahanap ng pinakamainam na balanse na may limitadong mga mapagkukunan.
Hindi lamang ito isang teknolohiya, kundi isa ring pilosopiya.
Samakatuwid, itigil ang paniniwalang "ang bilang ng mga core ang nagtatakda ng lahat." Ang tunay na nagtatakda ng limitasyon ng concurrency ay ang iyong kontrol sa memorya.
Kumilos at i-optimize ang iyong VPS sa pinakamataas nitong potensyal, at masulit ang bawat patak ng memorya.
Sana ay makatulong sa iyo ang artikulong "8-core 24GB VPS running out of memory? Extreme tuning of PHP-FPM process pool under HestiaCP" na ibinahagi sa blog ni Chen Weiliang ( https://www.chenweiliang.com/ ).
Huwag mag-atubiling ibahagi ang link ng artikulong ito: https://www.chenweiliang.com/cwl-34509.html