Please enable JavaScript.

Coggle requires JavaScript to display documents.

Backend throttling, Backend Throttler, Throttle method POST /orders but…

- - - - Attach backend throttling policy (3 req/min) to the pool
        
        Create an API using that pool
        
        Create and approve application
        
        Create and approve contract
        
        Generate access token
        
        Invoke Gateway API 3 times within a minute
        
        1 more item...
- - - - Create two Backend Throttling Policies:
        Policy A: 3 requests/min
        Policy B: 5 requests/min
        
        Create two Pools:
        Pool A with Backend A + Policy A
        Pool B with Backend B + Policy B
        
        Create API A using Pool A
        Create API B using Pool B
        
        Create Application
        
        Approve Application
        
        Create and Approve Contract for API A and API B
        
        1 more item...
- - - - Invoke API A 3x → wait 1 min → invoke again | Request allowed post 1 min |
        
        Invoke API B 5x → wait 1 min → invoke | Request throttled due to longer reset window |
- - - - Send requests repeatedly | Only requests routed through throttled backend get limited
- - - - Approve app & contract for both | Done |
        
        Call API A 3x, then API B 3x | API B’s 3rd call gets throttled (shared quota reached)
- - - - Approve app & contract | Done |
        
        Invoke API 6x | 6th request throttled due to stricter pool limit |
- - - - Update policy to 5/min | Policy updated
        
        Invoke 5 times in 1 min | 5 calls succeed (new limit respected) |
- - - - Send high-volume requests (e.g. 5000+) | No throttling until limit reached |
        
        At 10,001st request | Request throttled (HTTP 429) |
- - - - Create API with multiple methods (e.g., GET /orders, POST /orders) | API created |
        
        Attach pool only to GET /orders method | Method-level binding done |
        
        Approve app & contract | Application setup complete |
        
        Call GET /orders 4 times in 1 min | First 3 succeed, 4th is throttled
        
        Call POST /orders | Not throttled (no limit set) |
- - - - Assign pool to GET /products method | API method bound
        
        Approve app & contract | Done
        
        Call GET /products 4 times | Request routed; policy A or B may trigger throttling
        
        Confirm if combined logic is used or shortest limit is enforced | Expected: 3rd or 4th request throttled depending on routing/split
- - - - Approve full setup | Application ready |
        
        Call GET /inventory 3x | 3rd call throttled (2/min override applies) |
        
        Call other methods 5x | Allowed up to API-level limit
- - - - Assign pool at operational level to an API (not specific methods/resources) | Pool bound globally
        
        Create and approve application & contract | Setup complete
        
        Invoke any method of the API 3 times within 1 minute | All 3 calls succeed
        
        Invoke 4th request on any method | Throttled (HTTP 429)
- - - - Attach pool operationally to an API | Global attachment done
        
        Approve full setup | Done
        
        Invoke API 6+ times and monitor throttling | Throttling may trigger on backend A (after 3), backend B (after 5) depending on routing
- - - - Bind pool at operational level | Global scope attached
        
        Call API → Reach A’s limit and wait 1 min | API becomes available again through A
        
        Reach B’s limit → wait 1 min and retry | B remains throttled due to longer reset (10 min)
- - - - Attach pool operationally | API created
        
        Call API multiple times | Only calls routed through A get throttled; B calls pass regardless
- - - - Bind pool operationally | API setup
        
        Call API 4 times within 1 min | 4th call throttled due to pool-level limit (3/min) |
        
        Check headers/logs to confirm which limit triggered | Validated via system logs or headers
- - - - Call API 3x → 3rd call throttled | Expected
        
        Edit policy to 5/min (live) | Policy updated
        
        Retry API call without redeploying pool | Request allowed as updated limit applies instantly
- - - - Assign pool at API level
        
        Create method-level override (e.g., GET /orders → 3 req/min)
        
        Approve application and contract
        
        Invoke GET /orders 4 times in 1 minute
        4th call throttled (method-level policy applies)
        
        Invoke another method (e.g., POST /orders) 10 times
        All succeed (API-level policy applies)
- - - - Override one method (e.g., GET /info) with 2/min backend policy
        
        Approve application and contract
        
        Call GET /info 3x in 1 min
        3rd request throttled
        
        Call POST /info 5x
        All succeed
- - - - Approve application and contract
        
        Call GET /items 6x in 1 minute
        
        Call any other method 4x
        4th request throttled (global policy enforces 3/min)
- - - - Approve app and contract
        
        Call GET /stats 4x
        4th call throttled (method policy wins)
        
        Call POST /stats 6x
        6th call throttled (backend 5/min applies even though pool allows 10/min)
- - - - Approve application and contract
        
        Call GET /a 3x
        3rd call throttled
        
        Call POST /b 5x
        All succeed
        
        Call POST /b a 6th time
        6th call throttled (backend 5/min limit reached)
- - - - Approve and call GET /audit 3x
        3rd call throttled
        
        Remove method override (reset to default)
        
        Call GET /audit 5x
        All succeed (now follows API-level 5/min limit)
- - - - Approve both applications
        
        Call API 1 (3x) + API 2 (2x) → then API 2 once more(API 2's 3rd call throttled (shared quota reached at 5/min)
        
        Confirm log shows shared backend limit reached
        Validated
- - - - Leaky Bucket
      - Token Bucket
      - Sliding Window
      - Fixed Window
      - Sliding Log
      - PID
    - - Second
      - Minute
      - Hour
      - Day
- - - - Send delete throttling request
        
        If throttler is NOT in use
        
        On Success
        
        Show success message (toast/snackbar)
        
        Remove item from list view
        
        On Failure
        
        Show error message
        
        If throttler is in use
        
        Prevent deletion
        
        Show blocking message:
        
        "This throttler is currently in use and cannot be deleted."
        
        Optionally disable Delete button in UI
- - - - Name
      - Description
      - Algorithm
- - - - Create API with GET & POST methods | API created
        
        Approve flow | Done
        
        Call POST /orders 3x in 1 min | First 2 succeed, 3rd throttled
        
        Call GET /orders 3x | All succeed (no throttling expected)
- - - - Approve flow | Done |
        
        Invoke method 5x in 1 min | 3rd or 4th request throttled (lowest enforced) |
        
        Confirm logs show both policies evaluated | Verified |