Nginx解决访问大文件的超时问题配置优化指南

location /download/ {
    alias /var/www/downloads;
    proxy_pass http://localhost:8080;
    proxy_buffering off;           # 👈 关键！禁用缓冲，启用流式传输
    proxy_cache off;               # 👈 禁用缓存
    proxy_read_timeout 300s;       # 👈 延长后端读取超时
    proxy_send_timeout 300s;       # 👈 延长后端发送超时
    send_timeout 600s;             # 👈 延长向客户端发送响应的超时
    client_max_body_size 10G;      # 👈 允许上传大文件
    keepalive_timeout 300s;        # 👈 保持长连接
}

location /download/ {
    alias /var/www/downloads;
    proxy_pass http://localhost:8080;
    proxy_buffering on;
    proxy_buffer_size 128k;        # 👈 单个缓冲区大小
    proxy_buffers 8 128k;          # 👈 缓冲区数量 × 大小
    proxy_busy_buffers_size 256k;  # 👈 忙碌时允许使用的缓冲区上限
    proxy_temp_file_write_size 256k;
    proxy_temp_path /tmp/nginx_proxy_temp;

    proxy_read_timeout 600s;
    proxy_send_timeout 600s;
    send_timeout 1200s;
    client_max_body_size 20G;
    keepalive_timeout 300s;
}

upstream java_backend {
    server localhost:8080;
    keepalive 32;                  # 👈 保持 32 个空闲连接
    keepalive_timeout 300s;        # 👈 连接空闲超时
    keepalive_requests 1000;       # 👈 每个连接最多处理 1000 个请求
}

location /download/ {
    proxy_pass http://java_backend;
    proxy_http_version 1.1;        # 👈 必须启用 HTTP/1.1 才能使用 keepalive
    proxy_set_header Connection "";
}

client_header_buffer_size 16k;
large_client_header_buffers 4 16k;

net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 120
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 3

sudo sysctl -p

gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_types text/plain application/json application/xml text/css application/javascript;

package com.example.downloads;
import org.springframework.core.io.InputStreamResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
@RestController
public class FileDownloadController {
    private static final String DOWNLOAD_DIR = "/var/www/downloads/";
    @GetMapping("/download/{filename}")
    public ResponseEntity<Resource> downloadFile(@PathVariable String filename) throws IOException {
        Path filePath = Paths.get(DOWNLOAD_DIR, filename);
        File file = filePath.toFile();
        if (!file.exists() || !file.isFile()) {
            return ResponseEntity.notFound().build();
        }
        // 👇 关键：使用 InputStreamResource 实现流式传输
        InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
        // 👇 设置响应头：告诉客户端这是一个大文件下载
        HttpHeaders headers = new HttpHeaders();
        headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"");
        headers.add(HttpHeaders.CONTENT_LENGTH, String.valueOf(file.length()));
        headers.add(HttpHeaders.ACCEPT_RANGES, "bytes"); // 👈 支持断点续传
        headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        // 👇 使用 ResponseEntity 返回流，不加载整个文件到内存
        return ResponseEntity.ok()
                .headers(headers)
                .contentLength(file.length())
                .body(resource);
    }
}

@GetMapping("/download/{filename}")
public ResponseEntity<Resource> downloadFileWithRange(@PathVariable String filename, 
                                                      HttpServletRequest request) throws IOException {
    Path filePath = Paths.get(DOWNLOAD_DIR, filename);
    File file = filePath.toFile();
    if (!file.exists() || !file.isFile()) {
        return ResponseEntity.notFound().build();
    }
    long fileSize = file.length();
    long start = 0;
    long end = fileSize - 1;
    // 👇 解析 Range 请求头
    String rangeHeader = request.getHeader("Range");
    if (rangeHeader != null && rangeHeader.startsWith("bytes=")) {
        String[] range = rangeHeader.substring(6).split("-");
        start = Long.parseLong(range[0]);
        if (range.length > 1 && !range[1].isEmpty()) {
            end = Long.parseLong(range[1]);
        }
    }
    long contentLength = end - start + 1;
    InputStreamResource resource = new InputStreamResource(new FileInputStream(file)) {
        @Override
        public InputStream getInputStream() throws IOException {
            FileInputStream fis = new FileInputStream(file);
            fis.skip(start); // 👈 跳过前面字节
            return fis;
        }
    };
    HttpHeaders headers = new HttpHeaders();
    headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"");
    headers.add(HttpHeaders.CONTENT_RANGE, "bytes " + start + "-" + end + "/" + fileSize);
    headers.add(HttpHeaders.ACCEPT_RANGES, "bytes");
    headers.add(HttpHeaders.CONTENT_LENGTH, String.valueOf(contentLength));
    headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
    // 👇 根据是否是部分请求返回 206 或 200
    if (rangeHeader != null) {
        return ResponseEntity.status(206) // Partial Content
                .headers(headers)
                .body(resource);
    } else {
        return ResponseEntity.ok()
                .headers(headers)
                .contentLength(fileSize)
                .body(resource);
    }
}

curl -v -o /dev/null http://localhost:8080/download/large-file.zip

< Content-Length: 2147483648
< Content-Disposition: attachment; filename="large-file.zip"
< Accept-Ranges: bytes

Files.copy(Paths.get("file.zip"), response.getOutputStream()); // ❌ 错误！

tail -f /var/log/nginx/error.log | grep -i "upstream timed out\|client intended to send too large body"

docker run -d -p 9113:9113 --name nginx-exporter \
  -e NGINX_PLUS=false \
  -e NGINX_SCRAPE_URI=http://localhost:80/nginx_status \
  nginx/nginx-prometheus-exporter:0.10.0

location /nginx_status {
    stub_status on;
    access_log off;
    allow 127.0.0.1;
    deny all;
}

- alert: NginxProxyTimeoutHigh
  expr: rate(nginx_http_requests_total{status="504"}[5m]) > 0.1
  for: 10m
  labels:
    severity: critical
  annotations:
    summary: "Nginx 504 超时率超过 10% / 分钟"
    description: "请检查 proxy_read_timeout 和后端响应速度"

long startTime = System.currentTimeMillis();
try {
    // ... 下载逻辑
} finally {
    long duration = System.currentTimeMillis() - startTime;
    log.info("Download completed: {} bytes in {} ms", fileSize, duration);
}

import io.minio.MinioClient;
import io.minio.PutObjectArgs;
MinioClient minioClient = MinioClient.builder()
    .endpoint("http://localhost:9000")
    .credentials("minioadmin", "minioadmin")
    .build();
minioClient.putObject(
    PutObjectArgs.builder()
        .bucket("downloads")
        .object("large-file.zip")
        .stream(inputStream, fileSize, -1)
        .contentType("application/octet-stream")
        .build()
);

location /download/ {
    internal;
    alias /var/www/downloads;
}
location /files/ {
    set $target "";
    if (-f /var/www/downloads/$request_uri) {
        set $target http://minio-server:9000/downloads/$request_uri;
    }
    if ($http_user_agent ~* "(curl|wget|IDM)") {
        return 302 $target;
    }
    # 浏览器直接访问，返回 Nginx 代理（用于权限校验）
    proxy_pass http://java-backend;
}

# /etc/nginx/sites-available/large-file-download

server {
    listen 80;
    server_name files.example.com;

    # 大文件下载目录
    location /download/ {
        alias /var/www/downloads;
        proxy_pass http://localhost:8080;
        proxy_buffering off;
        proxy_cache off;
        proxy_read_timeout 900s;
        proxy_send_timeout 900s;
        send_timeout 1800s;
        client_max_body_size 50G;
        keepalive_timeout 300s;
        proxy_http_version 1.1;
        proxy_set_header Connection "";

        # 安全头
        add_header X-Content-Type-Options nosniff;
        add_header X-Frame-Options DENY;
        add_header X-XSS-Protection "1; mode=block";
    }

    # Nginx 状态页（仅内网访问）
    location /nginx_status {
        stub_status on;
        access_log off;
        allow 192.168.0.0/16;
        deny all;
    }

    # 错误页面
    error_page 502 503 504 /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

# 全局配置
http {
    client_header_buffer_size 16k;
    large_client_header_buffers 4 16k;
    tcp_nodelay on;
    tcp_nopush on;
    sendfile on;
    keepalive_timeout 300s;
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types text/plain application/json application/xml text/css application/javascript;
}