0

j'ai fpm-php.www.log fichier à l'intérieur / var / log. Mais ce ne sont pas des erreurs de journalisation.
J'ai défini 777 autorisations pour fpm-php.www.log les autorisations de fichier et de propriété sont www-data www-data.

ma www.conf fichier ressemble à ce qui est à l'intérieur /etc/php5/fpm/pool.d

; Démarrer un nouveau pool nommé 'www'.
; la variable $ pool peut-on utiliser dans une directive et sera remplacée par la
; nom de la piscine ('www' ici)
[www]

; Préfixe par pool
; Il ne s'applique qu'aux directives suivantes:
; - 'access.log'
; - 'slowlog'
; - 'écouter' (unixsocket)
; - chroot
; - 'chdir'
; - 'php_values'
; - 'php_admin_values'
; Lorsqu'il n'est pas défini, le préfixe global (ou / usr) s'applique à la place.
; Remarque: Cette directive peut également être relative au préfixe global.
; Valeur par défaut: aucune
; préfixe = / chemin / vers / pools / $ pool

; Unix utilisateur / groupe de processus
; Remarque: l'utilisateur est obligatoire Si le groupe n'est pas défini, le groupe d'utilisateurs par défaut
; sera utilisé.
user = www-data
group = www-data

; L'adresse sur laquelle accepter les requêtes FastCGI.
; Les syntaxes valides sont les suivantes:
; 'ip.add.re.ss: port' - pour écouter sur une socket TCP une adresse IPv4 spécifique sur
; un port spécifique;
; '[ip:6:addr:ess]: port '- pour écouter sur une socket TCP une adresse IPv6 spécifique sur
; un port spécifique;
; 'port' - pour écouter sur un socket TCP toutes les adresses IPv4 d'un
; port spécifique
; '[::]: port '- pour écouter sur un socket TCP à toutes les adresses
; (IPv6 et IPv4-mappé) sur un port spécifique;
; '/ path / to / unix / socket' - pour écouter sur un socket unix.
; Remarque: cette valeur est obligatoire.
listen = /var/run/php5-fpm.sock

; Définissez backlog listen (2).
; Valeur par défaut: 65535 (-1 sur FreeBSD et OpenBSD)
; listen.backlog = 65535

; Définissez les autorisations pour le socket unix, s'il en existe un. Sous Linux, lecture / écriture
; des autorisations doivent être définies pour autoriser les connexions à partir d'un serveur Web. Beaucoup
; Les systèmes dérivés de BSD permettent des connexions indépendamment des autorisations.
; Valeurs par défaut: l'utilisateur et le groupe sont définis comme utilisateur en cours d'exécution
; le mode est réglé sur 0660
listen.owner = www-data
listen.group = www-data
listen.mode = 0660

; Liste d'adresses (IPv4 / IPv6) des clients FastCGI autorisés à se connecter.
; Équivalent à la variable d'environnement FCGI_WEB_SERVER_ADDRS dans l'original
; PHP FCGI (5.2.2+). Fait sens seulement avec une prise d'écoute de tcp. Chaque adresse
; doit être séparé par une virgule. Si cette valeur est laissée vide, les connexions seront
; accepté de n'importe quelle adresse IP.
; Valeur par défaut: any
; listen.allowed_clients = 127.0.0.1

; Indiquez la priorité nice (2) à appliquer aux processus de pool (uniquement si défini)
; La valeur peut varier de -19 (priorité la plus élevée) à 20 (priorité inférieure)
; Remarque: - Cela ne fonctionnera que si le processus principal FPM est lancé en tant que root
; - Les processus du pool hériteront de la priorité du processus maître
; sauf indication contraire
; Valeur par défaut: aucun ensemble
; process.priority = -19

