Le site personnel de Said Abdouni

VPS avec Linux

Mes premiers pas avec un serveur privé virtuel sous Debian

Sécuriser le VPS

Se connecter :

ssh root@ip_de_votre_vps

Mette-à-jour le systeme :

apt update && apt upgrade

Changer le mot de passe de l’utilisateur root :

passwd root

Créer un nouveau utilisateur :

adduser NomUtilisateur

Désactiver l’accès au serveur via l’utilisateur root :

vi /etc/ssh/sshd_config

Dans la ligne PermitRootLogin remplacer yes par no.

Redémarrer le service SSH :

/etc/init.d/ssh restart

Pour les taches nécessitants les droits root utiliser :

su root

Installer Fail2ban :

apt install fail2ban

SSH

1. Modifier le port d’écoute du SSH

=> Soit avec la méthode "manuelle" :

vi /etc/ssh/sshd_config

Remplacer Port 22 par Port NouveauPort.

=> Soit en lançant :

sudo sed -i 's/Port 22/Port 23514/' /etc/ssh/sshd_config

Redémarrer le service SSH :

/etc/init.d/ssh restart

Maintenent pour se connecter il faut entrer :

ssh root@ip_de_votre_vps -p NouveauPort

2. Authentification par clé SSH

Générer des clés SSH :
ssh-keygen

La commande ssh-keyen va génerer:

  • Une clé publique : elle sera exportée sur le serveur sur lequel on souhaite se connecter.
  • Une clé privée : Pour prouver son identité au serveur.
  • Une passphrase : Pour sécuriser la clé privée.
Deux fichiers vont être crées dans le répertoire ~/.ssh/ :
  • id_rsa : contient la clé privée.
  • id_rsa.pub : contient la clé publique.

Copier de la clé publique sur votre serveur distant :
ssh-copy-id -i ~/.ssh/id_rsa.pub -p 12065 user@host

(-p si le port SSH a été modifier)

La commande ssh-copy-id va ajouter la clé publique dans le fichier authorized_keys du serveur distant (ce fichier contient toutes les clés publiques).

Dorénavant, pour ce connecter, il suffit de taper :

ssh -p 12065 user@host

Simplifier encore plus la connexion :

Avec le fichier ~/.ssh/config

host monvps
  User moi
  hostname monsite.com
  Port 23651
  IdentityFile ~/.ssh/id_rsa

Pour se connecter, il suffit d’entrer :

ssh monvps  

IPTABLES et IPSET

Bloquer/débloquer une IP avec iptables

Lister les règles du firewall iptables :

iptables -L

Bloquer une IP :

iptables -I INPUT -s 212.237.41.38 -j DROP

Débloquer une IP :

iptables -D INPUT -s 212.237.41.38 -j DROP

Créer un liste d’IPs avec ipset

Créer la liste :

ipset create blacklist hash:ip

Ajouter des ips (à bloquer par exemple) :

ipset add blacklist 212.237.41.38
ipset add blacklist 1.22.26.83

Pour afficher la liste :

iplist list

Pour ajouter cette -black- liste au firewall :

iptables -I INPUT -m set --match-set blacklist src -j DROP

Installer et configurer Nginx

Installation :

apt install nginx

Les fichiers de configuration :

  • Le fichier de configuration de Nginx est : /etc/nginx/nginx.conf
  • Les liens symboliques des sites actifs se trouve dans le répertoire : /etc/nginx/sites-enabled
  • Les fichiers de configuration des sites se trouve dans /etc/nginx/sites-available

Création d’un simple site statique :

Créer un fichier de configuration dans etc/nginx/sites-available :

vi /etc/nginx/sites-available/mon_site

Editer ce fichier :

server {
        listen 80;

        server_name domaine_ou_ip;
        root /var/www/mon_site;
        index index.html index.php;

        location / {
        try_files $uri $uri/ =404;
       }
}
  • listen : le port d’écoute.
  • server_name : le nom de domaine ou l’IP.
  • root : le répertoire où se trouvent vos fichiers.
  • index : l’ordre de de recherche de fichiers.
  • location : actions à effectuer lorsqu’un chemain est appelé.

Activer le site en créant un lien symbolique vers ce fichier dans le répertoire /etc/nginx/sites-available :

ln -s /etc/nginx/sites-available/mon_site  /etc/nginx/sites-enabled

Supprimer la configuration par défaut :

sh sudo rm /etc/nginx/sites-enabled/default

Recharger la configuration de Nginx :

nginx -s reload

Cas particulier : /var/www/mon_site/public_html

Dans le cas où les fichiers ne se trouvent pas dans le répertoire racine du site, mais dans un sous-répertoire et on veut quant même y accéder par le nom du répertoire racine, on utilise un alias.
server {
        root /var/www/mon_site/;
        location / {
                 return 410;  # Default root of site won't exist.
        }

        location /mon_site/ {
                 alias /var/www/mon_site/public_html/;
        }
}

