Acelere o carregamento de seu site com PHP Caching

julho 7, 2016 1:00 pm Publicado por Deixe um comentário

Criar um site dinâmico, de fácil manutenção e que carregue rápido é o desejo de todo desenvolvedor, mas para isso não existe uma fórmula mágica, é necessário conciliar diferentes ferramentas e técnicas.

Umas das minhas técnicas favoritas para aumentar a performance é o PHP Caching, que consiste em gerar e armazenar uma versão estática em HTML de uma página dinâmica criada em PHP.

Achou estranho? Sem problemas, vamos entender melhor o conceito e criarmos um exemplo.

O problema a ser resolvido, processamento desnecessário

Para cada acesso a um site dinâmico, o servidor geralmente realiza consultas no banco de dados, executa blocos de códigos e entrega uma página pronta para exibição.

Mesmo que os acessos a uma página ocorram com poucos segundos de diferença e nada no conteúdo tenha sido alterado, o servidor irá fazer o mesmo processo para cada solicitação, quantas vezes for preciso.

Isto é um trabalho desnecessário e que exige muito processamento do servidor, principalmente em momentos de tráfego intenso.

A solução, PHP Caching

Com a técnica PHP Caching, após o PHP processar uma página, ele armazena o conteúdo gerado em um arquivo HTML, e para os próximos acessos, durante um certo período que for definido, o servidor irá entregar o HTML já processado.

Sem a necessidade de consultar o banco de dados ou executar algum tipo de programação para montar a página, o servidor além de conseguir entregar uma página muito mais rapidamente, também suporta uma quantidade maior de acessos concorrentes.

Qual a diferença de tempo entre acessar uma página em PHP e uma HTML?

Vai depender muito da programação do site, mas quanto mais ações forem realizadas no backend, maior será o ganho com essa técnica.

Veja abaixo um exemplo utilizando uma página simples, aquela de boas vindas criada ao iniciarmos um projeto no Laravel:

A versão dinâmica foi entregue em 318 ms e a versão cacheada em 14 ms, 23 vezes mais rápido. A versão dinâmica foi entregue em 318 ms e a versão cacheada em 14 ms, 23 vezes mais rápido.

Desenvolvimento

Ficou interessado nesse ganho de performance? Então agora vamos recriar o código que foi utilizado no exemplo acima.

Para a criação do exemplo deste artigo utilizei o framework Laravel, mas você pode utilizar qualquer outro de sua preferência, apenas fique atento as diferenças e similaridades entre os frameworks para realizar as alterações correspondentes.

Não irei explicar como instalar um framework, nem outros aspectos básicos, pois esse não é o foco do artigo.

Organização das pastas e arquivos

Primeiro, inicie um novo projeto utilizando o framework de sua preferência, acesse a pasta raiz do site (no caso do Laravel é a pasta public) e crie uma nova pasta chamada versao-dinamica.

Agora mova os arquivos do framework responsáveis pelo controle de acesso que ficam na raiz para a pasta versao-dinamica que acabamos de criar, no caso do Laravel são os arquivos index.php e .htaccess.

Também na raiz, crie uma pasta chamada cache, como o nome já diz, ela será a responsável por armazenar as páginas cacheadas. A estrutura das pastas deve ter ficado assim:

pastas

Agora acesse a pasta da versão dinâmica do seu site pelo browser, no meu caso a url é:
http://localhost/phpcaching/public/versao-dinamica/

Uma página contendo erros será mostrada, isso acontece porque o arquivo index.php não consegue mais encontrar suas dependências. Para resolver isso é simples, abra o arquivo index.php e na chamada das dependências acrescente um ../.

Ou seja, onde esta escrito:
require __DIR__.'/../bootstrap/autoload.php';

Altere para:
require __DIR__.'/../../bootstrap/autoload.php';

E a linha que contém:
$app = require_once __DIR__.'/../bootstrap/app.php';

Altere para:
$app = require_once __DIR__.'/../../bootstrap/app.php';

Tente acessar novamente e a versão dinâmica voltará a funcionar.

Controle do cacheamento

Com as pastas criadas, iremos criar um arquivo para controlar o cacheamento, ele será chamado a cada acesso e funcionará da seguinte maneira:

Diagrama de atividades

Criação do código
Vamos colocar as mãos na massa, crie um arquivo chamado index.php na raiz do site com o código:

<?php
$validadeEmSegundos = 60;
$arquivoCache = 'cache/index.html';
$urlDinamica = 'http://localhost/phpcaching/public/versao-dinamica/';

// Verifica se o arquivo cache existe e se ainda é válido
if (file_exists($arquivoCache) && (filemtime($arquivoCache) > time() - $validadeEmSegundos)) {

    // Lê o arquivo cacheado
    $conteudo = file_get_contents($arquivoCache);
} else {

    // Acessa a versão dinâmica
    $conteudo = file_get_contents($urlDinamica);

    // Cria o cache
    file_put_contents($arquivoCache, $conteudo);
}

// Exibe o conteúdo da página
echo $conteudo;

Altere a variável $urlDinamica de acordo com o seu projeto, informando a url utilizada anteriormente para acessar a página dinâmica. É chato ter que fazer isso, mas é um sacrifício que será recompensado.

Faça um teste acessando a raiz do seu site, no meu caso:
http://localhost/phpcaching/public/

Se não houver nenhum erro, você verá o conteúdo da página e um arquivo HTML será criado na pasta cache.

É importante ressaltar que no primeiro acesso, não existe ganho de performance, pois o cache ainda não existe, somente nos acessos seguintes existirá o ganho.

Agora vamos incrementar nosso código para trabalhar com urls amigáveis, para isso, crie um arquivo chamado .htaccess com o código:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php?url=$1

E modifique o index.php da raiz para:

<?php
$validadeEmSegundos = 60;
$urlDinamica = 'http://localhost/phpcaching/public/versao-dinamica/';
$pastaCache = 'cache/';

// Verifica se está sendo acessada a página inicial ou uma interna
if (!isset($_GET['url'])) {
    $arquivoCache = $pastaCache.'index.html';
} else {
    $arquivoCache = $pastaCache.$_GET['url'].'/index.html';
    $urlDinamica .= $_GET['url'];
}

// Verifica se o arquivo cache existe e se ainda é válido
if (file_exists($arquivoCache) && (filemtime($arquivoCache) > time() - $validadeEmSegundos)) {

    // Lê o arquivo cacheado
    $conteudo = file_get_contents($arquivoCache);
} else {

    // Acessa a versão dinâmica
    $conteudo = file_get_contents($urlDinamica);

    // Monta a estrutura de pastas de acordo com a url acessada
    if (isset($_GET['url'])) {
        $pastas = explode('/', $_GET['url']);
        foreach ($pastas as $pasta) {
            $pastaCache .= $pasta.'/';
            if (!file_exists($pastaCache)) {
                mkdir($pastaCache);
            }
        }
    }

    // Cria o cache
    file_put_contents($arquivoCache, $conteudo);
}

// Exibe o conteúdo da página
echo $conteudo;

Crie uma nova rota para uma página interna, no caso do Laravel, é necessário abrir o arquivo app/Http/routes.php e acrescentar o código:

Route::get('/hello/world', function () {
    return view('welcome');
});

Acesse o endereço da página interna que acabou de ser criada, no meu caso:
http://localhost/phpcaching/public/hello/world

A página definida deverá ser mostrada e na pasta cache haverá novos diretórios, criados de acordo com a url acessada.

pastas-cache

Conclusão

Esta técnica é uma maneira eficiente de aumentar a performance de seu site, sem a necessidade de instalar nada, utilizando apenas comandos básicos do PHP e permitindo trabalhar com qualquer framework.

Tenham em mente que quanto mais básico for o código PHP, mais rápido ele será executado e isso fará toda a diferença num momento de pico.

Os códigos apresentados não são uma solução definitiva, mas uma base que podemos expandir de acordo com as necessidades de cada projeto.

Espero que essa dica tenha sido útil e que a performance esteja com você.


Este artigo foi escrito por Felipe Torretto.

Visite o nosso site para mais posts sobre desenvolvimento web! Tableless.

Source: Tableless

Categorizados em:

Este artigo foi escrito pormajor

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *