Como configurar o Apache HTTP com eventos MPM e PHP-FPM no FreeBSD 12.0

O autor selecionou o Open Internet/Free Speech Fund para receber uma doação como parte do programa Write for DOnations.

Introduction

O servidor web Apache HTTP evoluiu ao longo dos anos para trabalhar em diferentes ambientes e resolver diferentes necessidades. Um problema importante que o Apache HTTP tem que resolver, como qualquer servidor web, é como lidar com diferentes processos para servir uma requisição de protocolo http. Isso envolve abrir um socket, processar a requisição, manter a conexão aberta por um certo período, lidar com novos eventos que ocorrem através dessa conexão, e retornar o conteúdo produzido por um programa feito em uma determinada linguagem (como PHP, Perl, ou Python). Estas tarefas são executadas e controladas por um Módulo Multi-Processamento (MPM).

Apache HTTP vem com três diferentes MPM:

• Pre-fork: Um novo processo é criado para cada conexão de entrada que chega ao servidor. Cada processo é isolado dos outros, portanto nenhuma memória é compartilhada entre eles, mesmo que eles estejam executando chamadas idênticas em algum ponto de sua execução. Esta é uma forma segura de executar aplicações ligadas a bibliotecas que não suportam aplicações ou bibliotecas tipicamente mais antigas.
• Worker: Um processo pai é responsável por lançar um pool de processos filhos, alguns dos quais estão escutando novas conexões de entrada, e outros estão servindo o conteúdo solicitado. Cada processo é encadeado (uma única linha pode lidar com uma conexão), de modo que um processo pode lidar com várias solicitações ao mesmo tempo. Este método de tratamento de conexões incentiva uma melhor utilização dos recursos, mantendo a estabilidade. Isto é um resultado do conjunto de processos disponíveis, que muitas vezes tem threads livres disponíveis prontos para servir imediatamente novas conexões.
• Evento: Com base no trabalhador, este MPM vai um passo além, otimizando a forma como o processo pai programa tarefas para os processos filhos e os threads associados a eles. Uma conexão permanece aberta por padrão por 5 segundos e fecha se nenhum novo evento acontecer; este é o valor padrão da diretiva keep-alive, que mantém a thread associada a ela. O MPM de evento permite que o processo gerencie threads de forma que algumas threads fiquem livres para lidar com novas conexões de entrada enquanto outras são mantidas vinculadas às conexões ao vivo. Permitir a redistribuição de tarefas atribuídas a threads fará com que a utilização de recursos e a performance sejam melhores.

O módulo Event MPM é um módulo rápido de multi-processamento disponível no servidor web Apache HTTP.

PHP-FPM é o FastCGI Process Manager para PHP. O protocolo FastCGI é baseado no Common Gateway Interface (CGI), um protocolo que fica entre aplicações e servidores web como o Apache HTTP. Isto permite aos desenvolvedores escrever aplicações separadamente do comportamento dos servidores web. Os programas executam seus processos de forma independente e passam seu produto para o servidor web através deste protocolo. Cada nova conexão que precisa de processamento por uma aplicação criará um novo processo.

Ao combinar o evento MPM no Apache HTTP com o PHP FastCGI Process Manager (PHP-FPM) um website pode carregar mais rápido e lidar com mais conexões simultâneas enquanto usa menos recursos.

Neste tutorial você irá melhorar a performance da pilha FAMP mudando o módulo multi-processamento padrão de pré-fork para evento e usando o gerenciador de processos PHP-FPM para lidar com o código PHP ao invés do clássico mod_php no Apache HTTP.

Prerequisites

Antes de começar este guia você precisará do seguinte:

• Um servidor FreeBSD 12.0 configurado seguindo este guia.
• A pilha FAMP instalada no seu servidor seguindo este tutorial.
• Acesso a um usuário com privilégios de root (ou permitido usando o sudo) para fazer alterações de configuração.

Passo 1 – Alterando o Módulo Multi-Processamento

Você começará procurando a diretiva de pré-fabricação no arquivo httpd.conf. Este é o arquivo de configuração principal para o Apache HTTP no qual você pode habilitar e desabilitar módulos. Você pode editar e definir diretivas como a porta de escuta onde o Apache HTTP servirá o conteúdo ou a localização do conteúdo a ser exibido neste arquivo.

