Località App Engine
App Engine è regionale, il che significa che l'infrastruttura che esegue le tue app si trova in una regione specifica e Google la gestisce in modo che sia disponibile in modo ridondante in tutte le zone all'interno della regione.
Soddisfare i requisiti di latenza, disponibilità o durabilità sono fattori principali per selezionare la regione in cui vengono eseguite le tue app. In genere puoi selezionare la regione più vicina agli utenti dell'app, ma devi considerare le località in cui è disponibile App Engine e le località degli altri prodotti e servizi Google Cloud utilizzati dall'app. L'utilizzo di servizi in più località può influire sulla latenza dell'app e sui relativi pricing.
Non puoi modificare la regione di un'app dopo averla impostata.
Se hai già creato un'applicazione App Engine, puoi visualizzarne la regione eseguendo una delle seguenti operazioni:
Esegui il comando
gcloud app describe
.Apri la dashboard di App Engine nella console Google Cloud. L'area viene visualizzata vicino alla parte superiore della pagina.
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 nei database Datastore. Cloud NDB consente alle app Python 2 e Python 3 di archiviare ed eseguire query sui dati negli stessi database, tuttavia il prodotto che gestisce tali database è cambiato da Datastore a Firestore in modalità Datastore. Sebbene la libreria Cloud NDB possa accedere a tutti i dati creati con App Engine NDB, alcuni tipi di dati strutturati archiviati utilizzando Cloud NDB non sono accessibili con App Engine NDB. Per questo motivo, la migrazione a Cloud NDB dovrebbe essere considerata irreversibile.
Ti consigliamo di eseguire la migrazione a Cloud NDB prima di eseguire l'upgrade dell'app a Python 3. Questo approccio incrementale alla migrazione consente di mantenere un'app funzionante e verificabile per tutto il processo di migrazione.
Cloud NDB è destinato a sostituire le funzionalità di App Engine NDB, pertanto non supporterà le nuove funzionalità di Firestore in modalità Datastore. Consigliamo alle nuove app Python 3 di utilizzare la 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 dei metodi.
Differenze:
Le API NDB di App Engine che si basano su servizi specifici di runtime per Python 2.7 di App Engine sono state aggiornate o rimosse da Cloud NDB.
Le nuove funzionalità in Python 3 e Django hanno eliminato la necessità di
google.appengine.ext.ndb.django_middleware
. Puoi scrivere facilmente il tuo middleware con poche righe di codice.L'NDB di App Engine richiede che le app e il database Datastore siano nello stesso progetto Google Cloud, con App Engine che fornisce automaticamente le credenziali. Cloud NDB può accedere ai database in modalità Datastore in qualsiasi progetto, purché autentichi correttamente il client. Questa operazione è coerente con le altre API e librerie client di Google Cloud.
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 altri sistemi. Sebbene al momento siano supportati solo i datastore Redis, Cloud NDB ha generalizzato e definito la memorizzazione nella cache nell'interfaccia
GlobalCache
astratta, che può supportare ulteriori implementazioni concrete.Per accedere a Memorystore for Redis, l'app deve utilizzare l'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 il progetto GitHub Cloud NDB.
Esempi di codice:
Operazioni di database di base utilizzando NDB di App Engine
Operazioni di database di base utilizzando Cloud NDB
Prima di avviare la migrazione
Prima di avviare la migrazione:
Se non lo hai già fatto, configura il tuo ambiente di sviluppo Python in modo da utilizzare una versione Python compatibile con Google Cloud e installa gli strumenti di test per creare ambienti Python isolati.
Se hai bisogno di memorizzare dati nella cache, assicurati che la regione della tua app sia supportata dall'accesso VPC serverless e da Memorystore for Redis.
Determinare se è necessario memorizzare i dati nella cache
Se la tua app deve memorizzare dati nella cache, tieni presente che Memorystore for Redis e Accesso VPC serverless non hanno un livello gratuito e non supportano tutte le 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 sapere quanto attualmente ti affidi ai dati memorizzati nella cache, visualizza la dashboard Memcache per vedere il rapporto tra hit della cache e fallimenti. Se il rapporto è elevato, è probabile che l'utilizzo di una cache di dati abbia un grande impatto sulla riduzione della latenza dell'app.
Vai alla memcache di App Engine
Per informazioni sui prezzi, consulta i 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 dell'app sia supportata da Memorystore per Redis e Accesso VPC serverless:
Visualizza la regione della tua app, mostrata nella parte superiore della dashboard di App Engine nella console Google Cloud.
L'area viene visualizzata nella parte superiore della pagina, appena sotto l'URL dell'app.
Verifica che l'app si trovi in una delle regioni supportate dall'accesso VPC serverless.
Verifica che la tua app si trovi in una delle regioni supportate da Memorystore per Redis visitando la pagina Crea connettore e visualizzando le regioni nell'elenco Regioni.
Se l'app non si trova in una regione supportata da Memorystore for Redis e accesso VPC serverless:
Creare un progetto Google Cloud.
Crea una nuova app App Engine nel progetto e seleziona una regione supportata.
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 progetto precedente, ma i prezzi e l'utilizzo delle risorse potrebbero essere diversi se usi i servizi in un progetto e in una regione diversi. Per ulteriori informazioni, consulta la documentazione di ciascun servizio.
Esegui il deployment dell'app nel nuovo progetto.
Informazioni sulle autorizzazioni della modalità Datastore
Ogni interazione con un servizio Google Cloud deve essere autorizzata. 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 ad accedere al database.
Per impostazione predefinita, l'app fornisce le credenziali dell'account di servizio predefinito di App Engine, che è autorizzato ad accedere ai database nello stesso progetto della tua app.
Dovrai utilizzare una tecnica di autenticazione alternativa che fornisca esplicitamente le credenziali se una delle seguenti condizioni è vera:
L'app e il database in modalità Datastore si trovano in progetti Google Cloud diversi.
Hai modificato i ruoli assegnati all'account di servizio predefinito di App Engine.
Per informazioni sulle tecniche di autenticazione alternative, consulta Configurare l'autenticazione per le applicazioni di produzione server-server.
Panoramica del processo di migrazione
Per eseguire la migrazione a Cloud NDB:
-
Installa la libreria client di Cloud NDB.
Aggiorna le istruzioni di importazione per importare i moduli da Cloud NDB.
Aggiungi il codice che crea un client Cloud NDB. Il client può leggere le variabili di ambiente dell'app e utilizzare i dati per l'autenticazione con la modalità Datastore.
Aggiungi codice che utilizza il contesto di runtime del client per mantenere la memorizzazione nella cache e le transazioni separate tra i thread.
Rimuovi o aggiorna il codice che utilizza metodi e proprietà non più supportati.
Esegui il deployment dell'app in App Engine.
Come per qualsiasi modifica apportata alla tua app, ti consigliamo di utilizzare la suddivisione del traffico per aumentare lentamente il traffico. Monitora attentamente l'app per individuare eventuali problemi del database prima di indirizzare più traffico all'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:
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 delle librerie
grpcio
esetuptools
.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 una versione Python 3 supportata ed elimina le righe non necessarie. Ad esempio, il fileapp.yaml
potrebbe avere il seguente aspetto:runtime: python310 # or another support version
Il runtime Python 3 installa le librerie automaticamente, quindi non devi specificare le librerie integrate del runtime Python 2 precedente. Se durante la migrazione l'app Python 3 utilizza altri servizi in bundle legacy, lascia invariato il file
app.yaml
.Aggiorna il file
requirements.txt
. Segui le istruzioni per la tua versione di Python:Python 2
Aggiungi le librerie client di Cloud per Cloud NDB al tuo elenco di dipendenze nel file
requirements.txt
.google-cloud-ndb
Poi esegui
pip install -t lib -r requirements.txt
per aggiornare l'elenco delle librerie disponibili per la tua app.Python 3
Aggiungi le librerie client di Cloud per Cloud NDB al tuo elenco di dipendenze nel file
requirements.txt
.google-cloud-ndb
App Engine installa automaticamente queste dipendenze durante il deployment dell'app nel runtime di Python 3, quindi elimina la cartella
lib
, se esistente.Per le app Python 2, se l'app utilizza librerie integrate o copiate specificate nella directory
lib
, devi specificare questi percorsi nel fileappengine_config.py
: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 utilizzi la corretta distribuzione delle librerie client.Il file
appengine_config.py
nell'esempio precedente presuppone che la cartellalib
si trovi nella directory di lavoro attuale. Se non puoi garantire chelib
si trovi sempre nella directory di lavoro attuale, specifica il percorso completo della cartellalib
. 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 nella 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 seguente tabella:
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, il primo passaggio per l'utilizzo di Cloud NDB consiste nel creare un oggetto Client
. Il client contiene le credenziali e altri dati necessari per connettersi 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 dell'account di servizio predefinito di App Engine, autorizzato a interagire con la 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 la modalità Datastore, il client Cloud NDB contiene il metodo context()
che restituisce un contesto di runtime.
Il contesto di runtime isola le richieste di memorizzazione nella cache e di transazione da altre interazioni simultanee in modalità Datastore.
Tutte le interazioni con la modalità Datastore devono avvenire all'interno di un contesto di runtime NDB. Poiché la creazione di una definizione del modello non interagisce con la modalità Datastore, puoi definire la classe del modello prima di creare un client Cloud NDB e recuperare un contesto di runtime, quindi utilizzare il contesto di runtime nel gestore di richieste per ottenere dati dal database.
Ad esempio:
App multi-thread
Il contesto di runtime restituito dal client Cloud NDB si applica solo a un singolo thread. Se la tua app utilizza più thread per una singola richiesta, devi recuperare un contesto di runtime separato per ogni thread che utilizzerà la 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 nuovo contesto di runtime per ogni richiesta creando un oggetto middleware che recupera il contesto di runtime e quindi racchiudendo l'app nell'oggetto middleware.
Nell'esempio seguente di utilizzo del middleware con Flask:
Il metodo
middleware
crea un oggetto middleware WSGI all'interno del contesto di runtime 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.
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 utilizzato questo middleware
(google.appengine.ext.ndb.django_middleware
) nella tua app, segui questi passaggi
per aggiornare l'app:
Utilizza il sistema middleware di Django per creare un nuovo contesto di runtime 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 contesto di runtime del client NDB.
Nel file Django settings.py, aggiorna l'impostazione
MIDDLEWARE
in modo che elenca il nuovo middleware che hai creato al posto digoogle.appengine.ext.ndb.NdbDjangoMiddleware
.
Django ora passerà ogni richiesta tramite l'oggetto middleware elencato nell'impostazione MIDDLEWARE
e questo oggetto recupererà un nuovo contesto di runtime NDB 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 sono state aggiornate o rimosse dalla libreria NDB di Cloud.
Dovrai aggiornare il codice se utilizza una delle seguenti API NDB:
google.appengine.ext.ndb.Model
e proprietà del modellogoogle.appengine.ext.ndb.Key
google.appengine.ext.ndb.query.QueryOptions
ePropertyOrder
google.appengine.ext.ndb.utils
google.appengine.api.namespacemanager
google.appengine.api.ext.ndb.tasklets
google.appengine.api.datastore_errors
Modelli e proprietà del modello
I seguenti metodi di google.appengine.ext.ndb.Model
non sono disponibili nella libreria Cloud NDB perché utilizzano API specifiche di App Engine che non sono più disponibili.
API rimossa | Sostituzione |
---|---|
Model.get_indexes e Model.get_indexes_async
|
Nessuna |
Model._deserialize e Model._serialize
|
Nessuna |
Model.make_connection
|
Nessuna |
La seguente tabella descrive le proprietà google.appengine.ext.ndb.Model
specifiche che sono state modificate nella libreria di Cloud NDB:
Proprietà | Cambia |
---|---|
TextProperty
|
google.cloud.ndb.TextProperty non può essere indicizzato. Se provi a impostare google.cloud.ndb.TextProperty.indexed , verrà generato un NotImplementedError .
|
StringProperty
|
StringProperty è sempre indicizzato. Se provi a impostare
google.cloud.ndb.StringProperty.indexed , verrà generato un
NotImplementedError .
|
Tutte le proprietà con argomenti name o kind nel
costruttore.
|
name o kind devono essere tipi di dati str ,
poiché unicode è stato sostituito da str in Python 3.
|
Le classi e i metodi nella seguente tabella non sono più disponibili perché utilizzano 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
|
Nessuna
Se provi a creare questi oggetti, viene generato un valore |
da
google.appengine.ext.ndb.model.Property :_db_get_value _db_set_value _db_set_compressed_meaning _db_set_uncompressed_meaning __creation_counter_global
|
Nessuna
Questi metodi si basano su buffer di protocollo in modalità Datastore che sono stati modificati. |
Model.make_connection
|
Nessuna |
Chiavi
I seguenti metodi di
google.appengine.ext.ndb.Key
non sono disponibili nella libreria Cloud NDB. Questi metodi sono stati utilizzati per passare le 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
|
Nessuna |
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 creazione della chiave.
|
Il valore restituito da
google.cloud.ndb.Key.app() può essere diverso dall'ID originale
trasmesso nel costruttore. Questo perché gli ID app con prefisso come s~example sono identificatori legacy di App Engine.
Sono stati sostituiti da ID progetto equivalenti, come
example.
|
Query
Come l'NDB di App Engine, Cloud NDB fornisce una classe QueryOptions
(google.cloud.ndb.query.QueryOptions
) che ti consente di riutilizzare un set specifico di opzioni di query
anziché ridefinire le opzioni per ogni query. Tuttavia, QueryOptions
in Cloud NDB non eredita da google.appengine.datastore.datastore_rpc.Configuration
e quindi non supporta i metodi ...datastore_rpc.Configuration
.
Inoltre, google.appengine.datastore.datastore_query.Order
è stato sostituito con google.cloud.ndb.query.PropertyOrder
. Analogamente a Order
, la classe PropertyOrder
consente di specificare l'ordinamento per più query. Il costruttore PropertyOrder
è uguale a quello di Order
. È cambiato solo il nome della classe.
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 il codice sorgente per una descrizione di questi metodi. |
Nessuna |
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ù disponibile. La maggior parte dei metodi in quel modulo erano interni all'NDB di App Engine, alcuni sono stati scartati a causa delle differenze di implementazione nel nuovo ndb, mentre altri metodi sono stati resi obsoleti dalle nuove funzionalità di Python 3.
Ad esempio, il decorator posizionale 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 può 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 consentono a un'applicazione multitenant di utilizzare silos di dati separati per ciascun tenant, continuando a utilizzare lo stesso database in modalità Datastore. In altre parole, ogni tenant archivia i dati nel proprio spazio dei nomi.
Anziché utilizzare google.appengine.api.namespacemanager
, specifico per App Engine, puoi specificare uno spazio dei nomi predefinito quando crei un client Cloud NDB e quindi utilizzare quello predefinito chiamando i metodi Cloud NDB all'interno del contesto di runtime del client. che segue lo stesso pattern delle altre
API Google Cloud 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")oppure key-non-default-namespace=ndb.Key("SomeKind," "AnotherId", namespace="non-default-nspace") |
Tutti gli altri metodi google.appengine.api.namespacemanager |
Nessuna |
Tasklet
Ora i tasklet possono utilizzare un'istruzione return
standard per restituire un risultato anziché 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 aumentando un'eccezione Return
, ma questa operazione è sconsigliata.
Inoltre, i seguenti metodi e sottoclassi Tasklets
non sono più disponibili, principalmente a causa delle modifiche alle modalità di creazione e utilizzo di un contesto NDB nella libreria Cloud NDB.
API rimossa | Sostituzione |
---|---|
da
google.appengine.api.ext.ndb.tasklets :add_flow_exception make_context make_default_context set_context
|
Nessuna |
da
google.appengine.api.ext.ndb.tasklets :QueueFuture ReducedFuture SerialQueueFuture
|
Nessuna |
Eccezioni
Sebbene il modulo google.cloud.ndb.exceptions
nella libreria Cloud NDB contenga molte delle stesse eccezioni della libreria NDB di App Engine, non tutte le vecchie eccezioni sono disponibili nella nuova libreria. Nella tabella seguente sono elencate le eccezioni che non sono 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 utilizzare Memorystore for Redis per memorizzare i dati nella cache:
Configurazione dell'accesso VPC serverless
L'app può comunicare con Memorystore solo tramite un connettore di accesso VPC serverless. Per configurare un connettore di accesso VPC serverless:
Configurazione di Memorystore for Redis
Per configurare Memorystore for Redis:
Crea un'istanza Redis in Memorystore. Quando crei l'istanza:
In Regione, seleziona la stessa regione in cui si trova l'app App Engine.
In Rete autorizzata, seleziona la stessa rete utilizzata dal connettore di accesso VPC serverless.
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 per utilizzare un connettore VPC.
Aggiunta dell'URL di connessione Redis
Puoi connetterti alla cache Redis aggiungendo la variabile di ambiente REDIS_CACHE_URL
al file app.yaml
dell'app. Il valore di REDIS_CACHE_URL
assume la forma seguente:
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 un oggetto Redis con una singola riga di codice e poi usare la cache passandola 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, dovrai creare un client Redis e passarlo al costruttore ndb.RedisCache()
. 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'applicazione di esempio Memorystore per un esempio di creazione di un client Redis.
Test degli aggiornamenti in corso...
Per configurare un database di test ed eseguire l'app localmente prima di eseguirne il deployment in App Engine:
Esegui l'emulatore locale in modalità Datastore per archiviare e recuperare i dati.
Assicurati di seguire le istruzioni per l'impostazione delle variabili di ambiente in modo che l'app si connetta all'emulatore anziché all'ambiente di produzione in modalità Datastore.
Puoi anche importare i dati nell'emulatore se vuoi iniziare il test con i dati precaricati nel database.
Utilizza il server di sviluppo locale per eseguire l'app.
Per assicurarti che la variabile di ambiente
GOOGLE_CLOUD_PROJECT
sia impostata correttamente durante lo sviluppo locale, inizializzadev_appserver
utilizzando il seguente parametro:--application=PROJECT_ID
Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud. Per trovare l'ID progetto, puoi eseguire il comando
gcloud config list project
o consultare la pagina del progetto nella console Google Cloud.
Deployment dell'app
Quando l'app è in esecuzione nel server di sviluppo locale senza errori:
Se l'app viene eseguita senza errori, utilizza la suddivisione del traffico per incrementare lentamente il traffico dell'app aggiornata. Monitora attentamente l'app per individuare eventuali problemi del database prima di instradare ulteriore traffico all'app aggiornata.
Passaggi successivi
- Per un tutorial pratico, consulta Eseguire la migrazione da App Engine ndb a Cloud NDB codelab.
- Per ulteriori dettagli, consulta la documentazione di Cloud NDB.