TOC

Comment utiliser Firejail pour configurer une installation WordPress dans un environnement jailed

introduction

Lorsque vous utilisez un serveur Web accessible au public, il peut s’avérer difficile de trouver un équilibre entre rendre votre contenu accessible et établir une configuration sécurisée. Il y a beaucoup de domaines différents qui devraient être soumis à un examen minutieux. L’un d’entre eux est l’isolation et la visibilité des processus.

Un projet appelé * firejail * cherche à apporter son aide dans ce domaine en fournissant un mécanisme de conteneurisation de sécurité léger qui utilise l’espacement des noms du noyau pour appliquer des stratégies de séparation. Cela rend les environnements de chroot extrêmement légers.

Dans ce guide, nous allons vous montrer comment utiliser FireBail afin d’isoler les processus dans leur propre environnement chroot. Pour illustrer cela avec un exemple réel, nous allons configurer deux environnements chroot, l’un avec un serveur Web Nginx servant WordPress, et l’autre avec une base de données MySQL qui gérera les données du site. Ces deux instances auront leurs propres systèmes de fichiers et installations et communiqueront via un périphérique réseau ponté.

Prérequis et objectifs

Dans ce guide, nous utiliserons un serveur Ubuntu 14.04 64 bits comme installation de base. Cela nous permettra d’utiliser des paquetages + firejail + pré-construits et de créer facilement des environnements chroot.

Pour obtenir une bonne base pour l’installation, assurez-vous d’avoir terminé la configuration du serveur initial pour https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-14-04 pour Ubuntu 14.04] ici.

Nous allons configurer deux environnements chroot sur notre système hôte. Ce seront en fait des environnements stables Debian, une sélection choisie parce que les environnements Debian sont mieux testés avec l’outil + debootstrap + que nous allons utiliser.

Notre machine hôte sera configurée avec une adresse IP publique et servira de passerelle pour le réseau ponté que nous allons configurer pour communiquer avec les jails. Les environnements emprisonnés seront uniquement configurés pour utiliser l’interface de pont et ne pourront accéder à Internet plus large que par le biais de règles NAT sur l’hôte.

Les trois environnements que nous allons configurer auront les propriétés suivantes:

Environment Public IP Address Bridge IP Address

Host

10.10.20.1

Web Server

(none)

10.10.20.10

Database Server

(none)

10.10.20.20

Notez que la valeur en rouge ci-dessus doit être remplacée par l’adresse IP publique de votre serveur hôte. Les adresses IP de pont, cependant, doivent être utilisées telles quelles, car nous allons configurer cette interface et ces adresses tout au long du guide.

Tout au long de ce guide, toutes les commandes seront exécutées en tant qu’utilisateur * root *.

Télécharger et configurer les composants de la machine hôte

Pour commencer, nous devons télécharger certains des outils que nous utiliserons sur notre serveur.

Premièrement, nous devons télécharger le paquetage + .deb + pour le programme firejail. Recherchez le dernier nom de package + .deb + sur la page download du site et remplacez la partie du nom de fichier de l’URL ci-dessous par cette version. L’URL ci-dessous est le lien de téléchargement direct vers le package:

cd ~
wget http://downloads.sourceforge.net/project/firejail/firejail/

Une fois le fichier téléchargé, installez-le en utilisant + dpkg +:

dpkg -i firejail*

Une fois le programme firejail installé, nous devons obtenir des paquets supplémentaires à partir des dépôts par défaut d’Ubuntu. Plus précisément, nous avons besoin de l’outil + debootstrap + qui nous aidera à créer nos systèmes de fichiers chroot, et + bridge-utils + qui nous permettra de créer l’interface de pont réseau que nos jails utiliseront pour communiquer:

apt-get update
apt-get install debootstrap bridge-utils

Configurer l’interface de pont

Avant de commencer avec les jails réels, nous allons configurer l’interface réseau pontée.

Nous pouvons créer la nouvelle interface avec la commande + brctl + qui faisait partie du paquetage + bridge-utils +. Notre pont s’appellera + br0 +:

brctl addbr br0

Ensuite, nous devons mettre l’interface en place. En plus d’activer l’interface, nous assignons une plage de réseau CIDR. Notre serveur hôte aura l’adresse * 10.10.20.1 * sur cette interface:

ifconfig br0 10.10.20.1/24

Une fois l’interface opérationnelle, nous devons dire au noyau d’autoriser le transfert IP, ou routage, entre nos interfaces. Nous pouvons activer cette fonctionnalité pour cette session en tapant:

echo "1" > /proc/sys/net/ipv4/ip_forward

Nous devons maintenant configurer une règle + iptables + qui permettra au trafic destiné au port 80 de notre serveur hôte d’être routé vers le serveur Web que nous installerons dans l’une de nos jails. Notre serveur web aura l’adresse IP de * 10.10.20.10 * sur notre interface de pont:

iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to 10.10.20.10:80

Cela ajoute une règle au bas de la chaîne "PREROUTING" dans la table "nat". Lorsqu’un paquet TCP destiné au port 80 est atteint, le trafic est redirigé vers le port 80 à la suite de la traduction de l’adresse + 10.10.20.10 + `.

Nous devons également mettre en place une série de règles permettant à notre base de données et à notre serveur Web d’interroger Internet afin qu’ils puissent mettre à jour les composants à partir de WordPress. Nous allons commencer par ajouter une règle de masquage qui permettra à notre interface + br0 + de router les communications avec succès via notre ordinateur hôte:

iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

Nous pouvons ensuite verrouiller les communications entre nos interfaces en ajustant les règles de la chaîne FORWARD.

Premièrement, nous devrions refléter notre précédente règle NAT établie afin que nous puissions explicitement autoriser le trafic du port 80 dans notre réseau + br0 +:

iptables -A FORWARD -i eth0 -o br0 -p tcp -m tcp --dport 80 -j ACCEPT

Nous souhaitons également autoriser le trafic entrant lié à nos connexions établies:

iptables -A FORWARD -i eth0 -o br0 -m state --state RELATED,ESTABLISHED -j ACCEPT

Nous voulons autoriser le transfert de tout le trafic provenant de l’interface + br0 + afin que nos jails puissent communiquer entre eux et avec le monde extérieur:

iptables -A FORWARD -i br0 -j ACCEPT

Enfin, nous allons supprimer toutes les autres connexions de transfert afin que le transfert ne soit autorisé que pour les connexions sortantes à partir du réseau + br0 +. Les exceptions à cette politique ont déjà été établies dans les règles précédentes.

iptables -P FORWARD DROP

Maintenant, notre système hôte est configuré avec l’interface de pont qu’il utilisera pour communiquer avec les environnements jailed.

Créer la structure du répertoire Chroot

Nous sommes maintenant prêts à créer nos structures de répertoires chroot.

Comme nous l’avons dit précédemment, notre serveur Web et notre serveur de base de données fonctionneront dans des systèmes de fichiers complètement séparés. Nous allons garder ces deux systèmes de fichiers dans un répertoire appelé + / jails +. Créez ce répertoire maintenant:

mkdir /jails

Déplacez-vous dans le répertoire que vous venez de créer:

cd /jails

Maintenant, nous devons créer les structures de fichiers qui seront utilisées par nos systèmes d’exploitation emprisonnés. Pour ce faire, nous allons utiliser l’outil + debootstrap +. Cet utilitaire a été créé pour amorcer les environnements Debian dans un système de fichiers existant. Pour ce faire, il extrait les paquets des référentiels Debian et les "installe" au bon endroit.

Bien que + debootstrap + puisse être utilisé pour amorcer les environnements Ubuntu, nous choisirons plutôt des installations Debian stables. Depuis que l’outil a été créé pour fonctionner avec Debian, ces environnements sont les mieux testés pour cet outil.

Nous installerons notre environnement de base de données dans un répertoire appelé «db». Pour créer la structure de répertoires appropriée, télécharger et installer les packages nécessaires, tapez:

debootstrap --arch=amd64 stable db

Maintenant que notre système de fichiers est construit dans le répertoire + / jails / db +, nous pouvons utiliser + rsync + pour copier la structure dans un autre répertoire que notre serveur Web peut utiliser. Le nouveau répertoire s’appellera “www”. Assurez-vous de faire attention aux barres obliques (/) dans la commande qui suit. Cela copiera le contents du premier répertoire dans le second, au lieu de copier le répertoire lui-même:

rsync -azvh db/ www

Nous avons maintenant deux structures de répertoires chroot que nous pouvons utiliser avec notre programme + firejail +.

Utiliser Firejail pour configurer la base de données WordPress

Maintenant que nous avons notre structure de répertoires, nous pouvons utiliser + firejail + pour créer un environnement chroot dans notre structure de répertoires + / jails / db +.

Pour créer un environnement chroot et démarrer une session bash à l’intérieur, il suffit de spécifier l’emplacement du répertoire de la racine chroot et le nom d’hôte que nous souhaitons utiliser pour la session:

firejail --chroot=/jails/db --name=db
Parent pid 17390, child pid 17391
Interface           IP                  Mask                Status
lo                  127.0.0.1           255.0.0.0           UP
eth0                192.0.2.1           255.255.255.0       UP
eth1                10.128.1.228        255.255.0.0         UP
br0                 10.10.20.1          255.255.255.0       UP

Child process initialized
[root@db ~]$

La commande affichera le pid parent, le pid enfant et les interfaces configurées dans cette session jail (nous n’avons pas restreint ni configuré les interfaces à ce stade). Par la suite, il vous plongera dans une invite de commande dans votre environnement emprisonné.

La première chose à faire est de mettre à jour notre base de données de paquets et d’installer le serveur MySQL dans l’environnement chroot. Vous pouvez le faire en tapant:

apt-get update
apt-get install mysql-server

Pendant le processus de mise à jour, vous devriez voir que les référentiels Debian sont en cours de vérification. En effet, notre environnement chroot est une installation Debian.

Au cours du processus d’installation, vous serez invité à sélectionner et à confirmer un mot de passe pour le compte racine MySQL.

Une fois l’installation terminée, nous devrions générer la structure de répertoires de données MySQL en tapant:

mysql_install_db

Ensuite, verrouillez certaines valeurs par défaut non sécurisées avec un script inclus:

mysql_secure_installation

Le mot de passe racine MySQL que vous avez défini lors de l’installation vous sera demandé. Ensuite, il vous sera demandé si vous souhaitez changer le mot de passe. Sélectionnez «Non» si vous êtes satisfait de votre sélection. Pour le reste des invites, appuyez simplement sur ENTREE pour sélectionner les choix par défaut.

Créer la base de données WordPress et l’utilisateur

Ensuite, nous voulons configurer une base de données séparée pour WordPress. Connectez-vous au serveur MySQL en utilisant le compte racine MySQL. Entrez le mot de passe que vous avez sélectionné pour cet utilisateur à l’invite:

mysql -u root -p

Vous serez déposé dans une invite MySQL. Créez une nouvelle base de données à utiliser par WordPress:

CREATE DATABASE wordpress;

Ensuite, nous allons créer un utilisateur pour utiliser cette base de données à partir de la prison du serveur Web. Le serveur Web aura une adresse IP de * 10.10.20.10 * sur l’interface du pont. Nous devons donc associer cet utilisateur à cette adresse. Attribuez un mot de passe sécurisé à cet utilisateur. Nous donnerons ensuite à cet utilisateur la possibilité de travailler sur la base de données créée:

CREATE USER 'wordpressuser'@'10.10.20.10' IDENTIFIED BY '';
GRANT ALL PRIVILEGES ON wordpress.* TO 'wordpressuser'@'10.10.20.10';

Maintenant, il nous suffit de vider la table de privilèges et de quitter:

FLUSH PRIVILEGES;
exit

Modifier les paramètres MySQL pour se lier à l’adresse du pont

Ensuite, nous devons modifier le fichier de configuration MySQL. Ouvrez-le avec votre éditeur maintenant:

nano /etc/mysql/my.conf

Ce fichier est organisé en sections. Trouvez la section qui commence comme ceci:

[mysqld]

Vous devriez voir une directive appelée + bind-address + qui est définie sur + 127.0.0.1 + actuellement. Nous voulons démarrer notre instance MySQL en écoutant sur l’interface de pont. L’adresse de cette prison sur cette interface sera * 10.10.20.20 *, nous devons donc la modifier pour ressembler à ceci:

bind-address = 10.10.20.20

Enregistrez et fermez le fichier lorsque vous avez terminé.

Maintenant, nous pouvons arrêter l’instance MySQL en cours d’exécution et quitter cette prison:

service mysql stop
exit

Utiliser Firejail pour configurer le serveur Web WordPress

Maintenant que notre base de données est configurée, nous pouvons passer à notre prison qui sera utilisée pour le serveur Web. Utilisez firejail pour démarrer une session dans cet environnement jail maintenant:

firejail --chroot=/jail/www --name=www

La première chose à faire est de mettre à jour notre base de données de paquets locale et d’installer le serveur Web Nginx et les composants PHP. Celles-ci sont nécessaires pour traiter les requêtes dynamiques et se connecter à la base de données MySQL:

apt-get update
apt-get install nginx php5-fpm php5-mysql

Configurer PHP

Nous allons commencer par éditer le fichier de configuration du processeur PHP pour désactiver une fonctionnalité pouvant être un problème de sécurité:

nano /etc/php5/fpm/php.ini

Recherchez la directive + cgi.fix_pathinfo + dans le fichier. Il sera commenté et réglé sur «1». Nous devons le décommenter et le changer en «0»:

cgi.fix_pathinfo=0

Enregistrez et fermez le fichier lorsque vous avez terminé.

Configuration de Nginx

Nous devons maintenant configurer Nginx pour servir les fichiers WordPress correctement. Cela implique d’établir une nouvelle racine de document sur + / var / www / html, de définir le` + nom_serveur _` sur l’adresse IP publique de votre système hôte et de configurer le traitement PHP.

Ouvrez le fichier de configuration par défaut de Nginx:

vim /etc/nginx/sites-available/default

Voici un résumé des modifications à apporter:

  • Décommentez la directive + listen 80 + pour spécifier explicitement le numéro de port.

  • Modifiez la valeur de la directive + root + pour qu’elle pointe vers + / var / www / html +, l’emplacement où nous conserverons nos fichiers WordPress.

  • Modifiez le paramètre + index pour rechercher un fichier` + index.php` avant d’autres fichiers d’index.

  • Modifiez la valeur de la directive + nom_serveur + pour qu’elle pointe vers l’adresse IP ou le domaine du serveur * hôte

  • Ajustez la dernière valeur de la directive + try_files pour transmettre les demandes au fichier` + index.php` quand elles ne sont pas trouvées sous forme de fichiers ou de répertoires. Ceci est situé à l’intérieur du bloc + location / +.

  • Décommentez toutes les directives de page d’erreur pour autoriser les pages d’erreur.

  • Décommentez le bloc + location ~ \ .php $ +, la directive + fastcgi_split_path_info + incluse, les directives + fastcgi_pass + '* socket *, le + fastgci_index + et + include fastcgi_params + , et ajoutez un + try_files + `directive qui tente la requête telle qu’elle est donnée et retourne un 404 sinon.

Lorsque vous avez terminé les modifications ci-dessus, le fichier doit ressembler à celui ci-dessous (les commentaires ont été supprimés par souci de concision):

server {
   listen 80;
   root ;
   index  index.html index.htm;
   server_name ;
   location / {
       try_files $uri $uri/ ;
   }
   location /doc/ {
       alias /usr/share/doc/;
       autoindex on;
       allow 127.0.0.1;
       allow ::1;
       deny all;
   }
   error_page 404 /404.html;
   error_page 500 502 503 504 /50x.html;
   location = /50x.html {
       root /usr/share/nginx/www;
   }
   location ~ \.php$ {

       fastcgi_split_path_info ^(.+\.php)(/.+)$;
       fastcgi_pass unix:/var/run/php5-fpm.sock;
       fastcgi_index index.php;
       include fastcgi_params;
   }
}

Vous pouvez coller tout le contenu affiché ici si cela est plus facile. Vous devrez uniquement ajuster la directive + nom_serveur pour référencer l’adresse IP publique ou le nom de domaine de votre système hôte.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Téléchargement et configuration des fichiers WordPress

Maintenant que Nginx est configuré pour servir les fichiers correctement, nous pouvons les télécharger, les configurer et les installer.

Commencez par accéder au répertoire de base de l’utilisateur root et à télécharger la dernière archive WordPress:

cd ~
wget http://wordpress.org/latest.tar.gz

Extrayez le contenu de l’archive, en créant un répertoire appelé + ~ / / wordpress +:

tar xzvf latest.tar.gz

Copiez le fichier de configuration exemple dans le nom de fichier de configuration valide qui sera vérifié:

cd ~/wordpress
cp wp-config-sample.php wp-config.php

Ouvrez maintenant le nouveau fichier de configuration dans votre éditeur de texte:

nano wp-config.php

À l’intérieur, nous devons modifier les valeurs associées au stockage de la base de données. Nous devons renseigner les options de configuration avec les détails des choix que nous avons faits dans notre base de données MySQL.

À l’exception du champ de mot de passe, que vous auriez dû modifier à votre propre valeur plus tôt, vous pouvez utiliser les valeurs présentées ci-dessous:

/** The name of the database for WordPress */
define('DB_NAME', 'wordpress');

/** MySQL database username */
define('DB_USER', 'wordpressuser');

/** MySQL database password */
define('DB_PASSWORD', '');

/** MySQL hostname */
define('DB_HOST', '10.10.20.20');

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Ensuite, nous devons créer le répertoire + / var / www / html que nous avons référencé dans notre fichier de configuration Nginx en tant que racine du document. Nous copierons ensuite tous vos fichiers WordPress dans ce répertoire:

mkdir -p /var/www/html
cp -r ~/wordpress/* /var/www/html

Maintenant, nous pouvons donner la propriété des fichiers à l’internaute:

cd /var/www/html
chown -R www-data:www-data /var/www/html/*

La prison de votre serveur Web est maintenant complètement configurée. Nous pouvons arrêter notre serveur Web et les processus PHP sans problème en tapant:

service nginx stop
service php5-fpm stop

Maintenant, quittez la prison pour revenir à la session du serveur hôte:

exit

Démarrer les prisons

Nous avons maintenant nos prisons complètement configurées. Nous pouvons les démarrer individuellement avec notre interface de pont réseau.

Tout d’abord, nous allons démarrer le serveur de base de données, car il est plus simple. Nous devons spécifier l’emplacement de la racine chroot comme auparavant. Cette fois, nous allons également utiliser le paramètre + - net + pour spécifier l’interface du pont. Nous allons l’utiliser conjointement avec le paramètre - - ip + pour spécifier l’adresse exacte que nous voudrions attribuer à cette prison (+ 10.10.20.20 +, si vous vous en souvenez de notre configuration).

Nous allons également passer l’indicateur + - private + pour monter les nouveaux répertoires + / tmp,` + / root` et + / home / user et à l’intérieur de la prison. Nous devons ensuite spécifier les processus que nous voulons démarrer dans la prison et les mettre en arrière-plan avec une fin "&".

Les processus que nous devrions commencer sont le processus serveur MySQL, ainsi qu’un processus + sleep inf +. Cela permettra à la prison de fonctionner indéfiniment au lieu de sortir une fois les processus précédents terminés. Au total, la commande ressemble à ceci:

firejail --chroot=/jails/db --private --net=br0 --ip=10.10.20.20 \
   "/etc/init.d/mysql start; \
   sleep inf" &

La prison démarrera et les processus spécifiés commenceront à être exécutés de manière séquentielle. Vous pouvez voir les résultats de ces processus en utilisant l’option + - list pour` + firejail`:

firejail --list
21913:root:firejail --chroot=/jails/db --private --net=br0 --ip=10.10.20.20 /etc/init.d/mysql
 21916:root:bash -c /etc/init.d/mysql start; sleep inf
   21970:root:/bin/sh /usr/bin/mysqld_safe
     22322:syslog:/usr/sbin/mysqld --basedir=/usr --datadir=/var/lib/mysql --plugin-dir=/usr/
     22323:root:logger -t mysqld -p daemon.error
   22409:root:sleep inf

Comme vous pouvez le constater, l’arborescence des processus est disponible sur notre système hôte. Étant donné que nous pouvons voir le + sleep inf + en cours d’exécution et que les processus MySQL sont toujours actifs, nous pouvons voir que le système jail a fini de démarrer.

Pour la prison du serveur Web, la même configuration de base est requise. Nous devrons spécifier l’emplacement de la racine chroot, l’interface pontée et l’adresse IP réelle attribuée (+ 10.10.20.10 +) et l’indicateur + - private +.

En ce qui concerne la liste des processus, nous avons quelques considérations supplémentaires à prendre en compte. Pour commencer, le répertoire + / var / log + de la prison est créé dynamiquement à chaque démarrage. Pour cette raison, les directives de journalisation de nos fichiers Nginx pointent vers des emplacements inexistants. Nous pouvons créer ces emplacements avant d’essayer de démarrer Nginx.

En outre, le processus Nginx repose sur un enregistreur système. Nous allons également lancer le processus + rsyslog + avant Nginx. Après avoir démarré Nginx, nous devons également nous rappeler de démarrer notre processeur PHP, qui transmettra les requêtes à la prison de base de données si nécessaire. Encore une fois, nous voulons terminer par + sleep inf + afin que la prison persiste au-delà du point de départ des services.

En fin de compte, notre commande de démarrer notre prison de serveur Web ressemblera à ceci:

firejail --chroot=/jails/www --private --net=br0 --ip=10.10.20.10 \
   "mkdir -p /var/log/nginx; \
   touch /var/log/nginx/error.log; \
   touch /var/log/nginx/access.log; \
   /etc/init.d/rsyslog start; \
   /etc/init.d/nginx start; \
   /etc/init.d/php5-fpm start; \
   sleep inf" &

Le jail du serveur Web peut prendre un moment à démarrer. Vérifiez avec + firejail --list + pour voir si le processus atteint l’état + sleep inf +.

À présent, si vous accédez à l’adresse IP publique ou au nom de domaine de votre serveur hôte dans votre navigateur Web, la page d’installation initiale de WordPress devrait s’afficher:

http://

image: https: //assets.digitalocean.com/articles/firejail/wp_install.png [Écran d’installation initiale de WordPress]

Renseignez les valeurs appropriées et cliquez sur «Installer WordPress» en bas lorsque vous êtes prêt. Vous devrez vous connecter avec votre compte administratif nouvellement créé. Ensuite, vous serez amené au tableau de bord WordPress:

image: https: //assets.digitalocean.com/articles/firejail/wp_dashboard.png [tableau de bord WordPress]

Si tout fonctionne comme prévu, cela signifie que l’installation a réussi. Nous pouvons maintenant travailler à rendre cette configuration répétable et persistante.

Rendre les services d’instances Firejail

Maintenant que notre configuration est opérationnelle, nous voulons nous assurer de pouvoir y revenir facilement après un redémarrage. Pour ce faire, nous devons aborder un certain nombre de domaines. Ceux-ci inclus:

  • Configuration de la mise en réseau hôte à jail et jail-à-jail pour qu’elle apparaisse au démarrage.

  • Rendre vos changements + iptables persistants.

  • Configurer nos jails pour qu’ils démarrent automatiquement au démarrage du serveur hôte.

Nous pouvons commencer sur ces trois immédiatement.

Configuration de la mise en réseau pour les jails au démarrage

La première chose sur laquelle nous allons nous concentrer est de rendre le réseau de pont opérationnel. Cela est nécessaire avant que nous nous inquiétions de nos règles de pare-feu et avant de commencer nos environnements emprisonnés.

Nous devons configurer la connexion pontée réelle. Pour que cette connexion soit opérationnelle au démarrage, nous devons modifier les fichiers + / etc / network / interfaces +. Ouvrez ce fichier maintenant:

nano /etc/network/interfaces

À l’intérieur, vous verrez des sections indiquant les interfaces à démarrer, ainsi que d’autres lignes décrivant chaque interface. Commencez par ajouter le réseau + br0 + à la fin de la seconde ligne + auto + pour démarrer l’interface que nous définirons au démarrage:

auto eth0 eth1

Ensuite, nous devons créer une section qui définira l’interface. Etant donné qu’il s’agit d’une interface de pont et ne fonctionnant pas comme un pont classique pour combiner deux réseaux, nous définirons notre interface manuellement, ce qui signifie que nous donnerons les commandes exactes devant être utilisées pour configurer le réseau.

Commencez avec l’en-tête de section:

iface br0 inet manual

Sous cela, nous utiliserons les directives + pre-up +, + up +, + post-down + et + down + pour définir les commandes à exécuter à chaque étape. Pour les commandes + pre-up + et + up +, nous voulons créer le pont, puis l’interface de la même manière que nous l’avions fait précédemment. Le + $ IFACE + sera remplacé dynamiquement par le + br0 + lorsque les commandes seront exécutées, vous ne devriez donc pas les modifier ici:

iface br0 inet manual
   pre-up brctl addbr $IFACE
   up ifconfig $IFACE 10.10.20.1/24

Pour les commandes + post-down + et + + down +, nous voulons simplement inverser ces commandes. Nous ramènerons l’interface puis supprimerons le pont:

iface br0 inet manual
   pre-up brctl addbr $IFACE
   up ifconfig $IFACE 10.10.20.1/24
   down ifconfig $IFACE down
   post-down brctl delbr $IFACE

Notre interface + br0 + est maintenant définie et nous l’avons configurée pour démarrer automatiquement au démarrage. Enregistrez et fermez le fichier lorsque vous avez terminé.

Configurer IPTables pour autoriser le transfert restreint vers Jails

Ensuite, nous devons configurer iptables avec les règles que nous avons ajoutées précédemment. Heureusement, c’est simple avec l’aide du paquetage + iptables-persistent +.

Installez le paquet en tapant:

apt-get install iptables-persistent

Au cours des processus d’installation, il vous sera demandé si vous souhaitez enregistrer l’ensemble actuel de règles IPv4 et IPv6. Sélectionnez * oui * à ces invites pour enregistrer automatiquement les ensembles de règles actuels. Ceux-ci seront automatiquement réappliqués au démarrage.

Si vous avez besoin d’ajuster les règles qui sont appliquées au démarrage, apportez les modifications que vous souhaitez utiliser, puis tapez:

/etc/init.d/iptables-persistent save

Le jeu de règles actuel sera mis à jour.

Nos règles iptables sont maintenant configurées pour être ramenées au démarrage du serveur. Cependant, nous n’avons pas encore abordé un autre aspect: nous devons nous assurer que notre noyau autorise les transferts.

Avant, nous utilisions un "1" dans un fichier du pseudo système de fichiers + / proc + pour activer cette possibilité. Pour que cette modification se produise automatiquement au prochain démarrage, éditez le fichier + sysctl.conf +:

nano /etc/sysctl.conf

Décommentez la ligne suivante:

net.ipv4.ip_forward=1

Enregistrez et fermez le fichier lorsque vous avez terminé.

Créer un script de démarrage pour démarrer les jails WordPress

Pour configurer nos jails afin qu’ils démarrent au démarrage, nous devons créer un script de démarrage. Nous appellerons notre script + firejail_wp.conf +.

Ouvrez un fichier portant ce nom dans le répertoire + / etc / init + de votre éditeur de texte:

nano /etc/init/firejail_wp.conf

À l’intérieur, nous remplissons d’abord une brève description de ce service:

description "WordPress jail"

Ensuite, nous configurons les circonstances qui doivent être vraies pour que ce service démarre automatiquement. Nous voulons nous assurer que le système de fichiers est disponible et nous devons également nous assurer que le réseau + br0 + a été établi. Si le réseau + br0 + est en panne, nos deux commandes firejail échoueront.

Pour ce faire, nous allons utiliser la directive + start on + et les spécificateurs + local-filesystems + et + + net-device-up + pour construire nos conditions de départ. Nous allons également configurer notre script pour qu’il s’arrête à chaque fois que la machine passe en mode de redémarrage ou d’arrêt (indiquée par un niveau d’exécution différent de 1 à 5):

description "WordPress jail"

start on (local-filesystems and net-device-up IFACE=br0)
stop on runlevel [!12345]

Enfin, nous devons établir la commande qui sera exécutée au démarrage de ce service. En raison de la manière dont les services sont exécutés, nous placerons les commandes firejail dans un script externe. Il suffit donc de référencer le nom du script ici:

description "WordPress jail"

start on (local-filesystems and net-device-up IFACE=br0)
stop on runlevel [!12345]

exec /startjails.sh

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Maintenant, nous devons créer le fichier de script que nous venons de référencer. Utilisez votre éditeur de texte pour ouvrir un fichier à cet emplacement:

nano /startjails.sh

Comme il s’agit d’un script bash, commencez par l’appel standard shebang à bash:

#!/bin/bash

Ensuite, nous allons ajouter nos deux commandes firejail, avec une petite modification. Pour une raison inconnue, l’exécution du script d’initialisation Nginx dans l’environnement jailed lorsqu’il est démarré par upstart pose un problème. Ce problème n’est pas présent lorsqu’il est appelé par une autre méthode.

Pour résoudre ce problème, nous allons simplement appeler l’exécutable Nginx au lieu du script d’initialisation jailed interne. Autre que cela, les commandes sont exactement comme nous les avons utilisées plus tôt:

#!/bin/bash

firejail --chroot=/jails/db --private --net=br0 --ip=10.10.20.20 "/etc/init.d/mysql start; sleep inf" &

firejail --chroot=/jails/www --private --net=br0 --ip=10.10.20.10 "mkdir -p /var/log/nginx; touch /var/log/nginx/error.log; touch /var/log/nginx/access.log; /etc/init.d/rsyslog start; /usr/sbin/nginx; /etc/init.d/php5-fpm start; sleep inf" &

Une commande supplémentaire est nécessaire pour garantir qu’il s’agit d’un service permanent au lieu d’une tâche qui se terminerait immédiatement après le démarrage des prisons. Nous devons ajouter + sleep inf + comme dernière ligne du script. Cela permettra à upstart de gérer le service correctement:

#!/bin/bash

firejail --chroot=/jails/db --private --net=br0 --ip=10.10.20.20 "/etc/init.d/mysql start; sleep inf" &

firejail --chroot=/jails/www --private --net=br0 --ip=10.10.20.10 "mkdir -p /var/log/nginx; touch /var/log/nginx/error.log; touch /var/log/nginx/access.log; /etc/init.d/rsyslog start; /usr/sbin/nginx; /etc/init.d/php5-fpm start; sleep inf" &

sleep inf

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Maintenant, nous devons juste rendre ce fichier exécutable, afin que le script upstart puisse le démarrer:

chmod +x /startjails.sh

Avec cette étape, l’environnement jailed WordPress est complètement configuré pour démarrer au moment du démarrage.

Vous pouvez redémarrer votre serveur hôte pour essayer ceci:

shutdown -r now

Si tout a été configuré correctement, vous pourrez accéder à votre site WordPress une fois que tout aura eu le temps de démarrer.

Conclusion

Ce guide est simplement un exemple de l’une des nombreuses choses que vous pouvez faire avec un outil tel que Firejail. Bien qu’il existe de nombreuses autres manières de configurer des composants isolés pour vos serveurs, firejail est une excellente solution en raison de sa flexibilité et de sa capacité à gérer autant de scénarios différents avec des ressources minimales.

Related