A Minha Plataforma WordPress Ideal

Instruções passo a passo de como configurar um servidor Linux com a seguinte combinação:

Nginx + PHP-FPM + APC + Workpress Multisite + WP Super Cache

Distribuição de Linux: Ubuntu 10.04

1) Preparação e configurações iniciais

Instalar sysv-rc-conf, um programa para gerir os serviços instalados e configurar a timezone correcta. Adicionalmente, pode ser necessário acrescentar o Locale pt_PT:

$> apt-get install sysv-rc-conf
$> dpkg-reconfigure tzdata
$> locale-gen pt_PT

Remover PHP e Apache, caso venham instalados por defeito.

$> apt-get remove "php*"
$> apt-get remove "apache*"

Instalar pacotes necessários para compilar Nginx e PHP a partir do código fonte.

$> apt-get install make bison flex gcc patch autoconf subversion
$> apt-get install libxml2-dev libbz2-dev libpcre3-dev libssl-dev zlib1g-dev libmcrypt-dev libmhash-dev libmhash2 libcurl4-openssl-dev libpq-dev
$> apt-get install libc-client-dev libpng12-dev libjpeg-dev libgd2-xpm-dev

2) Instalar Nginx

$> cd /usr/src/
$> wget http://nginx.org/download/nginx-1.2.4.tar.gz
$> tar -xzf nginx-1.2.4.tar.gz
$> cd nginx-1.2.4

$> ./configure \
--prefix=/usr/local/nginx \
--conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--http-log-path=/var/log/nginx/access.log \
--pid-path=/var/run/nginx.pid  \
--user=www-data \
--group=www-data \
--with-http_ssl_module \
--with-http_stub_status_module \
--without-mail_pop3_module \
--without-mail_imap_module \
--without-mail_smtp_module \
--without-http_proxy_module \
--without-http_scgi_module \
--without-http_uwsgi_module \
--without-http_ssi_module

$> make
$> make install

Criar um script para gerir o serviço.
Ver exemplo ou http://wiki.nginx.org/Nginx-init-ubuntu

Criar o ficheiro “nginx” em “/etc/init.d/” com permissões de execução e correr o comando “update-rc.d” para gerar os ficheiros necessário nos vários run-levels. Por último configurar o arranque deste serviço com o programa “sysv-rc-conf”.

$> chmod +x /etc/init.d/nginx
$> /usr/sbin/update-rc.d -f nginx defaults
$> sysv-rc-conf

 3) Installar PHP-FPM + APC

$> wget http://pt.php.net/distributions/php-5.4.7.tar.gz
$> tar xzf php-5.4.7.tar.gz
$> cd php-5.4.7

$> ./configure --enable-fpm --with-fpm-user=www-data  --with-fpm-group=www-data --with-curl --with-gd --with-jpeg-dir --with-freetype-dir --enable-gd-native-ttf --with-mysql=mysqlnd --with-mysqli=mysqlnd  --with-pear --enable-soap --with-imap --with-imap-ssl  --with-kerberos --disable-pdo --with-zlib --with-openssl  --enable-zip

$> make
$> make install

$> cp /usr/src/php-5-4-7/php.ini-prodution /usr/local/lib/php/php.ini
$> ln -s /usr/local/lib/php/php.ini /usr/local/lib/php.ini
$> pear config-set php_ini /usr/local/lib/php/php.ini
$> pecl config-set php_ini /usr/local/lib/php/php.ini

Instalar o APC

pecl install apc

Editar “php.ini” para corrigir/adicionar alguns parâmetros e incluir a chamada ao APC

date.timezone = Europe/Lisbon
cgi.fix_pathinfo=0
mysql.default_socket = /var/run/mysqld/mysqld.sock
mysqli.default_socket = /var/run/mysqld/mysqld.sock
extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/apc.so

Configurar PHP-FPM

cp /usr/local/etc/php-fpm.conf.default /usr/local/etc/php-fpm.conf

Editar o ficheiro “php-fpm.conf”

pid = /usr/local/var/run/php-fpm.pid
error_log = /var/log/php-fpm/php-fpm.log
listen = /tmp/php-fpm.sock 
pm.status_path = /php-fpm-status

