Ce este serviciul nfs? Serviciu de fișiere de rețea. Funcții care afectează memorarea în cache a atributelor pe monturile NFS

Pentru distribuirea fișierelor într-o rețea locală, se pot distinge următoarele tehnologii (se iau în considerare sistemele bazate pe Linux):

• Protocolul NFS (Network File System). acces la retea la sistemele de fișiere;
• Fișierele transferate prin protocolul Shell (FISH) este un protocol de rețea care utilizează sau RSH pentru a transfera fișiere între computere;
• Secure SHell FileSystem (SSHFS) - client de sistem de fișiere pentru montare dispozitive de disc pe sistemele de la distanță, utilizate pentru a interacționa cu sistemul de la distanță SFTP;
• Samba este un pachet software care vă permite să accesați unități de rețea și imprimante pe diverse sisteme de operare prin protocolul SMB/CIFS;

În această notă vom vorbi despre NFS.

NFS (Rețea Sistemul de fișiere) util atunci când trebuie să distribuiți fișiere/directoare tuturor celor din rețea. Accesați transparența cu NFS permite clienților să monteze un sistem de fișiere la distanță ca director local, iar sistemele de fișiere pot fi de diferite tipuri. Aceasta înseamnă că orice aplicație client care poate funcționa cu un fișier local poate funcționa la fel de ușor cu un fișier conectat prin intermediul NFS, fără modificări ale programului în sine.

La beneficii NFS pot fi atribuite:

Disponibil acum NFS v4.1, care a introdus o nouă caracteristică pNFS permițându-vă să paralelizați implementarea partajării fișierelor. Există, de asemenea, o extensie pentru NFS 2 și 3 - WebNFS, care permit integrarea mai ușoară în browserele web și capacitatea de a lucra printr-un firewall.

Schema de lucru NFS protocol.

Instalarea și configurarea serverului NFS sub Linux

Să verificăm dacă suportă sistem NFS

Cat /proc/sisteme de fișiere | grep nfs

Sub Arch Linux serverul și clientul sunt în același pachet

Yaourt -S nfs-utils

Pentru a instala serverul ( nfs-kernel-server) și client ( nfs-comun) sub Ubuntu pachetele necesare

Sudo apt-get install nfs-kernel-server nfs-common portmap

Mai departe, în această notă, IP-ul va fi folosit pentru server 192.168.1.100 . Pentru ca același IP să fie întotdeauna atribuit serverului, este necesar să specificați în serverul DHCP (de obicei un router) distribuția unui anumit IP la o anumită adresă MAC. Sau ridicați-vă serverul DNS local. De exemplu sau.

Adresa MAC poate fi găsită folosind ifconfig (câmp eter V Arch Linux).

NFSv4 presupune că există un director rădăcină, în interiorul căruia sunt deja localizate fișierele pentru distribuție. De exemplu, /srv/nfs- radacina, /srv/nfs/audio- director pentru distribuirea muzicii. Dacă nu urmați acest nou ghid în versiune 4 , atunci este posibil să primiți o eroare la conectarea de către client:

Mount.nfs: acces refuzat de server în timpul instalării 192.168.1.100:/home/proft/torrents

Dacă tot doriți să utilizați abordarea pe server fără un director rădăcină pentru NFS, apoi la montare de către client, trebuie să specificați în mod explicit versiunea 3

# pentru comanda de montare mount -o "vers=3" 192.168.1.100:/home/proft/torrents /home/proft/nfs/torrents # pentru fstab 192.168.1.100:/home/proft/torrents /home/proft/nfs / torrents nfs soft,nfsvers=3 0 0

voi folosi NFSv4 cu directorul rădăcină în /srv/nfs/și montarea subdirectoarelor folosind mount --bind .

Să presupunem că vrem

• directorul de distribuție ~/torrenți Cu rw acces pentru toata lumeaîn cadrul rețelei locale;
• directorul de distribuție ~/fotografii Cu ro acces pentru gazdă cu IP 192.168.1.101 ;

Mai întâi, să creăm un director rădăcină și subdirectoarele necesare.

Sudo mkdir -p /srv/nfs/(torrenți, fotografii)

Montați directoarele existente torrente, fotografii V /srv/nfs.

# sudo vim /etc/fstab /home/proft/torrents /srv/nfs/torrents none bind 0 0 /home/proft/photos /srv/nfs/photos none bind 0 0

Hai să edităm /etc/exports, care descrie toate directoarele partajate

# sudo vim /etc/exports # format de fișier: directorul permit-hosts(opțiuni) /srv/nfs/torrents 192.168.1.1/24(rw,async) /srv/nfs/photos 192.168.1.101(ro,async)

Rețineți că nu există spațiu între gazde permiseȘi (Opțiuni). Prezența unui spațiu introduce o interpretare diferită a regulilor.

Optiuni Disponibile:

• ro (rw) - permite accesul doar în citire (citire/scriere);
• subtree_check (no_subtree_check) - în unele cazuri este necesar să exportați nu întreaga secțiune, ci doar o parte a acesteia. În acest caz, serverul NFS trebuie să efectueze verificări suplimentare asupra solicitărilor clienților pentru a se asigura că aceștia încearcă doar să acceseze fișierele aflate în subdirectoarele corespunzătoare. Acest control subarboresc ( verificări subarbore) încetinește oarecum interacțiunea cu clienții, dar dacă o refuzi, poate cauza probleme cu securitatea sistemului. Puteți anula controlul unui subarboresc folosind opțiunea no_subtree_check. Opțiune subtree_check, care include un astfel de control, se presupune implicit. Verificarea subarboare poate fi omisă dacă directorul exportat este același cu o partiție de disc;
• sync (async) - specifică că serverul ar trebui să răspundă la solicitări numai după ce modificările făcute de acele solicitări au fost scrise pe disc. Opțiune asincron spune serverului să nu aștepte ca informațiile să fie scrise pe disc, ceea ce îmbunătățește performanța, dar reduce fiabilitatea deoarece în cazul unei eșecuri a conexiunii sau a unei defecțiuni a echipamentului, poate apărea pierderea de date;
• noaccess - interzice accesul la directorul specificat. Poate fi util dacă ați setat anterior accesul pentru toți utilizatorii rețelei la un anumit director, iar acum doriți să restricționați accesul la subdirector doar la unii utilizatori;
• no_root_squash – utilizator implicit rădăcină pe computerul client nu va avea aceleași drepturi la directorul de pe server. Această opțiune elimină această limitare;
• nu ascunde- NFS nu afișează automat resurse non-locale (de exemplu, montate folosind mount --bind), această opțiune permite afișarea acestor resurse;
• nesigur - folosirea porturilor neprivilegiate (> 1024);

Pornirea serverului NFS

# sub archlinux sudo systemctl start rpc-idmapd.service rpc-mountd.service # sub ubuntu sudo /etc/init.d/nfs-kernel-server start

În viitor, când schimbați fișierul de configurare, citiți-l doar cu comanda:

Sudo exportfs -rav

Comanda rpcinfo -p | grep nfs vă permite să verificați dacă serverul a pornit cu succes.

client Linux

Instalare

# sub archlinux yaourt -S nfs-utils # sub ubuntu sudo apt-get install portmap nfs-common

Să creăm directoare pentru montare resursele rețelei torrenteȘi fotografii

Mkdir -p ~/nfs/(torrenți, fotografii)

Pentru montaj manual vom face

Sudo mount -t nfs -o rw,soft 192.168.1.100:/srv/nfs/torrents /home/proft/nfs/torrents sudo mount -t nfs -o rw,soft 192.168.1.100:/srv/nfs/photos /proft/nfs/photos

Opțiune moale specifică anularea în tăcere a încercărilor de conectare a partajării după o anumită perioadă de timp (timpul este specificat de opțiunea retrans). Mai multe detalii în man nfs.

Această metodă nu este foarte convenabilă, deoarece de fiecare dată după o repornire va trebui să executați aceste comenzi. Să facem instalarea automată.

Pentru a monta automat, editați fișierul /etc/fstab

# sudo vim /etc/fstab 192.168.1.100:/srv/nfs/torrents /home/proft/net/torrents nfs rw,soft 0 0 192.168.1.100:/srv/nfs/photos /home/proft/net/photos ro,soft 0 0

Dar această metodă are și dezavantajele sale, de exemplu, dacă serverul nu este disponibil, încărcarea clientului se poate îngheța din cauza încercărilor de conectare la serverul NFS. Pentru a remedia acest lucru, consultați mai jos despre AutoFS.

AutoFS - conectarea automată a resurselor de rețea

Se poate monta resursă la distanță prin utilizarea AutoFS la prima accesare și demontați automat când nu există activitate.

AutoFS folosește șabloane situate în /etc/autofs. Șablonul principal este numit auto.master, poate indica unul sau mai multe alte modele pentru anumite tipuri de media.

Instalare

# sub archlinux yaourt -S autofs # sub ubuntu sudo apt-get install autofs

Există mai multe moduri de a specifica metodele de montare automată. Il folosesc pe acesta: in /home/proft/nfs Este creat automat un director cu numele serverului NFS, în care directoarele accesibile de pe server sunt create automat.

# sudo vim /etc/autofs/auto.master /home/proft/nfs /etc/autofs/auto.nfs --timeout=60

Parametru suplimentar pauză setează numărul de secunde după care dispozitivul va fi demontat. Parametru fantomă specifică că resursele configurate vor fi întotdeauna afișate și nu numai atunci când sunt disponibile (această opțiune este activată implicit în AutoFS 5)

Vom descrie în /etc/autofs/auto.nfs Server NFS și director rădăcină.

# sudo vim /etc/autofs/auto.nfs nfsserver 192.168.1.100:/srv/nfs

Acum la primul apel /home/proft/nfs/torrents Resursa NFS va fi montată automat.

Să repornim serviciul autofs:

# sub archlinux sudo systemctl restart autofs # sub ubuntu sudo /etc/init.d/autofs restart

De asemenea, puteți specifica timpul de așteptare pentru ca o resursă NFS să devină disponibilă. Pentru a face acest lucru, trebuie să modificați valorile MOUNT_WAIT.

# sub archlinux # sudo vim /etc/conf.d/autofs MOUNT_WAIT=5 # sub ubuntu sudo /etc/default/autofs MOUNT_WAIT=5

Forțarea utilizării NFS v3

In unele cazuri NFSv4 poate funcționa lent. Pentru a remedia acest lucru, îl puteți forța să folosească a treia versiune.

Bună ziua, cititori și invitați. A fost o pauză foarte lungă între postări, dar am revenit în acțiune). În articolul de astăzi mă voi uita Operarea protocolului NFS, și configurarea serverului NFS și a clientului NFS pe Linux.

Introducere în NFS

NFS (Sistem de fișiere de rețea - sistem de fișiere de rețea) după părerea mea - o soluție ideală într-o rețea locală, unde este necesar schimbul de date rapid (mai rapid în comparație cu SAMBA și mai puțin consumator de resurse în comparație cu sistemele de fișiere la distanță cu criptare - sshfs, SFTP etc...). securitatea de prim plan a informațiilor transmise. Protocolul NFS permite montați sisteme de fișiere la distanță în rețea într-un arbore de directoare local, ca și cum ar fi un sistem de fișiere pe disc montat. Acest lucru permite aplicațiilor locale să lucreze cu un sistem de fișiere la distanță ca și cum ar fi unul local. Dar trebuie să fii atent (!) cu configurarea NFS, deoarece cu o anumită configurație este posibil să înghețe sistemul de operare al clientului în așteptarea unei I/O fără sfârșit. Protocolul NFS bazat pe muncă Protocolul RPC, care este încă dincolo de înțelegerea mea)) așa că materialul din articol va fi puțin vag... Înainte de a putea folosi NFS, fie că este un server sau un client, trebuie să vă asigurați că nucleul dumneavoastră are suport pentru fișierul NFS sistem. Puteți verifica dacă nucleul acceptă sistemul de fișiere NFS uitându-vă la prezența liniilor corespunzătoare în fișier /proc/sisteme de fișiere:

ARCHIV ~ # grep nfs /proc/filesystems nodev nfs nodev nfs4 nodev nfsd

Dacă liniile specificate în fișier /proc/sisteme de fișiere nu apare, atunci trebuie să instalați pachetele descrise mai jos. Acest lucru vă va permite cel mai probabil să instalați module dependente de kernel pentru a suporta sistemele de fișiere necesare. Dacă, după instalarea pachetelor, suportul NFS nu este afișat în fișierul specificat, atunci va trebui să activați această funcție.

Poveste Sistem de fișiere de rețea

Protocolul NFS dezvoltat de Sun Microsystems și are 4 versiuni în istoria sa. NFSv1 a fost dezvoltat în 1989 și a fost experimental, rulând pe protocolul UDP. Versiunea 1 este descrisă în . NFSv2 a fost lansat în același 1989, descris de același RFC1094 și, de asemenea, bazat pe protocolul UDP, permițând în același timp să nu fie citite mai mult de 2 GB dintr-un fișier. NFSv3 finalizat în 1995 și descris în . Principalele inovații ale celei de-a treia versiuni au fost suportul pentru fișiere mari, suport adăugat pentru protocolul TCP și pachete TCP mari, care au accelerat semnificativ performanța tehnologiei. NFSv4 finalizat în 2000 și descris în RFC 3010, revizuit în 2003 și descris în . A patra versiune a inclus îmbunătățiri de performanță, suport pentru diverse mijloace de autentificare (în special, Kerberos și LIPKEY folosind protocolul RPCSEC GSS) și liste de control al accesului (atât tipurile POSIX, cât și Windows). Versiunea NFS v4.1 a fost aprobat de IESG în 2010 și a primit numărul . O inovație importantă în versiunea 4.1 este specificarea pNFS - Parallel NFS, un mecanism pentru accesul clientului NFS paralel la datele de pe mai multe servere NFS distribuite. Prezența unui astfel de mecanism în standardul sistemului de fișiere de rețea va ajuta la construirea de sisteme de stocare și informații „în nor” distribuite.

Server NFS

Din moment ce avem NFS- Acest reţea sistem de fișiere, atunci este necesar. (Puteți citi și articolul). Următorul este necesar. Pe Debian, acesta este un pachet nfs-kernel-serverȘi nfs-comun, în RedHat acesta este un pachet nfs-utils. Și, de asemenea, trebuie să permiteți demonului să ruleze la nivelurile de execuție ale sistemului de operare necesare (comandă în RedHat - /sbin/chkconfig nfs activat, în Debian - Valorile implicite ale /usr/sbin/update-rc.d nfs-kernel-server).

Pachetele instalate în Debian sunt lansate în următoarea ordine:

ARCHIV ~ # ls -la /etc/rc2.d/ | grep nfs lrwxrwxrwx 1 root root 20 oct 18 15:02 S15nfs-common -> ../init.d/nfs-common lrwxrwxrwx 1 root root 27 oct 22 01:23 S16nfs-kernel-server -> kernel-server /nfs-kernel-server

Adică începe primul nfs-comun, apoi serverul în sine nfs-kernel-server. În RedHat situația este similară, cu singura excepție că se apelează primul script nfslock, iar serverul este numit simplu nfs. Despre nfs-comun Site-ul web debian ne spune textul acesta: fișiere partajate pentru client și server NFS, acest pachet trebuie instalat pe mașina care va acționa ca client sau server NFS. Pachetul include programe: lockd, statd, showmount, nfsstat, gssd și idmapd. Vizualizarea conținutului scriptului de lansare /etc/init.d/nfs-common puteți urmări următoarea secvență de lucru: scriptul verifică prezența unui fișier binar executabil /sbin/rpc.statd, verifică prezența în fișiere /etc/default/nfs-common, /etc/fstabȘi /etc/exports parametrii care necesită rularea demonilor idmapd Și gssd , pornește demonul /sbin/rpc.statd , apoi înainte de lansare /usr/sbin/rpc.idmapdȘi /usr/sbin/rpc.gssd verifică prezența acestor executabile fișiere binare, mai departe pentru demonul /usr/sbin/rpc.idmapd verifică disponibilitatea sunrpc, nfsȘi nfsd, precum și suport pentru sistemul de fișiere rpc_pipefsîn nucleu (adică având-l în fișier /proc/sisteme de fișiere), dacă totul are succes, începe /usr/sbin/rpc.idmapd . În plus, pentru demon /usr/sbin/rpc.gssd verificări modulul nucleului rpcsec_gss_krb5și pornește demonul.

Dacă vizualizați conținutul Scriptul de pornire a serverului NFS pe Debian ( /etc/init.d/nfs-kernel-server), apoi puteți urma următoarea secvență: la pornire, scriptul verifică existența fișierului /etc/exports, Disponibilitate nfsd, disponibilitatea suportului Sistem de fișiere NFSîn (adică în dosar /proc/sisteme de fișiere), dacă totul este la locul lui, atunci demonul începe /usr/sbin/rpc.nfsd , apoi verifică dacă parametrul este specificat NEED_SVCGSD(setat în fișierul de setări server /etc/default/nfs-kernel-server) și, dacă este dat, pornește demonul /usr/sbin/rpc.svcgssd , lansează demonul ultimul /usr/sbin/rpc.mountd . Din acest scenariu este clar că Operarea serverului NFS constă în demonii rpc.nfsd, rpc.mountd și dacă se folosește autentificarea Kerberos, atunci demonul rcp.svcgssd. În red hat, daemonul rpc.rquotad și nfslogd încă rulează (Din anumite motive în Debian nu am găsit informații despre acest demon și motivele absenței sale, se pare că a fost șters...).

De aici devine clar că Serverul Network File System este format din următoarele procese (a se citi: daemons), situat în directoarele /sbin și /usr/sbin:

În NFSv4, când utilizați Kerberos, sunt porniți daemoni suplimentari:

• rpc.gssd- Daemonul NFSv4 oferă metode de autentificare prin GSS-API (autentificare Kerberos). Funcționează pe client și server.
• rpc.svcgssd- Daemon server NFSv4 care oferă autentificare pe partea de server.

portmap și protocol RPC (Sun RPC)

În plus față de pachetele de mai sus, NFSv2 și v3 necesită pachet suplimentar portmap(înlocuit în distribuțiile mai noi cu redenumit în rpcbind). pachetul curent de obicei este instalat automat cu NFS ca dependent și implementează funcționarea serverului RPC, adică este responsabil de alocarea dinamică a porturilor pentru unele servicii înregistrate în serverul RPC. Literal, conform documentației, acesta este un server care convertește numerele de program RPC (Remote Procedure Call) în numere de porturi TCP/UDP. portmap operează pe mai multe entități: Apeluri sau solicitări RPC, porturi TCP/UDP,versiunea protocolului(tcp sau udp), numere de programȘi versiuni de software. Daemonul portmap este lansat de scriptul /etc/init.d/portmap înainte de a începe serviciile NFS.

Pe scurt, sarcina unui server RPC (Remote Procedure Call) este de a procesa apeluri RPC (așa-numitele proceduri RPC) din procesele locale și de la distanță. Folosind apeluri RPC, serviciile se înregistrează sau se elimină către/din portmapper (aka port mapper, aka portmap, aka portmapper, aka, în versiunile noi, rpcbind), iar clienții folosesc apelurile RPC pentru a trimite cereri către portmapper pentru a primi informațiile necesare . Numele ușor de utilizat ale serviciilor de program și numerele lor corespunzătoare sunt definite în fișierul /etc/rpc. De îndată ce orice serviciu a trimis cererea corespunzătoare și s-a înregistrat pe serverul RPC în port mapper, serverul RPC atribuie, mapează serviciului porturile TCP și UDP pe care a pornit serviciul și stochează în kernel informațiile corespunzătoare despre serviciul care rulează (nume), un serviciu cu număr unic (în conformitate cu /etc/rpc), despre protocolul și portul pe care rulează serviciul și despre versiunea serviciului și oferă informatiile specificate clienti la cerere. Convertorul de porturi în sine are un număr de program (100000), numărul de versiune - 2, portul TCP 111 și portul UDP 111. Mai sus, când am specificat compoziția demonilor serverului NFS, am indicat principalele numere de program RPC. Probabil că v-am confundat puțin cu acest paragraf, așa că voi spune o frază de bază care ar trebui să clarifice lucrurile: principala funcție a unui port mapper este de a reveni, la cererea unui client care a furnizat un număr de program RPC ( sau numărul programului RPC) și versiunea lui (client) a portului pe care rulează programul solicitat. În consecință, dacă un client trebuie să acceseze RPC cu număr specific programului, trebuie să contacteze mai întâi procesul portmap de pe computerul server și să determine numărul portului de comunicație cu serviciul RPC de care are nevoie.

Funcționarea unui server RPC poate fi reprezentată prin următorii pași:

1. Convertorul de porturi ar trebui să pornească mai întâi, de obicei când sistemul pornește. Aceasta creează un punct final TCP și deschide portul TCP 111. De asemenea, creează un punct final UDP care așteaptă să ajungă o datagramă UDP pe portul UDP 111.
2. La pornire, un program care rulează printr-un server RPC creează un punct final TCP și un punct final UDP pentru fiecare versiune acceptată a programului. (Un server RPC poate suporta mai multe versiuni. Clientul specifică versiunea necesară la efectuarea apelului RPC.) Fiecărei versiuni a serviciului i se atribuie un număr de port alocat dinamic. Serverul înregistrează fiecare program, versiune, protocol și număr de port făcând apelul RPC corespunzător.
3. Când programul client RPC trebuie să obțină informațiile necesare, apelează rutina de rezoluție de porturi pentru a obține un număr de port alocat dinamic pentru programul, versiunea și protocolul specificat.
4. Ca răspuns la această solicitare, nordul returnează un număr de port.
5. Clientul trimite un mesaj de solicitare RPC la numărul portului obținut la pasul 4. Dacă se folosește UDP, clientul trimite pur și simplu o datagramă UDP care conține mesajul de provocare RPC către numărul portului UDP pe care rulează serviciul solicitat. Ca răspuns, serviciul trimite o datagramă UDP care conține un mesaj de răspuns RPC. Dacă se folosește TCP, clientul se deschide activ la numărul portului TCP al serviciului dorit și apoi trimite un mesaj de provocare RPC prin conexiunea stabilită. Serverul răspunde cu un mesaj de răspuns RPC la conexiune.

