How To Install RustDesk on CentOS Stream 10
In this tutorial, we will show you how to install RustDesk on CentOS Stream 10. The digital landscape demands secure, reliable remote desktop solutions that don’t compromise on privacy or performance. RustDesk emerges as a powerful open-source alternative to commercial remote desktop software, offering complete control over your data while maintaining enterprise-grade functionality. CentOS Stream 10 provides the perfect foundation for hosting your own RustDesk server, combining stability, security, and performance in a production-ready environment.
This comprehensive guide walks you through every aspect of installing RustDesk on CentOS Stream 10. Whether you’re a system administrator managing enterprise infrastructure or a tech enthusiast seeking privacy-focused remote access solutions, you’ll discover multiple installation methods, troubleshooting strategies, and optimization techniques. By the end of this tutorial, you’ll have a fully functional RustDesk deployment ready for production use.
Remote desktop technology has evolved significantly, and self-hosted solutions now offer capabilities that rival commercial alternatives. RustDesk stands out by providing cross-platform compatibility, advanced security features, and complete customization freedom without subscription fees or licensing restrictions.
What is RustDesk and Why Choose It?
Overview of RustDesk Features
RustDesk represents a new generation of remote desktop software built with Rust programming language for maximum performance and security. This open-source solution supports all major operating systems including Windows, macOS, Linux distributions, Android, and iOS. The software architecture includes built-in file transfer capabilities, TCP tunneling functionality, and end-to-end encryption protocols that ensure secure communications across networks.
The platform’s lightweight design minimizes resource consumption while delivering high-quality remote desktop experiences. RustDesk supports multiple concurrent connections, making it suitable for both individual users and enterprise environments requiring scalable remote access solutions.
Advantages Over Commercial Solutions
Unlike proprietary remote desktop software, RustDesk eliminates ongoing licensing costs and subscription fees that can burden organizational budgets. You maintain complete control over your data, ensuring sensitive information never passes through third-party servers unless explicitly configured. The open-source nature allows for code auditing, custom modifications, and community-driven security improvements.
RustDesk’s self-hosted architecture means no external dependencies for core functionality. This independence provides reliability advantages, especially in environments with strict data governance requirements or limited internet connectivity. Organizations can customize the software to meet specific security policies and integration requirements.
RustDesk Architecture Components
The RustDesk ecosystem consists of three primary components working together to deliver seamless remote desktop functionality. The hbbs (RustDesk ID/Rendezvous server) manages device registration, authentication, and connection coordination. The hbbr (RustDesk Relay server) handles data relay when direct peer-to-peer connections aren’t possible due to network configurations. Client applications installed on end devices provide the user interface and handle local desktop capture and remote control functionality.
Prerequisites and System Requirements
Hardware Requirements
CentOS Stream 10 installations for RustDesk require minimal hardware resources for basic functionality. A single CPU core with 1 GB RAM and 10 GB available disk space suffices for small deployments serving fewer than 10 concurrent connections. However, production environments benefit significantly from enhanced specifications.
Recommended configurations include dual-core processors with at least 4 GB RAM for deployments supporting 20-50 concurrent connections. Enterprise environments should consider quad-core systems with 8 GB RAM or more, depending on expected usage patterns. Storage requirements scale with connection logging and temporary file handling, so allocate additional disk space accordingly.
Network bandwidth considerations vary dramatically based on screen resolution and content complexity. Basic desktop sharing consumes approximately 30 KB/s, while high-resolution video content can require up to 3 MB/s per connection. Plan network capacity accordingly for expected concurrent usage.
Software Prerequisites
Begin with a fresh CentOS Stream 10 installation including essential development tools and system utilities. Ensure your system includes the dnf package manager, systemd service management, and basic networking utilities. Root access or sudo privileges are mandatory for installation and configuration procedures.
SSH access configuration enables remote management and troubleshooting. Configure SSH key-based authentication for enhanced security, especially when managing production deployments. Verify that essential development tools including gcc, make, and related build utilities are available through the development group packages.
Network Prerequisites
Static IP address assignment is highly recommended for RustDesk server deployments, though not strictly required for testing environments. Dynamic IP addresses can cause connection issues as clients cache server addresses for reconnection attempts. Configure your network interface with a static IP or ensure DHCP reservations maintain consistent addressing.
Domain name setup provides professional appearance and simplifies client configuration. Register a dedicated subdomain for your RustDesk deployment and configure DNS A records pointing to your server’s public IP address. SSL certificate acquisition becomes straightforward with proper domain configuration.
Internet connectivity requirements depend on your deployment scope. Local network deployments function without internet access, but external client connections require appropriate port forwarding and firewall configurations.
Pre-Installation System Preparation
Updating the System
Start by updating your CentOS Stream 10 installation to ensure all security patches and system updates are current. Execute the following commands to refresh package repositories and install available updates:
sudo dnf update -y
sudo dnf groupinstall "Development Tools" -y
sudo dnf install wget curl unzip tar -yVerify system compatibility by checking the kernel version and architecture. RustDesk binaries require specific architecture matching, so confirm whether your system runs x86_64 or arm64 architecture using the uname -m command.
Install essential dependencies that RustDesk requires for proper operation. These include networking libraries, process management tools, and security frameworks that support the application’s functionality.
Firewall Configuration
CentOS Stream 10 uses firewalld as the default firewall management system. Configure necessary port openings for RustDesk communication while maintaining security best practices. RustDesk requires specific ports for different components of its architecture.
sudo firewall-cmd --permanent --add-port=21115/tcp
sudo firewall-cmd --permanent --add-port=21116/tcp
sudo firewall-cmd --permanent --add-port=21116/udp
sudo firewall-cmd --permanent --add-port=21117/tcp
sudo firewall-cmd --permanent --add-port=21118/tcp
sudo firewall-cmd --permanent --add-port=21119/tcp
sudo firewall-cmd --reloadThese ports handle different aspects of RustDesk communication including device registration, connection coordination, and data relay functionality. Customize port assignments if your network environment requires specific configurations or if default ports conflict with existing services.
SSH access security remains critical throughout the installation process. Ensure SSH is properly configured with key-based authentication and consider changing the default SSH port if your server will be internet-accessible.
User and Permission Setup
Create dedicated service users for RustDesk operations to follow security best practices and minimize privilege escalation risks. Service users should have minimal permissions necessary for application operation while maintaining system security boundaries.
sudo useradd -r -s /bin/false rustdesk
sudo mkdir -p /opt/rustdesk
sudo chown rustdesk:rustdesk /opt/rustdeskConfigure sudo permissions carefully if the installation process requires elevated privileges for specific operations. Document permission changes for future reference and security auditing purposes.
Installation Methods Overview
Script-Based Installation
Automated installation scripts streamline the deployment process by handling dependency installation, configuration file generation, and service setup automatically. The Techahold script has gained popularity in the RustDesk community for its comprehensive approach to installation and configuration management.
Script-based installations offer consistency across multiple deployments and reduce human error possibilities during complex configuration procedures. These tools typically handle service management setup, firewall configuration, and initial security hardening automatically.
Manual Installation
Manual installation provides complete control over every aspect of the deployment process. This approach suits environments with specific security requirements, custom configurations, or integration needs that automated scripts cannot accommodate. Manual installations also offer deeper understanding of RustDesk’s operational requirements.
Custom configuration advantages include the ability to modify default settings, integrate with existing authentication systems, and optimize performance parameters for specific use cases. Manual installations require more time investment but provide greater flexibility and learning opportunities.
Docker Deployment
Containerized installations using Docker offer advantages for environments already using container orchestration platforms. Docker deployments simplify updates, provide better resource isolation, and enable easier scaling across multiple hosts when necessary.
Docker Compose configurations handle multi-container deployments including separate containers for hbbs and hbbr services, load balancers, and monitoring tools. Container deployments also simplify backup and disaster recovery procedures.
Method 1: Automated Script Installation
Downloading and Running the Installation Script
The automated installation approach begins with downloading the installation script from trusted sources. Verify script authenticity before execution to prevent security compromises. The following commands download and prepare the installation script:
wget https://raw.githubusercontent.com/techahold/rustdeskinstall/master/install.sh
chmod +x install.shBefore execution, review the script contents to understand what changes will be made to your system. Automated scripts should never be executed without understanding their functionality and potential security implications.
Execute the installation script with appropriate parameters for your environment:
sudo ./install.shMonitor installation progress and note any error messages or warnings that appear during execution. The script handles dependency installation, binary downloads, and initial configuration automatically.
Configuration Generation
The automated script generates configuration files for both hbbs and hbbr services with reasonable default settings. These configurations include automatically generated encryption keys, service binding addresses, and basic security parameters.
Password-protected web interface setup occurs automatically, providing immediate access to basic server management functionality. The script generates random passwords and displays them during installation completion. Record these credentials securely for future administrative access.
Server key generation creates the cryptographic foundation for secure client-server communication. The installation script generates unique keys for your deployment and configures services to use these keys automatically. Backup these keys securely as they’re required for service restoration if needed.
Service Management Setup
The automated installation configures PM2 process management for RustDesk services, providing automatic restart capabilities, logging, and monitoring functionality. PM2 offers advantages over traditional systemd services for Node.js-based applications including better resource monitoring and easier service management.
Service startup configuration ensures RustDesk services begin automatically after system reboots. The installation script creates appropriate startup scripts and enables them through the system’s service management framework.
Automatic restart configuration protects against service failures by monitoring process health and restarting services when necessary. This functionality is crucial for production deployments where service availability must be maintained continuously.
Method 2: Manual Installation Process
Downloading RustDesk Server Binaries
Manual installation begins with downloading official RustDesk server binaries from the project’s GitHub releases page. Always download from official sources to ensure authenticity and avoid potentially compromised versions.
cd /opt/rustdesk
wget https://github.com/rustdesk/rustdesk-server/releases/latest/download/rustdesk-server-linux-amd64.zip
unzip rustdesk-server-linux-amd64.zip
chmod +x hbbs hbbrVerify binary integrity using checksums provided on the releases page. This verification step ensures downloaded files haven’t been corrupted during transfer and match the official release checksums.
Extract binaries to appropriate directories following Linux file system hierarchy standards. The /opt/rustdesk directory provides a logical location for application binaries while maintaining system organization principles.
Server Configuration
Manual configuration provides complete control over RustDesk server behavior and security settings. Create configuration files for both hbbs and hbbr services with parameters tailored to your environment’s specific requirements.
Generate encryption keys manually using the provided utilities:
./hbbs --gen-keypairThis command creates id_ed25519 and id_ed25519.pub files containing the server’s cryptographic identity. Secure these files appropriately as they’re fundamental to your deployment’s security architecture.
Create custom configuration files specifying binding addresses, port assignments, and security parameters:
echo "port = 21115" > hbbs.toml
echo "relay_servers = ['your-server-ip:21117']" >> hbbs.tomlConfigure hbbr relay server with appropriate settings for your network environment. Relay servers handle connections when direct peer-to-peer communication isn’t possible due to NAT or firewall restrictions.
Service Configuration and Management
Create systemd service files for proper service management and automatic startup configuration. Service files define how the system should manage RustDesk processes including restart policies, dependency requirements, and resource limitations.
sudo tee /etc/systemd/system/rustdesk-hbbs.service > /dev/null <Enable and start services using systemd commands:
sudo systemctl daemon-reload
sudo systemctl enable rustdesk-hbbs rustdesk-hbbr
sudo systemctl start rustdesk-hbbs rustdesk-hbbrService monitoring capabilities include checking service status, viewing logs, and managing service lifecycle through standard systemd commands. This integration provides consistent management interfaces with other system services.
Client Installation and Configuration
Installing RustDesk Clients
RustDesk client installation varies by operating system but follows standard application installation procedures for each platform. Windows clients use traditional installer executables (.exe files) downloadable from the official website or GitHub releases.
macOS installations utilize disk image files (.dmg) containing the application bundle. Download the appropriate version for your macOS architecture (Intel or Apple Silicon) and follow standard macOS installation procedures including security verification steps.
Linux client installations support multiple package formats including AppImage, Debian packages (.deb), and RPM packages (.rpm). Choose the format that best suits your Linux distribution’s package management system:
# For RPM-based systems like CentOS
sudo dnf install rustdesk-1.x.x-x86_64.rpmMobile applications are available through official app stores including Google Play Store for Android devices and Apple App Store for iOS devices. Mobile clients provide essential remote access functionality optimized for touch interfaces.
Client Configuration for Self-Hosted Server
Configure clients to connect to your self-hosted RustDesk server instead of the default public servers. This configuration ensures all remote desktop traffic flows through your controlled infrastructure rather than external services.
Navigate to client network settings and input your server’s IP address or domain name. Configure both the ID server and relay server addresses to point to your deployment:
- ID Server: your-server-ip:21116
- Relay Server: your-server-ip:21117
For environments using custom ports or domain names, adjust these settings accordingly. Consistent configuration across all clients ensures reliable connectivity and optimal performance.
Import the server’s public key into client applications to establish trusted connections. The public key file generated during server installation (id_ed25519.pub) contains the cryptographic identity that clients use to verify server authenticity.
Connection Testing and Validation
Initial connection testing verifies that clients can successfully communicate with your RustDesk server and establish remote desktop sessions. Begin testing with clients on the same local network to eliminate internet connectivity variables.
Perform comprehensive functionality testing including remote desktop viewing, mouse and keyboard control, file transfer operations, and audio redirection if supported. Document any issues encountered during testing for troubleshooting reference.
Test various screen resolutions and color depths to understand performance characteristics under different conditions. Higher resolutions and color depths increase bandwidth requirements but provide better visual quality.
Performance optimization settings within client applications can significantly impact user experience. Adjust compression levels, frame rates, and quality settings based on available network bandwidth and performance requirements.
Network Configuration and Security Setup
Firewall Rules and Port Management
Comprehensive firewall configuration balances security requirements with functional connectivity needs. RustDesk requires specific ports for different communication protocols, and blocking unnecessary ports reduces attack surface while maintaining functionality.
Configure firewalld with precise rules for RustDesk communication:
sudo firewall-cmd --permanent --new-service=rustdesk
sudo firewall-cmd --permanent --service=rustdesk --add-port=21115/tcp
sudo firewall-cmd --permanent --service=rustdesk --add-port=21116/tcp
sudo firewall-cmd --permanent --service=rustdesk --add-port=21116/udp
sudo firewall-cmd --permanent --service=rustdesk --add-port=21117/tcp
sudo firewall-cmd --permanent --add-service=rustdesk
sudo firewall-cmd --reloadPort forwarding configuration becomes necessary when clients connect from external networks. Configure your router or network gateway to forward appropriate ports to your RustDesk server’s internal IP address.
Cloud deployment environments require security group configurations that allow inbound traffic on RustDesk ports while maintaining restrictive policies for other services. Document firewall rules for future reference and security auditing.
SSL/TLS Certificate Setup
SSL certificate installation enhances security and enables encrypted web management interfaces. Let’s Encrypt provides free certificates suitable for most deployments, including automated renewal capabilities.
Install Certbot for automated certificate management:
sudo dnf install certbot -y
sudo certbot certonly --standalone -d your-domain.comConfigure RustDesk services to use SSL certificates by modifying configuration files to reference certificate locations. Some RustDesk components support direct SSL integration while others require reverse proxy configurations.
Automatic renewal setup ensures certificates remain valid without manual intervention. Configure cron jobs or systemd timers to execute renewal commands periodically:
echo "0 12 * * * /usr/bin/certbot renew --quiet" | sudo crontab -Advanced Security Configurations
Password policies enforcement strengthens authentication security by requiring complex passwords and regular password changes. Implement organizational password policies that balance security requirements with usability considerations.
User access controls should follow principle of least privilege, granting users only the permissions necessary for their specific roles and responsibilities. Document access control policies and review them regularly for compliance and effectiveness.
Connection logging and monitoring provide visibility into system usage patterns and potential security threats. Configure comprehensive logging for authentication attempts, connection establishments, and administrative actions.
Troubleshooting Common Installation Issues
Server-Side Issues
Service startup failures often result from permission problems, missing dependencies, or configuration errors. Examine service logs using systemd commands to identify specific error messages:
sudo journalctl -u rustdesk-hbbs -f
sudo journalctl -u rustdesk-hbbr -fPort binding problems occur when other services use the same ports or when firewall configurations block necessary traffic. Use netstat or ss commands to identify port conflicts and resolve them accordingly.
Permission and ownership issues prevent services from accessing necessary files or directories. Verify that service users have appropriate permissions for application directories, configuration files, and temporary storage locations.
Log file analysis provides detailed insights into service behavior and error conditions. Regular log review helps identify patterns that might indicate configuration problems or security concerns requiring attention.
Client Connection Problems
Network connectivity issues manifest as connection timeouts, failed handshakes, or inconsistent performance. Verify network paths between clients and servers using ping, traceroute, and telnet commands to isolate connectivity problems.
Firewall blocking connections appears as immediate connection failures or timeouts during specific protocol phases. Review firewall logs and temporarily disable firewalls for testing purposes to identify blocking rules.
Configuration errors in client applications prevent successful server communication. Double-check server addresses, port numbers, and authentication credentials for accuracy and consistency across all client installations.
Performance optimization requires balancing quality settings with available bandwidth and system resources. Monitor network utilization and system performance during connections to identify bottlenecks requiring optimization.
Performance and Optimization Issues
Bandwidth optimization becomes critical in environments with limited network capacity or high concurrent usage. Implement quality of service (QoS) policies to prioritize RustDesk traffic and ensure consistent performance.
Hardware resource monitoring identifies CPU, memory, and storage constraints that impact service performance. Use system monitoring tools to track resource utilization and plan capacity upgrades when necessary.
Connection quality troubleshooting involves analyzing network latency, packet loss, and jitter characteristics that affect user experience. Network monitoring tools provide insights into connection quality metrics and trends.
Best Practices and Production Considerations
Security Best Practices
Regular security updates maintain protection against newly discovered vulnerabilities and ensure optimal security posture. Establish update schedules that balance security requirements with system stability needs.
Access control implementation should include multi-factor authentication where possible, regular access reviews, and prompt removal of unnecessary user accounts. Document access control procedures and ensure compliance with organizational security policies.
Network segmentation recommendations include isolating RustDesk infrastructure from critical production systems while maintaining necessary connectivity for legitimate remote access requirements. Implement network monitoring to detect suspicious activities.
Monitoring and alerting setup provides early warning of security incidents, performance degradation, or service failures. Configure alerts for authentication failures, unusual connection patterns, and system resource exhaustion conditions.
Backup and Disaster Recovery
Configuration backup strategies should include all critical files including encryption keys, configuration files, user databases, and service definitions. Test backup restoration procedures regularly to ensure reliability during actual disaster scenarios.
Server migration procedures enable moving RustDesk deployments between hosts while maintaining service continuity. Document migration steps including data transfer, configuration updates, and client reconfiguration requirements.
Data protection considerations include encrypting backup files, securing backup storage locations, and implementing retention policies that balance storage costs with recovery requirements. Regular backup testing verifies restoration capabilities.
Performance Monitoring and Optimization
Resource usage monitoring tracks CPU utilization, memory consumption, network bandwidth, and storage utilization patterns. Establish baseline performance metrics and configure alerts for deviations that might indicate problems.
Connection quality metrics include latency measurements, bandwidth utilization, frame rates, and user satisfaction indicators. Regular performance analysis identifies optimization opportunities and capacity planning requirements.
Scaling considerations for larger deployments include load balancing strategies, horizontal scaling options, and performance optimization techniques that maintain service quality as usage grows.
Advanced Configuration Options
Custom Configuration Parameters
Advanced server settings enable fine-tuning RustDesk behavior for specific environments and requirements. Configuration parameters include connection timeouts, security settings, logging levels, and performance optimization options.
Custom port configurations accommodate environments with specific network requirements or security policies mandating non-standard port assignments. Document port changes and ensure firewall rules reflect custom configurations.
Load balancing setup distributes connection load across multiple RustDesk server instances, improving performance and providing redundancy for high-availability requirements. Implement health checking and automatic failover capabilities.
Multi-server deployments scale capacity and provide geographic distribution for improved performance across diverse user populations. Coordinate configuration management across multiple servers to ensure consistency.
Integration with Existing Infrastructure
LDAP and Active Directory integration centralizes user authentication and simplifies account management for organizations with existing directory services. Configure RustDesk to authenticate against organizational user databases.
VPN integration considerations include optimizing RustDesk performance over VPN connections and coordinating security policies between VPN and remote desktop access systems. Avoid double-encryption scenarios that waste resources.
Monitoring system integration enables incorporating RustDesk metrics into existing infrastructure monitoring platforms. Configure SNMP monitoring, log forwarding, and alerting integration as appropriate for your environment.
Congratulations! You have successfully installed RustDesk. Thanks for using this tutorial for installing the RustDesk open-source remote desktop access on your CentOS Stream 10 system. For additional or useful information, we recommend you check the official RustDesk website.
