Utiliser App Engine Memcache dans les applications Flask (module 12)

1. Présentation

La série d'ateliers de programmation Serverless Migration Station (tutoriels pratiques à suivre à votre rythme) et les vidéos associées sont destinées à aider les développeurs Google Cloud sans serveur à moderniser leurs applications en les guidant tout au long d'une ou plusieurs migrations, principalement en les aidant à abandonner les anciens services. Cela rend vos applications plus portables et vous offre plus d'options et de flexibilité, ce qui vous permet de vous intégrer à une plus large gamme de produits Cloud et d'y accéder, et de passer plus facilement aux versions linguistiques plus récentes. Bien qu'elle se concentre initialement sur les premiers utilisateurs de Cloud, principalement les développeurs App Engine (environnement standard), cette série est suffisamment large pour inclure d'autres plates-formes sans serveur comme Cloud Functions et Cloud Run, ou ailleurs si nécessaire.

Cet atelier de programmation vous explique comment inclure et utiliser App Engine Memcache dans l'exemple d'application de l'atelier de programmation du module 1. Dans ce tutoriel du module 12, nous ajoutons l'utilisation de Memcache, puis nous migrons vers Cloud Memorystore dans le module 13.

Vous apprendrez à

  • Utiliser l'API/bibliothèque Memcache d'App Engine
  • Ajouter la mise en cache à une application Python 2 Flask App Engine NDB de base

Prérequis

Enquête

Comment allez-vous utiliser ce tutoriel ?

Je vais le lire uniquement Je vais le lire et effectuer les exercices

Quel est votre niveau d'expérience avec Python ?

Débutant Intermédiaire Expert

Quel est votre niveau d'expérience avec les services Google Cloud ?

Débutant Intermédiaire Expert

2. Arrière-plan

Pour migrer depuis App Engine Memcache, ajoutez son utilisation à l'application Flask et App Engine NDB existante résultant de l'atelier de programmation du module 1. L'application exemple affiche les dix visites les plus récentes de l'utilisateur. Si le même utilisateur actualise son navigateur, il n'est pas optimal de créer continuellement de nouvelles entités "Visite" et d'extraire les visites les plus récentes du Datastore. Nous allons donc mettre en cache ces visites les plus récentes.

Si le même visiteur accède à la page, ces visites sont renvoyées à partir du cache. Si un nouvel utilisateur visite le site ou si une heure s'est écoulée, le cache est vidé et remplacé par les entrées les plus récentes (sans oublier qu'une nouvelle visite est enregistrée). Maintenant que cette intégration App Engine Memcache est implémentée, nous pouvons la migrer vers Cloud Memorystore dans le prochain atelier de programmation (module 13).

Ce tutoriel comprend les étapes suivantes :

  1. Configuration/Préparation
  2. Mettre à jour la configuration
  3. Modifier le code de l'application

3. Configuration/Préparation

Avant de passer à la partie principale de ce tutoriel, nous allons configurer notre projet, obtenir le code et déployer l'application de base pour nous assurer de bien utiliser du code fonctionnel.

1. Configurer le projet

Si vous avez terminé l'atelier de programmation du module 1, nous vous recommandons de réutiliser le même projet (et le même code). Vous pouvez également créer un projet ou réutiliser un autre projet existant. Assurez-vous que le projet dispose d'un compte de facturation actif et qu'App Engine est activé.

2. Obtenir un exemple d'application de référence

L'une des conditions préalables à cet atelier de programmation est de disposer d'un exemple d'application fonctionnel du Module 1. Si vous n'en avez pas, suivez l'un de ces tutoriels (liens ci-dessus) avant de continuer. Si vous connaissez déjà le contenu de ce tutoriel, vous pouvez récupérer le code du module 1 ci-dessous.

Que vous utilisiez votre application ou la nôtre, le code de départ ("START") est celui du module 1. Le présent atelier de programmation vous guide pour chaque étape jusqu'à obtenir un code similaire à celui du dossier du dépôt du module 11 ("FINISH").

Le répertoire des fichiers de départ du module 1 (qu'il s'agisse de votre code ou du nôtre) doit se présenter comme suit :

$ ls
README.md               main.py                 templates
app.yaml                requirements.txt

3. (Re)Déployer l'application de référence

Étapes préliminaires restantes :

  1. Familiarisez-vous avec l'outil de ligne de commande gcloud
  2. Redéployez l'exemple d'application avec gcloud app deploy
  3. Vérifier que l'application s'exécute sans problème sur App Engine

Une fois ces étapes effectuées et que vous avez vérifié que votre application Web fonctionne (avec un résultat semblable à celui ci-dessous), vous êtes prêt à ajouter l'utilisation de la mise en cache à votre application.

a7a9d2b80d706a2b.png

4. Mettre à jour la configuration

Aucune modification n'est nécessaire dans les fichiers de configuration App Engine standards (app.yaml, requirements.txt, appengine_config.py).

5. Modifier les fichiers d'application

Comme nous n'ajoutons qu'une API App Engine, aucun package externe n'est impliqué. Cela signifie qu'aucun fichier de configuration (app.yaml, requirements.txt, appengine_config.py) n'a besoin d'être mis à jour. Il n'y a qu'un fichier d'application, main.py. Par conséquent, toutes les modifications de la présente section s'appliquent uniquement à ce fichier.

Importations

L'étape la plus importante consiste à importer la bibliothèque Memcache, google.appengine.api.memcache. Comme nous allons mettre en cache les visites les plus récentes pendant une heure, ajoutons également une constante pour le nombre de secondes dans une heure. Voici à quoi ressemble votre code avant et après cette modification :

AVANT :

from flask import Flask, render_template, request
from google.appengine.ext import ndb

app = Flask(__name__)

APRÈS :

from flask import Flask, render_template, request
from google.appengine.api import memcache
from google.appengine.ext import ndb

app = Flask(__name__)
HOUR = 3600

Ajouter la mise en cache avec la prise en charge de Memcache

La modification la plus importante consiste à ajouter l'utilisation de la mise en cache dans notre application. Plus précisément, nous devons mettre en cache les visites les plus récentes, vérifier si des visites mises en cache sont disponibles et essayer d'utiliser les résultats mis en cache autant que possible en fonction de notre forfait. Voici les étapes que l'application suivra pour atteindre notre objectif :

  1. Définis la visite actuelle et appelle-la visitor
  2. Tentative de récupération du visits le plus récent à partir du cache
  3. Si le cache est vide ou si le visiteur le plus récent (visits[0]['visitor']) est différent du visitor actuel : stockez cette dernière visite, récupérez les visites les plus récentes et mettez-les en cache pendant une heure.
  4. Afficher visits à l'utilisateur via le modèle Web

Voici les captures d'écran avant et après ces modifications :

AVANT :

@app.route('/')
def root():
    'main application (GET) handler'
    store_visit(request.remote_addr, request.user_agent)
    visits = fetch_visits(10)
    return render_template('index.html', visits=visits)

APRÈS :

@app.route('/')
def root():
    'main application (GET) handler'
    # check for (hour-)cached visits
    ip_addr, usr_agt = request.remote_addr, request.user_agent
    visitor = '{}: {}'.format(ip_addr, usr_agt)
    visits = memcache.get('visits')

    # register visit & run DB query if cache empty or new visitor
    if not visits or visits[0]['visitor'] != visitor:
        store_visit(ip_addr, usr_agt)
        visits = list(fetch_visits(10))
        memcache.set('visits', visits, HOUR)  # set() not add()

    return render_template('index.html', visits=visits)

Voici une représentation visuelle des modifications apportées :

b1242503602f7bf0.png

Vous avez apporté toutes les modifications nécessaires pour ajouter l'utilisation d'App Engine memcache à l'exemple d'application du module 1. Créons et déployons cette application pour la voir fonctionner.

6. Résumé/Nettoyage

Cette section conclut cet atelier de programmation en déployant l'application et en vérifiant qu'elle fonctionne comme prévu et dans toutes les sorties reflétées. Après la validation de l'application, effectuez les étapes de nettoyage et réfléchissez aux prochaines étapes.

Déployer et vérifier l'application

Redéployez votre application avec gcloud app deploy et confirmez qu'elle fonctionne correctement. Votre code doit maintenant correspondre à celui du dossier Module 12 (FINISH). Le résultat doit être identique à celui de l'application du module 1 que vous avez déployée précédemment :

