« NFS » : différence entre les versions

De Lea Linux
Aller à la navigation Aller à la recherche
mAucun résumé des modifications
m (Rajout partie sécurisation à travers SSH)
Ligne 21 : Ligne 21 :
* <u>Pour le client:</u>
* <u>Pour le client:</u>
<br /><tt>NFS file system support et Provide NFSv3 client support</tt>
<br /><tt>NFS file system support et Provide NFSv3 client support</tt>
  CONFIG_NFS_FS=y ou m
  CONFIG_NFS_FS=y ou m
  CONFIG_NFS_V3=y
  CONFIG_NFS_V3=y
* <u>Pour le serveur:</u>
* <u>Pour le serveur:</u>
<br /><tt>NFS server support et Provide NFSv3 server support</tt>
<br /><tt>NFS server support et Provide NFSv3 server support</tt>
  CONFIG_NFSD=y ou m
  CONFIG_NFSD=y ou m
  CONFIG_NFSD_V3=y
  CONFIG_NFSD_V3=y


À partir du noyau 2.2.18, les modules supportent entièrement la version 3 du protocole ainsi que différentes corrections de bug. <br />Il serait temps d'upgrader si tu ne l'as pas déjà fait! (profites-en pour passer au 2.4, ce sera réglé :)
À partir du noyau 2.2.18, les modules supportent entièrement la version 3 du protocole ainsi que différentes corrections de bug. <br />Il serait temps d'upgrader si tu ne l'as pas déjà fait! (profites-en pour passer au 2.4, ce sera réglé :)
Ligne 49 : Ligne 49 :
Le fichier <tt>/etc/exports</tt> est très simple :
Le fichier <tt>/etc/exports</tt> est très simple :


   <tt>répertoire machine1(option11,option12) machine2(option21,option22)</tt>
  <code>répertoire machine1(option11,option12) machine2(option21,option22)</code>


par exemple :
par exemple :


   <tt>/home 192.168.0.10(rw) 192.168.0.25(ro)</tt>
  <code>/home 192.168.0.10(rw) 192.168.0.25(ro)</code>


signifie que l'on autorisera la machine ''192.168.0.10'' à accéder à notre répertoire <tt>/home</tt> en lecture et écriture (<tt>rw</tt>) ainsi que la machine ''192.168.0.25'' mais uniquement en lecture (<tt>ro</tt>).
signifie que l'on autorisera la machine ''192.168.0.10'' à accéder à notre répertoire <tt>/home</tt> en lecture et écriture (<tt>rw</tt>) ainsi que la machine ''192.168.0.25'' mais uniquement en lecture (<tt>ro</tt>).
Ligne 67 : Ligne 67 :
Un point important, pour un bon fonctionnement : tu dois avoir les mêmes numéros de groupes et d'utilisateurs sur les deux machines. <br />Des systèmes permettent de gérer çà, NIS (assez ancien) ou LDAP (plus récent). Avec peu d'utilisateurs, tu peux tout simplement éditer <tt>/etc/group</tt> et <tt>/etc/passwd</tt> pour synchroniser ces numéros.
Un point important, pour un bon fonctionnement : tu dois avoir les mêmes numéros de groupes et d'utilisateurs sur les deux machines. <br />Des systèmes permettent de gérer çà, NIS (assez ancien) ou LDAP (plus récent). Avec peu d'utilisateurs, tu peux tout simplement éditer <tt>/etc/group</tt> et <tt>/etc/passwd</tt> pour synchroniser ces numéros.


Il n'est pas recommandé d'exporter un système DOS ou VFAT à cause de leurs absences de gestion multi-utilisateurs ; ils ne sont pas fait pour être partagés avec NFS. <br /> 
Il n'est pas recommandé d'exporter un système DOS ou VFAT à cause de leurs absences de gestion multi-utilisateurs ; ils ne sont pas fait pour être partagés avec NFS. <br />  


=== /etc/hosts.deny ===
=== /etc/hosts.deny ===
Ligne 79 : Ligne 79 :
  statd:ALL
  statd:ALL


 


