API Memcache per servizi legacy in bundle

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 archivio permanente solido per alcune attività. App Engine include un servizio di cache di memoria per questo scopo. Per scoprire come configurare, monitorare e utilizzare il servizio memcache, leggi Utilizzare memcache.

Quando utilizzare una cache di memoria

Un utilizzo di una cache di memoria è quello di velocizzare le query datastore comuni. 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 ed eseguire la query 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 buoni candidati per la memorizzazione nella cache.

Memcache può essere utile per altri valori temporanei. Tuttavia, quando valuti se archiviare un valore solo in memcache e non supportato da altro spazio di archiviazione permanente, assicurati che la tua 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 causerebbe il malfunzionamento della sessione, è consigliabile archiviare questi dati 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 in base al massimo impegno ed è soggetta alla domanda complessiva 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 alle ore di GB di dimensione della cache e richiede l'attivazione della fatturazione. Il controllo delle dimensioni della cache consente alla tua app di funzionare in modo più prevedibile e con meno letture dallo spazio di archiviazione durable più costoso.

Entrambi i livelli di servizio memcache utilizzano la stessa API. Per configurare il servizio memcache per la tua applicazione, vedi Utilizzo di 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à
us-central
Da 1 a 100 GB
asia-northeast1, europe-west, europe-west3 e us-east1:
Da 1 a 20 GB
altre regioni:
Da 1 a 2 GB
 Nessuna capacità garantita
Prestazioni Fino a 10.000 letture o 5000 scritture (esclusive) 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 più capacità di memcache, contatta il nostro team di vendita.

Limiti

I seguenti limiti si applicano all'utilizzo del servizio memcache:

  • 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, che è di circa 73 byte.
  • Una chiave non può superare i 250 byte. Nel runtime PHP, se provi a impostare memcache con una chiave più grande, la chiamata genererà un'eccezione. (Altri runtime si comportano in modo diverso.)
  • Le operazioni batch "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 applicazioni in modo che:

  • Gestisci il caso in cui un valore memorizzato nella cache non è sempre disponibile.

    • Memcache non è uno spazio di archiviazione duraturo. In base alle norme di espulsione, le chiavi vengono espulse quando la cache è piena. Anche le modifiche alla configurazione della cache o gli eventi di manutenzione del data center possono svuotare parte o tutta la cache.
    • Memcache potrebbe non essere disponibile temporaneamente. 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 di impostazione.

  • Se possibile, utilizza la funzionalità di batch dell'API.

    • In questo modo aumenti le prestazioni e l'efficienza della tua app, soprattutto per gli elementi di piccole dimensioni.

  • Distribuisci il carico nello spazio delle chiavi memcache.

    • Se un singolo elemento memcache o un piccolo gruppo di elementi memcache rappresenta una quantità sproporzionata di traffico, l'app non potrà scalare. Queste indicazioni si applicano sia alle operazioni/sec sia alla larghezza di banda. Spesso puoi alleviare questo problema eseguendo lo sharding esplicito dei dati.

      Ad esempio, puoi dividere un contatore aggiornato di frequente tra più chiavi, leggerle e sommarle solo quando ti serve un totale. Allo stesso modo, puoi dividere un blocco di dati di 500.000 unità che deve essere letto in ogni richiesta HTTP in più chiavi e leggerlo di nuovo utilizzando una singola chiamata API batch. Ancora meglio sarebbe memorizzare nella cache il valore nella memoria dell'istanza. Per la memcache dedicata, la velocità di accesso di picco a una singola chiave deve 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 interromperla. Inoltre, alcuni linguaggi, come Python, eseguono l'hashing delle chiavi lunghe e le chiavi originali sono note solo all'applicazione.

Implementazione di memcache PHP

App Engine include implementazioni delle API standard Memcache e Memcached, che richiamano il servizio memcache di App Engine "sotto il cofano". Alcune funzioni sono richiamabili ("stubbed"), ma non fanno nulla, in quanto non sono necessarie nel contesto di un'app App Engine. Pertanto, le chiamate alle seguenti funzioni vengono ignorate:

Funzioni stub nell'API Memcache

  • memcache_add_server()
  • memcache_close()
  • memcache_connect()
  • memcache_pconnect()
  • memcache_set_compress_threshold()
  • addServer()
  • close()
  • connect()
  • pconnect()
  • setCompressThreshold()

Funzioni stub nell'API Memcached

  • addServer()
  • addServers()
  • getAllKeys()
  • getServerByKey()
  • getServerList()
  • getStats()
  • getVersion()
  • isPersistent()
  • isPristine()
  • quit()
  • resetServerList()
  • setSaslAuthData()

Un esempio di utilizzo dell'API PHP Memcache in App Engine:

$memcache = new Memcache;
return $memcache->get($key);

Un esempio di utilizzo dell'API Memcached PHP in App Engine:

$memcache = new Memcached;
$memcache->set('who', $request->get('who'));
return $twig->render('memcache.html.twig', [
    'who' => $request->get('who'),
    'count' => $memcache->increment('count', 1, 0),
    'host' => $request->getHost(),
]);

Scadenza dei 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 archiviati in memcache vengono conservati il più a lungo possibile. I valori possono essere rimossi dalla cache quando viene aggiunto un nuovo valore e la memoria della cache è insufficiente. Quando i valori vengono eliminati a causa della pressione della memoria, vengono eliminati per primi i valori utilizzati meno di recente.

L'app può fornire un'ora di scadenza quando viene memorizzato un valore, come numero di secondi relativo al momento in cui viene aggiunto il valore o come ora assoluta dell'epoca Unix in futuro (un numero di secondi dalla mezzanotte del 1° gennaio 1970). Il valore viene rimosso entro questo orario, anche se può essere rimosso prima per altri motivi. L'incremento del valore memorizzato per una chiave esistente non aggiorna la relativa ora di scadenza.

In rari casi, i valori possono scomparire dalla cache prima della scadenza per motivi diversi dalla pressione della memoria. Sebbene Memcache sia resiliente agli errori del server, i valori di Memcache non vengono salvati su disco, quindi un errore 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 consoleGoogle Cloud .

Statistiche della cache

Operazioni al secondo per dimensione dell'elemento

La memcache dedicata viene valutata in operazioni al secondo per GB, dove un'operazione è definita come un accesso individuale a un elemento della cache, ad esempio un get, un set o un delete. La velocità di operazione varia in base alle dimensioni dell'elemento circa in base alla seguente tabella. Il superamento di questi limiti potrebbe comportare un aumento della latenza dell'API o errori.

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 che è memorizzato un valore con la chiave specificata e restituisce quel valore.

Dimensioni elemento (kB) Massimo get-hit operazioni/secondo Massimo set operazioni/secondo
≤1 10.000 5000
100 2000 1000
512 500 250

Un'app configurata per più GB di cache può in teoria raggiungere una velocità di operazioni aggregata calcolata come il numero di GB moltiplicato per la velocità per GB. Ad esempio, un'app configurata per 5 GB di cache potrebbe raggiungere 50.000 operazioni memcache/sec su elementi da 1 KB. Per raggiungere questo livello è necessaria una buona distribuzione del carico nello spazio delle chiavi memcache.

Per ogni pattern I/O, i limiti elencati sopra si riferiscono a letture o scritture. Per le letture e le scritture simultanee, i limiti sono su una scala mobile. Più letture vengono eseguite, meno scritture possono essere eseguite e viceversa. Di seguito sono riportati esempi di limiti di IOPS 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 dalla memcache dedicata utilizzando un'unità chiamata 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 la quantità di MCU attualmente utilizzata dalla tua app.

Tieni presente che l'MCU è una stima statistica approssimativa e non è un'unità lineare. Ogni operazione di cache che legge o scrive un valore ha un costo MCU corrispondente che dipende dalle dimensioni del valore. Il costo dell'MCU per un set dipende dalle dimensioni 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'operazione get che rileva che non è memorizzato alcun valore con la chiave specificata.

Passaggi successivi