Nodejs behebt den 413-Fehler

Bei der Entwicklung von Webanwendungen mit Node.js kann es vorkommen, dass große Datei-Uploads verarbeitet werden müssen. Wenn die hochgeladene Datei jedoch zu groß ist, kann der Fehler „HTTP 413 Request Entity Too Large“ auftreten. Dies liegt daran, dass Node.js standardmäßig eine Größenbeschränkung für den Anforderungstext von 100 KB hat. Wenn die Größe der Anforderungsentität diesen Grenzwert überschreitet, tritt ein HTTP-413-Fehler auf.

Um dieses Problem zu lösen, stehen mehrere Methoden zur Auswahl.

1. Begrenzung des Anforderungstexts ändern

Eine Lösung besteht darin, die Größenbeschränkung für Upload-Dateien zu erhöhen, indem die standardmäßige Größenbeschränkung für den Anforderungstext geändert wird. In Node.js können Sie das Modul body-parser verwenden, um den Anforderungstext zu analysieren. Eine der Optionen dieses Moduls ist limit, mit der Sie den bearbeiten können Körpergrößenbeschränkung anfordern. body-parser 模块来解析请求体，这个模块其中一个选项就是 limit，可以用来修改请求体大小的限制。

const express = require('express')
const bodyParser = require('body-parser')

const app = express()

// limit设置为50MB
app.use(bodyParser.json({limit: '50mb'}))
app.use(bodyParser.urlencoded({limit: '50mb', extended: true}))

// 处理文件上传的请求
app.post('/upload', (req, res) => {
  // ...
})

app.listen(3000, () => {
  console.log('服务器启动成功')
})

使用上述代码，可以将请求体限制提高到 50MB。然而，这种方法并不适合处理非常大的文件上传请求，因为较大的请求体也会消耗不少的内存。

2. 使用 Streams 处理请求体

当上传文件较大时，将整个请求体读取到内存中可能会导致性能问题。为了避免这个问题，Node.js 提供了一个 Stream API，可以将请求体作为流处理。

Stream 与 Buffer 最大的不同在于，Stream 可以分批次地将数据读取到内存中。这样，即使请求体非常大，也不会对服务器的内存造成太大的压力。

const express = require('express')
const app = express()
const BUSBOY = require('busboy')

app.post('/upload', (req, res) => {
  const busboy = new BUSBOY({ headers: req.headers })
  busboy.on('file', function(fieldname, file, filename, encoding, mimetype) {
    console.log('文件名：', filename);
    file.on('data', function(data) {
      console.log('文件大小为：', data.length);
    });
    file.on('end', function() {
      console.log('文件上传成功');
    })
  })

  busboy.on('field', function(fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) {
    console.log('表单字段：', fieldname, val);
  })

  busboy.on('error', function(err) {
    console.log('文件上传失败：', err);
    res.status(500).send('文件上传失败')
  })

  req.pipe(busboy)
})

上述代码使用了 busboy 库，它是一个可读写的流 API，可以将解析上传文件的分解为多个流事件。

3. 使用 Nginx

当使用 Node.js 处理大文件上传请求时，你可以为你的应用程序后面添加 Nginx 网关服务器。Nginx 可以充当反向代理，从而可以缓解请求体大小限制的问题。

当请求体大小超出限制时，Nginx 可以拒绝请求并返回 HTTP 413 错误。要对 Nginx 的配置进行调整，请在 /etc/nginx/nginx.conf 文件中添加以下内容：

http {
  client_max_body_size 1000M;
  upstream app_servers {
    server localhost:3000;
  }
  server {
    listen 80;
    server_name yourdomain.com;
    location / {
      proxy_pass http://app_servers;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header Host $host;
      proxy_set_header X-NginX-Proxy true;
    }
  }
}

使用 client_max_body_sizerrreee

Mit dem obigen Code kann das Anforderungstextlimit auf 50 MB erhöht werden. Allerdings eignet sich diese Methode nicht für die Bearbeitung sehr großer Datei-Upload-Anfragen, da der größere Anfragetext auch viel Speicher verbraucht.

Verwenden Sie Streams, um den Anforderungstext zu verarbeiten
🎜Wenn die hochgeladene Datei groß ist, kann das Einlesen des gesamten Anforderungstexts in den Speicher zu Leistungsproblemen führen. Um dieses Problem zu vermeiden, stellt Node.js eine Stream-API bereit, die den Anforderungstext als Stream verarbeiten kann. 🎜🎜Der größte Unterschied zwischen Stream und Buffer besteht darin, dass Stream Daten stapelweise in den Speicher einlesen kann. Auf diese Weise wird der Speicher des Servers nicht zu stark belastet, selbst wenn der Anforderungstext sehr groß ist. 🎜rrreee🎜Der obige Code verwendet die busboy-Bibliothek, eine Lese-/Schreib-Stream-API, die das Parsen hochgeladener Dateien in mehrere Stream-Ereignisse zerlegen kann. 🎜
🎜Nginx verwenden🎜🎜🎜Wenn Sie Node.js zur Verarbeitung großer Datei-Upload-Anfragen verwenden, können Sie einen Nginx-Gateway-Server hinter Ihrer Anwendung hinzufügen. Nginx kann als Reverse-Proxy fungieren, was das Problem der Größenbeschränkungen des Anforderungstexts lindern kann. 🎜🎜Wenn die Größe des Anfragetextes den Grenzwert überschreitet, kann Nginx die Anfrage ablehnen und einen HTTP 413-Fehler zurückgeben. Um die Nginx-Konfiguration anzupassen, fügen Sie den folgenden Inhalt zur Datei /etc/nginx/nginx.conf hinzu: 🎜rrreee🎜Verwenden Sie client_max_body_size, um die Größenbeschränkung für den Anforderungstext zu ändern. Der obige Code legt die Größenbeschränkung für den Anforderungstext auf 1000 MB fest. 🎜🎜Fazit🎜🎜Bei der Verarbeitung großer Datei-Uploads kann das Problem auftreten, dass die HTTP 413-Anforderungseinheit zu groß ist. In diesem Artikel stellen wir drei Lösungen vor: Ändern des Anforderungskörperlimits, Verwenden von Streams zur Verarbeitung des Anforderungskörpers und Verwenden von Nginx. Sie können je nach Ihren Anwendungsanforderungen die geeignete Methode für die Bearbeitung großer Datei-Upload-Anfragen auswählen. 🎜

Das obige ist der detaillierte Inhalt vonNodejs behebt den 413-Fehler. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!