La compatibilité de Python 2 n'est plus assurée par la communauté. Nous vous recommandons de migrer les applications Python 2 vers Python 3.

Migrer Memcache vers Memorystore

Memcache est un magasin de données en mémoire distribué et intégré à l'environnement d'exécution Python 2. De nombreuses applications App Engine utilisent Memcache comme cache pour des tâches spécifiques au lieu de s'appuyer uniquement sur le stockage persistant. Les services groupés tels que Memcache ne sont pas disponibles dans les environnements d'exécution App Engine les plus récents, y compris l'environnement d'exécution Python 3.

Si votre application Python 2 utilise explicitement Memcache, vous devez migrer vers une autre solution de mise en cache pour pouvoir l'exécuter dans un environnement Python 3. Nous vous recommandons d'utiliser Memorystore pour Redis en tant que service de mise en cache. Notez que, contrairement à Memcache, Memorystore pour Redis ne propose pas de version gratuite. Pour en savoir plus, consultez la page Tarifs de Memorystore.

Avant de commencer, assurez-vous que votre application reste dans les quotas attribués à Memorystore pour Redis.

Si vous mettez en cache les données uniquement pour accélérer Cloud NDB, suivez les instructions du Guide de migration Cloud NDB.

Comprendre les autorisations de Memorystore

Chaque interaction avec un service Google Cloud doit être autorisée. Par exemple, pour interagir avec une base de données Redis hébergée par Memorystore, votre application doit fournir les identifiants d'un compte autorisé à accéder à Memorystore.

Par défaut, votre application fournit les identifiants du compte de service App Engine par défaut, autorisé à accéder aux bases de données du même projet que votre application.

Si l'une des conditions suivantes est remplie, vous devez utiliser une autre technique d'authentification qui fournit explicitement des identifiants :

  • Votre application et la base de données Memorystore font partie de différents projets Google Cloud.

  • Vous avez modifié les rôles attribués au compte de service App Engine par défaut.

Pour plus d'informations sur les autres techniques d'authentification, consultez la page Configurer l'authentification pour des applications de production serveur à serveur.

Présentation du processus de migration

Pour migrer votre application Python afin d'utiliser Memorystore au lieu de Memcache, procédez comme suit :

  1. Configurez Memorystore pour Redis. Pour cela, vous devez créer une instance Redis sur Memorystore et un accès au VPC sans serveur qui permettra à votre application de communiquer avec l'instance Redis.

  2. Installez une bibliothèque cliente pour Redis et mettez en cache les données à l'aide des commandes Redis.

    Memorystore pour Redis est compatible avec n'importe quelle bibliothèque cliente pour Redis. Ce guide explique comment envoyer des commandes Redis depuis votre application à l'aide de la bibliothèque clienteredis-py 3.0.

  3. Testez vos mises à jour.

  4. Déployez l'application sur App Engine.

Configurer Memorystore pour Redis

Pour configurer Memorystore pour Redis :

  1. Créez une instance Redis dans Memorystore.

    Lorsque vous êtes invité à sélectionner une région pour votre instance Redis, sélectionnez la même région que celle dans laquelle se trouve votre application App Engine.

  2. Prenez note de l'adresse IP et du numéro de port de l'instance Redis que vous créez. Vous utiliserez ces informations au moment de créer un client Redis dans votre code.

  3. Associez votre App Engine à un réseau VPC. Votre application ne peut communiquer avec Memorystore que via un connecteur VPC.

    Veillez à ajouter les informations de connexion VPC à votre fichier app.yaml comme décrit dans la section Configurer une application pour utiliser un connecteur.

Installer les dépendances

Pour que la bibliothèque cliente redis-py soit disponible pour votre application lorsqu'elle s'exécute dans App Engine, procédez comme suit :

  1. Ajoutez la ligne suivante au fichier requirements.txt de votre application :

     redis == 3.3.11
    

    Nous vous recommandons d'utiliser la version 3.3.11, car elle est compatible avec les applications Python 2.7.

  2. Si vous continuez d'exécuter votre application dans l'environnement d'exécution Python 2 :

    1. Utilisez pip (version 6 ou ultérieure) avec l'option -t <directory> pour installer les bibliothèques dans un dossier local nommé lib. Exemple :

      pip install -t lib -r requirements.txt

    2. Assurez-vous que le fichier appengine_config.py de l'application spécifie bien le répertoire lib.

    App Engine importe toutes les bibliothèques dans le répertoire que vous avez spécifié dans le fichier appengine_config.py. Pour en savoir plus, consultez la page Utiliser les bibliothèques Python 2.

L'environnement d'exécution Python 3 d'App Engine importe automatiquement toutes les bibliothèques figurant dans le fichier requirements.txt au moment du déploiement de l'application.

Pour le développement local, nous vous recommandons d'installer des dépendances dans un environnement virtuel tel que virtualenv pour Python 2 ou venv pour Python 3.

Créer un client Redis

Pour interagir avec une base de données Redis, votre code doit créer un client Redis qui gèrera la connexion à votre base de données Redis. Les sections suivantes décrivent la création d'un client Redis à l'aide de la bibliothèque cliente redis-py.

Spécifier des variables d'environnement

La bibliothèque cliente redis-py utilise deux variables d'environnement pour assembler l'URL de votre base de données Redis :

  • Une variable permettant d'identifier l'adresse IP de la base de données Redis que vous avez créée dans Memorystore.
  • Une variable permettant d'identifier le numéro de port de la base de données Redis que vous avez créée dans Memorystore.

Nous vous recommandons de définir ces variables dans le fichier app.yaml de votre application au lieu de les définir directement dans votre code. Cela facilitera l'exécution de votre application dans différents environnements, tels qu'un environnement local et App Engine.

Par exemple, ajoutez les lignes suivantes à votre fichier app.yaml :

 env_variables:
      REDISHOST: '10.112.12.112'
      REDISPORT: '6379'

Importer redis-py et créer le client

Après avoir défini les variables d'environnement REDISHOST et REDISPORT, utilisez les lignes suivantes pour importer la bibliothèque redis-py et créer un client :

  import redis

  redis_host = os.environ.get('REDISHOST', 'localhost')
  redis_port = int(os.environ.get('REDISPORT', 6379))
  redis_client = redis.Redis(host=redis_host, port=redis_port)

Si vous avez utilisé une version plus ancienne de redis-py pour d'autres applications, il est possible que vous ayez utilisé la classe StrictClient au lieu de Client. Cependant, redis-py recommande désormais d'utiliser Client au lieu de StrictClient.

Utiliser les commandes Redis pour stocker et récupérer des données dans le cache

Bien que la base de données Redis Memorystore soit compatible avec la plupart des commandes Redis, vous n'avez besoin que de quelques commandes pour stocker et récupérer des données à partir du cache. Le tableau suivant suggère des commandes Redis que vous pouvez utiliser pour mettre en cache des données. Pour savoir comment appeler ces commandes depuis votre application, consultez la documentation de votre bibliothèque cliente.

Bien que Memcache propose des alternatives asynchrones pour la plupart de ses commandes, il est à noter que la bibliothèque cliente redis-py ne fournit pas toujours de méthodes asynchrones équivalentes. Si vous souhaitez que toutes les interactions avec le cache soient asynchrones, il existe d'autres bibliothèques clientes Redis pour Python.
Tâche Commande Redis
Créer une entrée dans le cache de données et
définir un délai d'expiration pour l'entrée
SETNX
MSETNX
Récupérer les données du cache GET
MGET
Remplacer les valeurs de cache existantes SET
MSET
Augmenter ou diminuer les valeurs du cache numérique INCR
INCRBY
DECR
DECRBY
Supprimer les entrées du cache DEL
UNLINK
Accepter les interactions simultanées avec le cache ("compare and set") Consultez les informations relatives aux transactions avec Redis. Notez que la bibliothèque cliente redis-py exige que toutes les transactions aient lieu dans un pipeline.

Tester vos mises à jour

Lorsque vous testez votre application en local, songez à exécuter une instance locale de Redis pour éviter toute interaction avec les données de production (Memorystore ne fournit pas d'émulateur). Pour installer et exécuter Redis en local, suivez les instructions de la documentation Redis. Il est actuellement impossible d'exécuter Redis en local sous Windows.

Pour en savoir plus sur les tests des applications Python 2, consultez la page Utiliser le serveur de développement local.

Déployer l'application

Une fois que votre application est exécutée sur le serveur de développement local sans erreur :

  1. Testez l'application sur App Engine.

  2. Si l'application s'exécute sans erreur, répartissez le trafic pour augmenter lentement le trafic de votre application mise à jour. Surveillez attentivement les éventuels problèmes de base de données avant d'acheminer davantage de trafic vers l'application mise à jour.