Serveur

De Centre de Ressources Numériques - Labomedia
Aller à : navigation, rechercher

Pour différentes raisons, il est intéressant de pouvoir installer et administrer son propre serveur et ses propres services internet (mail, partage de fichier, outils de communication et de collaboration) afin d'en garder la maîtrise, les raisons :

  • Garder ses données "à la maison" ou les confier à un tiers de confiance plutôt qu'aux supermarchés américains qui en font commerce (les chères GAFAM)
  • Disposer de services internet autonomes dont on garde la maitrise, ces services étant, pour ceux que l'on va aborder ici, FLOSS
  • Assurer une forme de "souveraineté technologique"
  • Apprendre comment fonctionnent ces outils et systèmes informatiques afin de mieux comprendre leurs tenants et aboutissants

A ce titre, le projet de La brique Internet est tout à fait intéressant pour installer facilement un ensemble d'outils et disposer d'un accès à Internet neutre en s'acoquinant avec un fournisseur d'accès idéalement issu de la fédération FFDN

Installation d'un serveur sous Debian

Voir la page dédiée à L'Installation d'un serveur web sous Debian GNU/Linux : Installation de base, Utilitaires et paquets utiles, SSH, FTP avec VSFTPD, Firewall avec IPTables ...

note : pour booter sur une clef USB sur les serveurs DELL que l'on a récup, il faut indiquer dans le BIOS : "émulation de disque dur" pour la clef et au menu de choix du boot, choisir le disque dur, l'option clef USB apparait alors (sinon missing image bin iso ...)

Installer et configurer nginx

apt-get install nginx

Créer des virtual hosts ou Server Blocks

Installer Flask sous apache

Flask est un module web en python http://flask.pocoo.org/ 

su
apt-get install python-pip python-virtualenv
virtualenv venv
source venv/bin/activate
env
pip install flask
find venv/
flask run
ls
mkdir flaskprojet
cd flaskprojet/
nano hello.py
python hello.py 
nano /etc/apache2/sites-available/artlabo.org 
service apache2 reload
a2enmod proxy
a2enmod proxy_http
service apache2 reload
python hello.py 
chown artlabo: flaskprojet/
chown -R artlabo: flaskprojet/
chown -R artlabo: venv/

Le serveur tourne sur le port 5000, un petit proxy dans apache pour rediriger ce port 5000 vers un répertoire, cela donne pour /etc/apache2/sites-available/artlabo.org : 

<VirtualHost *:80>

        ServerAdmin dedibox@labomedia.net
        ServerName artlabo.org

        DocumentRoot "/home/artlabo/www"

        <Directory /home/artlabo/www>
                Options -Indexes FollowSymLinks MultiViews
                AllowOverride All
        </Directory>

        #ErrorLog /var/log/apache2/sites/artlabo.org.error.log
        LogLevel crit
        #CustomLog /var/log/apache2/sites/artlabo.org.access.log combined

        ProxyPass /flask http://localhost:5000
        ProxyPassReverse /flask http://localhost:5000


</VirtualHost>

<VirtualHost *:80>
        ServerName www.artlabo.org
        Redirect permanent / http://artlabo.org/
</VirtualHost>

Si on lance une appli flask : 

source ~/venv/bin/activate
pip install XXX (éventuellement)
python hello.py

Test en mieux sur le nouveau serveur : 

export FLASK_APP=hello.py
flask run
* Running on http://127.0.0.1:5000/

elle est désormais consultable sur http://libviz.artlabo.org (anciennement http://artlabo.org/flask)

Installer un certificat via letsencrypt pour disposer du https

Jusqu'à récemment, il fallait donner des $$$ à des organismes de certification pour pouvoir disposer d'un certificat "valide" qui permet de proposer une connexion au serveur via https sans que les internautes aient besoin de valider un certificat indiqué comme n'étant pas de confiance par le navigateur.

Grâce à l'initiative "letsencrypt", c'est désormais possible de faire cela gratuitement

Pour les parano

Il est possible d'utiliser let's encrypt même sans lui confier votre compte root. Dans cet exemple, on va supposer que vous avez le droit d'écrire dans le dossier /srv/www et que ce dossier pointe vers la racine du serveur pour lequel vous souhaitez générer un certificat.

D'abord, créer un virtualenv avec ` 

virtual ~/.le_env

activer l'environnement avec 

source ~/.le_env/bin/activate

et installer le module avec 

pip install letsencrypt

Si tout ce passe bien, vous pourrez lancer l'utilitaire en tapant 

~/.le_env/bin/letsencrypt

même si le virtualenv n'est pas activé.

Ensuite, il faut préparer la configuration pour let's encrypt. Par défaut, il écrit ses fichiers de log dans /var/logs et ses fichiers de travail dans /etc/letsencrypt. Cela risque de poser des soucis si on ne veux pas travailler en root. Le but du premier bloc de configuration, plutôt générique, est de régler ce problème. 

 config-dir = /home/user/.config/letsencrypt
 work-dir = /home/user/.local/share/letsencrypt
 logs-dir = /home/user/.local/share/letsencrypt/logs

 rsa-key-size = 4096
 text = True
 agree-tos = True

On remarqueras qu'il n'y a pas de guillement. De plus, les valeurs sont utilisé tel quel, un symbole ~ ne sera pas remplacé par le dossier utilisateur. Si les valeurs ne commencent pas par un symbole slash, elle seront prise comme un dossier dans le répertoire de travail. L'option text permet de ne pas avoir besoin de l'utilitaire "dialog" et agree-tos permet d'avoir une question en moins.

Ensuite viennent les informations en rapport avec le certificat que vous allez demander. 

email = user@exemple.com

authenticator = webroot
webroot-path = /srv/www
domains = exemple.com, www.exemple.com

authenticator indique que l'on va réutiliser un serveur http existant, webroot-path dans quel dossier le serveur prend ses document et domains indique l'ensemble des domaines pour lesquels le domaine sera valide. Enregistrez les deux bloc dans le même fichier, "exemple.com.ini" par exemple.

Finalement, il suffit de lancer let's encrypt. ~/.le_env/bin/letsencrypt certonly -c ~/exemple.com.ini "certonly" permet de préciser qu'on ne veux que récupérer les certificats, on s'occupera nous même de les installer à la bonne place. Vous pouvez aussi enregistrer la configuration sous "~/.config/letsencrypt/cli.ini" et ne pas préciser l'option -c.

Voilà, vous avez vos certificats dans le dossier "~/.config/letsencrypt/live". Vous n'avez plus qu'a configurer vos services pour les utiliser.

Installer Yunohost pour déployer rapidement un ensemble d'applications web

Yunohost utilise plutot nginx, du coup en installant la Debian, il ne faut pas cocher "Serveur web" sinon Apache va manger le port 80

Installez git 

sudo apt-get install git

Clonez le dépôt du script d’installation de YunoHost 

git clone https://github.com/YunoHost/install_script /tmp/install_script

L’utilisateur root doit avoir un mot de passe, si ce n’est pas le cas, créez en un (sinon le script d’installation échoue): 

sudo passwd root

Lancez le script d’installation 

cd /tmp/install_script && sudo ./install_yunohostv2