=== /etc/hosts.allow ===
=== /etc/hosts.allow ===
Ligne 85 : Ligne 85 :
Dans le même esprit que pour le <tt>/etc/hosts.deny</tt>, ce fichier a l'architecture suivante :
Dans le même esprit que pour le <tt>/etc/hosts.deny</tt>, ce fichier a l'architecture suivante :


  [service]: [IP de la machine client]
  [service]: [IP de la machine client]


Donc pour autoriser 192.168.1.34 à se connecter à un partage NFS, on écrira :
Donc pour autoriser 192.168.1.34 à se connecter à un partage NFS, on écrira :


  portmap:192.168.1.34
  portmap:192.168.1.34
  lockd:192.168.1.34
  lockd:192.168.1.34
  mountd:192.168.1.34
  mountd:192.168.1.34
  rquotad:192.168.1.34
  rquotad:192.168.1.34
  statd:192.168.1.34
  statd:192.168.1.34


On va pouvoir lancer les services ; sur ma Debian, je lance :
On va pouvoir lancer les services ; sur ma Debian, je lance :


  <nowiki># /etc/init.d/nfs-server start</nowiki>
  <code># /etc/init.d/nfs-server start</code>


Pour Slackware, ce serait
Pour Slackware, ce serait


  <nowiki># /etc/rc.d/rc.nfsd start</nowiki>
  <code># /etc/rc.d/rc.nfsd start</code>


La commande <tt>rpcinfo -p</tt> permet de vérifier que les services fonctionnent. Elle devrait produire un résultat dans cet esprit :
La commande <tt>rpcinfo -p</tt> permet de vérifier que les services fonctionnent. Elle devrait produire un résultat dans cet esprit :


cacahuete:~# rpcinfo -p
<code> cacahuete:~# rpcinfo -p
 program vers proto   port
  program vers proto  port
    100000    2   tcp    111  portmapper
  100000    2  tcp    111 portmapper
    100000    2   udp    111  portmapper
  100000    2  udp    111 portmapper
    100024    1   udp    737  status
  100024    1  udp    737 status
    100024    1   tcp    739  status
  100024    1  tcp    739 status
    100011    1   udp    851  rquotad
  100011    1  udp    851 rquotad
    100011    2   udp    851  rquotad
  100011    2  udp    851 rquotad
    100003    2   udp   2049  nfs
  100003    2  udp  2049 nfs
    100003    2   tcp   2049  nfs
  100003    2  tcp  2049 nfs
    100005    1   udp    872  mountd
  100005    1  udp    872 mountd
    100005    2   udp    872  mountd
  100005    2  udp    872 mountd
    100005    1   tcp    875  mountd
  100005    1  tcp    875 mountd
    100005    2   tcp    875  mountd
  100005    2  tcp    875 mountd
  cacahuete:~#
  cacahuete:~#
</code>


Pour recharger les services NFS (par exemple après une modification du fichier de config) :
Pour recharger les services NFS (par exemple après une modification du fichier de config) :


cacahuete:~# killall -HUP nfsd
<code> cacahuete:~# killall -HUP nfsd
</code>


le serveur est prêt ! <br /> 
le serveur est prêt ! <br />  


== Le client ==
== Le client ==
Ligne 131 : Ligne 133 :
Pour utiliser NFS v3, il faut au minimum la version 2.10m du programme <tt>mount</tt>. Pour voir sa version, taper :
Pour utiliser NFS v3, il faut au minimum la version 2.10m du programme <tt>mount</tt>. Pour voir sa version, taper :


cacahuete:~# mount -V
<code> cacahuete:~# mount -V
  mount: mount-2.11h
  mount: mount-2.11h
  cacahuete:~#
  cacahuete:~#
</code>


On va maintenant pouvoir monter notre partage!
On va maintenant pouvoir monter notre partage!


