Como otimizar PHP-FPM do zero em 20 minutos no Ubuntu 22.04

11 min de leitura  ·  Guia técnico

Otimizar PHP-FPM é o processo de ajustar configurações de pool, memória e processos para maximizar performance e estabilidade. Para otimizar do zero, siga estes passos:

1. Verificar versão atual e status do PHP-FPM
2. Calcular recursos disponíveis de memória RAM
3. Configurar pool manager e limites de processos
4. Ajustar timeouts e configurações de segurança
5. Testar e monitorar performance após mudanças
6. Implementar logs e status page para acompanhamento

Pré-requisitos

• Ubuntu 22.04 LTS com acesso root ou sudo
• PHP-FPM 8.1 ou superior instalado
• Mínimo 2GB de RAM disponível
• Conhecimento básico de linha de comando Linux
• Backup das configurações atuais antes de modificar

Verificando status atual do PHP-FPM no sistema

Antes de otimizar PHP-FPM, é essencial verificar a versão instalada e o status atual do serviço. Esta análise inicial fornece dados fundamentais para as configurações que serão aplicadas.

Primeiro, verifique qual versão do PHP-FPM está rodando:

php-fpm8.1 -v

PHP 8.1.2-1ubuntu2.14 (fpm-fcgi) (built: Aug 18 2023 11:41:11)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies

Confirme se o serviço está ativo:

systemctl status php8.1-fpm

Verifique o consumo atual de memória por processo:

ps aux | grep php-fpm | grep -v grep

www-data  1234  0.1  2.3  45672  23456 ?  S  10:30  0:01 php-fpm: pool www
www-data  1235  0.0  2.1  44532  21234 ?  S  10:30  0:00 php-fpm: pool www

Identifique o arquivo de configuração principal:

find /etc -name "php.ini" -type f 2>/dev/null
find /etc -name "*fpm*" -type d 2>/dev/null

Calculando recursos de memória disponível

O dimensionamento correto dos recursos é crucial para configurar PHP-FPM adequadamente. Calcular a memória disponível evita sobrecarga do sistema e garante estabilidade durante picos de tráfego.

Verifique a memória total do sistema:

free -h

              total        used        free      shared  buff/cache   available
Mem:           4.0Gi       1.2Gi       1.8Gi        12Mi       1.0Gi       2.6Gi
Swap:          2.0Gi          0B       2.0Gi

Calcule o consumo médio por processo PHP-FPM:

ps --no-headers -o "rss,cmd" -C php-fpm8.1 | awk '{ sum+=$1 } END { printf "%.0f MB\n", sum/1024 }'

Para determinar o número máximo de processos seguros, use esta fórmula:

echo "Memória disponível: $(free -m | awk 'NR==2{printf "%.0f MB", $7}')"
echo "Processos recomendados: $(($(free -m | awk 'NR==2{print $7}') * 70 / 100 / 30))"

Memória disponível: 2600 MB
Processos recomendados: 60

Atenção: Reserve sempre 30% da RAM para sistema operacional e outros serviços. Nunca use 100% da memória para PHP-FPM.

Configurando pool manager e otimizações de processo

A configuração do pool manager determina como o PHP-FPM gerencia processos filhos. Ajustar estes parâmetros corretamente é fundamental para balancear performance e uso de recursos.

Faça backup da configuração atual:

cp /etc/php/8.1/fpm/pool.d/www.conf /etc/php/8.1/fpm/pool.d/www.conf.backup

Edite o arquivo de configuração principal:

nano /etc/php/8.1/fpm/pool.d/www.conf

Localize e modifique as seguintes configurações para um servidor com 4GB de RAM:

; Modo de gerenciamento de processos
pm = dynamic

; Número máximo de processos filhos
pm.max_children = 60

; Processos iniciados na inicialização
pm.start_servers = 15

; Mínimo de processos ociosos
pm.min_spare_servers = 10

; Máximo de processos ociosos
pm.max_spare_servers = 25

; Máximo de requisições por processo
pm.max_requests = 1000

