ID regione
REGION_ID
è un codice abbreviato che Google assegna
in base alla regione selezionata al momento della creazione dell'app. Il codice non
corrisponde a un paese o a una provincia, anche se alcuni ID regione possono sembrare
simili ai codici paese e provincia di uso comune. Per le app create dopo
febbraio 2020, REGION_ID.r
è incluso
negli URL di App Engine. Per le app esistenti create prima di questa data, l'ID regione è facoltativo nell'URL.
Scopri di più sugli ID regione.
La libreria API Remote consente a qualsiasi client Python di accedere ai servizi disponibili per le applicazioni di App Engine.
Ad esempio, se l'applicazione App Engine utilizza Datastore o Google Cloud Storage, un client Python potrebbe accedere alle risorse di archiviazione utilizzando l'API Remote.
Puoi utilizzare l'API Remote per accedere al datastore della tua applicazione da un'app in esecuzione sulla tua macchina locale o da una shell dell'API Remote interattiva locale. L'API remota interagisce con servizi reali, pertanto questo accesso utilizza quote e risorse fatturabili.
Attivare l'accesso remoto all'API nell'app
Il modo più semplice per abilitare l'API Remote per la tua applicazione è usare
l'istruzione builtins
nel file app.yaml
della tua app, che specifica
l'URL predefinito /_ah/remote_api/
. Tuttavia, puoi utilizzare l'istruzione url
nello stesso file per specificare un altro URL.
integrato
L'istruzione builtins
nel file app.yaml
rende disponibile l'API Remote
all'URL predefinito /_ah/remote_api
:
URL
L'utilizzo dell'istruzione url
in app.yaml
consente di specificare un URL diverso da
utilizzare con l'API Remote:
- url: /some-URL/*
script: google.appengine.ext.remote_api.handler.application
Assicurati di eseguire il deployment della tua applicazione in App Engine dopo aver apportato questa modifica.
Utilizzo della shell dell'API Remote
L'SDK Python include una shell dell'API Remote, che ti consente di richiamare i comandi Python sui servizi App Engine utilizzati dalla tua applicazione. Non è necessario fornire alcuna autenticazione aggiuntiva, perché utilizza automaticamente le stesse credenziali che hai usato per caricare l'app in App Engine.
Per avviare la shell dell'API Remote:
Richiama il seguente comando da una finestra del terminale sul computer locale:
SDK-INSTALL-DIRECTORY/remote_api_shell.py -s YOUR-PROJECT-ID.
REGION_ID.r.appspot.com
Sostituisci
[SDK-INSTALL-DIRECTORY]
con il percorso dell'SDK App Engine per Python e[YOUR-PROJECT-ID]
con il tuo ID progetto.Nella shell interattiva visualizzata, richiama i comandi Python che vuoi eseguire. Ad esempio, se la tua applicazione utilizza Datastore, puoi richiamare la seguente query ndb per recuperare 10 record:
>>> from google.appengine.ext import ndb >>> >>> # Fetch 10 keys from the datastore >>> ndb.Query().fetch(10, keys_only=True)
Utilizzo dell'API Remote in un client locale
Puoi anche utilizzare l'API Remote nelle applicazioni locali per accedere ai servizi utilizzati dalla tua app in esecuzione in App Engine.
Per utilizzare l'API Remote in un'applicazione locale:
Esporta la variabile di ambiente
PYTHONPATH
per la tua directory Python, ad esempio:export PYTHONPATH=/usr/somedir/v3/bin/python2.7
Sostituisci questo percorso con i valori effettivi della tua posizione in Python.
Aggiungi la posizione dell'SDK di App Engine per Python a
PYTHONPATH
:export GAE_SDK_ROOT="/usr/local/home/mydir/google_appengine" export PYTHONPATH=${GAE_SDK_ROOT}:${PYTHONPATH}
Sostituisci il percorso SDK mostrato sopra con il percorso effettivo dell'SDK App Engine.
Nel codice client, importa
dev_appserver
e chiamadev_appserver.fix_sys_path()
per assicurarti che tutti i moduli dell'SDK di App Engine vengano importati correttamente:Aggiungi il seguente codice
remote_api_stub
all'applicazione, assicurandoti di passare il tuo ID progetto nel codice:Se non utilizzi l'URL predefinito
/_ah/remote_api
per l'API Remote, dovrai modificare il codice riportato sopra per riflettere l'URL utilizzato. Per la definizione e la documentazione diremote_api_stub.ConfigureRemoteApiForOAuth
, consulta il file dell'SDK[SDK-INSTALL-DIRECTORY]/google/appengine/ext/remote_api/remote_api_stub.py
.Aggiungi eventuali importazioni di App Engine e codice Python necessari per accedere ai servizi App Engine desiderati. Il codice campione seguente accede al datastore del progetto:
Dopo aver eseguito il deployment dell'applicazione in App Engine, avvia il client API Remote:
python your-client.py YOUR-PROJECT-ID
Sostituendo
your-client.py
con il modulo client eYOUR-PROJECT-ID
con l'ID progetto. Questo presuppone che il client accetti l'ID progetto come input della riga di comando, seguendo l'esempio di codiceclient.py
.
Limitazioni e best practice
Il modulo remote_api si impegna a fondo per fare in modo che, per quanto possibile, si comporti esattamente come il datastore nativo di App Engine. In alcuni casi, ciò significa fare cose meno efficienti di quanto potrebbero essere. Quando utilizzi remote_api, tieni presente quanto segue:
Ogni richiesta di datastore richiede un round trip
Dal momento che si accede al datastore tramite HTTP, il sovraccarico e la latenza sono leggermente superiori rispetto a quando si accede localmente. Per velocizzare le cose e ridurre il carico, prova a limitare il numero di andata e ritorno eseguendo il raggruppamento in batch di get e put e recuperando batch di entità dalle query. Questo è un buon consiglio non solo per remote_api, ma per l'utilizzo del datastore in generale, perché un'operazione batch è considerata come una singola operazione Datastore. Ad esempio, invece di questo:
for key in keys:
rec = key.get()
rec.foo = bar
rec.put()
puoi fare questo:
records = ndb.get_multi(keys)
for rec in records:
rec.foo = bar
ndb.put_multi(records)
Entrambi gli esempi hanno lo stesso effetto, ma il secondo richiede solo due roundtrip in totale, mentre il primo richiede due round trip per ciascuna entità.
Richieste alla quota di utilizzo remote_api
Poiché remote_api opera su HTTP, ogni chiamata al datastore che effettui comporta l'utilizzo della quota per le richieste HTTP, l'ingresso e l'uscita di byte, oltre alla normale quota del datastore. Tienilo presente se utilizzi remote_api per eseguire aggiornamenti collettivi.
Si applicano limiti API di 1 MB
Come quando viene eseguita in modo nativo, si applica comunque il limite di 1 MB per richieste e risposte API. Se le entità sono particolarmente grandi, potresti dover limitare il numero recuperato o inserito alla volta per rimanere al di sotto di questo limite. Questo è in conflitto con la riduzione al minimo dei round trip, quindi sfortunatamente, il miglior consiglio è quello di utilizzare il maggior numero possibile di batch, senza superare i limiti delle dimensioni della richiesta o della risposta. Tuttavia, per la maggior parte delle entità, è improbabile che si tratti di un problema.
Evita di ripetere l'iterazione delle query
Un pattern comune con l'accesso al datastore è il seguente:
q = MyModel.query()
for entity in q:
# Do something with entity
In questo modo, l'SDK recupera le entità dal datastore in batch di 20, recuperando un nuovo batch ogni volta che utilizza quelli esistenti. Poiché ogni batch deve essere recuperato in una richiesta separata da remote_api, non è in grado di farlo in modo più efficiente. Invece, remote_api esegue una query completamente nuova per ogni batch, utilizzando la funzionalità di offset per analizzare ulteriormente i risultati.
Se sai di quante entità hai bisogno, puoi eseguire l'intero recupero in una richiesta chiedendo il numero che ti serve:
entities = MyModel.query().fetch(100)
for entity in entities:
# Do something with entity
Se non sai quante entità vuoi, puoi utilizzare i cursors per eseguire in modo efficiente l'iterazione su set di risultati di grandi dimensioni. Ciò consente inoltre di evitare il limite di 1000 entità imposto alle normali query sul datastore.
Le transazioni sono meno efficienti
Per implementare le transazioni tramite remote_api, accumula informazioni sulle entità recuperate all'interno della transazione, insieme a copie delle entità inserite o eliminate all'interno della transazione. Al momento del commit della transazione, tutte queste informazioni vengono inviate al server App Engine, dove deve recuperare di nuovo tutte le entità utilizzate nella transazione, verificare che non siano state modificate, quindi applicare ed eliminare tutte le modifiche apportate alla transazione ed eseguirne il commit. In caso di conflitto, il server esegue il rollback della transazione e invia una notifica al client, che deve ripetere l'intero processo da capo.
Questo approccio funziona e duplica esattamente la funzionalità fornita dalle transazioni nel datastore locale, ma è piuttosto inefficiente. Utilizza le transazioni dove necessario, ma cerca di limitare il numero e la complessità delle transazioni eseguite per garantire l'efficienza.