Nginx और Node.js में 413 अनुरोध इकाई बहुत बड़ी त्रुटि को कैसे ठीक करें

त्रुटि413 अनुरोध इकाई बहुत बड़ी है इसका मतलब है कि अनुरोध निकाय (आमतौर पर एक फ़ाइल अपलोड या बड़ा JSON पेलोड) आपके सर्वर द्वारा अनुमत आकार सीमा से अधिक है। यह अक्सर nginx डिफ़ॉल्ट के कारण केवल उत्पादन में ही दिखाई देता है। यहां बताया गया है कि इसे हर परत पर कैसे ठीक किया जाए।

इस त्रुटि का क्या कारण है

एकाधिक परतें एक बड़े अनुरोध को अस्वीकार कर सकती हैं:

• Nginx (रिवर्स प्रॉक्सी) की डिफ़ॉल्ट बॉडी सीमा 1 एमबी है
• एक्सप्रेस/नोड.जेएस बॉडी पार्सर की अपनी सीमा होती है (डिफ़ॉल्ट ~100KB)
• मिडलवेयर अपलोड करें (मल्टर) में विन्यास योग्य फ़ाइल आकार सीमाएँ हैं

अनुरोध को सभी परतों से गुजरना होगा – केवल एक को ठीक करने से इसका समाधान नहीं हो सकता है।

समाधान 1: Nginx client_max_body_size

# nginx is the most common culprit — default is 1MB

# In your server or location block:
server {
    # Allow up to 50MB request bodies
    client_max_body_size 50M;

    location /api/upload {
        client_max_body_size 100M;   # larger for upload endpoints
        proxy_pass http://localhost:3000;
    }
}

# Or globally in http block (/etc/nginx/nginx.conf):
http {
    client_max_body_size 50M;
}

# Reload nginx after changing
sudo nginx -t && sudo systemctl reload nginx

समाधान 2: एक्सप्रेस बॉडी पार्सर सीमा

const express = require('express');
const app = express();

// 🐛 Default limit is ~100KB — large JSON fails
app.use(express.json());

// ✅ Increase the limit
app.use(express.json({ limit: '50mb' }));
app.use(express.urlencoded({ limit: '50mb', extended: true }));

// For specific routes only:
app.post('/api/large', express.json({ limit: '100mb' }), handler);

समाधान 3: फ़ाइल अपलोड सीमाएँ बदलें

const multer = require('multer');

// Configure size limits for file uploads
const upload = multer({
  storage: multer.diskStorage({ /* ... */ }),
  limits: {
    fileSize: 50 * 1024 * 1024,   // 50MB per file
    files: 5,                      // max 5 files
  },
});

app.post('/upload', upload.single('file'), (req, res) => {
  res.json({ filename: req.file.filename });
});

// Handle multer's own limit error gracefully
app.use((err, req, res, next) => {
  if (err instanceof multer.MulterError && err.code === 'LIMIT_FILE_SIZE') {
    return res.status(413).json({ error: 'File too large (max 50MB)' });
  }
  next(err);
});

तीनों परतें एक साथ

50एमबी अपलोड के सफल होने के लिए, सभी सीमाओं को इसकी अनुमति देनी होगी:

# 1. nginx (if used as reverse proxy)
client_max_body_size 50M;

# 2. Express body parser (for JSON/form data)
app.use(express.json({ limit: '50mb' }));

# 3. Multer (for multipart file uploads)
limits: { fileSize: 50 * 1024 * 1024 }

# The SMALLEST limit wins — the request fails at the first layer that rejects it

अन्य सर्वरों के लिए समाधान

# Apache — in .htaccess or config
LimitRequestBody 52428800   # 50MB in bytes

# Cloudflare — free plan limits uploads to 100MB
# (upgrade or upload directly to storage for larger files)

# Next.js API routes — configure the body size limit
export const config = {
  api: {
    bodyParser: { sizeLimit: '50mb' },
  },
};

बेहतर दृष्टिकोण: सीधे ऑब्जेक्ट स्टोरेज पर अपलोड करें

बड़ी फ़ाइलों के लिए, उन्हें अपने ऐप सर्वर के माध्यम से बिल्कुल भी रूट न करें – सीधे S3/क्लाउड स्टोरेज पर अपलोड करने के लिए निर्धारित URL का उपयोग करें:

// Backend generates a presigned upload URL
app.post('/api/presign', async (req, res) => {
  const url = await s3.getSignedUrl('putObject', {
    Bucket: 'my-bucket',
    Key: `uploads/${req.body.filename}`,
    Expires: 300,
  });
  res.json({ uploadUrl: url });
});

// Frontend uploads directly to S3 — bypasses your server's limits entirely
const { uploadUrl } = await fetch('/api/presign', { /* ... */ }).then(r => r.json());
await fetch(uploadUrl, { method: 'PUT', body: file });
// No 413 — the file never passes through your app server

अक्सर पूछे जाने वाले प्रश्न

प्रश्न: यह स्थानीय स्तर पर काम क्यों करता है लेकिन उत्पादन में विफल रहता है?
उ: प्रोडक्शन में आमतौर पर आपके ऐप के सामने डिफ़ॉल्ट 1MB बॉडी सीमा के साथ nginx (या कोई अन्य रिवर्स प्रॉक्सी) होता है। स्थानीय स्तर पर आप उस प्रॉक्सी के बिना सीधे अपने ऐप पर पहुंचते हैं। वृद्धिclient_max_body_size nginx में.

प्रश्न: मैंने एक्सप्रेस की सीमा बढ़ा दी लेकिन फिर भी मुझे 413 मिलता है। क्यों?
उत्तर: nginx एक्सप्रेस तक पहुंचने से पहले अनुरोध को अस्वीकार कर रहा है। रिवर्स प्रॉक्सी काclient_max_body_size भी बढ़ाया जाना चाहिए. सभी परतें ठीक करें – सबसे छोटी सीमा जीतती है।

प्रश्न: शरीर के आकार की उचित सीमा क्या है?
उत्तर: इसे उतना ही कम सेट करें जितना आपका उपयोग मामला अनुमति देता है – बड़ी सीमाएं दुरुपयोग/DoS जोखिम को बढ़ाती हैं। JSON API के लिए, कुछ MB काफी है। फ़ाइल अपलोड के लिए, अपनी सबसे बड़ी वैध फ़ाइल का आकार, या बेहतर, सीधे ऑब्जेक्ट स्टोरेज पर अपलोड करें।

प्रश्न: क्या बड़ी फ़ाइलें मेरे ऐप सर्वर से गुज़रनी चाहिए?
उ: आदर्श रूप से नहीं – सीधे S3/क्लाउड स्टोरेज पर अपलोड करने के लिए निर्धारित यूआरएल का उपयोग करें। यह पूरी तरह से शरीर के आकार की सीमा से बचता है, सर्वर लोड को कम करता है, और बेहतर स्केल करता है। अपने ऐप के माध्यम से केवल मेटाडेटा रूट करें।

प्रश्न: मैं रॉ 413 के बजाय फ्रेंडली एरर कैसे लौटाऊं?
उ: अपने मिडलवेयर में सीमा त्रुटि (मल्टर की LIMIT_FILE_SIZE, या बॉडी-पार्सर त्रुटि) को पकड़ें और एक स्पष्ट JSON संदेश लौटाएँ। तत्काल प्रतिक्रिया देने के लिए अपलोड करने से पहले फ्रंटएंड पर फ़ाइल का आकार भी सत्यापित करें।

निष्कर्ष

“413 अनुरोध इकाई बहुत बड़ी है” का अर्थ है कि अनुरोध निकाय सर्वर सीमा से अधिक है – और इसमें अक्सर कई परतें होती हैं। समाधान:वृद्धिclient_max_body_size nginx में, एक्सप्रेस के बॉडी पार्सर को बढ़ाएंlimit, और मल्टीर को कॉन्फ़िगर करेंfileSize – तीनों को आकार की अनुमति देनी होगी क्योंकि सबसे छोटी सीमा जीतती है। यह आमतौर पर nginx के 1MB डिफ़ॉल्ट के कारण उत्पादन में दिखाई देता है। बड़ी फ़ाइलों के लिए, सबसे अच्छा समाधान आपके ऐप सर्वर की सीमाओं को पूरी तरह से दरकिनार करते हुए और बेहतर स्केलिंग करते हुए, निर्धारित यूआरएल के साथ सीधे ऑब्जेक्ट स्टोरेज पर अपलोड करना है।