StartEncrypt, la respuesta de StartSSL a Let’s Encrypt

seguridad StartSSL, pionera en esto de dar certificados gratutitos, ha lanzado una agresiva campaña de respuesta a Let’s Encrypt ofreciéndonos su propio servicio para automatizar la instalación, gestión y renovación de certificados: StartEncrypt. Si alguien lo ha probado ya que avise y, si no, tendremos que hacerlo por aquí en breve. Que remedio 😉

NOTA: Por si mi lector no lo recuerda, hace bien poco contamos por aquí como configurar Let’s Encrypt en una web con nginx.

Pasar de http a https en una web con nginx y wordpress

nginx “Papá” Google dejó claro hace unos meses que quería darle un empujoncito en sus rankings a quienes usaran https en lugar de http. Y allá vamos todos como tiernos corderitos a hacer la migración. ¡Faltaría más! Lo bueno (por verle algo) es que a los que esto no nos va ni nos viene nos sirve para motivarnos a remozar un poquillo el blog y hacer cosas nuevas. Y en eso estamos. Hasta hace bien poquito si queríamos usar https en una web y no queríamos gastarnos dinero en certificados teníamos las opciones que nos ofrecían StartSSL o CaCert. Pero desde finales del año pasado contamos con Let’s Encrypt: un proyecto patrocinado, entre otros, por la EFF y Mozilla del que todo el mundo habla maravillas. Había que probarlo, estaba claro.

Con Lets Encrypt no hacemos la instalación de un certificado a la antigua usanza, sino que instalamos en nuestro servidor un programa que se encarga de realizar la instalación y posterior renovación periódica de forma automática. Además, si usamos Apache se encarga de realizar la configuración necesaria en nuestro servidor de forma automática. Está previsto que en el futuro también existirá un script para nginx pero de momento esta posibilidad no existe aún.

Nuestro punto de partida es un servidor web que funciona en Debian 8.4 usando nginx como servidor web y wordpress como CMS. El fichero de definición para nuestro virtualhost es de lo mas sencillito que se despacha:

server {
        listen   80 default_server;
        root /var/www/myblog;
        index index.php;
        server_name www.myblog.com;
        access_log /var/log/nginx/myblog-access.log;
        error_log /var/log/nginx/myblog-error.log;
        location / {
                try_files $uri $uri/ /index.php?q=$uri&$args;
        }
        error_page 404 /404.html;
        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
              root /usr/share/nginx/www;
        }
        location ~ \.php$ {
		include snippets/fastcgi-php.conf;
		fastcgi_pass unix:/var/run/php5-fpm.sock;
		fastcgi_param SCRIPT_FILENAME $request_filename;
		}
}

Lo primero que necesitamos es instalar el cliente de Lets Encrypt. Para ello ejecutamos lo siguiente (con privilegios de root):

apt-get install -y git
git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt
cd /opt/letsencrypt
./letsencrypt-auto

El código anterior instala el paquete git y copia el código necesario al directorio /opt/letsencrypt. Luego nos posiciona en dicho directorio y ejecuta el script que realizará la instalación de dependencias necesarias (augeas, gcc y python), instalará los certificados raices en nuestro servidor y creará el directorio /etc/letsencrypt.

Lo siguiente que necesitamos es crear un directorio temporal para letsencrypt accesible a través de nuestro servidor web. En la documentación nos recomiendan hacerlo de la siguiente forma:

cd /var/www
mkdir letsencrypt
chown www-data:www-data letsencrypt

En tercer lugar crearemos un fichero de configuración con los datos del certificado que queremos crear. Dicho fichero debe de estar en el directorio /etc/letsencrypt/configs/ y debería de llamarse como el dominio para el que queremos crear el certificado pero añadiendo la extensión .conf. En nuestro caso, por tanto, el fichero se llamará www.myblog.com.conf y tendrá el siguiente contenido:

