大文件上传经F5负载均衡器连接重置，求PHP TCP保活方案

Great question—since you can’t tweak the F5’s timeout window, we need to make sure the load balancer sees ongoing activity from your Apache/PHP server during that long file transfer and FTP sync process. Here are three actionable solutions tailored to your environment:

1. Send Chunked HTTP Heartbeats (Most Direct Fix) #

The core idea here is to periodically send small, empty chunks of data to the F5 while your script runs. This keeps the TCP connection marked as "active" so the load balancer doesn’t drop it prematurely.

Step-by-Step Implementation: #

• First, disable PHP’s output buffering and remove execution time limits for the script:

  ignore_user_abort(true); // Prevent script termination if the client disconnects early
  set_time_limit(0); // Remove the default execution time cap
  ob_end_flush(); // Turn off PHP’s default output buffering
  ob_implicit_flush(true); // Auto-flush output after every echo to avoid buffering
  

• Insert a heartbeat loop during your file transfer/FTP sync process. For example, if you’re sending the file to FTP in chunks, add a check every 2 minutes (well under the F5’s 5-minute timeout) to send a heartbeat:

  // Assume $ftpConn is your active FTP connection
  $localFile = fopen('/path/to/uploaded/file', 'rb');
  $lastHeartbeat = time();
  
  while (!feof($localFile)) {
      $chunk = fread($localFile, 8192);
      ftp_fput($ftpConn, 'remote-filename.ext', $chunk, FTP_BINARY);
  
      // Send a heartbeat every 2 minutes
      if (time() - $lastHeartbeat > 120) {
          echo str_repeat(' ', 1024); // Send 1KB of empty space (F5 needs visible data to register activity)
          $lastHeartbeat = time();
      }
  }
  fclose($localFile);
  

• Apache Configuration Tweaks:
  • Disable gzip compression for this script (mod_deflate will buffer output otherwise). Add this to your .htaccess or Apache config:

    <Files "your-upload-handler.php">
        SetEnv no-gzip 1
        SetEnv dont-vary 1
    </Files>
    

  • Ensure KeepAlive is enabled in your httpd.conf (it’s usually on by default, but double-check):

    KeepAlive On
    KeepAliveTimeout 60
    

2. System-Level TCP KeepAlive Settings #

You can configure your server’s TCP stack to automatically send keepalive packets, which the F5 will recognize as active connection activity. This is a server-wide change, so test it carefully.

For Linux Servers: #

• Edit /etc/sysctl.conf and add these lines:

  net.ipv4.tcp_keepalive_time = 180  # Send first keepalive after 3 minutes (under F5’s timeout)
  net.ipv4.tcp_keepalive_intvl = 60   # Resend keepalive every 60 seconds
  net.ipv4.tcp_keepalive_probes = 3   # Drop connection after 3 failed probes
  

• Apply the changes with sysctl -p.

Note: This affects all TCP connections on the server, not just your upload script. It’s a solid fallback if the heartbeat method doesn’t work, but less targeted.

3. Offload Long-Running Work to a Background Process (Most Robust) #

Instead of tying the HTTP request to the entire FTP transfer, split the workflow to avoid the F5 timeout entirely:

1. Accept the file upload via HTTP (this finishes quickly, so the F5 doesn’t trigger a timeout)
2. Queue the FTP transfer task to a background worker
3. Immediately return a response to the client (e.g., "Upload received—we’ll notify you when the transfer is complete")
4. Once the background worker finishes the FTP transfer, send the notification email

Tools for PHP 5.6: #

• Gearman: A lightweight job queue system that integrates smoothly with PHP 5.6. Set up a Gearman worker process to listen for FTP tasks, and your upload script submits the job to the queue.
• Cron + Database/Temp Files: A simpler (less scalable) alternative: write a job record to a database or temp file after upload, then have a cron job run every minute to check for pending tasks and execute the FTP transfer.

This approach makes your system more resilient too—if the FTP transfer fails, you can retry without losing the original upload.

Final Recommendations #

• Start with the chunked heartbeat method—it’s the quickest to implement without modifying your server’s overall configuration or adding new services.
• If you anticipate more long-running tasks in the future, invest in setting up a background job queue (option 3) for better scalability and reliability.

内容的提问来源于stack exchange，提问作者Mageotron