Cómo usar Memcache de App Engine en apps de Flask (módulo 12)

1. Descripción general

El objetivo de la serie de codelabs de Serverless Migration Station (instructivos prácticos y de autoaprendizaje) y los videos relacionados es ayudar a los desarrolladores de Google Cloud sin servidores a modernizar sus aplicaciones guiándolos a través de una o más migraciones, principalmente alejándose de los servicios heredados. De esta manera, tus apps serán más portátiles y tendrás más opciones y flexibilidad, lo que te permitirá integrar y acceder a una mayor variedad de productos de Cloud, y actualizarte más fácilmente a versiones de lenguaje más recientes. Si bien, en un principio, se enfoca en los primeros usuarios de Cloud, principalmente los desarrolladores de App Engine (entorno estándar), esta serie es lo suficientemente amplia como para incluir otras plataformas sin servidores, como Cloud Functions y Cloud Run, o en cualquier otro lugar si corresponde.

En este codelab, aprenderás a incluir y usar App Engine Memcache en la app de ejemplo del codelab del módulo 1. En este instructivo del módulo 12, agregamos el uso de Memcache y, luego, en el módulo 13, migramos a Cloud Memorystore.

En un próximo lab,

  • Usa la API o biblioteca de Memcache de App Engine
  • Cómo agregar almacenamiento en caché a una app básica de Python 2 de Flask App Engine NDB

Requisitos

Encuesta

¿Cómo usarás este instructivo?

Leer Leer y completar los ejercicios

¿Cómo calificarías tu experiencia en Python?

Principiante Intermedio Avanzado

¿Cómo calificarías tu experiencia en el uso de los servicios de Google Cloud?

Principiante Intermedio Avanzado

2. Fondo

Para migrar desde App Engine Memcache, agrega su uso a la app existente de Flask y App Engine NDB que se generó en el codelab del módulo 1. La app de ejemplo muestra las diez visitas más recientes del usuario. Si el mismo usuario actualiza su navegador, no es óptimo crear continuamente nuevas entidades de Visit y recuperar las visitas más recientes de Datastore, por lo que almacenaremos en caché esas visitas más recientes.

Si el mismo visitante accede a la página, esas visitas se recuperan de la caché. Si un usuario nuevo visita el sitio o transcurrió una hora, se borra la caché y se reemplaza por las entradas más recientes (sin mencionar que se registra una nueva visita). Con esta integración de App Engine Memcache implementada, podemos migrarla a Cloud Memorystore en el siguiente codelab (módulo 13).

En este instructivo, se incluyen los siguientes pasos:

  1. Configurar/trabajo previo
  2. Actualizar configuración
  3. Modifica el código de la aplicación

3. Configurar/trabajo previo

Antes de comenzar con la parte principal del instructivo, configuremos nuestro proyecto, obtengamos el código e implementemos la app de modelo de referencia para que comencemos a trabajar con el código.

1. Configura el proyecto

Si completaste el codelab del módulo 1, te recomendamos volver a usar ese mismo proyecto (y el código). De manera alternativa, puedes crear un proyecto nuevo o reutilizar otro proyecto existente. Asegúrate de que el proyecto tenga una cuenta de facturación activa y que App Engine esté habilitado.

2. Obtén app de ejemplo del modelo de referencia

Uno de los requisitos previos a este codelab es tener una app de ejemplo del módulo 1 que funcione. Si aún no tienes uno, lee los instructivos (vínculos anteriores) antes de avanzar. De lo contrario, si ya estás familiarizado con su contenido, puedes comenzar leyendo el código del Módulo 1 a continuación.

Sin importar si usas el tuyo o el nuestro, el código del módulo 1 es el que tendremos en cuenta. Este codelab te guiará en cada paso y concluirá con un código que se parezca al que se encuentra en la carpeta del repositorio del módulo 11 (FINALIZAR).

El directorio de archivos de INICIO del módulo 1 (los tuyos o los nuestros) debe verse así:

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

3. (vuelve a) implementa la aplicación de modelo de referencia

Los pasos del trabajo previo restantes para ejecutar ahora sin estos:

  1. Familiarízate con la herramienta de línea de comandos de gcloud
  2. Vuelve a implementar la app de muestra con gcloud app deploy
  3. Confirma que la app se ejecuta en App Engine sin problemas

Una vez que hayas ejecutado esos pasos de manera correcta y veas que tu app web funciona (con un resultado similar al siguiente), podrás agregar el uso del almacenamiento en caché a tu app.

a7a9d2b80d706a2b.png

4. Actualizar configuración

