Rendez-vous sur Arrakis

C'est lorsque nous croyons savoir quelque chose qu'il faut justement réfléchir un peu plus profondément. F. Herbert

Tutoriel pour installer un serveur chez soi (debian)

Cette page n'est plus d'actualité.

Un travail plus complet est accessible ici.

Vous pouvez trouver une autre documentation, un peu moins ancienne, basée sur debian :


Cette page tente de recenser les différents manœuvres pour installer un serveur chez soi, afin d'héberger son courriel, son site web, une seedbox… Les programmes et services décris sont choisis pour leur simplicité d'installation et légèreté, histoire de pouvoir les faire fonctionner sur des machines plus anciennes.

En plus de ce tuto, un script visant à faciliter toutes ces manipulations est disponible, il s'appelle Host@home.

Comme il y a un peu de tout, utilisez le sommaire ci-dessous pour rejoindre rapidement la partie qui vous intéresse.

Installation via un script

Un script nommé hostathome est disponible à cette page pour vous permettre d'installer votre serveur sans devoir comprendre tout ce qu'il y a ci-dessous, bien que cela soit vivement conseillé à l'avenir.

Serveur sftp (partage de fichiers) avec chroot

Suite à cette installation, vous pourrez partager des fichiers avec ceux que vous voulez, en toute sécurité. C'est ssh qui s'en charge! Il sera possible de déposer des fichiers sur le serveur, et d'en télécharger.

Dans la suite, je suppose que les fichiers déposés sur le serveur sont stockés dans /media/PIDATA/sftp

Configuration du serveur sftp

Un serveur sftp est disponible lorsqu'on installe openssh-server. Voici quelques modifications à apporter au fichier /etc/ssh/sshd_config :

Match Group sftpusers
ChrootDirectory /media/PIDATA/sftp
ForceCommand internal-sftp -f LOCAL7 -l INFO
AllowTcpForwarding no

Ainsi, tous les utilisateurs du groupe sftpusers seront coincés dans le dossier /media/PIDATA/sftp. Utiliser un groupe sftpusers exprès pour l'accès en sftp permet de faciliter la gestion du serveur en garantissant une sécurité particulière.

Ce dossier doit être appartenu par root pour plus de sécurité. Lancez la commande suivante pour que l'on ne puisse pas remonter plus haut dans l'arborescence: chown root:root /media/PIDATA/sftp

Créez un dossier /home dans le dossier /media/PIDATA/sftp pour que les utilisateurs y soient automatiquement placés à leur connexion. Dans /media/PIDATA/sftp/home, il y aura les dossiers portant le nom des utilisateurs.

En fait, on fait comme si le répertoire /media/PIDATA/sftp était la nouvelle racine / pour les utilisateurs.

Avec filezilla, les utilisateurs pourront déposer les fichiers voulus.

Pouvoir accéder aux documents avec un navigateur web (via http)

Afin de rendre les fichiers déposés par les utilisateurs disponibles au public, ajoutez ces lignes dans la configuration de nginx :

location ~ ^/~(.+?)(/.*)?$ {
         alias /media/PIDATA/sftp/home/$1/$2;
         index  index.html index.htm;
         autoindex on;
     }

Les documents seront accessible à l'adresse http://votreserveur.com/~utilisateur , ce qui est plus pratique que de devoir télécharger un client sftp pour un utilisateur moins averti.

Pour qu'un dossier ne soit pas accessible sur le net (en http) (utilisateur privé), il suffit de changer les droits sur son dossier : chmod 700 /media/PIDATA/home/sftp/home/utilisateur

Ajout d'utilisateur rapide avec script

Pour ajouter un nouvel utilisateur qui aura droit d'accès au sftp, et uniquement aux commande sftp (en supposant que le répertoire de stockage est dans /media/PIDATA/sftp), voici un résumé des commandes à éxécuter, que vous pouvez transformer en script si vous le souhaitez. De plus, l'utilisateur disposera d'un dossier public (accessible via http://serveur.net/~utilisateur/public) pour diffuser ses fichiers, et d'un dossier privé.

#!/bin/sh

### Création d'un utilisateur, qui n'a pas de shell
# et ne peut donc nuire au serveur
# On ne lui crée pas de /home/utilisateur non plus.
adduser --shell /bin/false --no-create-home "$1"

### On ajoute l'utilisateur au groupe sftpusers
usermod -a -G sftpusers "$1"

### On crée le répertoire utilisateur dans le chroot
mkdir -p "/media/PIDATA/sftp/home/$1"

### Accès seulement (pas d'ecriture) au dossier de l'utilisateur
chmod 555 "/media/PIDATA/sftp/home/$1"

### Création des dossiers public et prive
mkdir -p "/media/PIDATA/sftp/home/$1/public"
mkdir -p "/media/PIDATA/sftp/home/$1/prive"

### Seul l'utilisateur a le droit d'aller dans prive
chmod 700 "/media/PIDATA/sftp/home/$1/prive"

### public accessible par tous
chmod 755 "/media/PIDATA/sftp/home/$1/public"

### On rend l'utilisateur propriétaire de son répertoire
chown -R $1:$1 "/media/PIDATA/sftp/home/$1"

sed -i "s/AllowUsers.*/& $1/" /etc/ssh/sshd_config

exit 0

Une fois un nouvel utilisateur créé, la dernière ligne permet de l'ajouter aux utilisateurs autorisés à accéder au sftp. Vérifiez bien qu'il est bien en plus dans /etc/ssh/sshd_config :

AllowUsers utilisateur1 utilisateur2

Logs pour sftp.

Créez dans le chroot un répertoire dev/

mkdir /media/PIDATA/sftp/dev

Ajouter cette ligne dans /etc/rsyslog.conf

$AddUnixListenSocket /media/PIDATA/sftp/dev/log

En redémarrant rsyslog, un fichier log sera créé dans le répertoire dev. Pour le redémarrer : service rsyslog restart.

Ajouter dans /etc/ssh/sshd_config les lignes suivantes :

# Logging
SyslogFacility LOCAL6
LogLevel INFO

Et modifier la ligne concernant le subsystem :

Subsystem sftp /usr/lib/openssh/sftp-server -f LOCAL7 -l INFO

Enfin, ajouter ces lignes dans /etc/rsyslog.conf, pour dire dans quel fichier enregistrer les logs du chroot (moi je met tout dans /var/log/sshd)

local7.info /var/log/sftp
local6.info /var/log/sshd

Enfin, redémarrez rsyslog et ssh :

service ssh restart
service rsyslog restart

Utilisez le serveur comme mediacenter

C'est un bien grand mot. Ce que je vais décrire ici est une procédure pour lire les fichiers (videos, musiques…) présentes sur le serveur, déposés par un tiers ou téléchargés, comme s'il s'agissait de fichiers présents sur votre ordinateur.

Méthode 1

Bien que la plupart des gestionnaires de fichiers permettent de se connecter à un dossier distant, je décrirais ici une méthode fonctionnant avec n'importe quel gestionnaire de fichiers, qui permet de lire les dossiers avec vos logiciels habituels (ce qui n'est pas possible autrement, il faut les copier d'abord en dur).

On utilisera le paquet sshfs. Il permet de monter un dossier distant sur un dossier sur votre ordinateur, de façon tout à fait transparente. Assurez-vous d'appartenir au groupe fuse :

usermod -a -G fuse votrenomdutilisateur

J'utilise le script suivant pour monter le dossier distant sur un dossier local (/tmp/mediacenter), puis ouvre ce dossier avec thunar. J'ai lié ce script à un lanceur dans xfce. Libre à vous de l'adapter :

#!/bin/sh
PORT=22
mkdir -p /tmp/mediacenter
sshfs pi@dunespice.no-ip.org:/media/PIDATA/sftp/Telechargements /tmp/mediacenter/ -p $PORT
thunar /tmp/mediacenter

exit 0

Au final, vous avez dans le dossier /tmp/mediacenter tous vos documents présents sur le serveur, comme s'ils étaient sur votre ordinateur.

Pour démonter le dossier, il faut lancer la commande fusermount -u /tmp/mediacenter

Méthode 2

Ici, des hauts-parleurs ou votre chaine HiFi sont branchés sur la sortie son du raspberry pi.

Cette deuxième méthode nécessite donc que le serveur soit chez vous si vous souhaitez avoir du son. Cependant, elle présente l'avantage d'être beaucoup moins gourmande en bande passante. En effet, seul l'affichage est transmis entre les ordinateurs, et non les données entières de la video!

Afin de lire une vidéo, on va se connecter en ssh, avec l'option -X :

ssh -XC pi@10.1.4.5.3

En remplaçant bien sûr 10.1.4.5.3 par l'ip de votre serveur ou son nom de domaine.

Maintenant, on va lancer une vidéo avec votre lecteur favori, par exemple en faisant mplayer ma_super_video/video.avi. L'image sera sur votre ordinateur (non sur le raspberry), et le son sortira des enceintes.

Une précaution toutefois, avoir ceci dans /etc/ssh/sshd_config :

X11Forwarding yes

Serveur d'impression

Un serveur d'impression à domicile peut vous permettre d'imprimer n'importe quel documents, où que vous soyez.

Héberger un dépot mercurial

Il est tout à fait possible d'héberger soi-même son dépot mercurial. Cela permet de s'affranchir des hébergeurs non-libres, dont l'existence n'est pas garantie à vie.

J'ai choisi ici mercurial, qui à mon sens est beaucoup plus simple d'utilisation que git, en particulier pour la mise en place du serveur.

Cette méthode s'applique donc à une debian, avec nginx.

Pré-requis

On commence simple, il faut installer mercurial et fcgiwrap: apt-get install mercurial fcgiwrap

Ensuite, créez un dossier pour votre projet, puis initialisez le dépot :

mkdir coolrepo
cd coolrepo
hg init

Vous pouvez maintenant modifier le fichier .hg/hgrc de ce répertoire (le créer s'il n'existe pas). Son contenu peut par exemple être :

[web]
contact = Xavier Cartron
description = Divers programmes, scripts et documents.
allow_archive = gz, zip, bz2
allow_push = *

[hooks]
changegroup = hg update >&2

La deuxième section permet la mise à jour automatique du dépot après chaque changements.

Mise en place de l'interface web

On copie le script cgi (celui qui génère les pages web) et on le place dans votre dossier utilisateur :

cp /usr/share/doc/mercurial-common/examples/hgweb.cgi ~
chmod +x ~/hgweb.cgi

On édite ce fichier, afin d'adapter la ligne suivante :

config = "/home/pi/hgweb.config"

On crée le fichier hgweb.config et on le rempli ainsi :

[paths]
coolrepo = /home/pi/coolrepo/

[web]
baseurl = /hg
staticurl = /static
descent = True
collapse = True

Les instructions baseurl et staticurl sont importantes pour la configuration de nginx. baseurl sera placé devant chaque liens, il faut donc mettre le préfixe utilisé, si par exemple vous n'hébergez pas le dépot à la racine du serveur, par exemple à http://votreserveur/hg. staticurl correspond à l'adresse web des élements statiques (images, logos…)

Configurons nginx justement. Pour cela, on va ajouter dans le fichier de configuration ces quelques lignes :

location ~ /hg/ {
    rewrite ^/hg(.*)$ $1 break;
    fastcgi_pass unix:/var/run/fcgiwrap.socket;
    fastcgi_param   SCRIPT_FILENAME /home/pi/hgweb.cgi;
    fastcgi_param   PATH_INFO       $fastcgi_script_name;
    fastcgi_param   AUTH_USER       $remote_user;
    fastcgi_param   REMOTE_USER     $remote_user;
    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   SERVER_PROTOCOL $server_protocol;
    fastcgi_param   SERVER_PORT     $server_port;
    fastcgi_param   SERVER_NAME     $server_name;
    include fastcgi_params;
    }
location ^~ /static {
    rewrite ^/static(/.*)$ $1 break;
    root /usr/share/mercurial/templates/static;
    autoindex off;
    }

Et voilà. Comme ça, tout ce qui est statique (images de logos…) sont correctement affichées, et votre serveur est accessible à l'adresse http://votreserveur.com/hg/ .

