Configurer l'accès client NFS sous RHEL

Introduction

Dans ce laboratoire, vous apprendrez les compétences essentielles pour configurer l'accès client NFS sur un système Red Hat Enterprise Linux (RHEL). Vous commencerez par monter manuellement un partage réseau à l'aide de la commande mount pour comprendre le processus fondamental. Ensuite, vous configurerez un montage persistant dans /etc/fstab pour garantir que le partage NFS soit automatiquement disponible après un redémarrage du système, offrant ainsi une compréhension fondamentale de l'intégration statique des systèmes de fichiers réseau.

En s'appuyant sur ces concepts fondamentaux, vous progresserez vers une méthode plus dynamique et efficace en configurant l'automounter. Cela implique l'installation et l'activation du service autofs, puis la création de cartes indirectes pour le montage de répertoires à la demande et de cartes directes pour les points de montage statiques. Vous terminerez le laboratoire en vérifiant que les montages automatiques directs et indirects fonctionnent correctement pour différents utilisateurs, consolidant ainsi votre capacité à gérer des configurations client NFS robustes.

Monter manuellement un partage NFS à l'aide de la commande mount

Dans cette étape, vous apprendrez comment accéder manuellement à un répertoire partagé sur le réseau en utilisant le protocole Network File System (NFS). NFS permet à un système client d'accéder à des fichiers sur un réseau informatique d'une manière similaire à l'accès au stockage local. Pour cet exercice, nous allons simuler à la fois un serveur NFS et un client sur votre machine locale afin de pratiquer les commandes nécessaires.

Un serveur NFS a été pré-configuré sur votre système pour exporter (partager) le répertoire /srv/nfs/shared_data. Votre tâche consiste à monter ce répertoire partagé dans un dossier local, à vérifier l'accès, puis à le démonter.

Étape 1.1 : Créer un point de montage local

Pour accéder au répertoire NFS partagé, vous avez besoin d'un répertoire local qui servira de "point de montage". Il s'agit essentiellement d'un dossier vide sur votre système client où le contenu du partage distant apparaîtra une fois monté. Toutes les opérations seront effectuées dans votre répertoire ~/project.

Créez un répertoire nommé nfs_mount à l'intérieur de votre dossier de projet :

mkdir ~/project/nfs_mount

Vous pouvez vérifier que le répertoire a été créé en listant le contenu de votre dossier de projet :

ls -F ~/project

nfs_mount/

Étape 1.2 : Monter le partage NFS

Vous pouvez maintenant utiliser la commande mount pour attacher le partage NFS distant à votre point de montage nouvellement créé. La commande nécessite des privilèges sudo car le montage des systèmes de fichiers est une opération au niveau du système.

La syntaxe de base est mount -t nfs <serveur>:<répertoire_distant> <point_de_montage_local>.

• -t nfs : Spécifie que le type de système de fichiers est NFS.
• localhost:/srv/nfs/shared_data : La source, qui est le serveur et le chemin qu'il exporte.
• ~/project/nfs_mount : La destination, qui est votre point de montage local.

Exécutez la commande suivante pour monter le partage :

sudo mount -t nfs localhost:/srv/nfs/shared_data ~/project/nfs_mount

Cette commande ne produira aucune sortie si elle réussit.

Étape 1.3 : Vérifier le montage et interagir avec le partage

Après avoir exécuté la commande mount, vous devriez vérifier que le partage est correctement monté. Vous pouvez le faire de plusieurs manières.

Tout d'abord, utilisez la commande mount redirigée vers grep pour filtrer les montages NFS :

mount | grep nfs

localhost:/srv/nfs/shared_data on /home/labex/project/nfs_mount type nfs4 (rw,relatime,vers=4.2,rsize=...,wsize=...,namlen=255,hard,proto=tcp,timeo=600,retrans=2,sec=sys,clientaddr=...,local_lock=none,addr=...)

Ensuite, vérifiez le contenu de votre point de montage. Il devrait maintenant afficher les fichiers du répertoire distant /srv/nfs/shared_data.

ls -l ~/project/nfs_mount

total 4
-rw-r--r--. 1 root root 32 Nov 10 14:30 welcome.txt