No es necesario realizar cambios en los archivos de configuración estándar de App Engine (app.yaml, requirements.txt, appengine_config.py).

5. Modifica los archivos de la aplicación

Como solo agregamos una API de App Engine, no hay paquetes externos involucrados, lo que significa que no es necesario actualizar ningún archivo de configuración (app.yaml, requirements.txt, appengine_config.py). Solo hay un archivo de aplicación, main.py, por lo que todos los cambios de esta sección afectan solo a ese archivo.

Importaciones

El paso más importante es importar la biblioteca de Memcache, google.appengine.api.memcache. Como almacenaremos en caché las visitas más recientes durante una hora, también agregaremos una constante para la cantidad de segundos en una hora. A continuación, se muestra cómo se ve tu código antes y después de este cambio:

ANTES:

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

app = Flask(__name__)

DESPUÉ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

Cómo agregar almacenamiento en caché con compatibilidad con Memcache

El cambio más significativo es agregar el uso de almacenamiento en caché en nuestra aplicación. Más específicamente, deberíamos almacenar en caché las visitas más recientes, verificar si hay visitas almacenadas en caché disponibles y tratar de usar los resultados almacenados en caché tanto como sea posible según nuestro plan. Estos son los pasos que seguirá la app para lograr nuestro objetivo:

  1. Establece la visita actual y llámala visitor
  2. Intenta recuperar el visits más reciente de la caché.
  3. Si la caché está vacía o el visitante más reciente (visits[0]['visitor']) difiere del visitor actual, almacena esta visita más reciente, recupera las visitas más recientes y guárdalas en la caché durante una hora.
  4. Mostrar visits al usuario a través de la plantilla web

Aquí se muestran los resultados antes y después de aplicar estas actualizaciones:

ANTES:

@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)

DESPUÉ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)

A continuación, se incluye una representación gráfica de los cambios que se realizaron:

b1242503602f7bf0.png

Con esto, se completan todos los cambios necesarios para agregar el uso de memcache de App Engine a la app de muestra del módulo 1. Compilemos e implementemos esta app para ver cómo funciona.

6. Resumen/Limpieza

En esta sección, se completa el codelab con la implementación de la app y la verificación de que funcione según lo previsto y en cualquier resultado reflejado. Después de la validación de la app, realiza los pasos de limpieza necesarios y considera los próximos pasos.

Implementa y verifica la aplicación

Vuelve a implementar la app con gcloud app deploy y confirma que funciona. El código ahora debería coincidir con el contenido de FINISH, la carpeta del módulo 12. El resultado debería ser idéntico al de la app del módulo 1 que implementaste antes:

a7a9d2b80d706a2b.png

Lo único que hicimos fue acelerar la experiencia del usuario para el mismo usuario. Cuando se actualiza, deberías obtener los resultados directamente de la caché, lo que no crea una visita nueva ni realiza una recuperación de Datastore.

Felicitaciones por completar el codelab del módulo 12 para agregar el uso del servicio memcache de App Engine a nuestra aplicación de muestra. Ahora tienes la opción de transferir esta app de Python 2 a Python 3 en el paso adicional.

Limpia

General

Si terminaste por ahora, te recomendamos que inhabilites tu app de App Engine para evitar incurrir en cargos de facturación. Sin embargo, si deseas realizar más pruebas o experimentos, la plataforma de App Engine tiene una cuota gratuita, por lo que no se te cobrará siempre que no excedas ese nivel de uso. Esto se aplica a la capacidad de procesamiento, pero también puede haber cargos por los servicios relevantes de App Engine, por lo que debes consultar su página de precios para obtener más información. Si esta migración involucra otros servicios de Cloud, estos se facturarán por separado. En cualquier caso, si corresponde, consulta la sección "Específico para este codelab" que se encuentra más abajo.

Para divulgar toda la información, la implementación en una plataforma de computación sin servidores de Google Cloud, como App Engine, genera costos menores de compilación y almacenamiento. Cloud Build tiene su propia cuota gratuita, al igual que Cloud Storage. El almacenamiento de esa imagen usa parte de esa cuota. Sin embargo, es posible que vivas en una región que no tenga ese nivel gratuito, por lo que debes tener en cuenta tu uso de almacenamiento para minimizar los costos potenciales. Las "carpetas" específicas de Cloud Storage que debes revisar incluyen las siguientes:

  • 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
  • Los vínculos de almacenamiento anteriores dependen de tu PROJECT_ID y *LOC*ación, por ejemplo, "us" si tu app está alojada en EE.UU.

Por otro lado, si no vas a continuar con esta aplicación ni con otros codelabs de migración relacionados y quieres borrar todo por completo, cierra tu proyecto.

