Mount Remote Systems with SSHFS and ssh-copy-id

How to prepare your target system for integration with the Sectorise platform.

Step-by-Step Guide

The Sectorise platform supports various target systems, including Linux-based embedded systems, Raspberry Pi 5, and Debian/Ubuntu systems. With SSHFSand ssh-copy-id,you can efficiently set up, configure, and seamlessly integrate these systems with the Sectorise platform. This tutorial walks you through the process of preparing your target system, securing SSH connections, and using SSHFS for remote file access.

1. Prepare the system

Update the system: Ensure your system is up-to-date:
```
sudo apt update && sudo apt upgrade -y
```
Install an SSH server: Depending on your target system, use one of the following:
- For Debian/Ubuntu or Raspberry Pi:
```
sudo apt install openssh-server
```
- For Linux-based embedded systems (e.g., Dropbear):
```
sudo apt install dropbear
```
Enable and start the SSH service: Enable and start the SSH service:
```
sudo systemctl enable ssh
```
```
sudo systemctl start ssh
```
Adjust the firewall: If a firewall is active, allow SSH access:
```
sudo ufw allow ssh
```

2. Configure SSH access

Generate an SSH key: Create an SSH key on your local machine:
```
ssh-keygen -t rsa -b 4096 -C "sectorise-key"
```
Press Enterto save the key in the default location (`~/.ssh/id_rsa`). Optionally, set a passphrase for additional security.
Copy the SSH key to the target system: Use `ssh-copy-id` to securely transfer the key:
```
ssh-copy-id user@target-system
```
Example:
```
ssh-copy-id user@192.168.1.100
```
After successful transfer, you can log in without entering a password.

In this section, we will demonstrate how to use SSHFS to mount remote file systems so they can be accessed like local directories. This method is ideal for editing configuration files, analyzing logs, or accessing data processed by the Sectorise platform.

3. Mount remote file systems with SSHFS

Create a mount directory: On your local machine, create a directory to mount the remote file system:
```
mkdir ~/sectorise-mount
```
Mount the remote file system: Use SSHFS to mount the remote file system:
```
sshfs user@target-system:/path/to/directory ~/sectorise-mount
```
Example: For an embedded system:
```
sshfs root@192.168.1.100:/var/log ~/sectorise-mount
```
Parameters:
- user: The username on the target system.
- target-system: The IP address or hostname of the target system.
- /path/to/directory: The directory on the target system to be mounted.
- ~/sectorise-mount: The local directory where the remote file system will be mounted.
Optional: Optimize performance: Add parameters to improve connection reliability and speed:
```
sshfs -o reconnect -o compression=yes user@target-system:/path/to/directory ~/sectorise-mount
```
– `-o reconnect`: Automatically reconnect if the connection is interrupted.
– `-o compression=yes`: Enable compression to speed up data transfer.

4. Verify and use the remote file system

Check contents: Ensure the remote file system is successfully mounted:
```
ls ~/sectorise-mount
```
Edit files: Work with files in the mounted directory as if they were local:
```
nano ~/sectorise-mount/filename
```

5. Unmount the remote file system

Unmount: When finished, unmount the file system:
```
fusermount -u ~/sectorise-mount
```
Check: Verify that the directory is unmounted:
```
ls ~/sectorise-mount
```
The directory should be empty because the remote file system is no longer mounted.

In this section, we explain how to automatically mount the remote file system using **`fstab`**. This ensures that the file system is automatically accessible after each system restart, making integration with the Sectorise platform seamless.

6. Automatic mounting with `fstab`

Verify SSHFS connection: Test the SSHFS command to ensure the mount works properly:
```
sshfs user@192.168.1.100:/home/user ~/sectorise-mount
```
Edit the `fstab` file: Open the `/etc/fstab` file with a text editor:
```
sudo nano /etc/fstab
```
Add a mount entry: Add the following line to the `fstab` file:
```
sshfs#user@192.168.1.100:/home/user /home/username/sectorise-mount fuse defaults,_netdev,IdentityFile=/home/username/.ssh/id_rsa 0 0
```
Explanation of parameters:
- sshfs#user@192.168.1.100:/home/user: The user, target system, and remote directory to mount.
- /home/username/sectorise-mount: The local directory where the remote file system will be mounted.
- fuse: Specifies the file system type for SSHFS.
- defaults,_netdev: Default options and the `_netdev` flag, indicating that the mount depends on a network connection.
- IdentityFile=: Path to the SSH key used for authentication.
Save and exit: Save the file with **CTRL+O** and exit with **CTRL+X**.

7. Test the mount

Reload the `fstab` configuration: Apply the changes without restarting the system:
```
sudo mount -a
```
Check the mount: Verify that the remote file system is mounted:
```
ls ~/sectorise-mount
```

8. Troubleshooting

Permission issues: Ensure the SSH key is correct and the target system allows connections.
Use `_netdev`: Always include the `_netdev` option in the `fstab` entry to avoid issues when the network is unavailable during boot.
Manual testing: If automatic mounting fails, manually test the SSHFS command:
```
sshfs user@192.168.1.100:/home/user ~/sectorise-mount
```

In this tutorial, we guided you through setting up a remote system for integration with the Sectorise platform. From installing an SSH server to securely configuring access and using SSHFS for seamless file system integration, you now have the tools to effectively manage and interact with your systems. Below, we summarize the key steps and share best practices.

Key Steps Recap

Set up an SSH server: Install and configure an SSH server to enable secure access to your target system.
Use SSH keys: Employ `ssh-copy-id` to set up passwordless authentication, enhancing both security and convenience.
Mount with SSHFS: Access remote directories as if they were local, enabling easy management of configurations and logs.
Automate with `fstab`: Configure automatic mounting for consistent access after system reboots.

Best Practices

Secure access: Always use SSH keys instead of passwords for authentication. Keep your keys safe and consider using a passphrase for added security.
Ensure network stability: Verify that the target system has a reliable network connection, especially when using `fstab` for automatic mounting.
Monitor logs regularly: Use mounted remote directories to analyze system logs via the Sectorise platform and identify potential issues early.
Automate error handling: Regularly test mounting processes and set up alerts for mount failures to address issues proactively.
Stay updated: Keep both local and target systems updated to ensure compatibility and security.

Advantages of the Sectorise Platform

By following the steps in this tutorial, you can fully leverage the Sectorise platform to:

Efficiently collect and analyze data and logs from remote systems.
Implement configuration changes remotely with ease.
Maintain secure and reliable connections to your target systems.
Build a robust and scalable infrastructure for embedded systems.

Next Steps

You are now ready to apply these techniques to manage your target systems effectively and integrate them seamlessly with the Sectorise platform. For further assistance, the Sectorise GmbH team is here to support you.

References

Below are the sources and documentation used to develop this guide. These resources provide additional information and are excellent for deeper learning.

Official Documentation

Linux Man Pages – Official reference for Linux commands and system management.
SSH Academy – Comprehensive guide to SSH and its usage.
SSHFS GitHub Repository – Official GitHub page for SSHFS with source code and documentation.
Ubuntu Help – Instructions for installation and configuration on Ubuntu systems.
Raspberry Pi Documentation – Guides and resources for Raspberry Pi setup and configuration.

Additional Resources

DigitalOcean Community Tutorials – Practical guides and tips for Linux system administration.
ServerFault – Community-driven platform for system administration and networking solutions.
FUSE Project Page – Further insights into the Filesystem in Userspace (FUSE) technology that powers SSHFS.

Acknowledgments

We extend our gratitude to the open-source community for developing and maintaining the tools featured in this guide, particularly the SSHFS and OpenSSH projects.

Mount Remote Systems with SSHFS