Hey everyone and welcome back. So in this skill right here, what we're going to be focusing
on is something called NFS. This is the network file system. And the real emphasis here is
on that letter N network. This is really what the crux of this topic is all about. Now if you
recall from the previous skill, we happen to talk about SAMBA. Now SAMBA was all about being able
to share out different things such as printers or particular files and folders. And when we talk
about NFS, there is some overlap, some similarity here, and that ultimately we are sharing resources,
but we're not sharing the same things or in the same way as we would via a SAMBA server. So like I
say, SAMBA, we are sharing out printers and folders and files with respect to NFS. What we are
actually sharing is a file system itself. And how are we sharing this? We're sharing it via the
network IE to other computers that we can connect to. So this really is the crucial difference
when talking about NFS. It's actually that file system that is going to be mounted and going to
be shared with other people so that they can use that just like it was a local file system on their
local computer. This would be just like if they happen to have a new partition or a new hard disk,
whatever it may be, on their local drive. However, it has been accessed, like I say again, via the
network. And this really is the crux of what we are talking about here with respect to SAMBA. You
may remember that we could implement particular authentication, meaning that we could share
particular files with particular users or particular folders or printers, whatever it may be. But we
were targeting particular individuals, certain people we wanted to grant access to certain files.
In this case, though, what we're actually going to do is we're going to grant access to
particular servers or to particular clients, i.e. we are no longer targeting individual user
accounts. Instead, we are actually targeting particular machines. So really, if you want to
share a file system with another server, the solution you should be looking at would be NFS.
Now, with respect to NFS, we're going to have to talk about a few things. We're going to be looking
at the actual server configuration. The NFS server would be the one who's actually sharing
the file system. So that is where the file system is locally created. It's on the disk within that
physical server. So if we just have the server here, and the machine which is using or rather
accessing that file system over the network would be a client. So the client is receiving
that file system or accessing it via NFS. So we're going to be looking at the server configuration
within this skill, as well as the basic client configuration. And we'll also have to discuss
how we can actually control permissions here. Because if you recall, with respect to Samba,
we had particular styles of locking down security and access. We would have particular
user names and passwords for particular users. But as we now know, NFS does not work on that
user basis. It's going to be locking down things based on the server or the machine, if you will.
Certain machines we want to grant access to, but perhaps maybe there are other machines that we
want to not grant that access to. So this is something we're going to have to consider absolutely,
and we'll get to that within this skill. But with respect to how NFS actually operates,
we need to know a few basic components. The first thing we want to be aware of is that
NFS is going to use something called RPC. Now all RPC is, it is a protocol that is going to
facilitate some type of communication. Now, RPC actually stands for a remote procedure call.
And this protocol really does shine with respect to client server architectures
in a distributed fashion. So this really is a great fit for the type of solution that we want
to actually implement here, being able to share out particular file systems across different devices
within our network. Now, one thing to note about NFS with respect to the LPIC2 examination
is that NFS does have two relevant versions that we want to be aware of. There is going to be a
version three, which is what we will be looking at a little bit more closely. But we also have
the newer version four, but the LPIC2 exam objectives really just request that we have
an awareness of version four. So more of our time is going to be looking at how version three
actually operates. Now, version three is going to leverage something called RPC Bind or something
called Port Mapper. Now, whether you're using RPC Bind or Port Mapper, RPC Bind being the newer
implementation. So really RPC Bind or Port Mapper is going to be in between the communication of
the server sharing and the client, which is consuming RPC Bind or Port Mapper is going to
handle that communication and the interaction between these two different components. Now,
the reason why this is important is that because we have this intermediary with respect to version
three, i.e. we have Port Mapper or RPC Bind in play, the reason why that is so important is because
this is going to affect or at least can affect access to these particular shares. Because as
we're going to see, you can actually control access to a particular server by specifying the
devices or the devices within a certain network, which are allowed to access these network shares.
And you can do this directly via NFS. And we'll get to see what that looks like in the next nugget.
But we can also control access via TCP wrappers. And this is implemented at the level of either RPC
Bind or Port Mapper. So the point is I'm trying to highlight here is that if we happen to have a
particular clash, i.e. we have our server here with particular permissions, and we have our client
here, which wants to consume these shares to be able to use, because we have this intermediary on
the server, such as Port Mapper, if Port Mapper is implementing strict access controls that actually
prevent the client from connecting, then even if you happen to have relaxed rules on the NFS server,
the controls specified within Port Mapper can still override ultimately and prevent that access.
So basically on your NFS configuration, you could pretty much say anyone can access this server,
but via using TCP wrappers via Port Mapper, you may lock down that access. And in which case,
even though NFS itself is configured to allow absolutely anyone to use this particular share,
the client here can't actually get access due to the TCP wrapper configuration via Port Mapper or
via RPC Bind. So this is something we want to be aware of with respect to version three and
version four. When we're talking about version four, like I say, we don't need to worry about RPC Bind
or Port Mapper. Instead, all of this stuff is ultimately handled natively within NFS
version four. So that means within NFS version four, the security and the access permissions are
handled natively. NFS does this all on its own. Now with respect as to how to specify who can
actually access the NFS share, we're going to see how we can actually configure this. Now the
general syntax is really quite simple. We're going to go into a configuration file, which we'll see
in the very next nugget. We'll specify the share that we want to share out, i.e. the particular
file system. Then we're going to specify who is actually allowed access to that particular share.
And then within brackets, after we specify who is allowed access to the share, we're going to specify
the permissions they actually have, i.e. what can this person who can access this share, what can
they actually do on that share? Can they just read information on that share? Can they actually make
changes? So on and so forth. So that really is the general outline for what we have to look at within
this skill. The very first thing now, which I want to talk about is that NFS server configuration.
And well, that's what we're going to be talking about in the very next nuggets. I hope this has
been informative for you and I'd like to thank you for viewing.