Questa pagina fornisce una panoramica del servizio memcache di App Engine. Le applicazioni web scalabili ad alte prestazioni utilizzano spesso una cache di dati in memoria distribuita prima o al posto di un'efficace archiviazione permanente per alcune attività. A questo scopo, App Engine include un servizio di cache di memoria. Per informazioni su come configurare, monitorare e utilizzare il servizio memcache, consulta Utilizzo di memcache.
Quando utilizzare una cache di memoria
Un uso della cache di memoria è quello di velocizzare le query più comuni sul datastore. Se molte richieste effettuano la stessa query con gli stessi parametri e le modifiche ai risultati non devono apparire subito sul sito web, l'applicazione può memorizzare nella cache i risultati in memcache. Le richieste successive possono controllare la memcache ed eseguire la query sul datastore solo se i risultati sono assenti o scaduti. I dati di sessione, le preferenze utente e altri dati restituiti dalle query per le pagine web sono ottimi candidati per la memorizzazione nella cache.
memcache può essere utile per altri valori temporanei. Tuttavia, quando valuti se archiviare un valore esclusivamente nella memcache e non supportato da altri spazi di archiviazione permanenti, assicurati che la tua applicazione si comporti in modo accettabile quando il valore improvvisamente non è disponibile. I valori possono scadere dalla memcache in qualsiasi momento e possono essere scaduti prima della scadenza impostata per il valore. Ad esempio, se l'assenza improvvisa dei dati della sessione di un utente causa il malfunzionamento della sessione, è probabile che questi dati vengano archiviati nel datastore oltre che nella memcache.
Livelli di servizio
App Engine supporta due livelli del servizio memcache:
memcache condivisa è l'impostazione predefinita gratuita per le applicazioni App Engine. Fornisce capacità di cache secondo il criterio del "best effort" ed è soggetto alla richiesta generale di tutte le applicazioni App Engine che utilizzano il servizio memcache condiviso.
Memcache dedicata fornisce una capacità della cache fissa assegnata esclusivamente alla tua applicazione. Viene fatturato in base ai GB/ora di dimensioni della cache e richiede l'abilitazione della fatturazione. Avere il controllo sulle dimensioni della cache significa che l'app può eseguire in modo più prevedibile e con meno letture da uno spazio di archiviazione più durevole e costoso.
Entrambi i livelli di servizio memcache utilizzano la stessa API. Per configurare il servizio memcache per l'applicazione, consulta Utilizzo di memcache.
La seguente tabella riassume le differenze tra le due classi di servizi 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 (esclusive) al secondo per GB (elementi < 1 kB). Per ulteriori dettagli, vedi Statistiche cache. | Non garantito |
| Negozio durevole | No | No |
| SLA | Nessuna esperienza | Nessuna esperienza |
La fatturazione 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 maggiore capacità memcache, contatta il nostro team di vendita.
Limiti
I seguenti limiti si applicano all'utilizzo del servizio memcache:
- La dimensione massima di un valore dei dati memorizzati nella cache è 1 MiB (2^20 byte), meno la dimensione della chiave meno un overhead dipendente dall'implementazione, che è di circa 73 byte.
- Una chiave non può superare i 250 byte. Nel runtime Java, le chiavi che sono oggetti o stringhe più lunghe di 250 byte verranno sottoposte ad hashing. (gli altri runtime si comportano in modo diverso.)
- Le operazioni batch "multi" possono avere un numero di elementi illimitato. 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 nullo.
Consigli e best practice
Quando utilizzi Memcache, ti consigliamo di progettare le tue applicazioni in modo da:
Gestisci il caso in cui un valore memorizzato nella cache non è sempre disponibile.
- Memcache non è uno spazio di archiviazione durevole. In base ai criteri di rimozione, le chiavi vengono rimosse quando la cache si riempie. Anche le modifiche alla configurazione della cache o agli eventi di manutenzione del data center possono svuotare tutta o parte della cache.
- Memcache potrebbe riscontrare temporaneamente un'indisponibilità temporanea. Le operazioni memcache possono avere esito negativo 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. Questa guida si applica in particolare alle operazioni di impostazione.
Se possibile, utilizza la funzionalità di raggruppamento in batch dell'API.
- In questo modo puoi migliorare le prestazioni e l'efficienza dell'app, soprattutto per gli elementi di piccole dimensioni.
Distribuisci il carico sullo spazio delle chiavi memcache.
Avere un singolo o piccolo insieme di elementi memcache rappresenta una quantità sproporzionata di traffico impedirà alla tua app di scalare. Queste indicazioni si applicano sia alle operazioni/sec che alla larghezza di banda. Spesso puoi risolvere questo problema partizionando esplicitamente i dati.
Ad esempio, puoi suddividere un contatore aggiornato di frequente tra più chiavi, leggendole e sommandole solo quando è necessario un totale. Allo stesso modo, puoi suddividere 500.000 dati che devono essere letti su ogni richiesta HTTP in più chiavi e leggerli utilizzando una singola chiamata API batch. È ancora meglio memorizzare nella cache il valore nella memoria dell'istanza. Per memcache dedicata, la frequenza di accesso massima su una singola chiave dovrebbe essere di 1-2 ordini di grandezza inferiore alla valutazione per GB.
Conserva 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 danneggiarla. Inoltre, alcuni linguaggi, come Python, chiavi hash long e le chiavi originali, sono noti solo all'applicazione.
API disponibili
La memcache di App Engine supporta due interfacce: un'API Memcache di basso livello e la specifica JCache. Le seguenti sezioni forniscono ulteriori informazioni su ciascuna interfaccia.
API di basso livello
L'API Memcache di basso livello supporta più funzionalità rispetto a JCache. Ecco alcuni esempi:
- Aumentare e diminuire atomicamente i valori dei contatori di numeri interi.
- Esponi più statistiche sulla cache, ad esempio la quantità di tempo trascorsa dall'accesso alla voce meno utilizzata di recente e le dimensioni totali di tutti gli elementi presenti nella cache.
- Controlla e imposta le operazioni per archiviare i dati in modo condizionale.
- Esegui le operazioni memcache in modo asincrono utilizzando AsyncMemcacheService.
L'API di basso livello fornisce
MemcacheService
e
AsyncMemcacheService
per l'accesso al servizio memcache. Questa API è più completa di quella fornita da JCache.
Consulta gli 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. Puoi archiviare e recuperare i valori nella cache utilizzando le chiavi. Le chiavi e i valori possono essere di qualsiasi tipo o classe Serializable. Per ulteriori dettagli, consulta Utilizzo di memcache.
Funzionalità JCache non supportate
JCache non supporta le seguenti funzionalità:
- L'API JCache listener è parzialmente supportata per i listener che possono essere eseguiti durante l'elaborazione della chiamata API di un'app, ad esempio per gli ascoltatori
onPuteonRemove. I listener 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 contiene un determinato valore (
containsValue()non è supportato). - Un'app non può eseguire il dump dei contenuti delle chiavi o dei valori della cache.
- Un'app non può reimpostare manualmente le statistiche della cache.
- Il metodo
put()non restituisce il precedente valore noto per una chiave. Restituisce semprenull.
Come scadono i dati memorizzati nella cache
memcache contiene coppie chiave/valore. Le coppie in memoria cambiano in qualsiasi momento quando gli elementi vengono scritti e recuperati dalla cache.
Per impostazione predefinita, i valori memorizzati nella memcache vengono conservati il più a lungo possibile. I valori possono essere eliminati dalla cache quando ne viene aggiunto un nuovo valore e la memoria della cache è insufficiente. Quando i valori vengono eliminati a causa della pressione della memoria, i valori utilizzati meno di recente vengono eliminati per primi.
L'app può fornire una data di scadenza quando viene archiviato un valore, come un numero di secondi rispetto al momento in cui viene aggiunto il valore o come un'ora assoluta del periodo Unix nel futuro (un numero di secondi dalla mezzanotte del 1° gennaio 1970). Il valore viene rimosso non più tardi di questa data, ma può essere rimosso prima per altri motivi. L'aumento del valore archiviato per una chiave esistente non ne aggiorna la scadenza.
In rari casi, i valori possono scomparire dalla cache prima della scadenza per motivi diversi dalla pressione della memoria. Anche se memcache è resiliente in caso di errori del server, i valori memcache non vengono salvati su disco, pertanto un errore del servizio può causare la mancata disponibilità dei valori.
In generale, un'applicazione non deve aspettarsi che sia sempre disponibile un valore memorizzato nella cache.
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
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 velocità di operazione varia a seconda delle dimensioni dell'articolo all'incirca in base alla tabella seguente. Il superamento di queste valutazioni potrebbe comportare un aumento della latenza dell'API o degli errori.
Le seguenti tabelle forniscono il numero massimo di operazioni sostenute ed esclusive get-hit o set 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 tale valore.
| Dimensioni articolo (kB) | Massimo get-hit operazioni/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ò raggiungere una tariffa di operazione aggregata 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 memcache/sec per elementi da 1 kB. Il raggiungimento di questo livello richiede una buona distribuzione del carico nello spazio delle chiavi memcache.
Per ogni pattern IO, i limiti elencati sopra si riferiscono alle operazioni di lettura o scritture. Per le letture e simultanee, i limiti sono su una scala scorrevole. Maggiore è il numero di letture eseguite, minore sarà il numero di scritture eseguite e viceversa. Ognuno dei seguenti è un esempio di limiti IOP per letture e scritture simultanee di valori di 1 kB per 1 GB di cache:
| Lettura IOP | Scrittura IOPS |
|---|---|
| 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 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 dalla memcache dedicata utilizzando un'unità chiamata Memcache Compute Unit (MCU). MCU è definita in modo tale da prevedere 10.000 MCU al secondo per GB di memcache dedicata. La console Google Cloud mostra la quantità di MCU attualmente in uso nell'app.
Tieni presente che MCU è una stima statistica approssimativa e non è inoltre un'unità lineare. Ogni operazione di cache che legge o scrive un valore ha un costo MCU corrispondente che dipende dalla dimensione del valore. L'MCU per un set dipende dalla dimensione del valore: è il doppio del costo di un'operazione get-hit riuscita.
| Dimensioni elemento valore (kB) | Costo MCU per get-hit |
Costo 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 è stato archiviato alcun valore con la chiave specificata.
Passaggi successivi
- Scopri come configurare, monitorare e utilizzare memcache in Utilizzo di memcache.