1
opkg install nginx
2
opkg install php7-mod-mysqli php7-mod-pdo-mysql mysql-server
3
opkg install php7-mod-curl php7-mod-gd php7-mod-iconv php7-mod-json php7-mod-mbstring php7-mod-opcache php7-mod-session php7-mod-zip
4
opkg install php7-fpm

1
#user nobody nogroup;
2
user root root;
3
worker_processes  1;
4

5
error_log  /tmp/log/nginx/error.log;
6
#error_log  logs/error.log  notice;
7
#error_log  logs/error.log  info;
8

9
pid        /tmp/log/nginx/nginx.pid;
10

11

12
events {
13
    use epoll;
14
    worker_connections  1024;
15
}
16

17

18
http {
19
    include       mime.types;
20
    default_type  application/octet-stream;
21

22
    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
23
    #                  '$status $body_bytes_sent "$http_referer" '
24
    #                  '"$http_user_agent" "$http_x_forwarded_for"';
25

26
    #access_log  logs/access.log  main;
27

28
    sendfile        on;
29
    tcp_nopush     on;
30

31
    #keepalive_timeout  0;
32
    keepalive_timeout  65;
33

34
    #gzip  on;
35

36
    include       php.conf;
37

38

39
#    server {
40
#        listen       80;
41
#        server_name  localhost;
42

43
        #charset koi8-r;
44

45
        #access_log  logs/host.access.log  main;
46

47
#        location / {
48
#            root   html;
49
#            index  index.html index.htm;
50
#        }
51

52
        #error_page  404              /404.html;
53

54
        # redirect server error pages to the static page /50x.html
55
        #
56
#        error_page   500 502 503 504  /50x.html;
57
#        location = /50x.html {
58
#            root   html;
59
#        }
60

61
        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
62
        #
63
        #location ~ \.php$ {
64
        #    proxy_pass   http://127.0.0.1;
65
        #}
66

67
        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
68
        #
69
        #location ~ \.php$ {
70
        #    root           html;
71
        #    fastcgi_pass   127.0.0.1:9000;
72
        #    fastcgi_index  index.php;
73
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
74
        #    include        fastcgi_params;
75
        #}
76

77
        # deny access to .htaccess files, if Apache's document root
78
        # concurs with nginx's one
79
        #
80
        #location ~ /\.ht {
81
        #    deny  all;
82
        #}
83
#    }
84

85

86
    # another virtual host using mix of IP-, name-, and port-based configuration
87
    #
88
    #server {
89
    #    listen       8000;
90
    #    listen       somename:8080;
91
    #    server_name  somename  alias  another.alias;
92

93
    #    location / {
94
    #        root   html;
95
    #        index  index.html index.htm;
96
    #    }
97
    #}
98

99

100
    # HTTPS server
101
    #
102
    #server {
103
    #    listen       443;
104
    #    server_name  localhost;
105

106
    #    ssl                  on;
107
    #    ssl_certificate      cert.pem;
108
    #    ssl_certificate_key  cert.key;
109

110
    #    ssl_session_timeout  5m;
111

112
    #    ssl_protocols  SSLv2 SSLv3 TLSv1;
113
    #    ssl_ciphers  HIGH:!aNULL:!MD5;
114
    #    ssl_prefer_server_ciphers   on;
115

116
    #    location / {
117
    #        root   html;
118
    #        index  index.html index.htm;
119
    #    }
120
    #}
121

122
}

1
server {
2
        listen       80;
3
        server_name _;
4
        #charset utf-8
5
        root  /mnt/mmcblk0/Web/www;
6
        index  index.html index.htm index.php default.php;
7
        #error_page   500 502 503 504  /50x.html;
8

9
        #location = /50x.html {
10
        #root html;
11
        #}
12

13
        location ~* ^.+\.php(\/.*)*$ {
14
                #fastcgi_pass   127.0.0.1:9000;
15
    fastcgi_pass unix:/var/run/php7-fpm.sock;
16
                fastcgi_index  index.php;
17
                fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
18
                include        fastcgi_params;
19
    client_max_body_size  2048m;
20
        }
21

22
        #error_page   404   /404.html;
23

24
        # Deny access to PHP files in specific directory
25
        #location ~ /(wp-content|uploads|wp-includes|images)/.*\.php$ { deny all; }
26

27

28
        location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$
29
        {
30
            expires      30d;
31
        }
32

33
        location ~ .*\.(js|css)?$
34
        {
35
            expires      12h;
36
        }
37

38
        location ~ /.well-known {
39
            allow all;
40
        }
41

42
        location ~ /\.
43
        {
44
            deny all;
45
        }
46

47
}

