Memcached es simple pero a la vez muy potente, su objetivo es el de almacenar objetos en memoria RAM a los que podamos acceder a posteriori cuando sea necesario. Se puede almacenar cualquier clase de objeto que estará asociado a un identificador único.

Memcached no está pensado para sustituir a una base de datos ya que los objetos almacenados en ella no son persistentes, es decir, se almacenan únicamente en memoria RAM y nunca son volcados a disco. La clave es colocar a Memcached entre nuestra aplicación web y el sistema gestor de bases de datos que estemos usando (por ejemplo, MySQL). Cuando en la aplicación web se necesite un dato primero se consultará su existencia en Memcached, si el dato está disponible habremos obtenido el objeto deseado directamente de memoria RAM y a una velocidad mucho mayor que si se hubiera tenido que ir a buscar ese mismo dato a disco. En caso de que el dato no se encuentre en Memcached se procederá a obtener el dato del sistema gestor de bases de datos y a almacenarlo en Memcached para que la próxima vez que se intente acceder ya se encuentre en memoria. A continuación se puede observar el pseudocódigo equivalente a una parte de una aplicación web que use Memcached:

funcion obtener_objeto(objid)
{
   objeto = memcached_get("obj".objid)
   si(definido(objeto))
      devolver objeto
   objeto = basedatos_get(objid)
   memcached_set("obj".objid, objeto)
   devolver objeto
}

Por tanto sólo la primera vez que se necesite un objeto se tendrá que ir a disco a buscarlo y las sucesivas veces este objeto se encontrará en memoria para ser servido directamente. Esto es cierto mientras únicamente se produzcan lecturas en la base de datos, sin embargo cuando se producen escrituras la cosa cambia y hay que afrontar los problemas que surgen. Cuando se escribe un dato lo más sencillo es eliminar el objeto de memcached, de manera que la próxima vez éste no sea encontrado y se cargue desde el sistema gestor de bases de datos. Existen otras técnicas más complicadas para ganar en rendimiento en relación a las escrituras, pero se escapan de la visión general que se quiere dar en este artículo sobre este sistema. Para establecer un símil fácil de comprender para gente que ya conozca la arquitectura de un procesador podríamos decir que nuestra aplicación web es como la CPU, Memcached sería la caché L1 y el sistema gestor de bases de datos sería la caché L2. Memcached también permite agrupar servidores formando clústeres, de esta manera los datos se distribuyen entre los diferentes nodos del cluster y se gana en capacidad y en tolerancia a fallos.

En la propia página web de Memcached se puede ver como es usado en sitios web con grandes cargas de usuarios como la Wikipedia, Twitter, Youtube, WordPress, etc.

En definitiva se puede decir que el uso de Memcached es algo muy recomendado en nuestras aplicaciones web, ya que ayudará a que sean más escalables y que expriman aún más la capacidad de nuestros servidores.

En varios blogs se pueden encontrar soluciones a este problema, un tanto radicales bajo mi punto de vista, que hacen que cuando un blog te enlace directamente una imágen esta sea sustituida por otra en tiempo de ejecución, o incluso que no se muestre nada, ahorrando así todo el ancho de banda.

Sin embargo si nos paramos a pensar un poco, lo que nos gustaría no es que nadie nos hiciera hotlinking de las imágenes, sino que ese blog acreditara en alguna parte que la imagen está extraída de nuestro blog. Como no podemos obligar al propietario del mismo a que nos enlace o nos nombre en algún sitio acerca de donde ha sido obtenida la imagen, vamos a aprovecharnos para incluir la URL de nuestro blog en la imagen enlazada, para ello haremos uso de los archivos .htaccess de Apache y de la librería GD de PHP. Lógicamente no queremos que las imágenes que incluyamos en nuestro blog tengan incrustada la URL del mismo.

La idea es simple, cuando un blog nos enlace una imágen directamente la petición GET llegará al servidor con un campo HTTP_REFERER que no corresponderá con la URL de nuestro blog, en ese momento se invocará un script PHP al cual le pasamos la ruta de la imagen solicitada. Este script PHP se encargá en tiempo real de abrir la imagen, incrustarle la URL de nuestro blog y mostrarla.

Este es un ejemplo de una imagen enlazada directamente por nuestro blog:

Este es un ejemplo de como se mostraría la misma imagen si alguien nos hiciera Hotlinking:

Para conseguir incluir este sistema en cualquier página web es necesario usar Apache, con soporte de archivos .htaccess y tener instalada la librería GD en PHP.

Paso 1: Editar el archivo .htaccess e incluir lo siguiente sustituyendo tudominio.com por tu dominio.

RewriteEngine On
RewriteCond %{HTTP_REFERER} !^http://(.+\.)?tudominio\.com/ [NC]
RewriteCond %{HTTP_REFERER} !^$
RewriteCond %{REQUEST_URI} .*\.(jpe?g|gif|bmp|png)$
RewriteRule ^(.*)$ /nohotlink.php?i=$1 [L]

Paso 2: Crear un archivo en el directorio raiz de la web denominado nohotlink.php e incluir el siguiente contenido, sustituyendo www.tudominio.com por tu dominio

<?php
function imagecreatefromfile($path, $user_functions = false)
{
$info = @getimagesize($path);

if(!$info)
{
return false;
}

$functions = array(
IMAGETYPE_GIF => ‘imagecreatefromgif’,
IMAGETYPE_JPEG => ‘imagecreatefromjpeg’,
IMAGETYPE_PNG => ‘imagecreatefrompng’,
IMAGETYPE_WBMP => ‘imagecreatefromwbmp’,
IMAGETYPE_XBM => ‘imagecreatefromwxbm’,
);

if($user_functions)
{
$functions[IMAGETYPE_BMP] = ‘imagecreatefrombmp’;
}

if(!$functions[$info[2]])
{
return false;
}

if(!function_exists($functions[$info[2]]))
{
return false;
}

return $functions[$info[2]]($path);
}

header(“Content-type: image/png”);
$im        = imagecreatefromfile($_GET['i']);
$width    = imagesx($im);
$height    = imagesy($im);
putenv(‘GDFONTPATH=’ . realpath(‘.’));
$white = imagecolorallocate($im, 255, 255, 255);
$grey  = imagecolorallocate($im, 128, 128, 128);
$black = imagecolorallocate($im, 0, 0, 0);
$orange = imagecolorallocate($im, 220, 210, 60);
$tamano = 10;
$texto = “www.tudominio.com“;
$tb = imagettfbbox($tamano, 0, “arial”, $texto);
$altura = $tb[3] – $tb[5];
imagefilledrectangle  ($im  , 0  , $height-$altura-2  , $width  , $height, $black);
$x = ceil(($width – $tb[2]) / 2);
imagettftext($im, $tamano, 0, $x, $height-4, $orange, “arial”, $texto);
imagepng($im);
imagedestroy($im);

?>

Paso 3: Descargar en el directorio raiz de vuestra web la fuente arial.ttf, la podeis obtener desde aqui.

Y listo, ya tendríamos todo en funcionamiento. Podemos hacer una prueba de si el sistema funciona usando el siguiente comando desde wget:

wget http://www.tudominio.com/alguna_imagen.jpg –referer=http://www.otrodominio.com