Migrazione a Cloud NDB

Località App Engine

App Engine è regionale, il che significa che l'infrastruttura che esegue le tue app in una regione specifica e Google la gestisce in modo che sia disponibile in modo ridondante tutte le zone all'interno di quella regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è fondamentale i fattori necessari per selezionare la regione in cui vengono eseguite le tue app. In genere, puoi seleziona la regione più vicina agli utenti della tua app, ma devi considerare località in cui è disponibile App Engine nonché le località dell'altro Prodotti e servizi Google Cloud utilizzati dalla tua app. Utilizzo dei servizi in più località può influire sulla latenza dell'app e sulle sue pricing.

Non puoi modificare la regione di un'app dopo averla impostata.

Se hai già creato un'applicazione App Engine, puoi visualizzarne la regione effettuando una delle seguenti operazioni:

Cloud NDB è una libreria client per Python che sostituisce NDB di App Engine. L'NDB di App Engine consente alle app Python 2 di archiviare ed eseguire query sui dati in Database Datastore. Cloud NDB consente alle app Python 2 e Python 3 di archiviare ed eseguire query sui dati negli stessi database, ma il prodotto che gestisce i database sono passati da Datastore Firestore in modalità Datastore. Sebbene la libreria Cloud NDB possa accedere a tutti i dati creati con NDB di App Engine, alcuni tipi di dati strutturati archiviati utilizzando Cloud NDB non sono accessibili con l'NDB di App Engine. Per questo motivo, la migrazione a Cloud NDB deve essere considerata irreversibile.

Ti consigliamo di eseguire la migrazione a Cloud NDB prima di eseguire l'upgrade del a Python 3. Questo approccio incrementale alla migrazione consente di mantenere un'app funzionante e testabile in tutto di migrazione.

Cloud NDB è destinato a sostituire le funzionalità in App Engine NDB, non supporterà le nuove funzionalità di Firestore Modalità Datastore. Consigliamo alle nuove app Python 3 di utilizzare Libreria client in modalità Datastore anziché Cloud NDB.

Per maggiori informazioni su Cloud NDB, consulta le seguenti pagine su GitHub:

Confronto tra NDB di App Engine e Cloud NDB

Analogie:

  • Cloud NDB supporta quasi tutte le funzionalità supportate da App Engine NDB con solo lievi differenze nella sintassi del metodo.

Differenze:

  • API NDB di App Engine che si basano su App Engine Python 2.7 che i servizi specifici del runtime siano stati aggiornati o rimossi Cloud NDB.

  • Le nuove funzionalità di Python 3 e Django hanno eliminato la necessità di google.appengine.ext.ndb.django_middleware. Puoi invece semplificare e scrivere il tuo middleware con poche righe di codice.

  • App richieste NDB di App Engine e database Datastore nello stesso progetto Google Cloud, con App Engine fornendo automaticamente le credenziali. Cloud NDB può accedere in qualsiasi progetto, a condizione che di autenticare il client in modo adeguato. Questo approccio è coerente con gli altri API e librerie client.

  • Cloud NDB non utilizza il servizio Memcache di App Engine per memorizzare i dati nella cache.

    Cloud NDB può invece memorizzare nella cache i dati in un datastore in memoria Redis gestito da Memorystore Redis Labs, o in altri sistemi. Sebbene al momento siano supportati solo i datastore Redis, Cloud NDB ha generalizzato e definito la memorizzazione nella cache in modalità astratta GlobalCache in grado di supportare ulteriori implementazioni concrete.

    Per accedere a Memorystore for Redis, l'app deve utilizzare Accesso VPC serverless.

    Né Memorystore for Redis né l'accesso VPC serverless offrono un Livello gratuito e questi prodotti potrebbero non essere disponibili nella regione della tua app. Per ulteriori informazioni, consulta Prima di iniziare la migrazione.

L'elenco completo delle differenze è disponibile nelle note sulla migrazione per Progetto GitHub di Cloud NDB.

Esempi di codice:

Prima di avviare la migrazione