1
[PHP]
2
zend.ze1_compatibility_mode = Off
3

4
; Language Options
5

6
engine = On
7
short_open_tag = On
8
precision    =  12
9
y2k_compliance = On
10
output_buffering = Off
11
;output_handler =
12
zlib.output_compression = Off
13
;zlib.output_compression_level = -1
14
;zlib.output_handler =
15
implicit_flush = Off
16
unserialize_callback_func =
17
serialize_precision = 100
18

19
;open_basedir =
20
disable_functions =
21
disable_classes =
22

23
; Colors for Syntax Highlighting mode.  Anything that's acceptable in
24
; <span style="color: ???????"> would work.
25
;highlight.string  = #DD0000
26
;highlight.comment = #FF9900
27
;highlight.keyword = #007700
28
;highlight.bg      = #FFFFFF
29
;highlight.default = #0000BB
30
;highlight.html    = #000000
31

32
;ignore_user_abort = On
33
;realpath_cache_size = 16k
34
;realpath_cache_ttl = 120
35

36
; Miscellaneous
37

38
expose_php = On
39

40
; Resource Limits
41

42
max_execution_time = 500  ; Maximum execution time of each script, in seconds.
43
max_input_time = 120  ; Maximum amount of time each script may spend parsing request data.
44
;max_input_nesting_level = 64
45
memory_limit = 16M  ; Maximum amount of memory a script may consume.
46

47
; Error handling and logging
48

