Pour restreindre l’accès à ces applications/sites web, j’aurais pu choisir des scripts php qui intégraient une gestion utilisateurs. Mais il est déjà difficile de trouver un script php qui fasse ce que l’on veut et qui soit léger donc si il faut en plus qu’il intègre une gestion complète et sécurisée des accès utilisateurs cela devient mission impossible….

Surtout qu’il existe une alternative : déléguer l’accès à un site au serveur web.

Authentification par mot de passe

Avec Apache cela se fait avec les fichiers .htacces, sous Nginx cela se fait dans le fichier de configuration du site avec le module HttpAuthBasicModule.

La configuration d’un site se fait via la création d’un fichier dans le répertoire /etc/nginx/sites-enabled/, pour restreindre l’accès à un répertoire d’un site il suffit d’ajouter les directives auth_basic et auth_basic_user_file dans le fichier du site.

• La directive auth_basic indique que l’on utilise une authentification, les texte après sera affiché dans la boite de dialogue d’authentification :
• La directive auth_basic_user_file indique le chemin vers le fichier contenant les couple login / mot de passe (crypté) autorisé à accéder au répertoire.

Voici ma configuration :

server {
	listen       80;
	server_name  localhost;
	root         /var/www;
 
	# Security
	location ~ /\.ht {
		deny  all;
	}
 
	location /Repertoire_protege/ {
		auth_basic            "Qui va là";
		auth_basic_user_file  /$document_root/Repertoire_protege/.htpasswd;
 
		index  index.html index.htm index.php;
 
		location ~ \.php$ {
			include /etc/nginx/fastcgi_params;
			fastcgi_param   SCRIPT_FILENAME  $document_root$fastcgi_script_name;
			fastcgi_pass    127.0.0.1:9000;
		}
	}
}

J’ai personnellement choisi de stocker le fichier contenant les login/mots de passe dans le répertoire à protéger lui même mais on peut le mettre où l’on souhaite (/etc/nginx, etc…), de même le nom est par convention/ habitude .htpasswd (héritage d’Apache) mais on peut choisir le nom que l’on veut.

Par sécurité (indispensable) dès lors que l’on stock ce fichier dans un répertoire accessible par Nginx, il convient d’interdire son accès (sinon il pourra être affiché/télécharger). Dans mon cas il s’agit de la directive « location ~ /\.ht » qui interdit l’accès à tous fichier commençant par .ht

Création du fichier des login / mot de passe

Pour créer le fichier .htpasswd contenant les login et le mot de passe crypté, il est communément conseillé d’utiliser le programme htpasswd du package apache2-utils.

Lorsque l’on utilise Nginx, il est toujours un peu dérangeant d’installer un package apache (même si ce dernier est petit : 1.3Mo), il existe donc des alternative sous forme de script perl par exemple.

Le premier que j’ai trouvé/testé est basique  :

#!/usr/bin/perl
 use strict;
 chomp(my $username=$ARGV[0]);
 chomp(my $password=$ARGV[1]);
 print $username.":".crypt($password,$username)."\n";

Il prend en paramètre le login et le mot de passe (en clair), crypte le mot de passe et écrit sur la sortie standard le couple login / mot de passe crypté avec la format attendu d’un ficheir .htpasswd.

Le second (que j’ai gardé) est plus ressemblant à htpasswd d’Apache htpasswd-b: a smart replacement for the Apache htpasswd utility

#!/usr/bin/perl
 
if (! scalar @ARGV ) {
	print "Usage: htpasswd-b passwordfile user password\n";
	print "(this program automatically creates the pw file if needed.)\n";
	exit 0;
}
 
@saltsource = ('a'..'z', 'A'..'Z', '0'..'9','.','/');
$randum_num = int(rand(scalar @saltsource));
$salt = $saltsource[$randum_num];
$randum_num = int(rand(scalar @saltsource));
$salt .= $saltsource[$randum_num];
 
$outf=$ARGV[0];
$user=$ARGV[1];
$passwd=$ARGV[2];
 
if ($user && $passwd) {
	$encrypted = crypt($passwd, "$salt");
 
	if (-f $outf) {
		open(OUT, ">>$outf") || die "htpasswd-b error: $!\n";
	} else {
		open(OUT, ">$outf") || die "htpasswd-b error: $!\n";
	}
	print OUT "$user:$encrypted\n";
	close(OUT);
 
	exit 0;
}

Créer un fichier (par exemple htpasswd-perl.pl), y copier le texte ci-dessus, le rendre exécutable (chmod). Il suffit ensuite d’appeler ce script avec le nom du fichier à créer / compléter, le login et le mot de passe en clair.

./htpasswd-perl.pl /var/www/Repertoire_protege/.htpasswd utilisateur mot_de_passe

Enfin j’ai trouvé mais non testé un troisième script qui semble très complet :

htpasswd-perl: mon replacement de htpasswd | Shtark.fr

Authentification par mot de passe et php

Si votre site doit servir des pages php vous aurez surement une directive du type « location ~ \.php$ » indiquant le paramétrage fastCGI. Il est très important de mettre cette directive dans le bloc location protégé (cf ma configuration ci-dessus) sinon l’accès au répertoire sera protégé :

http:/localhost/Repertoire_protege

Mais pas l’accès directe à une page php sur le même site :

http:/localhost/Repertoire_protege/index.php

Restriction d’accès par IP

Pour être encore plus sécurisé on peut carrément restreindre l’accès d’un site ou d’un répertoire à une liste fini d’adresse IP avec les directives allow et deny :

	location /Repertoire_protege/ {
		auth_basic            "Qui va là";
		auth_basic_user_file  /$document_root/Repertoire_protege/.htpasswd;
 
		allow 127.0.0.1;
		deny all;
 
		index  index.html index.htm index.php;
 
		location ~ \.php$ {
			include /etc/nginx/fastcgi_params;
			fastcgi_param   SCRIPT_FILENAME  $document_root$fastcgi_script_name;
			fastcgi_pass    127.0.0.1:9000;
		}
	}

Allow liste les IP autorisés et deny celle qui sont interdites, dans l’exemple ci-dessus toutes les IP sont interdites sauf l’IP locale (127.0.0.1)

Enfin on peut affiner le comportement de la restriction par IP avec la restriction par mot de passe avec la directive satisfy qui indique si les 2 restrictions (IP + mot de passe) doivent être remplies (satisfy all) ou 1 seule d’entre elle (satisfy any) :

Exemple si on a une restriction par mot de passe + la restriction suivante :

allow 192.168.1.100;
deny all;

Voici les résultats en fonction de la machine accédant au site/répertoire :

Sources :

Password protect folders with NGINX the right way : Indique la « ruse » de protection d’un répertoire avec php

Restriction of the access with the help of Nginx : voir restriction sur IP

How nginx processes a request

nginx auth password or ip – Server Fault

Cependant pour certains usages (description à venir) du Dockstar j’ai besoin d’une base de donnée, c’est là qu’intervient SQLite, une base de donnée atypique puisque :

« Contrairement aux serveurs de bases de données traditionnels, comme MySQL ou PostgreSQL, sa particularité est de ne pas reproduire le schéma habituel client-serveur mais d’être directement intégrée aux programmes. L’intégralité de la base de données (déclarations, tables, index et données) est stockée dans un fichier indépendant de la plateforme. » (source Wikipedia)

Voici comment installer la base SQLite et comment l’intégrer à php :

sudo aptitude install libsqlite0 php5-sqlite

(594 ko utilisés)

Voila pour l’installation pour la configuration ce n’est pas beaucoup plus compliqué, il faut éditer le fichier php.ini (qui sous ma Debian Squeeze se trouve dans /etc/php5/cgi/).

Trouver la section suivante :