Prima di avviare la migrazione:

  1. Se non l'hai ancora fatto, configura il tuo Ambiente di sviluppo Python per utilizzare una versione Python. compatibile con Google Cloud e installare strumenti di test per creare in ambienti Python isolati.

  2. Stabilisci se è necessario memorizzare i dati nella cache.

  3. Se devi memorizzare i dati nella cache, assicurati che la regione della tua app sia supportata da accesso VPC serverless e Memorystore for Redis.

  4. Informazioni sulle autorizzazioni della modalità Datastore.

Determinare se è necessario memorizzare i dati nella cache

Se la tua app ha bisogno di memorizzare dati nella cache, ricorda che Memorystore for Redis e Accesso VPC serverless non hanno un livello gratuito e non supportano tutte regioni di Google Cloud.

In generale:

  • Se l'app legge spesso gli stessi dati, la memorizzazione nella cache potrebbe ridurre la latenza.

  • Maggiore è il numero di richieste gestite dall'app, maggiore sarà l'impatto che la memorizzazione nella cache potrebbe avere.

Per vedere quanto attualmente fai affidamento sui dati memorizzati nella cache, visualizza la dashboard Memcache per vedere il rapporto tra hit e fallimenti della cache. Se il rapporto è elevato, utilizza una cache di dati ha probabilmente un grande impatto sulla riduzione una latenza di pochi millisecondi.

Vai alla memcache di App Engine

Per informazioni sui prezzi, consulta Prezzi di Memorystore e i prezzi dell'accesso VPC serverless.

Conferma della regione dell'app

Se devi memorizzare nella cache i dati, assicurati che la regione della tua app sia supportata da Memorystore for Redis e Accesso VPC serverless:

  1. Visualizza la regione della tua app, mostrata vicino alla parte superiore dello Dashboard di App Engine nella console Google Cloud.

    Vai ad App Engine

    L'area viene visualizzata nella parte superiore della pagina, appena sotto il URL.

  2. Verifica che la tua app sia in uno dei regioni supportate dall'accesso VPC serverless.

  3. Verifica che la tua app si trovi in una delle regioni supportate da Memorystore for Redis: visita la pagina Crea connettore e visualizza le regioni nell'elenco Regioni.

    Vai all'accesso VPC serverless

Se la tua app non si trova in una regione supportata da Memorystore for Redis e Accesso VPC serverless:

  1. Creare un progetto Google Cloud.

  2. Crea una nuova app App Engine nel progetto e selezionane una supportata regione.

  3. Crea i servizi Google Cloud che la tua app utilizza nel nuovo progetto.

    In alternativa, puoi aggiornare l'app in modo che utilizzi i servizi esistenti nel tuo progetto precedente, ma i prezzi e l'utilizzo delle risorse potrebbero essere diversi in un progetto e in una regione diversi. Invita alla documentazione di ogni servizio per ulteriori informazioni.

  4. Esegui il deployment dell'app nel nuovo progetto.

Informazioni sulle autorizzazioni della modalità Datastore

Ogni interazione con un servizio Google Cloud deve essere autorizzata. Per ad esempio per archiviare o eseguire query sui dati in un database in modalità Datastore, la tua app deve fornire le credenziali di un account autorizzato a per accedere al database.

Per impostazione predefinita, l'app fornisce le credenziali di App Engine account di servizio predefinito, che è autorizzato ad accedere ai database nello stesso progetto della tua app.

Dovrai usare una tecnica di autenticazione alternativa che in modo esplicito fornisce le credenziali se una delle seguenti condizioni è vera:

  • L'app e il database in modalità Datastore sono in diversi progetti Google Cloud.

  • Hai modificato i ruoli assegnati all'App Engine predefinito l'account di servizio.

Per informazioni sulle tecniche di autenticazione alternative, vedi Configurare l'autenticazione per le applicazioni di produzione da server a server.

Panoramica del processo di migrazione