Par exemple, à la demande de /mon_site/contact.html, c’est le fichier /var/www/mon_site/public_html/contact.html qui sera envoyé.

Mais il est mieux d’utiliser la directive root, en mettant les fichiers directement dans /var/www/mon_site (ou en créant un lien symbolique?).

Petite astuce pour faire ça :
Séparer le Chemin complet : /var/www/mon_site en :
Dernier chemin : /mon_site et Premier chemin : /var/www , ça donnera :
donc :

location  {
    root ;
}
location /mon_site/ {
    root /var/www;
}

Hébérger un autre site (domaine) sur le même serveur

Créer le sous-répertoire où sera hébergé le site :

mkdir /srv/www/mon_autre_site.com

Créer un nouveau server block (sur Nginx ou virtual host sur Apache) :

sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/mon_autre_site.com

Éditer le fichier créé pour ressembler à ça :

server {
        listen 80;
        listen [::]:80;

        server_name mon_autre_site.com;

        root /srv/www/mon_autre_site.com;
        index index.html;

        location / {
                try_files $uri $uri/ =404;
        }
}

Activer le site :

ln -s /etc/nginx/sites-available/mon_autre_site.com  /etc/nginx/sites-enabled

Manipulation des fichiers

SCP

Depuis la machine locale :

Envoyer un fichier vers le serveur

scp -P 8452  /chemain/du/fichier.txt yourUsername@yourRemoteserver:/destination/

Télécharger un fichier depuis le serveur

scp -P 8452 yourUsername@yourRemoteserver:/chemain/du/fichier.txt  /destination/
-P pour désigner le port du ssh (s’il a été modifié).

Si vous avez configuré le SSH pour qu’il puisse se connecter automatiquement (via les clés d’authentification et le fichier ~/.ssh/config …), il suffit simplement de taper :

scp  monvps:/chemain/du/fichier.txt  /destination/

Pour télécharger ou envoyer un dossier entier, il suffit d’ajouter -r pour recursive.

scp -r  monvps:/chemain/du/dossier  /destination/

DU

du (Disk Usage) permet d’obtenir la taille d’un fichier ou d’un répertoire.

du -sh nom_fichier_ou_repertoire
  • -s : summmarise
  • -h : human-readable

RSYNC

Pour sauvegarder (synchroniser) un dossier vers un serveur distant :

rsync -e "ssh" -rtuz --del dossier/a/sauver/ monvps:/chemin/du/backup/
  • -e "ssh" : Utiliser un transfert ssh.
  • -r : Récursif.
  • -t : Préserve la date de modification des fichiers.
  • -z : Compresse les données lors du transfert.
  • –del : Supprime les documents ayant disparus dans le dossier source.
  • -a : récursif + conserve permissions et propriétaire (si root).
  • -u : ne pas changer les fichiers plus récents dans la destination.
  • -v : verbeux (affiche les fichiers et dossiers affectés).

Et pour un dossier du serveur vers un dossier local :

rsync -e "ssh" -rtuz --del monvps:/chemin/du/dossier/ /chemin/du/backup/
Dans tout les cas toujours mettre un / à la fin.

HTTPS avec Let’s Encrypt

Installer Certbot (pour le couple Debien Stretch/nginx)

Certbot est nom du client Let’s Encrypt. Premièrement il faut activer le Backport de Debian en ajoutant cette ligne dans le fichier /etc/apt/sources.list :

deb http://ftp.debian.org/debian stretch-backports main
puis lancer un apt-get update .

Maintenant on peut l’installer depuis le Backport :

sudo apt-get install python-certbot-nginx -t stretch-backports

Pour créer les certifications, la méthode la plus facile (et la plus automatisée) est de lancer cette commande :

sudo certbot --authenticator webroot --installer nginx
qui va proposer aussi de gérer les re-directions http/https.

Pour plus de détails : https://certbot.eff.org/lets-encrypt/debianstretch-nginx

Installation de Searx (testé sur Debian 9)

Searx

Installer les dépendances :

    sudo apt-get install git build-essential libxslt-dev \
    python-dev python-virtualenv python-babel \
    zlib1g-dev libffi-dev libssl-dev

Installer de Searx

    cd /usr/local
    sudo git clone https://github.com/asciimoo/searx.git
    sudo useradd searx -d /usr/local/searx
    sudo chown searx:searx -R /usr/local/searx

Installer les dépendances python dans Virtualenv

    sudo -u searx -i
    cd /usr/local/searx
    virtualenv searx-ve
    . ./searx-ve/bin/activate
    ./manage.sh update_packages

Modifier la phrase secrète du fichier settings.yml :

sed -i -e "s/ultrasecretkey/`openssl rand -hex 16`/g" searx/settings.yml

Lancer Searx :

python searx/webapp.py

Vérifier avec elinks :

elinks http://localhost:8888

Si tout fonctionne correctement, arrêter le serveur (Ctrl+C) et désactivez l’option de debug dans settings.yml :

sed -i -e "s/debug : True/debug : False/g" searx/settings.yml

Pour sortir du Virtualenv et du prompte de l’utilisateur searx il suffit de taper exit deux fois.

Uwsgi

Installer les packages :

sudo apt-get install uwsgi uwsgi-plugin-python

Créer le fichier de configuration /etc/uwsgi/apps-available/searx.ini avec ce contenu :

    [uwsgi]
    # Quel est l'utilisateur qui fera tourner le code
    uid = searx
    gid = searx

    # Nombre de workers (habituellement, on met le nombre de processeurs de la machine)
    workers = 1 #parce que je n'ai qu'un seul core

    # Quels sont les droits sur le socket créé
    chmod-socket = 666

    # Plugin à utiliser et configuration de l'interpréteur
    single-interpreter = true
    master = true
    plugin = python

    # Module à importer
    module = searx.webapp

    # Chemin du virtualenv
    virtualenv = /usr/local/searx/searx-ve/

Activer l’application de uwsgi et redémarrer le :

    cd /etc/uwsgi/apps-enabled
    sudo ln -s ../apps-available/searx.ini
    sudo /etc/init.d/uwsgi restart

Nginx

Cette Configuration est pour les hébergements en sous-répertoire (/searx):

Dans le fichier de configuration du site (exemple : /etc/nginx/sites-available/monsite.com), ajoutez ces lignes (à l’intérieur d’un bloc /server{ ) :

    location = /searx { rewrite ^ /searx/; }
    location /searx {
        try_files $uri @searx;
    }
    location @searx {
        uwsgi_param SCRIPT_NAME /searx;
        include uwsgi_params;
        uwsgi_modifier1 30;
        uwsgi_pass unix:/run/uwsgi/app/searx/socket;
    }

Éditer l’option base_url dans settings.yml :

    base_url : http://monsite.com/searx/

Redémarrer nginx et uwsgi :

sudo nginx -s reload
sudo service uwsgi restart

Mettre à jours

cd /usr/local/searx
sudo -u searx -i
. ./searx-ve/bin/activate
git stash
git pull origin master
git stash apply
./manage.sh update_packages
sudo service uwsgi restart

Références/Crédits:

https://framacloud.org/fr/cultiver-son-jardin/searx.html
https://asciimoo.github.io/searx/dev/install/installation.html

Installer et tester Rocket

Installer Rust

Ceci va installer la dernière version stable de Rust et qui va aussi ajouter automatiquement Rust à votre PATH après votre prochaine connexion :

curl https://sh.rustup.rs -sSf | sh

Si vous voulez commencer à utiliser Rust immédiatement (sans redémarrer) exécutez la commande suivante :

source $HOME/.cargo/env

Verifier le tout avec :

rustc --version

Rust a besoin d’un Linker (celui qui vient avec le compilateur C), donc sous Debien :

sudo apt install build-essential

Installer Rocket

Pour bien fonctionner, Rocket a besoin de la derniere Nightly version de Rust :

rustup default nightly
Qui va rendre Rust Nightly la chaîne d’outils par défaut.

Ou si vous préférez utiliser la version nocturne uniquement pour votre projet Rocket; exécutez cette commande dans le repertoire du projet:

rustup override set nightly

Hello, World!

Créer un nouveau projet :

cargo new hello-world --bin
cd hello-world

Ajouter les dépendances Rocket dans le fichier Cargo.toml (Chercher la dernière version : https://crates.io/crates/rocket)
[dependencies]
rocket = "0.3.11"
rocket_codegen = "0.3.11"

Modifier src/main.rs :

#![feature(plugin)]
#![plugin(rocket_codegen)]

extern crate rocket;

#[get("/")]
fn index() -> &'static str {
    "Hello, world!"
}

fn main() {
    rocket::ignite().mount("/", routes![index]).launch();
}

Compiler et lancer le programme avec :

cargo run

Visiter http://localhost:8000 pour voir l’application en action.

Configurer Nginx pour rediriger les requetes vers Rocket

Dans le fichier de configuration Nginx inserer :
   server {
    listen   ...;

    location / {
        ...;
    }
    
    location /rocket { 
     proxy_pass http://127.0.0.1:8000;
    }
   ...
}

proxy_pass va indiquer a Nginx de rediriger les requêtes vers /rocket vers le serveur qui écoute sur http://127.0.0.1:8000 .

Le problème ici c’est que Rocket sert les requêtes de / et non de /rocket. Mais, nginx envoie des requêtes à /rocket (qui va donner des erreurs 404). Pour résoudre ce problème, nous devons réécrire l’URL avec rewrite

 server {
  listen   ...;

  location / {
      ...;
  }

  location /rocket {
   rewrite ^/blog(.*) /$1 break; 
   proxy_pass http://127.0.0.1:8000;
  }
 ...
}

Recharger Nginx :

sudo nginx -s reload

et tester dans le navigateur avec http://monsite.com/rocket