domains = www.myblog.com
rsa-key-size = 2048 # Si lo deseas puedes usar claves de 4096
server = https://acme-v01.api.letsencrypt.org/directory
email = josemaria@myblog.com # Recibirás recordatorios de renovación en esta dirección
text = True
authenticator = webroot
webroot-path = /var/www/letsencrypt/

Cuarto paso: tenemos que hacer accesible el directorio letsencrypt que creamos anteriormente en /var/www a nuestro servidor web. Para ello añadimos las siguientes líneas dentro del bloque server de la definición de nuestro virtualhost:

location /.well-known/acme-challenge {
        root /var/www/letsencrypt;
    }

Para que el cambio anterior tenga efecto necesitamos hacer un reload del servicio de nginx:

systemctl reload nginx
NOTA: Para asegurarte de que no has metido la pata al editar los ficheros de configuración de nginx puedes hacer un test antes del reload:

nginx -t

Ahora ya vamos a solicitar el certificado a Let’s Encrypt. Para ello ejecutamos lo siguiente:

cd /opt/letsencrypt
./letsencrypt-auto --config /etc/letsencrypt/configs/www.myblog.com.conf certonly

Si todo ha salido bien se descargará el certificado a nuestra máquina y obtendremos una salida similar a esta:

Checking for new version...
Requesting root privileges to run letsencrypt...
   /root/.local/share/letsencrypt/bin/letsencrypt --config /etc/letsencrypt/configs/www.myblog.com.conf certonly

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at
   /etc/letsencrypt/live/www.myblog.com/fullchain.pem. Your
   cert will expire on 2016-07-10. To obtain a new version of the
   certificate in the future, simply run Let's Encrypt again.
 - If you like Let's Encrypt, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

Fíjate que el certificado descargado es válido sólo durante seis meses. Acuerdate de esto que luego veremos como renovarlo. Bien. Pues ya nos queda sólo ún último paso para terminar: tenemos que modificar de nuevo el fichero de definición del virtualhost de nuestro servidor web para que atienda las peticiones https, sepa donde está el certificado que necesita para ello y redireccione todas las peticiones que se hagan a través del puerto 80 al nuevo servicio que reside en el 443. El nuevo fichero de definición de virtualhost quedaría como sigue:

server {
        listen   80;
        server_name www.myblog.com;
        return 301 https://www.myblog.com/$request_uri;
}

server {
        listen   443 ssl default_server;
        root /var/www/myblog;
        index index.php;
        server_name www.myblog.com;
        location /.well-known/acme-challenge {
        	root /var/www/letsencrypt;
    	}
        ssl_certificate /etc/letsencrypt/live/www.myblog.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/www.myblog.com/privkey.pem;

        access_log /var/log/nginx/myblog-access.log;
        error_log /var/log/nginx/myblog-error.log;
        location / {
                try_files $uri $uri/ /index.php?q=$uri&$args;
        }
        error_page 404 /404.html;
        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
              root /usr/share/nginx/www;
        }
        location ~ \.php$ {
		include snippets/fastcgi-php.conf;
		fastcgi_pass unix:/var/run/php5-fpm.sock;
		fastcgi_param SCRIPT_FILENAME $request_filename;
		}
}
NOTA: Si quieres ver que líneas hemos añadido basta con que compares con las líneas que hemos dejado un poco más arriba 😉

Volvemos a hacer un reload de la configuración de nginx y nuestro servidor ya debería de funcionar correctamente con https y, es más, redirigir todas las peticiones de enlaces a través de http que hubiera en cualquier sitio de internet al nuevo servicio https. Puedes comprobar las características del nuevo certificado que acabas de instalar a traves de los servicios de SSLABS

¿Hemos dicho que hemos terminado? Bueno, en realidad no… Faltarían un par de detallitos. El primero, acordarte de que el certificado caduca a los seis meses. Para renovarlo basta con ejecutar de nuevo lo siguiente:

cd /opt/letsencrypt
./letsencrypt-auto --config /etc/letsencrypt/configs/www.myblog.com.conf certonly

Pero los chicos que llevan nginx nos han dejado un útil script que podemos crear y programar desde crontab:

#!/bin/sh