;;;;;;;;;;;;;;;;;;;;;;
; Dynamic Extensions ;
;;;;;;;;;;;;;;;;;;;;;;

Et y ajouter la ligne :

extension=sqlite.so

Pour finir re-démarrer le serveur Web ou le serveur php (sudo /etc/init.d/php5-fcgi restart)

J’ai déjà fait un article sur l’installation d’un serveur Web Cherokee et Lighttpd, mais ces 2 serveurs web sont soit trop gourmand en ressource soit trop gros.

Il reste un autre challenger à Apache, il s’agit de nginx (se prononce engine X).

Ce serveur web en plus d’être incroyablement performant est incroyablement sobre en ressources, il est quasiment systématiquement installé sur les machines de faible puissance que sont les plug computer.

Contrairement aux articles précédemment cités sur l’installation de Cherokee et Lihttpd je ne détaillerais pas l’installation de MySQL ici, pour la simple et bonne raison que je ne l’ai pas installé sur mon Dockstar (cf. Installer et configurer Mysql sur le Dockstar)

Installation de nginx

L’installation peut se faire simplement avec aptitude/apt-get car il existe un paquet nginx mais ce dernier est en version 0.7.x dans les dépôt Debian Squeeze, c’est à dire la version « legacy » (que l’on peut traduire par dépassé).

Un paquet de la version 0.8.54 est disponible sur dotdeb mais ce dernier est disponible que pour les architectures i386 et amd64 mais pas pour l’architecture ARM

On va donc installer la version 0.8.54 à partir des sources, ce qui est tout de même un peu « touchy ».

Heureusement pour nous / moi Nicolargo a publié un script automatisant le process. Ce script installe nginx depuis les sources, le configure et installe php 5.x en mode FPM depuis les dépôts dotdeb, il faut donc l’adapter pour supprimer toute la partie installation de php-fpm qui n’est pas disponible non plus sur dotdeb pour les machines ARM.

Voici le script modifié :

#!/bin/bash
# Mon script d'installation automatique de NGinx (depuis les sources)
#
# Nicolargo - 01/2011
# Modifié VoidAndAny - 03/2011
# GPL
#
# Syntaxe: # su - -c "./nginxautoinstall.sh"
# Syntaxe: or # sudo ./nginxautoinstall.sh
VERSION="2.0"
 
##############################
# Version de NGinx a installer
 
NGINX_VERSION="0.8.54"
 
##############################
# Debut de l'installation
 
# Test que le script est lance en root
if [ $EUID -ne 0 ]; then
echo "Le script doit être lancé en root: # sudo $0" 1>&2
exit 1
fi
 
# Pre-requis
aptitude install build-essential libpcre3-dev libssl-dev zlib1g-dev
 
# Telechargement des fichiers
wget http://sysoev.ru/nginx/nginx-$NGINX_VERSION.tar.gz
 
# Extract
tar zxvf nginx-$NGINX_VERSION.tar.gz
 
# Configure
cd nginx-$NGINX_VERSION
./configure   --conf-path=/etc/nginx/nginx.conf   --error-log-path=/var/log/nginx/error.log   --pid-path=/var/run/nginx.pid   --lock-path=/var/lock/nginx.lock   --http-log-path=/var/log/nginx/access.log   --with-http_dav_module   --http-client-body-temp-path=/var/lib/nginx/body   --with-http_ssl_module   --http-proxy-temp-path=/var/lib/nginx/proxy   --with-http_stub_status_module   --http-fastcgi-temp-path=/var/lib/nginx/fastcgi   --with-debug   --with-http_flv_module
 
# Compile
make
 
# Install
make install
 
# Post installation
cd ..
mkdir /var/lib/nginx
mkdir /etc/nginx/conf.d
mkdir /etc/nginx/sites-enabled
mkdir /var/www
chown -R www-data:www-data /var/www
 
