# NFS — Network File System

**Cicle formatiu:** CFGM Sistemes Microinformàtics i Xarxes (SMX)

**Mòdul:** 0224 – Sistemes operatius en xarxa 

# 1. Introducció

**NFS** (*Network File System*) és un protocol que permet a un sistema Linux/Unix compartir directoris i fitxers amb altres màquines a través de la xarxa, fent que els recursos remots es comportin com si fossin part del sistema de fitxers local. Va ser desenvolupat originalment per Sun Microsystems i avui en dia és l'estàndard de facto per compartir fitxers entre sistemes Unix-like.

## 1.1. Per a què serveix

- **Centralitzar dades** d'usuaris o aplicacions en un únic servidor.
- **Compartir directoris home** entre múltiples estacions de treball (entorns NIS/LDAP).
- **Servir imatges de sistema** a clients sense disc (per exemple, en arrencades PXE/LTSP).
- **Crear espais de treball compartits** per a equips de desenvolupament o aules.
- **Implementar còpies de seguretat** centralitzades accessibles des de diversos hosts.

## 1.2. Quan no usar NFS

- Quan calgui interoperabilitat amb clients Windows natius → millor **Samba**.
- Quan calgui xifratge fort sense Kerberos → considerar **SSHFS** o NFS sobre Kerberos.
- En xarxes públiques o no confiables, sense mesures addicionals de seguretat.


# 2. Arquitectura i versions

NFS funciona amb un model client-servidor: el servidor **exporta** (comparteix) directoris, i els clients els **munten** dins del seu propi arbre de fitxers.

