将HTTP请求重定向至无公网IP的树莓派(RPi)方案咨询

Great question! Let's break down your options, starting with the SSH tunnel approach you're leaning toward—it's absolutely reliable when configured properly, and there are straightforward ways to handle keepalive and automatic reconnection for your mobile, dynamic-IP Raspberry Pi.

Why SSH Tunneling (Option 3) Works & How to Make It Rock Solid #

SSH reverse tunneling is perfect for your use case because your Pi initiates the connection to the public server (no need for a public IP on the Pi), and the tunnel maintains bidirectional communication—so responses from your Pi's Python script can flow back to the webhook service without extra hoops.

Here's how to set it up for maximum reliability:

1. Basic Reverse Tunnel Command #

On your Raspberry Pi, run this to forward the public server's port 8080 to your Pi's local port 5000 (where your Python webhook handler is running):

ssh -R 8080:localhost:5000 your-server-user@your-public-server-ip

2. Add Keepalive to Prevent Dropped Connections #

SSH tunnels can drop silently if there's no traffic. Add these flags to send periodic heartbeats:

ssh -o ServerAliveInterval=30 -o ServerAliveCountMax=3 -R 8080:localhost:5000 your-server-user@your-public-server-ip

• ServerAliveInterval=30: Sends a keepalive packet every 30 seconds
• ServerAliveCountMax=3: Drops the connection after 3 failed heartbeats (triggers reconnection if using auto-restart tools)

3. Auto-Reconnect with autossh #

autossh is a wrapper around SSH that automatically restarts the tunnel if it drops. Install it on your Pi first (sudo apt install autossh), then use this command:

autossh -M 20000 -o ServerAliveInterval=30 -o ServerAliveCountMax=3 -R 8080:localhost:5000 your-server-user@your-public-server-ip

• -M 20000: Uses port 20000 to monitor tunnel health (pick a port not used by other services)

4. Auto-Start on Boot with systemd #

To make the tunnel survive Pi reboots and network changes, create a systemd service:

1. Create the service file:

   sudo nano /etc/systemd/system/autossh-webhook.service
   

2. Paste this content (adjust user, ports, and server details):

   [Unit]
   Description=AutoSSH Tunnel for Webhook Forwarding
   After=network.target
   
   [Service]
   User=pi
   ExecStart=/usr/bin/autossh -M 20000 -o ServerAliveInterval=30 -o ServerAliveCountMax=3 -R 8080:localhost:5000 your-server-user@your-public-server-ip
   Restart=always
   RestartSec=5
   
   [Install]
   WantedBy=multi-user.target
   

3. Enable and start the service:

   sudo systemctl enable --now autossh-webhook.service
   

5. Forward Webhook Requests on the Public Server #

Use Nginx on your public server to route incoming webhook POST/GET requests to the tunneled port 8080. Example Nginx config:

server {
    listen 80;
    server_name your-webhook-domain.com;

    location /webhook {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_connect_timeout 5s;  # Match your webhook service's timeout
        proxy_send_timeout 5s;
        proxy_read_timeout 5s;
    }
}

Now any webhook sent to http://your-webhook-domain.com/webhook will be forwarded to your Pi's Python script, and the response will flow back through the tunnel to the webhook service.

Are There Better Alternatives? #

If you want a more feature-rich solution than SSH tunneling, consider open-source reverse proxy tools like frp (Fast Reverse Proxy):

• It's designed specifically for internal network exposure, with built-in keepalive, custom domain routing, and multiple protocol support.
• You deploy the frps server on your public machine, and the frpc client on your Pi.
• Configuration is more flexible than SSH tunnels (e.g., you can forward multiple services or use subdomains without extra Nginx rules).

For example, a basic frp setup:

• Public server frps.ini:

  [common]
  bind_port = 7000
  vhost_http_port = 8080
  

• Pi frpc.ini:

  [common]
  server_addr = your-public-server-ip
  server_port = 7000
  
  [webhook]
  type = http
  local_port = 5000
  subdomain = webhook
  

Start the server and client, and your webhook will be accessible at http://webhook.your-server-domain.com:8080.

Final Verdict #

• SSH Tunneling: Lightweight, no extra software needed on the public server (just SSH), and reliable when paired with autossh and systemd. Perfect for your use case if you want a minimal setup.
• frp: More powerful, better for complex scenarios (multiple services, custom routing), but requires deploying an extra service on your public server.

Both options will let you route webhook requests to your Pi and send responses back within the required timeout window.

内容的提问来源于stack exchange，提问作者Adam Ježek