# Download the init script
wget http://svn.nicolargo.com/debianpostinstall/trunk/nginx
mv nginx /etc/init.d/
chmod 755 /etc/init.d/nginx
/usr/sbin/update-rc.d -f nginx defaults
 
# Download the default configuration file
# Nginx + default site
wget http://svn.nicolargo.com/debianpostinstall/trunk/nginx.conf
wget http://svn.nicolargo.com/debianpostinstall/trunk/default-site
mv nginx.conf /etc/nginx/
mv default-site /etc/nginx/sites-enabled/
 
# Start NGinx
/etc/init.d/nginx start
 
# Summary
echo ""
echo "--------------------------------------"
echo "NGinx installation finished"
echo "--------------------------------------"
echo "NGinx configuration folder:       /etc/nginx"
echo "NGinx default site configuration: /etc/nginx/sites-enabled/default-site"
echo "NGinx default HTML root:          /var/www"
echo ""
echo "If you use IpTables add the following rules:"
echo "iptables -A INPUT -i lo -s localhost -d localhost -j ACCEPT"
echo "iptables -A OUTPUT -o lo -s localhost -d localhost -j ACCEPT"
echo "iptables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT"
echo "iptables -A INPUT  -p tcp --dport http -j ACCEPT"
echo "--------------------------------------"
echo ""
 
# Fin du script

A l’issu de ce script si on va à l’adresse IP du Dockstar avec un navigateur web, on doit avoir la page suivante qui s’affiche :

Pour être sûr que nginx peut nous restituer une page HTML on peut lancer les commandes suivante (sur la Dockstar)

echo "test" > index.html
sudo chown www-data:www-data index.html
sudo mv index.html /var/www

En allant sur l’adresse IP du Dockstar, on devrait désormais avoir test qui s’affiche.

Installation de PHP

Il existe de plusieurs façon pour un serveur web d’interagir avec le « moteur » d’interprétation de php  :

• module  : php est interprété directement par le serveur Web (avec apache par exemple)
• CGI : le serveur Web laisse l’interprétation de php au module cgi php
• fastCGI : évolution de CGI pour le rendre plus performant
• spawn-fcgi : une implémentation de fastCGI initialement faite pour le serveur web lighttpd
• FPM : implémentation de fastCGI remplaçant de spawn-fcgi plus rapide et stable

Malheureusement il n’existe pas de paquet Debian de l’implémentation FPM de fastCGI (php-fpm) pour l’architecture ARM, donc à moins de vouloir le compiler depuis les sources on utilisera l’implémentation spawn-fcgi de php.

Pour l’installation on fera :

sudo aptitude install php5-cgi spawn-fcgi

(20,3 Mo utilisés)

Il faut ensuite faire un script init.d (/etc/init.d/php5-fcgi) pour que le serveur php démarre :

#!/bin/sh
 
### BEGIN INIT INFO
# Provides:       php5-fcgi
# Required-Start: $remote_fs $syslog
# Required-Stop:  $remote_fs $syslog
# Default-Start:  2 3 4 5
# Default-Stop:   0 1 6
# Short-Description: PHP5 FastCgi Spawned processes
### END INIT INFO
 
COMMAND=/usr/bin/spawn-fcgi
ADDRESS=127.0.0.1
PORT=9000
USER=www-data
GROUP=www-data
PHPCGI=/usr/bin/php5-cgi
PIDFILE=/var/run/fastcgi-php.pid
RETVAL=0
 
PHP_FCGI_MAX_REQUESTS=500
PHP_FCGI_CHILDREN=2
 
start() {
 export PHP_FCGI_MAX_REQUESTS PHP_FCGI_CHILDREN
 $COMMAND -a $ADDRESS -p $PORT -u $USER -g $GROUP -f $PHPCGI -P $PIDFILE
}
 
stop() {
 /usr/bin/killall -9 php5-cgi
}
 
case "$1" in
 start)
 start
 RETVAL=$?
 ;;
 stop)
 stop
 RETVAL=$?
 ;;
 restart|reload)
 stop
 start
 RETVAL=$?
 ;;
 *)
 echo "Usage: fastcgi {start|stop|restart}"
 exit 1
 ;;
esac
exit $RETVAL

Et on le démarre :

sudo /etc/init.d/php5-fcgi start

Il faut ensuite en théorie indiquer à nginx comment interpréter les fichiers php en ajouter ce genre de directives dans le fichier /etc/nginx/sites-enabled/default-site

location ~ \.php$ {
 include /etc/nginx/fastcgi_params;
 fastcgi_param   SCRIPT_FILENAME  $document_root$fastcgi_script_name;
 fastcgi_pass    127.0.0.1:9000;
 }

J’ai marqué en théorie car l’installation de nginx faite par le script de Nicolargo créé un fichier default-site qui contient déjà cette directive.

Pour tester php, on crée un fichier php contenant la directive phpinfo :

echo "<?php phpinfo(); ?>" > phpinfo.php
sudo chown www-data:www-data phpinfo.php
sudo mv phpinfo.php /var/www

Et en allant sur l’adresse IP du Dockstar, sur la page phpinfo.php on doit voir cette page s’afficher :

PS : Quelques information concernant l’espace disque utilisé par les différents serveur web (sur une Debian de base)

• nginx : 1.6 MB
• apache2 : 44.4 MB
• lighttpd : 35.8 MB

Sources :

Nicolargo : Installation automatique de NGinx, PHP-FPM, MemCached sous Debian

IT Wars : Seagate DockStar un plug computer green

Blog slucas : Installation de nginx sous Debian

Ici & Ailleurs : Un serveur web avec Nginx, PHP et MySQL

Linode library : Nginx and PHP-FastCGI on Debian 5 (Lenny)

Linode library : Basic Nginx Configuration

Linode Library : Nginx Configuration

Papy Geek : Optimiser son serveur Web avec Nginx

La galerie photo que j’avais sélectionné était Zenphoto qui nécessite une base de données MySQL or j’ai trouvé un nouveau script de galerie photo plus léger / simple et qui ne nécessite « que » SQLite (beaucoup plus léger que MySQL).

Voici donc brièvement mes notes d’installation et de configuration de MySQL (pour ne pas les perdre)

J’ai déjà traité cette installation ici et ici (pas sur le Dockstar)

L’installation est simplissime :

sudo aptitude install mysql-server mysql-client

Cela installe les paquets suivants :

libdbd-mysql-perl{a} libdbi-perl{a} libmysqlclient16{a} libnet-daemon-perl{a} libplrpc-perl{a} mysql-client mysql-client-5.1{a} mysql-common{a} mysql-server mysql-server-5.1{a} mysql-server-core-5.1{a} psmisc{a}

(54Mo sur le disque)

Lors de l’installation le mot de passe root est demandé :

Configuration de mysql-server-5.1
---------------------------------
Il est très fortement recommandé d'établir un mot de passe pour le compte d'administration de MySQL (« root »).
Si ce champ est laissé vide, le mot de passe ne sera pas changé.
Nouveau mot de passe du superutilisateur de MySQL :
Confirmation du mot de passe du superutilisateur de MySQL :

En l’état MySQL prend 14.5% de la mémoire du Dockstar (pas léger l’animal), on trouvera ici et là des optimisations pour MySQL, mais le plus simple est encore de prendre le fichier de configuration fournis par MySQL pour les petites machines :

sudo cp  /etc/mysql/my.cnf /etc/mysql/my.cnf.orig
sudo cp  /usr/share/doc/mysql-server-5.1/examples/my-small.cnf /etc/mysql/my.cnf
sudo /etc/init.d/mysql restart

Avec cette configuration MySQL prend toujours 12.8% de la mémoire, d’où mon exploration pour trouver une alternative à zenphoto pour ne pas avoir à installer ce glouton de MySQL

