ArrowLeft Icon

Fair Resource Allocation: Understand Rate Limiting and Throttling

📆 · ⏳ 6 min read · · 👀

Introduction

Hey there! Today, let’s explore a topic that’s crucial for developers building applications in a world where resources are finite and demand is ever-growing.

I’ll be talking about rate limiting and throttling - two techniques that help maintain harmony and fairness in a world of limited resources.

Imagine you’re in charge of a library, and you have a popular book that everyone wants to read. But here’s the catch: you only have a limited number of copies available.

Without a plan, the library could turn into chaos, with everyone rushing to grab the book at once, leaving some disappointed and others frustrated.

Rate limiting and throttling serve as the librarians of the digital world, ensuring a smooth experience for all users, preventing overloading, and maintaining system stability.

Rate Limiting - Balancing the Demand

Rate limiting is a technique that controls the rate at which users can access a resource. It ensures that no one user overwhelms the system by accessing too many resources at once.

Let’s go back to our library example. To ensure that everyone gets a chance to read the book, the library could implement a rate limit of one book per person.

This way, everyone gets a fair chance to read the book, and the library doesn’t run out of copies.

Rate Limiting in the Digital World

In the digital world, rate limiting is used to control the rate at which users can access resources like API endpoints, server capacity, and network bandwidth.

For example, a web service might implement a rate limit of 100 requests per minute. This ensures that no one user overwhelms the system by sending too many requests at once.

Rate Limiting Strategies

There are several strategies for implementing rate limiting. Let’s take a look at some of the most common ones.

Token Bucket

The token bucket strategy is one of the most popular rate limiting techniques. It works by maintaining a bucket of tokens that are refilled at a fixed rate.

Each time a user requests a resource, a token is removed from the bucket. If the bucket is empty, the user is denied access to the resource.

Fixed Window

The fixed window strategy works by maintaining a counter that is reset at a fixed interval.

Each time a user requests a resource, the counter is incremented. If the counter exceeds the limit, the user is denied access to the resource.

Rate Limiting in Action

Let’s take a look at an example of rate limiting in action. We’ll use the token bucket strategy to implement a rate limit of 100 requests per minute.

First, we’ll create a token bucket with 100 tokens. Each time a user requests a resource, we’ll remove a token from the bucket.

If the bucket is empty, we’ll deny access to the resource. Otherwise, we’ll grant access and refill the bucket at a rate of 1 token per second.

// Create a token bucket with 100 tokens
const bucket = new TokenBucket(100);
// Each time a user requests a resource, remove a token from the bucket
const request = () => {
if (bucket.isEmpty()) {
return 'Access denied';
} else {
bucket.removeToken();
return 'Access granted';
}
};
// Refill the bucket at a rate of 1 token per second
setInterval(() => {
bucket.addToken();
}, 1000);

Assume there is a class TokenBucket that implements the token bucket strategy. The TokenBucket class has the following methods:

  • isEmpty() - Returns true if the bucket is empty, false otherwise.
  • removeToken() - Removes a token from the bucket.
  • addToken() - Adds a token to the bucket.

Throttling - Taming the Flood

In a bustling library, even with rate limiting in place, some readers might still get overly excited and attempt to check out multiple copies of the book at once. This is where throttling comes to the rescue.

Throttling monitors the rate at which users access resources and ensures that no one user overwhelms the system. It gently slows down the process, allowing everyone to enjoy a smooth and balanced experience.

Throttling Strategies

There are several strategies for implementing throttling. Let’s take a look at some of the most common ones.

Fixed Delay

The fixed delay strategy works by delaying each request by a fixed amount of time.

For example, if the delay is set to 1 second, each request will be delayed by 1 second.

Exponential Backoff

The exponential backoff strategy works by delaying each request by an exponentially increasing amount of time.

For example, if the delay is set to 1 second, the first request will be delayed by 1 second, the second request will be delayed by 2 seconds, and so on.

Adaptive Delay

The adaptive delay strategy works by delaying each request by an amount of time that is determined by the current load on the system.

For example, if the system is under heavy load, each request will be delayed by a longer amount of time.

Throttling in Action

Let’s take a look at an example of throttling in action. We’ll use the fixed delay strategy to implement a throttling mechanism that limits the number of requests per minute.

First, we’ll create a counter that is reset at the start of each minute. Each time a user requests a resource, we’ll increment the counter.

If the counter exceeds the limit, we’ll delay the request by a fixed amount of time. Otherwise, we’ll grant access and reset the counter.

// Create a counter that is reset at the start of each minute
let counter = 0;
setInterval(() => {
counter = 0;
}, 60000);
// Each time a user requests a resource
// increment the counter
const request = () => {
counter++;
// If the counter exceeds the limit
// delay the request by a fixed amount of time
if (counter > 100) {
return new Promise((resolve) => {
setTimeout(() => {
resolve('Delayed Access granted');
}, 1000);
});
} else {
return Promise.resolve('Access granted');
}
};

Here we’re using a fixed delay of 1 second. If the counter exceeds the limit, we delay the request by 1 second.

The delay is caused by returning a Promise with a setTimeout function that resolves after 1 second.

The Role of Rate Limiting and Throttling in the Digital World

In the digital realm, resources like API endpoints, server capacity, and network bandwidth are finite.

Rate limiting and throttling play a vital role in controlling the access and usage of these resources, preventing denial-of-service (DoS) attacks, and maintaining the overall health of the system.

Conclusion

In conclusion, rate limiting and throttling are the superheroes of resource allocation in the digital world. They ensure fair and equitable access, prevent overloading, and keep your applications running smoothly for all users.

Just like the vigilant librarians at the bustling library, rate limiting and throttling create a harmonious and balanced experience for everyone involved.

So, next time you’re building an application that needs to handle limited resources, remember to embrace rate limiting and throttling - your keys to ensuring fair resource allocation and maintaining a stable system. Happy coding!

EnvelopeOpen IconStay up to date

Get notified when I publish something new, and unsubscribe at any time.

Need help with your software project? Let’s talk

You may also like

  • # system design# database

    Choosing the Right Data Storage Solution: SQL vs. NoSQL Databases

    Navigating the world of data storage solutions can be like choosing the perfect tool for a job. Join me as we dive into the dynamic debate of SQL and NoSQL databases, understanding their strengths, limitations, and where they best fit in real-world scenarios.

  • # system design

    Raft and Paxos: Distributed Consensus Algorithms

    Dive into the world of distributed systems and unravel the mysteries of consensus algorithms with Raft and Paxos. In this blog, we'll embark on a human-to-human exploration, discussing the inner workings of these two popular consensus algorithms. If you have a solid grasp of technical concepts and a curious mind eager to understand how distributed systems achieve consensus, this guide is your ticket to clarity!

  • # system design

    Understanding Load Balancing Algorithms: Round-robin and Consistent Hashing

    Welcome to the world of load balancing algorithms, where we unravel the magic behind Round-robin and Consistent Hashing. If you have a solid grasp of technical concepts and are eager to understand how these algorithms efficiently distribute traffic across servers, this blog is your ultimate guide. We'll embark on a human-to-human conversation, exploring the inner workings of Round-robin and Consistent Hashing, and how they keep our systems scalable and performant.