Remote Access via SSH

If you’re running Unmute on a remote machine (like a GPU server) and want to access it from your local computer, you’ll need to set up SSH port forwarding. This creates secure tunnels that forward traffic from your local machine to the remote server.

Why Port Forwarding?

Browsers require either HTTPS or localhost to access the microphone. Even if your remote server is accessible at http://remote-server:3000, your browser won’t allow microphone access over plain HTTP.

Port forwarding makes the remote server appear as localhost to your browser, which allows microphone access without HTTPS.

Port Forwarding Setup

The approach differs slightly between Docker Compose and Dockerless deployments.

For Docker Compose

Docker Compose runs everything through Traefik on port 80.

Start SSH Tunnel

Forward port 80 from the remote server to a local port (e.g., 3333):

ssh -N -L 3333:localhost:80 unmute-box

Command breakdown:

-N: Don’t execute a remote command (just forward ports)
-L 3333:localhost:80: Forward local port 3333 to remote port 80
unmute-box: Your remote server hostname or IP

If successful, this command produces no output and keeps running. Don’t close the terminal.

Access in Browser

Open your local browser to:

http://localhost:3333

The browser treats this as localhost and allows microphone access.

Docker Compose Architecture with Port Forwarding

For Dockerless

Dockerless deployment uses separate ports for frontend (3000) and backend (8000).

Start SSH Tunnel with Multiple Ports

Forward both ports in a single SSH command:

ssh -N -L 8000:localhost:8000 -L 3000:localhost:3000 unmute-box

This forwards:

Local port 3000 → Remote frontend (port 3000)
Local port 8000 → Remote backend (port 8000)

Access in Browser

Open your local browser to:

http://localhost:3000

The frontend will automatically connect to the backend at localhost:8000.

Dockerless Architecture with Port Forwarding

Advanced Configurations

Using a Different Local Port

If port 3333 (or 3000/8000) is already in use locally, choose different ports:

# Docker Compose - use port 4000 locally
ssh -N -L 4000:localhost:80 unmute-box
# Then access at http://localhost:4000

# Dockerless - use ports 4000 and 4001
ssh -N -L 4000:localhost:3000 -L 4001:localhost:8000 unmute-box
# Then access at http://localhost:4000

For Dockerless, you’ll need to update the frontend configuration to point to the correct backend port if you change it.

SSH Config for Easier Access

Create an SSH config file at ~/.ssh/config:

~/.ssh/config

Host unmute-box
    HostName 192.168.1.100  # Your server IP
    User yourusername
    Port 22
    
    # Docker Compose port forwarding
    LocalForward 3333 localhost:80
    
    # Uncomment for Dockerless instead:
    # LocalForward 3000 localhost:3000
    # LocalForward 8000 localhost:8000

Then simply run:

ssh unmute-box

Ports are automatically forwarded when you connect.

Background Port Forwarding

Run SSH tunnel in the background:

ssh -f -N -L 3333:localhost:80 unmute-box

The -f flag moves SSH to the background after authentication. To stop the background tunnel:

# Find the SSH process
ps aux | grep "ssh.*unmute-box"

# Kill it by PID
kill <PID>

Using SSH Keys

Avoid entering passwords by setting up SSH keys:

Generate SSH Key (if needed)

ssh-keygen -t ed25519 -C "your_email@example.com"

Copy Key to Remote Server

ssh-copy-id unmute-box

Connect Without Password

ssh -N -L 3333:localhost:80 unmute-box

No password prompt!

Autossh for Persistent Tunnels

For tunnels that automatically reconnect, use autossh:

# Install autossh
sudo apt install autossh  # Ubuntu/Debian
brew install autossh       # macOS

# Create persistent tunnel
autossh -M 0 -N -L 3333:localhost:80 unmute-box

Autossh monitors the connection and restarts it if it drops.

Firewall Considerations

Remote Server Firewall

SSH port forwarding works through the SSH connection, so you only need:

Port 22 (or your SSH port) open on the remote server

The forwarded ports (80, 3000, 8000) don’t need to be publicly accessible.

Local Firewall

No special configuration needed - you’re accessing localhost.

Troubleshooting

Connection Refused

Issue: ssh: connect to host unmute-box port 22: Connection refused Solutions:

Verify the hostname/IP is correct
Check if SSH is running on the remote server: sudo systemctl status ssh
Ensure firewall allows SSH: sudo ufw allow 22

Port Already in Use

Issue: bind [127.0.0.1]:3333: Address already in use Solutions:

Use a different local port: -L 3334:localhost:80
Find what’s using the port: lsof -i :3333
Kill the process using the port

Tunnel Works but Browser Shows Error

Issue: Tunnel is active but localhost:3333 doesn’t load Solutions:

Verify Unmute is running on the remote server
Check you’re using the correct port (80 for Docker Compose, 3000 for Dockerless)
Test the tunnel: curl http://localhost:3333

Microphone Permission Denied

Issue: Browser denies microphone access even with port forwarding Solutions:

Ensure you’re accessing localhost, not the server’s IP
Check browser permissions: Settings → Privacy → Microphone
Try a different browser (Chrome/Firefox/Edge)

SSH Tunnel Drops Frequently

Solutions:

Use autossh for automatic reconnection

Configure ServerAliveInterval in SSH config:

Host unmute-box
    ServerAliveInterval 60
    ServerAliveCountMax 3

Alternative: Direct HTTPS Access

If you prefer not to use SSH tunneling, set up HTTPS on your remote server:

For production, use Docker Swarm which includes Let’s Encrypt
For custom setups, see HTTPS configuration

Performance Considerations

Latency

SSH tunneling adds minimal latency (typically less than 10ms on good networks). The main latency comes from:

Network distance between you and the server
Server GPU processing time
Internet connection quality

Bandwidth

Unmute streams audio bidirectionally:

Upstream: User audio (~16-32 kbps)
Downstream: TTS audio (~32-64 kbps)

Total bandwidth: ~50-100 kbps, well within typical SSH capacity.

Compression

Enable SSH compression for better performance over slow connections:

ssh -C -N -L 3333:localhost:80 unmute-box

The -C flag enables compression.

Security Considerations

SSH tunneling is secure, but remember:

Don’t expose SSH to the public internet without proper hardening
Use SSH keys instead of passwords
Consider restricting SSH access by IP
Keep SSH software updated

Restricting Port Forwarding

If you’re sharing SSH access, you can disable port forwarding in /etc/ssh/sshd_config:

# Allow for specific users only
Match User trusted_user
    AllowTcpForwarding yes

Match User untrusted_user
    AllowTcpForwarding no

Next Steps

Set up HTTPS for production deployments without SSH tunneling
Learn about Docker Compose deployment options
Explore Docker Swarm for automatic HTTPS and scaling

Get Started

Deployment

Configuration

Remote Access via SSH

Why Port Forwarding?

Port Forwarding Setup

For Docker Compose

Docker Compose Architecture with Port Forwarding

For Dockerless

Dockerless Architecture with Port Forwarding

Advanced Configurations

Using a Different Local Port

SSH Config for Easier Access

Background Port Forwarding

Using SSH Keys

Autossh for Persistent Tunnels

Firewall Considerations

Remote Server Firewall

Local Firewall

Troubleshooting

Connection Refused

Port Already in Use

Tunnel Works but Browser Shows Error

Microphone Permission Denied

SSH Tunnel Drops Frequently

Alternative: Direct HTTPS Access

Performance Considerations

Latency

Bandwidth

Compression

Security Considerations

Restricting Port Forwarding

Next Steps

​Why Port Forwarding?

​Port Forwarding Setup

​For Docker Compose

​Docker Compose Architecture with Port Forwarding

​For Dockerless

​Dockerless Architecture with Port Forwarding

​Advanced Configurations

​Using a Different Local Port

​SSH Config for Easier Access

​Background Port Forwarding

​Using SSH Keys

​Autossh for Persistent Tunnels

​Firewall Considerations

​Remote Server Firewall

​Local Firewall

​Troubleshooting

​Connection Refused

​Port Already in Use

​Tunnel Works but Browser Shows Error

​Microphone Permission Denied

​SSH Tunnel Drops Frequently

​Alternative: Direct HTTPS Access

​Performance Considerations

​Latency

​Bandwidth

​Compression

​Security Considerations

​Restricting Port Forwarding

​Next Steps

Why Port Forwarding?

Port Forwarding Setup

For Docker Compose

Docker Compose Architecture with Port Forwarding

For Dockerless

Dockerless Architecture with Port Forwarding

Advanced Configurations

Using a Different Local Port

SSH Config for Easier Access

Background Port Forwarding

Using SSH Keys

Autossh for Persistent Tunnels

Firewall Considerations

Remote Server Firewall

Local Firewall

Troubleshooting

Connection Refused

Port Already in Use

Tunnel Works but Browser Shows Error

Microphone Permission Denied

SSH Tunnel Drops Frequently

Alternative: Direct HTTPS Access

Performance Considerations

Latency

Bandwidth

Compression

Security Considerations

Restricting Port Forwarding

Next Steps