Blog do Bragil

Depois de apresentar a configuração do Apache, PHP, APC e Memcached na primeira parte, agora é hora do Nginx. Basicamente, vamos utilizar o Nginx para servir apenas conteúdo estático (imagens, css, javascript, etc), pois ele possui recursos que garantem uma boa performance para este fim, como por exemplo usar o Memcached como cache. Quando ele recebe uma requisição para processar um arquivo PHP, ele “passa a bola” para o Apache, servindo também como um proxy. Fica mais fácil de entender olhando o fluxo abaixo:

                                PHP
requisição --> [Nginx] ------------> [Apache] ---> (PHP + APC)
                  |
                  |
                  |
                  | conteúdo estático
                  | (imagens, js, css, etc)
                  |
            (Memcached)

Após o famoso comando apt-get install nginx, devemos editar os arquivos de configuração e acertar os detalhes para que tudo isso aí em cima funcione corretamente. Vamos começar pelo arquivo /etc/nginx/nginx.conf, onde estão as configurações globais:

user www-data;
worker_processes  2;
 
error_log  /var/log/nginx/error.log;
pid        /var/run/nginx.pid;
 
events {
    worker_connections  1024;
}
 
http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;
 
    access_log  /var/log/nginx/access.log;
    client_body_temp_path /var/lib/nginx/body 1 2;
    sendfile        on;
 
    keepalive_timeout  65;
    tcp_nodelay        on;
 
    # Habilitar a compressão gzip
    gzip  on;
    gzip_buffers 32 8k;
    gzip_comp_level   6;
    gzip_http_version 1.0;
    gzip_min_length   0;
    gzip_types        text/html text/css image/x-icon
        application/x-javascript application/javascript text/javascript application/atom+xml application/xml ;
 
    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;
}

Não há muito segredo, principalmente se você já mexeu com os arquivos de configuração de outros web servers, como o Apache. O próximo passo agora é a configuração do virtual server, onde ficam os detalhes mais importantes. O arquivo para configuração do virtual server default é o /etc/nginx/sites-enabled/default:

# O alias "wordpressapache" aponta para o servidor Apache,
# onde serão redirecionados os scripts PHP para processamento.
upstream wordpressapache {
        server dominio.com:8080 weight=1 fail_timeout=120s;
}
 
server {
        listen   80;
        server_name www.dominio.com;
        access_log  /var/log/nginx/wordpressapache.access.log;
 
        location / {
                # Diretório raiz do site
                root /home/site;
                # As linhas abaixo servem para configurar o redirecionamento
                # para o servidor Apache, quando necessário.
                proxy_pass      http://wordpressapache;
                proxy_redirect off;
                proxy_set_header Host $host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                client_max_body_size 10m;
                client_body_buffer_size 128k;
                proxy_connect_timeout 90;
                proxy_send_timeout 90;
                proxy_read_timeout 90;
                proxy_buffer_size 4k;
                proxy_buffers 4 32k;
                proxy_busy_buffers_size 64k;
                proxy_temp_file_write_size 64k;
 
                # Aqui vão as configurações para que o Nginx use o Memcached
                # como cache, para aumentar a performance.
                set $memcached_key $uri;
                memcached_pass 127.0.0.1:11211;
                error_page 404 = @fallback;
        }
 
        # Caso a página não seja encontrada no memcached, passa para o Apache.
        location @fallback {
                proxy_pass      http://wordpressapache;
        }
 
        # Quando forem requisitados scripts PHP, redireciona para o Apache.
        location ~* wp\-.*\.php|wp\-admin {
                proxy_pass      http://wordpressapache;
        }
 
        # Todo o conteúdo estático será processado pelo Nginx.
        location ~* \.(htm|html|jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js)$ {
                root /home/site;
                expires max;
                break;
        }
 
        if (-f $request_filename) {
                break;
        }
 
        # Nega o acesso aos arquivos .htaccess
        location ~ /\.ht {
                deny all;
        }
 
}

Após acertar as configurações, reinicie o daemon do Nginx com o comando /etc/init.d/nginx restart. Podemos conferir o benchmark usando o Apache Benchmark:

 ab -n 1000 -c 5 http://www.dominio.com:80/
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
 
Benchmarking www.dominio.com (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests
 
Server Software:        nginx/0.6.32
Server Hostname:        www.dominio.com
Server Port:            80
 
Document Path:          /
Document Length:        91427 bytes
 
Concurrency Level:      5
Time taken for tests:   1.230 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      91715000 bytes
HTML transferred:       91427000 bytes
Requests per second:    812.80 [#/sec] (mean)
Time per request:       6.152 [ms] (mean)
Time per request:       1.230 [ms] (mean, across all concurrent requests)
Transfer rate:          72798.78 [Kbytes/sec] received
 
Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       1
Processing:     2    6   1.8      6      12
Waiting:        1    5   1.4      5      10
Total:          2    6   1.8      6      12
 
Percentage of the requests served within a certain time (ms)
  50%      6
  66%      7
  75%      7
  80%      7
  90%      8
  95%      9
  98%     10
  99%     10
 100%     12 (longest request)

O blog www.bragil.net passou por várias reformulações, dentre elas, a migração para WordPress 3 e a mudança de hosting para um Linux virtualizado. Graças a toda liberdade proporcionada por um ambiente com acesso root, foi possível fazer uma configuração de hosting bastante performática, que pode servir de base para outras aplicações.

A seguir vou detalhar o passo-a-passo resumido da configuração usada, que eu apelidei carinhosamente de NAPALM (sigla para Nginx + Apache + PHP + APC + Linux + Memcached).

Nginx é um servidor web que tem ganhado fama por ser extremamente rápido e também por ser uma excelente escolha para servir conteúdo estático, sendo usado como proxy para servidores de aplicação.

O Apache dispensa apresentações, assim como o PHP.

O APC é uma extensão para o PHP que otimiza o código intermediário e mantém um cache dos dados e do código compilado na memória compartilhada. Isto faz aumentar sensivelmente a performance de aplicações PHP.

O Memcached é um sistema de cache em memória de alta performance, bastante usado por grandes nomes da Internet, como Twitter, Flickr, Wikipedia, Youtube, dentre outros.

Quer performance para sua aplicação PHP? Basta misturar isso tudo!! E o melhor, a configuração é tranquila.

Para começar, instale o Apache 2 e o PHP 5. Não vou abordar a instalação e configuração do servidor Apache 2 + PHP 5, pois basta ir no Google, você encontrará bastante coisa.

Configuração do Apache

Depois do Apache + PHP instalados e configurados, altere a porta onde o Apache receberá as conexões para 8080. No Debian, edite as seguintes linhas do arquivo /etc/apache2/ports.conf para o seguinte:

NameVirtualHost dominio.com:8080
Listen 8080

E altere também a porta na configuração do virtual host:

VirtualHost dominio.com:8088

Isto significa que o Apache deixará de atender as requisições na porta 80 (padrão). Ou seja, usaremos o Apache apenas para processar os arquivos PHP, deixando todo o conteúdo estático (imagens, javascript, css, etc) para o Nginx.

Reinicie o servidor Apache. No Debian, o comando é /etc/init.d/apache2 restart.

Instalação e Configuração do APC

Agora é a instalação do APC. No Debian 5, isso é extremamente simples:

apt-get install php-apc

Após instalar, edite o arquivo /etc/php5/conf.d/apc.ini, adicionando as seguintes linhas:

extension=apc.so
apc.enabled=1

É possível configurar vários parâmetros, consulte a documentação do APC.

Para a nova configuração surtir efeito, reinicie o Apache:

/etc/init.d/apache2 restart

Instalação e Configuração do Memcached

apt-get install memcached

Após a instalação, edite o arquivo /etc/memcached.conf. Geralmente não é necessário mudar muita coisa, a não ser o tamanho máximo da memória para o Memcached (o default é 64 MB). O Memcached usa a porta 11211 por padrão, mas também é possível mudar. O arquivo de configuração vem todo comentado, não há segredo.

Para alterar o tamanho do espaço de memória, altere a linha -m 64 para o quanto for necessário (128, 256, 512, 1024,…). Lembrando que o Memcached só ocupa o espaço de memória que estiver em uso pelo cache, ele não reserva todo o espaço inicialmente. Feita a configuração, reinicie o daemon do Memcached com o comando:

/etc/init.d/memcached restart

Agora só falta o Nginx.

Instalação do Nginx

Adivinhem?

apt-get install nginx

Vamos abordar a configuração em um outro artigo. Até lá, que tal dar uma olhada nos arquivos de configuração do Nginx, em /etc/nginx ? Bons estudos!

Resolvi fazer este simples teste de performance para ver a diferença de tempo entre duas formas de concatenação de strings: usando a classe StringBuilder e usando o operador + para concatenação de strings em C#. O trecho de código que mede o tempo de execução entre as duas abordagens é bem simples, como segue:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

using System;
using System.Text;
using System.Diagnostics;
 
namespace TesteConcatStrings
{
    class Program
    {
        public static void Main(string[] args)
        {
            Stopwatch watch = new Stopwatch();
 
            // Testar concatenação usando StringBuilder
            StringBuilder sb = new StringBuilder();
 
            watch.Start();
 
            for (int i = 0; i < 10000; i++)
            {
                sb.Append("Testando a performance de concatenação de strings. ");
            }
 
            watch.Stop();
 
            Console.WriteLine(string.Format("Usando StringBuilder: {0} ms",
                                watch.ElapsedMilliseconds));
 
            string str = string.Empty;
 
 			// Teste de concatenação usando o operador +
            watch.Start();
 
            for (int i = 0; i < 10000; i++)
            {
                str += "Testando a performance de concatenação de strings. ";
            }
 
            watch.Stop();
 
            Console.WriteLine(string.Format("Usando operador + em string: {0} ms",
                                watch.ElapsedMilliseconds));
 
            Console.ReadKey();
        }
    }
}

Como podemos ver, cada teste é um loop for de 10000 iterações, onde em cada iteração é feita uma concatenação de strings. No primeiro usamos a classe StringBuilder e no segundo o operador + de concatenação de strings. Para medir o tempo, usamos a classe Stopwatch e os métodos Start() e Stop(). Ao fim da execução de cada teste, a propriedade ElapsedMilisecondes da classe Stopwatch retorna o resultado em milissegundos.

Agora, o resultado:

Realmente a diferença é impressionante! É claro que o resultado pode (e com certeza vai) variar de máquina para máquina, mas já dá para ter noção do tamanho da diferença de cada uma das abordagens de concatenação de strings.

E se você ainda não tem o hábito de usar StringBuilder em seus projetos, reveja seus conceitos… =)

Referências externas:

• Usando a classe StringBuilder
• StringBuilder – tratando Strings de modo mais eficiente