internet, desarrollo, diseño web, sysadmin

No sé desde cuándo se pueden instalar fuentes en Ubuntu de esta manera tan sencilla. En Gutsy Gibbon, es decir, la versión 7.10, funciona perfectamente:

• Abrir el navegador de archivos (Nautilus).
• Pulsar Control + L, para poder teclear un lugar manualmente.
• Escribir fonts:// + Enter.
• Arrastrar el fichero con la fuente que queremos instalar hasta la carpeta que hemos abierto en el navegador de archivos.

Realmente fácil. Visto en ubuntuforums.org.

Hace poco adquirí un VPS de 256 MB en slicehost. Para ahorrar RAM decidí utilizar nginx como servidor web en lugar de Apache.

La web que estoy montando en este VPS constará de una aplicación rails y de un blog basado en WordPress, por lo que será necesario PHP. En este post contaré cómo configurar un virtual host de nginx para que sirva una aplicación PHP mediante FastCGI. La distribución que utilizo es Debian Etch.

Instalación de nginx

Para poder disponer de la última versión estable de nginx (0.5.35) compilaremos el código. El primer paso será instalar algunos paquetes necesarios:

sudo aptitude install libpcre3 libpcre3-dev libpcrecpp0 libssl-dev zlib1g-dev

El “sbin-path” por defecto es “/usr/local/nginx/sbin”, así que al configure le indicaremos uno más conveniente: “/usr/local/sbin”. Asimismo, la compilación la realizaremos con soporte para SSL:

wget http://sysoev.ru/nginx/nginx-0.5.35.tar.gz
tar zxf nginx-0.5.35.tar.gz
cd nginx-0.5.35/
./configure --sbin-path=/usr/local/sbin --with-http_ssl_module
make
sudo make install

Cuando termina el configure obtenemos un resumen con los ficheros más importantes:

nginx path prefix: "/usr/local/nginx"
nginx binary file: "/usr/local/sbin"
nginx configuration file: "/usr/local/nginx/conf/nginx.conf"
nginx pid file: "/usr/local/nginx/logs/nginx.pid"
nginx error log file: "/usr/local/nginx/logs/error.log"
nginx http access log file: "/usr/local/nginx/logs/access.log"
nginx http client request body temporary files: "/usr/local/nginx/client_body_temp"
nginx http proxy temporary files: "/usr/local/nginx/proxy_temp"
nginx http fastcgi temporary files: "/usr/local/nginx/fastcgi_temp"

Arrancamos nginx:

sudo /usr/local/sbin/nginx

y comprobamos que funciona introduciendo en el navegador nuestra URL:

http://midominio.com/

Lo único que nos queda para tener nginx funcionando es crear un script que arranque el servidor web cuando arranque el VPS:

sudo kill `cat /usr/local/nginx/logs/nginx.pid`
sudo vi /etc/init.d/nginx
sudo chmod +x /etc/init.d/nginx
sudo /usr/sbin/update-rc.d -f nginx defaults

Siendo /etc/init.d/nginx:

#! /bin/sh
 
### BEGIN INIT INFO
# Provides:          nginx
# Required-Start:    $all
# Required-Stop:     $all
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: starts the nginx web server
# Description:       starts nginx using start-stop-daemon
### END INIT INFO
 
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/usr/local/sbin/nginx
NAME=nginx
DESC=nginx
 
test -x $DAEMON  exit 0
 
# Include nginx defaults if available
if [ -f /etc/default/nginx ]  then
        . /etc/default/nginx
fi
 
set -e
 