Plus d'informations ici : http://mercurial.selenic.com/wiki/PublishingRepositories

Utilisation du dépot.

Vous pouvez copier le dépot sur votre ordinateur ainsi :

hg clone http://votreserveur.com/hg/coolrepo

Ou bien si le dépot n'est pas accessible à tous, utiliser ssh :

hg clone ssh://utilisateur@votreserveur.com:22/home/pi/coolrepo

Réalisez les modifications à l'intérieur du dossier, puis poussez les modifications ainsi :

hg addremove
hg commit -m "mes modifications"
hg push

En ssh, il faudra peut-être pousser les modifications ainsi :

hg push ssh://utilisateur@votreserveur.com:22/home/pi/coolrepo

Héberger un dépot git

Il existe pléthore d'informations sur la gestion des dépôts git. Ici je ne parlerai que de l'interface web cgit que l'on utilisera avec nginx.

Vous aurez besoin des paquets cgit, fcgiwrap et spawn-fcgi

apt-get install cgit nginx spawn-fcgi fcgiwrap

La configuration de nginx devra donc ressembler à ceci :

server {
    listen                80;
    server_name votredomaine.com;
    index cgit.cgi;

    root                  /usr/share/cgit;
    try_files             $uri @cgit;

    location @cgit {
    include             fastcgi_params;
    fastcgi_param       SCRIPT_FILENAME /usr/lib/cgit/cgit.cgi;
    fastcgi_param       PATH_INFO       $uri;
    fastcgi_param       QUERY_STRING    $args;
    fastcgi_param       HTTP_HOST       $server_name;
    fastcgi_pass        unix:/run/fcgiwrap.socket;
    }
}

Pour configurer cgit, il faut modifier le fichier /etc/cgitrc. Voici un exemple qui va détecter comme un grand tous les dépôts git dans le dossier /home/xavier/gitreps :

virtual-root=/
css=/cgit.css
logo=/cgit.png
enable-http-clone=1
enable-commit-graph=1
enable-index-owner=0
snapshots=tar.gz tar.xz zip

root-title="Les bricolages de Thuban"
root-desc="Scripts, programmes et autres..."

enable-git-config=1

scan-path=/home/xavier/gitreps/

Pour pouvoir pousser des modifications via http, il vous faudra ajouter une section dans la configuration de nginx :

location ~ "^.*/(git-(receive|upload)-pack|HEAD|info/refs|objects/(info/(http-)?alternates|packs)|[0-9a-f]{2}/[0-9a-f]{38}|pack/pack-[0-9a-f]{40}\.(pack|idx))$" {
#    auth_basic          "Accès restreint";
#    auth_basic_user_file    /media/PIDATA/www/gitreps/git_access;
    root /media/PIDATA/www/gitreps/;
    fastcgi_param SCRIPT_FILENAME /usr/lib/git-core/git-http-backend;
    fastcgi_param GIT_PROJECT_ROOT /media/PIDATA/www/gitreps/;
    fastcgi_param GIT_HTTP_EXPORT_ALL "";
    fastcgi_param PATH_INFO $fastcgi_script_name;
    include fastcgi_params;
    fastcgi_pass unix:/run/fcgiwrap.socket;
    fastcgi_param   REMOTE_USER         $remote_user;
}

J'ai laissé commenté les lignes pour l'authentification. Cela veut dire que tout le monde y a accès, à condition d'avoir lancé la commande suivante dans votre dépôt git :

git config http.receivepack true

Sinon, décommentez les lignes avec auth_ puis créez un fichier pour gérer les authentifications avec la commande :

htpasswd -c /media/PIDATA/www/gitreps/git_access nom_dutilisateur

Seedbox avec rtorrent.

Nous allons voir comment transformer votre installation sur Raspberry pi en ce qu'on appelera une “seedbox”, autrement dit une machine qui partage tous vos torrents, 24H/24. Cela vous permettra notamment de rendre disponible vos distributions favorites à toutes heures.

Par la suite, nous verrons comment accéder aux téléchargements torrents, comme s'ils étaient présents dans un dossier de votre ordinateur.

Toutefois, sachez que le script Host@home vous permet d'installer rtorrent avec une interface d'accès dans un navigateur ainsi qu'un accès via navigateur aux fichiers téléchargés (protégé par mot de passe). Regardez la fonction dotorrent pour vous en inspirer.

Installation des paquets

On installe rtorrent et screen : apt-get install rtorrent screen

On configure rtorrent.

Pour cela, créez un dossier .rtorrent et de session : mkdir -p ~/.rtorrent/session

On crée ensuite le fichier ~/.rtorrent.rc à adapter selon vos besoins :

# ~/.rtorrent.rc and enable/modify the options as needed. Remember to
# uncomment the options you wish to enable.

# Maximum and minimum number of peers to connect to per torrent.
#min_peers = 40
#max_peers = 100

# Same as above but for seeding completed torrents (-1 = same as downloading)
#min_peers_seed = 10
#max_peers_seed = 50

# Maximum number of simultanious uploads per torrent.
#max_uploads = 15

# Global upload and download rate in KiB. "0" for unlimited.
#download_rate = 0
upload_rate = 35

# Default directory to save the downloaded torrents.
directory = ~/Telechargements/Finis

# Default session directory. Make sure you don't run multiple instance
# of rtorrent using the same session directory. Perhaps using a
# relative path?
session = /home/pi/.rtorrent/session

