dokkun

Geek Débutant
  • Compteur de contenus

    84
  • Inscrit(e) le

  • Dernière visite

  • Days Won

    1
  1. C'est sans aucun doute le plus gros tutoriel que je vous propose. Installer un serveur et le sécuriser au minimum représente une jolie masse de travail. J'ai installé 3 serveurs (2 en production et 1 de test) qui tournent impeccablement en suivant la procédure que je vais décrire. Un tutoriel Debian complet J'ai passé des heures à lire des docs, à consulter des tutos qui parfois n'avaient ni queue ni tête et faire de nombreux tests, voire de nouvelles installations de zéro, pour trouver la configuration qui fonctionnait. Au total, j'ai passé 19 jours pour peaufiner ma routine avant de commencer à installer les premiers sites sur le nouveau serveur. O_o Il y a une bonne vingtaine d'étapes avec un énorme morceau qui concerne la gestion des e-mails avec le couple Postfix/Dovecot. Ce tutoriel est basé sur l'installation d'une Debian 7 (wheezy) sur une dédibox. Il est possible que vous ayez des petits ajustements à faire chez un autre hébergeur. Pour info, les informations à remplacer sont indiquées en majuscule pour vous aider à les repérer plus facilement. Comme ce tutoriel est extrêmement complet, je vous propose un sommaire pour vous rendre plus facilement aux sections qui vous intéressent. Avant de commencer, j'en profite pour passer un petit coucou à Guillaume qui a eu la gentillesse de répondre à quelques unes de mes interrogations quand je me suis lancé le premier jour sur la configuration du serveur. Merci l'ami. Sommaire 01 - Un petit cadeau pour commencer 02 - Modification du mot de passe root 03 - Gestion de la carte réseau 04 - Mise à jour des paquets 05 - Création d'un nouvel utilisateur 06 - Installation d'Apticron (alerte e-mail) 07 - Mise à jour de NTP (horloge système) 08 - Installation d'utilitaires 09 - Installation d'Apache 2 10 - Installation de PHP 5 11 - Installation de MySQL 12 - Installation de phpMyAdmin 13 - Installation de proftpd 14 - Installation de Postfix et Dovecot 15 - Installation de suphp 16 - Installation de Spamassassin et Postgrey 17 - Gestion des tâches cron 18 - Installation d'iptables 19 - Installation de fail2ban 20 - Installation de Potsentry 21 - Installation de Rkhunter 22 - Configuration de Bind 23 - Gestion des noms de domaine 24 - Mise en place des sauvegardes 25 - Outils de monitoring 26 - Quelques astuces Je pars du principe que vous avez installé Debian depuis la console Online. C'est parti ! 1 - Un petit cadeau pour commencer Dans ce tutoriel, vous aurez besoin de mots de passe sécurisés. Je vous livre un bout de code maison pour les générer automatiquement avec 15 caractères mélangeant des lettres, des chiffres, des majuscules et des minuscules. J'ai volontairement oublié les caractères accentués pour cause éventuelle de conflit. <?php // Generation du mot de passe $chaine = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789"; srand((double)microtime()*1000000); for($i=0; $i<15; $i++) { // Mot de passe de 15 caracteres $pass .= $chaine[rand()%strlen($chaine)]; } echo $pass; ?> 2 - Modification du mot de passe root Commencez par vous connecter au serveur et indiquez le mot de passe quand il vous sera demandé : $ ssh root@IP_DU_SERVEUR Si le mot de passe root vous a été fourni par l'hébergeur du serveur dédié, il est conseillé de le changer. Il faudra le saisir à deux reprises. $ passwd root 3 - Gestion de la carte réseau Par défaut, la carte réseau est réglé sur DHCP. Comme j'utilise beaucoup les IP failover, je modifie les paramètres. Juste en dessous de # The primary network interface, remplacer par : auto eth0 iface eth0 inet static address IP_DU_SERVEUR netmask 255.255.255.0 gateway 3_PREMIERS_BLOCS_IP_DU_SERVEUR.1 Et si vous souhaitez utiliser une IP failover, ajouter en dessous : auto eth0:0 iface eth0:0 inet static address IP_FAILOVER netmask 255.255.255.255 Enregistrez le fichier. Pour que cette modification soit prise en compte, redémarrer la machine : $ reboot Une fois que le serveur est reparti et que vous êtes connecté, faites un ping pour vous assurer que la carte réseau (et toutes les IP) répondent parfaitement. Si toutefois la carte réseau ne réponde pas sur l'IP principale, il y a de fortes chances que le serveur ne redémarre pas. Si cela arrive, rendez-vous sur l'interface Online et cliquez sur le bouton Secours pour démarrer le serveur sur un autre OS et déboguer ainsi votre carte réseau. Online affiche les identifiants à utiliser à l'écran. On lance donc le ping en le limitant à 4 tentatives : $ ping -c 4 IP_DU_SERVEUR $ ping -c 4 IP_FAILOVER Si tout est OK, les différentes IP doivent répondre au 4 essais. 4 - Mise à jour des paquets Avant d'installer quoi que ce soit, on vérifie si une mise à jour de Debian est disponible. Lorsque le serveur est opérationnel et en production, c'est la première étape à effectuer avant chaque installation. $ aptitude update $ aptitude upgrade 5 - Création d'un nouvel utilisateur On verra l'utilité plus loin dans le tutoriel, il est conseillé de créer un nouvel utilisateur pour interdire les connexions en root au serveur. Par défaut, Online permet de renseigner cette information lors de l'installation d'une Dédibox. Ce n'est par contre pas le cas chez OVH. Pour ce faire, exécutez les commandes suivantes. On commence par créer un groupe d'utilisateurs dédié à SSH : $ groupadd sshusers On créé l'utilisateur : $ useradd -m NOM_UTILISATEUR On indique le mot de passe pour l'utilisateur (celui-ci vous sera demandé à deux reprises) : $ passwd NOM_UTILISATEUR On attribue l'utilisateur au groupe sshhusers $ usermod -a -G sshusers NOM_UTILISATEUR A partir de là, vous pourrez vous connecter au serveur sans utiliser le compte root. Au niveau sécurité c'est mieux mais cela reste insuffisant. Il faut maintenant interdire la connexion SSH avec le compte root et procéder à quelques réglages supplémentaires. Ouvrez le fichier de configuration SSH. $ nano /etc/ssh/sshd_config La première chose à faire est de modifier le numéro de port de SSH. Choisissez un numéro au dessus de 1024 (en dessous les ports sont attribués au système) : Port NOUVEAU_PORT Juste en dessous, ajoutez les informations suivantes : # Interdire l'acces en root PermitRootLogin no # Nom de l'utilisateur AllowUsers NOM_UTILISATEUR Même si ce n'est pas conseillé, vous pouvez créer plusieurs utilisateurs. Dans ce cas, modifiez comme suit : # Nom de l'utilisateur AllowUsers NOM_UTILISATEUR_1 NOM_UTILISATEUR_2 Redémarrez le service pour la prise en compte des modifications : $ service ssh restart On peut maintenant tester les différents accès SSH. Commencez par vous déconnecter : $ exit Tentez maintenant de vous connecter avec le compte root : $ ssh root@IP_DU_SERVEUR Vous devriez avoir ce message : ssh: connect to host IP_DU_SERVEUR port 22: Connection refused Nous allons donc nous connecter avec notre nouveau compte utilisateur sur le port que l'on a indiqué dans les paramètres un peu plus haut : $ ssh NOM_UTILISATEUR@IP_DU_SERVEUR -p NOUVEAU_PORT Il vous sera demandé de saisir le mot de passe de l'utilisateur. Maintenant que vous êtes connecté, il faut pouvoir agir sur le serveur avec les droits root. Pour ce faire, tapez la commande suivante : $ su root Lorsque cela vous est demandé, tapez votre mot de passe root. Vous avez à présent tous les droits pour gérer le serveur. 6 - Installation d'apticron (alerte MAJ) Lorsque l'on gère un serveur, il faut le maintenir à jour. Plutôt que se connecter chaque jour pour vérifier si une mise à jour est disponible, nous allons utiliser apticron qui nous alertera automatiquement par e-mail une fois par jour. $ aptitude install apticron -y Éditez le fichier de configuration : $ nano /etc/apticron/apticron.conf Et effectuez les réglages suivants : EMAIL="VOTRE_EMAIL" Enregistrez le fichier et lancez le service : $ apticron 7 - Mise à jour de NTP (horloge système) Il n'y a rien de plus chiant qu'une horloge qui ne se met pas à jour, notamment lors du passage de l'heure d'hiver à l'heure d'été et vice-versa. Pour pallier à ce problème, on va installer un utilitaire qui va se charger d'effectuer la mise à jour via des serveurs : $ aptitude install ntp ntpdate -y Le service est lancé après l'installation, on l'arrête : $ service ntp stop Et on lance la mise à jour (uniquement cette fois-ci) : $ ntpdate 0.fr.pool.ntp.org Ensuite on règle les paramètres des serveurs à interroger : $ nano /etc/ntp.conf Au dessus de la liste des serveurs, ajouter les serveurs français : server 0.fr.pool.ntp.org server 1.fr.pool.ntp.org server 2.fr.pool.ntp.org server 3.fr.pool.ntp.org Enregistrez le fichier et relancez le service : $ service ntp start 8 - Installation d'utilitaires Pour le fonctionnement du serveur, nous allons avoir besoin de quelques utilitaires. Cette liste est non exhaustive, vous pouvez en rajouter si besoin. $ aptitude install zip unzip gcc libc6-dev linux-kernel-headers mailutils ncftp -y 9 - Installation d'Apache 2 J'ai choisi Apache car je ne n'avais pas le temps de me pencher sérieusement sur Nginx. Libre à vous d'opter pour ce dernier si vous l'appréciez davantage. $ aptitude install apache2 apache2-doc apache2-mpm-prefork apache2-utils libexpat1 ssl-cert -y Une fois l'installation terminée, on active différents modules (le 4ème est normalement activé mais on vérifie quand même) : $ a2enmod rewrite expires headers deflate On vérifie les index (et leur extensions qui sont autorisées sur le serveur) : $ nano /etc/apache2/mods-available/dir.conf Vous devriez y voir cette configuration que vous pouvez modifier si besoin : <IfModule mod_dir.c> DirectoryIndex index.html index.cgi index.pl index.php index.xhtml index.htm </IfModule> J'ai pour habitude de préciser l'adresse IP du serveur dans le fichier de configuration des ports d'Apache : $ nano /etc/apache2/ports.conf Et modifiez comme suit en haut du fichier : NameVirtualHost IP_DU_SERVEUR:80 Enregistrez le fichier. Nous allons ensuite configurer le site par défaut. On commence par supprimer celui qui est actuellement renseigné : $ a2dissite default Cette modification est importante car le fichier par défaut doit être le premier qu'Apache va appeler. Si vous créez un site avec un nom comme "agenda" par exemple, il se positionne alphabétiquement avant "default". J'aime bien aussi créer un dossier spécifique à ce site : $ mkdir /var/www/default On crée 3 fichiers pour rendre les pages du site par défaut plus sexy : $ nano /var/www/default/index.html $ nano /var/www/default/403.html $ nano /var/www/default/404.html Dans chacune d'elle, vous pouvez copier le code suivant. A améliorer bien entendu. <!DOCTYPE html> <html lang="fr"> <head> <title>Coucou</title> <meta name="robots" content="noindex" /> </head> <body> <p>Cette page n'existe pas</p> </body> </html> Lorsque vous appellerez votre serveur par l'adresse http://IP_DU_SERVEUR, cela évitera d'avoir la page d'Apache It Works! affichée. Idem pour les erreurs 403 et 404. Vous pouvez évidemment créer un fichier pour chaque code d'erreur d'Apache. On peux maintenant créer notre site par défaut : $ nano /etc/apache2/sites-available/00-default Et y insérer le contenu suivant : <VirtualHost IP_DU_SERVEUR:80> ServerAdmin VOTRE_EMAIL ServerName IP_DU_SERVEUR DocumentRoot /var/www/default <Directory /> Options FollowSymLinks AllowOverride None </Directory> <Directory /var/www/default/> Options Indexes FollowSymLinks MultiViews AllowOverride None Order allow,deny allow from all </Directory> ErrorDocument 403 /403.html ErrorDocument 404 /404.html ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ <Directory "/usr/lib/cgi-bin"> AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all </Directory> ErrorLog ${APACHE_LOG_DIR}/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog ${APACHE_LOG_DIR}/access.log combined </VirtualHost> Enregistrez le fichier et activez le site par défaut : $ a2ensite 00-default On redémarre Apache pour prendre les modifications en compte : $ service apache2 restart 10 - Installation de PHP 5 On va maintenant procéder à l'installation de PHP 5 et de tous ses modules : $ aptitude install libapache2-mod-php5 php5 php5-common php5-curl php5-dev php5-gd php5-idn php-pear php5-imagick php5-imap php5-json php5-mcrypt php5-memcache php5-mhash php5-ming php5-mysql php5-ps php5-pspell php5-recode php5-snmp php5-sqlite php5-tidy php5-xmlrpc php5-xsl -y Pour vérifier que PHP 5 est opérationnel, créons un fichier de test : $ nano /var/www/default/test.php Copiez le contenu suivant : <?php phpinfo(); ?> Enregistrez le fichier et rendez-vous à cette adresse : http://IP_DU_SERVEUR/test.php. Si tout est OK, vous devriez voir les informations de PHP à l'écran. On va maintenant protéger un chouilla PHP des regards indiscrets. Ouvrez le fichier de configuration de PHP : $ nano /etc/php5/apache2/php.ini Libre de modifier son contenu, voici quelques paramètres à régler qui sont primordiaux : // Cacher la version de PHP expose_php = Off // Augmenter la mémoire utilisée memory_limit = 512M // Utile pour l'import de grosses bases de données post_max_size = 128M // Ajouter le phpinfo avant les autres fonctions disable_functions = phpinfo,... Enregistrez le fichier et ouvrez le fichier suivant : $ nano /etc/apache2/conf.d/security Il y a trois paramètres à vérifier et à modifier : ServerTokens Prod ServerSignature Off TraceEnable Off Enregistrez le fichier et retournez à l'adresse http://IP_DU_SERVEUR/test.php. Vous devriez avoir une page blanche. C'est normal puisque l'on a interdit la fonction phpinfo dans notre fichier php.ini. On redémarre Apache : $ service apache2 restart Et on supprime le fichier de test : $ rm /var/www/default/test.php 11 - Installation de MySQL Là encore j'ai choisi MySQL pour mon confort, libre à vous de choisir ce que vous voulez à la place. On installe le paquet comme suit : $ aptitude install mysql-server -y Lors de l'installation, on vous propose un bel écran. Ne paniquez pas, on n'est pas sur Windows, tout est normal. Il faudra indiquer deux fois un mot de passe root (évitez de choisir le même que SSH ^^). NB : appuyez sur TAB pour vous positionner sur OK et sur Entrée pour valider. On édite le fichier de configuration : $ nano /etc/mysql/my.cnf Et on renseigne les paramètres suivants : [client] port = NOUVEAU_PORT_MYSQL default-character-set=utf8 [mysqld] port = NOUVEAU_PORT_MYSQL default_storage_engine = MYISAM collation-server = utf8_unicode_ci init-connect='SET NAMES utf8' character-set-server = utf8 #log_bin = /var/log/mysql/mysql-bin.log #expire_logs_days = 10 [mysql] default-character-set=utf8 On redémarre MySQL pour prendre en compte les modifications : $ service mysql restart 12 - Installation de phpMyAdmin Utiliser MySQL depuis SSh peut vite vous faire perdre la tête. Pour plus de confort, installons phpMyAdmin : $ aptitude install phpmyadmin -y Là aussi, une pagaille d'écrans bleus vont apparaitre. Sur le premier, choisissez Apache2 ou Nginx si vous avez installé Nginx. Il faut ensuite créer un compte et les tables pour phpMyadmin. En écrivant ce tutoriel, je me demande si cela est bien utile vu que je ne les utilise pas. :-) Si vous choisissez de le faire, renseignez le mot de passe root MySQL et deux fois un autre mot de passe pour phpMyAdmin. Maintenant que l'installation est terminée, on va cacher notre phpMyAdmin en faisant quelques modifications : $ nano /etc/phpmyadmin/apache.conf Remplacez le nom du dossier par un autre dossier de votre choix au niveau de l'Alias : Alias /NOUVEAU_NOM_PHPMYADMIN /usr/share/phpmyadmin Enregistrez le fichier et créez le lien symbolique : ln -s /usr/share/phpmyadmin /var/www/NOUVEAU_NOM_PHPMYADMIN On va maintenant renforcer la protection de l'accès à nos bases de données. La première opération est de passer par une URL en HTTPS afin que les données ne transitent pas en clair sur le réseau. Tapez les deux lignes suivantes pour activer le mode SSL : $ a2enmod ssl $ a2ensite default-ssl On va maintenant créer les certificats auto-signés. Commencez par vous rendre dans le dossier dédié au SSL : $ cd /etc/ssl/ On créé maintenant le certificat.key : $ openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out certificat.key Avant de lancer la création du certificat.csr, on récupère le FQDN du serveur (notez-le) : $ hostname --fqdn Copiez le résultat affiché à l'écran et mettez le bien au chaud. On s'occupe maintenant du certificat.csr : $ openssl req -new -key certificat.key -out certificat.csr Quelques questions vont vous êtres posées, voici un exemple de ce que je renseigne : Country Name : FR State or Province Name : France Locality Name : Paris Organization Name : NOM_SOCIETE Organizational Unit Name : CE_QUE_VOUS_VOULEZ Common Name : HOSTNAME_FQDN Email Address : VOTRE_EMAIL Ensuite deux nouvelles questions vous sont posées : A challenge password []: MOTDEPASSE_CHALLENGE An optional company name []: NOM_SOCIETE On termine en créant le certificat.crt : $ openssl x509 -req -days 365 -in certificat.csr -signkey certificat.key -out certificat.crt Et on protège nos certificats en exécutant les lignes suivantes : $ chmod 400 certificat.key $ chmod 444 certificat.crt On déplace nos fichiers dans les répertoires respectifs : $ mv certificat.key private/ $ mv certificat.crt certs/ On peut modifier le fichier de configuration du site SSL : $ nano /etc/apache2/sites-available/default-ssl Voici les informations à indiquer dans le fichier : ServerName HOSTNAME_FQDN:443 SSLEngine on SSLCertificateFile /etc/ssl/certs/certificat.crt SSLCertificateKeyFile /etc/ssl/private/certificat.key Enregistrez le fichier et redémarrer Apache : $ service apache2 restart On peut vérifier que phpMyAdmin est opérationnel : https://IP_DU_SERVEUR/NOUVEAU_NOM_PHPMYADMIN/ après avoir accepté et compris les risques. Si tout est OK, on se connecte en root à phpMyAdmin et on crée un compte utilisateur avec tous les droits. Comme pour SSH, on interdira par la suite la connexion avec le compte root. Onglet Privilèges Ajouter un utlisateur => NOM_UTILISATEUR, Localhost et le MOT_DE_PASSE (2 fois) Privilèges globaux => Tout cocher On se déconnecte du compte root et on se connecte avec le nouveau compte pour s'assurer que tout est OK. Si c'est le cas, on ouvre le fichier de configuration de phpMyAdmin : $ nano /etc/phpmyadmin/config.inc.php Et on ajoute les deux lignes suivantes à l'intérieur du if (!empty($dbname)) { : $cfg['Servers'][$i]['auth_type'] = 'cookie'; $cfg['Servers'][$i]['AllowRoot'] = false; Enregistrez le fichier et redémarrez Apache : $ service apache2 restart Essayez maintenant de vous connecter en root à phpMyAdmin. Le système doit vous jeter. On termine par sécuriser MySQL en tapant la ligne suivante : $ mysql_secure_installation Enter current password for root (enter for none): tapez votre mot de passe root MySQL Set root password ? N Remove anonymous users ? Y Disallow root login remotely ? Y Remove test database and access to it ? Y Restart privilege tables now ? Y 13 - Installation de proftpd Si vous souhaitez héberger plusieurs sites clients ou des sites des copains et leur donner accès au FTP, il faut installer un FTP pou gérer les comptes. J'ai choisi Proftpd : $ aptitude install proftpd proftpd-mod-mysql -y Un premier écran bleu, vous demande de choisir entre From inetd et Standalone. Le premier choix ouvrira les accès à Proftpd à la demande afin de limiter l'utilisation des ressources du serveur, le second en permanence. Choisissez Standalone. Il faudra ensuite taper votre mot de passe root MySQL et à deux reprises le mot de passe dédié à Postfix. Une fois que l'installation est terminée, allez dans phpMyAdmin pour créer un utilisateur dédié au FTP. Créez ensuite les tables suivantes : CREATE TABLE IF NOT EXISTS `ftpgroup` ( `id` int(11) NOT NULL AUTO_INCREMENT, `groupname` varchar(16) NOT NULL, `gid` smallint(6) NOT NULL DEFAULT '4001', `members` varchar(16) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8; CREATE TABLE IF NOT EXISTS `ftpquotalimits` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(30) CHARACTER SET utf8 DEFAULT NULL, `quota_type` enum('user','group','class','all') CHARACTER SET utf8 NOT NULL DEFAULT 'user', `par_session` enum('false','true') CHARACTER SET utf8 NOT NULL DEFAULT 'false', `limit_type` enum('soft','hard') CHARACTER SET utf8 NOT NULL DEFAULT 'soft', `bytes_up_limit` float NOT NULL DEFAULT '0', `bytes_down_limit` float NOT NULL DEFAULT '0', `bytes_transfer_limit` float NOT NULL DEFAULT '0', `files_up_limit` int(10) unsigned NOT NULL DEFAULT '0', `files_down_limit` int(10) unsigned NOT NULL DEFAULT '0', `files_transfer_limit` int(10) unsigned NOT NULL DEFAULT '0', PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8; CREATE TABLE IF NOT EXISTS `ftpquotatotal` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(30) NOT NULL DEFAULT '', `quota_type` enum('user','group','class','all') NOT NULL DEFAULT 'user', `bytes_up_total` float NOT NULL DEFAULT '0', `bytes_down_total` float NOT NULL DEFAULT '0', `bytes_transfer_total` float NOT NULL DEFAULT '0', `files_up_total` int(10) unsigned NOT NULL DEFAULT '0', `files_down_total` int(10) unsigned NOT NULL DEFAULT '0', `files_transfer_total` int(10) unsigned NOT NULL DEFAULT '0', PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8; CREATE TABLE IF NOT EXISTS `ftpuser` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `userid` varchar(32) NOT NULL DEFAULT '', `passwd` varchar(32) NOT NULL DEFAULT '', `uid` smallint(6) NOT NULL DEFAULT '4001', `gid` smallint(6) NOT NULL DEFAULT '4001', `homedir` varchar(255) NOT NULL DEFAULT '', `shell` varchar(16) NOT NULL DEFAULT '/bin/false', `count` int(11) NOT NULL DEFAULT '0', `accessed` datetime NOT NULL DEFAULT '0000-00-00 00:00:00', `modified` datetime NOT NULL DEFAULT '0000-00-00 00:00:00', `LoginAllowed` enum('true','false') CHARACTER SET latin1 NOT NULL DEFAULT 'true', PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8; Je vous expliquerais plus tard comment insérer un nouveau compte FTP dans ces tables. On va éviter de multiplier les lignes pour rien. On ouvre le fichier de configuration de proftdp : $ nano /etc/proftpd/proftpd.conf Et on modifie pour obtenir les paramètres suivants : UseIPv6 off IdentLookups off ServerName "NOM_DU_SERVEUR" ShowSymlinks off # On limite le nombre de tentatives de login à 5 MaxLoginAttempts 5 DefaultRoot ~ RootLogin off RequireValidShell off umask 022 Ensuite, on va ajouter les lignes qui vont nous permettre d'interroger la base de données lors d'une connexion FTP pour nous assurer que les identifiants indiqués sont corrects. Il y a trois infos (en majuscule à modifier) : # Cryptage SQLAuthTypes Crypt SQLAuthenticate users* groups* # Identifiants de connexion SQLConnectInfo USER_PROFTPD@localhost DBNAME_PROFTPD MOTDEPASSE_PROFTPD # Colonnes utilisées pour les utilisateurs SQLUserInfo ftpuser userid passwd uid gid homedir shell SQLUserWhereClause "LoginAllowed = 'true'" # Colonnes utilisées pour les groupes SQLGroupInfo ftpgroup groupname gid members # Mise à jour des compteurs de connexion SQLLog PASS updatecount SQLNamedQuery updatecount UPDATE "count=count+1, accessed=now() WHERE userid='%u'" ftpuser # Mise à jour des compteurs de trafic SQLLog STOR,DELE modified SQLNamedQuery modified UPDATE "modified=now() WHERE userid='%u'" ftpuser # Quota QuotaEngine on QuotaDirectoryTally on QuotaDisplayUnits Mb QuotaShowQuotas on # Requêtes SQL relatives aux quotas SQLNamedQuery get-quota-limit SELECT "name, quota_type, par_session, limit_type, bytes_up_limit, bytes_down_limit, bytes_transfer_limit, files_up_limit, files_down_limit, files_transfer_limit FROM ftpquotalimits WHERE name = '%{0}' AND quota_type = '%{1}'" SQLNamedQuery get-quota-tally SELECT "name, quota_type, bytes_up_total, bytes_down_total, bytes_transfer_total, files_up_total, files_down_total, files_transfer_total FROM ftpquotatotal WHERE name = '%{0}' AND quota_type = '%{1}'" SQLNamedQuery update-quota-tally UPDATE "bytes_up_total = bytes_up_total + %{0}, bytes_down_total = bytes_down_total + %{1}, bytes_transfer_total = bytes_transfer_total + %{2}, files_up_total = files_up_total + %{3}, files_down_total = files_down_total + %{4}, files_transfer_total = files_transfer_total + %{5} WHERE name = '%{6}' AND quota_type = '%{7}'" ftpquotatotal SQLNamedQuery insert-quota-tally INSERT "%{0}, %{1}, %{2}, %{3}, %{4}, %{5}, %{6}, %{7}" ftpquotatotal QuotaLimitTable sql:/get-quota-limit QuotaTallyTable sql:/get-quota-tally/update-quota-tally/insert-quota-tally; Enregistrez le fichier et ouvrez celui de la configuration des modules de proftpd : $ nano /etc/proftpd/modules.conf Il y a deux lignes à décommenter et une à commenter comme ceci : LoadModule mod_sql.c LoadModule mod_sql_mysql.c #LoadModule mod_tls_memcache.c Enregistrez le fichier et redémarrez proftpd : $ service proftpd restart 14 - Installation de Postfix, Dovecot et Postfixadmin C'est sans doute la partie, celle de la gestion des e-mails sur un serveur, où je me suis le plus arraché les cheveux. A un tel point que j'ai failli abandonner pour passer sur Qmail. Ce dernier n'étant plus mis à jour depuis des années, cela m'a permis de poursuivre l'installation de Postfix malgré ma nouvelle calvitie. C'est parti et c'est du lourd. :-) On installe tous les paquets nécessaires : $ aptitude install postfix postfix-mysql dovecot-pop3d dovecot-imapd dovecot-mysql dovecot-lmtpd libsasl2-modules libsasl2-modules-sql postfixadmin -y Encore une fois, plusieurs écrans vous sont proposés. Plutôt que d'afficher toutes les images, je vous propose la liste à suivre : 1er écran : Type de serveur de messagerie => Site Internet 2ème écran : Nom de courrier => HOSTNAME_FQDN 3ème écran : Serveur web => Apache2 4ème écran : Base de données PostfixAdmin => Oui 5ème écran : Type de serveur de BDD => MySQL 6ème écran : Mot de passe administrateur MySQL => MOT_DE_PASSE_ROOT_MYSQL 6ème et 7ème écran : Mot de passe postfixadmin MySQL => MOT_DE_PASSE_POSTFIXADMIN_MYSQL On édite le fichier de configuration Apache pour Postfix : $ nano /etc/postfixadmin/apache.conf Comme pour phpMyAdmin, on va cacher le nom de notre outil de gestion d'e-mails : Alias /NOUVEAU_NOM_POSTFIXADMIN /usr/share/postfixadmin On enregistre le fichier et on créé le lien symbolique : $ ln -s /usr/share/postfixadmin /var/www/NOUVEAU_NOM_POSTFIXADMIN On édite maintenant le fichier de configuration de Postfix : $ nano /etc/postfixadmin/config.inc.php Je vous donne les principales lignes à modifier, à adapter bien sur selon vos besoins : $CONF['default_language'] = 'fr'; $CONF['postfix_admin_url'] = 'https://IP_DU_SERVEUR/NOUVEAU_NOM_POSTFIXADMIN'; $CONF['database_type'] = 'mysqli'; $CONF['database_host'] = 'localhost'; $CONF['database_user'] = 'USER_POSTFIXADMIN'; $CONF['database_password'] = 'MOTDEPASSE_POSTFIXADMIN'; $CONF['database_name'] = 'DBNAME_POSTFIXADMIN'; $CONF['database_port'] = 'PORT_MYSQL'; $CONF['admin_email'] = 'VOTRE_EMAIL'; $CONF['smtp_port'] = '587'; 'abuse' => 'VOTRE_EMAIL', 'hostmaster' => 'VOTRE_EMAIL', 'postmaster' => 'VOTRE_EMAIL', 'webmaster' => 'VOTRE_EMAIL' $CONF['domain_path'] = 'YES'; $CONF['domain_in_mailbox'] = 'NO'; Enregistrez le fichier et allez à cette adresse : https://IP_DU_SERVEUR/NOUVEAU_NOM_POSTFIXADMIN/setup.php Un premier écran liste que tout c'est bien passé. En bas, un formulaire vous propose de crypter le mot de passe de postfixadmin. Copiez-le dans les deux champs pour obtenir le mot de passe crypté. Copiez-le et ouvrez le fichier de configuration : $ nano /etc/postfixadmin/config.inc.php Copiez le code dans le champ suivant (sans oublier de supprimer changeme, y'a des têtes en l'air ^^) : $CONF['setup_password'] = 'changeme'; Enregistrez le fichier et retournez à l'adresse pour créer le super administrateur de Postfix : https://IP_DU_SERVEUR/NOUVEAU_NOM_POSTFIXADMIN/setup.php Une fois que le compte est crée, pour vous connecter à l'adresse : https://IP_DU_SERVEUR/NOUVEAU_NOM_POSTFIXADMIN/ Si vous souhaitez personnaliser le fichier de styles pour le rendre plus sexy, éditez le fichier suivant : $ nano /usr/share/postfixadmin/css/default.css Pour modifier les textes ou corriger les fautes d'orthographe, c'est ce fichier : $ nano /usr/share/postfixadmin/languages/fr.lang Nous allons maintenant créer un groupe et un utilisateur dédié aux e-mails : $ groupadd -g 5000 vmail $ useradd -d /var/vmail -m -u 5000 -g 5000 vmail Ensuite, on crée le dossier et les permissions de celui-ci : $ mkdir -p /var/vmail $ chown -R vmail:vmail /var/vmail On peut maintenant éditer le fichier de main de Postfix : $ nano /etc/postfix/main.cf Décommentez la ligne suivante et modifiez le temps de la file d'attente : delay_warning_time = 1h Modifiez les lignes ci-après : smtpd_tls_cert_file = /etc/ssl/certs/certificat.crt smtpd_tls_key_file = /etc/ssl/private/certificat.key En dessous de : inet_interfaces = all Ajoutez : inet_protocols = ipv4 Ensuite vous pouvez ajouter toutes les informations qui suivent : # Utilisateurs et chemin virtual_uid_maps = static:5000 virtual_gid_maps = static:5000 virtual_mailbox_base = /var/vmail # Fichiers MySQL virtual_mailbox_domains = mysql:/etc/postfix/mysql-virtual-mailbox-domains.cf virtual_mailbox_maps = mysql:/etc/postfix/mysql-virtual-mailbox-maps.cf virtual_alias_maps = mysql:/etc/postfix/mysql-virtual-alias-maps.cf # Transport virtual_transport = lmtp:unix:private/dovecot-lmtp # Regles sur les adresses de destination smtpd_recipient_restrictions = permit_mynetworks, permit_sasl_authenticated, reject_non_fqdn_recipient, reject_unauth_destination, reject_unknown_recipient_domain # Regles avant la connexion smtpd_helo_restrictions = permit_mynetworks, permit_sasl_authenticated, reject_invalid_helo_hostname, reject_non_fqdn_helo_hostname, reject_unknown_helo_hostname # Regles de connexion des clients smtpd_client_restrictions = permit_mynetworks, permit_inet_interfaces, permit_sasl_authenticated # Regles sur les expéditeurs smtpd_sender_restrictions = reject_non_fqdn_sender, reject_unknown_sender_domain # TLS smtpd_tls_auth_only = no smtpd_tls_security_level = may # Parametres de connexion SASL smtpd_sasl_auth_enable = yes smtpd_sasl_type = dovecot smtpd_sasl_path = private/auth smtpd_sasl_security_options = noanonymous smtpd_sasl_tls_security_options = $smtpd_sasl_security_options smtpd_sasl_local_domain = $mydomain smtpd_sasl_authenticated_header = yes Enregistrez le fichier et créez le fichier : $ nano /etc/postfix/mysql-virtual-mailbox-domains.cf Dans lequel vous ajoutez le code suivant : hosts = 127.0.0.1:PORT_MYSQL user = USER_POSTFIXADMIN password = PASSWORD_POSTFIXADMIN dbname = DBNAME_POSTFIXADMIN query = SELECT domain FROM domain WHERE domain='%s' Enregistrez le fichier et créez le fichier : $ nano /etc/postfix/mysql-virtual-mailbox-maps.cf Copiez le code suivant : hosts = 127.0.0.1:PORT_MYSQL user = USER_POSTFIXADMIN password = PASSWORD_POSTFIXADMIN dbname = DBNAME_POSTFIXADMIN query = SELECT maildir FROM mailbox WHERE username='%s' AND active = 1 Enregistrez le fichier et créez le fichier : $ nano /etc/postfix/mysql-virtual-alias-maps.cf Copiez le code suivant : hosts = 127.0.0.1:PORT_MYSQL user = USER_POSTFIXADMIN password = PASSWORD_POSTFIXADMIN dbname = DBNAME_POSTFIXADMIN query = SELECT goto FROM alias WHERE address='%s' AND active = 1 On protège ces 3 fichiers en limitant l'accès au groupe Postfix : $ chmod 640 /etc/postfix/mysql-* $ chgrp postfix /etc/postfix/mysql-* Editez le fichier suivant : $ nano /etc/postfix/master.cf Décommentez les lignes suivantes : submission inet n - - - - smtpd -o syslog_name=postfix/submission -o smtpd_tls_security_level=encrypt -o smtpd_sasl_auth_enable=yes -o smtpd_client_restrictions=permit_sasl_authenticated,reject Enregistrez le fichier et ouvrez : $ nano /etc/dovecot/dovecot.conf Modifiez les paramètres comme suit : !include_try /usr/share/dovecot/protocols.d/*.protocol protocols = imap pop3 lmtp listen = * !include conf.d/*.conf Enregistrez le fichier et ouvrez le suivant : $ nano /etc/dovecot/dovecot-mysql.conf.ext Copiez le code : driver = mysql connect = host=127.0.0.1 dbname=DBNAME_POSTFIXADMIN user=USER_POSTFIXADMIN password=PASSWORD_POSTFIXADMIN default_pass_scheme = MD5-CRYPT user_query = SELECT '/var/vmail/%d/%n' as var, 5000 AS uid, 5000 AS gid FROM mailbox WHERE username = '%u' password_query = SELECT password FROM mailbox WHERE username = '%u' Enregistre le fichier et passez au suivant : $ nano /etc/dovecot/conf.d/10-auth.conf Modifiez pour avoir les paramètres suivants : disable_plaintext_auth = yes auth_mechanisms = plain login #!include auth-system.conf.ext !include auth-sql.conf.ext Enregistrez le fichier et ouvrez : $ nano /etc/dovecot/conf.d/10-mail.conf Apportez les modifications suivantes (décommentez si nécessaire) : mail_location = maildir:/var/vmail/%d/%n mail_privileged_group = vmail Enregistrez et ouvrez le fichier ci-dessous : $ nano /etc/dovecot/conf.d/10-ssl.conf Modifiez le fichier comme suit : ssl = required # Attention de bien conserver le < ssl_cert = </etc/ssl/certs/certificat.crt ssl_key = </etc/ssl/private/certificat.key Enregistrez le fichier et passez au suivant : $ nano /etc/dovecot/conf.d/20-imap.conf Une toute petite modification à apporter : mail_max_userip_connections = 10 Enregistrez et ouvrez : $ nano /etc/dovecot/conf.d/auth-sql.conf.ext Pour obtenir la configuration suivante : passdb { driver = sql # Path for SQL configuration file, see example-config/dovecot-sql.conf.ext args = /etc/dovecot/dovecot-sql.conf.ext } userdb { driver = static args = uid=vmail gid=vmail home=/var/vmail/%d/%n } Enregistrez ce fichier et passez au suivant : $ nano /etc/dovecot/conf.d/10-master.conf Voici mes réglages : inet_listener imap { #port = 143 } inet_listener imaps { port = 993 ssl = yes } inet_listener pop3 { #port = 110 } inet_listener pop3s { port = 995 ssl = yes } service lmtp { unix_listener /var/spool/postfix/private/dovecot-lmtp { mode = 0600 user = postfix group = postfix } } service auth { # Postfix smtp-auth unix_listener /var/spool/postfix/private/auth { mode = 0666 user = postfix group = postfix } # On indique à Dovecot les permissions du conteneur local unix_listener auth-userdb { mode = 0600 user = vmail } user = dovecot } service auth-worker { user = vmail } Enregistrez ce fichier et ouvrez le petit dernier (ouf ^^) : $ nano /etc/dovecot/dovecot-sql.conf.ext Apportez les modifications suivantes : driver = mysql connect = host=127.0.0.1 dbname=DBNAME_POSTFIXADMIN user=USER_POSTFIXADMIN password=PASSWORD_POSTFIXADMIN default_pass_scheme = MD5-CRYPT password_query = SELECT password FROM mailbox WHERE username = '%u' Enregistrez le fichier et limitez l'accès des e-mails à Dovecot comme suit : $ chown -R vmail:dovecot /etc/dovecot $ chmod -R o-rwx /etc/dovecot On redémarre les services : $ service dovecot restart $ service postfix restart Vous pouvez maintenant vous connecter à Postfixadmin pour gérer les administrateurs, les domaines, les e-mails et les redirections. Voilà, le gros morceau est terminé. On a tous mérité une petite pause pour se boire un café. Elle sera salvatrice car ce n'est pas encore terminé. :-) 15 - Installation de suphp Ces deux services permettent d'enfermer les fichiers d'un site dans un espace confiné. Autrement dit, seul l'utilisateur autorisé pourra agir sur les fichiers de son compte FTP. De fait, si une personne parvient à profiter d'une faille dans un script php, son accès sera limité au dossier du site sans pourvoir accéder aux autres fichiers du serveur. On installe suexec et suphp comme suit : $ aptitude install apache2-suexec-custom libapache2-mod-suphp -y Et on commence le paramétrage : $ nano /etc/apache2/suexec/www-data Vérifiez que les deux premières lignes comme suit : /home / Enregistrez le fichier et passez à la suite : $ nano /etc/suphp/suphp.conf Indiquez les principaux réglages comme suit : loglevel=error docroot=/var/www:/${HOME}:/usr/share/phpmyadmin:/usr/share/postfixadmin check_vhost_docroot=false umask=0022 min_uid=33 min_gid=33 Enregistrez le fichiez et ouvrez le suivant : $ nano /etc/apache2/mods-enabled/suphp.conf Ajouter le contenu suivant : <IfModule mod_suphp.c> AddType application/x-httpd-suphp .php .php3 .php4 .php5 .phtml suPHP_AddHandler application/x-httpd-suphp suPHP_Engine on </IfModule> Enregistrez le fichiez et exécutez les commandes suivantes pour désactiver PHP 5 et passer le relais à suphp : $ a2dismod php5$ a2enmod suexec$ a2enmod suphp Il faut à présent copier le fichier de configuration de PHP pour suphp. On fait une sauvegarde par sécurité avec la commande mv : $ mv /etc/php5/cgi/php.ini /etc/php5/cgi/php.ini-old$ cp /etc/php5/apache2/php.ini /etc/php5/cgi/php.ini On ouvre le fichier de configuration de PHP-CGI : $ nano /etc/php5/cgi/php.ini Pour éviter l'affichage de messages d'erreur sur les sessions, on recherche la ligne session.save_path et on ajoute juste en dessous : session.save_path = "/tmp" Les modifications sont en place et nos sites seront confinés à leur espace. Il reste à modifier le propriétaire des fichiers de phpMyAdmin et Postfixadmin car ils ne fonctionnent plus avec cette configuration. $ chown -R www-data:www-data /usr/share/phpmyadmin $ chown -R www-data:www-data /usr/share/postfixadmin On redémarre Apache : $ service apache2 restart Le module est prêt à l'emploi et vous devriez avoir de nouveau accès à phpMyadmin et Postfixadmin. Nous verrons plus bas comment l'intégrer aux noms de domaine. 16 - Installation de Spamassassin et Postgrey Le spam, tout le monde connait. Pour le réduire, on installe spamassassin comme suit : $ aptitude install spamassassin spamc postgrey -y On doit apporter une modification au fichier de configuration de Postfix : $ nano /etc/postfix/master.cf Modifiez comme suit : smtp inet n - - - - smtpd -o content_filter=spamassassin #smtp inet n - - - 1 postscreen #smtpd pass - - - - - smtpd #dnsblog unix - - - - 0 dnsblog #tlsproxy unix - - - - 0 tlsproxy submission inet n - - - - smtpd -o syslog_name=postfix/submission -o smtpd_tls_security_level=encrypt -o smtpd_sasl_auth_enable=yes -o smtpd_client_restrictions=permit_sasl_authenticated,reject -o content_filter=spamassassin Tout en bas du fichier, ajoutez : spamassassin unix - n n - - pipe user=debian-spamd argv=/usr/bin/spamc -f -e /usr/sbin/sendmail -oi -f ${sender} ${recipient} On édite le fichier de configuration de spamassasin : $ nano /etc/spamassassin/local.cf Modifiez les paramètres comme ci-dessous : report_safe 0 required_score 5.0 use_bayes 1 bayes_auto_learn 1 On enregistre le fichier et on en profite pour modifier le fichier spamassassin : $ nano /etc/default/spamassassin Il y a deux infos à modifier pour la MAJ automatique de la base de données de spamassassin : ENABLED=1 CRON=1 On enregistre et on démarre le service : $ service spamassassin start Ouvrez le fichier suivant : $ nano /etc/default/postgrey Remplacez la ligne par celle ci-dessous : POSTGREY_OPTS="--inet=10023 --delay=300 --hostname=HOSTNAME_FQDN --auto-whitelist-clients" Enregistrez et ouvrez le fichier : $ nano /etc/postfix/main.cf Remplacez : reject_unknown_recipient_domain Par : reject_unknown_recipient_domain, reject_unauth_pipelining, check_policy_service inet:127.0.0.1:10023, reject_invalid_hostname Enregistrez le fichier et redémarrez les services : $ service postfix restart $ service postgrey restart 17 - Gestion des tâches cron On profite de l'installation de spamassasin pour porter un regard sur les tâches cron. Sur Debian, chaque fichier est propre à l'utilisateur connecté. Pour ajouter des règles dans le fichier, il suffit de taper : $ crontab -e Un fichier temporaire est ouvert dans lequel on va placer nos règles. On commence par copier les lignes suivantes (reprise du fichier /etc/crontab) avant d'aller plus loin (nécessaire pour apticron par exemple) : # m h dom mon dow command 17 * * * * root cd / && run-parts --report /etc/cron.hourly 25 6 * * * root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily ) 47 6 * * 7 root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly ) 52 6 1 * * root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly ) On place la règle de MAJ de spamassassin en dessous : # Mise à jour de spamassassin 0 2 * * * /usr/bin/sa-update -v On enregistre le fichier. Je vous conseille de conserver une copie locale de ces données. Un simple copier-coller dans un fichier texte suffit. Pour modifier le fichier, il suffira de l'éditer comme ceci : $ crontab -e 18 - Installation d'iptables iptables est le service qui permet d'autoriser les entrées et les sorties sur les ports du serveur. On installe donc le service comme suit : $ aptitude install iptables -y On crée les règles d'iptables comme suit et c'est à adapter en fonction de votre configuration ou de vos besoins : $ nano /etc/init.d/firewall Voici la configuration que je vous propose dans laquelle il y a quelques modifications à apporter (SSH, MYSQL et monitoring du serveur) : ### Infos # Provides: firewall # Required-Start: $remote_fs $syslog # Required-Stop: $remote_fs $syslog # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: Demarrage du script du firewall # Description: Regles du firewall ### Fin Infos #!/bin/sh case "$1" in start) ########## Initialisation ########## # Vidage des tables iptables -t filter -F iptables -t filter -X # Interdire toutes connexions entrantes et sortantes iptables -t filter -P INPUT DROP iptables -t filter -P FORWARD DROP iptables -t filter -P OUTPUT DROP # Ne pas casser les connexions etablies iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT iptables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT ########## Regles ########## # Trafic local iptables -t filter -A INPUT -i lo -j ACCEPT iptables -t filter -A OUTPUT -o lo -j ACCEPT # Ping iptables -t filter -A INPUT -p icmp -j ACCEPT iptables -t filter -A OUTPUT -p icmp -j ACCEPT # SSH iptables -t filter -A INPUT -p tcp --dport PORT_SSH -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport PORT_SSH -j ACCEPT # DNS iptables -t filter -A INPUT -p tcp --dport 53 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 53 -j ACCEPT iptables -t filter -A INPUT -p udp --dport 53 -j ACCEPT iptables -t filter -A OUTPUT -p udp --dport 53 -j ACCEPT # NTP iptables -t filter -A OUTPUT -p udp --dport 123 -j ACCEPT # FTP modprobe ip_conntrack modprobe ip_conntrack_ftp iptables -t filter -A INPUT -p tcp --dport 20:21 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 20:21 -j ACCEPT iptables -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT # FTP passif iptables -A OUTPUT -o eth0 -p tcp --dport 1024:65535 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT # HTTP iptables -t filter -A INPUT -p tcp --dport 80 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 80 -j ACCEPT # HTTPS iptables -t filter -A INPUT -p tcp --dport 443 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 443 -j ACCEPT iptables -t filter -A INPUT -p tcp --dport 8443 -j ACCEPT # MYSQL iptables -t filter -A INPUT -p tcp --dport PORT_MYSQL -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport PORT_MYSQL -j ACCEPT # SMTP iptables -t filter -A INPUT -p tcp --dport 25 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 25 -j ACCEPT # SMTPS iptables -t filter -A INPUT -p tcp --dport 587 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 587 -j ACCEPT # IMAPS iptables -t filter -A INPUT -p tcp --dport 993 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 993 -j ACCEPT # POP3S iptables -t filter -A INPUT -p tcp --dport 995 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 995 -j ACCEPT # Postgrey iptables -t filter -A INPUT -p tcp --dport 10023 -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport 10023 -j ACCEPT # Monitoring du serveur iptables -A INPUT -i eth0 -s 3_PREMIERS_BLOCS_IP_DU_SERVEUR.0/24 -p tcp --dport 161 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A INPUT -i eth0 -s 3_PREMIERS_BLOCS_IP_DU_SERVEUR.0/24 -p udp --dport 161 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -o eth0 -d 3_PREMIERS_BLOCS_IP_DU_SERVEUR.0/24 -p tcp --sport 161 -m state --state ESTABLISHED -j ACCEPT iptables -A OUTPUT -o eth0 -d 3_PREMIERS_BLOCS_IP_DU_SERVEUR.0/24 -p udp --sport 161 -m state --state ESTABLISHED -j ACCEPT # Flood iptables -A FORWARD -p tcp --syn -m limit --limit 1/second -j ACCEPT iptables -A FORWARD -p udp -m limit --limit 1/second -j ACCEPT iptables -A FORWARD -p icmp --icmp-type echo-request -m limit --limit 1/second -j ACCEPT # Scan de ports iptables -A FORWARD -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s -j ACCEPT # Monit iptables -t filter -A INPUT -p tcp --dport PORT_MONIT -j ACCEPT iptables -t filter -A OUTPUT -p tcp --dport PORT_MONIT -j ACCEPT echo Firewall start ;; status) echo - Liste des regles : iptables -L ;; stop) # Vidage des tables iptables -t filter -F iptables -t filter -X iptables -P INPUT ACCEPT iptables -P FORWARD ACCEPT iptables -P OUTPUT ACCEPT echo Firewall stop ;; esac exit 0 Vous enregistrez le fichier et vous le rendez exécutable : $ chmod +x /etc/init.d/firewall On peut démarrer le service : $ /etc/init.d/firewall start Et l'ajouter à la séquence de boot du serveur : $ update-rc.d firewall defaults A savoir : # Pour démarrer iptables $ /etc/init.d/firewall start # Pour arrêter iptables $ /etc/init.d/firewall stop # Pour lister la configuration d'iptables $ /etc/init.d/firewall status Si vous n'utilisez pas IPV6, autant le désactiver. Commencez par vérifier s'il est activé : $ more /proc/net/if_inet6 Normalement cela doit vous retourner les infos comme ceci (s'il n'y aucun résultat, IPV6 est désactivé) : fe80000000000000b283fefffec18bdb 02 40 20 80 eth0 00000000000000000000000000000001 01 80 10 80 lo Ouvrez le fichier : $ nano /etc/sysctl.conf Et ajoutez les lignes suivantes : # Désactivation des interfaces net.ipv6.conf.all.disable_ipv6 = 1 # Désactivation de l'auto configuration des interfaces net.ipv6.conf.all.autoconf = 0 # Désactivation des nouvelles interfaces net.ipv6.conf.default.disable_ipv6 = 1 # Désactivation de l'auto configuration des nouvelles interfaces net.ipv6.conf.default.autoconf = 0 Activez la configuration : $ sysctl -p Faites de nouveau le test qui doit vous retourner cette fois aucun résultat. $ more /proc/net/if_inet6 NB : Si vous rencontrez un souci sur le fonctionnement d'un paquet, commencez par stopper iptables pour vérifier que l'une des règles n'est pas bloquante ou absente. J'ai rencontré un problème de sauvegarde avec un script bash, et c'est iptables qui me bloquait. J'ai cherché deux bonnes heures avant de penser à stopper ce service. 19 - Installation de fail2ban Maintenant que l'on a déterminé quels ports pouvaient être écoutés, on va s'attacher à bannir les connexions un peu trop persistantes. Pour ce faire, on installe fail2ban : $ aptitude install fail2ban -y On ouvre le fichier de configuration : $ nano /etc/fail2ban/jail.conf Et on modifie selon ses besoins : ignoreip = 127.0.0.1 3_PREMIERS_BLOCS_IP_DU_SERVEUR.0/24 8.8.8.8 bantime = 600 action = %(action_mw)s [ssh] enabled = true port = PORT_SSH filter = sshd logpath = /var/log/auth.log maxretry = 6 [apache] enabled = true port = http,https filter = apache-auth logpath = /var/log/apache*/*error. logmaxretry = 6 ... Enregistrez le fichier et redémarrez le service $ service fail2ban restart Si vous souhaitez aller plus loin, je vous invite à lire la doc de Fail2ban :http://www.fail2ban.org/wiki/index.php/FAQ_french 20 - Installation de Portsentry Cet outil permet de surveiller le scan des ports du serveur. On l'installe comme ceci : $ aptitude install portsentry -y On ouvre le fichier de configuration : $ nano /etc/portsentry/portsentry.conf Décommentez la ligne suivante afin de bloquer le scan via iptables : KILL_ROUTE="/sbin/iptables -I INPUT -s $TARGET$ -j DROP" Puis vérifiez que toutes les lignes commençant par KILL_HOSTS_DENY sont commentées : #KILL_HOSTS_DENY="ALL: $TARGET$" #KILL_HOSTS_DENY="ALL: $TARGET$ : DENY" On peut ensuite lancer le service : $ portsentry –audp $ portsentry –atcp 21 - Installation de Rkhunter Cet utilitaire permet de surveiller le système et d'envoyer des mails d'alerte si un fichier système à été modifié. Attention, il se peut que vous ayez de temps en temps des faux positifs. Pour l'installer : $ aptitude install rkhunter -y Éditez le fichier de configuration : $ nano /etc/default/rkhunter Apportez les modifications suivantes : CRON_DAILY_RUN="yes" REPORT_EMAIL="VOTRE-EMAIL" Enregistrez le fichier. 22 - Configuration de Bind Voilà un autre gros morceau qui mérite une attention particulière. J'ai toujours géré les noms de domaine avec Bind via les VirtualHost. Je continue donc à faire la même chose. Pour cela, il est nécessaire d'apporter quelques modifications pour la gestion des DNS. Dans le cas contraire, la galère est assurée pour transférer ou installer des noms de domaine. :-) On commence par récupérer les infos du hostname qu'il faut noter : $ hostname $ hostname --fqdn On ouvre le fichier de configuration du host : $ nano /etc/host.conf Au début du fichier, ajoutez : order hosts, bind Enregsitrez le fichier et ouvrez celui des hosts : $ nano /etc/hosts Remplacez la ligne (la seconde normalement) : 127.0.0.1 HOSTNAME_FQDN HOSTNAME Par : IP_DU_SERVEUR HOSTNAME_FQDN HOSTNAME Enregistrez le fichier et rendez-vous dans votre console Online pour modifier le reverse. Dans le champ, indiquez le hostname --fqdn, à savoir HOSTNAME_FQDN. (avec un point à la fin). Ouvrez le fichier suivant : $ nano /etc/resolv.conf Au dessus des deux nameserver, ajoutez la ligne : nameserver IP_DU_SERVEUR Enregistrez le fichier. Copiez la commande suivante pour créer un nouveau fichier afin de paramétrer le reverse sur le serveur : $ cp /etc/bind/db.127 /etc/bind/db.HOSTNAME.inv Ouvrez le fichier qui vient d'être créé : $ nano /etc/bind/db.HOSTNAME.inv Et remplacez les 3 infos comme suit (normalement la 2ème ligne et les deux dernières) : @ IN SOA HOSTNAME_FQDN. email.HOSTNAME_FQDN. ( @ IN NS HOSTNAME. 230 IN PTR HOSTNAME_FQDN. Ouvrez le fichier de configuration de named.local : nano /etc/bind/named.conf.local On va renseigner les informations de notre reverse comme ceci : zone "3_PREMIERS_BLOC_IP_INVERSE.in-addr.arpa" { type master; file "/etc/bind/db.HOSTNAME.inv"; forwarders {}; }; Enregistrez le fichier et ouvrez celui de la configuration des options de named : $ nano /etc/bind/named.conf.options Dans ce fichier, on va indiquer les DNS de Google pour accélérer la résolution. Il faut décommenter la zone et remplacer l'IP et on ajoute 3 nouveaux paramètres avant la fermeture par ;} : forwarders { 8.8.8.8; }; listen-on port 53 { any; }; allow-recursion { 127.0.0.1; }; version none; Enregistrez le fichier et redémarrez Bind pour la prise en compte des modifications : $ /etc/init.d/bind9 restart 23 - Gestion des noms de domaines Cette partie vous explique comment installer un nom de domaine. Il se résume en plusieurs étapes : Création d'un groupe et d'un utilisateur Insertion des paramètres FTP dans MySQL Création des fichiers de configuration Ajout d'un domaine et d'une adresse e-mail dans PostfixAdmin Exemple de configuration d'un client e-mail Création d'un groupe et d'un utilisateur Comme expliqué dans la section suphp, il faut créer un groupe pour l'ensemble des noms de domaine et un utilisateur propre à un site. De cette manière, il pourra exécuter des commandes php. On commence par créer un groupe (GID 3001) : $ groupadd -g 3001 NOM_GROUPE On ajoute un utilisateur (on commence avec l'UID 3002) rattaché à ce groupe (GID 3001) et on crée son dossier en même temps dans le répertoire home : $ useradd -d /home/DOSSIER -m -u 3002 -g 3001 NOM_UTILISATEUR NB : pour chaque nouveau site (ou nom de domaine) à installer, il faudra incrémenter le numéro d'utilisateur (UID) : 3002, 3003, 3004, etc. Le groupe sera toujours 3001. Nous allons pouvoir utiliser ces informations dans la configuration ci-dessous. Insertion des données FTP dans MySQL On créée le compte FTP dans MySQL. Pour ce faire copiez les requêtes suivantes dans phpMyAdmin : INSERT INTO ftpgroup (groupname, members) VALUES ('NOM_GROUPE', 'NOM_UTILISATEUR'); INSERT INTO ftpuser (id, userid, passwd, uid, gid, homedir, shell, count, accessed, modified, LoginAllowed) VALUES ('', 'NOM_UTILISATEUR', ENCRYPT('MOTDEPASSE_EN_CLAIR'), '3002', '3001', '/var/www/DOSSIER/', '/bin/false', '0', '0000-00-00 00:00:00', '0000-00-00 00:00:00', 'true'); INSERT INTO ftpquotatotal (name, bytes_up_total) VALUES ('NOM_UTILISATEUR', 'QUOTA_MO'); Création des fichiers de configuration On commence par ouvrir le fichier de configuration locale de named : $ nano /etc/bind/named.conf.local Si vous souhaitez gérer les zones du nom de domaine directement sur le site de l'hébergeur, cette modification n'est pas nécessaire. Dans le cas contraire, vous y insérez les informations suivantes en bas du fichier : zone "DOMAINE.COM" { type master; file "/etc/bind/db.DOMAINE.COM"; forwarders {}; }; Vous enregistrez le fichier et créez le fichier du site : $ nano /etc/apache2/sites-available/DOMAINE.COM Vous copiez le code ci-dessous en apportant les modifications nécessaires : # VirtualHost DOMAINE.COM <VirtualHost IP_DU_SERVEUR:80> # Email admin ServerAdmin postmaster@DOMAINE.COM # Adresse du site ServerName www.DOMAINE.COM # Alias du site ServerAlias DOMAINE.COM # Chemin du site DocumentRoot /var/www/DOSSIER # Options du site <Directory /var/www/DOSSIER/> Options -Indexes FollowSymLinks Order allow,deny allow from all # Si besoin RewriteBase / </Directory> # Logs erreurs ErrorLog /var/log/apache2/DOMAINE.COM-error_log # Logs acces TransferLog /var/log/apache2/DOMAINE.COM-access_log # Droits modifs (suphp) SuexecUserGroup NOM_UTILISATEUR NOM_GROUPE </VirtualHost> Enregistrez le fichier et terminez en créant le fichier de configuration des DNS du site : $ nano /etc/bind/db.DOMAINE.COM Là aussi, si vous gérez les zones ci-dessous chez votre hébergeur de noms de domaine, inutile de vous en préoccuper. Il faudra indiquer l'IP du serveur dans les champs appropriés. Sinon, copiez le contenu ci-dessous et apportez les modifications nécessaires : $ttl 10800 @ IN SOA HOSTNAME_FQDN. postmaster.DOMAINE.COM. ( 2015020901 // A incrémenter d'un chiffre à chaque modif 21600 3600 604800 10800 ) IN NS DNS_1. IN NS DNS_2. IN MX 10 mail.DOMAINE.COM. IN A IP_DU_SERVEUR www IN A IP_DU_SERVEUR mail IN A IP_DU_SERVEUR smtp IN A IP_DU_SERVEUR pop IN A IP_DU_SERVEUR pop3 IN A IP_DU_SERVEUR imap IN A IP_DU_SERVEUR sql IN A IP_DU_SERVEUR mysql IN A IP_DU_SERVEUR DOMAINE.COM. IN TXT "v=spf1 ip4:IP_DU_SERVEUR ~all" Enregistrez le fichier et activez le site : $ a2ensite DOMAINE.COM Vous pouvez maintenant redémarrer les services : $ service apache2 restart $ service bind9 restart Pour tester la conformité de la configuration du domaine (doit vous retourner OK) : $ named-checkzone DOMAINE.COM /etc/bind/db.DOMAINE.COM Vous pouvez faire de même pour celle du serveur : $ named-checkzone HOSTNAME_FQDN /etc/bind/db.HOSTNAME.inv La dernière étape consiste à vous rendre dans votre console Online et d'ajouter le domaine aux DNS secondaires. Ajout d'un domaine et d'une adresse e-mail dans PostfixAdmin La première étape consiste à créer le dossier sur le serveur et lui donner les bons droits : $ mkdir -p /var/vmail/DOSSIER.COM $ chown -R vmail:vmail /var/vmail/DOMAINE.COM Ensuite, rendez-vous dans Postfixadmin et créez le domaine dans la section appropriée. Si vous souhaitez déléguer la gestion des e-mails à votre client, créez-lui un compte administrateur rattaché à ce domaine uniquement. Vous pouvez ensuite créer les adresses e-mails. Exemple de configuration d'un client e-mail Je vous montre en image un exemple de configuration que j'ai mis en place. Lorsque vous vous connecterez la première fois en POP ou en IMAP, vous devrez accepter le certificat. Il en sera de même lors du premier envoi d'un e-mail via SMTP. 24 - Mise en place des sauvegardes C'est la partie à ne pas oublier. En cas de crash d'une base de données ou d'une suppression accidentelle de fichiers, il faut pouvoir restaurer rapidement les données. Personnellement, j'utilise mes propres scripts pour sauvegarder le serveur. Je m'attache à faire un backup des sites, des bases de données et du système tous les jours. La sauvegarde des e-mails se fait toutes les semaines. Pour la petite info, il y a Backup-Manager qui est un très bon outil de sauvegarde automatique. Il est facilement configurable et semble avoir une très bonne réputation. 25 - Outils de monitoring Suite à quelques demandes, je rajoute deux outils de monitoring. Le premier pour surveiller l'était des services du serveur, le deuxième pour les logs. Installation de Monit Comme indiqué, il est important de surveiller les services du serveur. Monit est l'outil idéal pour le faire puisqu'il offre une interface web très pratique. C'est parti pour l'installation. $ aptitude install monit -y On peut ouvrir le fichier de configuration. La plupart des lignes étant commentées, plutôt que de cherche ligne ce qui doit être activé ou pas, je vous propose de placer notre configuration tout en bas du fichier. Ce serait plus pour s'y retrouver : $ nano /etc/monit/monitrc Voici comment j'ai configuré les paramètres. Libre à vous d'adapter selon vos besoins : ############################################################################## ## Configuration ############################################################################## set daemon 120 # 2 minutes set mailserver localhost set alert VOTRE_EMAIL set mail-format { from: postmaster@HOSTNAME_FQDN } set httpd port PORT_MONIT and allow VOTRE_LOGIN:VOTRE_MOTDEPASSE # Monitoring Apache 2 check process apache with pidfile /var/run/apache2.pid group root start program = "/etc/init.d/apache2 start" stop program = "/etc/init.d/apache2 stop" if cpu > 50% for 2 cycles then alert if cpu > 85% for 5 cycles then restart if 3 restarts within 5 cycles then timeout # Monitoring SSH check process sshd with pidfile /var/run/sshd.pid start program "/etc/init.d/ssh start" stop program "/etc/init.d/ssh stop" if failed port 1989 protocol ssh then restart if 5 restarts within 5 cycles then timeout # Monitoring MySQL check process mysql with pidfile /var/run/mysqld/mysqld.pid group mysql start program = "/etc/init.d/mysql start" stop program = "/etc/init.d/mysql stop" if failed unix "/var/run/mysqld/mysqld.sock" then restart if failed host 127.0.0.1 port 4712 then restart if 5 restarts within 5 cycles then timeout # Monitoring Bind check process named with pidfile /var/run/named/named.pid start program = "/etc/init.d/bind9 start" stop program = "/etc/init.d/bind9 stop" if failed host 127.0.0.1 port 53 type tcp protocol dns then alert if failed host 127.0.0.1 port 53 type udp protocol dns then alert if 5 restarts within 5 cycles then timeout # Monitoring Proftpd check process proftpd with pidfile /var/run/proftpd.pid start program = "/etc/init.d/proftpd start" stop program = "/etc/init.d/proftpd stop" if failed port 21 protocol ftp then restart if 5 restarts within 5 cycles then timeout # Monitoring Postfix check process postfix with pidfile /var/spool/postfix/pid/master.pid group vmail start program = "/etc/init.d/postfix start" stop program = "/etc/init.d/postfix stop" if failed port 587 protocol smtp then restart if 5 restarts within 5 cycles then timeout # Monitoring Dovecot check process dovecot with pidfile /var/run/dovecot/master.pid start program = "/etc/init.d/dovecot start" stop program = "/etc/init.d/dovecot stop" group vmail if failed host mail.DOMAINE.COM port 993 type tcpssl sslauto protocol imap for 5 cycles then restart if 3 restarts within 5 cycles then timeout # Monitoring spamassassin check process spamd with pidfile /var/run/spamd.pid group vmail start program = "/etc/init.d/spamassassin start" stop program = "/etc/init.d/spamassassin stop" if 5 restarts within 5 cycles then timeout if cpu usage > 85% for 5 cycles then alert if mem usage > 85% for 5 cycles then alert # Monitoring disque check device sda1 with path /dev/sda1 if space usage > 85% then alert group system NB : si vous avez installé iptables, pensez à ajouter une règle pour le numéro de port que vous avez choisi. Enregistrez le fichier et (re)démarrez le service : $ service monit restart Vous pouvez accéder à l'inteface web (après avoir saisi votre login et votre de passe) : http://IP_DU_SERVEUR:PORT_MONIT/ Comme le montre l'image ci-dessous, vous obtenez un récapitulatif des services surveillés. Un clic sur le nom de l'un d'eux vous amènera sur une page un peu plus détaillée. Installation de Logwatch Logwatch va surveiller les logs du serveur et envoyer un e-mail récapitulatif des erreurs tous les jours. $ aptitude install logwatch -y Entrez dans le fichier de config : $ nano /usr/share/logwatch/default.conf/logwatch.conf Et indiquez votre adresse e-mail : MailTo = VOTRE_EMAIL Enregistrez le fichier. NB : un dernier point important, rendez-vous dans votre console Online et activez les services de monitoring que vous souhaitez pour être alerté par e-mail en cas d'arrêt d'un service. 26 - Quelques astuces La configuration du serveur est à présent terminée. Avant de vous expliquer comment gérer les noms de domaine, voici une liste de tâches à affectuer pour vérification. Pour modifier la rotation des logs : $ nano /etc/logrotate.conf Pour corriger une erreur aperçue dans les logs : $ nano /etc/php5/cli/conf.d/ming.ini Remplacez la première ligne par : ;configuration for php MING module Enregistrez le fichier. Si vous souhaitez être alerté par mail lorsqu'une connexion se fait avec le compte root (ce qui normalement n'est pas possible), éditez le fichier suivant : $ nano /root/.bashrc En bas du fichier, ajoutez : # Alerte login root echo 'Connexion Root le ' `date` `who` | mail -s `hostname` Shell Root de `who | cut -d"(" -f2 | cut -d")" -f1` VOTRE_EMAIL On en profite pour spécifier l'éditeur par défaut en ajoutant : # Editeur par defaut export EDITOR=nano Pour vous assurer que votre serveur est sain, lancez de temps en temps cette commande : $ lsattr -R / 2>/dev/null | grep 's---ia--------' Si aucun résultat n'est retourné, c'est qu'à priori tout est OK.
  2. Bonjour à tous, Alors aujourd’hui on va voir comment installer un antivirus gratuit pour Windows Serveur 2012 et Windows Serveur 2012 R2. Comme vous l’avez peut-être remarquer, les antivirus pour stations de travail ne fonctionnent pas sous Windows Serveur 2012, et c’est normal car le système est différent et ne correspond pas aux mêmes usages. Mais nous sommes en 2014, et Microsoft ne propose plus les éditions Home Server qui elles étaient compatibles avec les antivirus pour stations de travail et quand vous êtes comme moi et que vous avez un serveur à la maison ça coince. Soit vous dépenser plus de 100€ par an dans une protection antivirus, soit vous téléchargez illégalement un logiciel contrefait, soit vous suivez cette procédure Installation de Microsoft Security Essentials : Alors dans un premier temps, téléchargez Microsoft Security Essentials en version 64 bits en cliquant sur le lums ci-dessous : Une fois que vous avez votre avez votre exécutable, faite un clic droit dessus et cliquez sur propriétés : Ensuite, activez le mode de compatibilité pour Windows 7 et cochez la case pour que le programme se lance en tant qu’administrateur : Maintenant, faite un Shift + Clic droit dans le dossier ou se trouve l’exécutable et cliquez sur ouvrir une fenêtre de commandes ici : Maintenant tapez la commande suivante dans l’invite de commandes : mseinstall /disableoslimit Et voilà, vous n’avez plus qu’a suivre la procédure d’installation du logiciel. Vous avez maintenant un antivirus gratuit pour Windows Serveur 2012 et ce aux frais de la princesse Pour les superstitieux, voici des screenshots de mes deux Windows Serveur 2012 Standard (dont 1 avec l’update R2). Tout est pleinement fonctionnel Microsoft Security Essentials sur Windows Serveur 2012 Standard Microsoft Security Essentials sur Windows Serveur 2012 R2 Standard Bonus : L’antivirus gratuit Immunet s’installe lui aussi mais le système détecte des problèmes de compatibilité et il est livré avec un peu de pub. Choisissez celui que vous préférez …
  3. dormir manger et....^^

  4. Présentation d´un script shell personnel permettant de mettre en place une sauvegarde de données grâce au fameux outil rsync, via Internet, sur un schéma de snapshots. Autrement dit, d’images des données à un instant précis. Le script permet la rotation des sauvegardes et une distribution non linéaire des plus anciennes. Le contexte Pour stocker mes précieuses données numériques personnelles j’utilise un NAS, basé sur FreeNAS, dont on a vu tout le processus de configuration Pour sauvegarder ces mêmes données dans un lieu physiquement séparé j’utilise un second NAS situé 500km plus loin. Entre les deux il y a … des lignes téléphoniques de particuliers, toutes simples, avec les limitations d’upload que cela implique : soit à peut près 100ko/s maximum. Le système d’exploitation est FreeNAS, dérivé de FreeBSD, ce script est donc un script bash, il devrait tourner sans problème à priori sur tout système Unix, Linux et dérivés. Le principe “snapshots-like”, l’utilisation de liens en durs (on va en reparler), et la suppression partielle des anciennes sauvegardes sont inspirés des scripts et informations de François Scheurer, Mike Rubel et Michael Jakl. Philosophie du script Tous les possesseurs de Mac connaissent Time Machine, cet utilitaire de sauvegarde extrêmement bien conçu et à ma connaissance malheureusement sans équivalent sous Windows. Et bien en gros ce script de sauvegarde fonctionne de façon similaire, la jolie interface graphique en moins. Le script crée quotidiennement une image des données sources sur la machine de destination, ainsi on a sur le NAS de sauvegarde un dossier par jour qui contient l´image complète de la source. Pour restaurer un fichier ou un dossier il suffit de choisir la date voulue et on retrouve toute l’arborescence telle qu’elle était à ce moment là. Les sauvegardes sont numérotées : 000 pour la plus récente puis 001 pour celle de la veille, 002 pour l’avant veille, etc…il y a donc une rotation quotidienne des plus anciennes en ajoutant 1 à tous les numéros de dossier. Le script maintient également un dossier “courante” qui est en fait un lien symbolique vers le dossier de la dernière sauvegarde valide. Après un certain temps, avoir une sauvegarde par jour ne sert plus à grand chose, l’idée est donc de supprimer quelques une des plus anciennes sauvegardes en partant du principe que plus elle sont anciennes et moins on a de chance d’en avoir besoin. Donc plus ça va et plus on les espace : une tous les 10 jours, puis 30 jours, etc… Le fonctionnement en détail Structure générale Je vous ai dit que l’on faisait une image des données sources par jour, alors évidemment on ne va pas transférer l’ensemble des données tous les jours. Rsync dispose d’une option magique (–link-dest=”reference”) qui compare les fichiers du dossier source avec le dossier “reference”, si l’un est manquant il l’envoi dans la destination mais si le fichier existe dans la référence alors il créé simplement un lien en dur dans la destination vers celui ci. Ainsi pas de transfert de tout ce qui existe déjà ! Sauf que, problème ! Si un utilisateur renomme son dossier “Images” en “Photos”, rsync ne le reconnaît pas dans le dossier de reference et on aura peut être 100, 300, 500Go ou plus à renvoyer vers la destination… à 100ko/s je vous laisse faire le calcul. :(Pour éviter ce problème de fichiers ou dossiers renommés, lié à la distance entre les NAS il existe un petit patch qui ajoute à rsync l’option –detect-renamed. –detect-renamed permet donc de repérer et d’éviter cela en utilisant simplement les données déjà à destination pour faire l’image du jour. Du coup je n’utilise pas l’option –link-dest. Comme finalement on n’utilisera pas l’option link-dest, afin d’avoir les liens en durs vers les fichiers préexistant on va donc commencer par faire une copie complète avec des liens puis on mettra celle-ci à jour. Pour fonctionner correctement en cas de renommage de dossier ou de déplacement de fichier dans la source vers un nouveau dossier, detect-renamed doit avoir dans la destination l’arborescence identique à la source. Si j’ajoute un contrôle d’unicité au lancement afin de ne pas se retrouver avec 2 scripts qui font la même chose en parallèle, ce qui collerai un gros bazar, ainsi qu’un retour d’erreur par mail à a fin, on obtient en gros cette structure : Structure de base du script Shell # # Y'a t'il un script précédent encore lancé ? # -> si oui on le supprime # #Copie en liens durs de la sauvegarde "courante" vers le dossier 000 #Mise à jour de l'arborescence de la destination à partir de la source # -> si erreur dans la mise à jour, on stoppe, envoi mail #Transfert des fichiers modifiés # -> si erreur dans le transfert, on stoppe, envoi mail # #Si tout c'est bien terminé on effectue la rotation : 000 devient 001, 001->002, etc... #Création du lien pour dire que la nouvelle sauvegarde courante est la 001 #Suppression sélective de certaines sauvegardes anciennes #Envoi de mail et enregistrement du log # A cela s’ajoute la contrainte du débit en upload limité, du coup en cas de gros volume à transférer il se pourrait qu’au bout de 24h la sauvegarde de la veille ne soit pas terminée. Pour traiter ce cas on ajoute un suffixe _incomplete au nom de dossier et on utilise cette sauvegarde comme nouvelle référence pour la suivante, ainsi le travail effectué n’est pas perdu. Le suffixe permettra à la fonction de suppression de ne pas garder la sauvegarde longtemps car elle n’a pas d’interêt. De plus comme l’upload est limité et toujours en cas de gros volume il peut être contraignant de saturer la ligne téléphone avec la sauvegarde. J’utilise donc un autre patch de rsync : –stop-at. Il permet d’indiquer à rsync de se fermer à une heure prévue. Ainsi de minuit à 8h j’upload presque sans limitation, à 8h rsync se ferme, le script le détecte et relance une instance de rsync avec un débit limité à 50% environ jusqu’à 23h50. Contrôle de l’unicité Au lancement, le script créé un fichier “flag” qui sert à enregistrer les différents retours texte en cas de succès ou d’échec. A la fin, ce fichier est copié dans les logs puis supprimé. Le script teste donc si un fichier flag est déjà présent, trahissant ainsi soit une autre instance de script, soit un plantage ou arrêt système ayant empêché le script précédent de se terminer correctement. Dans le premier cas on ferme le rsync précédent, dans le second on supprime la sauvegarde précédente partiellement échouée et on reprend sur des bases saines. Ceci est géré par cette partie du script : Contrôle de l'unicité Shell #Si il y a déjà un fichier flag (anormal)=> la synchro de la veille n'est soit pas terminée (mauvaise programmation heure de fin) ou stoppée due à plantage ou arrêt système) if [ -e $flag ]; then pkill -SIGUSR1 -f -u $USER_CIBLE rsync #tente de fermer Rsync avec le signal SIGUSR1 (le signal est testé par le script de la veille et lui signal de se fermer également) sleep 120 #Tempo 120 secondes if [ -e $flag ]; then #Re-teste présence fichier flag. Si oui c'est que le script précédent n etait plus lance => il y a eu plantage ou arret de la machine l hébergeant date_veille=$(head -n 1 $flag | cut -c15-) #récupère la date sauvegarde interrompue (dans 1ere ligne du fichier flag) echo -e 'n!!!!!!!!!!nScript du' $(date +%Y-%m-%d) >> $flag echo -e 'Suppression du dossier : 000_'$date_veille >> $flag rm -r $CIBLE/000_$date_veille >> $flag 2>&1 #supprime le dossier 000_ dans lequel la précédente sauvegarde a echoue envoi_mail 2 #mail sauvegarde non terminée cause arrêt NAS ou plantage script mv $flag $DOSS_SCRIPT/log/$date_veille-erreur$EXTENSION #déplace le fichier de flag dans le dossier des logs et le renomme fi fi Transfert des fichiers, analyse du code retour Pour s’assurer du bon déroulement des étapes critiques de la sauvegarde, à chaque exécution de rsync le code de retour est analysé. Parmis les codes remarquables citons : 0 : code signalant que rsync s’est terminé normalement 30 : signalant un arrêt sur timeout => peut être généré par l’option –stop-at, donc on s’en servira pour traiter le cas de l’arrêt programmé à heure fixée 19 : signale un arrêt suite à reception du signal SIGUSER1. C’est ce signal que l’on envoi avec la commande pkill (voir l’extrait de code ci-dessus) si l’instance précédente n’est pas fermée. Le script précédent peut ainsi savoir qu’un nouveau est lancé. Mise en place et paramétrage du script Script complet Voici le script au complet, j’ai essayé de largement commenter le tout, cela sera bien plus lisible en le collant dans un éditeur comme Notepad++ ou autre. NOTE : Mise à jour du script le 14 octobre 2014 avec une correction d’un bug au niveau du dossier des transferts partiels Script de sauvegarde rsync Shell #!/bin/bash # Version 3.2 - sauvegarde_nuit # #Update depuis 3.1 : # - déplacement "tempRsync" (dossier des incomplets) hors arborescence sauvegardée pour le préserver du --delete-excluded # - suppression du dossier "tempRsync" en cas d'erreur lors de la synchro. Non touché en cas d'erreur autre (ex : connexion impossible) # - amélioration test après une fin par time-out pour mieux détecter un run-time terminé (sort souvent en 3eme ligne avant #fin de fichier mais parfois en 2ème ligne, donc ajout d'un "ou" dans le test # - Suppression de l'option de compression -z (compression désormait assurée au niveau de ssh) # #-------------------------------------------------------------------------------------------------------------------------------------------# # SYNCHRONISATION DISTANTE DES DONNES PAR RSYNC ENTRE 2 NAS # # # #Créé un fichier "flag", témoin de son lancement, puis démarre une sauvegarde miroir depuis une machine distante vers celle qui l'héberge # #Lors du démarrage, il contrôle la présence du fichier flag, si celui ci est présent c'est qu'une synchro rsync est déjà en cours, # #on la stoppe avec le signal SIGUSR1 (code retour 19 de rsync). Ceci fermera également le script qui l'a lancé # # # #Le script lance ensuite un "dry run" pour tester la connexion et lister le volume de données à envoyer. Les stats sont envoyées dans le # #fichier de flag. Si tout s'est bien passé on lance la synchronisation réelle : d'abord mise à jour des dossiers puis des fichiers # # # #En cas d'erreur de rsync ou de sauvegarde de la veille non terminée, on envoie un mail pour alerter l'administrateur # #En cas de bonne exécution, le fichier flag est transformé en fichier log dans le dossier de la sauvegarde # # # #Le script utilise une version patchée de rsync incluant les options --detect-renamed pour ne pas retransférer des fichiers renommés ou # #déplacés et --stop-at pour donner une heure d'arrêt de rsync. La version patchée de rsync doit être installée sur les 2 machines # #-------------------------------------------------------------------------------------------------------------------------------------------# #VARIABLES ET CONFIGURATION #********************************************************************************** #Configuration : LIMITATION_JOUR=1 #Mettre à 1 pour activer une limitation de la bande passante différente en journée, 0 = pas de différence DEBUT_JOUR="08:00" #Heure de début de limitation pour le jour, format hh:mm impératif BP_LIMITE_JOUR=60 #Bande passante maximale en ko/s. 0 = pas de limite FIN_SAUVEGARDE="23:50" #Heure de fin de la sauvegarde, format hh:mm (avant l'heure de début de la suivante) BP_LIMITE=100 #Bande passante maximale en ko/s. 0 = pas de limite MAIL_SUCCES=0 #Mettre à 0 pour ne pas recevoir le rapport de sauvegarde par mail en cas de succès. Aucune influence sur les rapports d'erreur DOSS_SCRIPT="/mnt/pool_sauvegarde/Scripts" #Dossier abritant ce script NOM_FLAG="flag" #Nom du fichier "flag" (sans extension) EXTENSION=".log" #Extension à ajouter aux fichiers logs générés DOSSIER_SOURCE="/mnt/Tank/" #Dossier source à sauvegarder NAS_DISTANT=xxx.xxx.xxx.xxx #Adresse du serveur source PORT=22 #Port du service ssh serveur source USER="User" #Nom d'utilisateur source USER_MAIL="user@monmail.com" #E-mail pour la reception des rapports CIBLE="/mnt/pool_sauvegarde/Sauvegardes" #Dossier de destination des sauvegardes (un dossier par date est créé ensuite à l'intérieur) USER_CIBLE="UserSauvegarde" #Nom d'utilisateur serveur destination EXCLUS="/mnt/pool_sauvegarde/Scripts/liste.txt" #Liste des fichiers et dossiers à exclure de la sauvegarde #FIN DES VARIABLES ET DE LA CONFIGURATION, NE PAS MODIFIER PLUS BAS #******************************************************************************************************************************************* # La fonction envoi_mail gère l'ajout des textes explicatifs et l'envoi des mails aux utilisateurs # #Le mail envoyé dépend de l'argument passé à cette fonction : # 1 = Synchro précédente non terminée # 2 = Fin anormale de la synchro précédente (plantage script ou panne électrique) # 3 = Erreur lors du premier rsync d'analyse # 4 = Erreur lors du rsync de sauvegarde # 5 = Erreur lors du rsync de mise à jour arborescence # 6 = Le script a ete stoppé par une nouvelle occurence du script => mauvaise programmation des heures # # 9 = Sauvegarde terminée avec succès #-------------------------------------------------------------------------------------------------------------------- function envoi_mail() { if [ $1 -eq 1 ]; then echo -e 'n*** ATTENTION ! ***' >> $flag echo -e 'cette sauvegarde distante n a pas pu être complétée dans les dernières 24hn' >> $flag echo -e 'aide :' >> $flag echo -e 'number of files = nombre total de fichiers dans la source' >> $flag echo -e 'number of files transferred = nombre de fichiers qu il y avait à envoyer : absent -ou modifiés- de la destination' >> $flag echo -e 'total transferred size = Volume des données qu il y avait à envoyern' >> $flag mail -s 'NAS Caution: Sauvegarde distante non terminée' $USER_MAIL < $flag elif [ $1 -eq 2 ]; then echo -e 'n*** ATTENTION ! ***' >> $flag echo -e 'cette sauvegarde distante n a pas été terminée correctement' >> $flag echo -e 'Cela peut être du à un arrêt du NAS cible (hebergeant le script et les sauvegardes), une panne électrique ou un plantage du scriptn' >> $flag echo -e 'aide :' >> $flag echo -e 'number of files = nombre total de fichiers dans la source' >> $flag echo -e 'number of files transferred = nombre de fichiers qu il y avait à envoyer : absent -ou modifiés- de la destination' >> $flag echo -e 'total transferred size = Volume des données qu il y avait à envoyern' >> $flag mail -s 'NAS Caution: Sauvegarde distante interrompue' $USER_MAIL < $flag elif [ $1 -eq 3 ]; then echo -e 'n ==> ERREUR RSYNC LORS DU DRY-RUN, ARRET DU SCRIPT, erreur Rsync n°'$retval >>$flag mail -s 'NAS Warning : ECHEC DE SAUVEGARDE DISTANTE LORS DE L ANALYSE' $USER_MAIL <$flag elif [ $1 -eq 4 ]; then echo -e 'n ==> ERREUR RSYNC LORS DE LA SYNCHRO, ARRET DU SCRIPT. Erreur n°'$retval >> $flag mail -s 'NAS Warning : ECHEC DE SAUVEGARDE DISTANTE' $USER_MAIL <$flag elif [ $1 -eq 5 ]; then echo -e 'n ==> ERREUR RSYNC LORS DE LA MISE A JOUR DE L ARBORESCENCE, ARRET DU SCRIPT. Erreur n°'$retval >> $flag mail -s 'NAS Warning : ECHEC DE SAUVEGARDE DISTANTE' $USER_MAIL <$flag elif [ $1 -eq 6 ]; then echo -e 'n*** ATTENTION ! ***' >> $flag echo -e 'Cette sauvegarde a été interrompue suite au demarrage d une autre sauvegarde' >> $flag echo -e 'VERIFIEZ LA CONFIGURATION DE L HEURE DE FIN QUI DOIT ETRE PROGRAMMEE AVANT LE DEBUT DE LA SUIVANTE' >> $flag mail -s 'NAS Warning : ECHEC SAUVEGARDE, VERIFIEZ LA PROGRAMMATION' $USER_MAIL <$flag elif [ $1 -eq 9 ]; then if [ $MAIL_SUCCES -ne 0 ]; then #Envoie le mail si MAIL_SUCCES n'est pas 0 dans la conf echo 'Sauvegarde terminée avec succès' >> $flag mail -s 'NAS : Sauvegarde distante réussie' $USER_MAIL <$flag fi fi } # La fonction copie_liens permet de créer au début de la sauvegarde l'image précedente en faisant une copie de la #sauvegarde N-1 par des liens en durs, cette copie sera ensuite exploitée par rsync pour la mettre à jour. # L'utilisation de ce système à la place de l'option --link-dest de rsync permet d'utiliser l'option --detect-renamed de #rsync #---------------------------------------------------------------------------------------------------------------------- function copie_liens() { cp -alL $CIBLE/courante $CIBLE/000_$date_jour 2>> $flag #copie (liens durs) de la sauvegarde courante. Sert de base et est mise à jour ensuite echo -e 'nCopie image courante terminée...' >> $flag } # La fonction lien_courante permet de mettre à jour le lien symbolique "courante" sur la sauvegarde distante # qui pointe vers la sauvegarde actuelle (c'est l'image courante) # La fonction reçoit un argument qui est le dossier à lier au dossier "courante" #---------------------------------------------------------------------------------------------------------------------- function lien_courante() { rm -rf $CIBLE/courante 2>> $flag #Suppression du dossier de la sauvegarde courante... ln -s $CIBLE/$1 $CIBLE/courante 2>> $flag #... et recréation (en fait un simple lien vers la sauvegarde du jour) } # La fonction rotation_sauvegardes permet d'incrémenter le numéro des dossiers contenant les sauvegardes en conservant la date, par # exemple : 005_2012-12-12 est renommé en 006_2012-12-12. La sauvegarde numero 999 est supprimée. # Cette fonction supprime également les sauvegardes incompletes (nom de dossier se terminant par _incomplete) à partir de la 25eme sauvegarde #---------------------------------------------------------------------------------------------------------------------- function rotation_sauvegarde() { if ls $CIBLE/999_* > /dev/null 2>&1; then #suppression de la sauvegarde numéro 999 si elle existe echo "suppression de la sauvegarde 999" >> $flag rm -rf $CIBLE/999_* 2>> $flag fi for i in {999..0} #boucle de 999 à 0 do ichaine=$(printf "%.3d" $i) #génère le numéro de sauvegarde sur 3 chiffres if [ $i -gt 25 ] && find $CIBLE/${ichaine}_*_incomplete -maxdepth 0 > /dev/null 2>&1; then #à partir de la 25eme sauvegarde (et après) on teste si c'est une incomplète echo "suppression de la sauvegarde incomplète ${ichaine}" >> $flag rm -r $CIBLE/${ichaine}_*_incomplete 2>> $flag #si c'est une incomplète, on la supprime fi if ls $CIBLE/${ichaine}_* > /dev/null 2>&1; then #test de l'existence de la sauvegarde n for k in $CIBLE/${ichaine}_*; do #si existe on récupère son nom complet (avec chemin et date) let j=$i+1 #génére le numéro n+1 sur 3 chiffres j=$(printf "%.3d" $j) k=${k#${CIBLE}/} #supprime la partie chemin du nom de sauvegarde mv $CIBLE/$k $CIBLE/${j}${k#$ichaine} 2>> $flag #renomme la sauvegarde n en n+1 done fi done } # La fonction suppression sauvegarde permet de supprimer les anciennes sauvegardes en en gardant 1 seule par interval défini. Elle reçoit # 3 paramètres : une butée haute, une butée basse et un interval (dans cet ordre). La série entre les deux butées est divisées en intervals # de la longueur définie par le paramètre interval puis une seule sauvegarde est conservée dans celui ci. #Note : si la longueur de la série entre les butées n'est pas divisible par l'interval, le reste ne correspondant pas à un interval complet est #ignoré (ex : de 100 à 75 par pas de 10 : on garde une sauvegarde entre 100 et 91, une entre 90 et 81 mais rien n'est supprimé entre 80 et 75 #----------------------------------------------------------------------------------------------------------------------------------------------- function suppression_sauvegardes() { let start=$1 # initialise la première boucle avec la butée haute passée en paramètre let stop=$start-$3+1 # initialise la première boucle avec le calcul de stop (start-pas+1) let fin=$2 # récupère la butée basse en paramètre n°2 while [ $stop -ge $fin ] # Cette boucle génère les bornes entre les butées hautes, basses et avec l'interval passé en paramètre do f=0 #initialise le flag for ((i=$start;i>=$stop;--i)) #boucle entre les bornes start - stop do ichaine=$(printf "%.3d" $i) if ls $CIBLE/${ichaine}_* > /dev/null 2>&1; then #teste si on a une sauvegarde qui porte ce numéro if [ $f -eq 0 ]; then #si on en a une on regarde si c'est la première let f=1 #si oui, on positionne le flag pour dire qu'on en a une else k=$(find $CIBLE/${ichaine}_* -maxdepth 0) echo "suppression de la sauvegarde "${k#${CIBLE}/} >> $flag #si ce n'est pas la première, on la supprime rm -r $CIBLE/${k#${CIBLE}/} 2>> $flag fi fi done let start=$stop-1 #calculs prochaine bornes let stop=$start-$3+1 done } #La fonction finalisation permet d'effectuer les dernières opérations communes à la fin de la sauvegarde normale : #Ces opérations sont la rotation des sauvegardes puis la mise à jour du lien vers la sauvegarde courante et enfin la #gestion de la suppression des plus anciennes sauvegardes selon une répartition spécifique et variable dans le temps #----------------------------------------------------------------------------------------------------------------------------------------------- function finalisation() { echo -e 'nSauvegarde terminée à '$(date +%H:%M:%S)'nRotation des sauvegardes...' >> $flag rotation_sauvegarde #Effectue le renommage de toutes les sauvegardes n en n+1 (rotation) echo 'Rotation terminée, effacement et recréation du dossier de sauvegarde courante...' >> $flag lien_courante 001_$date_jour #Suppression du dossier de la sauvegarde courante et recréation (en fait un simple lien vers la sauvegarde du jour) suppression_sauvegardes 1000 401 200 #Suppression de quelques anciennes sauvegardes avec une répartition variable selon l'ancienneté suppression_sauvegardes 400 131 30 suppression_sauvegardes 130 41 10 envoi_mail 9 mv $flag $DOSS_SCRIPT/log/$date_jour$EXTENSION #...déplace et renomme le fichier flag dans les logs } #La fonction finalisation_incomplete permet d'effectuer les dernières opérations communes à la fin d'une sauvegarde incomplete : #renommage du dossier de sauvegarde avec ajout du suffixe "incomplete", rotation des sauvegardes puis la mise à jour du lien vers la sauvegarde courante #----------------------------------------------------------------------------------------------------------------------------------------------- function finalisation_incomplete() { echo -e 'nSauvegarde incomplete terminée à '$(date +%H:%M:%S)'nRotation des sauvegardes...' >> $flag mv $CIBLE/000_$date_jour $CIBLE/000_${date_jour}_incomplete rotation_sauvegarde echo 'Rotation terminée, effacement et recréation du dossier de sauvegarde courante...' >> $flag lien_courante 001_${date_jour}_incomplete #Mise à jour de la sauvegarde courante envoi_mail 1 mv $flag $DOSS_SCRIPT/log/$date_jour-incomplete$EXTENSION #déplacement fichier flag en log avec spécification incomplete } #La fonction finalisation_erreur permet d'effectuer les dernières opérations communes à la fin d'une sauvegarde qui se termine en erreur : #renommage du dossier de sauvegarde avec ajout du suffixe "incomplete", rotation des sauvegardes puis la mise à jour du lien vers la sauvegarde courante #----------------------------------------------------------------------------------------------------------------------------------------------- function finalisation_erreur() { echo -e 'nErreur d execution à '$(date +%H:%M:%S)'nSuppression du dossier 000_'$date_jour >> $flag rm -r $CIBLE/000_$date_jour >> $flag 2>&1 #supprime le dossier 000 dans lequel on faisait la sauvegarde if [ $1 -eq 4 ] && [ -e $DOSS_SCRIPT/tempRsync ]; then #si erreur lors de la synchro (1er argument = 4) on supprime aussi le dossier echo -e 'nSuppression du dossier tempRsync' >> $flag #des incomplets rsync rm -r $DOSS_SCRIPT/tempRsync fi envoi_mail $1 #envoi du mail selon le numéro d'erreur reçu en argument mv $flag $DOSS_SCRIPT/log/$date_jour-erreur$EXTENSION #déplace le fichier de flag dans le dossier des logs et le renomme } #PROGRAMME PRINCIPAL, contrôle l'état actuel, prépare le dossier de sauvegarde, lance une analyse (dry-run rsync), #puis copie l'arborescence des dossiers (sans supprimer les anciens) afin de permettre le bon fonctionnement de --detect-renamed #en cas de fichiers déplacés ou dossiers renommés et enfin lance la sauvegarde effective des fichiers. #Inclus le contrôle des codes retour des fonctions principales pour s'assurer de la bonne exécution. #---------------------------------------------------------------------------------------------------------------------- flag=$DOSS_SCRIPT/$NOM_FLAG$EXTENSION #définition du fichier de flag SOURCE=$USER@$NAS_DISTANT:$DOSSIER_SOURCE #et de la source #Si il y a déjà un fichier flag (anormal)=> la synchro de la veille n'est soit pas terminée (mauvaise programmation heure de fin) ou stoppée due à plantage ou arrêt système) if [ -e $flag ]; then pkill -SIGUSR1 -f -u $USER_CIBLE rsync #tente de fermer Rsync avec le signal SIGUSR1 (le signal est testé par le script de la veille et lui signal de se fermer également) sleep 120 #Tempo 120 secondes if [ -e $flag ]; then #Re-teste présence fichier flag. Si oui c'est que le script précédent n etait plus lance => il y a eu plantage ou arret de la machine l hébergeant date_veille=$(head -n 1 $flag | cut -c15-) #récupère la date sauvegarde interrompue (dans 1ere ligne du fichier flag) echo -e 'n!!!!!!!!!!nScript du' $(date +%Y-%m-%d) >> $flag echo -e 'Suppression du dossier : 000_'$date_veille >> $flag rm -r $CIBLE/000_$date_veille >> $flag 2>&1 #supprime le dossier 000_ dans lequel la précédente sauvegarde a echoue envoi_mail 2 #mail sauvegarde non terminée cause arrêt NAS ou plantage script mv $flag $DOSS_SCRIPT/log/$date_veille-erreur$EXTENSION #déplace le fichier de flag dans le dossier des logs et le renomme fi fi date_jour=$(date +%Y-%m-%d) #Enregistrement date du jour #Effacement et reCréation du fichier de flag : echo 'SAUVEGARDE DU '$date_jour > $flag #NE PAS MODIFIER CETTE LIGNE #Création du dossier de sauvegarde du jour : on recopie en liens l'image courante : copie_liens #on commence par un lancement de rsync en mode dry run pour lister dans le fichier de flag les fichiers à synchroniser (uniquement pour les statistiques) echo -e 'Début analyse du volume à '$(date +%H:%M:%S) >> $flag echo -e 'Rapport analyse, à synchroniser ce soir :n----------------------------------------------' >> $flag $DOSS_SCRIPT/rsync -ahzn -e "ssh -p "$PORT --stats --timeout=60 --delete --exclude-from=$EXCLUS $SOURCE $CIBLE/000_$date_jour >> $flag 2>&1 retval=$? #enregistre le code retour de rsync if [ $retval -ne 0 ]; then #contrôle du code retour #si erreur (clés ssh, connexion, serveur distant éteind, indisponible, ...) : on finalise et on quitte finalisation_erreur 3 exit fi #Copie de l'arborescence des dossiers uniquement (ordre des option --includes/--exclude important, pas de --delete) echo -e 'nDébut mise à jour arborescence à '$(date +%H:%M:%S) >> $flag $DOSS_SCRIPT/rsync -ahz -e "ssh -p $PORT" --timeout=60 --exclude-from=$EXCLUS --include='*/' --exclude='*' $SOURCE $CIBLE/000_$date_jour >> $flag 2>&1 retval=$? #enregistre le code retour de rsync if [ $retval -ne 0 ]; then #contrôle du code retour #si erreur (clés ssh, connexion, serveur distant éteind, indisponible, ...) : on finalise et on quitte finalisation_erreur 5 exit fi echo -e 'Mise à jour arborescence terminée à '$(date +%H:%M:%S) >> $flag #Lancement de la synchro réelle : if [ $LIMITATION_JOUR -ne 0 ]; then #Si débit different pour le jour on règle l'heure de fin en conséquence heure_fin=$DEBUT_JOUR else heure_fin=$FIN_SAUVEGARDE fi echo -e 'nnDébut de sauvegarde à '$(date +%H:%M:%S) >> $flag echo -e 'Rapport de sauvegarde :n----------------------------------------------' >> $flag $DOSS_SCRIPT/rsync -ahz -e "ssh -p $PORT" --stats --delete --delete-excluded --detect-renamed --timeout=60 --bwlimit=$BP_LIMITE --stop-at=$heure_fin --partial --partial-dir="tempRsync" --exclude-from=$EXCLUS $SOURCE $CIBLE/000_$date_jour >> $flag 2>&1 retval=$? #enregistrement et contrôle du code retour if [ $retval -eq 0 ]; then #si rsync est quitté normalement, terminé avant l'heure maxi, déroulement normal... finalisation #on appelle la fonction de finalisation exit elif [ $retval -eq 19 ]; then #si rsync est quitté avec le code 19 (SIGUSR1) alors finalise et quitte le script car une nouvelle occurence s'est lancée... finalisation_erreur 6 exit elif [ $retval -eq 30 ]; then #si rsync est quitté avec un code 30 (timeout) on analyse si c'est l'heure de fin ou une autre erreur if [ "$(tail -n -3 $flag | head -n 1)" = "run-time limit exceeded" ] || [ "$(tail -n -2 $flag | head -n 1)" = "run-time limit exceeded" ]; then #lecture 3ème ou 2ème ligne en partant de la fin de flag, si c'est bien une fin par run-time terminé et... if [ $LIMITATION_JOUR -ne 0 ]; then #...Si on a programmé un débit different pour la suite echo -e 'nFin de sauvegarde de nuit à '$(date +%H:%M:%S) >> $flag #on l'écrit et cela se poursuivra dessous else #Sinon la sauvegarde est terminée et elle est incomplete finalisation_incomplete #on finalise (renommage, rotation, lien courante) exit fi else #si on a eu une erreur 30 mais que c'est inattendu, c'est un vrai timeout => erreur finalisation_erreur 4 exit fi elif [ $retval -ne 0 ]; then #si on a une erreur autre, on finalise et on quitte finalisation_erreur 4 exit fi #Lancement de la sauvegarde de jour si on a pas quitté le script au dessus echo -e 'nDebut de la sauvegarde de jour' >> $flag $DOSS_SCRIPT/rsync -ahz -e "ssh -p $PORT" --stats --delete --delete-excluded --detect-renamed --timeout=60 --bwlimit=$BP_LIMITE_JOUR --stop-at=$FIN_SAUVEGARDE --partial --partial-dir="tempRsync" --exclude-from=$EXCLUS $SOURCE $CIBLE/000_$date_jour >> $flag 2>&1 retval=$? if [ $retval -eq 0 ]; then #si rsync est quitté normalement, terminé avant l'heure maxi, déroulement normal... finalisation #on appelle la fonction de finalisation exit elif [ $retval -eq 19 ]; then #si rsync est quitté avec le code 19 (SIGUSR1) alors finalise et quitte le script car une nouvelle occurence s'est lancée... finalisation_erreur 6 exit elif [ $retval -eq 30 ]; then #si rsync est quitté avec un code 30 (timeout) on analyse si c'est l'heure de fin ou une autre erreur if [ "$(tail -n -3 $flag | head -n 1)" = "run-time limit exceeded" ] || [ "$(tail -n -2 $flag | head -n 1)" = "run-time limit exceeded" ]; then #Si c'est bien l'heure de fin, c'est une incomplète finalisation_incomplete #on finalise (renommage, rotation, lien courante) exit else #si on a eu une erreur 30 mais que c'est inattendu, c'est un vrai timeout => erreur finalisation_erreur 4 fi elif [ $retval -ne 0 ]; then #si on a une erreur autre, on finalise et on quitte finalisation_erreur 4 exit fi Le script est prévu pour être exécuté via une tâche cron une seule fois par jour et ce sur la machine hébergeant les sauvegardes, cela me semblais plus robuste pour la création des liens, la rotation et suppression des sauvegarde en cas de coupure internet entre les machines. Ici il est sur un pool dédié contenant 2 dossiers : Scripts et Sauvegardes. Script héberge le script et les logs, Sauvegardes, l’ensemble des sauvegardes. Bien sûr vous pouvez modifier tout cela dans les paramètres. Version patchée de rsync ATTENTION : le script en l’état utilise 2 options de rsync qui n’existent pas dans la version “officielle” actuelle. Il s´agit de –detect-renamed et de –stop-at dont on a parlé précédemment. Pour inclure ces patches il est nécessaire de compiler rsync vous même en les incluant. Pour cela les sources se situent sur https://rsync.samba.org/ftp/rsync/ dans le dossier /src. Ou plus simplement dans les ports FreeBSD. Pour ceux qui utilisent FreeNAS en version 64 bits, vous pouvez télécharger ma version ici même. Paramétrage du script L’ensemble des paramètres réglable est situé en tête du script (lignes surlignées en jaune ci-dessus) et sont normalement décrit. L’heure de fin est à mettre avant l’heure de début de la sauvegarde suivante (lancée par cron) pour un fonctionnement plus propre. Ensuite évidemment il faut régler l’IP du serveur source, le nom d’utilisateur, le port et votre mail. Pour que tout fonctionne bien il faut avoir préalablement paramétré une authentification ssh par clé depuis le serveur distant hébergeant le script vers votre serveur local abritant les fichiers à sauvegarder. La connexion ssh doit avoir été ouverte au moins une fois pour ajouter la “key fingerprint” à la liste des serveurs connus. La liste des exclus est un fichier contenant une liste des dossiers et des fichiers à ne pas envoyer vers la sauvegarde distante. Il suffit de faire précéder le nom des dossiers ou fichier par – pour les exclure comme sur cet exemple : # # Liste des dossiers / fichiers à exclure de la sauvegarde distante # Exclusion des dossiers – Jail – Plugins – Medias – Scripts – Sauvegarde_MID/T??l??chargements – Sauvegarde_MID/zip et exe* – Sauvegarde_AD/T??l??chargements – Sauvegarde_MD # Exclusion des fichiers et dossiers commençant par un point #tels que .ssh et autres – .* ATTENTION : là encore un piège, il est indispensable d’avoir des sauts de ligne codés au format UNIX. Dans Notepad++ cela se fait avec Edition->Convertir les sauts de lignes. Et voilà ! Normalement si tout ce passe bien vous allez recevoir un rapport quotidien (à condition d’avoir activé l’option). Celui ci contient les stats rsync du dry-run, s’exécutant donc AVANT l’envoi réel des fichier. Par conséquent quand on y lit “transfered file” il ne s’agit en fait pas des fichiers réellement transféré mais qu’il VA transférer. Si tout se termine en moins de 24h, c’est pareil, mais si vous avez trop de données à envoyer et que cela prend plus de 24h cela correspondra donc à ce qu’il reste à envoyer. Vous voyez la subtilité ? N’hésitez pas à faire part de vos remarques ou suggestions, je suis preneur de tout ce qui peut l’améliorer car il n’est certainement pas parfait.
  5. E-mails, vidéos, factures numériques, créations personnelles, et surtout photos souvenir : les données numériques personnelles sont de plus en plus conséquentes et prennent au fil du temps d’avantage de valeur, qui n’a jamais perdu un seul fichier qui lui était cher ? Ou un seul mail ? C’est parfois un disque dur entier qui rend l’âme, emportant avec lui des années de souvenirs photographiques. Faites le test dans votre entourage, il y a forcément quelqu’un à qui c’est arrivé. On ne le répétera jamais assez : il faut faire des sauvegardes ! … Une sauvegarde ou Des sauvegardes ? Sauvegarder, oui mais comment ? il faut d’abord élaborer une stratégie en fonction de vos besoin et des risques dont vous souhaitez vous protéger. Les risques que j’ai identifiés pour vos données sont : Panne matérielle d’un disque dur Suppression de fichiers suite à une erreur de manipulation Destruction de fichier par un virus Vol du matériel de stockage Destruction du matériel informatique par un incendie, une inondation, … Fin du monde (ça approche décembre 2012…) Bon, contre le dernier point, je pense que de toute façon il ne sert à rien d’avoir une sauvegarde si vous n’êtes plus là pour l’utiliser donc on ne s’en protègera pas. Par contre il est possible de se protéger contre tous les autres risques. Méthode 1 : le disque dur externe Pour la majorité des utilisateurs le stockage informatique se limite au disque dur contenu dans l’ordinateur. Le premier moyen de se protéger contre une défaillance de ce dernier est donc de copier régulièrement les données à protéger sur un disque dur externe branché sur le port usb par exemple. Cela peut être automatisé, par l’excellent logiciel TimeMachine pour les utilisateurs de Mac et par des programmes comme SyncBackPro pour les utilisateurs de Windows. Les amis linuxiens connaissent déjà très certainement le puissant Rsync. Automatiser sa sauvegarde est le meilleur moyen de ne pas oublier de la faire. C’est entre autre pour cela que je ne recommande pas les solutions dépassées et couteuse en temps comme la gravure sur DVD-R, qui plus est à la capacité de stockage limitée devant les besoins actuels. Vous voilà donc maintenant protégé contre une panne ou une suppression accidentelle : vous pourrez alors aller rechercher le fichier sur la sauvegarde. Un ami s’est vu cambrioler sa maison et voler entre autre 2 ordinateurs portables et un disque externe sur lequel il sauvegardait scrupuleusement ses photos. Envolés toutes les images de naissances et des premières années de ses 2 enfants. Méthode 1bis : Être plus malin Pour éviter le risque de vol on pourrait stocker le disque externe à l’écart de l’ordinateur, idéalement très très bien caché car les voleurs sont inventifs, par contre cela ne simplifie pas le processus de mise à jour de la sauvegarde, avec le risque qu’elle soit de moins en moins faite. Méthode 2 : 2 sauvegardes, 2 disques externes On pousse plus loin la méthode : le principe est d’avoir une sauvegarde locale et une distante : un disque est connecté en permanence et la sauvegarde est mise à jour en continu, ou toutes les heures. Cela permet d’assurer la récupération d’un fichier supprimé simplement ainsi qu’une restauration et une disponibilité des données instantanée en cas de problème avec le disque source. Parallèlement, une seconde sauvegarde est effectuée sur un second disque qui est stocké à distance : dans une cave, ou mieux chez un proche, un ami, … Évidemment cette sauvegarde est mise à jour moins fréquemment de par la distance mais il est important de ne pas la négliger car c’est celle qui protège du vol, de l’incendie, d’un grave problème électrique, etc… C’est la méthode que j’utilise actuellement : techniquement la sauvegarde locale est incrémentielle, pour récupérer une erreur de manipulation, et la distante est un simple miroir du disque de stockage. Là on est quasiment protégé contre l’ensemble des risques, éventuellement une infection virale pourrait ne pas être détectée et se propager dans les 2 sauvegardes lors d’une mise à jour. Inconvénient majeur : la fréquence et la difficulté de mise à jour de la sauvegarde distante, qui risque à la longue de ne plus être faite. Méthode ultime : 2 NAS, 1 connexion internet La dernière méthode envisageable est celle que je suis entrain de développer actuellement : le stockage local est assuré par un NAS (serveur de stockage en réseau) dans lequel la sauvegarde est effectué par l’installation des disques en RAID 1 ou 5, on en reparlera. Ce NAS sauvegarde quotidiennement les données via une connexion internet sur un autre NAS distant hébergé chez un ami. Ainsi on peut même imaginer une sauvegarde réciproque de l’ami qui utilise le même système. Dans le schéma 2, on a 3 copies identiques des données : l’original, la copie locale et la distante. C’est nécessaire car la distante n’est pas continuellement à jour. Traduit sur le NAS ça nous donne un système avec des disques en RAID 1 : c’est à dire une copie identique de chaque disque sur un autre + un disque dans le NAS distant. Ainsi les disques locaux fonctionnent par paire et la sécurité est maximale, par contre cela a un coût. Afin de limiter le coût sans augmenter le risque on peut monter un RAID 5 avec 3 disques dans le NAS ainsi pour 3 disques de 1To on a 2To de stockage disponible. Le risque de perte local est légèrement augmenté car si l’on perd plus d’un disque dans la grappe RAID 5 on a perdu toutes les données, mais comme elles sont dupliquées quotidiennement sur le NAS distant on limite très fortement la perte.
  6. Cette page est la suite directe du tutoriel de configuration de FreeNAS. Nous allons à présent aborder des fonctionnalités un peu plus avancées pour les utilisateurs amateurs que nous sommes, car FreeNAS est capable de chose bien plus puissantes que ce que nous voyons ici mais si vous êtes à ce niveau vous n’avez pas besoin d’un tuto ! Au programme cette fois : Installation des mises à jour Les plugins : installation de la jail Installation et configuration de minidlna Configuration de SSH Sauvegarde des données entre 2 freenas NB: tout comme le premier tuto, celui ci est publié au fur et à mesure de l’écriture et de mes avancées personnelles, soyez donc patient, la suite arrive petit à petit. Etape 1 : Installation des mises à jour Téléchargement de l’image GUI_Upgrade Dans la première partie du tuto j’ai installé la version 8.04, car c’était la version stable du moment. Ensuite durant la rédaction, la version 8.2 est sortie et la 8.3 est en version beta3 au moment où j’écris ces lignes… FreeNAS évolue, de nouvelles fonctions sont régulièrement ajoutées, des bugs corrigés, de nouveaux matériels sont supportés,… En bref, pour en profiter il faut faire des mises à jour. Nous allons effectuer les mises à jour depuis l’interface graphique. NOTE IMPORTANTE mise à jour janvier 2014:Cette partie avancée du tutoriel a été écrite pour FreeNAS en version 8 (mon NAS est toujours en 8.3.2 actuellement), il s’agit de la dernière version de FreeNAS 8. FreeNAS est aujourd’hui en version 9 mais certains paramétrages sont sensiblement différent, particulièrement pour les plugins. Les téléchargements se font sur cette page : http://cdn.freenas.org/ Toutes les versions sont disponibles, puis à l’intérieur de chacune les sous-versions (beta, release candidate, stable). Je vous déconseille les versions autres que les stables sur votre NAS contenant vos données, sur une machine virtuelle pour test par contre c’est le but ! Pour la mise à jour depuis l’interface graphique il faut télécharger les images GUI_Upgrade. Petit piège : les images GUI_Upgrade sont disponible en 2 formats : xz et txz. Si vous mettez à jour depuis une version antérieur à la 8.2 BETA3 il faut télécharger le fichier au format xz, qui se termine donc par .GUI_Upgrade.xz. Si vous mettez à jour depuis une version 8.2 BETA3 ou plus récente il vous faut le format txz. Il vous faut également télécharger le fichier texte contenant le hash SHA256 correspondant à votre image, cela permet au système de recalculer le hash et vérifier l’intégrité de l’image avant de l’installer. Sauvegarde des paramètres Il est primordial de télécharger la base de données contenant tous vos paramètres avant de débuter, en effet en cas de problème lors de la mise à jour il suffira de faire une installation normale puis restaurer la sauvegarde au lieu de tout reparamétrer… à moins que vous soyez fan de mon tuto au point de le recommencer du début ! Donc dans System -> Settings on clique en bas sur le bouton Save Config et on télécharge le fichier .db. C’est tout ! En cas de besoin il suffit de partir d’une installation de FreeNAS toute vierge, d’aller directement dans System -> Settings et de faire Upload Config. Mise à jour proprement dite Avant de lancer la mise à jour il faut commencer par désactiver tous les services : dans Services -> Control Services on passe tous les interrupteurs sur OFF. Après ces étapes préliminaire on se rend dans System -> Settings puis l’onglet Advanced et on clique en bas sur le boutonFirmware Update On choisi un emplacement temporaire pour l’upload de l’image, la racine du pool proposée par défaut fait un bon choix. On clique sur Apply Update. Dans la fenêtre suivante on sélectionne l’emplacement de l’image téléchargée et on fait un copier-coller du contenu du fichier texte .sha256.txt avant de cliquer sur Apply Update. Ensuite il faut être patient : l’image est uploadée, le hash est vérifié, l’image décompressée et copiée sur la clé usb puis le système va rebooter 2 fois. Méé, heu ça marche pas, jfais quoi ? Si comme moi vous avez un message d’erreur très explicite, du style “an error occured”, sans autre explication rapidement après avoir cliqué sur Apply Update alors vous avez peut être un problème de droits d’accès au pool. Après avoir pas mal tatonné, j’ai découvert que “les autres” doivent avoir le droit d’exécution, autrement dit les droits du pool doivent être positionnés au moins comme ceci : Mise à jour d’un pool ZFS Comme le système, ZFS évolue également. En version v15 dans FreeNAS 8.3 et antérieur puis v18 dans FreeNAS 8.3.1 et avec avec les “ZFS Feature Flags” maintenant. Un pool ZFS ancien est toujours parfaitement utilisable par un système récent mais FreeNAS vous affichera le petit message suivant avec un clignotant jaune : Upgrader un pool est faisable en ligne de commande mais ATTENTION : une fois mis à jour, le pool ne sera plus lisible par une ancienne version de FreeNAS et l’opération est IRREVERSIBLE. Cette opération est normalement sans risque mais il est comme toujours recommandé de sauvegarder les données avant (et puis tout le reste du temps aussi d’ailleurs…) The pool is formatted using a legacy on-disk format. The pool can still be used, but some features are unavailable. action: Upgrade the pool using ‘zpool upgrade’. Once this is done, the pool will no longer be accessible on software that does not support feature flags. Pour mettre à jour le pool, on utilise un accès au Shell, via l’interface ou SSH. Quelques vérifications préliminaire pour commencer : Cela vous retourne la version actuelle de MonPool puis le status DOIT indiquer “All pools are healthy”, on ne met pas à jour si ce n’est pas le cas. Si tout est bon on peut lancer l’upgrade : zpool get version MonPool zpool status -x zpool upgrade MonPool Etape 2 :Les plugins, installation de la jail Note Importante (mise à jour janvier 2014) : Cette partie est écrite pour FreeNAS 8, sur la version 9, l’installation des plugins est assez différente. Avant tout quelques brèves explications car il est toujours plus intéressant de comprendre ce que l’on fait. Une jail c’est quoi ? L’environnement jail (prison en français) est une fonctionnalité avancée des systèmes BSD (FreeNAS est basé sur FreeBSD) qui permet d’installer des applications sur votre système en toute sécurité. L’environnement jail est en fait une partie virtualisée du système, ainsi pour un processus installé dedans tout est comme si il était installé directement dans le système sauf que si ce processus devient malveillant il ne pourra pas compromettre le système car il compromettra un système virtuel. En gros la jail est un système virtuel indépendant dans le système. Si vous voulez toutes les infos imaginables sur les jails lisez donc ceci, c’est le manuel FreeBSD en français et c’est très intéressant. Téléchargement de la jail FreeNAS a déménagé, les versions 8 des jails et plugins sont disponibles ici : cdn.freenas.org, dans le dossier de la version 8.3.2. Puis le dossier correspondant à votre architecture (32 ou 64 bits) et plugins. On télécharge le fichier FreeNAS-8.x.xxxxx.Plugin_Jail.pbi. Emplacement d’installation La jail et les plugins vont être installés sur le pool ZFS et non sur la clé USB contenant le système freeNAS. Pour que cela soit plus simple à gérer par la suite nous allons donc créer 2 datasets : un pour la jail et un pour les différents plugins. Cela se passe donc dans Storage -> Volumes -> votre volume -> Create ZFS Dataset, on sait faire je ne re-détaille pas tout, si ce n’est pas le cas jetez un œil à la première partie du tuto. Dans mon cas j’ai créé un dataset “Jail” et un dataset “Plugins”. 2 contraintes cependant : Les datasets doivent faire au moins 2Go et Le chemin doit faire moins de 88 caractères de long : /mnt/pool1/Jail par exemple Création de la jail On se rend dans Services -> Plugins -> Management -> Settings. Comme pour une mise à jour on choisit un emplacement temporaire pour uploader la jail téléchargée (voir dans l’étape 1 ci-dessus pour les problèmes de droits sur le volume si jamais votre upload se bloque à 1%). Ensuite dans la boite de dialogue suivante il y quelques paramètres à rentrer : D’abord le dataset où installer la jail, puis un nom pour notre jail, ici dans un élan d’inspiration j’ai mis « Jail ». Ensuite c’est important : il faut assigner une adresse IP et un masque à notre jail, et oui on a dit que c’est comme un système indépendant qui est virtualisé et il doit donc avoir un accès au réseau. Cette adresse doit être accessible depuis freeNAS, donc sur le même réseau et ne doit pas être utilisée par un autre poste sur votre réseau. Un bon plan est donc de mettre une adresse fixe en dehors de la plage de votre DHCP par exemple… On termine par le chemin du dataset où seront installés les plugins. On valide puis dans la dernière boite de dialogue il suffit de faire parcourir… et sélectionner le fichier de la jail précédemment téléchargé, puis une dernière validation et après un petit peu de patience la jail est installée. Démarrage de la jail Pour l’instant elle est installée mais pas activée, pour cela il faut se rendre dans Services -> Control Services et passer surON le bouton correspondant au service Plugins. Cela permet de « démarrer » le système virtuel dans la jail et est nécessaire pour l’installation et le fonctionnement de tous les futurs plugins. Une fois le bouton sur ON, la jail est installée, vous devriez être en mesure de la “pinguer” depuis le NAS (via l’accès au Shell depuis l’interface graphique) ou même depuis n’importe quel poste du réseau. Pour le ping depuis freenas on utilise la commande ping avec l’argument “-c” en précisant le nombre de ping (ici j’ai mis 2) sinon il faudra l’arrêter avec Ctrl + C. Ajouter des points de montage La jail étant un système virtualisé, les plugins que l’on va installer dedans n’auront donc évidemment pas d’accès au reste de l’arborescence du système… sauf que ça nous pose un problème : nos données étant sur le pool de stockage, comment faire pour que (par exemple) minidlna diffuse à la télévision un contenu auquel il n’a pas accès ? C’est là qu’interviennent les points de montage, on va créer une sorte de lien dans la jail permettant de lier un dossier vers un autre présent à l’extérieur de la jail. Les données ne sont physiquement présentes qu’une seule fois mais accessibles depuis 2 endroits différents de l’arborescence. Attention : effacer des fichiers depuis le point de montage dans la jail les efface réellement du dossier source. Dans l’optique de rendre nos données multimédias disponible à la diffusion par un plugin, on va donc créer un point de montage de notre dataset Medias vers la jail, c’est à dire que je monte /mnt/pool1/Medias en tant que /medias dans la jail (donc en vrai : /mnt/pool1/Jail/Jail/medias). Le dossier cible (dans la jail) doit obligatoirement exister. L’avantage de monter vers /medias dans la jail est que ce dossier existe déjà : on se rend donc dans Services -> Plugins -> Management -> Mount Points -> Add Mount Points et l’on sélectionne simplement avec les boutons Browse les dossiers source (hors jail) et cible (dans la jail). La caseMounted cochée indique que l’on veut l’activer, elle doit donc être cochée sinon ça ne fonctionne pas. Et pour créer un dossier dans la jail ? On vient de voir que pour ajouter un point de montage dans la jail, le dossier cible doit exister, si ce n’est pas le cas on peut le faire manuellement en ligne de commande. Pour accéder à la ligne de commande à l’intérieur de la jail on procède de la façon suivante : Dans le shell on utilise les commandes suivantes : jls pour lister les jails présentes et récupérer le numéro d’ID de celle que l’on veut (bon, là y’en a qu’une, ça devrait aller ) puis : pour lancer le shell csh dans la jail numéro 1. Un fois dans la jail, ce qui confirmé par le prompt : nomdevotrejail# on utilise mkdir pou créer un dossier : jexec 1 csh Et voilà, on quitte avec exit et c’est tout. Ca doit donner un truc comme ça : mkdir /mnt/Medias Ensuite, comme précédemment, on se rend dans Services -> Plugins -> Management -> Mount Points -> Add Mount Points pour le monter. Maintenant que la jail est installée, on est libre d’y mettre tous les plugins que l’on veut ! Et même bien plus encore. Etape 3 : Installation et configuration de minidlna Kesaco ? MiniDLNA est un serveur DLNA qui utilise UPnP pour partager vidéos, musiques et photos entre un NAS (par exemple…) et votre télévision, console de jeux, box tv, téléphone portable, ou application telles que xbmc par exemple. Chez moi je l’utilise pour diffuser vers la télévision via la Freebox v6 (Revolution) qui sert d’interface de navigation dans les fichiers et de lecteur. Je peux vous certifier que cette configuration fonctionne à merveille. Certaines télévisions modernes savent gérer le DLNA directement, mais il peut y avoir des soucis au niveau du décodage des vidéos par exemple. En effet, minidlna ne fait pas de transcodage, il ne fait que servir le contenu vers le client : donc pour lire votre fichier .avi encodé en divx il faut que votre lecteur sache décoder le xvid. Installation du plugin Pour installer le plugin on commence par le récupérer ici : cdn.freenas.org. On prend la version 8.3.2 et celle qui correspond à notre architecture (32 bits -> x86 ou 64 bits -> x64). Dans le dossier plugins, on télécharge le fichier minidlna-x.x.xx_x-amd64.pbi (par exemple, si on est sur du 64bits). L’installation en elle même est très simple et sera identique quelque soit le plugin : On se rend dans Services -> Control Service puis l’onglet Plugins et enfin le bouton Install Plugin Un clic sur Parcourir, on sélectionne le fichier pbi précédemment téléchargé puis Upload. Et l’installation est automatique. On retrouve le plugin listé avec le bouton Service status sur OFF. Et pour l’instant on n’y touche pas ! Configuration du plugin Dans l’arborescence de configuration on se rend dans Services -> Plugins -> MiniDLNA. Le Friendly name est le nom du serveur qui apparaitra sur votre client, laissez aller votre inspiration ! Ensuite le point important est bien sûr indiquer où se trouvent les fichiers à partager : un clic sur Browse et on sélectionne le point de montage créé à l’étape 2. On laisse le port et le Discover interval par défaut (ceci est la fréquence à laquelle minidlna annonce sa présence sur le réseau, rien à voir avec une recherche de nouveaux médias). Le Model number et le Serial sont inutiles, j’ai laissé les valeurs par défaut. On va en reparler ensuite mais il faut connaitre une limitation importante : miniDLNA liste dans une base de donnée les fichiers contenu dans le dossier à partager, mais sur FreeNAS, miniDLNA ne sait pas détecter automatiquement l’ajout de nouveaux fichiers. On va donc cocher l’option Rescan on (re)start pour forcer miniDLNA à rescanner l’ensemble du dossier quand le service redémarrera. Après l’ajout d’un fichier il faudra donc arrêter puis redémarrer le service pour voir le nouveau fichier partagé. Dans les paramètres auxiliaire, j’ai mis une option qui permet de choisir la racine de l’arborescence créée par miniDLNA quand on navigue dans le partage. Ceci est totalement facultatif, je vous conseille de ne rien mettre pour commencer et de vous faire votre propre idée ensuite. Les possibilités sont expliquées en bas de cette page. Et voilà ! On clique sur OK en bas pour valider, on retourne dans Control Services, onglet Plugins et on active Minidlna en passant le bouton sur ON. Rescan automatique lors d’un ajout de fichier Comme je l’ai dit, minidlna ne sait pas détecter l’ajout d’un fichier dans le dossier source des médias pour actualiser la liste. C’est une limitation système de FreeBSD. Fort astucieusement il y a joeschmuck qui a écrit et partagé sur le forum freeNAS un script faisant cela pour nous. En résumé : on installe un petit package nommé wait_on qui ajoute une fonction se déclenchant lors d’un évènement disque et qui va surveiller pour nous les modifs, puis on redémarre minidlna après la détection d’une modification, ce qui déclenche un rescan car on a coché la case adéquate. Limitations du script : Wait_on se déclenche à l’initiation d’un évènement et non à la fin Lors du redémarrage de minidlna si une lecture est en cours elle est interrompue Il y a une limitation dans la longueur de arborescence, plus exactement lorsque vous listez récursivement l’arborescence complète de vos dossiers médias : par exemple “/media /media/Movies_A_Z /media/Movies_A_Z/Movies_A /media/Movies_A_Z/Movies_B” ça fait une grande chaine de caractères qui ne doit pas dépasser 261649 caractères. Pour mettre en place ce script il faut avoir au moins un FreeNAS 8.3.1 et minidlna installé et surtout fonctionnel et actuellement démarré. Ensuite via SSH (voir l’étape 4) après l’établissement de la connexion on se logue en administrateur par “su root” et le mot de passe associé (voir la note de l’étape 4 si vous avez un problème à ce niveau). Puis “jls” permet de lister les jails présentes sur le système avec leur numéro d’ID et ensuite “jexec numéroID /bin/tcsh” permet de rentrer dans la jail. Une fois dedans on commence par installer waint_on en tapant : rehash est à faire une fois le téléchargement de wait_on terminé. On se rend alors dans le dossier rc.d pour y créer le script que l’on appelera scanmedia : pkg_add -r wait_on rehash cd /etc/rc.d ee scanmedia On fait un copier-coller du code suivant (clic droit dans putty pour coller) puis on modifie les paramètres Script scanmedia Shell #!/bin/sh # Nom de fichier 'scanmedia' # Placer ce fichier dans /etc/rc.d # Editer /etc/rc.conf pour ajouter scanmedia_enable="YES" # A savoir... Le but de ce script est de declencher un rescan des # medias pour le plugin minidlna. Il utilise la commande "wait_on" qui # bien qu'elle fonctionne, a ses propres limitations: # 1) Cela rescan a la detection d'un changement, pas une fois que celui ci est termine. # 2) Il y a une limite dans la longueur de chaine des dossiers donc j'ai ajoute # une methose alternative pour rescanner mais elle lit activement les disques, # donc si vous souhaitez que vos disques passent en veille, cette methode va # l'empecher et je vous recommande fortement de plutot modifier la structure de vos dossiers. . /etc/rc.subr name="scanmedia" rcvar=scanmedia_enable PATH="$PATH:/usr/local/bin" start_cmd="${name}_start" stop_cmd=":" load_rc_config $name eval "${rcvar}=${${rcvar}:-'NO'}" # Variables used in this script... # RedAlert = Maximum string length wait_on can handle RedAlert=261649 # YellowAlert = User selected warning point. Looking to use this to enable the # flashing warning light in the GUI. YellowAlert=255000 # TriggeredDelay = La duree en seconde pour retarder le scanning a partir du moment ou # un changement a ete detecte. 300 secondes (5 minutes) par defaut. Mettez ce que vous voulez # en reflechissant a combien de temps cela vous prend pour ecrire un gros fichier (film) sur votre NAS. TriggeredDelay=300 # AlternateScanRate = La duree en seconde entre 2 rescan pour la methose alternative. # La valeur par defaut est 1800 secondes (30 minutes). AlternateScanRate=1800 # ScanMode = Methode normal ou Alternative. Par defaut '0' pour la Normale. This changes # in the script based on the actual directory string length vs the RedAlert value. ScanMode=0 # MediaLocation = L'emplacement contenant les medias a surveiller. Par defaut il s'agit de "/media". MediaLocation="/media" scanmedia_normal() { while [ "$ScanMode" -eq "0" ] ; do # First lets locate all the subdirectories. Since the minidlna plugin only # allows one path for media we will use the path defined above (default=/media) directories=$(find $MediaLocation -type d -print0 | xargs -0 -I % echo -n '"%" ') # Check on maximum length of directory string. if [ ${#directories} -gt $YellowAlert ]; then if [ ${#directories} -gt $RedAlert ]; then date > /minidlnaerror.log echo "RED ALERT! You have exceeded the maximum directory string length of 261649 and you are currently at" >> /minidlnaerror.log echo ${#directories}". The alternate method is in use and you need to shorten the directory names or rearange your folders" >> /minidlnaerror.log echo "to restore the normal scanning method." >> /minidlnaerror.log # Change from normal scan mode to alternate scan mode. ScanMode=1 else date > /minidlnaerror.log echo "YELLOW ALERT! The maximum directory string length is 261649 and you are currently at" >> /minidlnaerror.log echo ${#directories}". You should shorten the directory names or rearange your folders" >> /minidlnaerror.log echo "to remove this warning." >> /minidlnaerror.log fi fi if [ "$ScanMode" -eq "0" ] then # Wait_on will trigger on any event which writes to the directories listed. csh -c "wait_on -w $directories" # Now let's call the rescanning routine scanmedia_rescan fi done } scanmedia_rescan() { # This routine pauses for the user specified delay (default 5 mins) before killing # the minidlna service and restarting it. sleep $TriggeredDelay # We must stop the minidlna service in the GUI first, then wait 10 seconds (probably overkill) # and then kill the service. service minidlna onestop sleep 10 pkill minidlna # We wait 10 seconds to allow the service lots of time to wrap up. sleep 10 # And now to start up the service again. service minidlna onestart } scanmedia_alternate() { while [ "$ScanMode" -eq "1" ] ; do #Lets check to see if we can go back to normal_scan mode. directories=$(find $MediaLocation -type d -print0 | xargs -0 -I % echo -n '"%" ') if [ ${#directories} -lt $RedAlert ] then ScanMode=0 fi # We list all the files and save as a file in memory, hopefully the file doesn't get too # big to cause an issue. If it does then remove the '/var/' from the below lines. ls -RlT $MediaLocation > /var/altscan1.dat sleep $AlternateScanRate ls -RlT $MediaLocation > /var/altscan2.dat # diff return 0 if files are identical, 1 if they are different, 2 if one of the files cannot open. diff -q /var/altscan1.dat /var/altscan2.dat # We don't really care about cases 0 and 2 but it's nice to have for troubleshooting. They # are commented out right now. case "$?" in #"0") echo "Files Identical";; "1") scanmedia_rescan;; #"2") echo "Failed to open one of the files";; esac done } scanmedia_start() { while :; do if [ "$ScanMode" -eq "0" ] then scanmedia_normal else scanmedia_alternate fi done } scanmedia_start run_rc_command "$1" Les lignes à personnaliser sont en jaune : 40,44 et 51. Surtout pensez à adapter le chemin où sont stockés les fichiers (le point de montage, en fait…) ligne 51. On sauvegarde avec Echap puis les options adaptées. On rend le script exécutable avec chmod : Dans le dossier parent on modifie rc.conf pour lui ajouter une ligne qui permet de démarrer le script avec la jail : chmod +x scanmedia La ligne scanmedia_enable=”YES” est ajoutée en fin de fichier et on enregistre avec Echap. On quitte avec “exit” puis on redémarre le NAS : le script et miniDLNA sont lancés cd .. ee rc.conf Ajouter : scanmedia_enable=”YES” Note : Dans FreeNAS 9.1.1 : après avoir fait cela dans l’interface web minidlna apparaitra comme arrêté, ce qui n’est pas le cas en réalité et n’empêche ni le fonctionnement du script ni de minidlna. Etape 4 : Configurer SSH SSH pour Secure Shell, va nous permettre un accès à distance au shell, ce qui est encore pour l’instant plus pratique que le shell de l’interface web (enfin ce n’est que mon avis) et permettra ensuite d’établir une connexion sécurisée entre 2 NAS distants pour synchroniser des données via l’outil rsync. Dans les étapes qui suivent nous allons donc mettre en place un accès ssh avec authentification par clé. Choix d’un client SSH Déjà avant de commencer à configurer notre NAS il nous faut un client pour s’y connecter en SSH, si vous êtes sur Mac ou Linux, pas de soucis car SSH est déjà intégré dans le système. Pour Windows il existe Putty, open source, complet et sans installation, il est très répandu. Ça se télécharge ici même (utiliser le premier lien pour putty.exe, et vous pouvez aussi au passage récupérer puttygen.exe qui servira plus tard à générer les clés) Accès par mot de passe Pour commencer on va configurer un accès SSH par mot de passe, par la suite celui ci sera pour une question de sécurité remplacé par un accès par clés publiques/privés, bien plus sécurisé. Tout commence comme souvent dans les services : Services -> SSH nous ouvre la boite de dialogue dans laquelle nous allons d’abord pour une question de sécurité changer le port par défaut : en effet le port 22 est celui le plus fréquemment utilisé pour le ssh et donc le plus visé par les attaques, donc autant le changer. Ici je met par exemple 12322, ensuite toujours pour raison de sécurité, on ne coche jamais Login as Root with password. J’ai choisi ici de ne pas compresser les connexions, en effet en local le réseau est rapide et pour l’utilisation à distance lors de la synchronisation entre NAS c’est rsync qui se chargera de la compression. On valide par OK, et on active le service dans Services -> Control Services, celui ci passe alors à l’état ON. Qui a le droit de se connecter ? Attention aux droits d’accès au shell ! Il n’est certainement pas très judicieux d’autoriser tout le monde à pouvoir se loguer en ssh. Les réglages se font dans Account -> Users puis pour chaque utilisateur : Dans le menu déroulant “Shell” vous pouvez choisir le shell que vous voulez et surtout “nologin” pour ceux à qui vous refusez l’accès. Enfin pour vous éviter de chercher autant que moi… sachez que seuls les membres du groupe “wheel” sont autorisés à faire un “su root” (pour passer en super-administrateur) une fois logués en ssh. Donc si vous en avez besoin, pensez à ajouter votre nom d’utilisateur à ce groupe Première connexion Sur notre PC client on lance donc Putty et on rentre les paramètres suivants : Nom@adresse_IP et le port défini précédemment, par exemple pour moi : Neo@192.168.0.11 dans le Host Name et 12322 pour le port puis Open. Comme c’est la première connexion, la fenêtre d’alerte nous indique que la clé d’hôte est inconnue, on est d’accord et on l’accepte. Reste à taper votre mot de passe et voilà la connexion établie : Connexion par clé Pour mettre en place l’authentification par clé on va d’abord utiliser puttygen pour générer celle-ci. Téléchargez le ici si ce n’est pas déjà fait. On le lance et on choisi une clé SSH-2 DSA de 1024 bits et on agite la souris pour générer du mouvement aléatoire. Une fois la génération terminée la clé publique est affichée, on la sélectionne jusque au bout et on copie (Ctrl + C). Dans l’interface web de FreeNAS on se rend dans Account -> Users -> Notre nom d’utilisateur puis on colle la clé dans la partie SSH Public Key avant de valider par OK. De retour dans Puttygen on fait “Save private key” (là, personnellement je n’ai pas mis de passphrase, c’est moins bon pour la sécurité car si le PC est physiquement volé ou que quelqu’un s’introduit dessus il peut se connecter au NAS) et on la sauvegarde quelque part en sécurité. On relance putty et après avoir de nouveau entré nos infos de connexion on va dans Connection -> SSH -> Auth et on sélectionne notre clé privée dans “Private key file for authentication”. Pour plus de facilité à l’avenir on peut revenir dans la partie Session, entrer un nom dans Saved Sessions et cliquer sur Save pour enregistrer les paramètres. Si l’on fait Open à ce stade, la connexion SSH s’établit sans nous demander de mot de passe, ce qui est confirmé par la ligne : Important : A présent dans les paramètres SSH de FreeNAS il faut désélectionner l’authentification par mot de passe pour gagner en sécurité. Ici pour configurer de cette façon on aurait pu s’en passer mais faire cette étape permet de mieux cerner le problème en cas d’échec de configuration. Autre note importante : pour pouvoir fair un “su” vers root (switcher vers le compte root depuis celui d’un utilisateur x) il faut obligatoirement que l’utilisateur en question soit membre (entre autre) du groupe wheel, donc penser à l’ajouter dans le groupe peut vous éviter des heures de recherche… Et voilà ! On a un accès au shell de notre NAS ailleurs que dans la console de l’interface web. Pour y accéder de l’extérieur de votre réseau il suffit de faire un renvoi du port choisi dans votre routeur comme d’habitude. Pour aller plus loin Putty est un client Windows, on peut aussi trouver des clients sur d’autres plateformes, par exemple sur iPhone ou iPad j’utilise ServerAuditor. Pour se connecter au NAS par clé j’ai généré une paire de clé dans l’application puis j’ai copié collé la clé publique dans un mail vers mon PC. Via Putty j’ouvre une session SSH sur le NAS, dans le dossier home de mon utilisateur en faisant “ls” on doit y voir un dossier .ssh, on entre dedans avec “cd .ssh”, un nouveau “ls” devrait faire apparaitre authorized_keys qui est le fichier contenant les clés publiques autorisées à se connecter. On fait “ee authorized_keys” pour éditer le fichier, celui ci contient pour l’instant une seule clé (celle de Putty), on ajoute la suivante sur une nouvelle ligne : Ctrl + E pour aller directement en fin de ligne puis Entrée et on colle la clé reçue par mail (clic droit pour faire coller dans Putty), on ajoute une ligne vide à la fin et on quitte par Echap en sauvegardant les changements. C’est tout ! Etape 5 : Sauvegarde des données entre 2 freenas Enfin nous y voilà ! Voici probablement l’ultime étape de ce tuto avancé et le but final que je m’étais fixé au commencement. J’ai déjà parlé des stratégies de sauvegardes informatiques dans ce petit article, je ne reviendrais donc pas dessus. Nous allons nous intéresser ici à la mise en pratique. Monter un second NAS Le but du jeu est d’avoir un second NAS connecté également à Internet dans un lieu physiquement différent du premier et ceci afin de mettre nos données sensibles à l’abri du feu, du vol, du dégât électrique, inondations, etc… Nous allons donc commencer par assembler et configurer un second NAS de la même façon que celui que nous venons de faire. Si ça peut vous aider je connais un site où il y a un tuto… Puis la synchronisation des données sera assurée quotidiennement par un script rsync “maison” qui se connectera par un tunnel ssh pour envoyer les données de façon totalement sécurisée. En ce qui me concerne, j’habite à Orléans et j’ai un ami domicilié à Toulouse (là au moins c’est vraiment physiquement séparé !), nous avons chacun monté un NAS avec un RAIDZ de 3x2To (soit 4To de stockage) et chacun a en plus dans son NAS un disque de 2To pour la sauvegarde distante de l’autre. Un pool ZFS est créé sur ce disque. Oui mais comment tu sauvegarde 4To sur un disque de 2 ?? Évidemment il faut faire un choix, pour ma part je sauvegarde tout ce qui n’existe pas ailleurs, à savoir les photos personnelles et tous les documents divers (sauvegarde des partitions documents des PC de la maison). Tout ce qui est musique, films, séries tv, enregistrements, etc etc n’est pas sauvegardé à distance. D’où l’intérêt des datasets créés plus tôt dans le tuto… Sur le NAS distant situé à Toulouse j’ai créé un utilisateur Mickael, un pool ZFS sur mon disque de 2To, j’en suis le seul propriétaire et suis le seul à avoir les droits en lecture/ecriture/modification dessus et le dossier home est ce pool. L’utilisateur Mickael a accès au shell évidemment pour pouvoir se connecter en ssh. Configurer ssh entre les deux NAS Voilà nos deux NAS sont fonctionnels, connectés à Internet, les bons ports sont routés dans les box internet et on arrive à se loguer en ssh à partir de notre PC sur chacun des deux où que l’on soit dans le monde, essayons donc de les faire se connecter entre eux ! Pour s’y retrouver, nommons LOCAL le NAS local et DISTANT le NAS distant, pas très compliqué ! Et pour que vous compreniez bien, dans mon cas, Neo est l’utilisateur sur LOCAL et Mickael l’utilisateur sur DISTANT. Momentanément (uniquement le temps de la mise en place des clés), on active dans les paramètres ssh l’authentification par mot de passe On va générer une paire de clé publique/privé sur LOCAL et envoyer la clé publique sur DISTANT, donc on commence par se connecter en SSH sur LOCAL via Putty par exemple sur l’utilisateur Neo puis l’on tape la commande : Et on valide les autres paramètres avec la touche Entrée : ssh-keygen -t dsa Nous avons généré une paire de clé dsa dans le dossier indiqué, pour pouvoir nous connecter à DISTANT nous devons donc envoyer la clé publique dans le fichier authorized_keys de l’utilisateur Mickael sur DISTANT, pour cela on exécute : cat ~/.ssh/id_dsa.pub | ssh -p N°PORT Mickael@IP_DISTANT ‘cat >> .ssh/authorized_keys’ en remplaçant bien sûr N°PORT par le port ssh de DISTANT et IP_DISTANT par… l’IP du NAS distant ! Après avoir entré le mot de passe de Mickael sur DISTANT la clé est copiée et si l’on retente un : Cette fois la connexion devrait se faire sans demander le mot de passe, à la première fois il y aura la demande de valider la host fingerprint et de l’ajouter à la liste des serveurs connus. ssh -p N°PORT Mickael@IP_DISTANT Quand cela est fait, on se connecte en tant que Mickael sur DISTANT et on recommence dans l’autre sens : génération d’une paire de clé, puis envoi sur LOCAL et tentative de connection depuis la machine DISTANT vers la machine LOCAL. Si tout ce passe bien, dans un sens comme dans l’autre, on n’oublie surtout pas de désactiver dans les paramètres ssh des deux machines l’authentification par mot de passe. Présentation du script de sauvegarde Pourquoi utiliser un script et pas les outils rsync présent dans l’interface de freenas ? Quand je l’ai commencé il n’était pas possible d’utiliser rsync sur ssh avec les outils de freenas, donc pas de sécurité dans l’envoi, c’était donc impensable. Maintenant c’est le cas mais je trouve que le script colle mieux à mon besoin. Toute la présentation, la description du fonctionnement et le sript en lui même sont présentés dans SCRIPT DE SAUVEGARDE RSYNC . Il y a les explications générales d’installation et même ma version de rsync adaptée. Tout est disponible pour les utilisateurs avancés. Mise à jour de rsync avec la version patchée Comme expliqué dans l’article, j’utilise des options de rsync non disponibles dans la version de base officielle, du coup je l’ai recompilé, vous pouvez soit le télécharger dans le lien sur l’article soit le recompiler vous même. On dépose le fichier quelque part sur le NAS puis on se logue en ssh ou via l’interface graphique et le shell. Pour remplacer l’exécutable rsync il faut déjà être logué en root puis monter le système en lecture-écriture car il est par défaut en lecture seule, puis on remplace l’ancien fichier par le nouveau et enfin on remonte en lecture seule. Tout cela ce fait comme ça : Et voici ce que vous devriez avoir : su root mount -uw / cp votreDossier/rsync /usr/local/bin mount -ur / Notez les deux dernières commandes qui permettent simplement d’afficher l’aide de rsync pour voir si les options voulues sont bien implémentées (la mise à jour a réussi). Mise en place du script Le script s’exécute sur le nas DISTANT et “tire” les données à sauvegarder vers lui. Sur le DISTANT on créé par exemple un dataset dédié, classiquement, via l’interface web. Ensuite on se connecte en FTP dessus et on créé un dossier pour héberger le script, je l’ai appelé… “Scripts” ! Et un pour héberger les sauvegardes…. “Sauvegardes” !! Ensuite il vous faut le script, soit sur le lien vers l’article ci dessus, soit ici, je vous ai fait un petit zip. Il vous faut ensuite un éditeur pour mettre vos paramètres dedans, pour ma part j’utilise l’excellent Notepad++. Ouvrez donc je fichier du script et modifiez les paramètres entre les lignes 26 et 48, notamment les deux noms d’utilisateurs, adresse mail, IP du nas LOCAL et port SSH. Tout est commenté pour une meilleur compréhension. Modifiez ensuite le fichier liste.txt pour indiquer les fichiers et dossiers à exclure de la sauvegarde. Quand tout est fait on envoie via FTP tout cela dans le dossier Scripts créé sur le NAS Distant. Le script est maintenant sur le serveur mais il faut lui créer les conditions initiales qu’il s’attend à rencontrer, c’est à dire un dossier “courante” (normalement lien symbolique vers la dernière sauvegarde). Toujours sur le nas DISTANT on créé donc un dossier vide nommé “courante” dans le dossier abritant les sauvegardes (que j’ai appelé Sauvegardes ci dessus). Et voilà, comme on a déjà mis en place et testé la communication via ssh précédemment, normalement tout va rouler. Il reste à programmer l’exécution du script via cron. Dans l’interface web du NAS DISTANT on se rend dans System-> Cron Jobs -> Add Cron Job Pour l’utilisateur, c’est celui qui va exécuter le script, il faut donc que ce soit celui qui a les droits d’écriture sur le dataset hébergeant les sauvegardes (je rappelle que nous sommes là sur le nas DISTANT). Ensuite la commande c’est simplement le chemin complet vers le fichier de script ( par exemple /mnt/poolDistant/Scripts/script.sh). Enfin l’heure, on veut une exécution par jour (surtout pas +) à heure fixe, ici j’ai par exemple sélectionné minuit 10, en dessous dans Every N day of month, on laisse 1 et on coche tous les mois et tous les jours et bien sûr la case “Enabled” pour activer. Validez par OK et voilà enfin la fin du tuto ! Bien sûr pour la sauvegarde initiale, il vaut mieux avoir les deux NAS côte à côte sur le même réseau, modifiez les paramètres du script dans ce cas..
  7. Avançons encore un peu dans l’utilisation de notre NAS et voyons maintenant comment lui donner de l’interactivité multimédia car c’est souvent un point recherché pour l’usage familial. De plus à travers ce tuto nous allons surtout aborder la gestion des plugins et autres extensions, ce qui permettra bien plus de fonctionnalités plus tard… Plugins et jail dans FreeNAS Commençons par quelques généralités pour comprendre comment sont gérés les plugins dans FreeNAS : leur installation est basé sur le principe des jails FreeBSD. Une jail c’est quoi ? L’environnement jail (prison en français) est une fonctionnalité avancée des systèmes BSD qui permet d’installer des applications sur votre système en toute sécurité. L’environnement jail est en fait une partie virtualisée du système, ainsi pour un processus installé dedans tout est comme si il était installé directement dans le système sauf que si ce processus devient malveillant il ne pourra pas compromettre le système car il compromettra un système virtuel. En gros la jail est un système virtuel indépendant dans le système. Si vous voulez toutes les infos imaginables sur les jails lisez donc ceci, c’est le manuel FreeBSD en français et c’est très intéressant. FreeNAS propose 2 moyens d’ajouter des logiciels externes : la méthode “Plugin” et la méthode manuelle. Dans la méthode plugin c’est extrêmement simple : il suffit d’en choisir un à ajouter et toute l’installation est automatique : une jail est créée pour chaque plugin, celui ci est installé dedans et le tour est joué. La méthode manuelle vous permet de créer vous même une jail et d’y installer n’importe quel soft porté sur FreeBSD, cela permet d’installer différents logiciel dans la même jail et autorise bien plus de flexibilité. Par contre il faut tout faire en ligne de commande et bien connaître la chose. Nous allons voir ici les 2 méthodes. L’attribution des IP Préalable indispensable quelque soit la méthode choisie pour installer vos extensions dans FreeNAS : la gestion des adresses IP des jails. Et oui, une jail est un système virtuel qui va se voir doté d’une carte réseau virtuelle mais se comportant sur notre réseau comme une véritable machine. Une jail va donc avoir une adresse IP propre. Il est possible depuis cette version 9.3 de laisser le serveur DHCP gérer l’attribution d’adresse pour les jails ou alors de définir une plage fixe qui sera utilisée par FreeNAS pour les jails. Voyons les deux moyens. Gestion des IP de jails par DHCP Méthode facile : dans Jails -> Configuration on va simplement cocher IPv4 DHCP Configuration des jails Ceci est le plus simple si vous avez un serveur DHCP sur le réseau mais il peut être contraignant d’avoir une jail avec une IP non fixe pour accéder par exemple à l’application installée dedans. Ce problème peut être résolu au niveau du routeur en fixant un bail DHCP en fonction de l’adresse MAC ou alors avec la seconde méthode. Utilisation de plage fixe pour l’IP des jails Cette seconde méthode est utilisable sans soucis si votre réseau est en IP fixe. Si jamais vous avez un DHCP sur votre réseau c’est utilisable aussi mais prenez bien garde à définir la plage d’adresse en dehors de la plage attribuable par le DHCP. Au niveau configuration, c’est aussi dans Jails -> Configuration mais cette fois on clique sur le bouton Advanced Mode : Configuration IP des jails avancée IPv4 Network comprend normalement déjà l’adresse de votre réseau telle que vous l’avez défini ou que votre serveur DHCP l’a présenté à FreeNAS. Il est indispensable que les jails soient sur le même réseau que le NAS, faites donc très attention si vous voulez modifier l’adresse du réseau ici. Nous allons pour notre part configurer les IPv4 Network Start et End Address pour définir une plage en dehors de celle du DHCP. Exemple concret de chez moi : réseau classique 192.168.0.0/24 géré par une Freebox. La plage DHCP est définie de 192.168.0.1 à 192.168.0.49 avec quelques IP fixées selon l’adresse MAC : NAS, player, imprimante. Ici j’ai mis les jails de 192.168.0.200 à 192.168.0.220 donc sur le même réseau et en dehors de la plage. En ajoutant des plugins ou des jails, FreeNAS leur donnera la première IP disponible dans notre plage. Une fois cette étape validée on peut passer à l’installation d’un Plugin ou d’une Jail. Installation d’un plugin : Plex Media Server L’installation automatique Pour commencer simplement voyons la méthode d’installation d’un plugin avec Plex Media Server. On ne va pas s’étendre dessus mais Plex offre une plateforme centralisant les médias, une jolie interface avec récupération de métadonnées et permettant de les diffuser sur de nombreux terminaux (tablette, smartphone, PC, TV “intelligente”, etc…). Il a également une fonctionnalité de serveur DLNA mais pas paramétrable et mal organisé à mon sens. Bref, passons aux choses sérieuses : on se rend dans Plugins et s’affiche alors la liste des plugins disponibles : Liste des plugins Si la liste ne daigne pas s’afficher, c’est probablement que votre NAS n’a pas accès à internet ou n’arrive pas à résoudre le nom de domaine : c’est vérifiable en tapant “ping www.google.fr” dans Shell. En cas d’échec vérifiez la configuration du réseau : Default Gateway et/ou DNS. Pour installer Plex on clique simplement sur plexmediaserver dans la liste puis sur le bouton Install en bas de l’écran. On patiente… apparaît alors une demande de confirmation que l’on accepte évidemment. Installation du plugin Puis une fenêtre de contrôle de l’avancement… il faut absolument être patient jusqu’à la fin du processus et ne pas fermer la fenêtre et bricoler ailleurs sous peine d’échec de l’installation. Installation du plugin terminée Une fois l’installation automatique de la jail et du plugin terminée, ce dernier est visible en 3 endroits : dans l’onglet Installed sous Plugins avec un bouton ON/OFF qui permettra de l’activer ou non. Une entrée dans le menu de gauche sous Plugins permettra de le configurer éventuellement. Et la jail créée dans Jails où l’on peut éditer ses paramètres et surtout y ajouter un point de montage… Ajouter un point de montage La jail est un système virtualisé, les plugins qui sont installés dedans n’ont donc évidemment pas d’accès au reste de l’arborescence du système… sauf que ça nous pose un problème : nos données étant sur le pool de stockage, comment faire pour que Plex diffuse un contenu auquel il n’a pas accès ? C’est là qu’interviennent les points de montage : on va créer une sorte de lien dans la jail permettant de lier un dossier vers un autre présent à l’extérieur de la jail. Les données ne sont physiquement présentes qu’une seule fois mais accessibles depuis 2 endroits différents de l’arborescence. Donc attention : effacer des fichiers depuis le point de montage dans la jail les efface réellement du dossier source ! Dans l’optique de rendre nos données multimédias disponible à la diffusion par Plex, on va donc créer un point de montage de notre dataset Medias vers la jail, c’est à dire que l’on monte /mnt/Stockage/Medias en tant que (par exemple) /medias dans la jail. Pour cela on utilise le menu de gauche : Jails -> plexmediaserver_1 -> Storage -> Add Storage Ajout d’un point de montage dans une jail On créé une sorte de pont donc on sélectionne le dossier source : notre dataset contenant les fichiers réels et la cible qui se trouve dans la jail : ici j’ai pris /media qui existe déjà. Si le dossier n’existe pas il sera créé car la dernière case est cochée. On valide avec OK et le point de montage apparaît dans le menu de gauche. Le (gros) problème des droits Les droits d’accès, voilà une préoccupation récurrente de l’administrateur. Réfléchissons y ici pour la jail et notre point de montage : On l’a dit et répété : la jail est un système isolé du reste, donc les utilisateurs et groupes créés à l’intérieur de celle-ci sont inconnus à l’extérieur… et vis-versa : les utilisateurs et groupe de l’hôte FreeNAS n’existent pas dans la jail. Or en créant un point de montage on souhaite que des utilisateurs de la jail accèdent à des données extérieures. Vous voyez le problème arriver là ? Prenons le cas de Plex. Dans la jail, le logiciel Plex est lancé avec comme utilisateur plex:plex (utilisateur:groupe), or l’utilisateur plex n’existe pas ailleurs que dans la jail. Pour que cet utilisateur accède aux données du dataset Medias que l’on a monté dans la jail il y a deux solutions : Soit les permissions “Autres” de Medias sont autorisées au moins en lecture-exécution, style 755 ou 775, un truc qui fini en 5 ou plus dans tous les cas. Pour rappel si vous avez suivi ce tuto on a mis pour Medias les droits suivants : nobody:GrpMedias 770. Donc la première solution est de le passer en 775 pour que Plex puisse lire et utiliser les fichiers. Je ne vous cache pas que c’est la solution simple. Soit seconde solution si jamais on ne souhaite pas déverrouiller des permissions pour tous les autres utilisateurs : on a dit que le dataset Medias était en nobody:GrpMedias 770. Donc dans la jail le dossier /media du point de montage a été créé avec exactement les mêmes droits : nobody:GrpMedias 770. Notre problème est que dans la jail GrpMedias n’existe pas…. encore. Donc on va le créer et mettre l’utilisateur plex dedans. Ça nécessite de passer par la ligne de commande et ça mériterai grandement d’être amélioré dans une future version de FreeNAS. Voyons ça : On commence par lancer le shell ou se connecter en ssh à la machine si vous l’avez configuré. Menu de gauche, Shell là on liste les jails du système puis on exécute une commande, en l’occurrence un shell (au choix) pour se connecter dedans, concrètement on tape : jls liste les jails avec un numéro que l’on indique à jexec avec la commande à exécuter, ici le shell “csh” et on atterrit dans la jail (visible sur l’invite de commande) : jls jexec <numéro de jail> csh Connexion dans une jail On peut contrôler quels utilisateurs et quels groupes existent sur le système en affichant les fichiers /etc/passwd et /etc/group avec les commandes : On y voit plex et ses UID et GID 972. cat /etc/passwd cat /etc/group Nous allons alors créer le groupe GrpMedias avec la commande pw en lui donnant le même GID que dans l’hôte FreeNAS, c’est important pour éviter d’éventuels futurs problèmes incompréhensibles. Dans l’hôte le GID de GrpMedias est 1001. On y ajoute dans la foulée l’utilisateur plex, ce qui donne : Et voilà le travail : pw groupadd GrpMedias -g 1001 pw usermod plex -G GrpMedias Ajout Manuel d’un groupe dans la jail Activation du plugin Pour terminer maintenant que les fichiers sont accessibles à Plex on retourne dans Plugins -> onglet Installed et on passe Plex sur ON. Pour accéder à la page de configuration du plugin on va dans le menu de gauche Plugins -> PlexMediaServer et on clique sur le lien dans la fenêtre : lien d’accès à Plex Installation manuelle de minidlna Et encore plus corsé pour ceux qui suivent, là je ne vais pas expliciter en détail la totalité des concepts abordés car ce serait long. Renseignez vous sur FreeBSD si certains points sont obscurs : packages, navigation dans l’arborescence en ligne de commande, connexion à la jail vue ci-dessus,… mais toutes les étapes sont là quand même ! Le principe est de créer une jail FreeBSD, dans laquelle on pourra installer n’importe quel logiciel porté sur FreeBSD, dans notre cas minidlna. C’est parti ! Créer une jail Avant d’attaquer cette partie assurez vous d’avoir lu et surtout appliqué la partie “L’attribution des IP” plus haut sur cette page. Ensuite on se rend dans Jails -> Add Jails, dans la fenêtre qui s’ouvre on donne un nom à notre jail, ici j’ai mis “minidlna” car il n’y aura que ça dedans. Et on clique quand même sur Advanced Mode pour aller indiquer simplement l’adresse de notre passerelle dans IPv4 default gateway, ce qui donne accès à Internet à la jail : Création d’un jail Les autres champs réseau ont été remplis automatiquement en fonction de la configuration définie auparavant, c’est ainsi que vous y retrouvez l’adresse IP suivante dans ma plage que FreeNAS me propose. Bien sûr vous pouvez mettre autre chose si ça vous chante. Un clic sur OK et débute le téléchargement de l’image de la jail, puis son installation. Ça prend un temps certain, ne surtout rien faire d’autre sur l’interface en attendant. Installation de minidlna A l’aide du Shell ou en SSH on se connecte dans la jail et on installe minidlna : jls jexec <numéro jail minidlna> csh pkg install minidlna La mise à jour du catalogue commence, puis probablement on vous indique que pkg (l’utilitaire de gestion des packages) doit être mis à jour : Mise à jour de pkg Répondez “y” pour valider cette mise à jour préalable. Puis procédez de la même façon pour les fichiers et dépendances de minidlna. Le téléchargement de minidlna et de tous ses paquets dépendants commence puis minidlna est installé et enfin on voit dans les dernières lignes qu’un utilisateur et un groupe nommés “dlna” ont été créé. Le point de montage et les droits Là aussi, attention aux permissions ! Exactement comme ci-dessus pour Plex, on va ajouter un point de montage pour avoir accès aux fichiers médias depuis l’intérieur de la jail. ATTENTION : Si vous avez pris l’option de garder comme permissions nobody:GrpMedias 770 pour votre dossier de médias : ici pour minidlna et pour une raison que j’ignore pour le moment, l’option de recréer dans la jail le groupe GrpMedias et d’y ajouter “dlna” semble ne pas fonctionner. En tout cas je n’ai pas réussi ! La seule option me semble donc de passer le dataset Medias en 775 (de façon récursive si vous avez déjà des fichiers dedans) Vous n’avez pas ce souci si votre dataset Medias est déjà accessible au moins en lecture-exécution par “Autres”. Puis on créé via la GUI le point de montage par Jails -> minidlna -> Storage -> Add Storage. Source : /mnt/Stockage/Medias. Destination : /media. Ne pas cocher Read-Only, certains clients ne semblent pas aimer. Vous pourrez le mettre éventuellement après essais. Configurer minidlna Bien, maintenant qu’il est installé dans sa jail, que les fichiers médias lui sont accessibles à l’intérieur et que l’on a réglé le problème des droits, on retourne avec le Shell dans la jail pour configurer le tout. Cela est aussi possible en SSH depuis un terminal Linux, Mac OS ou Putty depuis Windows et c’est incroyablement plus confortable. Pour activer SSH pour un accès local, il suffit d’activer le service, les paramètres par défaut sont parfait. Et pour l’utilisateur que vous allez utiliser pour la connection il faut sans Account -> Users -> Pierre (par exemple) cocherAllow sudo. On se reconnecte dans la jail, vous savez faire maintenant. En SSH il faut mettre “sudo jexec” car jexec s’exécute en droit root. Ca donne ça : Connection via SSH dans une jail On édite le fichier de configuration de minidlna avec l’éditeur “ee” : Avec les flèches on descend ligne 18 pour remplacer media_dir=/opt par : cd /usr/local/etc ee minidlna.conf Puis ligne 25 on enlève le # et on met un petit nom sous lequel va se présenter minidlna, mettez ce que vous voulez : media_dir=/media Puis lignes 28 et 31 on enlève les # : friendly_name=Medias NAS db_dir=/var/db/minidlna log_dir=/var/log Et enfin, c’est très personnel et tout à fait optionnel : tout en bas je préfère indiquer : Cela affiche sur le client simplement l’arborescence du dossier /media comme il est. Sinon minidlna propose des dossier Music, Video, Pictures mais je ne les utilisais pas. A vous de voir et tester comme bon vous semblera pour ce dernier paramètre. root_container=B Finalement on appuie sur la touche Echap, s’affiche le menu de l’éditeur et on valide 2 fois par Entrée “leave editor” puis “save changes”. Le fichier de config est édité ! Je sens que vous brûler d’essayer pour voir si ça marche ! Alors on lance un essai : Si comme moi vous êtes déconfit à la vue d’un message “Shared object “libiconv.so.2″ not found, required by “minidlnad””, ne paniquez pas et relancez un : service minidlna onestart le tout en validant l’installation par “y” et cette fois le démarrage de minidlna doit fonctionner. pkg install libiconv Vous êtes gratifié d’un magnifique “Starting minidlna.” ? Alors il n’y a plus qu’à aller voir sur votre client favori pour tester ça. Si vous ne voyez aucun fichier, il y a fort à parier qu’il y ait un problème de droits sur votre dossier : voyez plus haut et mettez des droits de lecture et exécution pour “Autres” sur votre dataset Medias. Rendre le démarrage persistant Ne partez pas ! On a pas fini car on vient de démarrer minidlna à la main, mais au prochain redémarrage du NAS ou de la jail il ne se redémarrera pas tout seul. Donc on continue : toujours dans le shell et dans la jail on tape : echo minidlna_enable=”YES” >> /etc/rc.conf rc.conf étant le fichier qui gère les services à démarrer à la mise en route du système, la ligne minidlna_enable=”YES” va y être ajoutée. Et enfin, nous allons juste modifier la commande de lancement de minidlna pour forcer un rescan de la liste des fichiers au redémarrage, ceci se passe dans un fichier situé sous /usr/local/etc/rc.d donc on fait : cd /usr/local/etc/rc.d ee minidlna on descend à la ligne 25 et on ajoute l’option “-R” aux arguments, ce qui va donner ça (n’oubliez pas l’espace entre -R et -P): command_args=”-R -P $pidfile -u $minidlna_uid -f /usr/local/etc/minidlna.conf -R” On presse Echap, puis deux fois Entrée pour valider les changements et on quitte la jail et le shell en tapant 2 fois “exit”. Redémarrage de la jail pour contrôle Et pour terminer, nous allons tenter de faire un redémarrage de la jail afin de confirmer que tout fonctionne bien : Dans Jails -> View Jails, on sélectionne la jail à redémarrer et on clique sur le bouton Stop : Redémarrage de la jail L’arrêt peut prendre un peu de temps, soyez patient. Une fois stoppée le status passe en Stopped, minidlna n’est plus accessible depuis votre client et le bouton Stop devient… Start. On clique dessus, la jail démarre, le dataset Medias est rescanné, ce qui peut prendre un certain temps selon la quantité de fichier et tout est de nouveau disponible !
  8. Continuons notre configuration du NAS : nous avons précédemment créé un partage CIFS pour accéder au stockage depuis un PC situé sur le réseau local. Une fonctionnalité intéressante peut être d’accéder à des données depuis l’extérieur, depuis n’importe quel poste connecté à Internet, voyons ça dans un premier temps avec WebDAV… De la sécurité des données On vient de parler d’accéder à des données personnelles depuis n’importe quel poste Internet… c’est alléchant pour notre usage perso mais ça veut aussi dire que n’importe qui parmi les 1,5 milliards d’appareils connectés à ce jour peut potentiellement y accéder aussi. La première des priorités est donc d’assurer la sécurité d’accès à nos données et la confidentialité lors de leur transfert. Concernant l’accès, tout dépend de l’endroit où vous allez mettre le curseur de la sécurité : ça peut être ouvert à tous vents, protégé par un mot de passe, uniquement accessible depuis votre réseau via VPN, derrière un VPN avec authentification par clé ou carrément interdit : pour ce dernier cas, fin du tuto De la même façon on peut imaginer un partage en lecture seule, permettant de montrer des photos à mamie ou visionner une vidéo stockée sur le NAS depuis n’importe où, ou bien un partage en lecture-écriture permettant l’upload, mais aussi la suppression ou modification… A titre d’exemple tout à fait personnel, j’utilise de l’extérieur un accès SSH avec authentification par clé et un accès VPN par mot de passe via le serveur de la Freebox pour la navigation web depuis les hotspots wifi publiques (hôtels, etc…) et depuis le VPN j’accède occasionnellement à mes partages CIFS ou à l’interface de FreeNAS si besoin. Ici nous allons nous voir un autre moyen : le partage WebDAV, très pratique car il permet d’accéder à ses fichiers depuis n’importe quel navigateur web moderne, c’est donc assez universel. La connexion sera bien sûr sécurisée et cryptée (HTTPS/TLS). Le point faible de cette méthode réside dans l’authentification par mot de passe, aussi pour diminuer les risques ce sera en partage en lecture seule. Je le répète : CHACUN EST LIBRE DE SES CHOIX ET SURTOUT DOIT LES ASSUMER, faites votre config en propre conscience. Création d’un certificat Pour pouvoir utiliser TLS (SSL) depuis FreeNAS, que ce soit pour l’interface, WebDAV, FTP ou autres, il faut commencer par créer un certificat électronique, et même avant cela une autorité de certification car nous sommes en usage privé familial. Ce processus est nouveau dans FreeNAS : auparavant un certificat par défaut était créé à l’installation, le nouveau process permet à ceux bénéficiant de certificats signés par une autorité reconnue de l’utiliser (utile pour une société) et il nous permettra d’exporter le certificat créé et de l’importer dans une future installation par exemple, cela permettant d’éviter certains soucis de connexion sécurisée. Tout commence donc dans System -> CAs pour l’autorité de certification, et l’on clique sur Create Internal CA Création d’une Autorité de Certification Les points important sont de mettre au moins 2048 en longueur de clé et SHA256 est pas mal comme algorithme par défaut, le reste c’est comme vous le sentez. On valide par OK et voilà notre autorité est créée. Prochaine étape dans System -> Certificates on va créer le certificat qui nous intéresse en cliquant sur Create Internal Certificate : Création d’un certificat La fenêtre est très ressemblante à la précédente, sauf que l’on sélectionne l’autorité qui signe le certificat et on remplit le reste comme précédemment. Un clic sur OK et le certificat est généré. Il est maintenant disponible pour chiffrer les connections. Les limites et pièges de WebDAV Dans FreeNAS il y a quelques limites avec le partage WebDAV : en effet, pour s’authentifier sur un partage webDAV on n’utilise pas un nom d’utilisateur créé auparavant mais l’utilisateur “webdav” préexistant dans le système. Ceci implique donc que différents utilisateurs ne pourrons pas avoir des accès privés et uniques à leurs données puisque tout le monde utilisera “webdav” pour la connexion. Et donc comme l’accès à ce partage se fait via l’utilisateur webdav, il faut que celui-ci ai les permissions d’accès aux fichiers et dossiers à partager. C’est là le piège : soit webdav est propriétaire du fichier ou dataset, soit il fait parti d’un groupe qui a l’accès, soit dans les permissions “Autre” est réglé au moins en lecture-exécution. Exemple concret avec ce qu’on a défini précédemment, on se met dans l’idée d’un partage WebDAV en lecture seule : Pour partager le dataset Public qui est en 775, il n’y a pas de problème car Autre est en lecture-execution Pour partager le dataset Medias qui est en 770, il va falloir soit ajouter l’utilisateur “webdav” au groupe GrpMedias, soit passer en 775. Pour partager le dataset Paul qui est en 700, il faut soit passer en 705 (pas terrible car ce n’est pas le but), soit ajouter “webdav” au groupe Paul et passer le dataset en 750. C’est là qu’on comprend que n’importe quel autre utilisateur accédant au partage WebDAV peut alors voir les données du dataset Paul, ce qui n’est pas le but à l’origine. Création d’un partage WebDAV On va donc ici créer un partage WebDAV du dossier Medias afin que Pierre et Paul aient accès aux fichiers de ce dataset en lecture seule. NB : il est recommandé de ne pas créer plus d’un type de partage par dataset, or Medias est déjà partagé en CIFS, ce qui va à l’encontre de la recommandation. Certes, mais on ajoute ici un partage en lecture seule, ce qui ne devrait pas créer de corruption de fichiers. On commence donc par ajouter l’utilisateur webdav au groupe GrpMedias qui détient le dataset Medias : dans Account ->Groups -> View Groups on clique sur GrpMedias et sur le bouton Members : Modification des membres d’un groupe Dans la liste Available, on sélectionne webdav (tout en bas) et on clique sur >> pour le passer en Selected. Évidemment on valide. Puis dans Sharing -> WebDAV Shares -> Add WebDAV Share on remplit les champs : Création d’un partage WebDAV Le nom du partage, un commentaire optionnel puis le chemin vers le dataset à partager. Ici j’ai coché Read Only ce qui force le partage en lecture seule, quelles que soit les permissions sur le dataset. Point important : Dans notre cas on DECOCHE Change User & Group Ownership. Cette case si elle est cochée va changer les propriétaires du dataset Medias et de TOUS ses fichiers et sous-dossiers en webdav:webdav. Ceci afin d’en permettre l’accès. Nous on a pris la méthode douce en mettant webdav dans le groupe qui a accès à Medias donc on décoche. En validant on nous demande si on veut activer le service WebDAV, on met non car on va commencer par le configurer. Dans Services -> WebDAV on va régler les paramètres impactant l’ensemble des partages WebDAV : Configuration du service WebDAV On veut un accès sûr, donc HTTPS seul en protocole, concernant le port on peut mettre celui qu’on veut mais il ne doit absolument pas être occupé par un autre service, je vous conseille de changer celui par défaut pour plus de sécurité également. Pour le certificat, c’est simple, on sélectionne celui que l’on a créé au début. Digest Authentication permet de ne pas faire circuler le mot de passe en clair, surtout utile en HTTP mais on peut laisser, et enfin on défini le mot de passe qui va être utilisé pour toutes les connexions aux partages WebDAV. Plus il est fort et mieux c’est pour la sécurité des données. N’oubliez pas que c’est la seule barrière ici. Enfin, on valide et on active le service en le passant sur ON dans Services -> Control Services. Accéder au partage Testons immédiatement tout ça, un petit coup de Firefox et on se rend à l’adresse suivante : https://ip.du.NAS:port/partage Par exemple dans mon cas en interne : https://192.168.0.9:8081/Medias ALARME ! Alerte rouge ! Au feu ! Au loup ! “Connexion non certifiée, accès non recommandé”. Qu’est ce que c’est que ça ?!?! Ben oui, se créer soi-même son propre certificat est quand même assez moyen au niveau authentification, donc le navigateur nous l’indique : on choisi de poursuivre quand même en acceptant notre certificat et ajoutant une exception. Ensuite : nom d’utilisateur : webdav et mot de passe : celui que vous avez choisi. Et voilà ! Accès au partage WebDAV Bon, là il n’y a aucun fichier dedans mais l’esprit y est ! Pour un accès depuis l’internet, ce n’est pas plus compliqué : dans le routeur / box, il suffit de faire une redirection du port choisi vers le NAS et de se connecter avec votre adresse IP publique : https://ip.publique:port/Medias Et voilà pour WebDAV dont on a fait le tour, là on a utilisé un navigateur, on peut faire pareil avec un client WebDAV sur smartphone par exemple… Prochain tuto à venir : on va revoir le FTP car la config a un peu évoluée.
  9. Cinquième partie du tutoriel concernant FreeNAS 9.3 : cette fois ci, nous abordons la création des partages. Nous avons vu précédemment comment créer des utilisateurs, leur attribuer des permissions d’accès à certaines parties du stockage et voici maintenant le temps de leur créer une porte vers ce nouvel espace. Un partage c’est effectivement ni plus ni moins qu’une porte d’accès vers un volume ou un dataset, afin qu’une machine distante puisse utiliser l’espace de stockage. Le type de partage à créer dépend du système d’exploitation qui va devoir l’utiliser. Dans FreeNAS 9.3 cinq types de partages sont disponibles : Partage Windows (CIFS) : C’est celui qui est supporté par le plus grand nombre d’OS : Windows, Mac OS X, Linux et BSD. Sa plus grande limitation réside dans le fait que Samba, utilisé par FreeNAS pour fournir le partage CIFS, est mono-thread, il n’utilise donc qu’un seul cœur du processeur, même si celui ci en a 8 et cela le rend plus lent que les autres partages. Partage Apple (AFP) : uniquement pour Mac OS X Partage Unix (NFS) : Supporté par Mac OS X, Linux et BSD bien sûr, mais aussi Windows, par contre uniquement dans ses versions Entreprise pour Windows 8 ou Entreprise et Ultimate pour Windows 7. Partage iSCSI : partage de blocs, on en parlera pas ici car c’est une utilisation plus “avancée” Partage WebDAV : le petit nouveau de FreeNAS 9.3, permet un accès simple aux fichiers depuis un navigateur web ou un client webDAV, on en parlera dans un prochain tuto. POINT IMPORTANT : Il est extrêmement déconseillé de créer différents types de partages vers le même dataset, même si cela est tentant et pas interdit par l’interface. Si vous avez un Mac et un PC Windows qui doivent accéder au même dossier, ne faites qu’un partage CIFS (ou NFS) mais surtout pas un CIFS pour le windows et un AFP pour le Mac : ce serait s’exposer aux ennuis. Donc dans cette partie nous allons créer des partages CIFS car malgré ses limitations (relatives) en terme de performances, c’est celui qui est accessible par le plus grand nombre et les utilisateurs de Windows sont les plus nombreux. Ceci s’effectue en 2 étapes : d’abord on configure le partage proprement dit et ensuite il faut paramétrer le service chargé de fournir les partages. Création d’un partage CIFS avec authentification On peut créer deux types de partages : soit nécessitant une authentification avec nom d’utilisateur et mot de passe, il est visible sur le réseau mais seul les personnes autorisées à y accéder, soit un partage ouvert, visible sur le réseau et montable par tout le monde. Commençons donc par la version authentification : Dans Sharing -> Windows (CIFS) Shares -> Add Windows (CIFS) Share, la fenêtre basique est bien simplifiée par rapport aux anciennes versions : Création du partage CIFS Nous allons commencer par créer un partage pour les données de Pierre : dans Path, nous renseignons le chemin du dataset vers lequel le partage doit mener, en cliquant sur Browse on navigue vers le dataset et il suffit de le sélectionner. Ensuite dans Name, on indique le nom du partage : c’est ce nom qui sera visible sur le réseau et depuis Windows. Et enfin comme on crée ici un partage nécessitant pour y accéder d’avoir un compte sur le NAS et de s’identifier avec, on laisse vide la case Allow Guest Access. Apply Default Permissions concerne les ACLs, cela les configure avec les options par défaut, je rappelle que j’ai choisi de ne pas m’en servir donc cela sera sans effet. Enfin, on valide avec OK… le partage est créé et FreeNAS, pas bête, se dit qu’on vient de configurer un nouveau partage mais que comme c’est le premier, le service n’est pas encore activé et il nous propose de le faire maintenant : Confirmation activation service CIFS Chose que l’on s’empresse d’accepter. Le service CIFS (Samba en fait) est démarré avec les paramètres par défaut, ce qui nous convient bien dans le cas général, donc on ne touche à rien. La page de contrôle des services s’est affichée et on voit que normalement le bouton CIFS est passé sur ON : parfait ! Note : Dans les paramètres par défaut pour le CIFS c’est le groupe de travail WORKGROUP qui est utilisé. Si à tout hasard ce n’est pas le cas chez vous il faudra le modifier. Connexion au partage depuis Windows Pour accéder à notre partage depuis un poste Windows il y a plusieurs possibilités, par exemple dans Ordinateur ->Réseau on voit apparaître le NAS (cela peut prendre plusieurs minutes après activation du service) Windows fenêtre réseau On double-clic alors sur FREENAS et c’est la liste des partages du NAS qui s’affiche, bon pour l’instant il n’y a pas trop de choix, on en a qu’un, donc on y va et on l’ouvre. Ici 2 possibilités : soit vous avez fait sur le NAS un compte avec le même nom d’utilisateur et le même mot de passe que Windows et normalement ça doit marcher, soit comme moi vous ne vous appelez pas Pierre et vous avez la fenêtre d’identification : Windows fenêtre d’identification Bien sûr on remplit avec le nom d’utilisateur et le mot de passe de notre utilisateur FreeNAS, ici pour moi c’est “Pierre”. Et voilà ! on est connecté au stockage, on peut déposer des fichiers. Comme ce n’est pas très pratique de passer par “Réseau”, on va monter le partage comme un disque réseau pour l’avoir en accès simple en permanence aux côtés des disques classiques. Pour cela on revient à la liste des partages du NAS, clic droit sur celui à monter, et on sélectionne Connecter un lecteur réseau… Windows, montage d’un lecteur réseau on lui attribue une lettre, et le tour est joué ! Une autre méthode pour connecter : via la ligne de commande, on ouvre un terminal par Démarrer, exécuter, “cmd” et l’on tape : net use x: nom_ou_IP_du_NASnom_du_partage /USER:utilisateur avec x, la lettre de lecteur à attribuer et le chemin selon le votre évidemment. “utilisateur” est à remplacer par le nom de l’utilisateur qui aura l’accès au partage. On valide et Windows demande ensuite le mot de passe de l’utilisateur. On le tape et c’est terminé, ce sera la seule fois. Création d’un partage CIFS sans authentification L’autre méthode de création de partage est un accès invité (guest) : le partage est visible de tous et n’importe qui présent sur le réseau et bénéficiant des permissions associées peut y accéder sans avoir besoin de compte utilisateur sur le NAS ou sans authentification. ATTENTION : Accès sans authentification ne signifie pas partage ouvert à tous vents : la partage n’est qu’un moyen d’accès à un dataset et les permissions accordées restent toujours celles du dataset, que l’utilisateur soit authentifié ou non. S’il n’est pas authentifié, les permissions sont donc celles de la catégorie “Autres” : dans ce cas pour accéder au partage sans authentification il faut que le dataset soit au moins en 705 et pour déposer ou modifier un fichier en 707. Pour rappel si la gestion des droits n’est pas claire pour vous, reportez vous aux chapitres 1 et 2 de cet article Wikipedia. On va essayer avec le dataset “Public” (permissions réglées en 775 préalablement) que l’on va partager également. Nous retournons dans Sharing -> Windows (CIFS) Shares -> Add Windows (CIFS) Share, et cette fois on coche la case Allow Guest Access. Comme tout à l’heure on sélectionne le dataset avec le bouton Browse. Partage CIFS ouvert On valide, et on s’empresse d’aller tester sur Windows : cette fois plus besoin d’identification pour accéder au dossier partagé Public ! Cacher des fichiers et dossier : les veto files Et pour finir sur les partages, une astuce un peu plus avancée : les datasets Pierre, Paul et Jacques sont des dossiers “home”, ils contiennent entre autre des fichiers cachés commençant par un point (comme .login par exemple) qui stockent des infos nécessaires au système. En aucun cas il ne faut les modifier ou les supprimer. Par défaut il sont cachés mais un autre moyen existe pour ne simplement pas les partager : l’utilisateur ne les verra simplement jamais. Pour cela on va éditer notre partage et afficher les paramètres avancés, ici je le fait sur celui de Pierre : Dans Windows (CIFS) Shares -> Perso Pierre, on clique sur Advanced Mode et tout en bas de la fenêtre dans Auxiliary Parameters on ajoute ces deux lignes : veto files = /Temporary Items/.DS_Store/.AppleDB/.TemporaryItems/.AppleDouble/.bin/.AppleDesktop/Network Trash Folder/.Spotlight/.Trashes/.fseventd/.cshrc/.login/.login_conf/.mail_aliases/.mailrc/.profile/.rhosts/.shrc delete veto files = yes le paramètre “veto files” défini une liste de fichiers ou dossier à ne pas afficher. “delete veto files” permet d’autoriser la suppression automatique des fichiers lorsque vous supprimez un dossier qui vous semble vide mais qui contiendrai en fait l’un des fichiers listé ci dessus. Voilà, nous avons fait le tour des options de base concernant les partages CIFS, le NAS est parfaitement fonctionnel à présent.
  10. Quatrième partie de la série de tutoriels consacrée à la mise en place d’un NAS avec FreeNAS. Précédemment, nous avons créé notre pool de stockage, nous voici alors avec cet énorme espace à organiser. C’est ce que nous allons voir maintenant en créant des utilisateurs et en leur attribuant à chacun un espace de stockage, le tout en gérant les permissions d’accès. Comme dans l’étape précédente, nous allons avant tout commencer par réfléchir. C’est une étape clé, il faut absolument savoir comment on va s’organiser avant de commencer. Faire le point sur les besoins Dans le cadre de ce tuto nous allons avoir 3 utilisateurs : Pierre, Paul et Jacques. Chacun aura un dataset “privé” auquel il sera le seul à avoir accès. Pierre et Paul utilisent Windows, Jacques est sur Mac. Schéma des accès Pierre et Paul auront tous deux un accès libre à un dataset Medias, leur permettant de mettre en commun leur musique et films. Et enfin un dataset Public sera disponible pour les fichiers que les trois utilisateurs souhaiterons se partager et ce dataset sera ouvert en lecture à toute autre personne connectée à leur réseau. Comprendre la gestion des droits Un des point clé pour bien comprendre ce que nous faisons est d’être familiarisé avec la gestion des permissions UNIX. C’est en effet par ce système simple que l’on va régler les accès, depuis le NAS, à nos différents datasets. Si vous avez ensuite des besoins avancés en terme de gestion de droits pour des fichiers ou dossiers individuels il faudra le faire via le système d’exploitation client : c’est là qu’entrent en jeu les ACLs. Nous n’aborderons pas ce point ici et resterons sur les permissions de base type UNIX. Il est très important de comprendre les notions d’utilisateur, de groupe, de propriétaire ainsi que les actions sur lesquelles les droits sont attribuables : Read, Write, Execute. Allez lire les 2 premiers chapitres de la page Wikipedia consacrée aux permissions UNIX, il est indispensable de maîtriser cela et c’est relativement simple. Création des datasets Maintenant que l’on a mis à plat ce que l’on souhaite faire, on va commencer par “découper” notre espace de stockage pour chaque usage. On va d’abord créer un dataset pour chacun de nos utilisateurs et on va leur attribuer 200Go chacun, c’est un exemple et l’intérêt est ici de voir que cela n’est pas fixe et peut être augmenté ou modifié ultérieurement à volonté. Donc dans Storage -> Volumes -> /mnt/Stockage (dans mon cas) -> Create Dataset : Création d’un dataset Ici je choisi de donner aux datasets le même nom que l’utilisateur qui l’utilisera, en effet ce sera également son dossier home, servant à stocker les fichiers cachés propres à l’utilisateur et il est important que le dossier home ai le nom de son détenteur. Les paramètres laissés sur inherit sont repris sur le dataset parent : on laisse par défaut ici comme cela convient mais vous pourriez choisir un niveau de compression différent par exemple. Le Share type est laissé sur UNIX, cela est dépendant du partage que vous allez attribuer à ce dataset : pour du CIFS, on peut mettre Windows, ce qui permet d’améliorer la prise en charge des ACLs pour gérer les droits mais je trouve cela trop complexe pour un usage à domicile. Je prends donc le parti de mettre UNIX pour tous mes datasets. Il s’agit là d’un choix personnel et non d’une règle, libre à vous de tester et faire comme bon vous semble. Point intéressant : on clique sur Advanced Mode, cela fait apparaître les champs permettant de définir les quotas et réservation d’espace. Le quota permet de limiter l’espace maximum que pourra occuper le dataset. Le même réglage est possible pour le dataset et tous ses “enfants” (sous-datasets). 0 signifie : pas de quota. Mais vous pouvez indiquer par exemple 20G ou 1T pour autoriser 20Go ou 1To maximum. Le quota est simplement une limite, vous pouvez mettre 2 dataset avec 800Go de quota sur un pool de 1To. La réservation d’espace va non seulement fixer la limite mais carrément réserver l’espace : vous pouvez mettre une réservation de 500Go et stocker seulement 100Go dans un dataset : celui ci prendra quand même 500Go d’espace sur le pool. Quota et réservation d’espace Ici on donne un quota de 200Go maximum à Pierre, sans faire de réservation. Un clic sur le bouton Add dataset et celui ci est créé. De la même façon, on créé les datasets Paul, Jacques, Medias et Public : Liste des datasets créés Création des groupes Nous allons commencer pour plus de facilité par la suite, par créer les groupes puis nous ajouterons les utilisateurs dedans lors de la création de ces derniers. Les groupes vont permettre de gérer finement les accès utilisateurs conformément au schéma établi plus haut. Ainsi on va créer un groupe “GrpMedias” dans lequel on mettra Pierre et Paul et qui sera propriétaire du dataset Medias. Un autre groupe appelé “TousUtilisateurs” regroupera nos 3 compères et ce groupe sera propriétaire du dataset Public. Le schémas suivant résume les propriétaires de chaque dataset : Groupes et propriétés Créer un groupe est très simple : on se rend dans Account -> Groups -> Add Group et on a simplement à remplir le nom du groupe sans se préoccuper du reste : Création d’un groupe L’opération est répétée pour le groupe TousUtilisateurs. Création des utilisateurs Nous allons maintenant nous rendre dans Account -> Users -> Add User pour créer nos utilisateurs : Création d’un utilisateur 1/2 Création d’un utilisateur 2/2 Donc on remplit le nom d’utilisateur, on laisse coché Create a new primary group for the user, qui va créer un groupe du même nom que notre utilisateur et l’ajoutera dedans. Ici on créé donc un groupe Pierre en même temps que l’utilisateur Pierre et Pierre est seul membre de ce groupe. Point important on sélectionne le dataset “Pierre” comme Home Directory. Puis viennent nom complet, adresse mail, mot de passe qui se passent de commentaires. Enfin dans Auxiliary groups on sélectionne pour Pierre “GrpMedias” et “TousUtilisateurs” et on ajoute Pierre dedans par un clic sur >> qui fait passer les groupes dans la liste selected. Cette opération peut aussi se faire après coup dans Account -> Groups -> View Groups en sélectionnant le groupe à modifier et en cliquant sur le bouton Members. On reproduit l’opération pour Paul et Jacques, sachant que ce dernier est ajouté uniquement dans le groupe “TousUtilisateurs”. Attribution des permissions Nous avons à présent nos datasets, nos utilisateurs et nos groupes, il ne reste qu’à les lier ensemble et à paramétrer les accès. On veut donc que chaque utilisateur ai accès à son dataset mais pas à celui des autres et que Pierre et Paul puissent lire et écrire dans Medias mais pas Jacques et enfin que tous puissent lire et écrire dans Public. On se rend dans Storage -> View Volumes et on sélectionne le dataset Pierre puis on clique en bas sur le bouton Change Permissions (le premier de la ligne) : Attention ! Je rappelle que la connaissance de la gestion des permissions unix est nécessaire pour bien comprendre cette partie. Modification des permissions Pierre Les propriétaires utilisateurs et groupes ont été automatiquement définis à Pierre (utilisateur) et Pierre (groupe) car le dataset est le dossier home de Pierre. Nous décochons les cases Read et Write de Other pour n’autoriser un accès qu’au propriétaire. Ici les droits du groupe n’ont pas d’importance puisque Pierre est seul membre de son groupe éponyme. Un clic sur Change valide les changements effectués. On procède de la même façon pour Paul et Jacques. Concernant le dataset Medias, c’est un peu différent : Permissions du dataset Medias Pour celui ci, il n’y a pas vraiment de propriétaire utilisateur car c’est un dataset que l’on va partager, on choisi donc ici un propriétaire nobody, et bien sur notre groupe GrpMedias comme groupe à qui appartient le dataset. On coche toutes les permissions pour le groupe et décoche celles des autres utilisateurs. Pour le dossier Public enfin : Permission du dataset Public Cette fois on considère (par exemple) que les données sont destinées à être partagée donc on coche Read et Executepour les autres utilisateurs, pour l’instant il n’y en a pas d’autres mais on verra plus tard comment faire un partage sans authentification de sorte que n’importe qui se connecte sur le réseau puisse y accéder. Nous voici maintenant avec un NAS bien organisé, la prochaine étape est de créer des partages afin que les machines des utilisateurs puissent avoir accès à ces espaces de stockage. NOTE : Tous les paramétrages abordés ici ne sont que des exemples permettant de comprendre le système, il est impossible de trouver une configuration convenant à tout le monde donc libre à vous de l’adapter ensuite à votre propre usage.
  11. Troisième partie de la série de tutoriels consacrée à la mise en place d’un NAS avec FreeNAS. Nous avons grâce à l’étape précédente, une installation toute neuve et configurée de FreeNAS. Attaquons nous maintenant à la création de l’espace de stockage : le pool ZFS. Depuis cette version, FreeNAS ne propose plus qu’un seul système de fichier à la création : le ZFS. Il est donc indispensable avant d’aborder cette partie que vous maîtrisiez les fondamentaux de ZFS. Si ce n’est pas le cas, j’ai fait un article sur le sujet pour aborder les bases. Idem pour les notions de RAID, il y a un article sur Wikipédia. Penser son pool Il est important de bien savoir ce que l’on veut faire avec ses disques car les modifications ultérieures sans détruire le pool sont limitées. Un autre point très important est de bien garder en tête qu’un RAID quel qu’il soit n’est pas une sauvegarde. Un RAID ne protège pas des erreurs de manipulation, ne protège pas d’une grosse défaillance matériel (alimentation par exemple), ne protège pas du vol de la machine, etc… Si le sujet de la sauvegarde vous intéresse, j’ai posté là encore un mot à ce sujet, il date un peu mais c’est toujours d’actualité. Le RAID quel qu’il soit doit être vu comme un moyen d’assurer la disponibilité des données et la continuité du service en cas de panne mais pas comme un moyen de sauvegarder ses données. Vous seul pouvez jugez de vos besoin et de vos attentes en terme de sécurité/valeur des données/utilisation/coût. Typiquement les possibilités d’organisation sont : Un ou plusieurs vdev miroirs de 2 disques offrant une bonne sécurité et de très bonnes performances en terme d’opérations par secondes, au prix d’un coût de stockage multiplié par 2. Un vdev RAIDZ de 3 ou 5 disques : perte d’un disque possible, sécurité moyenne, plus grand volume offert. Plus il y a de disques et plus le risque est grand. Typiquement une utilisation “Médias” Un vdev RAIDZ2 de 6 disques : perte de 2 disques possible, meilleur sécurité pour les grands vdev (maxi 10 disques par vdev recommandé), au prix d’un espace utilisable plus amputé et donc un coût plus important. Typiquement une utilisation “Stockage” Le RAIDZ2 tend à être privilégié par rapport au RAIDZ simple pour les pools récent avec des disques de grande taille (plus de 1-2To) car plus la taille du pool est importante et plus l’opération de reconstruction après remplacement d’un disque va être longue et intense. Le risque de perdre un second disque est alors plus important. D’autre part comme l’a souligné SmallGuy en commentaire : plus le disque est grand, plus la probabilité d’avoir une erreur irrécupérable sur l’un des disques restant est forte, cette erreur sera détectée par ZFS grâce à la checksum mais ne pourra pas être corrigée faute de redondance à ce moment là dans un RAIDZ1. L’erreur peut n’impacter qu’un fichier mais peut aussi conduire à l’impossibilité de reconstruire le pool. Pour notre tuto qui s’inscrit dans un usage familial, nous allons faire un RAIDZ avec 3 disques de 1To. ATTENTION : Un RAID ne remplace pas une sauvegarde et vous seul restez responsable de vos choix, encore plus quand il s’agit de la sécurité de données personnelles. Construction du pool On se rend dans Storage -> Volumes -> Volume Manager pour découvrir la nouvelle version du gestionnaire de volume. Celui ci inclus des protections permettant théoriquement de limiter les erreurs du style ajout d’un vdev stripe à un vdev RaidZ par exemple. Volume Manager : exemple d’un pool miroir Toutefois les protections peuvent être gênantes : il ne permet pas notamment de créer un vdev avec des disques de différentes tailles, alors que cela est tout à fait possible sachant que tous les disques ne seront exploité qu’à la taille du plus petit. Si vous êtes gêné par cette limitation, il faudra cliquer sur le bouton Manual Setup et l’ancien gestionnaire de volume. Revenons à notre volume et commençons par lui donner un nom, sachant que mirror, stripe, raidz, raidz2 et raidz3 sont des noms réservés. Il vaut mieux trouver quelque chose qui ressorte bien. Il est possible ici de choisir en cochant la case Encryption, de crypter le pool. Cela s’effectue directement au niveau des disques puis le pool est construit par dessus, c’est utile si vous travaillez à la CIA, sinon… chacun son choix mais 2 choses à prendre en compte : d’une part si vous perdez la clé de cryptage, impossible de retrouver les données, et d’autre part, il est recommandé d’avoir un processeur supportant le jeu d’instructions AES-NI pour ne pas avoir de diminution de performances. Volume Manager, création d’un RaidZ Dans Available disks, en passant la souris sur show on voit la liste des disques détectés par le système. Un clic sur le bouton + les ajoute tous dans le pool. Sinon en faisant glisser le petit curseur rond, on choisit le nombre de disque à mettre dans le pool. Le gestionnaire nous propose dans le menu déroulant la géométrie optimale : ici avec 3 disques un RaidZ. Ça tombe bien c’est ce qu’on voulait (on peut aussi faire un miroir triple si on manque de confiance ou un stripe si on aime le risque !). Quand tout est bon, un clic sur Add Volume et le pool est créé. Cela prend quelques temps. Visualiser la structure Pour contrôler l’organisation de notre pool on se rend dans Storage -> Volumes -> View Volumes. Cette page liste les pools et datasets présents sur le système, attachons nous à bien la comprendre : Visualiser les volumes En tête de liste on retrouve notre pool : Stockage. Imbriqué en dessous, créé automatiquement en même temps, le dataset “Stockage”. Le dataset est le système de fichier ZFS en lui même, alors que le pool représente l’espace qui lui est offert. On retrouve là toute la logique de ZFS : pour le système de fichier, quel que soit la structure sous-jacente dans le pool, ce n’est qu’un espace unique à diviser à volonté. Lorsque l’on créera d’autre datasets plus tard ils seront dans le dataset Stockage. Un clic pour sélectionner une ligne fait apparaître en bas les boutons d’actions. Ici j’ai sélectionné le pool, si on clic sur le bouton Volume Status on obtient l’état et le détail du contenu du pool : Détail de l’état du pool On retrouve donc notre pool stockage et les vdev qui le constituent : on est là dans la partie “gestionnaire de volume” de ZFS. Donc on peut voir un vdev de type raidz1 qui porte le numéro 0. Celui ci est composé des 3 disques ada1, ada2 et ada3. Si on agrège d’autres vdev dans le pool, ils apparaîtrons en dessous au même niveau que le vdev existant. Les colonnes Read, Write et Checksum indiquent les erreurs éventuelles de lecture, écriture et sommes de contrôle : il vaut mieux que tout reste à 0 Comprendre et adapter les options de ZFS Pour finir à propos de notre espace de stockage, nous allons jeter un œil aux options ZFS : toujours dans Storage ->Volumes -> View Volumes (ou directement sur le bouton Storage du haut), nous sélectionnons le dataset (et pas le pool) et cliquons en bas sur le bouton Edit Options qui est celui avec la clé plate. Options ZFS On voit ici les paramètres appliqués par défaut lors de la création du dataset racine. Premier paramètre, le choix de l’algorithme de compression, ici LZ4 : ZFS permet, pour gagner de la place, de compresser au niveau du système de fichier les données stockées. LZ4 est un algorithme rapide qui impactera peu les performances, il est conseillé de le laisser activé. Enable atime, pour “access time”, contrôle le fait d’actualiser ou non l’heure d’accès stockée dans les métadonnées d’un fichier quand il est lu. Mis sur Off, cela permet d’économiser des écritures lorsque l’on lit simplement un fichier. C’est le réglage que j’utilise mais cela peut parfois troubler certains logiciels de sauvegardes par exemple. Un mot sur la Deduplication enfin, dans le cadre de notre usage je n’aurais qu’une forte recommandation : NE SURTOUT PAS Y TOUCHER. Par défaut désactivée, la déduplication est un moyen permettant de ne pas dupliquer des données déjà existantes ailleurs dans le stockage et d’enregistrer simplement un pointeur vers un bloc unique. Problème : la table stockant tout cela est en RAM, il faut donc 3 à 5 Go de RAM par To de stockage, s’il n’y en a pas assez le système panique et une fois activée la déduplication ne peut plus être désactivée. La prochaine étape va être de créer nos utilisateurs, leur donner de l’espace et créer les partages nécessaires pour accéder à nos données.
  12. Continuons la mise en place de notre NAS sous FreeNAS en version 9.3 : nous venons de voir les étapes nécessaires à l’installation dans le précédent tutoriel. Il est désormais temps de se connecter à l’interface graphique pour configurer le tout. On attaque dans cette partie la configuration de base. A partir de notre navigateur préféré (là, c’est une question de goût, je ne me prononce pas !) on se rend à l’adresse IP indiquée par le menu console. Pour les étourdis on peut aussi y accéder par ici : http://freenas.local Donc soit vous avez défini un mot de passe pour root à l’installation, dans ce cas il faut se connecter avec “root” en nom d’utilisateur et votre mot de passe (je vous rappelle à toutes fins utiles que le clavier était en qwerty lors de l’installation…) Sinon la première chose demandée est donc de définir maintenant ce fameux mot de passe : Définition du mot de passe root Puis nouveauté de la version 9.3, nous tombons sur un assistant configuration qui nous propose de créer un pool de stockage, puis des services d’identifications, et enfin des partages et les utilisateurs associés. Assistant configuration de FreeNAS 9.3 L’assistant est relativement bien fait, petit bémol au niveau des partages et des utilisateurs, ce n’est pas la partie la plus simple. L’avantage est que cela est assez rapide, l’inconvénient c’est qu’on ne maîtrise pas tout et surtout je trouve que l’on ne comprend pas bien ce que l’on fait. C’est donc pour ça que j’ai choisi de ne pas utiliser cet assistant pour le tuto, on clique donc sur Exit. NOTE IMPORTANTE : La configuration que nous allons faire ensemble maintenant et pour la série de tutos à venir est basée sur une configuration à minima. Le but est d’utiliser simplement le NAS dans un réseau domestique classique avec une “box” de FAI (Freebox dans mon cas), plusieurs utilisateurs avec un espace de stockage dédié et un espace commun, et un partage CIFS (SMB) pour y accéder depuis Windows. Configuration réseau Commençons donc par terminer la configuration réseau de notre NAS : on se rend dans Network -> Global Configuration Configuration réseau Ici il faut commencer par indiquer la passerelle par défaut dans IPv4 Default Gateway, il s’agit d’indiquer à FreeNAS quelle machine sur le réseau lui permet d’accéder à Internet : l’adresse IP de la box semble donc un bon choix. Puis dans au moins le premier des champs Nameserver il faut indiquer l’adresse d’un serveur DNS pour permettre au NAS de résoudre les noms de domaine : ici j’ai mis la Freebox car elle fait un pont vers ses DNS et en 2 et 3 les serveurs d’OpenDNS. Cela fait n’oubliez pas de cliquer en bas sur Save sinon les modifs sont perdues en changeant de rubrique dans l’interface. Vous devriez retrouver la config dans Network->Network Summary Configuration système On se rend ensuite dans System -> General pour faire 3 réglages simples : Configuration système générale D’une part l’adresse de l’interface : WebGUI IPv4 Adress à paramétrer sur l’adresse du NAS : c’est celle qu’utilisera le serveur intégré pour fournir l’interface. Ensuite le fuseau horaire dans Timezone. Et enfin dans Console Keyboard Map on sélectionne French ISO-8859-1 (accent keys), si on a un clavier français, ce qui permet d’avoir un clavier azerty dans la console : c’est à dire uniquement quand on intervient directement avec clavier et écran branché sur le NAS (ce dernier réglage est actif uniquement après reboot d’après mes tests). Si vous voulez changer la langue de l’interface, le français est disponible. La traduction est partielle, c’est pourquoi je reste en anglais, mais les fonctions ancienne et courantes sont bien traduites. N’oubliez pas de valider les réglages par un clic sur Save. Ensuite, facultatif mais pratique pour mieux comprendre et/ou se faire aider en cas de problème : dans System ->Advanced on peut cocher la case Show console messages in the footer pour voir les messages que le NAS écrit dans le fichier /var/log/messages Configuration système avancée Paramétrage des mails Il est important de configurer un compte e-mail avec lequel FreeNAS va pouvoir nous envoyer des alertes en cas de problème, d’alerte SMART ou d’opérations programmées. Comme on ne passe pas sa vie dans l’interface pour voir le voyant Alert en haut à droite, c’est très pratique. Pour les habitués : depuis la version 9, le rapport quotidien a disparu, les tests associés ont bien lieu mais un rapport est envoyé uniquement en cas de retour anormal. L’envoi d’un mail de test à l’issue de la config se fait à l’utilisateur root, donc on doit déjà paramétrer son adresse. Rendez vous dans Account -> Users -> View Users puis sélectionnez la ligne de l’utilisateur root. Cliquez sur Change E-mail et renseignez l’adresse que vous souhaitez. Définition de l’adresse mail de root Maintenant, on se rend dans System -> Email. Et on remplit les champs : From est l’adresse écrite dans l’expéditeur du mail, je vous conseille de mettre la même adresse que votre Username. Renseignez ensuite le serveur smtp dansOutgoing mail server ainsi que le port dans Port to connect to, éventuellement dans TLS/SSL un cryptage en fonction du serveur que vous utilisez, Plain signifie pas de cryptage. Ci dessous un exemple utilisant gmail : Paramètres e-mail Cette partie de la configuration est très dépendante de votre serveur de messagerie, en général le port est 587 pour du TLS, 465 pour le SSL ou 25 sans sécurisation. Cochez ensuite la case (il y en a qu’une !) pour pouvoir inscrire votre nom d’utilisateur et 2 fois le mot de passe, il s’agit bien ici de vos propres paramètres de messagerie : nom d’utilisateur et mot de passe utilisés pour accéder à vos e-mails. Un clic sur Save pour enregistrer le tout puis sur Send Test Mail et …. vous devriez avoir reçu un mail de test ! Si cela ne fonctionne pas (l’erreur 65 est la plus fréquente): vérifiez que vous avez bien défini une IP pour la passerelle et au moins un serveur DNS (voir la partie ci dessus), vérifiez dans les spams (!), sinon selon votre fournisseur d’accès l’utilisation de serveur smtp autre que ceux du fournisseur est peut être bloqué, c’est notamment le cas chez Free par défaut, dans ce cas enlevez le blocage dans la configuration de votre box ou utilisez le serveur smtp de votre fournisseur. Voilà pour la configuration système de base d’un FreeNAS, la prochaine étape va être de configurer notre stockage avec tous les disques dur que l’on a acheté.
  13. Les différentes étapes nécessaires à l’utilisation basique du NAS sont décrites dans les tutoriels suivants, aboutissant à un système avec RAIDZ de 3 disques, 3 utilisateurs ayant un espace privé et des espaces partagés et un accès depuis Internet : On peut désormais parler à juste titre d’installation car si jusque là FreeNAS était une simple image bootable à copier sur une clé USB, les choses changent et il faut procéder à une installation à travers un menu. L’installateur crée maintenant une partition ZFS et ajoute un gestionnaire de boot : GRUB, ouvrant des possibilités de multiboot pour les mises à jour, récupérer une config foireuse, etc…. Fort heureusement on l’installe toujours sur une (ou plusieurs !) clés USB ….?..!… Plusieurs clés ?? C’est nouveau ? Et oui, nouveauté, l’installateur permet de sélectionner plusieurs supports pour installer le système qui sera ainsi en miroir, augmentant la disponibilité en cas de défaillance de l’un des deux. Évidemment le système est toujours indépendant des données et en cas de soucis sur la clé, il suffit de la changer, réinstaller le système, importer les pools de données et éventuellement la configuration sauvegardée et le tour est joué. Pour cette raison je n’utilise pas le mirroring de la clé USB système mais sachez que c’est possible. Le système est installable sur clé USB, sur carte compact flash moyennant adaptateur IDE par exemple, sur un petit SSD ou sur un disque dur. Attention : le support ne peut être utilisé que pour le système, la place libre est perdue, on ne peut y mettre de données. Le choix le plus économique est donc la clé USB (gain d’un port SATA également). Taille minimale 4Go, mais 8Go sont recommandés. Dans tous les cas une clé de marque est indispensable, bannissez absolument les clés noname pour installer le système, ce ne sont que des mauvaises surprises à prévoir. Téléchargement de FreeNAS et préparation Un seul fichier à télécharger pour l’installation, on se rend sur www.freenas.org/download-freenas-release.html et puis “Download the current stable release of FreeNAS”. Il y a sous le bouton Download, le résultat du hash SHA256 du fichier iso, je vous recommande de le vérifier après téléchargement pour s’assurer que le fichier n’a pas été corrompu. Pour cela sous Windows il faut utiliser un outil commeHashCalc ou équivalent. Sous Linux ça se fait en ligne de commande avec : sha256sum FreeNAS-9.3-RELEASE-x64.iso et sur Mac avec shasum -a 256 FreeNAS-9.3-RELEASE-x64.iso Maintenant 2 possibilités : votre (futur) NAS possède un lecteur CD => Il suffit de graver l’image iso et de booter sur le CD. Vous êtes comme moi et n’avez point de lecteur CD, ce n’est pas grave, on va “graver” l’iso sur une clé USB pour booter dessus et installer FreeNAS sur la clé USB système, il faut donc bien 2 clés. Pour les linuxiens, on utilise la très puissante commande dd, attention donc à ne pas se tromper de disque, ici la clé se nomme da0 : dd if=FreeNAS-9.3-RELEASE-x64.iso of=/dev/da0 bs=64k Pour les gens sur OS X, c’est relativement similaire, sauf qu’il faut d’abord s’assurer avec l’utilitaire de disque que la clé ne contient qu’une seule et unique partition. Ensuite on récupère le nom de la clé avec diskutil list et avant dd on démonte le volume : diskutil list diskutil unmountDisk /dev/disk1 dd if=FreeNAS-9.3-RELEASE-x64.iso of=/dev/disk1 bs=64k Enfin pour les Windowsiens, on utilise l’utilitaire Win32 Disk Imager récupéré sur SourceForge. Il est très simple d’emploi, ça ne va pas vous poser de soucis : on sélectionne le fichier iso puis la lettre de lecteur de la clé et zou ! C’est écrit. Installation proprement dite Le matériel est prêt, bien sûr avec un écran et un clavier branché seulement le temps de l’installation. Le BIOS est configuré pour démarrer sur la clé USB ou sur le CD, le média en question est inséré…. c’est parti ? Aller, on allume et on obtient ça : Installateur FreeNAS Bien sûr on valide, la machine boot sur la clé, et on arrive au menu de l’installateur. FreeNAS 9.3 Menu de l’installateur Après validation voici le choix du (ou des !) médias sur le(s)quel(s) installer le système. Je rappelle que la place libre à côté n’est pas utilisable, autant donc installer sur clé USB. Le choix s’effectue avec les flèches haut/bas et la sélection avec la barre d’espace. Attention, pas d’erreur, tout va être supprimé dessus. Choix du disque pour l’installation du système Ensuite, ATTENTION ! Gros Piège ! On vous demande de créer le mot de passe root (administrateur), il sera utilisé pour l’accès à l’interface graphique notamment. Mais le clavier est en QWERTY et ça ne se voit pas car il n’y a que des étoiles… Vous le voyez arriver le piège ? Je recommande de faire “cancel” à ce stade et on définira le mot de passe ultérieurement dans l’interface graphique. Création du mot de passe root Puis l’installation proprement dite commence et après quelques minutes, il n’y a plus qu’à faire ce qu’il dit : on retire la clé et on reboot. Bien sûr à partir de maintenant il faut aussi que la machine soit branchée au réseau. FreeNAS 9.3 Fin de l’installation Le premier démarrage est un peu plus long que les suivants mais si tout va bien vous devriez tomber là dessus : FreeNAS 9.3 menu console Tadamm ! (petite musique accompagnée d’un grand sourire que votre femme ne pourra pas comprendre mais ce n’est pas grave, vous pourrez toujours mettre un commentaire en bas pour partager votre joie, les prochains lecteurs comprendrons ! ) Intégration au réseau existant Avec serveur DHCP Sur la capture ci dessus, on constate que le NAS s’est déjà vu attribué une adresse IP, c’est le cas si il y a un serveur DHCP sur le réseau (cas typique de la box internet). Attention, là ça marche très bien comme ça mais il vaut mieux quand même fixer l’adresse IP du NAS. Personnellement j’ai choisi de le faire sur la Freebox avec un bail DHCP fixe pour l’adresse MAC du NAS. Si vous avez besoin de connaître l’adresse MAC de la carte réseau, depuis le menu console, faites le choix 9 puis tapez ifconfig cela liste les interfaces réseau : l’adresse MAC est notée “ether”. Sans serveur DHCP Vous n’avez pas ou ne souhaitez pas utiliser le DHCP sur votre réseau, dans ce cas il suffit de configurer l’interface du NAS à la main avec une IP fixe (et fixé en dehors de la plage du DHCP si vous en avez un que vous ne souhaitez pas utiliser). Pour cela depuis le menu console on fait le choix 1, puis c’est relativement simple : on sélectionne la carte réseau, réponse non pour le reset et le DHCP et ensuite c’est à vous de choisir. J’ai mis un exemple ci dessous : FreeNAS 9.3 Configuration réseau manuelle Et bien voilà, on arrive au bout pour l’installation, on peut maintenant, si le tout boot bien sans intervention et que l’on obtient le menu console, débrancher clavier et écran et se rendre avec son navigateur favori à l’adresse indiquée.
  14. On parle beaucoup de ZFS dans les tutos consacrés à FreeNAS mais souvent le système de fichier est mal connu, ou un peu obscur. Mais il ne le mérite pas ! Je vous propose donc un petit tour d’horizon pour essayer de mieux le connaître, aborder son fonctionnement ainsi que le vocabulaire associé. ZFS est un système de fichier relativement nouveau (introduit en 2005 par Sun) proposant une approche fondamentalement nouvelle de la gestion des données. C’est un système 128bits, donc aux limites pharaoniques, qui combine les fonctions de système de fichier et de gestionnaire de volume, ce qui le rend très puissant. ZFS est donc aussi un gestionnaire de volume, en ce sens il doit pouvoir traiter directement avec les disques durs, comprenez sans autre interface. C’est à dire qu’une carte RAID “matériel” est non seulement totalement inutile mais en plus fortement déconseillée. Sécurité des données avant tout ZFS assure en permanence l’intégrité des données et du système de fichier même en cas de coupure électrique en cours d’écriture : soit vos données seront écrites, soit elles ne le seront pas mais il n’y aura jamais de corruption de fichiers à récupérer avec fsck ou chkdsk par exemple. C’est le principe du copy-on-write : lors d’une écriture, les données à remplacer ne sont pas écrasées : elles sont réécrite à un autre endroit puis le système met à jour les pointeurs vers ces données en une seule opération. Cela permet également de faire des snapshots, ou instantanés. Les snapshots sont une image du système de fichier à un instant donné permettant une restauration en cas de problème (suppression accidentelle de fichier, échec de mise à jour, etc). Avec ZFS la création d’une image est instantanée, les données modifiées étant écrite à un autre endroit il suffit de garder au fur et à mesure des modifications une trace, en l’occurrence un simple pointeur, vers les données d’origine. Pour chaque bloc de données stocké, ZFS calcule également une checksum, somme de contrôle, stockée avec le pointeur vers ce bloc de données, cela permet de contrôler lors de la relecture qu’il n’y a pas eu de corruption sur le disque et de réparer le cas échéant si une copie de la donnée existe. Un pool unique ZFS est basé sur la notion de pool de stockage. Les autres systèmes de fichiers sont basés sur des partitions, des volumes, tout est cloisonné et difficilement extensible. ZFS agrège tous les disques ensembles pour créer un seul pool de stockage, une grosse entité, pouvant grossir à volonté, et ce pool abrite ensuite un ou plusieurs systèmes de fichiers que l’on nomme dataset et que l’on va pouvoir définir, supprimer, limiter, dimensionner à volonté sans se préoccuper de l’emplacement réel des données sur les disques physiques. Cela offre une flexibilité et une évolutivité bien plus grande. Les vdev, point critique On vient de voir qu’un pool (on dit parfois zpool) est constitué des disques dur, c’est en réalité un peu plus complexe et puissant que ça : un pool est en réalité constitué de un ou plusieurs vdev (pour virtual devices). Les vdevs sont en quelque sorte des périphériques logiques regroupant un ou plusieurs disques durs physiques pouvant être organisés selon les schémas de RAID pour assurer la redondance en cas de panne d’un des disques. On trouve ainsi des vdevs mirror où les disques sont en RAID1, des vdevs RAIDZ avec une organisation équivalente au RAID5 (simple parité, autorise la panne d’un disque) et le RAIDZ2 (double parité équivalent au RAID6, autorise la panne de 2 disques). Il y a même un RAIDZ3 et des miroirs avec 3 disques ou plus pour les plus paranoïaques. Les vdevs sont ensuite agrégés entre eux en stripe (équivalent d’un RAID 0) pour former le pool et donc leurs capacités s’additionnent. Il est conseillé d’agréger dans un pool uniquement des vdev de même capacité. Plusieurs points clés sont à noter concernant les vdevs : Il est impossible d’ajouter un disque à un vdev RAIDZ ou RAIDZ2 On peut agrandir un pool après sa création en ajoutant des vdevs Il est impossible de retirer un vdev d’un pool. Si un vdev est défaillant (ex : panne de 2 disques dans un RAIDZ), le pool complet est perdu Ces quelques points clés font ressortir la nécessité d’être très attentif lors des manipulations diverses car par exemple ajouter un vdev constitué d’un disque unique à un pool contenant déjà un RAIDZ2, c’est l’assurance de tout perdre si le disque seul tombe en panne. Cela c’est déjà vu, et une fois l’erreur faite, impossible de la corriger sans supprimer et reconstruire le pool. ZIL, ARC, L2ARC, Gniarck. Vive la RAM ! Et pour clôturer le point vocabulaire, voici 3 acronymes courants : ARC, L2ARC et ZIL. Il s’agit des caches utilisés par ZFS pour son fonctionnement dans le but d’accélérer la lecture et l’écriture de et vers le pool. ARC signifie “Adaptive Replacement Cache” et L2ARC “Level 2 ARC” ce sont les caches de lecture. L’ARC est situé dans la RAM du NAS et est constitué d’un subtil équilibre, dépendant de vos propres habitudes, entre les données récemment lues et les données régulièrement lues. Ainsi pour vous servir un fichier auquel vous est accédez tous les jours encore plus vite, ZFS le stocke dans la RAM et vous envoie directement le contenu de la mémoire quand vous accédez à ce fichier au lieu d’aller le lire dans le pool. Le L2ARC a le même principe de fonctionnement mais en utilisant un disque dur dédié, évidemment pour avoir un avantage il faut qu’il soit rapide, c’est pourquoi on utilise généralement un SSD. Pour notre usage sur FreeNAS à la maison d’hébergement de document, de streaming vidéo vers les télévisions, etc… l’intérêt est maigre voir nul, on en restera donc là. Le ZIL (ZFS Intent Log) est utilisé pour sa part afin d’optimiser les performances en écritures. A la base, là encore ZFS utilise la RAM : lors d’une écriture vers le pool, les données sont d’abord écrite en RAM, regroupées puis écrites simultanément dans le pool quand ZFS trouve du temps libre (attention : temps libre à l’échelle de l’ordinateur ce n’est pas dans une heure ou deux…). Tout ceci sauf quand on lui demande expressément d’assurer l’écriture sur le disque dur et de rendre compte à la fin, c’est ce que l’on appelle une écriture synchrone, et ça permet au processus qui l’a faite de s’assurer que sa demande ne sera pas envoyée en RAM et puis perdu si il y a une coupure de courant dans la seconde qui suit. C’est très pratique pour une base de donnée ou l’enregistrement de virements bancaires. Pour assurer les écritures synchrones sans attendre que les disques du pool soient disponibles, on peut là aussi ajouter un SSD rapide qui s’appelle donc le ZIL et sur lequel sont enregistrées ces transactions avant d’être transférées dans le pool ultérieurement. En cas de coupure de courant, il est toujours possible de finaliser ces écritures à la reprise. Astucieux, mais là non plus à domicile ce n’est pas très utile. Ce que l’on peut quand même conclure de ce point c’est que plus il y a de RAM et plus ZFS fonctionne mieux. On voit également rapidement que la RAM peut être un point critique, en effet autant l’intégrité des données est assurée sur les disques, autant en cas de corruption en RAM, ZFS ne voit rien et peut écrire une donnée corrompue => C’est pour cela que la RAM ECC (et donc carte mère la gérant et processeur adapté) sont conseillés pour une sécurité maximale des données. Le risque est faible mais non nul d’avoir des données corrompues suite à une erreur en RAM et encore plus faible mais toujours non nul de perdre le pool de données complet en cas de corruption en RAM suivie d’écriture si ces données concernent la structure du pool lui-même. Le risque est faible mais à priori plus important que sur les systèmes de fichiers classiques car la RAM est bien plus utilisée, notamment en cache d’écriture. A vous de choisir de faire avec ou non. Pour ma part, j’ai jugé ce risque acceptable et ai choisi de la RAM standard pour mon premier NAS, testée toutefois pendant 36h consécutives avec MemTest86, aucune erreur n’étant acceptable. Quelques ressources pour approfondir Pour terminer, si vous êtes curieux voici quelques ressources pour aller plus loin avec ZFS : En Français d’abord, pas énormément d’infos mais 2 liens : Un article du blog de Patrick Proniewski expliquant le fonctionnement des snapshots Manuel d’administration d’Oracle Solaris à propos de ZFS pratique pour en apprendre plus sur la manipulation de zfs en ligne de commande Et puis en anglais, beaucoup plus de documentation disponible, voici une sélection de 3 liens : Diaporama “pour les nuls” reprenant les points clé et erreur, réalisé par cyberjock sur le forum freenas. ZFS Best Practices Guide, un wiki très fourni en informations Une étude sur l’intégrité des données avec ZFS : pdf assez ardu, très poussé et très technique mais fort intéressant à propos de la RAM notamment.
  15. FreeNAS est un système d’exploitation libre et gratuit, basé sur FreeBSD et destiné aux serveurs NAS pour le stockage de données en réseau. Il est maintenu par iXSystems, société spécialisée dans le stockage et les serveurs open-source. Si vous êtes arrivés là vous devez certainement déjà connaitre FreeNAS, si ce n’est pas le cas vous pouvez faire un tour sur le site officiel du projet (en anglais) pour en savoir plus. Je vous propose ici une série de tutoriels couvrant la mise en place et la création d’un NAS avec FreeNAS. Les tutos sont publiés sous forme d’article séparés et cette page en est le tronc commun et le sommaire. Commençons donc par un mot à propos des besoins matériels Choix du matériel pour FreeNAS 9.3 Tout d’abord il faut savoir que FreeNAS utilise désormais uniquement le système de fichier ZFS pour la création des nouveaux espaces de stockage. Il est donc très important de connaitre ce système de fichier avant de commencer car il va impacter les choix matériels, notamment au niveau de la RAM (taille et ECC vs non-ECC). Concernant la configuration matériel minimale nécessaire pour utiliser FreeNAS (en version 9.3 à ce jour), il faudra : Un processeur 64 bits (FreeNAS est maintenant uniquement compilé en 64 bits) 8 Go de RAM pour utiliser au mieux ZFS, ça marche avec 4Go sans soucis, et même moins pour de petits tests mais plus il y a de RAM et plus ZFS est content et rapide. Une clé USB de 8Go minimum et de qualité (marque reconnue) pour installer le système, ou un disque dur mais celui-ci ne sera pas utilisable pour le stockage Un port RJ45 (et oui, dans NAS il y a Network) Un autre ordinateur sur le réseau pour administrer via l’interface web Quelques points à souligner : FreeNAS est basé sur FreeBSD, qui intègre les drivers au noyau, mais est parfois un peu touchy avec le matériel exotique. Vous pouvez vérifier si votre matériel est compatible sur cette page : FreeBSD 9.3-RELEASE Hardware Notes Certaines cartes-mères et/ou certaines clé USB semblent présenter des problèmes de boot avec la version 9.3 de FreeNAS utilisant GRUB et une partition GPT sur la clé USB conduisant à un freeze complet au moment du démarrage. Parfois certains ports USB seulement présentent ce problème. Le BIOS doit être capable de booter soit avec l’interface BIOS classique, soit avec l’UEFI. A ce jour le seul moyen d’utiliser FreeNAS si votre matériel présente ce problème est de l’installer sur un petit disque dur (ou SSD) qui ne pourra pas être utilisé comme stockage. Ceci ne change rien au système mais a pour inconvénient d’utiliser un port SATA. Toute forme de RAID matériel et pseudo-matériel est à fuir, utilisez vos cartes et contrôleurs en mode basique, ZFS se chargera du reste en étant bien plus performant. Et enfin, l’USB 3 n’est pas tellement supporté pour le moment par FreeBSD, donc utilisez une clé USB2, un port USB2 et désactivez l’USB 3 dans le BIOS pour éviter les problèmes. A titre d’exemple, ma configuration personnelle pour une utlisation familiale est la suivante : Processeur : AMD Sempron 140 Carte mère MSI 760GM-P23, carte vidéo et réseau gigabit intégrés. 8Go de RAM Kingston CL9 3 disques Western Digital Caviar Green de 2 To 1 disque Seagate Desktop HD.15 de 4To Une clé USB Sandisk Boitier M-Cube de MaxInPower Après assemblage de tout ce petit monde on obtient ça : C’était avant installation des disques durs bien sûr. Si vous prévoyez de faire du transcodage de vidéos, notamment avec le plugin Plex Media Server, un processeur type i3 d’entrée de gamme est plutôt conseillé. Si vous souhaitez utiliser le cryptage (cryptage des données au niveau du disque dur), un processeur supportant les instructions AES-NI est fortement recommandé. Si comme moi vous n’utilisez ni cryptage, ni transcodage, n’importe quel processeur actuel de bureautique sera suffisant pour un usage familial. Enfin pour des configurations avancées, des usages plus poussés, ou pour maximiser la sécurité des données avec ZFS le matériel suivant est couramment conseillé sur les forums FreeNAS : Carte mère type serveur RAM ECC Carte réseau ou chipset réseau Intel (les Realtek et consorts grand public sont moins performant avec FreeBSD et sollicitent bien plus le processeur) Alimentation de qualité et onduleur voir sujet Installation et configuration du système