# PHP 8.2 na raiz e 7.4 em /sistema na mesma conta

Como deixar a raiz em PHP 8.2 e o sistema legado em 7.4 no mesmo cPanel, por que um .htaccess esquecido na subpasta vence a escolha feita na tela, e como provar a versão efetiva de cada diretório.

> sim, dá para rodar duas versões na mesma conta cPanel. O MultiPHP Manager grava um bloco AddHandler no .htaccess do diretório, e o mais próximo do arquivo vence, desde que o domínio não esteja servido por PHP-FPM: com FPM a escolha é feita no vhost.

João Rizzon · 2026-09-21 · Painéis

---

Um cliente chega com o site institucional em WordPress atualizado e um sistema antigo em `/sistema`, escrito em PHP 5 tardio, que só abre até o 7.4. O painel deixa escolher uma versão por domínio, e a leitura apressada é que a conta inteira fica presa nessa escolha. Não fica. A versão é resolvida por diretório, e quem resolve é o Apache lendo o `.htaccess` mais próximo do arquivo requisitado.

Entender isso muda o diagnóstico: quando a versão "não pega" depois de trocar na tela, o problema quase nunca está no painel, está em um `.htaccess` que alguém deixou na subpasta.

## O que o MultiPHP Manager escreve de fato no .htaccess

Quando você escolhe uma versão para um domínio no MultiPHP Manager, o cPanel grava um bloco de handler delimitado por comentários no `.htaccess` do document root daquele domínio. O formato do bloco gerado é este (exemplo, para PHP 8.2):

```apache
# php -- BEGIN cPanel-generated handler, do not edit
# Set the "ea-php82" package as the default "PHP" programming language.
<IfModule mime_module>
  AddHandler application/x-httpd-ea-php82 .php .php7 .phtml
</IfModule>
# php -- END cPanel-generated handler, do not edit
```

Dois detalhes que importam no dia a dia. Primeiro, o comentário `do not edit` não é decorativo: o painel reescreve o trecho entre o BEGIN e o END quando você muda a versão de novo, e edições manuais dentro do bloco são perdidas. Segundo, se você escolher a versão padrão do sistema (a opção de herdar), o cPanel **remove** o bloco em vez de escrever um handler apontando para a versão atual. Ausência de bloco é uma decisão, não um esquecimento.

A lógica de herança entre diretórios está descrita na documentação oficial do EA4 em [PHP Inheritance](https://docs.cpanel.net/ea4/php/php-inheritance/). É ela que sustenta o resto deste artigo.

## Qual camada vence quando há mais de um handler

O Apache lê os `.htaccess` do caminho inteiro, da raiz até a pasta do arquivo, e o mais específico ganha. Aplicado ao handler de PHP, o resultado é esta pilha:

| Camada | Onde fica | Alcance | Quem vence |
|---|---|---|---||
| Versão padrão do servidor | Configuração do EasyApache 4 | Todo domínio sem definição própria | Menor prioridade |
| Versão do domínio (MultiPHP Manager) | Bloco de handler no `.htaccess` do document root | O domínio e todas as subpastas sem `.htaccess` próprio | Sobrepõe o padrão |
| Handler em subpasta | `.htaccess` dentro de `/sistema`, `/loja`, `/api` | A pasta e as filhas dela | Sobrepõe o document root |
| Handler em sub-subpasta | `.htaccess` mais fundo ainda | Só aquele ramo | Vence todos acima |
| PHP-FPM ligado no domínio | Configuração do vhost, fora do `.htaccess` | O domínio inteiro | Pode anular o `AddHandler` por diretório |

A última linha é a que mais custa tempo. Quando o domínio está servido por PHP-FPM, o processamento é entregue ao pool daquele vhost, e um `AddHandler` colocado em subpasta tende a não trocar a versão, porque a escolha já foi feita um nível acima, na configuração do servidor web. Não trate isso como regra universal do seu ambiente: trate como hipótese e confirme com o teste da seção de verificação. Se o `/sistema` insistir em responder a mesma versão da raiz mesmo com o bloco correto na pasta, PHP-FPM é o primeiro suspeito, e a saída limpa é o subdomínio.

### Por que o `.htaccess` da subpasta ganha da tela do painel

O caso clássico: o desenvolvedor anterior deixou em `/sistema/.htaccess` um `AddHandler application/x-httpd-ea-php56 .php` colado no topo, ou um bloco BEGIN/END gerado há três anos por um painel de outro servidor. Você troca o domínio para 8.2 na tela, o site responde 8.2, `/sistema` continua respondendo a versão velha, e a conclusão errada é que o painel está quebrado. O painel fez o trabalho dele, no document root. A subpasta simplesmente tem uma ordem mais específica.

A inversão também acontece: o cliente pede o sistema legado em 7.4, alguém coloca o handler 7.4 no document root para "garantir", e o WordPress da raiz passa a rodar em 7.4 inteiro. Funciona até o primeiro plugin exigir 8.0.

## Raiz em 8.2 e /sistema em 7.4 na mesma conta

### Mapeie os handlers que já existem na conta

Antes de escrever qualquer coisa, veja o que a conta já tem. Por SSH:

```bash
find ~/public_html -name '.htaccess' -exec grep -Hn 'ea-php' {} \;
```

A saída traz arquivo, linha e versão. Se aparecer handler em pastas que você nem sabia que existiam (`/old`, `/backup-2019`, `/wp-content/uploads`), anote. Handler em pasta de uploads é bandeira vermelha por outros motivos, e vale olhar com calma depois.

### Defina a versão do domínio pela tela, não à mão

No MultiPHP Manager, selecione o domínio principal e aplique a versão desejada (8.2 no exemplo). Deixe o painel escrever o bloco. Não copie o bloco à mão no document root: se amanhã alguém mudar pela tela, o cPanel precisa encontrar os marcadores BEGIN/END para substituir o conteúdo.

### Escreva o handler da subpasta fora do bloco do painel

Crie ou edite `/sistema/.htaccess` e coloque o handler da versão antiga no topo do arquivo, fora de qualquer bloco gerado pelo painel:

```apache
<IfModule mime_module>
  AddHandler application/x-httpd-ea-php74 .php .php7 .phtml
</IfModule>
```

O `<IfModule>` evita erro caso o módulo mime não esteja carregado. Mantenha seu handler manual **fora** do par BEGIN/END do cPanel, senão ele some na próxima alteração feita pela tela.

### Teste o mod_rewrite antes de considerar resolvido

Esse é o efeito colateral que pega quase todo mundo. As regras de rewrite do WordPress ficam no `.htaccess` da raiz e valem para as subpastas que não têm regras próprias. No comportamento padrão do mod_rewrite, quando a subpasta declara suas próprias regras, elas substituem as do pai em vez de somar. Ou seja: ao criar `/sistema/.htaccess` só com o handler, o sistema legado continua sujeito às regras do WordPress; ao criar com `RewriteEngine On` e regras próprias, ele deixa de herdar as de cima.

Nenhuma das duas situações é errada. Errado é descobrir qual delas você está usando pela reclamação do cliente. Teste as URLs do sistema legado logo depois de salvar o arquivo, inclusive uma URL que não corresponda a arquivo existente.

## Quando o subdomínio resolve melhor que a subpasta

Quando o legado aceita rodar em `sistema.dominio.com.br`, prefira isso à subpasta. O subdomínio tem document root próprio e aparece como linha separada no MultiPHP Manager, então a versão é definida na tela, o bloco é gerenciado pelo painel e você não disputa `.htaccess` com o WordPress.

| Critério | `/sistema` (subpasta) | `sistema.dominio.com.br` |
|---|---|---||
| Onde a versão é definida | `.htaccess` manual na pasta | MultiPHP Manager, entrada própria |
| Conflito com rewrite do WordPress | Provável, exige teste | Não existe |
| Efeito de PHP-FPM no domínio pai | Pode anular o handler da pasta | Configuração independente |
| Cookies e sessão compartilhados | Mesma origem, compartilha | Origem distinta, isola |
| Custo de migração | Zero, caminhos não mudam | Ajustar URLs e links absolutos do legado |

A última linha é o motivo real de tanta gente ficar na subpasta: sistema antigo com URL absoluta gravada em banco. Se o legado tem caminho relativo, mova; se tem `http://dominio.com.br/sistema/` cravado em tabela, avalie o custo antes.

## Como conferir a versão efetiva de cada diretório

Não confie na tela do painel como prova. Prove pelo que o interpretador responde.

### Arquivo de três linhas em vez de phpinfo completo

Crie um arquivo com nome não adivinhável em cada diretório que você quer auditar:

```php
<?php
header('Content-Type: text/plain');
echo PHP_VERSION, "\n";
echo php_sapi_name(), "\n";
echo php_ini_loaded_file(), "\n";
```

Três linhas de saída resolvem o diagnóstico: a versão, o SAPI (útil para identificar FPM, CGI ou LSAPI) e qual `php.ini` foi carregado. `phpinfo()` completo expõe caminhos, módulos e variáveis de ambiente para qualquer um que acerte a URL, e sempre tem alguém que esquece de apagar. Se precisar do `phpinfo()` para um caso específico, use e apague no mesmo turno de trabalho.

### Consultar por curl e apagar os arquivos de teste

```bash
curl -s https://exemplo.com.br/_ver-4f2a.php
curl -s https://exemplo.com.br/sistema/_ver-4f2a.php
```

O cabeçalho `X-Powered-By` também entrega a versão, mas só quando `expose_php` está ligado:

```bash
curl -sI https://exemplo.com.br/sistema/ | grep -i x-powered-by
```

Ausência do cabeçalho não significa que a versão está errada, significa que a diretiva está desligada. Por isso o arquivo de versão é o teste primário e o cabeçalho é só a conferência rápida.

Depois de validar, remova os arquivos:

```bash
find ~/public_html -name '_ver-4f2a.php' -delete
```

Use o mesmo sufixo aleatório em todos os sites do mesmo lote e a limpeza vira um comando só. Use um sufixo diferente a cada auditoria.

## Quando a opção some do painel ou a escolha não gruda

### O domínio não aparece com opção de versão

No cPanel, subdomínio criado pela tela ganha vhost próprio e, com ele, linha própria no MultiPHP Manager. Quem não ganha linha é alias, o domínio estacionado: ele responde com a versão do domínio para o qual aponta, e a única forma de diferenciar é pelo `.htaccess` da pasta de destino.

O caso que costuma confundir é outro. Se `sistema.dominio.com.br` foi criado com document root em `public_html/sistema`, ele aparece sim no painel, mas o document root dele e a subpasta do domínio principal são o mesmo diretório, logo o `.htaccess` é literalmente o mesmo arquivo. Definir 7.4 para o subdomínio pela tela grava o bloco ali, e esse bloco passa a valer também para `dominio.com.br/sistema`. Na maioria das vezes é exatamente o que você queria. Quando não for, o único jeito de ter versões diferentes nas duas rotas é dar document roots separados.

### A versão volta sozinha depois de alguns dias

Quase sempre é deploy. Plugin de cache, script de publicação ou restauração de backup que sobrescreve o `.htaccess` inteiro leva embora o handler manual da subpasta. Sintoma típico: funciona na sexta, quebra na terça. Guarde o `.htaccess` do legado no repositório do cliente e inclua o arquivo na rotina de deploy, ou o handler vai ser reescrito de novo a cada seis meses.

### Handler apontando para pacote que não existe no servidor

Escrever `ea-php56` num servidor que só tem 7.4 em diante não produz, necessariamente, um erro 500 amigável. O Apache recebe um tipo de handler que ninguém reclama, e o desfecho mais comum é pior que a página de erro: o `.php` é entregue ao navegador como texto puro ou como download. Isso expõe o código-fonte do legado e, com ele, a string de conexão com o banco em texto claro. Erro 500 acontece em algumas configurações, mas não conte com ele para te avisar.

Duas proteções, e elas não se substituem:

- Contra pacote inexistente: confira a lista de versões disponíveis na própria tela do MultiPHP Manager antes de escrever o nome do handler à mão, e valide com o arquivo de versão logo depois de salvar. Se o `curl` devolver o conteúdo do arquivo em vez do número da versão, o handler está inválido e o diretório está vazando fonte agora.
- Contra módulo ausente: o `<IfModule mime_module>` em volta. Ele só testa se o mime_module está carregado, nada mais. Não verifica se o `ea-phpXX` existe, porque o módulo está lá; o que falta é o pacote.

### Como devolver um diretório à herança

Para devolver um diretório à herança, apague o bloco inteiro, do BEGIN ao END quando for bloco do painel, ou as linhas do `AddHandler` quando for manual. Sem handler na pasta, o diretório volta a seguir o `.htaccess` acima, e na ausência de qualquer um deles, o padrão do servidor, conforme a [documentação de herança do EA4](https://docs.cpanel.net/ea4/php/php-inheritance/). Confirme a reversão rodando o arquivo de versão de novo, não pelo que a tela mostra.

## Checklist para padronizar em vários clientes

O mesmo procedimento em todos os sites, na mesma ordem, é o que transforma isso em tarefa de quinze minutos por conta em vez de investigação toda vez.

- Rodar o `find` de handlers e salvar a saída no card do cliente. Esse inventário é o que você vai consultar daqui a um ano.
- Definir a versão do domínio pela tela do painel, nunca escrevendo o bloco à mão no document root.
- Escrever o handler da versão antiga apenas nas pastas que precisam, fora do bloco BEGIN/END, conferindo antes se o pacote consta na lista do painel.
- Testar as URLs do legado, incluindo uma que não seja arquivo real, para flagrar conflito de rewrite.
- Subir o arquivo de versão na raiz e em cada pasta com handler próprio, conferir por `curl`, apagar. Se a resposta vier como código-fonte, o handler está errado.
- Versionar o `.htaccess` do legado junto com o código, para o deploy não apagar o handler.
- Restringir o acesso à pasta legada, porque versão antiga de PHP não recebe correção de segurança da comunidade. Autenticação básica, lista de IPs ou VPN, conforme o caso, além de `noindex` para não indexar tela de login de sistema interno.

### Como explicar a convivência das duas versões para o cliente

Quando precisar explicar sem entrar em Apache, funciona assim: "O site fica em PHP 8.2, que é a versão com suporte e a que os plugins exigem. O sistema antigo em /sistema continua em PHP 7.4 numa pasta isolada, porque ele não abre nas versões atuais. As duas versões convivem na mesma hospedagem, sem afetar uma à outra. Enquanto o sistema não for atualizado, o acesso a ele fica restrito, porque a versão 7.4 não recebe mais correção de segurança."

Isso costuma abrir a conversa certa, que é colocar a reescrita do legado no orçamento do ano em vez de empurrar mais um semestre. Rodar duas versões lado a lado é uma solução de convivência, não um destino final.