Per eseguire la migrazione a Cloud NDB:

  1. Aggiorna la tua app Python:

    1. Installa la libreria client di Cloud NDB.

    2. Aggiorna le istruzioni di importazione per importare i moduli da Cloud NDB.

    3. Aggiungi il codice che crea un client Cloud NDB. Il cliente possono leggere le variabili di ambiente della tua app e utilizzare i dati per l'autenticazione con la modalità Datastore.

    4. Aggiungi codice che utilizza il contesto di runtime del client per mantenere la memorizzazione nella cache e separate tra i thread.

    5. Rimuovi o aggiorna il codice che utilizza metodi e proprietà che non sono più a lungo.

  2. Abilitare la memorizzazione nella cache.

  3. Verifica gli aggiornamenti.

  4. Esegui il deployment dell'app in App Engine.

    Come per qualsiasi modifica apportata alla tua app, valuta la possibilità di utilizzare il traffico e per diminuire lentamente aumentare il traffico. Monitora attentamente l'app per rilevare eventuali problemi del database prima del routing più traffico verso l'app aggiornata.

Aggiornamento dell'app Python

Installazione della libreria Cloud NDB per le app Python

Per installare la libreria client Cloud NDB nell'app Python di App Engine:

  1. Aggiorna il file app.yaml. Segui le istruzioni per la tua versione di Python:

    Python 2

    Per le app Python 2, aggiungi le ultime versioni di grpcio e setuptools librerie.

    Di seguito è riportato un file app.yaml di esempio:

    runtime: python27
threadsafe: yes
api_version: 1

libraries:
- name: grpcio
  version: latest
- name: setuptools
  version: latest

    Python 3

    Per le app Python 3, specifica l'elemento runtime con un attributo supportato la versione Python 3 ed elimina le righe non necessarie. Ad esempio, app.yaml file potrebbe avere il seguente aspetto:

    runtime: python310 # or another support version

    Il runtime Python 3 installa le librerie automaticamente, quindi devi specificare le librerie integrate nel runtime Python 2 precedente. Se la tua app Python 3 utilizza altri servizi in bundle legacy quando migrazione, lascia invariato il file app.yaml.

  2. Aggiorna il file requirements.txt. Segui le istruzioni relative alla tua versione di Python:

    Python 2

    Aggiungi le librerie client di Cloud per Cloud NDB al tuo elenco di di dipendenze nel file requirements.txt.

    google-cloud-ndb

    Poi esegui pip install -t lib -r requirements.txt per aggiornare l'elenco librerie disponibili per la tua app.

    Python 3

    Aggiungi le librerie client di Cloud per Cloud NDB al tuo elenco di delle dipendenze File requirements.txt.

    google-cloud-ndb

    App Engine installa automaticamente queste dipendenze deployment di app nel runtime Python 3, quindi elimina la cartella lib, se esistente.

  3. Per le app Python 2, se l'app utilizza librerie integrate o copiate specificato nella directory lib, devi specificare quei percorsi nel appengine_config.py file:

    import pkg_resources
from google.appengine.ext import vendor

# Set PATH to your libraries folder.
PATH = 'lib'
# Add libraries installed in the PATH folder.
vendor.add(PATH)
# Add libraries to pkg_resources working set to find the distribution.
pkg_resources.working_set.add_entry(PATH)

    Assicurati di utilizzare il modulo pkg_resources, che garantisce che la tua app utilizza la corretta distribuzione delle librerie client.

    Il file appengine_config.py nell'esempio precedente presuppone che l'elemento La cartella lib si trova nella directory di lavoro attuale. Se non puoi garantisce che lib sia sempre presente nella directory di lavoro attuale, specifica il percorso completo della cartella lib. Ad esempio:

    import os
path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'lib')

    Quando esegui il deployment dell'app, App Engine carica tutte le librerie alla directory specificata nel file appengine_config.py.

Aggiornamento delle istruzioni di importazione

La posizione del modulo NDB è stata spostata in google.cloud.ndb. Aggiorna le istruzioni di importazione dell'app come mostrato nella tabella seguente:

Rimuovi Sostituisci con
from google.appengine.ext import ndb from google.cloud import ndb

Creazione di un client Cloud NDB

Come per altre librerie client basate sulle API Google Cloud, la prima per l'utilizzo di Cloud NDB è creare un Client .. Il client contiene credenziali e altri necessari per la connessione alla modalità Datastore. Ad esempio:

from google.cloud import ndb

client = ndb.Client()

