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 MB (10^6 byte).
- Una chiave non può superare i 250 byte. Nel runtime Python, le chiavi che sono 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.
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.
Confronta e imposta
Confronta e imposta è una funzionalità che consente a più richieste gestite contemporaneamente di aggiornare a livello atomico il valore della stessa chiave memcache, evitando le condizioni di gara.
Componenti logici chiave del confronto e dell'impostazione
Se aggiorni il valore di una chiave memcache che potrebbe ricevere altre 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é sono stateless. La classe Client stessa non è
thread-safe, quindi non devi utilizzare lo stesso oggetto Client in più di un
thread.
Quando recuperi le chiavi, devi utilizzare i metodi Client memcache che supportano il confronto e l'impostazione: gets() o get_multi() con il parametro for_cas impostato su True.
Quando aggiorni una chiave, devi utilizzare i metodi Client memcache che supportano il confronto e l'impostazione: cas() o cas_multi().
L'altro componente logico chiave è il servizio memcache di App Engine e il suo comportamento in relazione al confronto e all'impostazione. Il servizio memcache di App Engine
si comporta in modo atomico. In altre parole, quando due richieste in parallelo (per lo stesso ID app) utilizzano memcache, vanno alla stessa istanza del servizio memcache e il servizio Memcache ha un blocco interno sufficiente per serializzare correttamente le richieste in parallelo per la stessa chiave. In particolare, questo significa che due richieste cas() per la stessa chiave non vengono effettivamente eseguite in parallelo: il servizio gestisce la prima richiesta ricevuta fino al completamento (ovvero, l'aggiornamento del valore e del timestamp) prima di iniziare a gestire la seconda richiesta.
Per informazioni su come utilizzare il confronto e l'impostazione in Python, consulta Gestire le scritture simultanee.
Passaggi successivi
- Scopri come configurare, monitorare e utilizzare memcache in Utilizzo di memcache.
- Consulta gli esempi di Memcache.