# This file specifies files that are *not* uploaded to Google Cloud Platform

# using gcloud. It follows the same syntax as .gitignore, with the addition of

# "#!include" directives (which insert the entries of the given .gitignore-style

# file at that point).

#

# For more information, run:

# $ gcloud topic gcloudignore

#

.gcloudignore

# If you would like to upload your .git directory, .gitignore file or files

# from your .gitignore file, remove the corresponding line

# below:

.git

.gitignore

# Python pycache:

__pycache__/

# Ignored by the build system

/setup.cfg

[![Open in Cloud Shell][shell_img]][shell_link]

[shell_img]: http://gstatic.com/cloudssh/images/open-btn.png

[shell_link]: https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/GoogleCloudPlatform/python-docs-samples&page=editor&open_in_editor=appengine/standard/migration/memorystore/README.md

This is a sample app for Google App Engine that demonstrates how to replace

use of the [Memcache API](https://cloud.google.com/appengine/docs/standard/python/memcache)

with the [Memorystore for Redis offering](https://cloud.google.com/memorystore).

This newer library can be used on App Engine with either Python 2.7

or Python 3.

Code taken from the [Memcache sample](https://github.com/GoogleCloudPlatform/python-docs-samples/blob/master/appengine/standard/memcache/snippets/snippets.py)

is included in this new sample, with each line commented out with two # marks.

This allows the older solution's approach to be contrasted with the

Memorystore for Redis approach.

Prior to deploying this sample, a

[serverless VPC connector](https://cloud.google.com/vpc/docs/configure-serverless-vpc-access)

must be created and then a

[Memorystore for Redis instance](https://cloud.google.com/memorystore/docs/redis/quickstart-console)

on the same VPC. The IP address and port number of the Redis instance, and

the name of the VPC connector should be entered in either app.yaml

(for Python 2.7) or app3.yaml (for Python 3).

To deploy and run this sample in App Engine standard for Python 2.7:

pip install -t lib -r requirements.txt

gcloud app deploy

To deploy and run this sample in App Engine standard for Python 3.7:

gcloud app deploy app3.yaml

runtime: python27

api_version: 1

threadsafe: yes

handlers:

- url: .*

script: main.app

libraries:

- name: setuptools

version: 36.6.0

- name: grpcio

version: 1.0.0

env_variables:

REDISHOST: '<REDIS_HOST>'

REDISPORT: '<REDIS_PORT>'

vpc_access_connector:

name: 'projects/<PROJECT_ID>/locations/<REGION>/connectors/<CONNECTOR_NAME>'

runtime: python38

env_variables:

REDISHOST: '<REDIS_HOST>'

REDISPORT: '<REDIS_PORT>'

vpc_access_connector:

name: 'projects/<PROJECT_ID>/locations/<REGION>/connectors/<CONNECTOR_NAME>'

import pkg_resources

from google.appengine.ext import vendor

path = 'lib'

vendor.add(path)

pkg_resources.working_set.add_entry(path)

import os

import redis

import time

from flask import Flask, redirect, render_template, request

redis_host = os.environ.get('REDIS_HOST', 'localhost')

redis_port = os.environ.get('REDIS_PORT', '6379')

client = redis.Redis(host=redis_host, port=redis_port)

def query_for_data():

# Add artificial delay so user can see when cache has been used

time.sleep(5)

return 'prestored value'

def get_data(cache_key):

## data = memcache.get('key')

data = client.get(cache_key)

if data is not None:

return data.decode()

else:

data = query_for_data()

## memcache.add('key', data, 60)

client.set(cache_key, data, ex=60)

return data

def add_values(values, expires=3600):

# Add a value if it doesn't exist in the cache

# with a cache expiration of 1 hour.

## memcache.add(key="weather_USA_98105", value="raining", time=3600)

## # Remove one of the values and set by itself first

## first_key = values.keys()[0]

## first_value = values[first_key]

## del values[first_key]

## memcache.add(first_key, first_value, ex=expires)

##

## # Set several values, overwriting any existing values for these keys.

## memcache.set_multi(

## {"USA_98115": "cloudy", "USA_94105": "foggy", "USA_94043": "sunny"},

## key_prefix="weather_",

## time=3600

## )

# Redis mset is similar to memcache.set_multi, but cannot set expirations

client.mset(values)

# Rather than set expiration with separate operations for each key, batch

# them using pipeline

with client.pipeline() as pipe:

for name in values:

pipe.pexpire(name, expires * 1000) # Time in milliseconds

pipe.execute()

def increment_counter(name, expires=60, value=0):

# Atomically increment an integer value.

## memcache.set(key="counter", value=0)

client.set(name, value, ex=expires)

## memcache.incr("counter")

client.incr(name)

## memcache.incr("counter")

client.incr(name)

## memcache.incr("counter")

client.incr(name)

app = Flask(__name__)

def home():

return render_template('index.html')

def showdata():

data = get_data('data')

values = {}

for key in client.keys():

if key == 'data':

next

values[key.decode()] = client.get(key).decode()

return render_template('showdata.html', data=data, values=values)

def savedata():

key = request.form['key']

value = request.form['value']

add_values({key: value})

if key == 'counter':

increment_counter('counter', expires=60, value=value)

return redirect('/')

if __name__ == '__main__':

# This is used when running locally.

app.run(host='127.0.0.1', port=8080, debug=True)

from mock import patch

import pytest

import redis

import uuid

import main

KEY_PREFIX = str(uuid.uuid4()) # Avoid interfering with other tests

TEST_VALUES = {

KEY_PREFIX + "weather_USA_98105": "raining",

KEY_PREFIX + "weather_USA_98115": "cloudy",

KEY_PREFIX + "weather_USA_94105": "foggy",

KEY_PREFIX + "weather_USA_94043": "sunny",

}

def test_get_data_not_present(query_fn, testbed):

try:

main.client.set(KEY_PREFIX + 'counter', '0', 9000)

except redis.RedisError:

pytest.skip('Redis is unavailable')

data = main.get_data(KEY_PREFIX + 'key')

query_fn.assert_called_once_with()

assert data == 'data'

assert 'data' == main.client.get(KEY_PREFIX + 'key')

main.client.delete(KEY_PREFIX + 'key')

def test_get_data_present(query_fn, testbed):

try:

main.client.set(KEY_PREFIX + 'key', 'data', 9000)

except Exception:

pytest.skip('Redis is unavailable')

data = main.get_data()

query_fn.assert_not_called()

assert data == 'data'

main.client.delete(KEY_PREFIX + 'key')

def test_add_values(testbed):

try:

main.client.set(KEY_PREFIX + 'counter', '0', 9000)

except Exception:

pytest.skip('Redis is unavailable')

main.add_values(TEST_VALUES)

for key, value in TEST_VALUES.iteritems():

assert main.client.get(key) == value

assert main.client.get(KEY_PREFIX + 'counter') == 3

pytest==4.6.11; python_version < '3.0'

mock==3.0.5

<title>Memorystore Example</title>

<h1>Memorystore Example</h1>

<p>

The <a href="/showdata">following page</a> will display stored

data. The first time it is displayed it will fetch the value of

"data" from a slow store. Future refreshes will fetch it from cache

until it expires (60 seconds in this example).

</p>

<p>

Other values will be fetched only from the cache, if present. Values

can be stored in the cache by entering them in the form.

</p>

</html >

<title>Stored Data</title>

<h1>Stored Data</h1>

<p>

The value of "data" is {{ data }}.

</p>

<p>

<ul>

{% for key, value in values.items() %}

<li>The value of "{{ key }}" is "{{ value }}".</li>

{% endfor %}

</ul>

</p>

<form action="/showdata" method="post">

<div>

Add another entry name <input type="text" name="key" id="key" />

with value <input type="text" name="value" id="value" />. Note, any

value named "counter" will be incremented three times after storing.

</div>

<div>

<input type="submit" value="Store New Entry" />

</div>

</form>

</html >