NFS: esempi

NFS

Sommario

Spazio Kernel

In questa pagina si mostreranno alcuni esempi pratici sull'utilizzo di NFS.

LAN e autofs

L'esempio che segue presuppone una configurazione della propria LAN di questo tipo:

NFSv4
Client e server Debian
IP Server = 192.168.1.1
IP Client1 = 192.168.1.10
IP Client2 = 192.168.1.11
Mount con autofs (metodo (dinamico)
Risoluzione dei nomi attraverso il file /etc/hosts
La directory da esportare tramite NFS sarà, sul server, /home/nfs/

/etc/hosts

Le macchine della LAN avranno un nome di dominio fittizio, in questo caso sarà "mialan". Modificare di conseguenza il file /etc/hosts :

Server

192.168.1.1 nomeserver.mialan nomeserver

Client1

192.168.1.10 nomeclient1.mialan nomeclient1

Client2

192.168.1.11 nomeclient2.mialan nomeclient2

I nomi delle macchine (nomeserver, nomeclient1 e nomeclient2) sono tipicamente già presenti all'interno del file, altrimenti ricavarle con il comando:

$ hostname

Configurazione server

Tutti i passi seguenti richiedono i permessi di amministratore del server.

Installare il pacchetto "nfs-kernel-server":
```
# apt-get install nfs-kernel-server
```
Creare la directory da condividere:
```
# mkdir /home/nfs
```
Si noti che la directory appena creata dall'utente "root" ha permessi "755" per cui un normale utente non ha su di essa il permesso di scrittura. Questa situazione può essere risolta in due modi:
- Si modificano i permessi della directory in "777" (o "757")
- Si crea un nuovo gruppo e si fa in modo che la directory abbia permessi "775" e proprietari root/nuovogruppo
In questo esempio verrà percorsa questa seconda strada.
Creare un nuovo gruppo, ad esempio "nfs-users":
```
# addgroup nfs-users
```
Modificare i permessi della directory da condividere:
```
# chmod 775 /home/nfs
```
e infine modificarne i proprietari:
```
# chown root:nfs-users /home/nfs
```
Aggiungere tutti gli utenti che si desiderano al nuovo gruppo appena creato. Per l'utente "nomeutente1":
```
# adduser nomeutente1 nfs-users
```
Da questo momento in poi (previo un suo logout se l'utente è collegato al server) "nomeutente1" avrà i permessi per scrivere all'interno della directory "/home/nfs".
Modificare il file "/etc/exports" aggiungendovi la seguente riga per rendere condivisibile la directory /home/nfs:
```
/home/nfs 192.168.1.0/24(rw,fsid=0,no_subtree_check,crossmnt,sync)
```
Da questo momento la directory /home/nfs sarà la "radice" delle risorse esportate.
Modificare i file /etc/default/nfs-common e /etc/default/nfs-kernel-server come già spiegato qui.
Modificare il file /etc/idmapd.conf specificando il dominio fittizio scelto e aggiungendo questa riga (o decommentando/modificando la riga con la direttiva "Domain"):
```
Domain = mialan
```

Riavviare i servizi:

# service nfs-common restart
# service nfs-kernel-server restart

Configurazione client

La configurazione che segue è per un solo client. Per altri gli client la procedura è analoga.

Installare i pacchetti "nfs-common" e "autofs5":
```
# apt-get install nfs-common autofs5
```
Modificare i file /etc/default/nfs-common e /etc/idmapd.conf come spiegato qui. Il file idmapd.conf dovrà avere la stessa riga che specifica il dominio fittizio. In questo caso:
```
Domain = mialan
```
Riavviare nfs-common:
```
# service nfs-common restart
```
Creare il file /etc/auto.nfs il cui contenuto varierà a seconda del tipo di automount scelto.
Metodo indiretto
```
nfs -fstype=nfs4,hard,intr 192.168.1.1:/
```
Ciò significa che sul client verrà montata la "radice" (la directory contrassegnata da "fsid=0" sul server) delle risorse condivise tramite NFS e il nome sarà "nfs".
Metodo diretto
```
/nfs -fstype=nfs4,hard,intr 192.168.1.1:/
```
La risorsa remota sarà montata all'interno della directory /nfs . Questa directory verrà creata automaticamente da "autofs"; accertarsi che non esista.
Solo metodo indiretto
Creare un punto di mount:
```
# mkdir /home/condivisa
```
Modificare il file "/etc/auto.master" aggiungendovi la seguente riga in base al tipo di mount scelto.
Metodo diretto
```
/- /etc/auto.nfs
```
Ciò vuol dire che il mountpoint sul client sarà /home/nfs cioè ciò che è stato specificato nel file auto.nfs .
Metodo indiretto
```
/home/condivisa /etc/auto.nfs
```
Ciò vuol dire che il mountpoint sul client sarà /home/condivisa e al suo interno sarà montata la directory remota con il nome scelto nel file auto.nfs .
Riavviare "autofs":
```
# service autofs restart
```
Rendere operativo l'automount.
Metodo diretto
```
$ touch /nfs
```
Metodo indiretto
```
$ touch /home/condivisa/nfs
```
Per automatizzare l'eecuzione di questo comando è possibile creare uno script che verrà eseguito ogni volta che viene stabilita una connessione. È sufficiente creare il file /etc/network/if-up.d/my-touch-nfs contenente un comando coerente con il tipo di mount scelto.
Metodo diretto
```
#!/bin/sh


# File creato il ... per rendere operativo il mount dinamico della risorsa NFS attraverso autofs
touch /nfs >/dev/null 2>&1
```
Metodo indiretto
```
#!/bin/sh


# File creato il ... per rendere operativo il mount dinamico della risorsa NFS attraverso autofs
touch /home/condivisa/nfs >/dev/null 2>&1
```
In entrambi i casi bisogna rendere eseguibile il file appena creato:
```
# chmod +x /etc/network/if-up.d/my-touch-nfs
```