; Choisissez comment le gestionnaire de processus contrôlera le nombre de processus enfants.
; Valeurs possibles:
; static - un nombre fixe (pm.max_children) de processus enfants;
; dynamic - le nombre de processus enfants est défini dynamiquement en fonction de
; directives suivantes. Avec cette gestion de processus, il y aura
; toujours au moins 1 enfant.
; pm.max_children - le nombre maximum d'enfants qui peuvent
; être en vie en même temps.
; pm.start_servers - le nombre d'enfants créés au démarrage.
; pm.min_spare_servers - le nombre minimum d'enfants dans «inactif»
; état (en attente de traitement). Si le nombre
; des processus «inactifs» est moins que cela
; nombre alors certains enfants seront créés.
; pm.max_spare_servers - le nombre maximum d'enfants dans 'inactif'
; état (en attente de traitement). Si le nombre
; des processus «inactifs» est plus grand que cela
; nombre alors certains enfants seront tués.
; ondemand - aucun enfant n'est créé au démarrage. Les enfants seront fourchus quand
; les nouvelles demandes se connecteront. Les paramètres suivants sont utilisés:
; pm.max_children - le nombre maximum d'enfants que
; peut être vivant en même temps.
; pm.process_idle_timeout - Le nombre de secondes après lequel
; un processus inactif sera tué.
; Remarque: cette valeur est obligatoire.
pm = dynamique

; Le nombre de processus enfants à créer lorsque pm est défini sur "static" et le
; nombre maximal de processus enfants lorsque pm est défini sur 'dynamic' ou 'ondemand'.
; Cette valeur définit la limite du nombre de requêtes simultanées qui seront
; servi. Équivalent à la directive ApacheMaxClients avec mpm_prefork.
; Équivalent à la variable d'environnement PHP_FCGI_CHILDREN dans le PHP d'origine
; CGI. Les valeurs par défaut ci-dessous sont basées sur un serveur sans beaucoup de ressources. Ne pas
; oubliez de peaufiner pm. * pour répondre à vos besoins.
; Remarque: Utilisé lorsque pm est défini sur "static", "dynamic" ou "ondemand"
; Remarque: cette valeur est obligatoire.
pm.max_children = 55

; Nombre de processus enfants créés au démarrage.
; Remarque: Utilisé uniquement lorsque pm est défini sur 'dynamic'
; Valeur par défaut: min_spare_servers + (max_spare_servers - min_spare_servers) / 2
pm.start_servers = 20

; Le nombre minimum souhaité de processus de serveur inactif.
; Remarque: Utilisé uniquement lorsque pm est défini sur 'dynamic'
; Remarque: Obligatoire lorsque pm est défini sur «dynamique»
pm.min_spare_servers = 10

; Le nombre maximal de processus serveur inactif souhaité.
; Remarque: Utilisé uniquement lorsque pm est défini sur 'dynamic'
; Remarque: Obligatoire lorsque pm est défini sur «dynamique»
pm.max_spare_servers = 30

; Nombre de secondes après lesquelles un processus inactif sera tué.
; Remarque: Utilisé uniquement lorsque pm est défini sur "ondemand"
; Valeur par défaut: 10s
; pm.process_idle_timeout = 10s;

; Le nombre de requêtes que chaque processus enfant doit exécuter avant de réapparaître.
; Cela peut être utile pour contourner les fuites de mémoire dans les bibliothèques tierces. Pour
; le traitement de demande sans fin spécifie «0». Équivalent à PHP_FCGI_MAX_REQUESTS.
; Valeur par défaut: 0
; pm.max_requests = 500