Específico para este codelab

Los servicios que se indican a continuación son exclusivos de este codelab. Consulta la documentación de cada producto para obtener más información:

  • El servicio de Memcache de App Engine se ofrece en dos versiones diferentes, cada una con su propia estructura de precios, por lo que debes hacer un seguimiento del uso en relación con la facturación.
  • El servicio App Engine Datastore lo proporciona Cloud Datastore (Cloud Firestore en modo Datastore), que también tiene un nivel gratuito. Consulta su página de precios para obtener más información.

Próximos pasos

La siguiente migración lógica que se debe considerar se aborda en el módulo 13, en el que se muestra a los desarrolladores cómo migrar del servicio memcache de App Engine a Cloud Memorystore. Todas estas migraciones son opcionales y están disponibles para los usuarios que deseen realizar varios pasos para modernizar sus aplicaciones. El servicio de Cloud Memorystore es una actualización significativa de memcache de App Engine por muchos motivos:

  • Cloud Memorystore no es sin servidores. Esto significa que debes asignar un servidor para la caché. Cloud Memorystore tampoco tiene un nivel gratuito. Ambos factores pueden tener un impacto significativo en el costo.
  • Cloud Memorystore admite dos mecanismos de almacenamiento subyacentes diferentes (motores de almacenamiento en caché): Redis y Memcached.
  • Cloud Memorystore (para Redis) tiene un conjunto de funciones mucho más completo y detallado que App Engine Memcache.
  • Para usar Cloud Memorystore, debes configurar un servidor de Cloud Memorystore, agregarlo a una red de VPC de Google Cloud y, luego, hacer que tu app de App Engine use esa red para comunicarse con tu servidor de Memorystore.

Si crees que no necesitas todas las funciones disponibles en Cloud Memorystore o te preocupa su efecto en el costo, puedes seguir usando App Engine Memcache.

Más allá del módulo 13, hay una gran cantidad de otras migraciones posibles, como Cloud NDB y Cloud Datastore, o Cloud Tasks. También hay migraciones entre productos a Cloud Run y Cloud Functions. Los encontrarás todos en el repo de migración.

Otro posible paso siguiente es la portabilidad a Python 3, que se aborda en la siguiente sección como un paso opcional.

7. BONIFICACIÓN: Migración a Python 3

Descripción general

En esta sección, se incluye contenido adicional opcional para migrar la aplicación del módulo 12 que acabamos de completar a Python 3. Comenzaremos con la configuración y, luego, con la aplicación.

Simplifica app.yaml

Uno de los beneficios del entorno de ejecución de Python 3 es que el app.yaml se puede simplificar de manera significativa.

ANTES:

A continuación, se muestra el contenido de app.yaml al final del módulo 12:

runtime: python27
threadsafe: yes
api_version: 1

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

Dado que el entorno de ejecución de Python 3 requiere que los frameworks web realicen su propio enrutamiento, todos los controladores de rutas en app.yaml deben cambiarse a auto. Si no se publican archivos estáticos, los usuarios pueden quitar directamente toda la sección handlers:. Además, tanto threadsafe como api_version dejaron de estar disponibles.

DESPUÉS:

Con los cambios necesarios que acabamos de describir, este es el reemplazo de app.yaml para Python 3:

runtime: python39
app_engine_apis: true

La única línea que necesita una explicación es app_engine_apis: true. Cuando los servicios heredados de App Engine estuvieron disponibles para los entornos de ejecución de segunda generación en 2021, algunos entornos de ejecución, incluido Python 3, requirieron un proceso de arranque adicional para acceder a esas APIs, como ndb, taskqueue y memcache. Esta línea en la configuración cumple con ese propósito.

Actualiza requirements.txt

Se requiere otro bootstrapping de las APIs originales en requirements.txt: se debe incluir el acceso al nuevo SDK de App Engine.

ANTES:

A continuación, se muestra el contenido de app.yaml al final del módulo 12:

flask

DESPUÉS:

Solo tienes que agregar el SDK de App Engine para Python y deberías tener lo siguiente:

flask
appengine-python-standard

Borra appengine_config.py y lib

Los entornos de ejecución de App Engine de nueva generación renuevan el uso de paquetes de terceros:

  • Las bibliotecas integradas son aquellas que Google verificó y que están disponibles en los servidores de App Engine, probablemente porque contienen código en C/C++ que los desarrolladores no pueden implementar en la nube. Estas ya no están disponibles en los tiempos de ejecución de 2ª generación.
  • Ya no es necesario copiar bibliotecas no integradas (a veces llamadas "vendoring" o "self-bundling") en los entornos de ejecución de 2ª generación. En cambio, deben aparecer en requirements.txt, donde el sistema de compilación los instala automáticamente en tu nombre en el momento de la implementación.

Como resultado de esos cambios en la administración de paquetes de terceros, no se necesitan el archivo appengine_config.py ni la carpeta lib, por lo que debes borrarlos. En los entornos de ejecución de 2ª generación, App Engine instala automáticamente los paquetes de terceros que se indican en requirements.txt. Resumen:

  1. No hay bibliotecas de terceros copiadas ni autoagrupadas en paquetes; enuméralas en requirements.txt
  2. No hay pip install en una carpeta lib, lo que significa que no hay un período de carpeta lib
  3. No se enumeran las bibliotecas integradas de terceros (por lo tanto, no hay sección libraries) en app.yaml; se enumeran en requirements.txt
  4. No hay bibliotecas de terceros a las que hacer referencia desde tu app, lo que significa que no se necesita ningún archivo appengine_config.py

Enumerar todas las bibliotecas de terceros deseadas en requirements.txt es el único requisito para los desarrolladores.

Actualiza la aplicación para usar el SDK de App Engine

Como se mencionó anteriormente, las apps de Python 3 requieren algunas modificaciones para acceder a los servicios en paquetes de App Engine:

  1. Incluye el SDK de App Engine (en requirements.txt)
  2. Activa el SDK de App Engine (en app.yaml).
  3. Ajusta el objeto WSGI (en main.py)

El primer par se completó anteriormente, por lo que el último requisito es actualizar main.py.

ANTES:

A continuación, se muestra el main.py de Python 2 al final del módulo 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

DESPUÉS:

Para el port de Python 3, importa el SDK y envuelve el objeto de la app de Flask con él (el wrapper del SDK), lo que genera lo siguiente:

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

Los desarrolladores deben realizar estos cambios en sus apps de Python cuando las portan de la versión 2.x a la 3.x para acceder a los servicios agrupados en paquetes. Si no usas Flask, también hay ejemplos de Django y Pyramid en la documentación. Si tu código de Python 2 no es una app web, incluir el paquete del SDK debería ser suficiente cuando lo transfieras a Python 3. Nuestro código de aplicación se diseñó originalmente para funcionar con Python 2 y 3, por lo que no se necesitan cambios de compatibilidad adicionales.

Implemente la aplicación

Después de completar los cambios anteriores, puedes implementar la app de ejemplo actualizada. (No hay ningún problema cuando se implementa una versión de Python 3 de tu app sobre una versión original de Python 2 en el mismo proyecto de GCP). El comportamiento de la app debería seguir siendo el mismo. Si necesitas comparar tu app actualizada con la nuestra, consulta la carpeta Module 12b en el repositorio de migración. Para obtener más información sobre la compatibilidad de los servicios agrupados de App Engine en los entornos de ejecución más recientes, como Python 3, consulta el anuncio del lanzamiento de la función y el codelab del módulo 17.

¡Felicitaciones por finalizar el paso adicional del módulo 12! Consulta también la documentación sobre la preparación de archivos de configuración para el entorno de ejecución de Python 3. Revisa la sección Resumen/Limpieza anterior para conocer los próximos pasos y la limpieza.

8. Recursos adicionales

A continuación, se enumeran recursos adicionales para los desarrolladores que deseen explorar más a fondo este módulo de migración o uno relacionado, así como los productos relacionados. Esto incluye lugares para proporcionar comentarios sobre este contenido, vínculos al código y varios documentos que pueden resultarte útiles.

Problemas o comentarios de los codelabs

Si encuentras algún problema con este Codelab, primero busca el problema antes de enviarlo. Vínculos para buscar y crear problemas nuevos:

Recursos de migración

En la siguiente tabla, puedes encontrar vínculos a las carpetas del repositorio para el módulo 2 (INICIAR) y el módulo 12 (FINALIZAR). También se puede acceder a ellos desde el repositorio de todas las migraciones de codelab de App Engine, que puedes clonar o descargar un archivo ZIP.

Codelab

Python 2

Python 3

Módulo 1

código

code (no se incluye en este instructivo)

Módulo 12 (este codelab)

código

código

Referencias en línea

A continuación, se incluyen recursos en línea que pueden ser pertinentes para este instructivo:

App Engine

Cloud Memorystore y Cloud Datastore

Otra información de la nube

Videos

Licencia

Este trabajo cuenta con una licencia Atribución 2.0 Genérica de Creative Commons.