DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports
Events Video Library
Refcards
Trend Reports

Events

View Events Video Library

Zones

Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks

Generative AI has transformed nearly every industry. How can you leverage GenAI to improve your productivity and efficiency?

SBOMs are essential to circumventing software supply chain attacks, and they provide visibility into various software components.

Related

  • Building an SQL to DataFrame Converter With ANTLR
  • Master SQL Performance Optimization: Step-by-Step Techniques With Case Studies
  • MySQL Formatter: How to Make Beautiful Code and Why You Need It
  • Useful System Table Queries in Relational Databases

Trending

  • Building an AI Nutrition Coach With OpenAI, Gradio, and gTTS
  • Contract-Driven ML: The Missing Link to Trustworthy Machine Learning
  • Stop Prompt Hacking: How I Connected My AI Agent to Any API With MCP
  • The Invisible Risk in Your Middleware: A Next.js Flaw You Shouldn’t Ignore
  1. DZone
  2. Data Engineering
  3. Databases
  4. Redis vs. MySQL Benchmarks

Redis vs. MySQL Benchmarks

We take a comparative look at these two popular database options, pitting NoSQL and SQL databases against each other yet again.

By 
Ayush Jain user avatar
Ayush Jain
·
Updated Jul. 16, 19 · Tutorial
Likes (4)
Comment
Save
Tweet
Share
59.8K Views

Join the DZone community and get the full member experience.

Join For Free

In this article, we will be discussing the performance benchmarks of Redis and MySQL. We will start with the introduction and installation of Redis over Ubuntu. Then we will move towards the benchmarking between these two.

Image title

Introduction to Redis

According to the official website, Redis is an open source (BSD licensed), in-memory data structure store used as a database, cache, and message broker. Actually, Redis is an advanced key-value store. It is super fast with amazingly high throughput, as it can perform approximately 110000 SETs per second, about 81000 GETs per second. It also supports a very rich set of data types to store. As a matter of fact, Redis keeps the data in-memory every time, but also persistent on-disk. So, it comes with a trade-off: Amazing speed with a size limit on datasets (as per memory). In this article, to have some benchmarks in comparison to MySQL, we will be using Redis as a caching engine only.

Prerequisites

  • PHP installed/configured on your machine, if not, go here: How To Install PHP on Ubuntu 16.04
  • MySQL installed/configured on your machine, if not, go here: How To Install MySQL on Ubuntu 16.04

Installation of Redis on Ubuntu

To start with, run the following commands:

 sudo apt update  
 sudo apt install redis-server

These commands would update the apt package and install Redis on your Ubuntu machine.

Now, as a matter of fact, to enable Redis being used as a service, you need to configure it by updating the supervised directive present inside the configuration file of Redis. You can easily find the configuration file here:

 sudo vi /etc/redis/redis.conf

By default, the supervised directive is set to "no." You need to set it to: systemd. After updating, this section of the configuration file will look like something similar to this:

################################# GENERAL #####################################  
 # By default Redis does not run as a daemon. Use 'yes' if you need it.  
 # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.  
 daemonize yes  
 # If you run Redis from upstart or systemd, Redis can interact with your  
 # supervision tree. Options:  
 #  supervised no   - no supervision interaction  
 #  supervised upstart - signal upstart by putting Redis into SIGSTOP mode  
 #  supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET  
 #  supervised auto  - detect upstart or systemd method based on  
 #            UPSTART_JOB or NOTIFY_SOCKET environment variables  
 # Note: these supervision methods only signal "process is ready."  
 #    They do not enable continuous liveness pings back to your supervisor.  
 supervised systemd  
 # If a pid file is specified, Redis writes it where specified at startup  
 # and removes it at exit.  
 #  
 # When the server runs non daemonized, no pid file is created if none is  
 # specified in the configuration. When the server is daemonized, the pid file  
 # is used even if not specified, defaulting to "/var/run/redis.pid".  
 #  
 # Creating a pid file is best effort: if Redis is not able to create it  
 # nothing bad happens, the server will start and run normally.  
 pidfile /var/run/redis/redis-server.pid  
 # Specify the server verbosity level.  
 # This can be one of:  
 # debug (a lot of information, useful for development/testing)  
 # verbose (many rarely useful info, but not a mess like the debug level)  
 # notice (moderately verbose, what you want in production probably)

Enabling Password Authentication:

Configuring the Redis with password authentication is not mandatory, but it is super important (and easy too), as it enables the security factor over Redis. Configuring our Redis server with the password is super easy and can be done through the same configuration file as mentioned above. So, open the configuration file and look for requirepass directive. You would that line is commented by default, just uncomment that and enter your password there. The configuration file would look similar to this:

