# PHP-FPM, suPHP, LSAPI e DSO: o que muda na prática

O handler explica por que o upload nasce com dono errado em um servidor e certo em outro, e por que o php_value do .htaccess some. Com checklist de troca e validação por curl.

> a diferença está em três pontos práticos: suPHP e CGI sobem um processo por requisição e executam como o usuário da conta; PHP-FPM e LSAPI mantêm processos persistentes e também rodam como o usuário; só o DSO (mod_php) roda como nobody e lê php_value no .htaccess. Nos demais, use .user.ini.

João Rizzon · 2026-10-24 · Painéis

---

## O que o handler decide e o que ele não decide

O handler do PHP é o mecanismo que o Apache usa para executar o código. Não é a versão do PHP, não é o pool de recursos do plano, não é o cache. É só o "como" a requisição vira processo. Mesmo assim, três coisas que dão suporte quase todo dia dependem dele:

- **Qual usuário do sistema escreve os arquivos** que o site cria (upload do WordPress, cache do plugin, `wp-content/uploads`).
- **Quanto de memória cada requisição ocupa** e por quanto tempo o processo fica vivo.
- **Se `php_value` no `.htaccess` é lido, ignorado ou derruba o site com 500.**

Quem mantém carteira de sites costuma descobrir isso pelo sintoma errado. O cliente diz que o site "parou de aceitar upload" depois de uma migração, alguém sai dando `chmod 777`, e a causa era o dono do arquivo ter mudado de `nobody` para o usuário da conta (ou o contrário). Os handlers disponíveis em EasyApache 4 estão documentados em [PHP Handlers (EasyApache 4)](https://docs.cpanel.net/ea4/php/php-handlers/), que é a referência usada aqui.

## Os cinco handlers lado a lado em uma tabela

| Handler | Executa como | Modelo de processo | `php_value` no `.htaccess` | Onde ajustar diretiva por site |
|---|---|---|---|---||
| DSO (`mod_php`) | usuário do Apache (`nobody`) | módulo dentro do Apache | lido | `.htaccess` |
| CGI | usuário da conta (via suEXEC) | um processo por requisição | diretiva desconhecida pelo Apache (tende a 500) | `.user.ini` / `php.ini` local |
| suPHP | usuário da conta | um processo por requisição | diretiva desconhecida pelo Apache (tende a 500) | `.user.ini` / `php.ini` local |
| PHP-FPM | usuário da conta | pool persistente de workers | diretiva desconhecida pelo Apache (tende a 500) | `.user.ini` ou configuração do pool |
| LSAPI | usuário da conta | processos persistentes por usuário | diretiva desconhecida pelo Apache (tende a 500) | `.user.ini` |

Duas leituras práticas dessa tabela. Primeira: **DSO é o único que não roda com o usuário da conta**, e é exatamente por isso que o arquivo nasce `nobody`. Segunda: **DSO é o único em que `php_value` no `.htaccess` funciona**, porque essas diretivas são do `mod_php`. Fora dele, o lugar certo é `.user.ini`.

Nem toda versão de PHP oferece todos os handlers. O WHM mostra apenas os que estão instalados para aquela versão, e vale conferir a lista atual na documentação antes de planejar uma padronização. Vale lembrar que a escolha do handler é server-wide por versão de PHP: trocar o handler de uma versão afeta todos os domínios que usam aquela versão.

## Por que o upload vira `nobody` em um servidor e o usuário em outro

Em DSO, o PHP é um módulo carregado dentro do Apache. O processo que grava o arquivo é o processo do Apache, que roda com o usuário do servidor web. Resultado: o arquivo enviado pelo WordPress fica com dono `nobody` (ou `apache`, conforme o sistema) e o usuário FTP/SSH da conta não consegue sobrescrever nem apagar. Daí vem o `chmod 777` desesperado, que não resolve a causa e abre risco.

Nos outros quatro, o processo já roda como o usuário da conta. O arquivo criado pelo site pertence ao mesmo dono dos arquivos enviados por FTP. Permissão `644` para arquivo e `755` para diretório basta, e o WordPress consegue atualizar plugin sem pedir credencial de FTP.

Para descobrir em que situação você está, sem adivinhar:

```bash
# dentro da conta, via SSH
ls -l wp-content/uploads/$(date +%Y)/$(date +%m) | head
id
```

Se o dono dos arquivos recentes for diferente do que `id` devolve, você está em DSO (ou em um site que foi migrado de DSO e nunca teve o dono corrigido).

### Como corrigir o dono dos arquivos depois de trocar o handler

Trocar o handler não reescreve o passado. Os arquivos antigos continuam com o dono antigo. Depois de migrar de DSO para FPM ou LSAPI, peça ao administrador do servidor a correção de propriedade da conta, ou rode, com privilégio suficiente:

```bash
chown -R usuario:usuario /home/usuario/public_html
find /home/usuario/public_html -type d -exec chmod 755 {} \;
find /home/usuario/public_html -type f -exec chmod 644 {} \;
```

Substitua `usuario` pelo nome real da conta cPanel. Em hospedagem compartilhada, isso normalmente é feito pelo suporte, porque exige root.

## Processo persistente ou por requisição: o efeito em memória e fila

DSO e LSAPI mantêm processos vivos entre requisições, o que elimina o custo de subir o interpretador a cada hit. CGI e suPHP sobem e derrubam um processo por requisição: a memória é liberada rápido, mas o custo por requisição é maior e aparece em TTFB, principalmente em página não cacheada. PHP-FPM mantém um pool de workers por conta, com limite configurável.

O efeito colateral que mais confunde cliente de agência é o limite de processos. Em FPM e LSAPI, o pool tem teto. Se o site recebe um pico e todos os workers estão ocupados, as requisições novas entram em fila e o visitante vê lentidão ou erro 503, mesmo com CPU sobrando. Em suPHP, o mesmo pico vira muitos processos curtos e o gargalo aparece como memória.

Frase pronta para o cliente, sem jargão: "o servidor atende várias visitas ao mesmo tempo com um número fixo de atendentes; quando todos estão ocupados, a fila cresce. Cache na frente reduz quantas visitas chegam até eles."

## Por que `php_value` para de funcionar e o que escrever no `.user.ini`

Um site que funcionava com isto no `.htaccess`:

```apache
php_value upload_max_filesize 64M
php_value post_max_size 64M
php_value memory_limit 256M
```

para de aplicar esses valores assim que sai do DSO. `php_value` e `php_admin_value` são diretivas do `mod_php`: sem ele carregado, o Apache não as reconhece em nenhum handler, e o resultado mais comum é erro 500 na primeira requisição ao diretório. Se o servidor foi configurado para tolerar diretiva desconhecida, o site abre e os valores simplesmente não chegam ao PHP. Em qualquer um dos dois casos, o bloco precisa sair do `.htaccess`.

O equivalente vai em `.user.ini`, na raiz do site, com sintaxe de arquivo `ini`:

```ini
upload_max_filesize = 64M
post_max_size = 64M
memory_limit = 256M
```

Três detalhes que economizam meia hora de depuração:

- `.user.ini` tem cache. A alteração pode levar alguns minutos para valer, conforme o `user_ini.cache_ttl` do servidor. Não conclua que "não funcionou" no primeiro F5.
- Nem toda diretiva é aceita em `.user.ini`. As de modo `PHP_INI_SYSTEM`, como `disable_functions`, só mudam no `php.ini` do servidor.
- Valide pelo que o PHP enxerga, não pelo que você escreveu:

```bash
curl -s https://exemplo.com.br/info.php | grep -i memory_limit
```

Com um `info.php` temporário contendo `<?php phpinfo();`. Apague o arquivo depois do teste.

## Qual handler escolher, por tipo de site

- **WordPress de cliente, com plugin que atualiza sozinho e usuário que faz upload pelo painel**: LSAPI ou PHP-FPM. Dono correto dos arquivos e processo persistente.
- **Site legado que depende de `php_value` espalhado em vários `.htaccess` e ninguém tem tempo de mapear**: DSO resolve hoje, mas aceite que o problema de propriedade vai voltar. Trate como dívida, não como solução.
- **Site muito pequeno, tráfego raro, memória apertada**: suPHP ou CGI continuam coerentes, com TTFB pior por requisição.
- **Carteira com dezenas de sites**: padronize um handler só. A economia não está na performance de um site, está em você parar de diagnosticar o mesmo sintoma com causa diferente em cada servidor.

## Medir a mesma URL com curl antes e depois da troca

Não troque handler no escuro. Faça a mesma medição antes e depois, na mesma URL, com o mesmo comando. Crie o arquivo de formato:

```bash
cat > curl-format.txt <<'EOF'
     tempo_conexao:  %{time_connect}s
  tempo_handshake:  %{time_appconnect}s
             ttfb:  %{time_starttransfer}s
            total:  %{time_total}s
           status:  %{http_code}
EOF
```

E rode dez vezes contra uma URL que **não** passa por cache de página (área logada, ou com um parâmetro que fure o cache):

```bash
for i in $(seq 1 10); do
  curl -s -o /dev/null -w "@curl-format.txt\n" \
    "https://exemplo.com.br/?nocache=$(date +%s)-$i"
  sleep 1
done
```

Saída possível, aqui apenas como **exemplo de execução**, não como medição da Napoleon:

```
     tempo_conexao:  0.021s
  tempo_handshake:  0.064s
             ttfb:  0.412s
            total:  0.418s
           status:  200
```

O que observar no comparativo:

- Compare o **ttfb**, não o total. O total carrega o tamanho da página e varia com a sua rede.
- Ignore a primeira execução de cada rodada. Ela costuma pegar cache de opcode frio.
- Rode as duas rodadas no mesmo horário do dia, de preferência em minutos próximos. Comparar 3h da manhã com 20h não diz nada sobre o handler.
- Registre o `status`. Uma queda de ttfb acompanhada de 500 não é melhora, é o `php_value` do `.htaccess` quebrando.

### Checklist de troca, para repetir em cada site

- Anotar o handler e a versão de PHP atuais do site.
- Fazer `grep -r "php_value\|php_admin_value" public_html` e listar o que precisa virar `.user.ini`.
- Rodar a rodada de `curl` antes, salvando a saída em arquivo.
- Trocar o handler. O handler é definido no WHM, em MultiPHP Manager, por versão de PHP e valendo para o servidor inteiro. No cPanel da conta, o MultiPHP Manager escolhe apenas a versão de PHP de cada domínio, e o handler vem junto com a versão escolhida. Em hospedagem compartilhada, abra chamado pedindo o handler pelo nome ("usar PHP-FPM na versão X" ou "usar LSAPI") e a versão de PHP que deve ficar no domínio.
- Converter as diretivas para `.user.ini` e conferir com `phpinfo()`.
- Corrigir dono e permissões dos arquivos antigos.
- Rodar a rodada de `curl` depois e comparar ttfb e status.
- Testar upload de mídia, atualização de plugin e envio de formulário.

Se a rodada de `curl` posterior não mostrar diferença e os testes funcionais (upload, atualização de plugin, formulário) passarem, a troca ainda valeu: você eliminou a classe de chamado "permissão negada" daquele site. E se o ttfb não melhorou, o gargalo está em consulta lenta, plugin ou ausência de cache, não no handler. Trocar de plano nesse cenário não resolve.

