Come utilizzare Memcache di App Engine nelle app Flask (modulo 12)

1. Panoramica

La serie di codelab Serverless Migration Station (esercitazioni pratiche e autonome) e i video correlati hanno lo scopo di aiutare gli sviluppatori serverless di Google Cloud a modernizzare le loro applicazioni guidandoli attraverso una o più migrazioni, principalmente abbandonando i servizi legacy. In questo modo, le tue app sono più portatili e hai più opzioni e flessibilità, il che ti consente di integrarti e accedere a una gamma più ampia di prodotti cloud e di eseguire più facilmente l'upgrade alle versioni più recenti del linguaggio. Sebbene inizialmente si concentri sui primi utenti di Cloud, principalmente gli sviluppatori di App Engine (ambiente standard), questa serie è abbastanza ampia da includere altre piattaforme serverless come Cloud Functions e Cloud Run o altrove, se applicabile.

Questo codelab ti insegna come includere e utilizzare App Engine Memcache nell'app di esempio del codelab del modulo 1. In questo tutorial del modulo 12 aggiungiamo l'utilizzo di Memcache, per poi eseguire la migrazione a Cloud Memorystore nel modulo 13.

Imparerai a utilizzare

  • Utilizza l'API/libreria Memcache di App Engine
  • Aggiungere la memorizzazione nella cache a un'app Python 2 Flask App Engine NDB di base

Che cosa ti serve

Sondaggio

Come utilizzerai questo tutorial?

Leggilo e basta Leggilo e completa gli esercizi

Come valuteresti la tua esperienza con Python?

Principiante Intermedio Avanzato

Come valuti la tua esperienza di utilizzo dei servizi Google Cloud?

Principiante Intermedio Avanzato

2. Sfondo

Per eseguire la migrazione da App Engine Memcache, aggiungi il suo utilizzo all'app Flask e App Engine NDB esistente risultante dal codelab del modulo 1. L'app di esempio mostra le dieci visite più recenti dell'utente. Se lo stesso utente aggiorna il browser, non è ottimale creare continuamente nuove entità Visita e recuperare le visite più recenti da Datastore, pertanto memorizzeremo nella cache le visite più recenti.

Se lo stesso visitatore visita la pagina, queste visite vengono restituite dalla cache. Se un nuovo utente visita il sito o è trascorsa un'ora, la cache viene svuotata e sostituita con le voci più recenti (e viene registrata una nuova visita). Con questa integrazione di App Engine Memcache implementata, possiamo eseguirne la migrazione a Cloud Memorystore nel prossimo codelab (modulo 13).

Questo tutorial prevede i seguenti passaggi:

  1. Configurazione/preparazione
  2. Aggiorna configurazione
  3. Modificare il codice dell'applicazione

3. Configurazione/preparazione

Prima di passare alla parte principale del tutorial, configuriamo il progetto, recuperiamo il codice e poi implementiamo l'app di base per assicurarci di iniziare con un codice funzionante.

1. Configura il progetto

Se hai completato il codelab del modulo 1, ti consigliamo di riutilizzare lo stesso progetto (e codice). In alternativa, puoi creare un nuovo progetto o riutilizzarne uno esistente. Assicurati che il progetto abbia un account di fatturazione attivo e che App Engine sia abilitato.

2. Ottieni l'app di esempio di base

Uno dei prerequisiti di questo codelab è avere un'app di esempio del modulo 1 funzionante. Se non ne hai una, completa uno dei tutorial (link sopra) prima di procedere. Altrimenti, se hai già familiarità con i contenuti, puoi iniziare direttamente con il codice del Modulo 1 riportato di seguito.

Che tu utilizzi il tuo o il nostro, il codice del Modulo 1 è il punto di partenza. Questo codelab ti guida in ogni passaggio e si conclude con un codice simile a quello presente nella cartella del repository del modulo 11 (FINISH).

La directory dei file START di Module 1 (tuoi o nostri) dovrebbe avere il seguente aspetto:

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

3. (Esegui di nuovo il deployment dell'app di base

I passaggi preliminari rimanenti da eseguire ora:

  1. Acquisisci di nuovo familiarità con lo strumento a riga di comando gcloud
  2. Esegui di nuovo il deployment dell'app di esempio con gcloud app deploy
  3. Verifica che l'app venga eseguita su App Engine senza problemi

Una volta eseguiti correttamente questi passaggi e verificato che la tua app web funzioni (con un output simile a quello riportato di seguito), puoi aggiungere l'utilizzo della memorizzazione nella cache alla tua app.

a7a9d2b80d706a2b.png

4. Aggiorna configurazione

Non sono necessarie modifiche ai file di configurazione standard di App Engine (app.yaml, requirements.txt, appengine_config.py).

5. Modificare i file dell'applicazione

Poiché aggiungiamo solo un'API App Engine, non sono coinvolti pacchetti esterni, il che significa che non è necessario aggiornare i file di configurazione (app.yaml, requirements.txt, appengine_config.py). Esiste un solo file dell'applicazione, main.py, quindi tutte le modifiche in questa sezione interessano solo questo file.

Importazioni

Il passaggio più importante è importare la libreria Memcache, google.appengine.api.memcache. Poiché memorizzeremo nella cache le visite più recenti per un'ora, aggiungiamo anche una costante per il numero di secondi in un'ora. Di seguito è riportato l'aspetto del codice prima e dopo questa modifica:

PRIMA:

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

app = Flask(__name__)

DOPO:

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

app = Flask(__name__)
HOUR = 3600

Aggiungi la memorizzazione nella cache con il supporto di Memcache

La modifica più significativa è l'aggiunta dell'utilizzo della memorizzazione nella cache nella nostra applicazione. Più nello specifico, dovremmo memorizzare nella cache le visite più recenti, verificare se sono disponibili visite memorizzate nella cache e tentare di utilizzare i risultati memorizzati nella cache il più possibile in base al nostro piano. Questi sono i passaggi che l'app seguirà per raggiungere il nostro obiettivo:

  1. Imposta la visita corrente e chiamala visitor
  2. Tentativo di recupero dell'visits più recente dalla cache
  3. Se la cache è vuota o l'ultimo visitatore (visits[0]['visitor']) è diverso dall'attuale visitor: memorizza questa visita più recente, recupera le visite più recenti e memorizzale nella cache per un'ora.
  4. Mostra visits all'utente tramite il modello web

Ecco il prima e il dopo con questi aggiornamenti:

PRIMA:

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

DOPO:

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

Ecco una rappresentazione illustrata delle modifiche apportate:

b1242503602f7bf0.png

Con questo si concludono tutte le modifiche necessarie per aggiungere l'utilizzo di App Engine memcache all'app di esempio del modulo 1. Creiamo ed eseguiamo il deployment di questa app per vederla in azione.

6. Riepilogo/Pulizia

Questa sezione conclude il codelab eseguendo il deployment dell'app, verificando che funzioni come previsto e in qualsiasi output riflesso. Dopo la convalida dell'app, esegui i passaggi di pulizia e valuta i passaggi successivi.

Esegui il deployment e verifica l'applicazione

Esegui nuovamente il deployment dell'app con gcloud app deploy e verifica che funzioni. Il codice ora dovrebbe corrispondere a quello presente in FINISH, nella cartella Module 12. L'output dovrebbe essere identico all'app del modulo 1 che hai implementato in precedenza:

a7a9d2b80d706a2b.png

Abbiamo semplicemente velocizzato l'esperienza utente per lo stesso utente. Quando aggiornano, dovresti ottenere i risultati direttamente dalla cache, il che non crea una nuova visita né esegue un recupero di Datastore.

Congratulazioni per aver completato il codelab del modulo 12 per l'aggiunta dell'utilizzo del servizio App Engine memcache alla nostra applicazione di esempio. Ora hai la possibilità di eseguire il porting di questa app Python 2 a Python 3 nel passaggio bonus.

Esegui la pulizia

Generale

Se hai finito per il momento, ti consigliamo di disattivare l'app App Engine per evitare addebiti. Tuttavia, se vuoi fare altri test o esperimenti, la piattaforma App Engine ha una quota senza costi e, finché non superi questo livello di utilizzo, non ti verranno addebitati costi. Questo vale per il calcolo, ma potrebbero essere addebitati anche costi per i servizi App Engine pertinenti, quindi consulta la pagina dei prezzi per ulteriori informazioni. Se questa migrazione coinvolge altri servizi cloud, questi vengono fatturati separatamente. In entrambi i casi, se applicabile, consulta la sezione "Specifiche per questo codelab" di seguito.

Per una divulgazione completa, il deployment su una piattaforma di calcolo serverless di Google Cloud come App Engine comporta costi di build e archiviazione minimi. Cloud Build ha una propria quota senza costi, così come Cloud Storage. L'archiviazione di questa immagine utilizza parte della quota. Tuttavia, potresti vivere in una regione che non dispone di un livello senza costi, quindi tieni sotto controllo l'utilizzo dello spazio di archiviazione per ridurre al minimo i potenziali costi. Le "cartelle" Cloud Storage specifiche che devi esaminare includono:

  • 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
  • I link di archiviazione riportati sopra dipendono dalla tua PROJECT_ID e dalla tua *LOC*, ad esempio "us" se la tua app è ospitata negli Stati Uniti.

D'altra parte, se non intendi continuare con questa applicazione o con altri codelab di migrazione correlati e vuoi eliminare tutto completamente, chiudi il progetto.

Specifico per questo codelab

I servizi elencati di seguito sono univoci per questo codelab. Per saperne di più, consulta la documentazione di ogni prodotto:

  • Il servizio Memcache di App Engine è disponibile in due versioni diverse, ognuna con una propria struttura tariffaria, quindi devi monitorare l'utilizzo in relazione alla fatturazione.
  • Il servizio App Engine Datastore è fornito da Cloud Datastore (Cloud Firestore in modalità Datastore), che dispone anche di un livello senza costi. Per ulteriori informazioni, consulta la pagina dei prezzi.

Passaggi successivi

La successiva migrazione logica da prendere in considerazione è trattata nel Modulo 13, che mostra agli sviluppatori come eseguire la migrazione dal servizio App Engine memcache a Cloud Memorystore. Queste migrazioni sono tutte facoltative e disponibili per gli utenti che vogliono intraprendere varie procedure per modernizzare le proprie applicazioni. Il servizio Cloud Memorystore è un upgrade significativo di memcache di App Engine per molti motivi:

  • Cloud Memorystore non è serverless. Ciò significa che devi allocare un server per la cache. Cloud Memorystore non ha un Livello senza costi. Entrambi questi fattori possono avere un impatto significativo sul costo.
  • Cloud Memorystore supporta una coppia di diversi meccanismi di archiviazione sottostanti (motori di memorizzazione nella cache), Redis e Memcached.
  • Cloud Memorystore (per Redis) offre un insieme di funzionalità molto più ricco e approfondito rispetto ad App Engine Memcache.
  • Per utilizzare Cloud Memorystore, devi configurare un server Cloud Memorystore, aggiungerlo a una rete VPC di Google Cloud e quindi fare in modo che la tua app App Engine utilizzi questa rete per comunicare con il server Memorystore.

Se ritieni di non aver bisogno di tutte le funzionalità disponibili in Cloud Memorystore o se ti preoccupa l'impatto sui costi, puoi continuare a utilizzare App Engine Memcache.

Oltre al modulo 13, sono disponibili molte altre possibili migrazioni, come Cloud NDB e Cloud Datastore o Cloud Tasks. Esistono anche migrazioni tra prodotti a Cloud Run e Cloud Functions. Puoi trovarli tutti nel repository della migrazione.

Un altro possibile passaggio successivo è il porting a Python 3, che viene trattato nella sezione successiva come passaggio facoltativo.

7. BONUS: Migrazione a Python 3

Panoramica

Questa sezione comprende contenuti bonus facoltativi che eseguono la migrazione dell'applicazione del modulo 12 appena terminata in Python 3. Iniziamo con la configurazione, seguita dall'applicazione.

Semplificare app.yaml

Uno dei vantaggi del runtime Python 3 è che il app.yaml può essere notevolmente semplificato.

PRIMA:

Di seguito è riportato il contenuto di app.yaml al termine del Modulo 12:

runtime: python27
threadsafe: yes
api_version: 1

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

Poiché il runtime Python 3 richiede che i framework web eseguano il proprio routing, tutti i gestori di route in app.yaml devono essere modificati in auto. Se non vengono pubblicati file statici, gli utenti possono rimuovere completamente l'intera sezione handlers:. Inoltre, sia threadsafe che api_version sono stati ritirati.

DOPO:

Con le modifiche richieste appena descritte, questo è il app.yaml sostitutivo per Python 3:

runtime: python39
app_engine_apis: true

L'unica riga che richiede una spiegazione è app_engine_apis: true. Quando i servizi App Engine legacy sono diventati disponibili per i runtime di seconda generazione nel 2021, alcuni runtime, tra cui Python 3, richiedono un bootstrapping aggiuntivo per accedere a queste API come ndb, taskqueue e memcache. Questa riga nella configurazione serve a questo scopo.

Aggiorna requirements.txt

In requirements.txt è necessario un altro bootstrapping delle API originali: deve essere incluso l'accesso al nuovo SDK App Engine.

PRIMA:

Di seguito è riportato il contenuto di app.yaml al termine del Modulo 12:

flask

DOPO:

Basta aggiungere l'SDK Python di App Engine e dovresti avere quanto segue:

flask
appengine-python-standard

Elimina appengine_config.py e lib

I runtime App Engine di nuova generazione rinnovano l'utilizzo dei pacchetti di terze parti:

  • Le librerie integrate sono quelle verificate da Google e rese disponibili sui server App Engine, probabilmente perché contengono codice C/C++ che gli sviluppatori non sono autorizzati a eseguire il deployment nel cloud. Queste librerie non sono più disponibili nei runtime di seconda generazione.
  • La copia delle librerie non integrate (a volte chiamata "vendoring" o "self-bundling") non è più necessaria nei runtime di seconda generazione. Devono invece essere elencate in requirements.txt, dove il sistema di compilazione le installa automaticamente per tuo conto al momento del deployment.

A seguito di queste modifiche alla gestione dei pacchetti di terze parti, non sono necessari né il file appengine_config.py né la cartella lib, quindi eliminali. Nei runtime di seconda generazione, App Engine installa automaticamente i pacchetti di terze parti elencati in requirements.txt. Riepilogo in corso:

  1. Nessuna libreria di terze parti inclusa o copiata; elencale in requirements.txt
  2. Nessun pip install in una cartella lib, il che significa nessuna cartella lib
  3. Nessuna libreria di terze parti integrata nell'elenco (quindi nessuna sezione libraries) in app.yaml; elencale in requirements.txt
  4. Nessuna libreria di terze parti a cui fare riferimento dalla tua app significa nessun file appengine_config.py

L'unico requisito per gli sviluppatori è elencare tutte le librerie di terze parti desiderate in requirements.txt.

Aggiorna l'applicazione per utilizzare l'SDK App Engine

Come accennato in precedenza, le app Python 3 richiedono alcune modifiche per accedere ai servizi in bundle di App Engine:

  1. Bundle dell'SDK di App Engine (in requirements.txt)
  2. Attiva l'SDK App Engine (in app.yaml)
  3. Wrapper dell'oggetto WSGI (in main.py)

La prima coppia è stata completata sopra, quindi l'ultimo requisito è aggiornare main.py.

PRIMA:

Di seguito è riportato il codice Python 2 main.py al termine del Modulo 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

DOPO:

Per il porting di Python 3, importa l'SDK e racchiudi l'oggetto app Flask con l'SDK (il wrapper SDK), ottenendo quanto segue:

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

Gli sviluppatori devono apportare queste modifiche alle loro app Python durante il porting dalla versione 2.x alla 3.x per accedere ai servizi in bundle. Se non utilizzi Flask, nella documentazione sono disponibili anche esempi di Django e Pyramid. Se il tuo codice Python 2 non è un'app web, l'inclusione del pacchetto SDK dovrebbe essere sufficiente per il porting a Python 3. Il nostro codice dell'applicazione è stato originariamente creato per funzionare con Python 2 e 3, quindi non sono necessarie ulteriori modifiche alla compatibilità.

Esegui il deployment di un'applicazione

Dopo aver completato le modifiche precedenti, puoi eseguire il deployment dell'app di esempio aggiornata. Non si verificano problemi durante il deployment di una versione Python 3 dell'app rispetto a una versione Python 2 originale nello stesso progetto GCP. Il comportamento dell'app dovrebbe rimanere invariato. Se devi confrontare la tua app aggiornata con la nostra, consulta la cartella Modulo 12b nel repository di migrazione. Per scoprire di più sul supporto dei servizi in bundle di App Engine nei runtime più recenti come Python 3, consulta l'annuncio del lancio della funzionalità e il codelab del modulo 17.

Congratulazioni per aver completato il passaggio bonus del modulo 12. Consulta anche la documentazione sulla preparazione dei file di configurazione per il runtime Python 3. Per i passaggi successivi e la pulizia, consulta la sezione Riepilogo/Pulizia riportata sopra.

8. Risorse aggiuntive

Di seguito sono elencate risorse aggiuntive per gli sviluppatori che vogliono esplorare ulteriormente questo modulo di migrazione o quelli correlati, nonché i prodotti correlati. Sono inclusi i luoghi in cui fornire feedback su questi contenuti, i link al codice e vari documenti che potresti trovare utili.

Problemi/feedback relativi ai codelab

Se riscontri problemi con questo codelab, cerca prima il tuo problema prima di presentare una segnalazione. Link per cercare e creare nuovi problemi:

Risorse per la migrazione

I link alle cartelle del repository per il modulo 2 (INIZIO) e il modulo 12 (FINE) sono disponibili nella tabella di seguito. Puoi accedervi anche dal repository per tutte le migrazioni dei codelab di App Engine, che puoi clonare o scaricare come file ZIP.

Codelab

Python 2

Python 3

Module 1

code

Codice (non incluso in questo tutorial)

Modulo 12 (questo codelab)

code

code

Riferimenti online

Di seguito sono riportate risorse online che potrebbero essere pertinenti per questo tutorial:

App Engine

Cloud Memorystore e Cloud Datastore

Altre informazioni sul cloud

Video

Licenza

Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.