PHP consumindo muita RAM: como identificar e reduzir

17 min de leitura  ·  Guia técnico

PHP consumindo muita RAM é um dos problemas mais comuns em servidores de hospedagem e VPS, causado por configurações inadequadas no php.ini, pools PHP-FPM superdimensionados e extensões desnecessárias carregadas em memória. Para identificar e reduzir o consumo de RAM do PHP, siga estes passos:

1. Identifique quais processos PHP estão consumindo mais memória com ps aux
2. Analise as configurações atuais do php.ini e do pool PHP-FPM
3. Ajuste o memory_limit para um valor adequado à aplicação
4. Reduza pm.max_children e parâmetros relacionados no PHP-FPM
5. Desative extensões PHP desnecessárias
6. Configure e ajuste o OPcache corretamente

Pré-requisitos

• Acesso root ou sudo ao servidor (Debian 12, Ubuntu 24.04 LTS, AlmaLinux 9 ou Rocky Linux 9)
• PHP 8.1, 8.2 ou 8.3 instalado com PHP-FPM ativo
• Acesso ao terminal via SSH — veja como em Acessando servidores VPS Linux da AviraHost
• Conhecimento básico de edição de arquivos com nano ou vim
• Servidor com pelo menos 512 MB de RAM (recomendado 1 GB ou mais para ambientes de produção)

PHP consumindo muita RAM: como identificar os processos responsáveis

Antes de qualquer ajuste, é essencial mapear o consumo real de memória pelo PHP no servidor. O diagnóstico correto evita que você altere parâmetros errados e piore a situação.

Execute o comando abaixo para listar todos os processos PHP ordenados pelo maior consumo de memória:

ps aux --sort=-%mem | grep php

www-data  1234  0.0  4.2 512340 43012 ?  S  10:01  0:01 php-fpm: pool www
www-data  1235  0.0  3.8 498120 39204 ?  S  10:01  0:00 php-fpm: pool www
www-data  1236  0.0  3.5 491200 36100 ?  S  10:01  0:00 php-fpm: pool www

A coluna RSS (quarta coluna numérica) mostra o consumo real em kilobytes. Multiplique pelo número de processos ativos para ter o total consumido pelo PHP-FPM.

Para verificar o consumo total de memória do sistema em tempo real, use:

free -h

              total        used        free      shared  buff/cache   available
Mem:           2.0G        1.7G        102M        45M        198M        253M

Se a coluna available estiver abaixo de 200 MB em um servidor de 2 GB, o PHP-FPM provavelmente está com pm.max_children alto demais. Para monitorar em tempo real, filtre o top por processos PHP:

top -p $(pgrep -d',' php-fpm)

Outra forma eficaz de medir o consumo médio por processo PHP é usar o smem, que considera memória compartilhada de forma mais precisa:

smem -r -k | grep php

Com esses dados em mãos, você terá o consumo médio por processo — informação essencial para calcular o valor correto de pm.max_children na próxima etapa.

Ajustando o memory_limit e configurações do php.ini

O parâmetro memory_limit define o máximo de RAM que um único script PHP pode alocar. Valores excessivamente altos permitem que scripts mal otimizados consumam toda a memória disponível do servidor.

Localize o arquivo php.ini ativo com:

php --ini | grep "Loaded Configuration"

Loaded Configuration File:         /etc/php/8.3/fpm/php.ini

Abra o arquivo e localize as diretivas mais impactantes:

nano /etc/php/8.3/fpm/php.ini

Ajuste os seguintes parâmetros conforme o tipo de aplicação:

; Para WordPress simples ou sites institucionais
memory_limit = 128M

; Para WordPress com WooCommerce ou plugins pesados
memory_limit = 256M

; Para Laravel, Symfony ou aplicações complexas
memory_limit = 256M

; Tempo máximo de execução — evita scripts presos em loop
max_execution_time = 30

; Tamanho máximo de upload — não precisa ser alto se não há uploads grandes
upload_max_filesize = 10M
post_max_size = 12M

Além do memory_limit, desative extensões PHP que não são utilizadas pela sua aplicação. Cada extensão carregada consome memória em todos os processos PHP-FPM. Verifique as extensões ativas:

php -m

Para desativar uma extensão no Debian 12 ou Ubuntu 24.04:

phpdismod -v 8.3 -s fpm nome_da_extensao

Extensões comumente desnecessárias em servidores de hospedagem simples incluem ldap, snmp, soap (se não usado), xmlrpc e pspell. Após qualquer alteração no php.ini, recarregue o PHP-FPM:

systemctl reload php8.3-fpm

Otimizando o pool PHP-FPM para reduzir consumo de memória

O gerenciamento de processos do PHP-FPM é o principal fator de consumo de RAM em servidores com múltiplos sites ou alto tráfego. O arquivo de pool padrão fica em:

/etc/php/8.3/fpm/pool.d/www.conf

Abra o arquivo e localize a seção de gerenciamento de processos:

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

A configuração padrão muitas vezes usa o modo static ou dynamic com valores genéricos. Para servidores com RAM limitada, o modo ondemand ou dynamic bem ajustado é mais eficiente:

; Modo dinâmico — recomendado para a maioria dos servidores
pm = dynamic

; Fórmula: RAM disponível para PHP / consumo médio por processo
; Exemplo: 512MB disponíveis / 40MB por processo = ~12 processos
pm.max_children = 12

; Processos iniciados junto com o PHP-FPM
pm.start_servers = 3

; Mínimo de processos ociosos mantidos em memória
pm.min_spare_servers = 2

; Máximo de processos ociosos antes de serem encerrados
pm.max_spare_servers = 5

; Encerra processos após N requisições (evita vazamentos de memória)
pm.max_requests = 500

; Habilita o status page para monitoramento
pm.status_path = /status

Para servidores com menos de 1 GB de RAM, considere o modo ondemand, que só cria processos quando há requisições:

pm = ondemand
pm.max_children = 10
pm.process_idle_timeout = 10s
pm.max_requests = 200

Atenção: reduzir pm.max_children abaixo da demanda real do site causará fila de requisições e lentidão. Monitore o status page após a alteração antes de reduzir mais.

Após salvar, recarregue o PHP-FPM e verifique o status:

systemctl reload php8.3-fpm
curl http://127.0.0.1/status?full

pool:                 www
process manager:      dynamic
start time:           01/Jan/2025:10:00:00 +0000
start since:          3600
accepted conn:        1523
listen queue:         0
max listen queue:     0
idle processes:       2
active processes:     1
total processes:      3

O campo listen queue deve ser zero ou próximo de zero. Se estiver alto, pm.max_children está baixo demais para a demanda atual.

Configurando o OPcache para equilibrar velocidade e uso de RAM

O OPcache armazena o bytecode compilado dos scripts PHP em memória compartilhada, eliminando a necessidade de recompilar os arquivos a cada requisição. Isso reduz o uso de CPU significativamente, mas seu impacto na RAM depende diretamente da configuração.

Verifique se o OPcache está ativo:

php -r "echo ini_get('opcache.enable') ? 'OPcache ativo' : 'OPcache inativo';"

Edite as configurações do OPcache no php.ini ou em um arquivo dedicado:

nano /etc/php/8.3/fpm/conf.d/10-opcache.ini

opcache.enable=1
opcache.enable_cli=0

; Memória alocada para o OPcache — use 128M para a maioria dos sites
; Aumente para 256M apenas se tiver muitos arquivos PHP (ex.: Magento, Drupal)
opcache.memory_consumption=128

; Número máximo de arquivos PHP armazenados em cache
opcache.max_accelerated_files=10000

; Intervalo de verificação de mudanças nos arquivos (em segundos)
; Em produção, use 0 e limpe o cache manualmente após deploys
opcache.revalidate_freq=60

; Strings internadas — economiza memória em aplicações grandes
opcache.interned_strings_buffer=16

; Habilita otimizações de bytecode mais agressivas
opcache.optimization_level=0x7FFFBFFF

; Evita que o OPcache seja esvaziado por scripts individuais
opcache.restrict_api=""

Após ajustar, recarregue o PHP-FPM e verifique o status do OPcache:

systemctl reload php8.3-fpm
php -r "print_r(opcache_get_status());" | grep -E "memory_usage|hit_rate"

Se opcache_hit_rate estiver abaixo de 90%, aumente opcache.max_accelerated_files. Se memory_usage.used_memory estiver próximo de memory_usage.free_memory, aumente opcache.memory_consumption.

Para dicas adicionais de otimização do ambiente Linux como um todo, consulte o artigo Dicas de Otimização de Servidores Linux.

