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

1. Présentation

La série d'ateliers de programmation sur la station de migration sans serveur (tutoriels pratiques et d'auto-formation) et les vidéos associées visent à aider les développeurs sans serveur Google Cloud à moderniser leurs applications en les guidant dans une ou plusieurs migrations, principalement en abandonnant les anciens services. Vous améliorez ainsi la portabilité de vos applications, et vous bénéficiez de plus d'options et de flexibilité. Vous pouvez ainsi intégrer un plus large éventail de produits Cloud et y accéder, et passer plus facilement à de nouvelles langues. Bien qu'elle s'adresse initialement aux utilisateurs les plus anciens du cloud, principalement les développeurs d'environnements App Engine (standard), cette série est suffisamment large pour inclure d'autres plates-formes sans serveur telles que Cloud Functions et Cloud Run, ou ailleurs, le cas échéant.

Cet atelier de programmation vous explique comment inclure et utiliser Memcache d'App Engine dans l'application exemple de l'atelier de programmation du module 1. Nous allons utiliser Memcache dans le tutoriel du module 12, puis nous allons effectuer la migration vers Cloud Memorystore dans le module 13.

Vous apprendrez à

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

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 ?

<ph type="x-smartling-placeholder"></ph> Débutant Intermédiaire Expert .

2. Contexte

Pour effectuer la migration depuis App Engine Memcache, ajoutez son utilisation à l'application Flask et App Engine NDB existante issue 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 en permanence de nouvelles entités "Visit" et d'extraire les visites les plus récentes à partir de Datastore. Nous allons donc mettre en cache ces visites les plus récentes.

Si un même visiteur consulte la page, les visites sont renvoyées par le 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 parler d'une nouvelle visite enregistrée). Une fois l'intégration de Memcache d'App Engine 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 d'application

3. Configuration/Préparation

Avant de passer à la partie principale du tutoriel, nous allons configurer notre projet, récupérer le code, puis déployer l'application de base pour savoir si nous avons commencé avec 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'une application exemple du module 1 qui fonctionne. Si vous n'en avez pas, suivez l'un des tutoriels (liens ci-dessus) avant de poursuivre. Si vous connaissez déjà son contenu, vous pouvez simplement commencer par 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. Cet atelier de programmation passe en revue chaque étape et se termine par un code semblable à celui du dossier du dépôt du module 11 (FINISH).

Le répertoire des fichiers de démarrage du module 1 (les vôtres ou les nôtres) devrait ressembler à ceci:

$ 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 que vous avez exécuté ces étapes et constaté que votre application Web fonctionne (avec un résultat semblable à celui ci-dessous), vous pouvez ajouter 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

Étant donné que nous n'ajoutons qu'une API App Engine, aucun package externe n'est impliqué, ce qui signifie qu'aucun fichier de configuration (app.yaml, requirements.txt, appengine_config.py) n'a besoin d'être mis à jour. Il n'existe qu'un seul fichier d'application, main.py. Toutes les modifications apportées dans cette section ne concernent donc que ce fichier.

Importations

L'étape la plus importante consiste à importer la bibliothèque Memcache, google.appengine.api.memcache. Puisque 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 cette modification, ainsi que 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 grâce à la compatibilité avec Memcache

Le changement le plus important 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 les visites en cache sont disponibles et essayer d'utiliser les résultats mis en cache autant que possible en fonction de notre plan. Voici les étapes que l'application suivra pour atteindre notre objectif:

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

Voici ce qui a changé avant et après:

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 illustration des modifications apportées:

b1242503602f7bf0.png

Vous avez terminé 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 qu'elle fonctionne.

6. Résumé/Nettoyage

Cette section conclut cet atelier de programmation en déployant l'application, en vérifiant qu'elle fonctionne comme prévu et dans tout résultat réfléchi. Après la validation de l'application, effectuez toutes 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 devrait maintenant correspondre à ce qui se trouve dans FINISH, le dossier du module 12. Le résultat doit être identique à celui de l'application du module 1 que vous avez déployée précédemment:

a7a9d2b80d706a2b.png

Tout ce que nous avons fait, c'était d'accélérer l'expérience utilisateur pour le même utilisateur. Lorsqu'ils sont actualisés, vous devriez obtenir les résultats directement à partir du cache, ce qui ne crée pas de nouvelle visite ni n'effectue d'extraction dans Datastore.

Félicitations ! Vous avez terminé l'atelier de programmation du module 12, qui vous a permis d'ajouter l'utilisation du service memcache d'App Engine à notre exemple d'application. Vous avez désormais la possibilité de porter cette application Python 2 vers Python 3 lors de l'étape bonus.

Effectuer un nettoyage

Général

Si vous avez terminé, nous vous recommandons de désactiver votre application App Engine afin d'éviter que des frais ne vous soient facturés. Toutefois, si vous souhaitez effectuer d'autres tests, la plate-forme App Engine dispose d'un quota sans frais. Tant que vous ne dépassez pas ce niveau d'utilisation, aucuns frais ne vous seront facturés. Cela concerne le calcul, mais des frais peuvent également s'appliquer pour les services App Engine concernés. Pour en savoir plus, consultez sa page des tarifs. 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 "Informations spécifiques à cet atelier de programmation" ci-dessous.

Afin d'informer l'ensemble des utilisateurs, le déploiement sur une plate-forme de calcul sans serveur Google Cloud comme App Engine entraîne des coûts minimes de compilation et de stockage. Cloud Build et Cloud Storage disposent de leur propre quota sans frais. Le stockage de cette image utilise une partie de ce quota. Cependant, vous pouvez résider dans une région qui n'offre pas ce type de version sans frais. Vous devez donc surveiller l'utilisation de votre espace de stockage afin de réduire les coûts potentiels. "Dossiers" Cloud Storage spécifiques 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 comptez pas utiliser cette application ou d'autres ateliers de programmation liés à la migration, 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 se décline en deux versions, chacune étant associée à une grille tarifaire qui lui est propre. Vous devez donc suivre cette utilisation pour la facturation.
  • Le service App Engine Datastore est fourni par Cloud Datastore (Cloud Firestore en mode Datastore), également disponible avec une version sans frais. consultez la page des tarifs pour en savoir plus.

Étapes suivantes

La prochaine migration logique à envisager est traitée dans le module 13, qui montre 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. Le service Cloud Memorystore constitue une mise à niveau significative de la classe 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. De plus, Cloud Memorystore ne propose pas 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 différents (moteurs de mise en cache) : Redis et Memcached.
  • Cloud Memorystore (pour Redis) propose un ensemble de fonctionnalités beaucoup plus riche et approfondi que celui de Memcache d'App Engine.
  • Pour utiliser Cloud Memorystore, vous devez configurer un serveur Cloud Memorystore, l'ajouter à un réseau VPC Google Cloud, puis demander à votre application App Engine d'utiliser ce réseau pour communiquer avec votre serveur Memorystore.

Si vous n'avez pas besoin de toutes les fonctionnalités proposées par Cloud Memorystore ou si vous êtes préoccupé par l'impact de ces fonctionnalités sur les coûts, vous pouvez rester sur App Engine Memcache.

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

Il est également possible d'effectuer le portage vers Python 3. Cette étape facultative est décrite dans la section suivante.

7. BONUS: Migration vers Python 3

Présentation

Cette section comprend des contenus bonus facultatifs lors de la migration de 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 app.yaml peut être considérablement simplifié.

AVANT:

À la fin du module 12, voici ce que contient app.yaml:

runtime: python27
threadsafe: yes
api_version: 1

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

Étant donné que l'environnement d'exécution Python 3 nécessite que les frameworks Web effectuent leur propre routage, tous les gestionnaires de routage dans app.yaml doivent être définis sur auto. Si aucun fichier statique n'est diffusé, les utilisateurs peuvent simplement supprimer complètement l'intégralité de la section handlers:. Par ailleurs, threadsafe et api_version ont tous les deux été abandonnés.

APRÈS:

Avec les modifications requises décrites ci-dessus, voici l'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 disponibles pour les environnements d'exécution de deuxième génération en 2021, certains environnements d'exécution, y compris Python 3, nécessitent un démarrage supplémentaire pour accéder à ces API, comme ndb, taskqueue et memcache. Cette ligne de la configuration remplit cette fonction.

Mettre à jour le fichier requirements.txt

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

AVANT:

À la fin du module 12, voici ce que contient app.yaml:

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 nouvelle génération repensent l'utilisation des packages tiers:

  • Les bibliothèques intégrées sont approuvé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 environnements d'exécution de 2e génération.
  • La copie de bibliothèques non intégrées (parfois appelée "vendoring" ou "auto-regroupement") n'est plus nécessaire dans les environnements d'exécution de 2e génération. Ils devraient être répertorié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 devez donc les supprimer. Dans les environnements d'exécution de deuxième génération, App Engine installe automatiquement les packages tiers répertoriés dans requirements.txt. Résumé:

  1. Pas de bibliothèques tierces auto-groupées ou copiées les afficher 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 (et donc pas de section libraries) dans app.yaml. les afficher dans requirements.txt
  4. Pas de bibliothèques tierces à référencer depuis votre application : pas de fichier appengine_config.py

La seule condition requise pour les développeurs consiste à répertorier toutes les bibliothèques tierces souhaitées dans requirements.txt.

Mettre à jour l'application pour utiliser le SDK App Engine

Comme indiqué ci-dessus, l'accès aux services groupés App Engine par les applications Python 3 nécessite certaines modifications:

  1. Bundle App Engine SDK (in 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é réalisé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 lui (le wrapper du SDK). Vous obtenez 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 suffit d'inclure le package SDK lors du portage vers Python 3. À l'origine, notre code d'application a été conçu 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 lorsque vous déployez une version Python 3 de votre application plutôt qu'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 du 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 de lancement de la fonctionnalité ainsi que l'atelier de programmation du module 17.

Bravo ! Vous avez 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ésumé/Nettoyage ci-dessus pour connaître les étapes suivantes et le nettoyage.

8. Ressources supplémentaires

Vous trouverez ci-dessous des ressources supplémentaires destinées aux développeurs qui étudient plus en détail ce module de migration ou le module de migration associé, ainsi que les produits associés. Vous y trouverez, par exemple, des emplacements où vous pouvez envoyer des commentaires sur ce contenu, des liens vers le code et diverses documents susceptibles de vous être utiles.

Commentaires et problèmes concernant les ateliers 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

Le tableau ci-dessous contient des liens vers les dossiers de dépôt des modules 2 (START) et 12 (FINISH). Vous pouvez également y accéder à partir du dépôt de toutes les migrations de l'atelier 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 vous être utiles pour ce tutoriel:

App Engine

Cloud Memorystore et Cloud Datastore

Autres informations sur le cloud

Vidéos

Licence

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