hustshawn/docker.conf

## docker.conf
; if you're using the starter bundle file `docker/php/php-fpm.d/docker.conf`
[global]
daemonize = no
pid = run/php-fpm.pid

[www]
listen = /usr/local/var/run/php-fpm.sock
listen.owner = www-data
listen.group = www-data
listen.mode = 0660
pm = dynamic
pm.max_children = ${PHP_FPM_PM_MAX_CHILDREN}
pm.start_servers = ${PHP_FPM_PM_START_SERVERS}
pm.min_spare_servers = ${PHP_FPM_PM_MIN_SPARE_SERVERS}
pm.max_spare_servers = ${PHP_FPM_PM_MAX_SPARE_SERVERS}
pm.max_requests = ${PHP_FPM_PM_MAX_REQUESTS}

## example.md

      
    Raw
  

              example.md
            
          
    Configuring FPM Workers

To use the below www.conf file with docker you need to copy it into the image and version it.
For example, if your file lives in docker/php/www.conf you might copy it like so in your Dockerfile:
COPY docker/php/www.conf /usr/local/etc/php-fpm.d/www.conf

If you are following the Docker for PHP Developers Laravel Starter Bundle you could add the process configuration found below in www.conf to docker/php/php-fpm.d/docker.conf.
In the Dockerfile you might have some sort of default environment settings for the pm.* config that matches the defaults:
FROM php:7.2-fpm-stretch

ENV PATH="./vendor/bin:${PATH}" \
    NGINX_SERVER_NAME="_" \
    PHP_OPCACHE_VALIDATE_TIMESTAMPS="0" \
    PHP_OPCACHE_MAX_ACCELERATED_FILES="6000" \
    PHP_OPCACHE_MEMORY_CONSUMPTION="128"
    PHP_FPM_PM_MAX_CHILDREN=5 \
    PHP_FPM_PM_START_SERVERS=2 \
    PHP_FPM_PM_MIN_SPARE_SERVERS=1 \
    PHP_FPM_PM_MAX_SPARE_SERVERS=3 \
    PHP_FPM_PM_MAX_REQUESTS=500
# ...
COPY docker/php/www.conf /usr/local/etc/php-fpm.d/www.conf
You can dynamically set environment variables for the PHP-FPM processes that matches the server/container resources you have available. This article might be helpful (there are plenty of others):
https://www.kinamo.be/en/support/faq/determining-the-correct-number-of-child-processes-for-php-fpm-on-nginx

  
## www-no-comments.conf
[www]

user = www-data
group = www-data
listen = /usr/local/var/run/php-fpm.sock;
pm = dynamic
pm.max_children = ${PHP_FPM_PM_MAX_CHILDREN}
pm.start_servers = ${PHP_FPM_PM_START_SERVERS}
pm.min_spare_servers = ${PHP_FPM_PM_MIN_SPARE_SERVERS}
pm.max_spare_servers = ${PHP_FPM_PM_MAX_SPARE_SERVERS}
pm.max_requests = ${PHP_FPM_PM_MAX_REQUESTS}

## www.conf
; Start a new pool named 'www'.
; the variable $pool can be used in any directive and will be replaced by the
; pool name ('www' here)
[www]

; Per pool prefix
; It only applies on the following directives:
; - 'access.log'
; - 'slowlog'
; - 'listen' (unixsocket)
; - 'chroot'
; - 'chdir'
; - 'php_values'
; - 'php_admin_values'
; When not set, the global prefix (or NONE) applies instead.
; Note: This directive can also be relative to the global prefix.
; Default Value: none
;prefix = /path/to/pools/$pool

; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
user = www-data
group = www-data

; The address on which to accept FastCGI requests.
; Valid syntaxes are:
;   'ip.add.re.ss:port'    - to listen on a TCP socket to a specific IPv4 address on
;                            a specific port;
;   '[ip:6:addr:ess]:port' - to listen on a TCP socket to a specific IPv6 address on
;                            a specific port;
;   'port'                 - to listen on a TCP socket to all addresses
;                            (IPv6 and IPv4-mapped) on a specific port;
;   '/path/to/unix/socket' - to listen on a unix socket.
; Note: This value is mandatory.
listen = 127.0.0.1:9000

; Set listen(2) backlog.
; Default Value: 511 (-1 on FreeBSD and OpenBSD)
;listen.backlog = 511

; Set permissions for unix socket, if one is used. In Linux, read/write
; permissions must be set in order to allow connections from a web server. Many
; BSD-derived systems allow connections regardless of permissions.
; Default Values: user and group are set as the running user
;                 mode is set to 0660
;listen.owner = www-data
;listen.group = www-data
;listen.mode = 0660
; When POSIX Access Control Lists are supported you can set them using
; these options, value is a comma separated list of user/group names.
; When set, listen.owner and listen.group are ignored
;listen.acl_users =
;listen.acl_groups =

; List of addresses (IPv4/IPv6) of FastCGI clients which are allowed to connect.
; Equivalent to the FCGI_WEB_SERVER_ADDRS environment variable in the original
; PHP FCGI (5.2.2+). Makes sense only with a tcp listening socket. Each address
; must be separated by a comma. If this value is left blank, connections will be
; accepted from any ip address.
; Default Value: any
listen.allowed_clients = 127.0.0.1

; Specify the nice(2) priority to apply to the pool processes (only if set)
; The value can vary from -19 (highest priority) to 20 (lower priority)
; Note: - It will only work if the FPM master process is launched as root
;       - The pool processes will inherit the master process priority
;         unless it specified otherwise
; Default Value: no set
; process.priority = -19

; Choose how the process manager will control the number of child processes.
; Possible Values:
;   static  - a fixed number (pm.max_children) of child processes;
;   dynamic - the number of child processes are set dynamically based on the
;             following directives. With this process management, there will be
;             always at least 1 children.
;             pm.max_children      - the maximum number of children that can
;                                    be alive at the same time.
;             pm.start_servers     - the number of children created on startup.
;             pm.min_spare_servers - the minimum number of children in 'idle'
;                                    state (waiting to process). If the number
;                                    of 'idle' processes is less than this
;                                    number then some children will be created.
;             pm.max_spare_servers - the maximum number of children in 'idle'
;                                    state (waiting to process). If the number
;                                    of 'idle' processes is greater than this
;                                    number then some children will be killed.
;  ondemand - no children are created at startup. Children will be forked when
;             new requests will connect. The following parameter are used:
;             pm.max_children           - the maximum number of children that
;                                         can be alive at the same time.
;             pm.process_idle_timeout   - The number of seconds after which
;                                         an idle process will be killed.
; Note: This value is mandatory.
pm = dynamic

; The number of child processes to be created when pm is set to 'static' and the
; maximum number of child processes when pm is set to 'dynamic' or 'ondemand'.
; This value sets the limit on the number of simultaneous requests that will be
; served. Equivalent to the ApacheMaxClients directive with mpm_prefork.
; Equivalent to the PHP_FCGI_CHILDREN environment variable in the original PHP
; CGI. The below defaults are based on a server without much resources. Don't
; forget to tweak pm.* to fit your needs.
; Note: Used when pm is set to 'static', 'dynamic' or 'ondemand'
; Note: This value is mandatory.
pm.max_children = ${PHP_FPM_PM_MAX_CHILDREN}

; The number of child processes created on startup.
; Note: Used only when pm is set to 'dynamic'
; Default Value: min_spare_servers + (max_spare_servers - min_spare_servers) / 2
pm.start_servers = ${PHP_FPM_PM_START_SERVERS}

; The desired minimum number of idle server processes.
; Note: Used only when pm is set to 'dynamic'
; Note: Mandatory when pm is set to 'dynamic'
pm.min_spare_servers = ${PHP_FPM_PM_MIN_SPARE_SERVERS}

