Shulou(Shulou.com)06/01 Report--

Today Xiaobian to share with you what PHP FPM configuration parameters have related knowledge points, detailed content, clear logic, I believe most people still know too much about this knowledge, so share this article for everyone to refer to, I hope you have some gains after reading this article, let's learn about it together.

PHP-FPM is a PHP FastCGI process manager. FastCGI is a scalable, high-speed interface between web servers and scripting languages. The main advantage of FastCGI is that it separates dynamic languages from web servers. This technology allows web servers and dynamic languages to run on different hosts to massively scale and improve security without losing productivity.

PHP-FPM Configuration Details

The FPM configuration file is php-fpm.conf, which has syntax similar to php.ini.

php-fpm.conf Global configuration segment #Contains other POOL definitions Configuration files include=/etc/php-fpm.d/*.conf#Global configuration segment defines the location of PID files and the location of error logs [global]daemonize = yespid = /var/run/php-fpm/php-fpm.piderror_log = /var/log/php-fpm/error.log

Generally, there are very few configurations in the global configuration section of the main configuration file php-fpm.conf. php-fpm can configure multiple pools. Each pool operates as a separate configuration file, which is defined by default in the include file directory of the main configuration file. PHP will provide a www pool by default, roughly configured as follows.

$ cat /etc/php-fpm.d/www.conf[www]user = apachegroup = apachelisten = 127.0.0.1:9000listen.allowed_clients = 127.0.0.1pm = dynamicpm.max_children = 50pm.start_servers = 5pm.min_spare_servers = 5pm.max_spare_servers = 35

Each pool configuration file parameter can be set independently or in the global configuration section of the master configuration file, so that each pool shares one parameter. It is best to set them separately. The approximate parameters are as follows:

daemonize = yes

#background execution fpm, the default value is yes, if for debugging can be changed to no. In FPM, you can run multiple process pools with different settings. These settings can be set individually for each process pool.

listen = 127.0.0.1:9000

#fpm listening port, that is, the address handled by php in nginx, the general default value can be. Available formats are: 'ip: port',' port','/path/to/unix/socket', each process pool needs to be set. If nginx and php are on different machines and distributed processing, set ip here.

listen.backlog = -1

#backlog number, set the length of the semi-connected queue of listen,-1 means no limit, determined by the operating system, this line is commented out. Backlog meaning reference: www.3gyou.cc/? p=41。

log_level = notice

#Error level. The php-fpm.log above records the registration. Available levels are alert, error, warning, notice, debug. Default: notice.

emergency_restart_threshold = 60emergency_restart_interval = 60s

#indicates that php-fpm will restart gracefully if the number of php-cgi processes with SIGSEGV or SIGBUS errors exceeds the emergency_restart_threshold. These two options generally remain at their default values. 0 means 'Turn off this function'. Default: 0 (Off).

process_control_timeout = 0

#Set timeout time for child process to accept multiplex signal from main process. Available units: s(seconds), m(minutes), h(hours), or d(days) Default units: s(seconds). Default: 0.

listen.allowed_clients = 127.0.0.1

#Allow access to FastCGI process IP whitelist, set any to unrestricted IP, if you want to set nginx of other hosts can also access this FPM process, listen to set the cost to be accessible IP. The default value is any. Each address is separated by commas. If not set or empty, allows any server to request connections.

listen.owner = wwwlisten.group = wwwlisten.mode = 0666

#unix socket setting options, if you use tcp access, comments here can be.

user = wwwgroup = www

#Users and user groups for starting processes, Unix users for running FPM processes, must be set. User groups, if not set, the default user group is used.

pm = dynamic

#php-fpm process startup mode, pm can be set to static and dynamic and ondemand. If static is selected, the number of processes is fixed, with pm.max_children specifying a fixed number of child processes. If dynamic is selected, the number of processes is dynamically variable, determined by the following parameters:

pm.max_children = 50

#Maximum number of child processes that can be opened.

pm.start_servers = 2

#Number of processes at startup, default: min_spare_servers + (max_spare_servers-min_spare_servers) / 2.

pm.min_spare_servers = 1

#Ensure a minimum number of idle processes, if the idle process is less than this value, then create a new child process.

pm.max_spare_servers = 3

#Ensure the maximum number of idle processes, if the idle process is greater than this value, this is cleaned up.

pm.max_requests = 500

#Set the number of requests served before each child process is reborn. This is useful for third party modules that may have memory leaks. If set to '0' it always accepts requests. Equivalent to PHP_FCGI_MAX_REQUESTS environment variable. Default: 0.

pm.status_path = /status

#URL of FPM status page. If it is not set, the status page cannot be accessed. Default: none. Munin monitoring will be used

ping.path = /ping

#FPM monitoring page ping URL. If it is not set, you cannot access the ping page. This page is used to externally check if FPM is alive and available to respond to requests. Note that it must begin with a slash (/).

ping.response = pong

#Used to define the return response of ping requests. Returns text in HTTP 200 format. Default: pong.

access.log = log/$pool.access.log

#Access log for each request, default is off.

access.format = "%R – %u %t \"%m %r%Q%q\" %s %f %{mili}d %{kilo}M %C%%"

#Format access logs.

slowlog = log/$pool.log.slow

#Slow request log, used with request_slowlog_timeout, off by default

request_slowlog_timeout = 10s

#When a request for this timeout is set, the corresponding PHP call stack information is completely written to the slow log. Set to '0' means 'Off'

request_terminate_timeout = 0

#Set timeout abort time for individual requests. This option may be useful for scripts whose 'max_execution_time' setting in php.ini does not abort for some special reason. Set to '0' means 'Off'. Try changing this option when 502 errors occur frequently.

rlimit_files = 1024

#Set rlimit limit for file open descriptors. Default value: The default openable handle is 1024, which can be viewed by ulimit -n and modified by ulimit -n 2048.

rlimit_core = 0

#Set the maximum rlimit for the core. Available values: 'unlimited', 0 or positive integer. Default: System-defined value.

chroot = /data/app

#Chroot directory at startup. The directory defined needs to be an absolute path. If not set, chroot is not used.

chdir = /data/app

#Set the startup directory, which will be automatically Chdir to the directory when startup. The directory defined needs to be an absolute path. Default: Current directory, or/directory (when chroot).

catch_workers_output = yes

#Redirect stdout and stderr from the runtime to the main error log file. If not set, stdout and stderr will be redirected to/dev/null according to FastCGI rules. Default: null.

Of course, there are also some unimportant settings that can be used later.

PHP-FPM Important Settings php-fpm Process Assignment

It has been said in previous articles. In fasgcgi mode, php will start multiple php-fpm processes to receive requests from nginx. Is it that the more processes, the faster? That may not be true! It depends on our machine configuration and traffic.

Let's first look at where the configuration of the configuration process is?

pm = static | dynamic |Ondemandpm can be set to such 3 kinds, we use the most on the first 2 kinds. pm = static mode pm = static means that we create a fixed number of php-fpm child processes, then only pm.max_children = 50 parameter takes effect. When you start php-fpm, you start all 51(1 master +50 children) processes together, which is quite spectacular. pm = dynamic mode pm = dynamic mode, indicating that the startup process is dynamically allocated and changes dynamically with the amount of requests. It is determined by the parameters pm.max_children, pm.start_servers, pm.min_spare_servers, pm.max_spare_servers. As mentioned above, pm.max_children = 50 is the maximum number of child processes that can be created. Must be set. This means that there can be up to 50 child processes. pm.start_servers = 20 Number of child processes created when started with php-fpm. Default: min_spare_servers + (max_spare_servers-min_spare_servers) / 2. This means that there will be 20 child processes started together. pm.min_spare_servers = 10 Sets the minimum number of php-fpm processes when the server is idle. Must be set. If there are fewer than 10, several will be started to make up for it. pm.max_spare_servers = 30 Sets the maximum number of php-fpm processes when the server is idle. Must be set. If idle, check the number of processes, more than 30, will close a few, to 30 state.

The general principles are: dynamic adaptation to small memory machines, flexible allocation of processes, and memory saving. Static is suitable for large memory machines, and dynamically creating recycling processes is also a drain on server resources.

If your memory is large, 8-20G, according to a php-fpm process 20M, 100 on the 2G memory, then you can turn on static mode. If your memory is very small, such as only 256M, then be careful to set it, because other processes in your machine also need to occupy memory, so setting it to dynamic is the best, such as pm.max_chindren = 8, occupying about 160M of memory, and can be changed at any time.

Slow Log Query

Sometimes we are plagued by 500, 504 problems. When nginx receives the error code above, it can be determined that there is some problem with the backend php-fpm parsing php, such as execution error, execution timeout.

At this time, we can open the slow log function.

slowlog = /usr/local/var/log/php-fpm.log.slowrequest_slowlog_timeout = 15s

After a timeout of 15 seconds for a request to set this, the corresponding PHP call stack information is fully written to the slow log.

php-fpm slow log will record the process number, script name, which file, which line of code, which function execution time is too long:

[21-Nov-2013 14:30:38] [pool www] pid 11877script_filename = /usr/local/lnmp/nginx/html/www.quancha.cn/www/fyzb.php[0xb70fb88c] file_get_contents() /usr/local/lnmp/nginx/html/www.quancha.cn/www/fyzb.php:2

From the logs, we can see that there is something wrong with the file_get_contents function on line 2, so we can track down the problem.

The above is "PHP FPM configuration parameters what" all the content of this article, thank you for reading! I believe everyone has a great harvest after reading this article. Xiaobian will update different knowledge for everyone every day. If you want to learn more knowledge, please pay attention to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.