![El servidor exporta i el client munta](https://proferamon.com/tic/imatges/nfs/nfs01.png)

## 2.1. Versions principals

| Versió | Any | Característiques |
|---|---|-----------|
| NFSv2 | 1989 | Obsoleta, només UDP |
| NFSv3 | 1995 | Suport de fitxers grans, encara molt usada |
| **NFSv4** | 2003 | Integra autenticació, ACLs, funciona només sobre TCP, més segura |
| NFSv4.1/4.2 | 2010+ | Paral·lelisme (pNFS), millores de rendiment |

Aquest document se centra en **NFSv4**, recomanada per a desplegaments nous.

## 2.2. Components clau

| Component | Funció |
|---|-------|
| `nfs-kernel-server` | Dimoni del servidor NFS |
| `rpcbind` | Servei RPC necessari per a NFSv3 (NFSv4 no en depèn directament) |
| `nfs-common` | Eines client necessàries en totes les màquines |
| `exportfs` | Gestiona les exportacions actives |
| `/etc/exports` | Fitxer de configuració de les comparticions |
| `showmount` | Mostra les exportacions disponibles en un servidor |


## 2.3. Requisits previs 

- Dues o més màquines Linux (Debian/Ubuntu en els exemples) connectades en xarxa.
- Accés `sudo` o root a totes les màquines.
- Coneixement de l'esquema d'adreçament IP de la xarxa local.
- Tallafocs configurable (es treballa amb `ufw` en els exemples).

# 3. Instal·lació del servidor NFS

Actualitza la llista de paquets

```bash
sudo apt update
```

Instal·la el servidor NFS

```bash
sudo apt install nfs-kernel-server
```

Activa el servei

```bash
sudo systemctl enable nfs-kernel-server
```

Verifica l'estat del servei

```bash
sudo systemctl status nfs-kernel-server
```

Per a NFSv3 cal verificar també que el servei RPC funciona:

```bash
sudo systemctl status rpcbind
rpcinfo -p localhost
```

> [!NOTE] 
> Amb NFSv4 ja no és estrictament necessari `rpcbind` per al transport de dades, però sol mantenir-se actiu per compatibilitat amb eines com `showmount`.

## 3.1. Preparació dels directoris a compartir 

Crea els directoris

```bash
sudo mkdir -p /srv/nfs/compartit
sudo mkdir /srv/nfs/projectes
sudo mkdir /srv/nfs/backups
```

Directori de lectura/escriptura per a usuaris generals

```bash
sudo chown nobody:nogroup /srv/nfs/compartit
sudo chmod 755 /srv/nfs/compartit
```

Directori amb accés d'escriptura ampli

```bash
sudo chown nobody:nogroup /srv/nfs/projectes
sudo chmod 777 /srv/nfs/projectes
```

Directori restringit (només per a hosts concrets)

```bash
sudo chown root:root /srv/nfs/backups
sudo chmod 700 /srv/nfs/backups
```

## 3.2. Configuració de `/etc/exports`

Edita el fitxer `/etc/exports`

```bash
sudo nano /etc/exports
```

### Sintaxi general

```ini
/ruta/directori   client(opcions)   client2(opcions)
```

### Exemple complet

```nano
# ── Compartit general (lectura/escriptura) ────────────────
/srv/nfs/compartit    192.168.1.0/24(rw,sync,no_subtree_check)

# ── Projectes (lectura/escriptura, múltiples xarxes) ──────
/srv/nfs/projectes    192.168.1.0/24(rw,sync,no_subtree_check,no_root_squash)
/srv/nfs/projectes    10.0.0.0/24(rw,sync,no_subtree_check)

# ── Backups (només lectura) ───────────────────────────────
/srv/nfs/backups      192.168.1.10(ro,sync,no_subtree_check)
/srv/nfs/backups      192.168.1.11(ro,sync,no_subtree_check)

# ── Accés per a un host concret amb mapatge anònim ────────
/srv/nfs/compartit    192.168.1.50(rw,sync,no_subtree_check,all_squash,anonuid=1001,anongid=1001)

# ── Accés públic (qualsevol host) — evitar en producció ───
# /srv/nfs/public     *(ro,sync,no_subtree_check)
```

### Opcions principals

| Opció | Descripció |
|---|-----|
| `rw` | Lectura i escriptura |
| `ro` | Només lectura |
| `sync` | Escriu al disc abans de confirmar (segur) |
| `async` | Confirma abans d'escriure al disc (ràpid però arriscat) |
| `no_subtree_check` | Millora el rendiment; recomanat per defecte |
| `subtree_check` | Verifica que el fitxer és dins l'exportació |
| `root_squash` | Mapa l'usuari root del client a `nobody` (per defecte, recomanat) |
| `no_root_squash` | El root del client té privilegis de root al servidor (evitar-ho) |
| `all_squash` | Mapa tots els usuaris remots a `nobody` |
| `anonuid` / `anongid` | UID/GID assignats als usuaris anònims |
| `fsid=0` | Defineix el directori arrel per a NFSv4 |

## 3.3. Aplica i gestiona les exportacions

Exporta les comparticions definides a `/etc/exports`

```bash
sudo exportfs -a
```

Reinicia el servei perquè els canvis siguin efectius

```bash
sudo systemctl restart nfs-kernel-server
```

Verifica exportacions actives

```bash
sudo exportfs -v
```

Sortida d'exemple:

```ini
/srv/nfs/compartit
        192.168.1.0/24(sync,wdelay,hide,no_subtree_check,sec=sys,rw,secure,root_squash,no_all_squash)
/srv/nfs/backups
        192.168.1.10(sync,wdelay,hide,no_subtree_check,sec=sys,ro,secure,root_squash,no_all_squash)
```

Altres ordres útils:

Re-exporta després de modificar `/etc/exports` (sense reiniciar el servei)

```bash
sudo exportfs -rv
```

Elimina totes les exportacions actives

```bash
sudo exportfs -ua
```

## 3.4 Configuració del tallafocs

Ports NFS estàndard

```bash
sudo ufw allow from 192.168.1.0/24 to any port 2049 proto tcp
sudo ufw allow from 192.168.1.0/24 to any port 2049 proto udp
```

Ports RPC addicionals (NFSv3 / compatibilitat)

```bash
sudo ufw allow from 192.168.1.0/24 to any port 111 proto tcp
sudo ufw allow from 192.168.1.0/24 to any port 111 proto udp
sudo ufw reload
```

Per fixar els ports RPC dinàmics (mountd, lockd), cal editar:

```bash
sudo nano /etc/default/nfs-kernel-server
```

```nano
RPCMOUNTDOPTS="--manage-gids --port 32767"
RPCLOCKDOPTS="--port 32768"
```

```bash
sudo ufw allow 32767/tcp
sudo ufw allow 32767/udp
sudo ufw allow 32768/tcp
sudo ufw allow 32768/udp
sudo ufw reload
sudo systemctl restart nfs-kernel-server
```

# 4. Configuració del client NFS

Instal·la el paquet `nfs-common`

```bash
sudo apt install nfs-common
```

## 4.1. Descobreix exportacions disponibles

```bash
showmount -e 192.168.1.10
```

Sortida d'exemple:

```ini
Export list for 192.168.1.10:
/srv/nfs/projectes 192.168.1.0/24
/srv/nfs/compartit 192.168.1.0/24
/srv/nfs/backups   192.168.1.10
```

## 4.2. Munta manualment

Crea les carpetes 

```bash
sudo mkdir /mnt/compartit
sudo mkdir /mnt/projectes
```

Munta amb NFSv4 (recomanat)

```bash
sudo mount -t nfs4 192.168.1.10:/srv/nfs/compartit /mnt/compartit
```

Munta amb opcions específiques de rendiment

```bash
sudo mount -t nfs4 -o rw,hard,intr,rsize=8192,wsize=8192 \
  192.168.1.10:/srv/nfs/projectes /mnt/projectes
```

Verifica el muntatge

```bash
df -h | grep nfs
mount | grep nfs
```

## 4.3. Desmunta

Desmunta un recurs compartit

```bash
sudo umount /mnt/compartit
```

Si el recurs no respon (stale handle)

```bash
sudo umount -l /mnt/compartit
```

## 4.4. Muntatge automàtic amb `/etc/fstab`

Edita el fitxer de configuració `/etc/fstab` ("file systems table"), que s'utilitza per definir de manera automàtica i persistent quins sistemes de fitxers (particions, discos, unitats de xarxa...) s'han de muntar al sistema, on, i amb quines opcions — sense haver-ho de fer manualment cada cop que arrenca la màquina.

```bash
sudo nano /etc/fstab
```

```nano
# ── Muntatges NFS ─────────────────────────────────────────
192.168.1.10:/srv/nfs/compartit  /mnt/compartit  nfs4  defaults,_netdev,hard,intr  0  0
192.168.1.10:/srv/nfs/projectes  /mnt/projectes  nfs4  rw,_netdev,hard,intr,rsize=131072,wsize=131072  0  0
192.168.1.10:/srv/nfs/backups    /mnt/backups    nfs4  ro,_netdev,hard  0  0
```

## 4.5. Opcions importants del client

| Opció | Descripció |
|---|-----------|
| `_netdev` | Espera que la xarxa estigui disponible abans de muntar |
| `hard` | Reintenta indefinidament si el servidor no respon (recomanat) |
| `soft` | Retorna error si el servidor no respon (risc de pèrdua de dades) |
| `intr` | Permet interrompre operacions bloquejades |
| `rsize` / `wsize` | Mida del bloc de lectura/escriptura (bytes) |
| `timeo` | Temps d'espera per a reintents (en dècimes de segon) |
| `retrans` | Nombre de reintents abans de marcar error |

Prova la configuració:

```bash
sudo mount -a
df -h
```


## 4.6. Seguretat i mapatge d'usuaris

NFS, en la seva configuració bàsica (`sec=sys`), confia en els UID/GID que envia el client, el que pot ser un risc si la xarxa no és de confiança. Aspectes a tenir en compte:

- **UID/GID consistents**: els usuaris han de tenir el mateix UID/GID al servidor i als clients, o usar LDAP/NIS per centralitzar-ho.
- **`root_squash`** (per defecte): evita que el root d'un client tingui privilegis de root sobre els fitxers exportats.
- **Kerberos (`sec=krb5`)**: ofereix autenticació forta i, opcionalment, xifratge (`krb5i` per integritat, `krb5p` per privacitat total). Recomanat en xarxes no totalment confiables.
- **Restringir per IP/subxarxa**: no usar mai `*` en entorns de producció.
- **Tallafocs**: limitar l'accés als ports NFS només a les xarxes necessàries.

# 5. Diagnosi i resolució de problemes

## 5.1. Al servidor

Mostra exportacions actives

```bash
sudo exportfs -v
```

Mostra clients connectats

```bash
sudo showmount -a
```

Mostra estadístiques NFS

```bash
nfsstat -s
```

Logs del servidor

```bash
sudo journalctl -u nfs-kernel-server -f
sudo tail -f /var/log/syslog | grep nfs
```

## 5.2. Al client

Verifica muntatges actius

```bash
mount | grep nfs
df -hT | grep nfs
```

Estadístiques del client

```bash
nfsstat -c
```

Diagnosi de connexió RPC

```bash
rpcinfo -p 192.168.1.10
```

Comprova la latència

```bash
time ls /mnt/compartit
```

## 5.3. Problemes habituals

"Permission denied" — revisa exports i permisos

```bash
sudo exportfs -rv
ls -la /srv/nfs/
```

"Connection refused" — revisa tallafocs i serveis

```bash
sudo ufw status
sudo systemctl status nfs-kernel-server
sudo systemctl status rpcbind
```

"Stale file handle" — remunta

```bash
sudo umount -l /mnt/compartit
sudo mount /mnt/compartit
```

# 6. Accés des d'un client Windows

Encara que NFS és el protocol natural per compartir fitxers entre sistemes Linux/Unix, **Windows també pot actuar com a client NFS**, tant en versions de **Windows Server** (mitjançant el rol/funcionalitat *Client for NFS*) com en algunes edicions de **Windows 10/11 Pro i Enterprise**. Això permet muntar directoris exportats per un servidor Linux com si fossin unitats de xarxa locals, sense necessitat d'instal·lar Samba al servidor.

## 6.1. Quan té sentit fer-ho

- Entorns mixtos on el servidor de fitxers ja és Linux i s'exporta via NFS per a altres clients Unix.
- Aules o laboratoris on cal demostrar interoperabilitat entre sistemes.
- Migracions progressives d'infraestructura Linux cap a Windows (o viceversa).

> [!NOTE] 
> Si el cas d'ús principal és compartir fitxers amb clients Windows, sol ser més senzill i robust fer-ho amb **Samba** al servidor. NFS des de Windows és més habitual en entorns tècnics o de laboratori que en producció d'oficina.

## 6.2. Requisits previs 

- Un servidor Linux amb NFS configurat i exportacions actives (`/etc/exports`, `exportfs -v`).
- Connectivitat de xarxa entre el client Windows i el servidor (verificar amb `ping`).
- Privilegis d'administrador al client Windows.
- Conèixer la IP del servidor i la ruta exacta de l'exportació (per exemple, `192.168.1.10:/srv/nfs/compartit`).

## 6.3. Instal·lar el client NFS a Windows 

### Windows Server

Instal·la la funcionalitat de client NFS

```powershell
Install-WindowsFeature NFS-Client
```

Verifica que s'ha instal·lat correctament

```powershell
Get-WindowsFeature -Name NFS-Client
```

### Windows 10/11 Pro o Enterprise

Des del **Tauler de control**:

1. *Programes* → *Activar o desactivar funcions de Windows*.
2. Marcar **Services for NFS** → **Client for NFS**.
3. Acceptar i reiniciar si es demana.

O bé per PowerShell (amb privilegis d'administrador):

```powershell
Enable-WindowsOptionalFeature -Online -FeatureName ServicesForNFS-ClientOnly -All
Enable-WindowsOptionalFeature -Online -FeatureName ClientForNFS-Infrastructure -All
```

> [!NOTE] 
> Aquesta funcionalitat **no està disponible** a Windows Home.

## 6.4. Descobrir les exportacions del servidor 

Des del client Windows, amb el client NFS ja instal·lat, es pot consultar quines exportacions ofereix el servidor:

```cmd
showmount -e 192.168.1.10
```

Sortida d'exemple:

```ini
Exports list on 192.168.1.10:
/srv/nfs/dades     192.168.1.0/24
/srv/nfs/backups   192.168.1.10
```

>[!NOTE] 
> Si l'ordre `showmount` no es reconeix, comprovar que el client NFS s'ha instal·lat correctament i reiniciar la màquina.

## 6.5. Muntar una exportació com a unitat de xarxa 

El client NFS de Windows permet muntar una exportació remota assignant-li una lletra d'unitat, igual que ho faríem amb un recurs SMB.

```cmd
:: Sintaxi general
mount \\<ip_servidor>\<ruta_amb_barres_invertides> <lletra>:

:: Exemple: muntar /srv/nfs/compartit com a unitat Z:
mount \\192.168.1.10\srv\nfs\compartit Z:
```

> [!IMPORTANT] 
> La ruta Unix s'escriu substituint les barres `/` per barres invertides `\`. NFS internament tradueix la ruta correctament.

Verifica que la unitat s'ha muntat:

```cmd
dir Z:
```

O des de l'**Explorador d'arxius**, on apareixerà com una unitat de xarxa més.

## 6.6. Muntatge persistent amb PowerShell

Per evitar haver de tornar a muntar el recurs cada vegada que s'inicia la sessió, es pot crear una unitat persistent:

```powershell
New-PSDrive -Name "Z" `
    -PSProvider FileSystem `
    -Root "\\192.168.1.10\srv\nfs\compartit" `
    -Persist
```

Per comprovar les unitats NFS muntades:

```powershell
Get-PSDrive -PSProvider FileSystem
```

Per eliminar-la:

```powershell
Remove-PSDrive -Name "Z"
```

## 6.7. Configuració del mapatge d'usuaris (UID/GID) 

NFS es basa en UID/GID numèrics per controlar permisos, un concepte aliè al model de seguretat natiu de Windows (SID). El client NFS de Windows necessita saber quin UID/GID utilitzar en les seves peticions.

### Mapatge per defecte (anònim)

Per defecte, si no hi ha cap mapatge configurat, el client NFS de Windows sol presentar-se amb UID/GID **anònims** (sovint `-2` o `0`, segons la versió). Això fa que l'accés depengui directament de com el servidor tracti les peticions anònimes (vegeu `all_squash`/`anonuid` al servidor).

### Configurar el mapatge amb Active Directory (entorn corporatiu)

En entorns amb **Active Directory** i un servei de mapatge d'identitats (*Identity Mapping for UNIX*), es pot associar cada compte de domini a un UID/GID Unix concret, de manera que els permisos NFS es respectin de forma coherent amb els usuaris de domini.

Consulta el servei de mapatge d'identitats (si està configurat al domini)

```powershell
Get-WindowsFeature -Name "RSAT-NFS-Admin"
```

> La configuració detallada del mapatge amb AD requereix un servidor amb el rol *Server for NFS* i el component *Identity Mapping Service*, fora de l'abast d'un client aïllat.

### Entorns de laboratori sense AD

En aules o proves sense Active Directory, la solució més pràctica és controlar el mapatge **des del servidor Linux**, usant `all_squash` amb `anonuid`/`anongid` fixos, de manera que totes les peticions del client Windows es tractin amb un únic usuari conegut:

```ini
# /etc/exports al servidor Linux
/srv/nfs/compartit  192.168.1.0/24(rw,sync,no_subtree_check,all_squash,anonuid=1000,anongid=1000)
```

## 6.8. Permisos i `root_squash` des de Windows 

Per defecte, el client NFS de Windows pot presentar-se davant el servidor com a UID 0 (root). Si el servidor té `root_squash` actiu (comportament per defecte i recomanat), aquestes peticions es mapegen a `nobody`, el que pot limitar l'escriptura.

```ini
# Exemple per a entorn de LABORATORI (no recomanat en producció)
/srv/nfs/compartit  192.168.1.0/24(rw,sync,no_subtree_check,no_root_squash)
```

> [!CAUTION] 
> `no_root_squash` dona privilegis de root del servidor a qualsevol client que es presenti com a UID 0. Usar-ho només en entorns controlats (aules, laboratoris), mai en producció.

L'alternativa més segura i recomanada per a accés des de Windows és combinar `all_squash` amb un `anonuid`/`anongid` que correspongui a un usuari amb els permisos adequats sobre el directori exportat, tal com s'ha mostrat a la secció anterior.

## 6.9. Verificació i proves d'escriptura 

Des del client Windows, un cop muntada la unitat:

```cmd
:: Crear un fitxer de prova
echo prova > Z:\test.txt

:: Llistar el contingut
dir Z:

:: Esborrar el fitxer de prova
del Z:\test.txt
```

Des del servidor Linux, es pot comprovar qui ha creat el fitxer i amb quin UID:

```bash
ls -ln /srv/nfs/dades
```

Si l'UID que apareix no correspon a un usuari esperat, cal revisar la configuració de mapatge (`all_squash`, `anonuid`) al servidor.

## 6.10. Desmuntar el recurs

```cmd
:: Desmuntar una unitat muntada amb "mount"
umount Z:
```

```powershell
# Desmuntar una unitat persistent creada amb New-PSDrive
Remove-PSDrive -Name "Z"
```

## 6.11. Diagnosi de problemes habituals 

| Problema | Possible causa | Solució |
|---|---|---|
| `showmount` no es reconeix | Client NFS no instal·lat | Reinstal·lar la funcionalitat i reiniciar |
| `Network path not found` | Tallafocs bloqueja el port 2049/111 | Obrir els ports al tallafocs del servidor |
| Es pot llegir però no escriure | Exportació en `ro`, o UID sense permisos | Canviar a `rw` al servidor i revisar `anonuid`/permisos del directori |
| `Access is denied` en muntar | El client es presenta amb UID sense accés | Configurar `all_squash` + `anonuid`/`anongid` adequats |
| El recurs es desmunta sol en reiniciar | Muntatge no persistent | Usar `New-PSDrive -Persist` |

# 7. Comparativa amb altres protocols

| Característica | NFS | Samba | SSHFS |
|---|-----|---|---|
| Plataformes | Linux/Unix | Linux/Windows/Mac | Linux/Mac |
| Rendiment | Excel·lent | Bo | Regular |
| Seguretat | Mitjana (alta amb Kerberos) | Alta | Molt alta |
| Configuració | Mitjana | Complexa | Molt simple |
| Autenticació | UID/GID o Kerberos | Usuari/contrasenya | Clau SSH |
| Recomanat per | Xarxes Linux pures | Entorns mixtos | Accés puntual segur |

# Bones pràctiques

- Usar sempre **NFSv4**, més segura i eficient que NFSv3.
- Restringir les exportacions a **IP o subxarxes específiques**, mai a `*`.
- Mantenir `root_squash` actiu per defecte.
- Muntar sempre amb `_netdev` al `fstab` per evitar problemes durant l'arrencada.
- Preferir `hard` en lloc de `soft` per a dades importants, per evitar corrupció silenciosa.
- Monitorar l'ús del servidor periòdicament:

	```bash
	watch -n 1 nfsstat -s
	sudo showmount -a | wc -l
	```

- Combinar NFS amb **LVM** per poder redimensionar volums compartits sense interrompre el servei.
- Considerar **Kerberos (`sec=krb5`)** si la xarxa no és totalment de confiança.

# Resum d'ordres

| Ordre | Descripció |
|---|---|
| `sudo apt install nfs-kernel-server` | Instal·la el servidor NFS |
| `sudo apt install nfs-common` | Instal·la les eines client |
| `sudo exportfs -a` | Exporta totes les comparticions definides |
| `sudo exportfs -rv` | Reexporta després de modificar `/etc/exports` |
| `sudo exportfs -v` | Llista les exportacions actives |
| `sudo exportfs -ua` | Elimina totes les exportacions |
| `showmount -e <ip>` | Llista les exportacions d'un servidor remot |
| `showmount -a` | Mostra els clients connectats |
| `sudo mount -t nfs4 <ip>:/ruta /mnt/punt` | Munta una exportació manualment |
| `sudo umount /mnt/punt` | Desmunta una exportació |
| `sudo umount -l /mnt/punt` | Desmunta de forma forçada (stale handle) |
| `nfsstat -s` / `nfsstat -c` | Estadístiques del servidor / client |
| `rpcinfo -p <ip>` | Comprova els serveis RPC d'un host |

| Ordre al client Windows| Descripció |
|---|---|
| `Install-WindowsFeature NFS-Client` | Instal·la el client NFS a Windows Server |
| `Enable-WindowsOptionalFeature -FeatureName ClientForNFS-Infrastructure` | Instal·la el client NFS a Windows 10/11 Pro/Enterprise |
| `showmount -e <ip>` | Llista les exportacions disponibles en un servidor |
| `mount \\<ip>\<ruta> <lletra>:` | Munta una exportació com a unitat de xarxa |
| `umount <lletra>:` | Desmunta una unitat NFS |
| `New-PSDrive -Persist` | Crea una unitat NFS persistent entre sessions |
| `Remove-PSDrive` | Elimina una unitat persistent |
| `Get-PSDrive -PSProvider FileSystem` | Llista les unitats de fitxers actives |

#### Versions d'aquest document

+ HTML - [nfs.html](https://proferamon.com/tic/nfs.html)
+ PDF - [nfs.pdf](https://proferamon.com/tic/docs/nfs.pdf)
+ ODT - [nfs.odt](https://proferamon.com/tic/odt/nfs.odt)
+ MD - [nfs.md](https://proferamon.com/tic/md/nfs.md)

[Domini Públic (CC0)](https://creativecommons.org/publicdomain/zero/1.0/deed.ca)