Para fazer estas alterações, você usará o programa nl, linha numérica, com a bandeira -ba para contar e linhas numéricas para que nada seja desajustado em um estágio posterior. Combinado com grep este comando irá primeiro contar todas as linhas do ficheiro especificado no caminho, e uma vez terminado, irá procurar pela cadeia de caracteres que procura.

Executar o seguinte comando para que o programa nl processe e numere as linhas em httpd.conf. Então, grep processará a saída procurando pela string de caracteres dada 'mod_mpm_prefork':

nl -ba /usr/local/etc/apache24/httpd.conf | grep 'mod_mpm_prefork'

Como saída você verá algo similar a:

Output
 67 LoadModule mpm_prefork_module libexec/apache24/mod_mpm_prefork.so

Linha de edição 67 com o seu editor de texto. Neste tutorial, você vai usar vi, que é o editor padrão no FreeBSD:

sudo vi +67 /usr/local/etc/apache24/httpd.conf

Aplicar um símbolo # no início da linha para que esta linha seja comentada, como assim:

...# LoadModule mpm_prefork_module libexec/apache24/mod_mpm_prefork.so...

Aplicando o símbolo # você desabilitou o módulo MPM pré-fork.

Agora você encontrará a diretiva de eventos no mesmo arquivo httpd.conf.

nl -ba /usr/local/etc/apache24/httpd.conf | grep mpm_event

Vai ver a saída semelhante ao seguinte:

Output
...66 #LoadModule mpm_event_module libexec/apache24/mod_mpm_event.so...

Agora vai remover o símbolo # na linha 66 para activar o Evento MPM:

sudo vi +66 /usr/local/etc/apache24/httpd.conf

A directiva agora vai ler-se como se segue:

...LoadModule mpm_event_module libexec/apache24/mod_mpm_event.so...

Agora que você trocou a configuração da pré-ferramenta MPM por evento, você pode remover o pacote mod_php73 conectando o processador PHP ao Apache HTTP, uma vez que ele não é mais necessário e irá interferir se ele permanecer no sistema:

sudo pkg remove -y mod_php73

Certifique-se de que a configuração está correcta executando o seguinte comando para testar:

sudo apachectl configtest

Se vir Syntax OK na sua saída, pode reiniciar o servidor HTTP Apache:

sudo apachectl restart

Nota: Se existirem outras ligações HTTP em execução no seu servidor, recomenda-se um reinício gracioso em vez de um reinício regular. Isto irá garantir que os usuários não sejam empurrados para fora, perdendo sua conexão:

sudo apachectl graceful

Você trocou o MPM de pré-fork para event e removeu a conexão do módulo PHP para o Apache HTTP mod_php73. No próximo passo você vai instalar o módulo PHP-FPM e configurar o Apache HTTP para que ele possa se comunicar com o PHP mais rapidamente.

Passo 2 – Configurando o Apache HTTP para usar o FastCGI Process Manager

FreeBSD tem várias versões suportadas do PHP que você pode instalar através do gerenciador de pacotes. No FreeBSD são compilados diferentes binários das várias versões disponíveis, ao invés de usar apenas um, como a maioria das distribuições GNU/Linux oferecem em seus repositórios padrão. Para seguir as melhores práticas você usará a versão suportada, que você pode verificar na página de versões suportadas do PHP.

Neste passo você adicionará o PHP-FPM como um serviço em execução para começar no boot. Você também irá configurar o Apache HTTP para trabalhar com o PHP adicionando uma configuração dedicada para o módulo, assim como habilitar alguns módulos adicionais em httpd.conf.

Primeiro você irá anexar 'php_fpm_enable=YES' ao arquivo /etc/rc.conf para que o serviço PHP-FPM possa iniciar. Você fará isso usando o comando sysrc:

sudo sysrc php_fpm_enable="YES"

Agora você adicionará o módulo php-fpm ao diretório do módulo Apache, assim ele será configurado para ser usado pelo Apache HTTP. Crie o seguinte ficheiro para o fazer:

sudo vi /usr/local/etc/apache24/modules.d/030_php-fpm.conf

Adicionar o seguinte em 030_php-fpm.conf:

>

<IfModule proxy_fcgi_module> <IfModule dir_module> DirectoryIndex index.php </IfModule> <FilesMatch "\.(php|phtml|inc)$"> SetHandler "proxy:fcgi://127.0.0.1:9000" </FilesMatch></IfModule>

Esta instrução diz que se o módulo 'proxy_fcgi' estiver habilitado assim como o 'dir_module' então quaisquer arquivos processados que correspondam às extensões entre parênteses devem ser manuseados pelo gerenciador de processos FastCGI rodando na máquina local através da porta 9000 como se a máquina local fosse um servidor proxy. Aqui é onde o módulo PHP-FPM e o Apache HTTP se interconectam. Para conseguir isto, você ativará outros módulos durante este passo.

Para ativar o módulo proxy, você primeiro procurará por ele no arquivo httpd.conf:

nl -ba /usr/local/etc/apache24/httpd.conf | grep mod_proxy.so

Você verá uma saída similar à seguinte:

Output
...129 #LoadModule proxy_module libexec/apache24/mod_proxy.so...

Você descomentará a linha removendo o # symbol:

sudo vi +129 /usr/local/etc/apache24/httpd.conf

A linha terá a seguinte aparência uma vez editada:

...LoadModule proxy_module libexec/apache24/mod_proxy.so...

Agora você pode ativar o módulo FastCGI. Encontre o módulo com o seguinte comando:

nl -ba /usr/local/etc/apache24/httpd.conf | grep mod_proxy_fcgi.so

Vai ver algo semelhante ao seguinte:

Output
...133 #LoadModule proxy_fcgi_module libexec/apache24/mod_proxy_fcgi.so...

Descomente agora a linha 133 como já fez com os outros módulos:

sudo vi +133 /usr/local/etc/apache24/httpd.conf

Vai deixar a linha como se segue:

...LoadModule proxy_fcgi_module libexec/apache24/mod_proxy_fcgi.so...

É feito isso você iniciará o serviço PHP-FPM:

sudo service php-fpm start

E você reiniciará o Apache para que ele carregue as últimas mudanças de configuração incorporando o módulo PHP:

sudo apachectl restart

Você instalou o módulo PHP-FPM, configurou o Apache HTTP para funcionar com ele, habilitou os módulos necessários para o protocolo FastCGI funcionar, e iniciou os serviços correspondentes.

Agora que o Apache tem o módulo MPM do evento habilitado e o PHP-FPM está presente e rodando, é hora de verificar se tudo está funcionando como pretendido.

Passo 3 – Verificando sua configuração

Para verificar se as mudanças de configuração foram aplicadas, você irá executar alguns testes. O primeiro irá verificar qual módulo multi-processamento o Apache HTTP está usando. O segundo irá verificar se o PHP está usando o gerenciador FPM.

Cheque o servidor Apache HTTP executando o seguinte comando:

sudo apachectl -M | grep 'mpm'

Sua saída será a seguinte:

Output
mpm_event_module (shared)

Você pode repetir o mesmo para o módulo proxy e FastCGI:

sudo apachectl -M | grep 'proxy'

A saída irá mostrar:

Output
proxy_module (shared)proxy_fcgi_module (shared)

Se você quiser ver a lista completa dos módulos, você pode remover a segunda parte do comando depois de -M.

Agora é hora de verificar se o PHP está usando o Gerenciador de Processos FastCGI. Para fazer isso você irá escrever um script PHP muito pequeno que irá mostrar todas as informações relacionadas ao PHP.

Executar o seguinte comando para escrever um arquivo com o seguinte nome:

sudo vi /usr/local/www/apache24/data/info.php

Adicionar o seguinte conteúdo no arquivo info.php:

<?php phpinfo(); ?>

Agora visite a URL do seu servidor e anexe info.php no final assim: http://your_server_IP_address/info.php.

A entrada Server API será FPM/FastCGI.

Lembrar de excluir o arquivo info.php após esta verificação para que nenhuma informação sobre o servidor seja divulgada publicamente.

sudo rm /usr/local/www/apache24/data/info.php

Verificou o estado de funcionamento do módulo MPM, os módulos que manipulam o FastCGI, e o manuseio do código PHP.

Conclusão