cacahuete:~# mount mon.serveur.nfs:/home /mnt/home
<code> cacahuete:~# mount mon.serveur.nfs:/home /mnt/home
  cacahuete:~#
  cacahuete:~#
</code>


En principe tout devrait bien se dérouler.
En principe tout devrait bien se dérouler.
Ligne 144 : Ligne 148 :
Pour monter ce partage définitivement à chaque démarrage de la machine, éditons notre <tt>/etc/fstab</tt><nowiki>: </nowiki>
Pour monter ce partage définitivement à chaque démarrage de la machine, éditons notre <tt>/etc/fstab</tt><nowiki>: </nowiki>


  <nowiki># device       mountpoint  fs-type options dump fsckorder
 
  <code># device      mountpoint  fs-type options dump fsckorder
  ...
  ...
  master.foo.com:/home  /mnt nfs     rw      0    0
  master.foo.com:/home  /mnt nfs    rw      0    0
  ...</nowiki>
  ...</code>
 
== Sécuriser le NFS ==
 
Les données transitent en clair sur le réseau, néanmoins il est possible de crypter les échange grâce au ''port forwarding'' de ssh.
La mise en place de la cryptographie se fait en deux parties : une partie sur le serveur, une partie sur le client.


 
=== Configuration du serveur ===
 
Nous avons besoin de connaître et/ou de définir le port tcp utilisé par mountd. Un petit <code>rpcinfo -p</code> permettra de savoir quel port est utilisé par mountd. On peut définir celui-ci via l'option ''-d'' lors du lancement du service. Dans notre exemple, il s'agit du port 875.
Il faut également rajouter l'option ''insecure'' pour les machines/réseaux concernés dans <tt>/etc/exports</tt>. Cette option permet seulement de pouvoir atteindre le serveur via un port > 1024 (ce que nous allons faire).
 
=== Configuration du client ===
 
Nous avons besoin de deux ports libres, par exemple 38000 et 38001 pour créer un tunnel sécurisé entre le client et le serveur :
 
<code>ssh -f -N -L38000:serveur:2049 -L38001:serveur:875 -l root serveur</code>
 
L'utilisation de l'utilisateur root est nécessaire car on va travailler avec un port < 1024. La mise en place d'une authentification par clé peut être dans ce cas très intéressante.
Avec cette commande nous venons de créer un tunnel chiffré entre le port 38000 (resp. 38001) de notre client et le 2049 (resp. 875) du serveur.
Il ne reste plus qu'à monter le partage! Le fait d'utiliser un tunnel ssh implique que nous allons utiliser exclusivement une connection tcp.
Pour monter le partage :
 
<code>mount -t nfs -o rw,port=38000,mountport=38001 localhost:/repertoire /mnt/nfs</code>
 
Cette commande permet de monter serveur:/repertoire dans /mnt/nfs. Il faut bien utiliser localhost:/repertoire pour monter le partage. C'est justement cela qui va permettre d'utiliser la connexion sécurisée.
 
On peut également rajouter cette ligne dans le /etc/fstab :
 
<code># device      mountpoint  fs-type options dump fsckorder
...
localhost:/home  /mnt nfs    rw,port=38000,mountport=38001      0    0
...</code>


== Liens ==
== Liens ==

Version du 19 septembre 2006 à 17:30

Installation d'un serveur NFS

Installation d'un serveur NFS
Guillaume Pierronnet
NFS, ou le partage des ressources selon Unix.

Introduction

NFS signifie Network File System. C'est, comme son nom l'indique, un système de fichiers en réseau qui permet de partager ses données principalement entre systèmes UNIX. À la différence de SAMBA, NFS gère les permissions sur les fichiers et on peut donc l'utiliser de manière totalement transparente dans son arborescence Linux.

ATTENTION !

Comme toute application réseau, NFS ouvre des trous dans la sécurité du système. Je vous invite donc à consulter les liens à la fin de cet article pour des précisions sur la sécurité (celui-ci, en anglais, indique quelques règles à suivre, en parallèle des démarches indiquées dans ce guide nfs pour Debian ou ci-dessous).

