എൻഎഫ്എസ്

ലെവൽ (OSI മോഡൽ അനുസരിച്ച്):	പ്രയോഗിച്ചു
കുടുംബം:	TCP/IP പ്രോട്ടോക്കോൾ സ്റ്റാക്ക്
പോർട്ട്/ഐഡി:	67, 68/UDP
പ്രോട്ടോക്കോളിന്റെ ഉദ്ദേശ്യം:	നെറ്റ്‌വർക്ക് കോൺഫിഗറേഷൻ നേടുന്നു
സ്പെസിഫിക്കേഷൻ:	RFC 2131
പ്രധാന നടപ്പാക്കലുകൾ (സെർവറുകൾ):	dhcpd, ISC DHCP സെർവർ, Infoblox
ഇതിൽ നിന്ന് പ്രാബല്യത്തിൽ വന്നു:	1990

സെർവർ, ക്ലയന്റ് ഫയൽ സിസ്റ്റം തരങ്ങളിൽ നിന്ന് NFS സംഗ്രഹിക്കുന്നു, കൂടാതെ വ്യത്യസ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കും ഹാർഡ്‌വെയർ ആർക്കിടെക്ചറുകൾക്കുമായി ധാരാളം NFS സെർവറും ക്ലയന്റ് നടപ്പിലാക്കലുകളും ഉണ്ട്. NFS-ന്റെ ഏറ്റവും പ്രായപൂർത്തിയായ പതിപ്പ് v.4 ആണ്, ഇത് വിവിധ പ്രാമാണീകരണ മാർഗ്ഗങ്ങളെ (പ്രത്യേകിച്ച്, RPCSEC GSS പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച് Kerberos, LIPKEY) കൂടാതെ ആക്സസ് കൺട്രോൾ ലിസ്റ്റുകളും (POSIX, Windows തരങ്ങൾ) പിന്തുണയ്ക്കുന്നു.

ജനറൽ NFS ഓർഗനൈസേഷൻ

NFS ക്ലയന്റുകൾക്ക് സെർവറിന്റെ ഫയലുകളിലേക്കും ഫയൽ സിസ്റ്റത്തിലേക്കും സുതാര്യമായ പ്രവേശനം നൽകുന്നു. എഫ്‌ടിപിയിൽ നിന്ന് വ്യത്യസ്തമായി, എൻഎഫ്‌എസ് പ്രോട്ടോക്കോൾ ആക്‌സസ് ചെയ്യുന്ന ഫയലിന്റെ ഭാഗങ്ങൾ മാത്രമേ ആക്‌സസ് ചെയ്യൂ, ഈ ആക്‌സസ് സുതാര്യമാക്കുന്നു എന്നതാണ് ഇതിന്റെ പ്രധാന നേട്ടം. ഒരു ലോക്കൽ ഫയലിൽ പ്രവർത്തിക്കാൻ കഴിയുന്ന ഏതൊരു ക്ലയന്റ് ആപ്ലിക്കേഷനും പ്രോഗ്രാമിൽ തന്നെ മാറ്റങ്ങളൊന്നും വരുത്താതെ തന്നെ ഒരു NFS ഫയലിൽ എളുപ്പത്തിൽ പ്രവർത്തിക്കാൻ കഴിയുമെന്നാണ് ഇതിനർത്ഥം.

സെർവറിലേക്ക് RPC അഭ്യർത്ഥനകൾ അയച്ചുകൊണ്ട് NFS ക്ലയന്റുകൾ NFS സെർവറിൽ ഫയലുകൾ ആക്സസ് ചെയ്യുന്നു. സാധാരണ ഉപയോക്തൃ പ്രക്രിയകൾ ഉപയോഗിച്ച് ഇത് നടപ്പിലാക്കാൻ കഴിയും - അതായത്, NFS ക്ലയന്റ് സെർവറിലേക്ക് നിർദ്ദിഷ്ട RPC കോളുകൾ ചെയ്യുന്ന ഒരു ഉപയോക്തൃ പ്രക്രിയയായിരിക്കാം, അത് ഒരു ഉപയോക്തൃ പ്രക്രിയയും ആകാം.

NFS സ്റ്റാൻഡേർഡിന്റെ (v4.1) ഏറ്റവും പുതിയ പതിപ്പിന്റെ ഒരു പ്രധാന ഭാഗം pNFS സ്പെസിഫിക്കേഷനായിരുന്നു, ഇത് ഫയൽ പങ്കിടലിന്റെ സമാന്തരമായ നടപ്പാക്കൽ, സിസ്റ്റത്തിന്റെ സമാന്തരതയുടെ വലുപ്പത്തിനും അളവിനും ആനുപാതികമായി ഡാറ്റാ ട്രാൻസ്ഫർ വേഗത വർദ്ധിപ്പിക്കുന്നതിന് ലക്ഷ്യമിടുന്നു.

കഥ

NFS പ്രോട്ടോക്കോളിന് അതിന്റെ ചരിത്രത്തിൽ 4 പതിപ്പുകളുണ്ട്.

ആദ്യ പതിപ്പ് പരീക്ഷണ ആവശ്യങ്ങൾക്കായി സൂര്യനിൽ ആന്തരിക ഉപയോഗത്തിന് മാത്രമാണ് ഉപയോഗിച്ചത്. പതിപ്പ് 2 1989 മാർച്ചിൽ പുറത്തിറങ്ങി, തുടക്കത്തിൽ പൂർണ്ണമായും യുഡിപിയിൽ പ്രവർത്തിച്ചു. അടിസ്ഥാന പ്രോട്ടോക്കോളിന് പുറത്ത് നടപ്പിലാക്കിയ ലോക്കിംഗ് പോലുള്ള ആന്തരിക അവസ്ഥ ഡാറ്റ പ്രോട്ടോക്കോളിനുള്ളിൽ സംഭരിക്കേണ്ടതില്ലെന്ന് ഡെവലപ്പർമാർ തീരുമാനിച്ചു. NFS പതിപ്പ് 2 സൃഷ്ടിക്കുന്നതിൽ ഉൾപ്പെട്ടിരിക്കുന്ന ആളുകൾ റസ്റ്റി സാൻഡ്‌ബെർഗ്, ബോബ് ലിയോൺ, ബിൽ ജോയ്, സ്റ്റീവ് ക്ലെമാൻ എന്നിവരാണ്.

NFSv3 1995 ജൂണിൽ പുറത്തിറങ്ങി, ഇത് 64 ബൈറ്റുകൾ വരെയുള്ള വേരിയബിൾ വലുപ്പത്തിലുള്ള ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾക്കുള്ള പിന്തുണ ചേർത്തു (പതിപ്പ് 2-ൽ - 32 ബൈറ്റുകളുടെ ഒരു നിശ്ചിത വലിപ്പത്തിലുള്ള അറേ), RPC-യിലെ 8192 ബൈറ്റ് പരിധി നീക്കം ചെയ്തു (അങ്ങനെ, കോളുകളിലെ ട്രാൻസ്ഫർ ചെയ്ത ബ്ലോക്കിന്റെ വലുപ്പം യുഡിപി ഡാറ്റാഗ്രാമിന്റെ പരിധിയിൽ മാത്രം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു - 65535 ബൈറ്റുകൾ), വലിയ ഫയലുകൾക്കുള്ള പിന്തുണ നടപ്പിലാക്കി, റൈറ്റ് ഓപ്പറേഷനുകൾക്കുള്ള അസിൻക്രണസ് കോളുകൾ പിന്തുണയ്ക്കുന്നു, റീഡ്, റൈറ്റ് നടപടിക്രമങ്ങളിലേക്കുള്ള കോളുകൾ കോളുകളിലേക്ക് ചേർത്തു. ആക്‌സസ് (ഫയൽ ആക്‌സസ് അവകാശങ്ങൾ പരിശോധിക്കുന്നു), MKNOD (ഒരു പ്രത്യേക Unix ഫയൽ സൃഷ്‌ടിക്കുന്നു), READDIRPLUS (ഒരു ഡയറക്‌ടറിയിലെ ഫയലുകളുടെ പേരുകൾ അവയുടെ ആട്രിബ്യൂട്ടുകൾക്കൊപ്പം നൽകുന്നു), FSINFO (ഫയൽ സിസ്റ്റത്തെക്കുറിച്ചുള്ള സ്ഥിതിവിവരക്കണക്കുകൾ നൽകുന്നു), FSSTAT (ഇതിനെക്കുറിച്ചുള്ള ഡൈനാമിക് വിവരങ്ങൾ നൽകുന്നു ഫയൽ സിസ്റ്റം), PATHCONF (ഫയലിനെക്കുറിച്ചുള്ള POSIX.1 വിവരങ്ങൾ നൽകുന്നു), COMMIT (ശാശ്വത സംഭരണത്തിനായി മുമ്പ് നിർമ്മിച്ച അസിൻക്രണസ് റെക്കോർഡുകൾ കൈമാറുന്നു). പതിപ്പ് 3 അവതരിപ്പിക്കുന്ന സമയത്ത്, TCP പ്രോട്ടോക്കോളിന്റെ ഡെവലപ്പർമാർക്കിടയിൽ ജനപ്രീതി വർദ്ധിച്ചു. ചില സ്വതന്ത്ര ഡെവലപ്പർമാർ സ്വതന്ത്രമായി NFS പതിപ്പ് 2-ലേക്ക് ഒരു ട്രാൻസ്പോർട്ട് പ്രോട്ടോക്കോൾ ആയി TCP പിന്തുണ ചേർത്തു, പതിപ്പ് 3-ലേക്കുള്ള കൂട്ടിച്ചേർക്കലുകളിൽ ഒന്നിൽ Sun Microsystems NFS-ലേക്ക് TCP പിന്തുണ ചേർത്തു. TCP പിന്തുണ വൈഡ് ഏരിയ നെറ്റ്‌വർക്കുകളിൽ NFS ഉപയോഗിക്കുന്നതിനുള്ള പ്രായോഗിക സാധ്യത വർദ്ധിപ്പിച്ചു.

NFSv4 2000 ഡിസംബറിൽ പുറത്തിറങ്ങി, AFS, CIFS എന്നിവയെ സ്വാധീനിച്ചു, കൂടാതെ പ്രകടനവും സുരക്ഷാ മെച്ചപ്പെടുത്തലുകളും ഉൾപ്പെടുന്നു. ഇന്റർനെറ്റ് എഞ്ചിനീയറിംഗ് ടാസ്‌ക് ഫോഴ്‌സുമായി (ഐഇടിഎഫ്) സംയുക്തമായി വികസിപ്പിച്ച ആദ്യ പതിപ്പാണ് പതിപ്പ് 4. NFS v4.1 2010 ജനുവരിയിൽ IESG അംഗീകരിച്ചു (612 പേജുള്ള പുതിയ സ്പെസിഫിക്കേഷൻ, IETF അംഗീകരിച്ച ഏറ്റവും ദൈർഘ്യമേറിയ പ്രമാണമായി അറിയപ്പെട്ടു). പതിപ്പ് 4.1 ലെ ഒരു പ്രധാന കണ്ടുപിടുത്തം pNFS - പാരലൽ NFS-ന്റെ സ്പെസിഫിക്കേഷൻ ആണ്, ഒന്നിലധികം വിതരണം ചെയ്ത NFS സെർവറുകളിൽ നിന്നുള്ള ഡാറ്റയിലേക്ക് സമാന്തര NFS ക്ലയന്റ് ആക്സസ് ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനം. നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം സ്റ്റാൻഡേർഡിൽ അത്തരമൊരു സംവിധാനത്തിന്റെ സാന്നിധ്യം വിതരണം ചെയ്ത ക്ലൗഡ് സംഭരണവും വിവര സംവിധാനങ്ങളും നിർമ്മിക്കാൻ സഹായിക്കും.

വികസന ലക്ഷ്യങ്ങൾ

NFS-ന്റെ വികസനത്തിനുള്ള പ്രാഥമിക ആവശ്യകതകൾ ഇവയായിരുന്നു:

• വിവിധ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്കുള്ള സാധ്യതയുള്ള പിന്തുണ (UNIX മാത്രമല്ല), അങ്ങനെ NFS സെർവറുകളും ക്ലയന്റുകളും വ്യത്യസ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ നടപ്പിലാക്കാൻ കഴിയും;
• പ്രോട്ടോക്കോൾ ഏതെങ്കിലും പ്രത്യേക ഹാർഡ്‌വെയറിനെ ആശ്രയിക്കരുത്;
• സെർവർ അല്ലെങ്കിൽ ക്ലയന്റ് പരാജയങ്ങളുടെ കാര്യത്തിൽ ലളിതമായ വീണ്ടെടുക്കൽ സംവിധാനങ്ങൾ നടപ്പിലാക്കണം;
• പ്രത്യേക പാത്ത് നെയിമുകളോ ലൈബ്രറികളോ ഉപയോഗിക്കാതെയും റീകോമ്പൈൽ ചെയ്യാതെയും ആപ്ലിക്കേഷനുകൾക്ക് റിമോട്ട് ഫയലുകളിലേക്ക് സുതാര്യമായ ആക്സസ് ഉണ്ടായിരിക്കണം;
• UNIX ക്ലയന്റുകൾക്കായി UNIX സെമാന്റിക്‌സ് പിന്തുണയ്‌ക്കേണ്ടതാണ്;
• NFS പ്രകടനം ലോക്കൽ ഡിസ്കുകളുടെ പ്രകടനവുമായി താരതമ്യപ്പെടുത്താവുന്നതാണ്;
• നടപ്പാക്കൽ വാഹനത്തെ ആശ്രയിക്കരുത്.

NFS എങ്ങനെ പ്രവർത്തിക്കുന്നു

കുറഞ്ഞത് രണ്ട് പ്രധാന ഭാഗങ്ങളിൽ നിന്നാണ് NFS നിർമ്മിച്ചിരിക്കുന്നത്: ഒരു സെർവറും ഒന്നോ അതിലധികമോ ക്ലയന്റുകളും. റിമോട്ട് ആക്സസ് മോഡിൽ സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന ഡാറ്റ ക്ലയന്റ് ആക്സസ് ചെയ്യുന്നു. ഇത് ശരിയായി പ്രവർത്തിക്കുന്നതിന്, നിരവധി പ്രക്രിയകൾ ക്രമീകരിച്ച് സമാരംഭിക്കേണ്ടതുണ്ട്. NFS നടപ്പിലാക്കൽ നിരവധി ഘടകങ്ങൾ ഉൾക്കൊള്ളുന്നു. അവയിൽ ചിലത് സെർവറിലോ ക്ലയന്റിലോ പ്രാദേശികവൽക്കരിച്ചിരിക്കുന്നു, ചിലത് കണക്ഷന്റെ ഇരുവശത്തും ഉപയോഗിക്കുന്നു. കോർ ഫങ്ഷണാലിറ്റി നൽകുന്നതിന് ചില ഘടകങ്ങൾ ആവശ്യമില്ല, പക്ഷേ വിപുലീകൃത NFS ഇന്റർഫേസിന്റെ ഭാഗമാണ്.

NFS പ്രോട്ടോക്കോൾ ഒരു സെർവറിലേക്ക് ഒരു ക്ലയന്റ് അയയ്‌ക്കാൻ കഴിയുന്ന ഒരു കൂട്ടം അഭ്യർത്ഥനകൾ (പ്രവർത്തനങ്ങൾ) നിർവ്വചിക്കുന്നു, കൂടാതെ ഈ ഓരോ അഭ്യർത്ഥനകൾക്കും ഒരു കൂട്ടം ആർഗ്യുമെന്റുകളും റിട്ടേൺ മൂല്യങ്ങളും. ഈ പ്രോട്ടോക്കോളിന്റെ പതിപ്പ് 1 സൺ മൈക്രോസിസ്റ്റംസിന്റെ ആഴത്തിൽ മാത്രമേ നിലനിന്നിരുന്നുള്ളൂ, അത് ഒരിക്കലും പുറത്തിറങ്ങിയിട്ടില്ല. എല്ലാ NFS നടപ്പിലാക്കലുകളും (NFSv3 ഉൾപ്പെടെ) NFS പതിപ്പ് 2 (NFSv2) പിന്തുണയ്ക്കുന്നു, ഇത് 1985-ൽ SunOS 2.0-ൽ ആദ്യമായി പുറത്തിറക്കി. പ്രോട്ടോക്കോളിന്റെ പതിപ്പ് 3 1993 ൽ പ്രസിദ്ധീകരിച്ചു, ഇത് നിരവധി വെണ്ടർമാർ നടപ്പിലാക്കിയിട്ടുണ്ട്.

റിമോട്ട് പ്രൊസീജ്യർ കോൾ (RPC) പ്രോട്ടോക്കോൾ ക്ലയന്റും സെർവറും തമ്മിലുള്ള എല്ലാ ഇടപെടലുകളുടെയും ഫോർമാറ്റ് നിർവചിക്കുന്നു. ഓരോ NFS അഭ്യർത്ഥനയും ഒരു RPC പാക്കറ്റായി അയയ്ക്കുന്നു. ഇനിപ്പറയുന്ന ഡെമണുകൾ സെർവറിൽ പ്രവർത്തിക്കുന്നു:

• rpc.nfsd - പ്രധാന NFS സെർവർ ഡെമൺ nfsd ആണ് (ചിലപ്പോൾ പുതിയ പതിപ്പുകളിൽ nfsd4 എന്ന് വിളിക്കുന്നു). ഈ ഡെമൺ NFS ക്ലയന്റുകളിൽ നിന്നുള്ള അഭ്യർത്ഥനകൾ നൽകുന്നു. Debian-ലെ /etc/default/nfs-kernel-server ഫയലിലെ RPCNFSDCOUNT പരാമീറ്റർ, RedHat-ലെ /etc/sysconfig/nfs ഫയലിലെ NFSDCOUNT എന്നിവ ആരംഭിക്കേണ്ട ഡെമണുകളുടെ എണ്ണം നിർണ്ണയിക്കുന്നു (സ്ഥിരസ്ഥിതി 8 ആണ്). (RPC പ്രോഗ്രാം 100003)
• rpc.mountd - ഡയറക്‌ടറികൾ മൌണ്ട് ചെയ്യുന്നതിനുള്ള ക്ലയന്റ് അഭ്യർത്ഥനകൾ NFS മൗണ്ട് ഡെമൺ മൗണ്ട് പ്രോസസ്സ് ചെയ്യുന്നു. NFS സെർവറുകളിൽ മൗണ്ട് ചെയ്ത ഡെമൺ പ്രവർത്തിക്കുന്നു. (RPC പ്രോഗ്രാം 100005)
• rpc.statd - നെറ്റ്‌വർക്ക് സ്റ്റാറ്റസ് മോണിറ്ററിംഗ് ഡെമൺ (നെറ്റ്‌വർക്ക് സ്റ്റാറ്റസ് മോണിറ്റർ, അല്ലെങ്കിൽ NSM). ഒരു ക്രാഷ്/റീബൂട്ട് കഴിഞ്ഞ് ലോക്ക് ശരിയായി റദ്ദാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു പരാജയത്തെക്കുറിച്ച് അറിയിക്കുന്നതിന്, അത് /usr/sbin/sm-notify പ്രോഗ്രാം ഉപയോഗിക്കുന്നു. സ്റ്റാറ്റ് ഡെമൺ സെർവറുകളിലും ക്ലയന്റുകളിലും പ്രവർത്തിക്കുന്നു. മുമ്പ്, rpc.lockd പ്രവർത്തിക്കുന്നതിന് ഈ സെർവർ ആവശ്യമായിരുന്നു, എന്നാൽ ഇപ്പോൾ ലോക്ക് ചെയ്യുന്നതിനുള്ള ഉത്തരവാദിത്തം കേർണലിനാണ്. (RPC പ്രോഗ്രാം 100021, 100024 - പുതിയ പതിപ്പുകളിൽ)
• rpc.lockd - ലോക്ക് ചെയ്ത ഡെമൺ (NFS ലോക്ക് മാനേജർ (NLM) എന്നും അറിയപ്പെടുന്നു) ഫയൽ ലോക്ക് അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുന്നു. ലോക്കിംഗ് ഡെമൺ സെർവറുകളിലും ക്ലയന്റുകളിലും പ്രവർത്തിക്കുന്നു. ക്ലയന്റുകൾ ഫയൽ ലോക്കിംഗ് അഭ്യർത്ഥിക്കുന്നു, സെർവറുകൾ അത് അനുവദിക്കുന്നു. (കാലഹരണപ്പെട്ടതും പുതിയ വിതരണങ്ങളിൽ ഡെമണായി ഉപയോഗിക്കുന്നില്ല. ആധുനിക വിതരണങ്ങളിൽ (2.2.18-നേക്കാൾ പഴക്കമുള്ള ഒരു കേർണൽ ഉള്ളത്) അതിന്റെ പ്രവർത്തനങ്ങൾ നടത്തുന്നത് കേർണലുകളാണ് (ലോക്ക് ചെയ്തിരിക്കുന്നത്). (RPC പ്രോഗ്രാം 100024)
• rpc.idmapd - സെർവറിലെ NFSv4-നുള്ള idmapd ഡെമൺ, ഉപയോക്താക്കളുടെ ലോക്കൽ uid/gid നെ name@domain എന്ന ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, കൂടാതെ ക്ലയന്റിലുള്ള സേവനം name@domain എന്ന ഫോമിന്റെ ഉപയോക്തൃ/ഗ്രൂപ്പ് പേരുകളെ പ്രാദേശിക ഉപയോക്താവും ഗ്രൂപ്പ് ഐഡന്റിഫയറുമാക്കി മാറ്റുന്നു. (കോൺഫിഗറേഷൻ ഫയൽ പ്രകാരം /etc/idmapd .conf).

ക്ലയന്റിന് nfsiod എന്ന ഡെമൺ പ്രവർത്തിപ്പിക്കാനും കഴിയും. NFS സെർവറിൽ നിന്നുള്ള സെർവർ സൈഡ് അഭ്യർത്ഥനകൾ nfsiod നൽകുന്നു. ഇത് ഓപ്ഷണലാണ്, പ്രകടനം വർദ്ധിപ്പിക്കുന്നു, എന്നാൽ സാധാരണവും ശരിയായതുമായ പ്രവർത്തനത്തിന് ആവശ്യമില്ല. NFSv4-ൽ, Kerberos ഉപയോഗിക്കുമ്പോൾ, അധിക ഡെമണുകൾ ആരംഭിക്കുന്നു:

• rpc.gssd - NFSv4 ഡെമൺ GSS-API (Kerberos പ്രാമാണീകരണം) വഴി പ്രാമാണീകരണ രീതികൾ നൽകുന്നു. ക്ലയന്റിലും സെർവറിലും പ്രവർത്തിക്കുന്നു.
• rpc.svcgssd - സെർവർ സൈഡ് ക്ലയന്റ് ആധികാരികത നൽകുന്ന ഒരു NFSv4 സെർവർ ഡെമൺ.

പഴയ പതിപ്പ് ഡെമണുകൾ (NFS v.3 ഉം താഴെയും):

• nfslogd - കയറ്റുമതി ചെയ്ത ഫയൽ സിസ്റ്റങ്ങൾക്കായുള്ള എൻഎഫ്എസ് ലോഗ് ഡെമൺ ലോഗ് ആക്റ്റിവിറ്റി, എൻഎഫ്എസ് സെർവറുകളിൽ പ്രവർത്തിക്കുന്നു
• rpc.rquotad - റിമോട്ട് ക്വോട്ട സെർവർ റിമോട്ട് ഫയൽ സിസ്റ്റങ്ങളിലെ ഉപയോക്തൃ ക്വാട്ടകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ നൽകുന്നു, സെർവറുകളിലും ക്ലയന്റുകളിലും പ്രവർത്തിക്കാൻ കഴിയും.

മുകളിലെ പാക്കേജുകൾക്ക് പുറമേ, NFSv2, v3 എന്നിവ ശരിയായി പ്രവർത്തിക്കുന്നതിന്, ഒരു അധിക പോർട്ട്മാപ്പ് പാക്കേജ് ആവശ്യമാണ് (പുതിയ വിതരണങ്ങളിൽ rpcbind എന്ന് പുനർനാമകരണം ചെയ്തു). ആർപിസി (റിമോട്ട് പ്രൊസീജർ കോൾ) പ്രോഗ്രാം നമ്പറുകളെ ടിസിപി/യുഡിപി പോർട്ട് നമ്പറുകളാക്കി മാറ്റുന്ന സെർവറാണ് സൺ ആർപിസി.

പോർട്ട്മാപ്പ് നിരവധി എന്റിറ്റികളിൽ പ്രവർത്തിക്കുന്നു:

• RPC കോളുകൾ അല്ലെങ്കിൽ അഭ്യർത്ഥനകൾ
• TCP/UDP പോർട്ടുകൾ, പ്രോട്ടോക്കോൾ പതിപ്പ് (tcp അല്ലെങ്കിൽ udp)
• പ്രോഗ്രാം നമ്പറുകളും പ്രോഗ്രാം പതിപ്പുകളും

NFS സേവനങ്ങൾ ആരംഭിക്കുന്നതിന് മുമ്പ് /etc/init.d/portmap സ്ക്രിപ്റ്റ് വഴി പോർട്ട്മാപ്പ് ഡെമൺ സമാരംഭിക്കുന്നു.

RPC (റിമോട്ട് പ്രൊസീജർ കോൾ) സെർവറിന്റെ ജോലി ലോക്കൽ, റിമോട്ട് പ്രോസസുകളിൽ നിന്നുള്ള RPC കോളുകൾ (RPC നടപടിക്രമങ്ങൾ എന്ന് വിളിക്കപ്പെടുന്നവ) പ്രോസസ്സ് ചെയ്യുക എന്നതാണ്. RPC കോളുകൾ ഉപയോഗിച്ച്, സേവനങ്ങൾ പോർട്ട് മാപ്പറിലേക്ക്/അതിൽ നിന്ന് സ്വയം രജിസ്റ്റർ ചെയ്യുകയോ ഇല്ലാതാക്കുകയോ ചെയ്യുന്നു (പോർട്ട്മാപ്പ്, പോർട്ട്മാപ്പർ, പുതിയ പതിപ്പുകളിൽ rpcbind എന്നും അറിയപ്പെടുന്നു), കൂടാതെ ക്ലയന്റുകൾ, RPC കോളുകൾ ഉപയോഗിച്ച്, ആവശ്യമായ വിവരങ്ങൾ ലഭിക്കുന്നതിന് പോർട്ട്മാപ്പറിന് അഭ്യർത്ഥനകൾ അയയ്ക്കുന്നു.

ഒരു RPC സെർവറിന്റെ പ്രവർത്തനത്തെ ഇനിപ്പറയുന്ന ഘട്ടങ്ങളിലൂടെ പ്രതിനിധീകരിക്കാം:

1. പോർട്ട് കൺവെർട്ടർ ആദ്യം ആരംഭിക്കണം, സാധാരണയായി സിസ്റ്റം ബൂട്ട് ചെയ്യുമ്പോൾ. ഇത് ഒരു TCP എൻഡ്‌പോയിന്റ് സൃഷ്‌ടിക്കുകയും TCP പോർട്ട് 111 തുറക്കുകയും ചെയ്യുന്നു. UDP പോർട്ട് 111-ൽ ഒരു UDP ഡാറ്റാഗ്രാം വരുന്നതിനായി കാത്തിരിക്കുന്ന ഒരു UDP എൻഡ് പോയിന്റും ഇത് സൃഷ്ടിക്കുന്നു.
2. ആരംഭത്തിൽ, ഒരു RPC സെർവറിലൂടെ പ്രവർത്തിക്കുന്ന ഒരു പ്രോഗ്രാം പ്രോഗ്രാമിന്റെ പിന്തുണയ്ക്കുന്ന ഓരോ പതിപ്പിനും ഒരു TCP എൻഡ് പോയിന്റും UDP എൻഡ് പോയിന്റും സൃഷ്ടിക്കുന്നു. (ഒരു RPC സെർവറിന് ഒന്നിലധികം പതിപ്പുകളെ പിന്തുണയ്‌ക്കാൻ കഴിയും. RPC കോൾ ചെയ്യുമ്പോൾ ക്ലയന്റ് ആവശ്യമായ പതിപ്പ് വ്യക്തമാക്കുന്നു.) സേവനത്തിന്റെ ഓരോ പതിപ്പിനും ചലനാത്മകമായി അസൈൻ ചെയ്‌ത പോർട്ട് നമ്പർ നൽകിയിരിക്കുന്നു. ഉചിതമായ RPC കോൾ ചെയ്തുകൊണ്ട് സെർവർ ഓരോ പ്രോഗ്രാമും പതിപ്പും പ്രോട്ടോക്കോളും പോർട്ട് നമ്പറും ലോഗ് ചെയ്യുന്നു.
3. RPC ക്ലയന്റ് പ്രോഗ്രാമിന് ആവശ്യമായ വിവരങ്ങൾ ലഭിക്കേണ്ടിവരുമ്പോൾ, നിർദ്ദിഷ്ട പ്രോഗ്രാം, പതിപ്പ്, പ്രോട്ടോക്കോൾ എന്നിവയ്‌ക്കായി ഡൈനാമിക് ആയി അസൈൻ ചെയ്‌ത പോർട്ട് നമ്പർ ലഭിക്കുന്നതിന് അത് പോർട്ട് റിസോൾവർ ദിനചര്യയെ വിളിക്കുന്നു.
4. ഈ അഭ്യർത്ഥനയ്ക്ക് മറുപടിയായി, വടക്കൻ ഒരു പോർട്ട് നമ്പർ നൽകുന്നു.
5. ഘട്ടം 4-ൽ ലഭിച്ച പോർട്ട് നമ്പറിലേക്ക് ക്ലയന്റ് ഒരു RPC അഭ്യർത്ഥന സന്ദേശം അയയ്‌ക്കുന്നു. UDP ഉപയോഗിക്കുകയാണെങ്കിൽ, ക്ലയന്റ് അഭ്യർത്ഥിച്ച സേവനം പ്രവർത്തിക്കുന്ന UDP പോർട്ട് നമ്പറിലേക്ക് RPC ചലഞ്ച് സന്ദേശം അടങ്ങിയ UDP ഡാറ്റാഗ്രാം അയയ്ക്കുന്നു. പ്രതികരണമായി, സേവനം ഒരു RPC പ്രതികരണ സന്ദേശം അടങ്ങിയ UDP ഡാറ്റാഗ്രാം അയയ്ക്കുന്നു. ടിസിപി ഉപയോഗിക്കുകയാണെങ്കിൽ, ക്ലയന്റ് ആവശ്യമുള്ള സേവനത്തിന്റെ ടിസിപി പോർട്ട് നമ്പറിലേക്ക് സജീവമായി തുറക്കുകയും തുടർന്ന് സ്ഥാപിതമായ കണക്ഷനിലൂടെ ഒരു ആർപിസി ചലഞ്ച് സന്ദേശം അയയ്ക്കുകയും ചെയ്യുന്നു. കണക്ഷനിൽ ഒരു RPC പ്രതികരണ സന്ദേശവുമായി സെർവർ പ്രതികരിക്കുന്നു.

RPC സെർവറിൽ നിന്ന് വിവരങ്ങൾ ലഭിക്കുന്നതിന്, rpcinfo യൂട്ടിലിറ്റി ഉപയോഗിക്കുന്നു; ഇത് രജിസ്റ്റർ ചെയ്ത പ്രോഗ്രാം നമ്പർ, പതിപ്പ്, പ്രോട്ടോക്കോൾ, പോർട്ട്, പേര് എന്നിവ പ്രദർശിപ്പിക്കുന്നു. ഒരു പ്രോഗ്രാമിന്റെ രജിസ്ട്രേഷൻ നീക്കം ചെയ്യുന്നതിനോ വ്യക്തിഗത RPC സേവനത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുന്നതിനോ നിങ്ങൾക്ക് rpcinfo ഉപയോഗിക്കാം. നിങ്ങൾ -p ഹോസ്റ്റ് പാരാമീറ്ററുകൾ വ്യക്തമാക്കുമ്പോൾ, ഹോസ്റ്റ് ഹോസ്റ്റിൽ രജിസ്റ്റർ ചെയ്ത എല്ലാ RPC പ്രോഗ്രാമുകളുടെയും ഒരു ലിസ്റ്റ് പ്രോഗ്രാം പ്രദർശിപ്പിക്കുന്നു. ഹോസ്റ്റ് വ്യക്തമാക്കാതെ, പ്രോഗ്രാം ലോക്കൽ ഹോസ്റ്റിൽ സേവനങ്ങൾ പ്രദർശിപ്പിക്കും.

NFS സെർവർ (കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, rpc.nfsd ഡെമൺ) പോർട്ട് 2049-ലെ UDP ഡാറ്റാഗ്രാമുകളുടെ രൂപത്തിൽ ക്ലയന്റിൽ നിന്ന് അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നു. NFS ഒരു പോർട്ട് റിസോൾവറിൽ പ്രവർത്തിക്കുന്നു, ഇത് ചലനാത്മകമായി അസൈൻ ചെയ്ത പോർട്ടുകൾ ഉപയോഗിക്കാൻ സെർവറിനെ അനുവദിക്കുന്നു, UDP പോർട്ട് 2049 ആണ് മിക്ക നടപ്പിലാക്കലുകളിലും NFS-ലേക്ക് ഹാർഡ്കോഡ് ചെയ്തിരിക്കുന്നു.

ഒരു NFS സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു ഫയൽ ആക്സസ് ചെയ്യുന്ന പ്രക്രിയയുടെ വിവരണം:

• ക്ലയന്റ് (ഉപയോക്തൃ പ്രോസസ്സ്) ഒരു ലോക്കൽ ഫയലാണോ NFS ഫയലാണോ ആക്സസ് ചെയ്യുന്നതെന്ന് ശ്രദ്ധിക്കുന്നില്ല. കേർണൽ മൊഡ്യൂളുകൾ അല്ലെങ്കിൽ ബിൽറ്റ്-ഇൻ സിസ്റ്റം കോളുകൾ വഴി കേർണൽ ഹാർഡ്‌വെയറുമായി സംവദിക്കുന്നു.
• ഒരു NFS ക്ലയന്റിൻറെ പ്രവർത്തനങ്ങൾ നിർവ്വഹിക്കുന്ന കേർണൽ മൊഡ്യൂൾ kernel/fs/nfs/nfs.ko, TCP/IP മൊഡ്യൂൾ വഴി NFS സെർവറിലേക്ക് RPC അഭ്യർത്ഥനകൾ അയക്കുന്നു. NFS സാധാരണയായി UDP ഉപയോഗിക്കുന്നു, എന്നിരുന്നാലും പുതിയ നടപ്പിലാക്കലുകൾ TCP ഉപയോഗിച്ചേക്കാം.
• പോർട്ട് 2049-ൽ UDP ഡാറ്റാഗ്രാമുകളായി NFS സെർവറിന് ക്ലയന്റിൽ നിന്ന് അഭ്യർത്ഥനകൾ ലഭിക്കുന്നു. NFS-ന് ഒരു പോർട്ട് റിസോൾവറിൽ പ്രവർത്തിക്കാനാകുമെങ്കിലും, ചലനാത്മകമായി അസൈൻ ചെയ്‌ത പോർട്ടുകൾ ഉപയോഗിക്കാൻ സെർവറിനെ അനുവദിക്കുന്നുണ്ടെങ്കിലും, മിക്ക നടപ്പിലാക്കലുകളിലും UDP പോർട്ട് 2049 NFS-ലേക്ക് ഹാർഡ്-കോഡ് ചെയ്തിരിക്കുന്നു.
• NFS സെർവറിന് ഒരു ക്ലയന്റിൽ നിന്ന് ഒരു അഭ്യർത്ഥന ലഭിക്കുമ്പോൾ, അത് ഒരു ലോക്കൽ ഫയൽ ആക്സസ് ദിനചര്യയിലേക്ക് കൈമാറുന്നു, അത് സെർവറിലെ ലോക്കൽ ഡിസ്കിലേക്ക് ആക്സസ് നൽകുന്നു.
• ഡിസ്ക് പ്രവേശനത്തിന്റെ ഫലം ക്ലയന്റിലേക്ക് തിരികെ നൽകുന്നു.

ഒരു NFS സെർവർ സജ്ജീകരിക്കുന്നു

സെർവർ മൊത്തത്തിൽ സജ്ജീകരിക്കുന്നത് /etc/exports ഫയലിൽ റിമോട്ട് സിസ്റ്റങ്ങൾ മൌണ്ട് ചെയ്യാൻ അനുവദിക്കുന്ന ലോക്കൽ ഡയറക്ടറികൾ സജ്ജീകരിക്കുന്നതാണ്. ഈ പ്രവർത്തനത്തെ ഡയറക്‌ടറി ശ്രേണി എക്‌സ്‌പോർട്ടിംഗ് എന്ന് വിളിക്കുന്നു. കയറ്റുമതി ചെയ്ത കാറ്റലോഗുകളെക്കുറിച്ചുള്ള വിവരങ്ങളുടെ പ്രധാന ഉറവിടങ്ങൾ ഇനിപ്പറയുന്ന ഫയലുകളാണ്:

റൂട്ട് ഫോൾഡർ ഘടന

1. എക്‌സ്‌പോർട്ട് ചെയ്‌ത ഡയറക്‌ടറികളുടെ കോൺഫിഗറേഷൻ സംഭരിക്കുന്ന പ്രധാന കോൺഫിഗറേഷൻ ഫയലാണ് /etc/exports. NFS ആരംഭിക്കുമ്പോഴും കയറ്റുമതി യൂട്ടിലിറ്റിയിലും ഉപയോഗിക്കുന്നു.
2. /var/lib/nfs/xtab - റിമോട്ട് ക്ലയന്റുകൾ മൌണ്ട് ചെയ്ത ഡയറക്ടറികളുടെ ഒരു ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു. ഒരു ക്ലയന്റ് ഒരു ശ്രേണി മൌണ്ട് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ rpc.mountd ഡെമൺ ഉപയോഗിക്കുന്നു (ഒരു മൗണ്ട് എൻട്രി സൃഷ്ടിക്കപ്പെടുന്നു).
3. /var/lib/nfs/etab - കയറ്റുമതി ചെയ്ത ഡയറക്‌ടറികളുടെ എല്ലാ പാരാമീറ്ററുകളും സൂചിപ്പിക്കുന്ന റിമോട്ട് സിസ്റ്റങ്ങൾക്ക് മൌണ്ട് ചെയ്യാവുന്ന ഡയറക്ടറികളുടെ ഒരു ലിസ്റ്റ്.
4. /var/lib/nfs/rmtab - നിലവിൽ കയറ്റുമതി ചെയ്യാത്ത ഡയറക്ടറികളുടെ ലിസ്റ്റ്.
5. /proc/fs/nfsd - NFS സെർവർ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു പ്രത്യേക ഫയൽ സിസ്റ്റം (കേർണൽ 2.6).
6. /proc/net/rpc - nfsstat ഉപയോഗിച്ചും വിവിധ കാഷെകൾ ഉപയോഗിച്ചും ലഭിക്കുന്ന അസംസ്‌കൃത സ്ഥിതിവിവരക്കണക്കുകൾ അടങ്ങിയിരിക്കുന്നു.
7. /var/run/portmap_mapping - RPC-യിൽ രജിസ്റ്റർ ചെയ്ത സേവനങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

കയറ്റുമതി ഫയൽ ഇനിപ്പറയുന്ന പൊതുവായ ഓപ്ഷനുകൾ ഉപയോഗിക്കുന്നു:

• auth_nlm (no_auth_nlm) അല്ലെങ്കിൽ safe_locks (insecure_locks) - സെർവറിന് ലോക്ക് അഭ്യർത്ഥനകളുടെ പ്രാമാണീകരണം ആവശ്യമാണെന്ന് വ്യക്തമാക്കുന്നു (NFS ലോക്ക് മാനേജർ പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച്).
• nohide (മറയ്ക്കുക) - സെർവർ രണ്ട് ഡയറക്‌ടറി ശ്രേണികൾ കയറ്റുമതി ചെയ്യുന്നുവെങ്കിൽ, മറ്റൊന്നിനുള്ളിൽ ഒരു നെസ്റ്റഡ് (മൌണ്ട് ചെയ്‌തിരിക്കുന്നു). ക്ലയന്റ് രണ്ടാമത്തെ (കുട്ടി) ശ്രേണി വ്യക്തമായി മൗണ്ട് ചെയ്യേണ്ടതുണ്ട്, അല്ലാത്തപക്ഷം ചൈൽഡ് ശ്രേണിയുടെ മൗണ്ട് പോയിന്റ് ഒരു ശൂന്യമായ ഡയറക്ടറിയായി ദൃശ്യമാകും. nohide ഐച്ഛികം ഒരു വ്യക്തമായ മൗണ്ട് ഇല്ലാതെ രണ്ടാമത്തെ ഡയറക്‌ടറി ശ്രേണിയിൽ കലാശിക്കുന്നു.
• ro - റീഡ് അഭ്യർത്ഥനകൾ മാത്രം അനുവദിക്കുന്നു.
• rw - അഭ്യർത്ഥനകൾ എഴുതാൻ അനുവദിക്കുന്നു.
• സുരക്ഷിതം (സുരക്ഷിതമല്ലാത്തത്) - സുരക്ഷിത പോർട്ടുകളിൽ നിന്ന് വരാൻ NFS അഭ്യർത്ഥനകൾ ആവശ്യമാണ് (< 1024), чтобы программа без прав root не могла монтировать иерархию каталогов.
• subtree_check (no_subtree_check) - ഫയൽ സിസ്റ്റത്തിന്റെ ഒരു ഉപഡയറക്‌ടറി എക്‌സ്‌പോർട്ട് ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, മുഴുവൻ ഫയൽ സിസ്റ്റവും അല്ല, എക്‌സ്‌പോർട്ട് ചെയ്‌ത സബ്‌ഡയറക്‌ടറിയിൽ അഭ്യർത്ഥിച്ച ഫയൽ ഉണ്ടോ എന്ന് സെർവർ പരിശോധിക്കുന്നു. സ്ഥിരീകരണം പ്രവർത്തനരഹിതമാക്കുന്നത് സുരക്ഷ കുറയ്ക്കുന്നു, പക്ഷേ ഡാറ്റ കൈമാറ്റ വേഗത വർദ്ധിപ്പിക്കുന്നു.
• sync (async) - അഭ്യർത്ഥനകൾ വരുത്തിയ മാറ്റങ്ങൾ ഡിസ്കിലേക്ക് എഴുതിയതിനുശേഷം മാത്രമേ സെർവർ അഭ്യർത്ഥനകളോട് പ്രതികരിക്കാവൂ എന്ന് വ്യക്തമാക്കുന്നു. ഡിസ്കിലേക്ക് വിവരങ്ങൾ എഴുതുന്നതിനായി കാത്തിരിക്കരുതെന്ന് അസിൻക് ഓപ്ഷൻ സെർവറിനോട് പറയുന്നു, ഇത് പ്രകടനം മെച്ചപ്പെടുത്തുന്നു, പക്ഷേ വിശ്വാസ്യത കുറയ്ക്കുന്നു, കാരണം കണക്ഷൻ തകരുകയോ ഉപകരണങ്ങൾ തകരാറിലാകുകയോ ചെയ്താൽ, വിവരങ്ങൾ നഷ്ടപ്പെടാം.
• wdelay (no_wdelay) - തുടർന്നുള്ള ഒരു റൈറ്റ് അഭ്യർത്ഥന തീർപ്പുകൽപ്പിക്കാതെ, വലിയ ബ്ലോക്കുകളിൽ ഡാറ്റ എഴുതുന്നുണ്ടെങ്കിൽ, റൈറ്റ് അഭ്യർത്ഥനകൾ നടപ്പിലാക്കുന്നത് കാലതാമസം വരുത്താൻ സെർവറിനോട് നിർദ്ദേശിക്കുന്നു. റൈറ്റ് കമാൻഡുകളുടെ വലിയ ക്യൂകൾ അയയ്ക്കുമ്പോൾ ഇത് പ്രകടനം മെച്ചപ്പെടുത്തുന്നു. no_wdelay ഒരു റൈറ്റ് കമാൻഡിന്റെ നിർവ്വഹണം വൈകിപ്പിക്കരുതെന്ന് വ്യക്തമാക്കുന്നു, സെർവറിന് ബന്ധമില്ലാത്ത ധാരാളം കമാൻഡുകൾ ലഭിക്കുകയാണെങ്കിൽ അത് ഉപയോഗപ്രദമാകും.

NFS സെർവർ മാനേജ്മെന്റ്

ഇനിപ്പറയുന്ന യൂട്ടിലിറ്റികൾ ഉപയോഗിച്ചാണ് NFS സെർവർ നിയന്ത്രിക്കുന്നത്:

• nfsstat
• കാണിക്കുക സുരക്ഷിത (സുരക്ഷിതമല്ലാത്ത)മൌണ്ട്
• കയറ്റുമതി

RPC, NFS സെർവറുകളുടെ സ്ഥിതിവിവരക്കണക്കുകൾ കാണുന്നതിന് nfsstat യൂട്ടിലിറ്റി നിങ്ങളെ അനുവദിക്കുന്നു.

ഷോമൌണ്ട്

ഷോമൗണ്ട് യൂട്ടിലിറ്റി റിമോട്ട് ഹോസ്റ്റിലെ rpc.mountd ഡെമണിൽ മൗണ്ട് ചെയ്ത ഫയൽ സിസ്റ്റങ്ങളെ കുറിച്ച് അന്വേഷിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, ക്ലയന്റുകളുടെ അടുക്കിയ ഒരു ലിസ്റ്റ് തിരികെ നൽകും. ടീമുകൾ:

• --all - ക്ലയന്റ് ഡയറക്ടറി എവിടെയാണ് മൌണ്ട് ചെയ്തതെന്ന് സൂചിപ്പിക്കുന്ന ക്ലയന്റുകളുടെയും മൗണ്ട് പോയിന്റുകളുടെയും ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്നു. ഈ വിവരങ്ങൾ വിശ്വസനീയമല്ലായിരിക്കാം.
• --directories - മൌണ്ട് പോയിന്റുകളുടെ ഒരു ലിസ്റ്റ് കാണിക്കുന്നു.
• --exports - nfsd ന്റെ വീക്ഷണകോണിൽ നിന്ന് കയറ്റുമതി ചെയ്ത ഫയൽ സിസ്റ്റങ്ങളുടെ ഒരു ലിസ്റ്റ് കാണിക്കുന്നു.

ആർഗ്യുമെന്റുകളില്ലാതെ ഷോമൗണ്ട് പ്രവർത്തിപ്പിക്കുന്നത് ലോക്കൽ ഡയറക്‌ടറികൾ മൗണ്ട് ചെയ്യാൻ അനുവദിച്ചിരിക്കുന്ന സിസ്റ്റങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്യും.

കയറ്റുമതി

ഈ കമാൻഡ് /etc/exports ഫയലിൽ വ്യക്തമാക്കിയിട്ടുള്ള എക്‌സ്‌പോർട്ട് ചെയ്ത ഡയറക്ടറികൾ /var/lib/nfs/xtab ഫയലുമായി സമന്വയിപ്പിക്കുകയും xtab-ൽ നിന്ന് നിലവിലില്ലാത്ത ഡയറക്ടറികൾ നീക്കം ചെയ്യുകയും ചെയ്യുന്നു. -r ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് nfsd ഡെമൺ ആരംഭിക്കുമ്പോൾ exportfs എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു. 2.6 കേർണൽ മോഡിലുള്ള എക്സ്പോർട്ട്ഫ്സ് യൂട്ടിലിറ്റി /var/lib/nfs/ ഡയറക്ടറിയിലെ ഫയലുകൾ വഴി rpc.mountd ഡെമണുമായി ആശയവിനിമയം നടത്തുന്നു, കേർണലുമായി നേരിട്ട് ആശയവിനിമയം നടത്തുന്നില്ല. പരാമീറ്ററുകൾ ഇല്ലാതെ, നിലവിൽ കയറ്റുമതി ചെയ്ത ഫയൽ സിസ്റ്റങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്നു. കയറ്റുമതി പാരാമീറ്ററുകൾ:

1. [client:directory-name] - നിർദ്ദിഷ്ട ക്ലയന്റിനായി നിർദ്ദിഷ്ട ഫയൽ സിസ്റ്റം ചേർക്കുക അല്ലെങ്കിൽ നീക്കം ചെയ്യുക)
2. -v - കൂടുതൽ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുക
3. -r - എല്ലാ ഡയറക്ടറികളും വീണ്ടും കയറ്റുമതി ചെയ്യുക (/etc/exports ഒപ്പം /var/lib/nfs/xtab സമന്വയിപ്പിക്കുക)
4. -u - കയറ്റുമതി ചെയ്തവയുടെ പട്ടികയിൽ നിന്ന് നീക്കം ചെയ്യുക
5. -a - എല്ലാ ഫയൽ സിസ്റ്റങ്ങളും ചേർക്കുക അല്ലെങ്കിൽ നീക്കം ചെയ്യുക
6. -o - കോമകളാൽ വേർതിരിച്ച ഓപ്‌ഷനുകൾ (/etc/exports-ൽ ഉപയോഗിക്കുന്ന ഓപ്‌ഷനുകൾക്ക് സമാനമാണ്; അതായത്, ഇതിനകം മൌണ്ട് ചെയ്‌തിരിക്കുന്ന ഫയൽ സിസ്റ്റങ്ങളുടെ ഓപ്ഷനുകൾ നിങ്ങൾക്ക് മാറ്റാവുന്നതാണ്)
7. -i - ചേർക്കുമ്പോൾ /etc/exports ഉപയോഗിക്കരുത്, നിലവിലുള്ള കമാൻഡ് ലൈൻ ഓപ്ഷനുകൾ മാത്രം
8. -f - കേർണൽ 2.6-ൽ എക്സ്പോർട്ട് ചെയ്ത സിസ്റ്റങ്ങളുടെ ലിസ്റ്റ് പുനഃസജ്ജമാക്കുക.

മൗണ്ട് കമാൻഡ് ഉപയോഗിച്ച് നെറ്റ്‌വർക്ക് ഫയലുകൾ സിസ്റ്റം മൗണ്ട് ചെയ്യുന്നു

ഡെബിയനിൽ ഒരു NFS ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യുന്നതിനുള്ള മൗണ്ട് കമാൻഡിന്റെ ഒരു ഉദാഹരണം:

ഫയലുകൾ~# mount -t nfs ആർക്കൈവ്:/archiv-small /archivs/archiv-smallഫയലുകൾ~# മൗണ്ട് -t nfs -o ro ആർക്കൈവ്:/archiv-big /archivs/archiv-bigഫയലുകൾ ~ # മൗണ്ട് ....... archiv:/archiv-small on /archivs/archiv-small type nfs (rw,addr=10.0.0.6) archiv:/archiv-big on /archivs/archiv-big ടൈപ്പ് nfs (ro,addr=10.0.0.6)

ആദ്യത്തെ കമാൻഡ്, ആർക്കൈവ് സെർവറിലെ എക്‌സ്‌പോർട്ടുചെയ്‌ത /ആർക്കൈവ്-സ്മോൾ ഡയറക്‌ടറിയെ ഡിഫോൾട്ട് ഓപ്‌ഷനുകളോടെ (അതായത്, റീഡ്-റൈറ്റ്) ലോക്കൽ മൗണ്ട് പോയിന്റിലേക്ക് /archivs/archiv-small-ലേക്ക് മൗണ്ട് ചെയ്യുന്നു. രണ്ടാമത്തെ കമാൻഡ്, ആർക്കൈവ് സെർവറിൽ എക്‌സ്‌പോർട്ട് ചെയ്‌ത ഡയറക്‌ടറി /archiv-big റീഡ്-ഓൺലി (ro) ഓപ്‌ഷൻ ഉപയോഗിച്ച് ലോക്കൽ ഡയറക്‌ടറി /archivs/archiv-big-ലേക്ക് മൗണ്ട് ചെയ്യുന്നു. പരാമീറ്ററുകളില്ലാത്ത മൗണ്ട് കമാൻഡ് മൗണ്ടിംഗിന്റെ ഫലം വ്യക്തമായി കാണിക്കുന്നു. NFS മൌണ്ട് ചെയ്യുമ്പോൾ റീഡ്-ഒൺലി (ro) ഓപ്ഷന് പുറമേ, മറ്റ് അടിസ്ഥാന ഓപ്‌ഷനുകളും സജ്ജീകരിക്കാൻ സാധിക്കും:

• nosuid - ഈ ഐച്ഛികം മൌണ്ട് ചെയ്ത ഡയറക്ടറിയിൽ നിന്നും സെറ്റ്യൂഡ് പ്രോഗ്രാമുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിൽ നിന്നും തടയുന്നു.
• nodev (ഉപകരണമില്ല) - ഈ ഐച്ഛികം പ്രതീകം ഉപയോഗിക്കുന്നത് നിരോധിക്കുകയും പ്രത്യേക ഫയലുകൾ ഉപകരണങ്ങളായി തടയുകയും ചെയ്യുന്നു.
• ലോക്ക് (nolock) - NFS ലോക്കിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നു (സ്ഥിരസ്ഥിതി). nolock NFS ലോക്കിംഗ് പ്രവർത്തനരഹിതമാക്കുന്നു (ലോക്ക് ചെയ്ത ഡെമൺ ആരംഭിക്കുന്നില്ല) കൂടാതെ NFS ലോക്കിംഗിനെ പിന്തുണയ്ക്കാത്ത പഴയ സെർവറുകളിൽ പ്രവർത്തിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.
• mounthost=name - NFS മൗണ്ട് ഡെമൺ - mountd - പ്രവർത്തിക്കുന്ന ഹോസ്റ്റിന്റെ പേര്.
• mountport=n - മൗണ്ടഡ് ഡെമൺ ഉപയോഗിക്കുന്ന പോർട്ട്.
• port=n - NFS സെർവറിലേക്ക് കണക്റ്റുചെയ്യാൻ ഉപയോഗിക്കുന്ന പോർട്ട് (ആർപിസി സെർവറിൽ rpc.nfsd ഡെമൺ രജിസ്റ്റർ ചെയ്തിട്ടില്ലെങ്കിൽ സ്ഥിരസ്ഥിതി 2049 ആണ്). n=0 (സ്ഥിരസ്ഥിതി) ആണെങ്കിൽ, പോർട്ട് നിർണ്ണയിക്കാൻ NFS സെർവറിലെ പോർട്ട്മാപ്പിനെ അന്വേഷിക്കുന്നു.
• rsize=n (ബ്ലോക്ക് വലുപ്പം വായിക്കുക - ബ്ലോക്ക് വലുപ്പം വായിക്കുക) - NFS സെർവറിൽ നിന്ന് ഒരു സമയം വായിക്കുന്ന ബൈറ്റുകളുടെ എണ്ണം. സ്റ്റാൻഡേർഡ് - 4096.
• wsize=n (ബ്ലോക്ക് വലുപ്പം എഴുതുക - ബ്ലോക്ക് വലുപ്പം എഴുതുക) - NFS സെർവറിലേക്ക് ഒരു സമയം എഴുതിയ ബൈറ്റുകളുടെ എണ്ണം. സ്റ്റാൻഡേർഡ് - 4096.
• tcp അല്ലെങ്കിൽ udp - NFS മൌണ്ട് ചെയ്യുന്നതിന്, യഥാക്രമം TCP അല്ലെങ്കിൽ UDP പ്രോട്ടോക്കോൾ ഉപയോഗിക്കുക.
• bg - നിങ്ങൾക്ക് സെർവറിലേക്കുള്ള ആക്സസ് നഷ്ടപ്പെടുകയാണെങ്കിൽ, സിസ്റ്റം ബൂട്ട് പ്രക്രിയ തടയാതിരിക്കാൻ പശ്ചാത്തലത്തിൽ വീണ്ടും ശ്രമിക്കുക.
• fg - നിങ്ങൾക്ക് സെർവറിലേക്കുള്ള ആക്സസ് നഷ്ടപ്പെടുകയാണെങ്കിൽ, മുൻഗണനാ മോഡിൽ വീണ്ടും ശ്രമിക്കുക. മൌണ്ട് ശ്രമങ്ങൾ ആവർത്തിച്ച് സിസ്റ്റം ബൂട്ട് പ്രക്രിയ തടയാൻ ഈ ഐച്ഛികത്തിന് കഴിയും. ഇക്കാരണത്താൽ, fg പരാമീറ്റർ പ്രാഥമികമായി ഡീബഗ്ഗിംഗിനായി ഉപയോഗിക്കുന്നു.
• NFS മൗണ്ടുകളിലെ ആട്രിബ്യൂട്ട് കാഷിംഗിനെ ബാധിക്കുന്ന ഓപ്ഷനുകൾ
• പരിഷ്‌ക്കരണ സമയം, വലുപ്പം, ഹാർഡ് ലിങ്കുകൾ, ഉടമസ്ഥൻ തുടങ്ങിയ ഐനോഡുകളിൽ (ഇനോഡുകളിൽ) സംഭരിച്ചിരിക്കുന്ന ഫയൽ ആട്രിബ്യൂട്ടുകൾ സാധാരണ ഫയലുകൾക്കായി അപൂർവ്വമായി മാറുകയും ഡയറക്‌ടറികൾക്കായി വളരെ കുറച്ച് തവണ മാറുകയും ചെയ്യുന്നു. കാഷെയിലെ പരിഷ്‌ക്കരണ സമയവും ഫയലിന്റെ തന്നെ പരിഷ്‌ക്കരണ സമയവും താരതമ്യം ചെയ്ത് കാഷെ കാലഹരണപ്പെട്ടതാണോ എന്ന് നിർണ്ണയിക്കാൻ ഒരു ഫയലിന്റെ പരിഷ്‌ക്കരണ സമയം കേർണൽ ഉപയോഗിക്കുന്നു.

നിർദ്ദിഷ്ട പാരാമീറ്ററുകൾക്ക് അനുസൃതമായി ആട്രിബ്യൂട്ട് കാഷെ ആനുകാലികമായി അപ്ഡേറ്റ് ചെയ്യുന്നു:

1. ac (noac) (ആട്രിബ്യൂട്ട് കാഷെ - ആട്രിബ്യൂട്ട് കാഷിംഗ്) - ആട്രിബ്യൂട്ട് കാഷിംഗ് അനുവദിക്കുന്നു (സ്ഥിരസ്ഥിതിയായി). noac ഓപ്ഷൻ സെർവറിനെ മന്ദഗതിയിലാക്കുന്നുവെങ്കിലും, ഒന്നിലധികം ക്ലയന്റുകൾ ഒരു പൊതു ശ്രേണിയിലേക്ക് വിവരങ്ങൾ സജീവമായി എഴുതുമ്പോൾ അത് ആട്രിബ്യൂട്ട് സ്തംഭനാവസ്ഥ ഒഴിവാക്കുന്നു.
2. acdirmax=n (ആട്രിബ്യൂട്ട് കാഷെ ഡയറക്‌ടറി ഫയൽ പരമാവധി - ഒരു ഡയറക്‌ടറി ഫയലിനുള്ള പരമാവധി ആട്രിബ്യൂട്ട് കാഷിംഗ്) - ഡയറക്‌ടറി ആട്രിബ്യൂട്ടുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് NFS കാത്തിരിക്കുന്ന പരമാവധി സെക്കന്റുകൾ (സ്ഥിരസ്ഥിതി 60 സെ.)
3. acdirmin=n (ആട്രിബ്യൂട്ട് കാഷെ ഡയറക്‌ടറി ഫയൽ മിനിമം - ഒരു ഡയറക്‌ടറി ഫയലിനുള്ള ഏറ്റവും കുറഞ്ഞ ആട്രിബ്യൂട്ട് കാഷിംഗ്) - ഡയറക്‌ടറി ആട്രിബ്യൂട്ടുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് NFS കാത്തിരിക്കുന്ന ഏറ്റവും കുറഞ്ഞ സെക്കന്റുകൾ (സ്ഥിരസ്ഥിതി 30 സെ.)
4. acregmax=n (ആട്രിബ്യൂട്ട് കാഷെ റെഗുലർ ഫയൽ പരമാവധി - ഒരു സാധാരണ ഫയലിനുള്ള പരമാവധി ആട്രിബ്യൂട്ട് കാഷിംഗ്) - ഒരു സാധാരണ ഫയലിന്റെ ആട്രിബ്യൂട്ടുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് NFS കാത്തിരിക്കുന്ന പരമാവധി സെക്കൻഡ് (സ്ഥിരസ്ഥിതി 60 സെ.)
5. acregmin=n (ആട്രിബ്യൂട്ട് കാഷെ റെഗുലർ ഫയൽ മിനിമം - ഒരു സാധാരണ ഫയലിനുള്ള ഏറ്റവും കുറഞ്ഞ ആട്രിബ്യൂട്ട് കാഷിംഗ്) - ഒരു സാധാരണ ഫയലിന്റെ ആട്രിബ്യൂട്ടുകൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് NFS കാത്തിരിക്കുന്ന ഏറ്റവും കുറഞ്ഞ സെക്കൻഡ് (സ്ഥിരസ്ഥിതി 3 സെക്കൻഡ്)
6. actimeo=n (ആട്രിബ്യൂട്ട് കാഷെ ടൈംഔട്ട്) - മുകളിലുള്ള എല്ലാ ഓപ്‌ഷനുകൾക്കുമുള്ള മൂല്യങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നു. ആക്ടിമിയോ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, മുകളിലുള്ള മൂല്യങ്ങൾ സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ എടുക്കും.

NFS പിശക് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഓപ്ഷനുകൾ

സെർവറിൽ നിന്ന് പ്രതികരണം ഇല്ലാതിരിക്കുമ്പോഴോ I/O പിശകുകൾ സംഭവിക്കുമ്പോഴോ NFS എന്താണ് ചെയ്യുന്നതെന്ന് ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ നിയന്ത്രിക്കുന്നു:

• fg (bg) (ഫോർഗ്രൗണ്ട് - ഫോർഗ്രൗണ്ട്, ബാക്ക്ഗ്രൗണ്ട് - ബാക്ക്ഗ്രൗണ്ട്) - ഫോർഗ്രൗണ്ട്/പശ്ചാത്തലത്തിൽ പരാജയപ്പെട്ട NFS മൌണ്ട് ചെയ്യാനുള്ള ശ്രമങ്ങൾ.
• ഹാർഡ് (സോഫ്റ്റ്) - ഒരു ടൈംഔട്ട് എത്തുമ്പോൾ, മൗണ്ട് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ കൺസോളിലേക്ക് "സെർവർ പ്രതികരിക്കുന്നില്ല" എന്ന സന്ദേശം പ്രദർശിപ്പിക്കുന്നു. സോഫ്റ്റ് ഓപ്‌ഷൻ വ്യക്തമാക്കുമ്പോൾ, സമയപരിധി സമയത്ത്, ഓപ്പറേഷനെ വിളിച്ച പ്രോഗ്രാമിലേക്ക് ഒരു I/O പിശക് റിപ്പോർട്ട് ചെയ്യുന്നു.
• nointr (intr) (തടസ്സമില്ല) - ഒരു വലിയ സമയപരിധിയിൽ എത്തുമ്പോൾ, ഹാർഡ്-മൌണ്ടഡ് ഡയറക്‌ടറി ശ്രേണിയിലെ ഫയൽ പ്രവർത്തനങ്ങളെ തടസ്സപ്പെടുത്തുന്നതിൽ നിന്ന് സിഗ്നലുകളെ തടയുന്നു. intr - തടസ്സം സാധ്യമാക്കുന്നു.
• retrans=n (retransmission value) - n ചെറിയ ടൈംഔട്ടുകൾക്ക് ശേഷം, NFS ഒരു വലിയ ടൈംഔട്ട് ഉണ്ടാക്കുന്നു (സ്ഥിരസ്ഥിതി 3). ഹാർഡ്/സോഫ്റ്റ് ഓപ്‌ഷൻ വ്യക്തമാക്കിയിട്ടുണ്ടോ എന്നതിനെ ആശ്രയിച്ച്, ഒരു വലിയ സമയപരിധി പ്രവർത്തനങ്ങൾ നിർത്തുകയോ കൺസോളിലേക്ക് "സെർവർ പ്രതികരിക്കുന്നില്ല" എന്ന സന്ദേശം പ്രിന്റ് ചെയ്യുകയോ ചെയ്യുന്നു.
• retry=n (വീണ്ടും ശ്രമിക്കൂ മൂല്യം) - ഉപേക്ഷിക്കുന്നതിന് മുമ്പ് NFS സേവനം മൌണ്ട് പ്രവർത്തനങ്ങൾ ആവർത്തിക്കുന്ന മിനിറ്റുകളുടെ എണ്ണം (സ്ഥിരസ്ഥിതി 10000).
• timeo=n (ടൈമൗട്ട് മൂല്യം) - RPC അല്ലെങ്കിൽ ഒരു ചെറിയ ടൈംഔട്ട് (സ്ഥിരസ്ഥിതി 7) ആണെങ്കിൽ വീണ്ടും പ്രക്ഷേപണം ചെയ്യുന്നതിന് മുമ്പ് NFS സേവനം കാത്തിരിക്കുന്ന സെക്കൻഡിന്റെ പത്തിലൊന്ന്. ഈ മൂല്യം ഓരോ ടൈംഔട്ടിലും പരമാവധി 60 സെക്കൻഡ് വരെ അല്ലെങ്കിൽ ഒരു വലിയ ടൈംഔട്ട് സംഭവിക്കുന്നത് വരെ വർദ്ധിക്കുന്നു. നെറ്റ്‌വർക്ക് തിരക്കിലാണെങ്കിൽ, സെർവർ മന്ദഗതിയിലാണെങ്കിൽ, അല്ലെങ്കിൽ അഭ്യർത്ഥന ഒന്നിലധികം റൂട്ടറുകളിലൂടെയോ ഗേറ്റ്‌വേകളിലൂടെയോ പോകുകയാണെങ്കിൽ, ഈ മൂല്യം വർദ്ധിപ്പിക്കുന്നത് പ്രകടനം മെച്ചപ്പെടുത്തിയേക്കാം.

മെച്ചപ്പെട്ട NFS പ്രകടനം

NFS പ്രകടനത്തെ പല പാരാമീറ്ററുകൾ ബാധിക്കാം, പ്രത്യേകിച്ച് സ്ലോ കണക്ഷനുകളിൽ പ്രവർത്തിക്കുമ്പോൾ. വേഗത കുറഞ്ഞതും ഉയർന്ന ലോഡുചെയ്തതുമായ കണക്ഷനുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, ഹാർഡ് പാരാമീറ്റർ ഉപയോഗിക്കുന്നതാണ് ഉചിതം, അതിനാൽ സമയപരിധികൾ പ്രോഗ്രാമുകൾ പ്രവർത്തിക്കുന്നത് നിർത്തുന്നതിന് കാരണമാകില്ല. എന്നാൽ നിങ്ങൾ fstab വഴി ഹാർഡ് പാരാമീറ്റർ ഉപയോഗിച്ച് NFS വഴി ഒരു ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യുകയും റിമോട്ട് ഹോസ്റ്റ് ലഭ്യമല്ലെങ്കിൽ, ബൂട്ട് ചെയ്യുമ്പോൾ സിസ്റ്റം മരവിപ്പിക്കുകയും ചെയ്യുമെന്ന് നിങ്ങൾ അറിഞ്ഞിരിക്കണം.

NFS പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനുള്ള ഒരു മാർഗ്ഗം ഒരു സമയം കൈമാറ്റം ചെയ്യപ്പെടുന്ന ബൈറ്റുകളുടെ എണ്ണം വർദ്ധിപ്പിക്കുക എന്നതാണ്. ആധുനിക ഫാസ്റ്റ് കണക്ഷനുകൾക്ക് 4096 ബൈറ്റുകളുടെ വലുപ്പം വളരെ ചെറുതാണ്, ഈ മൂല്യം 8192 അല്ലെങ്കിൽ അതിൽ കൂടുതലായി വർദ്ധിപ്പിക്കുന്നത് ഒപ്റ്റിമൽ വേഗത കണ്ടെത്തുന്നതിന് പരീക്ഷണാത്മകമായി കണ്ടെത്താനാകും.

കൂടാതെ, കാലഹരണപ്പെടൽ ക്രമീകരണങ്ങൾ നിങ്ങൾ അവഗണിക്കരുത്. ടൈംയോ ഓപ്‌ഷനിൽ പറഞ്ഞിരിക്കുന്ന സമയത്തേക്ക് ഡാറ്റാ കൈമാറ്റത്തിനുള്ള പ്രതികരണത്തിനായി NFS കാത്തിരിക്കുന്നു; ഈ സമയത്തിനുള്ളിൽ ഒരു പ്രതികരണം ലഭിച്ചില്ലെങ്കിൽ, ഒരു പുനഃസംപ്രേഷണം നടത്തുന്നു. തിരക്കേറിയതും വേഗത കുറഞ്ഞതുമായ കണക്ഷനുകളിൽ, ഈ സമയം സെർവറിന്റെ പ്രതികരണ സമയത്തേക്കാളും ആശയവിനിമയ ചാനൽ ശേഷിയേക്കാളും കുറവായിരിക്കാം, ഇത് അനാവശ്യമായ പുനഃസംപ്രേക്ഷണങ്ങൾ പ്രകടനത്തെ മന്ദഗതിയിലാക്കുന്നു. ഡിഫോൾട്ടായി, ടൈംയോ 0.7 സെക്കൻഡ് (700 മില്ലിസെക്കൻഡ്) ആണ്. 700 ms-നുള്ളിൽ കണക്ഷൻ തടസ്സപ്പെട്ടുവെന്ന് കണ്ടെത്തിയതിന് ശേഷം, സെർവർ വീണ്ടും സംപ്രേക്ഷണം ചെയ്യുകയും കാത്തിരിപ്പ് സമയം 1.4 സെക്കൻഡിലേക്ക് ഇരട്ടിയാക്കുകയും ചെയ്യും, സമയത്തിന്റെ വർദ്ധനവ് പരമാവധി മൂല്യമായ 60 സെക്കൻഡിൽ തുടരും.

അധ്യായം 29 NFS: നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം

ആമുഖം

ഈ അധ്യായത്തിൽ, ക്ലയന്റ് ആപ്ലിക്കേഷനുകൾക്ക് ഫയലുകളിലേക്ക് സുതാര്യമായ പ്രവേശനം നൽകുന്ന ഒരു ജനപ്രിയ ആപ്ലിക്കേഷനായ നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം (NFS) നോക്കാം. NFS-ന്റെ മൂലക്കല്ല് Sun RPC: റിമോട്ട് പ്രൊസീജർ കോൾ ആണ്, അത് ഞങ്ങൾ ആദ്യം കവർ ചെയ്യും.

NFS പ്രയോജനപ്പെടുത്തുന്നതിന് ക്ലയന്റ് പ്രോഗ്രാമിന് പ്രത്യേക ഉപകരണങ്ങൾ ആവശ്യമില്ല. ഫയൽ ഒരു NFS സെർവറിലാണെന്ന് കേർണൽ കണ്ടെത്തുകയും ഫയൽ ആക്സസ് ചെയ്യുന്നതിനായി ഒരു RPC കോൾ സ്വയമേവ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു.

ഫയൽ ആക്സസ് എങ്ങനെ നടപ്പിലാക്കുന്നു എന്നതിനെക്കുറിച്ച് ഞങ്ങൾ വിശദമായി നോക്കില്ല, എന്നാൽ ഇന്റർനെറ്റ് പ്രോട്ടോക്കോളുകൾ എങ്ങനെ ഉപയോഗിക്കുന്നു, പ്രത്യേകിച്ച് യുഡിപി.

സൺ റിമോട്ട് പ്രൊസീജർ കോൾ

മിക്ക കേസുകളിലും, നിർദ്ദിഷ്ട നെറ്റ്‌വർക്ക് പ്രവർത്തനങ്ങൾ നടത്താൻ സിസ്റ്റം നൽകുന്ന ഫംഗ്ഷനുകളെ വിളിക്കുന്ന ആപ്ലിക്കേഷൻ പ്രോഗ്രാമുകൾ എഴുതുന്നതിലൂടെ നെറ്റ്‌വർക്ക് പ്രോഗ്രാമിംഗ് പ്രശ്നങ്ങൾ പരിഹരിക്കപ്പെടുന്നു. ഉദാഹരണത്തിന്, ഒരു ഫംഗ്‌ഷൻ സജീവമായ TCP ഓപ്പൺ ചെയ്യുന്നു, മറ്റൊന്ന് ഒരു നിഷ്ക്രിയ TCP ഓപ്പൺ ചെയ്യുന്നു, മൂന്നാമത്തേത് TCP കണക്ഷനിലൂടെ ഡാറ്റ അയയ്‌ക്കുന്നു, നാലാമത്തേത് നിർദ്ദിഷ്ട പ്രോട്ടോക്കോൾ ഓപ്ഷനുകൾ സജ്ജമാക്കുന്നു (TCP "സ്‌റ്റേ ലൈവ്" ടൈമർ പ്രവർത്തനക്ഷമമാക്കുന്നു) തുടങ്ങിയവ. അദ്ധ്യായം 1-ലെ ആപ്ലിക്കേഷൻ പ്രോഗ്രാമിംഗ് ഇന്റർഫേസുകളുടെ വിഭാഗത്തിൽ, രണ്ട് ജനപ്രിയ നെറ്റ്‌വർക്ക് പ്രോഗ്രാമിംഗ് ഫംഗ്‌ഷനുകൾ (അപ്ലിക്കേഷൻ പ്രോഗ്രാമിംഗ് ഇന്റർഫേസുകൾ, API-കൾ) ഉണ്ടെന്ന് ഞങ്ങൾ സൂചിപ്പിച്ചു: സോക്കറ്റുകൾ, TLI. ക്ലയന്റ് ഉപയോഗിക്കുന്ന എപിഐയും സെർവർ ഉപയോഗിക്കുന്ന എപിഐയും വ്യത്യസ്തമാകാം, ക്ലയന്റും സെർവറും പ്രവർത്തിപ്പിക്കുന്ന ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ പോലെ. ഒരു പ്രത്യേക ക്ലയന്റിന് സെർവറുമായി ആശയവിനിമയം നടത്താൻ കഴിയുമോ എന്ന് നിർണ്ണയിക്കുന്നത് ആശയവിനിമയവും ആപ്ലിക്കേഷൻ പ്രോട്ടോക്കോളുകളും ആണ്. പ്രോഗ്രാമിംഗ് ഇന്റർഫേസായി സോക്കറ്റുകളും TCP കമ്മ്യൂണിക്കേഷൻ പ്രോട്ടോക്കോളും ഉപയോഗിച്ച് C യിൽ എഴുതിയിരിക്കുന്ന ഒരു Unix ക്ലയന്റ്, രണ്ട് ഹോസ്റ്റുകളും നെറ്റ്‌വർക്കിലേക്ക് കണക്റ്റുചെയ്‌തിരിക്കുകയും രണ്ടും TCP നടപ്പിലാക്കിയിരിക്കുകയും ചെയ്താൽ, COBOL-ൽ എഴുതിയിരിക്കുന്ന ഒരു മെയിൻഫ്രെയിം സെർവറുമായി ആശയവിനിമയം നടത്താനാകും. /IP.

സാധാരണഗതിയിൽ, ക്ലയന്റ് സെർവറിലേക്ക് കമാൻഡുകൾ അയയ്ക്കുന്നു, കൂടാതെ സെർവർ ക്ലയന്റിലേക്ക് പ്രതികരണങ്ങൾ അയയ്ക്കുന്നു. ഞങ്ങൾ അവലോകനം ചെയ്ത എല്ലാ ആപ്ലിക്കേഷനുകളും - Ping, Traceroute, റൂട്ടിംഗ് ഡെമണുകൾ, DNS ക്ലയന്റുകളും സെർവറുകളും, TFTP, BOOTP, SNMP, Telnet, FTP, SMTP - എല്ലാം ഈ രീതിയിൽ നിർമ്മിച്ചതാണ്.

RPC, റിമോട്ട് പ്രൊസീജർ കോൾ, നെറ്റ്‌വർക്ക് പ്രോഗ്രാമിംഗിൽ വ്യത്യസ്തമായ ഒരു സമീപനം നടപ്പിലാക്കുന്നു. ക്ലയന്റ് പ്രോഗ്രാം സെർവർ പ്രോഗ്രാമിലെ ഫംഗ്ഷനുകളെ വിളിക്കുന്നു. അതിനാൽ ഇത് പ്രോഗ്രാമറുടെ വീക്ഷണകോണിൽ നിന്നാണ് തീരുമാനിക്കുന്നത്, എന്നാൽ വാസ്തവത്തിൽ ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങളുടെ ക്രമം നടക്കുന്നു.

1. ഒരു ക്ലയന്റ് ഒരു റിമോട്ട് നടപടിക്രമം വിളിക്കുമ്പോൾ, RPC പാക്കറ്റ് ജനറേറ്റ് ചെയ്യുന്ന ലോക്കൽ ഹോസ്റ്റിലെ ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നു. ഈ പ്രവർത്തനത്തെ ക്ലയന്റ് സ്റ്റബ് എന്ന് വിളിക്കുന്നു. ക്ലയന്റ് സ്റ്റബ് നടപടിക്രമത്തിന്റെ ആർഗ്യുമെന്റുകൾ ഒരു നെറ്റ്‌വർക്ക് സന്ദേശത്തിലേക്ക് പാക്കേജുചെയ്യുകയും സന്ദേശം സെർവറിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു.
2. സെർവർ ഹോസ്റ്റിലെ സെർവർ സ്റ്റബിന് നെറ്റ്‌വർക്ക് സന്ദേശം ലഭിക്കുന്നു. നെറ്റ്‌വർക്ക് സന്ദേശത്തിൽ നിന്ന് ആർഗ്യുമെന്റുകൾ വീണ്ടെടുക്കുകയും ആപ്ലിക്കേഷൻ പ്രോഗ്രാമർ എഴുതിയ സെർവർ നടപടിക്രമത്തിലേക്ക് ഒരു കോൾ നടത്തുകയും ചെയ്യുന്നു.
3. സെർവർ ഫംഗ്‌ഷൻ സെർവർ സ്റ്റബിലേക്ക് നിയന്ത്രണം നൽകുന്നു, അത് ലഭിച്ച മൂല്യങ്ങൾ എടുക്കുകയും അവയെ ഒരു നെറ്റ്‌വർക്ക് സന്ദേശമാക്കി പാക്കേജുചെയ്യുകയും സന്ദേശം ക്ലയന്റ് സ്റ്റബിലേക്ക് തിരികെ അയയ്ക്കുകയും ചെയ്യുന്നു.
4. ക്ലയന്റ് സ്റ്റബ് ഒരു നെറ്റ്‌വർക്ക് സന്ദേശത്തിൽ നിന്ന് ക്ലയന്റ് ആപ്ലിക്കേഷനിലേക്ക് മൂല്യങ്ങൾ നൽകുന്നു.

അപൂർണ്ണങ്ങളും ലൈബ്രറി RPC ദിനചര്യകളും ഉപയോഗിക്കുന്ന നെറ്റ്‌വർക്ക് പ്രോഗ്രാമിംഗ് API-കൾ (സോക്കറ്റുകൾ അല്ലെങ്കിൽ TLI) ഉപയോഗിക്കുന്നു, എന്നാൽ ഉപയോക്തൃ ആപ്ലിക്കേഷനുകൾ (ക്ലയന്റ് പ്രോഗ്രാമും സെർവർ നടപടിക്രമങ്ങളും) ഒരിക്കലും API-ലേക്ക് ആക്‌സസ്സ് ചെയ്യില്ല. RPC പാക്കേജ്, ക്ലയന്റ് സ്റ്റബ്, സെർവർ സ്റ്റബ് എന്നിവയാൽ എല്ലാ നിർവ്വഹണ വിശദാംശങ്ങളും മറച്ചിരിക്കുമ്പോൾ, ക്ലയന്റ് ആപ്ലിക്കേഷന് സെർവർ നടപടിക്രമം മാത്രം വിളിക്കേണ്ടതുണ്ട്.

RPC പാക്കറ്റുകൾക്ക് ഇനിപ്പറയുന്ന ഗുണങ്ങളുണ്ട്.

• നെറ്റ്‌വർക്ക് പ്രോഗ്രാമിംഗ് പ്രശ്നങ്ങൾ പരിഹരിക്കേണ്ടതില്ല എന്നതിനാൽ പ്രോഗ്രാമിംഗ് എളുപ്പമാകും (നിങ്ങൾ അങ്ങനെ ചെയ്യുകയാണെങ്കിൽ, ഇത് വളരെ കുറവാണ്). ക്ലയന്റ് വിളിക്കുന്ന ക്ലയന്റ് പ്രോഗ്രാമും സെർവർ നടപടിക്രമങ്ങളും ആപ്ലിക്കേഷൻ പ്രോഗ്രാമർമാർ എഴുതുന്നു.
• UDP പോലെയുള്ള വിശ്വസനീയമല്ലാത്ത ഒരു പ്രോട്ടോക്കോൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, എല്ലാ വിശദാംശങ്ങളും, അതായത് സമയപരിധിയും പുനഃസംപ്രേഷണവും, RPC പാക്കറ്റ് കൈകാര്യം ചെയ്യുന്നു. ഇത് ഉപയോക്തൃ ആപ്ലിക്കേഷനെ ലളിതമാക്കുന്നു.
• ആർഗ്യുമെന്റുകളുടെയും റിട്ടേൺ മൂല്യങ്ങളുടെയും ആവശ്യമായ പരിവർത്തനം RPC ലൈബ്രറി കൈകാര്യം ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ആർഗ്യുമെന്റുകളിൽ പൂർണ്ണസംഖ്യകളും ഫ്ലോട്ടിംഗ്-പോയിന്റ് നമ്പറുകളും അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ക്ലയന്റിലും സെർവറിലുമുള്ള പൂർണ്ണസംഖ്യകളുടെയും ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകളുടെയും പ്രാതിനിധ്യം തമ്മിലുള്ള എന്തെങ്കിലും വ്യത്യാസങ്ങൾ RPC പാക്കേജ് കൈകാര്യം ചെയ്യും. വൈവിധ്യമാർന്ന പരിതസ്ഥിതികളിൽ പ്രവർത്തിക്കുന്നതിന് ക്ലയന്റുകളുടെയും സെർവറുകളുടെയും നടപ്പാക്കൽ ഇത് ലളിതമാക്കുന്നു.

ആർ‌പി‌സി പ്രോഗ്രാമിംഗ് അദ്ധ്യായം 18 ൽ വിശദമായി ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. സൺ ആർപിസിയും ഓപ്പൺ സോഫ്റ്റ്‌വെയർ ഫൗണ്ടേഷന്റെ (ഒഎസ്‌എഫ്) ഡിസ്ട്രിബ്യൂട്ടഡ് കമ്പ്യൂട്ടിംഗ് എൻവയോൺമെന്റിലെ (ഡിസിഇ) ആർപിസി പാക്കേജുമാണ് ഏറ്റവും പ്രചാരമുള്ള രണ്ട് ആർപിസി പാക്കേജുകൾ. നടപടിക്രമത്തെ എങ്ങനെയാണ് വിളിക്കുന്നത്, റിട്ടേൺ സന്ദേശം എങ്ങനെയാണെന്നും ഇത് എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നുവെന്നും ഞങ്ങൾ പരിശോധിക്കും. സൺ RPC പാക്കേജിലേക്ക്, കാരണം നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റത്തിൽ ഉപയോഗിക്കുന്നത് ഈ പാക്കേജാണ്.Sun RPC പതിപ്പ് 2 RFC 1057 [Sun Microsystems 1988a] ൽ വിവരിച്ചിരിക്കുന്നു.

രണ്ട് തരത്തിലുള്ള സൺ ആർപിസി ഉണ്ട്. സോക്കറ്റ് API ഉപയോഗിച്ചാണ് ഒരു പതിപ്പ് നിർമ്മിച്ചിരിക്കുന്നത് കൂടാതെ TCP, UDP എന്നിവയിൽ പ്രവർത്തിക്കുന്നു. മറ്റൊന്ന് ടിഐ-ആർപിസി (ട്രാൻസ്പോർട്ട് ഇൻഡിപെൻഡന്റ്) എന്ന് വിളിക്കുന്നു, ഇത് ടിഎൽഐ എപിഐ ഉപയോഗിച്ച് നിർമ്മിച്ചതും കേർണൽ നൽകുന്ന ഏതെങ്കിലും ട്രാൻസ്പോർട്ട് ലെയറുകളിൽ പ്രവർത്തിക്കുന്നു. ഞങ്ങളുടെ കാഴ്ചപ്പാടിൽ, അവ തമ്മിൽ വ്യത്യാസമില്ല, കാരണം ഈ അധ്യായത്തിൽ ഞങ്ങൾ TCP, UDP എന്നിവ മാത്രമേ പരിഗണിക്കൂ.

UDP ഉപയോഗിച്ചുള്ള ഒരു RPC നടപടിക്രമ കോൾ സന്ദേശത്തിന്റെ ഫോർമാറ്റ് ചിത്രം 29.1 കാണിക്കുന്നു.

ചിത്രം 29.1 യുഡിപി ഡാറ്റാഗ്രാം ഫോർമാറ്റിലുള്ള ആർപിസി നടപടിക്രമ കോൾ സന്ദേശങ്ങൾ.

സ്റ്റാൻഡേർഡ് ഐപി, യുഡിപി തലക്കെട്ടുകൾ നേരത്തെ കാണിച്ചിരിക്കുന്നു (ചിത്രം 3.1, ചിത്രം 11.2). UDP തലക്കെട്ട് പിന്തുടരുന്ന എല്ലാം RPC പാക്കറ്റാണ് നിർണ്ണയിക്കുന്നത്.

ഇടപാട് ഐഡന്റിഫയർ (XID - ട്രാൻസാക്ഷൻ ഐഡി) ക്ലയന്റ് സെറ്റ് ചെയ്യുകയും സെർവർ തിരികെ നൽകുകയും ചെയ്യുന്നു. ക്ലയന്റിന് ഒരു പ്രതികരണം ലഭിക്കുമ്പോൾ, അത് അയച്ച അഭ്യർത്ഥനയുടെ XID-മായി സെർവർ നൽകുന്ന XID താരതമ്യം ചെയ്യുന്നു. അവ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ക്ലയന്റ് സന്ദേശം നിരസിക്കുകയും അടുത്തത് വരുന്നതിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു. ഓരോ തവണയും ക്ലയന്റ് ഒരു പുതിയ RPC ഇഷ്യൂ ചെയ്യുമ്പോൾ, അത് XID മാറ്റുന്നു. എന്നിരുന്നാലും, ക്ലയന്റ് ആർപിസി വീണ്ടും പ്രക്ഷേപണം ചെയ്താൽ (പ്രതികരണമൊന്നും ലഭിച്ചില്ലെങ്കിൽ), XID മാറില്ല.

കോൾ വേരിയബിൾ ഒരു കോളിന് 0 ഉം പ്രതികരണത്തിന് 1 ഉം ആണ്. നിലവിലെ RPC പതിപ്പ് 2 ആണ്. അടുത്ത മൂന്ന് വേരിയബിളുകൾ, പ്രോഗ്രാം നമ്പർ, പതിപ്പ് നമ്പർ, നടപടിക്രമ നമ്പർ എന്നിവ സെർവറിൽ വിളിക്കേണ്ട നിർദ്ദിഷ്ട നടപടിക്രമം തിരിച്ചറിയുക.

ക്രെഡൻഷ്യലുകൾ ഉപഭോക്താവിനെ തിരിച്ചറിയുന്നു. ചില ഉദാഹരണങ്ങളിൽ ഈ ഫീൽഡ് ശൂന്യമായി അവശേഷിക്കുന്നു, മറ്റുള്ളവയിൽ ഉപയോക്താവിന്റെ ഡിജിറ്റൽ ഐഡന്റിഫയറും അവൻ ഉൾപ്പെടുന്ന ഗ്രൂപ്പ് ഐഡന്റിഫയറും നിങ്ങൾക്ക് കാണാൻ കഴിയും. സെർവറിന് ക്രെഡൻഷ്യലുകൾ പരിശോധിച്ച് അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യണോ വേണ്ടയോ എന്ന് തീരുമാനിക്കാം. ഡിഇഎസ് എൻക്രിപ്ഷൻ ഉപയോഗിക്കുന്ന സെക്യുർ ആർപിസിക്ക് വെരിഫയർ ഉപയോഗിക്കുന്നു. അധികാരവും മൂല്യനിർണ്ണയ ഫീൽഡുകളും വേരിയബിൾ-ലെങ്ത്ത് ഫീൽഡുകളാണെങ്കിലും, അവയുടെ ദൈർഘ്യം ഫീൽഡിന്റെ ഭാഗമായി കടന്നുപോകുന്നു.

അടുത്തത് നടപടിക്രമ പാരാമീറ്ററുകളാണ്. ആപ്ലിക്കേഷൻ വിദൂര നടപടിക്രമത്തെ എങ്ങനെ നിർവചിക്കുന്നു എന്നതിനെ ആശ്രയിച്ചിരിക്കും അവയുടെ ഫോർമാറ്റ്. റിസീവർ (സെർവർ സ്റ്റബ്) പാരാമീറ്ററുകളുടെ വലുപ്പം എങ്ങനെ അറിയും? UDP ഉപയോഗിക്കുന്നതിനാൽ, ചെക്ക് ഫീൽഡ് വരെയുള്ള എല്ലാ ഫീൽഡുകളുടെയും ദൈർഘ്യം മൈനസ് UDP ഡാറ്റാഗ്രാമിന്റെ വലുപ്പമായി പരാമീറ്ററുകളുടെ വലുപ്പം കണക്കാക്കാം. UDP-ക്ക് പകരം TCP ഉപയോഗിക്കുമ്പോൾ, ഒരു നിശ്ചിത ദൈർഘ്യം എന്ന ആശയം ഇല്ല, കാരണം TCP എന്നത് റെക്കോർഡ് ഡിലിമിറ്ററുകൾ ഇല്ലാത്ത ബൈറ്റുകളുടെ ഒരു സ്ട്രീം ആണ്. അത്തരമൊരു സാഹചര്യത്തിൽ, TCP ഹെഡറിനും XID നും ഇടയിൽ ഒരു 4-ബൈറ്റ് ദൈർഘ്യമുള്ള ഫീൽഡ് ദൃശ്യമാകുന്നു, അതിൽ നിന്ന് റിസീവർ RPC കോളിന്റെ ദൈർഘ്യം ബൈറ്റുകളിൽ മനസ്സിലാക്കുന്നു. ആവശ്യമെങ്കിൽ ഒന്നിലധികം TCP സെഗ്‌മെന്റുകളിലൂടെ RPC കോൾ സന്ദേശം അയയ്ക്കാൻ ഇത് അനുവദിക്കുന്നു. (DNS സമാനമായ ഒരു സാങ്കേതികത ഉപയോഗിക്കുന്നു; അധ്യായം 14 ലെ വ്യായാമം 4.)

ചിത്രം 29.2 RPC പ്രതികരണ ഫോർമാറ്റ് കാണിക്കുന്നു. റിമോട്ട് നടപടിക്രമം പുറത്തുകടക്കുമ്പോൾ സെർവർ സ്റ്റബിൽ നിന്ന് ക്ലയന്റ് സ്റ്റബിലേക്ക് അയയ്‌ക്കും.

ചിത്രം 29.2 യുഡിപി ഡാറ്റാഗ്രാമായി ആർപിസി നടപടിക്രമ പ്രതികരണ സന്ദേശ ഫോർമാറ്റ്.

കോൾ XID പ്രതികരണം XID-ലേക്ക് പകർത്തിയതാണ്. മറുപടി ഫീൽഡിൽ 1 അടങ്ങിയിരിക്കുന്നു, ഈ ഫീൽഡ് ഒരു വെല്ലുവിളിയും പ്രതികരണവും തമ്മിൽ വേർതിരിക്കുന്നു. കോൾ സന്ദേശം സ്വീകരിച്ചിട്ടുണ്ടെങ്കിൽ സ്റ്റാറ്റസ് ഫീൽഡിൽ ഒരു അസാധുവായ മൂല്യം അടങ്ങിയിരിക്കുന്നു. (ആർ‌പി‌സി പതിപ്പ് നമ്പർ 2 അല്ലെങ്കിലോ സെർ‌വറിന് ക്ലയന്റിനെ ആധികാരികമാക്കാൻ കഴിയുന്നില്ലെങ്കിലോ സന്ദേശം നിരസിച്ചേക്കാം.) സെർവറിനെ സൂചിപ്പിക്കാൻ സുരക്ഷിത ആർ‌പി‌സിയുടെ കാര്യത്തിൽ വെരിഫയർ ഫീൽഡ് ഉപയോഗിക്കുന്നു.

എല്ലാം ശരിയാണെങ്കിൽ സ്വീകരിക്കുക സ്റ്റാറ്റസ് ഫീൽഡിൽ പൂജ്യം മൂല്യം അടങ്ങിയിരിക്കുന്നു. പൂജ്യമല്ലാത്ത മൂല്യം സൂചിപ്പിക്കാം, ഉദാഹരണത്തിന്, തെറ്റായ പതിപ്പ് നമ്പർ അല്ലെങ്കിൽ തെറ്റായ നടപടിക്രമ നമ്പർ. UDP-യ്‌ക്ക് പകരം TCP ഉപയോഗിക്കുകയാണെങ്കിൽ, RPC ചലഞ്ച് സന്ദേശം പോലെ, TCP ഹെഡറിനും XID-നും ഇടയിൽ 4-ബൈറ്റ് ദൈർഘ്യമുള്ള ഫീൽഡ് അയയ്‌ക്കും.

XDR: ബാഹ്യ ഡാറ്റ പ്രാതിനിധ്യം

ആർ‌പി‌സി കോൾ, പ്രതികരണ സന്ദേശങ്ങളിലെ മൂല്യങ്ങൾ എൻ‌കോഡ് ചെയ്യുന്നതിന് ഉപയോഗിക്കുന്ന ഒരു സ്റ്റാൻഡേർഡാണ് എക്‌സ്‌റ്റേണൽ ഡാറ്റ റെപ്രസന്റേഷൻ (എക്‌സ്‌ഡിആർ) - ആർ‌പി‌സി ഹെഡർ ഫീൽഡുകൾ (എക്‌സ്‌ഐ‌ഡി, പ്രോഗ്രാം നമ്പർ, സ്റ്റാറ്റസ് സ്വീകരിക്കുക മുതലായവ), നടപടിക്രമ പാരാമീറ്ററുകൾ, നടപടിക്രമ ഫലങ്ങൾ. ഡാറ്റ എൻകോഡ് ചെയ്യുന്നതിനുള്ള ഒരു സ്റ്റാൻഡേർഡ് മാർഗം, വ്യത്യസ്തമായ ഒരു ആർക്കിടെക്ചർ ഉള്ള ഒരു സിസ്റ്റത്തിൽ ഒരു പ്രൊസീജിയർ കോൾ ചെയ്യാൻ ഒരു ക്ലയന്റിനെ അനുവദിക്കുന്നു. RFC 1014 [Sun Microsystems 1987] ൽ XDR നിർവചിച്ചിരിക്കുന്നു.

ഒരു RPC സന്ദേശത്തിൽ (ബിറ്റ് ഓർഡർ, ബൈറ്റ് ഓർഡർ മുതലായവ) ഒരു നിശ്ചിത എണ്ണം ഡാറ്റ തരങ്ങളും അവ കൊണ്ടുപോകുന്ന കൃത്യമായ രീതിയും XDR നിർവചിക്കുന്നു. അയച്ചയാൾ RPC സന്ദേശം XDR ഫോർമാറ്റിൽ നിർമ്മിക്കണം, തുടർന്ന് സ്വീകർത്താവ് XDR ഫോർമാറ്റിനെ യഥാർത്ഥ പ്രാതിനിധ്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. (അവന്റെ സിസ്റ്റത്തിനായി സ്വീകരിച്ച ഫോർമാറ്റിൽ.) ഉദാഹരണമായി, ഞങ്ങൾ കാണിച്ചിരിക്കുന്ന എല്ലാ പൂർണ്ണസംഖ്യ മൂല്യങ്ങളും (XID, കോൾ, പ്രോഗ്രാം നമ്പർ, അങ്ങനെ പലതും) 4-ബൈറ്റ് പൂർണ്ണസംഖ്യകളാണെന്ന് ഞങ്ങൾ കാണുന്നു, ഉദാഹരണത്തിന്, ചിത്രം 29.1, 29.2 എന്നിവയിൽ . തീർച്ചയായും, XDR-ലെ എല്ലാ പൂർണ്ണസംഖ്യകളും 4 ബൈറ്റുകൾ ഉൾക്കൊള്ളുന്നു. ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ, ബൂളിയൻ, ഫ്ലോട്ടിംഗ് പോയിന്റ്, ഫിക്സഡ്-ലെങ്ത്ത് അറേകൾ, വേരിയബിൾ-ലെങ്ത്ത് അറേകൾ, ഘടനകൾ എന്നിവയുൾപ്പെടെയുള്ള മറ്റ് ഡാറ്റാ തരങ്ങളെ XDR പിന്തുണയ്ക്കുന്നു.

പോർട്ട് പാലിക്കൽ

വിദൂര നടപടിക്രമങ്ങൾ ഉൾക്കൊള്ളുന്ന ആർപിസി സെർവർ പ്രോഗ്രാമുകൾ മുൻകൂട്ടി അറിയാവുന്ന പോർട്ടുകളേക്കാൾ ചലനാത്മകമായി അസൈൻ ചെയ്ത പോർട്ടുകൾ ഉപയോഗിക്കുന്നു. ഏത് ആർ‌പി‌സി പ്രോഗ്രാമാണ് ഡൈനാമിക് ആയി അസൈൻ ചെയ്‌തിരിക്കുന്ന പോർട്ട് ഉപയോഗിക്കുന്നത് എന്ന് എപ്പോഴും അറിയുന്നതിന് ഇതിന് ചില തരത്തിലുള്ള "ലോഗിംഗ്" ആവശ്യമാണ്. സൺ ആർപിസിയിൽ ഈ ലോഗറിനെ പോർട്ട് മാപ്പർ എന്ന് വിളിക്കുന്നു. (ആർപിസി പ്രോഗ്രാം നമ്പറുകളെ DARPA പ്രോട്ടോക്കോൾ പോർട്ട് നമ്പറുകളാക്കി മാറ്റുന്ന ഒരു സെർവറാണ് പോർട്ട് മാപ്പർ. ഒരു RPC കോൾ ചെയ്യാൻ ഈ സെർവർ പ്രവർത്തിക്കണം.)

പേരിൽ "പോർട്ട്" എന്ന പദം ടിസിപി, യുഡിപി പോർട്ട് നമ്പറുകളിൽ നിന്നാണ് വന്നത്, ഇന്റർനെറ്റ് പ്രോട്ടോക്കോൾ കുടുംബത്തിന്റെ സവിശേഷതകൾ. ടി‌സി‌പി, യു‌ഡി‌പി എന്നിവ മാത്രമല്ല, ടി‌ഐ-ആർ‌പി‌സി ഏത് ട്രാൻസ്‌പോർട്ട് ലെയറുകളിലും പ്രവർത്തിക്കുന്നതിനാൽ, ടിഐ-ആർ‌പി‌സി (ഉദാഹരണത്തിന് എസ്‌വി‌ആർ 4, ​​സോളാരിസ് 2.2) ഉപയോഗിക്കുന്ന സിസ്റ്റങ്ങളിലെ പോർട്ട് മാപ്പർ എന്ന പേര് rpcbind ആയി പരിവർത്തനം ചെയ്‌തു. എന്നിരുന്നാലും, ഞങ്ങൾ കൂടുതൽ പരിചിതമായ പോർട്ട് മാപ്പർ ഉപയോഗിക്കുന്നത് തുടരും.

വാസ്തവത്തിൽ, പോർട്ട് റിസോൾവറിന് തന്നെ അറിയപ്പെടുന്ന ഒരു പോർട്ട് ഉണ്ടായിരിക്കണം: UDP പോർട്ട് 111, TCP പോർട്ട് 111. പോർട്ട് റിസോൾവർ ഒരു RPC സെർവർ പ്രോഗ്രാം മാത്രമാണ്. ഇതിന് ഒരു പ്രോഗ്രാം നമ്പർ (100000), പതിപ്പ് നമ്പർ (2), TCP പോർട്ട് 111, UDP പോർട്ട് 111 എന്നിവയുണ്ട്. RPC കോളുകൾ ഉപയോഗിച്ച് പോർട്ട് റിസോൾവറിൽ സെർവറുകൾ പരസ്പരം രജിസ്റ്റർ ചെയ്യുന്നു, കൂടാതെ ക്ലയന്റുകൾ RPC കോളുകൾ ഉപയോഗിച്ച് പോർട്ട് റിസോൾവറിനോട് അഭ്യർത്ഥിക്കുന്നു. പോർട്ട് റിസോൾവർ നാല് സെർവർ നടപടിക്രമങ്ങൾ നൽകുന്നു:

1. PMAPPROC_SET. പോർട്ട് റിസോൾവറിൽ പ്രോഗ്രാം നമ്പർ, പതിപ്പ് നമ്പർ, പ്രോട്ടോക്കോൾ എന്നിവ രജിസ്റ്റർ ചെയ്യാൻ സ്റ്റാർട്ടപ്പിൽ RPC സെർവർ വിളിക്കുന്നു.
2. PMAPPROC_UNSET. മുമ്പ് രജിസ്റ്റർ ചെയ്ത പരിവർത്തനം നീക്കം ചെയ്യാൻ സെർവർ വിളിച്ചു.
3. PMAPPROC_GETPORT. തന്നിരിക്കുന്ന പ്രോഗ്രാം നമ്പർ, പതിപ്പ് നമ്പർ, പ്രോട്ടോക്കോൾ എന്നിവയ്‌ക്കായുള്ള പോർട്ട് നമ്പർ ലഭിക്കുന്നതിന് സ്റ്റാർട്ടപ്പിൽ RPC ക്ലയന്റ് വിളിക്കുന്നു.
4. PMAPPROC_DUMP. പോർട്ട് റിസോൾവർ ഡാറ്റാബേസിലേക്ക് എല്ലാ ഇനങ്ങളും (പ്രോഗ്രാം നമ്പർ, പതിപ്പ് നമ്പർ, പ്രോട്ടോക്കോൾ, പോർട്ട് നമ്പർ) നൽകുന്നു.

RPC സെർവർ പ്രോഗ്രാം ആരംഭിക്കുമ്പോൾ, പിന്നീട് RPC ക്ലയന്റ് പ്രോഗ്രാം വിളിക്കുമ്പോൾ, ഇനിപ്പറയുന്ന ഘട്ടങ്ങൾ സംഭവിക്കുന്നു.

1. പോർട്ട് കൺവെർട്ടർ ആദ്യം ആരംഭിക്കണം, സാധാരണയായി സിസ്റ്റം ബൂട്ട് ചെയ്യുമ്പോൾ. ഇത് ഒരു TCP എൻഡ്‌പോയിന്റ് സൃഷ്‌ടിക്കുകയും TCP പോർട്ട് 111 നിഷ്ക്രിയമായി തുറക്കുകയും ചെയ്യുന്നു. UDP പോർട്ട് 111-ൽ ഒരു UDP ഡാറ്റഗ്രാം വരുന്നതിനായി കാത്തിരിക്കുന്ന ഒരു UDP എൻഡ്‌പോയിന്റും ഇത് സൃഷ്ടിക്കുന്നു.
2. RPC സെർവർ പ്രോഗ്രാം ആരംഭിക്കുമ്പോൾ, പ്രോഗ്രാമിന്റെ പിന്തുണയ്ക്കുന്ന ഓരോ പതിപ്പിനും ഒരു TCP എൻഡ് പോയിന്റും UDP എൻഡ് പോയിന്റും സൃഷ്ടിക്കുന്നു. (ഒരു RPC പ്രോഗ്രാമിന് ഒന്നിലധികം പതിപ്പുകളെ പിന്തുണയ്‌ക്കാൻ കഴിയും. സെർവർ നടപടിക്രമത്തിലേക്ക് വിളിക്കുമ്പോൾ ക്ലയന്റ് ആവശ്യമായ പതിപ്പ് വ്യക്തമാക്കുന്നു.) ഓരോ എൻഡ്‌പോയിന്റിനും ചലനാത്മകമായി അസൈൻ ചെയ്‌ത പോർട്ട് നമ്പർ നൽകിയിരിക്കുന്നു. (ടിസിപി, യുഡിപി പോർട്ട് നമ്പറുകൾ ഒന്നാണോ വ്യത്യസ്തമാണോ എന്നതിൽ വ്യത്യാസമില്ല.) PMAPPROC_SET പോർട്ട് റിസോൾവർ പ്രൊസീജറിലേക്ക് ഒരു റിമോട്ട് കോൾ ചെയ്തുകൊണ്ട് സെർവർ ഓരോ പ്രോഗ്രാമും പതിപ്പും പ്രോട്ടോക്കോളും പോർട്ട് നമ്പറും രജിസ്റ്റർ ചെയ്യുന്നു.
3. RPC ക്ലയന്റ് പ്രോഗ്രാം ആരംഭിക്കുമ്പോൾ, നിർദ്ദിഷ്ട പ്രോഗ്രാം, പതിപ്പ്, പ്രോട്ടോക്കോൾ എന്നിവയ്‌ക്കായി ഡൈനാമിക്കായി അസൈൻ ചെയ്‌ത പോർട്ട് നമ്പർ ലഭിക്കുന്നതിന് അത് പോർട്ട് റിസോൾവർ നടപടിക്രമത്തെ PMAPPROC_GETPORT എന്ന് വിളിക്കുന്നു.
4. ഘട്ടം 3-ൽ ലഭിച്ച പോർട്ട് നമ്പറിലേക്ക് ക്ലയന്റ് ഒരു RPC ചലഞ്ച് സന്ദേശം അയയ്‌ക്കുന്നു. UDP ഉപയോഗിക്കുകയാണെങ്കിൽ, ക്ലയന്റ് സെർവറിന്റെ UDP പോർട്ട് നമ്പറിലേക്ക് RPC ചലഞ്ച് സന്ദേശം (ചിത്രം 29.1) അടങ്ങുന്ന ഒരു UDP ഡാറ്റാഗ്രാം അയയ്ക്കുന്നു. പ്രതികരണമായി, സെർവർ ഒരു RPC പ്രതികരണ സന്ദേശം അടങ്ങിയ UDP ഡാറ്റാഗ്രാം അയയ്ക്കുന്നു (ചിത്രം 29.2). TCP ഉപയോഗിക്കുകയാണെങ്കിൽ, ക്ലയന്റ് സെർവറിന്റെ TCP പോർട്ട് നമ്പറിലേക്ക് സജീവമായി തുറക്കുകയും തുടർന്ന് കണക്ഷനിലൂടെ ഒരു RPC വെല്ലുവിളി സന്ദേശം അയയ്ക്കുകയും ചെയ്യുന്നു. കണക്ഷനിൽ ഒരു RPC പ്രതികരണ സന്ദേശവുമായി സെർവർ പ്രതികരിക്കുന്നു.

rpcinfo(8) പ്രോഗ്രാം നിലവിലുള്ള എല്ലാ പോർട്ട് മാപ്പർ ക്രമീകരണങ്ങളും പ്രിന്റ് ചെയ്യുന്നു. (ഇവിടെയാണ് പോർട്ട് മാപ്പർ ദിനചര്യ PMAPPROC_DUMP എന്ന് വിളിക്കുന്നത്.) സാധാരണ ഔട്ട്പുട്ട് താഴെ കാണിച്ചിരിക്കുന്നു:

സൂര്യൻ% /usr/etc/rpcinfo -p
പ്രോഗ്രാം വേഴ്സസ് പ്രോട്ടോ പോർട്ട്
100005 1 tcp 702 മൗണ്ട് NFS മൗണ്ട് ഡെമൺ
100005 1 udp 699 മൗണ്ട് ചെയ്തു
100005 2 ടിസിപി 702 മൌണ്ട് ചെയ്തു
100005 2 udp 699 മൗണ്ട് ചെയ്തു

100003 2 udp 2049 nfs NFS തന്നെ

100021 1 tcp 709 nlockmgr NFS ലോക്ക് മാനേജർ
100021 1 udp 1036 nlockmgr
100021 2 tcp 721 nlockmgr
100021 2 udp 1039 nlockmgr
100021 3 tcp 713 nlockmgr
100021 3 udp 1037 nlockmgr

ചില പ്രോഗ്രാമുകൾ ഒന്നിലധികം പതിപ്പുകളെ പിന്തുണയ്ക്കുന്നതായി ഞങ്ങൾ കാണുന്നു, കൂടാതെ പ്രോഗ്രാം നമ്പർ, പതിപ്പ് നമ്പർ, പ്രോട്ടോക്കോൾ എന്നിവയുടെ ഓരോ കോമ്പിനേഷനും അതിന്റേതായ പോർട്ട് നമ്പർ ലേഔട്ട് ഉണ്ട്, അത് ഒരു പോർട്ട് റിസോൾവർ നൽകുന്നു.

മൗണ്ടിംഗ് ഡെമണിന്റെ രണ്ട് പതിപ്പുകളും ഒരേ TCP പോർട്ട് നമ്പറിലൂടെയും (702) ഒരേ UDP പോർട്ട് നമ്പറിലൂടെയും (699) ആക്‌സസ് ചെയ്യാൻ കഴിയും, എന്നിരുന്നാലും ബ്ലോക്കിംഗ് മാനേജറിന്റെ ഓരോ പതിപ്പിനും അതിന്റേതായ പോർട്ട് നമ്പർ ഉണ്ട്.

NFS പ്രോട്ടോക്കോൾ

NFS ക്ലയന്റുകൾക്ക് സെർവറിന്റെ ഫയലുകളിലേക്കും ഫയൽ സിസ്റ്റത്തിലേക്കും സുതാര്യമായ പ്രവേശനം നൽകുന്നു. ഇത് ഫയൽ കൈമാറ്റം നൽകുന്ന FTP (അധ്യായം 27) ൽ നിന്ന് വ്യത്യസ്തമാണ്. FTP ഉപയോഗിച്ച്, ഒരു പൂർണ്ണമായ ഫയൽ പകർപ്പ് നടപ്പിലാക്കുന്നു. ഒരു പ്രോസസ്സ് ആക്‌സസ് ചെയ്‌ത ഫയലിന്റെ ഭാഗങ്ങൾ മാത്രമേ NFS ആക്‌സസ്സുചെയ്യുകയുള്ളൂ, മാത്രമല്ല NFS-ന്റെ പ്രധാന നേട്ടം ഈ ആക്‌സസ് സുതാര്യമാക്കുന്നു എന്നതാണ്. ഒരു ലോക്കൽ ഫയലിൽ പ്രവർത്തിക്കാൻ കഴിയുന്ന ഏതൊരു ക്ലയന്റ് ആപ്ലിക്കേഷനും പ്രോഗ്രാമിൽ തന്നെ മാറ്റങ്ങളൊന്നും വരുത്താതെ തന്നെ ഒരു NFS ഫയലിൽ എളുപ്പത്തിൽ പ്രവർത്തിക്കാൻ കഴിയുമെന്നാണ് ഇതിനർത്ഥം.

Sun RPC ഉപയോഗിച്ച് നിർമ്മിച്ച ഒരു ക്ലയന്റ്-സെർവർ ആപ്ലിക്കേഷനാണ് NFS. സെർവറിലേക്ക് RPC അഭ്യർത്ഥനകൾ അയച്ചുകൊണ്ട് NFS ക്ലയന്റുകൾ NFS സെർവറിൽ ഫയലുകൾ ആക്സസ് ചെയ്യുന്നു. സാധാരണ ഉപയോക്തൃ പ്രക്രിയകൾ ഉപയോഗിച്ച് ഇത് നടപ്പിലാക്കാൻ കഴിയും - അതായത്, NFS ക്ലയന്റ് സെർവറിലേക്ക് നിർദ്ദിഷ്ട RPC കോളുകൾ ചെയ്യുന്ന ഒരു ഉപയോക്തൃ പ്രക്രിയയായിരിക്കാം, അത് ഒരു ഉപയോക്തൃ പ്രക്രിയയും ആകാം. എന്നിരുന്നാലും, NFS സാധാരണയായി രണ്ട് കാരണങ്ങളാൽ വ്യത്യസ്തമായി നടപ്പിലാക്കുന്നു. ആദ്യം, NFS ഫയലുകളിലേക്കുള്ള ആക്സസ് ക്ലയന്റിന് സുതാര്യമായിരിക്കണം. അതിനാൽ, ക്ലയന്റിന്റെ ഉപയോക്തൃ പ്രക്രിയയെ പ്രതിനിധീകരിച്ച് ക്ലയന്റ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം NFS ക്ലയന്റ് കോളുകൾ ചെയ്യുന്നു. രണ്ടാമതായി, സെർവർ കാര്യക്ഷമത മെച്ചപ്പെടുത്തുന്നതിനായി ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിനുള്ളിൽ NFS സെർവറുകൾ നടപ്പിലാക്കുന്നു. NFS സെർവർ ഒരു ഉപയോക്തൃ പ്രോസസ്സ് ആണെങ്കിൽ, എല്ലാ ക്ലയന്റ് അഭ്യർത്ഥനകൾക്കും സെർവർ പ്രതികരണത്തിനും (വായിക്കാനോ എഴുതാനോ ഉള്ള ഡാറ്റ ഉൾപ്പെടെ) കേർണലിനും ഉപയോക്തൃ പ്രക്രിയയ്ക്കും ഇടയിലുള്ള ഒരു സെപ്പറേറ്ററിലൂടെ കടന്നുപോകേണ്ടതുണ്ട്, ഇത് സാധാരണയായി വളരെ ചെലവേറിയതാണ്.

ഈ വിഭാഗത്തിൽ, RFC 1094 [Sun Microsystems 1988b]-ൽ രേഖപ്പെടുത്തിയിരിക്കുന്ന NFS-ന്റെ പതിപ്പ് 2 നോക്കാം. Sun RPC, XDR, NFS എന്നിവയുടെ മികച്ച വിവരണം [X/Open 1991] ൽ നൽകിയിരിക്കുന്നു. NFS ഉപയോഗത്തിന്റെയും അഡ്മിനിസ്ട്രേഷന്റെയും വിശദാംശങ്ങൾ [Stern 1991] ൽ നൽകിയിരിക്കുന്നു. NFS പ്രോട്ടോക്കോൾ പതിപ്പ് 3 സ്പെസിഫിക്കേഷനുകൾ 1993-ൽ നടപ്പിലാക്കി, അത് ഈ അധ്യായത്തിന്റെ ഒരു വിഭാഗത്തിൽ നമ്മൾ ചർച്ച ചെയ്യും.

ചിത്രം 29.3 സാധാരണ NFS ക്ലയന്റ്, NFS സെർവർ ക്രമീകരണങ്ങൾ കാണിക്കുന്നു. ഈ ചിത്രത്തിൽ, നിങ്ങൾ ഇനിപ്പറയുന്നവ ശ്രദ്ധിക്കേണ്ടതുണ്ട്.

1. ഒരു ലോക്കൽ ഫയലാണോ NFS ഫയലാണോ ആക്‌സസ് ചെയ്യുന്നതെന്ന് ക്ലയന്റ് ശ്രദ്ധിക്കുന്നില്ല. ഫയൽ തുറക്കുമ്പോൾ കേർണൽ ഇത് കണ്ടെത്തുന്നു. ഫയൽ തുറന്ന ശേഷം, കേർണൽ ലോക്കൽ ഫയലുകളിലേക്കുള്ള എല്ലാ ആക്സസ്സും "ലോക്കൽ ഫയൽ ആക്സസ്" എന്ന് ലേബൽ ചെയ്ത ബോക്സിലേക്ക് കടത്തിവിടുന്നു, കൂടാതെ NFS ഫയലുകളിലേക്കുള്ള എല്ലാ ലിങ്കുകളും "NFS ക്ലയന്റ്" ബോക്സിലേക്ക് കൈമാറും.
2. NFS ക്ലയന്റ് TCP/IP മൊഡ്യൂൾ വഴി NFS സെർവറിലേക്ക് RPC അഭ്യർത്ഥനകൾ അയയ്ക്കുന്നു. NFS സാധാരണയായി UDP ഉപയോഗിക്കുന്നു, എന്നിരുന്നാലും പുതിയ നടപ്പിലാക്കലുകൾ TCP ഉപയോഗിച്ചേക്കാം.
3. പോർട്ട് 2049-ൽ UDP ഡാറ്റാഗ്രാമുകളായി NFS സെർവറിന് ക്ലയന്റിൽ നിന്ന് അഭ്യർത്ഥനകൾ ലഭിക്കുന്നു. NFS-ന് ഒരു പോർട്ട് റിസോൾവറിൽ പ്രവർത്തിക്കാനാകുമെങ്കിലും, ചലനാത്മകമായി അസൈൻ ചെയ്‌ത പോർട്ടുകൾ ഉപയോഗിക്കാൻ സെർവറിനെ അനുവദിക്കുന്നുണ്ടെങ്കിലും, മിക്ക നടപ്പിലാക്കലുകളിലും UDP പോർട്ട് 2049 NFS-ലേക്ക് ഹാർഡ്-കോഡ് ചെയ്തിരിക്കുന്നു.

ചിത്രം 29.3 സാധാരണ NFS ക്ലയന്റും NFS സെർവർ സജ്ജീകരണങ്ങളും.

NFS സെർവറിന് ഒരു ക്ലയന്റിൽ നിന്ന് ഒരു അഭ്യർത്ഥന ലഭിക്കുമ്പോൾ, അത് ഒരു ലോക്കൽ ഫയൽ ആക്സസ് ദിനചര്യയിലേക്ക് കൈമാറുന്നു, അത് സെർവറിലെ ലോക്കൽ ഡിസ്കിലേക്ക് ആക്സസ് നൽകുന്നു.

ക്ലയന്റ് അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് സെർവർ സമയമെടുത്തേക്കാം. ലോക്കൽ ഫയൽ സിസ്റ്റം ആക്സസ് ചെയ്യാൻ പോലും കുറച്ച് സമയമെടുത്തേക്കാം. ഈ സമയത്ത്, സെർവർ മറ്റ് ക്ലയന്റുകളിൽ നിന്നുള്ള അഭ്യർത്ഥനകൾ തടയാൻ ആഗ്രഹിക്കുന്നില്ല. ഈ സാഹചര്യത്തെ നേരിടാൻ, മിക്ക NFS സെർവറുകളും ഒന്നിലധികം തവണ ആരംഭിക്കുന്നു, അതായത് കേർണലിനുള്ളിൽ ഒന്നിലധികം NFS സെർവറുകൾ ഉണ്ട്. നിർദ്ദിഷ്ട പരിഹാര രീതികൾ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ആശ്രയിച്ചിരിക്കുന്നു. മിക്ക Unix കേർണലുകളും ഒന്നിലധികം NFS സെർവറുകൾ "ലൈവ്" ചെയ്യുന്നില്ല, പകരം ഒന്നിലധികം ഉപയോക്തൃ പ്രക്രിയകൾ (സാധാരണയായി nfsd എന്ന് വിളിക്കുന്നു) ആരംഭിക്കുന്നു, അത് ഒരൊറ്റ സിസ്റ്റം കോൾ ചെയ്യുകയും കേർണലിനുള്ളിൽ ഒരു കേർണൽ പ്രക്രിയയായി തുടരുകയും ചെയ്യുന്നു.

അതുപോലെ, ക്ലയന്റ് ഹോസ്റ്റിലെ ഒരു ഉപയോക്തൃ പ്രക്രിയയിൽ നിന്നുള്ള ഒരു അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യുന്നതിന് ഒരു NFS ക്ലയന്റ് സമയമെടുക്കുന്നു. സെർവർ ഹോസ്റ്റിന് RPC നൽകിയിട്ടുണ്ട്, അതിനുശേഷം ഒരു പ്രതികരണം പ്രതീക്ഷിക്കുന്നു. ക്ലയന്റ് ഹോസ്റ്റിലെ ഉപയോക്തൃ പ്രക്രിയകൾക്ക് എപ്പോൾ വേണമെങ്കിലും NFS പ്രയോജനപ്പെടുത്താൻ കഴിയുമെന്ന് ഉറപ്പാക്കാൻ, ക്ലയന്റ് കേർണലിനുള്ളിൽ നിരവധി NFS ക്ലയന്റുകൾ പ്രവർത്തിക്കുന്നു. നിർദ്ദിഷ്ട നടപ്പാക്കലും ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ആശ്രയിച്ചിരിക്കുന്നു. Unix സിസ്റ്റങ്ങൾ സാധാരണയായി ഒരു NFS സെർവറിനെ അനുസ്മരിപ്പിക്കുന്ന ഒരു സാങ്കേതികതയാണ് ഉപയോഗിക്കുന്നത്: ബയോഡ് എന്ന് വിളിക്കപ്പെടുന്ന ഒരു ഉപയോക്തൃ പ്രോസസ്സ് ഒരൊറ്റ സിസ്റ്റം കോൾ ഉണ്ടാക്കുകയും കേർണലിനുള്ളിൽ ഒരു കേർണൽ പ്രക്രിയയായി തുടരുകയും ചെയ്യുന്നു.

മിക്ക Unix ഹോസ്റ്റുകൾക്കും ഒരു NFS ക്ലയന്റും NFS സെർവറും അല്ലെങ്കിൽ രണ്ടും ഒരേ സമയം പ്രവർത്തിക്കാൻ കഴിയും. മിക്ക പിസി (എംഎസ്-ഡോസ്) നടപ്പിലാക്കലുകൾക്കും എൻഎഫ്എസ് ക്ലയന്റ് ഇംപ്ലിമെന്റേഷനുകൾ മാത്രമേ ഉള്ളൂ. മിക്ക IBM മെയിൻഫ്രെയിമുകളും NFS സെർവർ പ്രവർത്തനം മാത്രമാണ് നൽകുന്നത്.

NFS യഥാർത്ഥത്തിൽ NFS പ്രോട്ടോക്കോളിനേക്കാൾ കൂടുതലാണ്. NFS-നൊപ്പം ഉപയോഗിക്കുന്ന വിവിധ RPC പ്രോഗ്രാമുകൾ ചിത്രം 29.4 കാണിക്കുന്നു.

അപേക്ഷ	പ്രോഗ്രാം നമ്പർ	പതിപ്പ് നമ്പർ	നടപടിക്രമങ്ങളുടെ എണ്ണം
പോർട്ട് കൺവെർട്ടർ
എൻഎഫ്എസ്
മൌണ്ട് പ്രോഗ്രാം
തടയൽ മാനേജർ
സ്റ്റാറ്റസ് മോണിറ്റർ

ചിത്രം 29.4 NFS-ൽ ഉപയോഗിക്കുന്ന വിവിധ RPC പ്രോഗ്രാമുകൾ.

ഈ ചിത്രത്തിൽ നമ്മൾ യൂണിറ്റുകളായി കാണിച്ചിരിക്കുന്ന പതിപ്പുകൾ SunOS 4.1.3 പോലുള്ള സിസ്റ്റങ്ങളിൽ കാണപ്പെടുന്നു. പുതിയ നടപ്പാക്കലുകൾ ചില പ്രോഗ്രാമുകളുടെ പുതിയ പതിപ്പുകൾ നൽകുന്നു. ഉദാഹരണത്തിന്, സോളാരിസ് 2.2, പോർട്ട് റിസോൾവറിന്റെ 3, 4 പതിപ്പുകൾ, മൗണ്ട് ഡെമണിന്റെ പതിപ്പ് 2 എന്നിവയും പിന്തുണയ്ക്കുന്നു. പോർട്ട് കൺവെർട്ടറിന്റെ പതിപ്പ് 3-നെയും SVR4 പിന്തുണയ്ക്കുന്നു.

ക്ലയന്റിന് സെർവറിന്റെ ഫയൽ സിസ്റ്റം ആക്സസ് ചെയ്യുന്നതിന് മുമ്പ് ക്ലയന്റിൻറെ NFS ഹോസ്റ്റിൽ മൗണ്ട് ഡെമൺ ഇൻവോക്ക് ചെയ്യപ്പെടുന്നു. ഈ പ്രക്രിയ ഞങ്ങൾ താഴെ വിവരിക്കുന്നു.

NFS സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന ചില ഫയലുകൾ ബ്ലോക്ക് ചെയ്യാൻ ബ്ലോക്കിംഗ് മാനേജറും സ്റ്റാറ്റസ് മോണിറ്ററും ക്ലയന്റിനെ അനുവദിക്കുന്നു. ഈ രണ്ട് പ്രോഗ്രാമുകളും NFS പ്രോട്ടോക്കോളിൽ നിന്ന് സ്വതന്ത്രമാണ്, കാരണം തടയുന്നതിന് ക്ലയന്റ് ഹോസ്റ്റിനും സെർവറിനും ക്ലയന്റ് ആധികാരികത ആവശ്യമാണ്, കൂടാതെ NFS തന്നെ "നിഷ്പക്ഷമാണ്." (ഞങ്ങൾ NFS നിസ്സംഗതയെക്കുറിച്ച് കൂടുതൽ വിശദമായി ചുവടെ സംസാരിക്കും.) അധ്യായങ്ങൾ 9, 10, 11 [X/Open 1991] NFS-ൽ ലോക്കുചെയ്യുന്നതിന് ലോക്ക് മാനേജരും സ്റ്റാറ്റസ് മോണിറ്ററും ഉപയോഗിക്കുന്ന നടപടിക്രമങ്ങൾ രേഖപ്പെടുത്തുന്നു.

ഫയൽ വിവരണങ്ങൾ

NFS-ന്റെ അടിസ്ഥാനകാര്യങ്ങളിലൊന്ന് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ വഴി നടപ്പിലാക്കുന്നു. ഒബ്‌ജക്റ്റ് സെർവറിൽ ഒരു ഫയലോ ഡയറക്‌ടറിയോ ആക്‌സസ് ചെയ്യുന്നതിന്, അതാര്യമാണ് ഉപയോഗിക്കുന്നത്. അതാര്യമായ പദത്തിന്റെ അർത്ഥം സെർവർ ഒരു ഫയൽ ഹാൻഡിൽ സൃഷ്ടിക്കുകയും ക്ലയന്റിലേക്ക് തിരികെ കൈമാറുകയും ചെയ്യുന്നു, തുടർന്ന് ഫയൽ ആക്സസ് ചെയ്യുമ്പോൾ ക്ലയന്റ് അത് ഉപയോഗിക്കുന്നു എന്നാണ്. ക്ലയന്റ് ഒരിക്കലും ഫയൽ ഡിസ്ക്രിപ്റ്ററിന്റെ ഉള്ളടക്കത്തിലേക്ക് നോക്കുന്നില്ല - അതിന്റെ ഉള്ളടക്കങ്ങൾ സെർവറിന് മാത്രം താൽപ്പര്യമുള്ളതാണ്.

NFS സെർവറിൽ യഥാർത്ഥത്തിൽ വസിക്കുന്ന ഒരു ഫയൽ തുറക്കുമ്പോഴെല്ലാം NFS ക്ലയന്റ് ഒരു ഫയൽ ഹാൻഡിൽ സ്വീകരിക്കുന്നു. ഒരു NFS ക്ലയന്റ് ഈ ഫയൽ വായിക്കുകയോ എഴുതുകയോ ചെയ്യുമ്പോൾ (ഒരു ഉപയോക്തൃ പ്രക്രിയയുടെ പേരിൽ), ഫയലിലേക്കുള്ള ഒരു ഹാൻഡിൽ സെർവറിലേക്ക് തിരികെ നൽകും. ഫയൽ ആക്സസ് ചെയ്തതായി ഇത് സൂചിപ്പിക്കുന്നു.

സാധാരണയായി ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളിൽ ഉപയോക്തൃ പ്രക്രിയ പ്രവർത്തിക്കില്ല. NFS ക്ലയന്റും NFS സെർവറും തമ്മിൽ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ കൈമാറ്റം ചെയ്യപ്പെടുന്നു. NFS-ന്റെ പതിപ്പ് 2-ൽ, ഫയൽ ഡിസ്ക്രിപ്റ്റർ 32 ബൈറ്റുകളാണ്, പതിപ്പ് 3-ൽ ഇത് 64 ബൈറ്റുകളായി വളർന്നു.

Unix സെർവറുകൾ സാധാരണയായി ഫയൽ ഡിസ്ക്രിപ്റ്ററിൽ ഇനിപ്പറയുന്ന വിവരങ്ങൾ സംഭരിക്കുന്നു: ഫയൽ സിസ്റ്റം ഐഡന്റിഫയർ (പ്രധാനവും ചെറുതുമായ ഫയൽ സിസ്റ്റം ഉപകരണ നമ്പറുകൾ), ഐനോഡ് നമ്പർ (ഐ-നോഡ്) (ഫയൽ സിസ്റ്റത്തിനുള്ളിലെ ഒരു അദ്വിതീയ നമ്പർ), ഐനോഡ് ജനറേഷൻ നമ്പർ (മാറുന്ന ഒരു നമ്പർ ഓരോ തവണയും മറ്റൊരു ഫയലിനായി ഐനോഡ് വീണ്ടും ഉപയോഗിക്കുമ്പോൾ).

മൗണ്ട് പ്രോട്ടോക്കോൾ

NFS ഫയലുകൾ ആക്സസ് ചെയ്യുന്നതിന് മുമ്പ് സെർവറിന്റെ ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യുന്നതിന് ക്ലയന്റ് NFS മൗണ്ട് പ്രോട്ടോക്കോൾ ഉപയോഗിക്കുന്നു. ക്ലയന്റ് ലോഡ് ചെയ്യുമ്പോൾ ഇത് സാധാരണയായി സംഭവിക്കുന്നു. തൽഫലമായി, ക്ലയന്റ് സെർവറിന്റെ ഫയൽ സിസ്റ്റത്തിലേക്ക് ഒരു ഫയൽ ഹാൻഡിൽ സ്വീകരിക്കുന്നു.

മൗണ്ട്(8) കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ യുണിക്സ് ക്ലയന്റിൻറെ പ്രവർത്തനങ്ങളുടെ ക്രമം ചിത്രം 29.5 വിവരിക്കുന്നു.

ചിത്രം 29.5 Unix മൗണ്ട് കമാൻഡ് ഉപയോഗിക്കുന്ന മൗണ്ടിംഗ് പ്രോട്ടോക്കോൾ.

ഈ സാഹചര്യത്തിൽ, ഇനിപ്പറയുന്ന ഘട്ടങ്ങൾ നടപ്പിലാക്കുന്നു.

1. സെർവർ ബൂട്ട് ചെയ്യുമ്പോൾ, പോർട്ട് കൺവെർട്ടർ അതിൽ ആരംഭിക്കുന്നു.
2. പോർട്ട് റിസോൾവറിന് ശേഷം, സെർവറിൽ മൗണ്ട് ഡെമൺ (മൌണ്ട്ഡ്) ആരംഭിക്കുന്നു. ഇത് ഒരു ടിസിപി എൻഡ്‌പോയിന്റും യുഡിപി എൻഡ്‌പോയിന്റും സൃഷ്‌ടിക്കുകയും ഓരോന്നിനും ചലനാത്മകമായി അസൈൻ ചെയ്‌ത പോർട്ട് നമ്പർ നൽകുകയും ചെയ്യുന്നു. അത് പോർട്ട് മാപ്പറിൽ ഈ നമ്പറുകൾ രജിസ്റ്റർ ചെയ്യുന്നു.
3. ക്ലയന്റ് മൗണ്ട് കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു, ഇത് സെർവറിലെ മൌണ്ട് ഡെമണിൽ നിന്ന് ഒരു പോർട്ട് നമ്പർ ലഭിക്കുന്നതിന് സെർവറിന്റെ പോർട്ട് റിസോൾവറിലേക്ക് ഒരു RPC കോൾ നൽകുന്നു. ക്ലയന്റും പോർട്ട് റിസോൾവറും തമ്മിലുള്ള ആശയവിനിമയത്തിന് ടിസിപിയും യുഡിപിയും ഉപയോഗിക്കാം, എന്നാൽ യുഡിപി സാധാരണയായി ഉപയോഗിക്കുന്നു.
4. പോർട്ട് റിസോൾവർ പോർട്ട് നമ്പർ റിപ്പോർട്ട് ചെയ്യുന്നു.
5. സെർവറിന്റെ ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യുന്നതിനായി മൗണ്ട് കമാൻഡ് മൗണ്ട് ഡെമണിലേക്ക് ഒരു RPC കോൾ നൽകുന്നു. വീണ്ടും, TCP അല്ലെങ്കിൽ UDP ഉപയോഗിക്കാം, എന്നിരുന്നാലും UDP സാധാരണയായി ഉപയോഗിക്കുന്നു. ക്ലയന്റിന് നിർദ്ദിഷ്ട ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യാൻ കഴിയുമോ എന്നറിയാൻ സെർവറിന് അതിന്റെ IP വിലാസവും പോർട്ട് നമ്പറും അടിസ്ഥാനമാക്കി ക്ലയന്റ് സാധൂകരിക്കാനാകും.
6. നിർദ്ദിഷ്ട ഫയൽ സിസ്റ്റത്തിലേക്ക് ഒരു ഫയൽ ഹാൻഡിൽ ഉപയോഗിച്ച് മൗണ്ട് ഡെമൺ പ്രതികരിക്കുന്നു.
7. ക്ലയന്റിന്റെ മൌണ്ട് കമാൻഡ്, ക്ലയന്റ് ഹോസ്റ്റിലെ ലോക്കൽ മൌണ്ട് പോയിന്റുമായി ഘട്ടം 5-ൽ ലഭിച്ച ഫയൽ ഹാൻഡിൽ ബന്ധപ്പെടുത്തുന്നതിന് മൗണ്ട് സിസ്റ്റം കോൾ നൽകുന്നു. ഫയൽ ഹാൻഡിൽ ക്ലയന്റിൻറെ NFS കോഡിൽ സംഭരിച്ചിരിക്കുന്നു, ഇപ്പോൾ മുതൽ സെർവറിന്റെ ഫയൽ സിസ്റ്റത്തിലെ ഫയലുകളിലേക്കുള്ള ഉപയോക്തൃ പ്രോസസുകളുടെ ഏത് ആക്‌സസ്സും ഫയൽ ഹാൻഡിൽ ഒരു ആരംഭ പോയിന്റായി ഉപയോഗിക്കും.

ഈ നടപ്പിലാക്കൽ, ക്ലയന്റിലുള്ള മൗണ്ട് സിസ്റ്റം കോൾ ഒഴികെയുള്ള മുഴുവൻ മൌണ്ട് പ്രക്രിയയും കേർണലിനു പകരം ഉപയോക്തൃ പ്രക്രിയകളിലേക്കാണ് നൽകുന്നത്. ഞങ്ങൾ കാണിച്ച മൂന്ന് പ്രോഗ്രാമുകൾ - മൗണ്ട് കമാൻഡ്, പോർട്ട് റിസോൾവർ, മൗണ്ട് ഡെമൺ എന്നിവ - ഉപയോക്തൃ പ്രക്രിയകളാണ്.

ഈ ഉദാഹരണത്തിൽ, ഹോസ്റ്റ് സൂര്യനിൽ (NFS ക്ലയന്റ്), കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്തു

സൂര്യൻ # mount -t nfs bsdi:/usr /nfs/bsdi/usr

ഈ കമാൻഡ് /usr ഡയറക്ടറി bsdi ഹോസ്റ്റിൽ (NFS സെർവർ) ലോക്കൽ ഫയൽ സിസ്റ്റമായി /nfs/bsdi/usr ആയി മൌണ്ട് ചെയ്യുന്നു. ചിത്രം 29.6 ഫലം കാണിക്കുന്നു.

ചിത്രം 29.6 ഹോസ്റ്റ് സൂര്യനിൽ bsdi:/usr ഡയറക്ടറി /nfs/bsdi/usr ആയി മൌണ്ട് ചെയ്യുന്നു.

അതിനുശേഷം, സൺ ക്ലയന്റിലുള്ള /nfs/bsdi/usr/rstevens/hello.c എന്ന ഫയൽ ആക്സസ് ചെയ്യുമ്പോൾ, bsdi സെർവറിലെ /usr/rstevens/hello.c എന്ന ഫയൽ ആക്സസ് ചെയ്യപ്പെടും.

NFS നടപടിക്രമങ്ങൾ

NFS സെർവർ 15 നടപടിക്രമങ്ങൾ നൽകുന്നു, അത് ഞങ്ങൾ ഇപ്പോൾ വിവരിക്കും. (ഈ വിവരണത്തിൽ ഉപയോഗിച്ചിരിക്കുന്ന സംഖ്യകൾ NFS പ്രൊസീജിയർ നമ്പറുകൾക്ക് തുല്യമല്ല, കാരണം ഞങ്ങൾ അവയെ ഫങ്ഷണാലിറ്റി അനുസരിച്ച് തരംതിരിച്ചിട്ടുണ്ട്.) യുണിക്സ് സിസ്റ്റങ്ങളിൽ മാത്രമല്ല, ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ ഉടനീളം പ്രവർത്തിക്കാനാണ് NFS രൂപകൽപ്പന ചെയ്തിരിക്കുന്നതെങ്കിലും, ചില നടപടിക്രമങ്ങൾ യുണിക്സ് പ്രവർത്തനത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. , ഇത് മറ്റ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ പിന്തുണച്ചേക്കില്ല (ഉദാഹരണത്തിന്, ഹാർഡ് ലിങ്കുകൾ, പ്രതീകാത്മക ലിങ്കുകൾ, ഗ്രൂപ്പ് ഉപയോഗം, എക്സിക്യൂഷൻ ആക്സസ് അവകാശങ്ങൾ മുതലായവ). അദ്ധ്യായം 4-ൽ ഫയൽ സിസ്റ്റങ്ങളുടെ സവിശേഷതകളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു, അവയിൽ ചിലത് NFS ഉപയോഗിക്കുന്നു.

1. GETATTR. ഫയൽ ആട്രിബ്യൂട്ടുകൾ നൽകുന്നു: ഫയൽ തരം (സാധാരണ ഫയൽ, ഡയറക്‌ടറി മുതലായവ), ആക്‌സസ് അവകാശങ്ങൾ, ഫയൽ വലുപ്പം, ഫയൽ ഉടമ, അവസാന ആക്‌സസ് സമയം മുതലായവ.
2. SETATTR. ഫയൽ ആട്രിബ്യൂട്ടുകൾ സജ്ജമാക്കുന്നു. ഒരു നിർദ്ദിഷ്‌ട ആട്രിബ്യൂട്ടുകൾ മാത്രമേ സജ്ജീകരിക്കാൻ കഴിയൂ: ആക്‌സസ് അവകാശങ്ങൾ, ഉടമ, ഗ്രൂപ്പ് ഉടമസ്ഥത, വലുപ്പം, അവസാന ആക്‌സസ് സമയം, അവസാന പരിഷ്‌ക്കരണ സമയം.
3. എസ്.ടി.ടി.എഫ്.എസ്. ഫയൽ സിസ്റ്റത്തിന്റെ സ്റ്റാറ്റസ് നൽകുന്നു: ശൂന്യമായ ഇടത്തിന്റെ അളവ്, കൈമാറ്റത്തിനുള്ള ഒപ്റ്റിമൽ വലുപ്പം മുതലായവ. ഉദാഹരണത്തിന്, Unix df കമാൻഡ് ഉപയോഗിച്ചു.
4. തിരയൽ. ഫയൽ "വിലയിരുത്തുന്നു". എൻഎഫ്എസ് സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു ഫയൽ ഉപയോക്താവ് തുറക്കുമ്പോൾ ഓരോ തവണയും ക്ലയന്റ് ഈ നടപടിക്രമം വിളിക്കുന്നു. ഫയലിന്റെ ആട്രിബ്യൂട്ടുകൾക്കൊപ്പം ഒരു ഫയൽ ഹാൻഡിൽ തിരികെ നൽകുന്നു.
5. വായിക്കുക. ഒരു ഫയലിൽ നിന്ന് വായിക്കുന്നു. ക്ലയന്റ് ഒരു ഫയൽ ഹാൻഡിൽ, ഒരു ആരംഭ ബൈറ്റ് ഓഫ്‌സെറ്റ്, വായിക്കാനുള്ള പരമാവധി എണ്ണം ബൈറ്റുകൾ (8192 വരെ) എന്നിവ വ്യക്തമാക്കുന്നു.
6. എഴുതുക. ഒരു ഫയലിലേക്ക് എഴുതുന്നു. ക്ലയന്റ് ഫയൽ ഹാൻഡിൽ, ബൈറ്റുകളിലെ ആരംഭ ഓഫ്‌സെറ്റ്, എഴുതേണ്ട ബൈറ്റുകളുടെ എണ്ണം, എഴുതേണ്ട ഡാറ്റ എന്നിവ വ്യക്തമാക്കുന്നു.

   NFS റൈറ്റുകൾ സിൻക്രണസ് ആയിരിക്കണം (ഒരു കാത്തിരിപ്പോടെ). ഡാറ്റ വിജയകരമായി ഡിസ്കിലേക്ക് എഴുതുന്നത് വരെ (അപ്ഡേറ്റ് ചെയ്യേണ്ട മറ്റേതെങ്കിലും ഫയൽ വിവരങ്ങൾ) സെർവറിന് ശരി എന്ന് പ്രതികരിക്കാൻ കഴിയില്ല.

7. സൃഷ്ടിക്കാൻ. ഒരു ഫയൽ സൃഷ്ടിക്കുന്നു.
8. നീക്കം ചെയ്യുക. ഒരു ഫയൽ ഇല്ലാതാക്കുന്നു.
9. പുനർനാമകരണം ചെയ്യുക. ഫയലിന്റെ പേര് മാറ്റുന്നു.
10. ലിങ്ക്. ഫയലിലേക്ക് ഒരു ഹാർഡ് ലിങ്ക് ഉണ്ടാക്കുന്നു. ഒരു ഹാർഡ് ലിങ്ക് എന്നത് ഒരു യുണിക്സ് ആശയമാണ്, അത് ഡിസ്കിൽ നൽകിയിരിക്കുന്ന ഫയലിന് ആ ഫയലിലേക്ക് പോയിന്റ് ചെയ്യുന്ന എത്ര എൻട്രി പോയിന്റുകൾ (പേരുകൾ, ഹാർഡ് ലിങ്കുകൾ എന്നും വിളിക്കപ്പെടുന്നു) ഉണ്ടായിരിക്കാം എന്ന് വ്യക്തമാക്കുന്നു.
11. SYMLINK. ഒരു ഫയലിലേക്ക് ഒരു പ്രതീകാത്മക ലിങ്ക് സൃഷ്ടിക്കുന്നു. മറ്റൊരു ഫയലിന്റെ പേര് ഉൾക്കൊള്ളുന്ന ഒരു ഫയലാണ് പ്രതീകാത്മക ലിങ്ക്. ഒരു പ്രതീകാത്മക ലിങ്കിൽ നടത്തുന്ന മിക്ക പ്രവർത്തനങ്ങളും (ഉദാഹരണത്തിന്, തുറക്കൽ) പ്രതീകാത്മക ലിങ്ക് ചൂണ്ടിക്കാണിക്കുന്ന ഫയലിലാണ് യഥാർത്ഥത്തിൽ നടപ്പിലാക്കുന്നത്.
12. READLINK. ഒരു സിംലിങ്ക് വായിക്കുന്നത്, സിംലിങ്ക് ചൂണ്ടിക്കാണിച്ച ഫയലിന്റെ പേര് നൽകുന്നു.
13. എം.കെ.ഡി.ഐ.ആർ. ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുന്നു.
14. ആർഎംഡിഐആർ. ഒരു ഡയറക്ടറി ഇല്ലാതാക്കുന്നു.
15. READDIR. ഡയറക്ടറി വായിക്കുന്നു. ഉദാഹരണത്തിന്, Unix ls കമാൻഡ് ഉപയോഗിച്ചു.

വാസ്തവത്തിൽ, കാണിച്ചിരിക്കുന്ന നടപടിക്രമങ്ങളുടെ പേരുകൾ ഞങ്ങൾ ഒഴിവാക്കിയ NFSPROC_ പ്രിഫിക്‌സിൽ ആരംഭിക്കുന്നു.

UDP അല്ലെങ്കിൽ TCP?

എൻഎഫ്എസ് ആദ്യം എഴുതിയത് യുഡിപി ഉപയോഗിക്കാനാണ്, എല്ലാ വെണ്ടർമാരും ഈ കഴിവ് നൽകുന്നു. എന്നിരുന്നാലും, പുതിയ നടപ്പാക്കലുകളും ടിസിപിയെ പിന്തുണയ്ക്കുന്നു. വേഗത്തിലാകുന്ന ആഗോള നെറ്റ്‌വർക്കുകളിൽ പ്രവർത്തിക്കാൻ TCP പിന്തുണ ഉപയോഗിക്കുന്നു. അതിനാൽ, NFS-ന്റെ ഉപയോഗം ഇനി ലോക്കൽ നെറ്റ്‌വർക്കുകളിൽ മാത്രമായി പരിമിതപ്പെടുത്തിയിട്ടില്ല.

പ്രാദേശികവും ആഗോളവുമായ നെറ്റ്‌വർക്കുകൾ തമ്മിലുള്ള അതിരുകൾ മങ്ങുന്നു, ഇതെല്ലാം വളരെ വേഗത്തിൽ സംഭവിക്കുന്നു. റിട്ടേൺ ടൈംസ് വളരെ വിശാലമായ ശ്രേണിയിൽ വ്യത്യാസപ്പെടുകയും ഓവർഫ്ലോ കൂടുതൽ കൂടുതൽ സംഭവിക്കുകയും ചെയ്യുന്നു. ഗ്ലോബൽ നെറ്റ്‌വർക്കുകളുടെ ഈ സ്വഭാവസവിശേഷതകൾ, ടിസിപിക്കായി ഞങ്ങൾ പരിഗണിച്ച അൽഗോരിതങ്ങൾ അവർ കൂടുതലായി ഉപയോഗിക്കുന്നതിലേക്ക് നയിക്കുന്നു - സ്ലോ സ്റ്റാർട്ട്, തിരക്ക് ഒഴിവാക്കൽ. ഈ അൽഗോരിതങ്ങൾക്ക് സമാനമായ ഒന്നും UDP നൽകുന്നില്ല എന്നതിനാൽ, അവയോ സമാനമായവയോ NFS ക്ലയന്റിലേക്കും സെർവറിലേക്കും നിർമ്മിച്ചിരിക്കണം, അല്ലാത്തപക്ഷം TCP ഉപയോഗിക്കേണ്ടതാണ്.

ടിസിപിയിൽ എൻഎഫ്എസ്

Berkeley Net/2 NFS നടപ്പിലാക്കൽ UDP, TCP എന്നിവയെ പിന്തുണയ്ക്കുന്നു. [Macklem 1991] ഈ നടപ്പാക്കലിനെ വിവരിക്കുന്നു. ടിസിപിയിൽ പ്രവർത്തിക്കുമ്പോൾ NFS ഉപയോഗിക്കുന്നത് എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു എന്ന് നോക്കാം.

1. സെർവർ ബൂട്ട് ചെയ്യുമ്പോൾ, അത് എൻഎഫ്എസ് സെർവർ ആരംഭിക്കുന്നു, അത് ടിസിപി പോർട്ട് 2049-ൽ സജീവമായി തുറക്കുന്നു, ക്ലയന്റിൽനിന്നുള്ള ഒരു കണക്ഷൻ അഭ്യർത്ഥനയ്ക്കായി കാത്തിരിക്കുന്നു. UDP പോർട്ട് 2049-ൽ ഇൻകമിംഗ് ഡാറ്റാഗ്രാമുകൾ ശ്രദ്ധിക്കുന്ന സാധാരണ NFS UDP-ക്ക് പുറമേയാണ് ഇത് സാധാരണയായി ചെയ്യുന്നത്.
2. ഒരു ക്ലയന്റ് TCP ഉപയോഗിച്ച് ഒരു സെർവറിന്റെ ഫയൽ സിസ്റ്റം മൗണ്ട് ചെയ്യുമ്പോൾ, അത് സെർവറിലെ TCP പോർട്ട് 2049-ൽ സജീവമായി തുറക്കുന്നു. ഈ ഫയൽ സിസ്റ്റത്തിനായി ക്ലയന്റും സെർവറും തമ്മിൽ ഇത് ഒരു TCP കണക്ഷൻ സ്ഥാപിക്കുന്നു. ഒരേ ക്ലയന്റ് അതേ സെർവറിൽ മറ്റൊരു ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യുകയാണെങ്കിൽ, മറ്റൊരു TCP കണക്ഷൻ സൃഷ്ടിക്കപ്പെടും.
3. ക്ലയന്റും സെർവറും അവരുടെ കണക്ഷന്റെ അറ്റത്ത് TCP "സ്റ്റേ ലൈവ്" ഓപ്‌ഷൻ സജ്ജമാക്കി (അധ്യായം 23). ഒന്നോ അല്ലെങ്കിൽ മറ്റൊരു എക്സ്ചേഞ്ച് പങ്കാളിയുടെ പരാജയത്തിന്റെ നിമിഷം അല്ലെങ്കിൽ റീബൂട്ട് നിർണ്ണയിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.
4. സെർവറിന്റെ ഫയൽ സിസ്റ്റം ഉപയോഗിക്കുന്ന ക്ലയന്റിലുള്ള എല്ലാ ആപ്ലിക്കേഷനുകളും ആ ഫയൽ സിസ്റ്റത്തിലേക്ക് ഒരേ TCP കണക്ഷൻ പങ്കിടുന്നു. ഉദാഹരണത്തിന്, ചിത്രം 29.6-ൽ ഉണ്ടെങ്കിൽ, /usr ഡയറക്‌ടറിക്ക് താഴെ, bsdi-ൽ സ്മിത്ത് എന്ന പേരിൽ മറ്റൊരു ഡയറക്‌ടറി ഉണ്ടായിരിക്കും, /nfs/bsdi/usr/rstevens, /nfs/bsdi/usr/smith എന്നിവയിലെ ഫയലുകളിലേക്കുള്ള കോളുകൾ പങ്കിടും. അതേ കാര്യം അതേ ടിസിപി കണക്ഷൻ.
5. സെർവർ തകരുകയോ റീബൂട്ട് ചെയ്യുകയോ ചെയ്തതായി ക്ലയന്റ് നിർണ്ണയിക്കുകയാണെങ്കിൽ (ടിസിപി "കണക്ഷൻ കാലഹരണപ്പെട്ടു" അല്ലെങ്കിൽ "കണക്ഷൻ അടച്ചത് ഹോസ്റ്റ് വഴി" പിശക് ലഭിച്ചതിന് ശേഷം), അത് സെർവറിലേക്ക് വീണ്ടും കണക്റ്റുചെയ്യാൻ ശ്രമിക്കുന്നു. ഈ ഫയൽ സിസ്റ്റത്തിനായുള്ള TCP കണക്ഷൻ പുനഃസ്ഥാപിക്കുന്നതിനായി ക്ലയന്റ് മറ്റൊരു സജീവ ഓപ്പൺ നടത്തുന്നു. മുമ്പത്തെ കണക്ഷനിൽ കാലഹരണപ്പെട്ട ഒരു ക്ലയന്റിൽ നിന്നുള്ള ഏതൊരു അഭ്യർത്ഥനയും ഒരു പുതിയ കണക്ഷനിൽ വീണ്ടും നൽകും.
6. ഒരു ക്ലയന്റ് പരാജയപ്പെടുകയാണെങ്കിൽ, പരാജയത്തിന് മുമ്പ് പ്രവർത്തിച്ചിരുന്ന ആപ്ലിക്കേഷനുകളും അങ്ങനെ തന്നെ. ക്ലയന്റ് റീബൂട്ട് ചെയ്യുമ്പോൾ, അത് സെർവറിലേക്കുള്ള മറ്റൊരു TCP കണക്ഷൻ ഉപയോഗിച്ച് TCP ഉപയോഗിച്ച് സെർവറിന്റെ ഫയൽ സിസ്റ്റം റീമൗണ്ട് ചെയ്തേക്കാം. ഈ ഫയൽ സിസ്റ്റത്തിനായുള്ള ക്ലയന്റും സെർവറും തമ്മിലുള്ള മുമ്പത്തെ കണക്ഷൻ പകുതി തുറന്ന നിലയിലാണ് (ഇത് ഇപ്പോഴും തുറന്നിട്ടുണ്ടെന്ന് സെർവർ കരുതുന്നു), എന്നിരുന്നാലും, സെർവർ "ജീവനോടെ തുടരുക" ഓപ്ഷൻ സജ്ജമാക്കിയതിനാൽ, ഈ പകുതി തുറന്ന കണക്ഷൻ ആയിരിക്കും TCP സെർവർ അടുത്ത അന്വേഷണം അയയ്‌ക്കുമ്പോൾ അടച്ചു." ജീവനോടെയിരിക്കുക."

കാലക്രമേണ, മറ്റ് വെണ്ടർമാർ TCP വഴി NFS-നെ പിന്തുണയ്ക്കാൻ പദ്ധതിയിടുന്നു.

NFS ഉദാഹരണങ്ങൾ

സാധാരണ ഫയൽ പ്രവർത്തനങ്ങൾക്കായി ക്ലയന്റ് ഏതൊക്കെ എൻഎഫ്എസ് ദിനചര്യകളാണ് അഭ്യർത്ഥിക്കുന്നതെന്ന് കാണാൻ നമുക്ക് tcpdump ഉപയോഗിക്കാം. 2049 ഡെസ്റ്റിനേഷൻ പോർട്ട് ഉപയോഗിച്ച് ഒരു യുഡിപി ഡാറ്റാഗ്രാമിൽ ഒരു ആർപിസി കോൾ (ചിത്രം 29.1 ൽ കോൾ 0) ഉണ്ടെന്ന് tcpdump നിർണ്ണയിക്കുമ്പോൾ, അത് ഡാറ്റാഗ്രാമിനെ ഒരു NFS അഭ്യർത്ഥനയായി ഡീകോഡ് ചെയ്യുന്നു. അതുപോലെ, ഒരു യുഡിപി ഡാറ്റാഗ്രാമിൽ 2049-ന്റെ സോഴ്‌സ് പോർട്ട് ഉള്ള ഒരു ആർപിസി പ്രതികരണം (ചിത്രം 29.2-ൽ 1 ആണ്) അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, അത് ഡാറ്റാഗ്രാമിനെ ഒരു എൻഎഫ്എസ് പ്രതികരണമായി ഡീകോഡ് ചെയ്യുന്നു.

ലളിതമായ ഉദാഹരണം: ഒരു ഫയൽ വായിക്കുക

ആദ്യ ഉദാഹരണത്തിൽ, ഞങ്ങൾ cat(1) കമാൻഡ് ഉപയോഗിച്ച് NFS സെർവറിൽ സ്ഥിതിചെയ്യുന്ന ഒരു ഫയൽ ടെർമിനലിലേക്ക് പകർത്തും:

സൂര്യൻ% cat /nfs/bsdi/usr/rstevens/hello.cടെർമിനലിലേക്ക് ഒരു ഫയൽ പകർത്തുന്നു
പ്രധാന()
{
printf("ഹലോ, വേൾഡ്\n");
}

ചിത്രം 29.6-ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, ഹോസ്റ്റ് സൺ (NFS ക്ലയന്റ്)-ലെ /nfs/bsdi/usr ഫയൽ സിസ്റ്റം യഥാർത്ഥത്തിൽ ഹോസ്റ്റ് bsdi (NFS സെർവർ)-ലെ /usr ഫയൽ സിസ്റ്റമാണ്. പൂച്ച ഒരു ഫയൽ തുറക്കുകയും ഫയൽ ആക്‌സസ് ചെയ്യാൻ NFS ഉപയോഗിക്കുകയും ചെയ്യുമ്പോൾ സൺ കേർണൽ ഇത് കണ്ടെത്തുന്നു. tcpdump കമാൻഡിന്റെ ഔട്ട്പുട്ട് ചിത്രം 29.7 കാണിക്കുന്നു.

1 0.0 sun.7aa6 > bsdi.nfs: 104 getattr
2 0.003587 (0.0036) bsdi.nfs > sun.7aa6: മറുപടി ശരി 96

3 0.005390 (0.0018) sun.7aa7 > bsdi.nfs: 116 ലുക്ക്അപ്പ് "rstevens"
4 0.009570 (0.0042) bsdi.nfs > sun.7aa7: മറുപടി ശരി 128

5 0.011413 (0.0018) sun.7aa8 > bsdi.nfs: 116 നോക്കുക "hello.c"
6 0.015512 (0.0041) bsdi.nfs > sun.7aa8: മറുപടി ശരി 128

7 0.018843 (0.0033) sun.7aa9 > bsdi.nfs: 104 getattr
8 0.022377 (0.0035) bsdi.nfs > sun.7aa9: മറുപടി ശരി 96

9 0.027621 (0.0052) sun.7aaa > bsdi.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 0
10 0.032170 (0.0045) bsdi.nfs > sun.7aaa: മറുപടി ശരി 140

ചിത്രം 29.7 ഒരു ഫയൽ വായിക്കുമ്പോൾ NFS പ്രവർത്തനം.

tcpdump കമാൻഡ് NFS അഭ്യർത്ഥന അല്ലെങ്കിൽ പ്രതികരണം ഡീകോഡ് ചെയ്യുന്നു, കൂടാതെ ഇത് പോർട്ട് നമ്പറിന് പകരം ക്ലയന്റിനായുള്ള XID ഫീൽഡും പ്രിന്റ് ചെയ്യുന്നു. 1, 2 വരികളിലെ XID ഫീൽഡ് 0x7aa6 ആണ്.

/nfs/bsdi/usr/rstevens/hello.c എന്ന ഫയൽ നാമം ക്ലയന്റ് കേർണലിലെ ഓപ്പൺ ഫംഗ്ഷൻ വഴി പ്രോസസ്സ് ചെയ്യപ്പെടുന്നു. ഓപ്പൺ ഫംഗ്ഷൻ /nfs/bsdi/usr-ൽ എത്തുമ്പോൾ, ഇതൊരു NFS ഫയൽ സിസ്റ്റം മൌണ്ട് പോയിന്റാണെന്ന് അത് നിർണ്ണയിക്കുന്നു.

ലൈൻ 1-ൽ, ക്ലയന്റ് മൌണ്ട് ചെയ്ത (/usr) സെർവർ ഡയറക്ടറിയുടെ ആട്രിബ്യൂട്ടുകൾ ലഭിക്കുന്നതിന് ക്ലയന്റ് GETATTR-നെ വിളിക്കുന്നു. ഈ RPC അഭ്യർത്ഥനയിൽ IP, UDP തലക്കെട്ടുകൾ കൂടാതെ 104 ബൈറ്റുകൾ ഡാറ്റ അടങ്ങിയിരിക്കുന്നു. ലൈൻ 2-ലെ പ്രതികരണം OK നൽകുന്നു, കൂടാതെ IP, UDP തലക്കെട്ടുകൾക്ക് പുറമേ 96 ബൈറ്റുകൾ ഡാറ്റയും അടങ്ങിയിരിക്കുന്നു. ഏറ്റവും കുറഞ്ഞ NFS സന്ദേശത്തിൽ ഏകദേശം 100 ബൈറ്റുകൾ ഡാറ്റ അടങ്ങിയിരിക്കുന്നതായി ഈ ചിത്രത്തിൽ കാണാം.

ലൈൻ 3-ൽ, ക്ലയന്റ് ഫയൽ rstevens-ൽ LOOKUP-ലേക്ക് വിളിക്കുകയും ലൈൻ 4-ൽ ഒരു OK പ്രതികരണം ലഭിക്കുകയും ചെയ്യുന്നു. റിമോട്ട് ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്തപ്പോൾ കേർണൽ സംഭരിച്ച ഫയലിന്റെ rstevens-ന്റെ പേരും ഒരു ഹാൻഡിലുമാണ് LOOKUP വ്യക്തമാക്കുന്നു. പ്രതികരണത്തിൽ അടുത്ത ഘട്ടത്തിൽ ഉപയോഗിക്കുന്ന ഒരു പുതിയ ഫയൽ ഹാൻഡിൽ അടങ്ങിയിരിക്കുന്നു.

ലൈൻ 5-ൽ, ലൈൻ 4-ൽ നിന്നുള്ള ഫയൽ ഹാൻഡിൽ ഉപയോഗിച്ച് ക്ലയന്റ് hello.c ഫയൽ നോക്കുന്നു. ലൈൻ 6-ൽ ഇതിന് മറ്റൊരു ഫയൽ ഹാൻഡിൽ ലഭിക്കുന്നു. ഈ പുതിയ ഫയൽ ഹാൻഡിൽ, ഫയൽ ആക്സസ് ചെയ്യുന്നതിന് 7, 9 വരികളിൽ ക്ലയന്റ് ഉപയോഗിക്കുന്നത് തന്നെയാണ് / nfs /bsdi/usr/rstevens/hello.c. തുറക്കുന്ന ഫയലിലേക്കുള്ള പാതയിലെ ഓരോ നെയിം ഘടകത്തിലും ക്ലയന്റ് ഒരു ലുക്ക്അപ്പ് നടത്തുന്നത് ഞങ്ങൾ കാണുന്നു.

ലൈൻ 7-ൽ, ക്ലയന്റ് വീണ്ടും GETATTR എക്സിക്യൂട്ട് ചെയ്യുന്നു, തുടർന്ന് വരി 9-ൽ വായിക്കുക. ഓഫ്സെറ്റ് 0-ൽ ആരംഭിക്കുന്ന 1024 ബൈറ്റുകൾ ക്ലയന്റ് അഭ്യർത്ഥിക്കുന്നു, എന്നാൽ 1024 ബൈറ്റുകളിൽ കുറവ് ഡാറ്റയാണ് ലഭിക്കുന്നത്. (ആർ‌പി‌സി ഫീൽഡുകളുടെയും മറ്റ് മൂല്യങ്ങളുടെയും വലുപ്പങ്ങൾ റീഡ് നടപടിക്രമം വഴി തിരിച്ചുനൽകിയ ശേഷം, ലൈൻ 10-ൽ 38 ബൈറ്റുകൾ ഡാറ്റ നൽകുന്നു. ഇത് hello.c ഫയലിന്റെ വലുപ്പമാണ്.)

ഈ ഉദാഹരണത്തിൽ, കേർണൽ നടത്തുന്ന ഈ എൻഎഫ്എസ് അഭ്യർത്ഥനകളെയും പ്രതികരണങ്ങളെയും കുറിച്ച് ഉപയോക്തൃ പ്രോസസ്സിന് ഒന്നും അറിയില്ല. ആപ്ലിക്കേഷൻ കോർ ഓപ്പൺ ഫംഗ്‌ഷനെ വിളിക്കുന്നു, ഇത് 3 അഭ്യർത്ഥനകളും 3 പ്രതികരണങ്ങളും കൈമാറാൻ കാരണമാകുന്നു (ലൈനുകൾ 1-6), തുടർന്ന് 2 അഭ്യർത്ഥനകളും 2 പ്രതികരണങ്ങളും (ലൈനുകൾ 7-10) വിളിക്കുന്ന കോർ റീഡ് ഫംഗ്‌ഷനെ വിളിക്കുന്നു. ക്ലയന്റ് ആപ്ലിക്കേഷനായി, NFS സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന ഫയൽ സുതാര്യമാണ്.

ലളിതമായ ഉദാഹരണം: ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുന്നു

മറ്റൊരു ഉദാഹരണമായി, NFS സെർവറിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു ഡയറക്ടറിയിലേക്ക് വർക്കിംഗ് ഡയറക്ടറി മാറ്റാം, തുടർന്ന് ഒരു പുതിയ ഡയറക്ടറി സൃഷ്ടിക്കുക:

സൂര്യൻ% cd /nfs/bsdi/usr/rstevensപ്രവർത്തന ഡയറക്‌ടറി മാറ്റുക
സൂര്യൻ% mkdir മെയിൽഒരു ഡയറക്ടറി സൃഷ്ടിക്കുക

tcpdump കമാൻഡിന്റെ ഔട്ട്പുട്ട് ചിത്രം 29.8 കാണിക്കുന്നു.

1 0.0 sun.7ad2 > bsdi.nfs: 104 getattr
2 0.004912 (0.0049) bsdi.nfs > sun.7ad2: മറുപടി ശരി 96

3 0.007266 (0.0024) sun.7ad3 > bsdi.nfs: 104 getattr
4 0.010846 (0.0036) bsdi.nfs > sun.7ad3: മറുപടി ശരി 96

5 35.769875 (35.7590) sun.7ad4 > bsdi.nfs: 104 getattr
6 35.773432 (0.0036) bsdi.nfs > sun.7ad4: മറുപടി ശരി 96

7 35.775236 (0.0018) sun.7ad5 > bsdi.nfs: 112 "മെയിൽ" നോക്കുക
8 35.780914 (0.0057) bsdi.nfs > sun.7ad5: മറുപടി ശരി 28

9 35.782339 (0.0014) sun.7ad6 > bsdi.nfs: 144 mkdir "മെയിൽ"
10 35.992354 (0.2100) bsdi.nfs > sun.7ad6: മറുപടി ശരി 128

ചിത്രം 29.8 ഡയറക്‌ടറി (സിഡി) എൻഎഫ്എസ് ഡയറക്‌ടറിയിലേക്ക് മാറ്റുകയും തുടർന്ന് ഡയറക്‌ടറി (എംകെഡിർ) സൃഷ്‌ടിക്കുകയും ചെയ്യുമ്പോൾ എൻഎഫ്എസ് പ്രവർത്തനം.

ഡയറക്ടറി മാറ്റുമ്പോൾ, ക്ലയന്റ് GETATTR-നെ രണ്ടുതവണ വിളിക്കുന്നു (വരി 1-4). ഞങ്ങൾ ഒരു പുതിയ ഡയറക്‌ടറി സൃഷ്‌ടിക്കുമ്പോൾ, ക്ലയന്റ് GETATTR (ലൈനുകൾ 5 ഉം 6 ഉം), തുടർന്ന് LOOKUP (ഡയറക്‌ടറി നിലവിലില്ലെന്ന് പരിശോധിക്കാൻ 7, 8 വരികൾ), തുടർന്ന് ഡയറക്‌ടറി സൃഷ്‌ടിക്കാൻ MKDIR (ലൈനുകൾ 9 ഉം 10 ഉം) എന്ന് വിളിക്കുന്നു. 8 വരിയിലെ ശരി പ്രതികരണം ഡയറക്ടറി നിലവിലുണ്ടെന്ന് അർത്ഥമാക്കുന്നില്ല. നടപടിക്രമം കുറച്ച് മൂല്യം നൽകി എന്നാണ് ഇതിനർത്ഥം. NFS നടപടിക്രമങ്ങൾ നൽകുന്ന മൂല്യത്തെ tcpdump വ്യാഖ്യാനിക്കുന്നില്ല. കമാൻഡ് ശരിയും പ്രതികരണത്തിലെ ഡാറ്റയുടെ ബൈറ്റുകളുടെ എണ്ണവും പ്രിന്റ് ചെയ്യുന്നു.

നിസ്സംഗത

NFS-ന്റെ ഒരു പ്രത്യേകത (NFS വിമർശകർ ഇതിനെ ഒരു അരിമ്പാറ എന്നാണ് വിളിക്കുന്നത്, ഒരു സവിശേഷതയല്ല) NFS സെർവർ നിസ്സംഗമാണ് എന്നതാണ്. ഏത് ക്ലയന്റുകളാണ് ഏത് ഫയലുകൾ ആക്‌സസ് ചെയ്യുന്നതെന്ന് സെർവർ ശ്രദ്ധിക്കുന്നില്ല. നേരത്തെ കാണിച്ചിരിക്കുന്ന NFS നടപടിക്രമങ്ങളുടെ പട്ടികയിൽ ഒരു തുറന്ന അല്ലെങ്കിൽ ക്ലോസ് നടപടിക്രമം ഉൾപ്പെടുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക. LOOKUP നടപടിക്രമം ഒരു ഓപ്പൺ പോലെയാണ്, എന്നാൽ LOOKUP ഉണ്ടാക്കിയതിന് ശേഷം ക്ലയന്റ് ഫയൽ ആക്സസ് ചെയ്തിട്ടുണ്ടോ എന്ന് സെർവറിന് ഒരിക്കലും അറിയില്ല.

ഈ "ഡോണ്ട് കെയർ ബിഹേവിയർ" എന്നതിന്റെ കാരണം, അത് ക്രാഷുചെയ്‌ത് റീബൂട്ട് ചെയ്‌തതിന് ശേഷം സെർവർ പരാജയത്തിൽ നിന്ന് വീണ്ടെടുക്കുന്നത് എളുപ്പമാക്കുക എന്നതാണ്.

ഉദാഹരണം: സെർവർ പരാജയം

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, സെർവർ ക്രാഷ് ചെയ്യുകയും റീബൂട്ട് ചെയ്യുകയും ചെയ്യുമ്പോൾ ഞങ്ങൾ ഒരു NFS സെർവറിൽ നിന്ന് ഒരു ഫയൽ വായിക്കുന്നു. സെർവറിന്റെ "ഉദാസീനത" എങ്ങനെ സെർവർ പരാജയപ്പെട്ടുവെന്ന് "അറിയാൻ" ക്ലയന്റിനെ അനുവദിക്കുന്നത് ഇത് കാണിക്കും. സെർവർ തകരുകയും റീബൂട്ട് ചെയ്യുകയും ചെയ്യുന്ന മുഴുവൻ സമയവും, ക്ലയന്റ് പ്രശ്നത്തെക്കുറിച്ച് അറിയുന്നില്ല, കൂടാതെ ക്ലയന്റ് ആപ്ലിക്കേഷൻ മുമ്പത്തെപ്പോലെ തന്നെ പ്രവർത്തിക്കുന്നു.

സൺ ക്ലയന്റിൽ, ഞങ്ങൾ വളരെ വലിയ ഫയലുമായി ക്യാറ്റ് റൺ ചെയ്തു (/usr/share/lib/termcap svr4 NFS സെർവറിൽ), ഇഥർനെറ്റ് കേബിൾ മിഡ് ട്രാൻസ്ഫർ വിച്ഛേദിച്ചു, സെർവർ ഷട്ട്ഡൗൺ ചെയ്ത് റീബൂട്ട് ചെയ്തു, തുടർന്ന് കേബിൾ വീണ്ടും കണക്‌റ്റ് ചെയ്തു. . ഓരോ NFS റീഡിനും 1024 ബൈറ്റുകൾ വായിക്കാൻ ക്ലയന്റ് ക്രമീകരിച്ചിരിക്കുന്നു. ചിത്രം 29.9 tcpdump-ന്റെ ഔട്ട്പുട്ട് കാണിക്കുന്നു.

1-10 വരികൾ ഫയൽ തുറക്കുന്ന ക്ലയന്റുമായി യോജിക്കുന്നു. ഈ പ്രവർത്തനം ചിത്രം 29.7-ൽ കാണിച്ചിരിക്കുന്നതിന് സമാനമാണ്. 1024 ബൈറ്റ് ഡാറ്റയുടെ ഫയലിൽ നിന്ന് 11-ാം വരിയിൽ നമ്മൾ ആദ്യം വായിച്ചത് (വായിക്കുക) കാണുന്നു; പ്രതികരണം വരി 12-ൽ തിരിച്ചെത്തി. ഇത് ലൈൻ 129 വരെ തുടരുന്നു (വായനയുടെ 1024 ബൈറ്റുകൾ വായിക്കുകയും ശരി എന്ന് പ്രതികരിക്കുകയും ചെയ്യുന്നു).

130, 131 വരികളിൽ, കാലഹരണപ്പെട്ട രണ്ട് അഭ്യർത്ഥനകൾ ഞങ്ങൾ കാണുകയും 132, 133 വരികളിൽ വീണ്ടും സമർപ്പിക്കുകയും ചെയ്യുന്നു. ആദ്യ ചോദ്യം: രണ്ട് റീഡ് അഭ്യർത്ഥനകൾ ഞങ്ങൾ കാണുന്നു, ഒന്ന് ഓഫ്‌സെറ്റ് 65536-ലും മറ്റൊന്ന് ഓഫ്‌സെറ്റ് 73728-ലും ആരംഭിക്കുന്നു, എന്തുകൊണ്ട്? ക്ലയന്റ് ആപ്ലിക്കേഷൻ തുടർച്ചയായി വായിക്കുന്നുണ്ടെന്ന് ക്ലയന്റ് കേർണൽ നിർണ്ണയിക്കുകയും ഡാറ്റയുടെ ബ്ലോക്കുകൾ മുൻകൂട്ടി നേടുകയും ചെയ്തു. (മിക്ക യുണിക്സ് കേർണലുകളും ഇത് റീഡ്-എഹെഡ് ചെയ്യുന്നു.) ക്ലയന്റിനു വേണ്ടി ഒന്നിലധികം RPC അഭ്യർത്ഥനകൾ സൃഷ്ടിക്കാൻ ശ്രമിക്കുന്ന നിരവധി NFS ബ്ലോക്ക് ഇൻപുട്ട്/ഔട്ട്പുട്ട് (I/O) ഡെമണുകളും (ബയോഡ് പ്രോസസ്സുകൾ) ക്ലയന്റ് കേർണൽ പ്രവർത്തിപ്പിക്കുന്നു. ഒരു ഡെമൺ 65536 (1024-ബൈറ്റ് ശൃംഖലകളിൽ) ആരംഭിക്കുന്ന 8192 ബൈറ്റുകൾ വായിക്കുന്നു, മറ്റുള്ളവർ 73728 ൽ ആരംഭിക്കുന്ന 8192 ബൈറ്റുകൾ ഫോർവേഡ് ചെയ്യുന്നു.

ക്ലയന്റ് റീട്രാൻസ്മിഷനുകൾ 130-168 വരികളിൽ ദൃശ്യമാകുന്നു. ലൈൻ 169-ൽ, ലൈൻ 168-ൽ ക്ലയന്റിൻറെ NFS അഭ്യർത്ഥനയോട് പ്രതികരിക്കുന്നതിന് മുമ്പ് സെർവർ റീബൂട്ട് ചെയ്ത് ഒരു ARP അഭ്യർത്ഥന അയച്ചതായി ഞങ്ങൾ കാണുന്നു. ലൈൻ 168-നുള്ള പ്രതികരണം ലൈൻ 171-ൽ അയയ്‌ക്കുന്നു. ക്ലയന്റിന്റെ റീഡ് അഭ്യർത്ഥനകൾ തുടരുന്നു.

1 0.0 sun.7ade > svr4.nfs: 104 getattr
2 0.007653 (0.0077) svr4.nfs > sun.7ade: മറുപടി ശരി 96

3 0.009041 (0.0014) sun.7adf > svr4.nfs: 116 തിരയുക "പങ്കിടുക"
4 0.017237 (0.0082) svr4.nfs > sun.7adf: മറുപടി ശരി 128

5 0.018518 (0.0013) sun.7ae0 > svr4.nfs: 112 ലുക്ക്അപ്പ് "ലിബ്"
6 0.026802 (0.0083) svr4.nfs > sun.7ae0: മറുപടി ശരി 128

7 0.028096 (0.0013) sun.7ae1 > svr4.nfs: 116 ലുക്ക്അപ്പ് "ടേംക്യാപ്"
8 0.036434 (0.0083) svr4.nfs > sun.7ae1: മറുപടി ശരി 128

9 0.038060 (0.0016) sun.7ae2 > svr4.nfs: 104 getattr
10 0.045821 (0.0078) svr4.nfs > sun.7ae2: മറുപടി ശരി 96

11 0.050984 (0.0052) sun.7ae3 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 0
12 0.084995 (0.0340) svr4.nfs > sun.7ae3: മറുപടി ശരി 1124

വായന

128 3.430313 (0.0013) sun.7b22 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 64512
129 3.441828 (0.0115) svr4.nfs > sun.7b22: മറുപടി ശരി 1124

130 4.125031 (0.6832) sun.7b23 >
131 4.868593 (0.7436) sun.7b24 >

132 4.993021 (0.1244) sun.7b23 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 65536
133 5.732217 (0.7392) sun.7b24 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 73728

134 6.732084 (0.9999) sun.7b23 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 65536
135 7.472098 (0.7400) sun.7b24 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 73728

136 10.211964 (2.7399) sun.7b23 >
137 10.951960 (0.7400) sun.7b24 >

138 17.171767 (6.2198) sun.7b23 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 65536
139 17.911762 (0.7400) sun.7b24 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 73728

140 31.092136 (13.1804) sun.7b23 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 65536
141 31.831432 (0.7393) sun.7b24 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 73728

142 51.090854 (19.2594) sun.7b23 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 65536
143 51.830939 (0.7401) sun.7b24 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 73728

144 71.090305 (19.2594) sun.7b23 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 65536
145 71.830155 (0.7398) sun.7b24 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 73728

പുനഃസംപ്രേഷണം

167 291.824285 (0.7400) sun.7b24 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 73728
168 311.083676 (19.2594) sun.7b23 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 65536

സെർവർ റീബൂട്ട് ചെയ്തു

169 311.149476 (0.0658) ആർപ് ഹൂ-ഹസ് സൺ ടെൽ svr4
170 311.150004 (0.0005) arp മറുപടി സൂര്യൻ 8:0:20:3:f6:42-ന്

171 311.154852 (0.0048) svr4.nfs > sun.7b23: മറുപടി ശരി 1124

172 311.156671 (0.0018) sun.7b25 > svr4.nfs: 116 റീഡ് 1024 ബൈറ്റുകൾ @ 66560
173 311.168926 (0.0123) svr4.nfs > sun.7b25: മറുപടി ശരി 1124
വായന

ചിത്രം 29.9 NFS സെർവർ തകരുകയും റീബൂട്ട് ചെയ്യുകയും ചെയ്യുമ്പോൾ ക്ലയന്റ് ഒരു ഫയൽ വായിക്കുന്നു.

ലൈനുകൾ 129 നും 171 നും ഇടയിൽ 5 മിനിറ്റ് താൽക്കാലികമായി നിർത്തിയതൊഴിച്ചാൽ, സെർവർ ക്രാഷായതും റീബൂട്ട് ചെയ്തതും ക്ലയന്റ് ആപ്ലിക്കേഷന് ഒരിക്കലും അറിയാൻ കഴിയില്ല, അതിനാൽ സെർവർ ക്രാഷ് ക്ലയന്റിന് സുതാര്യമാണ്.

ഈ ഉദാഹരണത്തിൽ റീട്രാൻസ്മിഷൻ ടൈംഔട്ടുകളുടെ ദൈർഘ്യം കണക്കാക്കാൻ, രണ്ട് ക്ലയന്റ് ഡെമണുകൾ ഉണ്ടെന്ന് സങ്കൽപ്പിക്കുക, ഓരോന്നിനും അതിന്റേതായ സമയപരിധിയുണ്ട്. ആദ്യ ഡെമണിന്റെ ഇടവേളകൾ (ഓഫ്‌സെറ്റ് 65536-ൽ നിന്ന് വായിക്കുന്നത്) ഏകദേശം ഇപ്രകാരമാണ് (രണ്ട് ദശാംശ സ്ഥാനങ്ങളിലേക്ക് വൃത്താകൃതിയിലുള്ളത്): 0.68; 0.87; 1.74; 3.48; 6.96; 13.92; 20.0; 20.0; 20.0 തുടങ്ങിയവ. രണ്ടാമത്തെ ഡെമണിനുള്ള ഇടവേളകൾ (ഓഫ്‌സെറ്റ് 73728-ൽ നിന്ന് വായിക്കുന്നത്) കൃത്യമായി സമാനമാണ്. ഇതിനർത്ഥം ഈ NFS ക്ലയന്റുകൾ 0.875 സെക്കൻഡിന്റെ ഗുണിതങ്ങളായ ടൈംഔട്ടുകൾ ഉപയോഗിക്കുന്നു, ഉയർന്ന പരിധി 20 സെക്കൻഡ് ആണ്. ഓരോ ടൈംഔട്ടിനു ശേഷവും, റീട്രാൻസ്മിഷൻ ഇടവേള ഇരട്ടിയാകുന്നു: 0.875; 1.75; 3.5; 7.0, 14.0.

ക്ലയന്റ് റീട്രാൻസ്മിഷനുകൾ നടത്താൻ എത്ര സമയമെടുക്കും? ഉപഭോക്താവിന് ഇത് ബാധിക്കാവുന്ന രണ്ട് ഓപ്ഷനുകളുണ്ട്. ആദ്യം, സെർവറിന്റെ ഫയൽസിസ്റ്റം ഹാർഡ് മൌണ്ട് ആണെങ്കിൽ, ക്ലയന്റ് എന്നെന്നേക്കുമായി വീണ്ടും സംപ്രേഷണം ചെയ്യും, എന്നാൽ സെർവറിന്റെ ഫയൽസിസ്റ്റം സോഫ്റ്റ് മൗണ്ട് ആണെങ്കിൽ, ഒരു നിശ്ചിത എണ്ണം റീട്രാൻസ്മിഷനുകൾക്ക് ശേഷം ക്ലയന്റ് ശ്രമിക്കുന്നത് നിർത്തും. കൂടാതെ, ഹാർഡ് മൗണ്ടിന്റെ കാര്യത്തിൽ, പരാജയപ്പെട്ട റീട്രാൻസ്മിഷനുകൾ നിർത്തലാക്കാനോ അല്ലെങ്കിൽ നിർത്തലാക്കാതിരിക്കാനോ ഉപയോക്താവിനെ അനുവദിക്കുന്നതിനുള്ള ഓപ്ഷൻ ക്ലയന്റിനുണ്ട്. സെർവറിന്റെ ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യുമ്പോൾ, ക്ലയന്റ് ഹോസ്റ്റ് അത് തടസ്സപ്പെടുമെന്ന് സൂചിപ്പിക്കുന്നുവെങ്കിൽ, ക്രാഷുചെയ്‌തതിന് ശേഷം സെർവർ റീബൂട്ട് ചെയ്യുന്നതിന് 5 മിനിറ്റ് കാത്തിരിക്കേണ്ടതില്ലെങ്കിൽ, ക്ലയന്റ് ആപ്ലിക്കേഷൻ അവസാനിപ്പിക്കുന്നതിന് ഞങ്ങൾക്ക് ഒരു ഇന്ററപ്റ്റ് ചിഹ്നം നൽകാം.

സമാനമായ നിരവധി നടപടിക്രമങ്ങൾ

RPC നടപടിക്രമങ്ങൾ സെർവറിന് നിരവധി തവണ നടപ്പിലാക്കാൻ കഴിയും, പക്ഷേ ഇപ്പോഴും അതേ ഫലം നൽകുന്നു. ഉദാഹരണത്തിന്, NFS റീഡ് നടപടിക്രമം. ചിത്രം 29.9 ൽ നമ്മൾ കണ്ടതുപോലെ, ക്ലയന്റ് ഒരു പ്രതികരണം ലഭിക്കുന്നിടത്തോളം കാലം റീഡ് കോൾ വീണ്ടും ഇഷ്യൂ ചെയ്യുന്നു. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, സെർവർ പ്രവർത്തനരഹിതമായതാണ് വീണ്ടും സംപ്രേക്ഷണം ചെയ്യാനുള്ള കാരണം. സെർവർ പരാജയപ്പെടാതിരിക്കുകയും ആർപിസി പ്രതികരണങ്ങൾ അടങ്ങിയ സന്ദേശങ്ങൾ നഷ്‌ടപ്പെടുകയും ചെയ്‌താൽ (യുഡിപി വിശ്വസനീയമല്ലാത്ത പ്രോട്ടോക്കോൾ ആയതിനാൽ), ക്ലയന്റ് വീണ്ടും സംപ്രേഷണം ചെയ്യുകയും സെർവർ വീണ്ടും അതേ റീഡ് ചെയ്യുകയും ചെയ്യുന്നു. അതേ ഫയലിന്റെ അതേ ഭാഗം വീണ്ടും വായിക്കുകയും ക്ലയന്റിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു.

ഓരോ റീഡ് റീഡ് അഭ്യർത്ഥനയിലും ഒരു ആരംഭ ഓഫ്‌സെറ്റ് അടങ്ങിയിരിക്കുന്നതിനാൽ ഇത് പ്രവർത്തിക്കുന്നു. ഫയലിന്റെ അടുത്ത N ബൈറ്റുകൾ വായിക്കാൻ NFS നടപടിക്രമം സെർവറിനോട് ആവശ്യപ്പെട്ടാൽ, അത് പ്രവർത്തിക്കില്ല. സെർവർ നിസ്സംഗത പുലർത്തിയില്ലെങ്കിൽ (ഇത് നിസ്സംഗതയുടെ വിപരീതമാണ്) പ്രതികരണം നഷ്ടപ്പെടുകയും ക്ലയന്റ് അടുത്ത N ബൈറ്റുകൾക്കായി റീഡ് വീണ്ടും നൽകുകയും ചെയ്താൽ, ഫലം വ്യത്യസ്തമായിരിക്കും. അതുകൊണ്ടാണ് NFS READ, WRITE നടപടിക്രമങ്ങൾക്ക് ആരംഭ ഓഫ്‌സെറ്റ് ഉള്ളത്. സെർവറല്ല (ഓരോ ഫയലിനുമുള്ള നിലവിലെ ഓഫ്‌സെറ്റ്) അവസ്ഥ നിലനിർത്തുന്നത് ക്ലയന്റാണ്.

നിർഭാഗ്യവശാൽ, എല്ലാ ഫയൽ സിസ്റ്റം പ്രവർത്തനങ്ങളും ഒന്നിലധികം തവണ നടപ്പിലാക്കാൻ കഴിയില്ല. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന ഘട്ടങ്ങൾ സങ്കൽപ്പിക്കുക: ഒരു ഫയൽ നീക്കം ചെയ്യുന്നതിനായി NFS ക്ലയന്റ് ഒരു REMOVE അഭ്യർത്ഥന നൽകുന്നു; NFS സെർവർ ഫയൽ ഇല്ലാതാക്കുകയും ശരി എന്ന് പ്രതികരിക്കുകയും ചെയ്യുന്നു; സെർവർ പ്രതികരണം നഷ്ടപ്പെട്ടു; NFS ക്ലയന്റ് സമയം കഴിഞ്ഞു അഭ്യർത്ഥന വീണ്ടും കൈമാറുന്നു; NFS സെർവറിന് ഫയൽ കണ്ടെത്താനായില്ല, ഒരു പിശക് നൽകുന്നു; ഫയൽ നിലവിലില്ലെന്ന് പ്രസ്താവിക്കുന്ന ഒരു പിശക് ക്ലയന്റ് ആപ്ലിക്കേഷന് ലഭിക്കുന്നു. ഈ പിശക് ക്ലയന്റ് ആപ്ലിക്കേഷനിലേക്ക് തിരികെ നൽകി, ഈ പിശക് തെറ്റായ വിവരങ്ങൾ ഉൾക്കൊള്ളുന്നു - ഫയൽ നിലവിലില്ല, അത് ഇല്ലാതാക്കി.

ഒന്നിലധികം തവണ നടപ്പിലാക്കാൻ കഴിയുന്ന NFS നടപടിക്രമങ്ങളുടെ ഒരു ലിസ്റ്റ് ചുവടെയുണ്ട്: GETATTR, STATFS, LOOKUP, READ, WRITE, READLINK, READDIR. ഒന്നിലധികം തവണ നടപ്പിലാക്കാൻ കഴിയാത്ത നടപടിക്രമങ്ങൾ: സൃഷ്‌ടിക്കുക, നീക്കം ചെയ്യുക, പുനർനാമകരണം ചെയ്യുക, ലിങ്ക്, SYMLINK, MKDIR, RMDIR. SETATTR സാധാരണയായി ഒന്നിലധികം തവണ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു, ഒരു ഫയൽ വെട്ടിച്ചുരുക്കാൻ ഉപയോഗിച്ചിട്ടില്ലെങ്കിൽ.

UDP ഉപയോഗിക്കുമ്പോൾ അനാഥമായ പ്രതികരണങ്ങൾ ഉണ്ടാകാൻ സാധ്യതയുള്ളതിനാൽ, NFS സെർവറുകൾക്ക് ഒന്നിലധികം തവണ ചെയ്യാൻ കഴിയാത്ത പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു മാർഗം ഉണ്ടായിരിക്കണം. മിക്ക സെർവറുകൾക്കും സമീപകാല പ്രതികരണ കാഷെ ഉണ്ട്, അതിൽ അത്തരം പ്രവർത്തനങ്ങൾക്കായി അടുത്തിടെ ലഭിച്ച പ്രതികരണങ്ങൾ സംഭരിക്കുന്നു. ഓരോ തവണയും സെർവറിന് ഒരു അഭ്യർത്ഥന ലഭിക്കുമ്പോൾ, അത് ആദ്യം അതിന്റെ കാഷെ നോക്കുന്നു, ഒരു പൊരുത്തം കണ്ടെത്തിയാൽ, NFS നടപടിക്രമം വീണ്ടും വിളിക്കുന്നതിനുപകരം മുമ്പത്തെ പ്രതികരണം നൽകുന്നു. [Juszczak 1989] ഈ കാഷെ തരങ്ങളുടെ വിശദാംശങ്ങൾ വിവരിക്കുന്നു.

സെർവർ നടപടിക്രമങ്ങളിലേക്കുള്ള ഈ സമീപനം എൻഎഫ്എസ് മാത്രമല്ല, എല്ലാ യുഡിപി അധിഷ്ഠിത ആപ്ലിക്കേഷനുകൾക്കും ബാധകമാണ്. ഉദാഹരണത്തിന്, DNS, വേദന കൂടാതെ ഒന്നിലധികം തവണ ഉപയോഗിക്കാവുന്ന ഒരു സേവനം നൽകുന്നു. ഡിഎൻഎസ് സെർവറിന് എത്ര തവണ വേണമെങ്കിലും പാഴ്‌സറോട് ചോദിക്കാൻ കഴിയും, അത് നെഗറ്റീവ് ഫലങ്ങളിലേക്ക് നയിക്കില്ല (ഒരുപക്ഷേ, നെറ്റ്‌വർക്ക് ഉറവിടങ്ങൾ അധിനിവേശം ചെയ്യപ്പെടുമെന്നതൊഴിച്ചാൽ).

NFS പതിപ്പ് 3

1994-ൽ, NFS പ്രോട്ടോക്കോളിന്റെ പതിപ്പ് 3-ന്റെ പ്രത്യേകതകൾ പുറത്തിറങ്ങി [സൺ മൈക്രോസിസ്റ്റംസ് 1993]. 1994-ൽ നടപ്പിലാക്കലുകൾ ലഭ്യമാകുമെന്ന് പ്രതീക്ഷിക്കുന്നു.

പതിപ്പുകൾ 2 ഉം 3 ഉം തമ്മിലുള്ള പ്രധാന വ്യത്യാസങ്ങളുടെ ഒരു ദ്രുത അവലോകനം ഇതാ. ഞങ്ങൾ അവയെ V2, V3 എന്ന് വിളിക്കും.

1. V2-ലെ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ 32 ബൈറ്റുകളുടെ ഒരു നിശ്ചിത വലിപ്പത്തിലുള്ള അറേയാണ്. V3-ൽ ഇത് 64 ബൈറ്റുകൾ വരെ വലുപ്പമുള്ള ഒരു വേരിയബിൾ വലുപ്പമുള്ള അറേയാണ്. XDR-ൽ ഒരു വേരിയബിൾ-ലെങ്ത് അറേ നിർവചിക്കുന്നത് 4-ബൈറ്റ് കൗണ്ടർ ഉപയോഗിച്ചാണ്, തുടർന്ന് യഥാർത്ഥ ബൈറ്റുകൾ. ഏകദേശം 12 ബൈറ്റുകൾ മാത്രം ആവശ്യമുള്ള Unix പോലുള്ള നിർവ്വഹണങ്ങളിൽ ഇത് ഫയൽ ഡിസ്ക്രിപ്റ്ററിന്റെ വലിപ്പം കുറയ്ക്കുന്നു, എന്നാൽ Unix അല്ലാത്ത നടപ്പാക്കലുകളെ അധിക വിവരങ്ങൾ കൈമാറാൻ അനുവദിക്കുന്നു.
2. ഓരോ വായിക്കുന്നതിനോ എഴുതുന്നതിനോ ഉള്ള ബൈറ്റുകളുടെ എണ്ണം V2 8192 ബൈറ്റുകളായി പരിമിതപ്പെടുത്തുന്നു. ഈ പരിമിതി V3-ൽ ബാധകമല്ല, അതിനർത്ഥം UDP ഉപയോഗിക്കുമ്പോൾ പരിധി IP ഡാറ്റാഗ്രാമിന്റെ (65535 ബൈറ്റുകൾ) വലുപ്പം മാത്രമായിരിക്കും എന്നാണ്. വേഗതയേറിയ നെറ്റ്‌വർക്കുകളിൽ വായിക്കാനും എഴുതാനും വലിയ പാക്കറ്റുകൾ ഉപയോഗിക്കാൻ ഇത് അനുവദിക്കുന്നു.
3. ഫയൽ വലുപ്പങ്ങളും റീഡ്, റൈറ്റ് നടപടിക്രമങ്ങൾക്കുള്ള ആരംഭ ബൈറ്റ് ഓഫ്‌സെറ്റുകളും 32-ൽ നിന്ന് 64 ബിറ്റുകളായി വികസിപ്പിച്ചിരിക്കുന്നു, ഇത് വലിയ ഫയൽ വലുപ്പങ്ങൾ കൈകാര്യം ചെയ്യാൻ അനുവദിക്കുന്നു.
4. ആട്രിബ്യൂട്ടുകളെ ബാധിക്കുന്ന എല്ലാ കോളുകളിലും ഫയൽ ആട്രിബ്യൂട്ടുകൾ തിരികെ നൽകും. ഇത് ക്ലയന്റിന് ആവശ്യമായ GETATTR കോളുകളുടെ എണ്ണം കുറയ്ക്കുന്നു.
5. റൈറ്റുകൾ (എഴുതുകൾ) അസമന്വിതമാകാം, അതേസമയം V2-ൽ അവ സമന്വയമുള്ളതായിരിക്കണം. ഇത് WRITE നടപടിക്രമത്തിന്റെ പ്രകടനം മെച്ചപ്പെടുത്തിയേക്കാം.
6. ഒരു നടപടിക്രമം നീക്കം ചെയ്‌തു (STATFS) കൂടാതെ ഏഴെണ്ണം ചേർത്തു: ആക്‌സസ് (ഫയൽ അനുമതികൾ പരിശോധിക്കുക), MKNOD (ഒരു പ്രത്യേക Unix ഫയൽ സൃഷ്‌ടിക്കുക), READDIRPLUS (ഒരു ഡയറക്ടറിയിൽ ഫയലുകളുടെ പേരുകൾ അവയുടെ ആട്രിബ്യൂട്ടുകൾക്കൊപ്പം നൽകുന്നു), FSINFO (ഇതിനെക്കുറിച്ചുള്ള സ്ഥിതിവിവരക്കണക്ക് വിവരങ്ങൾ നൽകുന്നു. ഫയൽ സിസ്റ്റം ), FSSTAT (ഡൈനാമിക് ഫയൽ സിസ്റ്റം വിവരങ്ങൾ നൽകുന്നു), PATHCONF ( POSIX.1 ഫയൽ വിവരങ്ങൾ നൽകുന്നു), കൂടാതെ COMMIT (നേരത്തെ അസിൻക്രണസ് റൈറ്റുകളെ സ്ഥിരമായ സംഭരണത്തിലേക്ക് കമ്മിറ്റ് ചെയ്യുന്നു).

ഹ്രസ്വമായ നിഗമനങ്ങൾ

ക്ലയന്റ് സെർവറിലെ നടപടിക്രമങ്ങൾ വിളിക്കുന്ന തരത്തിൽ ഒരു ക്ലയന്റ്-സെർവർ ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിനുള്ള ഒരു മാർഗമാണ് RPC. എല്ലാ നെറ്റ്‌വർക്ക് വിശദാംശങ്ങളും ക്ലയന്റ്, സെർവർ സ്റ്റബുകളിൽ മറച്ചിരിക്കുന്നു, അവ ആർപിസി പാക്കേജിലും ആർപിസി ലൈബ്രറി ദിനചര്യകളിലും ആപ്ലിക്കേഷനുകൾക്കായി സൃഷ്‌ടിച്ചതാണ്. ഞങ്ങൾ RPC കോളിന്റെയും പ്രതികരണ സന്ദേശങ്ങളുടെയും ഫോർമാറ്റ് കാണിച്ചു, മൂല്യങ്ങൾ എൻകോഡ് ചെയ്യാൻ XDR ഉപയോഗിക്കുന്നു, RPC ക്ലയന്റുകളെയും സെർവറുകളെയും വ്യത്യസ്ത മെഷീൻ ആർക്കിടെക്ചറുകളിൽ പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു.

ഏറ്റവും വ്യാപകമായി ഉപയോഗിക്കുന്ന ആർപിസി ആപ്ലിക്കേഷനുകളിലൊന്നാണ് സൺ എൻഎഫ്എസ്, ഒരു വൈവിധ്യമാർന്ന ഫയൽ ആക്സസ് പ്രോട്ടോക്കോൾ, ഇത് മിക്കവാറും എല്ലാ വലുപ്പത്തിലുമുള്ള ഹോസ്റ്റുകളിലും വ്യാപകമായി ഉപയോഗിക്കുന്നു. ഞങ്ങൾ NFS-ലും അത് UDP അല്ലെങ്കിൽ TCP എങ്ങനെ ഉപയോഗിക്കുന്നുവെന്നും നോക്കി. NFS പതിപ്പ് 2 പ്രോട്ടോക്കോൾ 15 നടപടിക്രമങ്ങൾ നിർവ്വചിക്കുന്നു.

ഒരു NFS സെർവറിലേക്കുള്ള ക്ലയന്റ് ആക്സസ് ആരംഭിക്കുന്നത് ഒരു മൗണ്ട് പ്രോട്ടോക്കോൾ ഉപയോഗിച്ചാണ്, അതിനുശേഷം ഒരു ഫയൽ ഹാൻഡിൽ ക്ലയന്റിലേക്ക് തിരികെ നൽകും. ക്ലയന്റിന് ഈ ഫയൽ ഹാൻഡിൽ ഉപയോഗിച്ച് സെർവറിന്റെ ഫയൽ സിസ്റ്റത്തിൽ ഫയലുകൾ ആക്സസ് ചെയ്യാൻ കഴിയും. ഓരോ ഘടകത്തിനും ഒരു പുതിയ ഫയൽ ഹാൻഡിൽ തിരികെ നൽകിക്കൊണ്ട്, സെർവറിൽ ഒരു സമയത്ത് ഒരു നെയിം എലമെന്റ് ഫയലിന്റെ പേരുകൾ തിരയുന്നു. അന്തിമഫലം ആക്‌സസ് ചെയ്‌ത ഫയലിലേക്കുള്ള ഒരു ഹാൻഡിലാണ്, അത് തുടർച്ചയായ വായനകൾക്കും എഴുത്തുകൾക്കും ഉപയോഗിക്കുന്നു.

NFS അതിന്റെ എല്ലാ നടപടിക്രമങ്ങളും നിർവ്വഹണങ്ങളുടെ എണ്ണത്തിൽ നിന്ന് സ്വതന്ത്രമാക്കാൻ ശ്രമിക്കുന്നു, അതുവഴി പ്രതികരണം നഷ്‌ടപ്പെട്ടാൽ ക്ലയന്റിന് അഭ്യർത്ഥന വീണ്ടും നൽകാനാകും. സെർവർ ക്രാഷ് ചെയ്യുകയും റീബൂട്ട് ചെയ്യുകയും ചെയ്യുമ്പോൾ ഒരു ക്ലയന്റ് ഫയൽ വായിക്കുന്നതിന്റെ ഉദാഹരണങ്ങൾ ഞങ്ങൾ കണ്ടു.

വ്യായാമങ്ങൾ

ചിത്രം 29.7-ൽ, tcpdump പാക്കറ്റുകളെ NFS അഭ്യർത്ഥനകളായും പ്രതികരണങ്ങളായും വ്യാഖ്യാനിക്കുകയും XID പ്രിന്റ് ചെയ്യുകയും ചെയ്യുന്നു. ഏതെങ്കിലും RPC അഭ്യർത്ഥനകൾക്കോ ​​പ്രതികരണങ്ങൾക്കോ ​​വേണ്ടി tcpdump-ന് ഇത് ചെയ്യാൻ കഴിയുമോ?

Unix സിസ്റ്റങ്ങളിലെ RPC സെർവർ പ്രോഗ്രാം മുൻകൂട്ടി അറിയാവുന്നവയെക്കാൾ ചലനാത്മകമായി അസൈൻ ചെയ്‌ത പോർട്ടുകൾ ഉപയോഗിക്കുന്നതായി നിങ്ങൾ കരുതുന്നത് എന്തുകൊണ്ട്?

RPC ക്ലയന്റ് രണ്ട് സെർവർ നടപടിക്രമങ്ങൾ വിളിച്ചു. ആദ്യ നടപടിക്രമം പൂർത്തിയാക്കാൻ 5 സെക്കൻഡ് എടുത്തു, രണ്ടാമത്തേത് - 1 സെക്കൻഡ്. ക്ലയന്റിന് 4 സെക്കൻഡിന്റെ സമയപരിധിയുണ്ട്. ക്ലയന്റും സെർവറും തമ്മിൽ കൈമാറ്റം ചെയ്യപ്പെടുന്നതിന്റെ ഒരു ടൈമിംഗ് ഡയഗ്രം വരയ്ക്കുക. (ക്ലയന്റിൽ നിന്ന് സെർവറിലേക്കും തിരിച്ചും ഒരു സന്ദേശം കൈമാറാൻ സമയം ചെലവഴിച്ചിട്ടില്ലെന്ന് സങ്കൽപ്പിക്കുക.)

ചിത്രം 29.9-ലെ ഉദാഹരണത്തിൽ, NFS സെർവർ ഓഫായിരിക്കുമ്പോൾ NFS സെർവറിന്റെ ഇഥർനെറ്റ് കാർഡ് നീക്കം ചെയ്താൽ എന്ത് സംഭവിക്കും?

ചിത്രം 29.9-ൽ സെർവർ റീബൂട്ട് ചെയ്യുമ്പോൾ, അത് ഓഫ്‌സെറ്റ് 65536-ൽ (ലൈനുകൾ 168, 171) ആരംഭിക്കുന്ന അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്തു, തുടർന്ന് ഓഫ്‌സെറ്റ് 66560-ൽ (ലൈനുകൾ 172, 173) ആരംഭിക്കുന്ന അടുത്ത അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്തു. ഓഫ്‌സെറ്റ് 73728 (ലൈൻ 167) ൽ ആരംഭിക്കുന്ന അന്വേഷണത്തിന് എന്ത് സംഭവിക്കും?

NFS എക്സിക്യൂഷനുകളുടെ എണ്ണത്തിൽ നിന്ന് സ്വതന്ത്രമായ നടപടിക്രമങ്ങൾ ഞങ്ങൾ വിവരിച്ചപ്പോൾ, നെറ്റ്‌വർക്കിൽ നഷ്ടപ്പെട്ട ഒരു REMOVE പ്രതികരണത്തിന്റെ ഒരു ഉദാഹരണം ഞങ്ങൾ കാണിച്ചു. യുഡിപിക്ക് പകരം ടിസിപി ഉപയോഗിച്ചാൽ ഈ സാഹചര്യത്തിൽ എന്ത് സംഭവിക്കും?

NFS സെർവർ പോർട്ട് 2049-ന് പകരം ചലനാത്മകമായി അസൈൻ ചെയ്‌ത ഒരു പോർട്ട് ഉപയോഗിക്കുന്നുവെങ്കിൽ, സെർവർ ക്രാഷ് ചെയ്യുകയും റീബൂട്ട് ചെയ്യുകയും ചെയ്യുമ്പോൾ NFS ക്ലയന്റിന് എന്ത് സംഭവിക്കും?

റിസർവ് ചെയ്ത പോർട്ട് നമ്പറുകൾ വളരെ കുറവാണ് (അധ്യായം 1, വിഭാഗം "പോർട്ട് നമ്പറുകൾ"), ഒരു ഹോസ്റ്റിന് പരമാവധി 1023. ഒരു NFS സെർവറിന് അതിന്റെ ക്ലയന്റുകൾക്ക് റിസർവ് ചെയ്ത പോർട്ടുകൾ ആവശ്യമുണ്ടെങ്കിൽ (അവർ സാധാരണയായി ഇത് ചെയ്യുന്നു), കൂടാതെ TCP ഉപയോഗിക്കുന്ന ഒരു NFS ക്ലയന്റ് N വ്യത്യസ്ത സെർവറുകളിൽ N ഫയൽ സിസ്റ്റങ്ങൾ മൗണ്ട് ചെയ്യുന്നുവെങ്കിൽ, ഓരോ കണക്ഷനും ക്ലയന്റിന് വ്യത്യസ്ത റിസർവ് ചെയ്ത പോർട്ട് നമ്പറുകൾ ആവശ്യമുണ്ടോ?

ഒരു ലോക്കൽ നെറ്റ്‌വർക്കിനുള്ളിൽ ഫയലുകൾ വിതരണം ചെയ്യുന്നതിന്, ഇനിപ്പറയുന്ന സാങ്കേതികവിദ്യകൾ വേർതിരിച്ചറിയാൻ കഴിയും (ലിനക്സ് അടിസ്ഥാനമാക്കിയുള്ള സിസ്റ്റങ്ങൾ പരിഗണിക്കപ്പെടുന്നു):

• നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം (NFS) - ഫയൽ സിസ്റ്റങ്ങൾക്കായുള്ള നെറ്റ്‌വർക്ക് ആക്‌സസ് പ്രോട്ടോക്കോൾ;
• ഷെൽ പ്രോട്ടോക്കോൾ (ഫിഷ്) വഴി കൈമാറുന്ന ഫയലുകൾ അല്ലെങ്കിൽ ഉപയോഗിക്കുന്ന ഒരു നെറ്റ്‌വർക്ക് പ്രോട്ടോക്കോൾ ആണ് RSHകമ്പ്യൂട്ടറുകൾക്കിടയിൽ ഫയലുകൾ കൈമാറാൻ;
• സെക്യുർ ഷെൽ ഫയൽസിസ്റ്റം (എസ്എസ്എച്ച്എഫ്എസ്) - റിമോട്ട് സിസ്റ്റത്തിൽ ഡിസ്ക് ഡിവൈസുകൾ മൌണ്ട് ചെയ്യുന്നതിനുള്ള ഒരു ഫയൽ സിസ്റ്റം ക്ലയന്റ്, റിമോട്ട് സിസ്റ്റവുമായി സംവദിക്കാൻ ഉപയോഗിക്കുന്നു. എസ്.എഫ്.ടി.പി;
• SMB/CIFS പ്രോട്ടോക്കോൾ വഴി വിവിധ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലെ നെറ്റ്‌വർക്ക് ഡ്രൈവുകളും പ്രിന്ററുകളും ആക്‌സസ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു സോഫ്റ്റ്‌വെയർ പാക്കേജാണ് സാംബ;

ഈ കുറിപ്പിൽ നമ്മൾ സംസാരിക്കും എൻഎഫ്എസ്.

NFS (നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം)നെറ്റ്‌വർക്കിലുള്ള എല്ലാവർക്കും ഫയലുകൾ/ഡയറക്‌ടറികൾ വിതരണം ചെയ്യേണ്ടിവരുമ്പോൾ ഉപയോഗപ്രദമാണ്. ഉപയോഗിച്ച് സുതാര്യത ആക്സസ് ചെയ്യുക എൻഎഫ്എസ്ഒരു റിമോട്ട് ഫയൽ സിസ്റ്റം ഒരു ലോക്കൽ ഡയറക്ടറിയായി മൌണ്ട് ചെയ്യാൻ ക്ലയന്റുകളെ അനുവദിക്കുന്നു, കൂടാതെ ഫയൽ സിസ്റ്റങ്ങൾ വ്യത്യസ്ത തരത്തിലാകാം. ഇതിനർത്ഥം ഒരു ലോക്കൽ ഫയലിൽ പ്രവർത്തിക്കാൻ കഴിയുന്ന ഏതൊരു ക്ലയന്റ് ആപ്ലിക്കേഷനും വഴി കണക്റ്റുചെയ്‌ത ഒരു ഫയലിൽ എളുപ്പത്തിൽ പ്രവർത്തിക്കാൻ കഴിയും എന്നാണ് എൻഎഫ്എസ്, പ്രോഗ്രാമിൽ തന്നെ മാറ്റങ്ങളൊന്നും വരുത്താതെ.

നേട്ടങ്ങളിലേക്ക് എൻഎഫ്എസ്ആട്രിബ്യൂട്ട് ചെയ്യാം:

പ്രോസസറിലെ ലോഡ് കുറയ്ക്കൽ;

സിസ്റ്റത്തിൽ സാധാരണ ഡയറക്ടറികളായി പങ്കിട്ട വിഭവങ്ങൾ പ്രദർശിപ്പിക്കുന്നു;

ഇപ്പോൾ ലഭ്യമാണ് NFS v4.1, ഒരു പുതിയ ഫീച്ചർ അവതരിപ്പിച്ചു pNFSഫയൽ പങ്കിടൽ നടപ്പിലാക്കുന്നത് സമാന്തരമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. NFS 2, 3 എന്നിവയ്‌ക്കായി ഒരു വിപുലീകരണവും ഉണ്ട് - WebNFS, ഇത് വെബ് ബ്രൗസറുകളിലേക്ക് എളുപ്പത്തിൽ സംയോജിപ്പിക്കാനും ഫയർവാളിലൂടെ പ്രവർത്തിക്കാനുള്ള കഴിവും അനുവദിക്കുന്നു.

ജോലിയുടെ സ്കീം എൻഎഫ്എസ്പ്രോട്ടോക്കോൾ.

Linux-ന് കീഴിൽ NFS സെർവർ ഇൻസ്റ്റാൾ ചെയ്യുകയും ക്രമീകരിക്കുകയും ചെയ്യുന്നു

സിസ്റ്റം NFS പിന്തുണയ്ക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കാം

Cat /proc/filesystems | grep nfs

താഴെ ആർച്ച് ലിനക്സ്സെർവറും ക്ലയന്റും ഒരേ പാക്കേജിലാണ്

Yaourt -S nfs-utils

സെർവർ ഇൻസ്റ്റാൾ ചെയ്യാൻ ( nfs-kernel-server) കൂടാതെ ക്ലയന്റ് ( nfs-common) കീഴിൽ ഉബുണ്ടുപാക്കേജുകൾ ആവശ്യമാണ്

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

ഈ കുറിപ്പിൽ, സെർവറിനായി IP ഉപയോഗിക്കും 192.168.1.100 . എല്ലായ്‌പ്പോഴും സെർവറിലേക്ക് ഒരേ ഐപി അസൈൻ ചെയ്യപ്പെടുന്നതിന്, ഡിഎച്ച്സിപി സെർവറിൽ (സാധാരണയായി ഒരു റൂട്ടർ) ഒരു നിർദ്ദിഷ്‌ട IP-യുടെ ഒരു നിർദ്ദിഷ്ട MAC വിലാസത്തിലേക്ക് വിതരണം ചെയ്യേണ്ടത് ആവശ്യമാണ്. അല്ലെങ്കിൽ നിങ്ങളുടെ പ്രാദേശിക DNS സെർവർ ഉയർത്തുക. ഉദാഹരണത്തിന് അല്ലെങ്കിൽ.

ifconfig (ഫീൽഡ്) ഉപയോഗിച്ച് MAC വിലാസം കണ്ടെത്താനാകും ഈഥർവി ആർച്ച് ലിനക്സ്).

NFSv4ഒരു റൂട്ട് ഡയറക്ടറി ഉണ്ടെന്ന് അനുമാനിക്കുന്നു, അതിനുള്ളിൽ വിതരണത്തിനുള്ള ഫയലുകൾ ഇതിനകം സ്ഥിതിചെയ്യുന്നു. ഉദാഹരണത്തിന്, /srv/nfs- റൂട്ട്, /srv/nfs/audio- സംഗീതം വിതരണം ചെയ്യുന്നതിനുള്ള ഡയറക്ടറി. പതിപ്പിലെ ഈ പുതിയ മാർഗ്ഗനിർദ്ദേശം നിങ്ങൾ പിന്തുടരുന്നില്ലെങ്കിൽ 4 ക്ലയന്റ് കണക്റ്റുചെയ്യുമ്പോൾ നിങ്ങൾക്ക് ഒരു പിശക് ലഭിച്ചേക്കാം:

Mount.nfs: 192.168.1.100:/home/proft/torrents മൗണ്ട് ചെയ്യുമ്പോൾ സെർവർ ആക്സസ് നിരസിച്ചു

റൂട്ട് ഡയറക്‌ടറി ഇല്ലാതെ നിങ്ങൾക്ക് ഇപ്പോഴും സെർവറിൽ സമീപനം ഉപയോഗിക്കണമെങ്കിൽ എൻഎഫ്എസ്, തുടർന്ന് ക്ലയന്റ് മൗണ്ട് ചെയ്യുമ്പോൾ, നിങ്ങൾ പതിപ്പ് വ്യക്തമായി വ്യക്തമാക്കണം 3

# മൗണ്ട് കമാൻഡിനായി mount -o "vers=3" 192.168.1.100:/home/proft/torrents /home/proft/nfs/torrents # fstab 192.168.1.100:/home/proft/torrents /home/proft/nfs / ടോറന്റുകൾ nfs സോഫ്റ്റ്, nfsvers=3 0 0

ഞാൻ ഉപയോഗിക്കും NFSv4റൂട്ട് ഡയറക്ടറി ഉപയോഗിച്ച് /srv/nfs/കൂടാതെ mount --bind ഉപയോഗിച്ച് ഉപഡയറക്‌ടറികൾ മൗണ്ടുചെയ്യുന്നു.

നമുക്ക് വേണം എന്ന് കരുതുക

• ഡയറക്‌ടറി വിതരണം ചെയ്യുക ~/ടോറന്റുകൾകൂടെ rwപ്രവേശനം എല്ലാവരുംപ്രാദേശിക നെറ്റ്‌വർക്കിനുള്ളിൽ;
• ഡയറക്‌ടറി വിതരണം ചെയ്യുക ~/ഫോട്ടോകൾകൂടെ റോ IP ഉള്ള ഹോസ്റ്റിനുള്ള ആക്സസ് 192.168.1.101 ;

ആദ്യം, നമുക്ക് ഒരു റൂട്ട് ഡയറക്ടറിയും ആവശ്യമായ ഉപഡയറക്‌ടറികളും ഉണ്ടാക്കാം.

Sudo mkdir -p /srv/nfs/(ടോറന്റുകൾ,ഫോട്ടോകൾ)

നിലവിലുള്ള ഡയറക്ടറികൾ മൌണ്ട് ചെയ്യുക ടോറന്റുകൾ, ഫോട്ടോകൾവി /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

തിരുത്താം /etc/കയറ്റുമതി, എല്ലാ പങ്കിട്ട ഡയറക്ടറികളും വിവരിക്കുന്നു

# sudo vim /etc/exports # ഫയൽ ഫോർമാറ്റ്: ഡയറക്ടറി അനുവദനീയമായ-ഹോസ്റ്റുകൾ(ഓപ്ഷനുകൾ) /srv/nfs/torrents 192.168.1.1/24(rw,async) /srv/nfs/photos 192.168.1.101(ro,async)

ഇടയ്ക്ക് ഇടമില്ലെന്ന് ശ്രദ്ധിക്കുക അനുവദനീയമായ ഹോസ്റ്റുകൾഒപ്പം (ഓപ്ഷനുകൾ). ഒരു സ്ഥലത്തിന്റെ സാന്നിധ്യം നിയമങ്ങളുടെ വ്യത്യസ്തമായ വ്യാഖ്യാനം അവതരിപ്പിക്കുന്നു.

ലഭ്യമായ ഓപ്ഷനുകൾ:

• ro (rw) - വായന-മാത്രം ആക്സസ് അനുവദിക്കുക (വായിക്കുക/എഴുതുക);
• subtree_check (no_subtree_check) - ചില സന്ദർഭങ്ങളിൽ മുഴുവൻ വിഭാഗവും അല്ല, അതിന്റെ ഒരു ഭാഗം മാത്രം കയറ്റുമതി ചെയ്യേണ്ടത് ആവശ്യമാണ്. ഈ സാഹചര്യത്തിൽ, സെർവർ എൻഎഫ്എസ്ക്ലയന്റ് അഭ്യർത്ഥനകൾ ഉചിതമായ ഉപഡയറക്‌ടറികളിൽ ഉള്ള ഫയലുകൾ ആക്‌സസ് ചെയ്യാൻ മാത്രമാണ് ശ്രമിക്കുന്നതെന്ന് ഉറപ്പാക്കാൻ അധിക പരിശോധനകൾ നടത്തണം. ഈ സബ്ട്രീ നിയന്ത്രണം ( സബ്ട്രീ പരിശോധനകൾ) ക്ലയന്റുകളുമായുള്ള ആശയവിനിമയം ഒരു പരിധിവരെ മന്ദഗതിയിലാക്കുന്നു, എന്നാൽ നിങ്ങൾ അത് നിരസിച്ചാൽ, അത് സിസ്റ്റം സുരക്ഷയിൽ പ്രശ്നങ്ങൾ ഉണ്ടാക്കിയേക്കാം. ഓപ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് സബ്ട്രീയുടെ നിയന്ത്രണം റദ്ദാക്കാം no_subtree_check. ഓപ്ഷൻ സബ്ട്രീ_ചെക്ക്, അത്തരം നിയന്ത്രണം ഉൾപ്പെടുന്നു, സ്ഥിരസ്ഥിതിയായി അനുമാനിക്കപ്പെടുന്നു. എക്‌സ്‌പോർട്ട് ചെയ്‌ത ഡയറക്‌ടറി ഒരു ഡിസ്‌ക് പാർട്ടീഷൻ പോലെയാണെങ്കിൽ സബ്‌ട്രീ പരിശോധന ഒഴിവാക്കാവുന്നതാണ്;
• sync (async) - അഭ്യർത്ഥനകൾ വരുത്തിയ മാറ്റങ്ങൾ ഡിസ്കിലേക്ക് എഴുതിയതിനുശേഷം മാത്രമേ സെർവർ അഭ്യർത്ഥനകളോട് പ്രതികരിക്കാവൂ എന്ന് വ്യക്തമാക്കുന്നു. ഓപ്ഷൻ അസമന്വിതംഡിസ്കിലേക്ക് വിവരങ്ങൾ എഴുതുന്നതിനായി കാത്തിരിക്കരുതെന്ന് സെർവറിനോട് പറയുന്നു, ഇത് പ്രകടനം മെച്ചപ്പെടുത്തുന്നു, പക്ഷേ വിശ്വാസ്യത കുറയ്ക്കുന്നു, കാരണം ഒരു കണക്ഷൻ പരാജയം അല്ലെങ്കിൽ ഉപകരണങ്ങളുടെ പരാജയം സംഭവിക്കുമ്പോൾ, ഡാറ്റ നഷ്ടം സംഭവിക്കാം;
• noaccess - നിർദ്ദിഷ്‌ട ഡയറക്ടറിയിലേക്കുള്ള പ്രവേശനം നിഷേധിക്കുന്നു. നിങ്ങൾ മുമ്പ് എല്ലാ നെറ്റ്‌വർക്ക് ഉപയോക്താക്കൾക്കും ഒരു നിശ്ചിത ഡയറക്‌ടറിയിലേക്ക് ആക്‌സസ് സജ്ജീകരിച്ചാൽ അത് ഉപയോഗപ്രദമാകും, കൂടാതെ ഇപ്പോൾ ഉപഡയറക്‌ടറിയിലേക്കുള്ള ആക്‌സസ് ചില ഉപയോക്താക്കൾക്ക് മാത്രമായി പരിമിതപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു;
• no_root_squash - സ്ഥിര ഉപയോക്താവ് റൂട്ട്ക്ലയന്റ് മെഷീനിൽ സെർവറിലെ ഡയറക്‌ടറിക്ക് സമാനമായ അവകാശങ്ങൾ ഉണ്ടായിരിക്കില്ല. ഈ ഓപ്ഷൻ ഈ പരിമിതി ഇല്ലാതാക്കുന്നു;
• നോഹൈഡ്- എൻഎഫ്എസ്പ്രാദേശികേതര ഉറവിടങ്ങൾ സ്വയമേവ കാണിക്കുന്നില്ല (ഉദാഹരണത്തിന്, mount --bind ഉപയോഗിച്ച് മൗണ്ട് ചെയ്‌തിരിക്കുന്നു), ഈ ഐച്ഛികം അത്തരം ഉറവിടങ്ങളുടെ പ്രദർശനം സാധ്യമാക്കുന്നു;
• സുരക്ഷിതമല്ലാത്തത് - പ്രത്യേകാവകാശമില്ലാത്ത പോർട്ടുകളുടെ ഉപയോഗം (> 1024);

NFS സെർവർ ആരംഭിക്കുന്നു

# archlinux-ന് കീഴിൽ sudo systemctl ആരംഭിക്കുക rpc-idmapd.service rpc-mountd.service # ubuntu sudo ന് കീഴിൽ /etc/init.d/nfs-kernel-server start

ഭാവിയിൽ, കോൺഫിഗറേഷൻ ഫയൽ മാറ്റുമ്പോൾ, കമാൻഡ് ഉപയോഗിച്ച് അത് വീണ്ടും വായിക്കുക:

Sudo exportfs -rav

കമാൻഡ് rpcinfo -p | സെർവർ വിജയകരമായി ആരംഭിച്ചോ എന്ന് പരിശോധിക്കാൻ grep nfs നിങ്ങളെ അനുവദിക്കുന്നു.

Linux ക്ലയന്റ്

ഇൻസ്റ്റലേഷൻ

# archlinux yaourt -S nfs-utils # ന് കീഴിൽ ubuntu sudo apt-get install portmap nfs-common

നെറ്റ്‌വർക്ക് ഉറവിടങ്ങൾ മൌണ്ട് ചെയ്യുന്നതിനായി നമുക്ക് ഡയറക്ടറികൾ സൃഷ്ടിക്കാം ടോറന്റുകൾഒപ്പം ഫോട്ടോകൾ

Mkdir -p ~/nfs/(ടോറന്റുകൾ, ഫോട്ടോകൾ)

മാനുവൽ മൗണ്ടിംഗിനായി ഞങ്ങൾ ചെയ്യും

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:/srvotosn/srvotosn /proft/nfs/photos

ഓപ്ഷൻ മൃദുവായഒരു നിശ്ചിത സമയത്തിന് ശേഷം ഷെയർ കണക്റ്റുചെയ്യാനുള്ള ശ്രമങ്ങൾ നിശബ്ദമായി റദ്ദാക്കാൻ വ്യക്തമാക്കുന്നു (സമയം ഓപ്‌ഷൻ വഴി വ്യക്തമാക്കുന്നു റിട്രാൻസ്). കൂടുതൽ വിശദാംശങ്ങൾ ൽ മനുഷ്യൻ nfs.

ഈ രീതി വളരെ സൗകര്യപ്രദമല്ല, കാരണം ഒരു റീബൂട്ടിന് ശേഷം ഓരോ തവണയും നിങ്ങൾ ഈ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യേണ്ടിവരും. ഇൻസ്റ്റലേഷൻ ഓട്ടോമാറ്റിക് ആക്കാം.

സ്വയമേവ മൗണ്ട് ചെയ്യാൻ, ഫയൽ എഡിറ്റ് ചെയ്യുക /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/netfome/home/phots റോ, സോഫ്റ്റ് 0 0

എന്നാൽ ഈ രീതിക്ക് അതിന്റെ പോരായ്മകളും ഉണ്ട്, ഉദാഹരണത്തിന്, സെർവർ ലഭ്യമല്ലെങ്കിൽ, NFS സെർവറിലേക്ക് കണക്റ്റുചെയ്യാനുള്ള ശ്രമങ്ങൾ കാരണം ക്ലയന്റിന്റെ ലോഡിംഗ് മരവിച്ചേക്കാം. ഇത് പരിഹരിക്കാൻ, കുറിച്ച് താഴെ കാണുക ഓട്ടോഎഫ്എസ്.

AutoFS - നെറ്റ്‌വർക്ക് ഉറവിടങ്ങളുടെ യാന്ത്രിക കണക്ഷൻ

ഉപയോഗിച്ച് ഒരു റിമോട്ട് റിസോഴ്സ് മൌണ്ട് ചെയ്യാൻ സാധിക്കും ഓട്ടോഎഫ്എസ്ആദ്യ ആക്‌സസ് ചെയ്യുമ്പോൾ, പ്രവർത്തനമൊന്നുമില്ലെങ്കിൽ സ്വയമേവ അൺമൗണ്ട് ചെയ്യുക.

ഓട്ടോഎഫ്എസ്എന്നതിൽ സ്ഥിതിചെയ്യുന്ന ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുന്നു /etc/autofs. പ്രധാന ടെംപ്ലേറ്റ് വിളിക്കുന്നു auto.master, നിർദ്ദിഷ്‌ട മീഡിയ തരങ്ങൾക്കായി ഇതിന് ഒന്നോ അതിലധികമോ മറ്റ് പാറ്റേണുകൾ ചൂണ്ടിക്കാണിക്കാൻ കഴിയും.

ഇൻസ്റ്റലേഷൻ

# archlinux yaourt -S autofs-ന് കീഴിൽ # ubuntu sudo apt-get install autofs

ഓട്ടോമൗണ്ട് രീതികൾ വ്യക്തമാക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട്. ഞാൻ ഇത് ഉപയോഗിക്കുന്നു: ഇൻ /home/proft/nfs NFS സെർവറിന്റെ പേരിൽ ഒരു ഡയറക്ടറി സ്വയമേവ സൃഷ്ടിക്കപ്പെടുന്നു, അതിൽ സെർവറിൽ ആക്സസ് ചെയ്യാവുന്ന ഡയറക്ടറികൾ സ്വയമേവ സൃഷ്ടിക്കപ്പെടുന്നു.

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

അധിക പാരാമീറ്റർ ടൈം ഔട്ട്ഉപകരണം അൺമൗണ്ട് ചെയ്യുന്ന സെക്കൻഡുകളുടെ എണ്ണം സജ്ജമാക്കുന്നു. പരാമീറ്റർ പ്രേതംകോൺഫിഗർ ചെയ്‌ത ഉറവിടങ്ങൾ എല്ലായ്‌പ്പോഴും പ്രദർശിപ്പിക്കപ്പെടുമെന്ന് വ്യക്തമാക്കുന്നു, അവ ലഭ്യമാകുമ്പോൾ മാത്രമല്ല (ഈ ഓപ്ഷൻ സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു ഓട്ടോഎഫ്എസ് 5)

ഞങ്ങൾ അതിൽ വിവരിക്കും /etc/autofs/auto.nfs NFS സെർവറും റൂട്ട് ഡയറക്ടറിയും.

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

ഇപ്പോൾ ആദ്യ കോളിൽ /home/proft/nfs/torrents NFS റിസോഴ്സ് സ്വയമേവ മൌണ്ട് ചെയ്യപ്പെടും.

നമുക്ക് autofs സേവനം പുനരാരംഭിക്കാം:

# archlinux sudo systemctl autofs പുനരാരംഭിക്കുന്നതിന് കീഴിൽ # ubuntu sudo /etc/init.d/autofs പുനരാരംഭിക്കുന്നതിന് കീഴിൽ

ഒരു NFS റിസോഴ്സ് ലഭ്യമാകുന്നതിനുള്ള കാത്തിരിപ്പ് സമയവും നിങ്ങൾക്ക് വ്യക്തമാക്കാം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ മൂല്യങ്ങൾ മാറ്റേണ്ടതുണ്ട് MOUNT_WAIT.

# archlinux-ന് കീഴിൽ # sudo vim /etc/conf.d/autofs MOUNT_WAIT=5 # ubuntu sudo /etc/default/autofs MOUNT_WAIT=5

NFS v3 ഉപയോഗിക്കാൻ നിർബന്ധിക്കുന്നു

ചില കേസുകളിൽ NFSv4സാവധാനം പ്രവർത്തിക്കാം. ഇത് പരിഹരിക്കാൻ, മൂന്നാം പതിപ്പ് ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് നിർബന്ധിക്കാം.

NFS: സൗകര്യപ്രദവും പ്രതീക്ഷ നൽകുന്നതുമായ ഒരു നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം

നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റംഒരു സാധാരണ ഫയൽ സിസ്റ്റത്തിന്റെ മുകളിലുള്ള ഒരു നെറ്റ്‌വർക്ക് അബ്‌സ്‌ട്രാക്ഷൻ ആണ്, അത് ലോക്കൽ ഫയൽ സിസ്റ്റങ്ങൾ ആക്‌സസ് ചെയ്യുമ്പോൾ പോലെ തന്നെ നെറ്റ്‌വർക്കിലൂടെ ആക്‌സസ് ചെയ്യാൻ റിമോട്ട് ക്ലയന്റിനെ അനുവദിക്കുന്നു. NFS ആദ്യത്തെ നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം ആയിരുന്നില്ലെങ്കിലും, ഇന്ന് UNIX®-ലെ ഏറ്റവും പ്രാപ്തിയുള്ളതും ജനപ്രിയവുമായ നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റമായി ഇത് പരിണമിച്ചു. NFS ഒന്നിലധികം ഉപയോക്താക്കളെ ഒരു പൊതു ഫയൽ സിസ്റ്റം പങ്കിടാൻ അനുവദിക്കുകയും അത് സംഭരിക്കുന്നതിന് ആവശ്യമായ ഡിസ്ക് സ്പേസ് കുറയ്ക്കുന്നതിന് ഡാറ്റ കേന്ദ്രീകരിക്കുകയും ചെയ്യുന്നു.

ഈ ലേഖനം NFS-ന്റെ ചരിത്രത്തിന്റെ ഒരു ഹ്രസ്വ അവലോകനത്തോടെ ആരംഭിക്കുന്നു, തുടർന്ന് NFS-ന്റെ വാസ്തുവിദ്യയും ഭാവിയിൽ അത് എങ്ങനെ വികസിച്ചേക്കാം എന്നതും പര്യവേക്ഷണം ചെയ്യാൻ നീങ്ങുന്നു.

NFS-ന്റെ ഒരു സംക്ഷിപ്ത ചരിത്രം

ആദ്യത്തെ നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റത്തെ FAL (ഫയൽ ആക്‌സസ് ലിസണർ) എന്ന് വിളിച്ചിരുന്നു, ഇത് 1976-ൽ DEC (ഡിജിറ്റൽ എക്യുപ്‌മെന്റ് കോർപ്പറേഷൻ) വികസിപ്പിച്ചെടുത്തു. ഇത് DAP പ്രോട്ടോക്കോൾ (ഡാറ്റ ആക്‌സസ് പ്രോട്ടോക്കോൾ) നടപ്പിലാക്കുകയും DECnet പ്രോട്ടോക്കോൾ സ്യൂട്ടിന്റെ ഭാഗവുമായിരുന്നു. TCP/IP പോലെ, DAP പ്രോട്ടോക്കോൾ ഉൾപ്പെടെയുള്ള അതിന്റെ നെറ്റ്‌വർക്ക് പ്രോട്ടോക്കോളുകൾക്കായി DEC സ്പെസിഫിക്കേഷനുകൾ പ്രസിദ്ധീകരിച്ചു.

IP പ്രോട്ടോക്കോളിന് മുകളിൽ നിർമ്മിച്ച ആദ്യത്തെ ആധുനിക നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റമാണ് NFS. ഇതിന്റെ പ്രോട്ടോടൈപ്പ് 80-കളുടെ തുടക്കത്തിൽ സൺ മൈക്രോസിസ്റ്റംസിൽ വികസിപ്പിച്ച ഒരു പരീക്ഷണാത്മക ഫയൽ സിസ്റ്റമായി കണക്കാക്കാം. ഈ പരിഹാരത്തിന്റെ ജനപ്രീതി കണക്കിലെടുത്ത്, NFS പ്രോട്ടോക്കോൾ ഒരു RFC സ്പെസിഫിക്കേഷനായി അവതരിപ്പിക്കുകയും പിന്നീട് NFSv2 ആയി പരിണമിക്കുകയും ചെയ്തു. മറ്റ് ക്ലയന്റുകളുമായും സെർവറുകളുമായും ഇടപഴകാനുള്ള കഴിവ് കാരണം NFS പെട്ടെന്ന് തന്നെ ഒരു സ്റ്റാൻഡേർഡ് ആയി സ്വയം സ്ഥാപിച്ചു.

സ്റ്റാൻഡേർഡ് പിന്നീട് NFSv3 ലേക്ക് അപ്ഡേറ്റ് ചെയ്തു, RFC 1813-ൽ നിർവചിച്ചിരിക്കുന്നു. ഈ പ്രോട്ടോക്കോളിന്റെ പതിപ്പ് മുൻ പതിപ്പുകളേക്കാൾ കൂടുതൽ സ്കെയിലബിൾ ആയിരുന്നു കൂടാതെ വലിയ ഫയൽ വലുപ്പങ്ങൾ (2 GB-യിൽ കൂടുതൽ), അസിൻക്രണസ് റൈറ്റിംഗ്, TCP എന്നിവയെ ട്രാൻസ്പോർട്ട് പ്രോട്ടോക്കോൾ ആയി പിന്തുണയ്ക്കുകയും ചെയ്തു. വൈഡ് ഏരിയ നെറ്റ്‌വർക്കുകൾക്കുള്ള (WAN) ഫയൽ സിസ്റ്റങ്ങളുടെ വികസനത്തിനുള്ള ദിശ NFSv3 സജ്ജമാക്കി. 2000-ൽ, RFC 3010 (RFC 3530 ആയി പരിഷ്കരിച്ചു) എന്റർപ്രൈസ് പരിതസ്ഥിതിയിൽ NFS കൊണ്ടുവന്നു. സൺ സ്റ്റേറ്റ്ഫുൾ പിന്തുണയോടെ കൂടുതൽ സുരക്ഷിതമായ NFSv4 അവതരിപ്പിച്ചു (NFS-ന്റെ മുൻ പതിപ്പുകൾ സ്‌റ്റേറ്റ്‌ഫുൾ സ്റ്റോറേജിനെ പിന്തുണച്ചിരുന്നില്ല, അതായത് അവ സ്‌റ്റേറ്റ്‌ലെസ് എന്ന് തരംതിരിച്ചിട്ടുണ്ട്). നിലവിൽ, NFS-ന്റെ ഏറ്റവും പുതിയ പതിപ്പ് പതിപ്പ് 4.1 ആണ്, RFC 5661-ൽ നിർവചിച്ചിരിക്കുന്നത്, ഇത് പ്രോട്ടോക്കോളിലേക്ക് വിപുലീകരിക്കുന്നതിലൂടെ ചേർക്കുന്നു pNFSവിതരണം ചെയ്ത സെർവറുകളുടെ സമാന്തര പ്രവേശനത്തിനുള്ള പിന്തുണ ചേർത്തു.

NFS-ന്റെ ചരിത്രം, അതിന്റെ പതിപ്പുകൾ വിവരിക്കുന്ന നിർദ്ദിഷ്ട RFC-കൾ ഉൾപ്പെടെ, ചിത്രം 1-ൽ കാണിച്ചിരിക്കുന്നു.

അതിശയകരമെന്നു പറയട്ടെ, ഏകദേശം 30 വർഷമായി NFS വികസിച്ചുകൊണ്ടിരിക്കുന്നു. മികച്ച സ്കേലബിളിറ്റിയും പ്രകടനവും സേവന സവിശേഷതകളുടെ ഗുണനിലവാരവും ഉള്ള അസാധാരണമായ സ്ഥിരതയുള്ളതും പോർട്ടബിൾ നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റവുമാണ് ഇത്. ഒരു നെറ്റ്‌വർക്കിനുള്ളിൽ ആശയവിനിമയം നടത്തുമ്പോൾ വേഗത കൂടുകയും കാലതാമസം കുറയുകയും ചെയ്യുന്നതിനാൽ, ഒരു നെറ്റ്‌വർക്കിനുള്ളിൽ ഒരു ഫയൽ സിസ്റ്റം നടപ്പിലാക്കുന്നതിനുള്ള ഒരു ജനപ്രിയ മാർഗമായി NFS തുടരുന്നു. പ്രാദേശിക നെറ്റ്‌വർക്കുകളുടെ കാര്യത്തിൽ പോലും, വെർച്വൽ മെഷീനുകൾക്ക് അധിക മൊബിലിറ്റി നൽകുന്നതിന് നെറ്റ്‌വർക്കിൽ ഡാറ്റ സംഭരിക്കുന്നതിന് വിർച്ച്വലൈസേഷൻ പ്രോത്സാഹിപ്പിക്കുന്നു. വെർച്വൽ ഇൻഫ്രാസ്ട്രക്ചറുകൾ ഒപ്റ്റിമൈസ് ചെയ്യാൻ ലക്ഷ്യമിട്ടുള്ള ഏറ്റവും പുതിയ കമ്പ്യൂട്ടിംഗ് എൻവയോൺമെന്റ് മോഡലുകളും എൻഎഫ്എസ് പിന്തുണയ്ക്കുന്നു.

NFS ആർക്കിടെക്ചർ

NFS ഒരു സാധാരണ ക്ലയന്റ്-സെർവർ ആർക്കിടെക്ചറൽ മോഡൽ ഉപയോഗിക്കുന്നു (ചിത്രം 2 ൽ കാണിച്ചിരിക്കുന്നത് പോലെ). ക്ലയന്റുകളെ ബന്ധിപ്പിക്കുന്ന പങ്കിട്ട ഫയൽ സിസ്റ്റവും സംഭരണവും നടപ്പിലാക്കുന്നതിനുള്ള ഉത്തരവാദിത്തം സെർവറാണ്. ക്ലയന്റ് ലോക്കൽ ഫയൽ സ്‌പെയ്‌സിൽ ഘടിപ്പിച്ചിട്ടുള്ള ഒരു പങ്കിട്ട ഫയൽ സിസ്റ്റത്തിലേക്ക് ഒരു ഉപയോക്തൃ ഇന്റർഫേസ് നടപ്പിലാക്കുന്നു.

ചിത്രം 2. NFS ആർക്കിടെക്ചറിൽ ക്ലയന്റ്-സെർവർ മോഡൽ നടപ്പിലാക്കൽ

Linux®-ൽ, ഒരു വെർച്വൽ ഫയൽ സിസ്റ്റം സ്വിച്ച് (VFS) ഒന്നിലധികം ഫയൽ സിസ്റ്റങ്ങളെ (ഉദാഹരണത്തിന്, ഒരു CD-ROM-ലെ ഒരു ISO 9660 ഫയൽ സിസ്റ്റവും ഒരു ലോക്കൽ ഹാർഡ് ഡ്രൈവിലെ ഒരു ext3fs ഫയൽ സിസ്റ്റവും) ഒരേസമയം ഒരൊറ്റ ഹോസ്റ്റിൽ പിന്തുണയ്ക്കുന്നതിനുള്ള മാർഗങ്ങൾ നൽകുന്നു. . ഏത് ഡ്രൈവിലേക്കാണ് അഭ്യർത്ഥന നടത്തുന്നതെന്നും അതിനാൽ അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യുന്നതിന് ഏത് ഫയൽ സിസ്റ്റം ഉപയോഗിക്കണമെന്നും വെർച്വൽ സ്വിച്ച് നിർണ്ണയിക്കുന്നു. അതിനാൽ, ലിനക്സിൽ ഉപയോഗിക്കുന്ന മറ്റ് ഫയൽ സിസ്റ്റങ്ങളുടെ അതേ അനുയോജ്യത എൻഎഫ്എസിനുണ്ട്. NFS-ന്റെ ഒരേയൊരു വ്യത്യാസം, ഹോസ്റ്റിൽ പ്രാദേശികമായി പ്രോസസ്സ് ചെയ്യുന്നതിനുപകരം, I/O അഭ്യർത്ഥനകൾ നിർവ്വഹണത്തിനായി നെറ്റ്‌വർക്കിലേക്ക് അയയ്‌ക്കാൻ കഴിയും എന്നതാണ്.

സ്വീകരിച്ച അഭ്യർത്ഥന NFS ആണെന്ന് VFS നിർണ്ണയിക്കുകയും അത് കേർണലിൽ സ്ഥിതിചെയ്യുന്ന NFS ഹാൻഡ്‌ലറിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു. NFS ഹാൻഡ്‌ലർ I/O അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യുകയും ഒരു NFS നടപടിക്രമത്തിലേക്ക് വിവർത്തനം ചെയ്യുകയും ചെയ്യുന്നു (തുറക്കുക, ആക്‌സസ് ചെയ്യുക, സൃഷ്‌ടിക്കുക, വായിക്കുക, അടയ്ക്കുക, നീക്കംചെയ്യുക, മുതലായവ). ഒരു പ്രത്യേക RFC സ്പെസിഫിക്കേഷനിൽ വിവരിച്ചിരിക്കുന്ന ഈ നടപടിക്രമങ്ങൾ NFS പ്രോട്ടോക്കോളിന്റെ സ്വഭാവം നിർവ്വചിക്കുന്നു. അഭ്യർത്ഥനയെ ആശ്രയിച്ച് ആവശ്യമായ നടപടിക്രമം തിരഞ്ഞെടുക്കുകയും RPC (വിദൂര നടപടിക്രമ കോൾ) സാങ്കേതികവിദ്യ ഉപയോഗിച്ച് നടപ്പിലാക്കുകയും ചെയ്യുന്നു. അതിന്റെ പേര് സൂചിപ്പിക്കുന്നത് പോലെ, വിവിധ സിസ്റ്റങ്ങൾക്കിടയിൽ പ്രൊസീജർ കോളുകൾ ചെയ്യാൻ RPC അനുവദിക്കുന്നു. ആർ‌പി‌സി സേവനം ഒരു എൻ‌എഫ്‌എസ് അഭ്യർത്ഥന അതിന്റെ ആർഗ്യുമെന്റുകൾക്കൊപ്പം സംയോജിപ്പിച്ച് ഫലം ഉചിതമായ റിമോട്ട് ഹോസ്റ്റിലേക്ക് അയയ്‌ക്കുന്നു, തുടർന്ന് അഭ്യർത്ഥനയ്‌ക്ക് അത് തിരികെ നൽകുന്നതിന് പ്രതികരണത്തിന്റെ രസീതും പ്രോസസ്സിംഗും നിരീക്ഷിക്കുന്നു.

RPC-ൽ ഒരു പ്രധാന XDR ലെയറും ഉൾപ്പെടുന്നു ( ബാഹ്യ ഡാറ്റ പ്രാതിനിധ്യം- സ്വതന്ത്ര ഡാറ്റ പ്രാതിനിധ്യം), എല്ലാ NFS ഉപയോക്താക്കളും ഒരേ ഡാറ്റ തരങ്ങൾക്കായി ഒരേ ഫോർമാറ്റ് ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്നു. ഒരു പ്ലാറ്റ്‌ഫോം ഒരു അഭ്യർത്ഥന അയയ്‌ക്കുമ്പോൾ, അത് ഉപയോഗിക്കുന്ന ഡാറ്റ തരവും അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യുന്ന ഹോസ്റ്റിൽ ഉപയോഗിക്കുന്ന ഡാറ്റ തരവും വ്യത്യസ്തമായിരിക്കാം. വ്യത്യസ്ത ആർക്കിടെക്ചറുകൾ ഉപയോഗിക്കുന്ന പ്ലാറ്റ്‌ഫോമുകൾക്ക് ഫയൽ സിസ്റ്റങ്ങൾ പരസ്പരം പ്രവർത്തിക്കാനും പങ്കിടാനും കഴിയുന്ന തരത്തിൽ തരങ്ങളെ ഒരു സ്റ്റാൻഡേർഡ് പ്രാതിനിധ്യത്തിലേക്ക് (XDR) പരിവർത്തനം ചെയ്യുന്ന ജോലി XDR സാങ്കേതികവിദ്യ ശ്രദ്ധിക്കുന്നു. ഫ്ലോട്ട് പോലുള്ള തരങ്ങൾക്കുള്ള ബിറ്റ് ഫോർമാറ്റും കോൺസ്റ്റന്റ്, വേരിയബിൾ ലെങ്ത് അറേകൾ പോലുള്ള തരങ്ങൾക്കുള്ള ബൈറ്റ് ഓർഡറും XDR നിർവചിക്കുന്നു. എക്സ്ഡിആർ പ്രാഥമികമായി എൻഎഫ്എസിലെ ഉപയോഗത്തിന് പേരുകേട്ടതാണെങ്കിലും, വ്യത്യസ്ത ആർക്കിടെക്ചറുകളിൽ ഒരേ പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കേണ്ട എല്ലാ സാഹചര്യങ്ങളിലും ഈ സ്പെസിഫിക്കേഷൻ ഉപയോഗപ്രദമാകും.

XDR ഡാറ്റയെ ഒരു സ്റ്റാൻഡേർഡ് പ്രാതിനിധ്യത്തിലേക്ക് വിവർത്തനം ചെയ്ത ശേഷം, ഒരു നിർദ്ദിഷ്ട ട്രാൻസ്പോർട്ട് പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച് നെറ്റ്‌വർക്കിലൂടെ അഭ്യർത്ഥന അയയ്ക്കുന്നു. NFS-ന്റെ ആദ്യകാല നിർവ്വഹണങ്ങളിൽ UDP ഉപയോഗിച്ചിരുന്നു, എന്നാൽ ഇന്ന് TCP കൂടുതൽ വിശ്വാസ്യതയ്ക്കായി ഉപയോഗിക്കുന്നു.

NFS സെർവർ ഭാഗത്തും സമാനമായ ഒരു അൽഗോരിതം ഉപയോഗിക്കുന്നു. അഭ്യർത്ഥന നെറ്റ്‌വർക്ക് സ്റ്റാക്കിലൂടെ RPC/XDR ലെയറിലൂടെയും (സെർവർ ആർക്കിടെക്ചർ അനുസരിച്ച് ഡാറ്റ തരങ്ങൾ പരിവർത്തനം ചെയ്യുന്നതിന്) അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യുന്നതിന് ഉത്തരവാദിയായ NFS സെർവറിലേക്കും സഞ്ചരിക്കുന്നു. അവിടെ, അഭ്യർത്ഥന NFS ഡെമണിലേക്ക് അത് അഭിസംബോധന ചെയ്യുന്ന ടാർഗെറ്റ് ഫയൽ സിസ്റ്റം നിർണ്ണയിക്കാൻ കൈമാറുന്നു, തുടർന്ന് ലോക്കൽ ഡിസ്കിൽ ആ ഫയൽ സിസ്റ്റം ആക്സസ് ചെയ്യുന്നതിന് വീണ്ടും VFS-ലേക്ക് പോകുന്നു. ഈ പ്രക്രിയയുടെ പൂർണ്ണമായ ഒരു ഡയഗ്രം ചിത്രം 3-ൽ കാണിച്ചിരിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, സെർവറിന്റെ ലോക്കൽ ഫയൽ സിസ്റ്റം ഒരു സാധാരണ ലിനക്സ് ഫയൽ സിസ്റ്റമാണ്, ഉദാഹരണത്തിന്, ext4fs. സാരാംശത്തിൽ, ഈ പദത്തിന്റെ പരമ്പരാഗത അർത്ഥത്തിൽ എൻഎഫ്എസ് ഒരു ഫയൽ സിസ്റ്റമല്ല, ഫയൽ സിസ്റ്റങ്ങളിലേക്കുള്ള റിമോട്ട് ആക്‌സസിനുള്ള ഒരു പ്രോട്ടോക്കോൾ ആണ്.

നീണ്ട കാലതാമസമുള്ള നെറ്റ്‌വർക്കുകൾക്ക്, NFSv4 ഒരു പ്രത്യേക കോമ്പൗണ്ട് നടപടിക്രമം വാഗ്ദാനം ചെയ്യുന്നു ( സംയുക്ത നടപടിക്രമം). നെറ്റ്‌വർക്കിലൂടെ അഭ്യർത്ഥനകൾ അയക്കുന്നതിനുള്ള ചെലവ് കുറയ്ക്കുന്നതിന് ഒരൊറ്റ അഭ്യർത്ഥനയ്ക്കുള്ളിൽ ഒന്നിലധികം RPC കോളുകൾ വിളിക്കാൻ ഈ നടപടിക്രമം നിങ്ങളെ അനുവദിക്കുന്നു. പ്രതികരണങ്ങൾ സ്വീകരിക്കുന്നതിനുള്ള ഒരു കോൾബാക്ക് ഫംഗ്‌ഷൻ മെക്കാനിസവും ഈ നടപടിക്രമം നടപ്പിലാക്കുന്നു.

NFS പ്രോട്ടോക്കോൾ

ഒരു ക്ലയന്റ് NFS ഉപയോഗിക്കാൻ തുടങ്ങുമ്പോൾ, ആദ്യത്തെ പ്രവർത്തനം ഒരു മൗണ്ട് ഓപ്പറേഷൻ നടത്തുക എന്നതാണ്, അതായത് റിമോട്ട് ഫയൽ സിസ്റ്റം ലോക്കൽ ഫയൽ സിസ്റ്റം സ്പേസിലേക്ക് മൌണ്ട് ചെയ്യുക. ഈ പ്രക്രിയ ആരംഭിക്കുന്നത് മൌണ്ട് പ്രൊസീജറിലേക്കുള്ള (ലിനക്സ് സിസ്റ്റം ഫംഗ്ഷനുകളിലൊന്ന്) ഒരു കോളിലൂടെയാണ്, ഇത് VFS വഴി NFS ഘടകത്തിലേക്ക് റീഡയറക്ട് ചെയ്യപ്പെടുന്നു. തുടർന്ന്, റിമോട്ട് സെർവറിലെ get_port ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു RPC കോൾ മൗണ്ടിംഗിനായി ഉപയോഗിക്കുന്ന പോർട്ട് നമ്പർ നിർണ്ണയിക്കുന്നു, കൂടാതെ ക്ലയന്റ് RPC വഴി ഒരു മൗണ്ട് അഭ്യർത്ഥന അയയ്‌ക്കുന്നു. സെർവർ വശത്തുള്ള ഈ അഭ്യർത്ഥന ഒരു പ്രത്യേക ഡെമൺ rpc.mountd ആണ് പ്രോസസ്സ് ചെയ്യുന്നത്, അത് മൗണ്ട് പ്രോട്ടോക്കോളിന് ഉത്തരവാദിയാണ് ( മൗണ്ട് പ്രോട്ടോക്കോൾ). ക്ലയന്റ് ആവശ്യപ്പെട്ട ഫയൽ സിസ്റ്റം നൽകിയിരിക്കുന്ന സെർവറിൽ ലഭ്യമായ സിസ്റ്റങ്ങളുടെ ലിസ്റ്റിലാണോ എന്ന് ഡെമൺ പരിശോധിക്കുന്നു. അഭ്യർത്ഥിച്ച സിസ്റ്റം നിലവിലുണ്ടെങ്കിൽ ക്ലയന്റിന് അതിലേക്ക് ആക്സസ് ഉണ്ടെങ്കിൽ, മൗണ്ട് RPC പ്രതികരണം ഒരു ഫയൽ സിസ്റ്റം ഡിസ്ക്രിപ്റ്റർ വ്യക്തമാക്കുന്നു. ക്ലയന്റ് ലോക്കൽ, റിമോട്ട് മൗണ്ട് പോയിന്റുകളെ കുറിച്ചുള്ള വിവരങ്ങൾ സൂക്ഷിക്കുന്നു കൂടാതെ I/O അഭ്യർത്ഥനകൾ നടത്താനും കഴിയും. ഒരു സുരക്ഷാ കാഴ്ചപ്പാടിൽ നിന്ന് മൗണ്ട് പ്രോട്ടോക്കോൾ സുരക്ഷിതമല്ല, അതിനാൽ NFSv4 പകരം ആന്തരിക RPC കോളുകൾ ഉപയോഗിക്കുന്നു, അതിന് മൗണ്ട് പോയിന്റുകൾ നിയന്ത്രിക്കാനും കഴിയും.

ഒരു ഫയൽ വായിക്കാൻ, നിങ്ങൾ ആദ്യം അത് തുറക്കണം. RPC-യിൽ ഓപ്പൺ നടപടിക്രമം ഇല്ല; പകരം, മൗണ്ട് ചെയ്ത ഫയൽ സിസ്റ്റത്തിൽ നിർദ്ദിഷ്ട ഫയലും ഡയറക്ടറിയും നിലവിലുണ്ടോ എന്ന് ക്ലയന്റ് പരിശോധിക്കുന്നു. ഡയറക്‌ടറിയിലേക്ക് ഒരു GETATTR RPC അഭ്യർത്ഥന നടത്തി ക്ലയന്റ് ആരംഭിക്കുന്നു, അത് ഡയറക്‌ടറിയുടെ ആട്രിബ്യൂട്ടുകൾ അല്ലെങ്കിൽ ഡയറക്ടറി നിലവിലില്ല എന്നതിന്റെ സൂചകം നൽകുന്നു. അടുത്തതായി, ഫയലിന്റെ സാന്നിധ്യം പരിശോധിക്കുന്നതിനായി, ക്ലയന്റ് ഒരു LOOKUP RPC അഭ്യർത്ഥന നൽകുന്നു. ഫയൽ നിലവിലുണ്ടെങ്കിൽ, ഫയലിന്റെ ആട്രിബ്യൂട്ടുകൾ കണ്ടെത്തുന്നതിന് അതിൽ ഒരു GETATTR RPC അഭ്യർത്ഥന നടത്തുന്നു. വിജയകരമായ LOOKUP, GETATTR കോളുകളിൽ നിന്ന് ലഭിച്ച വിവരങ്ങൾ ഉപയോഗിച്ച്, ഭാവി അഭ്യർത്ഥനകൾക്കായി ഉപയോക്താവിന് നൽകുന്ന ഒരു ഫയൽ ഹാൻഡിൽ ക്ലയന്റ് സൃഷ്ടിക്കുന്നു.

റിമോട്ട് ഫയൽ സിസ്റ്റത്തിൽ ഫയൽ തിരിച്ചറിഞ്ഞുകഴിഞ്ഞാൽ, ക്ലയന്റിന് RPC റീഡ് അഭ്യർത്ഥനകൾ നൽകാം. ഈ അഭ്യർത്ഥനയിൽ ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ, ഒരു സംസ്ഥാനം, ഒരു ഓഫ്സെറ്റ്, വായിക്കാനുള്ള ബൈറ്റുകളുടെ എണ്ണം എന്നിവ അടങ്ങിയിരിക്കുന്നു. ക്ലയന്റ് സ്റ്റേറ്റ് ഉപയോഗിക്കുന്നു ( സംസ്ഥാനം) ഈ സമയത്ത് ഓപ്പറേഷൻ നടത്താൻ കഴിയുമോ എന്ന് നിർണ്ണയിക്കാൻ, അതായത്. ഫയൽ പൂട്ടിയിട്ടുണ്ടോ? ഓഫ്സെറ്റ് ( ഓഫ്സെറ്റ്) ഏത് സ്ഥാനത്താണ് വായന ആരംഭിക്കേണ്ടതെന്ന് സൂചിപ്പിക്കുന്നു, കൂടാതെ ബൈറ്റ് കൗണ്ടർ ( എണ്ണുക) എത്ര ബൈറ്റുകൾ വായിക്കണമെന്ന് നിർണ്ണയിക്കുന്നു. ഒരു RPC റീഡ് കോളിന്റെ ഫലമായി, സെർവർ എല്ലായ്‌പ്പോഴും അഭ്യർത്ഥിച്ച അത്രയും ബൈറ്റുകൾ തിരികെ നൽകുന്നില്ല, എന്നാൽ തിരികെ നൽകിയ ഡാറ്റയ്‌ക്കൊപ്പം ക്ലയന്റിലേക്ക് എത്ര ബൈറ്റുകൾ അയച്ചുവെന്ന് അത് എല്ലായ്പ്പോഴും റിപ്പോർട്ടുചെയ്യുന്നു.

NFS-ൽ ഇന്നൊവേഷൻ

NFS-ന്റെ ഏറ്റവും പുതിയ രണ്ട് പതിപ്പുകൾ താൽപ്പര്യമുണർത്തുന്നവയാണ് - 4, 4.1, ഉദാഹരണമായി നിങ്ങൾക്ക് NFS സാങ്കേതികവിദ്യയുടെ പരിണാമത്തിന്റെ ഏറ്റവും പ്രധാനപ്പെട്ട വശങ്ങൾ പഠിക്കാൻ കഴിയും.

NFSv4, മൗണ്ടിംഗ്, ലോക്കിംഗ് തുടങ്ങിയ ഫയൽ മാനേജ്മെന്റ് ജോലികൾ ചെയ്യുന്നതിന് മുമ്പ് ലഭ്യമായിരുന്നു. പ്രത്യേക അധിക പ്രോട്ടോക്കോളുകൾ ഉണ്ടായിരുന്നു. NFSv4-ൽ, ഫയൽ മാനേജ്മെന്റ് പ്രക്രിയ ഒരു പ്രോട്ടോക്കോളിലേക്ക് ലളിതമാക്കി; കൂടാതെ, ഈ പതിപ്പ് മുതൽ, UDP ഒരു ട്രാൻസ്പോർട്ട് പ്രോട്ടോക്കോൾ ആയി ഉപയോഗിക്കില്ല. NFSv4 UNIX, Windows® ഫയൽ ആക്സസ് സെമാന്റിക്സ് എന്നിവയ്ക്കുള്ള പിന്തുണ ഉൾക്കൊള്ളുന്നു, ഇത് മറ്റ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലേക്ക് NFS സ്വാഭാവികമായി സംയോജിപ്പിക്കാൻ അനുവദിക്കുന്നു.

NFSv4.1 എന്ന ആശയം അവതരിപ്പിച്ചു സമാന്തര NFS(സമാന്തര NFS - pNFS). ഉയർന്ന അളവിലുള്ള സ്കേലബിളിറ്റി നൽകാൻ, NFSv4.1 ഒരു ആർക്കിടെക്ചർ നടപ്പിലാക്കുന്നു, അതിൽ ഡാറ്റയും മെറ്റാഡാറ്റയും ( അടയാളപ്പെടുത്തൽ) ക്ലസ്റ്റേർഡ് ഫയൽ സിസ്റ്റങ്ങളിൽ ഇത് എങ്ങനെ ചെയ്യപ്പെടുന്നു എന്നതിന് സമാനമായി ഉപകരണങ്ങളിലുടനീളം വിതരണം ചെയ്യുന്നു. ൽ കാണിച്ചിരിക്കുന്നതുപോലെ, pNFS ആവാസവ്യവസ്ഥയെ മൂന്ന് ഘടകങ്ങളായി വിഭജിക്കുന്നു: ക്ലയന്റ്, സെർവർ, സംഭരണം. ഈ സാഹചര്യത്തിൽ, രണ്ട് ചാനലുകൾ പ്രത്യക്ഷപ്പെടുന്നു: ഒന്ന് ഡാറ്റ കൈമാറുന്നതിനും മറ്റൊന്ന് നിയന്ത്രണ കമാൻഡുകൾ കൈമാറുന്നതിനും. രണ്ട്-ചാനൽ ആർക്കിടെക്ചർ നൽകുന്ന, വിവരിക്കുന്ന മെറ്റാഡാറ്റയിൽ നിന്ന് pNFS ഡാറ്റ വേർതിരിക്കുന്നു. ഒരു ക്ലയന്റ് ഒരു ഫയൽ ആക്സസ് ചെയ്യാൻ ആഗ്രഹിക്കുമ്പോൾ, സെർവർ അതിനെ "മാർക്ക്അപ്പ്" ഉപയോഗിച്ച് മെറ്റാഡാറ്റ അയയ്ക്കുന്നു. മെറ്റാഡാറ്റയിൽ സ്റ്റോറേജ് ഡിവൈസുകളിലെ ഫയലിന്റെ സ്ഥാനം സംബന്ധിച്ച വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ക്ലയന്റിന് ഈ വിവരം ലഭിച്ചുകഴിഞ്ഞാൽ, സെർവറുമായി സംവദിക്കാതെ തന്നെ നേരിട്ട് സ്റ്റോറേജ് ആക്സസ് ചെയ്യാൻ കഴിയും, സ്കേലബിളിറ്റിയും പ്രകടനവും മെച്ചപ്പെടുത്തുന്നു. ക്ലയന്റ് ഫയലുമായി പ്രവർത്തിക്കുന്നത് പൂർത്തിയാക്കുമ്പോൾ, ഫയലിൽ വരുത്തിയ മാറ്റങ്ങളും അതിന്റെ "മാർക്ക്അപ്പും" അത് സ്ഥിരീകരിക്കുന്നു. ആവശ്യമെങ്കിൽ, ക്ലയന്റിൽ നിന്ന് മാർക്ക്അപ്പ് ഉപയോഗിച്ച് സെർവറിന് മെറ്റാഡാറ്റ അഭ്യർത്ഥിക്കാം.

pNFS-ന്റെ ആവിർഭാവത്തോടെ, NFS പ്രോട്ടോക്കോളിൽ അത്തരം ഒരു സംവിധാനത്തെ പിന്തുണയ്ക്കുന്നതിനായി നിരവധി പുതിയ പ്രവർത്തനങ്ങൾ ചേർത്തു. സെർവറിൽ നിന്ന് മെറ്റാഡാറ്റ വീണ്ടെടുക്കാൻ LayoutGet രീതി ഉപയോഗിക്കുന്നു, ക്ലയന്റ് മെറ്റാഡാറ്റ "സൌജന്യമാക്കുന്നു" ലേഔട്ട് റിട്ടേൺ രീതി ഉപയോഗിക്കുന്നു, കൂടാതെ LayoutCommit രീതി ക്ലയന്റിൽനിന്ന് ലഭിച്ച "ലേഔട്ട്" മറ്റ് ഉപയോക്താക്കൾക്ക് ലഭ്യമാകുന്നതിനായി സ്റ്റോറേജിലേക്ക് ലോഡ് ചെയ്യുന്നു. LayoutRecall രീതി ഉപയോഗിച്ച് സെർവറിന് ക്ലയന്റിൽ നിന്ന് മെറ്റാഡാറ്റ തിരിച്ചുവിളിക്കാൻ കഴിയും. സമാന്തര ആക്‌സസും ഉയർന്ന പ്രകടനവും നൽകുന്നതിനായി "ടാഗ് ചെയ്‌ത" മെറ്റാഡാറ്റ ഒന്നിലധികം സംഭരണ ​​ഉപകരണങ്ങളിൽ വിതരണം ചെയ്യുന്നു.

ഡാറ്റയും മെറ്റാഡാറ്റയും സ്റ്റോറേജ് ഉപകരണങ്ങളിൽ സംഭരിച്ചിരിക്കുന്നു. ലഭിച്ച മാർക്ക്അപ്പിനെ അടിസ്ഥാനമാക്കി ക്ലയന്റുകൾക്ക് നേരിട്ടുള്ള I/O അഭ്യർത്ഥനകൾ നടത്താനാകും, കൂടാതെ NFSv4.1 സെർവർ മെറ്റാഡാറ്റ സംഭരിക്കുകയും നിയന്ത്രിക്കുകയും ചെയ്യുന്നു. ഈ പ്രവർത്തനം തന്നെ പുതിയതല്ല, എന്നാൽ സ്റ്റോറേജ് ഡിവൈസുകൾ ആക്സസ് ചെയ്യുന്നതിനുള്ള വിവിധ രീതികൾക്കുള്ള പിന്തുണ pNFS ചേർത്തു. ഇന്ന്, pNFS ബ്ലോക്ക് പ്രോട്ടോക്കോളുകൾ (ഫൈബർ ചാനൽ), ഒബ്ജക്റ്റ് പ്രോട്ടോക്കോളുകൾ, NFS (pNFS രൂപത്തിൽ പോലും) എന്നിവയുടെ ഉപയോഗത്തെ പിന്തുണയ്ക്കുന്നു.

NFS-ന്റെ വികസനം തുടരുന്നു, 2010 സെപ്റ്റംബറിൽ NFSv4.2-നുള്ള ആവശ്യകതകൾ പ്രസിദ്ധീകരിച്ചു. വിർച്ച്വലൈസേഷനിലേക്കുള്ള ഡാറ്റ സ്റ്റോറേജ് ടെക്നോളജികളുടെ നിലവിലുള്ള മൈഗ്രേഷനുമായി ബന്ധപ്പെട്ടതാണ് ചില കണ്ടുപിടുത്തങ്ങൾ. ഉദാഹരണത്തിന്, ഒരു ഹൈപ്പർവൈസർ ഉള്ള വെർച്വൽ എൻവയോൺമെന്റുകളിൽ, ഡാറ്റ ഡ്യൂപ്ലിക്കേഷൻ (ഒന്നിലധികം ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ ഒരേ ഡാറ്റ റീഡിംഗ്/എഴുത്ത്, കാഷെ ചെയ്യൽ) സംഭവിക്കാൻ സാധ്യതയുണ്ട്. ഇക്കാരണത്താൽ, സ്റ്റോറേജ് സിസ്റ്റം മൊത്തത്തിൽ തനിപ്പകർപ്പ് സംഭവിക്കുന്നത് എവിടെയാണെന്ന് മനസ്സിലാക്കുന്നത് അഭികാമ്യമാണ്. ക്ലയന്റ് കാഷെ സ്ഥലവും മൊത്തത്തിലുള്ള സംഭരണ ​​ശേഷിയും ലാഭിക്കാൻ ഈ സമീപനം സഹായിക്കും. NFSv4.2 ഈ പ്രശ്നം പരിഹരിക്കാൻ "പങ്കിട്ട ബ്ലോക്കുകളുടെ ബ്ലോക്ക് മാപ്പ്" ഉപയോഗിക്കാൻ നിർദ്ദേശിക്കുന്നു. ആധുനിക സ്റ്റോറേജ് സിസ്റ്റങ്ങൾ അവരുടേതായ ആന്തരിക കമ്പ്യൂട്ടിംഗ് പവർ കൊണ്ട് സജ്ജീകരിച്ചിരിക്കുന്നതിനാൽ, സ്റ്റോറേജ് ഉപകരണത്തിൽ തന്നെ കാര്യക്ഷമമായി ചെയ്യാൻ കഴിയുമ്പോൾ ഒരു ആന്തരിക നെറ്റ്‌വർക്കിലുടനീളം ഡാറ്റ പകർത്തുന്നതിന്റെ ഭാരം കുറയ്ക്കുന്നതിന് സെർവർ സൈഡ് കോപ്പിംഗ് അവതരിപ്പിക്കുന്നു. ഫ്ലാഷ് മെമ്മറിയ്‌ക്കായുള്ള സബ്-ഫയൽ കാഷിംഗ്, ക്ലയന്റ്-സൈഡ് I/O ട്യൂണിംഗ് ശുപാർശകൾ (മാപ്പഡ്‌വൈസ് ഉപയോഗിക്കുന്നത് പോലുള്ളവ) എന്നിവ മറ്റ് പുതുമകളിൽ ഉൾപ്പെടുന്നു.

NFS ഇതരമാർഗങ്ങൾ

യുണിക്സിലും ലിനക്സിലും എൻഎഫ്എസ് ഏറ്റവും പ്രചാരമുള്ള നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റമാണെങ്കിലും, മറ്റ് നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റങ്ങളുണ്ട്. Windows® പ്ലാറ്റ്‌ഫോമിൽ, SMB ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്നത്, എന്നും അറിയപ്പെടുന്നു സിഐഎഫ്എസ്; എന്നിരുന്നാലും, വിൻഡോസ് ഒഎസും എൻഎഫ്എസ് പിന്തുണയ്ക്കുന്നു, അതുപോലെ ലിനക്സ് എസ്എംബിയെ പിന്തുണയ്ക്കുന്നു.

Linux-ൽ പിന്തുണയ്‌ക്കുന്ന ഏറ്റവും പുതിയ വിതരണം ചെയ്‌ത ഫയൽ സിസ്റ്റങ്ങളിലൊന്നായ Ceph, ഒരു തകരാർ-സഹിഷ്ണുതയുള്ള POSIX-കംപ്ലയന്റ് ഫയൽ സിസ്റ്റമായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. സെഫിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ വിഭാഗത്തിൽ കാണാം.

ഫയൽ സിസ്റ്റങ്ങളായ OpenAFS (കാർനെഗീ മെലോൺ യൂണിവേഴ്സിറ്റിയിലും IBM കോർപ്പറേഷനിലും വികസിപ്പിച്ച ആൻഡ്രൂ വിതരണം ചെയ്ത ഫയൽ സിസ്റ്റത്തിന്റെ ഓപ്പൺ സോഴ്സ് പതിപ്പ്), GlusterFS (സ്കേലബിൾ ഡാറ്റ സ്റ്റോറേജ് സംഘടിപ്പിക്കുന്നതിനുള്ള ഒരു പൊതു ആവശ്യത്തിനുള്ള വിതരണം ചെയ്ത ഫയൽ സിസ്റ്റം), ലസ്റ്റർ (വൻതോതിൽ) എന്നിവയും എടുത്തുപറയേണ്ടതാണ്. ക്ലസ്റ്റർ സൊല്യൂഷനുകൾക്കായുള്ള സമാന്തര നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം). ഈ ഓപ്പൺ സോഴ്സ് സിസ്റ്റങ്ങളെല്ലാം ഡിസ്ട്രിബ്യൂട്ടഡ് സ്റ്റോറേജ് നിർമ്മിക്കാൻ ഉപയോഗിക്കാം.

ഉപസംഹാരം

NFS ഫയൽ സിസ്റ്റത്തിന്റെ വികസനം തുടരുന്നു. ലോ-എൻഡ്, എംബഡഡ്, ഹൈ-എൻഡ് സൊല്യൂഷനുകളെ പിന്തുണയ്ക്കാൻ കഴിയുന്ന ലിനക്സ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് സമാനമായി, വ്യക്തികൾക്കും സ്ഥാപനങ്ങൾക്കും അനുയോജ്യമായ സ്കേലബിൾ സ്റ്റോറേജ് സൊല്യൂഷനുകൾക്കായി എൻഎഫ്എസ് ഒരു ആർക്കിടെക്ചർ നൽകുന്നു. NFS ഇതിനകം നടത്തിയ യാത്രയും അതിന്റെ ഭാവി വികസനത്തിനുള്ള സാധ്യതകളും നോക്കുമ്പോൾ, ഫയൽ സ്റ്റോറേജ് സാങ്കേതികവിദ്യകൾ എങ്ങനെ നടപ്പിലാക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നു എന്നതിനെക്കുറിച്ചുള്ള നമ്മുടെ ചിന്താഗതിയെ ഈ ഫയൽ സിസ്റ്റം മാറ്റുന്നത് തുടരുമെന്ന് വ്യക്തമാകും.

NFS (നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റം) ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനും ക്രമീകരിക്കുന്നതിനുമുള്ള നിർദ്ദേശങ്ങൾ ഞാൻ നൽകുന്നു. NFS ഒരു നെറ്റ്‌വർക്ക് ഫയൽ സിസ്റ്റമാണ്, ഈ ഫയലുകളും ഡയറക്‌ടറികളും ലോക്കൽ ആയതുപോലെ ഒരു റിമോട്ട് കമ്പ്യൂട്ടറിൽ (സെർവർ) ഫയലുകളും ഡയറക്‌ടറികളും ആക്‌സസ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. പങ്കിട്ട ഡാറ്റ ഒരു പ്രത്യേക മെഷീനിൽ (ഡാറ്റാ വെയർഹൗസ്) സംഭരിക്കുകയും നെറ്റ്‌വർക്കിലെ മറ്റ് മെഷീനുകൾക്ക് ലഭ്യമാകുകയും ചെയ്യുന്നതിനാൽ വ്യക്തിഗത വർക്ക്സ്റ്റേഷനുകൾക്ക് അവരുടേതായ ഡിസ്ക് സ്പേസ് കുറച്ച് മാത്രമേ ഉപയോഗിക്കാനാകൂ എന്നതാണ് അത്തരമൊരു സിസ്റ്റത്തിന്റെ പ്രധാന നേട്ടം. NFS എന്നത് ഒരു ക്ലയന്റ്-സെർവർ ആപ്ലിക്കേഷനാണ്, അവിടെ സ്റ്റോറേജ് റോൾ സെർവറിലേക്ക് നിയോഗിക്കപ്പെടുന്നു. ഓരോ നെറ്റ്‌വർക്ക് പങ്കാളിയും സെർവറിന്റെ നെറ്റ്‌വർക്ക് ഡ്രൈവ് അതിന്റെ ഫയൽ സിസ്റ്റത്തിൽ മൗണ്ട് ചെയ്യുന്ന ഒരു NFS ക്ലയന്റാണ്.

നമുക്ക് ഉബുണ്ടു 12.04 ഒരു സെർവറായി എടുക്കാം.
ഞങ്ങൾ Centos ഉം Winows 7 ഉം ക്ലയന്റുകളായി ഉപയോഗിക്കുകയും പരീക്ഷിക്കുകയും ചെയ്യും.

മാസ്റ്റർ സെർവർ: 192.168.2.213 (ഉബുണ്ടു)

ഉപഭോക്താക്കൾ: 192.168.2.72 (സെന്റോസ്), 192.168.2.180 (വിൻഡോസ്)

സെർവർ ട്യൂണിംഗ്

ആദ്യം നിങ്ങൾ സെർവർ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്. ഞങ്ങൾ ഉബുണ്ടു ഒരു സെർവറായി ഉപയോഗിക്കുന്നതിനാൽ, ഉചിതമായ പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്

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

ആവശ്യമായ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, ഞങ്ങൾ രണ്ട് കോൺഫിഗറേഷൻ ഫയലുകൾ സൃഷ്ടിച്ചു. ഇൻസ്റ്റാളേഷൻ ലോഗിൽ നിന്ന്:

... പുതിയ പതിപ്പ് ഉപയോഗിച്ച് കോൺഫിഗറേഷൻ ഫയൽ സൃഷ്ടിക്കുന്നു /etc/idmapd.conf പുതിയ പതിപ്പിനൊപ്പം കോൺഫിഗറേഷൻ ഫയൽ /etc/default/nfs-common സൃഷ്ടിക്കുന്നു ...

ആദ്യ ഫയൽ ഉപയോക്താവിനെയും (പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ സൃഷ്ടിച്ചത്) മാപ്പിംഗിൽ (ഉപയോക്തൃ ഐഡന്റിഫിക്കേഷൻ) പങ്കെടുക്കാനുള്ള ഗ്രൂപ്പിനെയും വിവരിക്കുന്നു.

Root@ubuntu:~# cat /etc/idmapd.conf Verbosity = 0 Pipefs-Directory = /run/rpc_pipefs # നിങ്ങളുടെ സ്വന്തം ഡൊമെയ്ൻ ഇവിടെ സജ്ജമാക്കുക, ഐഡി FQDN മൈനസ് ഹോസ്റ്റ്നാമത്തിൽ നിന്ന് വ്യത്യസ്തമാണെങ്കിൽ # ഡൊമെയ്ൻ = ലോക്കൽഡൊമെയ്ൻ ആരും-ഉപയോക്താവ് = ആരുമില്ല-ഗ്രൂപ്പ് = കൂട്ടം

നമുക്കറിയാവുന്നതുപോലെ, ലിനക്സിൽ ഓരോ ഫയലും ഒരു നിർദ്ദിഷ്ട ഉപയോക്താവിന്റെതാണ്, അവർക്ക് സ്വന്തമായി (യുഐഡി, ജിഐഡി) ഉണ്ട്, എന്നാൽ വിൻഡോസ് സിസ്റ്റങ്ങളിൽ ഈ സ്കീം അല്പം വ്യത്യസ്തമാണ്. ഇക്കാര്യത്തിൽ, ഒരു മാപ്പിംഗ് സംവിധാനം കണ്ടുപിടിച്ചു, അത് വ്യത്യസ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ നിന്നുള്ള വ്യത്യസ്ത ഉപയോക്താക്കളെ Linux ഫയൽ സിസ്റ്റത്തിന് മനസ്സിലാക്കാവുന്ന ഒരു രൂപത്തിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.
കെർബറോസ് പ്രാമാണീകരണം കോൺഫിഗർ ചെയ്യുന്നതിനും ഡെമൺ കേൾക്കുന്ന നിലവാരമില്ലാത്ത പോർട്ട് കോൺഫിഗർ ചെയ്യുന്നതിനും രണ്ടാമത്തെ ഫയൽ ആവശ്യമാണ്. ഞങ്ങൾക്ക് ഇതുവരെ അവനെ ആവശ്യമില്ല. കെർബറോസ് സജ്ജീകരിക്കുന്നത് അടുത്ത ലേഖനത്തിൽ ചർച്ച ചെയ്യും.

Root@ubuntu:~# cat /etc/default/nfs-common # NEED_ ഓപ്‌ഷനുകൾക്കായി നിങ്ങൾ മൂല്യങ്ങൾ സജ്ജീകരിച്ചില്ലെങ്കിൽ, അവ # സ്വയം കണ്ടുപിടിക്കാൻ ശ്രമിക്കും; മിക്ക ആളുകൾക്കും ഇത് മതിയാകും. NEED_ ഓപ്‌ഷനുകൾക്കുള്ള സാധുവായ ഇതരമാർഗങ്ങൾ "അതെ", "ഇല്ല" എന്നിവയാണ്. # നിങ്ങൾക്ക് സ്റ്റാറ്റ് ഡെമൺ ആരംഭിക്കണോ? NFSv4-ന് ഇത് ആവശ്യമില്ല. NEED_STATD= # rpc.statd-നുള്ള ഓപ്ഷനുകൾ. # rpc.statd ഒരു പ്രത്യേക പോർട്ടിൽ കേൾക്കണോ? നിങ്ങൾക്ക് ഒരു പോർട്ട് അധിഷ്ഠിത ഫയർവാൾ ഉള്ളപ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ് #. ഒരു നിശ്ചിത പോർട്ട് ഉപയോഗിക്കുന്നതിന്, ഈ # ഈ വേരിയബിൾ ഒരു സ്റ്റാറ്റ് ആർഗ്യുമെന്റായി സജ്ജമാക്കുക: "--port 4000 --outgoing-port 4001". # കൂടുതൽ വിവരങ്ങൾക്ക്, rpc.statd(8) കാണുക അല്ലെങ്കിൽ http://wiki.debian.org/SecuringNFS STATDOPTS= # നിങ്ങൾക്ക് gssd ഡെമൺ ആരംഭിക്കണോ? കെർബറോസ് മൗണ്ടുകൾക്ക് ഇത് ആവശ്യമാണ്. NEED_GSSD=

ഇപ്പോൾ നമുക്ക് സജ്ജീകരണത്തിൽ തുടരാം.
പങ്കിടുന്നതിനുള്ള എല്ലാ ഡയറക്ടറികളും /etc/exports ഫയലിൽ രജിസ്റ്റർ ചെയ്തിരിക്കണം. ആദ്യം, നമുക്ക് ഹോം ഡയറക്‌ടറിയിൽ 2 ഫോൾഡറുകൾ സൃഷ്‌ടിച്ച് ഫയലുകൾ അവയിലേക്ക് ഡ്രോപ്പ് ചെയ്യാം. കയറ്റുമതി ചെയ്യുന്നതിനുള്ള ഡയറക്ടറികളുടെയും ഫയലുകളുടെയും വൃക്ഷം:

Root@ubuntu:~# tree /home/alex/ /home/alex/ ├── nfs_dir1 │ ├── file1_dir1 │ ├── file2_dir1 │ └_3── ഫയൽ ─ ─ file1_dir2 ├── file2_dir2 └─ ─ ഫയൽ3_dir2

ഇപ്പോൾ നിങ്ങൾ ഈ ഡയറക്‌ടറികൾക്കായി ഒരു ഉപയോക്താവിനെയും ഗ്രൂപ്പിനെയും നിയോഗിക്കേണ്ടതുണ്ട് (അത് /etc/idmapd.conf ഫയലിൽ നിന്ന് എടുക്കുക).

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

ആദ്യം, ഒരു പ്രത്യേക ഐപിക്കായി nfs_dir1 ഡയറക്‌ടറി എക്‌സ്‌പോർട്ട് ചെയ്യാം. ഫയൽ /etc/exprots എഡിറ്റ് ചെയ്യുക.

Root@ubuntu:~# vim /etc/exports # ഒരു നിർദ്ദിഷ്‌ട ഹോസ്റ്റിന് (Windows) /home/alex/nfs_dir1 192.168.2.180(rw,sync,all_squash,no_subtree_check,secure) # സബ്‌നെറ്റിൽ /home/alex-ലെ ഏത് ഹോസ്റ്റിനും /nfs_dir2 192.168 .2.0/24(rw,no_root_squash,sync,no_subtree_check)

Windows OS-നൊപ്പം സ്റ്റോറേജ് ശരിയായി പ്രവർത്തിക്കുന്നതിനുള്ള ഏറ്റവും കുറഞ്ഞ ഓപ്ഷനുകൾ ഇതാ.

• /home/alex/nfs_dir1- ആക്സസ് അനുവദിച്ചിരിക്കുന്ന ഫോൾഡറിലേക്കുള്ള പാത;
• 192.168.2.180 - ഫോൾഡറിലേക്ക് ആക്‌സസ് നൽകിയിരിക്കുന്ന IP വിലാസം (നിങ്ങൾക്ക് മുഴുവൻ നെറ്റ്‌വർക്കും വ്യക്തമാക്കാൻ കഴിയും, തുടർന്ന് എൻട്രി 192.168.2.0/24 പോലെ കാണപ്പെടും)
• (rw,sync,all_squash,no_subtree_check)- ഒരു കൂട്ടം ഓപ്ഷനുകൾ.

ജനപ്രിയ ഓപ്ഷനുകൾ:

• rw–വായിക്കുക/എഴുതുക (മൂല്യം റോ എടുക്കാം - വായിക്കാൻ മാത്രം);
• no_root_squash- സ്ഥിരസ്ഥിതിയായി, ക്ലയന്റ് മെഷീനിലെ റൂട്ട് ഉപയോക്താവിന് സെർവറിന്റെ പങ്കിട്ട ഡയറക്ടറിയിലേക്ക് ആക്സസ് ഉണ്ടായിരിക്കില്ല. ഈ ഓപ്ഷൻ ഉപയോഗിച്ച് ഞങ്ങൾ ഈ പരിമിതി ഇല്ലാതാക്കുന്നു. സുരക്ഷാ കാരണങ്ങളാൽ, ഇത് ചെയ്യാതിരിക്കുന്നതാണ് നല്ലത്;
• സമന്വയിപ്പിക്കുക- സിൻക്രണസ് ആക്സസ് മോഡ് (വിപരീത മൂല്യം എടുക്കാം - അസമന്വിതം);
• പ്രവേശനം ഇല്ല- നിർദ്ദിഷ്ട ഡയറക്ടറിയിലേക്കുള്ള പ്രവേശനം നിഷേധിക്കുന്നു. നിങ്ങൾ മുമ്പ് എല്ലാ നെറ്റ്‌വർക്ക് ഉപയോക്താക്കൾക്കും ഒരു നിശ്ചിത ഡയറക്‌ടറിയിലേക്ക് ആക്‌സസ് സജ്ജീകരിച്ചാൽ അത് ഉപയോഗപ്രദമാകും, കൂടാതെ ഇപ്പോൾ ഉപഡയറക്‌ടറിയിലേക്കുള്ള ആക്‌സസ് ചില ഉപയോക്താക്കൾക്ക് മാത്രമായി പരിമിതപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു.
• എല്ലാം_സ്ക്വാഷ്- എല്ലാ കണക്ഷനുകളും ഒരു അജ്ഞാത ഉപയോക്താവിൽ നിന്നായിരിക്കുമെന്ന് സൂചിപ്പിക്കുന്നു (ഒരു വിൻഡോസ് ക്ലയന്റിന് ആവശ്യമാണ്)
• anonuid= 1000 - ഒരു അജ്ഞാത ഉപയോക്താവിനെ ഒരു "പ്രാദേശിക" ഉപയോക്താവുമായി ബന്ധിപ്പിക്കുന്നു;
• anongid= 1000 - അജ്ഞാത ഉപയോക്താവിനെ "ലോക്കൽ" ഉപയോക്താവിന്റെ ഗ്രൂപ്പിലേക്ക് ബന്ധിപ്പിക്കുന്നു.
• no_subtree_check(subtree_check)-ഒരു ഫയൽ സിസ്റ്റത്തിന്റെ ഒരു ഉപഡയറക്‌ടറി എക്‌സ്‌പോർട്ട് ചെയ്യപ്പെടുന്നു, എന്നാൽ മുഴുവൻ ഫയൽ സിസ്റ്റവും അല്ല, അഭ്യർത്ഥിച്ച ഫയൽ എക്‌സ്‌പോർട്ട് ചെയ്‌ത സബ്‌ഡയറക്‌ടറിയിലാണോ എന്ന് സെർവർ പരിശോധിക്കുന്നു. സ്ഥിരീകരണം പ്രവർത്തനരഹിതമാക്കുന്നത് സുരക്ഷ കുറയ്ക്കുന്നു, പക്ഷേ ഡാറ്റ കൈമാറ്റ വേഗത വർദ്ധിപ്പിക്കുന്നു.
• സാധാരണഗതിയിൽ, ലിനക്സ് (ഒപ്പം മറ്റ് യുണിക്സ് പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളും) റൂട്ട് യൂസർ പ്രോസസ്സുകൾക്കായി 1-1023 (സുരക്ഷിത പോർട്ടുകൾ എന്ന് വിളിക്കുന്നു) മുതൽ TCP, UDP പോർട്ടുകൾ റിസർവ് ചെയ്യുന്നു. റൂട്ട് എൻഎഫ്എസ് റിമോട്ട് കണക്ഷൻ ആരംഭിച്ചുവെന്ന് ഉറപ്പാക്കാൻ, എൻഎഫ്എസ് സെർവറിന് സാധാരണയായി റിമോട്ട് ക്ലയന്റുകൾ സുരക്ഷിത പോർട്ടുകൾ ഉപയോഗിക്കേണ്ടതുണ്ട്. എന്നിരുന്നാലും, ഈ കൺവെൻഷൻ ചില ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ (ഉദാ: വിൻഡോസ്) മാനിക്കുന്നില്ല. അത്തരം സന്ദർഭങ്ങളിൽ, ഓപ്ഷൻ അരക്ഷിതാവസ്ഥഏതെങ്കിലും TCP/UDP പോർട്ട് ഉപയോഗിക്കാൻ NFS ക്ലയന്റിനെ അനുവദിക്കുന്നു. വിൻഡോസ് ക്ലയന്റുകൾക്ക് സേവനം നൽകുമ്പോൾ ഇത് സാധാരണയായി ആവശ്യമാണ്.

ഹോസ്റ്റുകൾ, ഹോസ്റ്റ് ഗ്രൂപ്പുകൾ മുതലായവ എഴുതുന്നതിനുള്ള ലഭ്യമായ എല്ലാ ഓപ്ഷനുകളും വാക്യഘടനയും. നിങ്ങൾക്ക് അത് മാനുവലിൽ വായിക്കാം

Root@ubuntu:~# exportfs –a

ഇനി നമ്മൾ എന്താണ് കയറ്റുമതി ചെയ്തതെന്ന് പരിശോധിക്കാം.

Root@ubuntu:~# exportfs -v /home/alex/nfs_dir1 192.168.2.180(rw,wdelay,all_squash,no_subtree_check,secure) /home/alex/nfs_dir2 192,168 പരിശോധിക്കുക)

സെർവർ ക്രമീകരിച്ചു.

ക്ലയന്റുകളെ സജ്ജീകരിക്കുന്നു

ഒരു വിൻഡോസ് ക്ലയന്റ് സജ്ജീകരിക്കുന്നു

പിശക് സന്ദേശങ്ങൾ ഇല്ലായിരുന്നുവെങ്കിൽ. നിങ്ങൾക്ക് ക്ലയന്റ് ഭാഗത്ത് മൌണ്ട് ചെയ്യാൻ തുടങ്ങാം.
ആദ്യം, നിങ്ങൾ ഒരു NFS സേവനം (ക്ലയന്റ് സേവനം) ചേർക്കേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, പോകുക ആരംഭിക്കുക -> നിയന്ത്രണ പാനൽ -> പ്രോഗ്രാമുകളും സവിശേഷതകളുംഇടതുവശത്തുള്ള മെനു ഇനത്തിൽ ക്ലിക്ക് ചെയ്യുക വിൻഡോസ് സവിശേഷതകൾ ഓണാക്കുകയോ ഓഫാക്കുകയോ ചെയ്യുക. ദൃശ്യമാകുന്ന വിൻഡോയിൽ, തിരഞ്ഞെടുക്കുക NFS-നുള്ള ക്ലയന്റ്ക്ലിക്ക് ചെയ്യുക ശരി(ചിത്രം 1).

ചിത്രം 1

അടുത്തതായി നിങ്ങൾ ഡിസ്ക് മൌണ്ട് ചെയ്യേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് കമാൻഡ് ലൈൻ ഉപയോഗിക്കാം അല്ലെങ്കിൽ ക്ലിക്ക് ചെയ്യുക മൈ കമ്പ്യൂട്ടറിൽ റൈറ്റ് ക്ലിക്ക് ചെയ്ത് മാപ്പ് നെറ്റ്‌വർക്ക് ഡ്രൈവ് തിരഞ്ഞെടുക്കുക. ഒപ്പം \\192.168.2.213\home\alex\nfs_dir1 എന്ന വരി നൽകുക. ഇതാണ് സെർവർ ഐപിയും ഫോൾഡറിലേക്കുള്ള പാതയും (ചിത്രം 2).

ചിത്രം 2

എല്ലാം ശരിയാണെങ്കിൽ, ഞങ്ങൾ ഡിസ്ക് കാണും (ചിത്രം 3).

ചിത്രം 3

കമാൻഡ് ലൈൻ (ചിത്രം 4) ഉപയോഗിച്ചും ഇത് ചെയ്യാം.

ചിത്രം 4

സാധ്യമായ തെറ്റുകൾ:

എങ്കിൽ നിങ്ങൾക്ക് ഒരു NFS നെറ്റ്‌വർക്ക് ഡ്രൈവ് Windows OS-ലേക്ക് ബന്ധിപ്പിക്കാൻ കഴിയില്ല (ചിത്രം 5).
1. NFS ക്ലയന്റ് ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ല
2. ഫയർവാൾ പ്രവർത്തനക്ഷമമാക്കി (കോൺഫിഗർ ചെയ്തിട്ടില്ല)
3. സെർവറിലേക്ക് നെറ്റ്‌വർക്ക് ആക്‌സസ് ഇല്ല
4. തെറ്റായ മൗണ്ട് പാരാമീറ്ററുകൾ നൽകി
5. സെർവറിൽ എക്‌സ്‌പോർട്ട് കോൺഫിഗർ ചെയ്‌തിട്ടില്ല (ക്രമീകരണങ്ങൾ പ്രയോഗിച്ചിട്ടില്ല).
6. കയറ്റുമതി ക്രമീകരണങ്ങളിൽ സുരക്ഷിതമല്ലാത്ത ഓപ്ഷൻ ചേർക്കുക

ചിത്രം 5 - ഒരു നെറ്റ്‌വർക്ക് NFS ഡ്രൈവ് ബന്ധിപ്പിക്കുന്നതിൽ പിശക്

ഇനിപ്പറയുന്നവയാണെങ്കിൽ നിങ്ങൾക്ക് ഒരു മൌണ്ട് ചെയ്ത ഫയൽ സിസ്റ്റത്തിലേക്ക് ഒരു ഫയൽ ചേർക്കാൻ കഴിയില്ല (ചിത്രം 6):
1. ഫോൾഡർ അനുമതികൾ സെർവറിൽ സജ്ജീകരിച്ചിട്ടില്ല (ആരും:nogroup)
2. കയറ്റുമതി ക്രമീകരണങ്ങളിൽ all_squash ഓപ്ഷൻ സജ്ജീകരിച്ചിട്ടില്ല
3. കയറ്റുമതി ക്രമീകരണങ്ങളിൽ rw ഓപ്ഷൻ സജ്ജമാക്കിയിട്ടില്ല

ചിത്രം 6 - ഒരു NFS ഡിസ്കിലേക്ക് ഒരു ഫയൽ ചേർക്കുമ്പോൾ പിശക്

ഒരു സെന്റോസ് ക്ലയന്റ് സജ്ജീകരിക്കുന്നു

ലിനക്സ് സിസ്റ്റങ്ങൾ സജ്ജീകരിക്കുന്നത് വളരെ ലളിതവും വേദനയില്ലാത്തതുമാണ്. നിങ്ങൾ ആവശ്യമായ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്ത് ഡിസ്ക് മൌണ്ട് ചെയ്യേണ്ടതുണ്ട്. സെന്റോസിന് ഇനിപ്പറയുന്ന പാക്കേജുകൾ ആവശ്യമാണ്

# yum 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 / /proc-ൽ ext4 (rw) proc ടൈപ്പ് ചെയ്യുക proc (rw) sysfs on /sys ടൈപ്പ് sysfs (rw) devpts on /dev/pts ടൈപ്പ് devpts (rw,gid=5,mode=620) tmpfs on /dev/shm ടൈപ്പ് tmpfs (rw,rootcontext="system_u:object_r:tmpfs_t:s0 ) /boot ടൈപ്പ് ext4-ൽ /dev/sda1 (rw) ഒന്നുമില്ല /proc/sys/fs/binfmt_misc ടൈപ്പ് binfmt_misc (rw) sunrpc on /var/lib/nfs/rpc_pipefs ടൈപ്പ് rpc_pipefs (rw) 192.192.192.26 alex/nfs_dir1 on /mnt/nfs ടൈപ്പ് nfs (rw,vers=4,addr=192.168.2.213,clientaddr=192.168.2.72)

ഈ സാഹചര്യത്തിൽ, സിസ്റ്റത്തിലെ ഏതൊരു ഉപയോക്താവിനും വേണ്ടി മൌണ്ട് ചെയ്ത nfs_dir1 ഫോൾഡറിലേക്ക് നമുക്ക് ഏത് ഫയലും ഡയറക്ടറിയും ചേർക്കാം ( എല്ലാം_സ്ക്വാഷ്). എന്നാൽ നമ്മൾ രണ്ടാമത്തെ ഫോൾഡർ nfs_dir2 മൌണ്ട് ചെയ്യുകയാണെങ്കിൽ, അവിടെ ഒരു ഓപ്ഷൻ ഉള്ളതിനാൽ റൂട്ടിന് മാത്രമേ അതിൽ എഴുതാൻ കഴിയൂ. no_root_squash. നമുക്ക് പരിശോധിക്കാം.

# mkdir /mnt/dir1 # mkdir /mnt/dir2 # മൗണ്ട് 192.168.2.213:/home/alex/nfs_dir1 /mnt/dir1 # മൗണ്ട് 192.168.2.213:/home/alex/nfs_dir2 /dir2 -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 "Hello" > /mnt/dir1/file1 $ echo "Hello" > /mnt/dir2/file1 bash: /mnt/dir2/file1: അനുമതി നിരസിച്ചു

സാധ്യമായ മൌണ്ട് ഫ്ലാഗുകൾ.

പതാക	വിവരണം
rw	റീഡ്/റൈറ്റിനായി ഫയൽ സിസ്റ്റം മൗണ്ട് ചെയ്യുക (ഇത് റീഡ്/റൈറ്റ് മോഡിൽ സെർവർ കയറ്റുമതി ചെയ്യണം)
th	ഒരു റീഡ്-ഒൺലി ഫയൽ സിസ്റ്റം മൗണ്ട് ചെയ്യുന്നു
bg	ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യാൻ കഴിയുന്നില്ലെങ്കിൽ (സെർവർ പ്രതികരിക്കുന്നില്ലെങ്കിൽ), നിങ്ങൾ പ്രവർത്തനം പശ്ചാത്തലത്തിലേക്ക് നീക്കുകയും മറ്റ് മൌണ്ട് അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നത് തുടരുകയും വേണം.
കഠിനമായ	സെർവർ പ്രവർത്തനരഹിതമാകുകയാണെങ്കിൽ, സെർവർ ഓൺലൈനിൽ തിരിച്ചെത്തുന്നത് വരെ അത് ആക്‌സസ് ചെയ്യാൻ ശ്രമിക്കുന്ന പ്രവർത്തനങ്ങൾ ബ്ലോക്ക് ചെയ്യപ്പെടും
മൃദുവായ	സെർവർ പ്രവർത്തനരഹിതമാകുകയാണെങ്കിൽ, അത് ആക്സസ് ചെയ്യാൻ ശ്രമിക്കുന്ന പ്രവർത്തനങ്ങൾ ഒരു പിശക് സന്ദേശത്തിൽ പരാജയപ്പെടുന്നു. അപ്രധാനമായ ഫയൽ സിസ്റ്റങ്ങൾ മൌണ്ട് ചെയ്യുന്നതിൽ പരാജയപ്പെടുന്ന സാഹചര്യത്തിൽ, പ്രോസസ്സുകൾ ഹാംഗ് ചെയ്യുന്നത് തടയാൻ ഈ ഫ്ലാഗ് സജ്ജീകരിക്കാൻ ഉപയോഗപ്രദമാണ്.
intr	കീബോർഡിൽ നിന്ന് തടഞ്ഞ പ്രവർത്തനങ്ങൾ തടസ്സപ്പെടുത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു (പിശക് സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കും)
nointr	കീബോർഡിൽ നിന്ന് തടഞ്ഞ പ്രവർത്തനങ്ങൾ തടസ്സപ്പെടുത്താൻ നിങ്ങളെ അനുവദിക്കുന്നില്ല
retrans=n	ഒരു പിശക് സന്ദേശം നൽകുന്നതിന് മുമ്പ് അഭ്യർത്ഥന എത്ര തവണ ആവർത്തിക്കണമെന്ന് വ്യക്തമാക്കുന്നു (സോഫ്റ്റ് ഫ്ലാഗ് ഉപയോഗിച്ച് മൌണ്ട് ചെയ്ത ഫയൽ സിസ്റ്റങ്ങൾക്ക്)
timeo=n	അഭ്യർത്ഥനകൾക്കുള്ള കാലഹരണപ്പെടൽ ഇടവേള സജ്ജീകരിക്കുന്നു (സെക്കൻഡിന്റെ പത്തിലൊന്നിൽ)
rsize=n	റീഡ് ബഫർ വലുപ്പം n ബൈറ്റുകളായി സജ്ജമാക്കുന്നു
wsize=fl	റൈറ്റ് ബഫർ വലുപ്പം n ബൈറ്റുകളായി സജ്ജമാക്കുന്നു
സെക്കന്റ്=മോഡ്	സുരക്ഷാ മോഡ് സജ്ജമാക്കുന്നു
vers=n	NFS പ്രോട്ടോക്കോൾ പതിപ്പ് സജ്ജമാക്കുന്നു
പ്രോട്ടോ = പ്രോട്ടോക്കോൾ	ഗതാഗത പ്രോട്ടോക്കോൾ തിരഞ്ഞെടുക്കുന്നു; ഇത് എൻവിഎസ് പതിപ്പ് 4-ന് ടിസിപി പ്രോട്ടോക്കോൾ ആയിരിക്കണം

സെർവർ ഫയൽ സിസ്റ്റം ശരിയായി കയറ്റുമതി ചെയ്തിട്ടുണ്ടോ എന്ന് നിങ്ങൾക്ക് കൺസോളിൽ നിന്നും പരിശോധിക്കാം.

Root@centos ~# showmount -e 192.168.2.213 192.168.2.213 എന്നതിനായുള്ള കയറ്റുമതി ലിസ്റ്റ്: /home/alex/nfs_dir2 192.168.2.0/24 /home/alex/nfs_dir1 122.180.

സ്റ്റാർട്ടപ്പിലേക്ക് ഒരു മൗണ്ട് ചേർക്കുന്നു

# 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

സാധ്യമായ തെറ്റുകൾ.

Root@centos ~# mount -a -t nfs4 mount.nfs4: മൗണ്ട് പോയിന്റ് /mnt/dir2 നിലവിലില്ല root@centos ~# mount -a -t nfs4 mount.nfs4: റിമോട്ട് ഷെയർ "ഹോസ്റ്റ്:ഡിർ" ഫോർമാറ്റിൽ അല്ല

ആദ്യ സാഹചര്യത്തിൽ, നിങ്ങൾ ഒരു ഫോൾഡർ സൃഷ്ടിക്കേണ്ടതുണ്ട്. രണ്ടാമത്തേതിൽ fstab-ൽ വാക്യഘടന പിശകുകൾ അടങ്ങിയിരിക്കുന്നു.
NFS പാർട്ടീഷനുകൾ മൌണ്ട് ചെയ്യുമ്പോൾ പിശകുകൾ നേരിടുകയാണെങ്കിൽ, ലിസ്റ്റിലൂടെ പോകുക സാധ്യമായ തെറ്റുകൾമുമ്പത്തെ വിഭാഗത്തിൽ നിന്ന്.
എൻഎഫ്എസ് പാർട്ടീഷനുകൾ മൌണ്ട് ചെയ്യുന്നതിനും നിങ്ങൾക്ക് autofs ഉപയോഗിക്കാം. എന്നതിൽ ചർച്ച ചെയ്യും.