case "$1" in
  start)
        echo -n "Starting $DESC: "
        start-stop-daemon --start --quiet --pidfile /usr/local/nginx/logs/nginx.pid \
                --exec $DAEMON -- $DAEMON_OPTS
        echo "$NAME."
        
  stop)
        echo -n "Stopping $DESC: "
        start-stop-daemon --stop --quiet --pidfile /usr/local/nginx/logs/nginx.pid \
                --exec $DAEMON
        echo "$NAME."
        
  restartforce-reload)
        echo -n "Restarting $DESC: "
        start-stop-daemon --stop --quiet --pidfile \
                /usr/local/nginx/logs/nginx.pid --exec $DAEMON
        sleep 1
        start-stop-daemon --start --quiet --pidfile \
                /usr/local/nginx/logs/nginx.pid --exec $DAEMON -- $DAEMON_OPTS
        echo "$NAME."
        
  reload)
      echo -n "Reloading $DESC configuration: "
      start-stop-daemon --stop --signal HUP --quiet --pidfile /usr/local/nginx/logs/nginx.pid \
          --exec $DAEMON
      echo "$NAME."
      
  *)
        N=/etc/init.d/$NAME
        echo "Usage: $N {startstoprestartforce-reload}" >&2
        exit 1
        
esac
 
exit 0

Configuración del virtual host de nginx que servirá PHP

Supongamos que el virtual host de nginx en el que funcionará el blog basado en WordPress es blog.midominio.com. En este caso, en el fichero de configuración de nginx, que será /usr/local/nginx/conf/nginx.conf, tendremos que añadir, de momento:

    server {
        listen       80
        server_name  blog.midominio.com
 
        access_log /var/log/nginx/blog.midominio.com/access.log
        error_log  /var/log/nginx/blog.midominio.com/error.log
 
        location / {
            root   /var/www/blog.midominio.com
            index  index.html
        }
 
        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html
        location = /50x.html {
            root   html
        }
    }

El directorio para los logs, /var/log/nginx/blog.midominio.com, y el directorio para las páginas, /var/www/blog.midominio.com, pueden ser otros. En cualquier caso, los deberemos crear a mano. Después de cualquier cambio en el fichero de configuración de nginx es necesario un restart:

sudo /etc/init.d/nginx restart

Llegados a este punto, podemos crear un index.html en /var/www/blog.midominio.com y ver que carga correctamente en el navegador:

http://blog.midominio.com/

Instalación de PHP

La instalación de PHP es realmente sencilla:

$ sudo apt-get install php5-cli php5-cgi php5-mysql
$ php -v
PHP 5.2.0-8+etch9 (cli) (built: Dec 29 2007 14:49:25) 
Copyright (c) 1997-2006 The PHP Group
Zend Engine v2.2.0, Copyright (c) 1998-2006 Zend Technologies

Instalación de FastCGI

La implementación de FastCGI que vamos a utilizar es la que viene con lighttpd. Lo que haremos será compilar lighttpd, pero no instalarlo. Copiaremos a mano el proceso spawn-fcgi:

wget http://www.lighttpd.net/download/lighttpd-1.4.18.tar.gz
gunzip lighttpd-1.4.18.tar.gz
tar xvf lighttpd-1.4.18.tar
cd lighttpd-1.4.18/
./configure
make
sudo cp src/spawn-fcgi /usr/bin/spawn-fcgi

Ahora que ya tenemos FastCGI, crearemos un script para lanzarlo, al que llamaremos /usr/bin/php-fastcgi, y cuyo contenido será:

#!/bin/sh
/usr/bin/spawn-fcgi -a 127.0.0.1 -p 9000 -u www-data -f /usr/bin/php5-cgi

Crearemos también el script de arranque y parada para cuando rearranquemos el servidor. Le llamaremos /etc/init.d/php-fastcgi, y su contenido será:

#!/bin/bash
PHP_SCRIPT=/usr/bin/php-fastcgi
RETVAL=0
case "$1" in
    start)
      $PHP_SCRIPT
      RETVAL=$?
  
    stop)
      killall -9 php5-cgi
      RETVAL=$?
  
    restart)
      killall -9 php5-cgi
      $PHP_SCRIPT
      RETVAL=$?
  
    *)
      echo "Usage: php-fastcgi {startstoprestart}"
      exit 1
  
