Speeding up Existing Apps with a Redis Cache

Redis accelerates existing applications: cache queries and reduces server load

Core points:

• Redis effectively accelerates existing applications by caching query results, thereby reducing server pressure. It stores query results for a specified time (for example, 24 hours), and then reuses these results, significantly improving application speed.
• The installation of Redis can be completed through the operating system package manager or manually. The installation process includes avoiding common warnings and ensuring that Redis starts automatically after the server restarts.
• The Predis library works with Redis to provide a memory cache layer for applications. This process involves checking whether the results of the current query exist in the cache, fetching the results if they do not exist, and storing them for future use.
• To further improve performance, Predis recommends installing phpiredis, a PHP extension that reduces the overhead of Redis protocol serialization and parsing, making Redis installation faster.

We have introduced the basics of Redis in PHP before, but now it is time to introduce a practical application case. In this tutorial, we add it to the deployed application to improve application speed.

You can clone version 0.6 of the application to learn easily.

Problem description:

Before applying the solution, we need to clarify the problem definition.

The application in question accesses Diffbot's API and querys the dataset when executing a query. Then return and display the subset. This can take about 5 seconds, depending on how busy the Diffbot server is. Although this will undoubtedly improve as they expand their computing power, it would be great if the query results that were executed once were remembered and reused for 24 hours, because the set itself is only updated so frequently.

You might be thinking: "What are the benefits of caching a single query?" Most people don't search for the same content often.

In fact, research shows that people often search for the same content (React popular? "react" queries suddenly increase), and they will also search for well-known authors (or themselves). Given that implementing this cache costs almost nothing (actually by reducing the cost by reducing server pressure), adding it is a simple win, even if it is not used as frequently as you would like. No reason not to add it—It can only be in our favor.

When we clearly define the problem, let's deal with the prerequisites.

Installation:

First of all, we need to install Redis into the development and production environment (note that if you use Homestead in local development, Redis is already installed, but at the time of writing, version 3.0.1).

We can do this through the operating system's package manager:

sudo apt-get install redis-server

This is the easiest and recommended method, but we can also install it from scratch and configure it manually. According to the instructions on their website, it can be done by:

sudo apt-get install gcc make build-essential tcl
wget http://download.redis.io/releases/redis-3.0.2.tar.gz
tar xzf redis-3.0.2.tar.gz
cd redis-3.0.2
make
make test
sudo make install

If you encounter a fatal error mentioning jemalloc.h after running make , just run make distclean and run make again. The make test command is optional, but it is helpful.

Note: If you are reading this article and version 3.0.2 is no longer the latest, just adjust the command to the latest version number.

To prevent some common warnings (at least on Ubuntu), we also preventively run the following command:

sudo sh -c 'echo "vm.overcommit_memory=1" >> /etc/sysctl.conf'
sudo sh -c 'echo "net.core.somaxconn=65535" >> /etc/sysctl.conf'
sudo sh -c 'echo "never" > /sys/kernel/mm/transparent_hugepage/enabled'

We also make sure to add the last command to /etc/rc.local, right above exit 0, so that it can be re-executeed every time the server restarts. Finally, we can restart the server using sudo reboot and check if Redis is running properly by running sudo redis-server.

Finally, we need to make sure Redis starts automatically after the server restarts, so we will do this as per the official instructions.

Predis:

We have covered the basics of Predis before, and in this case we will use it as well. Let's install it using the following command:

composer require predis/predis

Next, let's assume that we have mastered the aforementioned introduction to Predis.

Since that post was published, some slight differences were introduced (such as the transition to namespaces), but the API we need to use is roughly the same.

Implementation:

In order to use Redis in our application, we need to follow the following steps:

• View whether the current query results exist in the cache
• If it exists, get the result
• If it does not exist, get the result, store the result, and forward the result to the rest of the application

Therefore, the implementation is very simple: under the "Form Submit" check (the one that looks for the "search" parameter), we instantiate the Predis client, calculate the md5 hash of the executed search query, and then check if its results are checked. Cachedated. If false, the previous process continues, but will not be:

$result = ...
$info = ...

ends, but directly serializes the result and saves it to cache. Then, outside of the code block, we get the results from the cache, and the application's flow continues as usual. Therefore, the changed part in the index.php file looks like this:

// 检查是否提交了搜索表单
if (isset($queryParams['search'])) {

    $redis = new Client();
    $hash = md5($_SERVER['QUERY_STRING']);
    if (!$redis->get($hash . '-results')) {

        $diffbot = new Diffbot(DIFFBOT_TOKEN);

        // 构建搜索字符串
        $searchHelper = new SearchHelper();
        $string = (isset($queryParams['q']) && !empty($queryParams['q']))
            ? $queryParams['q']
            : $searchHelper->stringFromParams($queryParams);

        // 基础设置
        $search = $diffbot
            ->search($string)
            ->setCol('sp_search')
            ->setStart(($queryParams['page'] - 1) * $resultsPerPage)
            ->setNum($resultsPerPage);

        $redis->set($hash . '-results', serialize($search->call()));
        $redis->expire($hash . '-results', 86400);
        $redis->set($hash . '-info', serialize($search->call(true)));
        $redis->expire($hash . '-info', 86400);
    }

    $results = unserialize($redis->get($hash . '-results'));
    $info = unserialize($redis->get($hash . '-info'));
}

After the test, we can see that it works well - if we refresh the page or execute another query and then return to the previous query, the query executed once is instant. Finally, we can add, submit and push for deployment:

git add -A
git commit -m "Added Redis cache [deploy:production]"
git push origin master

That's it! The latest version of our application is now available and Redis is providing cached data.

Note: If you want to know how we switch from development mode to production deployment with a single commit, you should read this article.

Fine-tuning:

To further improve performance, Predis recommends installing phpiredis, a PHP extension for "Reduce the overhead of Redis protocol serialization and parsing ". Since we have complete control of the server, why not do this?

sudo apt-get install redis-server

This installs prerequisites and enables extensions. Now all we have to do is configure the Predis client to use the phpiredis connection. We need to replace:

sudo apt-get install gcc make build-essential tcl
wget http://download.redis.io/releases/redis-3.0.2.tar.gz
tar xzf redis-3.0.2.tar.gz
cd redis-3.0.2
make
make test
sudo make install

is:

sudo sh -c 'echo "vm.overcommit_memory=1" >> /etc/sysctl.conf'
sudo sh -c 'echo "net.core.somaxconn=65535" >> /etc/sysctl.conf'
sudo sh -c 'echo "never" > /sys/kernel/mm/transparent_hugepage/enabled'

That's it! Our Redis installation is faster now!

Conclusion:

In this tutorial, we use the Redis and Predis libraries in combination to make deployed applications look faster. Instead of transferring to and from its source, we use the available RAM of the DigitalOcean droplet to save the results of the query once a day and then return these results from the cache. This means the results are not always up to date, but according to this post, the results themselves are not updated more frequently than this.

Hopefully this tutorial shows you how easy it is to add a memory cache layer to your application, and it will be very useful when you need to reduce loading time and reduce server costs.

Any other suggestions? Skill? Comment? Please leave a message below!

(The FAQ part is omitted here because the content of the FAQ part is duplicated with the main content of the article, which is redundant information. Pseudo-originality should avoid duplicate content.)

The above is the detailed content of Speeding up Existing Apps with a Redis Cache. For more information, please follow other related articles on the PHP Chinese website!