Para servidores com alta carga constante, considere usar pm.static:

; Para alta carga constante
pm = static
pm.max_children = 40

Adicione configurações de monitoramento:

; Habilita página de status
pm.status_path = /fpm-status

; Habilita página de ping
ping.path = /fpm-ping

Ajustando timeouts e configurações de segurança

Configurar timeouts adequados previne processos travados e melhora a responsividade geral. As configurações de segurança protegem contra ataques e uso inadequado de recursos.

Configure timeouts no arquivo de pool:

; Timeout para requisições (30 segundos)
request_terminate_timeout = 30

; Timeout para finalização lenta (10 segundos)
request_slowlog_timeout = 10

; Log de requisições lentas
slowlog = /var/log/php8.1-fpm-slow.log

Ajuste configurações de segurança:

; Limita acesso apenas ao localhost
listen.allowed_clients = 127.0.0.1

; Define usuário e grupo
user = www-data
group = www-data

; Configurações de socket
listen.owner = www-data
listen.group = www-data
listen.mode = 0660

Configure variáveis de ambiente essenciais:

; Limpa ambiente por segurança
clear_env = yes

; Variáveis permitidas
env[HOSTNAME] = $HOSTNAME
env[PATH] = /usr/local/bin:/usr/bin:/bin
env[TMP] = /tmp
env[TMPDIR] = /tmp
env[TEMP] = /tmp

Valide a configuração antes de aplicar:

php-fpm8.1 -t

[18-Nov-2023 15:30:45] NOTICE: configuration file /etc/php/8.1/fpm/php-fpm.conf test is successful

Implementando logs e monitoramento de performance

Configurar logs detalhados e ferramentas de monitoramento permite identificar gargalos e ajustar configurações baseado em dados reais de uso.

Configure logs detalhados no arquivo principal:

nano /etc/php/8.1/fpm/php-fpm.conf

Adicione configurações de log:

; Nível de log (alert, error, warning, notice, debug)
log_level = notice

; Arquivo de log principal
error_log = /var/log/php8.1-fpm.log

; Log de emergência
emergency_restart_threshold = 10
emergency_restart_interval = 1m

; Limite de core dump
rlimit_core = 0

Configure rotação de logs:

nano /etc/logrotate.d/php8.1-fpm

/var/log/php8.1-fpm*.log {
    daily
    missingok
    rotate 52
    compress
    delaycompress
    notifempty
    create 640 www-data adm
    postrotate
        systemctl reload php8.1-fpm
    endscript
}

Crie script de monitoramento básico:

nano /usr/local/bin/php-fpm-monitor.sh

#!/bin/bash
echo "=== PHP-FPM Status $(date) ==="
systemctl is-active php8.1-fpm
echo "Processos ativos:"
ps aux | grep php-fpm | grep -v grep | wc -l
echo "Uso de memória:"
ps aux | grep php-fpm | grep -v grep | awk '{sum+=$6} END {printf "%.2f MB\n", sum/1024}'

Torne o script executável:

chmod +x /usr/local/bin/php-fpm-monitor.sh

Testando e aplicando configurações otimizadas

Após configurar todas as otimizações, é crucial testar as mudanças em ambiente controlado antes de aplicar em produção. Este processo garante estabilidade e identifica possíveis problemas.

Recarregue as configurações sem interromper o serviço:

systemctl reload php8.1-fpm

Verifique se o reload foi bem-sucedido:

systemctl status php8.1-fpm

● php8.1-fpm.service - The PHP 8.1 FastCGI Process Manager
     Loaded: loaded (/lib/systemd/system/php8.1-fpm.service; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2023-11-18 15:35:22 UTC; 2min ago

Teste a página de status se configurada:

curl http://localhost/fpm-status

Execute teste de carga básico para validar performance:

ab -n 1000 -c 10 http://localhost/

Monitore o uso de recursos durante o teste:

watch -n 1 'ps aux | grep php-fpm | grep -v grep | wc -l && free -h'

Para aplicações WordPress, teste com:

curl -w "@curl-format.txt" -o /dev/null -s http://localhost/wp-admin/

Onde curl-format.txt contém:

time_namelookup:  %{time_namelookup}\n
time_connect:     %{time_connect}\n
time_appconnect:  %{time_appconnect}\n
time_pretransfer: %{time_pretransfer}\n
time_redirect:    %{time_redirect}\n
time_starttransfer: %{time_starttransfer}\n
time_total:       %{time_total}\n

Problemas comuns e como resolver

Erro: "server reached pm.max_children setting"

Causa: O número de processos simultâneos excedeu o limite configurado em pm.max_children.
Solução: Aumente o valor de pm.max_children gradualmente, verificando se há memória suficiente. Monitore com ps aux | grep php-fpm | wc -l durante picos de tráfego.

Erro: "pool www seems busy (you may need to increase pm.start_servers)"

Causa: Poucos processos iniciais para atender a demanda, causando fila de espera.
Solução: Aumente pm.start_servers para 25% do pm.max_children. Para 60 processos máximos, use pm.start_servers = 15.

Alto uso de memória mesmo com poucos acessos

Causa: Configuração pm.static com muitos processos ou vazamentos de memória em aplicações PHP.
Solução: Mude para pm.dynamic e reduza pm.max_requests para 500-1000. Investigue vazamentos com ferramentas como Xdebug profiler.

Timeouts frequentes em requisições

Causa: request_terminate_timeout muito baixo ou consultas lentas ao banco de dados.
Solução: Aumente request_terminate_timeout para 60-120 segundos. Otimize consultas SQL e considere usar cache como Redis. Para mais detalhes sobre configuração de servidores, consulte Dicas de Otimização de Servidores Linux.

Perguntas frequentes sobre otimizar PHP-FPM

Qual a diferença entre pm.dynamic e pm.static no PHP-FPM?

pm.static mantém um número fixo de processos sempre ativos, consumindo mais memória mas oferecendo resposta mais rápida. pm.dynamic ajusta o número de processos conforme a demanda, economizando memória mas com pequena latência na criação de novos processos.

Como saber se o PHP-FPM está consumindo muita memória?

Use o comando 'ps aux | grep php-fpm' para ver o uso de memória por processo. Multiplique o número de processos pelo consumo médio de cada um. Se ultrapassar 70% da RAM disponível, ajuste os valores de pm.max_children e pm.start_servers.

É seguro reiniciar o PHP-FPM em produção?

Sim, o PHP-FPM suporta reload graceful com 'systemctl reload php8.1-fpm'. Isso recarrega as configurações sem derrubar conexões ativas. Use 'systemctl restart' apenas se houver problemas que o reload não resolve.

Qual o valor ideal para pm.max_children?

Divida a RAM disponível pelo consumo médio de cada processo PHP-FPM (geralmente 20-50MB). Para um servidor com 4GB, com processos de 30MB cada, o ideal seria cerca de 130 processos. Sempre deixe margem para o sistema operacional.

Como monitorar a performance do PHP-FPM após otimização?

Habilite o status page do PHP-FPM e monitore métricas como 'slow requests', 'listen queue' e 'active processes'. Use ferramentas como htop para acompanhar uso de CPU e memória em tempo real.

Conclusão

• Configure pm.max_children baseado na memória disponível, reservando 30% para o sistema operacional
• Use pm.dynamic para a maioria dos casos e pm.static apenas para alta carga constante
• Implemente monitoramento contínuo com logs detalhados e status page para ajustes futuros

Leia também

• Otimizar cache Redis para aplicações PHP no Ubuntu 22.04
• Otimizar MySQL: como reduzir uso de memória e acelerar consultas
• Entenda o que é Swap no Linux: como funciona e quando usar

Precisa de ajuda com otimização de servidor?

Nossa equipe especializada pode configurar e otimizar seu ambiente PHP-FPM para máxima performance. Oferecemos suporte técnico completo para servidores VPS Linux.

Conheça nossos planos de VPS otimizados