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

1. Panoramica

La serie di codelab Serverless Migration Station (tutorial pratici e self-service) e i video correlati mirano ad aiutare gli sviluppatori Google Cloud serverless a modernizzare le proprie applicazioni guidandoli attraverso una o più migrazioni, principalmente abbandonando i servizi legacy. In questo modo le tue app saranno più portabili e avrai più opzioni e flessibilità, consentendoti di integrare e accedere a una gamma più ampia di prodotti Cloud e di eseguire più facilmente l'upgrade a release delle lingue più recenti. Pur concentrandosi inizialmente sui primi utenti di Cloud, principalmente sviluppatori di App Engine (ambiente standard), questa serie è sufficientemente ampia da includere altre piattaforme serverless come Cloud Functions e Cloud Run, o altrove, se applicabile.

Questo codelab ti insegna come includere e utilizzare memcache di App Engine nell'app di esempio del codelab del Modulo 1. Aggiungiamo l'utilizzo di Memcache in questo tutorial del modulo 12, quindi eseguiamo la migrazione a Cloud Memorystore nel modulo 13.

Imparerai a utilizzare

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

Che cosa ti serve

Sondaggio

Come utilizzerai questo tutorial?

Solo lettura Leggilo e completa gli esercizi

Come valuteresti la tua esperienza con Python?

Principiante Livello intermedio Eccellente

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

Principiante Livello intermedio Eccellente

2. Sfondo

Per eseguire la migrazione dalla memcache di App Engine, aggiungine l'utilizzo all'attuale app Flask e all'app NDB di App Engine risultante dal codelab del Modulo 1. L'app di esempio mostra le dieci visite più recenti all'utente. Se lo stesso utente aggiorna il browser, non è opportuno 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 raggiunge la pagina, queste visite vengono restituite dalla cache. Se un nuovo utente visita il sito o se è trascorsa un'ora, la cache viene svuotata e sostituita con le voci più recenti (per non parlare di una nuova visita registrata). Con questa integrazione della memcache di App Engine implementata, possiamo eseguirne la migrazione a Cloud Memorystore nel prossimo codelab (Modulo 13).

Questo tutorial illustra i seguenti passaggi:

  1. Configurazione/pre-lavoro
  2. Aggiorna configurazione
  3. Modifica il codice dell'applicazione

3. Configurazione/pre-lavoro

Prima di passare alla parte principale del tutorial, impostiamo il progetto, recuperiamo il codice ed eseguiamo il deployment dell'app di base in modo da sapere di aver iniziato con il codice funzionante.

1. Configura il progetto

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

2. Ottieni app di esempio di riferimento

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

Che tu usi il tuo o il nostro, il codice del Modulo 1 è il punto di partenza. Questo codelab ti guiderà in ogni passaggio, concludendo con un codice simile a quello presente nella cartella dei repository del modulo 11 (FINISH).

La directory dei file di AVVIO del modulo 1 (tuoi o nostri) dovrebbe avere il seguente aspetto:

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

3. (Ri)Esegui il deployment dell'app di base

I passaggi preliminari rimanenti da eseguire ora:

  1. Acquisisci 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

Dopo aver eseguito correttamente questi passaggi e aver verificato che la tua applicazione web funziona (con output simile all'output riportato di seguito), puoi iniziare ad 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. Modifica i file delle applicazioni

Poiché stiamo aggiungendo solo un'API App Engine, non ci sono pacchetti esterni, quindi 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 quel 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 precedente del codice e 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

Aggiungere la memorizzazione nella cache con il supporto di Memcache

La modifica più significativa è l'aggiunta dell'uso della memorizzazione nella cache nella nostra applicazione. In particolare, dobbiamo memorizzare nella cache le visite più recenti, verificare se le visite memorizzate nella cache sono disponibili e tentare di utilizzare il più possibile i risultati memorizzati nella cache in base al nostro piano. Di seguito sono riportati i passaggi che l'app eseguirà per raggiungere il nostro obiettivo:

  1. Imposta visita in corso e chiamala visitor
  2. Tentativo di recuperare l'elemento visits più recente dalla cache
  3. Se la cache è vuota o il visitatore più recente (visits[0]['visitor']) è diverso dal visitor corrente: memorizza la 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 i prima e dopo 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 grafica delle modifiche apportate:

b1242503602f7bf0.png

Con questo si concluderanno tutte le modifiche necessarie per aggiungere l'utilizzo di App Engine memcache all'app di esempio del Modulo 1. Costruiamo ed eseguiamo il deployment di questa app per farla funzionare.

6. Riepilogo/Pulizia

In questa sezione si conclude questo codelab eseguendo il deployment dell'app e verificando che funzioni come previsto e in qualsiasi output riportato. Dopo la convalida dell'app, esegui tutti i passaggi di pulizia e considera i passaggi successivi.

Esegui il deployment e verifica l'applicazione

Esegui di nuovo il deployment dell'app con gcloud app deploy e verifica che funzioni. Il codice dovrebbe corrispondere al contenuto in FINISH, la cartella del modulo 12. L'output dovrebbe essere identico all'app del modulo 1 di cui hai eseguito il deployment in precedenza:

a7a9d2b80d706a2b.png

Abbiamo solo accelerato l'esperienza utente per lo stesso utente. Quando vengono aggiornati, dovresti ottenere i risultati direttamente dalla cache, il che non crea una nuova visita né effettua un recupero di Datastore.

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

Esegui la pulizia

Generale

Se per il momento hai finito, ti consigliamo di disabilitare l'app App Engine per evitare di incorrere in fatturazione. Tuttavia, se desideri eseguire altri test o sperimentarli, la piattaforma App Engine ha una quota senza costi, pertanto, se non superi il livello di utilizzo, non ti verrà addebitato alcun costo. Questo riguarda il computing, ma potrebbero essere addebitati costi anche per i servizi App Engine pertinenti, quindi consulta la pagina dei prezzi per ulteriori informazioni. Se la migrazione coinvolge altri servizi Cloud, questi vengono fatturati separatamente. In entrambi i casi, se applicabile, consulta la sezione "Specifici di questo codelab" di seguito.

Per garantire la piena divulgazione, il deployment su una piattaforma di serverless computing di Google Cloud come App Engine comporta costi minori di build e archiviazione. Cloud Build e Cloud Storage hanno una quota senza costi specifica. Lo spazio di archiviazione dell'immagine esaurisce una parte della quota. Tuttavia, potresti risiedere in una regione che non ha un livello senza costi, quindi tieni presente l'utilizzo dello spazio di archiviazione per ridurre al minimo i costi potenziali. "cartelle" specifiche di Cloud Storage da 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 allo spazio di archiviazione riportati sopra dipendono dalla tua PROJECT_ID e dalla tua *LOC*azione, ad esempio "us" se la tua app è ospitata negli Stati Uniti.

Se invece non intendi continuare con questa applicazione o con altri codelab di migrazione correlati e vuoi eliminare tutto completamente, chiudi il progetto.

Specifico di questo codelab

I servizi elencati di seguito sono esclusivi per questo codelab. Per ulteriori informazioni, fai riferimento alla documentazione di ciascun prodotto:

  • Il servizio Memcache di App Engine è disponibile in due versioni diverse, ciascuna con una propria struttura dei prezzi, pertanto devi tenere traccia dell'utilizzo in relazione alla fatturazione.
  • Il servizio App Engine Datastore è fornito da Cloud Datastore (Cloud Firestore in modalità Datastore), che prevede anche un livello senza costi; consulta la pagina relativa ai prezzi per ulteriori informazioni.

Passaggi successivi

La prossima migrazione logica da considerare è 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 azioni per modernizzare le proprie applicazioni. Il servizio Cloud Memorystore è un upgrade significativo all'memcache di App Engine per molti motivi:

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

Se non ritieni di aver bisogno di tutte le funzionalità disponibili in Cloud Memorystore o temi che possano influire sui costi, puoi scegliere di continuare a utilizzare App Engine Memcache.

Oltre il Modulo 13 ci sono tutta una serie di altre possibili migrazioni come Cloud NDB e Cloud Datastore o Cloud Tasks. Esistono anche migrazioni tra prodotti a Cloud Run e Cloud Functions. Li troverai tutti nel repository di migrazione.

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

7. BONUS: migrazione a Python 3

Panoramica

Questa sezione comprende contenuti bonus facoltativi per la migrazione dell'applicazione del Modulo 12 appena terminata a Python 3. Iniziamo con la configurazione seguita dall'applicazione.

Semplifica app.yaml

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

PRIMA:

Di seguito è riportato il contenuto del documento app.yaml alla conclusione 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 semplicemente rimuovere l'intera sezione handlers:. Inoltre, threadsafe e api_version sono stati ritirati.

DOPO:

Con le modifiche richieste appena descritte, questa è la sostituzione di app.yaml per Python 3:

runtime: python39
app_engine_apis: true

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

Aggiorna requirements.txt

In requirements.txt è richiesto un altro bootstrap delle API originali: è necessario includere l'accesso al nuovo SDK di App Engine.

PRIMA:

Di seguito è riportato il contenuto del documento app.yaml alla conclusione del modulo 12:

flask

DOPO:

Basta aggiungere l'SDK Python di App Engine. Dovresti avere quanto segue:

flask
appengine-python-standard

Elimina appengine_config.py e lib

I runtime App Engine di nuova generazione rinnovano l'utilizzo di 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++ di cui 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 "auto-bundling") non è più necessaria nei runtime di seconda generazione. Devono invece essere elencate in requirements.txt, dove il sistema di build 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. Riassunto:

  1. Nessuna libreria di terze parti copiata o in un unico bundle. elencali in requirements.txt
  2. Nessun pip install in una cartella lib, il che significa che nessun punto della cartella lib
  3. Nessun elenco delle librerie di terze parti integrate (quindi nessuna sezione libraries) in app.yaml; elencali in requirements.txt
  4. Se non esistono librerie di terze parti a cui fare riferimento dalla tua app, significa che nessun file appengine_config.py

Elencare tutte le librerie di terze parti desiderate in requirements.txt è l'unico requisito degli sviluppatori.

Aggiorna l'applicazione per utilizzare l'SDK di App Engine

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

  1. SDK App Engine in bundle (in requirements.txt)
  2. Attiva l'SDK App Engine (in app.yaml)
  3. Aggrega oggetto WSGI (in main.py)

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

PRIMA:

Di seguito è riportato il main.py di Python 2 alla conclusione 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 la porta Python 3, importa l'SDK e aggrega l'oggetto app Flask al suo interno (il wrapper SDK), ottenendo il seguente risultato:

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 la portabilità da 2.x a 3.x per accedere ai servizi in bundle. Se non utilizzi Flask, la documentazione contiene anche esempi di Django e Pyramid. Se il codice Python 2 non è un'app web, è sufficiente includere il pacchetto SDK durante la portabilità in Python 3. Il codice della nostra 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 riportate sopra, puoi eseguire il deployment dell'app di esempio aggiornata. Non si verificano problemi quando viene eseguito il deployment di una versione Python 3 dell'app su una versione Python 2 originale nello stesso progetto Google Cloud. Il comportamento dell'app dovrebbe rimanere invariato. Se devi confrontare la tua app aggiornata con la nostra, vedi la cartella del modulo 12b nel repository di migrazione. Per saperne di più sul supporto dei servizi in bundle di App Engine nei runtime più recenti come Python 3, fai riferimento all'annuncio sul lancio delle funzionalità e al 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 di Python 3. Consulta la sezione Riepilogo/Pulizia in alto per i passaggi successivi e la pulizia.

8. Risorse aggiuntive

Di seguito sono elencate le risorse aggiuntive per gli sviluppatori che esplorano ulteriormente questo modulo di migrazione o i prodotti correlati, nonché i prodotti correlati. tra cui posizioni in cui fornire feedback su questi contenuti, link al codice e vari documenti che potrebbero esserti utili.

Problemi/feedback del codelab

Se riscontri problemi con questo codelab, cercali prima di procedere con l'invio. Link per eseguire ricerche e creare nuovi problemi:

Risorse di migrazione

I link alle cartelle repository per il modulo 2 (START) e il modulo 12 (FINISH) sono disponibili nella tabella seguente. Sono inoltre accessibili dal repository per tutte le migrazioni del codelab di App Engine che puoi clonare o scaricare un file ZIP.

Codelab

Python 2

Python 3

Module 1

codice

code (non presente in questo tutorial)

Modulo 12 (questo codelab)

codice

codice

Riferimenti online

Di seguito sono riportate alcune risorse online che potrebbero essere pertinenti per questa esercitazione:

App Engine

Cloud Memorystore e Cloud Datastore

Altre informazioni su Cloud

Video

Licenza

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