Swift में रेट लिमिटिंग और थ्रॉटलिंग: API सुरक्षा और अनुकूलन

आपका API हमले में: क्यों rate limiting और throttling Swift डेवलपर के लिए अनिवार्य हैं

कल्पना करें: आपने Swift पर एक शानदार ऐप लॉन्च किया, उपयोगकर्ता खुश हैं, सर्वर बेहतरीन काम कर रहे हैं। लेकिन अचानक - पतन। किसी ने एक स्क्रिप्ट चलाई जो आपके API पर प्रति सेकंड हजारों अनुरोध भेजती है। या फिर सिर्फ एक सक्रिय उपयोगकर्ता "रिफ्रेश" बटन को इतनी तेजी से दबा रहा है कि आप डेटा प्रोसेस नहीं कर पाते। परिणाम - धीमापन, सर्वर डाउन और नकारात्मक समीक्षाएँ।

परिचित लगता है? तो यह लेख आपके लिए है। हम Swift में rate limiting और throttling पर चर्चा करेंगे - ऐसी तकनीकें जो आपके बैकएंड को बचाएंगी और ऐप को स्थिर बनाएंगी। आप सीखेंगे कि async/await के साथ आधुनिक दृष्टिकोणों का उपयोग करके क्लाइंट साइड पर Swift में अनुरोध सीमा कैसे लागू करें, और कौन से पैटर्न वास्तव में काम करते हैं।

Rate limiting बनाम Throttling: क्या अंतर है?

कोड लिखने से पहले, आइए शब्दों को समझें। कई लोग इन अवधारणाओं को भ्रमित करते हैं, हालांकि ये अलग-अलग समस्याओं का समाधान करते हैं।

Rate limiting (गति सीमा)

यह एक सख्त सीमा है: "एक अवधि में N से अधिक अनुरोध नहीं"। यदि सीमा पार हो जाती है - अनुरोध अस्वीकार कर दिया जाता है। सर्वर आमतौर पर 429 Too Many Requests लौटाता है। उदाहरण: आप एक IP से प्रति मिनट 100 से अधिक अनुरोधों की अनुमति नहीं देते।

Throttling (थ्रॉटलिंग)

यह एक नरम तंत्र है: अनुरोध अवरुद्ध नहीं होते, बल्कि कतार में रखे जाते हैं और एक निर्धारित आवृत्ति पर निष्पादित होते हैं। कल्पना करें कि आपका API प्रति सेकंड केवल 5 अनुरोधों को संसाधित कर सकता है। Throttling उन्हें कतारबद्ध करेगा और आवश्यक गति से भेजेगा, सर्वर को ओवरलोड किए बिना।

Swift में, दोनों दृष्टिकोण अलग-अलग तरीके से लागू किए जाते हैं। आइए सर्वोत्तम अभ्यासों पर नज़र डालें।

Swift में rate limiting के व्यावहारिक कार्यान्वयन

1. सरल टाइमर-आधारित throttling (GCD)

Swift में अनुरोधों को सीमित करने का सबसे सरल तरीका DispatchQueue और टाइमर का उपयोग करना है। यहाँ एक उदाहरण है जो सुनिश्चित करता है कि अनुरोध प्रति सेकंड एक बार से अधिक न भेजे जाएँ:

import Foundation\n\nfinal class RequestThrottler {\n    private let queue = DispatchQueue(label: "com.app.throttle")\n    private var lastRequestTime: Date = .distantPast\n    private let minimumInterval: TimeInterval\n    \n    init(interval: TimeInterval = 1.0) {\n        self.minimumInterval = interval\n    }\n    \n    func performThrottledRequest(block: @escaping () -> Void) {\n        queue.sync {\n            let now = Date()\n            if now.timeIntervalSince(lastRequestTime) >= minimumInterval {\n                lastRequestTime = now\n                DispatchQueue.main.async {\n                    block()\n                }\n            } else {\n                print("अनुरोध अस्वीकृत: बहुत बार")\n            }\n        }\n    }\n}\n\n// उपयोग\nlet throttler = RequestThrottler(interval: 2.0)\nthrottler.performThrottledRequest {\n    // आपका API अनुरोध\n    print("अनुरोध निष्पादित")\n}

यह दृष्टिकोण सरल है, लेकिन आदर्श नहीं: यह केवल "अतिरिक्त" अनुरोधों को छोड़ देता है। कई परिदृश्यों के लिए यह पर्याप्त है, लेकिन यदि आपको क्रम बनाए रखना और निष्पादन सुनिश्चित करना है - आगे पढ़ें।

2. कतार के साथ Rate limiter (async/await)

Swift async/await के आगमन के साथ, हमें कतार समर्थन के साथ swift rate limiter को लागू करने का एक सुरुचिपूर्ण तरीका मिला। यहाँ यह कैसा दिखता है:

import Foundation\n\nactor RateLimiter {\n    private let maxRequests: Int\n    private let perSecond: Double\n    private var requestTimestamps: [Date] = []\n    private var pendingTasks: [CheckedContinuation] = []\n    private var isProcessing = false\n    \n    init(maxRequests: Int, perSecond: Double) {\n        self.maxRequests = maxRequests\n        self.perSecond = perSecond\n    }\n    \n    func waitForSlot() async throws {\n        try await withCheckedThrowingContinuation { continuation in\n            pendingTasks.append(continuation)\n            if