a7a9d2b80d706a2b.png

Nous avons simplement accéléré l'expérience utilisateur pour le même utilisateur. Lorsqu'il actualise la page, vous devriez obtenir les résultats directement à partir du cache, ce qui ne crée pas de visite ni n'effectue de récupération Datastore.

Bravo ! Vous avez terminé l'atelier de programmation du module 12, qui vous a permis d'ajouter l'utilisation du service memcache App Engine à notre exemple d'application. Vous avez maintenant la possibilité de transférer cette application Python 2 vers Python 3 dans l'étape bonus.

Effectuer un nettoyage

Général

Si vous avez terminé pour le moment, nous vous recommandons de désactiver votre application App Engine pour éviter d'être facturé. Toutefois, si vous souhaitez effectuer d'autres tests ou expériences, la plate-forme App Engine dispose d'un quota sans frais. Tant que vous ne dépassez pas ce niveau d'utilisation, aucun frais ne devrait vous être facturé. Cela concerne le calcul, mais des frais peuvent également s'appliquer aux services App Engine concernés. Pour en savoir plus, consultez la page de tarification. Si cette migration implique d'autres services Cloud, ceux-ci sont facturés séparément. Dans les deux cas, le cas échéant, consultez la section "Spécifique à cet atelier de programmation" ci-dessous.

Pour être tout à fait transparent, le déploiement sur une plate-forme de calcul sans serveur Google Cloud comme App Engine entraîne de légers coûts de compilation et de stockage. Cloud Build et Cloud Storage disposent chacun de leur propre quota sans frais. Le stockage de cette image utilise une partie de ce quota. Toutefois, il est possible que vous résidiez dans une région où ce niveau sans frais n'est pas disponible. Veillez donc à surveiller votre utilisation de l'espace de stockage pour minimiser les coûts potentiels. Voici quelques "dossiers" Cloud Storage spécifiques que vous devez examiner :

  • console.cloud.google.com/storage/browser/LOC.artifacts.PROJECT_ID.appspot.com/containers/images
  • console.cloud.google.com/storage/browser/staging.PROJECT_ID.appspot.com
  • Les liens de stockage ci-dessus dépendent de votre PROJECT_ID et de votre *LOC*ation. Par exemple, "us" si votre application est hébergée aux États-Unis.

En revanche, si vous ne souhaitez pas poursuivre avec cette application ni avec d'autres ateliers de programmation de migration associés et que vous souhaitez tout supprimer complètement, arrêtez votre projet.

Spécifique à cet atelier de programmation

Les services listés ci-dessous sont propres à cet atelier de programmation. Pour en savoir plus, consultez la documentation de chaque produit :

  • Le service Memcache d'App Engine est disponible en deux versions différentes, chacune avec sa propre structure tarifaire. Vous devez donc suivre l'utilisation de chacune d'elles pour la facturation.
  • Le service App Engine Datastore est fourni par Cloud Datastore (Cloud Firestore en mode Datastore), qui propose également un niveau sans frais. Pour en savoir plus, consultez sa page de tarification.

Étapes suivantes

La prochaine migration logique à envisager est abordée dans le module 13, qui explique aux développeurs comment migrer du service memcache App Engine vers Cloud Memorystore. Ces migrations sont toutes facultatives et disponibles pour les utilisateurs qui souhaitent moderniser leurs applications en plusieurs étapes. Le service Cloud Memorystore constitue une amélioration significative de memcache d'App Engine pour de nombreuses raisons :

  • Cloud Memorystore n'est pas sans serveur. Cela signifie que vous devez allouer un serveur pour le cache. Cloud Memorystore ne propose pas non plus de version sans frais. Ces deux facteurs peuvent avoir un impact significatif sur les coûts.
  • Cloud Memorystore est compatible avec deux mécanismes de stockage sous-jacents (moteurs de mise en cache) : Redis et Memcached.
  • Cloud Memorystore (pour Redis) offre un ensemble de fonctionnalités beaucoup plus riche et détaillé qu'App Engine Memcache.
  • Pour utiliser Cloud Memorystore, vous devez configurer un serveur Cloud Memorystore, l'ajouter à un réseau VPC Google Cloud, puis faire en sorte que votre application App Engine utilise ce réseau pour communiquer avec votre serveur Memorystore.

Si vous pensez ne pas avoir besoin de toutes les fonctionnalités disponibles dans Cloud Memorystore ou si vous vous inquiétez de son impact sur les coûts, vous pouvez continuer à utiliser App Engine Memcache.

Au-delà du module 13, vous trouverez de nombreuses autres migrations possibles, comme Cloud NDB et Cloud Datastore, ou Cloud Tasks. Il existe également des migrations interproduits vers Cloud Run et Cloud Functions. Vous les trouverez tous dans le dépôt de migration.

Une autre étape possible consiste à effectuer le portage vers Python 3, qui est abordé dans la section suivante en tant qu'étape facultative.

7. BONUS : Migration vers Python 3

Présentation

Cette section comprend du contenu bonus facultatif qui migre l'application du module 12 que nous venons de terminer vers Python 3. Nous commençons par la configuration, puis par l'application.

Simplifier le fichier app.yaml

L'un des avantages de l'environnement d'exécution Python 3 est que le app.yaml peut être considérablement simplifié.

AVANT :

Voici ce que contient app.yaml à la fin du module 12 :

runtime: python27
threadsafe: yes
api_version: 1

handlers:
- url: /.*
  script: main.app

Étant donné que l'environnement d'exécution Python 3 exige que les frameworks Web effectuent leur propre routage, tous les gestionnaires de routes dans app.yaml doivent être remplacés par auto. Si aucun fichier statique n'est diffusé, les utilisateurs peuvent supprimer complètement la section handlers:. De plus, threadsafe et api_version sont obsolètes.

APRÈS :

Avec les modifications requises que nous venons de décrire, voici le app.yaml de remplacement pour Python 3 :

runtime: python39
app_engine_apis: true

La seule ligne qui nécessite une explication est app_engine_apis: true. Lorsque les anciens services App Engine sont devenus disponibles pour les environnements d'exécution de deuxième génération en 2021, certains environnements d'exécution, y compris Python 3, ont nécessité un bootstrapping supplémentaire pour accéder à ces API, comme ndb, taskqueue et memcache. Cette ligne de la configuration sert à cet effet.

Mettre à jour le fichier requirements.txt

Un autre bootstrapping des API d'origine est requis dans requirements.txt : l'accès au nouveau SDK App Engine doit être inclus.

AVANT :

Voici ce que contient app.yaml à la fin du module 12 :

flask

APRÈS :

Il vous suffit d'ajouter le SDK App Engine pour Python pour obtenir les éléments suivants :

flask
appengine-python-standard

Supprimer les fichiers appengine_config.py et lib

Les environnements d'exécution App Engine de nouvelle génération remanient l'utilisation des packages tiers :

  • Les bibliothèques intégrées sont celles qui ont été vérifiées par Google et mises à disposition sur les serveurs App Engine, probablement parce qu'elles contiennent du code C/C++ que les développeurs ne sont pas autorisés à déployer dans le cloud. Elles ne sont plus disponibles dans les runtimes de deuxième génération.
  • Il n'est plus nécessaire de copier les bibliothèques non intégrées (parfois appelées "vendoring" ou "self-bundling") dans les environnements d'exécution de deuxième génération. Ils doivent plutôt être listés dans requirements.txt, où le système de compilation les installe automatiquement pour vous au moment du déploiement.

En raison de ces modifications apportées à la gestion des packages tiers, ni le fichier appengine_config.py ni le dossier lib ne sont nécessaires. Vous pouvez donc les supprimer. Dans les environnements d'exécution de deuxième génération, App Engine installe automatiquement les packages tiers listés dans requirements.txt. Résumer :

  1. Pas de bibliothèques tierces copiées ni groupées automatiquement ; répertoriez-les dans requirements.txt.
  2. Pas de pip install dans un dossier lib et pas de dossier lib.
  3. Pas de liste de bibliothèques tierces intégrées (donc pas de section libraries) dans app.yaml. Listez-les dans requirements.txt.
  4. Pas de bibliothèques tierces à référencer depuis votre application, donc pas de fichier appengine_config.py.

Il vous suffit de répertorier toutes les bibliothèques tierces souhaitées dans requirements.txt.

Mettre à jour l'application pour qu'elle utilise le SDK App Engine

Comme indiqué ci-dessus, les applications Python 3 nécessitent quelques modifications pour accéder aux services groupés App Engine :

  1. Regroupez le SDK App Engine (dans requirements.txt).
  2. Activer le SDK App Engine (dans app.yaml)
  3. Encapsuler l'objet WSGI (dans main.py)

La première paire a été complétée ci-dessus. La dernière exigence consiste donc à mettre à jour main.py.

AVANT :

Vous trouverez ci-dessous le fichier main.py Python 2 à la fin du module 12 :

from flask import Flask, render_template, request
from google.appengine.api import memcache
from google.appengine.ext import ndb

app = Flask(__name__)
HOUR = 3600

APRÈS :

Pour le port Python 3, importez le SDK et encapsulez l'objet d'application Flask avec celui-ci (l'encapsuleur SDK), ce qui donne le résultat suivant :

from flask import Flask, render_template, request
from google.appengine.api import memcache, wrap_wsgi_app
from google.appengine.ext import ndb

app = Flask(__name__)
app.wsgi_app = wrap_wsgi_app(app.wsgi_app)
HOUR = 3600

Les développeurs doivent apporter ces modifications à leurs applications Python lors du portage de la version 2.x vers la version 3.x pour accéder aux services groupés. Si vous n'utilisez pas Flask, vous trouverez également des exemples Django et Pyramid dans la documentation. Si votre code Python 2 n'est pas une application Web, il vous suffira d'inclure le package SDK lors du portage vers Python 3. Notre code d'application a été conçu à l'origine pour fonctionner sous Python 2 et 3. Aucune modification de compatibilité supplémentaire n'est donc nécessaire.

Déployer l'application

Une fois les modifications ci-dessus effectuées, vous pouvez déployer l'application exemple mise à jour. (Il n'y a aucun problème à déployer une version Python 3 de votre application sur une version Python 2 d'origine dans le même projet GCP.) Le comportement de l'application doit rester le même. Si vous devez comparer votre application mise à jour à la nôtre, consultez le dossier Module 12b dans le dépôt de migration. Pour en savoir plus sur la compatibilité des services groupés App Engine dans les derniers environnements d'exécution tels que Python 3, consultez l'annonce du lancement de la fonctionnalité ainsi que l'atelier de programmation du module 17.

Nous vous félicitons d'avoir terminé l'étape bonus du module 12 ! Consultez également la documentation sur la préparation des fichiers de configuration pour l'environnement d'exécution Python 3. Consultez la section "Récapitulatif/Nettoyage" ci-dessus pour connaître les étapes suivantes et effectuer un nettoyage.

8. Ressources supplémentaires

Vous trouverez ci-dessous des ressources supplémentaires pour les développeurs qui souhaitent en savoir plus sur ce module de migration ou sur des modules et produits associés. Vous y trouverez des liens vers le code, des informations sur la façon de nous faire part de vos commentaires sur ce contenu et divers éléments de documentation qui pourraient vous être utiles.

Problèmes/commentaires concernant l'atelier de programmation

Si vous rencontrez des problèmes avec cet atelier de programmation, commencez par faire une recherche avant de les signaler. Liens vers la recherche et la création d'un signalement :

Ressources de migration

Vous trouverez des liens vers les dossiers des dépôts du module 2 (code de départ "START") et du module 12 (code final "FINISH") dans le tableau ci-dessous. Vous pouvez également y accéder depuis le dépôt pour toutes les migrations d'ateliers de programmation App Engine que vous pouvez cloner ou télécharger sous forme de fichier ZIP.

Atelier de programmation

Python 2

Python 3

Module 1

code

code (non présenté dans ce tutoriel)

Module 12 (cet atelier de programmation)

code

code

Références en ligne

Vous trouverez ci-dessous des ressources en ligne qui peuvent être utiles pour ce tutoriel :

App Engine

Cloud Memorystore et Cloud Datastore

Informations sur les autres clouds

Vidéos

Licence

Ce document est publié sous une licence Creative Commons Attribution 2.0 Generic.