Pentru a obține informații de la serverul RPC, utilizați utilitarul rpcinfo. La specificarea parametrilor -p gazdă programul afișează o listă cu toate programele RPC înregistrate pe gazda gazdă. Fără a specifica gazda, programul va afișa serviciile pe localhost. Exemplu:

ARCHIV ~ # rpcinfo -p prog-ma vers proto port 100000 2 tcp 111 portmapper 100000 2 udp 111 portmapper 100024 1 udp 59451 status 100024 1 tcp 608702 status 100002 ngr 14101014 2 1 3 udp 44310 nlockmgr 100021 4 udp 44310 nlockmgr 100021 1 tcp 44851 nlockmgr 100021 3 tcp 44851 nlockmgr 100021 4 tcp 44851 nlockmgr 100003 2 tcp 2049 nfs 100003 3 tcp 44851 nlockmgr 100003 2 tcp 2049 nfs 100003 3 tcp 20490 nfs 20490 nps 003 2 udp 2049 nfs 100003 3 udp 2049 nfs 100003 4 udp 2049 nfs 100005 1 udp 51306 mountd 100005 1 tcp 41405 mountd 100005 2 udp 51306 mountd 100005 2 tcp 41405 mountd 100005 3 udp 51306 mountd 100005 3 tcp 41405 mountd

După cum puteți vedea, rpcinfo afișează (în coloane de la stânga la dreapta) numărul programului înregistrat, versiunea, protocolul, portul și numele. Folosind rpcinfo puteți elimina înregistrarea unui program sau puteți obține informații despre un anumit serviciu RPC (mai multe opțiuni în man rpcinfo). După cum puteți vedea, demonii portmapper versiunea 2 sunt înregistrate pe porturile udp și tcp, rpc.statd versiunea 1 pe porturile udp și tcp, NFS lock manager versiunile 1,3,4, nfs server daemon versiunea 2,3,4, de asemenea ca demonul de montare versiunile 1,2,3.

Serverul NFS (mai precis, demonul rpc.nfsd) primește cereri de la client sub formă de datagrame UDP pe portul 2049. Deși NFS funcționează cu un rezolutor de porturi, care permite serverului să utilizeze porturi alocate dinamic, portul UDP 2049 este codificat în NFS în majoritatea implementărilor.

Operarea protocolului sistemului de fișiere în rețea

Montarea NFS la distanță

Procesul de montare a unui sistem de fișiere NFS la distanță poate fi reprezentat prin următoarea diagramă:

Descrierea protocolului NFS la montarea unui director la distanță:

1. Un server RPC este lansat pe server și client (de obicei la pornire), deservit de procesul portmapper și înregistrat pe portul tcp/111 și udp/111.
2. Sunt lansate servicii (rpc.nfsd, rpc.statd etc.), care sunt înregistrate pe serverul RPC și înregistrate pe porturi de rețea arbitrare (dacă nu este specificat un port static în setările serviciului).
3. comanda mount de pe computerul client trimite o solicitare către kernel pentru a monta un director de rețea, indicând tipul de sistem de fișiere, gazdă și directorul propriu-zis; nucleul trimite și formează o cerere RPC către procesul portmap de pe serverul NFS de pe portul udp /111 (dacă opțiunea de a lucra prin tcp nu este setată pe client)
4. Nucleul serverului NFS interoghează RPC-ul pentru prezența demonului rpc.mountd și returnează nucleului clientului portul de rețea pe care rulează demonul.
5. mount trimite o cerere RPC către portul pe care rulează rpc.mountd. Serverul NFS poate valida acum un client pe baza adresei IP și a numărului de port pentru a vedea dacă clientul poate monta sistemul de fișiere specificat.
6. Daemonul de montare returnează o descriere a sistemului de fișiere solicitat.
7. Comanda de montare a clientului emite apelul de sistem de montare pentru a asocia mânerul de fișier obținut la pasul 5 cu punctul de montare local de pe gazda clientului. Hranul de fișier este stocat în codul NFS al clientului, iar de acum înainte orice acces de către procesele utilizatorului la fișierele din sistemul de fișiere al serverului va folosi handle-ul de fișier ca punct de plecare.

Comunicare între client și serverul NFS

Un acces tipic la un sistem de fișiere la distanță poate fi descris după cum urmează:

Descrierea procesului de accesare a unui fișier aflat pe un server NFS:

1. Clientului (procesului utilizatorului) nu îi pasă dacă accesează un fișier local sau un fișier NFS. Nucleul interacționează cu hardware-ul prin module de kernel sau apeluri de sistem încorporate.
2. Modul kernel kernel/fs/nfs/nfs.ko, care îndeplinește funcțiile unui client NFS, trimite cereri RPC către serverul NFS prin modulul TCP/IP. NFS utilizează de obicei UDP, însă implementările mai noi pot folosi TCP.
3. Serverul NFS primește cereri de la client ca datagrame UDP pe portul 2049. Deși NFS poate funcționa cu un rezolutor de porturi, care permite serverului să utilizeze porturi alocate dinamic, portul UDP 2049 este codificat în NFS în majoritatea implementărilor.
4. Când serverul NFS primește o solicitare de la un client, aceasta este trecută la o rutină locală de acces la fișiere, care oferă acces la discul local de pe server.
5. Rezultatul accesului la disc este returnat clientului.

Configurarea unui server NFS

Ajustarea serveruluiîn general constă în specificarea directoarelor locale care pot fi montate de sistemele de la distanță într-un fișier /etc/exports. Această acțiune se numește ierarhia directoarelor de export. Principalele surse de informații despre cataloagele exportate sunt următoarele fișiere:

• /etc/exports- fișierul principal de configurare care stochează configurația directoarelor exportate. Folosit la pornirea NFS și de utilitarul exportfs.
• /var/lib/nfs/xtab- conține o listă de directoare montate de clienți la distanță. Folosit de demonul rpc.mountd când un client încearcă să monteze o ierarhie (este creată o intrare de montare).
• /var/lib/nfs/etab- o listă de directoare care pot fi montate de către sistemele de la distanță, indicând toți parametrii directoarelor exportate.
• /var/lib/nfs/rmtab- o listă de directoare care nu sunt în prezent neexportate.
• /proc/fs/nfsd- un sistem de fișiere special (kernel 2.6) pentru gestionarea serverului NFS.
  • exporturi- o listă a ierarhiilor active exportate și a clienților către care au fost exportați, precum și parametrii. Nucleul primește aceste informații de la /var/lib/nfs/xtab.
  • fire- conține numărul de fire (de asemenea, poate fi schimbat)
  • folosind filehandle puteți obține un pointer către un fișier
  • si etc...
• /proc/net/rpc- conține statistici „brute”, care pot fi obținute folosind nfsstat, precum și diverse cache-uri.
• /var/run/portmap_mapping- informatii despre serviciile inregistrate in RPC

Notă: În general, pe internet există o mulțime de interpretări și formulări ale scopului fișierelor xtab, etab, rmtab, nu știu pe cine să cred.Chiar și pe http://nfs.sourceforge.net/ interpretarea este neclar.

Configurarea fișierului /etc/exports

În cel mai simplu caz, fișierul /etc/exports este singurul fișier care necesită editare pentru a configura serverul NFS. Acest fișier controlează următoarele aspecte:

• Ce fel de clienți poate accesa fișierele de pe server
• Care ierarhii? directoarele de pe server pot fi accesate de fiecare client
• Cum vor fi numele personalizate de clienți fi afisat la nume de utilizator locale

Fiecare linie a fișierului de export are următorul format:

export_point client1 (opțiuni) [client2(opțiuni) ...]

Unde punct_export calea absolută a ierarhiei directoarelor exportate, client1 - n numele unuia sau mai multor clienți sau adrese IP, separate prin spații, cărora li se permite montarea punct_export . Opțiuni descrie regulile de montare pt client, precizat mai înainte Opțiuni .

Iată una tipică exemplu de configurare a fișierelor de export:

ARCHIV ~ # cat /etc/exports /archiv1 files(rw,sync) 10.0.0.1(ro,sync) 10.0.230.1/24(ro,sync)

ÎN în acest exemplu Fișierele computerelor și 10.0.0.1 au acces la punctul de export /archiv1, în timp ce gazda fișierelor are acces de citire/scriere, iar gazda 10.0.0.1 și subrețeaua 10.0.230.1/24 au acces numai pentru citire.

Descrierile gazdelor din /etc/exports sunt permise în următorul format:

• Numele nodurilor individuale sunt descrise ca fișiere sau fișiere.DOMAIN.local.
• Descrierea măștii domeniului se face în următorul format: *DOMAIN.local include toate nodurile din domeniul DOMAIN.local.
• Subrețelele sunt specificate ca perechi adresă IP/mască. De exemplu: 10.0.0.0/255.255.255.0 include toate nodurile ale căror adrese încep cu 10.0.0.
• Specificarea numelui grupului de rețea @myclients care are acces la resursă (când se utilizează un server NIS)

Opțiuni generale pentru exportul ierarhiilor de directoare

Fișierul de exporturi utilizează următoarele opțiuni generale(opțiunile utilizate implicit în majoritatea sistemelor sunt enumerate mai întâi, cele care nu sunt implicite între paranteze):

• auth_nlm (nu_auth_nlm) sau secure_locks (blocuri_nesigure)- specifică faptul că serverul ar trebui să necesite autentificarea solicitărilor de blocare (folosind protocolul NFS Lock Manager).
• nohide (ascunde)- dacă serverul exportă două ierarhii de directoare, cu una imbricată (montată) în cealaltă. Clientul trebuie să monteze în mod explicit a doua ierarhie (copil), altfel punctul de montare al ierarhiei copil va apărea ca un director gol. Opțiunea nohide are ca rezultat o a doua ierarhie de director fără o montare explicită. ( Notă: Nu am putut face ca această opțiune să funcționeze...)
• ro(rw)- Permite numai cereri de citire (scriere). (În cele din urmă, dacă este posibil să citiți/scrieți sau nu este determinat pe baza drepturilor sistemului de fișiere, iar serverul nu este capabil să distingă o solicitare de citire a unui fișier de o solicitare de executare, deci permite citirea dacă utilizatorul a citit sau executa drepturi.)
• sigur (nesigur)- necesită ca cererile NFS să provină din porturi securizate (< 1024), чтобы программа без drepturi root nu a putut monta ierarhia directoarelor.
• subtree_check (fără_subtree_check)- Dacă se exportă un subdirector al sistemului de fișiere, dar nu întregul sistem de fișiere, serverul verifică dacă fișierul solicitat se află în subdirectorul exportat. Dezactivarea verificării reduce securitatea, dar crește viteza de transfer al datelor.
• sincronizare (async)- specifică că serverul ar trebui să răspundă la solicitări numai după ce modificările făcute de acele solicitări au fost scrise pe disc. Opțiunea asincronă îi spune serverului să nu aștepte ca informațiile să fie scrise pe disc, ceea ce îmbunătățește performanța, dar reduce fiabilitatea deoarece În cazul unei întreruperi a conexiunii sau a unei defecțiuni a echipamentului, informațiile se pot pierde.
• wdelay (fără_wdelay)- instruiește serverul să întârzie executarea cererilor de scriere dacă o cerere de scriere ulterioară este în așteptare, scriind datele în blocuri mai mari. Acest lucru îmbunătățește performanța la trimiterea unor cozi mari de comenzi de scriere. no_wdelay specifică să nu întârzie execuția unei comenzi de scriere, ceea ce poate fi util dacă serverul primește un număr mare de comenzi care nu au legătură.

Exportați linkuri simbolice și fișiere de dispozitiv. Când exportați o ierarhie de director care conține legături simbolice, obiectul link trebuie să fie accesibil sistemului client (la distanță), adică una dintre următoarele reguli trebuie să fie adevărată:

Fișierul dispozitivului aparține interfeței. Când exportați un fișier de dispozitiv, această interfață este exportată. Dacă sistemul client nu are un dispozitiv de același tip, dispozitivul exportat nu va funcționa. Pe sistemul client, atunci când montați obiecte NFS, puteți utiliza opțiunea nodev, astfel încât fișierele dispozitivului din directoarele montate să nu fie utilizate.

Opțiuni implicite în sisteme diferite pot varia, pot fi vizualizate în fișierul /var/lib/nfs/etab. După descrierea directorului exportat în /etc/exports și repornirea serverului NFS, toate opțiunile lipsă (a se citi: opțiuni implicite) vor fi reflectate în fișierul /var/lib/nfs/etab.

Opțiuni de afișare (potrivire) ID utilizator

Pentru o mai bună înțelegere a celor de mai jos, vă sfătuiesc să citiți articolul. Fiecare utilizator Linux are propriul său UID și GID principal, care sunt descrise în fișiere /etc/passwdȘi /etc/group. Serverul NFS presupune că sistemul de operare al gazdei la distanță a autentificat utilizatorii și le-a atribuit UID-ul și GID-ul corect. Exportarea fișierelor oferă utilizatorilor sistemului client același acces la acele fișiere ca și cum ar fi fost logați direct pe server. În consecință, atunci când un client NFS trimite o solicitare către server, serverul folosește UID și GID pentru a identifica utilizatorul pe sistemul local, ceea ce poate duce la unele probleme:

• este posibil ca un utilizator să nu aibă aceiași identificatori pe ambele sisteme și, prin urmare, poate să poată accesa fișierele altui utilizator.
• deoarece ID-ul utilizatorului root este întotdeauna 0, apoi acest utilizator este afișat utilizator local in functie de optiunile specificate.

Următoarele opțiuni specifică regulile de afișare utilizatori la distanțăîn local:

• root_squash (fără_root_squash)- Cu opțiunea specificată rădăcină_dovleac, solicitările de la utilizatorul root sunt mapate la uid/gid anonim sau la utilizatorul specificat în parametrul anonuid/anongid.
• no_all_squash (tot_squash)- Nu modifică UID/GID-ul utilizatorului care se conectează. Opțiune all_squash setează afișarea TOȚI utilizatorii (nu doar root) ca anonim sau specificat în parametrul anonuid/anongid.
• anonuid= UID Și anongid= GID - Setează în mod explicit UID/GID pentru utilizatorul anonim.
• map_static= /etc/file_maps_users - Specifică un fișier în care puteți seta maparea UID/GID la distanță la UID/GID local.

Exemplu de utilizare a unui fișier de mapare utilizator:

ARCHIV ~ # cat /etc/file_maps_users # Maparea utilizatorului # uid comentariu local la distanță 0-50 1002 # maparea utilizatorilor cu UID la distanță 0-50 la UID local 1002 gid 0-50 1002 # maparea utilizatorilor cu/interval GID la distanță 0-50 la GID local 1002

Managementul serverului NFS

Serverul NFS este gestionat folosind următoarele utilitare:

• nfsstat
• showmmontare sigură (nesigură).

nfsstat: statistici NFS și RPC

Utilitarul nfsstat vă permite să vizualizați statisticile serverelor RPC și NFS. Opțiunile de comandă pot fi găsite în man nfsstat.

showmount: Afișează informații despre starea NFS

utilitarul showmount interogează demonul rpc.mountd de pe gazda la distanță despre sistemele de fișiere montate. În mod implicit, este returnată o listă sortată de clienți. Chei:

• --toate- este afișată o listă de clienți și puncte de montare indicând locul unde clientul a montat directorul. Este posibil ca aceste informații să nu fie de încredere.
• --directoare- este afișată o listă de puncte de montare
• --exporturi- este afișată o listă de sisteme de fișiere exportate din punctul de vedere al nfsd

Când rulați showmount fără argumente, informațiile despre sistemele cărora li se permite montarea vor fi tipărite pe consolă local cataloagele. De exemplu, gazda ARCHIV ne oferă o listă de directoare exportate cu adresele IP ale gazdelor cărora li se permite să monteze directoarele specificate:

FIȘIERE ~ # showmount --exports archive Exportați lista pentru arhivă: /archiv-big 10.0.0.2 /archiv-small 10.0.0.2

Dacă specificați numele de gazdă/IP în argument, vor fi afișate informații despre această gazdă:

ARCHIV ~ # showmount files clnt_create: RPC: Programul nu este înregistrat # acest mesaj ne spune că demonul NFSd nu rulează pe gazda FILES

exportfs: gestionați directoarele exportate

Această comandă servește directoarele exportate specificate în fișier /etc/exports, ar fi mai corect să scrieți că nu servește, ci se sincronizează cu fișierul /var/lib/nfs/xtabși le elimină pe cele inexistente din xtab. exportfs este executat când demonul nfsd este pornit cu argumentul -r. Utilitarul exportfs în modul kernel 2.6 comunică cu demonul rpc.mountd prin fișiere din directorul /var/lib/nfs/ și nu comunică direct cu nucleul. Fără parametri, afișează o listă a sistemelor de fișiere exportate în prezent.

parametrii exportfs:

• [client:nume-director] - adăugați sau eliminați sistemul de fișiere specificat pentru clientul specificat)
• -v - afișează mai multe informații
• -r - reexportă toate directoarele (sincronizează /etc/exports și /var/lib/nfs/xtab)
• -u - elimina din lista de exportate
• -a - adăugați sau eliminați toate sistemele de fișiere
• -o - opțiuni separate prin virgule (similar cu opțiunile utilizate în /etc/exports; adică puteți modifica opțiunile sistemelor de fișiere deja montate)
• -i - nu utilizați /etc/exports când adăugați, doar opțiunile curente ale liniei de comandă
• -f - resetează lista sistemelor exportate în kernel 2.6;

Client NFS

Înainte de a accesa un fișier pe un sistem de fișiere la distanță, clientul (OS client) trebuie să montați-lși primiți de la server indicatorul spre ea. Montare NFS se poate face cu sau folosind unul dintre dispozitivele de montare automate în proliferare (amd, autofs, automount, supermount, superpupermount). Procesul de instalare este bine demonstrat în ilustrația de mai sus.

Pe Clienți NFS nu este nevoie să rulați niciun daemon, funcțiile clientului execută un modul kernel kernel/fs/nfs/nfs.ko, care este utilizat la montarea unui sistem de fișiere la distanță. Directoarele exportate de pe server pot fi montate pe client în următoarele moduri:

• manual folosind comanda mount
• automat la pornire, la montarea sistemelor de fișiere descrise în /etc/fstab
• automat folosind demonul autofs

Nu voi lua în considerare a treia metodă cu autofs în acest articol, din cauza informațiilor sale voluminoase. Poate că va exista o descriere separată în articolele viitoare.

Montarea sistemului de fișiere de rețea cu comanda mount

Un exemplu de utilizare a comenzii mount este prezentat în postare. Aici mă voi uita la un exemplu de comandă mount pentru montarea unui sistem de fișiere NFS:

FIȘIERE ~ # mount -t nfs arhiv:/archiv-small /archivs/archiv-small FIȘIERE ~ # mount -t nfs -o ro arhiv:/archiv-big /archivs/archiv-big FIȘIERE ~ # mount ..... .. arhiv:/archiv-small pe /archivs/archiv-small tip nfs (rw,addr=10.0.0.6) arhiv:/archiv-big pe /archivs/archiv-big tip nfs (ro,addr=10.0.0.6)

Prima comandă montează directorul exportat /arhiv-mic pe server Arhiva V punct local montare /archivs/archiv-small cu opțiuni implicite (adică citire și scriere). Cu toate că comanda de montareîn cele mai recente distribuții poate înțelege ce tip de sistem de fișiere este utilizat chiar și fără a specifica tipul, dar totuși indică parametrul -t nfs de dorit. A doua comandă montează directorul exportat /arhiv-mare pe server Arhiva la directorul local /archivs/archiv-big cu opțiune numai pentru citire ( ro). comanda de montare fara parametri, ne arata clar rezultatul montajului. Pe lângă opțiunea de numai citire (ro), este posibil să specificați și altele Opțiuni de bază la montarea NFS:

• nosuid- Această opțiune interzice executarea programelor din directorul montat.
• nodev(fără dispozitiv - nu dispozitiv) - Această opțiune interzice utilizarea caracterelor și blochează fișierele speciale ca dispozitive.
• blocare (nolock)- Permite blocarea NFS (implicit). nolock dezactivează blocarea NFS (nu pornește demonul lockd) și este util atunci când lucrați cu servere mai vechi care nu acceptă blocarea NFS.
• mounthost=nume- Numele gazdei pe care rulează demonul de montare NFS - mountd.
• mountport=n - Portul folosit de demonul mountd.
• port=n- portul folosit pentru conectarea la serverul NFS (implicit este 2049 dacă demonul rpc.nfsd nu este înregistrat pe serverul RPC). Dacă n=0 (implicit), atunci NFS interogează harta port pe server pentru a determina portul.
• dimensiunea=n(citiți dimensiunea blocului - citiți dimensiunea blocului) - Numărul de octeți citiți la un moment dat de pe serverul NFS. Standard - 4096.
• wsize=n(write block size - write block size) - Numărul de octeți scriiți simultan pe serverul NFS. Standard - 4096.
• tcp sau udp- Pentru a monta NFS, utilizați protocolul TCP sau, respectiv, UDP.
• bg- Dacă pierdeți accesul la server, încercați din nou în fundal pentru a nu bloca procesul de pornire a sistemului.
• fg- Dacă pierdeți accesul la server, încercați din nou în modul prioritar. Acest parametru poate bloca procesul de pornire a sistemului prin repetarea încercărilor de montare. Din acest motiv, parametrul fg este folosit în primul rând pentru depanare.

Opțiuni care afectează memorarea în cache a atributelor pe monturile NFS