Vous pouvez maintenant interagir avec ce répertoire comme s'il s'agissait d'un dossier local. Notez que dans cet environnement de laboratoire, les fichiers appartiennent à root en raison de la configuration du serveur NFS avec no_root_squash. Dans les environnements de production, vous pourriez voir nobody comme propriétaire en fonction des paramètres du serveur NFS. Créons un nouveau fichier dans le partage monté. Étant donné que le partage NFS peut appartenir à root, vous devez utiliser sudo avec la commande tee pour écrire des fichiers :

echo "My test file" | sudo tee ~/project/nfs_mount/my_file.txt > /dev/null

Vérifiez que votre nouveau fichier existe aux côtés de l'original :

ls -l ~/project/nfs_mount

total 8
-rw-r--r--. 1 root  root  13 Nov 10 14:35 my_file.txt
-rw-r--r--. 1 root  root  32 Nov 10 14:30 welcome.txt

Étape 1.4 : Démonter le partage NFS

Lorsque vous avez terminé d'utiliser un partage réseau, il est important de le démonter proprement à l'aide de la commande umount. Cela garantit que toutes les données sont synchronisées et que la connexion est correctement fermée. Vous n'avez qu'à spécifier le point de montage.

sudo umount ~/project/nfs_mount

Pour confirmer que le partage a été démonté, listez le contenu du répertoire ~/project/nfs_mount. Il devrait maintenant être à nouveau vide.

ls -l ~/project/nfs_mount

total 0

Configurer un montage NFS persistant dans /etc/fstab

Dans l'étape précédente, vous avez appris à monter manuellement un partage NFS à l'aide de la commande mount. Cependant, ces montages sont temporaires et ne survivront pas à un redémarrage du système. Pour rendre un montage permanent, vous devez ajouter une entrée au fichier /etc/fstab (abréviation de "file systems table"). Ce fichier contient une liste des systèmes de fichiers et des périphériques qui sont montés automatiquement au démarrage du système.

Dans cette étape, vous allez configurer le même partage NFS pour qu'il soit monté de manière persistante en ajoutant une entrée à /etc/fstab.

Étape 2.1 : Préparer l'environnement

Tout d'abord, assurez-vous que le point de montage de l'étape précédente, ~/project/nfs_mount, existe et est vide. Si vous continuez directement depuis la dernière étape, il devrait déjà être là.

Si le répertoire n'existe pas, créez-le maintenant :

mkdir -p ~/project/nfs_mount

Assurez-vous également que rien n'est actuellement monté sur ce répertoire. Vous pouvez exécuter la commande umount, qui signalera une erreur si rien n'est monté, et c'est tout à fait normal.

sudo umount ~/project/nfs_mount

Étape 2.2 : Modifier le fichier /etc/fstab

Maintenant, vous allez ajouter une nouvelle ligne au fichier /etc/fstab pour définir le montage NFS persistant. Vous devez utiliser sudo pour modifier ce fichier de configuration système. Nous utiliserons l'éditeur nano.

Ouvrez le fichier avec la commande suivante :

sudo nano /etc/fstab

Naviguez jusqu'en bas du fichier et ajoutez la ligne suivante. Soyez très prudent avec la syntaxe, car les erreurs dans ce fichier peuvent causer des problèmes au démarrage du système.

localhost:/srv/nfs/shared_data /home/labex/project/nfs_mount nfs defaults,_netdev 0 0

Décomposons cette ligne :

• localhost:/srv/nfs/shared_data : C'est le périphérique à monter. Il spécifie le serveur NFS (localhost) et le répertoire exporté (/srv/nfs/shared_data).
• /home/labex/project/nfs_mount : C'est le point de montage local où le partage sera accessible.
• nfs : Ceci spécifie le type de système de fichiers.
• defaults,_netdev : Ce sont les options de montage. defaults inclut un ensemble standard d'options (comme rw pour lecture-écriture). _netdev est crucial pour les systèmes de fichiers réseau ; il indique au système d'attendre que le réseau soit actif avant de tenter de monter ce partage.
• 0 : C'est le champ dump, utilisé par l'utilitaire de sauvegarde dump. Une valeur de 0 le désactive.
• 0 : C'est le champ pass, utilisé par l'utilitaire fsck pour déterminer l'ordre des vérifications du système de fichiers au démarrage. Une valeur de 0 signifie que le système de fichiers ne sera pas vérifié.

Après avoir ajouté la ligne, enregistrez le fichier et quittez nano en appuyant sur Ctrl+X, puis Y, et enfin Entrée.

Étape 2.3 : Tester l'entrée /etc/fstab

Vous n'avez pas besoin de redémarrer pour tester votre nouvelle entrée /etc/fstab. La commande mount est suffisamment intelligente pour lire /etc/fstab. Si vous ne fournissez que le point de montage, mount recherchera l'entrée correspondante dans /etc/fstab et utilisera les informations qu'elle y trouve.

Montez le partage en utilisant uniquement le point de montage :

sudo mount ~/project/nfs_mount

Si la commande se termine sans aucune erreur, votre entrée /etc/fstab est correcte.

Étape 2.4 : Vérifier le montage

Vérifiez que le partage est maintenant monté en consultant la sortie de la commande mount et en listant le contenu du répertoire.

mount | grep nfs_mount

localhost:/srv/nfs/shared_data on /home/labex/project/nfs_mount type nfs4 (rw,relatime,vers=4.2,rsize=...,wsize=...,namlen=255,hard,proto=tcp,timeo=600,retrans=2,sec=sys,clientaddr=...,local_lock=none,addr=...,_netdev)

Maintenant, vérifiez le contenu. Vous devriez voir les fichiers du partage.

ls -l ~/project/nfs_mount

total 4
-rw-r--r--. 1 root root 32 Nov 10 14:30 welcome.txt

Ce montage est maintenant persistant et serait automatiquement rétabli après un redémarrage.

Étape 2.5 : Nettoyer l'environnement

Pour éviter les conflits avec les exercices ultérieurs, vous devez maintenant annuler les modifications. Tout d'abord, démontez le partage, puis supprimez la ligne que vous avez ajoutée de /etc/fstab.

Démontez le répertoire :

sudo umount ~/project/nfs_mount

Ouvrez à nouveau /etc/fstab pour supprimer l'entrée :

sudo nano /etc/fstab

Utilisez les touches fléchées pour naviguer jusqu'à la ligne que vous avez ajoutée (localhost:/srv/nfs/shared_data ...), et appuyez sur Ctrl+K pour supprimer toute la ligne. Ensuite, enregistrez et quittez en appuyant sur Ctrl+X, Y, et Entrée.

Cela laisse le système dans un état propre pour la prochaine partie du laboratoire.

Configurer l'automounter en installant et activant autofs

Dans les étapes précédentes, vous avez exploré le montage manuel et persistant. Bien que /etc/fstab soit excellent pour les montages permanents, il présente un inconvénient : il tente de monter tous les systèmes de fichiers au démarrage. Si un partage réseau n'est pas disponible, cela peut ralentir, voire bloquer, le processus de démarrage. L'automounter, fourni par le service autofs, résout ce problème en montant les systèmes de fichiers réseau à la demande, uniquement lorsqu'ils sont accédés pour la première fois.

Le service autofs utilise un ensemble de fichiers de configuration appelés "maps" pour déterminer quels partages distants monter et où. Dans cette étape, vous préparerez votre système à utiliser l'automounter en installant le paquet nécessaire et en démarrant son service.

Étape 3.1 : Installer le paquet autofs

La fonctionnalité autofs n'est pas incluse dans l'installation par défaut de RHEL. Vous devez l'installer en utilisant le gestionnaire de paquets dnf. Cela nécessite des privilèges sudo.

Exécutez la commande suivante pour installer le paquet autofs. L'option -y répond automatiquement "oui" à l'invite de confirmation, ce qui est pratique pour ce laboratoire.

sudo dnf install -y autofs

La commande téléchargera et installera le paquet autofs ainsi que toutes les dépendances requises. Vous verrez une sortie similaire à la suivante :

Last metadata expiration check: ...
Dependencies resolved.
================================================================================
 Package       Architecture    Version                Repository           Size
================================================================================
Installing:
 autofs        x86_64          1:5.1.7-50.el9         ...                  ...
...

Transaction Summary
================================================================================
Install  1 Package

Total download size: ...
Installed size: ...
...
Complete!

Étape 3.2 : Démarrer le service autofs

Sur un système RHEL standard, vous utiliseriez systemctl pour démarrer et activer les services. Cependant, ce laboratoire s'exécute dans un environnement conteneurisé où systemctl n'est pas disponible. Au lieu de cela, nous allons démarrer le démon autofs directement en utilisant sa commande, automount.

Cette commande démarre le démon automounter, qui s'exécutera en arrière-plan et surveillera les tentatives d'accès aux répertoires configurés dans ses maps.

Exécutez la commande suivante pour démarrer le service :

sudo automount

En cas de succès, cette commande ne produira aucune sortie. Elle démarre simplement le processus du démon.

Étape 3.3 : Vérifier que le service est en cours d'exécution

Étant donné que vous ne pouvez pas utiliser systemctl status autofs pour vérifier le service, vous pouvez vérifier que le processus automount est en cours d'exécution à l'aide de la commande ps. La commande ps aux liste tous les processus en cours d'exécution, et nous pouvons rediriger (|) sa sortie vers grep pour filtrer le processus automount.

ps aux | grep automount

Vous devriez voir au moins une ligne pour le processus automount lui-même. La deuxième ligne affichant grep automount est simplement la commande grep que vous avez exécutée, et peut être ignorée.

root      ...  0.0  0.0 ...      ?        Ssl  15:30   0:00 /usr/sbin/automount
labex     ...  0.0  0.0 ...      pts/0    S+   15:31   0:00 grep --color=auto automount

Voir le processus /usr/sbin/automount confirme que le service est en cours d'exécution et prêt à gérer les montages à la demande. Dans les étapes suivantes, vous configurerez les maps qui indiquent à autofs quoi faire.

Créer une carte d'automontage indirecte pour les répertoires dynamiques

Dans cette étape, vous allez configurer votre première règle d'automontage à l'aide d'une carte indirecte. Une carte indirecte est le type de configuration d'automontage le plus courant. Elle fonctionne en associant un répertoire de base unique (comme /home ou /net) à un fichier de carte. Lorsqu'un utilisateur tente d'accéder à un sous-répertoire dans ce répertoire de base, autofs recherche le nom du sous-répertoire dans le fichier de carte et monte le partage distant correspondant à la demande.

Ceci est extrêmement utile pour monter les répertoires personnels des utilisateurs ou une collection de dossiers de projet partagés sans avoir à les monter tous en même temps. Nous allons configurer une carte indirecte pour monter dynamiquement des répertoires de projet situés sous un nouveau répertoire de base appelé /project_shares.

Étape 4.1 : Créer les exportations du serveur NFS

Tout d'abord, préparons les répertoires sur notre serveur NFS simulé que nous souhaitons partager. Nous allons créer deux répertoires de projet, design et testing, à l'intérieur de /srv/nfs/.

Créez les répertoires et placez un fichier d'exemple dans chacun d'eux :

sudo mkdir -p /srv/nfs/{design,testing}
sudo sh -c 'echo "Design documents" > /srv/nfs/design/README'
sudo sh -c 'echo "Testing scripts" > /srv/nfs/testing/README'

Ensuite, nous devons indiquer au serveur NFS d'exporter ces répertoires. Nous le faisons en ajoutant des entrées au fichier /etc/exports.

Ouvrez le fichier avec nano :

sudo nano /etc/exports

Ajoutez les lignes suivantes au fichier. Ces lignes indiquent au serveur NFS de partager les répertoires design et testing avec n'importe quel client (*) avec des permissions en lecture-écriture (rw).

/srv/nfs/design *(rw,sync,no_root_squash)
/srv/nfs/testing *(rw,sync,no_root_squash)

Enregistrez le fichier et quittez (Ctrl+X, Y, Entrée).

Enfin, appliquez les modifications au serveur NFS en réexportant tous les répertoires :

sudo exportfs -ra

Étape 4.2 : Créer l'entrée de la carte maîtresse

La configuration autofs commence par le fichier de carte maître, /etc/auto.master. La meilleure pratique est de ne pas modifier ce fichier directement, mais d'ajouter de nouveaux fichiers de configuration dans le répertoire /etc/auto.master.d/.

Créez un nouveau fichier de carte maître pour nos partages de projets :

sudo nano /etc/auto.master.d/shares.autofs

Ajoutez la ligne unique suivante à ce fichier :

/project_shares /etc/auto.shares

Cette ligne indique à autofs : "Pour tout accès sous le répertoire /project_shares, consultez le fichier de carte situé à /etc/auto.shares pour les instructions."

Enregistrez et quittez l'éditeur.

Étape 4.3 : Créer le fichier de carte indirecte

Maintenant, créez le fichier de carte indirecte /etc/auto.shares que vous venez de référencer dans la carte maître.

sudo nano /etc/auto.shares

Ajoutez les lignes suivantes à ce fichier :

design  -fstype=nfs,rw,sync   localhost:/srv/nfs/design
testing -fstype=nfs,rw,sync   localhost:/srv/nfs/testing

Décomposons une ligne :

• design : C'est la "clé". Elle correspond au nom du sous-répertoire sous /project_shares. Lorsqu'un utilisateur accède à /project_shares/design, cette ligne est déclenchée.
• -fstype=nfs,rw,sync : Ce sont les options de montage, spécifiant le type de système de fichiers, l'accès en lecture-écriture et les écritures synchrones.
• localhost:/srv/nfs/design : C'est l'emplacement du partage NFS distant à monter.

Enregistrez et quittez l'éditeur.

Étape 4.4 : Recharger autofs et tester le montage

Pour que le service autofs reconnaisse vos nouveaux fichiers de carte, vous devez recharger sa configuration. Comme systemctl n'est pas disponible, nous envoyons le signal HUP (hangup) au processus automount, ce qui le force à relire sa configuration.

sudo killall -HUP automount

Maintenant, testons. Tout d'abord, essayez de lister le contenu du répertoire de base /project_shares. Il apparaîtra vide car rien n'a encore été monté.

ls -l /project_shares

total 0

Ensuite, tentez d'accéder à l'un des sous-répertoires. C'est le déclencheur qui amène autofs à effectuer le montage.

ls -l /project_shares/design

total 4
-rw-r--r--. 1 root root 17 Nov 10 16:10 README

Succès ! Le partage design a été monté automatiquement. Maintenant, si vous listez à nouveau le répertoire de base, vous verrez le répertoire design car il s'agit d'un point de montage actif.

ls -l /project_shares

total 0
dr-xr-xr-x. 2 root root 0 Nov 10 16:12 design

Faites de même pour le répertoire testing afin de confirmer qu'il fonctionne également :

ls -l /project_shares/testing

total 4
-rw-r--r--. 1 root root 16 Nov 10 16:10 README

Vous avez configuré et testé avec succès une carte d'automontage indirecte.

Créer une carte d'automontage directe pour les points de montage statiques

Dans cette étape, vous allez découvrir le second type de configuration d'automontage : une carte directe. Contrairement à une carte indirecte, qui regroupe plusieurs montages sous un répertoire de base commun, une carte directe définit des points de montage spécifiques et individuels n'importe où dans le système de fichiers. Chaque entrée dans une carte directe correspond à un chemin absolu unique.

Les cartes directes sont utiles pour monter un petit nombre de partages à des emplacements fixes et bien connus, comme le montage d'un répertoire d'outils partagé à /usr/local/tools. Nous allons configurer une carte directe pour monter un répertoire partagé common_data à /mnt/common.

Étape 5.1 : Préparer l'exportation du serveur NFS

Comme précédemment, nous devons d'abord configurer le répertoire sur notre serveur NFS simulé que nous souhaitons partager. Nous allons créer un répertoire nommé common_data.

Créez le répertoire et un fichier d'exemple à l'intérieur :

sudo mkdir -p /srv/nfs/common_data
sudo sh -c 'echo "Common shared data" > /srv/nfs/common_data/info.txt'

Maintenant, ajoutez une entrée à /etc/exports pour rendre ce répertoire disponible via NFS.

sudo nano /etc/exports

Ajoutez la nouvelle ligne suivante au fichier. Cela partagera le répertoire /srv/nfs/common_data.

/srv/nfs/common_data *(rw,sync,no_root_squash)

Enregistrez le fichier et quittez (Ctrl+X, Y, Entrée).

Appliquez les modifications au serveur NFS en réexportant tous les répertoires :

sudo exportfs -ra

Étape 5.2 : Créer l'entrée de la carte maîtresse pour la carte directe

Pour utiliser une carte directe, vous devez d'abord la référencer depuis la configuration de la carte maîtresse. Le point de montage spécial /- est utilisé pour indiquer que le fichier de carte associé est une carte directe.

Créez un nouveau fichier de carte maîtresse pour notre montage direct :

sudo nano /etc/auto.master.d/direct.autofs