# Watch a directory for new torrents, and stop those that have been
# deleted.
schedule = watch_directory,5,5,load_start=~/Telechargements/torrents/*.torrent
schedule = untied_directory,5,5,stop_untied=
schedule = tied_directory,5,5,start_tied=

# Close torrents when diskspace is low.
schedule = low_diskspace,5,60,close_low_diskspace=100M

# The ip address reported to the tracker.
#ip = 127.0.0.1
#ip = rakshasa.no

# The ip address the listening socket and outgoing connections is
# bound to.
#bind = 127.0.0.1
#bind = rakshasa.no

# Port range to use for listening.
port_range = 49164-55555

# Start opening ports at a random position within the port range.
port_random = yes

# Check hash for finished torrents. Might be usefull until the bug is
# fixed that causes lack of diskspace not to be properly reported.
check_hash = yes

# Set whetever the client should try to connect to UDP trackers.
use_udp_trackers = yes

# Alternative calls to bind and ip that should handle dynamic ip's.
#schedule = ip_tick,0,1800,ip=rakshasa
#schedule = bind_tick,0,1800,bind=rakshasa

# Encryption options, set to none (default) or any combination of the following:
# allow_incoming, try_outgoing, require, require_RC4, enable_retry, prefer_plaintext
#
# The example value allows incoming encrypted connections, starts
#unencrypted
# outgoing connections but retries with encryption if they fail, preferring
# plaintext to RC4 encryption after the encrypted handshake
#
encryption = allow_incoming,require,require_rc4,enable_retry

# Enable DHT support for trackerless torrents or when all trackers are down.
# May be set to "disable" (completely disable DHT), "off" (do not start DHT),
# "auto" (start and stop DHT as needed), or "on" (start DHT immediately).
# The default is "off". For DHT to work, a session directory must be defined.
#
dht = auto

# UDP port to use for DHT.
#
dht_port = 55550

# Enable peer exchange (for torrents not marked private)
#
peer_exchange = yes

#
# Do not modify the following parameters unless you know what you're doing.
#

# Hash read-ahead controls how many MB to request the kernel to read
# ahead. If the value is too low the disk may not be fully utilized,
# while if too high the kernel might not be able to keep the read
# pages in memory thus end up trashing.
#hash_read_ahead = 10

# Interval between attempts to check the hash, in milliseconds.
#hash_interval = 100

# Number of attempts to check the hash while using the mincore status,
# before forcing. Overworked systems might need lower values to get a
# decent hash checking rate.
#hash_max_tries = 10
# First and only argument to rtorrent_mail.sh is completed file's name (d.get_name)
system.method.set_key = event.download.finished,notify_me,"execute=~/rtorrent_mail.sh,$d.get_name="

scgi_port = localhost:5000

Script de lancement de rtorrent en tant que démon.

Ce script est à placer dans /etc/init.d/rtorrent :

#!/bin/sh

### BEGIN INIT INFO
# Provides: rtorrent
# Required-Start: $network $syslog
# Required-Stop: $network
# Default-Start: 2 3 5
# Default-Stop: 0 1 6
# Description: Démarrer/arrêter rtorrent sous forme de daemon.
### END INIT INFO

#############
###<Notes>###
#############
# This script depends on screen.
# For the stop function to work, you must set an
# explicit session directory using ABSOLUTE paths (no, ~ is not absolute) in your rtorrent.rc.
# If you typically just start rtorrent with just "rtorrent" on the
# command line, all you need to change is the "user" option.
# Attach to the screen session as your user with
# "screen -dr rtorrent". Change "rtorrent" with srnname option.
# Licensed under the GPLv2 by lostnihilist: lostnihilist _at_ gmail _dot_ com
##############
###</Notes>###
##############

#######################
##Start Configuration##
#######################
# You can specify your configuration in a different file
# (so that it is saved with upgrades, saved in your home directory,
# or whateve reason you want to)
# by commenting out/deleting the configuration lines and placing them
# in a text file (say /home/user/.rtorrent.init.conf) exactly as you would
# have written them here (you can leave the comments if you desire
# and then uncommenting the following line correcting the path/filename
# for the one you used. note the space after the ".".
# . /etc/rtorrent.init.conf

#Do not put a space on either side of the equal signs e.g.
# user = user
# will not work
# system user to run as
user="pi"

# the system group to run as, not implemented, see d_start for beginning implementation
# group=`id -ng "$user"`

# the full path to the filename where you store your rtorrent configuration
config="`su -c 'echo $HOME' $user`/.rtorrent.rc"

# set of options to run with
options=""

# default directory for screen, needs to be an absolute path
base="`su -c 'echo $HOME' $user`"

# name of screen session
srnname="rtorrent"

# file to log to (makes for easier debugging if something goes wrong)
logfile="/var/log/rtorrentInit.log"
#######################
###END CONFIGURATION###
#######################
PATH=/usr/bin:/usr/local/bin:/usr/local/sbin:/sbin:/bin:/usr/sbin
DESC="rtorrent"
NAME=rtorrent
DAEMON=$NAME
SCRIPTNAME=/etc/init.d/$NAME

checkcnfg() {
    exists=0
    for i in `echo "$PATH" | tr ':' '\n'` ; do
        if [ -f $i/$NAME ] ; then
            exists=1
            break
        fi
    done
    if [ $exists -eq 0 ] ; then
        echo "cannot find rtorrent binary in PATH $PATH" | tee -a "$logfile" >&amp;2
        exit 3
    fi
    if ! [ -r "${config}" ] ; then
        echo "cannot find readable config ${config}. check that it is there and permissions are appropriate" | tee -a "$logfile" >&amp;2
        exit 3
    fi
    session=`getsession "$config"`
    if ! [ -d "${session}" ] ; then
        echo "cannot find readable session directory ${session} from config ${config}. check permissions" | tee -a "$logfile" >&amp;2
        exit 3
    fi
}

d_start() {
  [ -d "${base}" ] &amp;&amp; cd "${base}"
  stty stop undef &amp;&amp; stty start undef
  su -c "screen -ls | grep -sq "\.${srnname}[[:space:]]" " ${user} || su -c "screen -dm -S ${srnname} 2>&amp;1 1>/dev/null" ${user} | tee -a "$logfile" >&amp;2
  # this works for the screen command, but starting rtorrent below adopts screen session gid
  # even if it is not the screen session we started (e.g. running under an undesirable gid
  #su -c "screen -ls | grep -sq "\.${srnname}[[:space:]]" " ${user} || su -c "sg \"$group\" -c \"screen -fn -dm -S ${srnname} 2>&amp;1 1>/dev/null\"" ${user} | tee -a "$logfile" >&amp;2
  su -c "screen -S "${srnname}" -X screen rtorrent ${options} 2>&amp;1 1>/dev/null" ${user} | tee -a "$logfile" >&amp;2
}

d_stop() {
    session=`getsession "$config"`
    if ! [ -s ${session}/rtorrent.lock ] ; then
        return
    fi
    pid=`cat ${session}/rtorrent.lock | awk -F: '{print($2)}' | sed "s/[^0-9]//g"`
    if ps -A | grep -sq ${pid}.*rtorrent ; then # make sure the pid doesn't belong to another process
        kill -s INT ${pid}
    fi
}

getsession() {
    session=`cat "$1" | grep "^[[:space:]]*session[[:space:]]*=" | sed "s/^[[:space:]]*session[[:space:]]*=[[:space:]]*//" `
    echo $session
}

checkcnfg

case "$1" in
  start)
    echo -n "Starting $DESC: $NAME"
    d_start
    echo "."
    ;;
  stop)
    echo -n "Stopping $DESC: $NAME"
    d_stop
    echo "."
    ;;
  restart|force-reload)
    echo -n "Restarting $DESC: $NAME"
    d_stop
    sleep 1
    d_start
    echo "."
    ;;
  *)
    echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&amp;2
    exit 1
    ;;
esac

exit 0

Maintenant, on rend ce script exécutable : chmod +x /etc/init.d/rtorrent

Et on l'ajoute aux scripts de démarrage : update-rc.d rtorrent defaults

Et voilà, on peut démarrer rtorrent : /etc/init.d/rtorrent start

Accéder à rtorrent à distance

C'est bien beau tout ça, mais comment peut-on gérer les torrent? Voici deux solutions.

En console, tapez la commande suivante : stty stop undef; stty start undef; screen -r rtorrent. Pour quitter la console, tapez ctrl+a puis d. Il peut être judicieux d'utiliser un alias au lieu de taper à chaque fois cette longue commande. Par exemple, faisons en sorte que lorsque l'on tape torrent, on accède à rtorrent. Tapez alors une seule fois cette commande, pour ajouter un alias :

echo "alias torrent='stty stop undef; stty start undef; screen -r rtorrent'" >> ~/.bashrc

Une autre possibilité est d'utiliser ntorrent, qui va permettre de gérer rtorrent à partir d'un autre ordinateur (par exemple votre ordinateur de bureau).

Avant toute chose, assurez-vous d'avoir cette ligne dans le fichier ~/.rtorrent.rc :

scgi_port = localhost:5000

Sinon, ajoutez-là et redémarrez rtorrent /etc/init.d/rtorrent restart

Téléchargez l'archive de ntorrent, décompressez-là, et lancez ntorrent en cliquant sur ntorrent.sh (à rendre éxécutable avant). Vous pourrez vouloir créer un lanceur par la suite.

Vous voilà devant une fenêtre de ce type :

Choisissez dans le menu déroulant SSH (et non LOCAL). Dans le champ adresse, précisez le nom de domaine de votre serveur. Précisez le port ssh. Le port de socket est le port précisé dans le fichier de configuration de rtorrent ci-dessus. Vos identifiants sont ceux de l'utilisateur ayant lancé rtorrent. Cochez connexion au démarrage pour les prochaines fois, et cliquez sur Enregistrer, puis sur connecter. Et vous voilà devant votre interface. Vous pouvez ajouter des torrents, des liens magnets…

Ajout de torrents

Pour ajouter des torrents, je synchronise un dossier sur mon ordinateur, qui contient tous les .torrents, avec le dossier ~/Telechargements/torrents du serveur.

Ils sont automatiquement ajoutés par rtorrent. Cela se fait facilement avec rsync. Vous avez tout un tas d'autres solutions imaginables à la place.

Envoi de mail à la fin d'un téléchargement.

Tout d'abord, il faut que exim ou postfix soit configuré pour envoyer des mails. Par simplicité, j'ai ajouté cet alias dans /etc/aliases

pi: moi@adressemail.com

Ainsi, lorsqu'un mail est envoyé à l'utilisateur pi, il est transmis sur ma boite mail habituelle. N'oubliez pas toutefois d'exécuter ensuite la commande newaliases pour que cette opération soit prise en comple.

Pour l'envoi de mail par rtorrent lorsqu'il a fini un téléchargement, ajoutez cette ligne dans ~/.rtorrent.rc :

system.method.set_key = event.download.finished,notify_me,"execute=~/rtorrent_mail.sh,$d.get_name="

Créez le script ~/rtorrent_mail.sh

#!/bin/sh
echo "$(date) : $1 - Download completed." | mail -s "[rtorrent] - Download completed : $1" pi

Rendez-le exécutable : chmod +x rtorrent_mail.sh

Et voilà le résultat :

Surveillance

Logwatch

Il vous permettra de recevoir des mails quotidiens sur le status de votre serveur. Il se configure par le fichier /usr/share/logwatch/default.conf/logwatch.conf

Webalizer

webalizer est un outil pour obtenir des statistiques sur votre site. Il suffit de l'installer avec apt-get, puis d'ajouter ces lignes dans le fichier de configuration de nginx, afin d'accéder aux statistiques à la page nom_du_serveur/Divers/stats/index.html.

# Pour Webalizer
location /Divers/stats {
    alias /var/www/webalizer;
}

Vous pouvez surveiller plusieurs domaines. Pour cela, copier le fichier de configuration de webalizer par défaut, 1 fichier par nom de domaine à surveiller :

cp /etc/webalizer/webalizer.conf.sample /etc/webalizer/domaine1.conf
cp /etc/webalizer/webalizer.conf.sample /etc/webalizer/domaine2.conf
cp /etc/webalizer/webalizer.conf.sample /etc/webalizer/domaine3.conf

Créez ensuite 3 dossiers pour accueillir les pages générées par webalizer, et donnez l'accès à ces dossiers à nginx :

mkdir -p /var/www/webalizer-domaine1
mkdir -p /var/www/webalizer-domaine2
mkdir -p /var/www/webalizer-domaine3
chown -R www-data:www-data /var/www/webalizer-domaine*

Adaptez ces nouveaux fichiers de configuration, en particulier changez les variables

Awstats

Awstats permet lui aussi d'obtenir des statistiques sur les visites de votre site. Voici un exemple pour faire fonctionner awstats avec nginx.

Tout d'abord copiez et éditer le fichier de configuration de awstats selon vos besoin :

cp /etc/awstats/awstats.conf /etc/awstats/awstats.votredomaine.net.conf

Ensuite, créez un fichier à l'emplacement suivant /usr/local/bin/awstats_update. Remplissez-le ainsi :

#!/bin/sh
/usr/share/awstats/tools/awstats_buildstaticpages.pl -update -config=votredomaine.net -dir=/repertoire/de/sortie -awstatsprog=/usr/lib/cgi-bin/awstats.pl > /dev/null

Rendez-le exécutable avec la commande chmod +x /usr/local/bin/awstats_update

Assurez-vous que ce script soit lancé pour mettre à jour les statistiques à chaque fois que les logs de nginx tournent, en éditant le fichier /etc/logrotate.d/nginx et en ajoutant juste après la ligne prerotate

prerotate
    /usr/local/bin/awstats_update 2>&amp;1
            if [ -d /etc/logrotate.d/httpd-prerotate ]; then \
                    run-parts /etc/logrotate.d/httpd-prerotate; \
            fi; \
endscript

Maintenant, il ne reste plus qu'à configurer nginx en éditant /etc/nginx/nginx.conf

location /Divers/statistiques {
    alias /repertoire/de/sortie/;
    index awstats.votredomaine.net.html;
    }

    location /awstats-icon/ {
            alias /usr/share/awstats/icon/;
    }

Mais aussi…

Monit, munin,

Recevoir un mail lors d'une connexion ssh

Créez le script suivant à enregistrer sous /etc/ssh/sshrc :

#!/bin/sh
# source: http://blog.uggy.org/post/2009/06/05/...
DATE=`date "+%d.%m.%Y--%Hh%Mm"`
IP=`echo $SSH_CONNECTION | awk '{print $1}'`
REVERSE=`dig -x $IP +short`
echo "Connexion de $USER sur $HOSTNAME
IP: $IP
ReverseDNS: $REVERSE
Date: $DATE

" | mail -s "Connexion de $USER sur $HOSTNAME" moi@laposte.net

Liens utiles.