Nello scenario di autorizzazione predefinito descritto in precedenza, il client Cloud NDB contiene le credenziali con l'account di servizio predefinito, che è autorizzato a interagire Modalità Datastore. Se non stai lavorando in questo scenario predefinito, consulta Credenziali predefinite dell'applicazione (ADC) per informazioni su come fornire le credenziali.

Utilizzo del contesto di runtime del client

Oltre a fornire le credenziali necessarie per interagire con in modalità Datastore, il client Cloud NDB contiene context() che restituisce un contesto di runtime. Il contesto di runtime isola le richieste di memorizzazione nella cache e di transazione da altri interazioni simultanee in modalità Datastore.

Tutte le interazioni con la modalità Datastore devono avvenire all'interno di un NDB il contesto di runtime. Poiché la creazione di una definizione del modello non interagisce Modalità Datastore, puoi definire la classe del modello prima di creare Cloud NDB e il recupero di un contesto di runtime, quindi utilizzare contesto di runtime nel gestore delle richieste per ottenere i dati dal database.

Ad esempio:

from google.cloud import ndb


class Book(ndb.Model):
    title = ndb.StringProperty()


client = ndb.Client()


def list_books():
    with client.context():
        books = Book.query()
        for book in books:
            print(book.to_dict())

App multi-thread

Il contesto di runtime restituito dal client Cloud NDB si applica solo a un in un singolo thread. Se la tua app utilizza più thread per una singola richiesta, devi per recuperare un contesto di runtime separato per ogni thread che utilizzerà libreria Cloud NDB.

Utilizzo di un contesto di runtime con framework WSGI

Se la tua app web utilizza un framework WSGI, puoi creare automaticamente un un nuovo contesto di runtime per ogni richiesta, creando un oggetto middleware recupera il contesto di runtime, quindi aggrega l'app è un oggetto middleware.

Nell'esempio seguente di utilizzo del middleware con Flask:

  • Il metodo middleware crea un oggetto middleware WSGI all'interno del runtime contesto del client NDB.

  • L'app Flask è sottoposta a wrapping nell'oggetto middleware.

  • Flask passerà quindi ogni richiesta attraverso l'oggetto middleware, che recupera un nuovo contesto di runtime NDB per ogni richiesta.

from flask import Flask

from google.cloud import ndb


client = ndb.Client()


def ndb_wsgi_middleware(wsgi_app):
    def middleware(environ, start_response):
        with client.context():
            return wsgi_app(environ, start_response)

    return middleware


app = Flask(__name__)
app.wsgi_app = ndb_wsgi_middleware(app.wsgi_app)  # Wrap the app in middleware.


class Book(ndb.Model):
    title = ndb.StringProperty()


@app.route("/")
def list_books():
    books = Book.query()
    return str([book.to_dict() for book in books])

Utilizzo di un contesto di runtime con Django

Il middleware Django fornito dalla libreria NDB di App Engine non è supportato dalla libreria Cloud NDB. Se hai usato questo middleware (google.appengine.ext.ndb.django_middleware) nella tua app, segui questi passaggi per aggiornare la tua app:

  1. Utilizzare il sistema middleware di Django per creare un nuovo contesto di runtime per per ogni richiesta.

    Nell'esempio seguente:

    • Il metodo ndb_django_middleware crea un client Cloud NDB.

    • Il metodo middleware crea un oggetto middleware all'interno del runtime contesto del client NDB.

    from google.cloud import ndb


# Once this middleware is activated in Django settings, NDB calls inside Django
# views will be executed in context, with a separate context for each request.
def ndb_django_middleware(get_response):
    client = ndb.Client()

    def middleware(request):
        with client.context():
            return get_response(request)

    return middleware

  2. Nel file settings.py di Django, aggiorna il MIDDLEWARE predefinita in modo che elenca il nuovo middleware creato al posto di google.appengine.ext.ndb.NdbDjangoMiddleware.

Ora Django passerà ogni richiesta attraverso l'oggetto middleware che hai elencato l'impostazione MIDDLEWARE e questo oggetto recupererà un nuovo runtime NDB contesto per ogni richiesta.

Aggiornamento del codice per le API NDB rimosse o modificate