esac      
exit $RETVAL

Damos los permisos adecuados y añadimos php-fastcgi a los scripts de arranque y parada:

sudo chmod 755 /etc/init.d/php-fastcgi
sudo chmod 755 /usr/bin/php-fastcgi
sudo /usr/sbin/update-rc.d -f php-fastcgi defaults

Nos queda volver a editar el fichero de configuración de nginx, /usr/local/nginx/conf/nginx.conf, donde añadiremos, en la sección del servidor virtual que hemos creado, la configuración necesaria para que los scripts PHP sean redireccionados al proceso FastCGI. También en esta sección, deberemos cambiar la página de inicio de index.html a index.php y añadir una regla de reescritura para que WordPress funcione correctamente. Con todos estos cambios, la sección completa del servidor virtual de nginx para el blog quedaría:

    server {
        listen       80
        server_name  blog.midominio.com
 
        access_log /var/log/nginx/blog.midominio.com/access.log
        error_log  /var/log/nginx/blog.midominio.com/error.log
 
        location / {
            root   /var/www/blog.midominio.com
            index  index.php
            if (-e $request_filename) {
              break
            }
            rewrite ^/(.+)$ /index.php?q=$1 last
        }
 
        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        location ~ \.php$ {
            fastcgi_pass   127.0.0.1:9000
            fastcgi_index  index.php
            fastcgi_param  SCRIPT_FILENAME  /var/www/blog.midominio.com$fastcgi_script_name
            include        conf/fastcgi.conf
        }
 
        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html
        location = /50x.html {
            root   html
        }
    }

El fichero de configuración de FastCGI será /usr/local/nginx/conf/fastcgi.conf:

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  GATEWAY_INTERFACE  CGI/1.1
fastcgi_param  SERVER_SOFTWARE    nginx
 
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
 
# PHP only, required if PHP was built with --enable-force-cgi-redirect
fastcgi_param  REDIRECT_STATUS    200

Para probar que funcionar, después de rearrancar nginx, podemos crear en /var/www/blog.midominio.com el siguiente fichero index.php:

<? phpinfo(); ?>

Si introducimos en el navegador la URL http://blog.midominio.com obtendremos una página con información sobre nuestra instalación de PHP.

Enlaces relacionados

• Nginx HTTP Server + PHP5
• Nginx Web Server: Slicehost Articles
• Nginx rewrite rules For WordPress

Ésta va a ser sin duda una de las noticias más importantes del 2008 tanto en el mundo empresarial de las llamadas tecnologías de la información como en el mundo del código abierto: Sun compra MySQL por 1000 millones de dólares.

Jonathan Schwartz nos cuenta que en las empresas existen dos fuerzas que por lo general son contrapuestas. Por un lado, hay una parte más técnica que quiere que los productos software que se usen sean lo más abiertos posibles, para en caso de problemas, saber realmente qué está pasando y poder arreglarlos con rápidez. Y por el otro, hay una parte más gerencial preocupada sobre todo de adquirir un soporte comercial, más “enterprise”. Con este movimiento Sun intentará contentar a ambos mundos.

Desde mi punto de vista, existe una clara tendencia a que cada vez el modelo de licencias de software tenga menos validez y a que el negocio en el mundo del software venga de los servicios profesionales y de las aplicaciones en modo ASP. Por ello, creo que es un acierto la adquisición de MySQL por parte de Sun. Está apostando por la que creo que es la tendencia ganadora.

¿Cómo será el futuro?

MySQL es la “M” de LAMP. ¿Cómo evolucionará ahora LAMP? ¿Lucharán Linux y Solaris por ser la primera letra del acrónimo? ¿Será sustituida la “P” de PHP/Perl por la “J” de Java? ¿Por la “R” de Ruby on Rails? ¿Qué pasará con PostgreSQL? Desde luego el futuro se presenta apasionante.

