Nodejs résout l'erreur 413

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

En utilisant le code ci-dessus, la limite du corps de la requête peut être augmentée à 50 Mo. Cependant, cette méthode n'est pas adaptée au traitement des requêtes de téléchargement de fichiers très volumineuses, car le corps de la requête plus volumineux consomme également beaucoup de mémoire.
1. Utiliser Streams pour traiter le corps de la requête

   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)
   })

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

   2. 使用 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;
       }
     }
   }

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

   3. 使用 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.

   #🎜🎜#Utilisation de Nginx#🎜🎜##🎜🎜##🎜🎜#Lorsque vous utilisez Node.js pour gérer les demandes de téléchargement de fichiers volumineux, vous pouvez backend votre application Ajouter une passerelle Nginx serveur. Nginx peut agir comme un proxy inverse, ce qui peut atténuer le problème des limitations de la taille du corps des requêtes. #🎜🎜##🎜🎜#Lorsque la taille du corps de la requête dépasse la limite, Nginx peut rejeter la requête et renvoyer une erreur HTTP 413. Pour ajuster la configuration de Nginx, ajoutez le contenu suivant au fichier /etc/nginx/nginx.conf : #🎜🎜#rrreee#🎜🎜#Utilisez client_max_body_size pour modifier le demander une limite de taille corporelle. Le code ci-dessus définit la limite de taille du corps de la requête à 1 000 Mo. #🎜🎜##🎜🎜#Conclusion#🎜🎜##🎜🎜#Lors du traitement des téléchargements de fichiers volumineux, vous pouvez rencontrer le problème d'une entité de requête HTTP 413 trop volumineuse. Dans cet article, nous présentons trois solutions : modifier la limite du corps de la requête, utiliser Streams pour gérer le corps de la requête et utiliser Nginx. Vous pouvez choisir la méthode appropriée pour gérer les demandes de téléchargement de fichiers volumineux en fonction des besoins de votre application. #🎜🎜#

   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!