# Compilar o PHP a partir do código-fonte

> Compilar o PHP a partir do código-fonte: requisitos, opções do configure, verificação da assinatura, testes e por que os builds próprios implicam deveres de patches.

Fonte: https://phpsos.de/pt/php/php-kompilieren/  
Atualizado em: 25/10/2026  
Prestador: PHP SOS, Assistência de emergência PHP e segurança de servidores. Ajuda imediata por WhatsApp: https://wa.me/491736494914?text=Ol%C3%A1%2C%20PHP%20SOS%2C%20precisamos%20de%20ajuda%20com%20o%20nosso%20servidor%20PHP.%20Empresa%3A%20%E2%80%A6%20Site%3A%20%E2%80%A6

**Em resumo:** Compilar o PHP significa descarregar o pacote de código-fonte oficial do php.net, definir com `./configure` as interfaces e extensões pretendidas, construir com `make`, verificar com `make test` e depois instalar. Isso dá controlo total sobre a versão e o âmbito. O preço: por cada atualização de segurança é você o responsável, como ainda recentemente no PHP2Shell, quando foi preciso construir de novo e reiniciar todos os processos.

## Quando fazem sentido builds próprios do PHP

A maioria dos servidores obtém o PHP de uma fonte de pacotes: da distribuição Linux, de um repositório de terceiros ou de uma imagem de contentor. Para a operação normal, é geralmente a melhor escolha, porque as correções de segurança chegam automaticamente.

Os builds próprios têm, ainda assim, o seu lugar:

| Situação | Fonte de pacotes | Build próprio |
|---|---|---|
| Servidor web normal | geralmente melhor | raramente necessário |
| Versão ou opção ausente de uma fonte de confiança | não disponível | sensato |
| Deteção de falhas no próprio PHP, build de depuração | limitado | sensato |
| Âmbito de funções mínimo para sistemas especiais | limitado | sensato |
| Atualizações de segurança | chegam com a fonte | tarefa própria |

Quem opta por builds próprios precisa de um processo fixo para as atualizações, caso contrário a vantagem torna-se um risco.

## Requisitos

Segundo o manual, são necessários o GNU make e um compilador C; desde o PHP 8.4, o compilador tem de suportar C11. Quem constrói a partir do repositório Git, em vez de um pacote de versão, precisa ainda do autoconf (a partir da 2.68), do re2c (a partir da 1.0.3 para o PHP 8.3 e posteriores) e do bison (a partir da 3.0.0). O README do código-fonte indica, para o Ubuntu, este ponto de partida:

```bash
sudo apt install -y pkg-config build-essential autoconf bison re2c libxml2-dev libsqlite3-dev
```

Para cada extensão adicional, acrescem os pacotes de desenvolvimento correspondentes, por exemplo para o OpenSSL ou a libsodium.

## Descarregar o código-fonte e verificar a autenticidade

Um PHP construído por si é tão fiável quanto o seu código-fonte. O php.net oferece cada pacote com soma de verificação SHA-256 e assinatura GPG; as chaves dos release managers estão na página de downloads e na página das chaves GPG.

```bash
curl -O https://www.php.net/distributions/php-8.4.27.tar.xz
curl -O https://www.php.net/distributions/php-8.4.27.tar.xz.asc
sha256sum php-8.4.27.tar.xz                     # comparar com o valor no php.net
gpg --verify php-8.4.27.tar.xz.asc php-8.4.27.tar.xz
```

Só quando a soma de verificação e a assinatura coincidem se avança.

## Compilar o PHP: configure, make, test

O processo tem quatro passos:

1. **Configurar:** `./configure` com as opções pretendidas. Ao construir a partir do Git, executar antes `./buildconf`.
2. **Construir:** `make -j"$(nproc)"`; o número de jobs corresponde, segundo o README, de forma sensata ao número de núcleos do processador.
3. **Testar:** `make TEST_PHP_ARGS=-j4 test` executa a suite de testes do PHP.
4. **Instalar:** `make install`, consoante o diretório de destino com direitos de root.

Um exemplo de um build PHP-FPM com diretório de destino próprio:

```bash
tar xf php-8.4.27.tar.xz && cd php-8.4.27
./configure --prefix=/opt/php-8.4 \
  --with-config-file-path=/opt/php-8.4/etc \
  --enable-fpm --with-fpm-user=www-data --with-fpm-group=www-data --with-fpm-systemd \
  --with-openssl --with-sodium \
  --disable-cgi
make -j"$(nproc)"
make TEST_PHP_ARGS=-j4 test
sudo make install
/opt/php-8.4/bin/php -v
```

As opções mais importantes em resumo:

| Opção | Efeito |
|---|---|
| `--enable-fpm` | constrói o PHP-FPM; adicionalmente `--with-fpm-user`, `--with-fpm-group`, `--with-fpm-systemd` |
| `--with-config-file-path` | diretório em que o PHP procura o php.ini |
| `--with-openssl` | suporte para OpenSSL; desde o PHP 7.4, o caminho é encontrado através do pkg-config |
| `--with-sodium` | criptografia moderna com a libsodium |
| `--disable-cgi` | dispensa a variante CGI, se não for necessária |
| `--enable-debug` | símbolos de depuração, segundo o README recomendados para desenvolvimento, não para produção |
| `--enable-zts` | segurança de threads para modos de operação com threads |

Com `--prefix` podem instalar-se lado a lado várias versões construídas por si, por exemplo em `/opt/php-8.3` e `/opt/php-8.4`. Isso facilita as mudanças, mas exige disciplina: cada versão instalada é software próprio, que tem de ser reconstruído a cada versão de segurança, mesmo que nenhum site a use naquele momento. Os builds que já não são necessários devem ser totalmente removidos. As opções que um build existente tem mostra-as o `php -i` na linha «Configure Command»; é o melhor modelo para a próxima reconstrução.

Nota sobre o OPcache: desde o PHP 8.5, o OPcache está, segundo o RFC aprovado, compilado de forma fixa. Nas versões mais antigas, é construído como extensão e carregado com `zend_extension`. O que são extensões e interfaces explicam-no [Compreender as extensões PHP](https://phpsos.de/pt/php/php-erweiterungen/) e [SAPI explicada](https://phpsos.de/pt/php/sapi-erklaert/).

## Builds próprios e segurança: os deveres após o PHP2Shell

O PHP compilado por si tem uma verdadeira vantagem de segurança: constrói apenas o que precisa. Cada extensão não construída e cada modo de operação não construído é código que não pode conter uma vulnerabilidade. Um build sem CGI, com poucas extensões e caminhos claros é fácil de ter em vista.

Contrapõe-se um dever pesado. No PHP2Shell, as distribuições entregaram backports em parte a 21/10/2026; quem constrói por si não recebe nada automaticamente. Concretamente, isso significou:

1. Descarregar e verificar o código-fonte da versão corrigida.
2. Reconstruir com opções idênticas; o `php -i` mostra a linha original do configure.
3. Executar os testes e instalar.
4. Reiniciar todos os processos PHP, como descrito em [Reiniciar o PHP-FPM e todos os workers](https://phpsos.de/pt/php2shell/php-fpm-neustart/).
5. Verificar a versão em execução, como explicado em [Verificar corretamente a versão do PHP e o nível de patches](https://phpsos.de/pt/php2shell/php-version-pruefen/).

> **Importante:**
> Um PHP construído por si não aparece em nenhum gestor de pacotes. Mantenha um inventário de em que servidores correm builds próprios e em que versão, caso contrário serão ignorados na próxima vulnerabilidade.

## Como ajuda concretamente o PHP SOS?

Através do [serviço de patches PHP](https://phpsos.de/pt/leistungen/php-patch-service/), apoiamos os operadores de builds próprios:

- **Registar o parque instalado:** encontramos versões do PHP construídas por si e lemos as suas opções de build.
- **Reconstruir:** versão corrigida com assinatura verificada, as mesmas opções e execução completa dos testes.
- **Distribuir e reiniciar:** instalação, reinício de todos os processos, verificação da versão em execução.
- **Simplificar:** onde uma fonte de pacotes mantida cumpre o mesmo propósito, mostramos a mudança.


## Perguntas frequentes

**Quando compensa compilar o PHP por conta própria?**  
Quando uma versão ou opção necessária não está disponível em nenhuma fonte de pacotes de confiança, para desenvolvimento e deteção de falhas no próprio PHP, ou para builds muito enxutos e especiais. Para servidores web normais, os pacotes mantidos são geralmente a melhor escolha.

**Como verifico que o código-fonte do PHP é autêntico?**  
O php.net oferece, para cada pacote de código-fonte, uma soma de verificação SHA-256 e uma assinatura GPG. Compare a soma de verificação e verifique a assinatura com as chaves dos release managers publicadas no php.net.

**Tenho de compilar de novo após uma versão de segurança?**  
Sim. Um PHP construído por si não recebe atualizações da distribuição. Depois do PHP2Shell, isso significou: compilar o código-fonte do 8.5.12, 8.4.27, 8.3.36 ou 8.2.35, instalar e reiniciar todos os processos PHP.

**Onde encontro todas as opções do configure?**  
Com ./configure --help no diretório do código-fonte. O manual indica as opções principais mais importantes; as opções das extensões constam das respetivas páginas do manual.

## Fontes

- [Manual do PHP: instalação a partir do código-fonte](https://www.php.net/manual/en/install.unix.source.php)
- [Manual do PHP: opções do configure](https://www.php.net/manual/en/configure.about.php)
- [Manual do PHP: instalar o FPM](https://www.php.net/manual/en/install.fpm.install.php)
- [php.net: pacotes de código-fonte com somas de verificação e assinaturas](https://www.php.net/downloads.php)