Como configurar o módulo mpm prefork para melhorar a performance do servidor web Apache

Ao concluir a instalação do seu servidor web Apache, pode ser interessante realizar alguns ajustes na sua configuração para obter um melhor desempenho ou adequá-lo às condições de hardware e de uso.
Neste post, vou mostrar como ajustar o mpm_prefork.conf do Apache.
apache-feather-logo-24colors
As informações contidas neste post foram testadas em um sistema operacional Debian 8.2 “jessie”, com o servidor web Apache 2.4 padrão da distribuição — e servem para Ubuntu 14.04 LTS (ou superior) também.
Outras diretivas e parâmetros de configuração, presentes no Apache, precisam ser incluídas no ato da compilação do software — e, portanto, não serão abordados neste texto.
Para saber a versão do seu servidor Apache, use o seguinte comando:

sudo apache2 -v
Server version: Apache/2.4.10 (Debian)
Server built:   Aug 28 2015 16:28:08

O que é o MPM prefork do Apache?

MPM é sigla para Multi-Processing Module ou Módulo de Processamento Múltiplo (em uma tradução livre).
É responsável pela implementação de um servidor web sob a “metodologia” non-threaded, em um servidor pre-forking, que lida com as requisições de modo similar ao do Apache 1.3. (Veja o quadro ao final deste texto)
É apropriado para sites que precisam evitar a criação de threads, para manter compatibilidade com bibliotecas non-thread-safe (PHP, por exemplo…).
O MPM é autorregulado, de modo que raramente é necessário ajustar diretivas de configuração.

O conteúdo do arquivo mpm_prefork.conf

Para ver o conteúdo do arquivo de configuração, tema deste artigo, use o comando cat.
O conteúdo do meu arquivo mpm_prefork.conf (tirando os comentários) é o que segue:

cat /etc/apache2/mods-enabled/mpm_prefork.conf
#
<IfModule mpm_prefork_module>
	StartServers			5
	MinSpareServers			5
	MaxSpareServers			10
	MaxRequestWorkers		150
	MaxConnectionsPerChild  	0
</IfModule>

Estes são os valores originais.
O significado de cada uma destas linhas de configuração é o que segue:

  • StartServers — número de processos do servidor para iniciar
  • MinSpareServers — quantidade mínima de processos do servidor a ser reservada
  • MaxSpareServers — quantidade máxima de processos do servidor a ser reservada
  • MaxRequestWorkers — número máximo de processos do servidor permitidos para iniciar.
    Em versões anteriores ao Apache 2.4, era chamado de MaxClients
  • MaxConnectionsPerChild — número máximo de requisições que um processo do servidor deve atender

Como funciona o MPM

Um único processo é responsável pelo lançamento dos processos filhos, que ouvem as conexões e as atendem, quando chegam.
O Apache sempre tenta manter vários processos do servidor em reserva, prontos a atender novas requisições — desta forma, economiza tempo para criar novos processos filhos (forking) para atender a novas requisições.
As diretivas StartServers, MinSpareServers, MaxSpareServers e MaxRequestWorkers controlam o modo como os processos pais criam novos processos filhos para servir às novas requisições.
Em geral, o Apache é bom em se autorregular em função da demanda, de modo que muitos administradores de sites não vão precisar ajustar estas diretivas.
Manter os valores padrão é o recomendado para a maioria, portanto.
Sites que precisam servir mais do que 256 requisições simultâneas, contudo, podem precisar aumentar o valor de MaxRequestWorkers.
Caso os recursos de memória sejam limitados, pode ser necessário reduzir este valor para prevenir que o servidor faça thrashing — ou seja, faça uso da memória swap em disco (o que vai ocasionar um problema severo de lentidão).

O mais importante é que o MaxRequestWorkers seja grande o suficiente para comportar a quantidade de requisições simultâneas que você espera receber.
Ao mesmo tempo, o valor desta diretiva deve ser pequeno o suficiente para assegurar que haja memória RAM física suficiente para todos os processos.

Enquanto o processo pai é costumeiramente iniciado como root (UNIX e GNU/Linux) para se conectar à porta 80, os processos filhos são iniciados pelo Apache com privilégios de usuário comum.
As diretivas de Usuário e Grupo são usados para ajustar os privilégios dos processos filhos do Apache — que só precisam estar habilitados a ler aquele conteúdo que será servido.
A diretiva MaxRequestsPerChild controla a frequencia com que o servidor recicla processos, matando os velhos e criando novos.

A diretiva StartServers

Este parâmetro ajusta o número de processos filhos que devem ser criados na inicialização do Apache.
Uma vez que este número é controlado dinamicamente, em função da carga de trabalho do servidor web, geralmente há poucas razões para alterar este número.