Les softs

Les modules du noyau

Dans la configuration du noyau, on va dans la section "File systems ---> Network File Systems"

  • Pour le client:


NFS file system support et Provide NFSv3 client support

  CONFIG_NFS_FS=y ou m
  CONFIG_NFS_V3=y
  • Pour le serveur:


NFS server support et Provide NFSv3 server support

  CONFIG_NFSD=y ou m
  CONFIG_NFSD_V3=y

À partir du noyau 2.2.18, les modules supportent entièrement la version 3 du protocole ainsi que différentes corrections de bug.
Il serait temps d'upgrader si tu ne l'as pas déjà fait! (profites-en pour passer au 2.4, ce sera réglé :)

Les packages

Les packages (sur ma Debian) sont :

  • nfs-common
  • nfs-user-server pour le serveur.

Tu peux toujours récupérer les sources qui se trouvent sur http://nfs.sourceforge.net/.

On va aussi installer le wrapper TCP pour un minimum de sécurité. Toujours sur ma Debian, le paquet s'appelle tcpd. Les sources se trouvent ici.

Le serveur

Les 3 fichiers de configuration principaux sont /etc/exports, /etc/hosts.deny et /etc/hosts.allow.

/etc/exports

Le fichier /etc/exports est très simple :

  répertoire machine1(option11,option12) machine2(option21,option22)

par exemple :

  /home 192.168.0.10(rw) 192.168.0.25(ro)

signifie que l'on autorisera la machine 192.168.0.10 à accéder à notre répertoire /home en lecture et écriture (rw) ainsi que la machine 192.168.0.25 mais uniquement en lecture (ro).

  • répertoire :
    le répertoire du serveur à partager.
  • machine :
    Une liste de machines séparée par des virgules et autorisées à monter ce répertoire (utilisez des adresses IP plutôt que des noms à cause des problèmes de "dns spoofing").
  • options :
    • ro :
      C'est la valeur par défaut, lecture seule.
    • rw :
      La machine à un accès en lecture/écriture au répertoire.
    • no_root_squash :
      Les accès par l'utilisateur root sur le serveur se font sous l'identité root, au contraire de nobody (par défaut)
      À UTILISER AVEC PRÉCAUTION
    • sync : uniquement NFS v2
      Ne diffère pas les écritures physiques au volume, augmente la fiabilité en cas de mauvais démontage. La version 3 dispose d'un mécanisme de commit-rollback donc cette option n'est pas utile.

Un point important, pour un bon fonctionnement : tu dois avoir les mêmes numéros de groupes et d'utilisateurs sur les deux machines.
Des systèmes permettent de gérer çà, NIS (assez ancien) ou LDAP (plus récent). Avec peu d'utilisateurs, tu peux tout simplement éditer /etc/group et /etc/passwd pour synchroniser ces numéros.

Il n'est pas recommandé d'exporter un système DOS ou VFAT à cause de leurs absences de gestion multi-utilisateurs ; ils ne sont pas fait pour être partagés avec NFS.

/etc/hosts.deny

On va interdire toutes les machines qui ne sont pas autorisées explicitement dans le /etc/hosts.allow.
Un bon vieux "ALL: ALL" interdira l'accès à tous les services à partir de toutes les machines. On peut cependant être plus précis en écrivant :

portmap:ALL
lockd:ALL
mountd:ALL
rquotad:ALL
statd:ALL


/etc/hosts.allow

Dans le même esprit que pour le /etc/hosts.deny, ce fichier a l'architecture suivante :

  [service]: [IP de la machine client]

Donc pour autoriser 192.168.1.34 à se connecter à un partage NFS, on écrira :

  portmap:192.168.1.34
  lockd:192.168.1.34
  mountd:192.168.1.34
  rquotad:192.168.1.34
  statd:192.168.1.34

On va pouvoir lancer les services ; sur ma Debian, je lance :

# /etc/init.d/nfs-server start

Pour Slackware, ce serait

# /etc/rc.d/rc.nfsd start

La commande rpcinfo -p permet de vérifier que les services fonctionnent. Elle devrait produire un résultat dans cet esprit :

cacahuete:~# rpcinfo -p

 program vers proto   port
  100000    2   tcp    111  portmapper
  100000    2   udp    111  portmapper
  100024    1   udp    737  status
  100024    1   tcp    739  status
  100011    1   udp    851  rquotad
  100011    2   udp    851  rquotad
  100003    2   udp   2049  nfs
  100003    2   tcp   2049  nfs
  100005    1   udp    872  mountd
  100005    2   udp    872  mountd
  100005    1   tcp    875  mountd
  100005    2   tcp    875  mountd
cacahuete:~#

Pour recharger les services NFS (par exemple après une modification du fichier de config) :

cacahuete:~# killall -HUP nfsd

le serveur est prêt !

Le client

Pour utiliser NFS v3, il faut au minimum la version 2.10m du programme mount. Pour voir sa version, taper :

cacahuete:~# mount -V

mount: mount-2.11h
cacahuete:~#

On va maintenant pouvoir monter notre partage!

cacahuete:~# mount mon.serveur.nfs:/home /mnt/home

cacahuete:~#

En principe tout devrait bien se dérouler.

Pour monter ce partage définitivement à chaque démarrage de la machine, éditons notre /etc/fstab:


# device       mountpoint  fs-type options dump fsckorder
...
master.foo.com:/home  /mnt nfs     rw      0    0
...

Sécuriser le NFS

Les données transitent en clair sur le réseau, néanmoins il est possible de crypter les échange grâce au port forwarding de ssh. La mise en place de la cryptographie se fait en deux parties : une partie sur le serveur, une partie sur le client.

Configuration du serveur

Nous avons besoin de connaître et/ou de définir le port tcp utilisé par mountd. Un petit rpcinfo -p permettra de savoir quel port est utilisé par mountd. On peut définir celui-ci via l'option -d lors du lancement du service. Dans notre exemple, il s'agit du port 875. Il faut également rajouter l'option insecure pour les machines/réseaux concernés dans /etc/exports. Cette option permet seulement de pouvoir atteindre le serveur via un port > 1024 (ce que nous allons faire).

Configuration du client

Nous avons besoin de deux ports libres, par exemple 38000 et 38001 pour créer un tunnel sécurisé entre le client et le serveur :

ssh -f -N -L38000:serveur:2049 -L38001:serveur:875 -l root serveur

L'utilisation de l'utilisateur root est nécessaire car on va travailler avec un port < 1024. La mise en place d'une authentification par clé peut être dans ce cas très intéressante. Avec cette commande nous venons de créer un tunnel chiffré entre le port 38000 (resp. 38001) de notre client et le 2049 (resp. 875) du serveur. Il ne reste plus qu'à monter le partage! Le fait d'utiliser un tunnel ssh implique que nous allons utiliser exclusivement une connection tcp. Pour monter le partage :

mount -t nfs -o rw,port=38000,mountport=38001 localhost:/repertoire /mnt/nfs

Cette commande permet de monter serveur:/repertoire dans /mnt/nfs. Il faut bien utiliser localhost:/repertoire pour monter le partage. C'est justement cela qui va permettre d'utiliser la connexion sécurisée.

On peut également rajouter cette ligne dans le /etc/fstab :

# device mountpoint fs-type options dump fsckorder

...
localhost:/home  /mnt nfs     rw,port=38000,mountport=38001      0    0
...

Liens

Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Guillaume Pierronnet le 22/10/2001.

Copyright

Copyright © 22/10/2001, Guillaume Pierronnet

Creative Commons License
Creative Commons Attribution iconCreative Commons Share Alike iconCreative Commons Noncommercial
Ce document est publié sous licence Creative Commons
Attribution, Partage à l'identique, Contexte non commercial 2.0 :
http://creativecommons.org/licenses/by-nc-sa/2.0/fr/


Autres ressources