Questa pagina fornisce una panoramica del servizio memcache di App Engine. Le applicazioni web scalabili ad alte prestazioni spesso utilizzano una cache di dati in memoria distribuita davanti o al posto di un'archiviazione persistente solida per alcune attività. Per app Engine include un servizio di cache di memoria per questo scopo. Per scoprire come configurare, monitorare e utilizzare il servizio memcache, leggere Utilizzo di Memcache.
Quando utilizzare una cache in memoria
Un utilizzo di una cache di memoria è quello di velocizzare le query più comuni sul datastore. Se molte richieste eseguono la stessa query con gli stessi parametri e le modifiche ai risultati non devono essere visualizzate immediatamente sul sito web, l'applicazione può memorizzare nella cache i risultati in memcache. Le richieste successive possono controllare la memcache e eseguire la query di Datastore solo se i risultati sono assenti o scaduti. I dati delle sessioni, le preferenze utente e altri dati restituiti dalle query per le pagine web sono buoni candidati per la memorizzazione nella cache.
Memcache può essere utile per altri valori temporanei. Tuttavia, quando valuti se memorizzare un valore solo in memcache e non in un altro spazio di archiviazione permanente, assicurati che l'applicazione si comporti in modo accettabile quando il valore non è improvvisamente disponibile. I valori possono scadere dalla memcache in qualsiasi momento e possono scadere prima della scadenza impostata per il valore. Ad esempio, se l'improvvisa assenza dei dati di sessione di un utente causa il malfunzionamento della sessione, questi dati dovrebbero probabilmente essere archiviati nel datastore oltre che nella memcache.
Livelli di servizio
App Engine supporta due livelli del servizio memcache:
Memcache condivisa è l'opzione predefinita gratuita per le applicazioni App Engine. it fornisce capacità di cache secondo il criterio del "best effort" ed è soggetta alle modifiche generali la domanda di tutte le applicazioni App Engine che usano il servizio memcache condiviso.
Memcache dedicata fornisce una capacità della cache fissa assegnata in modo esclusivo alla tua applicazione. La fatturazione avviene in base alle dimensioni della cache in GB/h e richiede l'attivazione della fatturazione. Avere il controllo sulle dimensioni della cache consente all'app di funziona in modo più prevedibile e con meno letture da più costosi durevoli archiviazione.
Entrambi i livelli di servizio memcache utilizzano la stessa API. Per configurare il servizio memcache per la tua applicazione, consulta Utilizzare memcache.
La seguente tabella riassume le differenze tra le due classi di servizio memcache:
| Funzionalità | Memcache dedicata | Memcache condivisa |
|---|---|---|
| Prezzo | 0,06 $ per GB all'ora | Gratis |
| Capacità |
|
Capacità non garantita |
| Prestazioni | Fino a 10.000 letture o 5000 scritture (escluse) al secondo per GB (elementi < 1 KB). Per maggiori dettagli, consulta Statistiche della cache. | Non garantito |
| Negozio durevole | No | No |
| SLA | Nessuno | Nessuno |
La fatturazione con memcache dedicata viene addebitata per incrementi di 15 minuti. Se la valuta utilizzata per il pagamento è diversa da USD, si applicano i prezzi elencati nella tua valuta negli SKU di Cloud Platform.
Se la tua app ha bisogno di una maggiore capacità di memcache, contatta il nostro team di vendita.
Limiti
All'utilizzo del servizio memcache si applicano i seguenti limiti:
- La dimensione massima di un valore di dati memorizzati nella cache è 1 MB (10^6 byte).
- Una chiave non può avere dimensioni superiori a 250 byte. Nel runtime Python, le chiavi che sono stringhe più lunghe di 250 byte verranno sottoposte ad hashing.
- Il "multi" le operazioni batch possono avere un numero qualsiasi di elementi. Le dimensioni totali della chiamata e le dimensioni totali dei dati recuperati non devono superare i 32 megabyte.
- Una chiave memcache non può contenere un byte null.
Consigli e best practice
Quando utilizzi Memcache, ti consigliamo di progettare le tue applicazioni per:
Gestisci il caso in cui un valore memorizzato nella cache non sia sempre disponibile.
- Memcache non è uno spazio di archiviazione durevole. In base al criterio di espulsione, le chiavi vengono espulse quando la cache si riempie. Modifiche nella configurazione della cache o nel data center eventi di manutenzione possono anche svuotare parzialmente o interamente la cache.
- Memcache potrebbe essere temporaneamente indisponibilità. Operazioni memcache potrebbero non riuscire per vari motivi, tra cui modifiche alla configurazione della cache degli eventi di manutenzione dei data center. Le applicazioni devono essere progettate per rilevare le operazioni non riuscite senza esporre questi errori agli utenti finali. Questo queste indicazioni si applicano in particolare alle operazioni di impostazione.
Utilizza la funzionalità di raggruppamento dell'API, se possibile.
- In questo modo, aumenterai le prestazioni e l'efficienza della tua app, soprattutto per gli elementi di piccole dimensioni.
Distribuisci il carico nello spazio chiavi di memcache.
Avere un singolo o un piccolo insieme di elementi memcache rappresenta un Una quantità sproporzionata di traffico ostacolerà la scalabilità della tua app. Queste indicazioni valgono sia per le operazioni/sec sia per la larghezza di banda. Spesso puoi attenuare questo problema eseguendo lo sharding esplicito dei dati.
Ad esempio, puoi suddividere un contatore aggiornato di frequente tra più i tasti, rileggendoli e poi sommando solo quando serve un totale. Allo stesso modo, puoi suddividere un dato di 500.000 che deve essere letto su richiesta HTTP su più chiavi e rileggerele utilizzando un'unica chiamata API batch. Ancora meglio sarebbe memorizzare nella cache il valore dell'istanza memory.) Per memcache dedicata, la frequenza di accesso di picco su una singola chiave Deve essere di 1-2 ordini di grandezza inferiori alla classificazione per GB.
Mantieni le tue chiavi per recuperare i valori dalla cache.
- Memcache non fornisce un metodo per elencare le chiavi. A causa della natura cache, non è possibile elencare le chiavi senza interrompere la cache. Inoltre, alcuni linguaggi, come Python, eseguono l'hash delle chiavi lunghe e le chiavi originali sono conosciute solo dall'applicazione.
Come vengono scaduti i dati memorizzati nella cache
Memcache contiene coppie chiave/valore. Le coppie in memoria cambiano in qualsiasi momento man mano che gli elementi vengono scritti e recuperati dalla cache.
Per impostazione predefinita, i valori memorizzati in memcache vengono conservati il più a lungo possibile. I valori possono essere espulsi dalla cache quando viene aggiunto un nuovo valore e la cache è in esaurimento di memoria. Quando i valori vengono rimossi a causa della pressione di memoria, i valori utilizzati meno di recente vengono rimossi per primi.
L'app può fornire un'ora di scadenza quando viene memorizzato un valore, come un numero di secondi rispetto al momento in cui viene aggiunto il valore o come un'ora di epoch Unix assoluta futura (un numero di secondi dalla mezzanotte del 1° gennaio 1970). Il valore viene rimosso non più tardi di questo momento, anche se può essere rimosso in precedenza per altri motivi. L'incremento del valore memorizzato per una chiave esistente non aggiorna la relativa data e ora di scadenza.
In rari casi, i valori possono scomparire dalla cache anche prima della scadenza per motivi diversi dalla pressione della memoria. Sebbene memcache sia resiliente ai guasti del server, i valori di memcache non vengono salvati su disco, pertanto un guasto del servizio può causare la mancata disponibilità dei valori.
In generale, un'applicazione non deve aspettarsi che un valore memorizzato nella cache sia sempre disponibile.
Puoi cancellare l'intera cache di un'applicazione tramite l'API o nella sezione Memcache della console Google Cloud.
Statistiche cache
Operazioni al secondo per dimensioni dell'elemento
Una memcache dedicata è valutata in operazioni al secondo per GB,
Per operazione si intende l'accesso a un singolo elemento della cache, ad esempio get,
set o delete. La frequenza operativa varia in base alle dimensioni dell'articolo
in base alla tabella seguente. Il superamento di queste classificazioni potrebbe comportare un aumento della latenza o degli errori dell'API.
Le tabelle seguenti forniscono il numero massimo di operazioni get-hit o set esclusive e sostenute per GB di cache. Tieni presente che un'operazione get-hit
è una chiamata get che rileva un valore archiviato con la chiave specificata,
e restituisce quel valore.
| Dimensioni articolo (kB) | Massimo get-hit op/s |
Massimo set operazioni/s |
|---|---|---|
| ≤1 | 10.000 | 5000 |
| 100 | 2000 | 1000 |
| 512 | 500 | 250 |
In teoria, un'app configurata per più GB di cache può ottenere un'aggregazione calcolata come il numero di GB moltiplicato per la tariffa per GB. Ad esempio, un'app configurata per 5 GB di cache potrebbe raggiungere 50.000 operazioni/sec di memcache su elementi di 1 KB. Per raggiungere questo livello è necessaria una buona distribuzione del carico nello spazio chiavi di Memcache.
Per ogni pattern I/O, i limiti sopra elencati si riferiscono alle letture o alle scritture. Per letture e scritture simultanee, i limiti si trovano su un foglio su larga scala. Maggiore è il numero di letture eseguite, minore è il numero di scritture eseguito e viceversa. Ciascuno dei seguenti è un esempio di IOP limiti per letture e scritture simultanee di valori di 1 kB per 1 GB di cache:
| IOPS di lettura | Scrittura IOP |
|---|---|
| 10000 | 0 |
| 8000 | 1000 |
| 5000 | 2500 |
| 1000 | 4500 |
| 0 | 5000 |
Unità di calcolo memcache (MCU)
La velocità effettiva di Memcache può variare a seconda delle dimensioni dell'elemento a cui si accede e l'operazione che vuoi eseguire sull'elemento. Puoi associare approssimativamente un valore sui costi delle operazioni e stimare la capacità di traffico che puoi aspettarti una memcache dedicata utilizzando un'unità denominata Memcache Compute Unit (MCU). L'MCU è definita in modo da poter prevedere 10.000 MCU al secondo per GB di memcache dedicato. La console Google Cloud mostra quanta MCU è attualmente in uso dalla tua app.
Tieni presente che l'MCU è una stima statistica approssimativa e non è lineare.
unità. Ogni operazione della cache che legge o scrive un valore ha un costo MCU corrispondente che dipende dalle dimensioni del valore. L'MCU di un set dipende da
dimensione del valore: il doppio del costo di un'operazione get-hit riuscita.
| Dimensioni dell'elemento del valore (KB) | Costo dell'MCU per get-hit |
Costo di MCU per set |
|---|---|---|
| ≤1 | 1,0 | 2.0 |
| 2 | 1.3 | 2,6 |
| 10 | 1,7 | 3.4 |
| 100 | 5,0 | 10,0 |
| 512 | 20,0 | 40,0 |
| 1024 | 50,0 | 100,0 |
Le operazioni che non leggono o scrivono un valore hanno un costo MCU fisso:
| Operazione | MCU |
|---|---|
get-miss |
1,0 |
delete |
2.0 |
increment |
2.0 |
flush |
100,0 |
stats |
100,0 |
Tieni presente che un'operazione get-miss è un get che rileva che non è presente alcun valore
con la chiave specificata.
Confronta e imposta
Confronta e imposta è una funzionalità che consente a più richieste gestite contemporaneamente di aggiornare atomically il valore della stessa chiave memcache, evitando le condizioni di gara.
Componenti logici chiave di confronta e imposta
Se stai aggiornando il valore di una chiave memcache che potrebbe ricevere altri
richieste di scrittura simultanee, devi utilizzare l'oggetto Client memcache, che
memorizza alcune informazioni sullo stato utilizzate dai metodi
che supportano il confronto e l'impostazione. Non puoi utilizzare le funzioni memcache get() o
set() perché non sono stateless. La classe Client stessa non è sicura per i thread, pertanto non devi utilizzare lo stesso oggetto Client in più di un thread.
Quando recuperi le chiavi, devi utilizzare i metodi Client memcache che supportano
confronta e imposta: gets() o get_multi() con il parametro for_cas impostato su
True.
Quando aggiorni una chiave, devi usare i metodi Client memcache che supportano
confronta e imposta: cas() o cas_multi().
L'altro componente logico chiave è il servizio memcache di App Engine e la sua
di confronto e di impostazione. Il servizio memcache di App Engine stesso
si comporta in modo atomico. Vale a dire, quando due richieste in parallelo (per lo stesso ID app)
usa memcache, vanno alla stessa istanza di servizio memcache
il servizio memcache ha un blocco interno sufficiente per consentire alle richieste in parallelo
le stesse chiavi siano serializzate correttamente. In particolare, ciò significa che due richieste cas()
per la stessa chiave non vengono eseguite in parallelo: il servizio gestisce
la prima richiesta inviata fino al completamento (ovvero l'aggiornamento del valore e
del timestamp) prima di iniziare a gestire la seconda richiesta.
Per scoprire come utilizzare compare e impostare in Python, leggi Gestione delle scritture simultanee.
Passaggi successivi
- Scopri come configurare, monitorare e utilizzare memcache in Utilizzo di Memcache.
- Consulta la sezione Esempi di Memcache.