Ajoutez la ligne unique suivante à ce fichier :

/- /etc/auto.direct

Cette ligne indique à autofs : "Consultez le fichier /etc/auto.direct pour une liste des montages directs. Les points de montage sont des chemins absolus définis dans ce fichier."

Enregistrez et quittez l'éditeur.

Étape 5.3 : Créer le fichier de carte directe

Maintenant, créez le fichier de carte directe /etc/auto.direct que vous venez de référencer.

sudo nano /etc/auto.direct

Ajoutez la ligne suivante à ce fichier. Le format est légèrement différent de celui d'une carte indirecte.

/mnt/common -fstype=nfs,rw,sync   localhost:/srv/nfs/common_data

Analysons cette ligne :

• /mnt/common : C'est la "clé", mais pour une carte directe, la clé est le chemin absolu complet du point de montage.
• -fstype=nfs,rw,sync : Ce sont les options de montage, identiques à celles utilisées précédemment.
• localhost:/srv/nfs/common_data : C'est l'emplacement du partage NFS distant.

Enregistrez et quittez l'éditeur.

Étape 5.4 : Recharger autofs et tester le montage direct

Tout comme vous l'avez fait pour la carte indirecte, vous devez recharger la configuration autofs pour qu'elle prenne en compte la nouvelle carte directe.

sudo killall -HUP automount

Maintenant, testons le montage direct. Contrairement à une carte indirecte, le point de montage /mnt/common n'existe pas sur le système de fichiers tant que vous n'essayez pas d'y accéder.

Tentez d'accéder au répertoire /mnt/common. Cela déclenchera autofs pour créer le point de montage et monter le partage.

ls -l /mnt/common

total 4
-rw-r--r--. 1 root root 19 Nov 10 17:00 info.txt

Succès ! Le montage direct a été créé à la demande. Vous pouvez également le vérifier avec la commande mount :

mount | grep common

localhost:/srv/nfs/common_data on /mnt/common type nfs4 (rw,relatime,vers=4.2,rsize=...,wsize=...,namlen=255,hard,proto=tcp,timeo=600,retrans=2,sec=sys,clientaddr=...,local_lock=none,addr=...)

Vous avez maintenant configuré avec succès une carte indirecte pour les sous-répertoires dynamiques et une carte directe pour un point de montage statique et absolu.

Vérifier les automontages directs et indirects en tant qu'utilisateurs différents

Dans cette dernière étape, vous allez vérifier comment fonctionne l'automontage dans un environnement multi-utilisateurs. L'automontage rend un partage disponible, mais ce sont les permissions du système de fichiers sous-jacentes sur le serveur NFS qui contrôlent qui peut réellement lire ou écrire dans les fichiers. Vous allez créer quelques utilisateurs de test, leur attribuer la propriété des partages NFS respectifs, puis tester leur accès aux cartes indirectes et directes.

Cet exercice démontre un scénario réel où différentes équipes (par exemple, conception et test) possèdent leurs répertoires partagés respectifs, avec un accès en lecture disponible pour les autres utilisateurs, mais un accès en écriture restreint au propriétaire.

Étape 6.1 : Créer des utilisateurs de test et définir les permissions

Tout d'abord, vous devez créer deux nouveaux utilisateurs : designer1 et tester1. Vous définirez également un mot de passe simple pour eux afin de pouvoir basculer vers leurs comptes.

Utilisez la commande useradd pour créer les utilisateurs. L'option -m crée un répertoire personnel pour eux.

sudo useradd -m designer1
sudo useradd -m tester1

Ensuite, définissez un mot de passe pour chaque utilisateur. Pour simplifier dans ce laboratoire, nous utiliserons le mot de passe labex.io pour les deux (il répond aux exigences de complexité, y compris la longueur, les majuscules/minuscules, les chiffres et les caractères spéciaux).

sudo passwd designer1
## Entrez le nouveau mot de passe UNIX : labex.io
## Retype new UNIX password: labex.io
## passwd: mot de passe mis à jour avec succès

sudo passwd tester1
## Entrez le nouveau mot de passe UNIX : labex.io
## Retype new UNIX password: labex.io
## passwd: mot de passe mis à jour avec succès

Maintenant, changez la propriété des répertoires partagés du côté "serveur" (/srv/nfs/*) pour accorder l'accès à ces nouveaux utilisateurs.

sudo chown -R designer1:designer1 /srv/nfs/design
sudo chown -R tester1:tester1 /srv/nfs/testing

Le répertoire /srv/nfs/common_data restera la propriété de root, le rendant en lecture seule pour les utilisateurs réguliers.

Étape 6.2 : Tester l'accès en tant qu'utilisateur designer1

Basculez vers le compte utilisateur designer1 en utilisant la commande su (substitute user). Le - garantit que vous obtenez l'environnement de connexion complet de l'utilisateur.

su - designer1
## Mot de passe : labex.io

Votre invite de commande changera pour [designer1@host ~]$.

Tout d'abord, testez l'accès au partage design via la carte indirecte. Cela devrait réussir.

ls -l /project_shares/design

total 4
-rw-r--r--. 1 designer1 designer1 17 Jun 16 16:12 README

Maintenant, essayez d'écrire un fichier dans ce répertoire. Cela devrait également réussir.

echo "My design file" > /project_shares/design/design_file.txt
ls -l /project_shares/design

total 8
-rw-r--r--. 1 designer1 designer1 15 Jun 16 16:18 design_file.txt
-rw-r--r--. 1 designer1 designer1 17 Jun 16 16:12 README

Ensuite, tentez d'accéder au partage testing. Vous pouvez voir le contenu, mais vous ne pouvez pas y écrire car il appartient à tester1.

ls -l /project_shares/testing

total 4
-rw-r--r--. 1 tester1 tester1 16 Jun 16 16:12 README

Enfin, testez le partage mappé directement. designer1 devrait pouvoir le lire mais pas y écrire.

cat /mnt/common/info.txt

Common shared data

echo "test" > /mnt/common/new_file.txt

-bash: /mnt/common/new_file.txt: Permission denied

Quittez la session designer1 pour revenir à l'utilisateur labex.

exit

Étape 6.3 : Tester l'accès en tant qu'utilisateur tester1

Maintenant, effectuez des tests similaires en tant qu'utilisateur tester1.

su - tester1
## Mot de passe : labex.io

Accédez au partage design. Vous pouvez voir le contenu, y compris le fichier créé par designer1, mais vous ne pouvez pas y écrire.

ls -l /project_shares/design

total 8
-rw-r--r--. 1 designer1 designer1 15 Jun 16 16:18 design_file.txt
-rw-r--r--. 1 designer1 designer1 17 Jun 16 16:12 README

Maintenant, accédez au partage testing et écrivez-y. Cela devrait réussir car tester1 possède ce répertoire.

ls -l /project_shares/testing

total 4
-rw-r--r--. 1 tester1 tester1 16 Jun 16 16:12 README

echo "My test script" > /project_shares/testing/test_script.sh
ls -l /project_shares/testing

total 8
-rw-r--r--. 1 tester1 tester1 16 Jun 16 16:12 README
-rw-r--r--. 1 tester1 tester1 15 Jun 16 16:19 test_script.sh

Quittez la session tester1.

exit

Étape 6.4 : Nettoyer l'environnement

Pour terminer le laboratoire et restaurer le système à son état d'origine, supprimez les utilisateurs de test que vous avez créés. La commande userdel -r supprime l'utilisateur et son répertoire personnel.

sudo userdel -r designer1
sudo userdel -r tester1

Ceci conclut le laboratoire sur la gestion de NFS avec autofs.

Résumé

Dans ce laboratoire, vous apprendrez à configurer l'accès client NFS sur un système RHEL. Vous commencerez par effectuer un montage manuel, en créant d'abord un point de montage local, puis en utilisant la commande mount pour vous connecter au partage NFS. Après avoir établi la connexion manuelle avec la commande mount, vous procéderez à la configuration d'un montage persistant en créant une entrée dans le fichier /etc/fstab, garantissant ainsi que le partage est automatiquement monté au démarrage.

De plus, le laboratoire couvre la configuration du montage à la demande avec le service autofs. Cela implique l'installation et l'activation du service, puis la définition de la manière dont les partages sont montés en utilisant deux méthodes différentes : la création d'une carte indirecte pour le montage dynamique de répertoires et d'une carte directe pour le montage de partages à des emplacements statiques et prédéfinis. Le processus se termine par la vérification que les montages automatiques directs et indirects fonctionnent correctement pour différents utilisateurs.