Le API NDB che si basano su API e servizi specifici di App Engine hanno che è stato aggiornato o rimosso dalla libreria Cloud NDB.

Dovrai aggiornare il codice se utilizza una delle seguenti API NDB:

Modelli e proprietà del modello

I seguenti metodi da google.appengine.ext.ndb.Model non sono disponibili nella libreria Cloud NDB perché utilizzano API specifiche di App Engine non più disponibili.

API rimossa Sostituzione
Model.get_indexes e
Model.get_indexes_async 		Nessuno
Model._deserialize e
Model._serialize 		Nessuno
Model.make_connection Nessuno

Nella tabella seguente vengono descritti gli specifici google.appengine.ext.ndb.Model che sono state modificate nella libreria Cloud NDB:

Proprietà Cambia
TextProperty Impossibile indicizzare google.cloud.ndb.TextProperty. Se prova a impostare google.cloud.ndb.TextProperty.indexed, verrà generato un NotImplementedError.
StringProperty StringProperty è sempre indicizzati. Se provi a impostare google.cloud.ndb.StringProperty.indexed, un Verranno aumentati NotImplementedError.
Tutte le proprietà con argomenti name o kind in il costruttore. name o kind devono essere str tipi di dati, poiché unicode è stato sostituito da str in Python 3.

Le classi e i metodi nella seguente tabella non sono più disponibili perché usano risorse specifiche di App Engine che non sono più disponibili.

API rimossa Sostituzione
google.appengine.ext.ndb.msgprop.MessageProperty e
google.appengine.ext.ndb.msgprop.EnumProperty 		Nessuno

Se provi a creare questi oggetti, viene eseguito un NotImplementedError verrà sollevato.
da google.appengine.ext.ndb.model.Property:
_db_get_value
_db_set_value
_db_set_compressed_meaning
_db_set_uncompressed_meaning
__creation_counter_global 		Nessuno

Questi metodi si basano su buffer di protocollo in modalità Datastore che sono stati modificati.
Model.make_connection Nessuno

Chiavi

I seguenti metodi da google.appengine.ext.ndb.Key non sono disponibili nella libreria Cloud NDB. Questi metodi erano usati per passare chiavi da e verso l'API DB Datastore, che non è più supportata (DB era il predecessore di App Engine NDB).

API rimossa Sostituzione
Key.from_old_key e
Key.to_old_key 		Nessuno

Sono inoltre state apportate le seguenti modifiche:

NDB di App Engine NDB cloud
I tipi e gli ID stringa devono essere inferiori a 500 byte I tipi e gli ID stringa devono essere inferiori a 1500 byte.
Key.app() restituisce l'ID progetto specificato al momento della hai creato la chiave. Il valore restituito da google.cloud.ndb.Key.app() potrebbe essere diverso dall'originale ID trasmesso al costruttore. Questo perché gli ID app con prefisso come s~example sono identificatori legacy di App Engine. Sono stati sostituiti da ID progetto equivalenti, esempio.

Query

Come l'NDB di App Engine, Cloud NDB fornisce una classe QueryOptions (google.cloud.ndb.query.QueryOptions) che ti consente di riutilizzare un insieme specifico anziché ridefinire per ogni query. Tuttavia, QueryOptions in Cloud NDB non eredita google.appengine.datastore.datastore_rpc.Configuration e pertanto non assistenza ...datastore_rpc.Configuration metodi.

Inoltre, l'app google.appengine.datastore.datastore_query.Order è stata sostituito con google.cloud.ndb.query.PropertyOrder. Simile a Order, il corso PropertyOrder consente di specificare l'ordinamento per più query. PropertyOrder è uguale a quello di Order. Solo il nome del è cambiata.

API rimossa Sostituzione
da google.appengine.datastore.datastore_rpc.Configuration:
deadline(value)
on_completion(value)
read_policy(value)
force_writes(value)
max_entity_groups_per_rpc(value)
max_allocate_ids_keys(value)
max_rpc_bytes(value)
max_get_keys(value)
max_put_entities(value)
max_delete_keys(value)

Consulta le codice sorgente per una descrizione questi metodi.

 Nessuno
google.appengine.ext.ndb.Order
Ad esempio:
order=Order(-Account.birthday, Account.name) 		google.cloud.ndb.PropertyOrder
Ad esempio:
google.cloud.ndb.PropertyOrder(-Account.birthday, Account.name)

Utili

Il modulo ndb.utils (google.appengine.ext.ndb.utils) non è più disponibili. La maggior parte dei metodi di questo modulo riguardava NDB di App Engine, alcuni metodi sono stati ignorati a causa dell'implementazione differenze nel nuovo ndb, mentre altri metodi sono stati resi obsoleti dai nuovi le funzionalità di Python 3.

Ad esempio, il decorator di posizione nel vecchio modulo utils ha dichiarato che solo i primi n argomenti di una funzione o di un metodo possono essere posizionali. Tuttavia, Python 3 possono farlo utilizzando argomenti solo parole chiave. Quello che si scriveva in precedenza:

@utils.positional(2)
def function1(arg1, arg2, arg3=None, arg4=None)
  pass

Può essere scritto in questo modo in Python 3:

def function1(arg1, arg2, *, arg3=None, arg4=None)
  pass

Spazi dei nomi

Gli spazi dei nomi abilitano un multitenant per utilizzare silos di dati separati per ciascun tenant mentre continui a utilizzare lo stesso database in modalità Datastore. In altre parole, ogni tenant archivia all'interno del proprio spazio dei nomi.

Invece di utilizzare App Engine google.appengine.api.namespacemanager, specifichi uno spazio dei nomi predefinito quando crei un client Cloud NDB quindi utilizza lo spazio dei nomi predefinito chiamando i metodi Cloud NDB all'interno il contesto di runtime del client. che segue lo stesso pattern degli altri servizi Google Cloud API che supportano gli spazi dei nomi.

API rimossa Sostituzione
google.appengine.api.namespace_manager.namespace_manager.set_namespace(str) e
google.appengine.api.namespacemanager.getnamespace() 
client=google.cloud.ndb.Client(namespace="my namespace")

with client.context() as context:
    key = ndb.Key("SomeKind", "SomeId")
o 
key-non-default-namespace=ndb.Key("SomeKind," "AnotherId",
namespace="non-default-nspace")
Tutti gli altri metodi google.appengine.api.namespacemanager Nessuno

Tasklets

I Tasklets ora possono utilizzare un'istruzione return standard per restituiscono un risultato invece di generare un'eccezione Return. Ad esempio:

Libreria NDB di App Engine Libreria Cloud NDB 
        @ndb.tasklet
        def get_cart():
          cart = yield
        CartItem.query().fetch_async()
          raise Return(cart)
       
        @ndb.tasklet
        def get_cart():
          cart = yield
        CartItem.query().fetch_async()
          return cart

Tieni presente che puoi comunque restituire risultati in Cloud NDB generando un valore Return un'eccezione, ma è sconsigliato.

Inoltre, i seguenti metodi e sottoclassi Tasklets non sono più disponibile, principalmente a causa dei cambiamenti nel modo in cui un contesto NDB viene creato e utilizzato nella libreria Cloud NDB.

API rimossa Sostituzione
da google.appengine.api.ext.ndb.tasklets:
add_flow_exception
make_context
make_default_context
set_context 		Nessuno
da google.appengine.api.ext.ndb.tasklets:
QueueFuture
ReducedFuture
SerialQueueFuture 		Nessuno

Eccezioni

Mentre la google.cloud.ndb.exceptions nella libreria Cloud NDB contiene molti dei stesse eccezioni alla libreria NDB di App Engine, non tutte le applicazioni sono disponibili eccezioni nella nuova libreria. Nella tabella seguente sono elencate le Eccezioni non più disponibili:

API rimossa Sostituzione
da google.appengine.api.datastore_errors:
BadKeyError
BadPropertyError
CommittedButStillApplying
EntityNotFoundError
InternalError
NeedIndexError
QueryNotFoundError
ReferencePropertyResolveError
Timeout
TransactionFailedError
TransactionNotFoundError 		google.cloud.ndb.exceptions

Attivazione della memorizzazione nella cache dei dati

Cloud NDB può memorizzare nella cache i dati in un datastore in memoria Redis gestito da Memorystore Redis Labs o altri sistemi. Questa guida descrive come usa Memorystore for Redis per memorizzare nella cache i dati:

  1. Configura l'accesso VPC serverless.

  2. Configura Memorystore for Redis

  3. Aggiungi l'URL di connessione Redis all'app.

  4. Crea un oggetto RedisCache.

Configurazione dell'accesso VPC serverless

La tua app può comunicare con Memorystore solo tramite un Connettore di accesso VPC serverless. Per impostare un Connettore di accesso VPC serverless:

  1. Crea un connettore di accesso VPC serverless.

  2. Configura l'app per l'utilizzo del connettore.

Configurazione di Memorystore for Redis

Per configurare Memorystore for Redis:

  1. Crea un'istanza Redis in Memorystore. Quando crei l'istanza:

  2. Prendi nota dell'indirizzo IP e del numero di porta dell'istanza Redis che crei. Utilizzerai queste informazioni quando abiliti la memorizzazione nella cache dei dati per Cloud NDB.

    Assicurati di utilizzare il comando gcloud beta per eseguire il deployment degli aggiornamenti dell'app. Solo il comando beta può aggiornare la tua app in modo che utilizzi un connettore VPC.

Aggiunta dell'URL di connessione Redis

Puoi connetterti alla cache Redis aggiungendo REDIS_CACHE_URL al file app.yaml dell'app. Il valore di REDIS_CACHE_URL assume il seguente formato:

redis://IP address for your instance:port

Ad esempio, puoi aggiungere le seguenti righe al file app.yaml dell'app:

     env_variables:
      REDIS_CACHE_URL: redis://10.0.0.3:6379

Creazione e utilizzo di un oggetto cache Redis

Se hai impostato REDIS_CACHE_URL come variabile di ambiente, puoi creare una con una singola riga di codice, quindi usa la cache passando a Client.context() quando configuri il contesto di runtime:

client = ndb.Client()
global_cache = ndb.RedisCache.from_environment()

with client.context(global_cache=global_cache):
  books = Book.query()
  for book in books:
      print(book.to_dict())

Se non imposti REDIS_CACHE_URL come variabile di ambiente, devi: crea un client Redis e passa il client al ndb.RedisCache() come costruttore. Ad esempio:

global_cache = ndb.RedisCache(redis.StrictRedis(host=IP-address, port=redis_port))

Tieni presente che non è necessario dichiarare una dipendenza dalla libreria client Redis, poiché la libreria Cloud NDB dipende già dalla libreria client Redis.

Fai riferimento all'esempio di Memorystore applicazione per un esempio di creazione di un client Redis.

Test degli aggiornamenti in corso...

Per configurare un database di test ed eseguire la tua app in locale prima di eseguirne il deployment App Engine:

  1. Esegui il locale in modalità Datastore un emulatore per archiviare e recuperare i dati.

    Assicurati di seguire le istruzioni per l'impostazione dell'ambiente variabili in modo che l'app si connetta all'emulatore anziché l'ambiente di produzione in modalità Datastore.

    Puoi anche importare dati nell'emulatore se vuoi iniziare il test partendo da dati sono precaricate nel database.

  2. Utilizzare il server di sviluppo locale per eseguire la tua app.

    Per assicurarti che la variabile di ambiente GOOGLE_CLOUD_PROJECT sia impostata correttamente durante lo sviluppo locale, inizializza dev_appserver utilizzando il seguente codice : 

    --application=PROJECT_ID

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud. Tu può trovare l'ID progetto eseguendo il comando gcloud config list project o visualizzando la pagina del progetto nella console Google Cloud.

Deployment dell'app

Quando l'app è in esecuzione nel server di sviluppo locale senza errori:

  1. Testa l'app su in App Engine.

  2. Se l'app viene eseguita senza errori, utilizza il traffico da dividere in lentamente aumentare il traffico per la tua app aggiornata. Monitora attentamente l'app per individuare problemi di database prima di indirizzare una maggiore quantità di traffico all'app aggiornata.

Passaggi successivi