Nodejs résout l'erreur 413-Questions et réponses frontales-php.cn

Nodejs résout l'erreur 413

WBOY

Libérer： 2023-05-27 20:41:36

original

1012 Les gens l'ont consulté

Lors du développement d'applications Web à l'aide de Node.js, vous pouvez rencontrer des situations dans lesquelles vous devez gérer des téléchargements de fichiers volumineux. Cependant, lorsque le fichier téléchargé est trop volumineux, vous pouvez rencontrer une erreur HTTP 413 Request Entity Too Large. En effet, Node.js a une limite de taille de corps de requête de 100 Ko par défaut. Lorsque la taille de l'entité de requête dépasse cette limite, une erreur HTTP 413 se produit.

Pour résoudre ce problème, vous avez le choix entre plusieurs méthodes. Une solution consiste à augmenter la taille limite du fichier de téléchargement en modifiant la taille limite par défaut du corps de la requête. Dans Node.js, vous pouvez utiliser le module body-parser pour analyser le corps de la requête. L'une des options de ce module est limit, qui peut être utilisée pour modifier le corps de la requête. demander une limite de taille corporelle.

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('服务器启动成功')
})

Copier après la connexion

body-parser 模块来解析请求体，这个模块其中一个选项就是 limit，可以用来修改请求体大小的限制。
```
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)
})
```
Copier après la connexion
使用上述代码，可以将请求体限制提高到 50MB。然而，这种方法并不适合处理非常大的文件上传请求，因为较大的请求体也会消耗不少的内存。
1. 使用 Streams 处理请求体
当上传文件较大时，将整个请求体读取到内存中可能会导致性能问题。为了避免这个问题，Node.js 提供了一个 Stream API，可以将请求体作为流处理。
Stream 与 Buffer 最大的不同在于，Stream 可以分批次地将数据读取到内存中。这样，即使请求体非常大，也不会对服务器的内存造成太大的压力。
```
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;
    }
  }
}
```
Copier après la connexion
上述代码使用了 busboy 库，它是一个可读写的流 API，可以将解析上传文件的分解为多个流事件。
1. 使用 Nginx
当使用 Node.js 处理大文件上传请求时，你可以为你的应用程序后面添加 Nginx 网关服务器。Nginx 可以充当反向代理，从而可以缓解请求体大小限制的问题。

当请求体大小超出限制时，Nginx 可以拒绝请求并返回 HTTP 413 错误。要对 Nginx 的配置进行调整，请在 /etc/nginx/nginx.conf 文件中添加以下内容：
rrreee
使用 client_max_body_sizeLorsque le fichier téléchargé est volumineux, il est possible de lire l'intégralité de la requête corps en mémoire Peut entraîner des problèmes de performances. Pour éviter ce problème, Node.js fournit une API Stream qui peut traiter le corps de la requête comme un flux.

La plus grande différence entre Stream et Buffer est que Stream peut lire les données en mémoire par lots. De cette façon, même si le corps de la requête est très volumineux, cela n’exercera pas trop de pression sur la mémoire du serveur.
rrreee
Le code ci-dessus utilise la bibliothèque busboy, qui est une API de flux en lecture-écriture qui peut décomposer l'analyse des fichiers téléchargés en plusieurs événements de flux.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!