Criar o ficheiro “php-fpm” em “/etc/init.d/” com permissões de execução e correr o comando “update-rc.d” para gerar os ficheiros necessário nos vários run-levels. Por último configurar o arranque deste serviço com o programa “sysv-rc-conf”.

$> cp /usr/src/php-5.4.7/sapi/fpm/init.d.php-fpm /etc/init.d/php-fpm
$> chmod +x /etc/init.d/php-fpm
$> /usr/sbin/update-rc.d -f php-fpm defaults
$> sysv-rc-conf

4) Configurar o Nginx

Vamos usar 4 ficheiros de configuração, que serão colocados na directoria /etc/nginx/

Ficheiro principal nginx.conf, que chama os ficheiros de cada site individual a partir da directoria /etc/nginx/sites-enabled/

worker_processes  2;

events {
    worker_connections  1024;
}

error_log /var/log/nginx/error.log warn;

http {
	include mime.types;
	default_type application/octet-stream;
	index index.html index.php
	sendfile on;
	tcp_nopush on;	
	fastcgi_buffers 64 4k;
	keepalive_timeout 5;
	client_max_body_size 4m;

	gzip on;
	gzip_min_length 1100;
	gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript image/x-icon;

	fastcgi_intercept_errors on;	
	include sites-enabled/*.conf;
}

Ficheiro default_settings.conf, a ser chamado na configuração individual de cada site.

# catch static file requests, such as images, css, js
location ~* \.(?:ico|css|js|gif|jpg|jpeg|png|swf|mp3)$ {
	access_log off;
	expires max;
}

location = /robots.txt  { access_log off; log_not_found off; }
location = /favicon.ico { access_log off; log_not_found off; }	
location ~ /\.          { access_log off; log_not_found off; deny all; }
location ~ ~$           { access_log off; log_not_found off; deny all; }

Ficheiro fastcgi.conf, a ser chamado na configuração individual de cada site:

fastcgi_param  SCRIPT_FILENAME    $document_root$fastcgi_script_name;
fastcgi_param  QUERY_STRING       $query_string;
fastcgi_param  REQUEST_METHOD     $request_method;
fastcgi_param  CONTENT_TYPE       $content_type;
fastcgi_param  CONTENT_LENGTH     $content_length;

fastcgi_param  SCRIPT_NAME        $fastcgi_script_name;
fastcgi_param  REQUEST_URI        $request_uri;
fastcgi_param  DOCUMENT_URI       $document_uri;
fastcgi_param  DOCUMENT_ROOT      $document_root;
fastcgi_param  SERVER_PROTOCOL    $server_protocol;
fastcgi_param  HTTPS              $https if_not_empty;

fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
fastcgi_param  SERVER_SOFTWARE    nginx/$nginx_version;

fastcgi_param  REMOTE_ADDR        $remote_addr;
fastcgi_param  REMOTE_PORT        $remote_port;
fastcgi_param  SERVER_ADDR        $server_addr;
fastcgi_param  SERVER_PORT        $server_port;
fastcgi_param  SERVER_NAME        $server_name;

fastcgi_pass unix:/tmp/php-fpm.sock;
# fastcgi_pass 127.0.0.1:9000;

E o ficheiro wordpress-network-super-cache.conf, que pode ser usado em qualquer site a correr em WordPress Multisite com WP Super Cache.  Utiliza os dois ficheiros de configuração anteriores:

# WordPress multisite rules.
# Designed to be included in any server {} block.

charset UTF-8;

# This order might seem weird - this is attempted to match last if rules below fail.
# http://wiki.nginx.org/HttpCoreModule
location / {
	try_files $uri $uri/ /index.php?$query_string;
}

# Add trailing slash to */wp-admin requests.
rewrite /wp-admin$ $scheme://$host$uri/ permanent;

include default_settings.conf;

# Deny access to any files with a .php extension in the uploads directory
location ~* /(?:uploads|files)/.*\.php$ {
	deny all;
}

# Pass uploaded files to wp-includes/ms-files.php.
rewrite /files/$ /index.php last;

# For multisite: create symlinks to the correct subdirectory structure to get some performance gains.
set $cachetest "$document_root/wp-content/ms-filemap/${host}${uri}";
if ($uri ~ /$) {
	set $cachetest "";
}
if (-f $cachetest) {
	# Rewrites the URI and stops rewrite processing so it doesn't start over and attempt to pass it to the next rule.
	rewrite ^ /wp-content/ms-filemap/${host}${uri} break;
}

if ($uri !~ wp-content/plugins) {
	rewrite /files/(.+)$ /wp-includes/ms-files.php?file=$1 last;
}

# WP Super Cache rules.
set $supercacheuri "";
set $supercachefile "$document_root/wp-content/cache/supercache/${http_host}${uri}index.html";
if (-e $supercachefile) {
	set $supercacheuri "/wp-content/cache/supercache/${http_host}${uri}index.html";
}
# If this is a POST request, pass the request onto WordPress.
if ($request_method = POST) {
	set $supercacheuri "";
}
# If there is a query string, serve the uncached version.
if ($query_string) {
	set $supercacheuri "";
}
# Logged in users and those who have posted a comment get the non-cached version.
if ($http_cookie ~* comment_author_|wordpress_logged_in|wp-postpass_) {
	set $supercacheuri "";
}
# Stop processing if the supercache file is valid.
if ($supercacheuri) {
	rewrite ^ $supercacheuri break;
}

# Rewrite multisite '.../wp-.*' and '.../*.php'.
if (!-e $request_filename) {
	rewrite ^/[_0-9a-zA-Z-]+(/wp-.*) $1 last;
	rewrite ^/[_0-9a-zA-Z-]+.*(/wp-admin/.*\.php)$ $1 last;
	rewrite ^/[_0-9a-zA-Z-]+(/.*\.php)$ $1 last;
}

# Pass all .php files onto a php-fpm/php-fcgi server.
location ~ \.php$ {
	try_files $uri =404;
	include fastcgi.conf;
}

Vamos incluir agora mais 2 ficheiros. Um que serve de configuração por defeito quando o servidor é acedido pelo endereço IP, ou por um hostname que não é “apanhado” por nenhum dos blocos “server” das configurações individuais. Estes ficheiros devem ser colocados na directoria /etc/nginx/sites-available/.

O primeiro vai se chamar 10-default.conf e permite testar a configuração do PHP.

### configuração que responde por defeito caso nenhum outro bloco "server" corresponda ao host ###
server {
	client_max_body_size 32K;
	listen 80 default_server;
	server_name _;
	root /var/www/nginx-default;

	include default_settings.conf;

	location ~ ^/php-fpm-status$ {
		fastcgi_index index.php;
		include fastcgi.conf;
	}

	# Pass all .php files onto a php-fpm/php-fcgi server.
	location ~ \.php$ {		
		include fastcgi.conf;
	}
}

O  segundo é um exemplo dum “virtual host” a correr em WordPress. Vamos chamar-lhe 30-wordpress-ms.conf. Para cada multisite individual, só temos que criar um ficheiro destes e mudar o “server_name”.

### your.domain.tld ###
server {
	server_name    your.domain.tld;
	root           /var/www/wordpress;
	include wordpress-network-super-cache.conf;
}

Não se esquecer de activar os “symbolic links”

$> cd /etc/nginx/sites-enabled/
$> ln -s ../sites-available/10-default.conf 10-default.conf
$> ln -s ../sites-available/30-wordpress-ms.conf 30-wordpress-ms.conf

5) Iniciar os serviços e testar a configuração

$> cd 
$> mkdir /var/www/nginx-default
$> cd /var/www/nginx-default
$> echo '<?php phpinfo(); ?>' > php.php
$> cp /usr/local/lib/php/apc.php ./
$> /etc/init.d/php-fpm start
$> /etc/init.d/nginx start

Através dum browser, aceder aos endereços http://x.x.x.x/php.php e http://x.x.x.x/apc.php

No segundo endereço, temos acesso a um conjunto de informação útil sobre o APC.

6) Instalar WordPress Multisite

$> cd /var/www/
$>  wget http://pt.wordpress.org/wordpress-3.4.2-pt_PT.zip
$> unzip wordpress-3.4.2-pt_PT.zip
$> chown -R www-data wordpress/

Criar um utilizador e uma tabela no MySQL e editar o ficheiro wp-config.php com os dados correctos. Utilizar as instruções em http://codex.wordpress.org/Create_A_Network.

Neste passo basta acrescentar:

/* Multisite */
define('WP_ALLOW_MULTISITE', true);

Aceder com um browser a http://your.domain.tld/ e concluir a instalação do WordPress.

Ir a “Ferramentas > Configuração da Rede” para seleccionar o tipo de rede. Escolher a opção Sub-domínios, que em conjunto com plugin “WordPress MU Domain Mapping” permite criar sites com domínios diferentes.

Após esta operação, seguir as instruções para completar a a activação de rede. São 3 passos, sendo que podemos ignorar o 3º, que só se aplica ao Apache.

Passo 1) criar a directoria blogs.dir e dar permissões de escrita ao utilizador www-data:

$> cd /var/www/wordpress/wp-content/
$> mkdir blogs.dir
$> chown -R www-data blogs.dir/

Passo 2) acrescentar novas definições no ficheiro wp-config.php:

define('MULTISITE', true);
define('SUBDOMAIN_INSTALL', true);
$base = '/';
define('DOMAIN_CURRENT_SITE', 'your.domain.tld');
define('PATH_CURRENT_SITE', '/');
define('SITE_ID_CURRENT_SITE', 1);
define('BLOG_ID_CURRENT_SITE', 1);

Para concluir a activação basta fazer novamente login no WordPress. Verificamos que o Painel tem agora novas opções para administrar a rede de sites.

7) Instalar WordPress MU Domain Mapping + WP Super Cache

Instalar ambos os plugins normalmente, através do Painel de Administração da Rede. Completar a instalação com as configurações manuais seguindo as instruções em:
http://wordpress.org/extend/plugins/wordpress-mu-domain-mapping/installation/
http://wordpress.org/extend/plugins/wp-super-cache/installation/

O plugin MU Domain Mapping permite que cada site tenha o seu próprio domínio.

O WP Super Cache permite gerar páginas estáticas que são servidas directamente pelo Nginx, sem sequer passar pelo PHP-FPM.

Para cada site adicionado é necessário ir a “Opções > Domains” e acrescentar o Site ID e respectivo Domain pretendido. Depois é necessário voltar à administração de Sites e corrigir o domínio do novo site.

Uma vez que o WordPress Multisite recorre ao PHP para todos os pedidos de media carregados (imagens, etc), é necessário fazer uso das regras utilizadas no passo 4. Para isso basta criar a directoria “ms-filemap” e um “symbolic link” para cada site criado a apontar para a directoria de uploads:

$> cd /var/www/wordpress/wp-content/
$> mkdir ms-filemap
$> ln -s ../blogs.dir/2 www.domain2.com

Com este truque, todos o media carregado passa a ser processado apenas pelo Nginx, sem passar pelo PHP.

 

7) Configurar Log Rotation

  • colocar os scripts para rodar os logs do nginx e php-fpm em /etc/logrotate.d
  • desactivar/remover os scripts para rodar os logs do apache e do samba
  • se desactivarmos o serviço anacron, é necessário alterar o ficheiro /etc/crontab:
32 * * * * root cd / && run-parts --report /etc/cron.hourly
47 3 * * * root cd / && run-parts --report /etc/cron.daily
33 2 * * 7 root cd / && run-parts --report /etc/cron.weekly
20 5 11 * * root cd / && run-parts --report /etc/cron.monthly

2 comentários a “A Minha Plataforma WordPress Ideal

  1. Pingback: Rescaldo do WordCamp Lisboa 2012 | Templates Wordpress e Tutoriais

  2. Pingback: Rescaldo do WordCamp Lisboa 2012 | O Centro do Afiliado

Os comentários estão fechados.