# Require clients to issue AUTH <PASSWORD> before processing any other  
 # commands. This might be useful in environments in which you do not trust  
 # others with access to the host running redis-server.  
 #  
 # This should stay commented out for backward compatibility and because most  
 # people do not need auth (e.g. they run their own servers).  
 #  
 # Warning: since Redis is pretty fast an outside user can try up to  
 # 150k passwords per second against a good box. This means that you should  
 # use a very strong password otherwise it will be very easy to break.  
 requirepass yourpasswordhere  
 # Command renaming.  
 #  
 # It is possible to change the name of dangerous commands in a shared  
 # environment. For instance the CONFIG command may be renamed into something  
 # hard to guess so that it will still be available for internal-use tools  
 # but not available for general clients.  
 #  
 # Example:  
 #  
 # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52

Save this file now, and to have the changes reflected over Redis, restart the Redis Service by using the following command:

 sudo systemctl restart redis.service

Installation of PHPRedis over Ubuntu:

Now, to enable your PHP code to use Redis as a service:

  • Run the following command to install PHPRedis extension:
sudo apt-get install php-redis
  • Add the following line to your php.ini file:
extension=redis.so

Workflow

  • With MySQL Only:
    • Randomly generate a key between [1, 10000] and search for that key in MySQL database
    • Would take the note of the time it has taken to do so
    • Would take the time sample to process n number of such requests while increasing n gradually as 1, 10, 100, 1000, 10000, 100000, 1000000, 1000000
  • With MySQL and Redis:
    • Randomly generate a key between [1, 10000]
    • Would check if that key is already present/stored on our Redis
      • If it is present on Redis, we would not hit MySQL
      • If it is not present on Redis, we would search for that key on our MySQL database and store that key to Redis
    • Would take the note of the time it has taken to do so
    • Would take the time sample to process n number of such requests while increasing n gradually as 1, 10, 100, 1000, 10000, 100000, 1000000, 1000000

Source Code

MySQL Only Source Code

(When we try to fetch a key from MySQL only):

<?php  
 $con = mysqli_connect("localhost","root","admin","blog_db");  
 for($i = 1; $i <= 10000000; $i = $i *10) {       
      $startTime = microtime(true);  
      for($j = 1; $j <= $i; $j++) {  
           $rand = rand(1, 100000);  
           $sql = "SELECT VALUE from data WHERE `key` = $rand";            
           if (!mysqli_query($con, $sql)) {  
             echo "Error: " . $sql . "" . mysqli_error($con);  
           }  
      }  
 $endTime = microtime(true);  
 file_put_contents('/home/ayush/Desktop/temp/blog/mysqlonly.log', $i . ',' . ($endTime - $startTime) . "\n" , FILE_APPEND);  
 }

MySQL and Redis Source Code

(When we try to fetch a key from Redis first and then from MySQL if we are unable to find that key on Redis):

<?php  
 $con = mysqli_connect("localhost","root","admin","blog_db");  
 $client = new Redis();  
 $client->connect('localhost');  
 for($i = 1; $i <= 10000000; $i = $i *10) {  
      $startTime = microtime(true);  
      for($j = 1; $j <= $i; $j++) {  
           $rand = rand(1, 100000);  
           if(!$client->exists($rand)) {  
                $client->set($rand, $rand);  
                $sql = "SELECT VALUE from data WHERE `key` = $rand";            
                if (!mysqli_query($con, $sql)) {  
                  echo "Error: " . $sql . "" . mysqli_error($con);  
                }  
           }   
      }  
      $endTime = microtime(true);  
      file_put_contents('/home/ayush/Desktop/temp/blog/redis.log', $i . ',' . ($endTime - $startTime) . "\n" , FILE_APPEND);  
      $client->flushAll();  
 }

BenchMarks

Tabular Data


Tabular Data : Redis vs MySQL Benchmark

Graphical Representation

Graphical Representation : Redis vs MySQL Benchmark

Conclusion

As it can be easily seen from the graphical representation given above, as the number of requests increases significantly, Redis starts outperforming by a significant margin. Hence, using a caching engine like Redis along with your database is a good idea if the number of requests processed is huge.

References

  • Redis Official Website: Redis.io
  • Redis Installation Guide: How To Install and Secure Redis on Ubuntu 18.04
  • [Suggested Read]: Redis Tutorial
Redis (company) MySQL

Published at DZone with permission of Ayush Jain. See the original article here.

Opinions expressed by DZone contributors are their own.

Related

  • Building an SQL to DataFrame Converter With ANTLR
  • Master SQL Performance Optimization: Step-by-Step Techniques With Case Studies
  • MySQL Formatter: How to Make Beautiful Code and Why You Need It
  • Useful System Table Queries in Relational Databases

Partner Resources

×

Comments

The likes didn't load as expected. Please refresh the page and try again.

ABOUT US

  • About DZone
  • Support and feedback
  • Community research
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Core Program
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 3343 Perimeter Hill Drive
  • Suite 100
  • Nashville, TN 37211
  • [email protected]

Let's be friends: