Solution simple : Partage de fichiers avec Samba

Linux Mint permet de partager facilement des dossiers (comme le dossier Bureau) avec Samba, compatible avec tous les systèmes (Linux, Windows, macOS). 🔧 Étapes à suivre sur chaque ordinateur : 1. 📦 Installer Samba (si ce n’est pas déjà fait)

sudo apt update sudo apt install samba

2. 🖥️ Partager le dossier Bureau

Ouvre ton explorateur de fichiers (Nemo).

Va dans ~/Bureau.

Clic droit sur un espace vide → Propriétés

Onglet Partage

Coche "Partager ce dossier"

(Optionnel) Coche "Autoriser les autres à créer et supprimer des fichiers"

Si demandé, clique sur Installer les services de partage (ça installe Samba si ce n’est pas encore fait).

3. 🔓 Gérer les permissions

Tu peux donner accès à tout le monde sur le LAN ou seulement à certains utilisateurs. 📂 Pour accéder au dossier partagé depuis un autre PC :

Ouvre Fichiers (Nemo).

Menu → Se connecter à un serveur

Tape :

smb:nom-de-l-hôte/Bureau Ou, si tu connais l’IP : smb:192.168.x.x/Bureau

Tu peux enregistrer les favoris si tu veux les retrouver facilement. 🔐 Astuce : Activer le partage sans mot de passe (si nécessaire)

Dans /etc/samba/smb.conf, tu peux rendre le partage plus libre sur un LAN privé :

[global]

workgroup = WORKGROUP
server string = %h server
map to guest = Bad User
security = user

[Bureau]

path = /home/utilisateur/Bureau
browsable = yes
writable = yes
guest ok = yes
read only = no

Ensuite :

sudo systemctl restart smbd

Remplace /home/utilisateur/Bureau par le chemin réel, et adapte pour chaque utilisateur. 🧠 Autres alternatives (moins simples) : Méthode Avantage Inconvénient NFS Très rapide Plus technique SSHFS Sécurisé via SSH Montage manuel Syncthing Synchronisation automatique Pas en mode “partage” Nextcloud Interface web, mobile etc. Nécessite un serveur local ✅ En résumé

Pour partager le dossier Bureau de chaque ordinateur Mint de manière simple :

Utilise le partage de dossier via Nemo avec Samba

Chaque PC pourra accéder aux autres via smb://adresse/Bureau

Pas besoin de terminal une fois configuré

Souhaites-tu un script d’installation + partage auto du dossier Bureau sur tous les postes du réseau ? Vous avez dit : oui ChatGPT a dit :

Parfait ! Voici un script Bash que tu peux exécuter sur chaque ordinateur sous Linux Mint pour :

Installer Samba (si besoin)

Créer un partage Samba du dossier ~/Bureau

Autoriser l’accès aux autres machines du LAN (en mode "invité" = pas de mot de passe)

📜 Script de configuration Samba pour partager le dossier Bureau

#!/bin/bash

#

CONFIGURATION

PARTAGE_NAME=“Bureau” DOSSIER=“$HOME/Bureau” UTILISATEUR=$(whoami)

echo “➡ Installation de Samba…” sudo apt update && sudo apt install -y samba

echo “➡ Création du dossier Bureau (s'il n'existe pas)…” mkdir -p “$DOSSIER”

echo “➡ Sauvegarde de la config actuelle de Samba…” sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak

echo “➡ Ajout du partage Samba dans smb.conf…”

# Supprimer un ancien bloc [Bureau] s'il existe sudo sed -i '/^\[Bureau\]/,/^$/d' /etc/samba/smb.conf

# Ajouter la nouvelle config en bas sudo tee -a /etc/samba/smb.conf > /dev/null «EOL

[Bureau]

path = $DOSSIER
browseable = yes
writable = yes
guest ok = yes
read only = no
force user = $UTILISATEUR

EOL

echo “➡ Redémarrage du service Samba…” sudo systemctl restart smbd

echo “✅ Le dossier '$DOSSIER' est maintenant partagé sous le nom '$PARTAGE_NAME'.” echo “➡ Accessible via : smb:$(hostname)/$PARTAGE_NAME ou smb:<adresse-IP>/$PARTAGE_NAME”

▶️ Comment utiliser ce script

Ouvre un terminal.

Copie le script dans un fichier :

nano partage_bureau.sh

Colle le script, puis enregistre avec Ctrl+O, Entrée, puis Ctrl+X

Rends le script exécutable :

chmod +x partage_bureau.sh

Lance-le :

./partage_bureau.sh

🔁 Répète cela sur chaque machine Linux Mint du réseau.

Ensuite, tu peux accéder à chaque “Bureau” partagé depuis Nemo ou en tapant dans la barre d'adresse :

smb:nom-du-pc/Bureau ou smb:192.168.x.x/Bureau

Souhaites-tu aussi un script client pour monter automatiquement ces dossiers au démarrage ? Vous avez dit : oui ChatGPT a dit :

Parfait ! Voici un script client qui permet à chaque poste Linux Mint de :

Scanner les autres machines du réseau local (ou lire une liste IP/host)

Monter automatiquement leurs dossiers partagés Bureau dans un répertoire local (~/Réseau-Bureaux)

Créer les montages au démarrage via fstab ou un script de session

📜 Script client : Montage automatique des dossiers “Bureau” du réseau

#!/bin/bash

#

CONFIGURATION

MONTAGE_PARENT=“$HOME/Réseau-Bureaux” LISTE_IPS=(“192.168.1.10” “192.168.1.11” “192.168.1.12”) # ←- À adapter PARTAGE=“Bureau”

echo “➡ Création du dossier de base : $MONTAGE_PARENT” mkdir -p “$MONTAGE_PARENT”

echo “➡ Installation du support CIFS (Samba client)…” sudo apt install -y cifs-utils

# Boucle sur chaque IP for ip in “${LISTE_IPS[@]}”; do

MONTAGE="$MONTAGE_PARENT/$ip"
echo "➡ Création du dossier de montage pour $ip : $MONTAGE"
sudo mkdir -p "$MONTAGE"

# Tester si le partage est dispo
echo "🔍 Vérification de $ip..."
if smbclient -L //$ip -N 2>/dev/null | grep -q "$PARTAGE"; then
echo "✅ Partage '$PARTAGE' trouvé sur $ip, ajout dans fstab..."
# Nettoyage de lignes précédentes
sudo sed -i "\|//$ip/$PARTAGE|d" /etc/fstab

# Ajouter une ligne dans /etc/fstab
echo "//$ip/$PARTAGE $MONTAGE cifs guest,_netdev,uid=$USER,gid=$USER 0 0" | sudo tee -a /etc/fstab > /dev/null
else
echo "❌ Le partage '$PARTAGE' n’est pas disponible sur $ip."
fi

done

echo “➡ Montage de tous les partages listés dans fstab…” sudo mount -a

echo “✅ Tous les dossiers Bureau distants disponibles dans : $MONTAGE_PARENT”

📝 À faire avant d’exécuter le script

Adapter la liste des IPs dans cette ligne :

LISTE_IPS=(“192.168.1.10” “192.168.1.11” “192.168.1.12”)

Tu peux aussi utiliser les noms NetBIOS/hostnames si tu les connais. ▶️ Utilisation du script

Sauvegarde-le :

nano monter_bureaux.sh

Colle le script, modifie les IPs, puis :

chmod +x monter_bureaux.sh ./monter_bureaux.sh

🔁 Pour que ça monte automatiquement au démarrage

L’entrée dans /etc/fstab s’en occupe. Assure-toi que :

Le Wi-Fi ou Ethernet soit bien actif à l’ouverture de session

_netdev est bien présent dans la ligne fstab (il attend que le réseau soit prêt)

✅ Résultat

Tu auras dans ton dossier ~/Réseau-Bureaux un sous-dossier pour chaque PC contenant son dossier “Bureau” partagé :

~/Réseau-Bureaux/ ├── 192.168.1.10 │ └── fichiers du Bureau distant ├── 192.168.1.11 │ └── …

Souhaites-tu aussi une interface graphique (ex. petit menu Python ou app GTK) pour choisir les machines à monter ? Vous avez dit : oui ChatGPT a dit :

Super ! Voici une interface graphique simple en Python avec GTK pour :

Scanner des machines sur le réseau (à partir d’une liste d’IP/hostnames)

Vérifier la disponibilité du partage Bureau

Permettre à l'utilisateur de cocher/décocher les machines à monter

Monter les dossiers sélectionnés dans ~/Réseau-Bureaux

✅ Prérequis 📦 Installer les dépendances (une seule fois) :

sudo apt install python3-gi python3-gi-cairo gir1.2-gtk-3.0 cifs-utils smbclient

📜 Code Python : interface de montage de dossiers Bureau

Sauvegarde dans un fichier appelé monter_bureaux_gui.py :

#!/usr/bin/env python3

import gi gi.require_version(“Gtk”, “3.0”) from gi.repository import Gtk import subprocess import os

#

Configuration

MONTAGE_PARENT = os.path.expanduser(“~/Réseau-Bureaux”) PARTAGE = “Bureau” LISTE_MACHINES = [

"192.168.1.10",
"192.168.1.11",
"192.168.1.12"

] # À adapter selon ton réseau

class BureauShareItem(Gtk.Box):

def __init__(self, ip):
super().__init__(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
self.ip = ip
self.checkbox = Gtk.CheckButton(label=f"{ip}")
self.pack_start(self.checkbox, True, True, 0)

# Tester si le partage est dispo
self.share_available = self.check_share()
if not self.share_available:
self.checkbox.set_sensitive(False)
self.checkbox.set_label(f"{ip} (non disponible)")

def check_share(self):
try:
output = subprocess.check_output(["smbclient", "-L", f"//{self.ip}", "-N"], stderr=subprocess.DEVNULL).decode()
return PARTAGE in output
except:
return False

class BureauShareApp(Gtk.Window):

def __init__(self):
super().__init__(title="Montage des Bureaux distants")
self.set_border_width(15)
self.set_default_size(400, 300)

vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
self.add(vbox)

self.items = []
for ip in LISTE_MACHINES:
item = BureauShareItem(ip)
self.items.append(item)
vbox.pack_start(item, False, False, 0)

self.button = Gtk.Button(label="Monter les bureaux sélectionnés")
self.button.connect("clicked", self.on_mount_clicked)
vbox.pack_start(self.button, False, False, 0)

def on_mount_clicked(self, button):
os.makedirs(MONTAGE_PARENT, exist_ok=True)

for item in self.items:
if item.checkbox.get_active() and item.share_available:
mount_point = os.path.join(MONTAGE_PARENT, item.ip)
os.makedirs(mount_point, exist_ok=True)
subprocess.run([
"sudo", "mount", "-t", "cifs", f"//{item.ip}/{PARTAGE}", mount_point,
"-o", f"guest,uid={os.getuid()},gid={os.getgid()},_netdev"
])
dialog = Gtk.MessageDialog(
transient_for=self,
flags=0,
message_type=Gtk.MessageType.INFO,
buttons=Gtk.ButtonsType.OK,
text="Montage terminé",
)
dialog.run()
dialog.destroy()

# Lancer l'application if name == “main”:

win = BureauShareApp()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()

▶️ Exécuter l’interface

chmod +x monter_bureaux_gui.py ./monter_bureaux_gui.py

🔐 ⚠️ Permissions sudo

Le script utilise sudo mount, donc tu seras invité à entrer ton mot de passe.

Tu peux ajouter une règle sudoers pour permettre à mount -t cifs sans mot de passe (je peux t’aider à le faire si besoin).

✅ Résultat

Tu coches les machines qui ont un partage Bureau

Leurs dossiers sont montés dans ~/Réseau-Bureaux/192.168.x.x/

Montage facile à la demande, sans ligne de commande

Souhaites-tu :

Ajouter une option pour démonter les partages ?

Rendre la liste d’IP configurable via un fichier texte ?

Avoir une intégration automatique au démarrage ?