; L'URI pour afficher la page d'état FPM. Si cette valeur n'est pas définie, aucun URI ne sera
; reconnu comme une page d'état. Il montre les informations suivantes:
; pool - le nom du pool;
; gestionnaire de processus - statique, dynamique ou ondemand;
; heure de début - date et heure de début de FPM;
; start since - nombre de secondes écoulées depuis le démarrage de FPM;
; accept conn - le numéro de demande accepté par le pool;
; écouter la file d'attente - le nombre de demandes dans la file d'attente en attente
; connexions (voir l'arriéré dans listen (2));
; max listen queue - le nombre maximum de requêtes dans la file d'attente
; des connexions en attente depuis le démarrage de FPM;
; écouter la file d'attente len - la taille de la file d'attente des connexions en attente;
; processus inactifs - nombre de processus inactifs;
; processus actifs - le nombre de processus actifs;
; processus total - nombre de processus inactifs + actifs;
; Nombre maximal de processus actifs: nombre maximal de processus actifs depuis FPM
; a commencé;
; max enfants atteint - nombre de fois, la limite du processus a été atteinte,
; quand pm essaie de démarrer plus d'enfants (fonctionne seulement pour
; pm 'dynamique' et 'ondemand');
; La valeur est mise à jour en temps réel.
; Exemple de sortie:
; piscine: www
; gestionnaire de processus: statique
; heure de début: 01 / Jul / 2011: 17: 53: 49 +0200
; commence depuis: 62636
; prise acceptée: 190460
; écouter la file d'attente: 0
; file d'attente maximum d'écoute: 1
; écouter la file d'attente len: 42
; processus inactifs: 4
; processus actifs: 11
; total des processus: 15
; processus actifs maximum: 12
; max enfants atteint: 0
;
; Par défaut, la sortie de la page d'état est mise en forme sous la forme text / plain. En passant soit
; 'html', 'xml' ou 'json' dans la chaîne de requête renverra le
; syntaxe de sortie. Exemple:
; http://www.foo.bar/status
; http://www.foo.bar/status?json
; http://www.foo.bar/status?html
; http://www.foo.bar/status?xml
;
; Par défaut, la page d'état ne génère que des états courts. Passage 'full' dans le
; La chaîne de requête renverra également le statut de chaque processus de pool.
; Exemple:
; http://www.foo.bar/status?full
; http://www.foo.bar/status?json&full
; http://www.foo.bar/status?html&full
; http://www.foo.bar/status?xml&full
; Le statut complet renvoie à chaque processus:
; pid - le PID du processus;
; state - l'état du processus (Idle, Running, ...);
; heure de début - date et heure de début du processus;
; start since - le nombre de secondes écoulées depuis le début du processus;
; demandes - le nombre de demandes que le processus a traitées;
; durée de la demande - la durée en µs des requêtes;
; méthode de requête - la méthode de requête (GET, POST, ...);
; demande URI - l'URI de requête avec la chaîne de requête;
; longueur du contenu - la longueur du contenu de la demande (uniquement avec POST);
; user - l'utilisateur (PHP_AUTH_USER) (ou '-' s'il n'est pas défini);
; script - le script principal appelé (ou '-' s'il n'est pas défini);
; dernière demande cpu - le% cpu la dernière demande consommée
; il est toujours à 0 si le processus n'est pas en mode veille
; parce que le calcul du processeur est fait lorsque la demande
; le traitement est terminé;
; last request memory - la quantité maximale de mémoire consommée par la dernière requête
; il est toujours à 0 si le processus n'est pas en mode veille
; parce que le calcul de la mémoire est fait lorsque la demande
; le traitement est terminé;
; Si le processus est en mode veille, les informations sont liées au
; dernière demande que le processus a servie. Sinon les informations sont liées à
; la demande en cours de traitement.
; Exemple de sortie:
; ************************
; pid: 31330
; état: en cours d'exécution
; heure de début: 01 / Jul / 2011: 17: 53: 49 +0200
; à partir de: 63087
; requêtes: 12808
; durée de la demande: 1250261
; méthode de demande: GET
; demande URI: /test_mem.php?N=10000
; longueur du contenu: 0
; utilisateur: -
; script: /home/fat/web/docs/php/test_mem.php
; dernière demande cpu: 0.00
; dernière mémoire de demande: 0
;
; Remarque: une page Web d’échantillonnage de l’état du FPM en temps réel est disponible.
; Il est disponible dans: /usr/share/php5/fpm/status.html
;
; Remarque: La valeur doit commencer par une barre oblique (/). La valeur peut être
; quelque chose, mais ce n'est peut-être pas une bonne idée d'utiliser l'extension .php ou
; peut entrer en conflit avec un vrai fichier PHP.
; Valeur par défaut: non défini
; pm.status_path = / status

; L'URI de ping à appeler la page de surveillance de FPM. Si cette valeur n'est pas définie, no
; L'URI sera reconnu comme une page ping. Cela pourrait être utilisé pour tester de l'extérieur
; que FPM est vivant et répond, ou à
; - créer un graphique de la disponibilité FPM (rrd ou tel);
; - supprimer un serveur d'un groupe s'il ne répond pas (équilibrage de la charge);
; - déclencher des alertes pour l'équipe d'exploitation (24/7).
; Remarque: La valeur doit commencer par une barre oblique (/). La valeur peut être
; quelque chose, mais ce n'est peut-être pas une bonne idée d'utiliser l'extension .php ou
; peut entrer en conflit avec un vrai fichier PHP.
; Valeur par défaut: non défini
; ping.path = / ping

; Cette directive peut être utilisée pour personnaliser la réponse à une requête ping. le
; la réponse est formatée en text / plain avec un code de 200 réponses.
; Valeur par défaut: pong
; ping.response = pong

; Le fichier journal d'accès
; Par défaut: pas défini
; access.log = log / $ pool.access.log

; Le format du journal d'accès
; La syntaxe suivante est autorisée
; %%: le personnage
; % C:% CPU utilisé par la requête
; il peut accepter le format suivant:
; -% {utilisateur} C pour le processeur utilisateur uniquement
; -% {system} C uniquement pour le processeur système
; -% {total} C pour utilisateur + CPU du système (par défaut)
; % d: délai de traitement de la demande
; il peut accepter le format suivant:
; -% {secondes} d (par défaut)
; -% {millisecondes} d
; -% {mili} d
; -% {microsecondes} d
; -% {micro} d
; % e: une variable d'environnement (identique à $ _ENV ou $ _SERVER)
; il doit être associé à embraces pour spécifier le nom de l'env
; variable. Quelques exemples:
; - les spécificités du serveur comme:% {REQUEST_METHOD} e ou% {SERVER_PROTOCOL} e
; - les en-têtes HTTP comme:% {HTTP_HOST} e ou% {HTTP_USER_AGENT} e
; % f: nom de fichier du script
; % l: longueur du contenu de la demande (uniquement pour les requêtes POST)
; % m: méthode de demande
; % M: crête de mémoire allouée par PHP
; il peut accepter le format suivant:
; -% {octets} M (par défaut)
; -% {kilobytes} M
; -% {kilo} M
; -% {mégaoctets} M
; -% {mega} M
; % n: nom du pool
; % o: en-tête de sortie
; il doit être associé à des embrassements pour spécifier le nom de l'en-tête:
; -% {Content-Type} o
; -% {X-Powered-By} o
; -% {Transfert-Encoding} o
; - ....
; % p: PID de l'enfant qui a traité la demande
; % P: PID du parent de l'enfant qui a traité la demande
; % q: la chaîne de requête
; % Q: le '?' caractère si la chaîne de requête existe
; % r: l'URI de la requête (sans la chaîne de requête, voir% q et% Q)
; % R: adresse IP distante
; % s: status (code de réponse)
; % t: heure du serveur à laquelle la demande a été reçue
; il peut accepter un format strftime (3):
; % d /% b /% Y:% H:% M:% S% z (par défaut)
; % T: heure à laquelle le journal a été écrit (la demande est terminée)
; il peut accepter un format strftime (3):
; % d /% b /% Y:% H:% M:% S% z (par défaut)
; % u: utilisateur distant
;
; Valeur par défaut: "% R -% u% t "% m% r  "% s"
; access.format = "% R -% u% t "% m% r% Q% q  "% s% f% {mili} d% {kilo} M% C %%"

; Le fichier journal pour les requêtes lentes
; Valeur par défaut: non défini
; Remarque: slowlog est obligatoire si request_slowlog_timeout est défini
; slowlog = log / $ pool.log.slow

; Le délai d'expiration d'une requête unique après laquelle une trace PHP sera
; vidée dans le fichier 'slowlog'. Une valeur de «0» signifie «désactivé».
; Unités disponibles: s (econds) (par défaut), m (inutes), h (ours) ou d (ays)
; Valeur par défaut: 0
; request_slowlog_timeout = 0

; Le délai d'expiration d'une requête unique après laquelle le processus de travail
; être tué. Cette option doit être utilisée lorsque l'option ini 'max_execution_time'
; n'arrête pas l'exécution du script pour une raison quelconque. Une valeur de «0» signifie «désactivé».
; Unités disponibles: s (econds) (par défaut), m (inutes), h (ours) ou d (ays)
; Valeur par défaut: 0
; request_terminate_timeout = 0

; Définissez le descripteur de fichier ouvert rlimit.
; Valeur par défaut: valeur définie par le système
; rlimit_files = 1024

; Définit la taille de noyau max rlimit.
; Valeurs possibles: 'illimité' ou un entier supérieur ou égal à 0
; Valeur par défaut: valeur définie par le système
; rlimit_core = 0

; Chroot dans ce répertoire au début. Cette valeur doit être définie comme un
; chemin absolu. Lorsque cette valeur n'est pas définie, chroot n'est pas utilisé.
; Note: vous pouvez préfixer '$ prefix' pour chrooter sur le préfixe du pool ou un
; de ses sous-répertoires. Si le préfixe de pool n'est pas défini, le préfixe global
; sera utilisé à la place.
; Remarque: le chrooting est une fonctionnalité de sécurité géniale et doit être utilisé chaque fois que
; possible. Cependant, tous les chemins PHP seront relatifs au chroot
; (error_log, sessions.save_path, ...).
; Valeur par défaut: non défini
chroot =

; Chdir à ce répertoire au début.
; Remarque: le chemin relatif peut être utilisé.
; Valeur par défaut: répertoire en cours ou / quand chroot
chdir = /

; Rediriger le stdout et le stderr du travailleur dans le journal des erreurs principal. Si non défini, stdout et
; stderr sera redirigé vers / dev / null selon les spécifications de FastCGI.
; Remarque: dans un environnement chargé, cela peut retarder la page
; temps de traitement (plusieurs ms).
; Valeur par défaut: non
catch_workers_output = yes

; Environnement clair chez les travailleurs du FPM
; Empêche les variables d'environnement arbitraires d'atteindre les processus de travail FPM
; en nettoyant l’environnement chez les travailleurs avant l’environnement spécifié
; la configuration du pool est ajoutée.
; Mettre à "non" rendra toutes les variables d'environnement disponibles pour le code PHP
; via getenv (), $ _ENV et $ _SERVER.
; Valeur par défaut: oui
; clear_env = no

; Limite les extensions du script principal que FPM permettra d'analyser. Ceci peut
; empêcher les erreurs de configuration du côté du serveur Web. Vous ne devriez limiter que
; FPM vers des extensions .php pour empêcher les utilisateurs malveillants d’utiliser d’autres extensions pour
; code php exectute.
; Remarque: définissez une valeur vide pour autoriser toutes les extensions.
; Valeur par défaut: .php
; security.limit_extensions = .php .php3 .php4 .php5

; Passer des variables d'environnement comme LD_LIBRARY_PATH. Toutes les $ VARIABLES sont extraites de
; l'environnement actuel
; Valeur par défaut: clean env
env[HOSTNAME] = $ HOSTNAME
env[PATH] = / usr / local / bin: / usr / bin: / bin
env[TMP] = / tmp
env[TMPDIR] = / tmp
env[TEMP] = / tmp

; Php.ini supplémentaire définit, spécifique à ce pool de travailleurs. Ces paramètres
; remplacer les valeurs précédemment définies dans le fichier php.ini. Les directives sont les
; identique à PHP SAPI:
; php_value / php_flag - vous pouvez définir des définitions ini classiques qui peuvent
; être remplacé par un appel PHP "ini_set".
; php_admin_value / php_admin_flag - ces directives ne seront pas écrasées par
; Appel PHP 'ini_set'
; Pour le drapeau php_ *, les valeurs valides sont on, off, 1, 0, true, false, yes ou no.

; Définir «extension» chargera l’extension partagée correspondante à partir de
; extension_dir. Définir 'disable_functions' ou 'disable_classes' ne sera pas
; écraser les valeurs php.ini précédemment définies, mais ajoutera la nouvelle valeur
; au lieu.

; Remarque: les options INI du chemin peuvent être relatives et seront étendues avec le préfixe
; (pool, global ou / usr)

; Valeur par défaut: rien n'est défini par défaut sauf les valeurs de php.ini et
; spécifié au démarrage avec l'argument -d
; php_admin_value[sendmail_path] = / usr / sbin / sendmail -t -i -f www@mon.domaine.com
php_flag[display_errors] = sur
php_admin_value[error_log] = /var/log/fpm-php.www.log
php_admin_flag[log_errors] = sur
; php_admin_value[memory_limit] = 32M