Notice: Over the next few months, we're reorganizing the App Engine documentation site to make it easier to find content and better align with the rest of Google Cloud products. The same content will be available, but the navigation will now match the rest of the Cloud products.

PHP 8.1 is now generally available.

Caching data with Memorystore

Stay organized with collections Save and categorize content based on your preferences.

High performance scalable web applications often use a distributed in-memory data cache in front of or in place of robust persistent storage for some tasks. We recommend using Memorystore for Redis as your caching service. Note that Memorystore for Redis does not provide a free tier. See Memorystore Pricing for details.

Before getting started, make sure your app will stay within the Memorystore for Redis quotas.

When to use a memory cache

Session data, user preferences, and other data returned by queries for web pages are good candidates for caching. In general, if a frequently run query returns a set of results that do not need to appear in your app immediately, you can cache the results. Subsequent requests can check the cache and only query the database if the results are absent or have expired.

If you store a value only in Memorystore without backing it up in persistent storage, be sure that your application behaves acceptably if the value expires and is removed from the cache. For example, if the sudden absence of a user's session data would cause the session to malfunction, that data should probably be stored in the database in addition to Memorystore.

Understanding Memorystore permissions

Every interaction with a Google Cloud service needs to be authorized. For example, to interact with a Redis database hosted by Memorystore, your app needs to supply the credentials of an account that is authorized to access Memorystore.

By default your app supplies the credentials of the App Engine default service account, which is authorized to access databases in the same project as your app.

If any of the following conditions are true, you need to use an alternative authentication technique that explicitly provides credentials:

  • Your app and the Memorystore database are in different Google Cloud projects.

  • You have changed the roles assigned to the default App Engine service account.

For information about alternative authentication techniques, see Setting up Authentication for Server to Server Production Applications.

Overview of using Memorystore

To use Memorystore in your app:

  1. Set up Memorystore for Redis, which requires you to create a Redis instance on Memorystore and create a Serverless VPC Access that your app uses to communicate with the Redis instance.

  2. Install a client library for Redis and use Redis commands to cache data.

    Memorystore for Redis is compatible with any client library for Redis. This guide describes using the PHPRedis client library to send Redis commands from your app.

  3. Test your updates.

  4. Deploy your app to App Engine.

Setting up Memorystore for Redis

To set up Memorystore for Redis:

  1. Create a Redis instance in Memorystore.

    When prompted to select a region for your Redis instance, select the same region in which your App Engine app is located.

  2. Note the IP address and port number of the Redis instance you create. You will use this information when you create a Redis client in your code.

  3. Connect your App Engine to a VPC network. Your app can only communicate with Memorystore through a VPC connector.

    Be sure to add the VPC connection information to your app.yaml file as described in Configuring your app use the connector.

Installing dependencies

To make the PHPRedis client library available to your app when it runs in App Engine, add the extension to your app's php.ini file. For example:
; Enable the Redis extension on App Engine

For more information about enabling PHP extensions in App Engine, see Dynamically loadable extensions.

Creating a Redis client

To interact with a Redis database, your code needs to create a Redis client to manage the connection to your Redis database. The following sections describe creating a Redis client using the PHPRedis client library.

Specifying environment variables

The PHPRedis client library uses two environment variables to assemble the URL for your Redis database:

  • A variable to identify the IP address of the Redis database you created in Memorystore.
  • A variable to identify the port number of the Redis database you created in Memorystore.

We recommend you define these variables in your app's app.yaml file instead of defining them directly in your code. This makes it easier to run your app in different environments, such as a local environment and App Engine.

For example, add the following lines to your app.yaml file:

      REDIS_HOST: ''
      REDIS_PORT: '6379'

Importing PHPRedis and creating the client

After you've defined the REDIS_HOST and REDIS_PORT environment variables, you can use the following lines to create a Redis client:

 * Copyright 2019 Google Inc.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * See the License for the specific language governing permissions and
 * limitations under the License.

// Only serve traffic from "/"
switch (@parse_url($_SERVER['REQUEST_URI'])['path']) {
    case '/':
        exit('Not Found');

// Connect to Memorystore from App Engine.
if (!$host = getenv('REDIS_HOST')) {
    throw new Exception('The REDIS_HOST environment variable is required');

# Memorystore Redis port defaults to 6379
$port = getenv('REDIS_PORT') ?: '6379';

try {
    $redis = new Redis();
    $redis->connect($host, $port);
} catch (Exception $e) {
    return print('Error: ' . $e->getMessage());

$value = $redis->incr('counter');

printf('Visitor number: %s', $value);

Using Redis commands to store and retrieve data in the cache

While the Memorystore Redis database supports most Redis commands, you only need to use a few commands to store and retrieve data from the cache. The following table suggests Redis commands you can use to cache data. To see how to call these commands from your app, view your client library's documentation.

Task Redis command
Create an entry in the data cache and
set an expiration time for the entry
Retrieve data from the cache GET
Replace existing cache values SET
Increment or decrement numeric cache values INCR
Delete entries from the cache DEL
Support concurrent interactions with the cache See details about Redis transactions.

Testing your updates

When you test your app locally, consider running a local instance of Redis to avoid interacting with production data (Memorystore doesn't provide an emulator). To install and run Redis locally, follow the directions in the Redis documentation. Note that it currently isn't possible to run Redis locally on Windows.

Deploying your app

Once your app is running in the local development server without errors:

  1. Test the app on App Engine.

  2. If the app runs without errors, use traffic splitting to slowly ramp up traffic for your updated app. Monitor the app closely for any database issues before routing more traffic to the updated app.