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à. App Engine include un servizio di cache in memoria per questo scopo. Per scoprire come configurare, monitorare e utilizzare il servizio memcache, consulta Utilizzare Memcache.
Quando utilizzare una cache della memoria
Un utilizzo di una cache in memoria è velocizzare le query comuni del 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. Fornisce la capacità della cache secondo il criterio del massimo impegno ed è soggetta alla domanda complessiva di tutte le applicazioni App Engine che utilizzano il servizio memcache condiviso.
Memcache dedicata fornisce una capacità di cache fissa assegnata esclusivamente 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 significa che la tua app può eseguire operazioni in modo più prevedibile e con meno letture da archiviazione durevole più costosa.
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/ora | Gratis |
| Capacità |
|
Nessuna capacità 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 di memcache dedicata viene addebitata in 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
Per l'utilizzo del servizio memcache si applicano i seguenti limiti:
- La dimensione massima di un valore di dati memorizzato nella cache è 1 MiB (2^20 byte) meno la dimensione della chiave meno un overhead dipendente dall'implementazione, pari a circa 73 byte.
- Una chiave non può avere dimensioni superiori a 250 byte. In fase di runtime Java, le chiavi che sono oggetti o stringhe più lunghe di 250 byte verranno sottoposte ad hashing. (Gli altri ambienti di runtime si comportano diversamente).
- Le operazioni collettive "multi" 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 in modo che:
Gestisci il caso in cui un valore memorizzato nella cache non sia sempre disponibile.
- Memcache non è uno spazio di archiviazione duraturo. In base al criterio di espulsione, le chiavi vengono espulse quando la cache si riempie. Anche le modifiche alla configurazione della cache o agli eventi di manutenzione del datacenter possono svuotare la cache in parte o del tutto.
- Memcache potrebbe non essere temporaneamente disponibile. Le operazioni Memcache possono non riuscire per vari motivi, tra cui modifiche alla configurazione della cache o eventi di manutenzione del data center. Le applicazioni devono essere progettate per rilevare le operazioni non riuscite senza esporre questi errori agli utenti finali. Queste indicazioni si applicano in particolare alle operazioni con gli insiemi.
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.
La presenza di un singolo elemento o di un piccolo insieme di elementi memcache che rappresentano 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ù chiavi, rileggerle e sommarle solo quando hai bisogno di un totale. Allo stesso modo, puoi suddividere un insieme di dati di 500.000 che deve essere letto in ogni richiesta HTTP in più chiavi e rileggerli utilizzando una singola chiamata API batch. Ancora meglio sarebbe memorizzare nella cache il valore nella memoria dell'istanza. Per Memcache dedicato, la frequenza di accesso di picco su una singola chiave deve essere inferiore di 1-2 ordini di grandezza rispetto 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 della 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.
API disponibili
Memcache di App Engine supporta due interfacce: un'API Memcache di basso livello e la specifica JCache. Le sezioni seguenti forniscono ulteriori informazioni su ciascuna interfaccia.
API di basso livello
L'API Memcache a basso livello supporta più funzionalità rispetto a JCache. Ecco alcuni esempi:
- Consente di incrementare e decrementare in modo atomico i valori dei contatori interi.
- Mostrare altre statistiche della cache, ad esempio il tempo trascorso dall'accesso all'elemento meno utilizzato di recente e le dimensioni totali di tutti gli elementi della cache.
- Controlla e imposta le operazioni per archiviare i dati in modo condizionale.
- Esegui le operazioni memcache in modo asincrono utilizzando AsyncMemcacheService.
L'API a basso livello fornisce metodi MemcacheService e AsyncMemcacheService per accedere al servizio memcache. Questa API è più completa di quella fornita da JCache.
Consulta la sezione Esempi di Memcache per esempi di utilizzo sincrono e asincrono dell'API Memcache di basso livello.
JCache
L'SDK Java di App Engine supporta l'API JCache. JCache fornisce un'interfaccia simile a una mappa per i dati memorizzati nella cache. Memorizzi e recuperi i valori nella cache utilizzando le chiavi. Le chiavi e i valori possono essere di qualsiasi tipo o classe Serializable. Per maggiori dettagli, consulta Utilizzare Memcache.
Funzionalità JCache non supportate
JCache non supporta le seguenti funzionalità:
- L'API di listener JCache è supportata parzialmente per i listener che possono essere eseguiti
durante l'elaborazione della chiamata API di un'app, ad esempio per i listener
onPuteonRemove. Gli ascoltatori che richiedono l'elaborazione in background, comeonEvict, non sono supportati. - Un'app può verificare se la cache contiene una determinata chiave, ma non può verificare se la cache contiene un determinato valore (
containsValue()non è supportato). - Un'app non può scaricare i contenuti delle chiavi o dei valori della cache.
- Un'app non può reimpostare manualmente le statistiche della cache.
- Il metodo
put()non restituisce il valore noto precedente per una chiave. Rimanda semprenull.
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 espulsi a causa della pressione sulla memoria, vengono espulsi prima i valori meno di recente utilizzati.
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 eliminato non oltre questo momento, anche se può essere eliminato 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 sulla cache
Operazioni al secondo per dimensioni dell'articolo
La memcache dedicata è valutata in operazioni al secondo per GB, dove un'operazione è definita come accesso a un singolo elemento della cache, ad esempio get,set o delete. La frequenza delle operazioni varia in base alle dimensioni degli articoli
in base alla seguente tabella. 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 la presenza di un valore memorizzato con la chiave specificata
e lo restituisce.
| Dimensioni elemento (KB) | Massimo get-hit op/s |
Massimo set op/s |
|---|---|---|
| ≤1 | 10.000 | 5000 |
| 100 | 2000 | 1000 |
| 512 | 500 | 250 |
Un'app configurata per più GB di cache può in teoria raggiungere una frequenza di operazioni aggregate 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 le letture e le scritture simultanee, i limiti sono su una scala scorrevole. Più letture vengono eseguite, meno scrittura è possibile eseguire e viceversa. Di seguito sono riportati alcuni esempi di limiti di IOP per letture e scritture simultanee di valori di 1 KB per 1 GB di cache:
| IOPS di lettura | IOPS di scrittura |
|---|---|
| 10000 | 0 |
| 8000 | 1000 |
| 5000 | 2500 |
| 1000 | 4500 |
| 0 | 5000 |
Unità di calcolo memcache (MCU)
Il throughput di Memcache può variare a seconda delle dimensioni dell'elemento a cui accedi e dell'operazione che vuoi eseguire sull'elemento. Puoi associare approssimativamente un costo alle operazioni e stimare la capacità di traffico che puoi aspettarti da memcache dedicato utilizzando un'unità chiamata unità di calcolo Memcache (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 è un'unità lineare. Ogni operazione della cache che legge o scrive un valore ha un costo MCU corrispondente che dipende dalle dimensioni del valore. L'MCU per un set dipende dalle dimensioni del valore: è pari al doppio del costo di un'operazione get-hit andata a buon fine.
| Dimensioni dell'elemento del valore (KB) | Costo dell'MCU per get-hit |
Costo dell'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 è memorizzato alcun valore con la chiave specificata.
Passaggi successivi
- Scopri come configurare, monitorare e utilizzare memcache in Utilizzare Memcache.