; The desired maximum number of idle server processes.
; Note: Used only when pm is set to 'dynamic'
; Note: Mandatory when pm is set to 'dynamic'
pm.max_spare_servers = ${PHP_FPM_PM_MAX_SPARE_SERVERS}

; The number of seconds after which an idle process will be killed.
; Note: Used only when pm is set to 'ondemand'
; Default Value: 10s
;pm.process_idle_timeout = 10s;

; The number of requests each child process should execute before respawning.
; This can be useful to work around memory leaks in 3rd party libraries. For
; endless request processing specify '0'. Equivalent to PHP_FCGI_MAX_REQUESTS.
; Default Value: 0
pm.max_requests = ${PHP_FPM_PM_MAX_REQUESTS}
	; if you're using the starter bundle file `docker/php/php-fpm.d/docker.conf`
	[global]
	daemonize = no
	pid = run/php-fpm.pid

	[www]
	listen = /usr/local/var/run/php-fpm.sock
	listen.owner = www-data
	listen.group = www-data
	listen.mode = 0660
	pm = dynamic
	pm.max_children = ${PHP_FPM_PM_MAX_CHILDREN}
	pm.start_servers = ${PHP_FPM_PM_START_SERVERS}
	pm.min_spare_servers = ${PHP_FPM_PM_MIN_SPARE_SERVERS}
	pm.max_spare_servers = ${PHP_FPM_PM_MAX_SPARE_SERVERS}
	pm.max_requests = ${PHP_FPM_PM_MAX_REQUESTS}
	[www]

	user = www-data
	group = www-data
	listen = /usr/local/var/run/php-fpm.sock;
	pm = dynamic
	pm.max_children = ${PHP_FPM_PM_MAX_CHILDREN}
	pm.start_servers = ${PHP_FPM_PM_START_SERVERS}
	pm.min_spare_servers = ${PHP_FPM_PM_MIN_SPARE_SERVERS}
	pm.max_spare_servers = ${PHP_FPM_PM_MAX_SPARE_SERVERS}
	pm.max_requests = ${PHP_FPM_PM_MAX_REQUESTS}
	; Start a new pool named 'www'.
	; the variable $pool can be used in any directive and will be replaced by the
	; pool name ('www' here)
	[www]

	; Per pool prefix
	; It only applies on the following directives:
	; - 'access.log'
	; - 'slowlog'
	; - 'listen' (unixsocket)
	; - 'chroot'
	; - 'chdir'
	; - 'php_values'
	; - 'php_admin_values'
	; When not set, the global prefix (or NONE) applies instead.
	; Note: This directive can also be relative to the global prefix.
	; Default Value: none
	;prefix = /path/to/pools/$pool

	; Unix user/group of processes
	; Note: The user is mandatory. If the group is not set, the default user's group
	; will be used.
	user = www-data
	group = www-data

	; The address on which to accept FastCGI requests.
	; Valid syntaxes are:
	; 'ip.add.re.ss:port' - to listen on a TCP socket to a specific IPv4 address on
	; a specific port;
	; '[ip:6:addr:ess]:port' - to listen on a TCP socket to a specific IPv6 address on
	; a specific port;
	; 'port' - to listen on a TCP socket to all addresses
	; (IPv6 and IPv4-mapped) on a specific port;
	; '/path/to/unix/socket' - to listen on a unix socket.
	; Note: This value is mandatory.
	listen = 127.0.0.1:9000

	; Set listen(2) backlog.
	; Default Value: 511 (-1 on FreeBSD and OpenBSD)
	;listen.backlog = 511

	; Set permissions for unix socket, if one is used. In Linux, read/write
	; permissions must be set in order to allow connections from a web server. Many
	; BSD-derived systems allow connections regardless of permissions.
	; Default Values: user and group are set as the running user
	; mode is set to 0660
	;listen.owner = www-data
	;listen.group = www-data
	;listen.mode = 0660
	; When POSIX Access Control Lists are supported you can set them using
	; these options, value is a comma separated list of user/group names.
	; When set, listen.owner and listen.group are ignored
	;listen.acl_users =
	;listen.acl_groups =

	; List of addresses (IPv4/IPv6) of FastCGI clients which are allowed to connect.
	; Equivalent to the FCGI_WEB_SERVER_ADDRS environment variable in the original
	; PHP FCGI (5.2.2+). Makes sense only with a tcp listening socket. Each address
	; must be separated by a comma. If this value is left blank, connections will be
	; accepted from any ip address.
	; Default Value: any
	listen.allowed_clients = 127.0.0.1

	; Specify the nice(2) priority to apply to the pool processes (only if set)
	; The value can vary from -19 (highest priority) to 20 (lower priority)
	; Note: - It will only work if the FPM master process is launched as root
	; - The pool processes will inherit the master process priority
	; unless it specified otherwise
	; Default Value: no set
	; process.priority = -19

	; Choose how the process manager will control the number of child processes.
	; Possible Values:
	; static - a fixed number (pm.max_children) of child processes;
	; dynamic - the number of child processes are set dynamically based on the
	; following directives. With this process management, there will be
	; always at least 1 children.
	; pm.max_children - the maximum number of children that can
	; be alive at the same time.
	; pm.start_servers - the number of children created on startup.
	; pm.min_spare_servers - the minimum number of children in 'idle'
	; state (waiting to process). If the number
	; of 'idle' processes is less than this
	; number then some children will be created.
	; pm.max_spare_servers - the maximum number of children in 'idle'
	; state (waiting to process). If the number
	; of 'idle' processes is greater than this
	; number then some children will be killed.
	; ondemand - no children are created at startup. Children will be forked when
	; new requests will connect. The following parameter are used:
	; pm.max_children - the maximum number of children that
	; can be alive at the same time.
	; pm.process_idle_timeout - The number of seconds after which
	; an idle process will be killed.
	; Note: This value is mandatory.
	pm = dynamic

	; The number of child processes to be created when pm is set to 'static' and the
	; maximum number of child processes when pm is set to 'dynamic' or 'ondemand'.
	; This value sets the limit on the number of simultaneous requests that will be
	; served. Equivalent to the ApacheMaxClients directive with mpm_prefork.
	; Equivalent to the PHP_FCGI_CHILDREN environment variable in the original PHP
	; CGI. The below defaults are based on a server without much resources. Don't
	; forget to tweak pm.* to fit your needs.
	; Note: Used when pm is set to 'static', 'dynamic' or 'ondemand'
	; Note: This value is mandatory.
	pm.max_children = ${PHP_FPM_PM_MAX_CHILDREN}

	; The number of child processes created on startup.
	; Note: Used only when pm is set to 'dynamic'
	; Default Value: min_spare_servers + (max_spare_servers - min_spare_servers) / 2
	pm.start_servers = ${PHP_FPM_PM_START_SERVERS}

	; The desired minimum number of idle server processes.
	; Note: Used only when pm is set to 'dynamic'
	; Note: Mandatory when pm is set to 'dynamic'
	pm.min_spare_servers = ${PHP_FPM_PM_MIN_SPARE_SERVERS}

	; The desired maximum number of idle server processes.
	; Note: Used only when pm is set to 'dynamic'
	; Note: Mandatory when pm is set to 'dynamic'
	pm.max_spare_servers = ${PHP_FPM_PM_MAX_SPARE_SERVERS}

	; The number of seconds after which an idle process will be killed.
	; Note: Used only when pm is set to 'ondemand'
	; Default Value: 10s
	;pm.process_idle_timeout = 10s;

	; The number of requests each child process should execute before respawning.
	; This can be useful to work around memory leaks in 3rd party libraries. For
	; endless request processing specify '0'. Equivalent to PHP_FCGI_MAX_REQUESTS.
	; Default Value: 0
	pm.max_requests = ${PHP_FPM_PM_MAX_REQUESTS}