A diretiva MaxSpareServers

O valor padrão desta diretiva é 10, de acordo com a documentação oficial do Apache (link no final do texto).
Este parâmetro determina o número máximo de processos ociosos do servidor.
É denominado processo ocioso aquele que não esteja trabalhando com alguma requisição.
O processo pai vai ‘matar’ os processos filhos ociosos, assim que sua quantidade exceder o limite determinado em MaxSpareServers.
Ajustar este parâmetro só é necessário em sites muito ocupados.
Se você ajustar o valor deste parâmetro para um número igual ou menor do que o valor de MinSpareServers, o Apache irá automaticamente reajustá-lo para MinSpareServers + 1.

Ajustar os parâmetros MinSpareServers e MaxSpareServers para valores extremos é quase sempre uma idéia ruim.
Ao fazer isto, você adiciona ao servidor um excesso de carga de trabalho ou overhead, por que ele precisará terminar/iniciar, sem necessidade, os workers de reserva em execução no background.

A diretiva MinSpareServers

Esta variável ajusta o número desejado de processos filhos ociosos do servidor.
Como você já sabe, processo ocioso é aquele que não está lidando com alguma requisição.
Havendo menos destes processos do que a quantidade determinada em MinSpareServers, o processo pai irá iniciar a criação de novos processos filhos, a uma taxa máxima de 1 por segundo.

A diretiva MaxConnectionsPerChild

Delimita o número de conexões com que cada processo filho pode trabalhar individualmente.
Após atingir o valor definido em MaxConnectionsPerChild, o processo filho irá terminar (morrer).
Você pode ajustar o valor para 0 (zero), se quiser que o processo nunca expire.
Ao usar valores diferentes de 0, contudo, você vai limitar a quantidade de memória que cada processo poderá consumir em caso de vazamento acidental de memória.

Conclusão

Quando terminar de configurar estes parâmetros, não use o reload para reiniciar o Apache.
O certo é parar o servidor e, em seguida, iniciá-lo.
A razão disto é que nem todas as mudanças farão efeito até que você desligue o processo principal (inicial) do Apache.
No Debian, use o seguinte comando para isto:

sudo service apache2 stop
sudo service apache2 start
sudo service apache2 status

O resultado do último comando deve ser parecido com o que segue:

● apache2.service - LSB: Apache2 web server
   Loaded: loaded (/etc/init.d/apache2)
   Active: active (running) since Sex 2015-12-04 10:00:49 BRT; 1min 7s ago
  Process: 7399 ExecStop=/etc/init.d/apache2 stop (code=exited, status=0/SUCCESS)
  Process: 6561 ExecReload=/etc/init.d/apache2 reload (code=exited, status=0/SUCCESS)
  Process: 7451 ExecStart=/etc/init.d/apache2 start (code=exited, status=0/SUCCESS)
   CGroup: /system.slice/apache2.service
           ├─7465 /usr/sbin/apache2 -k start
           ├─7469 /usr/sbin/apache2 -k start
           ├─7470 /usr/sbin/apache2 -k start
           ├─7471 /usr/sbin/apache2 -k start
           ├─7472 /usr/sbin/apache2 -k start
           ├─7473 /usr/sbin/apache2 -k start
           └─7474 /usr/sbin/apache2 -k start

Dez 04 10:00:48 ultra apache2[7451]: Starting web server: apache2AH00558:...e
Dez 04 10:00:49 ultra apache2[7451]: .
Hint: Some lines were ellipsized, use -l to show in full.

O que são Non-threaded e Pre-fork no Apache?

Servidores web diferentes, tem diversas técnicas de manipulação das requisições HTTP em paralelo.
Uma das metodologias mais populares envolve o uso de threads — ou seja, o servidor web vai criar/dedicar uma única thread a cada nova requisição recebida.
O servidor web Apache suporta múltiplos modelos de tratamento de requisições — um deles, o MPM, usa threads.
Além disto, suporta um outro modelo chamado prefork MPM, que usa processos — no qual o servidor web cria/dedica um único processo a cada nova requisição.

Referências:

https://httpd.apache.org/docs/2.2/mod/prefork.html.
http://askubuntu.com/questions/488044/neither-prefork-nor-worker-settings-are-found-in-etc-apache2-apache2-conf-why.
http://wiki.zarafa.com/index.php/Apache_tuning.
http://stackoverflow.com/questions/1623914/what-is-thread-safe-or-non-thread-safe-in-php.
http://serverfault.com/questions/684424/how-to-tune-apache-on-ubuntu-14-04-server.

Como instalar o PHP 7.0 no Ubuntu 14.04 e no Debian 8

O PHP 7.0 é, provavelmente, a próxima grande sensação do início do ano de 2016, quando a versão final será lançada — previsto pra Março.
Os primeiros RC (Release Candidates) têm previsão de lançamento a partir de Junho de 2016.
Neste artigo, eu vou mostrar como instalar a versão beta, para você já poder testar os novos recursos da linguagem e verificar sua impressionante velocidade.

Eu sei que não estou escrevendo para crianças, mas… é sempre bom frisar que software em fase beta, não deve ser instalado em máquinas de produção — nem nos servidores, nem no seu notebook ou desktop de trabalho.

Logo unofficial PHP 7
O PHP 7.0, no momento em que estou escrevendo, conflita com o PHP 5.x — portanto, só será possível ter um dos dois instalado em seu sistema.
Eu testei a instalação, com sucesso, no Debian 8.2 “Jessie”, e Apache 2.4 — segundo desenvolvedores, há conflito com versões anteriores do Apache.
Os desenvolvedores afirmam, contudo, que o procedimento funciona para o Ubuntu 14.04 LTS.

Como configurar o sistema, baixar e instalar os pacotes do PHP 7

Nos procedimentos que seguem, vamos configurar o arquivo sources.list (não sem antes fazer um backup) para ele passar a buscar informações dos repositórios contendo os pacotes do PHP7.
Em seguida, vamos configurar a chave gpg e atualizar os repositórios.
Feito isto, o sistema já estará pronto para receber o novo PHP 7.0.
Comece com o backup:

sudo cp /etc/apt/sources.list /etc/apt/sources.list.backup-2015-11-17

Acrescente as seguintes linhas ao final do arquivo /etc/apt/sources.list:

# dotdeb PHP7 repositórios
deb http://packages.dotdeb.org jessie all
deb-src http://packages.dotdeb.org jessie all

Vamos à configuração da chave gpg…

wget https://www.dotdeb.org/dotdeb.gpg
sudo apt-key add dotdeb.gpg

Agora, atualize os repositórios e instale o PHP 7:

sudo apt-get update
sudo aptitude install php7.0

Divirta-se!

Referências:

https://wiki.php.net/rfc/php7timeline.
https://www.dotdeb.org/instructions/.

Como criar tabelas temporárias no MySQL

O uso de uma tabela temporária no MySQL, permite realizar testes ou serviços em uma entidade transitória, sem se preocupar em limpar a sujeira depois.
Ao desconectar-se do servidor, as tabelas temporárias são automaticamente descartadas.
Captur de tela - mysql create temporary table

Quando é útil usar tabelas temporárias no MySQL

Algumas operações requerem que a existência de algumas informações seja curta — e que elas sejam removidas, quando não mais forem necessárias.
A parte da remoção pode ser feita automaticamente pelo MySQL.
Você não precisa se lembrar de apagar uma tabela, que não tem mais serventia, com o comando DROP TABLE.
Para isto, basta criar uma tabela, com a opção TEMPORARY, assim: CREATE TABLE TEMPORARY Nome_da_tabela.
Este assunto foi abordado en passant no artigo Como criar tabelas no MySQL. Vamos procurar nos aprofundar um pouco mais neste assunto, aqui.

Como criar tabelas temporárias no MySQL

Você pode criar tabelas temporárias, mais ou menos, da mesma forma que cria as normais. Só que vai acrescentar a opção TEMPORARY.
Se eu quiser criar uma tabela temporária com o nome de ClientesCidadesTemp a partir da tabela ClientesCidades, uso o seguinte comando:

CREATE TEMPORARY TABLE ClientesCidadesTemp SELECT * FROM ClientesCidades;
Query OK, 200 rows affected (0.27 sec)
Records: 200  Duplicates: 0  Warnings: 0

Use o comando EXPLAIN para verificar a nova tabela temporária:

EXPLAIN ClientesCidadesTemp;
+---------------+-----------------------+------+-----+---------+-------+
| Field         | Type                  | Null | Key | Default | Extra |
+---------------+-----------------------+------+-----+---------+-------+
| id            | mediumint(8) unsigned | NO   |     | 0       |       |
| NomeCliente   | varchar(255)          | YES  |     | NULL    |       |
| IdadeCliente  | mediumint(9)          | YES  |     | NULL    |       |
| CidadeCliente | varchar(255)          | YES  |     | NULL    |       |
| CredCliente   | mediumint(9)          | YES  |     | NULL    |       |
+---------------+-----------------------+------+-----+---------+-------+
5 rows in set (0.03 sec)

Entenda melhor as tabelas temporárias

Se há vantagens em usar tabelas temporárias, por outro lado, há algumas características às quais você precisa estar atento:

  • Se você quiser reusar uma tabela temporária, dentro da mesma sessão, vai precisar removê-la, antes. Tentar criar uma segunda tabela com o mesmo nome da primeira, temporária, vai resultar em erro, caso ela não tenha sido apagada.
  • Uma das propriedades das tabelas temporárias permite que possam ser criadas com o mesmo nome de uma outra tabela permanente e preexistente.
    Neste caso, a tabela permanente fica “escondida”, durante a sessão ou enquanto a temporária ainda existir.
    Isto pode ser útil para criar e testar queries, usando o nome de uma tabela existente, sem afetá-la.
  • Algumas APIs, suportam conexões persistentes em um ambiente web. O seu uso previne que as tabelas temporárias expirem, como já é de esperar, ao fim do script — e possam continuar a ser usadas por outros scripts.
  • O MySQL é um ambiente de servidor de banco de dados com capacidade para atender a múltiplos clientes, cada qual com sua sessão.
    Desta forma, é possível que cada cliente tenha aberto uma tabela temporária. E nada impede que elas tenham os mesmos nomes — cada qual na sua sessão.
  • Há vários outros cuidados a serem tomados, quando estamos lidando com um ambiente de tabelas temporárias.
    Se o seu script cria e modifica tabelas temporárias que “escondem” tabelas permanentes com o mesmo nome, é necessário criar rotinas que verifiquem e testem se você ainda está trabalhando na tabela temporária, como esperado.
    Se um dos programas cliente fizer uma reconexão, após uma queda, você poderá alterar uma tabela permanente, em vez de uma temporária.

Referências:
Leia mais sobre como fazer conexões (persistentes) a um servidor MySQL a partir de um script PHP.

Qual a importância da linha de comando ou console para web designers?

A linha de comando, ou console, é onde se pode fornecer uma sequência de comandos, para executar um aplicativo ou vários, realizar uma tarefa ou uma sequência de tarefas etc.
Amparados por parâmetros, opções e cláusulas os comandos, dados no console ou no terminal, têm uma enorme (quase infinita) flexibilidade.
Command line tools for web design cover picture

Administradores de sistemas, desenvolvedores, hackers, autores etc. já descobriram o “poder divinal” que um terminal oferece a quem se dispõe a aprender a dominá-lo.

Mas, enfim… qual a utilidade ou a importância desta ferramenta a um web designer?
Se por um lado, a interface gráfica tem um grande apelo visual e facilidade de uso, ela também prejudica a flexibilidade e a agilidade — nenhum designer de interface “enche a tela” de botões para realizar uma determinada tarefa de n maneiras diferentes.
Além disto, a interface gráfica é comumente lenta em computadores mais antigos — o que implica na demora para iniciar a execução de alguma atividade.
O terminal permite determinar exatamente como se deseja que uma tarefa (ou uma sequência de tarefas) seja executada e ela começa a partir do momento em que você dá Enter.

Não abro mão da flexibilidade e da agilidade que só o terminal proporciona. É uma ferramenta que eleva exponencialmente o meu nível de controle sobre o sistema.

Terminal do Linux, do Windows ou do MacOS?

Se você ainda não usa o GNU/Linux, no seu trabalho, insisto: você deveria começar a considerar seriamente esta opção profissional — que te pode possibilitar trabalhar com softwares 100% legalizados a custos muito baixos ou gratuitos.
O terminal do Windows também oferece uma razoável dose de flexibilidade. O sistema, contudo, foi desenhado para que se usassem apenas as opções da interface gráfica. O processo de “castração” do terminal DOS, começou a partir do Windows 3.0 (Maio/1990) e tem se fortalecido até os dias de hoje.
A Microsoft tem se esforçados para esconder o terminal do usuário, como se fosse um parente indesejável.
O MacOS foi construído sobre a plataforma Unix FreeBSD e tem um terminal poderoso. A cultura dos usuários, incentivados pelo departamento de marketing da Apple constitui uma forte barreira para seu uso. Mas ele está lá. 😉
Usuários do MacOS X podem usar o Homebrew para instalar as ferramentas que não são parte do pacote de aplicativos padrão.
O Linux, como estes outros sistemas operacionais, também veio do ambiente em caracteres e evoluiu para o uso predominante da interface gráfica.
O Linux, contudo, convive muito bem com o uso do terminal. Todas as grandes distribuições oferecem facilidades de acesso ao console.
Embora haja ferramentas visuais sofisticadas para instalar softwares, muitos usuários Linux se sentem muito à vontade para instalar seus aplicativos com as ferramentas de linha de comando, como o apt-get — sendo que, na maioria das vezes, lhes basta copiar e colar a instrução de um site no seu terminal, podendo fazer as mudanças que achar pertinentes, se for o caso.
Encontre mais artigos sobre o uso do apt-get, na caixa de busca deste site.

O que há na linha de comando para profissionais do web design?

Há muito que um webdesigner já faz, usando a interface gráfica, que pode ser feito na linha de comando.
Eu sou um evangelista do uso do software livre e do uso de comandos no terminal — mas eu entendo, veja bem, que você deva usar sempre o que lhe oferecer os melhores resultados.
Tudo o que este artigo pede é que você abra os olhos para o terminal do seu sistema e veja (com generosidade e sem preconceitos) se há lá alguma coisa que lhe possa ser útil. Só isso.
Veja alguns pontos que Cadmin’s blog elenca como favoráveis ao uso do terminal:

  • O uso de pacotes de softwares de terceiros se torna invisível — Webdesigners usam vários pacotes de terceiros, tais como o Bootstrap, jQuery, Normalize.css etc.
    A gestão de pacotes, contudo, é muito morosa, quando feita manualmente.
    Com o uso do terminal, é possível inserir os pacotes requeridos pelo seu projeto com alguns comandos: bower install jquery, bower update jquery
  • Para quem não sabe, o Bower é um gestor de pacotes, semelhante ao apt-get ou o PIP.

  • No terminal, compilar é muito mais rápido — HTML, CSS e JavaScript são 3 linguagens sempre presentes em projetos de design web, entre outras. As ferramentas da linha de comando tornam a produção e entrega de código mais eficiente nestas linguagens.
    Eventualmente, compilar pré-processadores, é muito mais rápido na linha de comando.
  • Ferramentas de teste de sites — Há várias ferramentas de teste da rede e da eficiência de seu website ou do provedor em que ele se encontra hospedado, que podem ser invocadas do terminal — não somente as opções de execução, mas também as informações fornecidas, são extremamente flexíveis e maleáveis.

Uma vez iniciado o uso da linha de comando, você adquire o costume e um mundo novo de possibilidades surge, ao alcance de seus dedos.

Referências

Site oficial do Bower: bower.io
How important is command line for web designers — http://auckland.fortuneinnovations.com/how-important-command-line-web-designers
Command line tools for frontend developers — http://seesparkbox.com/foundry/command_line_tools_for_frontend_developers

Como usar expressões com variáveis para calcular os valores da cláusula LIMIT no MySQL

A possibilidade de paginar ou seccionar os resultados de suas queries ou consultas MySQL, tornam a cláusula LIMIT uma das mais requisitadas por desenvolvedores.
logo PHP mesclado ao logo MySQL
Enquanto outras cláusulas são usadas para filtrar a exibição de resultados, LIMIT é usado para inibir o envio de resultados do servidor — motivo pelo qual ele ajuda a poupar o fluxo de informações inúteis a trafegar pela rede.
Se você quiser entender melhor o uso da cláusula LIMIT e das variáveis no MySQL, sugiro usar o quadro de pesquisa, no topo desta página, para encontrar outros posts sobre estes assuntos — vale a pena!

Como criar expressões usando a cláusula LIMIT do MySQL

O MySQL só vai aceitar inteiros literais em expressões — a menos que você envie suas consultas de dentro de um script. Neste caso, você tem mais flexibilidade para elaborar suas expressões e inserir os valores resultantes nas strings das consultas.
Se vocẽ tentar incluir uma expressão matemática, direto na linha de comando do seu cliente MySQL, vai obter um erro:

SELECT * FROM ClientesCidades LIMIT 2+2;

Isto, simplesmente, não é permitido — e vai provavelmente retornar um erro como o reproduzido abaixo:

ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '+2' at line 1

O uso de variáveis, também não é permitido, deste jeito:

SELECT * FROM profile LIMIT @pula_contagem, @exibir_contagem;

A expressão precisa ser criada, primeiro. Depois, seu resultado, pode ser inserido em uma query.
Mesmo de dentro do PHP, isto não é aceito:

$str = "SELECT * FROM ClientesCidades LIMIT $a + $b";

Para evitar o problema, tente elaborar a expressão primeiro:

$c = $a + $b;
$str = "SELECT * FROM ClientesCidades LIMIT $c";

Uma outra abordagem possível (também de dentro do PHP), seria esta:

$str = "SELECT * FROM ClientesCidades LIMIT ".($a + $b);

Fique atento para as aspas e para os parênteses.