cd /opt/letsencrypt/
./letsencrypt-auto --config /etc/letsencrypt/configs/my-domain.conf certonly
if [ $? -ne 0 ]
 then
        ERRORLOG=`tail /var/log/letsencrypt/letsencrypt.log`
        echo -e "The Let's Encrypt cert has not been renewed! \n \n" \
                 $ERRORLOG
 else
        nginx -s reload
fi
exit 0

Para que funcione debes de crear un directorio llamado letsencrypt colgando de /var/log. Allí se dejarán los mensajes de error en caso de que la renovación no pueda realizarse correctamente. Ah, y no apures los seis meses de vida del certificado hasta el final. Por si acaso… Lets Encrypt nos deja renovar nuestros certificados hasta 5 veces al día, así que si lo programas para que se ejecute cada cuatro meses, por ejemplo, no va a morirse nadie 😉

En segundo lugar, si nuestra web lleva funcionando desde hace tiempo con http, google nos tendrá indexados en multitud de sitios y si no queremos perder el ranking de esos enlaces debemos de informarle del cambio. Existe una guía editada por la propia Google donde nos dicen paso a paso como hacer esto.

En tercer y, ahora si, último lugar, aunque nuestro servicio redirige todas las peticiones http a https, estas redirecciones podrían penalizar un poco el rendimiento de nuestra web. Debemos de tratar de ir eliminando los antiguos enlaces que estén en nuestra mano y para ello deberíamos de empezar por la propia configuración de wordpress cambiando la dirección del sitio en la entrada de Ajustes Generales.

Si necesitas alguna otra cosa no cubierta aquí tienes disponible un completito manual aquí

ACTUALIZACIÓN: La mejor forma ahora de instalar los certificados de Let’s Encrypt es usar certbot. Además hay otros cambios sobre lo aquí escrito: un paquete en Debian backports llamado certbot, la caducidad de los certificados se ha bajado a tres meses y alguna cosilla mas… Así que usa este artículo como base si quieres pero no te lo creas todo a pies juntillas que se ha quedado viejo muy pronto!

Cambios en la configuración de nginx y php5-fpm en Debian 8 (Jessie)

nginx Hace unos días, tras actualizar la versión de Debian a Jessie, nginx dejó de funcionar correctamente. Servía sin problemas las páginas estáticas pero cuando trataba de interpretar una página php devolvía una página en blanco sin, aparentemente, ningún error. Ni en ficheros de logs, ni por pantalla, ni nada de nada. Parecía más bien un error de php5-fpm que de nginx o, tal vez, de la forma en que se comunican ambos. Probé la comunicación por puertos TCP en lugar de hacerlo por sockets como lo tenía por defecto y el resultado era el mismo… Así que como me pilló entre semana y con mucho trabajo hice una migración de urgencia a apache y lo dejé pendiente hasta que tuviera un ratito libre.
Hoy ya tocaba y la solución ha sido rápida puesto que el “problema” estaba reportado en la bendita lista de bugs de debian desde hace meses, cuando se detectó durante el testing de la nueva versión. Y pongo “problema” entre comillas porque en realidad se trata de un cambio de estructura a partir de la versión 1.6.2 de nginx (la que acompaña a Jessie) y que viene perfectamente documentado en el fichero index.html que se crea por defecto en el directorio /var/www/html (si, esto también cambia y es la nueva ubicación por defecto para las páginas web).
Existe algún otro cambio pero, para resumir, ahora cuando creas un virtual host que necesita usar php en lugar de usar el bloque de configuración que vimos por aquí hace unas semanas tendrás que usar este:

location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass unix:/var/run/php5-fpm.sock;
    fastcgi_param SCRIPT_FILENAME $request_filename;
    }

Migrando de Apache 2 a nginx: Virtual Hosts

nginxLos ficheros de definición de Virtual Hosts en nginx se almacenan en directorios muy similares a los de apache. Tenemos un directorio llamado sites-available y otro que se llama sites-enabled y ambos están bajo el directorio principal de configuración que es /etc/nginx. En el primero se deberían de guardar todos los virtual hosts del servidor (estén disponibles o no) y en el segundo aquellos que están activos. La forma correcta de activar o desactivar un Virtual Host debería de ser crear un enlace en el segundo directorio al archivo correspondiente del primero, al igual que en Apache. Para desactivarlo temporal o definitivamente borraríamos ese enlace. La diferencia aquí con apache es que no contamos con comandos similares a los a2ensite y a2dissite que hacen estas operaciones de forma cómoda, pero tampoco se nos van a caer los anillos por hacer un enlace manualmente en línea de comando a estas alturas ¿verdad? Bueno, por si acaso, el siguiente comando realizaría un enlace del fichero de definición de Virtual Host llamado miweb del directorio sites-availabe en el directorio sites-enabled:

ln -s /etc/nginx/sites-available/miweb /etc/nginx/sites-enabled/

Veamos ahora el “esqueleto” de configuración más básico en Apache:

<VirtualHost *:80>
	ServerName www.miweb.com
	ServerAlias blog.miweb.com *.miweb.es
	DocumentRoot /var/www/miweb/
	DirectoryIndex index.php index.html index.htm;
</VirtualHost>

Y su equivalente en nginx:

server {
        listen 80;
        server_name www.miweb.com blog.miweb.com *.miweb.es;
        root /var/www/miweb/;
        index index.php index.html index.htm;
}

Puesto que partimos de que conocemos la sintaxis en Apache no deberíamos de encontrar problemas en entender la de nginx ¿verdad? Sólo un detalle adicional sobre estas líneas. Si tenemos un servidor con más de un interfaz y/o dirección IP y queremos que el servidor web sólo atienda a una de ellas en Apache sustituiríamos la primera línea del ejemplo anterior por esta:

<VirtualHost 123.45.67.89:80>

En nginx haríamos lo propio modificando así la segunda línea:

listen 123.45.67.89:80;

Cualquier configuración adicional del Virtual Host se realizaría incluyendo las directrices adecuadas en el interior del bloque de definición. Veamos algunas de las más comunes. Por ejemplo, si queremos dar una ubicación concreta y separada del lugar donde se almacenan los logs de acceso y error, en Apache lo hacíamos con estas líneas:

CustomLog /var/log/apache2/miweb-access.log combined
ErrorLog /var/log/apache2/miweb-error.log
LogLevel warn

Y en nginx lo haríamos así:

access_log /var/log/nginx/miweb-access.log;
error_log /var/log/nginx/miweb-error.log warn;

El formato del log de accesos por defecto en nginx es idéntico al modo combined de Apache. No obstante, tenemos un montón de opciones adicionales que puedes consultar aquí. Los niveles permitidos para el log de error son, además de warn, error, crit, alert, y emerg.

¿Cómo redefinimos las páginas de error que nos mostrará el servidor web? En Apache usábamos la directiva ErrorDocument:

ErrorDocument 404 /errores/404.html
ErrorDocument 500 /errores/500.html
ErrorDocument 502 /errores/502.html
ErrorDocument 503 /errores/503.html
ErrorDocument 504 /errores/504.html

En nginx usamos error_page:

error_page 404 /errores/404.html;
error_page 500 /errores/500.html;
error_page 502 /errores/502.html;
error_page 503 /errores/503.html;
error_page 504 /errores/504.html;

Si queremos redireccionar varios errores a una misma página podemos hacerlo de esta forma:

error_page 500 502 503 504 /errores/500bis.html;

Veamos ahora como se restringe el acceso a ciertos directorios. En Apache, para denegar el acceso a todo el mundo a un directorio del servidor web lo hacíamos de esta forma:

<Directory /secreto>
        Deny from all
</Directory>

Mientras que en nginx haríamos lo mismo así:

location /secreto {
        deny all;
}

Para restringir el acceso a determinados clientes, en Apache “jugamos” con las directrices Order, Deny y Allow. En nginx no existe ninguna directiva similar a Order. Debemos de poner una a una todas las instrucciones deny y allow que necesitemos. El servidor las analizará una a una y en orden hasta encontrar la primera que “cuadre” con la petición que está atendiendo de forma similar a como se comportaría un cortafuegos. Las siguientes reglas son todas válidas:

location /secreto2 {
    deny  192.168.1.1;
    allow 192.168.1.0/24;
    allow 10.1.1.0/16;
    allow 2001:0db8::/32;
    deny  all;
}

Si lo que queremos es restringir el acceso mediante usuario y contraseña con un fichero generado con htpasswd como hacíamos habitualmente con Apache, podemos hacerlo de forma fácil. El fichero de contraseña lo generamos de la misma forma que ya sabemos (tienes que tener instalado el paquete apache2-utils para contar con esta utilidad) e incluir las siguientes directivas:

location /secreto3 {
    auth_basic "Control de Acceso";
    auth_basic_user_file /etc/nginx/.htpasswd;
}

La línea auth_basic sólo aporta un mensaje de texto que aparecerá en la ventana en la que se nos pide el usuario y contraseña. La directiva auth_basic_user_file es la que marca el lugar y el nombre del fichero que contiene los usuarios y las contraseñas (las hashes de estas, en realidad) autorizadas para acceder al directorio /secreto3 de nuestro Virtual Host.

Si nuestro Virtual Host necesita interpretar páginas en PHP, debemos de pasar estas peticiones al módulo adecuado y tenemos que expecificarlo aquí, y no como ocurría en Apache que se hacía de forma automática con sólo tener activo el módulo php5. Yo uso php5-fpm (aunque existen otras alternativas) y para que funcione debemos de incluir un bloque como este:

location ~ \.php$ {
    try_files $uri =404;
    fastcgi_pass unix:/var/run/php5-fpm.sock;
    fastcgi_index index.php;
    include fastcgi_params;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }
ACTUALIZACIÓN MUY IMPORTANTE: A partir de la versión 1.6.2 de nginx en Debian 8 (Jessie) el anterior bloque de configuración para php ya no es válido y habría que usar en su lugar este otro.
ACTUALIZACIÓN: PHP-FPM puede usarse con puertos TCP o con sockets. Las ventajas de usar sockets te las cuenta brevemente aquí Javier Terceiro.

En Debian hay que instalar el paquete correspondiente (apt-get install php5-fpm) y asegurarse de que el módulo aceptará las peticiones en la dirección que hemos indicado con la directiva fastcgi_pass. Esto lo comprobamos en el fichero de configuración /etc/php5/fpm/pool.d/www.conf y buscando la línea siguiente:

listen = /var/run/php5-fpm.sock
IMPORTANTE: Si necesitas usar de forma imprescindible ficheros .htaccess este no es tu servidor web. nginx está diseñado para ser rápido y eficiente y no soporta nada parecido. Los .htaccess son cómodos para permitir pequeñas personalizaciones de configuración en servidores compartidos, pero en cualquier otro caso son absolutamente prescindibles y desde el punto de vista de la eficiencia son tremendamente negativos. Piensa que por cada petición que se hace al servidor web, este tiene que recorrer todos los directorios del Virtual Host uno por uno en busca de ficheros de este tipo. Aquí te lo explican muy bien y en este enlace y en este otro tienes herramientas automáticas para ayudarte a migrar las reglas que tengas en ellos a nginx.

Año nuevo, servidor web nuevo. Migrando a ningx

nginx Por aquello de terminar un año y empezar el siguiente con cambios y nuevos propósitos, ayer comencé a migrar la infraestructura que da soporte a este blog a nginx. Si has pasado por aquí en las últimas horas habrás podido experimentar problemas debido a los cambios. Ahora parece ya casi totalmente estable pero dista aún de estar optimizado y habrá que trabajar un poco mas en ello… Y bueno, ya que estamos, feliz año y tal 😉

Desde China ¿con amor?

blackhat Si tienes un servidor con presencia en Internet, usas (como deberías) algún sistema para bloquear los intentos de acceso no autorizados como fail2ban o denyhosts y analizas de vez en cuando los logs, no voy a decirte nada nuevo: en los últimos meses hemos experimentado un aumento inusitado de intentos de intrusión desde direcciones IP procedentes de China. En mi caso, en los últimos tres meses el 83% de los intentos irregulares de entrada a través de ssh que he observado proceden de este país. Concretando aún más, el 50% del total de estos intentos procede de la subred 116.10.191.0/24 y el 25% de la subred 61.174.51.0/24. Así que ya sabes: si eres de los que prefieres los métodos preventivos ya tardas en banear ambas subredes en tus cortafuegos.

Apache Tunning (y II). Ajustando el parámetro MaxClients

apache Como ya habíamos hablado por aquí, uno de los parámetros críticos en un servidor Apache es MaxClients, el número máximo de conexiones que es capaz de manejar simultaneamente. Es crítico porque cada tarea de Apache consume una determinada cantidad de memoria y si la suma de la memoria que consumen todos de forma simultanea es mayor que la memoria RAM que la máquina tiene libre comenzará a hacer swapping a disco y, si esta situación se mantiene, corremos un riesgo importante de que se nos quede virtualmente congelada. Una instalación de Apache por defecto toma un valor de 150 para este parámetro y esto es una verdadera burrada para casi cualquier servidor web con menos de 1 Gbytes (o incluso con bastante mas) que use contenidos dinámicos medianamente pesados.

Hace bien poco, buscando por ahí algún enlace para profundizar un poco más en estos temas, me encontré con este artículo de una empresa de hosting donde te proponen un script para ajustar el valor más adecuado a tus necesidades. Había dos cosas que no me gustaban en él script propuesto. Por un lado, tomaban el valor más conservador, es decir, el resultante de dividir la memoria libre entre lo que ocupa el proceso de Apache mayor. En segundo lugar, hacen el cálculo de la memoria libre sin tener en cuenta la que está ocupada por cache o buffers y que podría liberarse en caso de necesidad. Yo le he hecho algunos cambios para salvar ambos puntos y dejarlo un poco más bonito e informativo y me ha salido esto:

#!/bin/bash
clear

# Primero analizamos los procesos de apache funcionando actualmente
LISTA=`ps -aylC apache2 |grep apache2 |awk '{print $8'} |sort -n`

echo "Lista ordenada de la memoria, en bytes, ocupada por los procesos de Apache corriendo en este momento:"
COUNT=0
SUMA=0
for ITEM in $LISTA
do
        COUNT=`expr $COUNT + 1`
        SUMA=`expr $SUMA + $ITEM`
        echo "$COUNT -> $ITEM"
        if [ $COUNT -eq 1 ]
        then
                MENOR=$ITEM
        fi
done

MAYOR=$ITEM
MEDIA=`expr $SUMA / $COUNT`

# Pasamos las cantidades a Kbytes
MENOR=`expr $MENOR / 1024`
MAYOR=`expr $MAYOR / 1024`
MEDIA=`expr $MEDIA / 1024`

echo "El proceso de Apache más grande ocupa" $MAYOR "Kbytes y el menor" $MENOR "Kbytes"
echo "La media de la memoria ocupada por un proceso es de $MEDIA Kbytes"

echo "Detenemos Apache..."
apache2ctl graceful-stop > /dev/null

# Limpiamos los caches y buffers del servidor
sync
echo 3 > /proc/sys/vm/drop_caches

# Calculamos la memoria libre del sistema
FREEMEM=`free -m |head -n 2 |tail -n 1 |awk '{free=($4); print free}'`
echo "La memoria libre del servidor, después de liberar cache y buffers, es de $FREEMEM Kbytes"

echo "Arrancamos Apache de nuevo..."
apache2ctl start > /dev/null

echo "MaxClients debería de estar entre" `expr $FREEMEM / $MAYOR` "y" `expr $FREEMEM / $MENOR`
echo "Usando el valor medio de la memoria ocupada, un valor recomendable de MaxClients sería de" `expr $FREEMEM / $MEDIA`