Identificando vazamentos de memória em aplicações PHP

Quando o consumo de RAM cresce progressivamente mesmo com configurações corretas, o problema pode estar no código da aplicação. Vazamentos de memória em PHP ocorrem quando objetos ou arrays crescem indefinidamente sem serem liberados.

Uma forma simples de detectar o consumo de memória dentro de um script é usar as funções nativas do PHP:

<?php
// Adicione em pontos estratégicos do código para medir o consumo
echo "Memória atual: " . round(memory_get_usage() / 1024 / 1024, 2) . " MB\n";
echo "Pico de memória: " . round(memory_get_peak_usage() / 1024 / 1024, 2) . " MB\n";
?>

Para profiling mais detalhado, instale o Xdebug ou o Blackfire. No Debian 12, instale o Xdebug para PHP 8.3:

apt install php8.3-xdebug

Configure o Xdebug apenas em ambiente de desenvolvimento — nunca em produção, pois aumenta significativamente o consumo de memória e CPU:

nano /etc/php/8.3/fpm/conf.d/20-xdebug.ini

xdebug.mode=profile
xdebug.output_dir=/tmp/xdebug
xdebug.profiler_output_name=cachegrind.out.%p

Os arquivos gerados em /tmp/xdebug podem ser analisados com o KCachegrind ou o QCachegrind para identificar funções que consomem mais memória.

Em WordPress, plugins como Query Monitor e WP-Memory-Usage ajudam a identificar quais plugins ou temas consomem mais memória por requisição, sem necessidade de ferramentas externas.

O parâmetro pm.max_requests = 500 no PHP-FPM é uma proteção importante: ele encerra e recria processos após 500 requisições, liberando memória acumulada por vazamentos graduais sem exigir reinicialização manual do serviço.

Problemas comuns e como resolver

Sintoma: erro "Allowed memory size of X bytes exhausted"

Causa: O script PHP tentou alocar mais memória do que o valor definido em memory_limit no php.ini. Isso pode indicar tanto um limite muito baixo quanto um script com vazamento de memória ou processando dados excessivamente grandes.
Solução: Primeiro, identifique qual script gerou o erro verificando os logs em /var/log/php8.3-fpm.log ou nos logs do servidor web. Se o script for legítimo (ex.: importação de CSV grande), aumente o memory_limit pontualmente via ini_set('memory_limit', '512M') no início do script. Se o erro ocorrer em páginas comuns, investigue o código com memory_get_peak_usage() para encontrar o ponto de consumo excessivo.

Sintoma: servidor fica sem memória e processos PHP são encerrados pelo OOM Killer

Causa: O kernel Linux ativa o OOM Killer (Out of Memory Killer) quando a RAM disponível se esgota, encerrando processos para liberar memória. Isso geralmente ocorre quando pm.max_children está alto demais em relação à RAM disponível, ou quando há um pico de tráfego inesperado.
Solução: Verifique se o OOM Killer atuou com dmesg | grep -i "oom\|killed". Reduza pm.max_children usando a fórmula: RAM disponível para PHP dividida pelo consumo médio por processo. Considere também adicionar swap como proteção temporária: fallocate -l 1G /swapfile && chmod 600 /swapfile && mkswap /swapfile && swapon /swapfile. O swap não resolve o problema, mas evita quedas abruptas enquanto você ajusta as configurações.

Sintoma: PHP-FPM reinicia constantemente ou fica lento após horas de operação

Causa: Processos PHP-FPM acumulam memória ao longo do tempo devido a vazamentos graduais em plugins, extensões ou no próprio código da aplicação. Sem o parâmetro pm.max_requests, um processo pode ficar ativo indefinidamente, crescendo em memória.
Solução: Defina pm.max_requests = 500 (ou valor menor para aplicações com vazamentos conhecidos) no arquivo de pool. Isso força o PHP-FPM a reciclar processos periodicamente. Verifique também se há extensões com comportamento anômalo desativando-as uma a uma e monitorando o consumo com watch -n 5 'ps aux --sort=-%mem | grep php | head -5'.

Sintoma: OPcache usando mais memória do que o esperado

Causa: O valor de opcache.memory_consumption está alto demais para a quantidade de arquivos PHP da aplicação, ou opcache.max_accelerated_files está baixo, causando cache miss frequente e realocações.
Solução: Execute php -r "print_r(opcache_get_status());" e verifique a proporção entre used_memory e free_memory. Se free_memory for maior que 50% do total, reduza opcache.memory_consumption. Se oom_restarts for maior que zero, aumente o valor. Para contar o número real de arquivos PHP da aplicação: find /var/www -name "*.php" | wc -l.

Perguntas frequentes sobre PHP consumindo muita RAM

Por que o PHP consome tanta memória no servidor?

O PHP consome muita memória principalmente por configurações inadequadas no php.ini (memory_limit alto demais), pools PHP-FPM com número excessivo de processos filhos, extensões desnecessárias carregadas e código de aplicação com vazamentos de memória. Em ambientes compartilhados ou VPS com pouca RAM, esses fatores se somam rapidamente e podem derrubar o servidor. A combinação de pm.max_children mal calculado com um memory_limit generoso é a causa mais comum em servidores de hospedagem.

Como ver quanto de RAM cada processo PHP está usando?

Execute o comando ps aux --sort=-%mem | grep php para listar processos PHP ordenados por consumo de memória. Para uma visão mais detalhada por pool PHP-FPM, use php-fpm -tt ou acesse o status page do PHP-FPM configurando pm.status_path no pool. O comando top com filtro por php também mostra consumo em tempo real, e o smem oferece uma medição mais precisa considerando memória compartilhada entre processos.

Qual o valor ideal de memory_limit para PHP?

O valor ideal depende da aplicação: WordPress simples funciona bem com 128M a 256M, aplicações Laravel ou Symfony podem precisar de 256M a 512M. O erro Allowed memory size exhausted indica que o limite está baixo demais, mas aumentar sem critério piora o consumo total do servidor. O correto é identificar o pico real de uso com funções como memory_get_peak_usage() ou ferramentas de profiling e definir o limite com margem de 20% acima desse pico.

Como reduzir o número de processos PHP-FPM sem derrubar o site?

Ajuste os parâmetros pm.max_children, pm.start_servers, pm.min_spare_servers e pm.max_spare_servers no arquivo de pool do PHP-FPM (geralmente em /etc/php/8.x/fpm/pool.d/www.conf). Reduza pm.max_children gradualmente, monitorando o status page do PHP-FPM para verificar se há processos em fila. A fórmula prática é: pm.max_children = RAM disponível para PHP / consumo médio por processo. Nunca reduza abaixo de 3 processos sem monitorar o campo listen queue no status page.

OPcache ajuda a reduzir o consumo de RAM do PHP?

O OPcache reduz o consumo de CPU e melhora a velocidade ao armazenar bytecode compilado, mas seu impacto direto na RAM depende da configuração. Com opcache.memory_consumption muito alto (ex.: 512MB), ele pode aumentar o uso total de memória do servidor. O valor recomendado para a maioria dos sites é entre 128MB e 256MB, ajustado conforme o número de arquivos PHP da aplicação — use find /var/www -name "*.php" | wc -l para contar os arquivos e dimensionar corretamente.

Conclusão

• Meça antes de ajustar: use ps aux --sort=-%mem | grep php e o status page do PHP-FPM para obter o consumo médio real por processo antes de alterar qualquer parâmetro.
• Calcule pm.max_children com a fórmula correta: divida a RAM disponível para PHP pelo consumo médio por processo e defina o valor com margem de segurança, monitorando o listen queue após cada ajuste.
• Combine ajustes no php.ini, PHP-FPM e OPcache: nenhuma configuração isolada resolve o problema — o consumo ideal de RAM vem do equilíbrio entre memory_limit adequado, número correto de processos e OPcache dimensionado para a aplicação real.

Leia também

• Otimizar PHP 8.3 no Debian 12: OPcache, JIT e pool FPM
• Otimizar cache Redis para aplicações PHP no Ubuntu 22.04
• Como ativar OPcache no PHP 8.3: do zero ao funcionando

Precisa de ajuda com PHP e hospedagem de sites?

Configurar PHP-FPM, OPcache e php.ini corretamente pode ser complexo, especialmente em ambientes com múltiplos sites ou tráfego variável. Os planos de hospedagem da AviraHost já incluem PHP otimizado e suporte técnico para ajudar a identificar gargalos de memória no seu ambiente.

Conheça os planos de hospedagem da AviraHost