« Partage NFS » : différence entre les versions

De Le Wiki du Forum-Debian.fr
Aller à la navigation Aller à la recherche
m (→‎Discontinuité dans l'intervalle d'adresses : chg "dossier" par "répertoire")
Aucun résumé des modifications
 
(8 versions intermédiaires par 2 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
NFS (Network File System) est un protocole qui permet d'accéder à des fichiers via le réseau. Il est basé sur le protocole RPC (Remote Procedure Call). Les clients montent la partition de la machine distante comme si c'était un disque local.
NFS (Network File System) est un protocole qui permet d'accéder à des fichiers via le réseau. Il est basé sur le protocole RPC (Remote Procedure Call). Les clients montent la partition de la machine distante comme si c'était un disque local.
Ce document à été mis à jour pour stretch!
==Sur le serveur==
==Sur le serveur==


===Installation===
===Installation===


Les paquets nécessaires sont :
Installation très simple comme toujours avec Debian:
* [http://fr.wikipedia.org/wiki/Portmap portmap]
# apt install nfs-kernel-server
* nfs-common : fichiers communs au client et au serveur.
<pre>
* nfs-kernel-server : le démon NFS.
...
Les paquets supplémentaires suivants seront installés :
  nfs-common rpcbind
...</pre>


Installer les paquets avec son gestionnaire de paquets habituel, par exemple :
Les dépendances de nfs-kernel-server sont:
<code>
<pre>Depends: libblkid1 (>= 2.16), libc6 (>= 2.14), libcap2 (>= 1:2.10), libsqlite3-0 (>= 3.5.9), libtirpc1 (>= 0.2.4), libwrap0 (>= 7.6-4~), nfs-common (= 1:1.2.8-9), ucf, lsb-base (>= 1.3-9ubuntu3)</pre>
# apt-get install nfs-common nfs-kernel-server portmap
</code>


===Vérification de l'installation===
===Vérification de l'installation===


Exécuter rpcinfo pour confirmer que le serveur est lancé, et accepte les requêtes sur le port 2049 (UDP et TCP).
Exécuter rpcinfo pour confirmer que le serveur est lancé, et accepte les requêtes sur le port 2049 (UDP et TCP).
<code>
# rpcinfo -p | grep nfs
# rpcinfo -p | grep nfs
<pre>    100003    2  udp  2049  nfs
    100003    2  udp  2049  nfs
     100003    3  udp  2049  nfs
     100003    3  udp  2049  nfs
     100003    4  udp  2049  nfs
     100003    4  udp  2049  nfs
     100003    2  tcp  2049  nfs
     100003    2  tcp  2049  nfs
     100003    3  tcp  2049  nfs
     100003    3  tcp  2049  nfs
     100003    4  tcp  2049  nfs
     100003    4  tcp  2049  nfs</pre>
</code>
 
Vérifier que le système supporte effectivement NFS :
Vérifier que le système supporte effectivement NFS:
<code>
# cat /proc/filesystems | grep nfs
# cat /proc/filesystems | grep nfs
<pre>nodev nfs
nodev   nfs
nodev nfs4
nodev   nfs4
nodev nfsd</pre>
</code>
 
Si la commande n'effectue aucun retour, il se peut que le module NFS ne soit pas chargé, auquel cas, il faut le charger avec :
Si la commande ne renvoie rien, il se peut que le module NFS ne soit pas chargé, auquel cas, il faut le charger avec :
<code>
# modprobe nfs
# modprobe nfs
 
</code>
Enfin, vérifions que portmap attend les instructions sur le port 111 :  
Enfin, vérifions que portmap attend les instructions sur le port 111 :  
<code>
# rpcinfo -p | grep portmap
# rpcinfo -p | grep portmap
<pre>    100000    4  tcp    111  portmapper
    100000    3  tcp    111  portmapper
     100000    2  tcp    111  portmapper
     100000    2  tcp    111  portmapper
     100000    2  udp    111  portmapper
    100000    4  udp    111  portmapper
</code>
    100000    3  udp    111  portmapper
Cette même vérification est à faire sur le client.
     100000    2  udp    111  portmapper</pre>
 
Cette même vérification sera à faire sur le client.


===Configuration du partage===
===Configuration du partage===


Il faut maintenant indiquer au serveur les répertoires qui seront partagés, les machines qui y auront accès et les conditions de ce partage. Tous ces réglages se font par l'intermédiaire du fichier /etc/exports. Sa structure est la suivante :
Il faut maintenant indiquer au serveur les répertoires qui seront partagés, les machines qui y auront accès et les conditions de ce partage. Tous ces réglages se font par l'intermédiaire du fichier /etc/exports. Sa structure est la suivante :
<code>
 
/répertoire_partagé <hôte1>(options de partage) <hôte2>(options de partage)
<pre>/répertoire_partagé <hôte1>(options de partage) <hôte2>(options de partage)</pre>
</code>
 
====Désignation des hôtes destinataires====
====Désignation des hôtes destinataires====


On indique ici l'adresse ip ou l'intervalle d'adresses ip des machines pouvant accéder au partage. Pour spécifier un intervalle, on joue sur le masque de sous réseau (voir les outils de calculs type gip : http://ip2cidr.com). Les jokers (classiquement * ou ?) sont à proscrire à l'intérieur d'une adresse ip. Ainsi, pour désigner un réseau domestique complet :
On indique ici l'adresse ip ou l'intervalle d'adresses ip des machines pouvant accéder au partage. Pour spécifier un intervalle, on joue sur le masque de sous réseau (voir les outils de calculs type gip : http://ip2cidr.com). Les jokers (classiquement * ou ?) sont à proscrire à l'intérieur d'une adresse ip. Ainsi, pour désigner un réseau domestique complet :
<code>
 
192.168.0.0/255.255.255.0
<pre>192.168.0.0/255.255.255.0</pre>
</code>
 
ou
ou
<code>
 
192.168.0.0/24
<pre>192.168.0.0/24</pre>
</code>
 
Les autres solutions pour désigner les machines autorisées sont : nom d'hôte (connus via /etc/hosts ou un DNS), groupes réseau NIS, un domaine ou un sous domaine précédé d'un joker.
Les autres solutions pour désigner les machines autorisées sont : nom d'hôte (connus via /etc/hosts ou un DNS), groupes réseau NIS, un domaine ou un sous domaine précédé d'un joker.
=====Discontinuité dans l'intervalle d'adresses=====
 
=====Discontinuité dans le groupe d'adresses IP=====
<ol>
<ol>
<li>Si, dans l'intervalle d'adresses ip définies par la notation CIDR 192.168.0.0/24<br/>
<li>'''Introduction :'''<br/>
nous avons décidé que seule l'adresse ip 192.168.0.28 ne puisse '''PAS''' accéder au partage NFS,<br/>
        Si, dans l'ensemble des adresses IP définies par la notation CIDR 192.168.0.0/24<br/>
il nous faudra définir plusieurs intervalles d'adresses ip.<br/><br/>
 nous avons décidé que seule l'adresse IP 192.168.0.28 ne puisse '''PAS''' accéder au partage NFS,<br/>
 il nous faudra définir plusieurs groupes d'adresses IP.<br/><br/>


<ol type="a">
<ol type="a">
    <li>'''Pour les adresses ip 192.168.0.0 à 192.168.0.27'''<br/>
    <li>'''Pour les adresses IP 192.168.0.0 à 192.168.0.27'''<br/><br/>
Pour ces 28 adresses, il ne va pas être possible de les regrouper toutes dans un unique intervalle d'adresses ip, 28 n'étant pas une puissance de 2.<br/>
28 n'étant pas une puissance de 2, il ne sera pas possible de regrouper ces 28 adresses IP dans un unique groupe.<br/><br/>


Cherchons, parmi les puissances de 2, celle qui sera la plus grande mais qui restera tout de même inférieure ou égale à 28:<br/>
Cherchons, parmi les puissances de 2, celle qui sera la plus grande mais qui restera tout de même inférieure ou égale à 28 :<br/>
2¹=2, 2²=4, 2³=8, 2⁴=16, 2⁵=32 Oups! on a dépassé 28, alors on va prendre 16, c'est à dire 2 puissance 4.<br/>
2¹=2, 2²=4, 2³=8, 2⁴=16, 2⁵=32 Oups! on a dépassé 28, alors on va prendre 16, c'est à dire 2 puissance 4.<br/>
Il faudra donc 4 bits pour définir ce sous-intervalle d'adresses, et la notation CIDR pour cet intervalle sera donc : 32-4=28.<br/>
Il faudra donc 4 bits pour définir ce groupe d'adresses, et la notation CIDR pour ce groupe sera donc : 32-4=28.<br/>
Voilà donc ce premier sous de 16 adresses : 192.168.0.0 à 192.168.0.15 qu'on notera : '''192.168.0.0/28'''<br/><br/>
Voilà donc ce premier groupe de 16 adresses : 192.168.0.0 à 192.168.0.15 qu'on notera : '''192.168.0.0/28'''<br/><br/>


Il nous reste encore l'intervalle d'adresses 192.168.0.16 à 192.168.0.27, donc 12 adresses.<br/>
Il nous reste encore le groupe d'adresses 192.168.0.16 à 192.168.0.27, donc 12 adresses.<br/>
Pour ces 12 adresses, il n'est pas possible de créer un intervalle d'adresses ip les regroupant toutes, car 12 n'est pas une puissance de 2.<br/>
12 n'étant pas une puissance de 2, il ne sera pas possible de regrouper ces 12 adresses IP dans un unique groupe.<br/><br/>
Cherchons, parmi les puissances de 2, celle qui sera la plus grande mais qui restera tout de même inférieure ou égale à 12:<br/>
 
Cherchons, parmi les puissances de 2, celle qui sera la plus grande mais qui restera tout de même inférieure ou égale à 12 :<br/>
2¹=2, 2²=4, 2³=8, 2⁴=16 Oups! on a dépassé 12, alors on va prendre 8, c'est à dire 2 puissance 3.<br/>
2¹=2, 2²=4, 2³=8, 2⁴=16 Oups! on a dépassé 12, alors on va prendre 8, c'est à dire 2 puissance 3.<br/>
Il faudra donc 3 bits pour définir ce sous-intervalle d'adresses, et la notation CIDR pour cet intervalle sera donc : 32-3=29.<br/>
Il faudra donc 3 bits pour définir ce groupe d'adresses, et la notation CIDR pour cet groupe sera donc : 32-3=29.<br/>
Voilà donc ce deuxième intervalle de 8 adresses : 192.168.0.16 à 192.168.0.23 qu'on notera : '''192.168.0.16/29'''<br/><br/>
Voilà donc ce deuxième groupe de 8 adresses : 192.168.0.16 à 192.168.0.23 qu'on notera : '''192.168.0.16/29'''<br/><br/>


Il nous reste encore l'intervalle d'adresses 192.168.0.24 à 192.168.0.27, donc 4 adresses.<br/>
Il nous reste encore le groupe d'adresses 192.168.0.24 à 192.168.0.27, donc 4 adresses.<br/>
Pour ces 4 adresses, il est tout-à fait possible de créer un intervalle d'adresses ip les regroupant toutes, car 2²=4.<br/>
Pour ces 4 adresses, il est tout-à fait possible de créer un groupe d'adresses IP les regroupant toutes, car 2²=4.<br/>
Il faudra donc 2 bits pour définir cet intervalle d'adresses, et la notation CIDR pour cet intervalle sera donc : 32-2=30.<br/>
Il faudra donc 2 bits pour définir ce groupe d'adresses, et la notation CIDR pour ce groupe sera donc : 32-2=30.<br/>
Voilà donc ce troisième intervalle de 4 adresses : 192.168.0.24 à 192.168.0.27 qu'on notera : '''192.168.0.24/30'''<br/><br/>
Voilà donc ce troisième groupe de 4 adresses : 192.168.0.24 à 192.168.0.27 qu'on notera : '''192.168.0.24/30'''<br/><br/>


    <li>'''Pour les adresses ip 192.168.0.29 à 192.168.0.255'''<br/>
    <li>'''Pour les adresses IP 192.168.0.29 à 192.168.0.255'''<br/><br/>
Pour ces 226 adresses, il n'est pas possible de créer un intervalle d'adresses ip les regroupant toutes, car le nombre 226 n'est pas à une puissance 2.<br/>
226 n'étant pas une puissance de 2, il ne sera pas possible de regrouper ces 226 adresses IP dans un unique groupe.<br/>
De plus, comme le dernier octet de cette adresse n'est pas une puissance de 2, il nous est impossible d'utiliser un masque qui pourrait permettre de définir un intervalle d'adresses en notation CIDR.<br/><br/>
De plus, comme le dernier octet de la première adresse n'est pas une puissance de 2,<br/>
                 il nous sera impossible d'utiliser un masque qui pourrait permettre de définir un groupe d'adresses en notation CIDR.<br/><br/>


On va donc énumérer les adresses de ce deuxième intervalle jusqu'à obtenir une adresse de départ utilisable avec un masque.<br/>
On va donc énumérer les premières adresses de ce deuxième groupe jusqu'à obtenir une adresse de départ utilisable avec un masque.<br/>
'''192.168.0.29'''<br/>
'''192.168.0.29'''<br/>
'''192.168.0.30'''<br/>
'''192.168.0.30'''<br/>
'''192.168.0.31'''<br/>
'''192.168.0.31'''<br/>
192.168.0.32 Ah! On y est : 2⁵=32 corresponds bien à une puissance de 2, on va pouvoir définir un intervalle d'adresses en notation CIDR.<br/><br/>
'''192.168.0.32''' Ahhh! On y est : 2⁵=32 corresponds bien à une puissance de 2, on va maintenant pouvoir définir un groupe d'adresses.<br/><br/>


Le groupe d'adresses suivant débutera donc à l'adresse IP suivante, soit : 192.168.0.32<br/>
Avec cette adresse, on constate que les 5 derniers bits sont à 0 (32 => 0010 0000)<br/>
Avec cette adresse, on constate que les 5 derniers bits sont à 0 (32 => 0010 0000)<br/>
Le masque utilisable sera donc de 32-5=27 et l'intervalle sera donc noté : '''192.168.0.32/27'''<br/>
Le masque utilisable sera donc de 32-5=27 et le groupe d'adresses IP sera donc noté : '''192.168.0.32/27'''<br/>
Ce masque permet donc de regrouper 2⁵=32 adresses en notation CIDR.<br/>
Ce masque permet donc de regrouper 2⁵=32 adresses en notation CIDR.<br/>
Cet intervalle comprendra donc les adresses ip 192.168.0.32 à 192.168.0.63<br/><br/>
Ce groupe d'adresses comprendra donc les adresses IP 192.168.0.32 à 192.168.0.63<br/><br/>


L'intervalle suivant débutera donc à l'adresse ip suivante, soit: 192.168.0.64<br/>
Le groupe d'adresses suivant débutera donc à l'adresse IP suivante, soit : 192.168.0.64<br/>
Avec cette adresse, on constate que les 6 derniers bits sont à 0 (64 => 0100 0000)<br/>
Avec cette adresse, on constate que les 6 derniers bits sont à 0 (64 => 0100 0000)<br/>
Le masque utilisable sera donc de 32-6=26 et l'intervalle sera donc noté : '''192.168.0.64/26'''<br/>
Le masque utilisable sera donc de 32-6=26 et le groupe d'adresses IP sera donc noté : '''192.168.0.64/26'''<br/>
Ce masque permet donc de regrouper 2⁶=64 adresses en notation CIDR.<br/>
Ce masque permet donc de regrouper 2⁶=64 adresses en notation CIDR.<br/>
Cet intervalle comprendra donc les adresses ip 192.168.0.64 à 192.168.0.127<br/><br/>
Ce groupe d'adresses comprendra donc les adresses IP 192.168.0.64 à 192.168.0.127<br/><br/>


L'intervalle suivant débutera donc à l'adresse suivante, soit: 192.168.0.128<br/>
Le groupe d'adresses suivant débutera donc à l'adresse suivante, soit : 192.168.0.128<br/>
Avec cette adresse, on constate que les 7 derniers bits sont à 0 (128 => 1000 0000)<br/>
Avec cette adresse, on constate que les 7 derniers bits sont à 0 (128 => 1000 0000)<br/>
Le masque utilisable sera donc de 32-7=25, et l'intervalle sera donc noté : '''192.168.0.128/25'''<br/>
Le masque utilisable sera donc de 32-7=25, et le groupe d'adresses IP sera donc noté : '''192.168.0.128/25'''<br/>
Ce masque permet donc de regrouper 2⁷=128 adresses en notation CIDR.<br/>
Ce masque permet donc de regrouper 2⁷=128 adresses en notation CIDR.<br/>
Cet intervalle comprendra donc les adresses 192.168.0.128 à 192.168.0.255<br/><br/>
Ce groupe d'adresses comprendra donc les adresses 192.168.0.128 à 192.168.0.255<br/><br/>


    <li>'''Conclusion'''<br/>
</ol>
    <li>'''Conclusion :'''<br/><br/>
Pour que le répertoire "/home" soit exporté et accessible en lecture et écriture (rw)<br/>
Pour que le répertoire "/home" soit exporté et accessible en lecture et écriture (rw)<br/>
pour toutes les adresses du réseau 192.168.0.0/24 '''SAUF''' pour l'adresse 192.168.0.28,<br/>
pour l'ensemble des adresses définies par 192.168.0.0/24 '''SAUF''' pour l'adresse 192.168.0.28,<br/>
il faudra inscrire la ligne suivante dans le fichier de configuration "/etc/exports".
 il faudra inscrire la ligne suivante dans le fichier de configuration "/etc/exports".


<code>/home 192.168.0.0/28(rw) 192.168.0.16/29(rw) 192.168.0.24/30(rw) 192.168.0.29(rw) 192.168.0.30(rw) 192.168.0.31(rw) 192.168.0.32/27(rw) 192.168.0.64/26(rw) 192.168.0.128/25(rw)</code>
<pre>/home 192.168.0.0/28(rw) 192.168.0.16/29(rw) 192.168.0.24/30(rw) 192.168.0.29(rw) 192.168.0.30(rw) 192.168.0.31(rw) 192.168.0.32/27(rw) 192.168.0.64/26(rw) 192.168.0.128/25(rw)</pre>


Bon, mais c'est quand même pas très pratique à lire une ligne aussi longue,<br/>
Bon, mais c'est quand même pas très pratique à lire une ligne aussi longue,<br/>
mais grâce au caractère "\", il est possible de scinder cette ligne en plusieurs.
 mais dans le fichier "/etc/exports" il est possible de scinder cette trop longue ligne en plusieurs en utilisant le caractère "\".


<code>/home \
<pre>/home                                                       \
192.168.0.0/28(rw)  192.168.0.16/29(rw) 192.168.0.24/30(rw) \
192.168.0.0/28(rw)  192.168.0.16/29(rw) 192.168.0.24/30(rw) \
192.168.0.29(rw)    192.168.0.30(rw)    192.168.0.31(rw) \
192.168.0.29(rw)    192.168.0.30(rw)    192.168.0.31(rw)     \
192.168.0.32/27(rw) 192.168.0.64/26(rw) 192.168.0.128/25(rw)
192.168.0.32/27(rw) 192.168.0.64/26(rw) 192.168.0.128/25(rw)
</code>
</pre>


</ol>
</ol>
</ol>


Ligne 164 : Ligne 174 :


On peut résoudre le problème plus proprement en mettant en place un service d'annuaire typiquement NIS, basé lui aussi sur RPC, ou LDAP.
On peut résoudre le problème plus proprement en mettant en place un service d'annuaire typiquement NIS, basé lui aussi sur RPC, ou LDAP.
====Exemples====
====Exemples====
<code>
 
/data 192.168.0.25(rw,sync,no_subtree_check) 192.168.0.33(ro,async,no_subtree_check)
<pre>/data 192.168.0.25(rw,sync,no_subtree_check) 192.168.0.33(ro,async,no_subtree_check)
/home 192.168.0.0/24(ro,async,no_subtree_check,fsid=0)
/home 192.168.0.0/24(ro,async,no_subtree_check,fsid=0)
/home/pour_root 192.168.0.55(rw,sync,no_subtree_check,no_root_squash)
/home/pour_root 192.168.0.55(rw,sync,no_subtree_check,no_root_squash)</pre>
</code>


===Redémarrage===
===Redémarrage===
<code>
 
# service nfs-kernel-server restart
# service nfs-kernel-server restart
</code>
 
ou
ou
<code>
 
# /etc/init.d/nfs-kernel-server restart
# /etc/init.d/nfs-kernel-server restart
</code>
 
===Sécurisation minimale===
===Sécurisation===


Le protocole RPC n'a pas la réputation d'être bien sécurisé, mais la version 4 de NFS entend corriger ce problème, elle est donc à privilégier. Il est déconseillé d'effectuer un partage NFS via internet, ou bien dans ce cas, opter pour un tunnel crypté.
Le protocole RPC n'a pas la réputation d'être bien sécurisé, mais la version 4 de NFS entend corriger ce problème, elle est donc à privilégier. Il est déconseillé d'effectuer un partage NFS via internet, ou bien dans ce cas, opter pour un tunnel crypté.
* Une mesure minimale à prendre est de renseigner les fichiers /etc/hosts.allow et /etc/hosts.deny qui contrôlent l'accès aux services RPC selon l'adresse IP.
 
* Autre possibilité, paramétrer iptables si celui-ci est installé, sous réserve d'avoir figé les ports RPC au préalable.
# S'assurer que les partages sont réservés à certaines IP dans /etc/exports
# S'appuyer sur rpcbind (/etc/hosts.deny et /etc/hosts.allow) pour sécuriser l'accès au serveur NFS
# Configurer convenablement iptables
 
====rpcbind====
 
Exemple de configuration (Tout le monde est interdit, puis le LAN est autorisé):
# nano /etc/hosts.deny
<pre>...
rpcbind mountd nfsd statd lockd rquotad : ALL</pre>
 
# nano /etc/hosts.allow
<pre>...
rpcbind mountd nfsd statd lockd rquotad: 10.11.12.</pre>
 
====iptables====
 
[https://wiki.debian.org/SecuringNFS Source]
 
Par défaut, les différents services NFS (lockd, statd, mountd, etc.) demandent des assignations de ports aléatoires à partir du portmapper (portmap/rpcbind), ce qui signifie que la plupart des administrateurs doivent ouvrir une gamme de ports dans leur base de règles de pare-feu pour que NFS fonctionne.
 
# rpcinfo -p | grep nlockmgr
<pre>    100005    1  udp  53978  mountd
    100005    1  tcp  41663  mountd
    100005    2  udp  59420  mountd
    100005    2  tcp  51826  mountd
    100005    3  udp  43855  mountd
    100005    3  tcp  42371  mountd</pre>
 
# /etc/init.d/nfs-kernel-server restart
 
# rpcinfo -p | grep mountd
<pre>    100005    1  udp  43892  mountd
    100005    1  tcp  55590  mountd
    100005    2  udp  44020  mountd
    100005    2  tcp  43086  mountd
    100005    3  udp  33108  mountd
    100005    3  tcp  57843  mountd</pre>
 
Il va donc falloir fixer les ports de ces services afin de créer les règles iptables.
 
# nano /etc/default/nfs-common
<pre>...
STATDOPTS="--port 32765 --outgoing-port 32766"
...</pre>
 
# nano /etc/default/nfs-kernel-server
<pre>...
RPCMOUNTDOPTS="-p 32767"
...</pre>
 
# nano /etc/default/quota
<pre>...
RPCRQUOTADOPTS="-p 32769"
...</pre>
 
# sysctl --system
# /etc/init.d/nfs-kernel-server restart
 
Nous pouvons maintenant fixer nos règles iptables:
 
<pre>iptables -A INPUT -s 10.11.12.0/24 -p tcp -m multiport --ports 111,2049,32764:32769 -j ACCEPT
iptables -A INPUT -s 10.11.12.0/24 -p udp -m multiport --ports 111,2049,32764:32769 -j ACCEPT</pre>


==Sur le client==
==Sur le client==
Ligne 190 : Ligne 262 :


Installer le paquet nfs-common avec son gestionnaire de paquets habituel, par exemple :
Installer le paquet nfs-common avec son gestionnaire de paquets habituel, par exemple :
<code>
 
# apt-get install nfs-common
# apt-get install nfs-common
</code>
 
===Vérification de l'installation===
===Vérification de l'installation===


Portmap doit attendre les instructions sur le port 111 :  
Portmap doit attendre les instructions sur le port 111:
<code>
 
# rpcinfo -p | grep portmap
# rpcinfo -p | grep portmap
    100000    2  tcp    111  portmapper
<pre>    100000    2  tcp    111  portmapper
     100000    2  udp    111  portmapper
     100000    2  udp    111  portmapper</pre>
</code>
 
===Montage du répertoire distant===
===Montage du répertoire distant===


Ligne 219 : Ligne 291 :


* la commande mount :
* la commande mount :
<code>
 
# mount -t nfs4 -o <options> <ip_serveur>:<rep_serveur> <point_montage_local>
<pre># mount -t nfs4 -o <options> <ip_serveur>:<rep_serveur> <point_montage_local></pre>
</code>
 
* une entrée dans /etc/fstab
* une entrée dans /etc/fstab
<code>
 
<ip du serveur>:/dossier_partagé /point_de_montage nfs4 <options> 0 0
<pre><ip du serveur>:/répertoire_partagé /point_de_montage nfs4 <options> 0 0</pre>
</code>
 
====Exemples====
====Exemples====
Avec mount, montage de la "racine" nfs4 désigné au deuxième exemple de 1.3.4.
Avec mount, montage de la "racine" nfs4 désigné au deuxième exemple de 1.3.4.
<code>
 
# mount -t nfs4 -o ro 192.168.0.11:/ /tous_les_homes
# mount -t nfs4 -o ro 192.168.0.11:/ /tous_les_homes</pre>
</code>


/etc/fstab :
/etc/fstab :
<code>
<pre>
...
192.168.0.11:/data /home/serveur_nfs nfs _netdev,nodev,noexec 0 0
192.168.0.11:/data /home/serveur_nfs nfs _netdev,nodev,noexec 0 0
</code>
...</pre>
 
==Sources==
==Sources==
*man mount, fstab, exports, nfs
*man mount, fstab, exports, nfs
Ligne 242 : Ligne 316 :
*http://www.centos.org/docs/5/html/Deployment_Guide-en-US/ch-nfs.html
*http://www.centos.org/docs/5/html/Deployment_Guide-en-US/ch-nfs.html
*http://www.troubleshooters.com/linux/nfs.htm#_Mounting_an_NFS_Share_on_a_Client
*http://www.troubleshooters.com/linux/nfs.htm#_Mounting_an_NFS_Share_on_a_Client
Dernière mise à jour: [[Utilisateur:Lol|Lol]] ([[Discussion utilisateur:Lol|discussion]]) 28 juin 2017 à 14:09 (CEST)


[[Catégorie:Réseau]]
[[Catégorie:Réseau]]

Dernière version du 9 juin 2022 à 10:33

NFS (Network File System) est un protocole qui permet d'accéder à des fichiers via le réseau. Il est basé sur le protocole RPC (Remote Procedure Call). Les clients montent la partition de la machine distante comme si c'était un disque local.

Ce document à été mis à jour pour stretch!

Sur le serveur

Installation

Installation très simple comme toujours avec Debian: 

# apt install nfs-kernel-server

...
Les paquets supplémentaires suivants seront installés : 
  nfs-common rpcbind
...

Les dépendances de nfs-kernel-server sont: 

Depends: libblkid1 (>= 2.16), libc6 (>= 2.14), libcap2 (>= 1:2.10), libsqlite3-0 (>= 3.5.9), libtirpc1 (>= 0.2.4), libwrap0 (>= 7.6-4~), nfs-common (= 1:1.2.8-9), ucf, lsb-base (>= 1.3-9ubuntu3)

Vérification de l'installation

Exécuter rpcinfo pour confirmer que le serveur est lancé, et accepte les requêtes sur le port 2049 (UDP et TCP). 

# rpcinfo -p | grep nfs

    100003    2   udp   2049  nfs
    100003    3   udp   2049  nfs
    100003    4   udp   2049  nfs
    100003    2   tcp   2049  nfs
    100003    3   tcp   2049  nfs
    100003    4   tcp   2049  nfs

Vérifier que le système supporte effectivement NFS: 

# cat /proc/filesystems | grep nfs

nodev	nfs
nodev	nfs4
nodev	nfsd

Si la commande ne renvoie rien, il se peut que le module NFS ne soit pas chargé, auquel cas, il faut le charger avec : 

# modprobe nfs

Enfin, vérifions que portmap attend les instructions sur le port 111 : 

# rpcinfo -p | grep portmap

    100000    4   tcp    111  portmapper
    100000    3   tcp    111  portmapper
    100000    2   tcp    111  portmapper
    100000    4   udp    111  portmapper
    100000    3   udp    111  portmapper
    100000    2   udp    111  portmapper

Cette même vérification sera à faire sur le client.

Configuration du partage

Il faut maintenant indiquer au serveur les répertoires qui seront partagés, les machines qui y auront accès et les conditions de ce partage. Tous ces réglages se font par l'intermédiaire du fichier /etc/exports. Sa structure est la suivante : 

/répertoire_partagé <hôte1>(options de partage) <hôte2>(options de partage)

Désignation des hôtes destinataires

On indique ici l'adresse ip ou l'intervalle d'adresses ip des machines pouvant accéder au partage. Pour spécifier un intervalle, on joue sur le masque de sous réseau (voir les outils de calculs type gip : http://ip2cidr.com). Les jokers (classiquement * ou ?) sont à proscrire à l'intérieur d'une adresse ip. Ainsi, pour désigner un réseau domestique complet : 

192.168.0.0/255.255.255.0

ou 

192.168.0.0/24

Les autres solutions pour désigner les machines autorisées sont : nom d'hôte (connus via /etc/hosts ou un DNS), groupes réseau NIS, un domaine ou un sous domaine précédé d'un joker.

Discontinuité dans le groupe d'adresses IP
  1. Introduction :
    Si, dans l'ensemble des adresses IP définies par la notation CIDR 192.168.0.0/24
     nous avons décidé que seule l'adresse IP 192.168.0.28 ne puisse PAS accéder au partage NFS,
     il nous faudra définir plusieurs groupes d'adresses IP.

    1. Pour les adresses IP 192.168.0.0 à 192.168.0.27

      28 n'étant pas une puissance de 2, il ne sera pas possible de regrouper ces 28 adresses IP dans un unique groupe.

      Cherchons, parmi les puissances de 2, celle qui sera la plus grande mais qui restera tout de même inférieure ou égale à 28 :
      2¹=2, 2²=4, 2³=8, 2⁴=16, 2⁵=32 Oups! on a dépassé 28, alors on va prendre 16, c'est à dire 2 puissance 4.
      Il faudra donc 4 bits pour définir ce groupe d'adresses, et la notation CIDR pour ce groupe sera donc : 32-4=28.
      Voilà donc ce premier groupe de 16 adresses : 192.168.0.0 à 192.168.0.15 qu'on notera : 192.168.0.0/28

      Il nous reste encore le groupe d'adresses 192.168.0.16 à 192.168.0.27, donc 12 adresses.
      12 n'étant pas une puissance de 2, il ne sera pas possible de regrouper ces 12 adresses IP dans un unique groupe.

      Cherchons, parmi les puissances de 2, celle qui sera la plus grande mais qui restera tout de même inférieure ou égale à 12 :
      2¹=2, 2²=4, 2³=8, 2⁴=16 Oups! on a dépassé 12, alors on va prendre 8, c'est à dire 2 puissance 3.
      Il faudra donc 3 bits pour définir ce groupe d'adresses, et la notation CIDR pour cet groupe sera donc : 32-3=29.
      Voilà donc ce deuxième groupe de 8 adresses : 192.168.0.16 à 192.168.0.23 qu'on notera : 192.168.0.16/29

      Il nous reste encore le groupe d'adresses 192.168.0.24 à 192.168.0.27, donc 4 adresses.
      Pour ces 4 adresses, il est tout-à fait possible de créer un groupe d'adresses IP les regroupant toutes, car 2²=4.
      Il faudra donc 2 bits pour définir ce groupe d'adresses, et la notation CIDR pour ce groupe sera donc : 32-2=30.
      Voilà donc ce troisième groupe de 4 adresses : 192.168.0.24 à 192.168.0.27 qu'on notera : 192.168.0.24/30

    2. Pour les adresses IP 192.168.0.29 à 192.168.0.255

      226 n'étant pas une puissance de 2, il ne sera pas possible de regrouper ces 226 adresses IP dans un unique groupe.
      De plus, comme le dernier octet de la première adresse n'est pas une puissance de 2,
       il nous sera impossible d'utiliser un masque qui pourrait permettre de définir un groupe d'adresses en notation CIDR.

      On va donc énumérer les premières adresses de ce deuxième groupe jusqu'à obtenir une adresse de départ utilisable avec un masque.
      192.168.0.29
      192.168.0.30
      192.168.0.31
      192.168.0.32 Ahhh! On y est : 2⁵=32 corresponds bien à une puissance de 2, on va maintenant pouvoir définir un groupe d'adresses.

      Le groupe d'adresses suivant débutera donc à l'adresse IP suivante, soit : 192.168.0.32
      Avec cette adresse, on constate que les 5 derniers bits sont à 0 (32 => 0010 0000)
      Le masque utilisable sera donc de 32-5=27 et le groupe d'adresses IP sera donc noté : 192.168.0.32/27
      Ce masque permet donc de regrouper 2⁵=32 adresses en notation CIDR.
      Ce groupe d'adresses comprendra donc les adresses IP 192.168.0.32 à 192.168.0.63

      Le groupe d'adresses suivant débutera donc à l'adresse IP suivante, soit : 192.168.0.64
      Avec cette adresse, on constate que les 6 derniers bits sont à 0 (64 => 0100 0000)
      Le masque utilisable sera donc de 32-6=26 et le groupe d'adresses IP sera donc noté : 192.168.0.64/26
      Ce masque permet donc de regrouper 2⁶=64 adresses en notation CIDR.
      Ce groupe d'adresses comprendra donc les adresses IP 192.168.0.64 à 192.168.0.127

      Le groupe d'adresses suivant débutera donc à l'adresse suivante, soit : 192.168.0.128
      Avec cette adresse, on constate que les 7 derniers bits sont à 0 (128 => 1000 0000)
      Le masque utilisable sera donc de 32-7=25, et le groupe d'adresses IP sera donc noté : 192.168.0.128/25
      Ce masque permet donc de regrouper 2⁷=128 adresses en notation CIDR.
      Ce groupe d'adresses comprendra donc les adresses 192.168.0.128 à 192.168.0.255

  2. Conclusion :

    Pour que le répertoire "/home" soit exporté et accessible en lecture et écriture (rw)
    pour l'ensemble des adresses définies par 192.168.0.0/24 SAUF pour l'adresse 192.168.0.28,
     il faudra inscrire la ligne suivante dans le fichier de configuration "/etc/exports". 
    /home 192.168.0.0/28(rw) 192.168.0.16/29(rw) 192.168.0.24/30(rw) 192.168.0.29(rw) 192.168.0.30(rw) 192.168.0.31(rw) 192.168.0.32/27(rw) 192.168.0.64/26(rw) 192.168.0.128/25(rw)

    Bon, mais c'est quand même pas très pratique à lire une ligne aussi longue,
     mais dans le fichier "/etc/exports" il est possible de scinder cette trop longue ligne en plusieurs en utilisant le caractère "\". 

    /home                                                        \
192.168.0.0/28(rw)  192.168.0.16/29(rw) 192.168.0.24/30(rw)  \
192.168.0.29(rw)    192.168.0.30(rw)    192.168.0.31(rw)     \
192.168.0.32/27(rw) 192.168.0.64/26(rw) 192.168.0.128/25(rw)

Les options de partage classiques

Les options pas défaut sont en majuscule.

  • rw/RO

Lecture & écriture / Lecture uniquement

  • SYNC/async (doit être spécifié, sinon warning de la part de exportfs)

async permet au serveur NFS de passer outre le protocole NFS et de répondre aux requêtes avant que les changements effectués par une requête antérieure aient été appliqués. Utilisable raisonnablement en combinaison avec ro.

  • NO_SUBTREE_CHECK/subtree_check (doit être spécifié, sinon warning)

Distinction subtile, retenir que :

Dans le cas du partage d'un répertoire de type /home, où beaucoup de fichiers peuvent être renommés, préférer no_subtree_check.
Pour un répertoire principalement ro, ou peu de fichiers sont renommés (par exemple /usr ou /var), préférer subtree_check.
  • fsid=0 ou fsid=root

nfs4 utilise un pseudo système de fichiers. Il faut donc indiquer le répertoire qui en sera la racine, grâce à l'option fsid=0. Désormais, le montage de cette "racine" en nfs4 monte le répertoire ainsi désigné. Si l'on souhaite conserver la compatibilité avec les versions antérieures, il suffit de désigner la racine du serveur comme racine du pseudo système de fichiers en indiquant par exemple : / *(ro,async,no_subtree_check,fsdid=0)

Options de mapping

Attention, il s'agit d'un point délicat : l'UID de l'utilisateur de la machine cliente est utilisé sur le serveur. Aussi, pour créer un partage respectueux, il faut qu'il y ait correspondance exacte des UIDs/GIDs des utilisateurs/groupes entre le serveur et les clients. Pour contourner cette limitation, des options de mapping sont donc disponibles.

Par défaut, les utilisateurs mappés reçoivent l'uid/gid 65534. On peut écraser ces valeurs grâce aux options anonuid et anongid.

  • ROOT_SQUASH/no_root_squash : root_squash mappe root en utilisateur anonyme.
  • all_squash/NO_ALL_SQUASH : mappe tous les utilisateurs en utilisateur anonyme.

On peut résoudre le problème plus proprement en mettant en place un service d'annuaire typiquement NIS, basé lui aussi sur RPC, ou LDAP.

Exemples

/data 192.168.0.25(rw,sync,no_subtree_check) 192.168.0.33(ro,async,no_subtree_check)
/home 192.168.0.0/24(ro,async,no_subtree_check,fsid=0)
/home/pour_root 192.168.0.55(rw,sync,no_subtree_check,no_root_squash)

Redémarrage

# service nfs-kernel-server restart

ou 

# /etc/init.d/nfs-kernel-server restart

Sécurisation

Le protocole RPC n'a pas la réputation d'être bien sécurisé, mais la version 4 de NFS entend corriger ce problème, elle est donc à privilégier. Il est déconseillé d'effectuer un partage NFS via internet, ou bien dans ce cas, opter pour un tunnel crypté.

  1. S'assurer que les partages sont réservés à certaines IP dans /etc/exports
  2. S'appuyer sur rpcbind (/etc/hosts.deny et /etc/hosts.allow) pour sécuriser l'accès au serveur NFS
  3. Configurer convenablement iptables

rpcbind

Exemple de configuration (Tout le monde est interdit, puis le LAN est autorisé): 

# nano /etc/hosts.deny

...
 rpcbind mountd nfsd statd lockd rquotad : ALL
# nano /etc/hosts.allow

...
 rpcbind mountd nfsd statd lockd rquotad: 10.11.12.

iptables

Source

Par défaut, les différents services NFS (lockd, statd, mountd, etc.) demandent des assignations de ports aléatoires à partir du portmapper (portmap/rpcbind), ce qui signifie que la plupart des administrateurs doivent ouvrir une gamme de ports dans leur base de règles de pare-feu pour que NFS fonctionne. 

# rpcinfo -p | grep nlockmgr

    100005    1   udp  53978  mountd
    100005    1   tcp  41663  mountd
    100005    2   udp  59420  mountd
    100005    2   tcp  51826  mountd
    100005    3   udp  43855  mountd
    100005    3   tcp  42371  mountd
# /etc/init.d/nfs-kernel-server restart

# rpcinfo -p | grep mountd

    100005    1   udp  43892  mountd
    100005    1   tcp  55590  mountd
    100005    2   udp  44020  mountd
    100005    2   tcp  43086  mountd
    100005    3   udp  33108  mountd
    100005    3   tcp  57843  mountd

Il va donc falloir fixer les ports de ces services afin de créer les règles iptables. 

# nano /etc/default/nfs-common

...
STATDOPTS="--port 32765 --outgoing-port 32766"
...
# nano /etc/default/nfs-kernel-server

...
RPCMOUNTDOPTS="-p 32767"
...
# nano /etc/default/quota

...
RPCRQUOTADOPTS="-p 32769"
...
# sysctl --system
# /etc/init.d/nfs-kernel-server restart

Nous pouvons maintenant fixer nos règles iptables: 

iptables -A INPUT -s 10.11.12.0/24 -p tcp -m multiport --ports 111,2049,32764:32769 -j ACCEPT
iptables -A INPUT -s 10.11.12.0/24 -p udp -m multiport --ports 111,2049,32764:32769 -j ACCEPT

Sur le client

Installation

Installer le paquet nfs-common avec son gestionnaire de paquets habituel, par exemple : 

# apt-get install nfs-common

Vérification de l'installation

Portmap doit attendre les instructions sur le port 111: 

# rpcinfo -p | grep portmap

    100000    2   tcp    111  portmapper
    100000    2   udp    111  portmapper

Montage du répertoire distant

Les options de montage communes à tous les systèmes de fichiers

Pour mémoire, le raccourci "defaults" désigne l'ensemble des options suivantes : rw, suid, dev, exec, auto, nouser, et async.

Parmi toutes les autres options disponibles, les suivantes sont intéressantes :

  • "_netdev" indique que le système de fichiers se trouve sur un périphérique qui nécessite un accès réseau. Cela permet d'éviter d'essayer de le monter si la connexion réseau n'est pas établie.
  • AUTO/noauto monte (ou pas) le système de fichier à l'appel de "mount -a", c'est à dire lors du boot.

Les options de montage spécifiques à NFS

Lorsq'un montage se fait pour un système de fichiers de type NFS, une série d'options spécifiques est alors disponible. Voici les plus utiles :

  • HARD/soft

L'option hard spécifie au client d'attendre le retour du serveur dans le cas où celui-ci crasherait. L'utilisateur ne peut terminer l'attente, à moins d'avoir sélectionné l'option INTR. Dans une situation identique, l'option soft renvoie une erreur au programme appelant, au bout d'une durée d'attente à fixer grâce à l'option timeo.

  • INTR/nointr

Intr permet d'interrompre les requêtes NFS si le serveur ne répond pas. Accompagne l'option HARD.

Syntaxe

On peut utiliser :

  • la commande mount :
# mount -t nfs4 -o <options> <ip_serveur>:<rep_serveur> <point_montage_local>
  • une entrée dans /etc/fstab
<ip du serveur>:/répertoire_partagé	/point_de_montage	nfs4	<options>	0	0

Exemples

Avec mount, montage de la "racine" nfs4 désigné au deuxième exemple de 1.3.4.

# mount -t nfs4 -o ro 192.168.0.11:/ /tous_les_homes

/etc/fstab : 

...
192.168.0.11:/data	/home/serveur_nfs	nfs	_netdev,nodev,noexec	0	0
...

Sources

Dernière mise à jour: Lol (discussion) 28 juin 2017 à 14:09 (CEST)

Récupérée de « https://forum-debian.fr/wiki/index.php?title=Partage_NFS&oldid=7998 »