El script de aquí arriba imprime una lista de la memoria ocupada por todos procesos de Apache activos en el momento de ejecutarlo. Luego toma el mayor, el menor y la media de todos ellos y calcula la memoria libre del sistema. Para ello, antes detiene Apache (con un graceful-stop para no fastidiar a nadie que esté viendo nuestra web en ese momento) y libera los buffers y caches de memoria. Por último, arranca de nuevo Apache y nos da como salida dos valores: una horquilla entre el valor que debería de tomar MaxClient usando el menor y el mayor valor de los procesos tomados en la instantánea anterior y un valor recomendado que sale de usar el valor medio de todos ellos.

Evidentemente no se trata de algo matemático. Como es lógico, ejecutado en diferentes momentos obtendremos valores distintos ya que ni la RAM que usa nuestro servidor es inmutable ni el tamaño de los procesos de Apache es siempre el mismo ni siguen la misma distribución. Pero para darnos una primera idea del valor con el que tenemos que empezar a jugar creo que es bastante válido. Ya me contáis.

NOTA: En algunas instantáneas el valor de memoria ocupado por el proceso más pequeño de Apache puede ser cero, seguramente porque o está creándose o está destruyéndose en ese momento. En ese caso el valor de la horquilla pierde uno de sus extremos. Sería muy fácil modificar el script para que en ese caso tome el segundo valor y divida por un elemento menos, pero ocurre en tan pocas ocasiones que no creo que merezca la pena hacerlo. Al menos no hoy 😉

Chuletillas (y XXXV) – Instalar xampp en Chakra Linux

chuleta Si queremos instalar xampp en Chakra Linux nos encontramos con que esta distribución sólo está disponible ya para 64 bits mientras que xampp se distribuye en forma de script sólo para sistemas de 32 bits. La solución pasa, sencillamente, por instalar unas librerías de compatibilidad y listo. Manos a la obra, pues. En un primer paso sustituimos las gcc-libs por las gcc-libs-multilib:

sudo pacman -S gcc-libs-multilib

Luego, tenemos dos opciones, descargar e instalar xampp siguiendo sus instrucciones como haríamos normalmente o usar el paquete ccr disponible (aunque ligeramente desactualizado):

ccr -S xampp

En cualquiera de ambos casos, xampp se instalará en el directorio acostumbrado (/opt/lampp) y responderá a los comandos y opciones habituales.

NOTA: Siempre que he realizado operaciones de este tipo y he instalado versiones de librerías de 32 bits en distribuciones de 64 (concretamente en Ubuntu y Fedora) luego, en algún momento, he tenido problemas de dependencias no resueltas a la hora de realizar alguna instalación y/o actualización. Aunque de momento no he tenido ningún problema similar con Chakra no llevo suficiente tiempo con esta distribucion como para asegurar que esto esté mejor resuelto.
ACTUALIZACI?N: Olvidaos de esto: xampp ya está disponible en versión de 64 bits.

Instalando memcached en Debian y habilitando su uso con WordPress

herramientas memcached es uno de los sistemas de caché para servidores web más usado. Usa una zona de la memoria RAM del servidor web de tamaño configurable como caché y funciona bien tanto en sitios pequeños y discretos como en grandes sistemas con múltiples servidores. Facebook, Twitter o Youtube, por ejemplo, usan este sistema de cacheado. El 85% de los 20 sitios con más tráfico de Internet lo usan, en realidad. Nada mejor, pues, para estrenar una pequeña sección acerca de sistemas y extensiones de cacheado para apache ¿no?

Partimos para la instalación de una Debian en la que ya tenemos un servidor web apache y la versión 5 de php (paquetes apache2 y php5). Para instalar memcached en una Debian he tenido que recurrir a usar “paquetería” de wheezy (testing) porque parece que hay algún problema de dependencias en la versión estable (squeeze) y la librería de extensión para trabajar con PHP no compilaba correctamente. Así que manos a la obra. El primer paso es instalar el servidor de memcached:

apt-get install memcached

El servicio se instala, como es habitual, en el directorio /etc/init.d y responde a los argumentos start, stop, restart, force-reload y status. En el directorio /usr/share/memcached/scripts existe un script llamado start-memcached que es el encargado de realizar el inicio automático y que toma la configuración del archivo memcached.conf en el directorio /etc. Dentro de este fichero de configuración una de las opciones más interesantes es la que dice a memcached cuanta RAM va a usar como caché. Por defecto son 64M, pero en sistemas con muy poca RAM tal vez nos convenga bajarlo. Mi VPS tiene sólo 512M de RAM y yo he bajado esos 64M a la mitad. Para ello basta con cambiar la línea -m 64 por -m 32 y reiniciar el servicio.

Otra de las opciones interesantes en ese archivo de configuración es la posibilidad de habilitar un archivo de logs que, por defecto, viene deshabilitado. Para ello basta con quitar el comentario a una de las dos opciones que aparecen el el fichero según el nivel de detalle que queramos: -v o -vv. El log se grabará en el fichero /var/log/memcached.log. Esto también es configurable modificando la línea que aparece en el mismo fichero. Y no olvides que para que la opción tome efecto haz de reiniciar de nuevo el servicio de memcached.

El segundo paso sería instalar la extensión de memcached para PHP. Para ello tenemos que instalar los siguientes paquetes:

apt-get install php-pear php5-dev php5-memcached libmemcached10 libmemcached-dev libmemcachedutil2 libhashkit2 libhashkit-dev

Y, a continuación, ejecutar lo siguiente:

pecl install memcached

Si todo sale bien, al final del proceso se nos mostrará un mensaje similar a este:
Instalación del módulo PHP de memcached

La librería debería de haberse creado en el directorio de extensiones de php que se indica al final del proceso y que puedes ver en la imagen anterior (/usr/lib/php5/20100525+lfs) y ya sólo nos resta hacerle caso al mensaje final y añadir la línea extension=memcached.so al final de nuestro fichero php.ini que debería de estar en el directorio /etc/php5/apache2. Reiniciamos apache y, si ejecutamos la función phpinfo veremos una nueva sección:
phpinfo con información del módulo memcached

Para ver información acerca de como está funcionando nuestra cache tenemos un par de opciones más atractivas que inspeccionar el fichero de log que hemos mencionado antes. Una de ellas es usar el script memcached-tools que encontraremos en el directorio /usr/share/memcached/scripts/.

/usr/share/memcached/scripts/memcached-tool 127.0.0.1:11211

El comando anterior muestra información sobre el estado del servicio memcached que hemos instalado en nuestra máquina. Añadiendo al final el argumento stats nos mostrará estadísticas de uso y con el argumento dump realizará un volcado del contenido de la caché por pantalla.

La segunda opción que tenemos es bajarnos de aquí un script hecho en perl y llamado memcache-top. Tienes distintos argumentos para modificar la salida que puedes consultar en la web desde la que te has bajado el script. En la imagen siguiente se muestra con las opciones --cumulative y --commands
ejecución de memcached-top

Y ya sólo nos queda habilitar el uso de memcached desde wordpress. Para ello usaremos Memcached Object Cache que, aunque aparece como cualquier otro en el repositorio de plugins de wordpress, en realidad precisa de una sencilla instalación manual para que funcione. Bajamos el archivo, lo descomprimimos y copiamos el archivo object-cache.php en el directorio wp-content de nuestra instancia de wordpress.

phpSysInfo

herramientas phpSysInfo es un script escrito en PHP que muestra información acerca del sistema en el que corre. Es bastante ligero y extensible mediante la programación de plugins. Tienes una demo real bastante completa aquí, mucha información en las páginas del proyecto en sourceforge y hasta un cliente para tu android.

phpsysinfo

Las instalación es tan sencilla como descomprimir y copiar los ficheros del proyecto en un virtual host de tu apache, renombrar el ejemplo del archivo de configuración (de phpsysinfo.ini.new a phpsysinfo.ini) y editarlo siguiendo las indicaciones de los comentarios que lo acompañan.