Yo creo que Sun intentará vender una solución integrada compuesta por su hardware, claro está, Solaris, que también es software libre, MySQL y GlassFish. Habrá por supuesto otros suministradores que ofrezcan otro hardware y Linux. Lo positivo es que estas soluciones integradas basadas en software libre serán muy competitivas con respecto a otras que no lo son. Microsoft no creo que dé, a corto plazo, ningún paso en el sentido de acercarse al software libre. Habrá que estar atentos a lo que hace a partir de ahora Oracle, quien hoy mismo también ha anunciado que adquiere Bea Systems, ya que creo que puede ser uno de los grandes perjudicados.

¿Qué opináis vosotros?

Enlaces relacionados

• Helping Dolphins Fly, por Jonathan Schwartz.
• Sun To Acquire MySQL, por Tim O’Reilly.
• Sun acquires MySQL, por Kaj Arnö.

Según su propia página web, cacti es una solución completa para generar gráficas aprovechando toda la potencia que nos brinda RRDTool. Después de tres años de espera, en octubre de 2007 se anunció la versión 0.8.7 de cacti. En su día escribí un documento donde contaba los detalles de cómo instalar cacti (0.8.6) en Solaris 8. En este post contaré cómo instalar la nueva versión de cacti (0.8.7) en Solaris 10.

Instalación de Apache + MySQL + PHP

Antes de poder instalar cacti, necesitaremos instalar Apache + Mysql + PHP. En este post puedes leer cómo hacerlo.

Instalación de RRDTool

La manera más sencilla de instalar RRDTool es instalar el paquete de sunfreeware. Este paquete depende de los siguientes paquetes:

• libart_lpgl
• zlib
• libpng
• freetype
• libgcc-3.4.6

Pero si antes hemos instalado Apache + MySQL + PHP con los paquetes de sunfreeware, el único paquete que nos quedará por instalar es libart_lpgl. Por lo tanto, para instalar RRDTool, debemos instalar los siguientes paquetes de sunfreeware:

• libart_lgpl-2.3.19
• rrdtool-1.2.19

Necesitaremos también añadir /usr/local/rrdtool-1.2.19/bin a la variable PATH.

$ rrdtool
RRDtool 1.2.19  Copyright 1997-2007 by Tobias Oetiker <tobi@oetiker.ch>
Compiled Mar 24 2007 00:31:10

Instalación de Net-SNMP

La instalación es muy sencilla, simplemente instalamos el siguiente paquete de sunfreeware:

• netsnmp-5.1.4

y añadimos /usr/local/bin al PATH.

Instalación de cacti

Descargamos cacti, volcamos su contenido en el DocumentRoot de nuestro Apache y cambiamos el propietario y el grupo del nuevo directorio:

# cd /usr/local/apache2/htdocs
# gzcat cacti-0.8.7a.tar.gz  tar xf -
# rm cacti-0.8.7a.tar.gz
# ln -s cacti-0.8.7a cacti
# chown -R cactiuser:cactigroup cacti-0.8.7a

Apuntamos nuestro DocumentRoot al directorio de cacti. Lo más sencillo es que el propietario y el grupo de cacti sean los mismos que el usuario y el grupo con el que se ejecuta Apache. Estos serían los cambios que habría que hacer en el httpd.conf de Apache:

DocumentRoot "/usr/local/apache2/htdocs/cacti"
User cactiuser
Group cactigroup

Rearrancamos Apache para que los cambios sean tenidos en cuenta:

# /etc/init.d/apache stop
Parando Apache
# /etc/init.d/apache start
Arrancando Apache

Creamos en MySQL una base de datos para cacti, y creamos el modelo de datos importando el script cacti.sql:

$ cd /usr/local/apache2/htdocs/cacti
$ mysqladmin --user=root -p create cacti
$ mysql --user=root -p cacti < cacti.sql

Creamos un usuario para cacti en la base de datos y le asignamos una contraseña:

$ mysql --user=root -p cacti
mysql> GRANT ALL ON cacti.* TO cacti@localhost IDENTIFIED BY 'password'
mysql> flush privileges

Editamos el fichero de configuración de cacti, include/config.php:

$database_type = "mysql"
$database_default = "cacti"
$database_hostname = "localhost"
$database_username = "cacti"
$database_password = "password"

En nuestro navegador, abrimos la URL http://localhost/ y nos aparecerá la pantalla de bienvenida a la instalación de cacti:

En la siguiente pantalla seleccionamos:

type of installation > New Install

Después, en la siguiente pantalla, nos tenemos que asegurar de que todas las utilidades tienen bien configurado su path.

Lo siguiente que nos aparecerá será la pantalla de login:

Aquí nos conectaremos como admin/admin y se nos pedirá una nueva contraseña. Y ya está, después de seleccionar una nueva contraseña nos aparecerá la consola de administración de nuestra instalación de cacti:

ZFS fue introducido por Sun en OpenSolaris en noviembre de 2005 y en Solaris en la actualización 6/06. Pero, ¿qué es realmente ZFS? ¿Es sólo un nuevo tipo de sistema de ficheros?

ZFS realmente es algo más, ya que nos hace prescindir del gestor de volúmenes. Podemos decir que ZFS es un sistema avanzado de gestión del almacenamiento. Con ZFS nos olvidamos de las particiones y aprovechamos mucho mejor el espacio.

Las principales caraterísticas ZFS son:

• los dispositivos físicos se agregan a un pool de almacenamiento
• es un sistema de ficheros transaccional
• tiene control de errores incorporado
• es escalable
• se pueden crear snapshots
• se simplifica notablemente la administración

Veamos detalladamente cada una de estas características.

Pool de almacenamiento

En ZFS los dispositivos físicos se agregan a un pool de almacenamiento, en el cual se crean los sistemas de ficheros. Cuando se crea un sistema de ficheros ya no es necesario preasignarle un tamaño. En ZFS cada sistema de ficheros irá tomando dinámicamente espacio del pool.

Transacciones

ZFS es un sistema de ficheros transaccional. En una operación de escritura los datos nunca se sobreescriben. Cualquier secuencia de operaciones dentro de una transacción o bien es realizada totalmente o es anulada completamente.

Esto asegura que el estado del sistema de ficheros sea siempre consistente, incluso ante una pérdida accidental de la corriente eléctrica o ante una caída del sistema. Se podrán perder los datos de la transacción en curso, pero el estado será consistente. Por ello, herramientas como el fsck ya no serán necesarias.

Control de errores

ZFS calcula checksums de todos los datos y metadatos. Mediante estos checksums ZFS es capaz de detectar fallos y recuperarse de esta situación de manera transparente a las aplicaciones que pudieran estar utilizando dichos datos.

Escalabilidad

ZFS es un sistema de ficheros de 128 bits, por lo que el almacenamiento máximo es de 2¹²⁸ bits. ¿Será suficiente? 2¹²⁸ bits son unos 42.000 mil billones de zettabytes, siendo 1 zettabyte mil millones de terabytes. Cuesta imaginarlo.

Los metadatos son creados dinámicamente, con lo que no hay necesidad de reservar inodos con antelación. Cada directorio puede tener hasta 2⁴⁸ entradas y no hay límite para el número de ficheros en un sistema de ficheros.

Snapshots

Un snapshot es una copia de sólo lectura de un sistema de ficheros. Pueden crearse con gran facilidad y ser utilizados como copias de seguridad.

Otras características

• Es posible activar la compresión y descompresión automática de los datos almacenados.
• Es posible crear volúmenes emulando un raw device, para, por ejemplo, el área de swap.

Enlaces relacionados:

• What is ZFS?
• ZFS: The Last Word in File Systems
• ZFS Wikipedia Article
• Sun’s ZFS is close to perfect, but widely misunderstood