DEV Community: Kisore Subburaman

Why Redis? An Intro with Practical Use Cases for Developers

Kisore Subburaman — Wed, 06 Nov 2024 17:48:36 +0000

Redis Introduction

Redis is an in-memory data structure store that supports multiple data types, making it a top choice for many developers.

Major usage

Caching
Session management
Rate Limiting
Message Broker

Supported Data Types

String
Hash
List
Set
Sorted set
Stream
Bitmap
Bitfield
Geospatial

Refer redis documentation which is clean and well structured.

Why Redis?

Reading and writing data in RAM is several orders of magnitude faster than on disk, enabling Redis to handle hundreds of thousands to millions of operations per second.

Redis has a rich set of data structures. These structures enable complex data manipulation and aggregation tasks with minimal code.

Atomicity

Redis processes all the commands in a single-threaded, event-driven loop which ensures that the commands are executed in the order they are issued.

Redis offers atomic operations at the data structure level.
For example: If two clients concurrently execute INCR command on the same key, Redis ensures that the value is correctly incremented twice without any lost increments.

Transactional

Redis supports transactions using MULTI and EXEC commands. It allows a list of commands to be queued and executed atomically.

MULTI starts a transaction
Any commands issued after MULTI will be queued and not executed immediately
EXEC executes all commands atomically as a single batch
Note that if any command fails, the remaining commands in the transaction still execute. Redis does not support rollback.

Rate Limiting

Think about when your boss dumps a mountain of work on you in no time. You would be exhausted, maybe even seeing stars, right? While we can complain about it, networks don’t have that option—they just slow down and struggle! So, if we get tired from overload, it’s fair to say networks need a breather too!

Rate limiting is a technique which controls the follow of traffic by limiting the number of requests made to a network, server, or resource in a given time frame. It prevents users from exhausting network resources.

A rate-limited application signals users to slow down rather than overwhelming it with too many requests. It’s like traffic officers stopping speeding drivers—this isn't ideal for the fast driver (here, the user has to wait after hitting a certain limit) or for other drivers on the same road (other users trying to access the same resource). Rate limiting ensures smoother access for everyone.

Types of rate limits

Rate limit can be implemented based on the business objective and level of restriction required. There are 3 common types.

User rate limits: It monitors the number of requests made by a user by tracking IP address or API key. Users who have hit the threshold value are notified and denied for further requests until the timeframe resets.
Geographic rate limits: It relies on detecting user's location through IP address or geolocation APIs. By applying different rate limits to various geographic regions, developers can prioritize certain areas or reduce traffic from regions known for abusive behavior. For instance, some applications restrict access or enforce stricter rate limits from countries associated with a high frequency of DDoS or brute-force attacks.
Server rate limits: Developers can set rate limits directly on the server level if they assign specific servers to handle different parts of an application. This approach gives them more flexibility, letting them increase rate limits on frequently used servers while lowering traffic limits on servers that see less action.

Redisgraph - Deep Dive Part 1

Kisore Subburaman — Sat, 26 Sep 2020 07:34:13 +0000

RedisInsight

Hey guys! This is the second part of Redisgraph series. As we talked about RedisInsight earlier, it is a GUI for redis application. We can view the graphical representation of our data. Here, Install RedisInsight contains the steps for installation.
Once installed, run your redis server and redis insight, navigate to http://127.0.0.1:8001/. You will visit the home page of redis insight, there you can create a new database for your project as mentioned below.

Now, a database is created, you can navigate into it. In the sidebar, you can find Redisgraph, get into it. There, you can run commands and execute them. Both graphical and JSON notation of data is available.

CREATE

MATCH

Now, we can see some of the commands withdrawing the example we had from our last tutorial,

SKIP

It is used when we deal with batches of records.

syntax: SKIP [number of records to be skipped]

MATCH (e:emp) RETURN e SKIP 10;

It skips the first 10 records and returns the rest.

LIMIT

It is used to limit the number of records.

syntax: LIMIT [maximum number of records to be retrieved]

MATCH (e:emp) RETURN e LIMIT 10;

It returns only the first 10 records present.

SKIP and LIMIT together

MATCH (e:emp) RETURN e SKIP 10 LIMIT 10;

It skips the first 10 records and lists the next 10.

ORDER BY

It denotes the sorting option [ASC/DESC]. We can specify how the records have to be sorted.

syntax: ORDER BY [field name] [ASC/DESC]

If we want to retrieve records with sorting names of employees ascending order(default).

MATCH (e:emp) RETURN e ORDER BY e.name;

For descending,

MATCH (e:emp) RETURN e ORDER BY e.designation DESC;

Intro to Redisgraph

Kisore Subburaman — Thu, 17 Sep 2020 14:33:53 +0000

Hey guys! This is a series about RedisGraph. For the people out there who are new to this term, it is the first queryable Property Graph database to use sparse matrices to represent the adjacency matrix in graphs and linear algebra to query the graph. Don't panic, it is not as difficult as it seems, in a nutshell, it is a graph-based database where we're going to handle data through nodes and relationships. For guys who have worked in Neo4j, this would be a piece of cake.You can visit the official site here Redisgraph

Let's see the primary features:

It is based on the Property Graph Model.
Nodes are treated as vertices and edges are treated as relationships, that may have attributes.
Nodes can be labeled.
Relationships have a relationship type.
Graphs are represented as sparse adjacency matrices, Cypher as a query language
Cypher queries are translated into linear algebra expressions

Setting up redisgraph

You can find the installation and setup process here Setup Redisgraph

Why should I use Redisgraph?

Faster : Redisgraph provides faster access and retrieval of data.
Straightforward : Since it is based on nodes and relations, it is not a hard nut to crack.
Understandable : Queries are simple commands and clear.
Visual view : To interact with data visually, Redislabs provides a service RedisInsight, we will dig deeper into that service later in our tutorial.

Supported Datatypes

Integer
NULL
String
Boolean
Double

Let's get our hands dirty

We take an example of creating employees of an organization and perform CRUD.

CREATE

    CREATE (e:emp{id:1, name: 'John', age: '24', designation: 'developer'}) RETURN e;

    CREATE (e:emp{id:2, name: 'Jessie', age: '27', designation: 'tester'}) RETURN e;

Here,
* e - alias of the emp, we can use it within this entire command anywhere we needed.
* emp - name of the node.
* data will be given as key-value pair (object).
* RETURN - return the data after creation.

MATCH

It matches all docs(documents) when no condition is given explicitly and when given, it retrieves only the docs matching the condition.

To return the list of all employees

 MATCH (e:emp) RETURN e;

To fetch on condition basis

MATCH (e:emp{id:1}) RETURN e;

MATCH (e:emp) WHERE e.id = 1 RETURN e;

Both ways returns the doc of an employee having id 1.

SET

To update a single property

 MATCH (e:emp{id: 1}) SET e.age=28 RETURN e;

To update more than one property

MATCH (e:emp{id: 1}) SET e.age=28,e.designation=’senior developer’ RETURN e;

DELETE

To delete based on condition

MATCH (e:emp{id:2}) DELETE e;

Boom! It deletes the employee with id 2.
To delete all the docs

MATCH (e:emp) DELETE e;