Atributele fișierului, stocat in ( inoduri), cum ar fi timpul de modificare, dimensiunea, linkurile hard, proprietarul, se schimbă de obicei rar pentru fișierele obișnuite și chiar mai rar pentru directoare. Multe programe, cum ar fi ls, accesează fișiere doar în citire și nu schimbă atributele sau conținutul fișierelor, ci irosesc resursele sistemului cu operațiuni costisitoare de rețea. Pentru a evita irosirea resurselor, poți stocați în cache aceste atribute. Nucleul folosește timpul de modificare a unui fișier pentru a determina dacă memoria cache este învechită, comparând timpul de modificare din cache și timpul de modificare a fișierului însuși. Cache-ul de atribute este actualizat periodic în conformitate cu parametrii specificați:

• ac (noac) (cache de attribute- cache de atribute) - Permite memorarea în cache de atribute (implicit). Deși opțiunea noac încetinește serverul, evită învechirea atributelor atunci când mai mulți clienți scriu în mod activ informații într-o ierarhie comună.
• acdirmax=n (directorul cache al atributelor maxim- cache maximă a atributelor pentru un fișier de director) - Numărul maxim de secunde pe care NFS le așteaptă înainte de a actualiza atributele de director (implicit 60 de secunde)
• acdirmin=n (directorul cache al atributului minim- memoria cache minimă a atributelor pentru un fișier de director) - Numărul minim de secunde pe care NFS le așteaptă înainte de a actualiza atributele de director (implicit 30 de secunde)
• acregmax=n (cache de atribute maxim fișier normal- cache maximă a atributelor pentru un fișier obișnuit) - Numărul maxim de secunde pe care NFS le așteaptă înainte de a actualiza atributele unui fișier obișnuit (implicit 60 sec.)
• acregmin=n (cache de atribute fișier obișnuit minim- cache minimă a atributelor pentru un fișier obișnuit) - Numărul minim de secunde pe care NFS le așteaptă înainte de a actualiza atributele unui fișier obișnuit (implicit 3 secunde)
• actimeo=n (timeout cache-ul atributului- timeout caching atribute) - Înlocuiește valorile pentru toate opțiunile de mai sus. Dacă actimeo nu este specificat, atunci valorile de mai sus preiau valorile implicite.

Opțiuni de tratare a erorilor NFS

Următoarele opțiuni controlează ce face NFS atunci când nu există niciun răspuns de la server sau când apar erori I/O:

• fg(bg) (prim plan- prim plan, fundal- fundal) - Încercările de a monta un NFS eșuat în prim-plan/fundal.
• greu moale)- afișează mesajul „serverul nu răspunde” la consolă când este atins timpul de expirare și continuă să încerce montarea. Cu opțiunea oferită moale- în timpul unui timeout, informează programul care a apelat operația despre o eroare I/O. (se recomandă să nu folosiți opțiunea soft)
• nointr (intr) (nicio întrerupere- nu întrerupeți) - Nu permite semnalelor să întrerupă operațiunile cu fișiere într-o ierarhie de directoare montată greu atunci când este atins un timeout mare. intr- permite întreruperea.
• retrans=n (valoarea de retransmisie- valoarea retransmisie) - După n timeout-uri mici, NFS generează un timeout mare (implicit 3). Un timeout mare oprește operațiunile sau tipărește un mesaj „serverul nu răspunde” pe consolă, în funcție de dacă este specificată opțiunea hard/soft.
• reîncercați=n (valoare de reîncercare- valoare de reîncercare) - Numărul de minute în care serviciul NFS va repeta operațiunile de montare înainte de a renunța (implicit 10000).
• timeo=n (valoarea timeout- valoare timeout) - numărul de zecimi de secundă pe care serviciul NFS le așteaptă înainte de a retransmite în cazul RPC sau un timeout mic (implicit 7). Această valoare crește cu fiecare timeout până la maximum 60 de secunde sau până când apare un timeout mare. Când rețea ocupată, server lent sau când cererea trece prin mai multe routere sau gateway-uri, creșterea acestei valori poate îmbunătăți performanța.

Montare automată NFS la pornire (descrierea sistemelor de fișiere în /etc/fstab)

Puteți selecta timpul optim pentru o anumită valoare a pachetului transmis (valori rsiize/wsize) folosind comanda ping:

FIȘIERE ~ # ping -s 32768 arhiv PING arhiv.DOMAIN.local (10.0.0.6) 32768(32796) octeți de date. 32776 octeți din archiv.domain.local (10.0.0.6): icmp_req=1 ttl=64 time=0,931 ms 32776 octeți din archiv.domain.local (10.0.0.6): icmp_req=2 ttl=64 time=0,957 ms 32776 bytes din archiv.domain.local (10.0.0.6): icmp_req=3 ttl=64 time=1.03 ms 32776 bytes din archiv.domain.local (10.0.0.6): icmp_req=4 ttl=64 time=1.00 ms 32776 bytes din arhiva .domain.local (10.0.0.6): icmp_req=5 ttl=64 time=1.08 ms ^C --- archive.DOMAIN.local statistics ping --- 5 pachete transmise, 5 primite, 0% pierdere de pachete, timp 4006ms rtt min/avg/max/mdev = 0,931/1,002/1,083/0,061 ms

După cum puteți vedea, atunci când trimiteți un pachet de dimensiunea 32768 (32Kb), timpul său de călătorie de la client la server și înapoi plutește în jur de 1 milisecundă. Dacă acest timp depășește 200 ms, atunci ar trebui să vă gândiți la creșterea valorii timeo, astfel încât să depășească valoarea de schimb de trei până la patru ori. Prin urmare, este recomandabil să faceți acest test în timpul sarcinii grele ale rețelei.

Lansarea NFS și configurarea paravanului de protecție

Nota a fost copiata de pe blogul http://bog.pp.ru/work/NFS.html, pentru care multumesc mult!!!

Rulați serverul NFS, montați, blocați, cota și starea cu porturi „corecte” (pentru firewall)

• Este recomandabil să demontați mai întâi toate resursele de pe clienți
• opriți și dezactivați pornirea rpcidmapd dacă nu intenționați să utilizați NFSv4: chkconfig --level 345 rpcidmapd off service rpcidmapd stop
• dacă este necesar, permiteți pornirea serviciilor portmap, nfs și nfslock: chkconfig --levels 345 portmap/rpcbind on chkconfig --levels 345 nfs on chkconfig --levels 345 nfslock on
• dacă este necesar, opriți serviciile nfslock și nfs, porniți portmap/rpcbind, descărcați modulele service nfslock stop service nfs stop service portmap start # service rpcbind start umount /proc/fs/nfsd service rpcidmapd stop rmmod nfsd service autofs stop # undeva mai târziu trebuie lansat rmmod nfs rmmod nfs_acl rmmod lockd
• deschide porturi în
  • pentru RPC: UDP/111, TCP/111
  • pentru NFS: UDP/2049, TCP/2049
  • pentru rpc.statd: UDP/4000, TCP/4000
  • pentru blocare: UDP/4001, TCP/4001
  • pentru mountd: UDP/4002, TCP/4002
  • pentru rpc.rquota: UDP/4003, TCP/4003
• pentru serverul rpc.nfsd, adăugați linia RPCNFSDARGS="--port 2049" la /etc/sysconfig/nfs
• pentru serverul de montare, adăugați linia MOUNTD_PORT=4002 la /etc/sysconfig/nfs
• pentru a configura rpc.rquota pentru versiuni noi, trebuie să adăugați linia RQUOTAD_PORT=4003 la /etc/sysconfig/nfs
• pentru a configura rpc.rquota este necesar pentru versiunile mai vechi (totuși, trebuie să aveți pachetul de cotă 3.08 sau mai nou) adăugați la /etc/services rquotad 4003/tcp rquotad 4003/udp
• va verifica caracterul adecvat al /etc/exports
• rulați serviciile rpc.nfsd, mountd și rpc.rquota (rpcsvcgssd și rpc.idmapd sunt lansate în același timp, dacă vă amintiți să le ștergeți) service nfsd start sau în versiuni noi service nfs start
• pentru serverul de blocare pentru sisteme noi, adăugați liniile LOCKD_TCPPORT=4001 LOCKD_UDPPORT=4001 la /etc/sysconfig/nfs
• pentru serverul de blocare pentru sisteme mai vechi, adăugați direct în /etc/modprobe[.conf]: opțiuni lockd nlm_udpport=4001 nlm_tcpport=4001
• legați serverul de stare rpc.statd la portul 4000 (pentru sisteme mai vechi, rulați rpc.statd cu cheia -p 4000 în /etc/init.d/nfslock) STATD_PORT=4000
• porniți serviciile lockd și rpc.statd service nfslock start
• asigurați-vă că toate porturile sunt legate în mod normal folosind „lsof -i -n -P” și „netstat -a -n” (unele dintre porturi sunt folosite de modulele kernel pe care lsof nu le vede)
• dacă înainte de „reconstruire” serverul era folosit de clienți și nu puteau fi demontați, atunci va trebui să reporniți serviciile de montare automată pe clienți (am-utils, autofs)

Exemplu de configurare pentru server și client NFS

Configurare server

Dacă doriți să faceți directorul dvs. partajat NFS deschis și inscriptibil, puteți utiliza opțiunea all_squashîn combinație cu opțiuni anonuidȘi anongid. De exemplu, pentru a seta permisiuni pentru utilizatorul „nimeni” din grupul „nimeni”, puteți face următoarele:

ARCHIV ~ # cat /etc/exports # Acces de citire și scriere pentru client pe 192.168.0.100, cu acces rw pentru utilizatorul 99 cu gid 99 /fișiere 192.168.0.100(rw,sync,all_squash,anonuid=99,anongid=99) ) # Acces de citire și scriere pentru client pe 192.168.0.100, cu acces rw pentru utilizatorul 99 cu gid 99 /fișiere 192.168.0.100(rw,sync,all_squash,anonuid=99,anongid=99))

Aceasta înseamnă, de asemenea, că, dacă doriți să permiteți accesul la directorul specificat, nobody.nobody trebuie să fie proprietarul directorului partajat:

man mount
omul exportă
http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/nfs_perf.htm - Performanță NFS de la IBM.

Salutări, McSim!

Ofer instrucțiuni pentru instalarea și configurarea NFS (Network File System). NFS este un sistem de fișiere de rețea care vă permite să accesați fișiere și directoare de pe un computer (server) la distanță ca și cum aceste fișiere și directoare ar fi locale. Principalul avantaj al unui astfel de sistem este că stațiile de lucru individuale pot folosi mai puțin spațiul pe disc, deoarece datele partajate sunt stocate pe o mașină separată (depozitul de date) și sunt disponibile pentru alte mașini din rețea. NFS este o aplicație client-server în care rolul de stocare este atribuit serverului. Fiecare participant la rețea este un client NFS care montează unitatea de rețea a serverului în sistemul său de fișiere.

Să luăm Ubuntu 12.04 ca server.
Vom folosi și testa Centos și Winows 7 ca clienți.

Server principal: 192.168.2.213 (Ubuntu)

Clienți: 192.168.2.72 (Centos), 192.168.2.180 (Windows)

Ajustarea serverului

Mai întâi trebuie să configurați serverul. Deoarece vom folosi Ubuntu ca server, trebuie să instalăm pachetul corespunzător

Root@ubuntu:~# apt-get install nfs-kernel-server

După instalarea pachetelor necesare, am creat două fișiere de configurare. Din jurnalul de instalare:

... Se creează fișierul de configurare /etc/idmapd.conf cu noua versiune. Se creează fișierul de configurare /etc/default/nfs-common cu noua versiune...

Primul fișier descrie utilizatorul (creat la instalarea pachetului) și grupul care urmează să participe la mapare (identificarea utilizatorului).

Root@ubuntu:~# cat /etc/idmapd.conf Verbosity = 0 Pipefs-Directory = /run/rpc_pipefs # setați-vă propriul domeniu aici, dacă id-ul diferă de FQDN minus hostname # Domain = localdomain Nimeni-Utilizator = nimeni Nimeni-Grup = fără grup

După cum știm, în Linux fiecare fișier aparține unui anumit utilizator, care are propriul său (UID, GID), dar pe sistemele Windows schema este ușor diferită. Și în legătură cu aceasta, a fost inventat un mecanism de cartografiere, care face traducerea diferiților utilizatori din diferite sisteme de operare într-unul prietenos cu fișierele. sisteme Linux vedere.
Al doilea fișier este necesar pentru a configura autentificarea și configurarea Kerberos port non-standard, pe care demonul se va supune. Încă nu avem nevoie de el. Configurarea Kerberos va fi discutată în articolul următor.

Root@ubuntu:~# cat /etc/default/nfs-common # Dacă nu setați valori pentru opțiunile NEED_, acestea vor fi încercate # autodetectate; acest lucru ar trebui să fie suficient pentru majoritatea oamenilor. Alternativele valide # pentru opțiunile NEED_ sunt „da” și „nu”. # Doriți să porniți demonul statd? Nu este necesar pentru NFSv4. NEED_STATD= # Opțiuni pentru rpc.statd. # Ar trebui rpc.statd să asculte pe un anumit port? Acest lucru este util mai ales # când aveți un firewall bazat pe porturi. Pentru a utiliza un port fix, setați această # variabilă la un argument statd precum: „--port 4000 --outgoing-port 4001”. # Pentru mai multe informații, consultați rpc.statd(8) sau http://wiki.debian.org/SecuringNFS STATDOPTS= # Doriți să porniți demonul gssd? Este necesar pentru monturile Kerberos. NEED_GSSD=

Acum să continuăm cu configurarea.
Toate directoarele pentru partajare trebuie să fie înregistrate în fișierul /etc/exports. Mai întâi, să creăm 2 foldere în directorul principal și să aruncăm fișierele în ele. Arborele directoarelor și fișierelor pentru export:

Rădăcină@ubuntu:~# arbore /home/alex/ /home/alex/ ├── nfs_dir1 │ ├── fișier1_dir1 │ ├── fișier2_dir1 │ └── └── fișier3_dir1 ───file3_dir1 ├──fișier ── 1_dir2 ├── fișier2_dir2 └─ ─ fișier3_dir2

Acum trebuie să atribuiți un utilizator și un grup pentru aceste directoare (luați-l din fișierul /etc/idmapd.conf).

Root@ubuntu:~# chown –R nobody:nogroup nfs_dir1/ root@ubuntu:~# chown –R nobody:nogroup nfs_dir2/

Mai întâi, să exportăm directorul nfs_dir1 pentru un anumit IP. Editați fișierul /etc/exprots.

Root@ubuntu:~# vim /etc/exports # Pentru o anumită gazdă (Windows) /home/alex/nfs_dir1 192.168.2.180(rw,sync,all_squash,no_subtree_check,insecure) # Pentru orice gazdă de pe subrețea /home/alex /nfs_dir2 192.168 .2.0/24(rw,no_root_squash,sync,no_subtree_check)

Iată un set minim de opțiuni pentru ca stocarea să funcționeze corect cu sistemul de operare Windows.

• /home/alex/nfs_dir1– calea către folderul pentru care este acordat accesul;
• 192.168.2.180 – Adresă IP căreia i se oferă acces la folder (puteți specifica întreaga rețea, apoi intrarea va arăta ca 192.168.2.0/24)
• (rw,sync,all_squash,no_subtree_check)– un set de opțiuni.

Opțiuni populare:

• rw–citire/scriere (poate lua valoarea ro - numai citire);
• no_root_squash– implicit, utilizatorul root de pe computerul client nu va avea acces la directorul partajat al serverului. Cu această opțiune eliminăm această limitare. Din motive de siguranță, este mai bine să nu faci asta;
• sincronizare– mod de acces sincron (poate lua valoarea opusă - asincron);
• fără acces– interzice accesul la directorul specificat. Poate fi util dacă ați setat anterior accesul pentru toți utilizatorii rețelei la un anumit director, iar acum doriți să restricționați accesul la subdirector doar la unii utilizatori.
• all_squash– implică faptul că toate conexiunile vor fi făcute de la un utilizator anonim (necesar pentru un client Windows)
• anonuid= 1000 – leagă un utilizator anonim cu un utilizator „local”;
• anongid= 1000 – leagă utilizatorul anonim de grupul de utilizator „local”.
• no_subtree_check(subtree_check)–Dacă este exportat un subdirector al unui sistem de fișiere, dar nu întregul sistem de fișiere, serverul verifică dacă fișierul solicitat se află în subdirectorul exportat. Dezactivarea verificării reduce securitatea, dar crește viteza de transfer al datelor.
• De obicei, Linux (și alte sisteme de operare asemănătoare Unix) rezervă porturile TCP și UDP de la 1-1023 (numite porturi securizate) pentru a fi utilizate de către procesele utilizatorului root. Pentru a se asigura că root a inițiat conexiunea la distanță NFS, serverul NFS solicită de obicei clienților la distanță să utilizeze porturi securizate. Această convenție, însă, nu este respectată de unele sisteme de operare (de ex. Windows). În astfel de cazuri, opțiunea nesigur Permite clientului NFS să utilizeze orice port TCP/UDP. Acest lucru este de obicei necesar atunci când se deservesc clienții Windows.

Toate Optiuni Disponibileși sintaxa pentru scrierea gazdelor, a grupurilor de gazde etc. il poti citi in manual

Root@ubuntu:~# exportfs –a

Acum să verificăm ce am exportat.

Root@ubuntu:~# exportfs -v /home/alex/nfs_dir1 192.168.2.180(rw,wdelay,all_squash,no_subtree_check,insecure) /home/alex/nfs_dir2 192.168.2.0/24)(rw,wdelay,subtree_check,subtree_check)

Serverul este configurat.

Stabilirea clienților

Configurarea unui client Windows

Dacă nu ar exista mesaje de eroare. Puteți începe montarea pe partea clientului.
Mai întâi, trebuie să adăugați un serviciu NFS (serviciu client). Pentru a face acest lucru, accesați Start -> Panou de control -> Programe și caracteristiciși faceți clic pe elementul de meniu din stânga Activați sau dezactivați Componentele Windows . În fereastra care apare, selectați Client pentru NFSși faceți clic Bine(Fig. 1).

Poza 1

Apoi, trebuie să montați discul. Pentru a face acest lucru, puteți utiliza linia de comandă sau pur și simplu faceți clic faceți clic dreapta pe My Computer și selectați Map Network Drive. ȘI introduceți linia \\192.168.2.213\home\alex\nfs_dir1. Acesta este IP-ul serverului și calea către folder (Fig. 2).

Figura 2

Dacă totul este în regulă, vom vedea discul (Fig. 3).

Figura 3

Același lucru se poate face folosind linia de comandă (Fig. 4).

Figura 4

Posibile greșeli:

Nu veți putea conecta o unitate de rețea NFS la sistemul de operare Windows (Fig. 5) dacă
1. Clientul NFS nu este instalat
2. Firewall activat (neconfigurat)
3. Fără acces la rețea la server
4. Parametrii de montare introduși incorect
5. Exportul nu este configurat (setările nu sunt aplicate) pe server.
6. Adăugați opțiunea nesigură în setările de export

Figura 5 – Eroare la conectarea unei unități NFS de rețea

Nu veți putea adăuga un fișier la un sistem de fișiere montat (Figura 6) dacă:
1. Permisiunile folderului nu sunt setate pe server (nobody:nogroup)
2. Opțiunea all_squash nu este setată în setările de export
3. Opțiunea rw nu este setată în setările de export

Figura 6 – Eroare la adăugarea unui fișier pe un disc NFS

Configurarea unui client Centos

Configurarea sistemelor Linux este destul de simplă și nedureroasă. Trebuie doar să instalați pachetele necesareși montați discul. Centos necesită următoarele pachete

# yum install nfs-utils nfs-utils-lib

# mkdir -p /mnt/nfs # mount 192.168.2.213:/home/alex/nfs_dir1 /mnt/nfs # mount /dev/mapper/vg_slave-lv_root on / type ext4 (rw) proc on /proc type proc (rw) sysfs pe /sys tip sysfs (rw) devpts pe /dev/pts tip devpts (rw,gid=5,mode=620) tmpfs pe /dev/shm tip tmpfs (rw,rootcontext="system_u:object_r:tmpfs_t:s0" ) /dev/sda1 pe /boot tip ext4 (rw) niciunul pe /proc/sys/fs/binfmt_misc tip binfmt_misc (rw) sunrpc pe /var/lib/nfs/rpc_pipefs tip rpc_pipefs (rw) 192.218./16. alex/nfs_dir1 pe /mnt/nfs tip nfs (rw,vers=4,addr=192.168.2.213,clientaddr=192.168.2.72)

ÎN în acest caz, putem adăuga orice fișier și director în folderul nfs_dir1 montat în numele oricărui utilizator de pe sistem ( all_squash). Dar dacă montem al doilea folder nfs_dir2, atunci DOAR root poate scrie în el, deoarece există o opțiune acolo no_root_squash. Sa verificam.

# mkdir /mnt/dir1 # mkdir /mnt/dir2 # mount 192.168.2.213:/home/alex/nfs_dir1 /mnt/dir1 # mount 192.168.2.213:/home/alex/nfs_dir2 /mnt/dir2 sau # mount -t -o rw,hard,intr,bg 192.168.2.213:/home/alex/nfs_dir2 /mnt/dir2 # echo "Hello" > /mnt/dir1/file1 # echo "Hello" > /mnt/dir2/file1 # su alex $ echo "Bună ziua" > /mnt/dir1/file1 $ echo "Bună ziua" > /mnt/dir2/file1 bash: /mnt/dir2/file1: Permisiune refuzată

Posibile steaguri de montare.

De asemenea, puteți verifica din consolă dacă serverul a exportat corect sistemul de fișiere.

Root@centos ~# showmount -e 192.168.2.213 Exportați lista pentru 192.168.2.213: /home/alex/nfs_dir2 192.168.2.0/24 /home/alex/nfs_dir1 192.168.2.180

Adăugarea unei monturi la pornire

# cat /etc/fstab ... 192.168.2.213:/home/alex/nfs_dir2 /mnt/dir2 nfs4 rw,bg,intr,hard,nodev,nosuid 0 0

Root@centos ~# mount -a -t nfs4

Posibile greșeli.

Root@centos ~# mount -a -t nfs4 mount.nfs4: punctul de montare /mnt/dir2 nu există root@centos ~# mount -a -t nfs4 mount.nfs4: partajarea la distanță nu este în format "gazdă:dir"

În primul caz, trebuie să creați un folder. Al doilea conține erori de sintaxă în fstab.
Dacă întâmpinați erori la montarea partițiilor NFS, parcurgeți lista Posibile greșeli din secțiunea anterioară.
De asemenea, puteți utiliza autofs pentru a monta partiții NFS. Ce se va discuta în .

NFS: un sistem de fișiere de rețea convenabil și promițător

Sistem de fișiere în rețea este o abstractizare a rețelei peste un sistem de fișiere obișnuit care permite unui client la distanță să îl acceseze prin rețea în același mod ca atunci când accesează sistemele de fișiere locale. Deși NFS nu a fost primul sistem de fișiere de rețea, a evoluat pentru a deveni cel mai capabil și popular sistem de fișiere de rețea din UNIX® astăzi. NFS permite mai multor utilizatori să partajeze un sistem de fișiere comun și centralizează datele pentru a minimiza spațiul pe disc necesar pentru stocarea acestora.

Acest articol începe cu prezentare scurta istoria NFS și apoi trece la explorarea arhitecturii NFS și a dezvoltării sale viitoare.

O scurtă istorie a NFS

Primul sistem de fișiere de rețea a fost numit FAL (File Access Listener) și a fost dezvoltat în 1976 de către DEC (Digital Equipment Corporation). Era o implementare a protocolului DAP (Data Access Protocol) și făcea parte din suita de protocoale DECnet. Ca și în cazul TCP/IP, DEC a publicat specificații pentru protocoalele sale de rețea, inclusiv protocolul DAP.

NFS a fost primul sistem modern de fișiere de rețea construit pe baza protocolului IP. Prototipul său poate fi considerat un sistem de fișiere experimental dezvoltat la Sun Microsystems la începutul anilor 80. Având în vedere popularitatea acestei soluții, protocolul NFS a fost introdus ca specificație RFC și a evoluat ulterior în NFSv2. NFS s-a impus rapid ca standard datorită capacității sale de a interopera cu alți clienți și servere.

Standardul a fost ulterior actualizat la NFSv3, definit în RFC 1813. Această versiune a protocolului a fost mai scalabilă decât versiunile anterioare și a acceptat fișiere de dimensiuni mai mari (mai mari de 2 GB), scriere asincronă și TCP ca protocol de transport. NFSv3 a stabilit direcția pentru dezvoltarea sistemelor de fișiere pentru rețelele WAN. În 2000, RFC 3010 (revizuit ca RFC 3530) a adus NFS în mediul întreprinderii. Sun a introdus un NFSv4 mai sigur cu suport stateful (versiunile anterioare de NFS nu acceptau stocarea stateful, adică erau clasificate ca apatride). În prezent, cea mai recentă versiune a NFS este versiunea 4.1, definită în RFC 5661, care se adaugă la protocol prin extinderea pNFS a fost adăugat suport pentru acces paralel pentru serverele distribuite.

Istoricul NFS, inclusiv RFC-uri specifice care descriu versiunile sale, este prezentat în Figura 1.

În mod surprinzător, NFS a fost în dezvoltare de aproape 30 de ani. Este un sistem de fișiere de rețea extrem de stabil și portabil, cu caracteristici remarcabile de scalabilitate, performanță și calitate a serviciilor. Pe măsură ce vitezele cresc și latența scade atunci când se comunică într-o rețea, NFS continuă să fie o modalitate populară de a implementa un sistem de fișiere într-o rețea. Chiar și în cazul rețelelor locale, virtualizarea încurajează stocarea datelor în rețea pentru a oferi mobilitate suplimentară mașinilor virtuale. NFS acceptă, de asemenea, cele mai recente modele de mediu de calcul care vizează optimizarea infrastructurilor virtuale.

Arhitectura NFS

NFS folosește un model arhitectural standard client-server (așa cum se arată în Figura 2). Serverul este responsabil pentru implementarea sistemului de fișiere partajat și stocarea la care se conectează clienții. Clientul implementează o interfață cu utilizatorul într-un sistem de fișiere partajat montat în spațiul de fișiere local al clientului.

Figura 2. Implementarea modelului client-server în arhitectura NFS

În sistemul de operare Linux®, un comutator de sistem de fișiere virtual (VFS) oferă mijloacele de a suporta simultan mai multe sisteme de fișiere (de exemplu, un sistem de fișiere) pe o singură gazdă. sisteme ISO 9660 pe CD-ROM și sistem de fișiere ext3fs pe hard disk local). Comutatorul virtual determină la ce unitate se face cererea și, prin urmare, ce sistem de fișiere trebuie utilizat pentru a procesa cererea. Prin urmare, NFS are aceeași compatibilitate ca și alte sisteme de fișiere utilizate în Linux. Singura diferență cu NFS este că, în loc să fie procesate local pe gazdă, cererile I/O pot fi trimise în rețea pentru execuție.

VFS determină că cererea primită este NFS și o transmite handlerului NFS situat în kernel. Hander-ul NFS procesează cererea I/O și o traduce într-o procedură NFS (OPEN, ACCESS, CREATE, READ, CLOSE, REMOVE etc.). Aceste proceduri, descrise într-o specificație RFC separată, definesc comportamentul protocolului NFS. Procedura necesară este selectată în funcție de solicitare și este executată folosind tehnologia RPC (apel de procedură la distanță). După cum sugerează și numele, RPC permite efectuarea apelurilor de procedură între diferite sisteme. Serviciul RPC concatenează o solicitare NFS cu argumentele sale și trimite rezultatul gazdei la distanță corespunzătoare, apoi monitorizează primirea și procesarea răspunsului pentru a-l returna solicitantului.

RPC include, de asemenea, un strat XDR important ( reprezentarea datelor externe- reprezentarea independentă a datelor), asigurându-se că toți utilizatorii NFS utilizează același format pentru aceleași tipuri de date. Când o platformă trimite o solicitare, tipul de date pe care îl folosește poate fi diferit de tipul de date utilizat pe gazda care procesează cererea. Tehnologia XDR se ocupă de munca de conversie a tipurilor într-o reprezentare standard (XDR), astfel încât platformele care utilizează arhitecturi diferite să poată interopera și partaja sisteme de fișiere. XDR definește formatul de biți pentru tipuri precum float și ordinea octeților pentru tipuri precum matricele cu lungime constantă și variabilă. Deși XDR este cunoscut în primul rând pentru utilizarea sa în NFS, această specificație poate fi utilă în toate cazurile în care trebuie să lucrați în același mediu cu arhitecturi diferite.

După ce XDR a tradus datele într-o reprezentare standard, cererea este trimisă prin rețea folosind un protocol de transport specific. Implementările timpurii ale NFS foloseau UDP, dar astăzi TCP este folosit pentru o mai mare fiabilitate.

Un algoritm similar este utilizat pe partea serverului NFS. Solicitarea parcurge stiva de rețea prin stratul RPC/XDR (pentru a converti tipurile de date în funcție de arhitectura serverului) și în serverul NFS, care este responsabil de procesarea cererii. Acolo, cererea este transmisă demonului NFS pentru a determina sistemul de fișiere țintă căruia îi este adresată și apoi merge din nou la VFS pentru a accesa acel sistem de fișiere pe discul local. O diagramă completă a acestui proces este prezentată în Figura 3. În acest caz, sistemul de fișiere local al serverului este un sistem de fișiere Linux standard, de exemplu, ext4fs. În esență, NFS nu este un sistem de fișiere în sensul tradițional al termenului, ci un protocol pentru accesul de la distanță la sistemele de fișiere.

Pentru rețelele cu latență lungă, NFSv4 oferă o procedură compusă specială ( procedeu compus). Această procedură vă permite să plasați mai multe apeluri RPC într-o singură cerere pentru a minimiza costul trimiterii cererilor prin rețea. Această procedură implementează, de asemenea, un mecanism de funcție de apel invers pentru primirea răspunsurilor.

Protocolul NFS

Când un client începe să folosească NFS, prima acțiune este să efectueze o operație de montare, care este să monteze sistemul de fișiere la distanță în spațiul local al sistemului de fișiere. Acest proces începe cu un apel la procedura de montare (una din sistemul Funcții Linux), care este redirecționat prin VFS către componenta NFS. Apoi, un apel RPC la funcția get_port de pe serverul de la distanță determină numărul portului care va fi folosit pentru montare, iar clientul trimite o cerere de montare prin RPC. Această solicitare pe partea de server este procesată de un demon special rpc.mountd, care este responsabil pentru protocolul de montare ( protocol de montare). Daemonul verifică dacă sistemul de fișiere solicitat de client se află în lista de sisteme disponibile pe acest server. Dacă sistemul solicitat există și clientul are acces la el, răspunsul RPC de montare specifică un descriptor de sistem de fișiere. Clientul reține informații despre punctele de montare locale și la distanță și este capabil să facă cereri I/O. Protocolul de montare nu este sigur din punct de vedere al securității, așa că NFSv4 utilizează în schimb apeluri interne RPC, care pot gestiona și punctele de montare.

Pentru a citi un fișier, trebuie mai întâi să îl deschideți. Nu există nicio procedură OPEN în RPC; în schimb, clientul verifică pur și simplu dacă fișierul și directorul specificat există pe sistemul de fișiere montat. Clientul începe prin a face o solicitare GETATTR RPC către director, care returnează atributele directorului sau un indicator că directorul nu există. Apoi, pentru a verifica prezența fișierului, clientul emite o solicitare LOOKUP RPC. Dacă fișierul există, se face o solicitare GETATTR RPC asupra acestuia pentru a afla atributele fișierului. Folosind informațiile obținute din apelurile de succes LOOKUP și GETATTR, clientul creează un handle de fișier care este furnizat utilizatorului pentru cereri viitoare.

Odată ce fișierul a fost identificat pe sistemul de fișiere la distanță, clientul poate emite solicitări RPC READ. Această solicitare constă dintr-un descriptor de fișier, o stare, un offset și numărul de octeți de citit. Clientul folosește starea ( stat) pentru a determina dacă operația poate fi efectuată în momentul de față, adică. Fișierul este blocat? Decalaj ( decalaj) indică în ce poziție să începeți citirea și contorul de octeți ( numara) determină câți octeți trebuie citiți. Ca urmare a unui apel RPC READ, serverul nu returnează întotdeauna câți octeți au fost solicitați, dar împreună cu datele returnate raportează întotdeauna câți octeți au fost trimiși către client.

Inovație în NFS

Cele mai recente două versiuni de NFS sunt de cel mai mare interes - 4 și 4.1, ca exemple din care puteți studia cele mai importante aspecte ale evoluției tehnologiei NFS.

Înainte ca NFSv4 să fie disponibil pentru a efectua sarcini de gestionare a fișierelor, cum ar fi montarea, blocarea etc. existau protocoale suplimentare speciale. În NFSv4, procesul de gestionare a fișierelor a fost simplificat la un singur protocol; În plus, începând cu această versiune, UDP nu mai este folosit ca protocol de transport. NFSv4 include suport pentru semantica de acces la fișiere UNIX și Windows®, permițând NFS să se integreze în mod natural în alte sisteme de operare.

NFSv4.1 a introdus conceptul de NFS paralel(NFS paralel - pNFS). Pentru a oferi niveluri mai mari de scalabilitate, NFSv4.1 implementează o arhitectură în care datele și metadatele ( marcare) sunt distribuite pe dispozitive într-un mod similar cu modul în care se face în sistemele de fișiere în cluster. După cum se arată în , pNFS împarte ecosistemul în trei componente: client, server și stocare. În acest caz, apar două canale: unul pentru transmiterea datelor, iar celălalt pentru transmiterea comenzilor de control. pNFS separă datele de metadatele care le descriu, oferind o arhitectură cu două canale. Când un client dorește să acceseze un fișier, serverul îi trimite metadate cu „markup”. Metadatele conțin informații despre locația fișierului pe dispozitivele de stocare. Odată ce clientul are aceste informații, poate accesa stocarea direct, fără a fi nevoit să interacționeze cu serverul, îmbunătățind scalabilitatea și performanța. Când clientul termină de lucru cu fișierul, acesta confirmă modificările aduse fișierului și „markupul” acestuia. Dacă este necesar, serverul poate solicita metadate cu marcaj de la client.

Odată cu apariția pNFS, mai multe operațiuni noi au fost adăugate la protocolul NFS pentru a sprijini un astfel de mecanism. Metoda LayoutGet este folosită pentru a prelua metadate de pe server, metoda LayoutReturn „eliberează” metadatele „capturate” de client, iar metoda LayoutCommit încarcă „layout-ul” primit de la client în stocare, astfel încât să fie disponibil pentru alți utilizatori. Serverul poate rechema metadatele de la client folosind metoda LayoutRecall. Metadatele „etichetate” sunt distribuite pe mai multe dispozitive de stocare pentru a oferi acces paralel și performanță ridicată.

Datele și metadatele sunt stocate pe dispozitive de stocare. Clienții pot efectua solicitări I/O directe pe baza markupului primit, iar serverul NFSv4.1 stochează și gestionează metadatele. Această funcționalitate în sine nu este nouă, dar pNFS a adăugat suport pentru diferite metode de accesare a dispozitivelor de stocare. Astăzi, pNFS acceptă utilizarea protocoalelor bloc (Fibre Channel), a protocoalelor obiect și a NFS în sine (nici măcar în formă pNFS).

Dezvoltarea NFS continuă, iar în septembrie 2010 au fost publicate cerințele pentru NFSv4.2. Unele dintre inovații sunt legate de migrarea continuă a tehnologiilor de stocare a datelor către virtualizare. De exemplu, în medii virtuale Cu un hypervisor, duplicarea datelor este foarte probabilă (mai multe sisteme de operare citesc/scriu și memorează în cache aceleași date). Din această cauză, este de dorit ca sistemul de stocare în ansamblu să înțeleagă unde are loc duplicarea. Această abordare va ajuta la economisirea spațiului cache al clientului și a capacității generale de stocare. NFSv4.2 propune utilizarea unei „hărți de blocuri a blocurilor partajate” pentru a rezolva această problemă. Pe măsură ce sistemele moderne de stocare sunt din ce în ce mai echipate cu propria lor putere de calcul internă, este introdusă copierea pe server pentru a reduce sarcina copierii datelor într-o rețea internă, atunci când aceasta poate fi realizată eficient pe dispozitivul de stocare în sine. Alte inovații includ stocarea în cache a sub-fișierului pentru memoria flash și recomandări de reglare I/O la nivelul clientului (cum ar fi utilizarea mapadvise).

Alternative NFS

Deși NFS este cel mai popular sistem de fișiere de rețea în UNIX și Linux, există și alte sisteme de fișiere de rețea. Pe Platforma Windows® cel mai frecvent utilizat SMB, cunoscut și ca CIFS; cu toate acestea, sistemul de operare Windows acceptă și NFS, precum și Linux acceptă SMB.

Unul dintre cele mai noi sisteme de fișiere distribuite acceptate pe Linux, Ceph, este proiectat de la zero pentru a fi un sistem de fișiere compatibil POSIX tolerant la erori. Mai multe informații despre Ceph pot fi găsite în secțiunea.

De asemenea, merită menționate sistemele de fișiere OpenAFS (versiunea Open Source a sistemului de fișiere distribuit Andrew, dezvoltat la Carnegie Mellon University și IBM Corporation), GlusterFS (sistem de fișiere distribuite). scop general pentru organizarea stocării de date scalabile) și Luster (un sistem de fișiere de rețea cu paralelism masiv pentru soluții de cluster). Toate aceste sisteme open source pot fi folosite pentru a construi stocare distribuită.

Concluzie

Dezvoltarea sistemului de fișiere NFS continuă. Similar cu sistemul de operare Linux, potrivit pentru a accepta atât soluții low-end, încorporate și high-end, NFS oferă o arhitectură pentru soluții de stocare scalabile potrivite atât pentru utilizatori individuali, și organizații. Când vă uitați la călătoria pe care a făcut-o deja NFS și la perspectivele dezvoltării sale viitoare, devine clar că acest sistem de fișiere va continua să schimbe modul în care ne gândim la modul în care sunt implementate și utilizate tehnologiile de stocare a fișierelor.

NFS, sau Network File System, este un protocol de sistem de fișiere de rețea popular, care permite utilizatorilor să monteze directoare de rețea la distanță pe mașina lor și să transfere fișiere între servere. Puteți utiliza spațiul pe disc de pe o altă mașină pentru fișierele dvs. și puteți lucra cu fișiere aflate pe alte servere. În esență, este o alternativă la comun Acces Windows pentru Linux, spre deosebire de Samba, este implementat la nivel de kernel și funcționează mai stabil.

Acest articol va acoperi instalarea nfs pe Ubuntu 16.04. Vom analiza instalarea tuturor componentele necesare, configurarea unui folder partajat, precum și conectarea folderelor de rețea.

După cum am menționat deja, NFS este un sistem de fișiere de rețea. Pentru a funcționa, aveți nevoie de un server care va găzdui folderul partajat și clienți care pot monta folderul de rețea ca un disc obișnuit în sistem. Spre deosebire de alte protocoale, NFS oferă acces transparent la fișiere șterse. Programele vor vedea fișierele ca într-un sistem de fișiere obișnuit și vor lucra cu ele ca și cu ele fisiere locale, nfs returnează doar partea solicitată a fișierului, în loc de întregul fișier, astfel încât acest sistem de fișiere va funcționa excelent pe sisteme cu Internet rapid sau pe o rețea locală.

Instalarea componentelor NFS

Înainte de a putea lucra cu NFS, va trebui să instalăm mai multe programe. Pe mașina care va fi serverul, trebuie să instalați pachetul nfs-kernel-server, care va fi folosit pentru a deschide share-uri nfs în ubuntu 16.04. Pentru a face acest lucru, rulați:

sudo apt install nfs-kernel-server

Acum să verificăm dacă serverul a fost instalat corect. Serviciul NFS ascultă conexiunile atât pentru TCP, cât și pentru UDP pe portul 2049. Puteți vedea dacă aceste porturi sunt de fapt utilizate cu comanda:

rpcinfo -p | grep nfs

De asemenea, este important să verificați dacă NFS este acceptat la nivel de kernel:

cat /proc/sisteme de fișiere | grep nfs

Vedem că funcționează, dar dacă nu, trebuie să încărcați manual modulul kernel nfs:

Să adăugăm și nfs la pornire:

sudo systemctl enable nfs

Trebuie să instalați pachetul nfs-common pe computerul client pentru a putea lucra cu acest sistem de fișiere. Nu trebuie să instalați componentele serverului, doar acest pachet va fi suficient:

sudo apt install nfs-common

Configurarea unui server NFS pe Ubuntu

Putem deschide accesul NFS la orice folder, dar haideți să creăm unul nou în acest scop:

client folder_address (opțiuni)

Adresa folderului este folderul care trebuie să fie accesibil prin rețea. Client - adresa IP sau adresa de rețea din care poate fi accesat acest folder. Dar cu opțiuni este puțin mai complicat. Să ne uităm la unele dintre ele:

• rw- permite citirea și scrierea în acest folder
• ro- permite numai citire
• sincronizare- răspunde la următoarele solicitări numai atunci când datele sunt salvate pe disc (implicit)
• asincron- nu blocați conexiunile în timp ce datele sunt scrise pe disc
• sigur- utilizați numai porturi sub 1024 pentru conectare
• nesigur- utilizați orice porturi
• nohide- nu ascundeți subdirectoare când deschideți accesul la mai multe directoare
• rădăcină_dovleac- înlocuiți cererile de la root cu altele anonime
• all_squash- transformați toate cererile în anonimat
• anonuidȘi anongid- specifică uid-ul și gid-ul pentru utilizatorul anonim.

De exemplu, pentru folderul nostru, această linie ar putea arăta astfel:

/var/nfs 127.0.0.1(rw,sync,no_subtree_check)

Odată ce totul a fost configurat, tot ce a mai rămas a fost actualizarea tabelului de export NFS:

sudo exportfs -a

Asta e tot, deschiderea acțiunilor nfs în ubuntu 16.04 este finalizată. Acum să încercăm să configuram clientul și să încercăm să-l montem.

conexiune NFS

Nu ne vom opri asupra acestei probleme în detaliu în articolul de astăzi. Acesta este un subiect destul de amplu care merită propriul articol. Dar tot voi spune câteva cuvinte.

Pentru a conecta un folder de rețea nu aveți nevoie de niciunul client nfs ubuntu, folosește doar comanda mount:

sudo mount 127.0.0.1:/var/nfs/ /mnt/

Acum puteți încerca să creați un fișier în directorul conectat:

Ne vom uita, de asemenea, la sistemele de fișiere montate folosind df:

127.0.0.1:/var/nfs 30G 6.7G 22G 24% /mnt

Pentru a dezactiva acest sistem de fișiere, trebuie doar să utilizați umountul standard:

sudo umount /mnt/

concluzii

Acest articol a discutat despre configurarea nfs ubuntu 16.04, după cum puteți vedea, totul se face foarte simplu și transparent. Conectarea partajărilor NFS se face în câteva clicuri folosind comenzi standard, iar deschiderea partajărilor NFS în ubuntu 16.04 nu este mult mai complicată decât conectarea. Dacă aveți întrebări, scrieți în comentarii!

Postări asemănatoare: