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

1. Descripción general

La serie de codelabs Serverless Migration Station (instructivos prácticos y autoaprendizaje) y los videos relacionados tienen como objetivo ayudar a los desarrolladores de Google Cloud sin servidores a modernizar sus apps guiándolos a través de una o más migraciones, en especial al alejarse 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á integrarlas con una variedad más amplia de productos de Cloud y acceder a ella, y actualizar con mayor facilidad a versiones de idiomas más recientes. Aunque inicialmente 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 cualquier otra, si corresponde.

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

En un próximo lab,

  • Usa la API o biblioteca de Memcache de App Engine
  • Agrega almacenamiento en caché a una app básica de Python 2 Flask en 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. Información general

Para migrar desde Memcache de App Engine, agrega su uso a la app existente de Flask y App Engine NDB que resulta del 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 visita y recuperar las visitas más recientes desde Datastore, por lo que almacenaremos en caché esas visitas más recientes.

Si el mismo visitante llega a la página, esas visitas se devuelven de la caché. Si un usuario nuevo visita el sitio o ha pasado una hora, la caché se vacía y se reemplaza con las entradas más recientes (sin mencionar una nueva visita registrada). Con esta integración de Memcache de App Engine implementada, podemos migrarla a Cloud Memorystore en el siguiente codelab (Módulo 13).

En este instructivo, se muestran 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 llegar a la parte principal del instructivo, configuremos el proyecto, obtengamos el código y, luego, implementemos la app de referencia para que sepamos que comenzamos a trabajar con el código.

1. Configura el proyecto

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

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

Uno de los requisitos previos de este codelab es tener una app de ejemplo del Módulo 1 que funcione. Si no tienes uno, completa cualquiera de los instructivos (vínculos anteriores) antes de continuar con este paso. Como alternativa, si ya conoces su contenido, puedes comenzar con el código del módulo 1 que aparece 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. En este codelab, se explica cada paso y se concluye con un código similar al que está en la carpeta del repositorio del módulo 11 (FINISH).

El directorio de los archivos STARTing del módulo 1 (tuyos o los nuestros) debería verse de la siguiente manera:

$ 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 correctamente esos pasos y veas que tu aplicación web funciona (con un resultado similar al que se muestra a continuación), estarás listo para agregar el uso del almacenamiento en caché a tu aplicación.

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 archivos de la aplicación

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

Importaciones

El paso más importante es importar la biblioteca de Memcache, google.appengine.api.memcache. Dado que almacenaremos en caché las visitas más recientes durante una hora, agreguemos también una constante para la cantidad de segundos en una hora. A continuación, se muestra cómo se veía tu código antes y 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

Agrega almacenamiento en caché gracias a la compatibilidad con Memcache

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

  1. Establece la visita actual y asígnale el nombre visitor.
  2. Intentar 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 almacénalas en caché durante una hora.
  4. Muestra visits al usuario a través de la plantilla web

A continuación, te mostramos el antes y el después de 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)

Esta es una representación gráfica de los cambios que se hicieron:

b1242503602f7bf0.png

Con esto concluye todos los cambios necesarios para agregar el uso de memcache de App Engine a la app de ejemplo del módulo 1. Compila e implementemos esta app para ver cómo funciona.

6. Resumen/limpieza

En esta sección, se finaliza este codelab implementando la app y verificando que funcione según lo previsto y en cualquier resultado reflejado. Después de validar la app, realiza los pasos de limpieza y considera los siguientes.

Implementa y verifica la aplicación

Vuelve a implementar la app con gcloud app deploy y confirma que funciona. Tu código ahora debería coincidir con el que está en 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 actualicen, deberías obtener los resultados directamente de la caché, 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 ejemplo. Ahora, tienes la opción de transferir esta app de Python 2 a Python 3 en el paso adicional.

Limpia

General

Si ya terminaste, te recomendamos que inhabilites la aplicación de App Engine para evitar que se te facture. Sin embargo, si deseas probar o experimentar un poco más, la plataforma de App Engine tiene una cuota gratuita y, siempre y cuando no superes ese nivel de uso, no se te debería cobrar. Eso es para procesamiento, pero es posible que también se apliquen cargos por servicios relevantes de App Engine, así que consulta la página de precios para obtener más información. Si esta migración implica otros servicios de Cloud, estos se facturan por separado. En ambos casos, si corresponde, consulta la sección "Específico de este codelab" a continuación.

Para una divulgación completa, la implementación en una plataforma de procesamiento 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 ocupa parte de esa cuota. Sin embargo, es posible que vivas en una región que no cuenta con ese nivel gratuito, así que ten en cuenta el uso que haces del almacenamiento para minimizar posibles costos. “Carpetas” específicas de Cloud Storage que debes revisar incluyen

  • 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*; por ejemplo, "us" si tu app está alojada en EE.UU.

Por otro lado, si no vas a continuar con esta aplicación o algún otro codelab de migración relacionado y quieres borrar todo por completo, cierra tu proyecto.

Información específica de 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 Memcache de App Engine tiene dos variantes, cada una con su propia estructura de precios, por lo que debes realizar un seguimiento de ese uso en relación con la facturación.
  • El servicio de 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 y 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 con el objetivo de modernizar sus aplicaciones. El servicio Cloud Memorystore es una actualización importante del memcache de App Engine por muchos motivos:

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

Si no necesitas todas las funciones disponibles de Cloud Memorystore o te preocupan sus efectos en el costo, puedes permanecer en Memcache de App Engine.

Más allá del módulo 13, hay un montón de migraciones posibles, como Cloud NDB, Cloud Datastore o Cloud Tasks. También hay migraciones de productos cruzados a Cloud Run y Cloud Functions. Los encontrarás en el repositorio de migración.

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

7. VENTAJA ADICIONAL: Migración a Python 3

Descripción general

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

Simplifica app.yaml

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

ANTES:

A continuación, se muestra lo que se incluye en app.yaml al final del Módulo 12:

runtime: python27
threadsafe: yes
api_version: 1

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

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

DESPUÉS:

Con los cambios requeridos que se describieron, este es el app.yaml de reemplazo 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 están disponibles para los entornos de ejecución de segunda generación en 2021, algunos entornos de ejecución, incluido Python 3, requieren un arranque adicional para acceder a esas APIs, como ndb, taskqueue y memcache. Esta línea en la configuración tiene ese propósito.

Actualiza requirements.txt

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

ANTES:

A continuación, se muestra lo que se incluye en app.yaml al final del Módulo 12:

flask

DESPUÉS:

Solo debes agregar el SDK de Python en App Engine. 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 aprueba y que están disponibles en los servidores de App Engine, probablemente porque contienen código C/C++ que los desarrolladores no pueden implementar en la nube y ya no están disponibles en los entornos de ejecución de 2a generación.
  • Ya no es necesario copiar bibliotecas no integradas (a veces denominadas "proveedores" o "agrupación automática") en los entornos de ejecución de 2a generación. En su lugar, 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 2a generación, App Engine instala automáticamente los paquetes de terceros enumerados en requirements.txt. Resumen:

  1. No deben incluirse bibliotecas de terceros autoempaquetadas ni copiadas. incluirlas 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 deben enumerar bibliotecas de terceros integradas (por lo tanto, no hay una sección libraries) en app.yaml. incluirla en requirements.txt
  4. Si no hay bibliotecas de terceros a las que hacer referencia desde tu app, significa que no hay un archivo appengine_config.py.

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

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

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

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

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

ANTES:

A continuación, se muestra la 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 puerto de Python 3, importa el SDK y une 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 cambian de 2.x a 3.x para acceder a los servicios agrupados. Si no estás usando Flask, también hay muestras de Django y Pirámide en los documentos. Si tu código de Python 2 no es una app web, solo incluir el paquete del SDK debería ser suficiente cuando se realiza la portabilidad a Python 3. El código de nuestra aplicación se creó originalmente para funcionar con Python 2 y 3, por lo que no se necesitan cambios adicionales de compatibilidad.

Implemente la aplicación

Después de completar los cambios anteriores, puedes implementar la app de ejemplo actualizada. (no hay problema cuando implementas una versión de Python 3 de tu aplicación sobre una versión original de Python 2 en el mismo proyecto de GCP). El comportamiento de la aplicación debería ser el mismo. Si necesitas comparar tu app actualizada con la nuestra, consulta la carpeta del módulo 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 de lanzamiento de funciones y el codelab del módulo 17.

¡Felicitaciones por completar el paso adicional en el módulo 12! Consulta también la documentación sobre cómo preparar archivos de configuración para el entorno de ejecución de Python 3. Consulta la sección anterior Resumen/Limpieza para conocer los próximos pasos y realizar una limpieza.

8. Recursos adicionales

A continuación, se incluyen recursos adicionales para los desarrolladores que exploran este módulo o uno relacionado, así como productos relacionados. Esto incluye lugares donde enviar comentarios sobre este contenido, vínculos al código y varios documentos que pueden resultarte útiles.

Problemas o comentarios sobre el codelab

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, encontrarás los vínculos a las carpetas de repositorio del Módulo 2 (COMENZAR) y Módulo 12 (FINALIZAR). También puedes acceder a ellos desde el repositorio para todas las migraciones del codelab de App Engine. 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, hay recursos en línea que pueden ser relevantes para este tutorial:

App Engine

Cloud Memorystore y Cloud Datastore

Otra información de Cloud

Videos

Licencia

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