Montage SSHFS via AUTOFS 5 multi-utilisateurs

SSHFS permet d’accéder à des données distantes via SSH comme s’il s’agissait d’un classique montage réseau (type NFS, NBD, iSCSI, etc).
En parallèle, AUTOFS permet de monter un système de fichier, local ou distant lorsque l’utilisateur y accède et de le démonter proprement après un temps définit d’inactivité. Par exemple, il est possible de ne monter la partition /dev/sda6 dans /mnt/backup qu’au moment ou l’on entrera dans le répertoire /mnt/backup et de le démonter 5 minutes après qu’elle ne soit plus utilisée (un « Mémo » sur la configuration d’autofs sera bientôt disponible sur ce site).

L’association de ces deux outils ouvre des perspectives plus qu’intéressantes : dès lors que vous disposez d’une connexion réseau, la consultation de vos données distantes ce résume à un simple « cd /mnt/sshfs/mamachine » ! le tous sans qu’aucun autre service qu’SSH ne soit activé sur le poste cible !

La solution généralement proposée est cependant difficile à maintenir sur un poste multi-utilisateurs… Cette note revient sur la solution généralement proposée avant de proposer un système plus souple.

Installation des outils

L’installation des outils ne représente aucune difficulté sous les différentes distributions. Installez via l’outil habituel les pacquages « autofs » et « sshfs » ce qui donne sous Debian et ses dérivés :

root@debian:~# aptitude install sshfs autofs
...
The following NEW packages will be installed:
  fuse-utils{a} libdb4.7{a} libfuse2{a} libglib2.0-0{a} libglib2.0-data{a}
  libpcre3{a} libxml2{a} make{a} perl{a} perl-modules{a} sgml-base{a}
  shared-mime-info{a} sshfs xml-core{a}
...
Do you want to continue? [Y/n/?] Y

ou sous Gentoo :

17:04 srv ~ # emerge -av autofs sshfs
 
Calculating dependencies... done!
[ebuild   N   ] net-fs/autofs-5.0.4-r5  USE="ldap" 144 kB
...
[ebuild   N   ] sys-fs/sshfs-fuse-2.2  0 kB
...
Would you like to merge these packages? [Yes/No]

en ayant pensé à activé l' »automount » ET fuse dans le kernel :

File systems  --->
...
  <   > Kernel automounter support
  < M > Kernel automounter version 4 support (also supports v3)
...
  < M > Filesystem in Userspace support
...

Si le module « fuse » n’est pas chargé, un classique « modprobe » y remédiera :

root@debian:~# modprobe fuse

Enfin, dernier maillon de la mise en place pour les systèmes type Debian, ajouter les utilisateurs autorisé à utiliser « fuse » au groupe « fuse »

root@debian:~# gpasswd -a fhh fuse
Adding user fhh to group fuse

La méthode traditionnelle

  • La méthode courante d’utilisation conjointe d’SSHFS et d’AUTOFS consiste à générer un couple de clés publique/privée appartenant à « root » :
    fhh@mafalda ~ $ su -
    Mot de passe :
    root@mafalda:~# ssh-keygen -b4096
    Generating public/private rsa key pair.
    Enter file in which to save the key (/root/.ssh/id_rsa):
    Enter passphrase (empty for no passphrase): rien
    Enter same passphrase again: rien non plus
    Your identification has been saved in /root/.ssh/id_rsa.
    Your public key has been saved in /root/.ssh/id_rsa.pub.
    The key fingerprint is:
    ...
  • puis à déplacer la clé publique sur le compte utilisateur de la machine distante à monter :
    root@mafalda:~# cat .ssh/id_rsa.pub | ssh -p2240 fhh@srv.rez0.lan 'cat >> .ssh/authorized_keys'
    Password:
    root@mafalda:~# ssh -p2240 fhh@srv.rez0.lan
    Last login: Wed May 19 22:52:43 2010 from mafalda.rez0.lan
    fhh@srv ~ $ ^d
  • à modifier le fichier « auto.master » placé sous /etc ou /etc/autofs en fonction des distributions pour définir un nouvel espace de points de montages (à créer) et le fichier associé les définissants :
    root@mafalda:~# cat /etc/auto.master
    ...
    /mnt/sshfs      /etc/auto.sshfs --timeout=60
    ...
    root@mafalda:~# mkdir -p /mnt/sshfs

    Notez l’option « –timeout=60 » qui assurera le démontage du répertoire après une minute (60 secondes) de non utilisation des systèmes de fichiers montés par SSHFS.

  • pour terminer par la définition du fichier auto.sshfs (ou de son équivalent définit dans « auto.master ») :
    root@mafalda:~# cat /etc/auto.sshfs
    ...
    srv         -fstype=fuse,port=2240,rw,nodev,nonempty,noatime,allow_other    :sshfs\#fhh@srv.rez0.lan\:
  • et le redémarrage d’autofs :
    root@mafalda:~# /etc/init.d/autofs restart

Dans le cas ou « root » utiliserait plusieurs clés, vous pouvez naturellement utiliser le fichier de configuration d’OpenSSH de l’utilisateur « root » :

root@mafalda:~# ssh-keygen -b4096 -f .ssh/key.srv
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase): rien
Enter same passphrase again: encore rien
Your identification has been saved in .ssh/key.srv.
Your public key has been saved in .ssh/key.srv.pub.
The key fingerprint is:
...
root@mafalda:~# ls .ssh
config  id_rsa  id_rsa.pub  key.srv  key.srv.pub  known_hosts
root@mafalda:~# cat .ssh/key.srv.pub | ssh -p2240 fhh@srv.rez0.lan 'cat >> .ssh/authorized_keys'
Password:
root@mafalda:~# cat .ssh/config
...
Host=srv
Hostname=srv.rez0.lan
User=fhh
Port=2240
Compression=yes
IdentityFile=~/.ssh/key.srv
...
root@mafalda:~# ssh srv
Last login: Thu May 20 00:37:26 2010 from mafalda.rez0.lan
fhh@srv ~ $ ^d

en résumé, nous créons un couple de clé SSH nommé « key.srv » et « key.srv.pub », nous copions la clé publique sur le compte de l’utilisateur distant dans son fichier « authorized_keys » et vérifions que le fichier .ssh/config pointe bien vers la bonne clé, le bon serveur et le bon port. Si le fichier .ssh/config n’existe pas, créez le. Son contenu est simple et peut rendre bien d’autres services :

  • Host définit le nom simplifié ou l’alias que vous souhaitez,
  • Hostname est le nom complet ou l’ip de la machine visée par l’alias,
  • User et le nom d’utilisateur a utiliser (facultatif, par défaut le login appelant la commande),
  • Port et le port a utiliser (facultatif, par défaut 22 ou celui renseigné dans les fichier de configuration d’OpenSSH)
  • Compression active ou non la compression (facultatif),
  • IdentityFile renseigne le chemin vers la clé à utiliser (facultatif).

Le fichier « auto.master » reste alors inchangé, mais le fichier « auto.sshfs » ou le nom que vous lui aurez donné dans « /etc/auto.master » ce simplifie en :

root@mafalda:~# cat /etc/auto.sshfs
...
srv         -fstype=fuse,rw,nodev,nonempty,noatime,allow_other     :sshfs\#srv\:

et, quelque soit la solution choisie, après un redémarrage d’autofs… :

fhh@mafalda ~ $ whoami
fhh
fhh@mafalda ~ $ mount
/dev/sda1 on / type ext3 (rw)
proc on /proc type proc (rw)
...
fhh@mafalda ~ $ ls /mnt/sshfs
rien
fhh@mafalda ~ $ cd /mnt/sshfs/srv
fhh@mafalda /mnt/sshfs/srv $ ls
archives ... tmp.txt
fhh@mafalda ~ $ mount
/dev/sda1 on / type ext3 (rw)
proc on /proc type proc (rw)
...
srv: on /mnt/sshfs/srv type fuse.sshfs (rw,nodev,noatime,max_read=65536,allow_other)

… le système de fichier et accessible EN SSH comme n’importe quel disque !

Premiers constats

Le système fonctionne, mais dès que la machine dispose de plus d’un compte utilisateur actif, les choses ce compliquent…

Les montages sont effectué par « root », donc tous les utilisateurs peuvent accéder aux montages des autres.

Le système est difficile à maintenir car chaque utilisateur désireux d’ajouter un nouveau montage doit demander à l’administrateur (« root ») d’ajouter les paramètres de la connexion SSH à son fichier « .ssh/config »…

Dans le pire des cas, tous les utilisateurs peuvent utiliser la même clé publique…

Dans le cas de clés différentes en fonction des comptes utilisés, on assistera à une multiplication des clé « privée » ce qui n’a rien de bon…

Un début de solution…

Autofs permet d’utiliser des scripts pour générer la carte des points de montages…

Le script proposé ci dessous génère une cartographie des points de montage en fonction du fichier « ~/.auto.sshfs » de l’utilisateur. Dans ce fichier, l’utilisateur peut définir tous les paramètres de connexion SSH sans avoir à demander l’intervention de « root » pour l’ajout ou la suppression d’un point de montage.

Les fichiers sont ensuite accessible sous :

/mnt/sshfs/<login>/<login>/<point de montage>

Mise en place

Tous comme dans la méthode traditionnelle, la mise en place du script commence par la modification d’auto.master et la création du répertoire des points de montages :

root@mafalda:~# cat /etc/auto.master
...
/mnt/sshfs      /etc/auto.sshfs --timeout=60
...
root@mafalda:~# mkdir -p /mnt/sshfs

Le script, disponible en fin d’article et téléchargeable à l’url suivante https://www.admin-linux.fr/wp-content/uploads/2010/05/autofssh, est copié sous « /etc/auto.sshfs » (ou le nom définit dans le fichier « auto.master »). Les droits « 700 » lui sont appliqué :

root@mafalda:~# wget https://www.admin-linux.fr/wp-content/uploads/2010/05/autofssh
--2010-05-30 00:21:55--  https://www.admin-linux.fr/wp-content/uploads/2010/05/autofssh
Resolving www.admin-linux.fr... 82.67.215.202
Connecting to www.admin-linux.fr|82.67.215.202|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 5230 (5.1K) [text/plain]
Saving to: “autofssh”
 
100%[================================================>] 5,230       --.-K/s   in 0.004s  
 
2010-05-30 00:21:55 (1.24 MB/s) - “autofssh” saved [5230/5230]
 
root@mafalda:~# cp autofssh /etc/auto.sshfs
root@mafalda:~# chmod 700 /etc/auto.sshfs
root@mafalda:~# ls -l /etc/auto.sshfs
-rwx------ 1 root root 5230 May 30 00:22 /etc/auto.sshfs

le redémarrage d’autofs termine la partie administrateur de la configuration :

root@mafalda:~# /etc/init.d/autofs restart
Stopping automount: done.
Starting automount: done.

Les utilisateurs peuvent alors configurer les points de montages qu’ils souhaitent dans le fichier « .auto.sshfs » à la racine de leur compte.

Une entrée du fichier « .auto.sshfs » de l’utilisateur est de la forme :

<point de montage>:<machine distante>:<port>:<login distant>:<répertoire distant à monter>:<clé ssh>

où seul le point de montage DOIT être précisé. Pour ajouter un nouveau montage, l’utilisateur créera son couple de clé SSH puis déploiera la clé publique sur la machine distante avant de compléter son fichier « .auto.sshfs » :

00:56:20 fhh@mafalda ~ $ ssh-keygen -b2048 -f .ssh/key.backup
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase): RIEN
Enter same passphrase again: RIEN
Your identification has been saved in .ssh/key.backup.
Your public key has been saved in .ssh/key.backup.pub.
The key fingerprint is:
...
01:05:58 fhh@mafalda ~ $ cat .ssh/key.backup.pub | ssh -p3300 nours@backup.rez0.lan 'cat >> .ssh/authorized_keys'
Password:
01:08:32 fhh@mafalda ~ $ ssh -p3300 -i .ssh/key.backup nours@backup.rez0.lan
fhh@backup ~ $ # la connexion par clé fonctionne :-)
fhh@backup ~ $ ^d
01:08:32 fhh@mafalda ~ $ cat > .auto.sshfs
backup:backup.rez0.lan:3300:nours::key.backup

Si un montage est déjà en cours d’utilisation, l’utilisateur devra attendre le démontage automatique avant que les modifications soient prisent en compte… Mais ensuite, le montage est disponible sans intervention de « root » :

22:37:01 fhh@mafalda ~ $ ls /mnt/sshfs/
22:37:06 fhh@mafalda ~ $ ls /mnt/sshfs/fhh
fhh
22:37:08 fhh@mafalda ~ $ ls /mnt/sshfs/fhh/fhh/
backup
22:37:12 fhh@mafalda ~ $ ls /mnt/sshfs/fhh/fhh/backup
0493.pdf         ...

Les paramètres déjà définits dans « .ssh/config » n’ont bien sur pas besoin d’être re définits… les fichiers de configurations permettent une grande souplesse :

23:26:56 fhh@mafalda ~ $ cat .auto.sshfs
# Montage de mon compte sur srv (entierement definit dans .ssh/config) :
srv
 
# Montage du compte nours sur backup :
nours@backup:backup.rez0.lan:3300:nours::key.backup
 
# Montage de mon compte sur backup :
backup:backup.rez0.lan:3300:fhh::~/.ssh/key.backup
23:27:00 fhh@mafalda ~ $ cat .ssh/config
Host=srv
Hostname=srv.rez0.lan
Port=2240
IdentityFile=~/.ssh/key.srv
User=fhh
Compression=yes
23:31:35 fhh@mafalda ~ $ ls /mnt/sshfs/fhh/fhh/
backup  srv  nours@backup

Fonctionnement du script

Le script commence par déterminer les paramètres correspondant à l’utilisateur à utiliser par l’accès au répertoire « /racine/montage/login », les paramètres du compte « login » sont chargés :

  • vérification de l’existence du compte,
  • récupération des uid, gid, homedir, etc.
  • récupération du fichier de configuration dans le home du compte utilisé

En fonction des paramètres définits dans le fichier de configuration de l’utilisateur, un fichier de chargement utilisant « sudo » est construit et stocké dans « LAUNCHERS_LOCATION ».

Enfin la cartographie des points de montages est retournée en fin de script.

Le montage est effectué sous l’uid et le gid de l’utilisateur à qui appartient le fichier « .auto.sshfs ». Les autres utilisateurs ne sont pas autorisé à entrer dans les répertoires de données.

Télécharger le script “autosshfs”.

#!/bin/bash
 
# Par FHH <fhh@admin-linux.fr>
# 
# Sources disponibles sur https://www.admin-linux.fr
# 
# Description :
# Génération des points de montages pour AutoFS en SSHFS.
# Ce script lits les données du fichier FILE_USER de l'utilisateur
# pour générer les points de montages nécessaires.
# 
# Format du fichier FILE_USER :
# <point de montage>:<machine distante>:<port>:<login distant>:<répertoire distant à monter>:<clé ssh>
#
 
# Login utilisateur :
KEY=${1} ;
DEFAULT_OPTS="-fstype=fuse,rw,nodev,nonempty,noatime,allow_other,default_permissions,reconnect" ;
FILE_USER=".auto.sshfs" ;
SCRIPT_NAME=${0} ;
LAUNCHERS_LOCATION="/var/autofs/sshfs" ;
LAUNCHERS_LOCATION_OWNER="root.root" ;
LAUNCHERS_LOCATION_PERMISSION="700" ;
SSH_DIR=".ssh" ;
DELAY=10 ;
SUDO_OPTS="-Hiu" ;
 
# Binaires :
GETENT="/usr/bin/getent" ;
GREP="/bin/grep" ;
SED="/bin/sed" ;
LOGGER="/usr/bin/logger" ;
MKDIR="/bin/mkdir" ;
RM="/bin/rm" ;
STAT="/usr/bin/stat" ;
CHOWN="/bin/chown" ;
CHMOD="/bin/chmod" ;
SSL="/usr/bin/openssl" ;
TOUCH="/bin/touch" ;
CAT="/bin/cat" ;
DATE="/bin/date" ;
SUDO="/usr/bin/sudo" ;
SSH="/usr/bin/ssh" ;
FIND="/usr/bin/find" ;
 
# Fonction de sortie de script :
die() {
        echo $@ >&2 ;
        ${LOGGER} $@ ;
        exit 1 ;
}
 
# Fonction de creation des fichiers de connexions :
create_launcher() {
        USER=${1} ;
        FILE_NAME=${2} ;
        [[ ! -z "${3}" ]] &&  KEY_FILE="-i ${3}" ;
        CURRENT_DATE=$(date +'%s') ;
${CAT} << EOF > "${LAUNCHERS_LOCATION}/${FILE_NAME}"
#!/bin/bash
 
# Script de chargement de connexion pour SSHFS et AUTOFS
# Généré automatiquement par ${0} le ${CURRENT_DATE}
 
${SUDO} ${SUDO_OPTS} ${USER} "${SSH} ${KEY_FILE} \$@"
EOF
 
}
 
# Check file
check_launcher() {
        FILE_NAME=${1} ;
        KEY_FILE="" ; [[ ! -z "${2}" ]] &&  KEY_FILE="${2}" ;
        [[ ! -f "${LAUNCHERS_LOCATION}/${FILE_NAME}" ]] && \
                create_launcher ${KEY} ${FILE_NAME} ${KEY_FILE} ;
        [[ "${LAUNCHERS_LOCATION_PERMISSION}" != `${STAT} -c%a "${LAUNCHERS_LOCATION}/${FILE_NAME}"` ]] && \
                ${CHMOD} "${LAUNCHERS_LOCATION_PERMISSION}" "${LAUNCHERS_LOCATION}/${FILE_NAME}" ;
        [[ "${LAUNCHERS_LOCATION_OWNER}" != `${STAT} -c%U.%G "${LAUNCHERS_LOCATION}/${FILE_NAME}"` ]] && \
                ${CHOWN} "${LAUNCHERS_LOCATION_OWNER}" "${LAUNCHERS_LOCATION}" ;
}
 
# Récupération des données :
TMP_IFS=${IFS} ;
IFS=":" ;
 
USERDATA=`${GETENT} passwd | ${GREP} "^${KEY}:"` ;
 
[[ -z "${USERDATA}" ]] && die "ERR ${SCRIPT_NAME} > Data ${KEY} unavailable !" ;
 
for tmp in ${USERDATA} ; do
        USERDATA_T[${#USERDATA_T[*]}]=${tmp} ;
done
 
IFS=${TMP_IFS} ;
 
[[ -z "${USERDATA_T[5]}" ]] && die "ERR ${SCRIPT_NAME} > ${KEY} homedir empty !" ;
[[ -d "${USERDATA_T[5]}" ]] || die "ERR ${SCRIPT_NAME} > ${KEY} homedir not found !" ;
[[ -f "${USERDATA_T[5]}/${FILE_USER}" ]] || die "ERR ${SCRIPT_NAME} > ${FILE_USER} to ${KEY} not found !" ;
[[ -s "${USERDATA_T[5]}/${FILE_USER}" ]] || die "ERR ${SCRIPT_NAME} > empty file ${FILE_USER} to ${KEY} !" ; 
[[ -z "${LAUNCHERS_LOCATION}" ]] && die "ERR ${SCRIPT_NAME} > launcher location not set !" ;
 
if [ ! -d "${LAUNCHERS_LOCATION}" ] ; then
        ${LOGGER} "WARN ${SCRIPT_NAME} > launcher directory not found ! Script create it !" ;
        [[ -e "${LAUNCHERS_LOCATION}" ]] && ${RM} -rf "${LAUNCHERS_LOCATION}" ;
        ${MKDIR} -p -m ${LAUNCHERS_LOCATION_PERMISSION} "${LAUNCHERS_LOCATION}" ;
        [[ $? -eq 0 ]] || die "ERR ${SCRIPT_NAME} > impossible to create launcher directory ${LAUNCHERS_LOCATION} !" ;
fi
 
if [ "${LAUNCHERS_LOCATION_OWNER}" != `${STAT} -c%U.%G "${LAUNCHERS_LOCATION}"` ] ; then
        ${LOGGER} "WARN ${SCRIPT_NAME} > curious owner to launcher directory ! Script change it !" ;
        ${CHOWN} -R "${LAUNCHERS_LOCATION_OWNER}" "${LAUNCHERS_LOCATION}" ;
fi
 
if [ "${LAUNCHERS_LOCATION_PERMISSION}" != `${STAT} -c%a "${LAUNCHERS_LOCATION}"` ] ; then
        ${LOGGER} "WARN ${SCRIPT_NAME} > curious rigth to launcher directory ! Script change it !" ;
        ${CHMOD} -R "${LAUNCHERS_LOCATION_PERMISSION}" "${LAUNCHERS_LOCATION}" ;
fi
 
${FIND} ${LAUNCHERS_LOCATION} -atime +${DELAY} -type f -exec ${RM} {} \;
 
DEFAULT_FILE_LAUNCHER=$(echo "${KEY}" | ${SSL} md5) ;
check_launcher "${DEFAULT_FILE_LAUNCHER}" ;
 
MOUNT_OPTS=$(echo "${DEFAULT_OPTS},uid=${USERDATA_T[2]},gid=${USERDATA_T[3]},ssh_command=${LAUNCHERS_LOCATION}/${DEFAULT_FILE_LAUNCHER}") ;
 
MOUNT_CMD="${MOUNT_OPTS}        /${KEY}" ;
cpteur=0 ;
 
while read ligne ; do
        ligne=$(echo $(echo $(echo "${ligne}" | ${SED} -e 's/[[:blank:]]*$//') | ${SED} -e 's/^[[:blank:]]*//') | ${GREP} -v "^#") ;
        if [ ! -z "${ligne}" ] ; then
                FILE_LAUNCHER=$(echo "${KEY}.${ligne}" | ${SSL} md5) ;
                [[ ${cpteur} -gt 0 ]] && MOUNT_CMD="${MOUNT_CMD}        /${KEY}" ;
                (( cpteur++ )) ;
                TMP_IFS=${IFS} ; IFS=":" ;
                for elem in ${ligne} ; do
                        DETAILS_T[${#DETAILS_T[*]}]=${elem}
                done
                IFS=${TMP_IFS} ;
                if [ -z "${DETAILS_T[5]}" ] ; then
                        check_launcher "${DEFAULT_FILE_LAUNCHER}" ;
                else
                        [[ -z $(echo $(echo "${DETAILS_T[5]}" | ${GREP} -v "^/") | ${GREP} -v "^~/") ]] || \
                                DETAILS_T[5]=${USERDATA_T[5]}/${SSH_DIR}/${DETAILS_T[5]} ;
                        check_launcher "${FILE_LAUNCHER}" "${DETAILS_T[5]}";
                fi
                [[ ! -z "${DETAILS_T[4]}" ]] && DETAILS_T[4]=$(echo $(echo "${DETAILS_T[4]}" | ${GREP} -v "^~/$") | ${GREP} -v "^~$") ;
                [[ -z "${DETAILS_T[1]}" ]] && DETAILS_T[1]="${DETAILS_T[0]}" ;
                MOUNT_CMD="${MOUNT_CMD}/${DETAILS_T[0]} " ;
                [[ -z "${DETAILS_T[2]}" ]] || SPECIAL_OPTS="-port=${DETAILS_T[2]}" ;
                if [ ! -z "${DETAILS_T[5]}" ] ; then
                        if [ ! -z "${SPECIAL_OPTS}" ] ; then
                                SPECIAL_OPTS="${SPECIAL_OPTS},ssh_command=${LAUNCHERS_LOCATION}/${FILE_LAUNCHER}" ;
                        else
                                SPECIAL_OPTS="-ssh_command=${LAUNCHERS_LOCATION}/${FILE_LAUNCHER}" ;
                        fi
                fi
                MOUNT_CMD="${MOUNT_CMD} ${SPECIAL_OPTS} :sshfs\#" ;
                [[ ! -z "${DETAILS_T[3]}" ]] && MOUNT_CMD="${MOUNT_CMD}${DETAILS_T[3]}@" ;
                MOUNT_CMD="${MOUNT_CMD}${DETAILS_T[1]}:${DETAILS_T[4]}" ;
        fi
        unset SPECIAL_OPTS ;
        unset DETAILS_T ;
done < "${USERDATA_T[5]}/${FILE_USER}" ;
 
[[ ${cpteur} -gt 0 ]] || die "ERR ${SCRIPT_NAME} > No entries found !" ;
 
echo "${MOUNT_CMD}" ;

Note : en cas de dysfonctionnement, consultez les commentaires en fin d’article…

Télécharger le script “autosshfs”.

Le script peut être testé à vide :

root@mafalda:~# /etc/auto.sshfs toto
ERR /etc/auto.sshfs &gt; Data toto unavailable !
root@mafalda:~# cat ~fhh/.auto.sshfs
backup
root@mafalda:~# /etc/auto.sshfs fhh
-fstype=fuse,rw,nodev,nonempty,noatime,allow_other,default_permissions,reconnect,uid=1000,gid=1000,ssh_command=/var/autofs/sshfs/f12f89aa181867c470b46ecd8bcf2f5f      /fhh/backup                     :sshfs\#backup:
root@mafalda:~#

Limites du script

Le script est destiné à offrir une plus grande souplesse d’utilisation d’sshfs sur autofs. Il est loin d’être parfait et ne fonctionne pas lorsque « root » n’a pas accès aux comptes des utilisateurs par exemple. Il utilise SUDO dont certains ce méfient… Il ne répond pas à tous les besoins, et soufre de quelques bug tel que la construction des chemin ou le login est répété … D’autres tentatives ont été développées pour assouplir et sécuriser le système comme par exemple « autofs_sshfs » disponible sur http://pturing.firehead.org/software/autofs_sshfs/ mais ces alternatives utilisent plusieurs scripts et sont peu réactives…

Il semble que dans l’immédiat, nous devions nous contenter de ce type de scripts en attendant que les outils évoluent encore en permettant par exemple de passer des paramètres à « ssh_command » (ce qui éviterai d’avoir à générer des scripts à la volée) ou en permettant de récupérer l’utilisateur à l’origine de l’accès au point de montage…

Références

autofs_sshfs : http://pturing.firehead.org/software/autofs_sshfs/
Man autofs : http://linux.die.net/man/8/autofs , http://linux.die.net/man/5/autofs
Man automount : http://linux.die.net/man/8/automount
Man sshfs : http://pwet.fr/man/linux/commandes/sshfs

2 réflexions au sujet de « Montage SSHFS via AUTOFS 5 multi-utilisateurs »

  1. Un grand merci pour ce script qui fait exactement ce que je cherchais !

    Par contre, j’ai dû faire les deux adaptations suivantes pour le faire marcher :
    – openssl (version 1.0.0f) renvoie chez moi (stdin)= xxxxx, donc j’ai remplacé ${SSL} md5 par ${SSL} md5 | awk '{print $2}'

    – dans le fichier launcher, j’ai supprimé les  »  » autour de la commande ssh car sudo ne reconnait pas ce format (sudo version 1.8.2-r1): ${SUDO} ${SUDO_OPTS} ${USER} ${SSH} ${KEY_FILE} \$@

    HTH

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *