A detailed explanation of LNMP concurrency and Resource allocation optimization

Writing Background
For a long time did not write a blog, the front end times to say go on the trip, and love to resign, go to Yunnan play for half a month, just come back, recently a time in looking for work, nothing on the Internet to see technology-related articles, recharge, yesterday occasionally found to explain lnmp concurrency and resource allocation of the article, feel good, Share with you.
Many times the interviewer will ask you, what is your program performance? How much can the concurrency of the program achieve? Where is the bottleneck of the program? How many servers should be purchased to meet business requirements? How many units does the PHP application server need in load balancing?
Perhaps these problems in the interview will be set up an application of the scene and some prerequisites, so that the interviewer to design, and put forward suggestions, can answer very good people or relatively few.
Concept
N in Lnmp is Nginx acting as a web Server
The distributor of the content, who finds the appropriate file in the file system, returns it to the browser, such as Nginx. If it is a static file, it can be returned directly, but if it is the index.php script file that needs to be parsed and executed, the Web server is powerless, and the request is forwarded to the corresponding scripting language parser to interpret and execute, eventually returning the execution result of the program to the Web server. and return to the browser.
P in LNMP is the logical handler for PHP to act as a backend
So how is the regular collaboration between PHP and Nginx? We need to define a few concepts.
Cgi
A common Gateway interface, described in the HTTP protocol, that communicates between Web server and back-end handler processes
php-cgi
PHP implementation of the CGI protocol, so that Web server and PHP together to complete a Dynamic Web page request response
FastCGI
is to solve CGI performance problems, and another protocol to the specification, why to solve the CGI performance problem, because in the face of the business requirements of large and medium-sized Web sites, the CGI program has become more and more powerless, because the CGI program every time you receive a request to start a new process, and initialization of the environment, and then execute the program, The specific content of the agreement is not quoted here.
php-fpm
Implementation of the FASTCGI protocol, is a php-cgi process manager, to solve the high concurrent Web site performance problems.
There are several concepts that need to be clarified in the final answer to LNMP's concurrent consideration and resource allocation
Concurrent
Typically measured by the number of requests completed within the unit, such as the number of transactions per second (TPS), the number of HTTP requests per second (HPS), and the number of queries per second (QPS). Normally, we say that PHP concurrency is the number of dynamic requests that PHP completes in a second. If a site peak dynamic request concurrency of 5000 per second, this number is not too high, but also not low. The average number of active users in the 10 million-50 million web site applications to achieve this level.
Performance
Generally refers to the processing speed of the application, if the PHP application, open a page (execute a script program) usually need to complete in the 50-100ms, this performance requirements for the program is still relatively high. But this is only the process of processing, PHP processing is completed, but also to the Web Server,web server to return data to the browser, there will be a network delay, usually network normal situation, need about 100ms, The final request for a Dynamic Web page is approximately 200ms (ideally) accessible to the user's browser (just an HTML structure).
Resource allocation
Number of PHP-FPM processes
As described above, concurrency of 5000 per second, each request completed about 200MS (specific page to be specific analysis, here is only an ideal value), if only 5 PHP application server, then each machine on average concurrent 1000 per second, if the use of NGINX+PHP-FPM architecture, What about the configuration of the PHP-FPM php-cgi process Manager? The result of my calculation is (specific configuration item description in the following text):
Pm=static
pm.max_children=100
The above 100 is how to get, because the machine average concurrency of 1000 per second, each dynamic request processing time is 100ms, that is to say 1 php-fpm worker processing process in 1 seconds can handle 10 requests, 100 PHP-FPM worker processing process, 1000 requests can be processed.
Of course, the need to combine server hardware resources to configure, if improperly configured, it is easy to peak in the request or traffic surges caused server downtime.
Network bandwidth
Network bandwidth will also be an important factor, if your service processing is very strong, but the user's request and response can not arrive in time is also white busy, this parameter how to calculate?
Concurrent 5000 per second, output of each request is 20K, then 5000x20k=100000k=100m
This requires that your public network Load Equalizer External network export bandwidth at least to reach 100M
Memory
In the above 100 php-fpm worker processing process, theoretically if the server only runs PHP-FPM, then we can allocate half of the server memory to PHP-FPM, usually we can think that a PHP-FPM worker process takes up memory 20M , then 100x20m=2g, which means that the server's memory is approximately 4G
Cpu
Because PHP-FPM is a multi process model application, CPU process scheduling consumption is also very large, and PHP application problems will lead to high CPU occupancy rate, there is no quantitative indicators, the need for concrete analysis of the situation. But there is a small suggestion that you can deploy a crontab every minute to detect the CPU occupancy rate more than how to kill the corresponding PHP-FPM worker processing process.
PHP-FPM Unix sockets
If Nginx is in the same machine as PHP, Nginx and php-fpm use UNIX domain sockets instead of TCP Socke to communicate, this configuration is very critical, pure echo AB test, using UNIX domain sockets per second to increase the number of calls 10%-20%
Configuration in Nginx:
Fastcgi_pass Unix:/data/server/var/php/php-fpm.sock;
Configuration in php-fpm.conf:
Listen =/data/server/var/php/php-fpm.sock
Finally encountered a lot of students on the PHP-FPM Process Manager's core configuration is not very familiar with, the following is my translation of the configuration instructions:
PHP-FPM Configuration Items
Pm
Static a fixed value, specified by Pm.max_children
Dynamic (works in the same way as Apache's prefork mode), but keep at least one, by
Pm.max_children the maximum number of processes at the same time
Pm.start_servers the number of processes on which the wait request came on when PHP-FPM started
Pm.min_spare_servers the minimum number of processes to run in idle state, if less than this value, creates a new process
Pm.max_spare_servers the maximum number of processes running in idle state, if greater than this value, will kill part of the process
OnDemand does not create a process at startup and creates a subprocess process request when the request is reached
Pm.max_children the maximum number of processes at the same time
Pm.process_idle_timeout the process will be killed after a few seconds of idle
PM = static
Pm.max_children
Maximum number of processes at the same time
Pm.max_children = 120
Pm.start_servers
PHP-FPM the number of processes on which waiting requests come on at startup, the default is: Min_spare_servers + (max_spare_servers–min_spare_servers)/2
Pm.start_servers = 80
Pm.min_spare_servers
The minimum number of processes running in idle state, if less than this value, creates a new process
Pm.min_spare_servers = 60
Pm.max_spare_servers
The maximum number of processes running in idle state, if greater than this value, will kill part of the process
Pm.max_spare_servers = 120
Pm.process_idle_timeout
The process is killed after how many seconds are idle, and the default is 10s
Pm.process_idle_timeout = 10s
Pm.max_requests
Automatic termination of the number of requests processed by each process can effectively prevent a memory overflow, if 0 will not automatically terminate, the default is 0
Pm.max_requests = 5000
Pm.status_path
Registered URI to show statistics for the PHP-FPM status
Pm.status_path =/status
Where the Statistics page information is:
Pool Process Pools Name
Process Manager Processes manager name (static, dynamic or OnDemand)
Start Time php-fpm startup times
The total number of seconds that start since PHP-FPM started
Accepted conn The number of requests received by the current process pool
Number of requests for listen queue waiting queues
Max Listen Queue The maximum number of requests queued since startup
Listen queue Len waiting for connection socket queue Size
Idle processes the number of currently idle processes
Active processes the number of processes active
Total processes number of processes (idle+active)
Max Active processes the maximum number of processes active since startup
Max children reached maximum number of processes
Ping.path
Ping URL, which can be used to test whether PHP-FPM is alive and can respond
Ping.path =/ping
Ping.response
The response body of the ping URL
Ping.response = Pong