49
; Error Level Constants:
50
; E_ALL             - All errors and warnings (includes E_STRICT as of PHP 6.0.0)
51
; E_ERROR           - fatal run-time errors
52
; E_RECOVERABLE_ERROR  - almost fatal run-time errors
53
; E_WARNING         - run-time warnings (non-fatal errors)
54
; E_PARSE           - compile-time parse errors
55
; E_NOTICE          - run-time notices (these are warnings which often result
56
;                     from a bug in your code, but it's possible that it was
57
;                     intentional (e.g., using an uninitialized variable and
58
;                     relying on the fact it's automatically initialized to an
59
;                     empty string)
60
; E_STRICT      - run-time notices, enable to have PHP suggest changes
61
;                     to your code which will ensure the best interoperability
62
;                     and forward compatibility of your code
63
; E_CORE_ERROR      - fatal errors that occur during PHP's initial startup
64
; E_CORE_WARNING    - warnings (non-fatal errors) that occur during PHP's
65
;                     initial startup
66
; E_COMPILE_ERROR   - fatal compile-time errors
67
; E_COMPILE_WARNING - compile-time warnings (non-fatal errors)
68
; E_USER_ERROR      - user-generated error message
69
; E_USER_WARNING    - user-generated warning message
70
; E_USER_NOTICE     - user-generated notice message
71
; E_DEPRECATED      - warn about code that will not work in future versions
72
;                     of PHP
73
; E_USER_DEPRECATED - user-generated deprecation warnings
74
;
75
; Common Values:
76
;   E_ALL & ~E_NOTICE  (Show all errors, except for notices and coding standards warnings.)
77
;   E_ALL & ~E_NOTICE | E_STRICT  (Show all errors, except for notices)
78
;   E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR  (Show only errors)
79
;   E_ALL | E_STRICT  (Show all errors, warnings and notices including coding standards.)
80
; Default Value: E_ALL & ~E_NOTICE
81
error_reporting  =  E_ALL & ~E_NOTICE & ~E_STRICT
82

83
display_errors = On
84
display_startup_errors = Off
85
log_errors = Off
86
log_errors_max_len = 1024
87
ignore_repeated_errors = Off
88
ignore_repeated_source = Off
89
report_memleaks = On
90
;report_zend_debug = 0
91
track_errors = Off
92
;html_errors = Off
93
;docref_root = "/phpmanual/"
94
;docref_ext = .html
95
;error_prepend_string = "<font color=#ff0000>"
96
;error_append_string = "</font>"
97
; Log errors to specified file.
98
;error_log = /var/log/php_errors.log
99
; Log errors to syslog.
100
;error_log = syslog
101

102
; Data Handling
103

104
;arg_separator.output = "&amp;"
105
;arg_separator.input = ";&"
106
variables_order = "EGPCS"
107
request_order = "GP"
108
register_globals = Off
109
register_long_arrays = Off
110
register_argc_argv = On
111
auto_globals_jit = On
112
post_max_size = 2048M
113
;magic_quotes_gpc = Off
114
magic_quotes_runtime = Off
115
magic_quotes_sybase = Off
116
auto_prepend_file =
117
auto_append_file =
118
default_mimetype = "text/html"
119
;default_charset = "iso-8859-1"
120
;always_populate_raw_post_data = On
121

122
; Paths and Directories
123

124
; UNIX: "/path1:/path2"
125
;include_path = ".:/php/includes"
126
#doc_root = "/www"
127
user_dir =
128
extension_dir = "/usr/lib/php"
129
enable_dl = On
130
;cgi.force_redirect = 1
131
;cgi.nph = 1
132
;cgi.redirect_status_env = ;
133
cgi.fix_pathinfo=1
134
;fastcgi.impersonate = 1;
135
;fastcgi.logging = 0
136
;cgi.rfc2616_headers = 0
137

138
; File Uploads
139

140
file_uploads = On
141
upload_tmp_dir = "/mnt/mmcblk0/Web/tmp"
142
upload_max_filesize = 2048M
143
max_file_uploads = 20
144

145
; Fopen wrappers
146

147
allow_url_fopen = On
148
allow_url_include = Off
149
;from="[email protected]"
150
;user_agent="PHP"
151
default_socket_timeout = 60
152
;auto_detect_line_endings = Off</span>

1
[client]
2
port    = 3306
3
socket    = /var/run/mysqld.sock
4

5
[mysqld]
6
user    = root
7
socket    = /var/run/mysqld.sock
8
port    = 3306
9
basedir    = /usr
10

11
############ Don't put this on the NAND #############
12
# Figure out where you are going to put the databases
13
# And run mysql_install_db --force
14
datadir    = /mnt/mmcblk0/Web/mysql/
15

16
######### This should also not go on the NAND #######
17
tmpdir    = /mnt/mmcblk0/Web/tmp/
18

19
skip-external-locking
20

21
bind-address    = 127.0.0.1
22

23
# Fine Tuning
24
key_buffer    = 16M
25
max_allowed_packet  = 16M
26
thread_stack    = 192K
27
thread_cache_size       = 8
28

29
# Here you can see queries with especially long duration
30
#log_slow_queries  = /var/log/mysql/mysql-slow.log
31
#long_query_time = 2
32
#log-queries-not-using-indexes
33

34
# The following can be used as easy to replay backup logs or for replication.
35
#server-id    = 1
36
#log_bin      = /var/log/mysql/mysql-bin.log
37
#expire_logs_days  = 10
38
#max_binlog_size         = 100M
39
#binlog_do_db    = include_database_name
40
#binlog_ignore_db  = include_database_name
41

42

43
[mysqldump]
44
quick
45
quote-names
46
max_allowed_packet  = 16M
47

48
[mysql]
49
#no-auto-rehash  # faster start of mysql but no tab completition
50

51
[isamchk]
52
key_buffer    = 16M

1
; Start a new pool named 'www'.
2
; the variable $pool can we used in any directive and will be replaced by the
3
; pool name ('www' here)
4
[www]
5

6
; Per pool prefix
7
; It only applies on the following directives:
8
; - 'slowlog'
9
; - 'listen' (unixsocket)
10
; - 'chroot'
11
; - 'chdir'
12
; - 'php_values'
13
; - 'php_admin_values'
14
; When not set, the global prefix (or /usr) applies instead.
15
; Note: This directive can also be relative to the global prefix.
16
; Default Value: none
17
;prefix = /path/to/pools/$pool
18

19
; Unix user/group of processes
20
; Note: The user is mandatory. If the group is not set, the default user's group
21
;       will be used.
22
user = root
23
;group = root
24

25
; The address on which to accept FastCGI requests.
26
; Valid syntaxes are:
27
;   'ip.add.re.ss:port'    - to listen on a TCP socket to a specific address on
28
;                            a specific port;
29
;   'port'                 - to listen on a TCP socket to all addresses on a
30
;                            specific port;
31
;   '/path/to/unix/socket' - to listen on a unix socket.
32
; Note: This value is mandatory.
33
;listen = 127.0.0.1:9000
34
listen = /var/run/php7-fpm.sock
35

36
; Set listen(2) backlog.
37
; Default Value: 128 (-1 on FreeBSD and OpenBSD)
38
;listen.backlog = 128
39

40
; Set permissions for unix socket, if one is used. In Linux, read/write
41
; permissions must be set in order to allow connections from a web server. Many
42
; BSD-derived systems allow connections regardless of permissions.
43
; Default Values: user and group are set as the running user
44
;                 mode is set to 0666
45
listen.owner = root
46
listen.group = root
47
listen.mode = 0666
48

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

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

65
; Choose how the process manager will control the number of child processes.
66
; Possible Values:
67
;   static  - a fixed number (pm.max_children) of child processes;
68
;   dynamic - the number of child processes are set dynamically based on the
69
;             following directives. With this process management, there will be
70
;             always at least 1 children.
71
;             pm.max_children      - the maximum number of children that can
72
;                                    be alive at the same time.
73
;             pm.start_servers     - the number of children created on startup.
74
;             pm.min_spare_servers - the minimum number of children in 'idle'
75
;                                    state (waiting to process). If the number
76
;                                    of 'idle' processes is less than this
77
;                                    number then some children will be created.
78
;             pm.max_spare_servers - the maximum number of children in 'idle'
79
;                                    state (waiting to process). If the number
80
;                                    of 'idle' processes is greater than this
81
;                                    number then some children will be killed.
82
;  ondemand - no children are created at startup. Children will be forked when
83
;             new requests will connect. The following parameter are used:
84
;             pm.max_children           - the maximum number of children that
85
;                                         can be alive at the same time.
86
;             pm.process_idle_timeout   - The number of seconds after which
87
;                                         an idle process will be killed.
88
; Note: This value is mandatory.
89
pm = dynamic
90

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

102
; The number of child processes created on startup.
103
; Note: Used only when pm is set to 'dynamic'
104
; Default Value: min_spare_servers + (max_spare_servers - min_spare_servers) / 2
105
pm.start_servers = 2
106

107
; The desired minimum number of idle server processes.
108
; Note: Used only when pm is set to 'dynamic'
109
; Note: Mandatory when pm is set to 'dynamic'
110
pm.min_spare_servers = 1
111

112
; The desired maximum number of idle server processes.
113
; Note: Used only when pm is set to 'dynamic'
114
; Note: Mandatory when pm is set to 'dynamic'
115
pm.max_spare_servers = 3
116

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

122
; The number of requests each child process should execute before respawning.
123
; This can be useful to work around memory leaks in 3rd party libraries. For
124
; endless request processing specify '0'. Equivalent to PHP_FCGI_MAX_REQUESTS.
125
; Default Value: 0
126
;pm.max_requests = 500
127

128
; The URI to view the FPM status page. If this value is not set, no URI will be
129
; recognized as a status page. It shows the following informations:
130
;   pool                 - the name of the pool;
131
;   process manager      - static, dynamic or ondemand;
132
;   start time           - the date and time FPM has started;
133
;   start since          - number of seconds since FPM has started;
134
;   accepted conn        - the number of request accepted by the pool;
135
;   listen queue         - the number of request in the queue of pending
136
;                          connections (see backlog in listen(2));
137
;   max listen queue     - the maximum number of requests in the queue
138
;                          of pending connections since FPM has started;
139
;   listen queue len     - the size of the socket queue of pending connections;
140
;   idle processes       - the number of idle processes;
141
;   active processes     - the number of active processes;
142
;   total processes      - the number of idle + active processes;
143
;   max active processes - the maximum number of active processes since FPM
144
;                          has started;
145
;   max children reached - number of times, the process limit has been reached,
146
;                          when pm tries to start more children (works only for
147
;                          pm 'dynamic' and 'ondemand');
148
; Value are updated in real time.
149
; Example output:
150
;   pool:                 www
151
;   process manager:      static
152
;   start time:           01/Jul/2011:17:53:49 +0200
153
;   start since:          62636
154
;   accepted conn:        190460
155
;   listen queue:         0
156
;   max listen queue:     1
157
;   listen queue len:     42
158
;   idle processes:       4
159
;   active processes:     11
160
;   total processes:      15
161
;   max active processes: 12
162
;   max children reached: 0
163
;
164
; By default the status page output is formatted as text/plain. Passing either
165
; 'html', 'xml' or 'json' in the query string will return the corresponding
166
; output syntax. Example:
167
;   http://www.foo.bar/status
168
;   http://www.foo.bar/status?json
169
;   http://www.foo.bar/status?html
170
;   http://www.foo.bar/status?xml
171
;
172
; By default the status page only outputs short status. Passing 'full' in the
173
; query string will also return status for each pool process.
174
; Example:
175
;   http://www.foo.bar/status?full
176
;   http://www.foo.bar/status?json&full
177
;   http://www.foo.bar/status?html&full
178
;   http://www.foo.bar/status?xml&full
179
; The Full status returns for each process:
180
;   pid                  - the PID of the process;
181
;   state                - the state of the process (Idle, Running, ...);
182
;   start time           - the date and time the process has started;
183
;   start since          - the number of seconds since the process has started;
184
;   requests             - the number of requests the process has served;
185
;   request duration     - the duration in µs of the requests;
186
;   request method       - the request method (GET, POST, ...);
187
;   request URI          - the request URI with the query string;
188
;   content length       - the content length of the request (only with POST);
189
;   user                 - the user (PHP_AUTH_USER) (or '-' if not set);
190
;   script               - the main script called (or '-' if not set);
191
;   last request cpu     - the %cpu the last request consumed
192
;                          it's always 0 if the process is not in Idle state
193
;                          because CPU calculation is done when the request
194
;                          processing has terminated;
195
;   last request memory  - the max amount of memory the last request consumed
196
;                          it's always 0 if the process is not in Idle state
197
;                          because memory calculation is done when the request
198
;                          processing has terminated;
199
; If the process is in Idle state, then informations are related to the
200
; last request the process has served. Otherwise informations are related to
201
; the current request being served.
202
; Example output:
203
;   ************************
204
;   pid:                  31330
205
;   state:                Running
206
;   start time:           01/Jul/2011:17:53:49 +0200
207
;   start since:          63087
208
;   requests:             12808
209
;   request duration:     1250261
210
;   request method:       GET
211
;   request URI:          /test_mem.php?N=10000
212
;   content length:       0
213
;   user:                 -
214
;   script:               /home/fat/web/docs/php/test_mem.php
215
;   last request cpu:     0.00
216
;   last request memory:  0
217
;
218
; Note: There is a real-time FPM status monitoring sample web page available
219
;       It's available in: ${prefix}/share/fpm/status.html
220
;
221
; Note: The value must start with a leading slash (/). The value can be
222
;       anything, but it may not be a good idea to use the .php extension or it
223
;       may conflict with a real PHP file.
224
; Default Value: not set
225
;pm.status_path = /status
226

227
; The ping URI to call the monitoring page of FPM. If this value is not set, no
228
; URI will be recognized as a ping page. This could be used to test from outside
229
; that FPM is alive and responding, or to
230
; - create a graph of FPM availability (rrd or such);
231
; - remove a server from a group if it is not responding (load balancing);
232
; - trigger alerts for the operating team (24/7).
233
; Note: The value must start with a leading slash (/). The value can be
234
;       anything, but it may not be a good idea to use the .php extension or it
235
;       may conflict with a real PHP file.
236
; Default Value: not set
237
;ping.path = /ping
238

239
; This directive may be used to customize the response of a ping request. The
240
; response is formatted as text/plain with a 200 response code.
241
; Default Value: pong
242
;ping.response = pong
243

244
; The access log file
245
; Default: not set
246
;access.log = log/$pool.access.log
247

248
; The access log format.
249
; The following syntax is allowed
250
;  %%: the '%' character
251
;  %C: %CPU used by the request
252
;      it can accept the following format:
253
;      - %{user}C for user CPU only
254
;      - %{system}C for system CPU only
255
;      - %{total}C  for user + system CPU (default)
256
;  %d: time taken to serve the request
257
;      it can accept the following format:
258
;      - %{seconds}d (default)
259
;      - %{miliseconds}d
260
;      - %{mili}d
261
;      - %{microseconds}d
262
;      - %{micro}d
263
;  %e: an environment variable (same as $_ENV or $_SERVER)
264
;      it must be associated with embraces to specify the name of the env
265
;      variable. Some exemples:
266
;      - server specifics like: %{REQUEST_METHOD}e or %{SERVER_PROTOCOL}e
267
;      - HTTP headers like: %{HTTP_HOST}e or %{HTTP_USER_AGENT}e
268
;  %f: script filename
269
;  %l: content-length of the request (for POST request only)
270
;  %m: request method
271
;  %M: peak of memory allocated by PHP
272
;      it can accept the following format:
273
;      - %{bytes}M (default)
274
;      - %{kilobytes}M
275
;      - %{kilo}M
276
;      - %{megabytes}M
277
;      - %{mega}M
278
;  %n: pool name
279
;  %o: ouput header
280
;      it must be associated with embraces to specify the name of the header:
281
;      - %{Content-Type}o
282
;      - %{X-Powered-By}o
283
;      - %{Transfert-Encoding}o
284
;      - ....
285
;  %p: PID of the child that serviced the request
286
;  %P: PID of the parent of the child that serviced the request
287
;  %q: the query string
288
;  %Q: the '?' character if query string exists
289
;  %r: the request URI (without the query string, see %q and %Q)
290
;  %R: remote IP address
291
;  %s: status (response code)
292
;  %t: server time the request was received
293
;      it can accept a strftime(3) format:
294
;      %d/%b/%Y:%H:%M:%S %z (default)
295
;  %T: time the log has been written (the request has finished)
296
;      it can accept a strftime(3) format:
297
;      %d/%b/%Y:%H:%M:%S %z (default)
298
;  %u: remote user
299
;
300
; Default: "%R - %u %t \"%m %r\" %s"
301
;access.format = "%R - %u %t \"%m %r%Q%q\" %s %f %{mili}d %{kilo}M %C%%"
302

303
; The log file for slow requests
304
; Default Value: not set
305
; Note: slowlog is mandatory if request_slowlog_timeout is set
306
;slowlog = log/$pool.log.slow
307

308
; The timeout for serving a single request after which a PHP backtrace will be
309
; dumped to the 'slowlog' file. A value of '0s' means 'off'.
310
; Available units: s(econds)(default), m(inutes), h(ours), or d(ays)
311
; Default Value: 0
312
;request_slowlog_timeout = 0
313

314
; The timeout for serving a single request after which the worker process will
315
; be killed. This option should be used when the 'max_execution_time' ini option
316
; does not stop script execution for some reason. A value of '0' means 'off'.
317
; Available units: s(econds)(default), m(inutes), h(ours), or d(ays)
318
; Default Value: 0
319
;request_terminate_timeout = 0
320

321
; Set open file descriptor rlimit.
322
; Default Value: system defined value
323
;rlimit_files = 1024
324

325
; Set max core size rlimit.
326
; Possible Values: 'unlimited' or an integer greater or equal to 0
327
; Default Value: system defined value
328
;rlimit_core = 0
329

330
; Chroot to this directory at the start. This value must be defined as an
331
; absolute path. When this value is not set, chroot is not used.
332
; Note: you can prefix with '$prefix' to chroot to the pool prefix or one
333
; of its subdirectories. If the pool prefix is not set, the global prefix
334
; will be used instead.
335
; Note: chrooting is a great security feature and should be used whenever
336
;       possible. However, all PHP paths will be relative to the chroot
337
;       (error_log, sessions.save_path, ...).
338
; Default Value: not set
339
;chroot =
340

341
; Chdir to this directory at the start.
342
; Note: relative path can be used.
343
; Default Value: current directory or / when chroot
344
chdir = /
345

346
; Redirect worker stdout and stderr into main error log. If not set, stdout and
347
; stderr will be redirected to /dev/null according to FastCGI specs.
348
; Note: on highloaded environement, this can cause some delay in the page
349
; process time (several ms).
350
; Default Value: no
351
;catch_workers_output = yes
352

353
; Limits the extensions of the main script FPM will allow to parse. This can
354
; prevent configuration mistakes on the web server side. You should only limit
355
; FPM to .php extensions to prevent malicious users to use other extensions to
356
; exectute php code.
357
; Note: set an empty value to allow all extensions.
358
; Default Value: .php
359
;security.limit_extensions = .php .php3 .php4 .php5
360

361
; Pass environment variables like LD_LIBRARY_PATH. All $VARIABLEs are taken from
362
; the current environment.
363
; Default Value: clean env
364
;env[HOSTNAME] = $HOSTNAME
365
;env[PATH] = /usr/local/bin:/usr/bin:/bin
366
;env[TMP] = /tmp
367
;env[TMPDIR] = /tmp
368
;env[TEMP] = /tmp
369

370
; Additional php.ini defines, specific to this pool of workers. These settings
371
; overwrite the values previously defined in the php.ini. The directives are the
372
; same as the PHP SAPI:
373
;   php_value/php_flag             - you can set classic ini defines which can
374
;                                    be overwritten from PHP call 'ini_set'.
375
;   php_admin_value/php_admin_flag - these directives won't be overwritten by
376
;                                     PHP call 'ini_set'
377
; For php_*flag, valid values are on, off, 1, 0, true, false, yes or no.
378

379
; Defining 'extension' will load the corresponding shared extension from
380
; extension_dir. Defining 'disable_functions' or 'disable_classes' will not
381
; overwrite previously defined php.ini values, but will append the new value
382
; instead.
383

384
; Note: path INI options can be relative and will be expanded with the prefix
385
; (pool, global or /usr)
386

387
; Default Value: nothing is defined by default except the values in php.ini and
388
;                specified at startup with the -d argument
389
;php_admin_value[sendmail_path] = /usr/sbin/sendmail -t -i -f [email protected]
390
;php_flag[display_errors] = off
391
;php_admin_value[error_log] = /var/log/fpm-php.www.log
392
;php_admin_flag[log_errors] = on
393
;php_admin_value[memory_limit] = 32M

1
#!/bin/sh /etc/rc.common
2

3
START=50
4

5
PROG=/usr/bin/php-fpm
6
CONFIG=/etc/php7-fpm.conf
7
#CONFIG=/etc/php7-fdm.d/www.conf
8

9
SERVICE_PID_FILE=/var/run/php7-fpm.pid
10

11
start_instance() {
12
  local section="$1"
13
  local enabled
14

15
  config_get_bool enabled "$section" 'enabled' 0
16

17
  [ $enabled -gt 0 ] || return 1
18

19
  service_start $PROG -y $CONFIG -g $SERVICE_PID_FILE -R
20
}
21

22
start() {
23
  config_load 'php7-fpm'
24
  config_foreach start_instance 'php7-fpm'
25
}
26

27
stop() {
28
  service_stop $PROG
29
}