J’avais donc la possibilité d’installer apache2, la référence en la matière mais les souvenir que j’en ai sont peu probants (configuration pas super simple), j’ai donc choisi lighttpd.

Comme l’article précédemment cité on installera MySQL, Lighttpd et php.

Installation de MySQL

Comme dans l’article précédent (pas de changement) :

sudo aptitude install mysql-server mysql-client

Ce qui installe :

 libdbd-mysql-perl{a} libdbi-perl{a} libhtml-template-perl{a} libnet-daemon-perl{a}
 libplrpc-perl{a} mysql-client mysql-client-5.1{a} mysql-client-core-5.1{a} mysql-server
 mysql-server-5.1{a} mysql-server-core-5.1{a}

Il faudra renseigner le mot de passe du super-utilisateur root.

Installation de Lighttpd

sudo aptitude install  lighttpd

Ce qui installe :

libterm-readline-perl-perl{a} lighttpd spawn-fcgi{a}

Si on test en allant sur l’adresse du serveur en http (http://ip_server), on aura alors la page suivante si tout fonctionne correctement :

Installation de PHP

Là encore aucune modification par rapport à Cherokee :

sudo aptitude install php5-cgi php5-mysql

Qui installe :

php5-cgi php5-common{a} php5-mysql

Ajout du support php à Lighttpd

Contrairement à Cherokee cela se fait en ligne de commande (ce qui ma foi est plus simple) :

sudo lighty-enable-mod fastcgi-php
sudo lighty-enable-mod fastcgi
sudo /etc/init.d/lighttpd force-reload

Test de php

Tout comme pour Cherokee on crée un fichier php contenant l’instruction phpinfo() dans /var/www (racine du site web)

<?php
   echo phpinfo();
?>

Si on va sur l’URL correspondante on devrait avoir :

Sources :

lighttpd – Documentation Ubuntu Francophone

Installer un serveur web Lighttpd | throka.org

En effet compte tenu de la volumétrie (plusieurs gigas de photos) et du caractère personnel des photos je ne souhaite pas faire héberger cette gallerie (sur Free.fr par exemple).

Un serveur web est un ensemble de briques logiciel :

• une base de données : MySQL le plus souvent
• un moteur de scripts : c’est ce qui permet de faire un site dynamique le plus courant est php
• un serveur web proprement dit : le plus souvent Apache, mais il existe des prétendants et notamment Cheroke qui serait plus rapide qu’Apache et surtout plus facile à administrer.

Installation de MySQL

Cela se fait par un simple :

sudo aptitude install mysql-server mysql-client

Qui installe les paquets suivant (par le jeu des dépendances et des méta-paquets) :

libdbd-mysql-perl{a} libdbi-perl{a} libhtml-template-perl{a} libnet-daemon-perl{a}
 libplrpc-perl{a} mysql-client mysql-client-5.1{a} mysql-client-core-5.1{a} mysql-server
 mysql-server-5.1{a} mysql-server-core-5.1{a}

Lors de l’installation on nous demande le mot de passe du super-utilisateur de MySQL (root) :

Au terme de l’installation on peut s’assurer que le service MySQL tourne par :

sudo service mysql status

Qui renvoi :

mysql start/running, process 25769

Installation de Cherokee

Là encore l’installation est simplissime :

sudo aptitude install cherokee

Qui installe :

cherokee libcherokee-base0{a} libcherokee-client0{a} libcherokee-config0{a}
 libcherokee-mod-admin{a} libcherokee-server0{a} spawn-fcgi{a}

Au terme de l’installation on à un serveur Web statique c’est à dire capable de servir aux navigateurs de simples pages HTML, pour s’en assurer il suffit d’aller sur l’adresse de votre serveur en http :

http://ip_server

ip_server : est l’adresse IP de la machine sur laquelle vous avez installé Cherokee, si il s’agit de la machine locale, on pourra utiliser localhost.

Cherokee vous sert alors la page d’accueil du serveur :

Administration Cherokee

Le gros point fort de Cherokee est sont interface d’administration web, pas besoin d’éditer des fichiers de configuration.

Par défaut l’interface d’administration n’est pas accessible, il au préalable lancer sur le serveur contenant Cherokee la commande suivante :

sudo cherokee-admin -b

Qui renvoi le login et le mot passe unique pour cette session de connexion à l’interface d’administration :

Login:
 User:              admin
 One-time Password: yDRmCWliaUxnM480
 
Web Interface:
 URL:               http://localhost:9090/
 
Cherokee Web Server 1.0.8 (Aug 11 2010): Listening on port ALL:9090, TLS
 disabled, IPv6 enabled, using epoll, 4096 fds system limit, max. 2041
 connections, caching I/O, single thread

Rque : si vous ne lancez pas cette commande avec sudo vous aurez le messages suivant

Unable to raise file descriptor limit to 4096
Configuration file is not writable
The configuration file <code>/etc/cherokee/cherokee.conf</code> cannot be modified

Il suffit alors d’aller à l’URL http://ip_server:9090 pour accéder à l’interface d’administration (après avoir renseigné le login, mot de passe indiqué par la commande cherokee-admin)

Rque : les copie d’écran de cherokee sont réalisées avec la version 1.0.4-1 (version par défaut sous Ubuntu 10.10)

PHP

Pour avoir un site dynamique, on a besoin d’un moteur de script, le plus courant étant php

Pour l’installer

sudo aptitude install php5-cgi php5-mysql

Rque : php5-mysql installe les modules autorisant la connexion à MySQL depuis php

Ce qui installe :

php5-cgi php5-common{a} php5-mysql

Ajout du support php à Cherokee

Rque : les copie d’écran de cherokee sont réalisées avec la version 1.0.4-1 (version par défaut sous Ubuntu 10.10)

Dans l’administration de cherokee cliquer sur vServers dans le bandeau haut :

Par défaut il n’y a qu’un seul site de configuré « default », cliquer dans l’onglet « Behavior » :

Cliquer sur le bouton « Rule management » pour afficher les caractéristique du serveur virtuel :

Cliquer sur le bouton + à gauche (à côté de « Behavior ») pour ajouter un rôle à notre serveur, un wizard apparait :

Sélectionner Langues, puis php et enfin appuyer sur ajouter :

Cliquer sur Créer

Le rôle php est ajouté à notre serveur :

Cliquer sur Sauvegarder (dans le bandeau haut) puis sur « redémarrage gracieux » dans la boite de dialogue qui apparait.

Test de php

Pour tester php, il suffit de copier le code suivant dans un fichier portant l’extension php (par exemple info.php) et placé dans /var/www (racine du site web)

<?php
   echo phpinfo();
?>

Puis ensuite d’aller à l’url :

http://ip_serveur/info.php

Une page comme celle-ci doit apparaitre :

Problème rencontré

Lors de mes premier essai, sur mon serveur (Ubuntu minimal 10.04), le php n’était pas reconnu par Cherokee, dès que j’allais sur une page php, mon navigateur me proposait de télécharger le fichier php, comme si l’ajout du support php à Cherokee n’était pas configuré.

J’ai essayé de nombreuses choses sans succès à tel point que j’ai renoncé à Cherokee pour Apache et au moment de rédiger cet article j’ai ré-essayé Cherokee et là miracle ca marche.

Je me suis dit que ça venait du fait que j’avais installé Apache et d’autres modules php (php5 et libapache2-mod-php5 au lieu de php5-cgi) j’ai donc refait une installation de zéro de Cherokee sur une machine virtuelle et là aussi ça marche…..

Sources :

Ubuntu – Installation de Cherokee : Serveur Web simple et Performant

Installing Cherokee With PHP5 And MySQL Support On Ubuntu 10.04

Installation et configuration de Cherokee sous Ubuntu