Il faut ensuite se connecter au serveur via un navigateur web, une fois l'installation terminée, l'écran du serveur (s'il existe) indique l'adresse IP sur laquelle il faut se connecter

  • Il faudra définir un mot de passe administrateur
  • Et un nom de domaine, soit on dispose d'un domaine ou d'un sous-domaine que l'on fait pointer sur le serveur, soit on utilise un dyndns proposé par yunohost de type labomedia.nohost.me
  • Une fois tout ça réaliser, installer des applications, ça donne :
Interface listant les applis dans YuNoHost

Installer un serveur cache pour les paquets debian et ubuntu

Avec Cacher-ng installé sur un serveur local, tous les ordinateurs de ce réseau local configurés pour l'interroger vont télécharger les paquets une fois sur le serveur de cache, ils seront ensuite disponibles pour les autres ordinateurs locaux

Install & config

sudo apt-get install apt-cacher-ng

Les paquets sont stockés dans 

ls -al /var/cache/apt-cacher-ng/

Le serveur proxy tourne sur le port 3142 par défaut, possible d'accéder à des pages web d'administration, mot de passe à configurer là 

sudo nano /etc/apt-cacher-ng/security.conf 
http://localhost:3142

Configurer un client pour utiliser le cacher-ng

Créer le fichier suivant 

sudo nano /etc/apt/apt.conf.d/00proxy

et y mettre 

Acquire::http::Proxy "http://dev.lobotomie.org:3142";

remplacer dev.lobotomie.org par l'adresse du serveur 

sudo apt-get update

Virtualiser le serveur

aptitude install qemu-kvm libvirt-bin virtinst

In order to be able to manage virtual machines as regular user you should put this user into the kvm and libvirt groups: 

# adduser <youruser> kvm
# adduser <youruser> libvirt

You should then be able to list your domains: 

# virsh list --all

libvirt defaults to qemu:///session for non-root. So from <youruser> you'll need to do: 

virsh --connect qemu:///system list --all

Config réseau

Installer 

apt-get install bridge-utils vde2

Configurer le bridge 

 
# Interface eth0 is unchanged
auto eth0
iface eth0 inet dhcp

# Virtual interface 
auto tap0
iface tap0 inet manual
  vde2-switch -t tap0

# Bridge for containers
auto br0
iface br0 inet static
  bridge-ports tap0
  address 192.168.1.1
  netmask 255.255.255.0

Installation du Linux sur la machine virtuelle

root@dev:/srv/isos# mkdir /srv/kvm
root@dev:/srv/isos# virsh pool-create-as srv-kvm dir --target /srv/kvm
Pool srv-kvm created

Créer et installer la machine 

virt-install --connect qemu:///system --virt-type kvm --name virtserver1 --ram 1024 --disk /srv/kvm/virtserver1.qcow,format=qcow2,size=10 5 --cdrom /srv/isos/debian-8.3.0-amd64-netinst.iso --network bridge=br0 --vnc --os-type linux --os-variant debianjessie

Sécuriser le serveur

Quelques howTo / tips :

Restreindre l'accès au serveur ssh en ne permettant que le log avec clef

#Privilege Separation is turned on for security
UsePrivilegeSeparation yes

AllowUsers labomedia # mettre les users authorisés
PasswordAuthentication no # pas d'authentification par password

# Authentication:
LoginGraceTime 120
#PermitRootLogin without-password
StrictModes yes

RSAAuthentication yes
PubkeyAuthentication yes # permet le log par clef
AuthorizedKeysFile      %h/.ssh/authorized_keys

Activer des notifications SMS via free.fr lorsque quelqu'un se connecte en ssh sur le serveur

Possible d'activer chez Free les notifications par SMS sur son mobile et d'envoyer un SMS via une requête web sur le serveur de free :

  • Créer un script "smsfree.sh" sur le serveur :
#!/bin/sh
if [ "$PAM_TYPE" != "open_session" ]; then
#       echo "pas open session"
        exit 0
fi

NEWLINE_CHAR="%0D%0A" # Valeurs possibles : %0A, %0D et %0D%0A
SMSAPI_BASEURL="https://smsapi.free-mobile.fr"
SMSAPI_SEND_ACTION="sendmsg"
USER_LOGIN="VotreID"
API_KEY="LaClefDonnéeParFree"
MESSAGE_HEADER="Connexion SSH${NEWLINE_CHAR}--${NEWLINE_CHAR}"
MESSAGE_FOOTER="${NEWLINE_CHAR}--${NEWLINE_CHAR}Serveur: `hostname -s`"
MESSAGE_TO_SEND="date: `date`${NEWLINE_CHAR}login: $PAM_USER${NEWLINE_CHAR}from: $PAM_RHOST"
FINAL_MESSAGE_TO_SEND="$MESSAGE_HEADER$MESSAGE_TO_SEND$MESSAGE_FOOTER"
HTTP_STATUS_CODE=$(curl --get "${SMSAPI_BASEURL}/${SMSAPI_SEND_ACTION}" --data "user=${USER_LOGIN}" --data "pass=${API_KEY}" --data "msg=${FINAL_MESSAGE_TO_SEND}")

if [ "$HTTP_STATUS_CODE" -eq 200 ]; then
#    echo "API responded with 200: exiting with 0"
    exit 0
else
    echo "Error: API responded with $HTTP_STATUS_CODE"
    exit 1
fi
  • Le placer dans /usr/bin par exemple, puis
chmod +x smsfree.sh
  • Modifier le fichier /etc/pam.d/ssh en ajoutant en dernière ligne :
session    optional     pam_exec.so    /usr/bin/smsfree.sh

Test de l'api 

https://smsapi.free-mobile.fr/sendmsg?user=XXXXXXXX&pass=XXXXXXXXXXXXXX&msg=Hello%20World%20!
Récupérée de « https://wiki.labomedia.org/index.php?title=Serveur&oldid=33769 »