In this blog, we will learn how to set up a Redis server step-by-step
Prerequisite:
Launch the AWS instance RHEL and ssh into it.
What is Redis
Redis is in the family of databases called key-value stores.
The essence of a key-value store is the ability to store some data, called a value, inside a key. This data can later be retrieved only if we know the exact key used to store it.
Often Redis it is called a data structure server because it has outer key-value shell, but each value can contain a complex data structure, such as a string, a list, a hashes, or ordered data structures called sorted sets as well as probabilistic data structures like hyperloglog.
Install Redis on Redhat Linux
Run the below command:
sudo yum install redis
systemctl start redis
systemctl enable redis
systemctl status redis
If you want to Install and configure the Redis server from the source use the below commands:
wget https://download.redis.io/redis-stable.tar.gz
yum install wget -y
wget https://download.redis.io/redis-stable.tar.gz
tar -xzvf redis-stable.tar.gz
cd redis-stable
sudo make >> error
Used link >> Used google search and bing search.
Used link > https://stackoverflow.com/questions/30692708/redis-linux-error-when-installing-redis-on-linux-cc-command-not-found
sudo yum groupinstall "Development Tools"
sudo yum install make
sudo make
sudo make install
sudo make install
systemctl status redis
Starting Redis CLI You can start the Redis command line interface using the following command:
redis-cli
Data structures in Redis server
Data structures in Redis server are different ways of storing and organizing data in memory. Each data structure has its own commands and features that make it suitable for different use cases.
As a first example, we can use the command SET to store the value "vin" at key "server:name":
SET server:name "vin"
Redis will store our data permanently, so we can later ask "What is the value stored at key server:name?" and Redis will reply with "vin"
GET server:name
There is a command to test if a given key exists or not:
EXISTS server:name
If the output is 1 then the key exists and if 0 then the key does not exist.
OK
"vin"
(integer) 1
(integer) 0
OK
(integer) 1
DEL: The DEL command is used to delete a specified key along with its associated value. It allows you to remove data from Redis.
INCR: INCR is used for atomically incrementing a numeric value stored at a given key. This is particularly useful for implementing counters, where you need to increase a value by 1 each time it's called.
INCRBY: INCRBY is similar to INCR, but it allows you to increment the number contained inside a key by a specific amount, which you specify as an argument.
DECR: DECR is the counterpart to INCR. It is used to decrement the value stored at a key by 1. This is useful for reducing counters or decreasing values.
DECRBY: DECRBY is similar to DECR, but it allows you to decrease the value inside a key by a specified amount, which you specify as an argument.
OK
(integer) 11
"11"
(integer) 12
(integer) 1
(nil)
(integer) 1
"1"
(nil)
"salunke"
(integer) 1
(nil)
(integer) 1
OK
""
OK
"vinayak"
> get con
"1"
> incrby con 1000
(integer) 1001
> decr con
(integer) 1000
> decr con
(integer) 999
> decr con
(integer) 998
> decrby con 10
(integer) 988
> decrby con 100
(integer) 888
It is also possible to increment the number contained inside a key by a specific amount:
INCRBY connections 100 => 101
And there are similar commands in order to decrement the value of the key.
DECR connections => 100
DECRBY connections 10 => 90
When you manipulate Redis strings with incrementing and decrementing commands, you are implementing counters. Counters are a very popular application for Redis.
There is something special about INCR. Why do we provide such an operation if we can do it ourself with a bit of code? After all it is as simple as:
x = GET count
x = x + 1
SET count x
The problem is that doing the increment in this way will only work as long as there is a single client using the key. See what happens if two clients are accessing this key at the same time:
Client A reads count as 10.
Client B reads count as 10.
Client A increments 10 and sets count to 11.
Client B increments 10 and sets count to 11.
We wanted the value to be 12, but instead it is 11! This is because incrementing the value in this way is not an atomic operation. Calling the INCR command in Redis will prevent this from happening, because it is an atomic operation.
All the Redis operations implemented by single commands are atomic, including the ones operating on more complex data structures. So when you use a Redis command that modifies some value, you don't have to think about concurrent access.
Redis can be told that a key should only exist for a certain length of time. This is accomplished with the EXPIRE and TTL commands, and by the similar PEXPIRE and PTTL commands that operate using time in milliseconds instead of seconds.
The
EXPIREcommand sets a key to expire after a specified number of seconds.The
TTLcommand is used to check how many seconds remain until a key expires. If the key no longer exists, it returns -2, and if the key will never expire, it returns -1.PERSISTcommand is used to cancel the expiration of a key, making it permanent. This can be useful when you want to retain a key indefinitely after initially setting it to expire.
I will add some more Redis complex commands in my next blog.
If you find the blog helpful, please do like it and share it with your friends. If you have any doubts or questions related to the topics covered in the blog, feel free to ask them in the comments section. I'll be more than happy to help! 😊👍👥